From 13330f6d180090e55b351b229b83db0b9c9ca2b3 Mon Sep 17 00:00:00 2001 From: jgravois Date: Wed, 4 May 2016 10:49:33 -0700 Subject: [PATCH] second attempt at tagging 2.0.0 --- dist/esri-leaflet-debug.js | 3820 ++++++++++++++++++++++++++++++++++++ dist/esri-leaflet.js | 6 + dist/esri-leaflet.js.map | 1 + esri-leaflet-v2.0.0.zip | Bin 0 -> 148734 bytes 4 files changed, 3827 insertions(+) create mode 100644 dist/esri-leaflet-debug.js create mode 100644 dist/esri-leaflet.js create mode 100644 dist/esri-leaflet.js.map create mode 100644 esri-leaflet-v2.0.0.zip diff --git a/dist/esri-leaflet-debug.js b/dist/esri-leaflet-debug.js new file mode 100644 index 000000000..3fa90aa01 --- /dev/null +++ b/dist/esri-leaflet-debug.js @@ -0,0 +1,3820 @@ +/* esri-leaflet - v2.0.0 - Wed May 04 2016 10:49:10 GMT-0700 (PDT) + * Copyright (c) 2016 Environmental Systems Research Institute, Inc. + * Apache-2.0 */ +(function (global, factory) { + typeof exports === 'object' && typeof module !== 'undefined' ? factory(exports, require('leaflet')) : + typeof define === 'function' && define.amd ? define(['exports', 'leaflet'], factory) : + (factory((global.L = global.L || {}, global.L.esri = global.L.esri || {}),global.L)); +}(this, function (exports,L) { 'use strict'; + + L = 'default' in L ? L['default'] : L; + + var version = "2.0.0"; + + var cors = ((window.XMLHttpRequest && 'withCredentials' in new window.XMLHttpRequest())); + var pointerEvents = document.documentElement.style.pointerEvents === ''; + + var Support = { + cors: cors, + pointerEvents: pointerEvents + }; + + /* + * Copyright 2015 Esri + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the Liscense. + */ + + // checks if 2 x,y points are equal + function pointsEqual (a, b) { + for (var i = 0; i < a.length; i++) { + if (a[i] !== b[i]) { + return false; + } + } + return true; + } + + // checks if the first and last points of a ring are equal and closes the ring + function closeRing (coordinates) { + if (!pointsEqual(coordinates[0], coordinates[coordinates.length - 1])) { + coordinates.push(coordinates[0]); + } + return coordinates; + } + + // determine if polygon ring coordinates are clockwise. clockwise signifies outer ring, counter-clockwise an inner ring + // or hole. this logic was found at http://stackoverflow.com/questions/1165647/how-to-determine-if-a-list-of-polygon- + // points-are-in-clockwise-order + function ringIsClockwise (ringToTest) { + var total = 0; + var i = 0; + var rLength = ringToTest.length; + var pt1 = ringToTest[i]; + var pt2; + for (i; i < rLength - 1; i++) { + pt2 = ringToTest[i + 1]; + total += (pt2[0] - pt1[0]) * (pt2[1] + pt1[1]); + pt1 = pt2; + } + return (total >= 0); + } + + // ported from terraformer.js https://github.com/Esri/Terraformer/blob/master/terraformer.js#L504-L519 + function vertexIntersectsVertex (a1, a2, b1, b2) { + var uaT = (b2[0] - b1[0]) * (a1[1] - b1[1]) - (b2[1] - b1[1]) * (a1[0] - b1[0]); + var ubT = (a2[0] - a1[0]) * (a1[1] - b1[1]) - (a2[1] - a1[1]) * (a1[0] - b1[0]); + var uB = (b2[1] - b1[1]) * (a2[0] - a1[0]) - (b2[0] - b1[0]) * (a2[1] - a1[1]); + + if (uB !== 0) { + var ua = uaT / uB; + var ub = ubT / uB; + + if (ua >= 0 && ua <= 1 && ub >= 0 && ub <= 1) { + return true; + } + } + + return false; + } + + // ported from terraformer.js https://github.com/Esri/Terraformer/blob/master/terraformer.js#L521-L531 + function arrayIntersectsArray (a, b) { + for (var i = 0; i < a.length - 1; i++) { + for (var j = 0; j < b.length - 1; j++) { + if (vertexIntersectsVertex(a[i], a[i + 1], b[j], b[j + 1])) { + return true; + } + } + } + + return false; + } + + // ported from terraformer.js https://github.com/Esri/Terraformer/blob/master/terraformer.js#L470-L480 + function coordinatesContainPoint (coordinates, point) { + var contains = false; + for (var i = -1, l = coordinates.length, j = l - 1; ++i < l; j = i) { + if (((coordinates[i][1] <= point[1] && point[1] < coordinates[j][1]) || + (coordinates[j][1] <= point[1] && point[1] < coordinates[i][1])) && + (point[0] < (coordinates[j][0] - coordinates[i][0]) * (point[1] - coordinates[i][1]) / (coordinates[j][1] - coordinates[i][1]) + coordinates[i][0])) { + contains = !contains; + } + } + return contains; + } + + // ported from terraformer-arcgis-parser.js https://github.com/Esri/terraformer-arcgis-parser/blob/master/terraformer-arcgis-parser.js#L106-L113 + function coordinatesContainCoordinates (outer, inner) { + var intersects = arrayIntersectsArray(outer, inner); + var contains = coordinatesContainPoint(outer, inner[0]); + if (!intersects && contains) { + return true; + } + return false; + } + + // do any polygons in this array contain any other polygons in this array? + // used for checking for holes in arcgis rings + // ported from terraformer-arcgis-parser.js https://github.com/Esri/terraformer-arcgis-parser/blob/master/terraformer-arcgis-parser.js#L117-L172 + function convertRingsToGeoJSON (rings) { + var outerRings = []; + var holes = []; + var x; // iterator + var outerRing; // current outer ring being evaluated + var hole; // current hole being evaluated + + // for each ring + for (var r = 0; r < rings.length; r++) { + var ring = closeRing(rings[r].slice(0)); + if (ring.length < 4) { + continue; + } + // is this ring an outer ring? is it clockwise? + if (ringIsClockwise(ring)) { + var polygon = [ ring ]; + outerRings.push(polygon); // push to outer rings + } else { + holes.push(ring); // counterclockwise push to holes + } + } + + var uncontainedHoles = []; + + // while there are holes left... + while (holes.length) { + // pop a hole off out stack + hole = holes.pop(); + + // loop over all outer rings and see if they contain our hole. + var contained = false; + for (x = outerRings.length - 1; x >= 0; x--) { + outerRing = outerRings[x][0]; + if (coordinatesContainCoordinates(outerRing, hole)) { + // the hole is contained push it into our polygon + outerRings[x].push(hole); + contained = true; + break; + } + } + + // ring is not contained in any outer ring + // sometimes this happens https://github.com/Esri/esri-leaflet/issues/320 + if (!contained) { + uncontainedHoles.push(hole); + } + } + + // if we couldn't match any holes using contains we can try intersects... + while (uncontainedHoles.length) { + // pop a hole off out stack + hole = uncontainedHoles.pop(); + + // loop over all outer rings and see if any intersect our hole. + var intersects = false; + + for (x = outerRings.length - 1; x >= 0; x--) { + outerRing = outerRings[x][0]; + if (arrayIntersectsArray(outerRing, hole)) { + // the hole is contained push it into our polygon + outerRings[x].push(hole); + intersects = true; + break; + } + } + + if (!intersects) { + outerRings.push([hole.reverse()]); + } + } + + if (outerRings.length === 1) { + return { + type: 'Polygon', + coordinates: outerRings[0] + }; + } else { + return { + type: 'MultiPolygon', + coordinates: outerRings + }; + } + } + + // This function ensures that rings are oriented in the right directions + // outer rings are clockwise, holes are counterclockwise + // used for converting GeoJSON Polygons to ArcGIS Polygons + function orientRings (poly) { + var output = []; + var polygon = poly.slice(0); + var outerRing = closeRing(polygon.shift().slice(0)); + if (outerRing.length >= 4) { + if (!ringIsClockwise(outerRing)) { + outerRing.reverse(); + } + + output.push(outerRing); + + for (var i = 0; i < polygon.length; i++) { + var hole = closeRing(polygon[i].slice(0)); + if (hole.length >= 4) { + if (ringIsClockwise(hole)) { + hole.reverse(); + } + output.push(hole); + } + } + } + + return output; + } + + // This function flattens holes in multipolygons to one array of polygons + // used for converting GeoJSON Polygons to ArcGIS Polygons + function flattenMultiPolygonRings (rings) { + var output = []; + for (var i = 0; i < rings.length; i++) { + var polygon = orientRings(rings[i]); + for (var x = polygon.length - 1; x >= 0; x--) { + var ring = polygon[x].slice(0); + output.push(ring); + } + } + return output; + } + + // shallow object clone for feature properties and attributes + // from http://jsperf.com/cloning-an-object/2 + function shallowClone$1 (obj) { + var target = {}; + for (var i in obj) { + if (obj.hasOwnProperty(i)) { + target[i] = obj[i]; + } + } + return target; + } + + function arcgisToGeoJSON$1 (arcgis, idAttribute) { + var geojson = {}; + + if (typeof arcgis.x === 'number' && typeof arcgis.y === 'number') { + geojson.type = 'Point'; + geojson.coordinates = [arcgis.x, arcgis.y]; + } + + if (arcgis.points) { + geojson.type = 'MultiPoint'; + geojson.coordinates = arcgis.points.slice(0); + } + + if (arcgis.paths) { + if (arcgis.paths.length === 1) { + geojson.type = 'LineString'; + geojson.coordinates = arcgis.paths[0].slice(0); + } else { + geojson.type = 'MultiLineString'; + geojson.coordinates = arcgis.paths.slice(0); + } + } + + if (arcgis.rings) { + geojson = convertRingsToGeoJSON(arcgis.rings.slice(0)); + } + + if (arcgis.geometry || arcgis.attributes) { + geojson.type = 'Feature'; + geojson.geometry = (arcgis.geometry) ? arcgisToGeoJSON$1(arcgis.geometry) : null; + geojson.properties = (arcgis.attributes) ? shallowClone$1(arcgis.attributes) : null; + if (arcgis.attributes) { + geojson.id = arcgis.attributes[idAttribute] || arcgis.attributes.OBJECTID || arcgis.attributes.FID; + } + } + + return geojson; + } + + function geojsonToArcGIS$1 (geojson, idAttribute) { + idAttribute = idAttribute || 'OBJECTID'; + var spatialReference = { wkid: 4326 }; + var result = {}; + var i; + + switch (geojson.type) { + case 'Point': + result.x = geojson.coordinates[0]; + result.y = geojson.coordinates[1]; + result.spatialReference = spatialReference; + break; + case 'MultiPoint': + result.points = geojson.coordinates.slice(0); + result.spatialReference = spatialReference; + break; + case 'LineString': + result.paths = [geojson.coordinates.slice(0)]; + result.spatialReference = spatialReference; + break; + case 'MultiLineString': + result.paths = geojson.coordinates.slice(0); + result.spatialReference = spatialReference; + break; + case 'Polygon': + result.rings = orientRings(geojson.coordinates.slice(0)); + result.spatialReference = spatialReference; + break; + case 'MultiPolygon': + result.rings = flattenMultiPolygonRings(geojson.coordinates.slice(0)); + result.spatialReference = spatialReference; + break; + case 'Feature': + if (geojson.geometry) { + result.geometry = geojsonToArcGIS$1(geojson.geometry, idAttribute); + } + result.attributes = (geojson.properties) ? shallowClone$1(geojson.properties) : {}; + if (geojson.id) { + result.attributes[idAttribute] = geojson.id; + } + break; + case 'FeatureCollection': + result = []; + for (i = 0; i < geojson.features.length; i++) { + result.push(geojsonToArcGIS$1(geojson.features[i], idAttribute)); + } + break; + case 'GeometryCollection': + result = []; + for (i = 0; i < geojson.geometries.length; i++) { + result.push(geojsonToArcGIS$1(geojson.geometries[i], idAttribute)); + } + break; + } + + return result; + } + + function geojsonToArcGIS (geojson, idAttr) { + return geojsonToArcGIS$1(geojson, idAttr); + } + + function arcgisToGeoJSON (arcgis, idAttr) { + return arcgisToGeoJSON$1(arcgis, idAttr); + } + + // shallow object clone for feature properties and attributes + // from http://jsperf.com/cloning-an-object/2 + function shallowClone (obj) { + var target = {}; + for (var i in obj) { + if (obj.hasOwnProperty(i)) { + target[i] = obj[i]; + } + } + return target; + } + + // convert an extent (ArcGIS) to LatLngBounds (Leaflet) + function extentToBounds (extent) { + var sw = L.latLng(extent.ymin, extent.xmin); + var ne = L.latLng(extent.ymax, extent.xmax); + return L.latLngBounds(sw, ne); + } + + // convert an LatLngBounds (Leaflet) to extent (ArcGIS) + function boundsToExtent (bounds) { + bounds = L.latLngBounds(bounds); + return { + 'xmin': bounds.getSouthWest().lng, + 'ymin': bounds.getSouthWest().lat, + 'xmax': bounds.getNorthEast().lng, + 'ymax': bounds.getNorthEast().lat, + 'spatialReference': { + 'wkid': 4326 + } + }; + } + + function responseToFeatureCollection (response, idAttribute) { + var objectIdField; + + if (idAttribute) { + objectIdField = idAttribute; + } else if (response.objectIdFieldName) { + objectIdField = response.objectIdFieldName; + } else if (response.fields) { + for (var j = 0; j <= response.fields.length - 1; j++) { + if (response.fields[j].type === 'esriFieldTypeOID') { + objectIdField = response.fields[j].name; + break; + } + } + } else { + objectIdField = 'OBJECTID'; + } + + var featureCollection = { + type: 'FeatureCollection', + features: [] + }; + var features = response.features || response.results; + if (features.length) { + for (var i = features.length - 1; i >= 0; i--) { + var feature = arcgisToGeoJSON(features[i], objectIdField); + featureCollection.features.push(feature); + } + } + + return featureCollection; + } + + // trim url whitespace and add a trailing slash if needed + function cleanUrl (url) { + // trim leading and trailing spaces, but not spaces inside the url + url = L.Util.trim(url); + + // add a trailing slash to the url if the user omitted it + if (url[url.length - 1] !== '/') { + url += '/'; + } + + return url; + } + + function isArcgisOnline (url) { + /* hosted feature services can emit geojson natively. + our check for 'geojson' support will need to be revisted + once the functionality makes its way to ArcGIS Server*/ + return (/\.arcgis\.com.*?FeatureServer/g).test(url); + } + + function geojsonTypeToArcGIS (geoJsonType) { + var arcgisGeometryType; + switch (geoJsonType) { + case 'Point': + arcgisGeometryType = 'esriGeometryPoint'; + break; + case 'MultiPoint': + arcgisGeometryType = 'esriGeometryMultipoint'; + break; + case 'LineString': + arcgisGeometryType = 'esriGeometryPolyline'; + break; + case 'MultiLineString': + arcgisGeometryType = 'esriGeometryPolyline'; + break; + case 'Polygon': + arcgisGeometryType = 'esriGeometryPolygon'; + break; + case 'MultiPolygon': + arcgisGeometryType = 'esriGeometryPolygon'; + break; + } + + return arcgisGeometryType; + } + + function warn () { + if (console && console.warn) { + console.warn.apply(console, arguments); + } + } + + var Util = { + shallowClone: shallowClone, + warn: warn, + cleanUrl: cleanUrl, + isArcgisOnline: isArcgisOnline, + geojsonTypeToArcGIS: geojsonTypeToArcGIS, + responseToFeatureCollection: responseToFeatureCollection, + geojsonToArcGIS: geojsonToArcGIS, + arcgisToGeoJSON: arcgisToGeoJSON, + boundsToExtent: boundsToExtent, + extentToBounds: extentToBounds + }; + + var callbacks = 0; + + function serialize (params) { + var data = ''; + + params.f = params.f || 'json'; + + for (var key in params) { + if (params.hasOwnProperty(key)) { + var param = params[key]; + var type = Object.prototype.toString.call(param); + var value; + + if (data.length) { + data += '&'; + } + + if (type === '[object Array]') { + value = (Object.prototype.toString.call(param[0]) === '[object Object]') ? JSON.stringify(param) : param.join(','); + } else if (type === '[object Object]') { + value = JSON.stringify(param); + } else if (type === '[object Date]') { + value = param.valueOf(); + } else { + value = param; + } + + data += encodeURIComponent(key) + '=' + encodeURIComponent(value); + } + } + + return data; + } + + function createRequest (callback, context) { + var httpRequest = new window.XMLHttpRequest(); + + httpRequest.onerror = function (e) { + httpRequest.onreadystatechange = L.Util.falseFn; + + callback.call(context, { + error: { + code: 500, + message: 'XMLHttpRequest error' + } + }, null); + }; + + httpRequest.onreadystatechange = function () { + var response; + var error; + + if (httpRequest.readyState === 4) { + try { + response = JSON.parse(httpRequest.responseText); + } catch (e) { + response = null; + error = { + code: 500, + message: 'Could not parse response as JSON. This could also be caused by a CORS or XMLHttpRequest error.' + }; + } + + if (!error && response.error) { + error = response.error; + response = null; + } + + httpRequest.onerror = L.Util.falseFn; + + callback.call(context, error, response); + } + }; + + httpRequest.ontimeout = function () { + this.onerror(); + }; + + return httpRequest; + } + + function xmlHttpPost (url, params, callback, context) { + var httpRequest = createRequest(callback, context); + httpRequest.open('POST', url); + + if (typeof context !== 'undefined' && context !== null) { + if (typeof context.options !== 'undefined') { + httpRequest.timeout = context.options.timeout; + } + } + httpRequest.setRequestHeader('Content-Type', 'application/x-www-form-urlencoded'); + httpRequest.send(serialize(params)); + + return httpRequest; + } + + function xmlHttpGet (url, params, callback, context) { + var httpRequest = createRequest(callback, context); + httpRequest.open('GET', url + '?' + serialize(params), true); + + if (typeof context !== 'undefined' && context !== null) { + if (typeof context.options !== 'undefined') { + httpRequest.timeout = context.options.timeout; + } + } + httpRequest.send(null); + + return httpRequest; + } + + // AJAX handlers for CORS (modern browsers) or JSONP (older browsers) + function request (url, params, callback, context) { + var paramString = serialize(params); + var httpRequest = createRequest(callback, context); + var requestLength = (url + '?' + paramString).length; + + // get around ie10/11 bug which requires that the request be opened before a timeout is applied + if (requestLength <= 2000 && Support.cors) { + httpRequest.open('GET', url + '?' + paramString); + + } else if (requestLength > 2000 && Support.cors) { + httpRequest.open('POST', url); + httpRequest.setRequestHeader('Content-Type', 'application/x-www-form-urlencoded'); + } + + if (typeof context !== 'undefined' && context !== null) { + if (typeof context.options !== 'undefined') { + httpRequest.timeout = context.options.timeout; + } + } + + // request is less then 2000 characters and the browser supports CORS, make GET request with XMLHttpRequest + if (requestLength <= 2000 && Support.cors) { + httpRequest.send(null); + + // request is less more then 2000 characters and the browser supports CORS, make POST request with XMLHttpRequest + } else if (requestLength > 2000 && Support.cors) { + httpRequest.send(paramString); + + // request is less more then 2000 characters and the browser does not support CORS, make a JSONP request + } else if (requestLength <= 2000 && !Support.cors) { + return jsonp(url, params, callback, context); + + // request is longer then 2000 characters and the browser does not support CORS, log a warning + } else { + warn('a request to ' + url + ' was longer then 2000 characters and this browser cannot make a cross-domain post request. Please use a proxy http://esri.github.io/esri-leaflet/api-reference/request.html'); + return; + } + + return httpRequest; + } + + function jsonp (url, params, callback, context) { + window._EsriLeafletCallbacks = window._EsriLeafletCallbacks || {}; + var callbackId = 'c' + callbacks; + params.callback = 'window._EsriLeafletCallbacks.' + callbackId; + + window._EsriLeafletCallbacks[callbackId] = function (response) { + if (window._EsriLeafletCallbacks[callbackId] !== true) { + var error; + var responseType = Object.prototype.toString.call(response); + + if (!(responseType === '[object Object]' || responseType === '[object Array]')) { + error = { + error: { + code: 500, + message: 'Expected array or object as JSONP response' + } + }; + response = null; + } + + if (!error && response.error) { + error = response; + response = null; + } + + callback.call(context, error, response); + window._EsriLeafletCallbacks[callbackId] = true; + } + }; + + var script = L.DomUtil.create('script', null, document.body); + script.type = 'text/javascript'; + script.src = url + '?' + serialize(params); + script.id = callbackId; + + callbacks++; + + return { + id: callbackId, + url: script.src, + abort: function () { + window._EsriLeafletCallbacks._callback[callbackId]({ + code: 0, + message: 'Request aborted.' + }); + } + }; + } + + var get = ((Support.cors) ? xmlHttpGet : jsonp); + get.CORS = xmlHttpGet; + get.JSONP = jsonp; + + // export the Request object to call the different handlers for debugging + var Request = { + request: request, + get: get, + post: xmlHttpPost + }; + + var Task = L.Class.extend({ + + options: { + proxy: false, + useCors: cors + }, + + // Generate a method for each methodName:paramName in the setters for this task. + generateSetter: function (param, context) { + return L.Util.bind(function (value) { + this.params[param] = value; + return this; + }, context); + }, + + initialize: function (endpoint) { + // endpoint can be either a url (and options) for an ArcGIS Rest Service or an instance of EsriLeaflet.Service + if (endpoint.request && endpoint.options) { + this._service = endpoint; + L.Util.setOptions(this, endpoint.options); + } else { + L.Util.setOptions(this, endpoint); + this.options.url = cleanUrl(endpoint.url); + } + + // clone default params into this object + this.params = L.Util.extend({}, this.params || {}); + + // generate setter methods based on the setters object implimented a child class + if (this.setters) { + for (var setter in this.setters) { + var param = this.setters[setter]; + this[setter] = this.generateSetter(param, this); + } + } + }, + + token: function (token) { + if (this._service) { + this._service.authenticate(token); + } else { + this.params.token = token; + } + return this; + }, + + request: function (callback, context) { + if (this._service) { + return this._service.request(this.path, this.params, callback, context); + } + + return this._request('request', this.path, this.params, callback, context); + }, + + _request: function (method, path, params, callback, context) { + var url = (this.options.proxy) ? this.options.proxy + '?' + this.options.url + path : this.options.url + path; + + if ((method === 'get' || method === 'request') && !this.options.useCors) { + return Request.get.JSONP(url, params, callback, context); + } + + return Request[method](url, params, callback, context); + } + }); + + function task (options) { + return new Task(options); + } + + var Query = Task.extend({ + setters: { + 'offset': 'offset', + 'limit': 'limit', + 'fields': 'outFields', + 'precision': 'geometryPrecision', + 'featureIds': 'objectIds', + 'returnGeometry': 'returnGeometry', + 'token': 'token' + }, + + path: 'query', + + params: { + returnGeometry: true, + where: '1=1', + outSr: 4326, + outFields: '*' + }, + + within: function (geometry) { + this._setGeometry(geometry); + this.params.spatialRel = 'esriSpatialRelContains'; // will make code read layer within geometry, to the api this will reads geometry contains layer + return this; + }, + + intersects: function (geometry) { + this._setGeometry(geometry); + this.params.spatialRel = 'esriSpatialRelIntersects'; + return this; + }, + + contains: function (geometry) { + this._setGeometry(geometry); + this.params.spatialRel = 'esriSpatialRelWithin'; // will make code read layer contains geometry, to the api this will reads geometry within layer + return this; + }, + + crosses: function (geometry) { + this._setGeometry(geometry); + this.params.spatialRel = 'esriSpatialRelCrosses'; + return this; + }, + + touches: function (geometry) { + this._setGeometry(geometry); + this.params.spatialRel = 'esriSpatialRelTouches'; + return this; + }, + + overlaps: function (geometry) { + this._setGeometry(geometry); + this.params.spatialRel = 'esriSpatialRelOverlaps'; + return this; + }, + + // only valid for Feature Services running on ArcGIS Server 10.3 or ArcGIS Online + nearby: function (latlng, radius) { + latlng = L.latLng(latlng); + this.params.geometry = [latlng.lng, latlng.lat]; + this.params.geometryType = 'esriGeometryPoint'; + this.params.spatialRel = 'esriSpatialRelIntersects'; + this.params.units = 'esriSRUnit_Meter'; + this.params.distance = radius; + this.params.inSr = 4326; + return this; + }, + + where: function (string) { + // instead of converting double-quotes to single quotes, pass as is, and provide a more informative message if a 400 is encountered + this.params.where = string; + return this; + }, + + between: function (start, end) { + this.params.time = [start.valueOf(), end.valueOf()]; + return this; + }, + + simplify: function (map, factor) { + var mapWidth = Math.abs(map.getBounds().getWest() - map.getBounds().getEast()); + this.params.maxAllowableOffset = (mapWidth / map.getSize().y) * factor; + return this; + }, + + orderBy: function (fieldName, order) { + order = order || 'ASC'; + this.params.orderByFields = (this.params.orderByFields) ? this.params.orderByFields + ',' : ''; + this.params.orderByFields += ([fieldName, order]).join(' '); + return this; + }, + + run: function (callback, context) { + this._cleanParams(); + + // if the service is hosted on arcgis online request geojson directly + if (Util.isArcgisOnline(this.options.url)) { + this.params.f = 'geojson'; + + return this.request(function (error, response) { + this._trapSQLerrors(error); + callback.call(context, error, response, response); + }, this); + + // otherwise convert it in the callback then pass it on + } else { + return this.request(function (error, response) { + this._trapSQLerrors(error); + callback.call(context, error, (response && Util.responseToFeatureCollection(response)), response); + }, this); + } + }, + + count: function (callback, context) { + this._cleanParams(); + this.params.returnCountOnly = true; + return this.request(function (error, response) { + callback.call(this, error, (response && response.count), response); + }, context); + }, + + ids: function (callback, context) { + this._cleanParams(); + this.params.returnIdsOnly = true; + return this.request(function (error, response) { + callback.call(this, error, (response && response.objectIds), response); + }, context); + }, + + // only valid for Feature Services running on ArcGIS Server 10.3 or ArcGIS Online + bounds: function (callback, context) { + this._cleanParams(); + this.params.returnExtentOnly = true; + return this.request(function (error, response) { + callback.call(context, error, (response && response.extent && Util.extentToBounds(response.extent)), response); + }, context); + }, + + // only valid for image services + pixelSize: function (point) { + point = L.point(point); + this.params.pixelSize = [point.x, point.y]; + return this; + }, + + // only valid for map services + layer: function (layer) { + this.path = layer + '/query'; + return this; + }, + + _trapSQLerrors: function (error) { + if (error) { + if (error.code === '400') { + Util.warn('one common syntax error in query requests is encasing string values in double quotes instead of single quotes'); + } + } + }, + + _cleanParams: function () { + delete this.params.returnIdsOnly; + delete this.params.returnExtentOnly; + delete this.params.returnCountOnly; + }, + + _setGeometry: function (geometry) { + this.params.inSr = 4326; + + // convert bounds to extent and finish + if (geometry instanceof L.LatLngBounds) { + // set geometry + geometryType + this.params.geometry = Util.boundsToExtent(geometry); + this.params.geometryType = 'esriGeometryEnvelope'; + return; + } + + // convert L.Marker > L.LatLng + if (geometry.getLatLng) { + geometry = geometry.getLatLng(); + } + + // convert L.LatLng to a geojson point and continue; + if (geometry instanceof L.LatLng) { + geometry = { + type: 'Point', + coordinates: [geometry.lng, geometry.lat] + }; + } + + // handle L.GeoJSON, pull out the first geometry + if (geometry instanceof L.GeoJSON) { + // reassign geometry to the GeoJSON value (we are assuming that only one feature is present) + geometry = geometry.getLayers()[0].feature.geometry; + this.params.geometry = Util.geojsonToArcGIS(geometry); + this.params.geometryType = Util.geojsonTypeToArcGIS(geometry.type); + } + + // Handle L.Polyline and L.Polygon + if (geometry.toGeoJSON) { + geometry = geometry.toGeoJSON(); + } + + // handle GeoJSON feature by pulling out the geometry + if (geometry.type === 'Feature') { + // get the geometry of the geojson feature + geometry = geometry.geometry; + } + + // confirm that our GeoJSON is a point, line or polygon + if (geometry.type === 'Point' || geometry.type === 'LineString' || geometry.type === 'Polygon') { + this.params.geometry = Util.geojsonToArcGIS(geometry); + this.params.geometryType = Util.geojsonTypeToArcGIS(geometry.type); + return; + } + + // warn the user if we havn't found a + /* global console */ + Util.warn('invalid geometry passed to spatial query. Should be an L.LatLng, L.LatLngBounds or L.Marker or a GeoJSON Point Line or Polygon object'); + + return; + } + }); + + function query (options) { + return new Query(options); + } + + var Find = Task.extend({ + setters: { + // method name > param name + 'contains': 'contains', + 'text': 'searchText', + 'fields': 'searchFields', // denote an array or single string + 'spatialReference': 'sr', + 'sr': 'sr', + 'layers': 'layers', + 'returnGeometry': 'returnGeometry', + 'maxAllowableOffset': 'maxAllowableOffset', + 'precision': 'geometryPrecision', + 'dynamicLayers': 'dynamicLayers', + 'returnZ': 'returnZ', + 'returnM': 'returnM', + 'gdbVersion': 'gdbVersion', + 'token': 'token' + }, + + path: 'find', + + params: { + sr: 4326, + contains: true, + returnGeometry: true, + returnZ: true, + returnM: false + }, + + layerDefs: function (id, where) { + this.params.layerDefs = (this.params.layerDefs) ? this.params.layerDefs + ';' : ''; + this.params.layerDefs += ([id, where]).join(':'); + return this; + }, + + simplify: function (map, factor) { + var mapWidth = Math.abs(map.getBounds().getWest() - map.getBounds().getEast()); + this.params.maxAllowableOffset = (mapWidth / map.getSize().y) * factor; + return this; + }, + + run: function (callback, context) { + return this.request(function (error, response) { + callback.call(context, error, (response && Util.responseToFeatureCollection(response)), response); + }, context); + } + }); + + function find (options) { + return new Find(options); + } + + var Identify = Task.extend({ + path: 'identify', + + between: function (start, end) { + this.params.time = [start.valueOf(), end.valueOf()]; + return this; + } + }); + + function identify (options) { + return new Identify(options); + } + + var IdentifyFeatures = Identify.extend({ + setters: { + 'layers': 'layers', + 'precision': 'geometryPrecision', + 'tolerance': 'tolerance', + 'returnGeometry': 'returnGeometry' + }, + + params: { + sr: 4326, + layers: 'all', + tolerance: 3, + returnGeometry: true + }, + + on: function (map) { + var extent = Util.boundsToExtent(map.getBounds()); + var size = map.getSize(); + this.params.imageDisplay = [size.x, size.y, 96]; + this.params.mapExtent = [extent.xmin, extent.ymin, extent.xmax, extent.ymax]; + return this; + }, + + at: function (latlng) { + latlng = L.latLng(latlng); + this.params.geometry = [latlng.lng, latlng.lat]; + this.params.geometryType = 'esriGeometryPoint'; + return this; + }, + + layerDef: function (id, where) { + this.params.layerDefs = (this.params.layerDefs) ? this.params.layerDefs + ';' : ''; + this.params.layerDefs += ([id, where]).join(':'); + return this; + }, + + simplify: function (map, factor) { + var mapWidth = Math.abs(map.getBounds().getWest() - map.getBounds().getEast()); + this.params.maxAllowableOffset = (mapWidth / map.getSize().y) * (1 - factor); + return this; + }, + + run: function (callback, context) { + return this.request(function (error, response) { + // immediately invoke with an error + if (error) { + callback.call(context, error, undefined, response); + return; + + // ok no error lets just assume we have features... + } else { + var featureCollection = Util.responseToFeatureCollection(response); + response.results = response.results.reverse(); + for (var i = 0; i < featureCollection.features.length; i++) { + var feature = featureCollection.features[i]; + feature.layerId = response.results[i].layerId; + } + callback.call(context, undefined, featureCollection, response); + } + }); + } + }); + + function identifyFeatures (options) { + return new IdentifyFeatures(options); + } + + var IdentifyImage = Identify.extend({ + setters: { + 'setMosaicRule': 'mosaicRule', + 'setRenderingRule': 'renderingRule', + 'setPixelSize': 'pixelSize', + 'returnCatalogItems': 'returnCatalogItems', + 'returnGeometry': 'returnGeometry' + }, + + params: { + returnGeometry: false + }, + + at: function (latlng) { + latlng = L.latLng(latlng); + this.params.geometry = JSON.stringify({ + x: latlng.lng, + y: latlng.lat, + spatialReference: { + wkid: 4326 + } + }); + this.params.geometryType = 'esriGeometryPoint'; + return this; + }, + + getMosaicRule: function () { + return this.params.mosaicRule; + }, + + getRenderingRule: function () { + return this.params.renderingRule; + }, + + getPixelSize: function () { + return this.params.pixelSize; + }, + + run: function (callback, context) { + return this.request(function (error, response) { + callback.call(context, error, (response && this._responseToGeoJSON(response)), response); + }, this); + }, + + // get pixel data and return as geoJSON point + // populate catalog items (if any) + // merging in any catalogItemVisibilities as a propery of each feature + _responseToGeoJSON: function (response) { + var location = response.location; + var catalogItems = response.catalogItems; + var catalogItemVisibilities = response.catalogItemVisibilities; + var geoJSON = { + 'pixel': { + 'type': 'Feature', + 'geometry': { + 'type': 'Point', + 'coordinates': [location.x, location.y] + }, + 'crs': { + 'type': 'EPSG', + 'properties': { + 'code': location.spatialReference.wkid + } + }, + 'properties': { + 'OBJECTID': response.objectId, + 'name': response.name, + 'value': response.value + }, + 'id': response.objectId + } + }; + + if (response.properties && response.properties.Values) { + geoJSON.pixel.properties.values = response.properties.Values; + } + + if (catalogItems && catalogItems.features) { + geoJSON.catalogItems = Util.responseToFeatureCollection(catalogItems); + if (catalogItemVisibilities && catalogItemVisibilities.length === geoJSON.catalogItems.features.length) { + for (var i = catalogItemVisibilities.length - 1; i >= 0; i--) { + geoJSON.catalogItems.features[i].properties.catalogItemVisibility = catalogItemVisibilities[i]; + } + } + } + return geoJSON; + } + + }); + + function identifyImage (params) { + return new IdentifyImage(params); + } + + var Service = L.Evented.extend({ + + options: { + proxy: false, + useCors: cors, + timeout: 0 + }, + + initialize: function (options) { + options = options || {}; + this._requestQueue = []; + this._authenticating = false; + L.Util.setOptions(this, options); + this.options.url = cleanUrl(this.options.url); + }, + + get: function (path, params, callback, context) { + return this._request('get', path, params, callback, context); + }, + + post: function (path, params, callback, context) { + return this._request('post', path, params, callback, context); + }, + + request: function (path, params, callback, context) { + return this._request('request', path, params, callback, context); + }, + + metadata: function (callback, context) { + return this._request('get', '', {}, callback, context); + }, + + authenticate: function (token) { + this._authenticating = false; + this.options.token = token; + this._runQueue(); + return this; + }, + + getTimeout: function () { + return this.options.timeout; + }, + + setTimeout: function (timeout) { + this.options.timeout = timeout; + }, + + _request: function (method, path, params, callback, context) { + this.fire('requeststart', { + url: this.options.url + path, + params: params, + method: method + }, true); + + var wrappedCallback = this._createServiceCallback(method, path, params, callback, context); + + if (this.options.token) { + params.token = this.options.token; + } + + if (this._authenticating) { + this._requestQueue.push([method, path, params, callback, context]); + return; + } else { + var url = (this.options.proxy) ? this.options.proxy + '?' + this.options.url + path : this.options.url + path; + + if ((method === 'get' || method === 'request') && !this.options.useCors) { + return Request.get.JSONP(url, params, wrappedCallback, context); + } else { + return Request[method](url, params, wrappedCallback, context); + } + } + }, + + _createServiceCallback: function (method, path, params, callback, context) { + return L.Util.bind(function (error, response) { + if (error && (error.code === 499 || error.code === 498)) { + this._authenticating = true; + + this._requestQueue.push([method, path, params, callback, context]); + + // fire an event for users to handle and re-authenticate + this.fire('authenticationrequired', { + authenticate: L.Util.bind(this.authenticate, this) + }, true); + + // if the user has access to a callback they can handle the auth error + error.authenticate = L.Util.bind(this.authenticate, this); + } + + callback.call(context, error, response); + + if (error) { + this.fire('requesterror', { + url: this.options.url + path, + params: params, + message: error.message, + code: error.code, + method: method + }, true); + } else { + this.fire('requestsuccess', { + url: this.options.url + path, + params: params, + response: response, + method: method + }, true); + } + + this.fire('requestend', { + url: this.options.url + path, + params: params, + method: method + }, true); + }, this); + }, + + _runQueue: function () { + for (var i = this._requestQueue.length - 1; i >= 0; i--) { + var request = this._requestQueue[i]; + var method = request.shift(); + this[method].apply(this, request); + } + this._requestQueue = []; + } + }); + + function service (options) { + return new Service(options); + } + + var MapService = Service.extend({ + + identify: function () { + return identifyFeatures(this); + }, + + find: function () { + return find(this); + }, + + query: function () { + return query(this); + } + + }); + + function mapService (options) { + return new MapService(options); + } + + var ImageService = Service.extend({ + + query: function () { + return query(this); + }, + + identify: function () { + return identifyImage(this); + } + }); + + function imageService (options) { + return new ImageService(options); + } + + var FeatureLayerService = Service.extend({ + + options: { + idAttribute: 'OBJECTID' + }, + + query: function () { + return query(this); + }, + + addFeature: function (feature, callback, context) { + delete feature.id; + + feature = geojsonToArcGIS(feature); + + return this.post('addFeatures', { + features: [feature] + }, function (error, response) { + var result = (response && response.addResults) ? response.addResults[0] : undefined; + if (callback) { + callback.call(context, error || response.addResults[0].error, result); + } + }, context); + }, + + updateFeature: function (feature, callback, context) { + feature = geojsonToArcGIS(feature, this.options.idAttribute); + + return this.post('updateFeatures', { + features: [feature] + }, function (error, response) { + var result = (response && response.updateResults) ? response.updateResults[0] : undefined; + if (callback) { + callback.call(context, error || response.updateResults[0].error, result); + } + }, context); + }, + + deleteFeature: function (id, callback, context) { + return this.post('deleteFeatures', { + objectIds: id + }, function (error, response) { + var result = (response && response.deleteResults) ? response.deleteResults[0] : undefined; + if (callback) { + callback.call(context, error || response.deleteResults[0].error, result); + } + }, context); + }, + + deleteFeatures: function (ids, callback, context) { + return this.post('deleteFeatures', { + objectIds: ids + }, function (error, response) { + // pass back the entire array + var result = (response && response.deleteResults) ? response.deleteResults : undefined; + if (callback) { + callback.call(context, error || response.deleteResults[0].error, result); + } + }, context); + } + }); + + function featureLayerService (options) { + return new FeatureLayerService(options); + } + + var Logo = L.Control.extend({ + options: { + position: 'bottomright', + marginTop: 0, + marginLeft: 0, + marginBottom: 0, + marginRight: 0 + }, + + onAdd: function () { + var div = L.DomUtil.create('div', 'esri-leaflet-logo'); + div.style.marginTop = this.options.marginTop; + div.style.marginLeft = this.options.marginLeft; + div.style.marginBottom = this.options.marginBottom; + div.style.marginRight = this.options.marginRight; + div.innerHTML = 'Powered by Esri'; + + return div; + } + }); + + function logo (options) { + return new Logo(options); + } + + var tileProtocol = (window.location.protocol !== 'https:') ? 'http:' : 'https:'; + + var BasemapLayer = L.TileLayer.extend({ + statics: { + TILES: { + Streets: { + urlTemplate: tileProtocol + '//{s}.arcgisonline.com/ArcGIS/rest/services/World_Street_Map/MapServer/tile/{z}/{y}/{x}', + attributionUrl: 'https://static.arcgis.com/attribution/World_Street_Map', + options: { + hideLogo: false, + logoPosition: 'bottomright', + minZoom: 1, + maxZoom: 19, + subdomains: ['server', 'services'], + attribution: 'Esri' + } + }, + Topographic: { + urlTemplate: tileProtocol + '//{s}.arcgisonline.com/ArcGIS/rest/services/World_Topo_Map/MapServer/tile/{z}/{y}/{x}', + attributionUrl: 'https://static.arcgis.com/attribution/World_Topo_Map', + options: { + hideLogo: false, + logoPosition: 'bottomright', + minZoom: 1, + maxZoom: 19, + subdomains: ['server', 'services'], + attribution: 'Esri' + } + }, + Oceans: { + urlTemplate: tileProtocol + '//{s}.arcgisonline.com/arcgis/rest/services/Ocean/World_Ocean_Base/MapServer/tile/{z}/{y}/{x}', + attributionUrl: 'https://static.arcgis.com/attribution/Ocean_Basemap', + options: { + hideLogo: false, + logoPosition: 'bottomright', + minZoom: 1, + maxZoom: 16, + subdomains: ['server', 'services'], + attribution: 'Esri' + } + }, + OceansLabels: { + urlTemplate: tileProtocol + '//{s}.arcgisonline.com/arcgis/rest/services/Ocean/World_Ocean_Reference/MapServer/tile/{z}/{y}/{x}', + options: { + hideLogo: true, + logoPosition: 'bottomright', + minZoom: 1, + maxZoom: 16, + subdomains: ['server', 'services'], + pane: (pointerEvents) ? 'esri-labels' : 'tilePane' + } + }, + NationalGeographic: { + urlTemplate: tileProtocol + '//{s}.arcgisonline.com/ArcGIS/rest/services/NatGeo_World_Map/MapServer/tile/{z}/{y}/{x}', + options: { + hideLogo: false, + logoPosition: 'bottomright', + minZoom: 1, + maxZoom: 16, + subdomains: ['server', 'services'], + attribution: 'National Geographic, Esri, DeLorme, HERE, UNEP-WCMC, USGS, NASA, ESA, METI, NRCAN, GEBCO, NOAA, increment P Corp.' + } + }, + DarkGray: { + urlTemplate: tileProtocol + '//{s}.arcgisonline.com/ArcGIS/rest/services/Canvas/World_Dark_Gray_Base/MapServer/tile/{z}/{y}/{x}', + options: { + hideLogo: false, + logoPosition: 'bottomright', + minZoom: 1, + maxZoom: 16, + subdomains: ['server', 'services'], + attribution: 'Esri, HERE, DeLorme, MapmyIndia, © OpenStreetMap contributors' + } + }, + DarkGrayLabels: { + urlTemplate: tileProtocol + '//{s}.arcgisonline.com/ArcGIS/rest/services/Canvas/World_Dark_Gray_Reference/MapServer/tile/{z}/{y}/{x}', + options: { + hideLogo: true, + logoPosition: 'bottomright', + minZoom: 1, + maxZoom: 16, + subdomains: ['server', 'services'], + pane: (pointerEvents) ? 'esri-labels' : 'tilePane' + + } + }, + Gray: { + urlTemplate: tileProtocol + '//{s}.arcgisonline.com/ArcGIS/rest/services/Canvas/World_Light_Gray_Base/MapServer/tile/{z}/{y}/{x}', + options: { + hideLogo: false, + logoPosition: 'bottomright', + minZoom: 1, + maxZoom: 16, + subdomains: ['server', 'services'], + attribution: 'Esri, HERE, DeLorme, MapmyIndia, © OpenStreetMap contributors' + } + }, + GrayLabels: { + urlTemplate: tileProtocol + '//{s}.arcgisonline.com/ArcGIS/rest/services/Canvas/World_Light_Gray_Reference/MapServer/tile/{z}/{y}/{x}', + options: { + hideLogo: true, + logoPosition: 'bottomright', + minZoom: 1, + maxZoom: 16, + subdomains: ['server', 'services'], + pane: (pointerEvents) ? 'esri-labels' : 'tilePane' + } + }, + Imagery: { + urlTemplate: tileProtocol + '//{s}.arcgisonline.com/ArcGIS/rest/services/World_Imagery/MapServer/tile/{z}/{y}/{x}', + options: { + hideLogo: false, + logoPosition: 'bottomright', + minZoom: 1, + maxZoom: 19, + subdomains: ['server', 'services'], + attribution: 'Esri, DigitalGlobe, GeoEye, i-cubed, USDA, USGS, AEX, Getmapping, Aerogrid, IGN, IGP, swisstopo, and the GIS User Community' + } + }, + ImageryLabels: { + urlTemplate: tileProtocol + '//{s}.arcgisonline.com/ArcGIS/rest/services/Reference/World_Boundaries_and_Places/MapServer/tile/{z}/{y}/{x}', + options: { + hideLogo: true, + logoPosition: 'bottomright', + minZoom: 1, + maxZoom: 19, + subdomains: ['server', 'services'], + pane: (pointerEvents) ? 'esri-labels' : 'tilePane' + } + }, + ImageryTransportation: { + urlTemplate: tileProtocol + '//{s}.arcgisonline.com/ArcGIS/rest/services/Reference/World_Transportation/MapServer/tile/{z}/{y}/{x}', + options: { + hideLogo: true, + logoPosition: 'bottomright', + minZoom: 1, + maxZoom: 19, + subdomains: ['server', 'services'], + pane: (pointerEvents) ? 'esri-labels' : 'tilePane' + } + }, + ShadedRelief: { + urlTemplate: tileProtocol + '//{s}.arcgisonline.com/ArcGIS/rest/services/World_Shaded_Relief/MapServer/tile/{z}/{y}/{x}', + options: { + hideLogo: false, + logoPosition: 'bottomright', + minZoom: 1, + maxZoom: 13, + subdomains: ['server', 'services'], + attribution: 'Esri, USGS' + } + }, + ShadedReliefLabels: { + urlTemplate: tileProtocol + '//{s}.arcgisonline.com/ArcGIS/rest/services/Reference/World_Boundaries_and_Places_Alternate/MapServer/tile/{z}/{y}/{x}', + options: { + hideLogo: true, + logoPosition: 'bottomright', + minZoom: 1, + maxZoom: 12, + subdomains: ['server', 'services'], + pane: (pointerEvents) ? 'esri-labels' : 'tilePane' + } + }, + Terrain: { + urlTemplate: tileProtocol + '//{s}.arcgisonline.com/ArcGIS/rest/services/World_Terrain_Base/MapServer/tile/{z}/{y}/{x}', + options: { + hideLogo: false, + logoPosition: 'bottomright', + minZoom: 1, + maxZoom: 13, + subdomains: ['server', 'services'], + attribution: 'Esri, USGS, NOAA' + } + }, + TerrainLabels: { + urlTemplate: tileProtocol + '//{s}.arcgisonline.com/ArcGIS/rest/services/Reference/World_Reference_Overlay/MapServer/tile/{z}/{y}/{x}', + options: { + hideLogo: true, + logoPosition: 'bottomright', + minZoom: 1, + maxZoom: 13, + subdomains: ['server', 'services'], + pane: (pointerEvents) ? 'esri-labels' : 'tilePane' + } + }, + USATopo: { + urlTemplate: tileProtocol + '//{s}.arcgisonline.com/ArcGIS/rest/services/USA_Topo_Maps/MapServer/tile/{z}/{y}/{x}', + options: { + hideLogo: false, + logoPosition: 'bottomright', + minZoom: 1, + maxZoom: 15, + subdomains: ['server', 'services'], + attribution: 'National Geographic Society, i-cubed' + } + } + } + }, + initialize: function (key, options) { + var config; + + // set the config variable with the appropriate config object + if (typeof key === 'object' && key.urlTemplate && key.options) { + config = key; + } else if (typeof key === 'string' && BasemapLayer.TILES[key]) { + config = BasemapLayer.TILES[key]; + } else { + throw new Error('L.esri.BasemapLayer: Invalid parameter. Use one of "Streets", "Topographic", "Oceans", "OceansLabels", "NationalGeographic", "Gray", "GrayLabels", "DarkGray", "DarkGrayLabels", "Imagery", "ImageryLabels", "ImageryTransportation", "ShadedRelief", "ShadedReliefLabels", "Terrain" or "TerrainLabels"'); + } + + // merge passed options into the config options + var tileOptions = L.Util.extend(config.options, options); + + L.Util.setOptions(this, tileOptions); + + // call the initialize method on L.TileLayer to set everything up + L.TileLayer.prototype.initialize.call(this, config.urlTemplate, tileOptions); + + // if this basemap requires dynamic attribution set it up + if (config.attributionUrl) { + this._getAttributionData(config.attributionUrl); + } + + this._logo = logo({ + position: this.options.logoPosition + }); + }, + + onAdd: function (map) { + if (!this.options.hideLogo && !map._hasEsriLogo) { + this._logo.addTo(map); + map._hasEsriLogo = true; + } + + if (this.options.pane === 'esri-labels') { + this._initPane(); + } + + map.on('moveend', this._updateMapAttribution, this); + + L.TileLayer.prototype.onAdd.call(this, map); + }, + + onRemove: function (map) { + // check to make sure the logo hasn't already been removed + if (this._logo && this._logo._container) { + map.removeControl(this._logo); + map._hasEsriLogo = false; + } + + map.off('moveend', this._updateMapAttribution, this); + + L.TileLayer.prototype.onRemove.call(this, map); + }, + + getAttribution: function () { + if (this.options.attribution) { + var attribution = '' + this.options.attribution + ''; + } + return attribution; + }, + + _initPane: function () { + if (!this._map.getPane(this.options.pane)) { + var pane = this._map.createPane(this.options.pane); + pane.style.pointerEvents = 'none'; + pane.style.zIndex = 500; + } + }, + + _getAttributionData: function (url) { + jsonp(url, {}, L.Util.bind(function (error, attributions) { + if (error) { return; } + this._attributions = []; + + for (var c = 0; c < attributions.contributors.length; c++) { + var contributor = attributions.contributors[c]; + for (var i = 0; i < contributor.coverageAreas.length; i++) { + var coverageArea = contributor.coverageAreas[i]; + var southWest = L.latLng(coverageArea.bbox[0], coverageArea.bbox[1]); + var northEast = L.latLng(coverageArea.bbox[2], coverageArea.bbox[3]); + this._attributions.push({ + attribution: contributor.attribution, + score: coverageArea.score, + bounds: L.latLngBounds(southWest, northEast), + minZoom: coverageArea.zoomMin, + maxZoom: coverageArea.zoomMax + }); + } + } + + this._attributions.sort(function (a, b) { + return b.score - a.score; + }); + + this._updateMapAttribution(); + }, this)); + }, + + _updateMapAttribution: function () { + if (this._map && this._map.attributionControl && this._attributions) { + var newAttributions = ''; + var bounds = this._map.getBounds(); + var zoom = this._map.getZoom(); + + for (var i = 0; i < this._attributions.length; i++) { + var attribution = this._attributions[i]; + var text = attribution.attribution; + if (!newAttributions.match(text) && bounds.intersects(attribution.bounds) && zoom >= attribution.minZoom && zoom <= attribution.maxZoom) { + newAttributions += (', ' + text); + } + } + newAttributions = newAttributions.substr(2); + var attributionElement = this._map.attributionControl._container.querySelector('.esri-attributions'); + + attributionElement.innerHTML = newAttributions; + attributionElement.style.maxWidth = (this._map.getSize().x * 0.65) + 'px'; + + this.fire('attributionupdated', { + attribution: newAttributions + }); + } + } + }); + + function basemapLayer (key, options) { + return new BasemapLayer(key, options); + } + + var TiledMapLayer = L.TileLayer.extend({ + options: { + zoomOffsetAllowance: 0.1 + }, + + statics: { + MercatorZoomLevels: { + '0': 156543.03392799999, + '1': 78271.516963999893, + '2': 39135.758482000099, + '3': 19567.879240999901, + '4': 9783.9396204999593, + '5': 4891.9698102499797, + '6': 2445.9849051249898, + '7': 1222.9924525624899, + '8': 611.49622628138002, + '9': 305.74811314055802, + '10': 152.874056570411, + '11': 76.437028285073197, + '12': 38.218514142536598, + '13': 19.109257071268299, + '14': 9.5546285356341496, + '15': 4.7773142679493699, + '16': 2.38865713397468, + '17': 1.1943285668550501, + '18': 0.59716428355981699, + '19': 0.29858214164761698, + '20': 0.14929107082381, + '21': 0.07464553541191, + '22': 0.0373227677059525, + '23': 0.0186613838529763 + } + }, + + initialize: function (options) { + options.url = cleanUrl(options.url); + options = L.Util.setOptions(this, options); + + // set the urls + this.tileUrl = options.url + 'tile/{z}/{y}/{x}'; + this.service = mapService(options); + this.service.addEventParent(this); + + var arcgisonline = new RegExp(/tiles.arcgis(online)?\.com/g); + if (arcgisonline.test(options.url)) { + this.tileUrl = this.tileUrl.replace('://tiles', '://tiles{s}'); + options.subdomains = ['1', '2', '3', '4']; + } + + if (this.options.token) { + this.tileUrl += ('?token=' + this.options.token); + } + + // init layer by calling TileLayers initialize method + L.TileLayer.prototype.initialize.call(this, this.tileUrl, options); + }, + + getTileUrl: function (tilePoint) { + return L.Util.template(this.tileUrl, L.extend({ + s: this._getSubdomain(tilePoint), + z: (this._lodMap && this._lodMap[tilePoint.z]) ? this._lodMap[tilePoint.z] : tilePoint.z, // try lod map first, then just defualt to zoom level + x: tilePoint.x, + y: tilePoint.y + }, this.options)); + }, + + createTile: function (coords, done) { + var tile = document.createElement('img'); + + L.DomEvent.on(tile, 'load', L.bind(this._tileOnLoad, this, done, tile)); + L.DomEvent.on(tile, 'error', L.bind(this._tileOnError, this, done, tile)); + + if (this.options.crossOrigin) { + tile.crossOrigin = ''; + } + + /* + Alt tag is set to empty string to keep screen readers from reading URL and for compliance reasons + http://www.w3.org/TR/WCAG20-TECHS/H67 + */ + tile.alt = ''; + + // if there is no lod map or an lod map with a proper zoom load the tile + // otherwise wait for the lod map to become available + if (!this._lodMap || (this._lodMap && this._lodMap[coords.z])) { + tile.src = this.getTileUrl(coords); + } else { + this.once('lodmap', function () { + tile.src = this.getTileUrl(coords); + }, this); + } + + return tile; + }, + + onAdd: function (map) { + if (map.options.crs === L.CRS.EPSG3857 && !this._lodMap) { + this._lodMap = {}; + this.metadata(function (error, metadata) { + if (!error) { + var sr = metadata.spatialReference.latestWkid || metadata.spatialReference.wkid; + if (sr === 102100 || sr === 3857) { + // create the zoom level data + var arcgisLODs = metadata.tileInfo.lods; + var correctResolutions = TiledMapLayer.MercatorZoomLevels; + + for (var i = 0; i < arcgisLODs.length; i++) { + var arcgisLOD = arcgisLODs[i]; + for (var ci in correctResolutions) { + var correctRes = correctResolutions[ci]; + + if (this._withinPercentage(arcgisLOD.resolution, correctRes, this.options.zoomOffsetAllowance)) { + this._lodMap[ci] = arcgisLOD.level; + break; + } + } + } + + this.fire('lodmap'); + } else { + warn('L.esri.TiledMapLayer is using a non-mercator spatial reference. Support may be available through Proj4Leaflet http://esri.github.io/esri-leaflet/examples/non-mercator-projection.html'); + } + } + }, this); + } + + L.TileLayer.prototype.onAdd.call(this, map); + }, + + metadata: function (callback, context) { + this.service.metadata(callback, context); + return this; + }, + + identify: function () { + return this.service.identify(); + }, + + find: function () { + return this.service.find(); + }, + + query: function () { + return this.service.query(); + }, + + authenticate: function (token) { + var tokenQs = '?token=' + token; + this.tileUrl = (this.options.token) ? this.tileUrl.replace(/\?token=(.+)/g, tokenQs) : this.tileUrl + tokenQs; + this.options.token = token; + this.service.authenticate(token); + return this; + }, + + _withinPercentage: function (a, b, percentage) { + var diff = Math.abs((a / b) - 1); + return diff < percentage; + } + }); + + function tiledMapLayer (url, options) { + return new TiledMapLayer(url, options); + } + + var Overlay = L.ImageOverlay.extend({ + onAdd: function (map) { + this._topLeft = map.getPixelBounds().min; + L.ImageOverlay.prototype.onAdd.call(this, map); + }, + _reset: function () { + if (this._map.options.crs === L.CRS.EPSG3857) { + L.ImageOverlay.prototype._reset.call(this); + } else { + L.DomUtil.setPosition(this._image, this._topLeft.subtract(this._map.getPixelOrigin())); + } + } + }); + + var RasterLayer = L.Layer.extend({ + + options: { + opacity: 1, + position: 'front', + f: 'image', + useCors: cors, + attribution: null, + interactive: false, + alt: '' + }, + + onAdd: function (map) { + this._update = L.Util.throttle(this._update, this.options.updateInterval, this); + + map.on('moveend', this._update, this); + + // if we had an image loaded and it matches the + // current bounds show the image otherwise remove it + if (this._currentImage && this._currentImage._bounds.equals(this._map.getBounds())) { + map.addLayer(this._currentImage); + } else if (this._currentImage) { + this._map.removeLayer(this._currentImage); + this._currentImage = null; + } + + this._update(); + + if (this._popup) { + this._map.on('click', this._getPopupData, this); + this._map.on('dblclick', this._resetPopupState, this); + } + }, + + onRemove: function (map) { + if (this._currentImage) { + this._map.removeLayer(this._currentImage); + } + + if (this._popup) { + this._map.off('click', this._getPopupData, this); + this._map.off('dblclick', this._resetPopupState, this); + } + + this._map.off('moveend', this._update, this); + }, + + bindPopup: function (fn, popupOptions) { + this._shouldRenderPopup = false; + this._lastClick = false; + this._popup = L.popup(popupOptions); + this._popupFunction = fn; + if (this._map) { + this._map.on('click', this._getPopupData, this); + this._map.on('dblclick', this._resetPopupState, this); + } + return this; + }, + + unbindPopup: function () { + if (this._map) { + this._map.closePopup(this._popup); + this._map.off('click', this._getPopupData, this); + this._map.off('dblclick', this._resetPopupState, this); + } + this._popup = false; + return this; + }, + + bringToFront: function () { + this.options.position = 'front'; + if (this._currentImage) { + this._currentImage.bringToFront(); + } + return this; + }, + + bringToBack: function () { + this.options.position = 'back'; + if (this._currentImage) { + this._currentImage.bringToBack(); + } + return this; + }, + + getAttribution: function () { + return this.options.attribution; + }, + + getOpacity: function () { + return this.options.opacity; + }, + + setOpacity: function (opacity) { + this.options.opacity = opacity; + this._currentImage.setOpacity(opacity); + return this; + }, + + getTimeRange: function () { + return [this.options.from, this.options.to]; + }, + + setTimeRange: function (from, to) { + this.options.from = from; + this.options.to = to; + this._update(); + return this; + }, + + metadata: function (callback, context) { + this.service.metadata(callback, context); + return this; + }, + + authenticate: function (token) { + this.service.authenticate(token); + return this; + }, + + _renderImage: function (url, bounds) { + if (this._map) { + // create a new image overlay and add it to the map + // to start loading the image + // opacity is 0 while the image is loading + var image = new Overlay(url, bounds, { + opacity: 0, + crossOrigin: this.options.useCors, + alt: this.options.alt, + pane: this.options.pane || this.getPane(), + interactive: this.options.interactive + }).addTo(this._map); + + // once the image loads + image.once('load', function (e) { + if (this._map) { + var newImage = e.target; + var oldImage = this._currentImage; + + // if the bounds of this image matches the bounds that + // _renderImage was called with and we have a map with the same bounds + // hide the old image if there is one and set the opacity + // of the new image otherwise remove the new image + if (newImage._bounds.equals(bounds) && newImage._bounds.equals(this._map.getBounds())) { + this._currentImage = newImage; + + if (this.options.position === 'front') { + this.bringToFront(); + } else { + this.bringToBack(); + } + + if (this._map && this._currentImage._map) { + this._currentImage.setOpacity(this.options.opacity); + } else { + this._currentImage._map.removeLayer(this._currentImage); + } + + if (oldImage && this._map) { + this._map.removeLayer(oldImage); + } + + if (oldImage && oldImage._map) { + oldImage._map.removeLayer(oldImage); + } + } else { + this._map.removeLayer(newImage); + } + } + + this.fire('load', { + bounds: bounds + }); + }, this); + + this.fire('loading', { + bounds: bounds + }); + } + }, + + _update: function () { + if (!this._map) { + return; + } + + var zoom = this._map.getZoom(); + var bounds = this._map.getBounds(); + + if (this._animatingZoom) { + return; + } + + if (this._map._panTransition && this._map._panTransition._inProgress) { + return; + } + + if (zoom > this.options.maxZoom || zoom < this.options.minZoom) { + this._currentImage._map.removeLayer(this._currentImage); + return; + } + + var params = this._buildExportParams(); + + this._requestExport(params, bounds); + }, + + _renderPopup: function (latlng, error, results, response) { + latlng = L.latLng(latlng); + if (this._shouldRenderPopup && this._lastClick.equals(latlng)) { + // add the popup to the map where the mouse was clicked at + var content = this._popupFunction(error, results, response); + if (content) { + this._popup.setLatLng(latlng).setContent(content).openOn(this._map); + } + } + }, + + _resetPopupState: function (e) { + this._shouldRenderPopup = false; + this._lastClick = e.latlng; + } + }); + + var ImageMapLayer = RasterLayer.extend({ + + options: { + updateInterval: 150, + format: 'jpgpng', + transparent: true, + f: 'json' + }, + + query: function () { + return this.service.query(); + }, + + identify: function () { + return this.service.identify(); + }, + + initialize: function (options) { + options.url = cleanUrl(options.url); + this.service = imageService(options); + this.service.addEventParent(this); + + L.Util.setOptions(this, options); + }, + + setPixelType: function (pixelType) { + this.options.pixelType = pixelType; + this._update(); + return this; + }, + + getPixelType: function () { + return this.options.pixelType; + }, + + setBandIds: function (bandIds) { + if (L.Util.isArray(bandIds)) { + this.options.bandIds = bandIds.join(','); + } else { + this.options.bandIds = bandIds.toString(); + } + this._update(); + return this; + }, + + getBandIds: function () { + return this.options.bandIds; + }, + + setNoData: function (noData, noDataInterpretation) { + if (L.Util.isArray(noData)) { + this.options.noData = noData.join(','); + } else { + this.options.noData = noData.toString(); + } + if (noDataInterpretation) { + this.options.noDataInterpretation = noDataInterpretation; + } + this._update(); + return this; + }, + + getNoData: function () { + return this.options.noData; + }, + + getNoDataInterpretation: function () { + return this.options.noDataInterpretation; + }, + + setRenderingRule: function (renderingRule) { + this.options.renderingRule = renderingRule; + this._update(); + }, + + getRenderingRule: function () { + return this.options.renderingRule; + }, + + setMosaicRule: function (mosaicRule) { + this.options.mosaicRule = mosaicRule; + this._update(); + }, + + getMosaicRule: function () { + return this.options.mosaicRule; + }, + + _getPopupData: function (e) { + var callback = L.Util.bind(function (error, results, response) { + if (error) { return; } // we really can't do anything here but authenticate or requesterror will fire + setTimeout(L.Util.bind(function () { + this._renderPopup(e.latlng, error, results, response); + }, this), 300); + }, this); + + var identifyRequest = this.identify().at(e.latlng); + + // set mosaic rule for identify task if it is set for layer + if (this.options.mosaicRule) { + identifyRequest.setMosaicRule(this.options.mosaicRule); + // @TODO: force return catalog items too? + } + + // @TODO: set rendering rule? Not sure, + // sometimes you want raw pixel values + // if (this.options.renderingRule) { + // identifyRequest.setRenderingRule(this.options.renderingRule); + // } + + identifyRequest.run(callback); + + // set the flags to show the popup + this._shouldRenderPopup = true; + this._lastClick = e.latlng; + }, + + _buildExportParams: function () { + var bounds = this._map.getBounds(); + var size = this._map.getSize(); + var ne = this._map.options.crs.project(bounds._northEast); + var sw = this._map.options.crs.project(bounds._southWest); + + // ensure that we don't ask ArcGIS Server for a taller image than we have actual map displaying + var top = this._map.latLngToLayerPoint(bounds._northEast); + var bottom = this._map.latLngToLayerPoint(bounds._southWest); + + if (top.y > 0 || bottom.y < size.y) { + size.y = bottom.y - top.y; + } + + var sr = parseInt(this._map.options.crs.code.split(':')[1], 10); + + var params = { + bbox: [sw.x, sw.y, ne.x, ne.y].join(','), + size: size.x + ',' + size.y, + format: this.options.format, + transparent: this.options.transparent, + bboxSR: sr, + imageSR: sr + }; + + if (this.options.from && this.options.to) { + params.time = this.options.from.valueOf() + ',' + this.options.to.valueOf(); + } + + if (this.options.pixelType) { + params.pixelType = this.options.pixelType; + } + + if (this.options.interpolation) { + params.interpolation = this.options.interpolation; + } + + if (this.options.compressionQuality) { + params.compressionQuality = this.options.compressionQuality; + } + + if (this.options.bandIds) { + params.bandIds = this.options.bandIds; + } + + if (this.options.noData) { + params.noData = this.options.noData; + } + + if (this.options.noDataInterpretation) { + params.noDataInterpretation = this.options.noDataInterpretation; + } + + if (this.service.options.token) { + params.token = this.service.options.token; + } + + if (this.options.renderingRule) { + params.renderingRule = JSON.stringify(this.options.renderingRule); + } + + if (this.options.mosaicRule) { + params.mosaicRule = JSON.stringify(this.options.mosaicRule); + } + + return params; + }, + + _requestExport: function (params, bounds) { + if (this.options.f === 'json') { + this.service.request('exportImage', params, function (error, response) { + if (error) { return; } // we really can't do anything here but authenticate or requesterror will fire + this._renderImage(response.href, bounds); + }, this); + } else { + params.f = 'image'; + this._renderImage(this.options.url + 'exportImage' + L.Util.getParamString(params), bounds); + } + } + }); + + function imageMapLayer (url, options) { + return new ImageMapLayer(url, options); + } + + var DynamicMapLayer = RasterLayer.extend({ + + options: { + updateInterval: 150, + layers: false, + layerDefs: false, + timeOptions: false, + format: 'png24', + transparent: true, + f: 'json' + }, + + initialize: function (options) { + options.url = cleanUrl(options.url); + this.service = mapService(options); + this.service.addEventParent(this); + + if ((options.proxy || options.token) && options.f !== 'json') { + options.f = 'json'; + } + L.Util.setOptions(this, options); + }, + + getDynamicLayers: function () { + return this.options.dynamicLayers; + }, + + setDynamicLayers: function (dynamicLayers) { + this.options.dynamicLayers = dynamicLayers; + this._update(); + return this; + }, + + getLayers: function () { + return this.options.layers; + }, + + setLayers: function (layers) { + this.options.layers = layers; + this._update(); + return this; + }, + + getLayerDefs: function () { + return this.options.layerDefs; + }, + + setLayerDefs: function (layerDefs) { + this.options.layerDefs = layerDefs; + this._update(); + return this; + }, + + getTimeOptions: function () { + return this.options.timeOptions; + }, + + setTimeOptions: function (timeOptions) { + this.options.timeOptions = timeOptions; + this._update(); + return this; + }, + + query: function () { + return this.service.query(); + }, + + identify: function () { + return this.service.identify(); + }, + + find: function () { + return this.service.find(); + }, + + _getPopupData: function (e) { + var callback = L.Util.bind(function (error, featureCollection, response) { + if (error) { return; } // we really can't do anything here but authenticate or requesterror will fire + setTimeout(L.Util.bind(function () { + this._renderPopup(e.latlng, error, featureCollection, response); + }, this), 300); + }, this); + + var identifyRequest = this.identify().on(this._map).at(e.latlng); + + if (this.options.layers) { + identifyRequest.layers('visible:' + this.options.layers.join(',')); + } else { + identifyRequest.layers('visible'); + } + + identifyRequest.run(callback); + + // set the flags to show the popup + this._shouldRenderPopup = true; + this._lastClick = e.latlng; + }, + + _buildExportParams: function () { + var bounds = this._map.getBounds(); + var size = this._map.getSize(); + var ne = this._map.options.crs.project(bounds.getNorthEast()); + var sw = this._map.options.crs.project(bounds.getSouthWest()); + var sr = parseInt(this._map.options.crs.code.split(':')[1], 10); + + // ensure that we don't ask ArcGIS Server for a taller image than we have actual map displaying + var top = this._map.latLngToLayerPoint(bounds._northEast); + var bottom = this._map.latLngToLayerPoint(bounds._southWest); + + if (top.y > 0 || bottom.y < size.y) { + size.y = bottom.y - top.y; + } + + var params = { + bbox: [sw.x, sw.y, ne.x, ne.y].join(','), + size: size.x + ',' + size.y, + dpi: 96, + format: this.options.format, + transparent: this.options.transparent, + bboxSR: sr, + imageSR: sr + }; + + if (this.options.dynamicLayers) { + params.dynamicLayers = this.options.dynamicLayers; + } + + if (this.options.layers) { + params.layers = 'show:' + this.options.layers.join(','); + } + + if (this.options.layerDefs) { + params.layerDefs = JSON.stringify(this.options.layerDefs); + } + + if (this.options.timeOptions) { + params.timeOptions = JSON.stringify(this.options.timeOptions); + } + + if (this.options.from && this.options.to) { + params.time = this.options.from.valueOf() + ',' + this.options.to.valueOf(); + } + + if (this.service.options.token) { + params.token = this.service.options.token; + } + + return params; + }, + + _requestExport: function (params, bounds) { + if (this.options.f === 'json') { + this.service.request('export', params, function (error, response) { + if (error) { return; } // we really can't do anything here but authenticate or requesterror will fire + this._renderImage(response.href, bounds); + }, this); + } else { + params.f = 'image'; + this._renderImage(this.options.url + 'export' + L.Util.getParamString(params), bounds); + } + } + }); + + function dynamicMapLayer (url, options) { + return new DynamicMapLayer(url, options); + } + + var VirtualGrid = L.Layer.extend({ + + options: { + cellSize: 512, + updateInterval: 150 + }, + + initialize: function (options) { + options = L.setOptions(this, options); + this._zooming = false; + }, + + onAdd: function (map) { + this._map = map; + this._update = L.Util.throttle(this._update, this.options.updateInterval, this); + this._reset(); + this._update(); + }, + + onRemove: function () { + this._map.removeEventListener(this.getEvents(), this); + this._removeCells(); + }, + + getEvents: function () { + var events = { + moveend: this._update, + zoomstart: this._zoomstart, + zoomend: this._reset + }; + + return events; + }, + + addTo: function (map) { + map.addLayer(this); + return this; + }, + + removeFrom: function (map) { + map.removeLayer(this); + return this; + }, + + _zoomstart: function () { + this._zooming = true; + }, + + _reset: function () { + this._removeCells(); + + this._cells = {}; + this._activeCells = {}; + this._cellsToLoad = 0; + this._cellsTotal = 0; + this._cellNumBounds = this._getCellNumBounds(); + + this._resetWrap(); + this._zooming = false; + }, + + _resetWrap: function () { + var map = this._map; + var crs = map.options.crs; + + if (crs.infinite) { return; } + + var cellSize = this._getCellSize(); + + if (crs.wrapLng) { + this._wrapLng = [ + Math.floor(map.project([0, crs.wrapLng[0]]).x / cellSize), + Math.ceil(map.project([0, crs.wrapLng[1]]).x / cellSize) + ]; + } + + if (crs.wrapLat) { + this._wrapLat = [ + Math.floor(map.project([crs.wrapLat[0], 0]).y / cellSize), + Math.ceil(map.project([crs.wrapLat[1], 0]).y / cellSize) + ]; + } + }, + + _getCellSize: function () { + return this.options.cellSize; + }, + + _update: function () { + if (!this._map) { + return; + } + + var bounds = this._map.getPixelBounds(); + var cellSize = this._getCellSize(); + + // cell coordinates range for the current view + var cellBounds = L.bounds( + bounds.min.divideBy(cellSize).floor(), + bounds.max.divideBy(cellSize).floor()); + + this._removeOtherCells(cellBounds); + this._addCells(cellBounds); + + this.fire('cellsupdated'); + }, + + _addCells: function (bounds) { + var queue = []; + var center = bounds.getCenter(); + var zoom = this._map.getZoom(); + + var j, i, coords; + // create a queue of coordinates to load cells from + for (j = bounds.min.y; j <= bounds.max.y; j++) { + for (i = bounds.min.x; i <= bounds.max.x; i++) { + coords = L.point(i, j); + coords.z = zoom; + + if (this._isValidCell(coords)) { + queue.push(coords); + } + } + } + + var cellsToLoad = queue.length; + + if (cellsToLoad === 0) { return; } + + this._cellsToLoad += cellsToLoad; + this._cellsTotal += cellsToLoad; + + // sort cell queue to load cells in order of their distance to center + queue.sort(function (a, b) { + return a.distanceTo(center) - b.distanceTo(center); + }); + + for (i = 0; i < cellsToLoad; i++) { + this._addCell(queue[i]); + } + }, + + _isValidCell: function (coords) { + var crs = this._map.options.crs; + + if (!crs.infinite) { + // don't load cell if it's out of bounds and not wrapped + var bounds = this._cellNumBounds; + if ( + (!crs.wrapLng && (coords.x < bounds.min.x || coords.x > bounds.max.x)) || + (!crs.wrapLat && (coords.y < bounds.min.y || coords.y > bounds.max.y)) + ) { + return false; + } + } + + if (!this.options.bounds) { + return true; + } + + // don't load cell if it doesn't intersect the bounds in options + var cellBounds = this._cellCoordsToBounds(coords); + return L.latLngBounds(this.options.bounds).intersects(cellBounds); + }, + + // converts cell coordinates to its geographical bounds + _cellCoordsToBounds: function (coords) { + var map = this._map; + var cellSize = this.options.cellSize; + var nwPoint = coords.multiplyBy(cellSize); + var sePoint = nwPoint.add([cellSize, cellSize]); + var nw = map.wrapLatLng(map.unproject(nwPoint, coords.z)); + var se = map.wrapLatLng(map.unproject(sePoint, coords.z)); + + return L.latLngBounds(nw, se); + }, + + // converts cell coordinates to key for the cell cache + _cellCoordsToKey: function (coords) { + return coords.x + ':' + coords.y; + }, + + // converts cell cache key to coordiantes + _keyToCellCoords: function (key) { + var kArr = key.split(':'); + var x = parseInt(kArr[0], 10); + var y = parseInt(kArr[1], 10); + + return L.point(x, y); + }, + + // remove any present cells that are off the specified bounds + _removeOtherCells: function (bounds) { + for (var key in this._cells) { + if (!bounds.contains(this._keyToCellCoords(key))) { + this._removeCell(key); + } + } + }, + + _removeCell: function (key) { + var cell = this._activeCells[key]; + + if (cell) { + delete this._activeCells[key]; + + if (this.cellLeave) { + this.cellLeave(cell.bounds, cell.coords); + } + + this.fire('cellleave', { + bounds: cell.bounds, + coords: cell.coords + }); + } + }, + + _removeCells: function () { + for (var key in this._cells) { + var bounds = this._cells[key].bounds; + var coords = this._cells[key].coords; + + if (this.cellLeave) { + this.cellLeave(bounds, coords); + } + + this.fire('cellleave', { + bounds: bounds, + coords: coords + }); + } + }, + + _addCell: function (coords) { + // wrap cell coords if necessary (depending on CRS) + this._wrapCoords(coords); + + // generate the cell key + var key = this._cellCoordsToKey(coords); + + // get the cell from the cache + var cell = this._cells[key]; + // if this cell should be shown as isnt active yet (enter) + + if (cell && !this._activeCells[key]) { + if (this.cellEnter) { + this.cellEnter(cell.bounds, coords); + } + + this.fire('cellenter', { + bounds: cell.bounds, + coords: coords + }); + + this._activeCells[key] = cell; + } + + // if we dont have this cell in the cache yet (create) + if (!cell) { + cell = { + coords: coords, + bounds: this._cellCoordsToBounds(coords) + }; + + this._cells[key] = cell; + this._activeCells[key] = cell; + + if (this.createCell) { + this.createCell(cell.bounds, coords); + } + + this.fire('cellcreate', { + bounds: cell.bounds, + coords: coords + }); + } + }, + + _wrapCoords: function (coords) { + coords.x = this._wrapLng ? L.Util.wrapNum(coords.x, this._wrapLng) : coords.x; + coords.y = this._wrapLat ? L.Util.wrapNum(coords.y, this._wrapLat) : coords.y; + }, + + // get the global cell coordinates range for the current zoom + _getCellNumBounds: function () { + var bounds = this._map.getPixelWorldBounds(); + var size = this._getCellSize(); + + return bounds ? L.bounds( + bounds.min.divideBy(size).floor(), + bounds.max.divideBy(size).ceil().subtract([1, 1])) : null; + } + }); + + function BinarySearchIndex (values) { + this.values = [].concat(values || []); + } + + BinarySearchIndex.prototype.query = function (value) { + var index = this.getIndex(value); + return this.values[index]; + }; + + BinarySearchIndex.prototype.getIndex = function getIndex (value) { + if (this.dirty) { + this.sort(); + } + + var minIndex = 0; + var maxIndex = this.values.length - 1; + var currentIndex; + var currentElement; + + while (minIndex <= maxIndex) { + currentIndex = (minIndex + maxIndex) / 2 | 0; + currentElement = this.values[Math.round(currentIndex)]; + if (+currentElement.value < +value) { + minIndex = currentIndex + 1; + } else if (+currentElement.value > +value) { + maxIndex = currentIndex - 1; + } else { + return currentIndex; + } + } + + return Math.abs(~maxIndex); + }; + + BinarySearchIndex.prototype.between = function between (start, end) { + var startIndex = this.getIndex(start); + var endIndex = this.getIndex(end); + + if (startIndex === 0 && endIndex === 0) { + return []; + } + + while (this.values[startIndex - 1] && this.values[startIndex - 1].value === start) { + startIndex--; + } + + while (this.values[endIndex + 1] && this.values[endIndex + 1].value === end) { + endIndex++; + } + + if (this.values[endIndex] && this.values[endIndex].value === end && this.values[endIndex + 1]) { + endIndex++; + } + + return this.values.slice(startIndex, endIndex); + }; + + BinarySearchIndex.prototype.insert = function insert (item) { + this.values.splice(this.getIndex(item.value), 0, item); + return this; + }; + + BinarySearchIndex.prototype.bulkAdd = function bulkAdd (items, sort) { + this.values = this.values.concat([].concat(items || [])); + + if (sort) { + this.sort(); + } else { + this.dirty = true; + } + + return this; + }; + + BinarySearchIndex.prototype.sort = function sort () { + this.values.sort(function (a, b) { + return +b.value - +a.value; + }).reverse(); + this.dirty = false; + return this; + }; + + var FeatureManager = VirtualGrid.extend({ + /** + * Options + */ + + options: { + attribution: null, + where: '1=1', + fields: ['*'], + from: false, + to: false, + timeField: false, + timeFilterMode: 'server', + simplifyFactor: 0, + precision: 6 + }, + + /** + * Constructor + */ + + initialize: function (options) { + VirtualGrid.prototype.initialize.call(this, options); + + options.url = cleanUrl(options.url); + options = L.setOptions(this, options); + + this.service = featureLayerService(options); + this.service.addEventParent(this); + + // use case insensitive regex to look for common fieldnames used for indexing + if (this.options.fields[0] !== '*') { + var oidCheck = false; + for (var i = 0; i < this.options.fields.length; i++) { + if (this.options.fields[i].match(/^(OBJECTID|FID|OID|ID)$/i)) { + oidCheck = true; + } + } + if (oidCheck === false) { + warn('no known esriFieldTypeOID field detected in fields Array. Please add an attribute field containing unique IDs to ensure the layer can be drawn correctly.'); + } + } + + if (this.options.timeField.start && this.options.timeField.end) { + this._startTimeIndex = new BinarySearchIndex(); + this._endTimeIndex = new BinarySearchIndex(); + } else if (this.options.timeField) { + this._timeIndex = new BinarySearchIndex(); + } + + this._cache = {}; + this._currentSnapshot = []; // cache of what layers should be active + this._activeRequests = 0; + }, + + /** + * Layer Interface + */ + + onAdd: function (map) { + map.on('zoomend', this._handleZoomChange, this); + + return VirtualGrid.prototype.onAdd.call(this, map); + }, + + onRemove: function (map) { + map.off('zoomend', this._handleZoomChange, this); + + return VirtualGrid.prototype.onRemove.call(this, map); + }, + + getAttribution: function () { + return this.options.attribution; + }, + + /** + * Feature Management + */ + + createCell: function (bounds, coords) { + this._requestFeatures(bounds, coords); + }, + + _requestFeatures: function (bounds, coords, callback) { + this._activeRequests++; + + // our first active request fires loading + if (this._activeRequests === 1) { + this.fire('loading', { + bounds: bounds + }, true); + } + + return this._buildQuery(bounds).run(function (error, featureCollection, response) { + if (response && response.exceededTransferLimit) { + this.fire('drawlimitexceeded'); + } + + // no error, features + if (!error && featureCollection && featureCollection.features.length) { + // schedule adding features until the next animation frame + L.Util.requestAnimFrame(L.Util.bind(function () { + this._addFeatures(featureCollection.features, coords); + this._postProcessFeatures(bounds); + }, this)); + } + + // no error, no features + if (!error && featureCollection && !featureCollection.features.length) { + this._postProcessFeatures(bounds); + } + + if (error) { + this._postProcessFeatures(bounds); + } + + if (callback) { + callback.call(this, error, featureCollection); + } + }, this); + }, + + _postProcessFeatures: function (bounds) { + // deincriment the request counter now that we have processed features + this._activeRequests--; + + // if there are no more active requests fire a load event for this view + if (this._activeRequests <= 0) { + this.fire('load', { + bounds: bounds + }); + } + }, + + _cacheKey: function (coords) { + return coords.z + ':' + coords.x + ':' + coords.y; + }, + + _addFeatures: function (features, coords) { + var key = this._cacheKey(coords); + this._cache[key] = this._cache[key] || []; + + for (var i = features.length - 1; i >= 0; i--) { + var id = features[i].id; + this._currentSnapshot.push(id); + this._cache[key].push(id); + } + + if (this.options.timeField) { + this._buildTimeIndexes(features); + } + + // need to PR removal of the logic below too... + // https://github.com/patrickarlt/leaflet-virtual-grid/blob/master/src/virtual-grid.js#L100-L102 + + this.createLayers(features); + }, + + _buildQuery: function (bounds) { + var query = this.service.query() + .intersects(bounds) + .where(this.options.where) + .fields(this.options.fields) + .precision(this.options.precision); + + if (this.options.simplifyFactor) { + query.simplify(this._map, this.options.simplifyFactor); + } + + if (this.options.timeFilterMode === 'server' && this.options.from && this.options.to) { + query.between(this.options.from, this.options.to); + } + + return query; + }, + + /** + * Where Methods + */ + + setWhere: function (where, callback, context) { + this.options.where = (where && where.length) ? where : '1=1'; + + var oldSnapshot = []; + var newSnapshot = []; + var pendingRequests = 0; + var requestError = null; + var requestCallback = L.Util.bind(function (error, featureCollection) { + if (error) { + requestError = error; + } + + if (featureCollection) { + for (var i = featureCollection.features.length - 1; i >= 0; i--) { + newSnapshot.push(featureCollection.features[i].id); + } + } + + pendingRequests--; + + if (pendingRequests <= 0) { + this._currentSnapshot = newSnapshot; + // schedule adding features for the next animation frame + L.Util.requestAnimFrame(L.Util.bind(function () { + this.removeLayers(oldSnapshot); + this.addLayers(newSnapshot); + if (callback) { + callback.call(context, requestError); + } + }, this)); + } + }, this); + + for (var i = this._currentSnapshot.length - 1; i >= 0; i--) { + oldSnapshot.push(this._currentSnapshot[i]); + } + + for (var key in this._activeCells) { + pendingRequests++; + var coords = this._keyToCellCoords(key); + var bounds = this._cellCoordsToBounds(coords); + this._requestFeatures(bounds, key, requestCallback); + } + + return this; + }, + + getWhere: function () { + return this.options.where; + }, + + /** + * Time Range Methods + */ + + getTimeRange: function () { + return [this.options.from, this.options.to]; + }, + + setTimeRange: function (from, to, callback, context) { + var oldFrom = this.options.from; + var oldTo = this.options.to; + var pendingRequests = 0; + var requestError = null; + var requestCallback = L.Util.bind(function (error) { + if (error) { + requestError = error; + } + this._filterExistingFeatures(oldFrom, oldTo, from, to); + + pendingRequests--; + + if (callback && pendingRequests <= 0) { + callback.call(context, requestError); + } + }, this); + + this.options.from = from; + this.options.to = to; + + this._filterExistingFeatures(oldFrom, oldTo, from, to); + + if (this.options.timeFilterMode === 'server') { + for (var key in this._activeCells) { + pendingRequests++; + var coords = this._keyToCellCoords(key); + var bounds = this._cellCoordsToBounds(coords); + this._requestFeatures(bounds, key, requestCallback); + } + } + + return this; + }, + + refresh: function () { + for (var key in this._activeCells) { + var coords = this._keyToCellCoords(key); + var bounds = this._cellCoordsToBounds(coords); + this._requestFeatures(bounds, key); + } + + if (this.redraw) { + this.once('load', function () { + this.eachFeature(function (layer) { + this._redraw(layer.feature.id); + }, this); + }, this); + } + }, + + _filterExistingFeatures: function (oldFrom, oldTo, newFrom, newTo) { + var layersToRemove = (oldFrom && oldTo) ? this._getFeaturesInTimeRange(oldFrom, oldTo) : this._currentSnapshot; + var layersToAdd = this._getFeaturesInTimeRange(newFrom, newTo); + + if (layersToAdd.indexOf) { + for (var i = 0; i < layersToAdd.length; i++) { + var shouldRemoveLayer = layersToRemove.indexOf(layersToAdd[i]); + if (shouldRemoveLayer >= 0) { + layersToRemove.splice(shouldRemoveLayer, 1); + } + } + } + + // schedule adding features until the next animation frame + L.Util.requestAnimFrame(L.Util.bind(function () { + this.removeLayers(layersToRemove); + this.addLayers(layersToAdd); + }, this)); + }, + + _getFeaturesInTimeRange: function (start, end) { + var ids = []; + var search; + + if (this.options.timeField.start && this.options.timeField.end) { + var startTimes = this._startTimeIndex.between(start, end); + var endTimes = this._endTimeIndex.between(start, end); + search = startTimes.concat(endTimes); + } else { + search = this._timeIndex.between(start, end); + } + + for (var i = search.length - 1; i >= 0; i--) { + ids.push(search[i].id); + } + + return ids; + }, + + _buildTimeIndexes: function (geojson) { + var i; + var feature; + if (this.options.timeField.start && this.options.timeField.end) { + var startTimeEntries = []; + var endTimeEntries = []; + for (i = geojson.length - 1; i >= 0; i--) { + feature = geojson[i]; + startTimeEntries.push({ + id: feature.id, + value: new Date(feature.properties[this.options.timeField.start]) + }); + endTimeEntries.push({ + id: feature.id, + value: new Date(feature.properties[this.options.timeField.end]) + }); + } + this._startTimeIndex.bulkAdd(startTimeEntries); + this._endTimeIndex.bulkAdd(endTimeEntries); + } else { + var timeEntries = []; + for (i = geojson.length - 1; i >= 0; i--) { + feature = geojson[i]; + timeEntries.push({ + id: feature.id, + value: new Date(feature.properties[this.options.timeField]) + }); + } + + this._timeIndex.bulkAdd(timeEntries); + } + }, + + _featureWithinTimeRange: function (feature) { + if (!this.options.from || !this.options.to) { + return true; + } + + var from = +this.options.from.valueOf(); + var to = +this.options.to.valueOf(); + + if (typeof this.options.timeField === 'string') { + var date = +feature.properties[this.options.timeField]; + return (date >= from) && (date <= to); + } + + if (this.options.timeField.start && this.options.timeField.end) { + var startDate = +feature.properties[this.options.timeField.start]; + var endDate = +feature.properties[this.options.timeField.end]; + return ((startDate >= from) && (startDate <= to)) || ((endDate >= from) && (endDate <= to)); + } + }, + + _visibleZoom: function () { + // check to see whether the current zoom level of the map is within the optional limit defined for the FeatureLayer + if (!this._map) { + return false; + } + var zoom = this._map.getZoom(); + if (zoom > this.options.maxZoom || zoom < this.options.minZoom) { + return false; + } else { return true; } + }, + + _handleZoomChange: function () { + if (!this._visibleZoom()) { + this.removeLayers(this._currentSnapshot); + this._currentSnapshot = []; + } else { + /* + for every cell in this._activeCells + 1. Get the cache key for the coords of the cell + 2. If this._cache[key] exists it will be an array of feature IDs. + 3. Call this.addLayers(this._cache[key]) to instruct the feature layer to add the layers back. + */ + for (var i in this._activeCells) { + var coords = this._activeCells[i].coords; + var key = this._cacheKey(coords); + if (this._cache[key]) { + this.addLayers(this._cache[key]); + } + } + } + }, + + /** + * Service Methods + */ + + authenticate: function (token) { + this.service.authenticate(token); + return this; + }, + + metadata: function (callback, context) { + this.service.metadata(callback, context); + return this; + }, + + query: function () { + return this.service.query(); + }, + + _getMetadata: function (callback) { + if (this._metadata) { + var error; + callback(error, this._metadata); + } else { + this.metadata(L.Util.bind(function (error, response) { + this._metadata = response; + callback(error, this._metadata); + }, this)); + } + }, + + addFeature: function (feature, callback, context) { + this._getMetadata(L.Util.bind(function (error, metadata) { + if (error) { + if (callback) { callback.call(this, error, null); } + return; + } + + this.service.addFeature(feature, L.Util.bind(function (error, response) { + if (!error) { + // assign ID from result to appropriate objectid field from service metadata + feature.properties[metadata.objectIdField] = response.objectId; + + // we also need to update the geojson id for createLayers() to function + feature.id = response.objectId; + this.createLayers([feature]); + } + + if (callback) { + callback.call(context, error, response); + } + }, this)); + }, this)); + }, + + updateFeature: function (feature, callback, context) { + this.service.updateFeature(feature, function (error, response) { + if (!error) { + this.removeLayers([feature.id], true); + this.createLayers([feature]); + } + + if (callback) { + callback.call(context, error, response); + } + }, this); + }, + + deleteFeature: function (id, callback, context) { + this.service.deleteFeature(id, function (error, response) { + if (!error && response.objectId) { + this.removeLayers([response.objectId], true); + } + if (callback) { + callback.call(context, error, response); + } + }, this); + }, + + deleteFeatures: function (ids, callback, context) { + return this.service.deleteFeatures(ids, function (error, response) { + if (!error && response.length > 0) { + for (var i = 0; i < response.length; i++) { + this.removeLayers([response[i].objectId], true); + } + } + if (callback) { + callback.call(context, error, response); + } + }, this); + } + }); + + var FeatureLayer = FeatureManager.extend({ + + options: { + cacheLayers: true + }, + + /** + * Constructor + */ + initialize: function (options) { + FeatureManager.prototype.initialize.call(this, options); + this._originalStyle = this.options.style; + this._layers = {}; + }, + + /** + * Layer Interface + */ + + onRemove: function (map) { + for (var i in this._layers) { + map.removeLayer(this._layers[i]); + } + + return FeatureManager.prototype.onRemove.call(this, map); + }, + + createNewLayer: function (geojson) { + var layer = L.GeoJSON.geometryToLayer(geojson, this.options); + layer.defaultOptions = layer.options; + return layer; + }, + + _updateLayer: function (layer, geojson) { + // convert the geojson coordinates into a Leaflet LatLng array/nested arrays + // pass it to setLatLngs to update layer geometries + var latlngs = []; + var coordsToLatLng = this.options.coordsToLatLng || L.GeoJSON.coordsToLatLng; + + // copy new attributes, if present + if (geojson.properties) { + layer.feature.properties = geojson.properties; + } + + switch (geojson.geometry.type) { + case 'Point': + latlngs = L.GeoJSON.coordsToLatLng(geojson.geometry.coordinates); + layer.setLatLng(latlngs); + break; + case 'LineString': + latlngs = L.GeoJSON.coordsToLatLngs(geojson.geometry.coordinates, 0, coordsToLatLng); + layer.setLatLngs(latlngs); + break; + case 'MultiLineString': + latlngs = L.GeoJSON.coordsToLatLngs(geojson.geometry.coordinates, 1, coordsToLatLng); + layer.setLatLngs(latlngs); + break; + case 'Polygon': + latlngs = L.GeoJSON.coordsToLatLngs(geojson.geometry.coordinates, 1, coordsToLatLng); + layer.setLatLngs(latlngs); + break; + case 'MultiPolygon': + latlngs = L.GeoJSON.coordsToLatLngs(geojson.geometry.coordinates, 2, coordsToLatLng); + layer.setLatLngs(latlngs); + break; + } + }, + + /** + * Feature Management Methods + */ + + createLayers: function (features) { + for (var i = features.length - 1; i >= 0; i--) { + var geojson = features[i]; + + var layer = this._layers[geojson.id]; + var newLayer; + + if (this._visibleZoom() && layer && !this._map.hasLayer(layer)) { + this._map.addLayer(layer); + } + + // update geometry if necessary + if (layer && this.options.simplifyFactor > 0 && (layer.setLatLngs || layer.setLatLng)) { + this._updateLayer(layer, geojson); + } + + if (!layer) { + newLayer = this.createNewLayer(geojson); + newLayer.feature = geojson; + + // bubble events from individual layers to the feature layer + newLayer.addEventParent(this); + + if (this.options.onEachFeature) { + this.options.onEachFeature(newLayer.feature, newLayer); + } + + // cache the layer + this._layers[newLayer.feature.id] = newLayer; + + // style the layer + this.setFeatureStyle(newLayer.feature.id, this.options.style); + + this.fire('createfeature', { + feature: newLayer.feature + }, true); + + // add the layer if the current zoom level is inside the range defined for the layer, it is within the current time bounds or our layer is not time enabled + if (this._visibleZoom() && (!this.options.timeField || (this.options.timeField && this._featureWithinTimeRange(geojson)))) { + this._map.addLayer(newLayer); + } + } + } + }, + + addLayers: function (ids) { + for (var i = ids.length - 1; i >= 0; i--) { + var layer = this._layers[ids[i]]; + if (layer) { + this.fire('addfeature', { + feature: layer.feature + }, true); + this._map.addLayer(layer); + } + } + }, + + removeLayers: function (ids, permanent) { + for (var i = ids.length - 1; i >= 0; i--) { + var id = ids[i]; + var layer = this._layers[id]; + if (layer) { + this.fire('removefeature', { + feature: layer.feature, + permanent: permanent + }, true); + this._map.removeLayer(layer); + } + if (layer && permanent) { + delete this._layers[id]; + } + } + }, + + cellEnter: function (bounds, coords) { + if (!this._zooming && this._map) { + L.Util.requestAnimFrame(L.Util.bind(function () { + var cacheKey = this._cacheKey(coords); + var cellKey = this._cellCoordsToKey(coords); + var layers = this._cache[cacheKey]; + if (this._activeCells[cellKey] && layers) { + this.addLayers(layers); + } + }, this)); + } + }, + + cellLeave: function (bounds, coords) { + if (!this._zooming) { + L.Util.requestAnimFrame(L.Util.bind(function () { + if (this._map) { + var cacheKey = this._cacheKey(coords); + var cellKey = this._cellCoordsToKey(coords); + var layers = this._cache[cacheKey]; + var mapBounds = this._map.getBounds(); + if (!this._activeCells[cellKey] && layers) { + var removable = true; + + for (var i = 0; i < layers.length; i++) { + var layer = this._layers[layers[i]]; + if (layer && layer.getBounds && mapBounds.intersects(layer.getBounds())) { + removable = false; + } + } + + if (removable) { + this.removeLayers(layers, !this.options.cacheLayers); + } + + if (!this.options.cacheLayers && removable) { + delete this._cache[cacheKey]; + delete this._cells[cellKey]; + delete this._activeCells[cellKey]; + } + } + } + }, this)); + } + }, + + /** + * Styling Methods + */ + + resetStyle: function () { + this.options.style = this._originalStyle; + this.eachFeature(function (layer) { + this.resetFeatureStyle(layer.feature.id); + }, this); + return this; + }, + + setStyle: function (style) { + this.options.style = style; + this.eachFeature(function (layer) { + this.setFeatureStyle(layer.feature.id, style); + }, this); + return this; + }, + + resetFeatureStyle: function (id) { + var layer = this._layers[id]; + var style = this._originalStyle || L.Path.prototype.options; + if (layer) { + L.Util.extend(layer.options, layer.defaultOptions); + this.setFeatureStyle(id, style); + } + return this; + }, + + setFeatureStyle: function (id, style) { + var layer = this._layers[id]; + if (typeof style === 'function') { + style = style(layer.feature); + } + if (layer.setStyle) { + layer.setStyle(style); + } + return this; + }, + + /** + * Utility Methods + */ + + eachFeature: function (fn, context) { + for (var i in this._layers) { + fn.call(context, this._layers[i]); + } + return this; + }, + + getFeature: function (id) { + return this._layers[id]; + }, + + bringToBack: function () { + this.eachFeature(function (layer) { + if (layer.bringToBack) { + layer.bringToBack(); + } + }); + }, + + bringToFront: function () { + this.eachFeature(function (layer) { + if (layer.bringToFront) { + layer.bringToFront(); + } + }); + }, + + redraw: function (id) { + if (id) { + this._redraw(id); + } + return this; + }, + + _redraw: function (id) { + var layer = this._layers[id]; + var geojson = layer.feature; + + // if this looks like a marker + if (layer && layer.setIcon && this.options.pointToLayer) { + // update custom symbology, if necessary + if (this.options.pointToLayer) { + var getIcon = this.options.pointToLayer(geojson, L.latLng(geojson.geometry.coordinates[1], geojson.geometry.coordinates[0])); + var updatedIcon = getIcon.options.icon; + layer.setIcon(updatedIcon); + } + } + + // looks like a vector marker (circleMarker) + if (layer && layer.setStyle && this.options.pointToLayer) { + var getStyle = this.options.pointToLayer(geojson, L.latLng(geojson.geometry.coordinates[1], geojson.geometry.coordinates[0])); + var updatedStyle = getStyle.options; + this.setFeatureStyle(geojson.id, updatedStyle); + } + + // looks like a path (polygon/polyline) + if (layer && layer.setStyle && this.options.style) { + this.resetStyle(geojson.id); + } + } + }); + + function featureLayer (options) { + return new FeatureLayer(options); + } + + exports.VERSION = version; + exports.Support = Support; + exports.Util = Util; + exports.get = get; + exports.post = xmlHttpPost; + exports.request = request; + exports.Task = Task; + exports.task = task; + exports.Query = Query; + exports.query = query; + exports.Find = Find; + exports.find = find; + exports.Identify = Identify; + exports.identify = identify; + exports.IdentifyFeatures = IdentifyFeatures; + exports.identifyFeatures = identifyFeatures; + exports.IdentifyImage = IdentifyImage; + exports.identifyImage = identifyImage; + exports.Service = Service; + exports.service = service; + exports.MapService = MapService; + exports.mapService = mapService; + exports.ImageService = ImageService; + exports.imageService = imageService; + exports.FeatureLayerService = FeatureLayerService; + exports.featureLayerService = featureLayerService; + exports.BasemapLayer = BasemapLayer; + exports.basemapLayer = basemapLayer; + exports.TiledMapLayer = TiledMapLayer; + exports.tiledMapLayer = tiledMapLayer; + exports.RasterLayer = RasterLayer; + exports.ImageMapLayer = ImageMapLayer; + exports.imageMapLayer = imageMapLayer; + exports.DynamicMapLayer = DynamicMapLayer; + exports.dynamicMapLayer = dynamicMapLayer; + exports.FeatureManager = FeatureManager; + exports.FeatureLayer = FeatureLayer; + exports.featureLayer = featureLayer; + +})); +//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"file":"esri-leaflet-debug.js","sources":["../package.json","../src/Support.js","../node_modules/arcgis-to-geojson-utils/index.js","../src/Util.js","../src/Request.js","../src/Tasks/Task.js","../src/Tasks/Query.js","../src/Tasks/Find.js","../src/Tasks/Identify.js","../src/Tasks/IdentifyFeatures.js","../src/Tasks/IdentifyImage.js","../src/Services/Service.js","../src/Services/MapService.js","../src/Services/ImageService.js","../src/Services/FeatureLayerService.js","../src/Controls/Logo.js","../src/Layers/BasemapLayer.js","../src/Layers/TiledMapLayer.js","../src/Layers/RasterLayer.js","../src/Layers/ImageMapLayer.js","../src/Layers/DynamicMapLayer.js","../node_modules/leaflet-virtual-grid/src/virtual-grid.js","../node_modules/tiny-binary-search/index.js","../src/Layers/FeatureLayer/FeatureManager.js","../src/Layers/FeatureLayer/FeatureLayer.js"],"sourcesContent":["{\n  \"name\": \"esri-leaflet\",\n  \"description\": \"Leaflet plugins for consuming ArcGIS Online and ArcGIS Server services.\",\n  \"version\": \"2.0.0\",\n  \"author\": \"Patrick Arlt <parlt@esri.com> (http://patrickarlt.com)\",\n  \"browser\": \"dist/esri-leaflet-debug.js\",\n  \"bugs\": {\n    \"url\": \"https://github.com/esri/esri-leaflet/issues\"\n  },\n  \"contributors\": [\n    \"Patrick Arlt <parlt@esri.com> (http://patrickarlt.com)\",\n    \"John Gravois <jgravois@esri.com> (http://johngravois.com)\"\n  ],\n  \"dependencies\": {\n    \"arcgis-to-geojson-utils\": \"^1.0.1\",\n    \"leaflet\": \"^1.0.0-rc.1\",\n    \"leaflet-virtual-grid\": \"^1.0.3\",\n    \"tiny-binary-search\": \"^1.0.2\"\n  },\n  \"devDependencies\": {\n    \"chai\": \"2.3.0\",\n    \"eslint\": \"^1.10.2\",\n    \"gh-release\": \"^2.0.0\",\n    \"highlight.js\": \"^8.0.0\",\n    \"http-server\": \"^0.8.5\",\n    \"isparta\": \"^3.0.3\",\n    \"istanbul\": \"^0.4.2\",\n    \"karma\": \"^0.12.16\",\n    \"karma-chai-sinon\": \"^0.1.3\",\n    \"karma-coverage\": \"^0.5.3\",\n    \"karma-mocha\": \"^0.1.0\",\n    \"karma-mocha-reporter\": \"^0.2.5\",\n    \"karma-phantomjs-launcher\": \"^0.2.0\",\n    \"karma-sourcemap-loader\": \"^0.3.5\",\n    \"load-grunt-tasks\": \"^0.4.0\",\n    \"mkdirp\": \"^0.5.1\",\n    \"mocha\": \"^2.3.4\",\n    \"phantomjs\": \"^1.9.17\",\n    \"rollup\": \"^0.25.4\",\n    \"rollup-plugin-json\": \"^2.0.0\",\n    \"rollup-plugin-node-resolve\": \"^1.4.0\",\n    \"rollup-plugin-uglify\": \"^0.3.1\",\n    \"semistandard\": \"^7.0.5\",\n    \"sinon\": \"^1.11.1\",\n    \"sinon-chai\": \"2.7.0\",\n    \"snazzy\": \"^2.0.1\",\n    \"uglify-js\": \"^2.6.1\",\n    \"watch\": \"^0.17.1\"\n  },\n  \"homepage\": \"http://esri.github.io/esri-leaflet\",\n  \"jsnext:main\": \"src/EsriLeaflet.js\",\n  \"jspm\": {\n    \"registry\": \"npm\",\n    \"format\": \"es6\",\n    \"main\": \"src/EsriLeaflet.js\"\n  },\n  \"keywords\": [\n    \"arcgis\",\n    \"esri\",\n    \"esri leaflet\",\n    \"gis\",\n    \"leaflet plugin\",\n    \"mapping\"\n  ],\n  \"license\": \"Apache-2.0\",\n  \"main\": \"dist/esri-leaflet-debug.js\",\n  \"readmeFilename\": \"README.md\",\n  \"repository\": {\n    \"type\": \"git\",\n    \"url\": \"git@github.com:Esri/esri-leaflet.git\"\n  },\n  \"scripts\": {\n    \"build\": \"rollup -c profiles/debug.js & rollup -c profiles/production.js\",\n    \"lint\": \"semistandard src/**/*.js | snazzy\",\n    \"prebuild\": \"mkdirp dist\",\n    \"prepublish\": \"npm run build\",\n    \"pretest\": \"npm run build\",\n    \"release\": \"./scripts/release.sh\",\n    \"start\": \"watch 'npm run build' src & http-server -p 5000 -c-1 -o\",\n    \"test\": \"npm run lint && karma start\"\n  }\n}\n","export var cors = ((window.XMLHttpRequest && 'withCredentials' in new window.XMLHttpRequest()));\nexport var pointerEvents = document.documentElement.style.pointerEvents === '';\n\nexport var Support = {\n  cors: cors,\n  pointerEvents: pointerEvents\n};\n\nexport default Support;\n","/*\n * Copyright 2015 Esri\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *     http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the Liscense.\n */\n\n// checks if 2 x,y points are equal\nfunction pointsEqual (a, b) {\n  for (var i = 0; i < a.length; i++) {\n    if (a[i] !== b[i]) {\n      return false;\n    }\n  }\n  return true;\n}\n\n// checks if the first and last points of a ring are equal and closes the ring\nfunction closeRing (coordinates) {\n  if (!pointsEqual(coordinates[0], coordinates[coordinates.length - 1])) {\n    coordinates.push(coordinates[0]);\n  }\n  return coordinates;\n}\n\n// determine if polygon ring coordinates are clockwise. clockwise signifies outer ring, counter-clockwise an inner ring\n// or hole. this logic was found at http://stackoverflow.com/questions/1165647/how-to-determine-if-a-list-of-polygon-\n// points-are-in-clockwise-order\nfunction ringIsClockwise (ringToTest) {\n  var total = 0;\n  var i = 0;\n  var rLength = ringToTest.length;\n  var pt1 = ringToTest[i];\n  var pt2;\n  for (i; i < rLength - 1; i++) {\n    pt2 = ringToTest[i + 1];\n    total += (pt2[0] - pt1[0]) * (pt2[1] + pt1[1]);\n    pt1 = pt2;\n  }\n  return (total >= 0);\n}\n\n// ported from terraformer.js https://github.com/Esri/Terraformer/blob/master/terraformer.js#L504-L519\nfunction vertexIntersectsVertex (a1, a2, b1, b2) {\n  var uaT = (b2[0] - b1[0]) * (a1[1] - b1[1]) - (b2[1] - b1[1]) * (a1[0] - b1[0]);\n  var ubT = (a2[0] - a1[0]) * (a1[1] - b1[1]) - (a2[1] - a1[1]) * (a1[0] - b1[0]);\n  var uB = (b2[1] - b1[1]) * (a2[0] - a1[0]) - (b2[0] - b1[0]) * (a2[1] - a1[1]);\n\n  if (uB !== 0) {\n    var ua = uaT / uB;\n    var ub = ubT / uB;\n\n    if (ua >= 0 && ua <= 1 && ub >= 0 && ub <= 1) {\n      return true;\n    }\n  }\n\n  return false;\n}\n\n// ported from terraformer.js https://github.com/Esri/Terraformer/blob/master/terraformer.js#L521-L531\nfunction arrayIntersectsArray (a, b) {\n  for (var i = 0; i < a.length - 1; i++) {\n    for (var j = 0; j < b.length - 1; j++) {\n      if (vertexIntersectsVertex(a[i], a[i + 1], b[j], b[j + 1])) {\n        return true;\n      }\n    }\n  }\n\n  return false;\n}\n\n// ported from terraformer.js https://github.com/Esri/Terraformer/blob/master/terraformer.js#L470-L480\nfunction coordinatesContainPoint (coordinates, point) {\n  var contains = false;\n  for (var i = -1, l = coordinates.length, j = l - 1; ++i < l; j = i) {\n    if (((coordinates[i][1] <= point[1] && point[1] < coordinates[j][1]) ||\n         (coordinates[j][1] <= point[1] && point[1] < coordinates[i][1])) &&\n        (point[0] < (coordinates[j][0] - coordinates[i][0]) * (point[1] - coordinates[i][1]) / (coordinates[j][1] - coordinates[i][1]) + coordinates[i][0])) {\n      contains = !contains;\n    }\n  }\n  return contains;\n}\n\n// ported from terraformer-arcgis-parser.js https://github.com/Esri/terraformer-arcgis-parser/blob/master/terraformer-arcgis-parser.js#L106-L113\nfunction coordinatesContainCoordinates (outer, inner) {\n  var intersects = arrayIntersectsArray(outer, inner);\n  var contains = coordinatesContainPoint(outer, inner[0]);\n  if (!intersects && contains) {\n    return true;\n  }\n  return false;\n}\n\n// do any polygons in this array contain any other polygons in this array?\n// used for checking for holes in arcgis rings\n// ported from terraformer-arcgis-parser.js https://github.com/Esri/terraformer-arcgis-parser/blob/master/terraformer-arcgis-parser.js#L117-L172\nfunction convertRingsToGeoJSON (rings) {\n  var outerRings = [];\n  var holes = [];\n  var x; // iterator\n  var outerRing; // current outer ring being evaluated\n  var hole; // current hole being evaluated\n\n  // for each ring\n  for (var r = 0; r < rings.length; r++) {\n    var ring = closeRing(rings[r].slice(0));\n    if (ring.length < 4) {\n      continue;\n    }\n    // is this ring an outer ring? is it clockwise?\n    if (ringIsClockwise(ring)) {\n      var polygon = [ ring ];\n      outerRings.push(polygon); // push to outer rings\n    } else {\n      holes.push(ring); // counterclockwise push to holes\n    }\n  }\n\n  var uncontainedHoles = [];\n\n  // while there are holes left...\n  while (holes.length) {\n    // pop a hole off out stack\n    hole = holes.pop();\n\n    // loop over all outer rings and see if they contain our hole.\n    var contained = false;\n    for (x = outerRings.length - 1; x >= 0; x--) {\n      outerRing = outerRings[x][0];\n      if (coordinatesContainCoordinates(outerRing, hole)) {\n        // the hole is contained push it into our polygon\n        outerRings[x].push(hole);\n        contained = true;\n        break;\n      }\n    }\n\n    // ring is not contained in any outer ring\n    // sometimes this happens https://github.com/Esri/esri-leaflet/issues/320\n    if (!contained) {\n      uncontainedHoles.push(hole);\n    }\n  }\n\n  // if we couldn't match any holes using contains we can try intersects...\n  while (uncontainedHoles.length) {\n    // pop a hole off out stack\n    hole = uncontainedHoles.pop();\n\n    // loop over all outer rings and see if any intersect our hole.\n    var intersects = false;\n\n    for (x = outerRings.length - 1; x >= 0; x--) {\n      outerRing = outerRings[x][0];\n      if (arrayIntersectsArray(outerRing, hole)) {\n        // the hole is contained push it into our polygon\n        outerRings[x].push(hole);\n        intersects = true;\n        break;\n      }\n    }\n\n    if (!intersects) {\n      outerRings.push([hole.reverse()]);\n    }\n  }\n\n  if (outerRings.length === 1) {\n    return {\n      type: 'Polygon',\n      coordinates: outerRings[0]\n    };\n  } else {\n    return {\n      type: 'MultiPolygon',\n      coordinates: outerRings\n    };\n  }\n}\n\n// This function ensures that rings are oriented in the right directions\n// outer rings are clockwise, holes are counterclockwise\n// used for converting GeoJSON Polygons to ArcGIS Polygons\nfunction orientRings (poly) {\n  var output = [];\n  var polygon = poly.slice(0);\n  var outerRing = closeRing(polygon.shift().slice(0));\n  if (outerRing.length >= 4) {\n    if (!ringIsClockwise(outerRing)) {\n      outerRing.reverse();\n    }\n\n    output.push(outerRing);\n\n    for (var i = 0; i < polygon.length; i++) {\n      var hole = closeRing(polygon[i].slice(0));\n      if (hole.length >= 4) {\n        if (ringIsClockwise(hole)) {\n          hole.reverse();\n        }\n        output.push(hole);\n      }\n    }\n  }\n\n  return output;\n}\n\n// This function flattens holes in multipolygons to one array of polygons\n// used for converting GeoJSON Polygons to ArcGIS Polygons\nfunction flattenMultiPolygonRings (rings) {\n  var output = [];\n  for (var i = 0; i < rings.length; i++) {\n    var polygon = orientRings(rings[i]);\n    for (var x = polygon.length - 1; x >= 0; x--) {\n      var ring = polygon[x].slice(0);\n      output.push(ring);\n    }\n  }\n  return output;\n}\n\n// shallow object clone for feature properties and attributes\n// from http://jsperf.com/cloning-an-object/2\nfunction shallowClone (obj) {\n  var target = {};\n  for (var i in obj) {\n    if (obj.hasOwnProperty(i)) {\n      target[i] = obj[i];\n    }\n  }\n  return target;\n}\n\nexport function arcgisToGeoJSON (arcgis, idAttribute) {\n  var geojson = {};\n\n  if (typeof arcgis.x === 'number' && typeof arcgis.y === 'number') {\n    geojson.type = 'Point';\n    geojson.coordinates = [arcgis.x, arcgis.y];\n  }\n\n  if (arcgis.points) {\n    geojson.type = 'MultiPoint';\n    geojson.coordinates = arcgis.points.slice(0);\n  }\n\n  if (arcgis.paths) {\n    if (arcgis.paths.length === 1) {\n      geojson.type = 'LineString';\n      geojson.coordinates = arcgis.paths[0].slice(0);\n    } else {\n      geojson.type = 'MultiLineString';\n      geojson.coordinates = arcgis.paths.slice(0);\n    }\n  }\n\n  if (arcgis.rings) {\n    geojson = convertRingsToGeoJSON(arcgis.rings.slice(0));\n  }\n\n  if (arcgis.geometry || arcgis.attributes) {\n    geojson.type = 'Feature';\n    geojson.geometry = (arcgis.geometry) ? arcgisToGeoJSON(arcgis.geometry) : null;\n    geojson.properties = (arcgis.attributes) ? shallowClone(arcgis.attributes) : null;\n    if (arcgis.attributes) {\n      geojson.id = arcgis.attributes[idAttribute] || arcgis.attributes.OBJECTID || arcgis.attributes.FID;\n    }\n  }\n\n  return geojson;\n}\n\nexport function geojsonToArcGIS (geojson, idAttribute) {\n  idAttribute = idAttribute || 'OBJECTID';\n  var spatialReference = { wkid: 4326 };\n  var result = {};\n  var i;\n\n  switch (geojson.type) {\n    case 'Point':\n      result.x = geojson.coordinates[0];\n      result.y = geojson.coordinates[1];\n      result.spatialReference = spatialReference;\n      break;\n    case 'MultiPoint':\n      result.points = geojson.coordinates.slice(0);\n      result.spatialReference = spatialReference;\n      break;\n    case 'LineString':\n      result.paths = [geojson.coordinates.slice(0)];\n      result.spatialReference = spatialReference;\n      break;\n    case 'MultiLineString':\n      result.paths = geojson.coordinates.slice(0);\n      result.spatialReference = spatialReference;\n      break;\n    case 'Polygon':\n      result.rings = orientRings(geojson.coordinates.slice(0));\n      result.spatialReference = spatialReference;\n      break;\n    case 'MultiPolygon':\n      result.rings = flattenMultiPolygonRings(geojson.coordinates.slice(0));\n      result.spatialReference = spatialReference;\n      break;\n    case 'Feature':\n      if (geojson.geometry) {\n        result.geometry = geojsonToArcGIS(geojson.geometry, idAttribute);\n      }\n      result.attributes = (geojson.properties) ? shallowClone(geojson.properties) : {};\n      if (geojson.id) {\n        result.attributes[idAttribute] = geojson.id;\n      }\n      break;\n    case 'FeatureCollection':\n      result = [];\n      for (i = 0; i < geojson.features.length; i++) {\n        result.push(geojsonToArcGIS(geojson.features[i], idAttribute));\n      }\n      break;\n    case 'GeometryCollection':\n      result = [];\n      for (i = 0; i < geojson.geometries.length; i++) {\n        result.push(geojsonToArcGIS(geojson.geometries[i], idAttribute));\n      }\n      break;\n  }\n\n  return result;\n}\n","import L from 'leaflet';\nimport {\n  geojsonToArcGIS as g2a,\n  arcgisToGeoJSON as a2g\n} from 'arcgis-to-geojson-utils';\n\nexport function geojsonToArcGIS (geojson, idAttr) {\n  return g2a(geojson, idAttr);\n}\n\nexport function arcgisToGeoJSON (arcgis, idAttr) {\n  return a2g(arcgis, idAttr);\n}\n\n// shallow object clone for feature properties and attributes\n// from http://jsperf.com/cloning-an-object/2\nexport function shallowClone (obj) {\n  var target = {};\n  for (var i in obj) {\n    if (obj.hasOwnProperty(i)) {\n      target[i] = obj[i];\n    }\n  }\n  return target;\n}\n\n// convert an extent (ArcGIS) to LatLngBounds (Leaflet)\nexport function extentToBounds (extent) {\n  var sw = L.latLng(extent.ymin, extent.xmin);\n  var ne = L.latLng(extent.ymax, extent.xmax);\n  return L.latLngBounds(sw, ne);\n}\n\n// convert an LatLngBounds (Leaflet) to extent (ArcGIS)\nexport function boundsToExtent (bounds) {\n  bounds = L.latLngBounds(bounds);\n  return {\n    'xmin': bounds.getSouthWest().lng,\n    'ymin': bounds.getSouthWest().lat,\n    'xmax': bounds.getNorthEast().lng,\n    'ymax': bounds.getNorthEast().lat,\n    'spatialReference': {\n      'wkid': 4326\n    }\n  };\n}\n\nexport function responseToFeatureCollection (response, idAttribute) {\n  var objectIdField;\n\n  if (idAttribute) {\n    objectIdField = idAttribute;\n  } else if (response.objectIdFieldName) {\n    objectIdField = response.objectIdFieldName;\n  } else if (response.fields) {\n    for (var j = 0; j <= response.fields.length - 1; j++) {\n      if (response.fields[j].type === 'esriFieldTypeOID') {\n        objectIdField = response.fields[j].name;\n        break;\n      }\n    }\n  } else {\n    objectIdField = 'OBJECTID';\n  }\n\n  var featureCollection = {\n    type: 'FeatureCollection',\n    features: []\n  };\n  var features = response.features || response.results;\n  if (features.length) {\n    for (var i = features.length - 1; i >= 0; i--) {\n      var feature = arcgisToGeoJSON(features[i], objectIdField);\n      featureCollection.features.push(feature);\n    }\n  }\n\n  return featureCollection;\n}\n\n  // trim url whitespace and add a trailing slash if needed\nexport function cleanUrl (url) {\n  // trim leading and trailing spaces, but not spaces inside the url\n  url = L.Util.trim(url);\n\n  // add a trailing slash to the url if the user omitted it\n  if (url[url.length - 1] !== '/') {\n    url += '/';\n  }\n\n  return url;\n}\n\nexport function isArcgisOnline (url) {\n  /* hosted feature services can emit geojson natively.\n  our check for 'geojson' support will need to be revisted\n  once the functionality makes its way to ArcGIS Server*/\n  return (/\\.arcgis\\.com.*?FeatureServer/g).test(url);\n}\n\nexport function geojsonTypeToArcGIS (geoJsonType) {\n  var arcgisGeometryType;\n  switch (geoJsonType) {\n    case 'Point':\n      arcgisGeometryType = 'esriGeometryPoint';\n      break;\n    case 'MultiPoint':\n      arcgisGeometryType = 'esriGeometryMultipoint';\n      break;\n    case 'LineString':\n      arcgisGeometryType = 'esriGeometryPolyline';\n      break;\n    case 'MultiLineString':\n      arcgisGeometryType = 'esriGeometryPolyline';\n      break;\n    case 'Polygon':\n      arcgisGeometryType = 'esriGeometryPolygon';\n      break;\n    case 'MultiPolygon':\n      arcgisGeometryType = 'esriGeometryPolygon';\n      break;\n  }\n\n  return arcgisGeometryType;\n}\n\nexport function warn () {\n  if (console && console.warn) {\n    console.warn.apply(console, arguments);\n  }\n}\n\nexport var Util = {\n  shallowClone: shallowClone,\n  warn: warn,\n  cleanUrl: cleanUrl,\n  isArcgisOnline: isArcgisOnline,\n  geojsonTypeToArcGIS: geojsonTypeToArcGIS,\n  responseToFeatureCollection: responseToFeatureCollection,\n  geojsonToArcGIS: geojsonToArcGIS,\n  arcgisToGeoJSON: arcgisToGeoJSON,\n  boundsToExtent: boundsToExtent,\n  extentToBounds: extentToBounds\n};\n\nexport default Util;\n","import L from 'leaflet';\nimport Support from './Support';\nimport { warn } from './Util';\n\nvar callbacks = 0;\n\nfunction serialize (params) {\n  var data = '';\n\n  params.f = params.f || 'json';\n\n  for (var key in params) {\n    if (params.hasOwnProperty(key)) {\n      var param = params[key];\n      var type = Object.prototype.toString.call(param);\n      var value;\n\n      if (data.length) {\n        data += '&';\n      }\n\n      if (type === '[object Array]') {\n        value = (Object.prototype.toString.call(param[0]) === '[object Object]') ? JSON.stringify(param) : param.join(',');\n      } else if (type === '[object Object]') {\n        value = JSON.stringify(param);\n      } else if (type === '[object Date]') {\n        value = param.valueOf();\n      } else {\n        value = param;\n      }\n\n      data += encodeURIComponent(key) + '=' + encodeURIComponent(value);\n    }\n  }\n\n  return data;\n}\n\nfunction createRequest (callback, context) {\n  var httpRequest = new window.XMLHttpRequest();\n\n  httpRequest.onerror = function (e) {\n    httpRequest.onreadystatechange = L.Util.falseFn;\n\n    callback.call(context, {\n      error: {\n        code: 500,\n        message: 'XMLHttpRequest error'\n      }\n    }, null);\n  };\n\n  httpRequest.onreadystatechange = function () {\n    var response;\n    var error;\n\n    if (httpRequest.readyState === 4) {\n      try {\n        response = JSON.parse(httpRequest.responseText);\n      } catch (e) {\n        response = null;\n        error = {\n          code: 500,\n          message: 'Could not parse response as JSON. This could also be caused by a CORS or XMLHttpRequest error.'\n        };\n      }\n\n      if (!error && response.error) {\n        error = response.error;\n        response = null;\n      }\n\n      httpRequest.onerror = L.Util.falseFn;\n\n      callback.call(context, error, response);\n    }\n  };\n\n  httpRequest.ontimeout = function () {\n    this.onerror();\n  };\n\n  return httpRequest;\n}\n\nfunction xmlHttpPost (url, params, callback, context) {\n  var httpRequest = createRequest(callback, context);\n  httpRequest.open('POST', url);\n\n  if (typeof context !== 'undefined' && context !== null) {\n    if (typeof context.options !== 'undefined') {\n      httpRequest.timeout = context.options.timeout;\n    }\n  }\n  httpRequest.setRequestHeader('Content-Type', 'application/x-www-form-urlencoded');\n  httpRequest.send(serialize(params));\n\n  return httpRequest;\n}\n\nfunction xmlHttpGet (url, params, callback, context) {\n  var httpRequest = createRequest(callback, context);\n  httpRequest.open('GET', url + '?' + serialize(params), true);\n\n  if (typeof context !== 'undefined' && context !== null) {\n    if (typeof context.options !== 'undefined') {\n      httpRequest.timeout = context.options.timeout;\n    }\n  }\n  httpRequest.send(null);\n\n  return httpRequest;\n}\n\n// AJAX handlers for CORS (modern browsers) or JSONP (older browsers)\nexport function request (url, params, callback, context) {\n  var paramString = serialize(params);\n  var httpRequest = createRequest(callback, context);\n  var requestLength = (url + '?' + paramString).length;\n\n  // get around ie10/11 bug which requires that the request be opened before a timeout is applied\n  if (requestLength <= 2000 && Support.cors) {\n    httpRequest.open('GET', url + '?' + paramString);\n\n  } else if (requestLength > 2000 && Support.cors) {\n    httpRequest.open('POST', url);\n    httpRequest.setRequestHeader('Content-Type', 'application/x-www-form-urlencoded');\n  }\n\n  if (typeof context !== 'undefined' && context !== null) {\n    if (typeof context.options !== 'undefined') {\n      httpRequest.timeout = context.options.timeout;\n    }\n  }\n\n  // request is less then 2000 characters and the browser supports CORS, make GET request with XMLHttpRequest\n  if (requestLength <= 2000 && Support.cors) {\n    httpRequest.send(null);\n\n  // request is less more then 2000 characters and the browser supports CORS, make POST request with XMLHttpRequest\n  } else if (requestLength > 2000 && Support.cors) {\n    httpRequest.send(paramString);\n\n  // request is less more then 2000 characters and the browser does not support CORS, make a JSONP request\n  } else if (requestLength <= 2000 && !Support.cors) {\n    return jsonp(url, params, callback, context);\n\n  // request is longer then 2000 characters and the browser does not support CORS, log a warning\n  } else {\n    warn('a request to ' + url + ' was longer then 2000 characters and this browser cannot make a cross-domain post request. Please use a proxy http://esri.github.io/esri-leaflet/api-reference/request.html');\n    return;\n  }\n\n  return httpRequest;\n}\n\nexport function jsonp (url, params, callback, context) {\n  window._EsriLeafletCallbacks = window._EsriLeafletCallbacks || {};\n  var callbackId = 'c' + callbacks;\n  params.callback = 'window._EsriLeafletCallbacks.' + callbackId;\n\n  window._EsriLeafletCallbacks[callbackId] = function (response) {\n    if (window._EsriLeafletCallbacks[callbackId] !== true) {\n      var error;\n      var responseType = Object.prototype.toString.call(response);\n\n      if (!(responseType === '[object Object]' || responseType === '[object Array]')) {\n        error = {\n          error: {\n            code: 500,\n            message: 'Expected array or object as JSONP response'\n          }\n        };\n        response = null;\n      }\n\n      if (!error && response.error) {\n        error = response;\n        response = null;\n      }\n\n      callback.call(context, error, response);\n      window._EsriLeafletCallbacks[callbackId] = true;\n    }\n  };\n\n  var script = L.DomUtil.create('script', null, document.body);\n  script.type = 'text/javascript';\n  script.src = url + '?' + serialize(params);\n  script.id = callbackId;\n\n  callbacks++;\n\n  return {\n    id: callbackId,\n    url: script.src,\n    abort: function () {\n      window._EsriLeafletCallbacks._callback[callbackId]({\n        code: 0,\n        message: 'Request aborted.'\n      });\n    }\n  };\n}\n\nvar get = ((Support.cors) ? xmlHttpGet : jsonp);\nget.CORS = xmlHttpGet;\nget.JSONP = jsonp;\n\n// choose the correct AJAX handler depending on CORS support\nexport { get };\n\n// always use XMLHttpRequest for posts\nexport { xmlHttpPost as post };\n\n// export the Request object to call the different handlers for debugging\nexport var Request = {\n  request: request,\n  get: get,\n  post: xmlHttpPost\n};\n\nexport default Request;\n","import L from 'leaflet';\nimport {cors} from '../Support';\nimport {cleanUrl} from '../Util';\nimport Request from '../Request';\n\nexport var Task = L.Class.extend({\n\n  options: {\n    proxy: false,\n    useCors: cors\n  },\n\n  // Generate a method for each methodName:paramName in the setters for this task.\n  generateSetter: function (param, context) {\n    return L.Util.bind(function (value) {\n      this.params[param] = value;\n      return this;\n    }, context);\n  },\n\n  initialize: function (endpoint) {\n    // endpoint can be either a url (and options) for an ArcGIS Rest Service or an instance of EsriLeaflet.Service\n    if (endpoint.request && endpoint.options) {\n      this._service = endpoint;\n      L.Util.setOptions(this, endpoint.options);\n    } else {\n      L.Util.setOptions(this, endpoint);\n      this.options.url = cleanUrl(endpoint.url);\n    }\n\n    // clone default params into this object\n    this.params = L.Util.extend({}, this.params || {});\n\n    // generate setter methods based on the setters object implimented a child class\n    if (this.setters) {\n      for (var setter in this.setters) {\n        var param = this.setters[setter];\n        this[setter] = this.generateSetter(param, this);\n      }\n    }\n  },\n\n  token: function (token) {\n    if (this._service) {\n      this._service.authenticate(token);\n    } else {\n      this.params.token = token;\n    }\n    return this;\n  },\n\n  request: function (callback, context) {\n    if (this._service) {\n      return this._service.request(this.path, this.params, callback, context);\n    }\n\n    return this._request('request', this.path, this.params, callback, context);\n  },\n\n  _request: function (method, path, params, callback, context) {\n    var url = (this.options.proxy) ? this.options.proxy + '?' + this.options.url + path : this.options.url + path;\n\n    if ((method === 'get' || method === 'request') && !this.options.useCors) {\n      return Request.get.JSONP(url, params, callback, context);\n    }\n\n    return Request[method](url, params, callback, context);\n  }\n});\n\nexport function task (options) {\n  return new Task(options);\n}\n\nexport default task;\n","import L from 'leaflet';\nimport { Task } from './Task';\nimport Util from '../Util';\n\nexport var Query = Task.extend({\n  setters: {\n    'offset': 'offset',\n    'limit': 'limit',\n    'fields': 'outFields',\n    'precision': 'geometryPrecision',\n    'featureIds': 'objectIds',\n    'returnGeometry': 'returnGeometry',\n    'token': 'token'\n  },\n\n  path: 'query',\n\n  params: {\n    returnGeometry: true,\n    where: '1=1',\n    outSr: 4326,\n    outFields: '*'\n  },\n\n  within: function (geometry) {\n    this._setGeometry(geometry);\n    this.params.spatialRel = 'esriSpatialRelContains'; // will make code read layer within geometry, to the api this will reads geometry contains layer\n    return this;\n  },\n\n  intersects: function (geometry) {\n    this._setGeometry(geometry);\n    this.params.spatialRel = 'esriSpatialRelIntersects';\n    return this;\n  },\n\n  contains: function (geometry) {\n    this._setGeometry(geometry);\n    this.params.spatialRel = 'esriSpatialRelWithin'; // will make code read layer contains geometry, to the api this will reads geometry within layer\n    return this;\n  },\n\n  crosses: function (geometry) {\n    this._setGeometry(geometry);\n    this.params.spatialRel = 'esriSpatialRelCrosses';\n    return this;\n  },\n\n  touches: function (geometry) {\n    this._setGeometry(geometry);\n    this.params.spatialRel = 'esriSpatialRelTouches';\n    return this;\n  },\n\n  overlaps: function (geometry) {\n    this._setGeometry(geometry);\n    this.params.spatialRel = 'esriSpatialRelOverlaps';\n    return this;\n  },\n\n  // only valid for Feature Services running on ArcGIS Server 10.3 or ArcGIS Online\n  nearby: function (latlng, radius) {\n    latlng = L.latLng(latlng);\n    this.params.geometry = [latlng.lng, latlng.lat];\n    this.params.geometryType = 'esriGeometryPoint';\n    this.params.spatialRel = 'esriSpatialRelIntersects';\n    this.params.units = 'esriSRUnit_Meter';\n    this.params.distance = radius;\n    this.params.inSr = 4326;\n    return this;\n  },\n\n  where: function (string) {\n    // instead of converting double-quotes to single quotes, pass as is, and provide a more informative message if a 400 is encountered\n    this.params.where = string;\n    return this;\n  },\n\n  between: function (start, end) {\n    this.params.time = [start.valueOf(), end.valueOf()];\n    return this;\n  },\n\n  simplify: function (map, factor) {\n    var mapWidth = Math.abs(map.getBounds().getWest() - map.getBounds().getEast());\n    this.params.maxAllowableOffset = (mapWidth / map.getSize().y) * factor;\n    return this;\n  },\n\n  orderBy: function (fieldName, order) {\n    order = order || 'ASC';\n    this.params.orderByFields = (this.params.orderByFields) ? this.params.orderByFields + ',' : '';\n    this.params.orderByFields += ([fieldName, order]).join(' ');\n    return this;\n  },\n\n  run: function (callback, context) {\n    this._cleanParams();\n\n    // if the service is hosted on arcgis online request geojson directly\n    if (Util.isArcgisOnline(this.options.url)) {\n      this.params.f = 'geojson';\n\n      return this.request(function (error, response) {\n        this._trapSQLerrors(error);\n        callback.call(context, error, response, response);\n      }, this);\n\n    // otherwise convert it in the callback then pass it on\n    } else {\n      return this.request(function (error, response) {\n        this._trapSQLerrors(error);\n        callback.call(context, error, (response && Util.responseToFeatureCollection(response)), response);\n      }, this);\n    }\n  },\n\n  count: function (callback, context) {\n    this._cleanParams();\n    this.params.returnCountOnly = true;\n    return this.request(function (error, response) {\n      callback.call(this, error, (response && response.count), response);\n    }, context);\n  },\n\n  ids: function (callback, context) {\n    this._cleanParams();\n    this.params.returnIdsOnly = true;\n    return this.request(function (error, response) {\n      callback.call(this, error, (response && response.objectIds), response);\n    }, context);\n  },\n\n  // only valid for Feature Services running on ArcGIS Server 10.3 or ArcGIS Online\n  bounds: function (callback, context) {\n    this._cleanParams();\n    this.params.returnExtentOnly = true;\n    return this.request(function (error, response) {\n      callback.call(context, error, (response && response.extent && Util.extentToBounds(response.extent)), response);\n    }, context);\n  },\n\n  // only valid for image services\n  pixelSize: function (point) {\n    point = L.point(point);\n    this.params.pixelSize = [point.x, point.y];\n    return this;\n  },\n\n  // only valid for map services\n  layer: function (layer) {\n    this.path = layer + '/query';\n    return this;\n  },\n\n  _trapSQLerrors: function (error) {\n    if (error) {\n      if (error.code === '400') {\n        Util.warn('one common syntax error in query requests is encasing string values in double quotes instead of single quotes');\n      }\n    }\n  },\n\n  _cleanParams: function () {\n    delete this.params.returnIdsOnly;\n    delete this.params.returnExtentOnly;\n    delete this.params.returnCountOnly;\n  },\n\n  _setGeometry: function (geometry) {\n    this.params.inSr = 4326;\n\n    // convert bounds to extent and finish\n    if (geometry instanceof L.LatLngBounds) {\n      // set geometry + geometryType\n      this.params.geometry = Util.boundsToExtent(geometry);\n      this.params.geometryType = 'esriGeometryEnvelope';\n      return;\n    }\n\n    // convert L.Marker > L.LatLng\n    if (geometry.getLatLng) {\n      geometry = geometry.getLatLng();\n    }\n\n    // convert L.LatLng to a geojson point and continue;\n    if (geometry instanceof L.LatLng) {\n      geometry = {\n        type: 'Point',\n        coordinates: [geometry.lng, geometry.lat]\n      };\n    }\n\n    // handle L.GeoJSON, pull out the first geometry\n    if (geometry instanceof L.GeoJSON) {\n      // reassign geometry to the GeoJSON value  (we are assuming that only one feature is present)\n      geometry = geometry.getLayers()[0].feature.geometry;\n      this.params.geometry = Util.geojsonToArcGIS(geometry);\n      this.params.geometryType = Util.geojsonTypeToArcGIS(geometry.type);\n    }\n\n    // Handle L.Polyline and L.Polygon\n    if (geometry.toGeoJSON) {\n      geometry = geometry.toGeoJSON();\n    }\n\n    // handle GeoJSON feature by pulling out the geometry\n    if (geometry.type === 'Feature') {\n      // get the geometry of the geojson feature\n      geometry = geometry.geometry;\n    }\n\n    // confirm that our GeoJSON is a point, line or polygon\n    if (geometry.type === 'Point' || geometry.type === 'LineString' || geometry.type === 'Polygon') {\n      this.params.geometry = Util.geojsonToArcGIS(geometry);\n      this.params.geometryType = Util.geojsonTypeToArcGIS(geometry.type);\n      return;\n    }\n\n    // warn the user if we havn't found a\n    /* global console */\n    Util.warn('invalid geometry passed to spatial query. Should be an L.LatLng, L.LatLngBounds or L.Marker or a GeoJSON Point Line or Polygon object');\n\n    return;\n  }\n});\n\nexport function query (options) {\n  return new Query(options);\n}\n\nexport default query;\n","import { Task } from './Task';\nimport Util from '../Util';\n\nexport var Find = Task.extend({\n  setters: {\n    // method name > param name\n    'contains': 'contains',\n    'text': 'searchText',\n    'fields': 'searchFields', // denote an array or single string\n    'spatialReference': 'sr',\n    'sr': 'sr',\n    'layers': 'layers',\n    'returnGeometry': 'returnGeometry',\n    'maxAllowableOffset': 'maxAllowableOffset',\n    'precision': 'geometryPrecision',\n    'dynamicLayers': 'dynamicLayers',\n    'returnZ': 'returnZ',\n    'returnM': 'returnM',\n    'gdbVersion': 'gdbVersion',\n    'token': 'token'\n  },\n\n  path: 'find',\n\n  params: {\n    sr: 4326,\n    contains: true,\n    returnGeometry: true,\n    returnZ: true,\n    returnM: false\n  },\n\n  layerDefs: function (id, where) {\n    this.params.layerDefs = (this.params.layerDefs) ? this.params.layerDefs + ';' : '';\n    this.params.layerDefs += ([id, where]).join(':');\n    return this;\n  },\n\n  simplify: function (map, factor) {\n    var mapWidth = Math.abs(map.getBounds().getWest() - map.getBounds().getEast());\n    this.params.maxAllowableOffset = (mapWidth / map.getSize().y) * factor;\n    return this;\n  },\n\n  run: function (callback, context) {\n    return this.request(function (error, response) {\n      callback.call(context, error, (response && Util.responseToFeatureCollection(response)), response);\n    }, context);\n  }\n});\n\nexport function find (options) {\n  return new Find(options);\n}\n\nexport default find;\n","import { Task } from './Task';\n\nexport var Identify = Task.extend({\n  path: 'identify',\n\n  between: function (start, end) {\n    this.params.time = [start.valueOf(), end.valueOf()];\n    return this;\n  }\n});\n\nexport function identify (options) {\n  return new Identify(options);\n}\n\nexport default identify;\n","import L from 'leaflet';\nimport { Identify } from './Identify';\nimport Util from '../Util';\n\nexport var IdentifyFeatures = Identify.extend({\n  setters: {\n    'layers': 'layers',\n    'precision': 'geometryPrecision',\n    'tolerance': 'tolerance',\n    'returnGeometry': 'returnGeometry'\n  },\n\n  params: {\n    sr: 4326,\n    layers: 'all',\n    tolerance: 3,\n    returnGeometry: true\n  },\n\n  on: function (map) {\n    var extent = Util.boundsToExtent(map.getBounds());\n    var size = map.getSize();\n    this.params.imageDisplay = [size.x, size.y, 96];\n    this.params.mapExtent = [extent.xmin, extent.ymin, extent.xmax, extent.ymax];\n    return this;\n  },\n\n  at: function (latlng) {\n    latlng = L.latLng(latlng);\n    this.params.geometry = [latlng.lng, latlng.lat];\n    this.params.geometryType = 'esriGeometryPoint';\n    return this;\n  },\n\n  layerDef: function (id, where) {\n    this.params.layerDefs = (this.params.layerDefs) ? this.params.layerDefs + ';' : '';\n    this.params.layerDefs += ([id, where]).join(':');\n    return this;\n  },\n\n  simplify: function (map, factor) {\n    var mapWidth = Math.abs(map.getBounds().getWest() - map.getBounds().getEast());\n    this.params.maxAllowableOffset = (mapWidth / map.getSize().y) * (1 - factor);\n    return this;\n  },\n\n  run: function (callback, context) {\n    return this.request(function (error, response) {\n      // immediately invoke with an error\n      if (error) {\n        callback.call(context, error, undefined, response);\n        return;\n\n      // ok no error lets just assume we have features...\n      } else {\n        var featureCollection = Util.responseToFeatureCollection(response);\n        response.results = response.results.reverse();\n        for (var i = 0; i < featureCollection.features.length; i++) {\n          var feature = featureCollection.features[i];\n          feature.layerId = response.results[i].layerId;\n        }\n        callback.call(context, undefined, featureCollection, response);\n      }\n    });\n  }\n});\n\nexport function identifyFeatures (options) {\n  return new IdentifyFeatures(options);\n}\n\nexport default identifyFeatures;\n","import L from 'leaflet';\nimport { Identify } from './Identify';\nimport Util from '../Util';\n\nexport var IdentifyImage = Identify.extend({\n  setters: {\n    'setMosaicRule': 'mosaicRule',\n    'setRenderingRule': 'renderingRule',\n    'setPixelSize': 'pixelSize',\n    'returnCatalogItems': 'returnCatalogItems',\n    'returnGeometry': 'returnGeometry'\n  },\n\n  params: {\n    returnGeometry: false\n  },\n\n  at: function (latlng) {\n    latlng = L.latLng(latlng);\n    this.params.geometry = JSON.stringify({\n      x: latlng.lng,\n      y: latlng.lat,\n      spatialReference: {\n        wkid: 4326\n      }\n    });\n    this.params.geometryType = 'esriGeometryPoint';\n    return this;\n  },\n\n  getMosaicRule: function () {\n    return this.params.mosaicRule;\n  },\n\n  getRenderingRule: function () {\n    return this.params.renderingRule;\n  },\n\n  getPixelSize: function () {\n    return this.params.pixelSize;\n  },\n\n  run: function (callback, context) {\n    return this.request(function (error, response) {\n      callback.call(context, error, (response && this._responseToGeoJSON(response)), response);\n    }, this);\n  },\n\n  // get pixel data and return as geoJSON point\n  // populate catalog items (if any)\n  // merging in any catalogItemVisibilities as a propery of each feature\n  _responseToGeoJSON: function (response) {\n    var location = response.location;\n    var catalogItems = response.catalogItems;\n    var catalogItemVisibilities = response.catalogItemVisibilities;\n    var geoJSON = {\n      'pixel': {\n        'type': 'Feature',\n        'geometry': {\n          'type': 'Point',\n          'coordinates': [location.x, location.y]\n        },\n        'crs': {\n          'type': 'EPSG',\n          'properties': {\n            'code': location.spatialReference.wkid\n          }\n        },\n        'properties': {\n          'OBJECTID': response.objectId,\n          'name': response.name,\n          'value': response.value\n        },\n        'id': response.objectId\n      }\n    };\n\n    if (response.properties && response.properties.Values) {\n      geoJSON.pixel.properties.values = response.properties.Values;\n    }\n\n    if (catalogItems && catalogItems.features) {\n      geoJSON.catalogItems = Util.responseToFeatureCollection(catalogItems);\n      if (catalogItemVisibilities && catalogItemVisibilities.length === geoJSON.catalogItems.features.length) {\n        for (var i = catalogItemVisibilities.length - 1; i >= 0; i--) {\n          geoJSON.catalogItems.features[i].properties.catalogItemVisibility = catalogItemVisibilities[i];\n        }\n      }\n    }\n    return geoJSON;\n  }\n\n});\n\nexport function identifyImage (params) {\n  return new IdentifyImage(params);\n}\n\nexport default identifyImage;\n","import L from 'leaflet';\nimport {cors} from '../Support';\nimport {cleanUrl} from '../Util';\nimport Request from '../Request';\n\nexport var Service = L.Evented.extend({\n\n  options: {\n    proxy: false,\n    useCors: cors,\n    timeout: 0\n  },\n\n  initialize: function (options) {\n    options = options || {};\n    this._requestQueue = [];\n    this._authenticating = false;\n    L.Util.setOptions(this, options);\n    this.options.url = cleanUrl(this.options.url);\n  },\n\n  get: function (path, params, callback, context) {\n    return this._request('get', path, params, callback, context);\n  },\n\n  post: function (path, params, callback, context) {\n    return this._request('post', path, params, callback, context);\n  },\n\n  request: function (path, params, callback, context) {\n    return this._request('request', path, params, callback, context);\n  },\n\n  metadata: function (callback, context) {\n    return this._request('get', '', {}, callback, context);\n  },\n\n  authenticate: function (token) {\n    this._authenticating = false;\n    this.options.token = token;\n    this._runQueue();\n    return this;\n  },\n\n  getTimeout: function () {\n    return this.options.timeout;\n  },\n\n  setTimeout: function (timeout) {\n    this.options.timeout = timeout;\n  },\n\n  _request: function (method, path, params, callback, context) {\n    this.fire('requeststart', {\n      url: this.options.url + path,\n      params: params,\n      method: method\n    }, true);\n\n    var wrappedCallback = this._createServiceCallback(method, path, params, callback, context);\n\n    if (this.options.token) {\n      params.token = this.options.token;\n    }\n\n    if (this._authenticating) {\n      this._requestQueue.push([method, path, params, callback, context]);\n      return;\n    } else {\n      var url = (this.options.proxy) ? this.options.proxy + '?' + this.options.url + path : this.options.url + path;\n\n      if ((method === 'get' || method === 'request') && !this.options.useCors) {\n        return Request.get.JSONP(url, params, wrappedCallback, context);\n      } else {\n        return Request[method](url, params, wrappedCallback, context);\n      }\n    }\n  },\n\n  _createServiceCallback: function (method, path, params, callback, context) {\n    return L.Util.bind(function (error, response) {\n      if (error && (error.code === 499 || error.code === 498)) {\n        this._authenticating = true;\n\n        this._requestQueue.push([method, path, params, callback, context]);\n\n        // fire an event for users to handle and re-authenticate\n        this.fire('authenticationrequired', {\n          authenticate: L.Util.bind(this.authenticate, this)\n        }, true);\n\n        // if the user has access to a callback they can handle the auth error\n        error.authenticate = L.Util.bind(this.authenticate, this);\n      }\n\n      callback.call(context, error, response);\n\n      if (error) {\n        this.fire('requesterror', {\n          url: this.options.url + path,\n          params: params,\n          message: error.message,\n          code: error.code,\n          method: method\n        }, true);\n      } else {\n        this.fire('requestsuccess', {\n          url: this.options.url + path,\n          params: params,\n          response: response,\n          method: method\n        }, true);\n      }\n\n      this.fire('requestend', {\n        url: this.options.url + path,\n        params: params,\n        method: method\n      }, true);\n    }, this);\n  },\n\n  _runQueue: function () {\n    for (var i = this._requestQueue.length - 1; i >= 0; i--) {\n      var request = this._requestQueue[i];\n      var method = request.shift();\n      this[method].apply(this, request);\n    }\n    this._requestQueue = [];\n  }\n});\n\nexport function service (options) {\n  return new Service(options);\n}\n\nexport default service;\n","import { Service } from './Service';\nimport identifyFeatures from '../Tasks/IdentifyFeatures';\nimport query from '../Tasks/Query';\nimport find from '../Tasks/Find';\n\nexport var MapService = Service.extend({\n\n  identify: function () {\n    return identifyFeatures(this);\n  },\n\n  find: function () {\n    return find(this);\n  },\n\n  query: function () {\n    return query(this);\n  }\n\n});\n\nexport function mapService (options) {\n  return new MapService(options);\n}\n\nexport default mapService;\n","import { Service } from './Service';\nimport identifyImage from '../Tasks/IdentifyImage';\nimport query from '../Tasks/Query';\n\nexport var ImageService = Service.extend({\n\n  query: function () {\n    return query(this);\n  },\n\n  identify: function () {\n    return identifyImage(this);\n  }\n});\n\nexport function imageService (options) {\n  return new ImageService(options);\n}\n\nexport default imageService;\n","import { Service } from './Service';\nimport query from '../Tasks/Query';\nimport { geojsonToArcGIS } from '../Util';\n\nexport var FeatureLayerService = Service.extend({\n\n  options: {\n    idAttribute: 'OBJECTID'\n  },\n\n  query: function () {\n    return query(this);\n  },\n\n  addFeature: function (feature, callback, context) {\n    delete feature.id;\n\n    feature = geojsonToArcGIS(feature);\n\n    return this.post('addFeatures', {\n      features: [feature]\n    }, function (error, response) {\n      var result = (response && response.addResults) ? response.addResults[0] : undefined;\n      if (callback) {\n        callback.call(context, error || response.addResults[0].error, result);\n      }\n    }, context);\n  },\n\n  updateFeature: function (feature, callback, context) {\n    feature = geojsonToArcGIS(feature, this.options.idAttribute);\n\n    return this.post('updateFeatures', {\n      features: [feature]\n    }, function (error, response) {\n      var result = (response && response.updateResults) ? response.updateResults[0] : undefined;\n      if (callback) {\n        callback.call(context, error || response.updateResults[0].error, result);\n      }\n    }, context);\n  },\n\n  deleteFeature: function (id, callback, context) {\n    return this.post('deleteFeatures', {\n      objectIds: id\n    }, function (error, response) {\n      var result = (response && response.deleteResults) ? response.deleteResults[0] : undefined;\n      if (callback) {\n        callback.call(context, error || response.deleteResults[0].error, result);\n      }\n    }, context);\n  },\n\n  deleteFeatures: function (ids, callback, context) {\n    return this.post('deleteFeatures', {\n      objectIds: ids\n    }, function (error, response) {\n      // pass back the entire array\n      var result = (response && response.deleteResults) ? response.deleteResults : undefined;\n      if (callback) {\n        callback.call(context, error || response.deleteResults[0].error, result);\n      }\n    }, context);\n  }\n});\n\nexport function featureLayerService (options) {\n  return new FeatureLayerService(options);\n}\n\nexport default featureLayerService;\n","import L from 'leaflet';\n\nexport var Logo = L.Control.extend({\n  options: {\n    position: 'bottomright',\n    marginTop: 0,\n    marginLeft: 0,\n    marginBottom: 0,\n    marginRight: 0\n  },\n\n  onAdd: function () {\n    var div = L.DomUtil.create('div', 'esri-leaflet-logo');\n    div.style.marginTop = this.options.marginTop;\n    div.style.marginLeft = this.options.marginLeft;\n    div.style.marginBottom = this.options.marginBottom;\n    div.style.marginRight = this.options.marginRight;\n    div.innerHTML = '<a href=\"http://www.esri.com\" target=\"_blank\" style=\"border: none;\"><img src=\"https://js.arcgis.com/3.13/esri/images/map/logo-sm.png\" alt=\"Powered by Esri\" style=\"border: none;\"></a>';\n\n    return div;\n  }\n});\n\nexport default function logo (options) {\n  return new Logo(options);\n}\n","import L from 'leaflet';\nimport logo from '../Controls/Logo';\nimport { jsonp } from '../Request';\nimport { pointerEvents } from '../Support';\n\nvar tileProtocol = (window.location.protocol !== 'https:') ? 'http:' : 'https:';\n\nexport var BasemapLayer = L.TileLayer.extend({\n  statics: {\n    TILES: {\n      Streets: {\n        urlTemplate: tileProtocol + '//{s}.arcgisonline.com/ArcGIS/rest/services/World_Street_Map/MapServer/tile/{z}/{y}/{x}',\n        attributionUrl: 'https://static.arcgis.com/attribution/World_Street_Map',\n        options: {\n          hideLogo: false,\n          logoPosition: 'bottomright',\n          minZoom: 1,\n          maxZoom: 19,\n          subdomains: ['server', 'services'],\n          attribution: 'Esri'\n        }\n      },\n      Topographic: {\n        urlTemplate: tileProtocol + '//{s}.arcgisonline.com/ArcGIS/rest/services/World_Topo_Map/MapServer/tile/{z}/{y}/{x}',\n        attributionUrl: 'https://static.arcgis.com/attribution/World_Topo_Map',\n        options: {\n          hideLogo: false,\n          logoPosition: 'bottomright',\n          minZoom: 1,\n          maxZoom: 19,\n          subdomains: ['server', 'services'],\n          attribution: 'Esri'\n        }\n      },\n      Oceans: {\n        urlTemplate: tileProtocol + '//{s}.arcgisonline.com/arcgis/rest/services/Ocean/World_Ocean_Base/MapServer/tile/{z}/{y}/{x}',\n        attributionUrl: 'https://static.arcgis.com/attribution/Ocean_Basemap',\n        options: {\n          hideLogo: false,\n          logoPosition: 'bottomright',\n          minZoom: 1,\n          maxZoom: 16,\n          subdomains: ['server', 'services'],\n          attribution: 'Esri'\n        }\n      },\n      OceansLabels: {\n        urlTemplate: tileProtocol + '//{s}.arcgisonline.com/arcgis/rest/services/Ocean/World_Ocean_Reference/MapServer/tile/{z}/{y}/{x}',\n        options: {\n          hideLogo: true,\n          logoPosition: 'bottomright',\n          minZoom: 1,\n          maxZoom: 16,\n          subdomains: ['server', 'services'],\n          pane: (pointerEvents) ? 'esri-labels' : 'tilePane'\n        }\n      },\n      NationalGeographic: {\n        urlTemplate: tileProtocol + '//{s}.arcgisonline.com/ArcGIS/rest/services/NatGeo_World_Map/MapServer/tile/{z}/{y}/{x}',\n        options: {\n          hideLogo: false,\n          logoPosition: 'bottomright',\n          minZoom: 1,\n          maxZoom: 16,\n          subdomains: ['server', 'services'],\n          attribution: 'National Geographic, Esri, DeLorme, HERE, UNEP-WCMC, USGS, NASA, ESA, METI, NRCAN, GEBCO, NOAA, increment P Corp.'\n        }\n      },\n      DarkGray: {\n        urlTemplate: tileProtocol + '//{s}.arcgisonline.com/ArcGIS/rest/services/Canvas/World_Dark_Gray_Base/MapServer/tile/{z}/{y}/{x}',\n        options: {\n          hideLogo: false,\n          logoPosition: 'bottomright',\n          minZoom: 1,\n          maxZoom: 16,\n          subdomains: ['server', 'services'],\n          attribution: 'Esri, HERE, DeLorme, MapmyIndia, © OpenStreetMap contributors'\n        }\n      },\n      DarkGrayLabels: {\n        urlTemplate: tileProtocol + '//{s}.arcgisonline.com/ArcGIS/rest/services/Canvas/World_Dark_Gray_Reference/MapServer/tile/{z}/{y}/{x}',\n        options: {\n          hideLogo: true,\n          logoPosition: 'bottomright',\n          minZoom: 1,\n          maxZoom: 16,\n          subdomains: ['server', 'services'],\n          pane: (pointerEvents) ? 'esri-labels' : 'tilePane'\n\n        }\n      },\n      Gray: {\n        urlTemplate: tileProtocol + '//{s}.arcgisonline.com/ArcGIS/rest/services/Canvas/World_Light_Gray_Base/MapServer/tile/{z}/{y}/{x}',\n        options: {\n          hideLogo: false,\n          logoPosition: 'bottomright',\n          minZoom: 1,\n          maxZoom: 16,\n          subdomains: ['server', 'services'],\n          attribution: 'Esri, HERE, DeLorme, MapmyIndia, © OpenStreetMap contributors'\n        }\n      },\n      GrayLabels: {\n        urlTemplate: tileProtocol + '//{s}.arcgisonline.com/ArcGIS/rest/services/Canvas/World_Light_Gray_Reference/MapServer/tile/{z}/{y}/{x}',\n        options: {\n          hideLogo: true,\n          logoPosition: 'bottomright',\n          minZoom: 1,\n          maxZoom: 16,\n          subdomains: ['server', 'services'],\n          pane: (pointerEvents) ? 'esri-labels' : 'tilePane'\n        }\n      },\n      Imagery: {\n        urlTemplate: tileProtocol + '//{s}.arcgisonline.com/ArcGIS/rest/services/World_Imagery/MapServer/tile/{z}/{y}/{x}',\n        options: {\n          hideLogo: false,\n          logoPosition: 'bottomright',\n          minZoom: 1,\n          maxZoom: 19,\n          subdomains: ['server', 'services'],\n          attribution: 'Esri, DigitalGlobe, GeoEye, i-cubed, USDA, USGS, AEX, Getmapping, Aerogrid, IGN, IGP, swisstopo, and the GIS User Community'\n        }\n      },\n      ImageryLabels: {\n        urlTemplate: tileProtocol + '//{s}.arcgisonline.com/ArcGIS/rest/services/Reference/World_Boundaries_and_Places/MapServer/tile/{z}/{y}/{x}',\n        options: {\n          hideLogo: true,\n          logoPosition: 'bottomright',\n          minZoom: 1,\n          maxZoom: 19,\n          subdomains: ['server', 'services'],\n          pane: (pointerEvents) ? 'esri-labels' : 'tilePane'\n        }\n      },\n      ImageryTransportation: {\n        urlTemplate: tileProtocol + '//{s}.arcgisonline.com/ArcGIS/rest/services/Reference/World_Transportation/MapServer/tile/{z}/{y}/{x}',\n        options: {\n          hideLogo: true,\n          logoPosition: 'bottomright',\n          minZoom: 1,\n          maxZoom: 19,\n          subdomains: ['server', 'services'],\n          pane: (pointerEvents) ? 'esri-labels' : 'tilePane'\n        }\n      },\n      ShadedRelief: {\n        urlTemplate: tileProtocol + '//{s}.arcgisonline.com/ArcGIS/rest/services/World_Shaded_Relief/MapServer/tile/{z}/{y}/{x}',\n        options: {\n          hideLogo: false,\n          logoPosition: 'bottomright',\n          minZoom: 1,\n          maxZoom: 13,\n          subdomains: ['server', 'services'],\n          attribution: 'Esri, USGS'\n        }\n      },\n      ShadedReliefLabels: {\n        urlTemplate: tileProtocol + '//{s}.arcgisonline.com/ArcGIS/rest/services/Reference/World_Boundaries_and_Places_Alternate/MapServer/tile/{z}/{y}/{x}',\n        options: {\n          hideLogo: true,\n          logoPosition: 'bottomright',\n          minZoom: 1,\n          maxZoom: 12,\n          subdomains: ['server', 'services'],\n          pane: (pointerEvents) ? 'esri-labels' : 'tilePane'\n        }\n      },\n      Terrain: {\n        urlTemplate: tileProtocol + '//{s}.arcgisonline.com/ArcGIS/rest/services/World_Terrain_Base/MapServer/tile/{z}/{y}/{x}',\n        options: {\n          hideLogo: false,\n          logoPosition: 'bottomright',\n          minZoom: 1,\n          maxZoom: 13,\n          subdomains: ['server', 'services'],\n          attribution: 'Esri, USGS, NOAA'\n        }\n      },\n      TerrainLabels: {\n        urlTemplate: tileProtocol + '//{s}.arcgisonline.com/ArcGIS/rest/services/Reference/World_Reference_Overlay/MapServer/tile/{z}/{y}/{x}',\n        options: {\n          hideLogo: true,\n          logoPosition: 'bottomright',\n          minZoom: 1,\n          maxZoom: 13,\n          subdomains: ['server', 'services'],\n          pane: (pointerEvents) ? 'esri-labels' : 'tilePane'\n        }\n      },\n      USATopo: {\n        urlTemplate: tileProtocol + '//{s}.arcgisonline.com/ArcGIS/rest/services/USA_Topo_Maps/MapServer/tile/{z}/{y}/{x}',\n        options: {\n          hideLogo: false,\n          logoPosition: 'bottomright',\n          minZoom: 1,\n          maxZoom: 15,\n          subdomains: ['server', 'services'],\n          attribution: 'National Geographic Society, i-cubed'\n        }\n      }\n    }\n  },\n  initialize: function (key, options) {\n    var config;\n\n    // set the config variable with the appropriate config object\n    if (typeof key === 'object' && key.urlTemplate && key.options) {\n      config = key;\n    } else if (typeof key === 'string' && BasemapLayer.TILES[key]) {\n      config = BasemapLayer.TILES[key];\n    } else {\n      throw new Error('L.esri.BasemapLayer: Invalid parameter. Use one of \"Streets\", \"Topographic\", \"Oceans\", \"OceansLabels\", \"NationalGeographic\", \"Gray\", \"GrayLabels\", \"DarkGray\", \"DarkGrayLabels\", \"Imagery\", \"ImageryLabels\", \"ImageryTransportation\", \"ShadedRelief\", \"ShadedReliefLabels\", \"Terrain\" or \"TerrainLabels\"');\n    }\n\n    // merge passed options into the config options\n    var tileOptions = L.Util.extend(config.options, options);\n\n    L.Util.setOptions(this, tileOptions);\n\n    // call the initialize method on L.TileLayer to set everything up\n    L.TileLayer.prototype.initialize.call(this, config.urlTemplate, tileOptions);\n\n    // if this basemap requires dynamic attribution set it up\n    if (config.attributionUrl) {\n      this._getAttributionData(config.attributionUrl);\n    }\n\n    this._logo = logo({\n      position: this.options.logoPosition\n    });\n  },\n\n  onAdd: function (map) {\n    if (!this.options.hideLogo && !map._hasEsriLogo) {\n      this._logo.addTo(map);\n      map._hasEsriLogo = true;\n    }\n\n    if (this.options.pane === 'esri-labels') {\n      this._initPane();\n    }\n\n    map.on('moveend', this._updateMapAttribution, this);\n\n    L.TileLayer.prototype.onAdd.call(this, map);\n  },\n\n  onRemove: function (map) {\n    // check to make sure the logo hasn't already been removed\n    if (this._logo && this._logo._container) {\n      map.removeControl(this._logo);\n      map._hasEsriLogo = false;\n    }\n\n    map.off('moveend', this._updateMapAttribution, this);\n\n    L.TileLayer.prototype.onRemove.call(this, map);\n  },\n\n  getAttribution: function () {\n    if (this.options.attribution) {\n      var attribution = '<span class=\"esri-attributions\" style=\"line-height:14px; vertical-align: -3px; text-overflow:ellipsis; white-space:nowrap; overflow:hidden; display:inline-block;\">' + this.options.attribution + '</span>';\n    }\n    return attribution;\n  },\n\n  _initPane: function () {\n    if (!this._map.getPane(this.options.pane)) {\n      var pane = this._map.createPane(this.options.pane);\n      pane.style.pointerEvents = 'none';\n      pane.style.zIndex = 500;\n    }\n  },\n\n  _getAttributionData: function (url) {\n    jsonp(url, {}, L.Util.bind(function (error, attributions) {\n      if (error) { return; }\n      this._attributions = [];\n\n      for (var c = 0; c < attributions.contributors.length; c++) {\n        var contributor = attributions.contributors[c];\n        for (var i = 0; i < contributor.coverageAreas.length; i++) {\n          var coverageArea = contributor.coverageAreas[i];\n          var southWest = L.latLng(coverageArea.bbox[0], coverageArea.bbox[1]);\n          var northEast = L.latLng(coverageArea.bbox[2], coverageArea.bbox[3]);\n          this._attributions.push({\n            attribution: contributor.attribution,\n            score: coverageArea.score,\n            bounds: L.latLngBounds(southWest, northEast),\n            minZoom: coverageArea.zoomMin,\n            maxZoom: coverageArea.zoomMax\n          });\n        }\n      }\n\n      this._attributions.sort(function (a, b) {\n        return b.score - a.score;\n      });\n\n      this._updateMapAttribution();\n    }, this));\n  },\n\n  _updateMapAttribution: function () {\n    if (this._map && this._map.attributionControl && this._attributions) {\n      var newAttributions = '';\n      var bounds = this._map.getBounds();\n      var zoom = this._map.getZoom();\n\n      for (var i = 0; i < this._attributions.length; i++) {\n        var attribution = this._attributions[i];\n        var text = attribution.attribution;\n        if (!newAttributions.match(text) && bounds.intersects(attribution.bounds) && zoom >= attribution.minZoom && zoom <= attribution.maxZoom) {\n          newAttributions += (', ' + text);\n        }\n      }\n      newAttributions = newAttributions.substr(2);\n      var attributionElement = this._map.attributionControl._container.querySelector('.esri-attributions');\n\n      attributionElement.innerHTML = newAttributions;\n      attributionElement.style.maxWidth = (this._map.getSize().x * 0.65) + 'px';\n\n      this.fire('attributionupdated', {\n        attribution: newAttributions\n      });\n    }\n  }\n});\n\nexport function basemapLayer (key, options) {\n  return new BasemapLayer(key, options);\n}\n\nexport default basemapLayer;\n","import L from 'leaflet';\nimport {warn, cleanUrl} from '../Util';\nimport mapService from '../Services/MapService';\n\nexport var TiledMapLayer = L.TileLayer.extend({\n  options: {\n    zoomOffsetAllowance: 0.1\n  },\n\n  statics: {\n    MercatorZoomLevels: {\n      '0': 156543.03392799999,\n      '1': 78271.516963999893,\n      '2': 39135.758482000099,\n      '3': 19567.879240999901,\n      '4': 9783.9396204999593,\n      '5': 4891.9698102499797,\n      '6': 2445.9849051249898,\n      '7': 1222.9924525624899,\n      '8': 611.49622628138002,\n      '9': 305.74811314055802,\n      '10': 152.874056570411,\n      '11': 76.437028285073197,\n      '12': 38.218514142536598,\n      '13': 19.109257071268299,\n      '14': 9.5546285356341496,\n      '15': 4.7773142679493699,\n      '16': 2.38865713397468,\n      '17': 1.1943285668550501,\n      '18': 0.59716428355981699,\n      '19': 0.29858214164761698,\n      '20': 0.14929107082381,\n      '21': 0.07464553541191,\n      '22': 0.0373227677059525,\n      '23': 0.0186613838529763\n    }\n  },\n\n  initialize: function (options) {\n    options.url = cleanUrl(options.url);\n    options = L.Util.setOptions(this, options);\n\n    // set the urls\n    this.tileUrl = options.url + 'tile/{z}/{y}/{x}';\n    this.service = mapService(options);\n    this.service.addEventParent(this);\n\n    var arcgisonline = new RegExp(/tiles.arcgis(online)?\\.com/g);\n    if (arcgisonline.test(options.url)) {\n      this.tileUrl = this.tileUrl.replace('://tiles', '://tiles{s}');\n      options.subdomains = ['1', '2', '3', '4'];\n    }\n\n    if (this.options.token) {\n      this.tileUrl += ('?token=' + this.options.token);\n    }\n\n    // init layer by calling TileLayers initialize method\n    L.TileLayer.prototype.initialize.call(this, this.tileUrl, options);\n  },\n\n  getTileUrl: function (tilePoint) {\n    return L.Util.template(this.tileUrl, L.extend({\n      s: this._getSubdomain(tilePoint),\n      z: (this._lodMap && this._lodMap[tilePoint.z]) ? this._lodMap[tilePoint.z] : tilePoint.z, // try lod map first, then just defualt to zoom level\n      x: tilePoint.x,\n      y: tilePoint.y\n    }, this.options));\n  },\n\n  createTile: function (coords, done) {\n    var tile = document.createElement('img');\n\n    L.DomEvent.on(tile, 'load', L.bind(this._tileOnLoad, this, done, tile));\n    L.DomEvent.on(tile, 'error', L.bind(this._tileOnError, this, done, tile));\n\n    if (this.options.crossOrigin) {\n      tile.crossOrigin = '';\n    }\n\n    /*\n     Alt tag is set to empty string to keep screen readers from reading URL and for compliance reasons\n     http://www.w3.org/TR/WCAG20-TECHS/H67\n    */\n    tile.alt = '';\n\n    // if there is no lod map or an lod map with a proper zoom load the tile\n    // otherwise wait for the lod map to become available\n    if (!this._lodMap || (this._lodMap && this._lodMap[coords.z])) {\n      tile.src = this.getTileUrl(coords);\n    } else {\n      this.once('lodmap', function () {\n        tile.src = this.getTileUrl(coords);\n      }, this);\n    }\n\n    return tile;\n  },\n\n  onAdd: function (map) {\n    if (map.options.crs === L.CRS.EPSG3857 && !this._lodMap) {\n      this._lodMap = {};\n      this.metadata(function (error, metadata) {\n        if (!error) {\n          var sr = metadata.spatialReference.latestWkid || metadata.spatialReference.wkid;\n          if (sr === 102100 || sr === 3857) {\n            // create the zoom level data\n            var arcgisLODs = metadata.tileInfo.lods;\n            var correctResolutions = TiledMapLayer.MercatorZoomLevels;\n\n            for (var i = 0; i < arcgisLODs.length; i++) {\n              var arcgisLOD = arcgisLODs[i];\n              for (var ci in correctResolutions) {\n                var correctRes = correctResolutions[ci];\n\n                if (this._withinPercentage(arcgisLOD.resolution, correctRes, this.options.zoomOffsetAllowance)) {\n                  this._lodMap[ci] = arcgisLOD.level;\n                  break;\n                }\n              }\n            }\n\n            this.fire('lodmap');\n          } else {\n            warn('L.esri.TiledMapLayer is using a non-mercator spatial reference. Support may be available through Proj4Leaflet http://esri.github.io/esri-leaflet/examples/non-mercator-projection.html');\n          }\n        }\n      }, this);\n    }\n\n    L.TileLayer.prototype.onAdd.call(this, map);\n  },\n\n  metadata: function (callback, context) {\n    this.service.metadata(callback, context);\n    return this;\n  },\n\n  identify: function () {\n    return this.service.identify();\n  },\n\n  find: function () {\n    return this.service.find();\n  },\n\n  query: function () {\n    return this.service.query();\n  },\n\n  authenticate: function (token) {\n    var tokenQs = '?token=' + token;\n    this.tileUrl = (this.options.token) ? this.tileUrl.replace(/\\?token=(.+)/g, tokenQs) : this.tileUrl + tokenQs;\n    this.options.token = token;\n    this.service.authenticate(token);\n    return this;\n  },\n\n  _withinPercentage: function (a, b, percentage) {\n    var diff = Math.abs((a / b) - 1);\n    return diff < percentage;\n  }\n});\n\nexport function tiledMapLayer (url, options) {\n  return new TiledMapLayer(url, options);\n}\n\nexport default tiledMapLayer;\n","import L from 'leaflet';\nimport {cors} from '../Support';\n\nvar Overlay = L.ImageOverlay.extend({\n  onAdd: function (map) {\n    this._topLeft = map.getPixelBounds().min;\n    L.ImageOverlay.prototype.onAdd.call(this, map);\n  },\n  _reset: function () {\n    if (this._map.options.crs === L.CRS.EPSG3857) {\n      L.ImageOverlay.prototype._reset.call(this);\n    } else {\n      L.DomUtil.setPosition(this._image, this._topLeft.subtract(this._map.getPixelOrigin()));\n    }\n  }\n});\n\nexport var RasterLayer = L.Layer.extend({\n\n  options: {\n    opacity: 1,\n    position: 'front',\n    f: 'image',\n    useCors: cors,\n    attribution: null,\n    interactive: false,\n    alt: ''\n  },\n\n  onAdd: function (map) {\n    this._update = L.Util.throttle(this._update, this.options.updateInterval, this);\n\n    map.on('moveend', this._update, this);\n\n    // if we had an image loaded and it matches the\n    // current bounds show the image otherwise remove it\n    if (this._currentImage && this._currentImage._bounds.equals(this._map.getBounds())) {\n      map.addLayer(this._currentImage);\n    } else if (this._currentImage) {\n      this._map.removeLayer(this._currentImage);\n      this._currentImage = null;\n    }\n\n    this._update();\n\n    if (this._popup) {\n      this._map.on('click', this._getPopupData, this);\n      this._map.on('dblclick', this._resetPopupState, this);\n    }\n  },\n\n  onRemove: function (map) {\n    if (this._currentImage) {\n      this._map.removeLayer(this._currentImage);\n    }\n\n    if (this._popup) {\n      this._map.off('click', this._getPopupData, this);\n      this._map.off('dblclick', this._resetPopupState, this);\n    }\n\n    this._map.off('moveend', this._update, this);\n  },\n\n  bindPopup: function (fn, popupOptions) {\n    this._shouldRenderPopup = false;\n    this._lastClick = false;\n    this._popup = L.popup(popupOptions);\n    this._popupFunction = fn;\n    if (this._map) {\n      this._map.on('click', this._getPopupData, this);\n      this._map.on('dblclick', this._resetPopupState, this);\n    }\n    return this;\n  },\n\n  unbindPopup: function () {\n    if (this._map) {\n      this._map.closePopup(this._popup);\n      this._map.off('click', this._getPopupData, this);\n      this._map.off('dblclick', this._resetPopupState, this);\n    }\n    this._popup = false;\n    return this;\n  },\n\n  bringToFront: function () {\n    this.options.position = 'front';\n    if (this._currentImage) {\n      this._currentImage.bringToFront();\n    }\n    return this;\n  },\n\n  bringToBack: function () {\n    this.options.position = 'back';\n    if (this._currentImage) {\n      this._currentImage.bringToBack();\n    }\n    return this;\n  },\n\n  getAttribution: function () {\n    return this.options.attribution;\n  },\n\n  getOpacity: function () {\n    return this.options.opacity;\n  },\n\n  setOpacity: function (opacity) {\n    this.options.opacity = opacity;\n    this._currentImage.setOpacity(opacity);\n    return this;\n  },\n\n  getTimeRange: function () {\n    return [this.options.from, this.options.to];\n  },\n\n  setTimeRange: function (from, to) {\n    this.options.from = from;\n    this.options.to = to;\n    this._update();\n    return this;\n  },\n\n  metadata: function (callback, context) {\n    this.service.metadata(callback, context);\n    return this;\n  },\n\n  authenticate: function (token) {\n    this.service.authenticate(token);\n    return this;\n  },\n\n  _renderImage: function (url, bounds) {\n    if (this._map) {\n      // create a new image overlay and add it to the map\n      // to start loading the image\n      // opacity is 0 while the image is loading\n      var image = new Overlay(url, bounds, {\n        opacity: 0,\n        crossOrigin: this.options.useCors,\n        alt: this.options.alt,\n        pane: this.options.pane || this.getPane(),\n        interactive: this.options.interactive\n      }).addTo(this._map);\n\n      // once the image loads\n      image.once('load', function (e) {\n        if (this._map) {\n          var newImage = e.target;\n          var oldImage = this._currentImage;\n\n          // if the bounds of this image matches the bounds that\n          // _renderImage was called with and we have a map with the same bounds\n          // hide the old image if there is one and set the opacity\n          // of the new image otherwise remove the new image\n          if (newImage._bounds.equals(bounds) && newImage._bounds.equals(this._map.getBounds())) {\n            this._currentImage = newImage;\n\n            if (this.options.position === 'front') {\n              this.bringToFront();\n            } else {\n              this.bringToBack();\n            }\n\n            if (this._map && this._currentImage._map) {\n              this._currentImage.setOpacity(this.options.opacity);\n            } else {\n              this._currentImage._map.removeLayer(this._currentImage);\n            }\n\n            if (oldImage && this._map) {\n              this._map.removeLayer(oldImage);\n            }\n\n            if (oldImage && oldImage._map) {\n              oldImage._map.removeLayer(oldImage);\n            }\n          } else {\n            this._map.removeLayer(newImage);\n          }\n        }\n\n        this.fire('load', {\n          bounds: bounds\n        });\n      }, this);\n\n      this.fire('loading', {\n        bounds: bounds\n      });\n    }\n  },\n\n  _update: function () {\n    if (!this._map) {\n      return;\n    }\n\n    var zoom = this._map.getZoom();\n    var bounds = this._map.getBounds();\n\n    if (this._animatingZoom) {\n      return;\n    }\n\n    if (this._map._panTransition && this._map._panTransition._inProgress) {\n      return;\n    }\n\n    if (zoom > this.options.maxZoom || zoom < this.options.minZoom) {\n      this._currentImage._map.removeLayer(this._currentImage);\n      return;\n    }\n\n    var params = this._buildExportParams();\n\n    this._requestExport(params, bounds);\n  },\n\n  _renderPopup: function (latlng, error, results, response) {\n    latlng = L.latLng(latlng);\n    if (this._shouldRenderPopup && this._lastClick.equals(latlng)) {\n      // add the popup to the map where the mouse was clicked at\n      var content = this._popupFunction(error, results, response);\n      if (content) {\n        this._popup.setLatLng(latlng).setContent(content).openOn(this._map);\n      }\n    }\n  },\n\n  _resetPopupState: function (e) {\n    this._shouldRenderPopup = false;\n    this._lastClick = e.latlng;\n  }\n});\n","import L from 'leaflet';\nimport { RasterLayer } from './RasterLayer';\nimport { cleanUrl } from '../Util';\nimport imageService from '../Services/ImageService';\n\nexport var ImageMapLayer = RasterLayer.extend({\n\n  options: {\n    updateInterval: 150,\n    format: 'jpgpng',\n    transparent: true,\n    f: 'json'\n  },\n\n  query: function () {\n    return this.service.query();\n  },\n\n  identify: function () {\n    return this.service.identify();\n  },\n\n  initialize: function (options) {\n    options.url = cleanUrl(options.url);\n    this.service = imageService(options);\n    this.service.addEventParent(this);\n\n    L.Util.setOptions(this, options);\n  },\n\n  setPixelType: function (pixelType) {\n    this.options.pixelType = pixelType;\n    this._update();\n    return this;\n  },\n\n  getPixelType: function () {\n    return this.options.pixelType;\n  },\n\n  setBandIds: function (bandIds) {\n    if (L.Util.isArray(bandIds)) {\n      this.options.bandIds = bandIds.join(',');\n    } else {\n      this.options.bandIds = bandIds.toString();\n    }\n    this._update();\n    return this;\n  },\n\n  getBandIds: function () {\n    return this.options.bandIds;\n  },\n\n  setNoData: function (noData, noDataInterpretation) {\n    if (L.Util.isArray(noData)) {\n      this.options.noData = noData.join(',');\n    } else {\n      this.options.noData = noData.toString();\n    }\n    if (noDataInterpretation) {\n      this.options.noDataInterpretation = noDataInterpretation;\n    }\n    this._update();\n    return this;\n  },\n\n  getNoData: function () {\n    return this.options.noData;\n  },\n\n  getNoDataInterpretation: function () {\n    return this.options.noDataInterpretation;\n  },\n\n  setRenderingRule: function (renderingRule) {\n    this.options.renderingRule = renderingRule;\n    this._update();\n  },\n\n  getRenderingRule: function () {\n    return this.options.renderingRule;\n  },\n\n  setMosaicRule: function (mosaicRule) {\n    this.options.mosaicRule = mosaicRule;\n    this._update();\n  },\n\n  getMosaicRule: function () {\n    return this.options.mosaicRule;\n  },\n\n  _getPopupData: function (e) {\n    var callback = L.Util.bind(function (error, results, response) {\n      if (error) { return; } // we really can't do anything here but authenticate or requesterror will fire\n      setTimeout(L.Util.bind(function () {\n        this._renderPopup(e.latlng, error, results, response);\n      }, this), 300);\n    }, this);\n\n    var identifyRequest = this.identify().at(e.latlng);\n\n    // set mosaic rule for identify task if it is set for layer\n    if (this.options.mosaicRule) {\n      identifyRequest.setMosaicRule(this.options.mosaicRule);\n      // @TODO: force return catalog items too?\n    }\n\n    // @TODO: set rendering rule? Not sure,\n    // sometimes you want raw pixel values\n    // if (this.options.renderingRule) {\n    //   identifyRequest.setRenderingRule(this.options.renderingRule);\n    // }\n\n    identifyRequest.run(callback);\n\n    // set the flags to show the popup\n    this._shouldRenderPopup = true;\n    this._lastClick = e.latlng;\n  },\n\n  _buildExportParams: function () {\n    var bounds = this._map.getBounds();\n    var size = this._map.getSize();\n    var ne = this._map.options.crs.project(bounds._northEast);\n    var sw = this._map.options.crs.project(bounds._southWest);\n\n    // ensure that we don't ask ArcGIS Server for a taller image than we have actual map displaying\n    var top = this._map.latLngToLayerPoint(bounds._northEast);\n    var bottom = this._map.latLngToLayerPoint(bounds._southWest);\n\n    if (top.y > 0 || bottom.y < size.y) {\n      size.y = bottom.y - top.y;\n    }\n\n    var sr = parseInt(this._map.options.crs.code.split(':')[1], 10);\n\n    var params = {\n      bbox: [sw.x, sw.y, ne.x, ne.y].join(','),\n      size: size.x + ',' + size.y,\n      format: this.options.format,\n      transparent: this.options.transparent,\n      bboxSR: sr,\n      imageSR: sr\n    };\n\n    if (this.options.from && this.options.to) {\n      params.time = this.options.from.valueOf() + ',' + this.options.to.valueOf();\n    }\n\n    if (this.options.pixelType) {\n      params.pixelType = this.options.pixelType;\n    }\n\n    if (this.options.interpolation) {\n      params.interpolation = this.options.interpolation;\n    }\n\n    if (this.options.compressionQuality) {\n      params.compressionQuality = this.options.compressionQuality;\n    }\n\n    if (this.options.bandIds) {\n      params.bandIds = this.options.bandIds;\n    }\n\n    if (this.options.noData) {\n      params.noData = this.options.noData;\n    }\n\n    if (this.options.noDataInterpretation) {\n      params.noDataInterpretation = this.options.noDataInterpretation;\n    }\n\n    if (this.service.options.token) {\n      params.token = this.service.options.token;\n    }\n\n    if (this.options.renderingRule) {\n      params.renderingRule = JSON.stringify(this.options.renderingRule);\n    }\n\n    if (this.options.mosaicRule) {\n      params.mosaicRule = JSON.stringify(this.options.mosaicRule);\n    }\n\n    return params;\n  },\n\n  _requestExport: function (params, bounds) {\n    if (this.options.f === 'json') {\n      this.service.request('exportImage', params, function (error, response) {\n        if (error) { return; } // we really can't do anything here but authenticate or requesterror will fire\n        this._renderImage(response.href, bounds);\n      }, this);\n    } else {\n      params.f = 'image';\n      this._renderImage(this.options.url + 'exportImage' + L.Util.getParamString(params), bounds);\n    }\n  }\n});\n\nexport function imageMapLayer (url, options) {\n  return new ImageMapLayer(url, options);\n}\n\nexport default imageMapLayer;\n","import L from 'leaflet';\nimport { RasterLayer } from './RasterLayer';\nimport { cleanUrl } from '../Util';\nimport mapService from '../Services/MapService';\n\nexport var DynamicMapLayer = RasterLayer.extend({\n\n  options: {\n    updateInterval: 150,\n    layers: false,\n    layerDefs: false,\n    timeOptions: false,\n    format: 'png24',\n    transparent: true,\n    f: 'json'\n  },\n\n  initialize: function (options) {\n    options.url = cleanUrl(options.url);\n    this.service = mapService(options);\n    this.service.addEventParent(this);\n\n    if ((options.proxy || options.token) && options.f !== 'json') {\n      options.f = 'json';\n    }\n    L.Util.setOptions(this, options);\n  },\n\n  getDynamicLayers: function () {\n    return this.options.dynamicLayers;\n  },\n\n  setDynamicLayers: function (dynamicLayers) {\n    this.options.dynamicLayers = dynamicLayers;\n    this._update();\n    return this;\n  },\n\n  getLayers: function () {\n    return this.options.layers;\n  },\n\n  setLayers: function (layers) {\n    this.options.layers = layers;\n    this._update();\n    return this;\n  },\n\n  getLayerDefs: function () {\n    return this.options.layerDefs;\n  },\n\n  setLayerDefs: function (layerDefs) {\n    this.options.layerDefs = layerDefs;\n    this._update();\n    return this;\n  },\n\n  getTimeOptions: function () {\n    return this.options.timeOptions;\n  },\n\n  setTimeOptions: function (timeOptions) {\n    this.options.timeOptions = timeOptions;\n    this._update();\n    return this;\n  },\n\n  query: function () {\n    return this.service.query();\n  },\n\n  identify: function () {\n    return this.service.identify();\n  },\n\n  find: function () {\n    return this.service.find();\n  },\n\n  _getPopupData: function (e) {\n    var callback = L.Util.bind(function (error, featureCollection, response) {\n      if (error) { return; } // we really can't do anything here but authenticate or requesterror will fire\n      setTimeout(L.Util.bind(function () {\n        this._renderPopup(e.latlng, error, featureCollection, response);\n      }, this), 300);\n    }, this);\n\n    var identifyRequest = this.identify().on(this._map).at(e.latlng);\n\n    if (this.options.layers) {\n      identifyRequest.layers('visible:' + this.options.layers.join(','));\n    } else {\n      identifyRequest.layers('visible');\n    }\n\n    identifyRequest.run(callback);\n\n    // set the flags to show the popup\n    this._shouldRenderPopup = true;\n    this._lastClick = e.latlng;\n  },\n\n  _buildExportParams: function () {\n    var bounds = this._map.getBounds();\n    var size = this._map.getSize();\n    var ne = this._map.options.crs.project(bounds.getNorthEast());\n    var sw = this._map.options.crs.project(bounds.getSouthWest());\n    var sr = parseInt(this._map.options.crs.code.split(':')[1], 10);\n\n    // ensure that we don't ask ArcGIS Server for a taller image than we have actual map displaying\n    var top = this._map.latLngToLayerPoint(bounds._northEast);\n    var bottom = this._map.latLngToLayerPoint(bounds._southWest);\n\n    if (top.y > 0 || bottom.y < size.y) {\n      size.y = bottom.y - top.y;\n    }\n\n    var params = {\n      bbox: [sw.x, sw.y, ne.x, ne.y].join(','),\n      size: size.x + ',' + size.y,\n      dpi: 96,\n      format: this.options.format,\n      transparent: this.options.transparent,\n      bboxSR: sr,\n      imageSR: sr\n    };\n\n    if (this.options.dynamicLayers) {\n      params.dynamicLayers = this.options.dynamicLayers;\n    }\n\n    if (this.options.layers) {\n      params.layers = 'show:' + this.options.layers.join(',');\n    }\n\n    if (this.options.layerDefs) {\n      params.layerDefs = JSON.stringify(this.options.layerDefs);\n    }\n\n    if (this.options.timeOptions) {\n      params.timeOptions = JSON.stringify(this.options.timeOptions);\n    }\n\n    if (this.options.from && this.options.to) {\n      params.time = this.options.from.valueOf() + ',' + this.options.to.valueOf();\n    }\n\n    if (this.service.options.token) {\n      params.token = this.service.options.token;\n    }\n\n    return params;\n  },\n\n  _requestExport: function (params, bounds) {\n    if (this.options.f === 'json') {\n      this.service.request('export', params, function (error, response) {\n        if (error) { return; } // we really can't do anything here but authenticate or requesterror will fire\n        this._renderImage(response.href, bounds);\n      }, this);\n    } else {\n      params.f = 'image';\n      this._renderImage(this.options.url + 'export' + L.Util.getParamString(params), bounds);\n    }\n  }\n});\n\nexport function dynamicMapLayer (url, options) {\n  return new DynamicMapLayer(url, options);\n}\n\nexport default dynamicMapLayer;\n","import L from 'leaflet';\n\nvar VirtualGrid = L.Layer.extend({\n\n  options: {\n    cellSize: 512,\n    updateInterval: 150\n  },\n\n  initialize: function (options) {\n    options = L.setOptions(this, options);\n    this._zooming = false;\n  },\n\n  onAdd: function (map) {\n    this._map = map;\n    this._update = L.Util.throttle(this._update, this.options.updateInterval, this);\n    this._reset();\n    this._update();\n  },\n\n  onRemove: function () {\n    this._map.removeEventListener(this.getEvents(), this);\n    this._removeCells();\n  },\n\n  getEvents: function () {\n    var events = {\n      moveend: this._update,\n      zoomstart: this._zoomstart,\n      zoomend: this._reset\n    };\n\n    return events;\n  },\n\n  addTo: function (map) {\n    map.addLayer(this);\n    return this;\n  },\n\n  removeFrom: function (map) {\n    map.removeLayer(this);\n    return this;\n  },\n\n  _zoomstart: function () {\n    this._zooming = true;\n  },\n\n  _reset: function () {\n    this._removeCells();\n\n    this._cells = {};\n    this._activeCells = {};\n    this._cellsToLoad = 0;\n    this._cellsTotal = 0;\n    this._cellNumBounds = this._getCellNumBounds();\n\n    this._resetWrap();\n    this._zooming = false;\n  },\n\n  _resetWrap: function () {\n    var map = this._map;\n    var crs = map.options.crs;\n\n    if (crs.infinite) { return; }\n\n    var cellSize = this._getCellSize();\n\n    if (crs.wrapLng) {\n      this._wrapLng = [\n        Math.floor(map.project([0, crs.wrapLng[0]]).x / cellSize),\n        Math.ceil(map.project([0, crs.wrapLng[1]]).x / cellSize)\n      ];\n    }\n\n    if (crs.wrapLat) {\n      this._wrapLat = [\n        Math.floor(map.project([crs.wrapLat[0], 0]).y / cellSize),\n        Math.ceil(map.project([crs.wrapLat[1], 0]).y / cellSize)\n      ];\n    }\n  },\n\n  _getCellSize: function () {\n    return this.options.cellSize;\n  },\n\n  _update: function () {\n    if (!this._map) {\n      return;\n    }\n\n    var bounds = this._map.getPixelBounds();\n    var cellSize = this._getCellSize();\n\n    // cell coordinates range for the current view\n    var cellBounds = L.bounds(\n      bounds.min.divideBy(cellSize).floor(),\n      bounds.max.divideBy(cellSize).floor());\n\n    this._removeOtherCells(cellBounds);\n    this._addCells(cellBounds);\n\n    this.fire('cellsupdated');\n  },\n\n  _addCells: function (bounds) {\n    var queue = [];\n    var center = bounds.getCenter();\n    var zoom = this._map.getZoom();\n\n    var j, i, coords;\n    // create a queue of coordinates to load cells from\n    for (j = bounds.min.y; j <= bounds.max.y; j++) {\n      for (i = bounds.min.x; i <= bounds.max.x; i++) {\n        coords = L.point(i, j);\n        coords.z = zoom;\n\n        if (this._isValidCell(coords)) {\n          queue.push(coords);\n        }\n      }\n    }\n\n    var cellsToLoad = queue.length;\n\n    if (cellsToLoad === 0) { return; }\n\n    this._cellsToLoad += cellsToLoad;\n    this._cellsTotal += cellsToLoad;\n\n    // sort cell queue to load cells in order of their distance to center\n    queue.sort(function (a, b) {\n      return a.distanceTo(center) - b.distanceTo(center);\n    });\n\n    for (i = 0; i < cellsToLoad; i++) {\n      this._addCell(queue[i]);\n    }\n  },\n\n  _isValidCell: function (coords) {\n    var crs = this._map.options.crs;\n\n    if (!crs.infinite) {\n      // don't load cell if it's out of bounds and not wrapped\n      var bounds = this._cellNumBounds;\n      if (\n        (!crs.wrapLng && (coords.x < bounds.min.x || coords.x > bounds.max.x)) ||\n        (!crs.wrapLat && (coords.y < bounds.min.y || coords.y > bounds.max.y))\n      ) {\n        return false;\n      }\n    }\n\n    if (!this.options.bounds) {\n      return true;\n    }\n\n    // don't load cell if it doesn't intersect the bounds in options\n    var cellBounds = this._cellCoordsToBounds(coords);\n    return L.latLngBounds(this.options.bounds).intersects(cellBounds);\n  },\n\n  // converts cell coordinates to its geographical bounds\n  _cellCoordsToBounds: function (coords) {\n    var map = this._map;\n    var cellSize = this.options.cellSize;\n    var nwPoint = coords.multiplyBy(cellSize);\n    var sePoint = nwPoint.add([cellSize, cellSize]);\n    var nw = map.wrapLatLng(map.unproject(nwPoint, coords.z));\n    var se = map.wrapLatLng(map.unproject(sePoint, coords.z));\n\n    return L.latLngBounds(nw, se);\n  },\n\n  // converts cell coordinates to key for the cell cache\n  _cellCoordsToKey: function (coords) {\n    return coords.x + ':' + coords.y;\n  },\n\n  // converts cell cache key to coordiantes\n  _keyToCellCoords: function (key) {\n    var kArr = key.split(':');\n    var x = parseInt(kArr[0], 10);\n    var y = parseInt(kArr[1], 10);\n\n    return L.point(x, y);\n  },\n\n  // remove any present cells that are off the specified bounds\n  _removeOtherCells: function (bounds) {\n    for (var key in this._cells) {\n      if (!bounds.contains(this._keyToCellCoords(key))) {\n        this._removeCell(key);\n      }\n    }\n  },\n\n  _removeCell: function (key) {\n    var cell = this._activeCells[key];\n\n    if (cell) {\n      delete this._activeCells[key];\n\n      if (this.cellLeave) {\n        this.cellLeave(cell.bounds, cell.coords);\n      }\n\n      this.fire('cellleave', {\n        bounds: cell.bounds,\n        coords: cell.coords\n      });\n    }\n  },\n\n  _removeCells: function () {\n    for (var key in this._cells) {\n      var bounds = this._cells[key].bounds;\n      var coords = this._cells[key].coords;\n\n      if (this.cellLeave) {\n        this.cellLeave(bounds, coords);\n      }\n\n      this.fire('cellleave', {\n        bounds: bounds,\n        coords: coords\n      });\n    }\n  },\n\n  _addCell: function (coords) {\n    // wrap cell coords if necessary (depending on CRS)\n    this._wrapCoords(coords);\n\n    // generate the cell key\n    var key = this._cellCoordsToKey(coords);\n\n    // get the cell from the cache\n    var cell = this._cells[key];\n    // if this cell should be shown as isnt active yet (enter)\n\n    if (cell && !this._activeCells[key]) {\n      if (this.cellEnter) {\n        this.cellEnter(cell.bounds, coords);\n      }\n\n      this.fire('cellenter', {\n        bounds: cell.bounds,\n        coords: coords\n      });\n\n      this._activeCells[key] = cell;\n    }\n\n    // if we dont have this cell in the cache yet (create)\n    if (!cell) {\n      cell = {\n        coords: coords,\n        bounds: this._cellCoordsToBounds(coords)\n      };\n\n      this._cells[key] = cell;\n      this._activeCells[key] = cell;\n\n      if (this.createCell) {\n        this.createCell(cell.bounds, coords);\n      }\n\n      this.fire('cellcreate', {\n        bounds: cell.bounds,\n        coords: coords\n      });\n    }\n  },\n\n  _wrapCoords: function (coords) {\n    coords.x = this._wrapLng ? L.Util.wrapNum(coords.x, this._wrapLng) : coords.x;\n    coords.y = this._wrapLat ? L.Util.wrapNum(coords.y, this._wrapLat) : coords.y;\n  },\n\n  // get the global cell coordinates range for the current zoom\n  _getCellNumBounds: function () {\n    var bounds = this._map.getPixelWorldBounds();\n    var size = this._getCellSize();\n\n    return bounds ? L.bounds(\n        bounds.min.divideBy(size).floor(),\n        bounds.max.divideBy(size).ceil().subtract([1, 1])) : null;\n  }\n});\n\nexport default VirtualGrid;\n","function BinarySearchIndex (values) {\n  this.values = [].concat(values || []);\n}\n\nBinarySearchIndex.prototype.query = function (value) {\n  var index = this.getIndex(value);\n  return this.values[index];\n};\n\nBinarySearchIndex.prototype.getIndex = function getIndex (value) {\n  if (this.dirty) {\n    this.sort();\n  }\n\n  var minIndex = 0;\n  var maxIndex = this.values.length - 1;\n  var currentIndex;\n  var currentElement;\n\n  while (minIndex <= maxIndex) {\n    currentIndex = (minIndex + maxIndex) / 2 | 0;\n    currentElement = this.values[Math.round(currentIndex)];\n    if (+currentElement.value < +value) {\n      minIndex = currentIndex + 1;\n    } else if (+currentElement.value > +value) {\n      maxIndex = currentIndex - 1;\n    } else {\n      return currentIndex;\n    }\n  }\n\n  return Math.abs(~maxIndex);\n};\n\nBinarySearchIndex.prototype.between = function between (start, end) {\n  var startIndex = this.getIndex(start);\n  var endIndex = this.getIndex(end);\n\n  if (startIndex === 0 && endIndex === 0) {\n    return [];\n  }\n\n  while (this.values[startIndex - 1] && this.values[startIndex - 1].value === start) {\n    startIndex--;\n  }\n\n  while (this.values[endIndex + 1] && this.values[endIndex + 1].value === end) {\n    endIndex++;\n  }\n\n  if (this.values[endIndex] && this.values[endIndex].value === end && this.values[endIndex + 1]) {\n    endIndex++;\n  }\n\n  return this.values.slice(startIndex, endIndex);\n};\n\nBinarySearchIndex.prototype.insert = function insert (item) {\n  this.values.splice(this.getIndex(item.value), 0, item);\n  return this;\n};\n\nBinarySearchIndex.prototype.bulkAdd = function bulkAdd (items, sort) {\n  this.values = this.values.concat([].concat(items || []));\n\n  if (sort) {\n    this.sort();\n  } else {\n    this.dirty = true;\n  }\n\n  return this;\n};\n\nBinarySearchIndex.prototype.sort = function sort () {\n  this.values.sort(function (a, b) {\n    return +b.value - +a.value;\n  }).reverse();\n  this.dirty = false;\n  return this;\n};\n\nexport default BinarySearchIndex;\n","import L from 'leaflet';\nimport featureLayerService from '../../Services/FeatureLayerService';\nimport { cleanUrl, warn } from '../../Util';\nimport VirtualGrid from 'leaflet-virtual-grid';\nimport BinarySearchIndex from 'tiny-binary-search';\n\nexport var FeatureManager = VirtualGrid.extend({\n  /**\n   * Options\n   */\n\n  options: {\n    attribution: null,\n    where: '1=1',\n    fields: ['*'],\n    from: false,\n    to: false,\n    timeField: false,\n    timeFilterMode: 'server',\n    simplifyFactor: 0,\n    precision: 6\n  },\n\n  /**\n   * Constructor\n   */\n\n  initialize: function (options) {\n    VirtualGrid.prototype.initialize.call(this, options);\n\n    options.url = cleanUrl(options.url);\n    options = L.setOptions(this, options);\n\n    this.service = featureLayerService(options);\n    this.service.addEventParent(this);\n\n    // use case insensitive regex to look for common fieldnames used for indexing\n    if (this.options.fields[0] !== '*') {\n      var oidCheck = false;\n      for (var i = 0; i < this.options.fields.length; i++) {\n        if (this.options.fields[i].match(/^(OBJECTID|FID|OID|ID)$/i)) {\n          oidCheck = true;\n        }\n      }\n      if (oidCheck === false) {\n        warn('no known esriFieldTypeOID field detected in fields Array.  Please add an attribute field containing unique IDs to ensure the layer can be drawn correctly.');\n      }\n    }\n\n    if (this.options.timeField.start && this.options.timeField.end) {\n      this._startTimeIndex = new BinarySearchIndex();\n      this._endTimeIndex = new BinarySearchIndex();\n    } else if (this.options.timeField) {\n      this._timeIndex = new BinarySearchIndex();\n    }\n\n    this._cache = {};\n    this._currentSnapshot = []; // cache of what layers should be active\n    this._activeRequests = 0;\n  },\n\n  /**\n   * Layer Interface\n   */\n\n  onAdd: function (map) {\n    map.on('zoomend', this._handleZoomChange, this);\n\n    return VirtualGrid.prototype.onAdd.call(this, map);\n  },\n\n  onRemove: function (map) {\n    map.off('zoomend', this._handleZoomChange, this);\n\n    return VirtualGrid.prototype.onRemove.call(this, map);\n  },\n\n  getAttribution: function () {\n    return this.options.attribution;\n  },\n\n  /**\n   * Feature Management\n   */\n\n  createCell: function (bounds, coords) {\n    this._requestFeatures(bounds, coords);\n  },\n\n  _requestFeatures: function (bounds, coords, callback) {\n    this._activeRequests++;\n\n    // our first active request fires loading\n    if (this._activeRequests === 1) {\n      this.fire('loading', {\n        bounds: bounds\n      }, true);\n    }\n\n    return this._buildQuery(bounds).run(function (error, featureCollection, response) {\n      if (response && response.exceededTransferLimit) {\n        this.fire('drawlimitexceeded');\n      }\n\n      // no error, features\n      if (!error && featureCollection && featureCollection.features.length) {\n        // schedule adding features until the next animation frame\n        L.Util.requestAnimFrame(L.Util.bind(function () {\n          this._addFeatures(featureCollection.features, coords);\n          this._postProcessFeatures(bounds);\n        }, this));\n      }\n\n      // no error, no features\n      if (!error && featureCollection && !featureCollection.features.length) {\n        this._postProcessFeatures(bounds);\n      }\n\n      if (error) {\n        this._postProcessFeatures(bounds);\n      }\n\n      if (callback) {\n        callback.call(this, error, featureCollection);\n      }\n    }, this);\n  },\n\n  _postProcessFeatures: function (bounds) {\n    // deincriment the request counter now that we have processed features\n    this._activeRequests--;\n\n    // if there are no more active requests fire a load event for this view\n    if (this._activeRequests <= 0) {\n      this.fire('load', {\n        bounds: bounds\n      });\n    }\n  },\n\n  _cacheKey: function (coords) {\n    return coords.z + ':' + coords.x + ':' + coords.y;\n  },\n\n  _addFeatures: function (features, coords) {\n    var key = this._cacheKey(coords);\n    this._cache[key] = this._cache[key] || [];\n\n    for (var i = features.length - 1; i >= 0; i--) {\n      var id = features[i].id;\n      this._currentSnapshot.push(id);\n      this._cache[key].push(id);\n    }\n\n    if (this.options.timeField) {\n      this._buildTimeIndexes(features);\n    }\n\n    // need to PR removal of the logic below too...\n    // https://github.com/patrickarlt/leaflet-virtual-grid/blob/master/src/virtual-grid.js#L100-L102\n\n    this.createLayers(features);\n  },\n\n  _buildQuery: function (bounds) {\n    var query = this.service.query()\n      .intersects(bounds)\n      .where(this.options.where)\n      .fields(this.options.fields)\n      .precision(this.options.precision);\n\n    if (this.options.simplifyFactor) {\n      query.simplify(this._map, this.options.simplifyFactor);\n    }\n\n    if (this.options.timeFilterMode === 'server' && this.options.from && this.options.to) {\n      query.between(this.options.from, this.options.to);\n    }\n\n    return query;\n  },\n\n  /**\n   * Where Methods\n   */\n\n  setWhere: function (where, callback, context) {\n    this.options.where = (where && where.length) ? where : '1=1';\n\n    var oldSnapshot = [];\n    var newSnapshot = [];\n    var pendingRequests = 0;\n    var requestError = null;\n    var requestCallback = L.Util.bind(function (error, featureCollection) {\n      if (error) {\n        requestError = error;\n      }\n\n      if (featureCollection) {\n        for (var i = featureCollection.features.length - 1; i >= 0; i--) {\n          newSnapshot.push(featureCollection.features[i].id);\n        }\n      }\n\n      pendingRequests--;\n\n      if (pendingRequests <= 0) {\n        this._currentSnapshot = newSnapshot;\n        // schedule adding features for the next animation frame\n        L.Util.requestAnimFrame(L.Util.bind(function () {\n          this.removeLayers(oldSnapshot);\n          this.addLayers(newSnapshot);\n          if (callback) {\n            callback.call(context, requestError);\n          }\n        }, this));\n      }\n    }, this);\n\n    for (var i = this._currentSnapshot.length - 1; i >= 0; i--) {\n      oldSnapshot.push(this._currentSnapshot[i]);\n    }\n\n    for (var key in this._activeCells) {\n      pendingRequests++;\n      var coords = this._keyToCellCoords(key);\n      var bounds = this._cellCoordsToBounds(coords);\n      this._requestFeatures(bounds, key, requestCallback);\n    }\n\n    return this;\n  },\n\n  getWhere: function () {\n    return this.options.where;\n  },\n\n  /**\n   * Time Range Methods\n   */\n\n  getTimeRange: function () {\n    return [this.options.from, this.options.to];\n  },\n\n  setTimeRange: function (from, to, callback, context) {\n    var oldFrom = this.options.from;\n    var oldTo = this.options.to;\n    var pendingRequests = 0;\n    var requestError = null;\n    var requestCallback = L.Util.bind(function (error) {\n      if (error) {\n        requestError = error;\n      }\n      this._filterExistingFeatures(oldFrom, oldTo, from, to);\n\n      pendingRequests--;\n\n      if (callback && pendingRequests <= 0) {\n        callback.call(context, requestError);\n      }\n    }, this);\n\n    this.options.from = from;\n    this.options.to = to;\n\n    this._filterExistingFeatures(oldFrom, oldTo, from, to);\n\n    if (this.options.timeFilterMode === 'server') {\n      for (var key in this._activeCells) {\n        pendingRequests++;\n        var coords = this._keyToCellCoords(key);\n        var bounds = this._cellCoordsToBounds(coords);\n        this._requestFeatures(bounds, key, requestCallback);\n      }\n    }\n\n    return this;\n  },\n\n  refresh: function () {\n    for (var key in this._activeCells) {\n      var coords = this._keyToCellCoords(key);\n      var bounds = this._cellCoordsToBounds(coords);\n      this._requestFeatures(bounds, key);\n    }\n\n    if (this.redraw) {\n      this.once('load', function () {\n        this.eachFeature(function (layer) {\n          this._redraw(layer.feature.id);\n        }, this);\n      }, this);\n    }\n  },\n\n  _filterExistingFeatures: function (oldFrom, oldTo, newFrom, newTo) {\n    var layersToRemove = (oldFrom && oldTo) ? this._getFeaturesInTimeRange(oldFrom, oldTo) : this._currentSnapshot;\n    var layersToAdd = this._getFeaturesInTimeRange(newFrom, newTo);\n\n    if (layersToAdd.indexOf) {\n      for (var i = 0; i < layersToAdd.length; i++) {\n        var shouldRemoveLayer = layersToRemove.indexOf(layersToAdd[i]);\n        if (shouldRemoveLayer >= 0) {\n          layersToRemove.splice(shouldRemoveLayer, 1);\n        }\n      }\n    }\n\n    // schedule adding features until the next animation frame\n    L.Util.requestAnimFrame(L.Util.bind(function () {\n      this.removeLayers(layersToRemove);\n      this.addLayers(layersToAdd);\n    }, this));\n  },\n\n  _getFeaturesInTimeRange: function (start, end) {\n    var ids = [];\n    var search;\n\n    if (this.options.timeField.start && this.options.timeField.end) {\n      var startTimes = this._startTimeIndex.between(start, end);\n      var endTimes = this._endTimeIndex.between(start, end);\n      search = startTimes.concat(endTimes);\n    } else {\n      search = this._timeIndex.between(start, end);\n    }\n\n    for (var i = search.length - 1; i >= 0; i--) {\n      ids.push(search[i].id);\n    }\n\n    return ids;\n  },\n\n  _buildTimeIndexes: function (geojson) {\n    var i;\n    var feature;\n    if (this.options.timeField.start && this.options.timeField.end) {\n      var startTimeEntries = [];\n      var endTimeEntries = [];\n      for (i = geojson.length - 1; i >= 0; i--) {\n        feature = geojson[i];\n        startTimeEntries.push({\n          id: feature.id,\n          value: new Date(feature.properties[this.options.timeField.start])\n        });\n        endTimeEntries.push({\n          id: feature.id,\n          value: new Date(feature.properties[this.options.timeField.end])\n        });\n      }\n      this._startTimeIndex.bulkAdd(startTimeEntries);\n      this._endTimeIndex.bulkAdd(endTimeEntries);\n    } else {\n      var timeEntries = [];\n      for (i = geojson.length - 1; i >= 0; i--) {\n        feature = geojson[i];\n        timeEntries.push({\n          id: feature.id,\n          value: new Date(feature.properties[this.options.timeField])\n        });\n      }\n\n      this._timeIndex.bulkAdd(timeEntries);\n    }\n  },\n\n  _featureWithinTimeRange: function (feature) {\n    if (!this.options.from || !this.options.to) {\n      return true;\n    }\n\n    var from = +this.options.from.valueOf();\n    var to = +this.options.to.valueOf();\n\n    if (typeof this.options.timeField === 'string') {\n      var date = +feature.properties[this.options.timeField];\n      return (date >= from) && (date <= to);\n    }\n\n    if (this.options.timeField.start && this.options.timeField.end) {\n      var startDate = +feature.properties[this.options.timeField.start];\n      var endDate = +feature.properties[this.options.timeField.end];\n      return ((startDate >= from) && (startDate <= to)) || ((endDate >= from) && (endDate <= to));\n    }\n  },\n\n  _visibleZoom: function () {\n    // check to see whether the current zoom level of the map is within the optional limit defined for the FeatureLayer\n    if (!this._map) {\n      return false;\n    }\n    var zoom = this._map.getZoom();\n    if (zoom > this.options.maxZoom || zoom < this.options.minZoom) {\n      return false;\n    } else { return true; }\n  },\n\n  _handleZoomChange: function () {\n    if (!this._visibleZoom()) {\n      this.removeLayers(this._currentSnapshot);\n      this._currentSnapshot = [];\n    } else {\n      /*\n      for every cell in this._activeCells\n        1. Get the cache key for the coords of the cell\n        2. If this._cache[key] exists it will be an array of feature IDs.\n        3. Call this.addLayers(this._cache[key]) to instruct the feature layer to add the layers back.\n      */\n      for (var i in this._activeCells) {\n        var coords = this._activeCells[i].coords;\n        var key = this._cacheKey(coords);\n        if (this._cache[key]) {\n          this.addLayers(this._cache[key]);\n        }\n      }\n    }\n  },\n\n  /**\n   * Service Methods\n   */\n\n  authenticate: function (token) {\n    this.service.authenticate(token);\n    return this;\n  },\n\n  metadata: function (callback, context) {\n    this.service.metadata(callback, context);\n    return this;\n  },\n\n  query: function () {\n    return this.service.query();\n  },\n\n  _getMetadata: function (callback) {\n    if (this._metadata) {\n      var error;\n      callback(error, this._metadata);\n    } else {\n      this.metadata(L.Util.bind(function (error, response) {\n        this._metadata = response;\n        callback(error, this._metadata);\n      }, this));\n    }\n  },\n\n  addFeature: function (feature, callback, context) {\n    this._getMetadata(L.Util.bind(function (error, metadata) {\n      if (error) {\n        if (callback) { callback.call(this, error, null); }\n        return;\n      }\n\n      this.service.addFeature(feature, L.Util.bind(function (error, response) {\n        if (!error) {\n          // assign ID from result to appropriate objectid field from service metadata\n          feature.properties[metadata.objectIdField] = response.objectId;\n\n          // we also need to update the geojson id for createLayers() to function\n          feature.id = response.objectId;\n          this.createLayers([feature]);\n        }\n\n        if (callback) {\n          callback.call(context, error, response);\n        }\n      }, this));\n    }, this));\n  },\n\n  updateFeature: function (feature, callback, context) {\n    this.service.updateFeature(feature, function (error, response) {\n      if (!error) {\n        this.removeLayers([feature.id], true);\n        this.createLayers([feature]);\n      }\n\n      if (callback) {\n        callback.call(context, error, response);\n      }\n    }, this);\n  },\n\n  deleteFeature: function (id, callback, context) {\n    this.service.deleteFeature(id, function (error, response) {\n      if (!error && response.objectId) {\n        this.removeLayers([response.objectId], true);\n      }\n      if (callback) {\n        callback.call(context, error, response);\n      }\n    }, this);\n  },\n\n  deleteFeatures: function (ids, callback, context) {\n    return this.service.deleteFeatures(ids, function (error, response) {\n      if (!error && response.length > 0) {\n        for (var i = 0; i < response.length; i++) {\n          this.removeLayers([response[i].objectId], true);\n        }\n      }\n      if (callback) {\n        callback.call(context, error, response);\n      }\n    }, this);\n  }\n});\n","import L from 'leaflet';\nimport { FeatureManager } from './FeatureManager';\n\nexport var FeatureLayer = FeatureManager.extend({\n\n  options: {\n    cacheLayers: true\n  },\n\n  /**\n   * Constructor\n   */\n  initialize: function (options) {\n    FeatureManager.prototype.initialize.call(this, options);\n    this._originalStyle = this.options.style;\n    this._layers = {};\n  },\n\n  /**\n   * Layer Interface\n   */\n\n  onRemove: function (map) {\n    for (var i in this._layers) {\n      map.removeLayer(this._layers[i]);\n    }\n\n    return FeatureManager.prototype.onRemove.call(this, map);\n  },\n\n  createNewLayer: function (geojson) {\n    var layer = L.GeoJSON.geometryToLayer(geojson, this.options);\n    layer.defaultOptions = layer.options;\n    return layer;\n  },\n\n  _updateLayer: function (layer, geojson) {\n    // convert the geojson coordinates into a Leaflet LatLng array/nested arrays\n    // pass it to setLatLngs to update layer geometries\n    var latlngs = [];\n    var coordsToLatLng = this.options.coordsToLatLng || L.GeoJSON.coordsToLatLng;\n\n    // copy new attributes, if present\n    if (geojson.properties) {\n      layer.feature.properties = geojson.properties;\n    }\n\n    switch (geojson.geometry.type) {\n      case 'Point':\n        latlngs = L.GeoJSON.coordsToLatLng(geojson.geometry.coordinates);\n        layer.setLatLng(latlngs);\n        break;\n      case 'LineString':\n        latlngs = L.GeoJSON.coordsToLatLngs(geojson.geometry.coordinates, 0, coordsToLatLng);\n        layer.setLatLngs(latlngs);\n        break;\n      case 'MultiLineString':\n        latlngs = L.GeoJSON.coordsToLatLngs(geojson.geometry.coordinates, 1, coordsToLatLng);\n        layer.setLatLngs(latlngs);\n        break;\n      case 'Polygon':\n        latlngs = L.GeoJSON.coordsToLatLngs(geojson.geometry.coordinates, 1, coordsToLatLng);\n        layer.setLatLngs(latlngs);\n        break;\n      case 'MultiPolygon':\n        latlngs = L.GeoJSON.coordsToLatLngs(geojson.geometry.coordinates, 2, coordsToLatLng);\n        layer.setLatLngs(latlngs);\n        break;\n    }\n  },\n\n  /**\n   * Feature Management Methods\n   */\n\n  createLayers: function (features) {\n    for (var i = features.length - 1; i >= 0; i--) {\n      var geojson = features[i];\n\n      var layer = this._layers[geojson.id];\n      var newLayer;\n\n      if (this._visibleZoom() && layer && !this._map.hasLayer(layer)) {\n        this._map.addLayer(layer);\n      }\n\n      // update geometry if necessary\n      if (layer && this.options.simplifyFactor > 0 && (layer.setLatLngs || layer.setLatLng)) {\n        this._updateLayer(layer, geojson);\n      }\n\n      if (!layer) {\n        newLayer = this.createNewLayer(geojson);\n        newLayer.feature = geojson;\n\n        // bubble events from individual layers to the feature layer\n        newLayer.addEventParent(this);\n\n        if (this.options.onEachFeature) {\n          this.options.onEachFeature(newLayer.feature, newLayer);\n        }\n\n        // cache the layer\n        this._layers[newLayer.feature.id] = newLayer;\n\n        // style the layer\n        this.setFeatureStyle(newLayer.feature.id, this.options.style);\n\n        this.fire('createfeature', {\n          feature: newLayer.feature\n        }, true);\n\n        // add the layer if the current zoom level is inside the range defined for the layer, it is within the current time bounds or our layer is not time enabled\n        if (this._visibleZoom() && (!this.options.timeField || (this.options.timeField && this._featureWithinTimeRange(geojson)))) {\n          this._map.addLayer(newLayer);\n        }\n      }\n    }\n  },\n\n  addLayers: function (ids) {\n    for (var i = ids.length - 1; i >= 0; i--) {\n      var layer = this._layers[ids[i]];\n      if (layer) {\n        this.fire('addfeature', {\n          feature: layer.feature\n        }, true);\n        this._map.addLayer(layer);\n      }\n    }\n  },\n\n  removeLayers: function (ids, permanent) {\n    for (var i = ids.length - 1; i >= 0; i--) {\n      var id = ids[i];\n      var layer = this._layers[id];\n      if (layer) {\n        this.fire('removefeature', {\n          feature: layer.feature,\n          permanent: permanent\n        }, true);\n        this._map.removeLayer(layer);\n      }\n      if (layer && permanent) {\n        delete this._layers[id];\n      }\n    }\n  },\n\n  cellEnter: function (bounds, coords) {\n    if (!this._zooming && this._map) {\n      L.Util.requestAnimFrame(L.Util.bind(function () {\n        var cacheKey = this._cacheKey(coords);\n        var cellKey = this._cellCoordsToKey(coords);\n        var layers = this._cache[cacheKey];\n        if (this._activeCells[cellKey] && layers) {\n          this.addLayers(layers);\n        }\n      }, this));\n    }\n  },\n\n  cellLeave: function (bounds, coords) {\n    if (!this._zooming) {\n      L.Util.requestAnimFrame(L.Util.bind(function () {\n        if (this._map) {\n          var cacheKey = this._cacheKey(coords);\n          var cellKey = this._cellCoordsToKey(coords);\n          var layers = this._cache[cacheKey];\n          var mapBounds = this._map.getBounds();\n          if (!this._activeCells[cellKey] && layers) {\n            var removable = true;\n\n            for (var i = 0; i < layers.length; i++) {\n              var layer = this._layers[layers[i]];\n              if (layer && layer.getBounds && mapBounds.intersects(layer.getBounds())) {\n                removable = false;\n              }\n            }\n\n            if (removable) {\n              this.removeLayers(layers, !this.options.cacheLayers);\n            }\n\n            if (!this.options.cacheLayers && removable) {\n              delete this._cache[cacheKey];\n              delete this._cells[cellKey];\n              delete this._activeCells[cellKey];\n            }\n          }\n        }\n      }, this));\n    }\n  },\n\n  /**\n   * Styling Methods\n   */\n\n  resetStyle: function () {\n    this.options.style = this._originalStyle;\n    this.eachFeature(function (layer) {\n      this.resetFeatureStyle(layer.feature.id);\n    }, this);\n    return this;\n  },\n\n  setStyle: function (style) {\n    this.options.style = style;\n    this.eachFeature(function (layer) {\n      this.setFeatureStyle(layer.feature.id, style);\n    }, this);\n    return this;\n  },\n\n  resetFeatureStyle: function (id) {\n    var layer = this._layers[id];\n    var style = this._originalStyle || L.Path.prototype.options;\n    if (layer) {\n      L.Util.extend(layer.options, layer.defaultOptions);\n      this.setFeatureStyle(id, style);\n    }\n    return this;\n  },\n\n  setFeatureStyle: function (id, style) {\n    var layer = this._layers[id];\n    if (typeof style === 'function') {\n      style = style(layer.feature);\n    }\n    if (layer.setStyle) {\n      layer.setStyle(style);\n    }\n    return this;\n  },\n\n  /**\n   * Utility Methods\n   */\n\n  eachFeature: function (fn, context) {\n    for (var i in this._layers) {\n      fn.call(context, this._layers[i]);\n    }\n    return this;\n  },\n\n  getFeature: function (id) {\n    return this._layers[id];\n  },\n\n  bringToBack: function () {\n    this.eachFeature(function (layer) {\n      if (layer.bringToBack) {\n        layer.bringToBack();\n      }\n    });\n  },\n\n  bringToFront: function () {\n    this.eachFeature(function (layer) {\n      if (layer.bringToFront) {\n        layer.bringToFront();\n      }\n    });\n  },\n\n  redraw: function (id) {\n    if (id) {\n      this._redraw(id);\n    }\n    return this;\n  },\n\n  _redraw: function (id) {\n    var layer = this._layers[id];\n    var geojson = layer.feature;\n\n    // if this looks like a marker\n    if (layer && layer.setIcon && this.options.pointToLayer) {\n      // update custom symbology, if necessary\n      if (this.options.pointToLayer) {\n        var getIcon = this.options.pointToLayer(geojson, L.latLng(geojson.geometry.coordinates[1], geojson.geometry.coordinates[0]));\n        var updatedIcon = getIcon.options.icon;\n        layer.setIcon(updatedIcon);\n      }\n    }\n\n    // looks like a vector marker (circleMarker)\n    if (layer && layer.setStyle && this.options.pointToLayer) {\n      var getStyle = this.options.pointToLayer(geojson, L.latLng(geojson.geometry.coordinates[1], geojson.geometry.coordinates[0]));\n      var updatedStyle = getStyle.options;\n      this.setFeatureStyle(geojson.id, updatedStyle);\n    }\n\n    // looks like a path (polygon/polyline)\n    if (layer && layer.setStyle && this.options.style) {\n      this.resetStyle(geojson.id);\n    }\n  }\n});\n\nexport function featureLayer (options) {\n  return new FeatureLayer(options);\n}\n\nexport default featureLayer;\n"],"names":["shallowClone","arcgisToGeoJSON","geojsonToArcGIS","g2a","a2g"],"mappings":"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"} \ No newline at end of file diff --git a/dist/esri-leaflet.js b/dist/esri-leaflet.js new file mode 100644 index 000000000..953bc90f0 --- /dev/null +++ b/dist/esri-leaflet.js @@ -0,0 +1,6 @@ +/* esri-leaflet - v2.0.0 - Wed May 04 2016 10:49:11 GMT-0700 (PDT) + * Copyright (c) 2016 Environmental Systems Research Institute, Inc. + * Apache-2.0 */ +!function(t,e){"object"==typeof exports&&"undefined"!=typeof module?e(exports,require("leaflet")):"function"==typeof define&&define.amd?define(["exports","leaflet"],e):e((t.L=t.L||{},t.L.esri=t.L.esri||{}),t.L)}(this,function(t,e){"use strict";function i(t,e){for(var i=0;is;s++)e=t[s+1],i+=(e[0]-r[0])*(e[1]+r[1]),r=e;return i>=0}function r(t,e,i,s){var o=(s[0]-i[0])*(t[1]-i[1])-(s[1]-i[1])*(t[0]-i[0]),r=(e[0]-t[0])*(t[1]-i[1])-(e[1]-t[1])*(t[0]-i[0]),n=(s[1]-i[1])*(e[0]-t[0])-(s[0]-i[0])*(e[1]-t[1]);if(0!==n){var a=o/n,l=r/n;if(a>=0&&1>=a&&l>=0&&1>=l)return!0}return!1}function n(t,e){for(var i=0;i=0;e--)if(i=a[e][0],l(i,r)){a[e].push(r),m=!0;break}m||d.push(r)}for(;d.length;){r=d.pop();var f=!1;for(e=a.length-1;e>=0;e--)if(i=a[e][0],n(i,r)){a[e].push(r),f=!0;break}f||a.push([r.reverse()])}return 1===a.length?{type:"Polygon",coordinates:a[0]}:{type:"MultiPolygon",coordinates:a}}function h(t){var e=[],i=t.slice(0),r=s(i.shift().slice(0));if(r.length>=4){o(r)||r.reverse(),e.push(r);for(var n=0;n=4&&(o(a)&&a.reverse(),e.push(a))}}return e}function c(t){for(var e=[],i=0;i=0;o--){var r=s[o].slice(0);e.push(r)}return e}function p(t){var e={};for(var i in t)t.hasOwnProperty(i)&&(e[i]=t[i]);return e}function d(t,e){var i={};return"number"==typeof t.x&&"number"==typeof t.y&&(i.type="Point",i.coordinates=[t.x,t.y]),t.points&&(i.type="MultiPoint",i.coordinates=t.points.slice(0)),t.paths&&(1===t.paths.length?(i.type="LineString",i.coordinates=t.paths[0].slice(0)):(i.type="MultiLineString",i.coordinates=t.paths.slice(0))),t.rings&&(i=u(t.rings.slice(0))),(t.geometry||t.attributes)&&(i.type="Feature",i.geometry=t.geometry?d(t.geometry):null,i.properties=t.attributes?p(t.attributes):null,t.attributes&&(i.id=t.attributes[e]||t.attributes.OBJECTID||t.attributes.FID)),i}function m(t,e){e=e||"OBJECTID";var i,s={wkid:4326},o={};switch(t.type){case"Point":o.x=t.coordinates[0],o.y=t.coordinates[1],o.spatialReference=s;break;case"MultiPoint":o.points=t.coordinates.slice(0),o.spatialReference=s;break;case"LineString":o.paths=[t.coordinates.slice(0)],o.spatialReference=s;break;case"MultiLineString":o.paths=t.coordinates.slice(0),o.spatialReference=s;break;case"Polygon":o.rings=h(t.coordinates.slice(0)),o.spatialReference=s;break;case"MultiPolygon":o.rings=c(t.coordinates.slice(0)),o.spatialReference=s;break;case"Feature":t.geometry&&(o.geometry=m(t.geometry,e)),o.attributes=t.properties?p(t.properties):{},t.id&&(o.attributes[e]=t.id);break;case"FeatureCollection":for(o=[],i=0;i=0;n--){var a=g(r[n],i);o.features.push(a)}return o}function L(t){return t=e.Util.trim(t),"/"!==t[t.length-1]&&(t+="/"),t}function x(t){return/\.arcgis\.com.*?FeatureServer/g.test(t)}function S(t){var e;switch(t){case"Point":e="esriGeometryPoint";break;case"MultiPoint":e="esriGeometryMultipoint";break;case"LineString":e="esriGeometryPolyline";break;case"MultiLineString":e="esriGeometryPolyline";break;case"Polygon":e="esriGeometryPolygon";break;case"MultiPolygon":e="esriGeometryPolygon"}return e}function T(){console&&console.warn&&console.warn.apply(console,arguments)}function I(t){var e="";t.f=t.f||"json";for(var i in t)if(t.hasOwnProperty(i)){var s,o=t[i],r=Object.prototype.toString.call(o);e.length&&(e+="&"),s="[object Array]"===r?"[object Object]"===Object.prototype.toString.call(o[0])?JSON.stringify(o):o.join(","):"[object Object]"===r?JSON.stringify(o):"[object Date]"===r?o.valueOf():o,e+=encodeURIComponent(i)+"="+encodeURIComponent(s)}return e}function w(t,i){var s=new window.XMLHttpRequest;return s.onerror=function(o){s.onreadystatechange=e.Util.falseFn,t.call(i,{error:{code:500,message:"XMLHttpRequest error"}},null)},s.onreadystatechange=function(){var o,r;if(4===s.readyState){try{o=JSON.parse(s.responseText)}catch(n){o=null,r={code:500,message:"Could not parse response as JSON. This could also be caused by a CORS or XMLHttpRequest error."}}!r&&o.error&&(r=o.error,o=null),s.onerror=e.Util.falseFn,t.call(i,r,o)}},s.ontimeout=function(){this.onerror()},s}function P(t,e,i,s){var o=w(i,s);return o.open("POST",t),"undefined"!=typeof s&&null!==s&&"undefined"!=typeof s.options&&(o.timeout=s.options.timeout),o.setRequestHeader("Content-Type","application/x-www-form-urlencoded"),o.send(I(e)),o}function R(t,e,i,s){var o=w(i,s);return o.open("GET",t+"?"+I(e),!0),"undefined"!=typeof s&&null!==s&&"undefined"!=typeof s.options&&(o.timeout=s.options.timeout),o.send(null),o}function C(t,e,i,s){var o=I(e),r=w(i,s),n=(t+"?"+o).length;if(2e3>=n&&X.cors?r.open("GET",t+"?"+o):n>2e3&&X.cors&&(r.open("POST",t),r.setRequestHeader("Content-Type","application/x-www-form-urlencoded")),"undefined"!=typeof s&&null!==s&&"undefined"!=typeof s.options&&(r.timeout=s.options.timeout),2e3>=n&&X.cors)r.send(null);else{if(!(n>2e3&&X.cors))return 2e3>=n&&!X.cors?O(t,e,i,s):void T("a request to "+t+" was longer then 2000 characters and this browser cannot make a cross-domain post request. Please use a proxy http://esri.github.io/esri-leaflet/api-reference/request.html");r.send(o)}return r}function O(t,i,s,o){window._EsriLeafletCallbacks=window._EsriLeafletCallbacks||{};var r="c"+Y;i.callback="window._EsriLeafletCallbacks."+r,window._EsriLeafletCallbacks[r]=function(t){if(window._EsriLeafletCallbacks[r]!==!0){var e,i=Object.prototype.toString.call(t);"[object Object]"!==i&&"[object Array]"!==i&&(e={error:{code:500,message:"Expected array or object as JSONP response"}},t=null),!e&&t.error&&(e=t,t=null),s.call(o,e,t),window._EsriLeafletCallbacks[r]=!0}};var n=e.DomUtil.create("script",null,document.body);return n.type="text/javascript",n.src=t+"?"+I(i),n.id=r,Y++,{id:r,url:n.src,abort:function(){window._EsriLeafletCallbacks._callback[r]({code:0,message:"Request aborted."})}}}function F(t){return new it(t)}function k(t){return new st(t)}function M(t){return new ot(t)}function G(t){return new rt(t)}function E(t){return new nt(t)}function q(t){return new at(t)}function A(t){return new lt(t)}function U(t){return new ut(t)}function z(t){return new ht(t)}function D(t){return new ct(t)}function B(t){return new pt(t)}function j(t,e){return new mt(t,e)}function Z(t,e){return new ft(t,e)}function N(t,e){return new _t(t,e)}function W(t,e){return new vt(t,e)}function J(t){this.values=[].concat(t||[])}function Q(t){return new xt(t)}e="default"in e?e["default"]:e;var H="2.0.0",K=window.XMLHttpRequest&&"withCredentials"in new window.XMLHttpRequest,V=""===document.documentElement.style.pointerEvents,X={cors:K,pointerEvents:V},$={shallowClone:y,warn:T,cleanUrl:L,isArcgisOnline:x,geojsonTypeToArcGIS:S,responseToFeatureCollection:b,geojsonToArcGIS:f,arcgisToGeoJSON:g,boundsToExtent:v,extentToBounds:_},Y=0,tt=X.cors?R:O;tt.CORS=R,tt.JSONP=O;var et={request:C,get:tt,post:P},it=e.Class.extend({options:{proxy:!1,useCors:K},generateSetter:function(t,i){return e.Util.bind(function(e){return this.params[t]=e,this},i)},initialize:function(t){if(t.request&&t.options?(this._service=t,e.Util.setOptions(this,t.options)):(e.Util.setOptions(this,t),this.options.url=L(t.url)),this.params=e.Util.extend({},this.params||{}),this.setters)for(var i in this.setters){var s=this.setters[i];this[i]=this.generateSetter(s,this)}},token:function(t){return this._service?this._service.authenticate(t):this.params.token=t,this},request:function(t,e){return this._service?this._service.request(this.path,this.params,t,e):this._request("request",this.path,this.params,t,e)},_request:function(t,e,i,s,o){var r=this.options.proxy?this.options.proxy+"?"+this.options.url+e:this.options.url+e;return"get"!==t&&"request"!==t||this.options.useCors?et[t](r,i,s,o):et.get.JSONP(r,i,s,o)}}),st=it.extend({setters:{offset:"offset",limit:"limit",fields:"outFields",precision:"geometryPrecision",featureIds:"objectIds",returnGeometry:"returnGeometry",token:"token"},path:"query",params:{returnGeometry:!0,where:"1=1",outSr:4326,outFields:"*"},within:function(t){return this._setGeometry(t),this.params.spatialRel="esriSpatialRelContains",this},intersects:function(t){return this._setGeometry(t),this.params.spatialRel="esriSpatialRelIntersects",this},contains:function(t){return this._setGeometry(t),this.params.spatialRel="esriSpatialRelWithin",this},crosses:function(t){return this._setGeometry(t),this.params.spatialRel="esriSpatialRelCrosses",this},touches:function(t){return this._setGeometry(t),this.params.spatialRel="esriSpatialRelTouches",this},overlaps:function(t){return this._setGeometry(t),this.params.spatialRel="esriSpatialRelOverlaps",this},nearby:function(t,i){return t=e.latLng(t),this.params.geometry=[t.lng,t.lat],this.params.geometryType="esriGeometryPoint",this.params.spatialRel="esriSpatialRelIntersects",this.params.units="esriSRUnit_Meter",this.params.distance=i,this.params.inSr=4326,this},where:function(t){return this.params.where=t,this},between:function(t,e){return this.params.time=[t.valueOf(),e.valueOf()],this},simplify:function(t,e){var i=Math.abs(t.getBounds().getWest()-t.getBounds().getEast());return this.params.maxAllowableOffset=i/t.getSize().y*e,this},orderBy:function(t,e){return e=e||"ASC",this.params.orderByFields=this.params.orderByFields?this.params.orderByFields+",":"",this.params.orderByFields+=[t,e].join(" "),this},run:function(t,e){return this._cleanParams(),$.isArcgisOnline(this.options.url)?(this.params.f="geojson",this.request(function(i,s){this._trapSQLerrors(i),t.call(e,i,s,s)},this)):this.request(function(i,s){this._trapSQLerrors(i),t.call(e,i,s&&$.responseToFeatureCollection(s),s)},this)},count:function(t,e){return this._cleanParams(),this.params.returnCountOnly=!0,this.request(function(e,i){t.call(this,e,i&&i.count,i)},e)},ids:function(t,e){return this._cleanParams(),this.params.returnIdsOnly=!0,this.request(function(e,i){t.call(this,e,i&&i.objectIds,i)},e)},bounds:function(t,e){return this._cleanParams(),this.params.returnExtentOnly=!0,this.request(function(i,s){t.call(e,i,s&&s.extent&&$.extentToBounds(s.extent),s)},e)},pixelSize:function(t){return t=e.point(t),this.params.pixelSize=[t.x,t.y],this},layer:function(t){return this.path=t+"/query",this},_trapSQLerrors:function(t){t&&"400"===t.code&&$.warn("one common syntax error in query requests is encasing string values in double quotes instead of single quotes")},_cleanParams:function(){delete this.params.returnIdsOnly,delete this.params.returnExtentOnly,delete this.params.returnCountOnly},_setGeometry:function(t){return this.params.inSr=4326,t instanceof e.LatLngBounds?(this.params.geometry=$.boundsToExtent(t),void(this.params.geometryType="esriGeometryEnvelope")):(t.getLatLng&&(t=t.getLatLng()),t instanceof e.LatLng&&(t={type:"Point",coordinates:[t.lng,t.lat]}),t instanceof e.GeoJSON&&(t=t.getLayers()[0].feature.geometry,this.params.geometry=$.geojsonToArcGIS(t),this.params.geometryType=$.geojsonTypeToArcGIS(t.type)),t.toGeoJSON&&(t=t.toGeoJSON()),"Feature"===t.type&&(t=t.geometry),"Point"===t.type||"LineString"===t.type||"Polygon"===t.type?(this.params.geometry=$.geojsonToArcGIS(t),void(this.params.geometryType=$.geojsonTypeToArcGIS(t.type))):void $.warn("invalid geometry passed to spatial query. Should be an L.LatLng, L.LatLngBounds or L.Marker or a GeoJSON Point Line or Polygon object"))}}),ot=it.extend({setters:{contains:"contains",text:"searchText",fields:"searchFields",spatialReference:"sr",sr:"sr",layers:"layers",returnGeometry:"returnGeometry",maxAllowableOffset:"maxAllowableOffset",precision:"geometryPrecision",dynamicLayers:"dynamicLayers",returnZ:"returnZ",returnM:"returnM",gdbVersion:"gdbVersion",token:"token"},path:"find",params:{sr:4326,contains:!0,returnGeometry:!0,returnZ:!0,returnM:!1},layerDefs:function(t,e){return this.params.layerDefs=this.params.layerDefs?this.params.layerDefs+";":"",this.params.layerDefs+=[t,e].join(":"),this},simplify:function(t,e){var i=Math.abs(t.getBounds().getWest()-t.getBounds().getEast());return this.params.maxAllowableOffset=i/t.getSize().y*e,this},run:function(t,e){return this.request(function(i,s){t.call(e,i,s&&$.responseToFeatureCollection(s),s)},e)}}),rt=it.extend({path:"identify",between:function(t,e){return this.params.time=[t.valueOf(),e.valueOf()],this}}),nt=rt.extend({setters:{layers:"layers",precision:"geometryPrecision",tolerance:"tolerance",returnGeometry:"returnGeometry"},params:{sr:4326,layers:"all",tolerance:3,returnGeometry:!0},on:function(t){var e=$.boundsToExtent(t.getBounds()),i=t.getSize();return this.params.imageDisplay=[i.x,i.y,96],this.params.mapExtent=[e.xmin,e.ymin,e.xmax,e.ymax],this},at:function(t){return t=e.latLng(t),this.params.geometry=[t.lng,t.lat],this.params.geometryType="esriGeometryPoint",this},layerDef:function(t,e){return this.params.layerDefs=this.params.layerDefs?this.params.layerDefs+";":"",this.params.layerDefs+=[t,e].join(":"),this},simplify:function(t,e){var i=Math.abs(t.getBounds().getWest()-t.getBounds().getEast());return this.params.maxAllowableOffset=i/t.getSize().y*(1-e),this},run:function(t,e){return this.request(function(i,s){if(i)return void t.call(e,i,void 0,s);var o=$.responseToFeatureCollection(s);s.results=s.results.reverse();for(var r=0;r=0;r--)o.catalogItems.features[r].properties.catalogItemVisibility=s[r];return o}}),lt=e.Evented.extend({options:{proxy:!1,useCors:K,timeout:0},initialize:function(t){t=t||{},this._requestQueue=[],this._authenticating=!1,e.Util.setOptions(this,t),this.options.url=L(this.options.url)},get:function(t,e,i,s){return this._request("get",t,e,i,s)},post:function(t,e,i,s){return this._request("post",t,e,i,s)},request:function(t,e,i,s){return this._request("request",t,e,i,s)},metadata:function(t,e){return this._request("get","",{},t,e)},authenticate:function(t){return this._authenticating=!1,this.options.token=t,this._runQueue(),this},getTimeout:function(){return this.options.timeout},setTimeout:function(t){this.options.timeout=t},_request:function(t,e,i,s,o){this.fire("requeststart",{url:this.options.url+e,params:i,method:t},!0);var r=this._createServiceCallback(t,e,i,s,o);if(this.options.token&&(i.token=this.options.token),this._authenticating)return void this._requestQueue.push([t,e,i,s,o]);var n=this.options.proxy?this.options.proxy+"?"+this.options.url+e:this.options.url+e;return"get"!==t&&"request"!==t||this.options.useCors?et[t](n,i,r,o):et.get.JSONP(n,i,r,o)},_createServiceCallback:function(t,i,s,o,r){return e.Util.bind(function(n,a){!n||499!==n.code&&498!==n.code||(this._authenticating=!0,this._requestQueue.push([t,i,s,o,r]),this.fire("authenticationrequired",{authenticate:e.Util.bind(this.authenticate,this)},!0),n.authenticate=e.Util.bind(this.authenticate,this)),o.call(r,n,a),n?this.fire("requesterror",{url:this.options.url+i,params:s,message:n.message,code:n.code,method:t},!0):this.fire("requestsuccess",{url:this.options.url+i,params:s,response:a,method:t},!0),this.fire("requestend",{url:this.options.url+i,params:s,method:t},!0)},this)},_runQueue:function(){for(var t=this._requestQueue.length-1;t>=0;t--){var e=this._requestQueue[t],i=e.shift();this[i].apply(this,e)}this._requestQueue=[]}}),ut=lt.extend({identify:function(){return E(this)},find:function(){return M(this)},query:function(){return k(this)}}),ht=lt.extend({query:function(){return k(this)},identify:function(){return q(this)}}),ct=lt.extend({options:{idAttribute:"OBJECTID"},query:function(){return k(this)},addFeature:function(t,e,i){return delete t.id,t=f(t),this.post("addFeatures",{features:[t]},function(t,s){var o=s&&s.addResults?s.addResults[0]:void 0;e&&e.call(i,t||s.addResults[0].error,o)},i)},updateFeature:function(t,e,i){return t=f(t,this.options.idAttribute),this.post("updateFeatures",{features:[t]},function(t,s){var o=s&&s.updateResults?s.updateResults[0]:void 0;e&&e.call(i,t||s.updateResults[0].error,o)},i)},deleteFeature:function(t,e,i){return this.post("deleteFeatures",{objectIds:t},function(t,s){var o=s&&s.deleteResults?s.deleteResults[0]:void 0;e&&e.call(i,t||s.deleteResults[0].error,o)},i)},deleteFeatures:function(t,e,i){return this.post("deleteFeatures",{objectIds:t},function(t,s){var o=s&&s.deleteResults?s.deleteResults:void 0;e&&e.call(i,t||s.deleteResults[0].error,o)},i)}}),pt=e.Control.extend({options:{position:"bottomright",marginTop:0,marginLeft:0,marginBottom:0,marginRight:0},onAdd:function(){var t=e.DomUtil.create("div","esri-leaflet-logo");return t.style.marginTop=this.options.marginTop,t.style.marginLeft=this.options.marginLeft,t.style.marginBottom=this.options.marginBottom,t.style.marginRight=this.options.marginRight,t.innerHTML='Powered by Esri',t}}),dt="https:"!==window.location.protocol?"http:":"https:",mt=e.TileLayer.extend({statics:{TILES:{Streets:{urlTemplate:dt+"//{s}.arcgisonline.com/ArcGIS/rest/services/World_Street_Map/MapServer/tile/{z}/{y}/{x}",attributionUrl:"https://static.arcgis.com/attribution/World_Street_Map",options:{hideLogo:!1,logoPosition:"bottomright",minZoom:1,maxZoom:19,subdomains:["server","services"],attribution:"Esri"}},Topographic:{urlTemplate:dt+"//{s}.arcgisonline.com/ArcGIS/rest/services/World_Topo_Map/MapServer/tile/{z}/{y}/{x}",attributionUrl:"https://static.arcgis.com/attribution/World_Topo_Map",options:{hideLogo:!1,logoPosition:"bottomright",minZoom:1,maxZoom:19,subdomains:["server","services"],attribution:"Esri"}},Oceans:{urlTemplate:dt+"//{s}.arcgisonline.com/arcgis/rest/services/Ocean/World_Ocean_Base/MapServer/tile/{z}/{y}/{x}",attributionUrl:"https://static.arcgis.com/attribution/Ocean_Basemap",options:{hideLogo:!1,logoPosition:"bottomright",minZoom:1,maxZoom:16,subdomains:["server","services"],attribution:"Esri"}},OceansLabels:{urlTemplate:dt+"//{s}.arcgisonline.com/arcgis/rest/services/Ocean/World_Ocean_Reference/MapServer/tile/{z}/{y}/{x}",options:{hideLogo:!0,logoPosition:"bottomright",minZoom:1,maxZoom:16,subdomains:["server","services"],pane:V?"esri-labels":"tilePane"}},NationalGeographic:{urlTemplate:dt+"//{s}.arcgisonline.com/ArcGIS/rest/services/NatGeo_World_Map/MapServer/tile/{z}/{y}/{x}",options:{hideLogo:!1,logoPosition:"bottomright",minZoom:1,maxZoom:16,subdomains:["server","services"],attribution:"National Geographic, Esri, DeLorme, HERE, UNEP-WCMC, USGS, NASA, ESA, METI, NRCAN, GEBCO, NOAA, increment P Corp."}},DarkGray:{urlTemplate:dt+"//{s}.arcgisonline.com/ArcGIS/rest/services/Canvas/World_Dark_Gray_Base/MapServer/tile/{z}/{y}/{x}",options:{hideLogo:!1,logoPosition:"bottomright",minZoom:1,maxZoom:16,subdomains:["server","services"],attribution:"Esri, HERE, DeLorme, MapmyIndia, © OpenStreetMap contributors"}},DarkGrayLabels:{urlTemplate:dt+"//{s}.arcgisonline.com/ArcGIS/rest/services/Canvas/World_Dark_Gray_Reference/MapServer/tile/{z}/{y}/{x}",options:{hideLogo:!0,logoPosition:"bottomright",minZoom:1,maxZoom:16,subdomains:["server","services"],pane:V?"esri-labels":"tilePane"}},Gray:{urlTemplate:dt+"//{s}.arcgisonline.com/ArcGIS/rest/services/Canvas/World_Light_Gray_Base/MapServer/tile/{z}/{y}/{x}",options:{hideLogo:!1,logoPosition:"bottomright",minZoom:1,maxZoom:16,subdomains:["server","services"],attribution:"Esri, HERE, DeLorme, MapmyIndia, © OpenStreetMap contributors"}},GrayLabels:{urlTemplate:dt+"//{s}.arcgisonline.com/ArcGIS/rest/services/Canvas/World_Light_Gray_Reference/MapServer/tile/{z}/{y}/{x}",options:{hideLogo:!0,logoPosition:"bottomright",minZoom:1,maxZoom:16,subdomains:["server","services"],pane:V?"esri-labels":"tilePane"}},Imagery:{urlTemplate:dt+"//{s}.arcgisonline.com/ArcGIS/rest/services/World_Imagery/MapServer/tile/{z}/{y}/{x}",options:{hideLogo:!1,logoPosition:"bottomright",minZoom:1,maxZoom:19,subdomains:["server","services"],attribution:"Esri, DigitalGlobe, GeoEye, i-cubed, USDA, USGS, AEX, Getmapping, Aerogrid, IGN, IGP, swisstopo, and the GIS User Community"}},ImageryLabels:{urlTemplate:dt+"//{s}.arcgisonline.com/ArcGIS/rest/services/Reference/World_Boundaries_and_Places/MapServer/tile/{z}/{y}/{x}",options:{hideLogo:!0,logoPosition:"bottomright",minZoom:1,maxZoom:19,subdomains:["server","services"],pane:V?"esri-labels":"tilePane"}},ImageryTransportation:{urlTemplate:dt+"//{s}.arcgisonline.com/ArcGIS/rest/services/Reference/World_Transportation/MapServer/tile/{z}/{y}/{x}",options:{hideLogo:!0,logoPosition:"bottomright",minZoom:1,maxZoom:19,subdomains:["server","services"],pane:V?"esri-labels":"tilePane"}},ShadedRelief:{urlTemplate:dt+"//{s}.arcgisonline.com/ArcGIS/rest/services/World_Shaded_Relief/MapServer/tile/{z}/{y}/{x}",options:{hideLogo:!1,logoPosition:"bottomright",minZoom:1,maxZoom:13,subdomains:["server","services"],attribution:"Esri, USGS"}},ShadedReliefLabels:{urlTemplate:dt+"//{s}.arcgisonline.com/ArcGIS/rest/services/Reference/World_Boundaries_and_Places_Alternate/MapServer/tile/{z}/{y}/{x}",options:{hideLogo:!0,logoPosition:"bottomright",minZoom:1,maxZoom:12,subdomains:["server","services"],pane:V?"esri-labels":"tilePane"}},Terrain:{urlTemplate:dt+"//{s}.arcgisonline.com/ArcGIS/rest/services/World_Terrain_Base/MapServer/tile/{z}/{y}/{x}",options:{hideLogo:!1,logoPosition:"bottomright",minZoom:1,maxZoom:13,subdomains:["server","services"],attribution:"Esri, USGS, NOAA"}},TerrainLabels:{urlTemplate:dt+"//{s}.arcgisonline.com/ArcGIS/rest/services/Reference/World_Reference_Overlay/MapServer/tile/{z}/{y}/{x}",options:{hideLogo:!0,logoPosition:"bottomright",minZoom:1,maxZoom:13,subdomains:["server","services"],pane:V?"esri-labels":"tilePane"}},USATopo:{urlTemplate:dt+"//{s}.arcgisonline.com/ArcGIS/rest/services/USA_Topo_Maps/MapServer/tile/{z}/{y}/{x}",options:{hideLogo:!1,logoPosition:"bottomright",minZoom:1,maxZoom:15,subdomains:["server","services"],attribution:"National Geographic Society, i-cubed"}}}},initialize:function(t,i){var s;if("object"==typeof t&&t.urlTemplate&&t.options)s=t;else{if("string"!=typeof t||!mt.TILES[t])throw new Error('L.esri.BasemapLayer: Invalid parameter. Use one of "Streets", "Topographic", "Oceans", "OceansLabels", "NationalGeographic", "Gray", "GrayLabels", "DarkGray", "DarkGrayLabels", "Imagery", "ImageryLabels", "ImageryTransportation", "ShadedRelief", "ShadedReliefLabels", "Terrain" or "TerrainLabels"');s=mt.TILES[t]}var o=e.Util.extend(s.options,i);e.Util.setOptions(this,o),e.TileLayer.prototype.initialize.call(this,s.urlTemplate,o),s.attributionUrl&&this._getAttributionData(s.attributionUrl),this._logo=B({position:this.options.logoPosition})},onAdd:function(t){this.options.hideLogo||t._hasEsriLogo||(this._logo.addTo(t),t._hasEsriLogo=!0),"esri-labels"===this.options.pane&&this._initPane(),t.on("moveend",this._updateMapAttribution,this),e.TileLayer.prototype.onAdd.call(this,t)},onRemove:function(t){this._logo&&this._logo._container&&(t.removeControl(this._logo),t._hasEsriLogo=!1),t.off("moveend",this._updateMapAttribution,this),e.TileLayer.prototype.onRemove.call(this,t)},getAttribution:function(){if(this.options.attribution)var t=''+this.options.attribution+"";return t},_initPane:function(){if(!this._map.getPane(this.options.pane)){var t=this._map.createPane(this.options.pane);t.style.pointerEvents="none",t.style.zIndex=500}},_getAttributionData:function(t){O(t,{},e.Util.bind(function(t,i){if(!t){this._attributions=[];for(var s=0;s=o.minZoom&&i<=o.maxZoom&&(t+=", "+r)}t=t.substr(2);var n=this._map.attributionControl._container.querySelector(".esri-attributions");n.innerHTML=t,n.style.maxWidth=.65*this._map.getSize().x+"px",this.fire("attributionupdated",{attribution:t})}}}),ft=e.TileLayer.extend({options:{zoomOffsetAllowance:.1},statics:{MercatorZoomLevels:{0:156543.033928,1:78271.5169639999,2:39135.7584820001,3:19567.8792409999,4:9783.93962049996,5:4891.96981024998,6:2445.98490512499,7:1222.99245256249,8:611.49622628138,9:305.748113140558,10:152.874056570411,11:76.4370282850732,12:38.2185141425366,13:19.1092570712683,14:9.55462853563415,15:4.77731426794937,16:2.38865713397468,17:1.19432856685505,18:.597164283559817,19:.298582141647617,20:.14929107082381,21:.07464553541191,22:.0373227677059525,23:.0186613838529763}},initialize:function(t){t.url=L(t.url),t=e.Util.setOptions(this,t),this.tileUrl=t.url+"tile/{z}/{y}/{x}",this.service=U(t),this.service.addEventParent(this);var i=new RegExp(/tiles.arcgis(online)?\.com/g);i.test(t.url)&&(this.tileUrl=this.tileUrl.replace("://tiles","://tiles{s}"),t.subdomains=["1","2","3","4"]),this.options.token&&(this.tileUrl+="?token="+this.options.token),e.TileLayer.prototype.initialize.call(this,this.tileUrl,t)},getTileUrl:function(t){return e.Util.template(this.tileUrl,e.extend({s:this._getSubdomain(t),z:this._lodMap&&this._lodMap[t.z]?this._lodMap[t.z]:t.z,x:t.x,y:t.y},this.options))},createTile:function(t,i){var s=document.createElement("img");return e.DomEvent.on(s,"load",e.bind(this._tileOnLoad,this,i,s)),e.DomEvent.on(s,"error",e.bind(this._tileOnError,this,i,s)),this.options.crossOrigin&&(s.crossOrigin=""),s.alt="",!this._lodMap||this._lodMap&&this._lodMap[t.z]?s.src=this.getTileUrl(t):this.once("lodmap",function(){s.src=this.getTileUrl(t)},this),s},onAdd:function(t){t.options.crs!==e.CRS.EPSG3857||this._lodMap||(this._lodMap={},this.metadata(function(t,e){if(!t){var i=e.spatialReference.latestWkid||e.spatialReference.wkid;if(102100===i||3857===i){for(var s=e.tileInfo.lods,o=ft.MercatorZoomLevels,r=0;rs}}),gt=e.ImageOverlay.extend({onAdd:function(t){this._topLeft=t.getPixelBounds().min,e.ImageOverlay.prototype.onAdd.call(this,t)},_reset:function(){this._map.options.crs===e.CRS.EPSG3857?e.ImageOverlay.prototype._reset.call(this):e.DomUtil.setPosition(this._image,this._topLeft.subtract(this._map.getPixelOrigin()))}}),yt=e.Layer.extend({options:{opacity:1,position:"front",f:"image",useCors:K,attribution:null,interactive:!1,alt:""},onAdd:function(t){this._update=e.Util.throttle(this._update,this.options.updateInterval,this),t.on("moveend",this._update,this),this._currentImage&&this._currentImage._bounds.equals(this._map.getBounds())?t.addLayer(this._currentImage):this._currentImage&&(this._map.removeLayer(this._currentImage),this._currentImage=null),this._update(),this._popup&&(this._map.on("click",this._getPopupData,this),this._map.on("dblclick",this._resetPopupState,this))},onRemove:function(t){this._currentImage&&this._map.removeLayer(this._currentImage),this._popup&&(this._map.off("click",this._getPopupData,this),this._map.off("dblclick",this._resetPopupState,this)),this._map.off("moveend",this._update,this)},bindPopup:function(t,i){return this._shouldRenderPopup=!1,this._lastClick=!1,this._popup=e.popup(i),this._popupFunction=t,this._map&&(this._map.on("click",this._getPopupData,this),this._map.on("dblclick",this._resetPopupState,this)),this},unbindPopup:function(){return this._map&&(this._map.closePopup(this._popup),this._map.off("click",this._getPopupData,this),this._map.off("dblclick",this._resetPopupState,this)),this._popup=!1,this},bringToFront:function(){return this.options.position="front",this._currentImage&&this._currentImage.bringToFront(),this},bringToBack:function(){return this.options.position="back",this._currentImage&&this._currentImage.bringToBack(),this},getAttribution:function(){return this.options.attribution},getOpacity:function(){return this.options.opacity},setOpacity:function(t){return this.options.opacity=t,this._currentImage.setOpacity(t),this},getTimeRange:function(){return[this.options.from,this.options.to]},setTimeRange:function(t,e){return this.options.from=t, +this.options.to=e,this._update(),this},metadata:function(t,e){return this.service.metadata(t,e),this},authenticate:function(t){return this.service.authenticate(t),this},_renderImage:function(t,e){if(this._map){var i=new gt(t,e,{opacity:0,crossOrigin:this.options.useCors,alt:this.options.alt,pane:this.options.pane||this.getPane(),interactive:this.options.interactive}).addTo(this._map);i.once("load",function(t){if(this._map){var i=t.target,s=this._currentImage;i._bounds.equals(e)&&i._bounds.equals(this._map.getBounds())?(this._currentImage=i,"front"===this.options.position?this.bringToFront():this.bringToBack(),this._map&&this._currentImage._map?this._currentImage.setOpacity(this.options.opacity):this._currentImage._map.removeLayer(this._currentImage),s&&this._map&&this._map.removeLayer(s),s&&s._map&&s._map.removeLayer(s)):this._map.removeLayer(i)}this.fire("load",{bounds:e})},this),this.fire("loading",{bounds:e})}},_update:function(){if(this._map){var t=this._map.getZoom(),e=this._map.getBounds();if(!(this._animatingZoom||this._map._panTransition&&this._map._panTransition._inProgress)){if(t>this.options.maxZoom||t0||r.y0||n.ys;s++)this._addCell(r[s])},_isValidCell:function(t){var i=this._map.options.crs;if(!i.infinite){var s=this._cellNumBounds;if(!i.wrapLng&&(t.xs.max.x)||!i.wrapLat&&(t.ys.max.y))return!1}if(!this.options.bounds)return!0;var o=this._cellCoordsToBounds(t);return e.latLngBounds(this.options.bounds).intersects(o)},_cellCoordsToBounds:function(t){var i=this._map,s=this.options.cellSize,o=t.multiplyBy(s),r=o.add([s,s]),n=i.wrapLatLng(i.unproject(o,t.z)),a=i.wrapLatLng(i.unproject(r,t.z));return e.latLngBounds(n,a)},_cellCoordsToKey:function(t){return t.x+":"+t.y},_keyToCellCoords:function(t){var i=t.split(":"),s=parseInt(i[0],10),o=parseInt(i[1],10);return e.point(s,o)},_removeOtherCells:function(t){for(var e in this._cells)t.contains(this._keyToCellCoords(e))||this._removeCell(e)},_removeCell:function(t){var e=this._activeCells[t];e&&(delete this._activeCells[t],this.cellLeave&&this.cellLeave(e.bounds,e.coords),this.fire("cellleave",{bounds:e.bounds,coords:e.coords}))},_removeCells:function(){for(var t in this._cells){var e=this._cells[t].bounds,i=this._cells[t].coords;this.cellLeave&&this.cellLeave(e,i),this.fire("cellleave",{bounds:e,coords:i})}},_addCell:function(t){this._wrapCoords(t);var e=this._cellCoordsToKey(t),i=this._cells[e];i&&!this._activeCells[e]&&(this.cellEnter&&this.cellEnter(i.bounds,t),this.fire("cellenter",{bounds:i.bounds,coords:t}),this._activeCells[e]=i),i||(i={coords:t,bounds:this._cellCoordsToBounds(t)},this._cells[e]=i,this._activeCells[e]=i,this.createCell&&this.createCell(i.bounds,t),this.fire("cellcreate",{bounds:i.bounds,coords:t}))},_wrapCoords:function(t){t.x=this._wrapLng?e.Util.wrapNum(t.x,this._wrapLng):t.x,t.y=this._wrapLat?e.Util.wrapNum(t.y,this._wrapLat):t.y},_getCellNumBounds:function(){var t=this._map.getPixelWorldBounds(),i=this._getCellSize();return t?e.bounds(t.min.divideBy(i).floor(),t.max.divideBy(i).ceil().subtract([1,1])):null}});J.prototype.query=function(t){var e=this.getIndex(t);return this.values[e]},J.prototype.getIndex=function(t){this.dirty&&this.sort();for(var e,i,s=0,o=this.values.length-1;o>=s;)if(e=(s+o)/2|0,i=this.values[Math.round(e)],+i.value<+t)s=e+1;else{if(!(+i.value>+t))return e;o=e-1}return Math.abs(~o)},J.prototype.between=function(t,e){var i=this.getIndex(t),s=this.getIndex(e);if(0===i&&0===s)return[];for(;this.values[i-1]&&this.values[i-1].value===t;)i--;for(;this.values[s+1]&&this.values[s+1].value===e;)s++;return this.values[s]&&this.values[s].value===e&&this.values[s+1]&&s++,this.values.slice(i,s)},J.prototype.insert=function(t){return this.values.splice(this.getIndex(t.value),0,t),this},J.prototype.bulkAdd=function(t,e){return this.values=this.values.concat([].concat(t||[])),e?this.sort():this.dirty=!0,this},J.prototype.sort=function(){return this.values.sort(function(t,e){return+e.value-+t.value}).reverse(),this.dirty=!1,this};var Lt=bt.extend({options:{attribution:null,where:"1=1",fields:["*"],from:!1,to:!1,timeField:!1,timeFilterMode:"server",simplifyFactor:0,precision:6},initialize:function(t){if(bt.prototype.initialize.call(this,t),t.url=L(t.url),t=e.setOptions(this,t),this.service=D(t),this.service.addEventParent(this),"*"!==this.options.fields[0]){for(var i=!1,s=0;s=0;s--){var o=t[s].id;this._currentSnapshot.push(o),this._cache[i].push(o)}this.options.timeField&&this._buildTimeIndexes(t),this.createLayers(t)},_buildQuery:function(t){var e=this.service.query().intersects(t).where(this.options.where).fields(this.options.fields).precision(this.options.precision);return this.options.simplifyFactor&&e.simplify(this._map,this.options.simplifyFactor),"server"===this.options.timeFilterMode&&this.options.from&&this.options.to&&e.between(this.options.from,this.options.to),e},setWhere:function(t,i,s){this.options.where=t&&t.length?t:"1=1";for(var o=[],r=[],n=0,a=null,l=e.Util.bind(function(t,l){if(t&&(a=t),l)for(var u=l.features.length-1;u>=0;u--)r.push(l.features[u].id);n--,0>=n&&(this._currentSnapshot=r,e.Util.requestAnimFrame(e.Util.bind(function(){this.removeLayers(o),this.addLayers(r),i&&i.call(s,a)},this)))},this),u=this._currentSnapshot.length-1;u>=0;u--)o.push(this._currentSnapshot[u]);for(var h in this._activeCells){n++;var c=this._keyToCellCoords(h),p=this._cellCoordsToBounds(c);this._requestFeatures(p,h,l)}return this},getWhere:function(){return this.options.where},getTimeRange:function(){return[this.options.from,this.options.to]},setTimeRange:function(t,i,s,o){var r=this.options.from,n=this.options.to,a=0,l=null,u=e.Util.bind(function(e){e&&(l=e),this._filterExistingFeatures(r,n,t,i),a--,s&&0>=a&&s.call(o,l)},this);if(this.options.from=t,this.options.to=i,this._filterExistingFeatures(r,n,t,i),"server"===this.options.timeFilterMode)for(var h in this._activeCells){a++;var c=this._keyToCellCoords(h),p=this._cellCoordsToBounds(c);this._requestFeatures(p,h,u)}return this},refresh:function(){for(var t in this._activeCells){var e=this._keyToCellCoords(t),i=this._cellCoordsToBounds(e);this._requestFeatures(i,t)}this.redraw&&this.once("load",function(){this.eachFeature(function(t){this._redraw(t.feature.id)},this)},this)},_filterExistingFeatures:function(t,i,s,o){var r=t&&i?this._getFeaturesInTimeRange(t,i):this._currentSnapshot,n=this._getFeaturesInTimeRange(s,o);if(n.indexOf)for(var a=0;a=0&&r.splice(l,1)}e.Util.requestAnimFrame(e.Util.bind(function(){this.removeLayers(r),this.addLayers(n)},this))},_getFeaturesInTimeRange:function(t,e){var i,s=[];if(this.options.timeField.start&&this.options.timeField.end){var o=this._startTimeIndex.between(t,e),r=this._endTimeIndex.between(t,e);i=o.concat(r)}else i=this._timeIndex.between(t,e);for(var n=i.length-1;n>=0;n--)s.push(i[n].id);return s},_buildTimeIndexes:function(t){var e,i;if(this.options.timeField.start&&this.options.timeField.end){var s=[],o=[];for(e=t.length-1;e>=0;e--)i=t[e],s.push({id:i.id,value:new Date(i.properties[this.options.timeField.start])}),o.push({id:i.id,value:new Date(i.properties[this.options.timeField.end])});this._startTimeIndex.bulkAdd(s),this._endTimeIndex.bulkAdd(o)}else{var r=[];for(e=t.length-1;e>=0;e--)i=t[e],r.push({id:i.id,value:new Date(i.properties[this.options.timeField])});this._timeIndex.bulkAdd(r)}},_featureWithinTimeRange:function(t){if(!this.options.from||!this.options.to)return!0;var e=+this.options.from.valueOf(),i=+this.options.to.valueOf();if("string"==typeof this.options.timeField){var s=+t.properties[this.options.timeField];return s>=e&&i>=s}if(this.options.timeField.start&&this.options.timeField.end){var o=+t.properties[this.options.timeField.start],r=+t.properties[this.options.timeField.end];return o>=e&&i>=o||r>=e&&i>=r}},_visibleZoom:function(){if(!this._map)return!1;var t=this._map.getZoom();return!(t>this.options.maxZoom||t0)for(var o=0;o=0;e--){var i,s=t[e],o=this._layers[s.id];this._visibleZoom()&&o&&!this._map.hasLayer(o)&&this._map.addLayer(o),o&&this.options.simplifyFactor>0&&(o.setLatLngs||o.setLatLng)&&this._updateLayer(o,s),o||(i=this.createNewLayer(s),i.feature=s,i.addEventParent(this),this.options.onEachFeature&&this.options.onEachFeature(i.feature,i),this._layers[i.feature.id]=i,this.setFeatureStyle(i.feature.id,this.options.style),this.fire("createfeature",{feature:i.feature},!0),this._visibleZoom()&&(!this.options.timeField||this.options.timeField&&this._featureWithinTimeRange(s))&&this._map.addLayer(i))}},addLayers:function(t){for(var e=t.length-1;e>=0;e--){var i=this._layers[t[e]];i&&(this.fire("addfeature",{feature:i.feature},!0),this._map.addLayer(i))}},removeLayers:function(t,e){for(var i=t.length-1;i>=0;i--){var s=t[i],o=this._layers[s];o&&(this.fire("removefeature",{feature:o.feature,permanent:e},!0),this._map.removeLayer(o)),o&&e&&delete this._layers[s]}},cellEnter:function(t,i){!this._zooming&&this._map&&e.Util.requestAnimFrame(e.Util.bind(function(){var t=this._cacheKey(i),e=this._cellCoordsToKey(i),s=this._cache[t];this._activeCells[e]&&s&&this.addLayers(s)},this))},cellLeave:function(t,i){this._zooming||e.Util.requestAnimFrame(e.Util.bind(function(){if(this._map){var t=this._cacheKey(i),e=this._cellCoordsToKey(i),s=this._cache[t],o=this._map.getBounds();if(!this._activeCells[e]&&s){for(var r=!0,n=0;n (http://patrickarlt.com)\",\n \"browser\": \"dist/esri-leaflet-debug.js\",\n \"bugs\": {\n \"url\": \"https://github.com/esri/esri-leaflet/issues\"\n },\n \"contributors\": [\n \"Patrick Arlt (http://patrickarlt.com)\",\n \"John Gravois (http://johngravois.com)\"\n ],\n \"dependencies\": {\n \"arcgis-to-geojson-utils\": \"^1.0.1\",\n \"leaflet\": \"^1.0.0-rc.1\",\n \"leaflet-virtual-grid\": \"^1.0.3\",\n \"tiny-binary-search\": \"^1.0.2\"\n },\n \"devDependencies\": {\n \"chai\": \"2.3.0\",\n \"eslint\": \"^1.10.2\",\n \"gh-release\": \"^2.0.0\",\n \"highlight.js\": \"^8.0.0\",\n \"http-server\": \"^0.8.5\",\n \"isparta\": \"^3.0.3\",\n \"istanbul\": \"^0.4.2\",\n \"karma\": \"^0.12.16\",\n \"karma-chai-sinon\": \"^0.1.3\",\n \"karma-coverage\": \"^0.5.3\",\n \"karma-mocha\": \"^0.1.0\",\n \"karma-mocha-reporter\": \"^0.2.5\",\n \"karma-phantomjs-launcher\": \"^0.2.0\",\n \"karma-sourcemap-loader\": \"^0.3.5\",\n \"load-grunt-tasks\": \"^0.4.0\",\n \"mkdirp\": \"^0.5.1\",\n \"mocha\": \"^2.3.4\",\n \"phantomjs\": \"^1.9.17\",\n \"rollup\": \"^0.25.4\",\n \"rollup-plugin-json\": \"^2.0.0\",\n \"rollup-plugin-node-resolve\": \"^1.4.0\",\n \"rollup-plugin-uglify\": \"^0.3.1\",\n \"semistandard\": \"^7.0.5\",\n \"sinon\": \"^1.11.1\",\n \"sinon-chai\": \"2.7.0\",\n \"snazzy\": \"^2.0.1\",\n \"uglify-js\": \"^2.6.1\",\n \"watch\": \"^0.17.1\"\n },\n \"homepage\": \"http://esri.github.io/esri-leaflet\",\n \"jsnext:main\": \"src/EsriLeaflet.js\",\n \"jspm\": {\n \"registry\": \"npm\",\n \"format\": \"es6\",\n \"main\": \"src/EsriLeaflet.js\"\n },\n \"keywords\": [\n \"arcgis\",\n \"esri\",\n \"esri leaflet\",\n \"gis\",\n \"leaflet plugin\",\n \"mapping\"\n ],\n \"license\": \"Apache-2.0\",\n \"main\": \"dist/esri-leaflet-debug.js\",\n \"readmeFilename\": \"README.md\",\n \"repository\": {\n \"type\": \"git\",\n \"url\": \"git@github.com:Esri/esri-leaflet.git\"\n },\n \"scripts\": {\n \"build\": \"rollup -c profiles/debug.js & rollup -c profiles/production.js\",\n \"lint\": \"semistandard src/**/*.js | snazzy\",\n \"prebuild\": \"mkdirp dist\",\n \"prepublish\": \"npm run build\",\n \"pretest\": \"npm run build\",\n \"release\": \"./scripts/release.sh\",\n \"start\": \"watch 'npm run build' src & http-server -p 5000 -c-1 -o\",\n \"test\": \"npm run lint && karma start\"\n }\n}\n","export var cors = ((window.XMLHttpRequest && 'withCredentials' in new window.XMLHttpRequest()));\nexport var pointerEvents = document.documentElement.style.pointerEvents === '';\n\nexport var Support = {\n cors: cors,\n pointerEvents: pointerEvents\n};\n\nexport default Support;\n","/*\n * Copyright 2015 Esri\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n * http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the Liscense.\n */\n\n// checks if 2 x,y points are equal\nfunction pointsEqual (a, b) {\n for (var i = 0; i < a.length; i++) {\n if (a[i] !== b[i]) {\n return false;\n }\n }\n return true;\n}\n\n// checks if the first and last points of a ring are equal and closes the ring\nfunction closeRing (coordinates) {\n if (!pointsEqual(coordinates[0], coordinates[coordinates.length - 1])) {\n coordinates.push(coordinates[0]);\n }\n return coordinates;\n}\n\n// determine if polygon ring coordinates are clockwise. clockwise signifies outer ring, counter-clockwise an inner ring\n// or hole. this logic was found at http://stackoverflow.com/questions/1165647/how-to-determine-if-a-list-of-polygon-\n// points-are-in-clockwise-order\nfunction ringIsClockwise (ringToTest) {\n var total = 0;\n var i = 0;\n var rLength = ringToTest.length;\n var pt1 = ringToTest[i];\n var pt2;\n for (i; i < rLength - 1; i++) {\n pt2 = ringToTest[i + 1];\n total += (pt2[0] - pt1[0]) * (pt2[1] + pt1[1]);\n pt1 = pt2;\n }\n return (total >= 0);\n}\n\n// ported from terraformer.js https://github.com/Esri/Terraformer/blob/master/terraformer.js#L504-L519\nfunction vertexIntersectsVertex (a1, a2, b1, b2) {\n var uaT = (b2[0] - b1[0]) * (a1[1] - b1[1]) - (b2[1] - b1[1]) * (a1[0] - b1[0]);\n var ubT = (a2[0] - a1[0]) * (a1[1] - b1[1]) - (a2[1] - a1[1]) * (a1[0] - b1[0]);\n var uB = (b2[1] - b1[1]) * (a2[0] - a1[0]) - (b2[0] - b1[0]) * (a2[1] - a1[1]);\n\n if (uB !== 0) {\n var ua = uaT / uB;\n var ub = ubT / uB;\n\n if (ua >= 0 && ua <= 1 && ub >= 0 && ub <= 1) {\n return true;\n }\n }\n\n return false;\n}\n\n// ported from terraformer.js https://github.com/Esri/Terraformer/blob/master/terraformer.js#L521-L531\nfunction arrayIntersectsArray (a, b) {\n for (var i = 0; i < a.length - 1; i++) {\n for (var j = 0; j < b.length - 1; j++) {\n if (vertexIntersectsVertex(a[i], a[i + 1], b[j], b[j + 1])) {\n return true;\n }\n }\n }\n\n return false;\n}\n\n// ported from terraformer.js https://github.com/Esri/Terraformer/blob/master/terraformer.js#L470-L480\nfunction coordinatesContainPoint (coordinates, point) {\n var contains = false;\n for (var i = -1, l = coordinates.length, j = l - 1; ++i < l; j = i) {\n if (((coordinates[i][1] <= point[1] && point[1] < coordinates[j][1]) ||\n (coordinates[j][1] <= point[1] && point[1] < coordinates[i][1])) &&\n (point[0] < (coordinates[j][0] - coordinates[i][0]) * (point[1] - coordinates[i][1]) / (coordinates[j][1] - coordinates[i][1]) + coordinates[i][0])) {\n contains = !contains;\n }\n }\n return contains;\n}\n\n// ported from terraformer-arcgis-parser.js https://github.com/Esri/terraformer-arcgis-parser/blob/master/terraformer-arcgis-parser.js#L106-L113\nfunction coordinatesContainCoordinates (outer, inner) {\n var intersects = arrayIntersectsArray(outer, inner);\n var contains = coordinatesContainPoint(outer, inner[0]);\n if (!intersects && contains) {\n return true;\n }\n return false;\n}\n\n// do any polygons in this array contain any other polygons in this array?\n// used for checking for holes in arcgis rings\n// ported from terraformer-arcgis-parser.js https://github.com/Esri/terraformer-arcgis-parser/blob/master/terraformer-arcgis-parser.js#L117-L172\nfunction convertRingsToGeoJSON (rings) {\n var outerRings = [];\n var holes = [];\n var x; // iterator\n var outerRing; // current outer ring being evaluated\n var hole; // current hole being evaluated\n\n // for each ring\n for (var r = 0; r < rings.length; r++) {\n var ring = closeRing(rings[r].slice(0));\n if (ring.length < 4) {\n continue;\n }\n // is this ring an outer ring? is it clockwise?\n if (ringIsClockwise(ring)) {\n var polygon = [ ring ];\n outerRings.push(polygon); // push to outer rings\n } else {\n holes.push(ring); // counterclockwise push to holes\n }\n }\n\n var uncontainedHoles = [];\n\n // while there are holes left...\n while (holes.length) {\n // pop a hole off out stack\n hole = holes.pop();\n\n // loop over all outer rings and see if they contain our hole.\n var contained = false;\n for (x = outerRings.length - 1; x >= 0; x--) {\n outerRing = outerRings[x][0];\n if (coordinatesContainCoordinates(outerRing, hole)) {\n // the hole is contained push it into our polygon\n outerRings[x].push(hole);\n contained = true;\n break;\n }\n }\n\n // ring is not contained in any outer ring\n // sometimes this happens https://github.com/Esri/esri-leaflet/issues/320\n if (!contained) {\n uncontainedHoles.push(hole);\n }\n }\n\n // if we couldn't match any holes using contains we can try intersects...\n while (uncontainedHoles.length) {\n // pop a hole off out stack\n hole = uncontainedHoles.pop();\n\n // loop over all outer rings and see if any intersect our hole.\n var intersects = false;\n\n for (x = outerRings.length - 1; x >= 0; x--) {\n outerRing = outerRings[x][0];\n if (arrayIntersectsArray(outerRing, hole)) {\n // the hole is contained push it into our polygon\n outerRings[x].push(hole);\n intersects = true;\n break;\n }\n }\n\n if (!intersects) {\n outerRings.push([hole.reverse()]);\n }\n }\n\n if (outerRings.length === 1) {\n return {\n type: 'Polygon',\n coordinates: outerRings[0]\n };\n } else {\n return {\n type: 'MultiPolygon',\n coordinates: outerRings\n };\n }\n}\n\n// This function ensures that rings are oriented in the right directions\n// outer rings are clockwise, holes are counterclockwise\n// used for converting GeoJSON Polygons to ArcGIS Polygons\nfunction orientRings (poly) {\n var output = [];\n var polygon = poly.slice(0);\n var outerRing = closeRing(polygon.shift().slice(0));\n if (outerRing.length >= 4) {\n if (!ringIsClockwise(outerRing)) {\n outerRing.reverse();\n }\n\n output.push(outerRing);\n\n for (var i = 0; i < polygon.length; i++) {\n var hole = closeRing(polygon[i].slice(0));\n if (hole.length >= 4) {\n if (ringIsClockwise(hole)) {\n hole.reverse();\n }\n output.push(hole);\n }\n }\n }\n\n return output;\n}\n\n// This function flattens holes in multipolygons to one array of polygons\n// used for converting GeoJSON Polygons to ArcGIS Polygons\nfunction flattenMultiPolygonRings (rings) {\n var output = [];\n for (var i = 0; i < rings.length; i++) {\n var polygon = orientRings(rings[i]);\n for (var x = polygon.length - 1; x >= 0; x--) {\n var ring = polygon[x].slice(0);\n output.push(ring);\n }\n }\n return output;\n}\n\n// shallow object clone for feature properties and attributes\n// from http://jsperf.com/cloning-an-object/2\nfunction shallowClone (obj) {\n var target = {};\n for (var i in obj) {\n if (obj.hasOwnProperty(i)) {\n target[i] = obj[i];\n }\n }\n return target;\n}\n\nexport function arcgisToGeoJSON (arcgis, idAttribute) {\n var geojson = {};\n\n if (typeof arcgis.x === 'number' && typeof arcgis.y === 'number') {\n geojson.type = 'Point';\n geojson.coordinates = [arcgis.x, arcgis.y];\n }\n\n if (arcgis.points) {\n geojson.type = 'MultiPoint';\n geojson.coordinates = arcgis.points.slice(0);\n }\n\n if (arcgis.paths) {\n if (arcgis.paths.length === 1) {\n geojson.type = 'LineString';\n geojson.coordinates = arcgis.paths[0].slice(0);\n } else {\n geojson.type = 'MultiLineString';\n geojson.coordinates = arcgis.paths.slice(0);\n }\n }\n\n if (arcgis.rings) {\n geojson = convertRingsToGeoJSON(arcgis.rings.slice(0));\n }\n\n if (arcgis.geometry || arcgis.attributes) {\n geojson.type = 'Feature';\n geojson.geometry = (arcgis.geometry) ? arcgisToGeoJSON(arcgis.geometry) : null;\n geojson.properties = (arcgis.attributes) ? shallowClone(arcgis.attributes) : null;\n if (arcgis.attributes) {\n geojson.id = arcgis.attributes[idAttribute] || arcgis.attributes.OBJECTID || arcgis.attributes.FID;\n }\n }\n\n return geojson;\n}\n\nexport function geojsonToArcGIS (geojson, idAttribute) {\n idAttribute = idAttribute || 'OBJECTID';\n var spatialReference = { wkid: 4326 };\n var result = {};\n var i;\n\n switch (geojson.type) {\n case 'Point':\n result.x = geojson.coordinates[0];\n result.y = geojson.coordinates[1];\n result.spatialReference = spatialReference;\n break;\n case 'MultiPoint':\n result.points = geojson.coordinates.slice(0);\n result.spatialReference = spatialReference;\n break;\n case 'LineString':\n result.paths = [geojson.coordinates.slice(0)];\n result.spatialReference = spatialReference;\n break;\n case 'MultiLineString':\n result.paths = geojson.coordinates.slice(0);\n result.spatialReference = spatialReference;\n break;\n case 'Polygon':\n result.rings = orientRings(geojson.coordinates.slice(0));\n result.spatialReference = spatialReference;\n break;\n case 'MultiPolygon':\n result.rings = flattenMultiPolygonRings(geojson.coordinates.slice(0));\n result.spatialReference = spatialReference;\n break;\n case 'Feature':\n if (geojson.geometry) {\n result.geometry = geojsonToArcGIS(geojson.geometry, idAttribute);\n }\n result.attributes = (geojson.properties) ? shallowClone(geojson.properties) : {};\n if (geojson.id) {\n result.attributes[idAttribute] = geojson.id;\n }\n break;\n case 'FeatureCollection':\n result = [];\n for (i = 0; i < geojson.features.length; i++) {\n result.push(geojsonToArcGIS(geojson.features[i], idAttribute));\n }\n break;\n case 'GeometryCollection':\n result = [];\n for (i = 0; i < geojson.geometries.length; i++) {\n result.push(geojsonToArcGIS(geojson.geometries[i], idAttribute));\n }\n break;\n }\n\n return result;\n}\n","import L from 'leaflet';\nimport {\n geojsonToArcGIS as g2a,\n arcgisToGeoJSON as a2g\n} from 'arcgis-to-geojson-utils';\n\nexport function geojsonToArcGIS (geojson, idAttr) {\n return g2a(geojson, idAttr);\n}\n\nexport function arcgisToGeoJSON (arcgis, idAttr) {\n return a2g(arcgis, idAttr);\n}\n\n// shallow object clone for feature properties and attributes\n// from http://jsperf.com/cloning-an-object/2\nexport function shallowClone (obj) {\n var target = {};\n for (var i in obj) {\n if (obj.hasOwnProperty(i)) {\n target[i] = obj[i];\n }\n }\n return target;\n}\n\n// convert an extent (ArcGIS) to LatLngBounds (Leaflet)\nexport function extentToBounds (extent) {\n var sw = L.latLng(extent.ymin, extent.xmin);\n var ne = L.latLng(extent.ymax, extent.xmax);\n return L.latLngBounds(sw, ne);\n}\n\n// convert an LatLngBounds (Leaflet) to extent (ArcGIS)\nexport function boundsToExtent (bounds) {\n bounds = L.latLngBounds(bounds);\n return {\n 'xmin': bounds.getSouthWest().lng,\n 'ymin': bounds.getSouthWest().lat,\n 'xmax': bounds.getNorthEast().lng,\n 'ymax': bounds.getNorthEast().lat,\n 'spatialReference': {\n 'wkid': 4326\n }\n };\n}\n\nexport function responseToFeatureCollection (response, idAttribute) {\n var objectIdField;\n\n if (idAttribute) {\n objectIdField = idAttribute;\n } else if (response.objectIdFieldName) {\n objectIdField = response.objectIdFieldName;\n } else if (response.fields) {\n for (var j = 0; j <= response.fields.length - 1; j++) {\n if (response.fields[j].type === 'esriFieldTypeOID') {\n objectIdField = response.fields[j].name;\n break;\n }\n }\n } else {\n objectIdField = 'OBJECTID';\n }\n\n var featureCollection = {\n type: 'FeatureCollection',\n features: []\n };\n var features = response.features || response.results;\n if (features.length) {\n for (var i = features.length - 1; i >= 0; i--) {\n var feature = arcgisToGeoJSON(features[i], objectIdField);\n featureCollection.features.push(feature);\n }\n }\n\n return featureCollection;\n}\n\n // trim url whitespace and add a trailing slash if needed\nexport function cleanUrl (url) {\n // trim leading and trailing spaces, but not spaces inside the url\n url = L.Util.trim(url);\n\n // add a trailing slash to the url if the user omitted it\n if (url[url.length - 1] !== '/') {\n url += '/';\n }\n\n return url;\n}\n\nexport function isArcgisOnline (url) {\n /* hosted feature services can emit geojson natively.\n our check for 'geojson' support will need to be revisted\n once the functionality makes its way to ArcGIS Server*/\n return (/\\.arcgis\\.com.*?FeatureServer/g).test(url);\n}\n\nexport function geojsonTypeToArcGIS (geoJsonType) {\n var arcgisGeometryType;\n switch (geoJsonType) {\n case 'Point':\n arcgisGeometryType = 'esriGeometryPoint';\n break;\n case 'MultiPoint':\n arcgisGeometryType = 'esriGeometryMultipoint';\n break;\n case 'LineString':\n arcgisGeometryType = 'esriGeometryPolyline';\n break;\n case 'MultiLineString':\n arcgisGeometryType = 'esriGeometryPolyline';\n break;\n case 'Polygon':\n arcgisGeometryType = 'esriGeometryPolygon';\n break;\n case 'MultiPolygon':\n arcgisGeometryType = 'esriGeometryPolygon';\n break;\n }\n\n return arcgisGeometryType;\n}\n\nexport function warn () {\n if (console && console.warn) {\n console.warn.apply(console, arguments);\n }\n}\n\nexport var Util = {\n shallowClone: shallowClone,\n warn: warn,\n cleanUrl: cleanUrl,\n isArcgisOnline: isArcgisOnline,\n geojsonTypeToArcGIS: geojsonTypeToArcGIS,\n responseToFeatureCollection: responseToFeatureCollection,\n geojsonToArcGIS: geojsonToArcGIS,\n arcgisToGeoJSON: arcgisToGeoJSON,\n boundsToExtent: boundsToExtent,\n extentToBounds: extentToBounds\n};\n\nexport default Util;\n","import L from 'leaflet';\nimport Support from './Support';\nimport { warn } from './Util';\n\nvar callbacks = 0;\n\nfunction serialize (params) {\n var data = '';\n\n params.f = params.f || 'json';\n\n for (var key in params) {\n if (params.hasOwnProperty(key)) {\n var param = params[key];\n var type = Object.prototype.toString.call(param);\n var value;\n\n if (data.length) {\n data += '&';\n }\n\n if (type === '[object Array]') {\n value = (Object.prototype.toString.call(param[0]) === '[object Object]') ? JSON.stringify(param) : param.join(',');\n } else if (type === '[object Object]') {\n value = JSON.stringify(param);\n } else if (type === '[object Date]') {\n value = param.valueOf();\n } else {\n value = param;\n }\n\n data += encodeURIComponent(key) + '=' + encodeURIComponent(value);\n }\n }\n\n return data;\n}\n\nfunction createRequest (callback, context) {\n var httpRequest = new window.XMLHttpRequest();\n\n httpRequest.onerror = function (e) {\n httpRequest.onreadystatechange = L.Util.falseFn;\n\n callback.call(context, {\n error: {\n code: 500,\n message: 'XMLHttpRequest error'\n }\n }, null);\n };\n\n httpRequest.onreadystatechange = function () {\n var response;\n var error;\n\n if (httpRequest.readyState === 4) {\n try {\n response = JSON.parse(httpRequest.responseText);\n } catch (e) {\n response = null;\n error = {\n code: 500,\n message: 'Could not parse response as JSON. This could also be caused by a CORS or XMLHttpRequest error.'\n };\n }\n\n if (!error && response.error) {\n error = response.error;\n response = null;\n }\n\n httpRequest.onerror = L.Util.falseFn;\n\n callback.call(context, error, response);\n }\n };\n\n httpRequest.ontimeout = function () {\n this.onerror();\n };\n\n return httpRequest;\n}\n\nfunction xmlHttpPost (url, params, callback, context) {\n var httpRequest = createRequest(callback, context);\n httpRequest.open('POST', url);\n\n if (typeof context !== 'undefined' && context !== null) {\n if (typeof context.options !== 'undefined') {\n httpRequest.timeout = context.options.timeout;\n }\n }\n httpRequest.setRequestHeader('Content-Type', 'application/x-www-form-urlencoded');\n httpRequest.send(serialize(params));\n\n return httpRequest;\n}\n\nfunction xmlHttpGet (url, params, callback, context) {\n var httpRequest = createRequest(callback, context);\n httpRequest.open('GET', url + '?' + serialize(params), true);\n\n if (typeof context !== 'undefined' && context !== null) {\n if (typeof context.options !== 'undefined') {\n httpRequest.timeout = context.options.timeout;\n }\n }\n httpRequest.send(null);\n\n return httpRequest;\n}\n\n// AJAX handlers for CORS (modern browsers) or JSONP (older browsers)\nexport function request (url, params, callback, context) {\n var paramString = serialize(params);\n var httpRequest = createRequest(callback, context);\n var requestLength = (url + '?' + paramString).length;\n\n // get around ie10/11 bug which requires that the request be opened before a timeout is applied\n if (requestLength <= 2000 && Support.cors) {\n httpRequest.open('GET', url + '?' + paramString);\n\n } else if (requestLength > 2000 && Support.cors) {\n httpRequest.open('POST', url);\n httpRequest.setRequestHeader('Content-Type', 'application/x-www-form-urlencoded');\n }\n\n if (typeof context !== 'undefined' && context !== null) {\n if (typeof context.options !== 'undefined') {\n httpRequest.timeout = context.options.timeout;\n }\n }\n\n // request is less then 2000 characters and the browser supports CORS, make GET request with XMLHttpRequest\n if (requestLength <= 2000 && Support.cors) {\n httpRequest.send(null);\n\n // request is less more then 2000 characters and the browser supports CORS, make POST request with XMLHttpRequest\n } else if (requestLength > 2000 && Support.cors) {\n httpRequest.send(paramString);\n\n // request is less more then 2000 characters and the browser does not support CORS, make a JSONP request\n } else if (requestLength <= 2000 && !Support.cors) {\n return jsonp(url, params, callback, context);\n\n // request is longer then 2000 characters and the browser does not support CORS, log a warning\n } else {\n warn('a request to ' + url + ' was longer then 2000 characters and this browser cannot make a cross-domain post request. Please use a proxy http://esri.github.io/esri-leaflet/api-reference/request.html');\n return;\n }\n\n return httpRequest;\n}\n\nexport function jsonp (url, params, callback, context) {\n window._EsriLeafletCallbacks = window._EsriLeafletCallbacks || {};\n var callbackId = 'c' + callbacks;\n params.callback = 'window._EsriLeafletCallbacks.' + callbackId;\n\n window._EsriLeafletCallbacks[callbackId] = function (response) {\n if (window._EsriLeafletCallbacks[callbackId] !== true) {\n var error;\n var responseType = Object.prototype.toString.call(response);\n\n if (!(responseType === '[object Object]' || responseType === '[object Array]')) {\n error = {\n error: {\n code: 500,\n message: 'Expected array or object as JSONP response'\n }\n };\n response = null;\n }\n\n if (!error && response.error) {\n error = response;\n response = null;\n }\n\n callback.call(context, error, response);\n window._EsriLeafletCallbacks[callbackId] = true;\n }\n };\n\n var script = L.DomUtil.create('script', null, document.body);\n script.type = 'text/javascript';\n script.src = url + '?' + serialize(params);\n script.id = callbackId;\n\n callbacks++;\n\n return {\n id: callbackId,\n url: script.src,\n abort: function () {\n window._EsriLeafletCallbacks._callback[callbackId]({\n code: 0,\n message: 'Request aborted.'\n });\n }\n };\n}\n\nvar get = ((Support.cors) ? xmlHttpGet : jsonp);\nget.CORS = xmlHttpGet;\nget.JSONP = jsonp;\n\n// choose the correct AJAX handler depending on CORS support\nexport { get };\n\n// always use XMLHttpRequest for posts\nexport { xmlHttpPost as post };\n\n// export the Request object to call the different handlers for debugging\nexport var Request = {\n request: request,\n get: get,\n post: xmlHttpPost\n};\n\nexport default Request;\n","import L from 'leaflet';\nimport {cors} from '../Support';\nimport {cleanUrl} from '../Util';\nimport Request from '../Request';\n\nexport var Task = L.Class.extend({\n\n options: {\n proxy: false,\n useCors: cors\n },\n\n // Generate a method for each methodName:paramName in the setters for this task.\n generateSetter: function (param, context) {\n return L.Util.bind(function (value) {\n this.params[param] = value;\n return this;\n }, context);\n },\n\n initialize: function (endpoint) {\n // endpoint can be either a url (and options) for an ArcGIS Rest Service or an instance of EsriLeaflet.Service\n if (endpoint.request && endpoint.options) {\n this._service = endpoint;\n L.Util.setOptions(this, endpoint.options);\n } else {\n L.Util.setOptions(this, endpoint);\n this.options.url = cleanUrl(endpoint.url);\n }\n\n // clone default params into this object\n this.params = L.Util.extend({}, this.params || {});\n\n // generate setter methods based on the setters object implimented a child class\n if (this.setters) {\n for (var setter in this.setters) {\n var param = this.setters[setter];\n this[setter] = this.generateSetter(param, this);\n }\n }\n },\n\n token: function (token) {\n if (this._service) {\n this._service.authenticate(token);\n } else {\n this.params.token = token;\n }\n return this;\n },\n\n request: function (callback, context) {\n if (this._service) {\n return this._service.request(this.path, this.params, callback, context);\n }\n\n return this._request('request', this.path, this.params, callback, context);\n },\n\n _request: function (method, path, params, callback, context) {\n var url = (this.options.proxy) ? this.options.proxy + '?' + this.options.url + path : this.options.url + path;\n\n if ((method === 'get' || method === 'request') && !this.options.useCors) {\n return Request.get.JSONP(url, params, callback, context);\n }\n\n return Request[method](url, params, callback, context);\n }\n});\n\nexport function task (options) {\n return new Task(options);\n}\n\nexport default task;\n","import L from 'leaflet';\nimport { Task } from './Task';\nimport Util from '../Util';\n\nexport var Query = Task.extend({\n setters: {\n 'offset': 'offset',\n 'limit': 'limit',\n 'fields': 'outFields',\n 'precision': 'geometryPrecision',\n 'featureIds': 'objectIds',\n 'returnGeometry': 'returnGeometry',\n 'token': 'token'\n },\n\n path: 'query',\n\n params: {\n returnGeometry: true,\n where: '1=1',\n outSr: 4326,\n outFields: '*'\n },\n\n within: function (geometry) {\n this._setGeometry(geometry);\n this.params.spatialRel = 'esriSpatialRelContains'; // will make code read layer within geometry, to the api this will reads geometry contains layer\n return this;\n },\n\n intersects: function (geometry) {\n this._setGeometry(geometry);\n this.params.spatialRel = 'esriSpatialRelIntersects';\n return this;\n },\n\n contains: function (geometry) {\n this._setGeometry(geometry);\n this.params.spatialRel = 'esriSpatialRelWithin'; // will make code read layer contains geometry, to the api this will reads geometry within layer\n return this;\n },\n\n crosses: function (geometry) {\n this._setGeometry(geometry);\n this.params.spatialRel = 'esriSpatialRelCrosses';\n return this;\n },\n\n touches: function (geometry) {\n this._setGeometry(geometry);\n this.params.spatialRel = 'esriSpatialRelTouches';\n return this;\n },\n\n overlaps: function (geometry) {\n this._setGeometry(geometry);\n this.params.spatialRel = 'esriSpatialRelOverlaps';\n return this;\n },\n\n // only valid for Feature Services running on ArcGIS Server 10.3 or ArcGIS Online\n nearby: function (latlng, radius) {\n latlng = L.latLng(latlng);\n this.params.geometry = [latlng.lng, latlng.lat];\n this.params.geometryType = 'esriGeometryPoint';\n this.params.spatialRel = 'esriSpatialRelIntersects';\n this.params.units = 'esriSRUnit_Meter';\n this.params.distance = radius;\n this.params.inSr = 4326;\n return this;\n },\n\n where: function (string) {\n // instead of converting double-quotes to single quotes, pass as is, and provide a more informative message if a 400 is encountered\n this.params.where = string;\n return this;\n },\n\n between: function (start, end) {\n this.params.time = [start.valueOf(), end.valueOf()];\n return this;\n },\n\n simplify: function (map, factor) {\n var mapWidth = Math.abs(map.getBounds().getWest() - map.getBounds().getEast());\n this.params.maxAllowableOffset = (mapWidth / map.getSize().y) * factor;\n return this;\n },\n\n orderBy: function (fieldName, order) {\n order = order || 'ASC';\n this.params.orderByFields = (this.params.orderByFields) ? this.params.orderByFields + ',' : '';\n this.params.orderByFields += ([fieldName, order]).join(' ');\n return this;\n },\n\n run: function (callback, context) {\n this._cleanParams();\n\n // if the service is hosted on arcgis online request geojson directly\n if (Util.isArcgisOnline(this.options.url)) {\n this.params.f = 'geojson';\n\n return this.request(function (error, response) {\n this._trapSQLerrors(error);\n callback.call(context, error, response, response);\n }, this);\n\n // otherwise convert it in the callback then pass it on\n } else {\n return this.request(function (error, response) {\n this._trapSQLerrors(error);\n callback.call(context, error, (response && Util.responseToFeatureCollection(response)), response);\n }, this);\n }\n },\n\n count: function (callback, context) {\n this._cleanParams();\n this.params.returnCountOnly = true;\n return this.request(function (error, response) {\n callback.call(this, error, (response && response.count), response);\n }, context);\n },\n\n ids: function (callback, context) {\n this._cleanParams();\n this.params.returnIdsOnly = true;\n return this.request(function (error, response) {\n callback.call(this, error, (response && response.objectIds), response);\n }, context);\n },\n\n // only valid for Feature Services running on ArcGIS Server 10.3 or ArcGIS Online\n bounds: function (callback, context) {\n this._cleanParams();\n this.params.returnExtentOnly = true;\n return this.request(function (error, response) {\n callback.call(context, error, (response && response.extent && Util.extentToBounds(response.extent)), response);\n }, context);\n },\n\n // only valid for image services\n pixelSize: function (point) {\n point = L.point(point);\n this.params.pixelSize = [point.x, point.y];\n return this;\n },\n\n // only valid for map services\n layer: function (layer) {\n this.path = layer + '/query';\n return this;\n },\n\n _trapSQLerrors: function (error) {\n if (error) {\n if (error.code === '400') {\n Util.warn('one common syntax error in query requests is encasing string values in double quotes instead of single quotes');\n }\n }\n },\n\n _cleanParams: function () {\n delete this.params.returnIdsOnly;\n delete this.params.returnExtentOnly;\n delete this.params.returnCountOnly;\n },\n\n _setGeometry: function (geometry) {\n this.params.inSr = 4326;\n\n // convert bounds to extent and finish\n if (geometry instanceof L.LatLngBounds) {\n // set geometry + geometryType\n this.params.geometry = Util.boundsToExtent(geometry);\n this.params.geometryType = 'esriGeometryEnvelope';\n return;\n }\n\n // convert L.Marker > L.LatLng\n if (geometry.getLatLng) {\n geometry = geometry.getLatLng();\n }\n\n // convert L.LatLng to a geojson point and continue;\n if (geometry instanceof L.LatLng) {\n geometry = {\n type: 'Point',\n coordinates: [geometry.lng, geometry.lat]\n };\n }\n\n // handle L.GeoJSON, pull out the first geometry\n if (geometry instanceof L.GeoJSON) {\n // reassign geometry to the GeoJSON value (we are assuming that only one feature is present)\n geometry = geometry.getLayers()[0].feature.geometry;\n this.params.geometry = Util.geojsonToArcGIS(geometry);\n this.params.geometryType = Util.geojsonTypeToArcGIS(geometry.type);\n }\n\n // Handle L.Polyline and L.Polygon\n if (geometry.toGeoJSON) {\n geometry = geometry.toGeoJSON();\n }\n\n // handle GeoJSON feature by pulling out the geometry\n if (geometry.type === 'Feature') {\n // get the geometry of the geojson feature\n geometry = geometry.geometry;\n }\n\n // confirm that our GeoJSON is a point, line or polygon\n if (geometry.type === 'Point' || geometry.type === 'LineString' || geometry.type === 'Polygon') {\n this.params.geometry = Util.geojsonToArcGIS(geometry);\n this.params.geometryType = Util.geojsonTypeToArcGIS(geometry.type);\n return;\n }\n\n // warn the user if we havn't found a\n /* global console */\n Util.warn('invalid geometry passed to spatial query. Should be an L.LatLng, L.LatLngBounds or L.Marker or a GeoJSON Point Line or Polygon object');\n\n return;\n }\n});\n\nexport function query (options) {\n return new Query(options);\n}\n\nexport default query;\n","import { Task } from './Task';\nimport Util from '../Util';\n\nexport var Find = Task.extend({\n setters: {\n // method name > param name\n 'contains': 'contains',\n 'text': 'searchText',\n 'fields': 'searchFields', // denote an array or single string\n 'spatialReference': 'sr',\n 'sr': 'sr',\n 'layers': 'layers',\n 'returnGeometry': 'returnGeometry',\n 'maxAllowableOffset': 'maxAllowableOffset',\n 'precision': 'geometryPrecision',\n 'dynamicLayers': 'dynamicLayers',\n 'returnZ': 'returnZ',\n 'returnM': 'returnM',\n 'gdbVersion': 'gdbVersion',\n 'token': 'token'\n },\n\n path: 'find',\n\n params: {\n sr: 4326,\n contains: true,\n returnGeometry: true,\n returnZ: true,\n returnM: false\n },\n\n layerDefs: function (id, where) {\n this.params.layerDefs = (this.params.layerDefs) ? this.params.layerDefs + ';' : '';\n this.params.layerDefs += ([id, where]).join(':');\n return this;\n },\n\n simplify: function (map, factor) {\n var mapWidth = Math.abs(map.getBounds().getWest() - map.getBounds().getEast());\n this.params.maxAllowableOffset = (mapWidth / map.getSize().y) * factor;\n return this;\n },\n\n run: function (callback, context) {\n return this.request(function (error, response) {\n callback.call(context, error, (response && Util.responseToFeatureCollection(response)), response);\n }, context);\n }\n});\n\nexport function find (options) {\n return new Find(options);\n}\n\nexport default find;\n","import { Task } from './Task';\n\nexport var Identify = Task.extend({\n path: 'identify',\n\n between: function (start, end) {\n this.params.time = [start.valueOf(), end.valueOf()];\n return this;\n }\n});\n\nexport function identify (options) {\n return new Identify(options);\n}\n\nexport default identify;\n","import L from 'leaflet';\nimport { Identify } from './Identify';\nimport Util from '../Util';\n\nexport var IdentifyFeatures = Identify.extend({\n setters: {\n 'layers': 'layers',\n 'precision': 'geometryPrecision',\n 'tolerance': 'tolerance',\n 'returnGeometry': 'returnGeometry'\n },\n\n params: {\n sr: 4326,\n layers: 'all',\n tolerance: 3,\n returnGeometry: true\n },\n\n on: function (map) {\n var extent = Util.boundsToExtent(map.getBounds());\n var size = map.getSize();\n this.params.imageDisplay = [size.x, size.y, 96];\n this.params.mapExtent = [extent.xmin, extent.ymin, extent.xmax, extent.ymax];\n return this;\n },\n\n at: function (latlng) {\n latlng = L.latLng(latlng);\n this.params.geometry = [latlng.lng, latlng.lat];\n this.params.geometryType = 'esriGeometryPoint';\n return this;\n },\n\n layerDef: function (id, where) {\n this.params.layerDefs = (this.params.layerDefs) ? this.params.layerDefs + ';' : '';\n this.params.layerDefs += ([id, where]).join(':');\n return this;\n },\n\n simplify: function (map, factor) {\n var mapWidth = Math.abs(map.getBounds().getWest() - map.getBounds().getEast());\n this.params.maxAllowableOffset = (mapWidth / map.getSize().y) * (1 - factor);\n return this;\n },\n\n run: function (callback, context) {\n return this.request(function (error, response) {\n // immediately invoke with an error\n if (error) {\n callback.call(context, error, undefined, response);\n return;\n\n // ok no error lets just assume we have features...\n } else {\n var featureCollection = Util.responseToFeatureCollection(response);\n response.results = response.results.reverse();\n for (var i = 0; i < featureCollection.features.length; i++) {\n var feature = featureCollection.features[i];\n feature.layerId = response.results[i].layerId;\n }\n callback.call(context, undefined, featureCollection, response);\n }\n });\n }\n});\n\nexport function identifyFeatures (options) {\n return new IdentifyFeatures(options);\n}\n\nexport default identifyFeatures;\n","import L from 'leaflet';\nimport { Identify } from './Identify';\nimport Util from '../Util';\n\nexport var IdentifyImage = Identify.extend({\n setters: {\n 'setMosaicRule': 'mosaicRule',\n 'setRenderingRule': 'renderingRule',\n 'setPixelSize': 'pixelSize',\n 'returnCatalogItems': 'returnCatalogItems',\n 'returnGeometry': 'returnGeometry'\n },\n\n params: {\n returnGeometry: false\n },\n\n at: function (latlng) {\n latlng = L.latLng(latlng);\n this.params.geometry = JSON.stringify({\n x: latlng.lng,\n y: latlng.lat,\n spatialReference: {\n wkid: 4326\n }\n });\n this.params.geometryType = 'esriGeometryPoint';\n return this;\n },\n\n getMosaicRule: function () {\n return this.params.mosaicRule;\n },\n\n getRenderingRule: function () {\n return this.params.renderingRule;\n },\n\n getPixelSize: function () {\n return this.params.pixelSize;\n },\n\n run: function (callback, context) {\n return this.request(function (error, response) {\n callback.call(context, error, (response && this._responseToGeoJSON(response)), response);\n }, this);\n },\n\n // get pixel data and return as geoJSON point\n // populate catalog items (if any)\n // merging in any catalogItemVisibilities as a propery of each feature\n _responseToGeoJSON: function (response) {\n var location = response.location;\n var catalogItems = response.catalogItems;\n var catalogItemVisibilities = response.catalogItemVisibilities;\n var geoJSON = {\n 'pixel': {\n 'type': 'Feature',\n 'geometry': {\n 'type': 'Point',\n 'coordinates': [location.x, location.y]\n },\n 'crs': {\n 'type': 'EPSG',\n 'properties': {\n 'code': location.spatialReference.wkid\n }\n },\n 'properties': {\n 'OBJECTID': response.objectId,\n 'name': response.name,\n 'value': response.value\n },\n 'id': response.objectId\n }\n };\n\n if (response.properties && response.properties.Values) {\n geoJSON.pixel.properties.values = response.properties.Values;\n }\n\n if (catalogItems && catalogItems.features) {\n geoJSON.catalogItems = Util.responseToFeatureCollection(catalogItems);\n if (catalogItemVisibilities && catalogItemVisibilities.length === geoJSON.catalogItems.features.length) {\n for (var i = catalogItemVisibilities.length - 1; i >= 0; i--) {\n geoJSON.catalogItems.features[i].properties.catalogItemVisibility = catalogItemVisibilities[i];\n }\n }\n }\n return geoJSON;\n }\n\n});\n\nexport function identifyImage (params) {\n return new IdentifyImage(params);\n}\n\nexport default identifyImage;\n","import L from 'leaflet';\nimport {cors} from '../Support';\nimport {cleanUrl} from '../Util';\nimport Request from '../Request';\n\nexport var Service = L.Evented.extend({\n\n options: {\n proxy: false,\n useCors: cors,\n timeout: 0\n },\n\n initialize: function (options) {\n options = options || {};\n this._requestQueue = [];\n this._authenticating = false;\n L.Util.setOptions(this, options);\n this.options.url = cleanUrl(this.options.url);\n },\n\n get: function (path, params, callback, context) {\n return this._request('get', path, params, callback, context);\n },\n\n post: function (path, params, callback, context) {\n return this._request('post', path, params, callback, context);\n },\n\n request: function (path, params, callback, context) {\n return this._request('request', path, params, callback, context);\n },\n\n metadata: function (callback, context) {\n return this._request('get', '', {}, callback, context);\n },\n\n authenticate: function (token) {\n this._authenticating = false;\n this.options.token = token;\n this._runQueue();\n return this;\n },\n\n getTimeout: function () {\n return this.options.timeout;\n },\n\n setTimeout: function (timeout) {\n this.options.timeout = timeout;\n },\n\n _request: function (method, path, params, callback, context) {\n this.fire('requeststart', {\n url: this.options.url + path,\n params: params,\n method: method\n }, true);\n\n var wrappedCallback = this._createServiceCallback(method, path, params, callback, context);\n\n if (this.options.token) {\n params.token = this.options.token;\n }\n\n if (this._authenticating) {\n this._requestQueue.push([method, path, params, callback, context]);\n return;\n } else {\n var url = (this.options.proxy) ? this.options.proxy + '?' + this.options.url + path : this.options.url + path;\n\n if ((method === 'get' || method === 'request') && !this.options.useCors) {\n return Request.get.JSONP(url, params, wrappedCallback, context);\n } else {\n return Request[method](url, params, wrappedCallback, context);\n }\n }\n },\n\n _createServiceCallback: function (method, path, params, callback, context) {\n return L.Util.bind(function (error, response) {\n if (error && (error.code === 499 || error.code === 498)) {\n this._authenticating = true;\n\n this._requestQueue.push([method, path, params, callback, context]);\n\n // fire an event for users to handle and re-authenticate\n this.fire('authenticationrequired', {\n authenticate: L.Util.bind(this.authenticate, this)\n }, true);\n\n // if the user has access to a callback they can handle the auth error\n error.authenticate = L.Util.bind(this.authenticate, this);\n }\n\n callback.call(context, error, response);\n\n if (error) {\n this.fire('requesterror', {\n url: this.options.url + path,\n params: params,\n message: error.message,\n code: error.code,\n method: method\n }, true);\n } else {\n this.fire('requestsuccess', {\n url: this.options.url + path,\n params: params,\n response: response,\n method: method\n }, true);\n }\n\n this.fire('requestend', {\n url: this.options.url + path,\n params: params,\n method: method\n }, true);\n }, this);\n },\n\n _runQueue: function () {\n for (var i = this._requestQueue.length - 1; i >= 0; i--) {\n var request = this._requestQueue[i];\n var method = request.shift();\n this[method].apply(this, request);\n }\n this._requestQueue = [];\n }\n});\n\nexport function service (options) {\n return new Service(options);\n}\n\nexport default service;\n","import { Service } from './Service';\nimport identifyFeatures from '../Tasks/IdentifyFeatures';\nimport query from '../Tasks/Query';\nimport find from '../Tasks/Find';\n\nexport var MapService = Service.extend({\n\n identify: function () {\n return identifyFeatures(this);\n },\n\n find: function () {\n return find(this);\n },\n\n query: function () {\n return query(this);\n }\n\n});\n\nexport function mapService (options) {\n return new MapService(options);\n}\n\nexport default mapService;\n","import { Service } from './Service';\nimport identifyImage from '../Tasks/IdentifyImage';\nimport query from '../Tasks/Query';\n\nexport var ImageService = Service.extend({\n\n query: function () {\n return query(this);\n },\n\n identify: function () {\n return identifyImage(this);\n }\n});\n\nexport function imageService (options) {\n return new ImageService(options);\n}\n\nexport default imageService;\n","import { Service } from './Service';\nimport query from '../Tasks/Query';\nimport { geojsonToArcGIS } from '../Util';\n\nexport var FeatureLayerService = Service.extend({\n\n options: {\n idAttribute: 'OBJECTID'\n },\n\n query: function () {\n return query(this);\n },\n\n addFeature: function (feature, callback, context) {\n delete feature.id;\n\n feature = geojsonToArcGIS(feature);\n\n return this.post('addFeatures', {\n features: [feature]\n }, function (error, response) {\n var result = (response && response.addResults) ? response.addResults[0] : undefined;\n if (callback) {\n callback.call(context, error || response.addResults[0].error, result);\n }\n }, context);\n },\n\n updateFeature: function (feature, callback, context) {\n feature = geojsonToArcGIS(feature, this.options.idAttribute);\n\n return this.post('updateFeatures', {\n features: [feature]\n }, function (error, response) {\n var result = (response && response.updateResults) ? response.updateResults[0] : undefined;\n if (callback) {\n callback.call(context, error || response.updateResults[0].error, result);\n }\n }, context);\n },\n\n deleteFeature: function (id, callback, context) {\n return this.post('deleteFeatures', {\n objectIds: id\n }, function (error, response) {\n var result = (response && response.deleteResults) ? response.deleteResults[0] : undefined;\n if (callback) {\n callback.call(context, error || response.deleteResults[0].error, result);\n }\n }, context);\n },\n\n deleteFeatures: function (ids, callback, context) {\n return this.post('deleteFeatures', {\n objectIds: ids\n }, function (error, response) {\n // pass back the entire array\n var result = (response && response.deleteResults) ? response.deleteResults : undefined;\n if (callback) {\n callback.call(context, error || response.deleteResults[0].error, result);\n }\n }, context);\n }\n});\n\nexport function featureLayerService (options) {\n return new FeatureLayerService(options);\n}\n\nexport default featureLayerService;\n","import L from 'leaflet';\n\nexport var Logo = L.Control.extend({\n options: {\n position: 'bottomright',\n marginTop: 0,\n marginLeft: 0,\n marginBottom: 0,\n marginRight: 0\n },\n\n onAdd: function () {\n var div = L.DomUtil.create('div', 'esri-leaflet-logo');\n div.style.marginTop = this.options.marginTop;\n div.style.marginLeft = this.options.marginLeft;\n div.style.marginBottom = this.options.marginBottom;\n div.style.marginRight = this.options.marginRight;\n div.innerHTML = '\"Powered';\n\n return div;\n }\n});\n\nexport default function logo (options) {\n return new Logo(options);\n}\n","import L from 'leaflet';\nimport logo from '../Controls/Logo';\nimport { jsonp } from '../Request';\nimport { pointerEvents } from '../Support';\n\nvar tileProtocol = (window.location.protocol !== 'https:') ? 'http:' : 'https:';\n\nexport var BasemapLayer = L.TileLayer.extend({\n statics: {\n TILES: {\n Streets: {\n urlTemplate: tileProtocol + '//{s}.arcgisonline.com/ArcGIS/rest/services/World_Street_Map/MapServer/tile/{z}/{y}/{x}',\n attributionUrl: 'https://static.arcgis.com/attribution/World_Street_Map',\n options: {\n hideLogo: false,\n logoPosition: 'bottomright',\n minZoom: 1,\n maxZoom: 19,\n subdomains: ['server', 'services'],\n attribution: 'Esri'\n }\n },\n Topographic: {\n urlTemplate: tileProtocol + '//{s}.arcgisonline.com/ArcGIS/rest/services/World_Topo_Map/MapServer/tile/{z}/{y}/{x}',\n attributionUrl: 'https://static.arcgis.com/attribution/World_Topo_Map',\n options: {\n hideLogo: false,\n logoPosition: 'bottomright',\n minZoom: 1,\n maxZoom: 19,\n subdomains: ['server', 'services'],\n attribution: 'Esri'\n }\n },\n Oceans: {\n urlTemplate: tileProtocol + '//{s}.arcgisonline.com/arcgis/rest/services/Ocean/World_Ocean_Base/MapServer/tile/{z}/{y}/{x}',\n attributionUrl: 'https://static.arcgis.com/attribution/Ocean_Basemap',\n options: {\n hideLogo: false,\n logoPosition: 'bottomright',\n minZoom: 1,\n maxZoom: 16,\n subdomains: ['server', 'services'],\n attribution: 'Esri'\n }\n },\n OceansLabels: {\n urlTemplate: tileProtocol + '//{s}.arcgisonline.com/arcgis/rest/services/Ocean/World_Ocean_Reference/MapServer/tile/{z}/{y}/{x}',\n options: {\n hideLogo: true,\n logoPosition: 'bottomright',\n minZoom: 1,\n maxZoom: 16,\n subdomains: ['server', 'services'],\n pane: (pointerEvents) ? 'esri-labels' : 'tilePane'\n }\n },\n NationalGeographic: {\n urlTemplate: tileProtocol + '//{s}.arcgisonline.com/ArcGIS/rest/services/NatGeo_World_Map/MapServer/tile/{z}/{y}/{x}',\n options: {\n hideLogo: false,\n logoPosition: 'bottomright',\n minZoom: 1,\n maxZoom: 16,\n subdomains: ['server', 'services'],\n attribution: 'National Geographic, Esri, DeLorme, HERE, UNEP-WCMC, USGS, NASA, ESA, METI, NRCAN, GEBCO, NOAA, increment P Corp.'\n }\n },\n DarkGray: {\n urlTemplate: tileProtocol + '//{s}.arcgisonline.com/ArcGIS/rest/services/Canvas/World_Dark_Gray_Base/MapServer/tile/{z}/{y}/{x}',\n options: {\n hideLogo: false,\n logoPosition: 'bottomright',\n minZoom: 1,\n maxZoom: 16,\n subdomains: ['server', 'services'],\n attribution: 'Esri, HERE, DeLorme, MapmyIndia, © OpenStreetMap contributors'\n }\n },\n DarkGrayLabels: {\n urlTemplate: tileProtocol + '//{s}.arcgisonline.com/ArcGIS/rest/services/Canvas/World_Dark_Gray_Reference/MapServer/tile/{z}/{y}/{x}',\n options: {\n hideLogo: true,\n logoPosition: 'bottomright',\n minZoom: 1,\n maxZoom: 16,\n subdomains: ['server', 'services'],\n pane: (pointerEvents) ? 'esri-labels' : 'tilePane'\n\n }\n },\n Gray: {\n urlTemplate: tileProtocol + '//{s}.arcgisonline.com/ArcGIS/rest/services/Canvas/World_Light_Gray_Base/MapServer/tile/{z}/{y}/{x}',\n options: {\n hideLogo: false,\n logoPosition: 'bottomright',\n minZoom: 1,\n maxZoom: 16,\n subdomains: ['server', 'services'],\n attribution: 'Esri, HERE, DeLorme, MapmyIndia, © OpenStreetMap contributors'\n }\n },\n GrayLabels: {\n urlTemplate: tileProtocol + '//{s}.arcgisonline.com/ArcGIS/rest/services/Canvas/World_Light_Gray_Reference/MapServer/tile/{z}/{y}/{x}',\n options: {\n hideLogo: true,\n logoPosition: 'bottomright',\n minZoom: 1,\n maxZoom: 16,\n subdomains: ['server', 'services'],\n pane: (pointerEvents) ? 'esri-labels' : 'tilePane'\n }\n },\n Imagery: {\n urlTemplate: tileProtocol + '//{s}.arcgisonline.com/ArcGIS/rest/services/World_Imagery/MapServer/tile/{z}/{y}/{x}',\n options: {\n hideLogo: false,\n logoPosition: 'bottomright',\n minZoom: 1,\n maxZoom: 19,\n subdomains: ['server', 'services'],\n attribution: 'Esri, DigitalGlobe, GeoEye, i-cubed, USDA, USGS, AEX, Getmapping, Aerogrid, IGN, IGP, swisstopo, and the GIS User Community'\n }\n },\n ImageryLabels: {\n urlTemplate: tileProtocol + '//{s}.arcgisonline.com/ArcGIS/rest/services/Reference/World_Boundaries_and_Places/MapServer/tile/{z}/{y}/{x}',\n options: {\n hideLogo: true,\n logoPosition: 'bottomright',\n minZoom: 1,\n maxZoom: 19,\n subdomains: ['server', 'services'],\n pane: (pointerEvents) ? 'esri-labels' : 'tilePane'\n }\n },\n ImageryTransportation: {\n urlTemplate: tileProtocol + '//{s}.arcgisonline.com/ArcGIS/rest/services/Reference/World_Transportation/MapServer/tile/{z}/{y}/{x}',\n options: {\n hideLogo: true,\n logoPosition: 'bottomright',\n minZoom: 1,\n maxZoom: 19,\n subdomains: ['server', 'services'],\n pane: (pointerEvents) ? 'esri-labels' : 'tilePane'\n }\n },\n ShadedRelief: {\n urlTemplate: tileProtocol + '//{s}.arcgisonline.com/ArcGIS/rest/services/World_Shaded_Relief/MapServer/tile/{z}/{y}/{x}',\n options: {\n hideLogo: false,\n logoPosition: 'bottomright',\n minZoom: 1,\n maxZoom: 13,\n subdomains: ['server', 'services'],\n attribution: 'Esri, USGS'\n }\n },\n ShadedReliefLabels: {\n urlTemplate: tileProtocol + '//{s}.arcgisonline.com/ArcGIS/rest/services/Reference/World_Boundaries_and_Places_Alternate/MapServer/tile/{z}/{y}/{x}',\n options: {\n hideLogo: true,\n logoPosition: 'bottomright',\n minZoom: 1,\n maxZoom: 12,\n subdomains: ['server', 'services'],\n pane: (pointerEvents) ? 'esri-labels' : 'tilePane'\n }\n },\n Terrain: {\n urlTemplate: tileProtocol + '//{s}.arcgisonline.com/ArcGIS/rest/services/World_Terrain_Base/MapServer/tile/{z}/{y}/{x}',\n options: {\n hideLogo: false,\n logoPosition: 'bottomright',\n minZoom: 1,\n maxZoom: 13,\n subdomains: ['server', 'services'],\n attribution: 'Esri, USGS, NOAA'\n }\n },\n TerrainLabels: {\n urlTemplate: tileProtocol + '//{s}.arcgisonline.com/ArcGIS/rest/services/Reference/World_Reference_Overlay/MapServer/tile/{z}/{y}/{x}',\n options: {\n hideLogo: true,\n logoPosition: 'bottomright',\n minZoom: 1,\n maxZoom: 13,\n subdomains: ['server', 'services'],\n pane: (pointerEvents) ? 'esri-labels' : 'tilePane'\n }\n },\n USATopo: {\n urlTemplate: tileProtocol + '//{s}.arcgisonline.com/ArcGIS/rest/services/USA_Topo_Maps/MapServer/tile/{z}/{y}/{x}',\n options: {\n hideLogo: false,\n logoPosition: 'bottomright',\n minZoom: 1,\n maxZoom: 15,\n subdomains: ['server', 'services'],\n attribution: 'National Geographic Society, i-cubed'\n }\n }\n }\n },\n initialize: function (key, options) {\n var config;\n\n // set the config variable with the appropriate config object\n if (typeof key === 'object' && key.urlTemplate && key.options) {\n config = key;\n } else if (typeof key === 'string' && BasemapLayer.TILES[key]) {\n config = BasemapLayer.TILES[key];\n } else {\n throw new Error('L.esri.BasemapLayer: Invalid parameter. Use one of \"Streets\", \"Topographic\", \"Oceans\", \"OceansLabels\", \"NationalGeographic\", \"Gray\", \"GrayLabels\", \"DarkGray\", \"DarkGrayLabels\", \"Imagery\", \"ImageryLabels\", \"ImageryTransportation\", \"ShadedRelief\", \"ShadedReliefLabels\", \"Terrain\" or \"TerrainLabels\"');\n }\n\n // merge passed options into the config options\n var tileOptions = L.Util.extend(config.options, options);\n\n L.Util.setOptions(this, tileOptions);\n\n // call the initialize method on L.TileLayer to set everything up\n L.TileLayer.prototype.initialize.call(this, config.urlTemplate, tileOptions);\n\n // if this basemap requires dynamic attribution set it up\n if (config.attributionUrl) {\n this._getAttributionData(config.attributionUrl);\n }\n\n this._logo = logo({\n position: this.options.logoPosition\n });\n },\n\n onAdd: function (map) {\n if (!this.options.hideLogo && !map._hasEsriLogo) {\n this._logo.addTo(map);\n map._hasEsriLogo = true;\n }\n\n if (this.options.pane === 'esri-labels') {\n this._initPane();\n }\n\n map.on('moveend', this._updateMapAttribution, this);\n\n L.TileLayer.prototype.onAdd.call(this, map);\n },\n\n onRemove: function (map) {\n // check to make sure the logo hasn't already been removed\n if (this._logo && this._logo._container) {\n map.removeControl(this._logo);\n map._hasEsriLogo = false;\n }\n\n map.off('moveend', this._updateMapAttribution, this);\n\n L.TileLayer.prototype.onRemove.call(this, map);\n },\n\n getAttribution: function () {\n if (this.options.attribution) {\n var attribution = '' + this.options.attribution + '';\n }\n return attribution;\n },\n\n _initPane: function () {\n if (!this._map.getPane(this.options.pane)) {\n var pane = this._map.createPane(this.options.pane);\n pane.style.pointerEvents = 'none';\n pane.style.zIndex = 500;\n }\n },\n\n _getAttributionData: function (url) {\n jsonp(url, {}, L.Util.bind(function (error, attributions) {\n if (error) { return; }\n this._attributions = [];\n\n for (var c = 0; c < attributions.contributors.length; c++) {\n var contributor = attributions.contributors[c];\n for (var i = 0; i < contributor.coverageAreas.length; i++) {\n var coverageArea = contributor.coverageAreas[i];\n var southWest = L.latLng(coverageArea.bbox[0], coverageArea.bbox[1]);\n var northEast = L.latLng(coverageArea.bbox[2], coverageArea.bbox[3]);\n this._attributions.push({\n attribution: contributor.attribution,\n score: coverageArea.score,\n bounds: L.latLngBounds(southWest, northEast),\n minZoom: coverageArea.zoomMin,\n maxZoom: coverageArea.zoomMax\n });\n }\n }\n\n this._attributions.sort(function (a, b) {\n return b.score - a.score;\n });\n\n this._updateMapAttribution();\n }, this));\n },\n\n _updateMapAttribution: function () {\n if (this._map && this._map.attributionControl && this._attributions) {\n var newAttributions = '';\n var bounds = this._map.getBounds();\n var zoom = this._map.getZoom();\n\n for (var i = 0; i < this._attributions.length; i++) {\n var attribution = this._attributions[i];\n var text = attribution.attribution;\n if (!newAttributions.match(text) && bounds.intersects(attribution.bounds) && zoom >= attribution.minZoom && zoom <= attribution.maxZoom) {\n newAttributions += (', ' + text);\n }\n }\n newAttributions = newAttributions.substr(2);\n var attributionElement = this._map.attributionControl._container.querySelector('.esri-attributions');\n\n attributionElement.innerHTML = newAttributions;\n attributionElement.style.maxWidth = (this._map.getSize().x * 0.65) + 'px';\n\n this.fire('attributionupdated', {\n attribution: newAttributions\n });\n }\n }\n});\n\nexport function basemapLayer (key, options) {\n return new BasemapLayer(key, options);\n}\n\nexport default basemapLayer;\n","import L from 'leaflet';\nimport {warn, cleanUrl} from '../Util';\nimport mapService from '../Services/MapService';\n\nexport var TiledMapLayer = L.TileLayer.extend({\n options: {\n zoomOffsetAllowance: 0.1\n },\n\n statics: {\n MercatorZoomLevels: {\n '0': 156543.03392799999,\n '1': 78271.516963999893,\n '2': 39135.758482000099,\n '3': 19567.879240999901,\n '4': 9783.9396204999593,\n '5': 4891.9698102499797,\n '6': 2445.9849051249898,\n '7': 1222.9924525624899,\n '8': 611.49622628138002,\n '9': 305.74811314055802,\n '10': 152.874056570411,\n '11': 76.437028285073197,\n '12': 38.218514142536598,\n '13': 19.109257071268299,\n '14': 9.5546285356341496,\n '15': 4.7773142679493699,\n '16': 2.38865713397468,\n '17': 1.1943285668550501,\n '18': 0.59716428355981699,\n '19': 0.29858214164761698,\n '20': 0.14929107082381,\n '21': 0.07464553541191,\n '22': 0.0373227677059525,\n '23': 0.0186613838529763\n }\n },\n\n initialize: function (options) {\n options.url = cleanUrl(options.url);\n options = L.Util.setOptions(this, options);\n\n // set the urls\n this.tileUrl = options.url + 'tile/{z}/{y}/{x}';\n this.service = mapService(options);\n this.service.addEventParent(this);\n\n var arcgisonline = new RegExp(/tiles.arcgis(online)?\\.com/g);\n if (arcgisonline.test(options.url)) {\n this.tileUrl = this.tileUrl.replace('://tiles', '://tiles{s}');\n options.subdomains = ['1', '2', '3', '4'];\n }\n\n if (this.options.token) {\n this.tileUrl += ('?token=' + this.options.token);\n }\n\n // init layer by calling TileLayers initialize method\n L.TileLayer.prototype.initialize.call(this, this.tileUrl, options);\n },\n\n getTileUrl: function (tilePoint) {\n return L.Util.template(this.tileUrl, L.extend({\n s: this._getSubdomain(tilePoint),\n z: (this._lodMap && this._lodMap[tilePoint.z]) ? this._lodMap[tilePoint.z] : tilePoint.z, // try lod map first, then just defualt to zoom level\n x: tilePoint.x,\n y: tilePoint.y\n }, this.options));\n },\n\n createTile: function (coords, done) {\n var tile = document.createElement('img');\n\n L.DomEvent.on(tile, 'load', L.bind(this._tileOnLoad, this, done, tile));\n L.DomEvent.on(tile, 'error', L.bind(this._tileOnError, this, done, tile));\n\n if (this.options.crossOrigin) {\n tile.crossOrigin = '';\n }\n\n /*\n Alt tag is set to empty string to keep screen readers from reading URL and for compliance reasons\n http://www.w3.org/TR/WCAG20-TECHS/H67\n */\n tile.alt = '';\n\n // if there is no lod map or an lod map with a proper zoom load the tile\n // otherwise wait for the lod map to become available\n if (!this._lodMap || (this._lodMap && this._lodMap[coords.z])) {\n tile.src = this.getTileUrl(coords);\n } else {\n this.once('lodmap', function () {\n tile.src = this.getTileUrl(coords);\n }, this);\n }\n\n return tile;\n },\n\n onAdd: function (map) {\n if (map.options.crs === L.CRS.EPSG3857 && !this._lodMap) {\n this._lodMap = {};\n this.metadata(function (error, metadata) {\n if (!error) {\n var sr = metadata.spatialReference.latestWkid || metadata.spatialReference.wkid;\n if (sr === 102100 || sr === 3857) {\n // create the zoom level data\n var arcgisLODs = metadata.tileInfo.lods;\n var correctResolutions = TiledMapLayer.MercatorZoomLevels;\n\n for (var i = 0; i < arcgisLODs.length; i++) {\n var arcgisLOD = arcgisLODs[i];\n for (var ci in correctResolutions) {\n var correctRes = correctResolutions[ci];\n\n if (this._withinPercentage(arcgisLOD.resolution, correctRes, this.options.zoomOffsetAllowance)) {\n this._lodMap[ci] = arcgisLOD.level;\n break;\n }\n }\n }\n\n this.fire('lodmap');\n } else {\n warn('L.esri.TiledMapLayer is using a non-mercator spatial reference. Support may be available through Proj4Leaflet http://esri.github.io/esri-leaflet/examples/non-mercator-projection.html');\n }\n }\n }, this);\n }\n\n L.TileLayer.prototype.onAdd.call(this, map);\n },\n\n metadata: function (callback, context) {\n this.service.metadata(callback, context);\n return this;\n },\n\n identify: function () {\n return this.service.identify();\n },\n\n find: function () {\n return this.service.find();\n },\n\n query: function () {\n return this.service.query();\n },\n\n authenticate: function (token) {\n var tokenQs = '?token=' + token;\n this.tileUrl = (this.options.token) ? this.tileUrl.replace(/\\?token=(.+)/g, tokenQs) : this.tileUrl + tokenQs;\n this.options.token = token;\n this.service.authenticate(token);\n return this;\n },\n\n _withinPercentage: function (a, b, percentage) {\n var diff = Math.abs((a / b) - 1);\n return diff < percentage;\n }\n});\n\nexport function tiledMapLayer (url, options) {\n return new TiledMapLayer(url, options);\n}\n\nexport default tiledMapLayer;\n","import L from 'leaflet';\nimport {cors} from '../Support';\n\nvar Overlay = L.ImageOverlay.extend({\n onAdd: function (map) {\n this._topLeft = map.getPixelBounds().min;\n L.ImageOverlay.prototype.onAdd.call(this, map);\n },\n _reset: function () {\n if (this._map.options.crs === L.CRS.EPSG3857) {\n L.ImageOverlay.prototype._reset.call(this);\n } else {\n L.DomUtil.setPosition(this._image, this._topLeft.subtract(this._map.getPixelOrigin()));\n }\n }\n});\n\nexport var RasterLayer = L.Layer.extend({\n\n options: {\n opacity: 1,\n position: 'front',\n f: 'image',\n useCors: cors,\n attribution: null,\n interactive: false,\n alt: ''\n },\n\n onAdd: function (map) {\n this._update = L.Util.throttle(this._update, this.options.updateInterval, this);\n\n map.on('moveend', this._update, this);\n\n // if we had an image loaded and it matches the\n // current bounds show the image otherwise remove it\n if (this._currentImage && this._currentImage._bounds.equals(this._map.getBounds())) {\n map.addLayer(this._currentImage);\n } else if (this._currentImage) {\n this._map.removeLayer(this._currentImage);\n this._currentImage = null;\n }\n\n this._update();\n\n if (this._popup) {\n this._map.on('click', this._getPopupData, this);\n this._map.on('dblclick', this._resetPopupState, this);\n }\n },\n\n onRemove: function (map) {\n if (this._currentImage) {\n this._map.removeLayer(this._currentImage);\n }\n\n if (this._popup) {\n this._map.off('click', this._getPopupData, this);\n this._map.off('dblclick', this._resetPopupState, this);\n }\n\n this._map.off('moveend', this._update, this);\n },\n\n bindPopup: function (fn, popupOptions) {\n this._shouldRenderPopup = false;\n this._lastClick = false;\n this._popup = L.popup(popupOptions);\n this._popupFunction = fn;\n if (this._map) {\n this._map.on('click', this._getPopupData, this);\n this._map.on('dblclick', this._resetPopupState, this);\n }\n return this;\n },\n\n unbindPopup: function () {\n if (this._map) {\n this._map.closePopup(this._popup);\n this._map.off('click', this._getPopupData, this);\n this._map.off('dblclick', this._resetPopupState, this);\n }\n this._popup = false;\n return this;\n },\n\n bringToFront: function () {\n this.options.position = 'front';\n if (this._currentImage) {\n this._currentImage.bringToFront();\n }\n return this;\n },\n\n bringToBack: function () {\n this.options.position = 'back';\n if (this._currentImage) {\n this._currentImage.bringToBack();\n }\n return this;\n },\n\n getAttribution: function () {\n return this.options.attribution;\n },\n\n getOpacity: function () {\n return this.options.opacity;\n },\n\n setOpacity: function (opacity) {\n this.options.opacity = opacity;\n this._currentImage.setOpacity(opacity);\n return this;\n },\n\n getTimeRange: function () {\n return [this.options.from, this.options.to];\n },\n\n setTimeRange: function (from, to) {\n this.options.from = from;\n this.options.to = to;\n this._update();\n return this;\n },\n\n metadata: function (callback, context) {\n this.service.metadata(callback, context);\n return this;\n },\n\n authenticate: function (token) {\n this.service.authenticate(token);\n return this;\n },\n\n _renderImage: function (url, bounds) {\n if (this._map) {\n // create a new image overlay and add it to the map\n // to start loading the image\n // opacity is 0 while the image is loading\n var image = new Overlay(url, bounds, {\n opacity: 0,\n crossOrigin: this.options.useCors,\n alt: this.options.alt,\n pane: this.options.pane || this.getPane(),\n interactive: this.options.interactive\n }).addTo(this._map);\n\n // once the image loads\n image.once('load', function (e) {\n if (this._map) {\n var newImage = e.target;\n var oldImage = this._currentImage;\n\n // if the bounds of this image matches the bounds that\n // _renderImage was called with and we have a map with the same bounds\n // hide the old image if there is one and set the opacity\n // of the new image otherwise remove the new image\n if (newImage._bounds.equals(bounds) && newImage._bounds.equals(this._map.getBounds())) {\n this._currentImage = newImage;\n\n if (this.options.position === 'front') {\n this.bringToFront();\n } else {\n this.bringToBack();\n }\n\n if (this._map && this._currentImage._map) {\n this._currentImage.setOpacity(this.options.opacity);\n } else {\n this._currentImage._map.removeLayer(this._currentImage);\n }\n\n if (oldImage && this._map) {\n this._map.removeLayer(oldImage);\n }\n\n if (oldImage && oldImage._map) {\n oldImage._map.removeLayer(oldImage);\n }\n } else {\n this._map.removeLayer(newImage);\n }\n }\n\n this.fire('load', {\n bounds: bounds\n });\n }, this);\n\n this.fire('loading', {\n bounds: bounds\n });\n }\n },\n\n _update: function () {\n if (!this._map) {\n return;\n }\n\n var zoom = this._map.getZoom();\n var bounds = this._map.getBounds();\n\n if (this._animatingZoom) {\n return;\n }\n\n if (this._map._panTransition && this._map._panTransition._inProgress) {\n return;\n }\n\n if (zoom > this.options.maxZoom || zoom < this.options.minZoom) {\n this._currentImage._map.removeLayer(this._currentImage);\n return;\n }\n\n var params = this._buildExportParams();\n\n this._requestExport(params, bounds);\n },\n\n _renderPopup: function (latlng, error, results, response) {\n latlng = L.latLng(latlng);\n if (this._shouldRenderPopup && this._lastClick.equals(latlng)) {\n // add the popup to the map where the mouse was clicked at\n var content = this._popupFunction(error, results, response);\n if (content) {\n this._popup.setLatLng(latlng).setContent(content).openOn(this._map);\n }\n }\n },\n\n _resetPopupState: function (e) {\n this._shouldRenderPopup = false;\n this._lastClick = e.latlng;\n }\n});\n","import L from 'leaflet';\nimport { RasterLayer } from './RasterLayer';\nimport { cleanUrl } from '../Util';\nimport imageService from '../Services/ImageService';\n\nexport var ImageMapLayer = RasterLayer.extend({\n\n options: {\n updateInterval: 150,\n format: 'jpgpng',\n transparent: true,\n f: 'json'\n },\n\n query: function () {\n return this.service.query();\n },\n\n identify: function () {\n return this.service.identify();\n },\n\n initialize: function (options) {\n options.url = cleanUrl(options.url);\n this.service = imageService(options);\n this.service.addEventParent(this);\n\n L.Util.setOptions(this, options);\n },\n\n setPixelType: function (pixelType) {\n this.options.pixelType = pixelType;\n this._update();\n return this;\n },\n\n getPixelType: function () {\n return this.options.pixelType;\n },\n\n setBandIds: function (bandIds) {\n if (L.Util.isArray(bandIds)) {\n this.options.bandIds = bandIds.join(',');\n } else {\n this.options.bandIds = bandIds.toString();\n }\n this._update();\n return this;\n },\n\n getBandIds: function () {\n return this.options.bandIds;\n },\n\n setNoData: function (noData, noDataInterpretation) {\n if (L.Util.isArray(noData)) {\n this.options.noData = noData.join(',');\n } else {\n this.options.noData = noData.toString();\n }\n if (noDataInterpretation) {\n this.options.noDataInterpretation = noDataInterpretation;\n }\n this._update();\n return this;\n },\n\n getNoData: function () {\n return this.options.noData;\n },\n\n getNoDataInterpretation: function () {\n return this.options.noDataInterpretation;\n },\n\n setRenderingRule: function (renderingRule) {\n this.options.renderingRule = renderingRule;\n this._update();\n },\n\n getRenderingRule: function () {\n return this.options.renderingRule;\n },\n\n setMosaicRule: function (mosaicRule) {\n this.options.mosaicRule = mosaicRule;\n this._update();\n },\n\n getMosaicRule: function () {\n return this.options.mosaicRule;\n },\n\n _getPopupData: function (e) {\n var callback = L.Util.bind(function (error, results, response) {\n if (error) { return; } // we really can't do anything here but authenticate or requesterror will fire\n setTimeout(L.Util.bind(function () {\n this._renderPopup(e.latlng, error, results, response);\n }, this), 300);\n }, this);\n\n var identifyRequest = this.identify().at(e.latlng);\n\n // set mosaic rule for identify task if it is set for layer\n if (this.options.mosaicRule) {\n identifyRequest.setMosaicRule(this.options.mosaicRule);\n // @TODO: force return catalog items too?\n }\n\n // @TODO: set rendering rule? Not sure,\n // sometimes you want raw pixel values\n // if (this.options.renderingRule) {\n // identifyRequest.setRenderingRule(this.options.renderingRule);\n // }\n\n identifyRequest.run(callback);\n\n // set the flags to show the popup\n this._shouldRenderPopup = true;\n this._lastClick = e.latlng;\n },\n\n _buildExportParams: function () {\n var bounds = this._map.getBounds();\n var size = this._map.getSize();\n var ne = this._map.options.crs.project(bounds._northEast);\n var sw = this._map.options.crs.project(bounds._southWest);\n\n // ensure that we don't ask ArcGIS Server for a taller image than we have actual map displaying\n var top = this._map.latLngToLayerPoint(bounds._northEast);\n var bottom = this._map.latLngToLayerPoint(bounds._southWest);\n\n if (top.y > 0 || bottom.y < size.y) {\n size.y = bottom.y - top.y;\n }\n\n var sr = parseInt(this._map.options.crs.code.split(':')[1], 10);\n\n var params = {\n bbox: [sw.x, sw.y, ne.x, ne.y].join(','),\n size: size.x + ',' + size.y,\n format: this.options.format,\n transparent: this.options.transparent,\n bboxSR: sr,\n imageSR: sr\n };\n\n if (this.options.from && this.options.to) {\n params.time = this.options.from.valueOf() + ',' + this.options.to.valueOf();\n }\n\n if (this.options.pixelType) {\n params.pixelType = this.options.pixelType;\n }\n\n if (this.options.interpolation) {\n params.interpolation = this.options.interpolation;\n }\n\n if (this.options.compressionQuality) {\n params.compressionQuality = this.options.compressionQuality;\n }\n\n if (this.options.bandIds) {\n params.bandIds = this.options.bandIds;\n }\n\n if (this.options.noData) {\n params.noData = this.options.noData;\n }\n\n if (this.options.noDataInterpretation) {\n params.noDataInterpretation = this.options.noDataInterpretation;\n }\n\n if (this.service.options.token) {\n params.token = this.service.options.token;\n }\n\n if (this.options.renderingRule) {\n params.renderingRule = JSON.stringify(this.options.renderingRule);\n }\n\n if (this.options.mosaicRule) {\n params.mosaicRule = JSON.stringify(this.options.mosaicRule);\n }\n\n return params;\n },\n\n _requestExport: function (params, bounds) {\n if (this.options.f === 'json') {\n this.service.request('exportImage', params, function (error, response) {\n if (error) { return; } // we really can't do anything here but authenticate or requesterror will fire\n this._renderImage(response.href, bounds);\n }, this);\n } else {\n params.f = 'image';\n this._renderImage(this.options.url + 'exportImage' + L.Util.getParamString(params), bounds);\n }\n }\n});\n\nexport function imageMapLayer (url, options) {\n return new ImageMapLayer(url, options);\n}\n\nexport default imageMapLayer;\n","import L from 'leaflet';\nimport { RasterLayer } from './RasterLayer';\nimport { cleanUrl } from '../Util';\nimport mapService from '../Services/MapService';\n\nexport var DynamicMapLayer = RasterLayer.extend({\n\n options: {\n updateInterval: 150,\n layers: false,\n layerDefs: false,\n timeOptions: false,\n format: 'png24',\n transparent: true,\n f: 'json'\n },\n\n initialize: function (options) {\n options.url = cleanUrl(options.url);\n this.service = mapService(options);\n this.service.addEventParent(this);\n\n if ((options.proxy || options.token) && options.f !== 'json') {\n options.f = 'json';\n }\n L.Util.setOptions(this, options);\n },\n\n getDynamicLayers: function () {\n return this.options.dynamicLayers;\n },\n\n setDynamicLayers: function (dynamicLayers) {\n this.options.dynamicLayers = dynamicLayers;\n this._update();\n return this;\n },\n\n getLayers: function () {\n return this.options.layers;\n },\n\n setLayers: function (layers) {\n this.options.layers = layers;\n this._update();\n return this;\n },\n\n getLayerDefs: function () {\n return this.options.layerDefs;\n },\n\n setLayerDefs: function (layerDefs) {\n this.options.layerDefs = layerDefs;\n this._update();\n return this;\n },\n\n getTimeOptions: function () {\n return this.options.timeOptions;\n },\n\n setTimeOptions: function (timeOptions) {\n this.options.timeOptions = timeOptions;\n this._update();\n return this;\n },\n\n query: function () {\n return this.service.query();\n },\n\n identify: function () {\n return this.service.identify();\n },\n\n find: function () {\n return this.service.find();\n },\n\n _getPopupData: function (e) {\n var callback = L.Util.bind(function (error, featureCollection, response) {\n if (error) { return; } // we really can't do anything here but authenticate or requesterror will fire\n setTimeout(L.Util.bind(function () {\n this._renderPopup(e.latlng, error, featureCollection, response);\n }, this), 300);\n }, this);\n\n var identifyRequest = this.identify().on(this._map).at(e.latlng);\n\n if (this.options.layers) {\n identifyRequest.layers('visible:' + this.options.layers.join(','));\n } else {\n identifyRequest.layers('visible');\n }\n\n identifyRequest.run(callback);\n\n // set the flags to show the popup\n this._shouldRenderPopup = true;\n this._lastClick = e.latlng;\n },\n\n _buildExportParams: function () {\n var bounds = this._map.getBounds();\n var size = this._map.getSize();\n var ne = this._map.options.crs.project(bounds.getNorthEast());\n var sw = this._map.options.crs.project(bounds.getSouthWest());\n var sr = parseInt(this._map.options.crs.code.split(':')[1], 10);\n\n // ensure that we don't ask ArcGIS Server for a taller image than we have actual map displaying\n var top = this._map.latLngToLayerPoint(bounds._northEast);\n var bottom = this._map.latLngToLayerPoint(bounds._southWest);\n\n if (top.y > 0 || bottom.y < size.y) {\n size.y = bottom.y - top.y;\n }\n\n var params = {\n bbox: [sw.x, sw.y, ne.x, ne.y].join(','),\n size: size.x + ',' + size.y,\n dpi: 96,\n format: this.options.format,\n transparent: this.options.transparent,\n bboxSR: sr,\n imageSR: sr\n };\n\n if (this.options.dynamicLayers) {\n params.dynamicLayers = this.options.dynamicLayers;\n }\n\n if (this.options.layers) {\n params.layers = 'show:' + this.options.layers.join(',');\n }\n\n if (this.options.layerDefs) {\n params.layerDefs = JSON.stringify(this.options.layerDefs);\n }\n\n if (this.options.timeOptions) {\n params.timeOptions = JSON.stringify(this.options.timeOptions);\n }\n\n if (this.options.from && this.options.to) {\n params.time = this.options.from.valueOf() + ',' + this.options.to.valueOf();\n }\n\n if (this.service.options.token) {\n params.token = this.service.options.token;\n }\n\n return params;\n },\n\n _requestExport: function (params, bounds) {\n if (this.options.f === 'json') {\n this.service.request('export', params, function (error, response) {\n if (error) { return; } // we really can't do anything here but authenticate or requesterror will fire\n this._renderImage(response.href, bounds);\n }, this);\n } else {\n params.f = 'image';\n this._renderImage(this.options.url + 'export' + L.Util.getParamString(params), bounds);\n }\n }\n});\n\nexport function dynamicMapLayer (url, options) {\n return new DynamicMapLayer(url, options);\n}\n\nexport default dynamicMapLayer;\n","import L from 'leaflet';\n\nvar VirtualGrid = L.Layer.extend({\n\n options: {\n cellSize: 512,\n updateInterval: 150\n },\n\n initialize: function (options) {\n options = L.setOptions(this, options);\n this._zooming = false;\n },\n\n onAdd: function (map) {\n this._map = map;\n this._update = L.Util.throttle(this._update, this.options.updateInterval, this);\n this._reset();\n this._update();\n },\n\n onRemove: function () {\n this._map.removeEventListener(this.getEvents(), this);\n this._removeCells();\n },\n\n getEvents: function () {\n var events = {\n moveend: this._update,\n zoomstart: this._zoomstart,\n zoomend: this._reset\n };\n\n return events;\n },\n\n addTo: function (map) {\n map.addLayer(this);\n return this;\n },\n\n removeFrom: function (map) {\n map.removeLayer(this);\n return this;\n },\n\n _zoomstart: function () {\n this._zooming = true;\n },\n\n _reset: function () {\n this._removeCells();\n\n this._cells = {};\n this._activeCells = {};\n this._cellsToLoad = 0;\n this._cellsTotal = 0;\n this._cellNumBounds = this._getCellNumBounds();\n\n this._resetWrap();\n this._zooming = false;\n },\n\n _resetWrap: function () {\n var map = this._map;\n var crs = map.options.crs;\n\n if (crs.infinite) { return; }\n\n var cellSize = this._getCellSize();\n\n if (crs.wrapLng) {\n this._wrapLng = [\n Math.floor(map.project([0, crs.wrapLng[0]]).x / cellSize),\n Math.ceil(map.project([0, crs.wrapLng[1]]).x / cellSize)\n ];\n }\n\n if (crs.wrapLat) {\n this._wrapLat = [\n Math.floor(map.project([crs.wrapLat[0], 0]).y / cellSize),\n Math.ceil(map.project([crs.wrapLat[1], 0]).y / cellSize)\n ];\n }\n },\n\n _getCellSize: function () {\n return this.options.cellSize;\n },\n\n _update: function () {\n if (!this._map) {\n return;\n }\n\n var bounds = this._map.getPixelBounds();\n var cellSize = this._getCellSize();\n\n // cell coordinates range for the current view\n var cellBounds = L.bounds(\n bounds.min.divideBy(cellSize).floor(),\n bounds.max.divideBy(cellSize).floor());\n\n this._removeOtherCells(cellBounds);\n this._addCells(cellBounds);\n\n this.fire('cellsupdated');\n },\n\n _addCells: function (bounds) {\n var queue = [];\n var center = bounds.getCenter();\n var zoom = this._map.getZoom();\n\n var j, i, coords;\n // create a queue of coordinates to load cells from\n for (j = bounds.min.y; j <= bounds.max.y; j++) {\n for (i = bounds.min.x; i <= bounds.max.x; i++) {\n coords = L.point(i, j);\n coords.z = zoom;\n\n if (this._isValidCell(coords)) {\n queue.push(coords);\n }\n }\n }\n\n var cellsToLoad = queue.length;\n\n if (cellsToLoad === 0) { return; }\n\n this._cellsToLoad += cellsToLoad;\n this._cellsTotal += cellsToLoad;\n\n // sort cell queue to load cells in order of their distance to center\n queue.sort(function (a, b) {\n return a.distanceTo(center) - b.distanceTo(center);\n });\n\n for (i = 0; i < cellsToLoad; i++) {\n this._addCell(queue[i]);\n }\n },\n\n _isValidCell: function (coords) {\n var crs = this._map.options.crs;\n\n if (!crs.infinite) {\n // don't load cell if it's out of bounds and not wrapped\n var bounds = this._cellNumBounds;\n if (\n (!crs.wrapLng && (coords.x < bounds.min.x || coords.x > bounds.max.x)) ||\n (!crs.wrapLat && (coords.y < bounds.min.y || coords.y > bounds.max.y))\n ) {\n return false;\n }\n }\n\n if (!this.options.bounds) {\n return true;\n }\n\n // don't load cell if it doesn't intersect the bounds in options\n var cellBounds = this._cellCoordsToBounds(coords);\n return L.latLngBounds(this.options.bounds).intersects(cellBounds);\n },\n\n // converts cell coordinates to its geographical bounds\n _cellCoordsToBounds: function (coords) {\n var map = this._map;\n var cellSize = this.options.cellSize;\n var nwPoint = coords.multiplyBy(cellSize);\n var sePoint = nwPoint.add([cellSize, cellSize]);\n var nw = map.wrapLatLng(map.unproject(nwPoint, coords.z));\n var se = map.wrapLatLng(map.unproject(sePoint, coords.z));\n\n return L.latLngBounds(nw, se);\n },\n\n // converts cell coordinates to key for the cell cache\n _cellCoordsToKey: function (coords) {\n return coords.x + ':' + coords.y;\n },\n\n // converts cell cache key to coordiantes\n _keyToCellCoords: function (key) {\n var kArr = key.split(':');\n var x = parseInt(kArr[0], 10);\n var y = parseInt(kArr[1], 10);\n\n return L.point(x, y);\n },\n\n // remove any present cells that are off the specified bounds\n _removeOtherCells: function (bounds) {\n for (var key in this._cells) {\n if (!bounds.contains(this._keyToCellCoords(key))) {\n this._removeCell(key);\n }\n }\n },\n\n _removeCell: function (key) {\n var cell = this._activeCells[key];\n\n if (cell) {\n delete this._activeCells[key];\n\n if (this.cellLeave) {\n this.cellLeave(cell.bounds, cell.coords);\n }\n\n this.fire('cellleave', {\n bounds: cell.bounds,\n coords: cell.coords\n });\n }\n },\n\n _removeCells: function () {\n for (var key in this._cells) {\n var bounds = this._cells[key].bounds;\n var coords = this._cells[key].coords;\n\n if (this.cellLeave) {\n this.cellLeave(bounds, coords);\n }\n\n this.fire('cellleave', {\n bounds: bounds,\n coords: coords\n });\n }\n },\n\n _addCell: function (coords) {\n // wrap cell coords if necessary (depending on CRS)\n this._wrapCoords(coords);\n\n // generate the cell key\n var key = this._cellCoordsToKey(coords);\n\n // get the cell from the cache\n var cell = this._cells[key];\n // if this cell should be shown as isnt active yet (enter)\n\n if (cell && !this._activeCells[key]) {\n if (this.cellEnter) {\n this.cellEnter(cell.bounds, coords);\n }\n\n this.fire('cellenter', {\n bounds: cell.bounds,\n coords: coords\n });\n\n this._activeCells[key] = cell;\n }\n\n // if we dont have this cell in the cache yet (create)\n if (!cell) {\n cell = {\n coords: coords,\n bounds: this._cellCoordsToBounds(coords)\n };\n\n this._cells[key] = cell;\n this._activeCells[key] = cell;\n\n if (this.createCell) {\n this.createCell(cell.bounds, coords);\n }\n\n this.fire('cellcreate', {\n bounds: cell.bounds,\n coords: coords\n });\n }\n },\n\n _wrapCoords: function (coords) {\n coords.x = this._wrapLng ? L.Util.wrapNum(coords.x, this._wrapLng) : coords.x;\n coords.y = this._wrapLat ? L.Util.wrapNum(coords.y, this._wrapLat) : coords.y;\n },\n\n // get the global cell coordinates range for the current zoom\n _getCellNumBounds: function () {\n var bounds = this._map.getPixelWorldBounds();\n var size = this._getCellSize();\n\n return bounds ? L.bounds(\n bounds.min.divideBy(size).floor(),\n bounds.max.divideBy(size).ceil().subtract([1, 1])) : null;\n }\n});\n\nexport default VirtualGrid;\n","function BinarySearchIndex (values) {\n this.values = [].concat(values || []);\n}\n\nBinarySearchIndex.prototype.query = function (value) {\n var index = this.getIndex(value);\n return this.values[index];\n};\n\nBinarySearchIndex.prototype.getIndex = function getIndex (value) {\n if (this.dirty) {\n this.sort();\n }\n\n var minIndex = 0;\n var maxIndex = this.values.length - 1;\n var currentIndex;\n var currentElement;\n\n while (minIndex <= maxIndex) {\n currentIndex = (minIndex + maxIndex) / 2 | 0;\n currentElement = this.values[Math.round(currentIndex)];\n if (+currentElement.value < +value) {\n minIndex = currentIndex + 1;\n } else if (+currentElement.value > +value) {\n maxIndex = currentIndex - 1;\n } else {\n return currentIndex;\n }\n }\n\n return Math.abs(~maxIndex);\n};\n\nBinarySearchIndex.prototype.between = function between (start, end) {\n var startIndex = this.getIndex(start);\n var endIndex = this.getIndex(end);\n\n if (startIndex === 0 && endIndex === 0) {\n return [];\n }\n\n while (this.values[startIndex - 1] && this.values[startIndex - 1].value === start) {\n startIndex--;\n }\n\n while (this.values[endIndex + 1] && this.values[endIndex + 1].value === end) {\n endIndex++;\n }\n\n if (this.values[endIndex] && this.values[endIndex].value === end && this.values[endIndex + 1]) {\n endIndex++;\n }\n\n return this.values.slice(startIndex, endIndex);\n};\n\nBinarySearchIndex.prototype.insert = function insert (item) {\n this.values.splice(this.getIndex(item.value), 0, item);\n return this;\n};\n\nBinarySearchIndex.prototype.bulkAdd = function bulkAdd (items, sort) {\n this.values = this.values.concat([].concat(items || []));\n\n if (sort) {\n this.sort();\n } else {\n this.dirty = true;\n }\n\n return this;\n};\n\nBinarySearchIndex.prototype.sort = function sort () {\n this.values.sort(function (a, b) {\n return +b.value - +a.value;\n }).reverse();\n this.dirty = false;\n return this;\n};\n\nexport default BinarySearchIndex;\n","import L from 'leaflet';\nimport featureLayerService from '../../Services/FeatureLayerService';\nimport { cleanUrl, warn } from '../../Util';\nimport VirtualGrid from 'leaflet-virtual-grid';\nimport BinarySearchIndex from 'tiny-binary-search';\n\nexport var FeatureManager = VirtualGrid.extend({\n /**\n * Options\n */\n\n options: {\n attribution: null,\n where: '1=1',\n fields: ['*'],\n from: false,\n to: false,\n timeField: false,\n timeFilterMode: 'server',\n simplifyFactor: 0,\n precision: 6\n },\n\n /**\n * Constructor\n */\n\n initialize: function (options) {\n VirtualGrid.prototype.initialize.call(this, options);\n\n options.url = cleanUrl(options.url);\n options = L.setOptions(this, options);\n\n this.service = featureLayerService(options);\n this.service.addEventParent(this);\n\n // use case insensitive regex to look for common fieldnames used for indexing\n if (this.options.fields[0] !== '*') {\n var oidCheck = false;\n for (var i = 0; i < this.options.fields.length; i++) {\n if (this.options.fields[i].match(/^(OBJECTID|FID|OID|ID)$/i)) {\n oidCheck = true;\n }\n }\n if (oidCheck === false) {\n warn('no known esriFieldTypeOID field detected in fields Array. Please add an attribute field containing unique IDs to ensure the layer can be drawn correctly.');\n }\n }\n\n if (this.options.timeField.start && this.options.timeField.end) {\n this._startTimeIndex = new BinarySearchIndex();\n this._endTimeIndex = new BinarySearchIndex();\n } else if (this.options.timeField) {\n this._timeIndex = new BinarySearchIndex();\n }\n\n this._cache = {};\n this._currentSnapshot = []; // cache of what layers should be active\n this._activeRequests = 0;\n },\n\n /**\n * Layer Interface\n */\n\n onAdd: function (map) {\n map.on('zoomend', this._handleZoomChange, this);\n\n return VirtualGrid.prototype.onAdd.call(this, map);\n },\n\n onRemove: function (map) {\n map.off('zoomend', this._handleZoomChange, this);\n\n return VirtualGrid.prototype.onRemove.call(this, map);\n },\n\n getAttribution: function () {\n return this.options.attribution;\n },\n\n /**\n * Feature Management\n */\n\n createCell: function (bounds, coords) {\n this._requestFeatures(bounds, coords);\n },\n\n _requestFeatures: function (bounds, coords, callback) {\n this._activeRequests++;\n\n // our first active request fires loading\n if (this._activeRequests === 1) {\n this.fire('loading', {\n bounds: bounds\n }, true);\n }\n\n return this._buildQuery(bounds).run(function (error, featureCollection, response) {\n if (response && response.exceededTransferLimit) {\n this.fire('drawlimitexceeded');\n }\n\n // no error, features\n if (!error && featureCollection && featureCollection.features.length) {\n // schedule adding features until the next animation frame\n L.Util.requestAnimFrame(L.Util.bind(function () {\n this._addFeatures(featureCollection.features, coords);\n this._postProcessFeatures(bounds);\n }, this));\n }\n\n // no error, no features\n if (!error && featureCollection && !featureCollection.features.length) {\n this._postProcessFeatures(bounds);\n }\n\n if (error) {\n this._postProcessFeatures(bounds);\n }\n\n if (callback) {\n callback.call(this, error, featureCollection);\n }\n }, this);\n },\n\n _postProcessFeatures: function (bounds) {\n // deincriment the request counter now that we have processed features\n this._activeRequests--;\n\n // if there are no more active requests fire a load event for this view\n if (this._activeRequests <= 0) {\n this.fire('load', {\n bounds: bounds\n });\n }\n },\n\n _cacheKey: function (coords) {\n return coords.z + ':' + coords.x + ':' + coords.y;\n },\n\n _addFeatures: function (features, coords) {\n var key = this._cacheKey(coords);\n this._cache[key] = this._cache[key] || [];\n\n for (var i = features.length - 1; i >= 0; i--) {\n var id = features[i].id;\n this._currentSnapshot.push(id);\n this._cache[key].push(id);\n }\n\n if (this.options.timeField) {\n this._buildTimeIndexes(features);\n }\n\n // need to PR removal of the logic below too...\n // https://github.com/patrickarlt/leaflet-virtual-grid/blob/master/src/virtual-grid.js#L100-L102\n\n this.createLayers(features);\n },\n\n _buildQuery: function (bounds) {\n var query = this.service.query()\n .intersects(bounds)\n .where(this.options.where)\n .fields(this.options.fields)\n .precision(this.options.precision);\n\n if (this.options.simplifyFactor) {\n query.simplify(this._map, this.options.simplifyFactor);\n }\n\n if (this.options.timeFilterMode === 'server' && this.options.from && this.options.to) {\n query.between(this.options.from, this.options.to);\n }\n\n return query;\n },\n\n /**\n * Where Methods\n */\n\n setWhere: function (where, callback, context) {\n this.options.where = (where && where.length) ? where : '1=1';\n\n var oldSnapshot = [];\n var newSnapshot = [];\n var pendingRequests = 0;\n var requestError = null;\n var requestCallback = L.Util.bind(function (error, featureCollection) {\n if (error) {\n requestError = error;\n }\n\n if (featureCollection) {\n for (var i = featureCollection.features.length - 1; i >= 0; i--) {\n newSnapshot.push(featureCollection.features[i].id);\n }\n }\n\n pendingRequests--;\n\n if (pendingRequests <= 0) {\n this._currentSnapshot = newSnapshot;\n // schedule adding features for the next animation frame\n L.Util.requestAnimFrame(L.Util.bind(function () {\n this.removeLayers(oldSnapshot);\n this.addLayers(newSnapshot);\n if (callback) {\n callback.call(context, requestError);\n }\n }, this));\n }\n }, this);\n\n for (var i = this._currentSnapshot.length - 1; i >= 0; i--) {\n oldSnapshot.push(this._currentSnapshot[i]);\n }\n\n for (var key in this._activeCells) {\n pendingRequests++;\n var coords = this._keyToCellCoords(key);\n var bounds = this._cellCoordsToBounds(coords);\n this._requestFeatures(bounds, key, requestCallback);\n }\n\n return this;\n },\n\n getWhere: function () {\n return this.options.where;\n },\n\n /**\n * Time Range Methods\n */\n\n getTimeRange: function () {\n return [this.options.from, this.options.to];\n },\n\n setTimeRange: function (from, to, callback, context) {\n var oldFrom = this.options.from;\n var oldTo = this.options.to;\n var pendingRequests = 0;\n var requestError = null;\n var requestCallback = L.Util.bind(function (error) {\n if (error) {\n requestError = error;\n }\n this._filterExistingFeatures(oldFrom, oldTo, from, to);\n\n pendingRequests--;\n\n if (callback && pendingRequests <= 0) {\n callback.call(context, requestError);\n }\n }, this);\n\n this.options.from = from;\n this.options.to = to;\n\n this._filterExistingFeatures(oldFrom, oldTo, from, to);\n\n if (this.options.timeFilterMode === 'server') {\n for (var key in this._activeCells) {\n pendingRequests++;\n var coords = this._keyToCellCoords(key);\n var bounds = this._cellCoordsToBounds(coords);\n this._requestFeatures(bounds, key, requestCallback);\n }\n }\n\n return this;\n },\n\n refresh: function () {\n for (var key in this._activeCells) {\n var coords = this._keyToCellCoords(key);\n var bounds = this._cellCoordsToBounds(coords);\n this._requestFeatures(bounds, key);\n }\n\n if (this.redraw) {\n this.once('load', function () {\n this.eachFeature(function (layer) {\n this._redraw(layer.feature.id);\n }, this);\n }, this);\n }\n },\n\n _filterExistingFeatures: function (oldFrom, oldTo, newFrom, newTo) {\n var layersToRemove = (oldFrom && oldTo) ? this._getFeaturesInTimeRange(oldFrom, oldTo) : this._currentSnapshot;\n var layersToAdd = this._getFeaturesInTimeRange(newFrom, newTo);\n\n if (layersToAdd.indexOf) {\n for (var i = 0; i < layersToAdd.length; i++) {\n var shouldRemoveLayer = layersToRemove.indexOf(layersToAdd[i]);\n if (shouldRemoveLayer >= 0) {\n layersToRemove.splice(shouldRemoveLayer, 1);\n }\n }\n }\n\n // schedule adding features until the next animation frame\n L.Util.requestAnimFrame(L.Util.bind(function () {\n this.removeLayers(layersToRemove);\n this.addLayers(layersToAdd);\n }, this));\n },\n\n _getFeaturesInTimeRange: function (start, end) {\n var ids = [];\n var search;\n\n if (this.options.timeField.start && this.options.timeField.end) {\n var startTimes = this._startTimeIndex.between(start, end);\n var endTimes = this._endTimeIndex.between(start, end);\n search = startTimes.concat(endTimes);\n } else {\n search = this._timeIndex.between(start, end);\n }\n\n for (var i = search.length - 1; i >= 0; i--) {\n ids.push(search[i].id);\n }\n\n return ids;\n },\n\n _buildTimeIndexes: function (geojson) {\n var i;\n var feature;\n if (this.options.timeField.start && this.options.timeField.end) {\n var startTimeEntries = [];\n var endTimeEntries = [];\n for (i = geojson.length - 1; i >= 0; i--) {\n feature = geojson[i];\n startTimeEntries.push({\n id: feature.id,\n value: new Date(feature.properties[this.options.timeField.start])\n });\n endTimeEntries.push({\n id: feature.id,\n value: new Date(feature.properties[this.options.timeField.end])\n });\n }\n this._startTimeIndex.bulkAdd(startTimeEntries);\n this._endTimeIndex.bulkAdd(endTimeEntries);\n } else {\n var timeEntries = [];\n for (i = geojson.length - 1; i >= 0; i--) {\n feature = geojson[i];\n timeEntries.push({\n id: feature.id,\n value: new Date(feature.properties[this.options.timeField])\n });\n }\n\n this._timeIndex.bulkAdd(timeEntries);\n }\n },\n\n _featureWithinTimeRange: function (feature) {\n if (!this.options.from || !this.options.to) {\n return true;\n }\n\n var from = +this.options.from.valueOf();\n var to = +this.options.to.valueOf();\n\n if (typeof this.options.timeField === 'string') {\n var date = +feature.properties[this.options.timeField];\n return (date >= from) && (date <= to);\n }\n\n if (this.options.timeField.start && this.options.timeField.end) {\n var startDate = +feature.properties[this.options.timeField.start];\n var endDate = +feature.properties[this.options.timeField.end];\n return ((startDate >= from) && (startDate <= to)) || ((endDate >= from) && (endDate <= to));\n }\n },\n\n _visibleZoom: function () {\n // check to see whether the current zoom level of the map is within the optional limit defined for the FeatureLayer\n if (!this._map) {\n return false;\n }\n var zoom = this._map.getZoom();\n if (zoom > this.options.maxZoom || zoom < this.options.minZoom) {\n return false;\n } else { return true; }\n },\n\n _handleZoomChange: function () {\n if (!this._visibleZoom()) {\n this.removeLayers(this._currentSnapshot);\n this._currentSnapshot = [];\n } else {\n /*\n for every cell in this._activeCells\n 1. Get the cache key for the coords of the cell\n 2. If this._cache[key] exists it will be an array of feature IDs.\n 3. Call this.addLayers(this._cache[key]) to instruct the feature layer to add the layers back.\n */\n for (var i in this._activeCells) {\n var coords = this._activeCells[i].coords;\n var key = this._cacheKey(coords);\n if (this._cache[key]) {\n this.addLayers(this._cache[key]);\n }\n }\n }\n },\n\n /**\n * Service Methods\n */\n\n authenticate: function (token) {\n this.service.authenticate(token);\n return this;\n },\n\n metadata: function (callback, context) {\n this.service.metadata(callback, context);\n return this;\n },\n\n query: function () {\n return this.service.query();\n },\n\n _getMetadata: function (callback) {\n if (this._metadata) {\n var error;\n callback(error, this._metadata);\n } else {\n this.metadata(L.Util.bind(function (error, response) {\n this._metadata = response;\n callback(error, this._metadata);\n }, this));\n }\n },\n\n addFeature: function (feature, callback, context) {\n this._getMetadata(L.Util.bind(function (error, metadata) {\n if (error) {\n if (callback) { callback.call(this, error, null); }\n return;\n }\n\n this.service.addFeature(feature, L.Util.bind(function (error, response) {\n if (!error) {\n // assign ID from result to appropriate objectid field from service metadata\n feature.properties[metadata.objectIdField] = response.objectId;\n\n // we also need to update the geojson id for createLayers() to function\n feature.id = response.objectId;\n this.createLayers([feature]);\n }\n\n if (callback) {\n callback.call(context, error, response);\n }\n }, this));\n }, this));\n },\n\n updateFeature: function (feature, callback, context) {\n this.service.updateFeature(feature, function (error, response) {\n if (!error) {\n this.removeLayers([feature.id], true);\n this.createLayers([feature]);\n }\n\n if (callback) {\n callback.call(context, error, response);\n }\n }, this);\n },\n\n deleteFeature: function (id, callback, context) {\n this.service.deleteFeature(id, function (error, response) {\n if (!error && response.objectId) {\n this.removeLayers([response.objectId], true);\n }\n if (callback) {\n callback.call(context, error, response);\n }\n }, this);\n },\n\n deleteFeatures: function (ids, callback, context) {\n return this.service.deleteFeatures(ids, function (error, response) {\n if (!error && response.length > 0) {\n for (var i = 0; i < response.length; i++) {\n this.removeLayers([response[i].objectId], true);\n }\n }\n if (callback) {\n callback.call(context, error, response);\n }\n }, this);\n }\n});\n","import L from 'leaflet';\nimport { FeatureManager } from './FeatureManager';\n\nexport var FeatureLayer = FeatureManager.extend({\n\n options: {\n cacheLayers: true\n },\n\n /**\n * Constructor\n */\n initialize: function (options) {\n FeatureManager.prototype.initialize.call(this, options);\n this._originalStyle = this.options.style;\n this._layers = {};\n },\n\n /**\n * Layer Interface\n */\n\n onRemove: function (map) {\n for (var i in this._layers) {\n map.removeLayer(this._layers[i]);\n }\n\n return FeatureManager.prototype.onRemove.call(this, map);\n },\n\n createNewLayer: function (geojson) {\n var layer = L.GeoJSON.geometryToLayer(geojson, this.options);\n layer.defaultOptions = layer.options;\n return layer;\n },\n\n _updateLayer: function (layer, geojson) {\n // convert the geojson coordinates into a Leaflet LatLng array/nested arrays\n // pass it to setLatLngs to update layer geometries\n var latlngs = [];\n var coordsToLatLng = this.options.coordsToLatLng || L.GeoJSON.coordsToLatLng;\n\n // copy new attributes, if present\n if (geojson.properties) {\n layer.feature.properties = geojson.properties;\n }\n\n switch (geojson.geometry.type) {\n case 'Point':\n latlngs = L.GeoJSON.coordsToLatLng(geojson.geometry.coordinates);\n layer.setLatLng(latlngs);\n break;\n case 'LineString':\n latlngs = L.GeoJSON.coordsToLatLngs(geojson.geometry.coordinates, 0, coordsToLatLng);\n layer.setLatLngs(latlngs);\n break;\n case 'MultiLineString':\n latlngs = L.GeoJSON.coordsToLatLngs(geojson.geometry.coordinates, 1, coordsToLatLng);\n layer.setLatLngs(latlngs);\n break;\n case 'Polygon':\n latlngs = L.GeoJSON.coordsToLatLngs(geojson.geometry.coordinates, 1, coordsToLatLng);\n layer.setLatLngs(latlngs);\n break;\n case 'MultiPolygon':\n latlngs = L.GeoJSON.coordsToLatLngs(geojson.geometry.coordinates, 2, coordsToLatLng);\n layer.setLatLngs(latlngs);\n break;\n }\n },\n\n /**\n * Feature Management Methods\n */\n\n createLayers: function (features) {\n for (var i = features.length - 1; i >= 0; i--) {\n var geojson = features[i];\n\n var layer = this._layers[geojson.id];\n var newLayer;\n\n if (this._visibleZoom() && layer && !this._map.hasLayer(layer)) {\n this._map.addLayer(layer);\n }\n\n // update geometry if necessary\n if (layer && this.options.simplifyFactor > 0 && (layer.setLatLngs || layer.setLatLng)) {\n this._updateLayer(layer, geojson);\n }\n\n if (!layer) {\n newLayer = this.createNewLayer(geojson);\n newLayer.feature = geojson;\n\n // bubble events from individual layers to the feature layer\n newLayer.addEventParent(this);\n\n if (this.options.onEachFeature) {\n this.options.onEachFeature(newLayer.feature, newLayer);\n }\n\n // cache the layer\n this._layers[newLayer.feature.id] = newLayer;\n\n // style the layer\n this.setFeatureStyle(newLayer.feature.id, this.options.style);\n\n this.fire('createfeature', {\n feature: newLayer.feature\n }, true);\n\n // add the layer if the current zoom level is inside the range defined for the layer, it is within the current time bounds or our layer is not time enabled\n if (this._visibleZoom() && (!this.options.timeField || (this.options.timeField && this._featureWithinTimeRange(geojson)))) {\n this._map.addLayer(newLayer);\n }\n }\n }\n },\n\n addLayers: function (ids) {\n for (var i = ids.length - 1; i >= 0; i--) {\n var layer = this._layers[ids[i]];\n if (layer) {\n this.fire('addfeature', {\n feature: layer.feature\n }, true);\n this._map.addLayer(layer);\n }\n }\n },\n\n removeLayers: function (ids, permanent) {\n for (var i = ids.length - 1; i >= 0; i--) {\n var id = ids[i];\n var layer = this._layers[id];\n if (layer) {\n this.fire('removefeature', {\n feature: layer.feature,\n permanent: permanent\n }, true);\n this._map.removeLayer(layer);\n }\n if (layer && permanent) {\n delete this._layers[id];\n }\n }\n },\n\n cellEnter: function (bounds, coords) {\n if (!this._zooming && this._map) {\n L.Util.requestAnimFrame(L.Util.bind(function () {\n var cacheKey = this._cacheKey(coords);\n var cellKey = this._cellCoordsToKey(coords);\n var layers = this._cache[cacheKey];\n if (this._activeCells[cellKey] && layers) {\n this.addLayers(layers);\n }\n }, this));\n }\n },\n\n cellLeave: function (bounds, coords) {\n if (!this._zooming) {\n L.Util.requestAnimFrame(L.Util.bind(function () {\n if (this._map) {\n var cacheKey = this._cacheKey(coords);\n var cellKey = this._cellCoordsToKey(coords);\n var layers = this._cache[cacheKey];\n var mapBounds = this._map.getBounds();\n if (!this._activeCells[cellKey] && layers) {\n var removable = true;\n\n for (var i = 0; i < layers.length; i++) {\n var layer = this._layers[layers[i]];\n if (layer && layer.getBounds && mapBounds.intersects(layer.getBounds())) {\n removable = false;\n }\n }\n\n if (removable) {\n this.removeLayers(layers, !this.options.cacheLayers);\n }\n\n if (!this.options.cacheLayers && removable) {\n delete this._cache[cacheKey];\n delete this._cells[cellKey];\n delete this._activeCells[cellKey];\n }\n }\n }\n }, this));\n }\n },\n\n /**\n * Styling Methods\n */\n\n resetStyle: function () {\n this.options.style = this._originalStyle;\n this.eachFeature(function (layer) {\n this.resetFeatureStyle(layer.feature.id);\n }, this);\n return this;\n },\n\n setStyle: function (style) {\n this.options.style = style;\n this.eachFeature(function (layer) {\n this.setFeatureStyle(layer.feature.id, style);\n }, this);\n return this;\n },\n\n resetFeatureStyle: function (id) {\n var layer = this._layers[id];\n var style = this._originalStyle || L.Path.prototype.options;\n if (layer) {\n L.Util.extend(layer.options, layer.defaultOptions);\n this.setFeatureStyle(id, style);\n }\n return this;\n },\n\n setFeatureStyle: function (id, style) {\n var layer = this._layers[id];\n if (typeof style === 'function') {\n style = style(layer.feature);\n }\n if (layer.setStyle) {\n layer.setStyle(style);\n }\n return this;\n },\n\n /**\n * Utility Methods\n */\n\n eachFeature: function (fn, context) {\n for (var i in this._layers) {\n fn.call(context, this._layers[i]);\n }\n return this;\n },\n\n getFeature: function (id) {\n return this._layers[id];\n },\n\n bringToBack: function () {\n this.eachFeature(function (layer) {\n if (layer.bringToBack) {\n layer.bringToBack();\n }\n });\n },\n\n bringToFront: function () {\n this.eachFeature(function (layer) {\n if (layer.bringToFront) {\n layer.bringToFront();\n }\n });\n },\n\n redraw: function (id) {\n if (id) {\n this._redraw(id);\n }\n return this;\n },\n\n _redraw: function (id) {\n var layer = this._layers[id];\n var geojson = layer.feature;\n\n // if this looks like a marker\n if (layer && layer.setIcon && this.options.pointToLayer) {\n // update custom symbology, if necessary\n if (this.options.pointToLayer) {\n var getIcon = this.options.pointToLayer(geojson, L.latLng(geojson.geometry.coordinates[1], geojson.geometry.coordinates[0]));\n var updatedIcon = getIcon.options.icon;\n layer.setIcon(updatedIcon);\n }\n }\n\n // looks like a vector marker (circleMarker)\n if (layer && layer.setStyle && this.options.pointToLayer) {\n var getStyle = this.options.pointToLayer(geojson, L.latLng(geojson.geometry.coordinates[1], geojson.geometry.coordinates[0]));\n var updatedStyle = getStyle.options;\n this.setFeatureStyle(geojson.id, updatedStyle);\n }\n\n // looks like a path (polygon/polyline)\n if (layer && layer.setStyle && this.options.style) {\n this.resetStyle(geojson.id);\n }\n }\n});\n\nexport function featureLayer (options) {\n return new FeatureLayer(options);\n}\n\nexport default featureLayer;\n"],"names":["pointsEqual","a","b","i","length","closeRing","coordinates","push","ringIsClockwise","ringToTest","pt2","total","rLength","pt1","vertexIntersectsVertex","a1","a2","b1","b2","uaT","ubT","uB","ua","ub","arrayIntersectsArray","j","coordinatesContainPoint","point","contains","l","coordinatesContainCoordinates","outer","inner","intersects","convertRingsToGeoJSON","rings","x","outerRing","hole","outerRings","holes","r","ring","slice","polygon","uncontainedHoles","pop","contained","reverse","type","orientRings","poly","output","shift","flattenMultiPolygonRings","shallowClone","obj","target","hasOwnProperty","arcgisToGeoJSON","arcgis","idAttribute","geojson","y","points","paths","geometry","attributes","properties","id","OBJECTID","FID","geojsonToArcGIS","spatialReference","wkid","result","features","geometries","idAttr","g2a","a2g","extentToBounds","extent","sw","L","latLng","ymin","xmin","ne","ymax","xmax","latLngBounds","boundsToExtent","bounds","getSouthWest","lng","lat","getNorthEast","responseToFeatureCollection","response","objectIdField","objectIdFieldName","fields","name","featureCollection","results","feature","cleanUrl","url","Util","trim","isArcgisOnline","test","geojsonTypeToArcGIS","geoJsonType","arcgisGeometryType","warn","console","apply","arguments","serialize","params","data","f","key","value","param","Object","prototype","toString","call","JSON","stringify","join","valueOf","encodeURIComponent","createRequest","callback","context","httpRequest","window","XMLHttpRequest","onerror","e","onreadystatechange","falseFn","error","code","message","readyState","parse","responseText","ontimeout","this","xmlHttpPost","open","options","timeout","setRequestHeader","send","xmlHttpGet","request","paramString","requestLength","Support","cors","jsonp","_EsriLeafletCallbacks","callbackId","callbacks","responseType","script","DomUtil","create","document","body","src","abort","_callback","task","Task","query","Query","find","Find","identify","Identify","identifyFeatures","IdentifyFeatures","identifyImage","IdentifyImage","service","Service","mapService","MapService","imageService","ImageService","featureLayerService","FeatureLayerService","logo","Logo","basemapLayer","BasemapLayer","tiledMapLayer","TiledMapLayer","imageMapLayer","ImageMapLayer","dynamicMapLayer","DynamicMapLayer","BinarySearchIndex","values","concat","featureLayer","FeatureLayer","pointerEvents","documentElement","style","get","CORS","JSONP","Request","post","Class","extend","proxy","useCors","generateSetter","bind","initialize","endpoint","_service","setOptions","setters","setter","token","authenticate","path","_request","method","offset","limit","precision","featureIds","returnGeometry","where","outSr","outFields","within","_setGeometry","spatialRel","crosses","touches","overlaps","nearby","latlng","radius","geometryType","units","distance","inSr","string","between","start","end","time","simplify","map","factor","mapWidth","Math","abs","getBounds","getWest","getEast","maxAllowableOffset","getSize","orderBy","fieldName","order","orderByFields","run","_cleanParams","_trapSQLerrors","count","returnCountOnly","ids","returnIdsOnly","objectIds","returnExtentOnly","pixelSize","layer","LatLngBounds","getLatLng","LatLng","GeoJSON","getLayers","toGeoJSON","text","sr","layers","dynamicLayers","returnZ","returnM","gdbVersion","layerDefs","tolerance","on","size","imageDisplay","mapExtent","at","layerDef","undefined","layerId","setMosaicRule","setRenderingRule","setPixelSize","returnCatalogItems","getMosaicRule","mosaicRule","getRenderingRule","renderingRule","getPixelSize","_responseToGeoJSON","location","catalogItems","catalogItemVisibilities","geoJSON","pixel","crs","objectId","Values","catalogItemVisibility","Evented","_requestQueue","_authenticating","metadata","_runQueue","getTimeout","setTimeout","fire","wrappedCallback","_createServiceCallback","addFeature","addResults","updateFeature","updateResults","deleteFeature","deleteResults","deleteFeatures","Control","position","marginTop","marginLeft","marginBottom","marginRight","onAdd","div","innerHTML","tileProtocol","protocol","TileLayer","statics","TILES","Streets","urlTemplate","attributionUrl","hideLogo","logoPosition","minZoom","maxZoom","subdomains","attribution","Topographic","Oceans","OceansLabels","pane","NationalGeographic","DarkGray","DarkGrayLabels","Gray","GrayLabels","Imagery","ImageryLabels","ImageryTransportation","ShadedRelief","ShadedReliefLabels","Terrain","TerrainLabels","USATopo","config","Error","tileOptions","_getAttributionData","_logo","_hasEsriLogo","addTo","_initPane","_updateMapAttribution","onRemove","_container","removeControl","off","getAttribution","_map","getPane","createPane","zIndex","attributions","_attributions","c","contributors","contributor","coverageAreas","coverageArea","southWest","bbox","northEast","score","zoomMin","zoomMax","sort","attributionControl","newAttributions","zoom","getZoom","match","substr","attributionElement","querySelector","maxWidth","zoomOffsetAllowance","MercatorZoomLevels","0","1","2","3","4","5","6","7","8","9","10","11","12","13","14","15","16","17","18","19","20","21","22","23","tileUrl","addEventParent","arcgisonline","RegExp","replace","getTileUrl","tilePoint","template","s","_getSubdomain","z","_lodMap","createTile","coords","done","tile","createElement","DomEvent","_tileOnLoad","_tileOnError","crossOrigin","alt","once","CRS","EPSG3857","latestWkid","arcgisLODs","tileInfo","lods","correctResolutions","arcgisLOD","ci","correctRes","_withinPercentage","resolution","level","tokenQs","percentage","diff","Overlay","ImageOverlay","_topLeft","getPixelBounds","min","_reset","setPosition","_image","subtract","getPixelOrigin","RasterLayer","Layer","opacity","interactive","_update","throttle","updateInterval","_currentImage","_bounds","equals","addLayer","removeLayer","_popup","_getPopupData","_resetPopupState","bindPopup","fn","popupOptions","_shouldRenderPopup","_lastClick","popup","_popupFunction","unbindPopup","closePopup","bringToFront","bringToBack","getOpacity","setOpacity","getTimeRange","from","to","setTimeRange","_renderImage","image","newImage","oldImage","_animatingZoom","_panTransition","_inProgress","_buildExportParams","_requestExport","_renderPopup","content","setLatLng","setContent","openOn","format","transparent","setPixelType","pixelType","getPixelType","setBandIds","bandIds","isArray","getBandIds","setNoData","noData","noDataInterpretation","getNoData","getNoDataInterpretation","identifyRequest","project","_northEast","_southWest","top","latLngToLayerPoint","bottom","parseInt","split","bboxSR","imageSR","interpolation","compressionQuality","href","getParamString","timeOptions","getDynamicLayers","setDynamicLayers","setLayers","getLayerDefs","setLayerDefs","getTimeOptions","setTimeOptions","dpi","VirtualGrid","cellSize","_zooming","removeEventListener","getEvents","_removeCells","events","moveend","zoomstart","_zoomstart","zoomend","removeFrom","_cells","_activeCells","_cellsToLoad","_cellsTotal","_cellNumBounds","_getCellNumBounds","_resetWrap","infinite","_getCellSize","wrapLng","_wrapLng","floor","ceil","wrapLat","_wrapLat","cellBounds","divideBy","max","_removeOtherCells","_addCells","queue","center","getCenter","_isValidCell","cellsToLoad","distanceTo","_addCell","_cellCoordsToBounds","nwPoint","multiplyBy","sePoint","add","nw","wrapLatLng","unproject","se","_cellCoordsToKey","_keyToCellCoords","kArr","_removeCell","cell","cellLeave","_wrapCoords","cellEnter","createCell","wrapNum","getPixelWorldBounds","index","getIndex","dirty","currentIndex","currentElement","minIndex","maxIndex","round","startIndex","endIndex","insert","item","splice","bulkAdd","items","FeatureManager","timeField","timeFilterMode","simplifyFactor","oidCheck","_startTimeIndex","_endTimeIndex","_timeIndex","_cache","_currentSnapshot","_activeRequests","_handleZoomChange","_requestFeatures","_buildQuery","exceededTransferLimit","requestAnimFrame","_addFeatures","_postProcessFeatures","_cacheKey","_buildTimeIndexes","createLayers","setWhere","oldSnapshot","newSnapshot","pendingRequests","requestError","requestCallback","removeLayers","addLayers","getWhere","oldFrom","oldTo","_filterExistingFeatures","refresh","redraw","eachFeature","_redraw","newFrom","newTo","layersToRemove","_getFeaturesInTimeRange","layersToAdd","indexOf","shouldRemoveLayer","search","startTimes","endTimes","startTimeEntries","endTimeEntries","Date","timeEntries","_featureWithinTimeRange","date","startDate","endDate","_visibleZoom","_getMetadata","_metadata","cacheLayers","_originalStyle","_layers","createNewLayer","geometryToLayer","defaultOptions","_updateLayer","latlngs","coordsToLatLng","coordsToLatLngs","setLatLngs","newLayer","hasLayer","onEachFeature","setFeatureStyle","permanent","cacheKey","cellKey","mapBounds","removable","resetStyle","resetFeatureStyle","setStyle","Path","getFeature","setIcon","pointToLayer","getIcon","updatedIcon","icon","getStyle","updatedStyle"],"mappings":"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"} \ No newline at end of file diff --git a/esri-leaflet-v2.0.0.zip b/esri-leaflet-v2.0.0.zip new file mode 100644 index 0000000000000000000000000000000000000000..c43357c02ed6d335886ac5a5fca10deb7ae44c09 GIT binary patch literal 148734 zcmV)YK&-z|O9KQ70000008Ub*NB{r;000000000000jUX0Ay)%bT3s@2>=7*E-F{{ zE-F`bcnbgl1kA#^9R#ewPIXXA0|XQR000O8R#K!$zfa2HjZy&scisj78UP#sWNCAB zFJ*IbX)SDJVP=81E-F{`E-F`bcnbgl1kA#^9R#ewPIcTo z{d3zkvOhO}1(JIcQL#ixZra|H>dUx}o4U`9GqHQU8=t2GNsvT`B6TDcS=ab~f4hqh zE=bCDnqIH(b*8ZhEEcRO(qyTULdN2J zn-^-Ci?=FQGMg;KNs<>)u`W~xeojI}a=4O{h3dle;#u!eFk2^+B1#hx%;R({YwWWAR6Ww5q7!lAojsbwL7-4-5x!<4T?ns%#@AX=_tkXn?8Q()rs(luR)p*Tgr_c9ajRhA>l1M!3uas zrs*d9+YhJT6~*c;2vp?-3aPb;ip5c;rl1RvjB}bRQ5(@XB4{HkgnE@mNujdi_b?FW zn5L68DpY8H9LI{D^I{vTumX;Y)v{EcuU9AuKmy7mi0C2x+rdX~3fxfs&<(44ROT{M{f)$AtuV2_shUG~=w?eLfvWXl6y|LVg zG!t^3Dd;Owq1tB2Q<&&A346Y5p#@!i>v7viVGw{H($Uz{ADi?g@l=s)?d=&jfwKhiGP)wqIEEjtN5FCx>ns6p73XTC z8*lLs{bM?dY>j=lRnn2US(Jg4MHgdzivnH)ICWgna^e`ddpG$6VSuG)@i4zOD1iwZU}O^<)pUy5O>3e*6I z6F}W6jkj~)f>>tY#6GY#dAEr`0m`2ukLC%e7J#In=oyVfKGx`px+NTFf0QH!fF_1z zU!>sww6loQIq2s`g4=+xQ?PSu+j$`;?@(Q5F?e0@B0X}rsGPmQ;L9(*eEwB$k#4$0 z+I75iqghvWV=%yOI_ny)x-_j8e-{|)MoCFv7kE_}TS%nyBtLQt1lVwqUcl651yE;; z6!QesTiX(OPuZznxdTxSx4La%R>i>U2gPQ6`y*#0kv0yC6STp%4*;$p5__OA#vC-M zdl2&g4)g=Y!_25CVDZ#8xB_@=8yMvghBiwDSEfMY`wMW}F0~1x6}Y=umM#UXMJ9pp zrOLwVoR%|(^_+tbTaRfWF%I=EO0eD-(t_R+3=n?%!~b;pMgMvC^ozlNvo!*xDAdgf zs#*>?RQ^|b1}8D-2)Pd~2L6us*>bJr1qS`G;eYJdm&mkk0p{Tc!tfRi!$!F!T8{~* zG&toQIHkcU@5T9zA+t(?KS{Td6>kzu0<_}+oai_EPF=J>U?P-C59S=P_A$1PZF}i| zVE`^UCP?t}>jN>MpX0K1Os#d-Y`ib?%uJiC-~JucXnz1|^!b3PkpzfssYQqQ_}~y# zH$w+~t)Z_0dh9`8GiWW=W=*DO2dZog83?+(*8kFTn;~fuvk~-vR^HFQ>UU3{|GCd& zWEohF(gc&eH|UhTh}qGOn%V9|gJMQqMtN^#x?t|;jO&rJLu(Oh>F@2~`o$w^i@fY2 z@M36mg_Z=`Or+p%&~NwqYcE<~Uy+S|_)sp0$BzbhATpX5R`==C5?i2Q`v_Y_OdgrTSq$l$z@2(^m#huEybI>l;tfBtX z>7f5*_jEA${7ywZVmVPj8Ba&&HB3<>XT>0mCg0)@95pET4h!)Hx`07hC7TrV%A#^B zRCNxwyM4hlg=B4OQ^6byAj;5)6N{NZQYuE80bdZVHP)4Aqm*o8QaLkeAA##dpo}H| z11ZAbD^P^5_B};N&_iQhpI@Y}RQmn-*=wB==4|C@c?byB@UqO}G{aug%}4;h5x~nL z&1wj!ce2hhsO4E^EyfD}RqtiI2IZLY3A`cLPyk(Xw1VT~8U%Hc1v+a6h1=BsWA01@==;LW`{t z(ENH`bU{?sLlzxD*P=9~V2QCcHT{n1k6Fac0(V!?02LKyTE${DE5Z;9bOR7*YP9g3 zB*@ZMP}-83q_Y`vC8*HS0Mve9SxHwx+vb2UG)`eG7Gy%kF_#CG#<^0arY@aDx;C|5 zsX>l6FPs})yn#lx7(8{lp+pn@cDrn09k4g>@&?0{TVB+VJ3V^fhIWWtKfeObvEC=q zfC`oj&{9UY$3^PlRID88k)&0F@Q+FmE)Oq-6Jnex`L3SQx%D6|28wX=twdvev|Anr zpQlSzL`!8%Y#~=GmF#w@e51V=BBB;c0wq?=QSNs|QztRTkjQkpNKu#Q`P4?g=4aOjT7mL`P zp!{bH!4t&CSVAQYYLbP~!b_5Urtok;1?{T_jYMR1dE@5%pqf*;Y4Fr#C|Ykc)2&V! zDsM*BN;NSy-)wXp&|TWD(kn z=uJ*MJD5h9qG38&^HiPh4|a^vQe!3XRnkJ8SD~8Pr0R`LCqah}v&pNIbJxTYGEJaP zwJ1*eS=ee__~}*|_3@X>QbufyGnX=}F{8qK5zUIAT}f^{9kD6`w)osDDIZsp5;vsX zq@tx-j(qjjTxkU^QFuh6>YWV`fXu1*l zSR8dT(Fa*GC1C($&RM#`B~UuRf>`w-n_ej@9nHzXbq;_t%484?P|=l1S0nE6^3Ke8 zgmeAZ0IYg^&G-0aHdk~8ds|%)%xxX4@d)GVa3S-vP4Y$)x(y<302&*fVjbXEyV>7# zTt$#ZGHkOF>s42TBDuP$Bckb{6$T@JuF~tAwBeWAayQsq5zs@!8-4Date0bz@v8`? zf9v%-ZVc)Wf$>zHHYr*ozmp#$fl}KUI}Z2N$d9|GT_4o!oXc3!y%T!ad_ApCDT_t! zttRhi&I0O`okB8nUZB#qMpc+*+7LUW163=kR+fz-_;s_@rfQT2cTIvRQsZ`rH>eUm zYM22R6d{nlfB0bODh+w(nt!WZKy|?#vV$7_ws=vum^#oIg&AVti6wg23|I*~H6me7z%3k_l za=+S}<(mj=#egeIc}6b5fQ(-nS}|*6==7Q_g%?N$a=Qa^P=jpXsM_R)@M=cW$$VOs zSaTtvk&b%w{Y|K0o~1?&`VjQycTw~25Y7W=`uzlC3$ZFCnb`s6+1FiE{l;W@MdB{n zcIBhLC!yAzI~vhHR-Jm~jFYBi4!`E0Y6yHsRV^bN&eBh!x39;526x{CG_)S7%1<~Qg^@N?wvxOZqM_4kF8v1a z*Litm7VcA-F$xfUGCL)rk7LLSuzIR{;%hCs8fyI@T_@3j-%~AAYXu+uu0*Md{SQ#3 z{UK{KI_IIx7>}&fO@SwIfnKXNZV#Nw;xw6mgBRSO@ITdi>TSlN9&?de5dF;f%r`*N zX&4hC(;aS?5omyUxPgaqUkk5)H^9pq1}|?kykW^gYZ`)l(*Z2)Mi!g-K~5{oGZx1L zeUTm;2>onW)DMhgLxch1WSYflA-}Dm840FZoTuwz@e^Ii4&!8Qc1c^?JK6P|X%#~89JQJSPmjA%wFee1{M8GJb zjmbj@omR;_q`AkEZG*ziHR=$SyUp)PwoqRt49XQCb6w7CEk?DiMH@d3s?jL$k_t~^ zWe~2(r_5+5#+#>xT@QN~ri#FrqCWM?qNP}8F&;5OBwNXe(!p&C|3j~gV%!+bV~OWr zGjN+~igz^Fyjs1q-C(UHuFpEsv)9sy`q?EJzi4 z%^!;>4iO*C;BE^vQV4F^V6d0q*SP|Jv5X2j`YG%>1H>i#&u^jYmy>#>fgqMWYO1F` z&{y?nQGQ6vdzQp_^_#`WN4dE}lVa^cuK^eWWgHb-v6Syn+E90IQRhK!w~${t8% z(2gyTIv!#CpKbHDRv)@qaX;E0^r6c=xSPuShmag^QJwCk`rn7XR(3xOEe`qUivE*O zdj{I5Ri27&B}Uf*b#HdJisluc+Lb_ubHa z*^tK5{h{|n5e*R!>0f%Zu65{sQM2!7hLvXmX|TRwQ)5R9Y-c7mysOijsWuCrp%V6n z)rL-)C)*@?Sa~K8zmynOp3UolbQ22%JC^t=6ur2@3oeyG<{JGA{PRj?a>-9Ar?S9T z2lT6oLg@Z*hNpt|C+_)@3)UbmD|n~yE{yO{YNawmE2SC0*DmoPpquLwAj<6kDhIVO zoKcp5`!hv~O<|F0vk#GJJzd)yh<7F3%^OV=a$3!B@IR6OhP2sNvf+qCxz2aiHQ#r|QSICr9ZLY!fVi)Jg1#)m_}^EqNBt>hP2a6{SO8zjtD+v$dQ z1()&nxWr6ZCv@Gy1|2YF>AxGSeV!P5oPbDyV-2I_|8Wc1fbpiv{e^Xu99is z5+9rQv_EorU#Z`HbzdEu#l_h60%Kc^iw@nV{eQCfuuLY1+_^Hno;dve@NWXb$TU`2 zPH8ClzF-L|0At2kx&cu^CJH_1I^T#Ojq#%guE*PoH9`Ktt4lCCk;CKB>Y|K3K?`&M zBoOzWdB9bG&E0mdotr%&JTH+My=)(;LBBT`i1B)kdt3Nwkp4P`xfo1WfDLI7Mo{4} zj3|($!hI#Pl=$w~iatkS70f5@>jSah@6%ht=EEi-e#@jeh1sFhoFmPOw{Og+`^(49 z<~hh3%x~v!ZvQVDpwSwu2KdPa`~(T8Mxx~mnOY_%c>P}QVS>&W1F~CiIT>Duw$%hI ztwToNgYgrQPuHNTi)bKziTeAiIY4!}kA>etIf;?F-hUE5(^TmfhV1Sr<4YPZm_2|E zwjhri88MC-_W@S-`OHSXQb_-^Phu)g=fD&06q&c6{BjaIf|hiX7O6l-W1J3slH`6O zfKp4vL?%ds5#=OH^SnDvm-rss3bQ^lPbl8R3U~MLdr1<{%Wt;!NF4X@Lh~M0l=^RA z$yL|tWhB3l&8*cJ9#=Jjp9JMtD#NKJHrVb zdQDL5ZZ~Sgwv}unLfwTvBgOBuOC;CzxrtAdK)m+6w~V4W=nE#1}9`zxLD z%X8y&y47T82zR3z3GQ9X_tK2yFnKn?_aE=7C^$G>TCN(OGv~cMFHyHvH65}cMtjz{ zi(k@UTICo#`mm`Szgw>1&vpVX;h?sm)x4c$6LOkeP0Nju+v*;IJHycTkb=Muhc9?( zIMn_YQ2=yE<;Vd8Fzwnf4m9vc7c=_Ph!plLZN`!yZXtuzHH~HzAqv0lnJUQe=M)8z z(z4q4MK29K4($(fW>MfdMPWWTh}~=pgB>GW$ow7YDTo=znZ(lh4GMNc z{hF&?^jsaeuN#s`J2o451=U7|8+H;FrdXuY@(Tv~8LyBGNh9%>eP5f}851szP#A2erkuJD=lEc)^oKw2%T zRCb2@D2WPfahysJEdMwT3CXt6Avx4&=1YN+>^Hz9#VkUb1Ohsn9@`0nttx+T00zt!s1h`I7nB9OsJz2kPWv1Pm*8rU#oZgVu0bsa4Je z?i*ivV!efD>K%P~!k!zJT(Lrsy>74XI-0MInhZt1@=RK$t&wdM8VI*%X)ObmocHSw zqq6tPt(F=^Ho6XZrp)yRCApFtA3$G&TeDt*+To~XKfC!jrff#Ms9O?<*BlV)naRz zA1#ONp@0YmCItw=S9RX!zQ%pB z8xgZ_79iQq%&M<)j4F$@=9>MC8SO84PZ@Izmmaar`ZF;*Z%E)ZYh)LgyKF*?mpA%x zG1#|Gyqcd`cYZmk67;NiW0>^u4m^8pl4jlj+9L51f2|Q&!PDGrh7@gq@72|gydOLH z@@9Xv`1~23z4}4^CH!CsQx>1IKg46^J4xj?>n!^r-Yp-7{mF{_|H+?=`LxJ~vI^#G zk>}NL&p=fT8=vrQ!7|npQIL){zGr`EyBaqNJpT=+;gxuVQ~!g>B8Vz~ApV`#yG4*5 z_&WMiR5S%+tv)cnU-g8I9t!?dZyFU#6NBzKkuicWtVQ#x$dArNq+)gg;Vx8_PdFyd z>J@<&k;feAF_1+*L(}P5(A~l9z&drNLTtD%VRt!Uw;+9rAFN~{h2BDS93-6z#^ZMy zxB@^C&Kw~<6NC7j`qiX~KDHckW}mkpd=-x`2Pv_Jzt@=4thFNxv0iNYrYAYYdM#d*}`(8+8w|$9fbBd*U0c7T5PPD@73(XX5Yf`j-P=9ra>; zIWf?`+{`Bwh|4~z)Zyo^B?O-K6-EsBE(?rg^WrHpnO9K*g_ptMh2$5BnsVlVrHg?m zx*=U)Rv`gZGFWVS!SMUvHVX`I1k!+LTEXy)JwP^MwL(oC%1S6I0!#IX4(45EQJBop zjzzxKLN!8|R%aKH2nNO0vK z?ci>qV#;%jK2Se@Io#}u#HP>2Zk~0QBKL*Cm%{VrWI&eI5-fA*}Y!^=l=E;@aM0NH-g~hKifV3 z!k&NENaC_}^Y%te?^bg=sRa{%(< zA2gQroM{#d-RIG|=Y#A~aV?`WR95R(})NFr*D zbOn>AVNkWS_@)YroUbr`f7bfWnIYjFg^7X2g^U-9bt6bz5+vG^ps>lldIop z%z@MiLgP&IgxmWaQ;QsK+9a@sHN&vUl3BsB(#mJ&B>0jh4p>h!hJaR;`EsCszQ35w zFob0XlJOI_^1{VJT^0B8iZicW0+(eBDznrOJ|N?oIg_k&)&}>ihf}yDTR$LP^gy4{9{Y%HSGwCG*KB3}vq}QP+>HhrdfY2PJ@S zQP$SX=mswB&vFbT(yLz})XM|pj)~c?p)Vr*?QFSWFw0unE>YRB@$fp#t@SVj)^ajZ z+DxH46PPJ1*68f@mLaV}>CFr&1-Zr&JtgoHe*FST!Q^asi5y)>AfRw3v*O^l7Q6Q6}c8GBI03bPqCj8?Ah4d>xDb_5ZMRC8RD%TURYxV&EpB%b;kG2=0T1H{ifOR ze0xR{y0DB~O#wFZxM;1Dt=`K5&4^FY%!Q^sFCxV#3ZN)77_=6RA zC9Di+A(MYg+Zoi2FIb{njEM7?_}EKfq={a_)+;W4sCvh|a6kgKPo* zG#?OeN=@>=o^1XE zzfQJr0-rYU8#q^{y;9l1G)w0JBPbt*=UIt6f@z(hMY|e)HdyA#;4RaDdwEj%iLHs0 zFKjKO`T}H_A44^eS~1i<%3esd;}6Hwj{o-R<&*WQzk|I0McOw<#COOro{s}m7>TWq z2sKtc^|5K;4vD5<(@*Q)$y zv?hmiU)&e}xw`)7tLt?XTHzi2gD)_&8qQ|J!KAw$2B?&H1pbS~3?il(ekY3h6rjg$ zKpE@lGbky+LhH?9dNyBhwP-M0ug>l_80CPfjUkt*h6=jx{9I~iJV-2lSi;jUVxy-f z)SwO>!5?`O$M|xj9KZq$g9El92*ayTkg&W1Tz^AHEj7hXhF&B4EJpeDaJEtxzwz`da0&K(Zwoiy;(oK>nB{ymt_b;sRh6-ePOZ(@X;y`weCE7EmB|hH zXO)^n5P+c8LJxaHSW=D(%D{*!R2nbC;6mN7Kp7<0Q&NbLvXg(XTr4*M#<}#_LByoE zGaySWYvLPTYBqcrQJzbd*0Qe-Z3Ec<-XxeXtnn3#rCtu1@|L2+G_9>WMtu#ONkj@4 zEEuGNPSeFRjpNpOWL#VNbANGT0RAuaB3dP4IyGwyBYv-p!}|(#tFII|ux_J~g48Q3 zs#kvGm~}`MC@nis5|CYw-KJ z6NGwv-XJ@-X^~+#XSjj%lH4Nx(}8L%MLhw8>gNH0OtjyUjq)^aoui{{q+VWeK~@ip zBW89+f2C*m^7Y5&APwfx;6aZxZ~z25Y%X-xQ(pjIOS|wMn2hT`?agG|IJ_I2kqqS| z8S7_4gnGD0Dy9XF3l6d><3Wq(nMaCU{Icj_p^9NBHb0z2v##6YE4tMQSkq!u9UoDPMKOb#PYb*A2Lxgm z-0{#oy?GWT{gViL-cwU-ltT300K07GBVTW;AQT&b#$}jX+gu?epYe zD7OeH-(P9?sRU*b5_&4{dLcpb7R6)MogetWitAP&evA#=K41#>fq=Xaan`>wR1i*I z#oLnysq+=?j?iu_J3!hg>){T3yU+>P)=4bS+eV<5=^W|XpkHzz4+3?BOUhE`ic@X7nqDN6xHQhwk0xAF2wi2~ z&UUdc+u5o%OrApeOWvQET=qH7HKUvifzCW3#jUk_G)7zxw+ju6a*06EZ!8UAP9 zGWtwYRr+hLAkd{7lX&qV=-EfcD8cvp1TBc(i+U8uj=)X$s3^J>8Z))$9MH+=hJxNW z*iCJxo~A(wf#Y(O_wF^pV6m;4J?W~z|3a<{{7)hmv1#BxjUo*0NNs29d-uvQS1y!H zcrL>YE#$WtrvwtuVhksy1HyxI!TnmN>ybCv6@EgTvuPAkw zO5o&wnc}7pYY#E2wh`sEvt;Nfa;S#Sf)p8Fk(b}0&!~X@ohz2l)Cj|8NKJ#+sDq;V zk!gBUCT8_LQG+p5rEh?Ai1_RzN zBXE~JI>ZI>5D;OLoD9STr7WAaGp|aF<_cvffdh9Sdt(rEEv+2?^A}0SPGP-_zGX1pe7j|^oB0aMV0jCltmk{yLad&(5@_DUz;z+PoZ-EO@)|n3fBoh9ldhHP zMeDh44>;AjrG0mJaWPsj08(iDVG$S}D2@$bv6|o$xUzeT^?EUTn2g5K$~o(zvAMQb zDp*+ds5tz*wx6Zwd;4hx>oaW+i}~fi&l6HYwaKFw(ifhi23W@c|2}}BO4mIoaK2ja zg5kOBwylMeFG4=SVfnwoHz6Ofar-}G??OJLsqueDue8r5^ZD@Mx>hQp7s=ncXXA(A z=b!$mr6>g`5g(=D;z){q5WLuvvzm5HY;JAVnqzLzX7-rFchaA=t1fTO9rU z19^|~rvl42)m;r?;B?|>Q`Vpj`enLxt)Yd!I#jiMF;ms7=hgMYaJXI>_H>Y#Ys1+x zAnlRSb&Mo`_rF&EKCK9Ha_&cfPJi|{Zi@) z@fXmK#pt2C98db+a!Ik7-)lidTmL&Q=WT!3oqze^WDl&Bq`LVW)8D@$N%^)bs@j?T zX%_VT@4ukMZf_X;Zp$hitxjCqV{4&B2mYCsV%f#y!3>mT_&{DN#D;UWjHa9}Qkq>T ze0ZhGbTfB@-0<5HRA>j9_?0c#=_K{vP{pY}a^#k|29yVF zw)vk`d&a6&$KAnjP#Fdj#1;64+Ei-iSJu#sS;2BI3X|IY&%Qa?(oto(D<({*`4<`C826w>vstv^rn; z=+vv1XfpXWO9hongUr|B>b~KrNqkdPe(%hW#O8D*h`hzHvI-spvx8 z>3|?fM;eIpiUXjs7g%P3kUI>jh9#83*wcpz1?;mzdd5qN?b$66ZWkJ5fh-*75*=FL z*}1k~#3MIVD6je_d~L?=_*z(ToKvVyH(j5TLHcJX_KUCTkfI@>LhJFvVoQej40^x3 zepO`72YM|(oaH&BDEWS4QlN8`sR$q#I{X)I5&z5Ev%hH8RQ$<|H|j4&6Y;leEWoFz zs1X0EvO-0v|E=C~=3o2Md1o@|_(JD+?BD8hPRaj*0G@v_$ogMiDQ9oF%@ECDDBxB_ zj4jWhs`eFou68RDf?FAyYo=3W--w;0$I`Oz!(wi=I`zaPGLy18P{QkdG1na;2rL#3 z4T2Kwpvw8^Y_k+iDz^!h(p^=kr-$I(*Um<0*C<+M!t%f(d_ND=S)FktQJuC>*CuP( zCGrJhO_^3!C-!bMTwkgZSKW0t)9|GCY5Dg3RkOeEb}@DIFt^ z^1K_>3EEFlbBGG|>$tn3EXMHA874N4UcR*jRV!WD><`bZjO-e}x24y5kzh9kJ zaSz~S>)>2tvy1ubSF^?AkcFSH517*`T#4G6SlM*^yNxDK-)M4_a&{|2Y%Oep@hpso z=)JgLxd&J1kc=mT))=M;v6s66rWV|t^`O_VA+f@NHAQSsNURx}_+L4S>`;%F!Z~17 za7RAv`-2OlhcFux`uX!$ol!PnhbGlLJYJVSXX|Lk%5vq^&ojEgtzeh2tj<6Eg|?Yi zU?pAAkk|TtJR~>7=*9Bs$1}V>Jd?%XkPU|OAI}C1I`W4Jv3B40f<=G&<6r*ngvaVb0Iu+F z?{Ex%e08oAtQK!saAmoBq{#ueW&mIr7WfGxup!i&7UA z&VltBBMj!@3S-_1<5q?4DzaE(V+t%;L?6EP;;s3~s=vUn2crx0%qk}mN{OLxuunN{ zZ`FX`Sf5Jy%V=Z|k4h7}J5nff%XXjiqW{z51|sYC5PKflMuX8L0q}lZ#<+$JKLUh2|Lv8jp=@D9%T|O;1)E=&$)dMvH$3zv8LpF z)?N3a6Y8gf+fC#5&MD@xIz$vN6sFG|M&^~aCES*b z$N;OmKOXo@#34KhsN&bgUgYq>PiKEUi=4ktyg_DV`Si*e=xVT-5ARZeU-dB-Vs6u<6xQL%e;_+ncLlXa!bp2Hn-hcQQ`w%@(MBgXh$KmD2 zq*8^xioyGMG8#{ue@J}1_!x`8fBN@vtUsA}|Ka@Ohh*#`g0)AKD(}?=yib1k7(Y+O zlka1Z3wWK->rcS@i;v0ZdGdYoV>A+j0w0ne)cg1FK6Y`DI8T1ONJbJ-DDW})QN90w z?Z;xV^CYyMh$Y^~pf;_4AL0G`X!QI7T93VteT>FGMk2~e@+yhri@@kEK1QSQ=tU%v z_^7{+vI&gA@ZjD1#D~a5R2yED=I{OaMf^h~_A&M`5&000>iv(>1b#e^ML#B@7txDY zBK|(14t#S|hOtm4KedlF`VA$j4axqt-+$O0Of(vx@`_ z5+*sRzmBoj@elD>?8EyHA0mk)EVfo4&I&|7zJCu(9RHYzB|p56yWIb?faz>BI0pz$ zhp;=2HYX*0q5Xw=R+>5o6;X9+(Zs!Ylh4L@m!1bY0ET@ckUBt?DdK45kO zLl&p|MzbO?s()4)jxtZn*JL6Paa^xii8ufAf0L;}LMP+RZ5Sffh_H4j&$1e~{`34{ zxJ2{o>sLR#V-4d?EB^jptAA=4Aw})VI)HK%5VyBT!QLX7dW*D3DxFWo+%oz{xBdT6 zk)IsVn|n74d5|^u_#R=qr^`yZ5=3hzf%nauYbAK@Wyy*sO)UOf07vNPXy7i=2_9T0|(;x2)xk1`ejA>?C z4V-BMj1WUQc*5S#U5&LuG{$e;$ifzR(aP$sV93%_&KGhwVwSqO{KfK7aQJM#8)3QVO2CR`Z7Oa1wmV^VXO94PjKn zv+iSe5}*Om(bDl__K$xYId^Q2;-RxwYxU3(pk&hx*~f*@jP9ro+COoun->WRxK2&7z8tDBfPJ^#0>I<>#Ll=P-AxAKkC|i-!l0Rx88RB9M}@ zAy1vVB9D%AhyVGM8>%}8G?h-@QClHDv~`n4Q~e2|=DXeZv|x{v^r7~5KldlU*y9q* z#&#bPlF9rN%mxs0gm98QMJR7x&s(i(3&+MIZNBmL_RJy{lV9{{Ij2qFObq_lgY7c) zy!og7$a?TkYuuVXfD;r`1?$4(;eRasD0d(*MRK6e8%jssMG%4SXM9J=grpDh*ql{2 zOSIGj$=y+AQbB9URbew4pM82*++P$KW`wv*sL2tm&!%@iS-jI>CEg96x^NQ>SMT(e zzlZDKo@c)quV;ZhK%ZvGPY+*cp?n^UvLR7OViy9O912-{3P_pJlK9~Dvq0dCDhLto zd1!FP_Y6hs1&GkZ@!^v@Qts-4gpK*EBqFbP@;`n->D~X$>wJCw-J5r#x1zN-0xMSv zGUAQi=20MODL-nXeQk(6A*<}rDSeJm(f{^rDc@OOEuTN@dCp#U&)%V3;QOxXWCZ7P&$s+dUe`pp}^winl`(nU~MrIocbvb0i`N_MgA_9yF|a!}MTjX>5=Ia@ws zc2VrIc;L&HU}~#3LBOAr5d(%bAr}$Nn-YW!OgnfgW2;-flu`6H^=Hd^Nay?a)d z^HVzZ^l^3VU_SrT*u{q(qQ3f6y0G{MrUYG?UNk58;d3WNU%(@dR36Y`)YVYk2IwWQ z{WQE=OS8=?gQK+x1}tG4ee26i@oNCYGK~ZAzFqR~is$s#Yoj^0WLESI>Jk^3aq0XS z_GTyxvzdFR*?)a{N74@#t07fj?7px)^t)|7&x-169Woz1)WFpiS-k(e6JlH~;>JX_ zmtC381~_=g4GOL|{ra@k3328dp)rcHFDKT- z*&V%>mA4jN&_9X%C7H5Recm}zwaY3G?>(O9rqZ2{{7#DeyPu67p<3ADc-D(wtYLcV z>`;A`zu3?;z)LBx`hB|$KmS|PE6C#$mvI_dIM7_23D$iEd| zkgid1XV4=q5$U5cyjG-C5qYZ~YK9Rz0Rj^xw6Y`@m^2_*YwuY^nn~Hv3HKlWka~9J z8n1n02qDI&+8a^)pKrKBzgi$O^)(t=)Rf_TNq-!ABn<>)!_xHRj%M7q1;nJoWDBl% zc+S8{f3(Xif`KUG5+GB>s?wxzDP+OJK-efWu|*VEkGpHD27Qa4ZM!Qn`-1Gl6Oj*O z=I^eu2Vsq??o3o`)rip+R0M`1_Mm2J!nh}_S2z~%-DOp>U<1<*j4e_bul28S6~s*2 zGL+_M7gpq`n8p6{%R0PHTNUmGg~*HhC&_1cwAu8Hmx&Pn`IX7$m&TPYKMd=l=_G0j zr0%x%PlbL_`tI6ijl%82$pUHkP~|bx-C;w=X16K6er`+R@37X4_b0Zf{q#?xe+Xi$ z9#Gw@zYUW{*UA4RT)J&?pt)B6)6%;*bz-olQLVqyfBNKe&ZV3X1)|NlnFLPrDLUkk zEDIfTaJG4Z?i}b8=Kr!hb-leX6`a4qT}UyQjA9u6+vYorBKw5EKEu`Ols1^Jv3YxP zXJWj2nXj?+nzo8eI(&&jR_~p-w2RQsc zoV~hVj+RL0c&{k1nmii~un1JnV>s8d5(XK9j>qozmCTo4+b30T5{l}%n_lb~dQvWB zB}kJ!rnXxeBU*}wA&M9A8u~2%eu3aT3TghJ+QV#64I~9@HKim`_4L>y<2K~eGg)0? z#t~V>Ch4Lz{vHO(|2n^4Oy;j&y;VW{UXQBK&)178ImOvprf1HZXS4@rjW=)2S$Sax zRn8YobIJatjsCJhJkk)5u<HJ}AOOACVk)+e?`rM5nn+c$)b3yXM0zH3X4 zw?RPpWnZn&28*-qoP&7~=hfS+4HYE%&FYz4&$g2wpiI1?F_o?SwZFq2?n>iSUkjGy z0E6m?TW`|Jf!~CDK@?uSR7jM-}EM`MYCciq{EjGZ11FQYe-7>ZS<~V?^%d*b6{lo=I zdPi@Ni9;3rDC?2(o>kk!X0B3zdE$LO2i+0nTb8a3#OWX7x-~?UV@x+c?T%a*nhxuv zpki`D#sC$o7z^Xn3Rxfznj6tMcW>m{!t-BMK)T+@_T=wnY`Z?u!#Rgd>8_F53>E~M z0_TPSp`9_LGdeh3I8Z?_6k2=uWUkb*{WVCBBocDu4XNp8PJBzFn@nD=_xoj#c3fls5cgdA>XQ`x*IcvkKw&-)Nc6ciMSp50F(9g}y(dk3HG}ax@3wX@wG( z-yMunS)aq4OxCYo{qX9|&(UAro<$=D{gX-t*$ISA_~Gp5)%N@eF_F)AzzPoWZ}|V+ zFN$w_tM~c`*7qljfP0H>l58lljF13La~wUCWlV91bFJ*^9sL0H_R*y+NTIP{xi!}H(evH<`-K*7ITNGMcq z%jYaU3^}diw|Qv8Ugn9nYH;+2nshlRD`<&TXem-Pm8+pXF}1Ibja-rvW&k5?mo21< zHQJ+yma$xBPQ`qcrdpcj+VXX>v;llE(ZQVi?fz)Y zmC=-Gjb~xm`rN^9E`X3>9ct#<1lGzMyLTZ#6ca;Hdc-~5(5i;Ir(ZF+!mq1+C9z{= zdMeYitKnzsG2V8!qGJ7p)Zi}Xqu9ku6u945arzbF>G6ojmVkwQ+9AJYQB5>r%Cr05 zzO$(vxG9G^v)T*VYC z@cPx`WHspp!yg>ck`+*bco@%gq+$ny`ac@77i-AKJj1m|uiqFAovbCp9tic3RmYdB zdj6wt`%-<|@1!UjEGIvlX^3HeHpQ8rN0b7Z%^x0NN)O2N4xQvJNapPolAYt!@uYSP zM$2r9Gg*f;2dau=jrrIhL)EBQphFGn)f{W`Poe4jRw}4JmuBWaN|_faWxkd^W?(5# zj%Z{oT}!A=rZIWI8!z`T8Jrr1-X8`*m56;pX8H2yXI`oup>7=3ABYt|7uE^6YAScY z(?io|1eXN=?-9bjO2GPm>3ao6^!kmbB~vQ$#Ui`i=H9oY>nTp)Ow5HBE^IM|OaJ%rPkY|{_gV$lPmh*km3k#$4!9nBio zJ4^vTVe9LJ${!J_*|cOI5Kuh4M%(52Sag{-1EGtlcCZv23MQ|rA*NTwo_Vv;W~4}*qRUB`@BI%B&6ZX8>dGxYG0IhzhFiE`pW$ z94rQo_W@F9}QFS~31K)UPG z2BK9&xe+4Ji{0}EqE`|1RpAcgzYJ|tTHaeH>H$T~#y0$_!6<%--ay;=@wprD9h;If z!YrI%uF%!l14a@{)JB1B@;Di8&D!NLE^^TN*HW%xGAW$S^TFhCG8m?IujS116<3QW zN_U?Qly+zW(z9C(1Y|@_b;u+VK-oP7v=S`rh=`WJX*X4mq6Wj4+T@sVMu6Yk;AH>& zi?IlJ&689u6dP%JWGvP3v%J@o=^nm zLl2u&F*K7^1M}zMdI*?JD|C*gf#or=aX7V*wtu>(%e>N9H5_kIr*V2I5Q-u``tRP6 z-~FW5A9h{ZrQ{-Gk`Z=J*(#gMI+=sS1HuIll${{{7_br)$GqTMkX6M-bvR{-NV9Y< zDyc1AvpNvJtmkmi)JY@nt5rp!T87xiJefJll4d3 z`2W}cC58qU@ZXH{hN?XI>hH$6gVXSje|W2eyH~4nXI8n>s@$1X?%v3&(l}{+o9K~M z&arZ{?^$$H-K1{vys%Y(r$b6AC-bMAX;JNX7Fb&$ca>U?G>x~m;CH7o9D$c};p+Y^DVNdj zfbELeCRk6F!A`%Lb+!CZl;>ZfLpUst-Kvf zW5Dp(_q<=`_lH(^zI}Tp3}h#+9;TU<%o4rt_8B^yv3NJb-GP-8{^;UZe|PqZ^ts|t z9_|n}Nc}*1Prd8Hreqrk9@iFW*%2%6ud#Kemk-FRV9H%(KGEj;Nw>XVVdBoC5xvaL zDPx&md>9<&d>o8xleY}k-?_>fNT!Kgjg+y{mJLaaG)OReb zxJeLXoV>|gzmhFO@PBif$Ws&vYzS+1X-Z9&#FoFQh)XdI*;SN1v{M;eTJ2e1vtI@LI z&U@Pf8TMATR`rmXh<*t|?m2ON?aYW;MCxTK$n5=yyp6^=V5ni}E1+cT$erz=#n+5~ zw$7@C-ftgIizdm9kzwq)Z_m&x>wKQNaj1JQI-1VzvG{#!TxU%1aXCPS#|nJlnpxb{ z^wK%yOT;FVNy2Y*{@$c~eEl4uRP^_)JIrI;q8y?iiy{5t8NkNjvo@0sW6Ks^9|fF6G z3u<-Rtd}4aqhQekR{ccn8LBjBPHbiOGyQi++t*w?1cPIqJYIF5$VSTQ{vTI!=hxk> zym~vo=8lymjqDqRdi`@0m_SU@@`C~acFmS4m_tna*nQ}aSvKU?ENGI?42_IEAx#@{ zWBu-$7eXQS=U;@q(y2>B`6fR{v>V8&ry6)Gn5sZwihN7KIQcRu?}1hzdOIX<5|ufWKYGoKtY^T4X}g~u=DkONUcHf91HSW@!wT6>p>#c3 zg{U<}9!Gu3^{57k;%fAN>YGj93tEjZx4%fY9{+2;VAv8HfM`vX`~LgG4a)9*=V{J( zsWqmi^-PZUyYIAyKZ8ZvQ9D7C54P(B&E~ku=Yy;X5>Gx~jWFJub^ESWh@!j?P*>_#` zC+pao^M~OhYB~96jQ%Sfu&3)tB(lsEz0{p|M`R7t{D_QfBk%tDSL)AS&u%p(?qA<| zJ&VFpQV<&24`;8UKSgDVi^(uRR_o_ie|`0fc*Yz!^oXy88v&NZFMW>#5RFQU0XDQE zZ(-5aYJ%zdKJT(!OkJ&ja+eRo{$xd+eXnzra>!{I9Bc*rN+0%V?oj%S9!tBayrbB+ zrw5vy=yau@02!6W;}OUs=1arVfDK2SyM7n1XCN_zdH9Haf+HY(WF1>fMe@WM%olBd zc^82>;6s*Ik=QlquK|G7-!1$vfA!}7^=@JtL$y9?78c1{7=I8xsVx5!AC*xd%S$$2 zoK5Gb(ZJ+jbUrZl9y-Bh`D`#;5BqDF8P`O*$0U$BS{K)p>Wh8ZXw& zwSkNeRDSUpC~cSL2wrLGE*)-LS9b7Nnw6AH916&MRmn5*bGJVno%Jxa54Z-VOc@^8154$KE-o{%Q1ZcHpZbIaQooY6=@P#;1Kjl%sfzWKjCS51;zO;b1r* zOySSNhvH;5@u0r4AtEUbuz>jLl~4N!a}BqL*}awC5td69yWw=+`|w;;!f#Wfd+0a= zlxl!@7jWg^y&{Uk1+$(6XAC#~3D%uKG9#z(09=BqgR2YqhPZ@cSuAi$jHc$?BDZ+> z09>W5s$scUtv@|1&}d>E7Q?xT6OyA74}ZO2?*IFFlYe^8RWJ1zkT0*vp#%7zc&HQ5 zu;b!#6P`3yzK$I*IHOm~a5C>dOh~_l8&D9NK9odf!8t{cvdBa-dMsJ($hI2G<|9L> z#gHw@R10V_hgF{~9)=c)TM>;r>oPAJ@|@?o>&Z%U`3$9cf74YrN5J8qgW^s+#&cXI z_O{E!VIKMr%;}>W zh-@FhVl?RkI~m|PO zz(T$21&iLh83D+=TRrsO=`YXkSN~@*8i{-l{}^QXI#@hapi(rTDXK#x=jCTsabM^#2DAuQB2@i;tI-&AX8i%w&ZuT@C474>9& zf7$n`9atad!Cll777yxo{kC%;w*`$g6Gnd2tW+0t-5UJMMa6^5ZOg_PPJ zv~Y@14atgSEHj!<*dH)Z`a@p2|HJYBxynm-8D9hgQ+!jeKtK$8#XT|{d5ygl(WJyI z7%4rqx9OJxafHBcs7u6Zo(hC80Ea5~6W(y%<`5~y|Fr33Bs9E6MyNyF(#2oa8mMcX z4b5I6>lzLh;kABh9XP}(3rqI5=99I6xz%fJ<9Zlk5v{j+tqsR47s>$QeDWhARb$q5Qp|2)PWEo^%HnxXwE3dqL0e|QMnxtT_XGf$Udmx zBE8`sjZ(FRT}CE<{9UhvFQxy+mikN#MCNI-!fZ=&XYomS%f|ioOeV_w@l^6Fai-uh zK1zz8MQuWeiOcVtkh)WsNM1S>&tc5$II$DS&mjWzd=m6hBJ?F>$T2sBMvi}mD#y=o zLiW$tpM)%jGVu>XR0rCEVMy9cmu(q>G|Jo4$OG9Kyb3nf94jEWEStl!vrpS_9=c5D zKP!gy)jBr7hOpo8M{QwHU}hevEtuXO*?2*dSq?xf{y)lPPqdbwOS*5hhAwnoF5pME zQRe+{uyU*G`nlI?IVWT3?PuQ+*UX&y7h&d2@-O08Xp-YQ`^lOp(V*T5jm;5VbSwJ1 zO@7bpnz_@7^Xc2O=qa(HU#eApF{kWu$>zYUldG6yZ3^XnH@H|W?A^0P^o{R$iwQ;4 z$`&G5WOh7qjXdA}D!tQclx0I~ZqpzuC4H^C1~KG@SoOVbnLYS58`jxRS|@~8kf<~a zB1nE}S!)lp=Wz3Q)>u6!2oJC-OlV+Vm~y9eRZYxnSdJ1;-vp!K0->PH9iS~eKMp^B z%calE*AJ7SvFnVb^}d&J$$SJS$@Y9S>MNK>jZD}*Vl!^gp9vbS<+b!ye?=})0{d{QdetDxR`=?I4%vt!o`UI_p^vGh&?c>V4@?P6>dB}f4eq;_c z?C=pD1NoO>SP>#XJuX&)LdAdul@_)oRfkEW>pYT2EA{orKQIK1Y3+wM-sz>u`{dF^D- zG}vFS6y%sTeO_$-JL276^$P+0op)NSp(TzhS{pq-%Zcz&8Hg|AznGZLcL~;}K8&58 z0YHoS`mSt=Y=iPqLJ@mrm=MYf;koobpof zuv zT1`gtGxS(Tu9D?WCE~Y4-sNFJAi_OFkeLj)b2^n2(F|g`^m;wqk0^G|>dFro8>np; z`9_C3JL9OwaL+EJhYUxWrO0C@Z=m}Rg*fP5Dn#MM4Eef8K0}`7ZF*_c`ZNF9qLrcB zLa!~v{9&)1mk8S@!>6@k6Y~Y9MC?1GBK7qt+bv|Xxh%`iY8iepJ$+A}_-8vg9-s09 z?u`sB#xuJhwVpb$MjiCw^XAm>N)|iz*hD)YIP?9_KWrXX=0vUz&7|*oH7jE^e8H4* zZO7j&#ko(xZ++ux_YbZG@_M1m5f+p5?N&y>4`?BZ!WdyjEFM8PM@~{?-NG?>c}7ok z-+!GN+-LRX^!PrF6<9n>MiUT6tLt6hAi%Bgp;26>mf%4_&x_SL92w&i9-I^xJ`8P9 z%;WFEk4flEof0_1C~tYVr52BAyaT>fis!lEf-+PViF982P^V*yxqPQnMS&>21KQS$3xtY@ESG=-4HbIWj?KMdm?!#vt{W?D=kv z=@bU+he~3;1YQb7RZ^C$*#|3)UtzPvXJ#^7>GOxljU2mCpBtrl+fGVcvva_&{1Xwww|>g!)&paN346&C9BYrZ!d&t=+lWPS*XgYC!Ci^R=1j zm;zc~5oF=39~8AyQx!H^w`OfwbsEb?A(!ekuUaqCgJUrL(d<%jG9R);6wm9|>R`tx zyx;ubKwnp`Puli z9eSP&R>~ukU}!!g{bHF7#6P`vvKuBZVgw3M>N3>q+dBYhzxB-5Y3+)%@5K;_>c3q_ zBQd#RF-%6`wNs(`LfjYXlF$Wxn5*8V2TLRJrI35+ zju2D5m}iu$m5+`07JO|F?yc-Xn0i14jZ4k4y-s|4+g0N}XI|^p?q+^C#LI@&xsu*2 z#Pd4cM#HOz4K}8XUURrST6F%c8Q3PZD?d03ug!-Pc#JU^`gR_%=d&|SkULvV25h_x zWX`rJ@eK~_m}!a<)lphA?g$8x879J|(-*=YGr(Ffo2w(}|ev&>JoJ!5Tqsd70nIBzjcXSlM+RnOj*hgPFTcm{uKTn)xT~_r^ zv~}sZ(~18X=**re@GP1{c|8GmL9?@p>`C%Gnnvd@2Th z$x-7YIWc{(2tou zJG?&zSv|Dn+``5NI$YMb<(yIdm-oj>ghcZ|08SN&w?}-X%y-1`hNlBG7+$$24HdDj z4L&U(gRi;Gc87&!SP>W@eh0p>FgE?*fE2ou2k z_d*wrDMddaQmm%_HWbP}K8oKV+|psFq2GFy)s~}`J!|ef9b4z{*%388W0Ew_PCi%Y z$SEq-T{(>{V=lJUbvbS4VplrqVe#ViGls5CHLk#9z4M)FZT}iNskv)0JjuNBd2X4` zLhUPux~>97LbkJkTV*X0ucL=L+S(%3?N7rA)@jFAEs$2JaT_>qU%T?q8&B`D4~zMM z^r|oH9@QG&KYD$vgDm(hWcsniiHp#}1LpK#kVC8d>%lfoq*zMfX&f;dt!T0$>`wUq z$rNFUX5ELW?jUP%L~!2neTGkE+yj(bh}+?`;Vb22f3sSnL(gv3TLg>I?ro@+@|1eT z5Lst_3h#@u35vW^2esmqJLzD7$S-efp@?U(igzu)|7vnzTcI%VCkA(x`k-oG^} z@*pD_bG(Gx{Ot9TnO)xDzrg(sUogEZ>(){{o83W^|8z1n=xDyS!-AGrUU#d|(SC8D zEaUy^ypgF?^S5P~OhlNT(DoGXs+;AK;al^+w0C%0!VCOIdy45fXj!yp2+;-)pJu`J zdcFJvzqFSEe(fg_-L1W=bytX2fd6Pu*X-%qe0s+Lp6)nEka#YDpMJBRXF*y=PZRh@ zd-|C@{cJwX570sQGgc%1)ZR|i+ll*Dd?4I~v^vBiPhDDR`;n*a{H!|~Y8BIOPpzWd zB&1wbqDAw+w08^+PK$(@V^JC8#f|jQ&#}iCJpmFQspLRoL@XUwQ90 zo~PP3sqShx!-O^L`qh7GrFv$mp1)LW5)20=Rm}LU?|!S?I;32Mz}7@5?Uz00T3yC( zd)BpblaO*(yLopu>1!peCtBHoQ+5zq)^sa!{KG<4-dggIwYC-+sO&%S%6a$h|2$hQ zHV=Iq=MwnAdZqXiInTq-0D}d9QobXLVt0(N(9Jo%M2!NU>Q7+VjS|I9u-XlkKD*OGf*%a?s!9 z-#2&pO>vUkwwvXLc5@J5nO^K-QcTnHeScPZtj8PMelEEiq!YivH>>>QVpEJI9y__l z=Uy{89YDMNU2+U{&bzJBdXW3L?!+38-Ff-3H;G0ExnKqFm%Ujf80vMz%e(e2*}(Ur zZ^g;QV?SQFFGdSNztsr(@w-iTUNZXA$YuB4IRAI&)K_n}$`8<9WzcNwhSkvbxo$Ht zb=$3s`?2-D7zw7GW+KvUb`qzQsmvPV!F6NTX_Z3zTZMJ#%`3~!JSg;<*?Gt9TMgDU z)@|b2sK4Fz;r+a`Y{weVhv>MU6~F6F+x1vuH<$(Y&@X5|I)-&QvEEM5ZdG8PG)nDO z5cGraHtu4{&EUH5*t;%0)^f>t&s`H%#~jMevilD7qn~*i4`F?rK1A4a7=Io2b0>3B z*($7Q1jfbMnS{5`=b+qfrH+=ZTnC$WGrDX?{C()nlG9Ejx$ea(Q8;J&V(cksH#@6N z>uwEmzJvWR?xmyi{w$dCx?|l|Au?!YSHcJAv<~a!yD6+*7mzWAE=$vtB$uYQw(k#~W*ypLsr$ z-L)fwLVcI|)SEp4t*MXNaK5$YwC|zsqrN&5n^ro%YUM6Q`RsNwn8Dn|w6^c_n^O8> ztCwlF8j&v0LU{Hbf7f%_2=w{ByGy0|v!_V@>S^0<6;^{xij8#!^HRGQ-Q>oR!S&_) z;tptSs{(5e^cKsd6ZgGXWNEZ9FFX$7FsGs)v&s_a;Nu~>ZhqgG_oMXf2YQyK`Gs|Q z66>%STvxXJ{o=708!QL8akM?5e(*Mu);iric3b5=&{JrqKUS#lEcs{agdj8Pox1z@5*-_g$2)U2ySKyuaL( z8gNdtYEEGN#+}(yFvwcv(ovuj7f;q$)ta|D%l^C)Z8x{;4$NK0{yu896GlVC{%zf7 zaF6di>k8+wlj*cl0p8oaS$PS2gVuJat!+Ct9(NnsdD&^_h4nq?$KX89D`M{rOVx`f z)}~Qz-i5JuaL={Mf$E=i23grfw>en!a>2ZNjWo0@>%N7u#ru?`D{L)kU#;1>Z|qdv zmm4S_wd#hmmV&vej8(Z3_F?aqs{k!6M0;utpzXU&DKOWd8_VwCzE|TxM3R=rquiuWtD1?PqFYWg>2cR#JWF`%*Ylr?u*Ywqkhqx~MS z>e_a5+07uATdn=?bO-ATv>+(f^4i{W=4Fa!pco@wWG(Of zbQI)9*n21^MYV5XZQ9Msx>N5gd&qY*qq4pFw2`W0qS@jsI@R|F@aWrKybL^Ca>vi4 z&Z9(zaDR(BV9fSB={zCs$xAHLy>3hxPqxewf9CX`_OH9PbI!kCd-#NT1I8rxlb|c3 zVzV^rgY4Lu1tjwTeV+`PeUvXog-I&39Q}RWxF=a*qR*q?uY!%_tzg}HP1y55mpi%a zu9HsDe!ZD2;D0Fpr9S4b%bRv<`F?2AvFk!$^_|}pm!nP&>a^(&l<&j*LHqlzXn&U2 z_Npnkk1j^CE`zqDfF8r08kcQs`nkxcKW}XExk41=;HgcQZ9WNQxHha+|GKg-#tQ+i zRUc&aer#;h&Z1V?XeWpVlRPIfJ$3cYF%hWrt-M9gX&TbNJr`Wb#?#g6W-7v385(J&^2H_c46R7Lq9D|Jqbo9c9V3;P#nFPyJJB!Ar*_a~_>$P7?dV^?W)P?xjMUqxUa zB<}}sRzddNsJ|;&Sc5g{hl()gLs+lkJoN}|qMjlP^SBvYgUnKkz4E`ao&xyA*2w}p4h-XsO`BJe!8=Cg8;zeX8%gyjR(&-#Yf-BEQX zVc%x)`!UV$^>oyWwe9alcrW6Z+4q-pCZ&8CAH)YckhR#DH?Vi+#h4t^z8HBb+(jC< z^+lR*)7~zP)8Q%3iLIXjYD5|@EqjWMga6I z(%aFv<3N8Sc!w2%#`R*I2%PU-r@`tcdUah`!ugJLny|-U|D!&{9v{lmcG+GG=mMNy zpgpPjE>)<*dCzCy??_N%=N|eW3F_5Mve8JVT6c{?^{$?%SL=;hK9j8GGv!aUX{FG} z1fOa_X;h1}NASLr&#Viz>D>y}5A_fMoH0BDJDLX?V}QKp68a$4tJZ1Ooj!MFNwMGd zAh+Llo1JBQms$b;IUkU&H8tsQ=;93el@23Z68JcDyG8m6BT;v7OfAa_AOfkw5PK#yk~ zsJBdQ$TE?}6Y2)@>G2rWZ*n8geCM%0xm*xU$W4J3TyAe+z4KSwQM(Fz2FI8ieSmil zH@m62cd;K(S2Gq2^65+xXvhTrmi4CTPQbed_<#$T!|V#iCEtB+u=}0Sm_mU1L)c>x zxR(N?SNI;@Jr;K@F8@Hy}?5<+4EYN=w1>Vt;PZSw^?7%UL*A z<6e3U^dY%}Jq~w1tZj6)Z2?U(>nQiEIycCZb>fvpJ{=jA8j+y z_pCbA3qhBmtpT3FcpK@-4C9vk+1q-&HyO5ZgEz!N+I9bVN%<@`x1P)LW<6$m0dKD++Z&(MUQM<)eolLL6Xf5= zlTv`+T&`gbV9#X5o*BdQEqk63duh$fZ&mq}Uj9jyhk9_IGP!iw!8@~_ALWt9hW(@M zb&@9r%?$2$nseAs(Yt&5eV)A!wD*B=w?^C5%kS_$CYj^9F@`%C+RA|J+GgM1!?|bj z4(z?lk5Kk0?EVFQE80=#EGh4az&sb~o=zl*pPzhu%wIFTEZm*5{w%o$UI_MLVT^oH zPuMLFB~O^AO>k7?e!RYpIF*MajQ>0uhy`6}b#b9DY_A^4-;h(DT0 z{z%Zh-%PqE*D}V=>DcHm$|*4RiWd-&KDLv@dddm9qIUga06(0FqmBE)S)riTIWe!K6qUMzK!l%t9`X+wxcf6oZObL|K-C?jP})v?U4xV zH=Ac3EpDv(kZ(r%Lg$UH{f<2>R+9x4P4LJx}3fiIzWxv~lda zhw%2bHDdfW+g~8N!9EykzmLf;WUp=m57^(YnXZY;Z=@5+q0HUc!8sYx9X`vFE*$t> z$nCxPRLNU&lyRkuGsblqR@I(D`4xUYa$N?T zm#0K0MtTI)&qTVpfMhe+SBXztb{c?Of%i7^X(1f~$;EUh=EjdblIN&yz7H6W-jDvv z?%SvG4)<+;=kD7C-NPi;$IJCzWDxWs%UUgh@&L&`duxwA4sb6A>>ci{X4H_07O(~Z z>5a4N0h2!%e>c2Zjd1?DBui#Nt|@5yH5tV*Q9t&qTsw~Q+Sm-zyiF;47XtQgBi3#{ zMe%HPvZ@`Di)&6D)UU8_+1>@dj_$lv0CMs|>Om}isXyWT(sds11-3VKnqKHSZ}LlQ zURdAhEIvKLdRFnbnB!)=FeuK;WcRuO-uXuHrNmb=J%Qq_KBX@s7GFze0_t>mT6oXq zy(G>NpU3P*%sbZ&z01>i2_lB>qLy^~V#(=j9Q~!$CpKSFcY=Fj#dRL3!L4?`F#1!d z^10l?8C~35OTEGp_z2>|@Hx61v$%l5Ne%czu{bvdgyle94CWH=3xXM^#WM0;Z6CF+!kUZKw%>EZ;E%qK{EPh54z}H?blnlq~ z%RK>4fNRphGdJ!5FK6hh;!J;=hk5Q)aZezfZ6wrvaDnAHEv;|F+F17z&|u^f)jgog z7DIZc(S*3A4}|j#WxnIG$3?Lkv1APG+nrrkxi`#4QEt}vD(&sCd-BfIH!k%3TI96F z=9%DsxMxX^&2)7sJbUu)LV1GkvnAP4=4@Z<_n5&~I%9|ky(eqGX39a5M?<>?>_t=F zhQz6zC*bo#;1EskN+i{F{`=d`<6qt(XuG4#`bIc&mSzpgBh9(Bpq(%77EKZg29 z7WbuHDQn0RW4&({P4b>qK^xdQO+7rVI>V%MN8K#yY;%=O0p94okC|S7I^s6NeWzKD^miAVBGWy@fp39+fb7*wX#1s-=jT@31Nxrlaw@E8 zRor#SS%>ax*k|zy%!#}g*n8X){`$WbT_9dgA0yx2)P6BA?nj6B)$}f+-^8=sT$2vh z;6ogp1(rcw&=t~&$lBTi+P8hDu4a5pGLU{h5f9Ay$f~|(5%%oHpf_87-d)`U-2r5; zVYC>}fN_qlX&=J#JDNARf1q#L9UAEL#qD?4KIUgb)03hcr)*1Fo#^8-?(VgI^E*#J z2ZCPan?{}CG&nA8G(Fb0#IDoo(0bpbgTYO>9*)|v_yffUk*+bL>l&rrPN&6#>tNfd zEk=c?dX`ZD7_Zr%y`itK*mbC9c` zEu6^+^D@(STKtyB-nCME41X7I(B5ckd?N2}l>8PLuPtQ|7FVF;kGduU4sstyAot!^ zB0(*m6>FHV<#1TT0DVFDJ^@}8>yY;{<418X!Cs7bWEXkw=9xYSzD?|V=tof_l$T(@mfJ66%XmddlrG?%vku81gm-kI&_BTE{B#CTi}DI&40~ zs2}co7I#r!m}gF&YutChXWxnQs?*9P^P6G)IiN#Uh0$wqSNiAeQsWT}nyk;C%bOYW)NgYTd(_g8c+Poe1u|>|{d`Q_ zMKs#GhI4G4AviOE(1##@kiXW?(lp(EYA%L)G=+j0bV|`Dy$IlZyrIP;0<=dPOH}o<-kRG*0imY3SL2 zP61CbxUzJwu`%#(PmcrOFWR#u@LYGKmq339rUw%-X?5}gMgJXGvjFc8=2uV=F-U>X zi*ehC^u6xR%UjqxGj8+3yJAB$sF~dqo5@KR@0j#QTPL*#nP3HF<9ED2z*|ka6O)Fc z4`V0BX!tN5@!Bg$4viIlb7&~lmsqr0Ue3>PSFne^x!^$`ta{t zk3PV#E%NWw`BlD#md%cIg^gVDy31?kn30ODs{o(a(P_71^3H?u_y=DRU_&&3pB7f8bdLVV4Aje!ql0Zl2y?JBZ2HICJ zY=A%uVidc)p>OdFrU!RquSoahe5*LEgk_H+{h-#bt(=SET+FY!mjwUK`zHKLbiPl{ zMRAVfMm>klb3LP9ZaeOowD?oi_Z0ANzI=>~9S?lo%o&CbzU*6(n zkxt2Z?xUaGHS)85I^)-$dHYgEKh|y?V?P_U0n`7@by?!nIp*`>@L6H9fSPOTzA)P4 zHp)5qh%kOIT6wI%`)W}BRGW;|oCx{E<|>uLjdAN74W&9|PD zExlPusX3^RK3{J~g-9}8oi?r-nII$f72{dTc-EG%X4Os;eE>1mmh{2EuM8f#&Aa#c ztGj*azAfcU?mHKNEV&xs++VMgx=p96{D1a?SU@_k8)vWU=b(&n5+sMCextBoYJ9P1 zCvidgpD_A?ew_wCEx$_~`R*y?yFJmxW_DGdHD<8?1M*`>88D9YJQ(+~g`fj>Akgf4 zLx-Bf*pTeQtv$X7d1Yq0K}MmfUx?EZW2+|hkVcjQT9(C;_3 zj-ltuJ2t%zTmRmUW%salb17d_xx=AnL-U=J*(KWk^B|+8{ zagE-+Y3LnvJ%FWm(8eb5T=s|cUnV^zoA=Q*S9OzK%w2bbM(Mh#Fj|8=aj)5k^yk49 z#($z+19eM&y080nTvNrjm*=B6jeTLv<9U5NJe6tJ3UlNs zg}+fDCjERcHbdOkvNfe&^0zBu z&2sYj`#o@3!l3+ceXeA%77a_a;%HOM5JZ&4VK|T`mkA6_0Cyd6{>Z&QsD+Q|C$k zZP4CA*MTs50@PQW!F)xM@m?UunYhVKZT}qJ4#l+)F9H2mF)r!wm^9u$bN;2geMfOi zh@;S9zQ|(FFUfZ&^E4i0V16P6^u3v)ou($wPY@??@xs2oi}yk| z;<2+1E^uxO`-N;1d6Yr6jJoSZBL=iIJz7HDa9*VCb3Sb1{P*AIWuFqbCu?W}>1GE! zK0L8%x9((2ejz?yw_Bq*@EM|Cc+W&?GxW_IXEFW}ZEihSJ7wn`(Aqiu%Oo(CV^KlB zO4h&eAg%i6=NbF&On>lFc4g_?!1cq&=p)^)DYUl+uudWT3HshOfc_*m z%-(uXH_T~KrO?TAmYwF)RNC$sFJ|A7nvBkM^O;~;LD?clbjU0(?9f7A$ZcytH@9f} z=~NR=`?XnieL_3O>p0%_40wT6$J7sV-w~Rd-z2X>F+wTdw~oJAcjDMDxj&>_lTC-l zQQ1?RiqJz7=D>jbm)JNfb@U0SMS@Jh<$s(pll&Fd2I2kHO`g)0#dMxW>_>u=Ym zOR{_)XCZqvsnsogAQUcQ8L^TAPNUQr%_;sC&UUZG?;l;~)KS=<_I{ClL5z{lY2zK| zD=T~5_O8_>*W1u1+jhpBhqqU8Qqtzvt@>?#vc0ON$29fQY77`-g7G$-m#H=@Iog}1 z9w=n~^|=tTg|z7{efBHs{_@v*ujp8w`!@ppS?BQ^=C_8t6XM$jJhpt?fpgtPU!z%e ziFhQPT?*v%Ecrcl@UCq(rk!Rb?B2ge-ntiH{g(^q&q~cJ@_fkmM@Gbdv%1MX33O@< zyfDKah$D7T19{8|+L3#+WQ62>!hJ=*v+}aTeR63Wj30-2+OoSaK)!mrAsa_^jL$Vc z2;_URQyeGurQHlxWGlZeV+=m?Rc1H|RG*C32iXSw=0JX50{@Kh2+KiMi=%{bHsd&E zGoB7)-!a+mb|2^Z{=)M4^a`;}9^G>)*A)A3Oh3IupElZ;k>rNftLn`AZ|G})aciBl z&QmKqTkhkCI6x6i7962Yvx`_R*HeBMkv|~AGvGL*g_tal^C&S{2C-lTdyMuA^8v>; z(JuqBh8j~|AL-sWCW5?Qf#-&Ko}!=T1JaFdtAf6m7)ydac2Xv*bIcvWnb2jB^ysmb z-EM@uLVsiI{ABS?(zFJRA7lAoZO}&$cn~@l(_?e424sLs^D7ctQtb6|7H5|XSG?EelDz@6LhNw z^uj_0*T$r5$%KJcS2{PQ(sz7M^$%wbjF^kgH-thI95TrzbQuLy-Ku8)_1+)`y{3G zjk}A-2F7i$dSQRke!R!M)}Cbvhlt{ESl3fHkIWN{kX1iPP1!G=fHU4TsG1s zdLwYz2xEpk!Lz_iG&tnSKo8AjiE{$ZWp?zRz`yY>s#H}Vz9 zi1Oq|g19v}2Z+rp{DXjJ0-BW`vw7sWCtN=6Nu8~zCyVV}zRPFm>}~pdzA*oT*h}Qk z!v8MLmcV~pEDF2r+_Y~-Mj+4bSxgG-5q`fBA01sw|Hm3{zg6u!^9bv(8Z>D=i9R64 zAn^~eU^cAs@mMxD5g(v@@#>zjR?s#(@aO?3KDDFmwc?!3buHFjgp4nAZTQ|gu>RPO z%;;v1b)jy%5;Pix0?^?#(p}QAvU7pB8}m=qKH?0aeHbxB8}%vLj-n`QqkeJ0=j#+X za|*P4tocbAvLD{>Fh3gBk1{Z_0NmIHez9g<2+^7A~Asova#;3FU-u!-p z#|QS{u{WSVjK3 za^Fn@t#;x=b^R31hv}E6udU+yE>ButsC$i=j+kQz^=@|*t0;6I441$dXD+)JbT*%5 zv6*fD4eY%=$jFlpjis^2n4$K3iaMRETC`9j+{kSB9x6@-X1s(Q3!%w=JjO+wHNPv~sdEE-CC66e zy1O{x_0Cufyv1ucG|X6EwRdJombYhKLab$wA(Je|!xIZ)-$}4fBXX`XW2BKme=?dg z3@Mabq9m)~ycJ>+3zx}Q@zHt^AH<7qph6j+O|qoFz(Q2@d^&#aTB(e1xAj2?}IGSgE_54 z8gl>T)2mTo|8b80BAyHS*>zjXK$DAB95ZKW+3JWdM{Hy@2Jc>ydI`NuZ{7g9V$K1jrN$tp5fPC&Iz-)*`e5En@6?BEccyY zx3l*Z4SOjqNZLsJ zN-KpJ>`*#!1Cj7jE`TQmJH zj4wSHLqE`Gc+Bqn4yzbI_#o`Zec( z_&R;A(azOPr`okT=Sju(+C zZD2eB-hV!<4e|$_KjYpzyl);+N5XOdJa5l*a>+p86ZMteo8(kzf7Ofiac;;aBk_qm z`ZJ~jAI;lUt#4>^PLtk?Z271MLmM)~UPqrbmfN8x_EN5l{;lIS;q(b?94=d{^#mR@ zLH*@>8*^d6c*^@?6Z5!Hehkbx6w&q($mo=dX-|FyY`szEdNI`EuTRN+RRsRNi}}e^ z%)_IiEs4b-7hM&0O0OwoL_0q61liHcGx2@%65d_rlW9fBCR`F@x|6cvnqnB0&X3_P zOJB;2+MC>8=z|gWrtRHolW@D|?H#SZZu|IP*(s=2pm-FLb zm-uYv{Hk23eqjCtSzn=(jX3%MUB}?at*6XUbZzuc_@WT5m>oB7>FG>+hGz2=@M9N=3NtKhujvx&EK)yQ-tPD1$l!#`|uKd{^yRaypb4 z|2+R&IuVinF>&HsAG@A?edt9jj;B`J@$#wHQin-ZKPt3MBgxWi{Y4R^B`qE zgEl_g>|NcC#>-D{Cnn94X8`YmtA%QFj=9lfUbS%>{k-A5ewW;&EgEzZ-A{bh#$m7R z!rHT>=enKPXVuiTEByuUC!AM92Ywy#>v*~Dg3-=FK(a`Bv~YQIjJ-E?Uoem4^U!BD zER?-BT+flT%F6d-*9b0gAFyxv8uHvqkBG&@eHXFa9kW+vZ|)i+#BGGReIkC8=PV{) zOI!!muHsGgyMM^_0^)2?Tg@ln#{$AjgtlBBp8Ib1QO}Hd)s)Z92W@P3#3P{{1KWz5 zZ75$F8joh9khBy10BJAsGShCe!(w2e-*UY363543xxg{6CFbO@e05a)%3nwFk+&1| zxAa+Q-MwdP&h|Ks754WK_%D_#564tFl2cCCmts!2g7g8YN#Bow~L-O%qF5wlkvrNgKc3+$^ zzZsA}<=ro3^u2b+Qhe7q0dqZT6K^kR2jW{@;Wm=KcjfKKRm%IpX%HHtG-4V}t(_HhIhbx!|}kMC+Sz#>Y~Ot>$+kXq|@bj^Amx zF-G4$*mDXz@RDL^P>)%&=r*n=&*`A+9q8PmpB3}%#QSDLKEEn=-I(j(7A$^G+C-K- z-Vc3{m2dBiXbH@5A=V}TbjsqQYSTLb)-Yu({OYgtV;Nw^glqIU`Ec}g4qhU zdS6VRByLL-?G)#<21(tIP+wE_-o(_^*I43?DPK3CKM)wG9LHby1&Muc?p@QTLeUA_ zo4n7mUgY_Q@rZ$ENc&AY_c+&td6|m_@ckpk#sQzQ7x@|O^Q~e|Sq?>@4;#j-XYf8< zk}W;Zi$!4YdI0ZzPt4JtnvBc;{th3d^@oCZkq3AoR2MF zJTC1u#2lD4cIeAe=k*BtRgr&p80%2c1d#0>I?W54)>wXe`uuN!L+#v1Rl6(4KRVCsj^j})`YX2tJ1d%Q>V94C)o!=9sk z@tNfhMm&s!s+i*w@pb0M|1Uef0h5jc0c3&&EyExhRy$rbISBc z)XwSpBzazV+>bn$8l7W21>?Wjcr^O}*T3oZAg2tMw^D?ilZXC?&{DD`Ax46Yx2(n} zaQu*GWI7DNj|km`Hvdbm%jIWS^BriF(bsxsV{XZNUeo(yd~I=xK0=ARXXxv^bl6yhpGv9xMcP4%ygm1>P&M@N|jL&4T>a)9rh#e4jhVC<1h$Uwo==t1?eEz4gBFihye{c=Y!O?!+bUDsC(6qmExts5 zr+p)1%&N`G9%HNvF%>%u?P+o0oDNS_>6~N#Jh+kfx5kYCRwVgaiE>C9?uIrHsd*uA>LzOZ@6ATqmN_{ z?7H`=ff=Z19-~n$yz4U>Mo~`tTgydC^kXh{-8x>>N{i2`>Ca_ux_N2N^SH#jC}#^> z73x6I&eF^RukazHG3Y#i_Rmaq?)%?IrkoG(PZU5<3PW8~4)ewrG2%X+zN z0@lrcckP{f#>hv2a-=RxX>I7bbnT9=sCBOzb8q|PiM?ZBQxQMS~@ z)7t)8wOaw@B0g~*$u`Gw1pGyv=Qiq>%S?Q{t%~n!=+B?(K-(}5c&}lh9y_Ct7^~aE95R2NaeR_}dd7NCPVZP^ zHLOzH$5P~{ld;8BrMJNRU2uLkEVm5oy^M%wV`cE1lxmlo(vE!Dr2eA@^`oy1+sBCj z&gx|7=whDWd_GYQ6WD{(ZmVI)m57Ifm?~V>M(p`gZ`NOk=Lhz(iEWo%k&o^ z<*XOKvys**^&E~DHRFL_ww6ZTMQvZ&eF8cVFdR=o=c0uMK5IpgUvKOVd^^QF>TQWb zSU?&KXmsWYG2_t3iCx zkG?+1d{KN-^5uS7Y6-o*>#|I2VzDX-bb&mb?{HOf~9&NM4KEhGf5PVtd84VsC51v!aV zboJ5M$E**9^sp}EE7CEn3cJhqB4*Z01_pqrD?JTHCuPtt8g zopW-`-&wnhc`W)JAFn6x7@U8`+bLZ+(E*7;@~C3{OLULoJ*WHKDa^tY(Axsi^VP6n z=-0U3IKce66b~-$%NxHQ$HCIG_P~tsYYNN6ir=+$XG%wB#TWWwgq-+PK9`7l)6bSG zHST-U--++-Twu@ll_(ni7-p=iq5Cz~E{Q&TJIW(k)p70+7be&U`?AsyP3_nYa9&svz=47~Ta6C)cgvw^kBT!$N601s8exI242g{@m#KWZX{j4DI(^ z_lmJzyCl+IkkwC@nLKx<-3Qkfl<{6(A5j+5&-X9kObGmpex!7D>0*&&IZhw<-DkMZ za4wrs!lD_%{nKuZ1aCt&bUHKhsfwq$COMTbFxqH`ApAfU&n5g}2s3aZW#EyNfi0Q2 zkG^4;XZJcA?O_bSu5aGe4ko9vaaug_`vX`BQ`pbJfZ-RKI#|A5XfvUEw|4qB0@vud z-`z2}9O-AmkrT3(F4@sN9n{&$wqPx4s~U=LcjPrQ-xKE#J-AYS9sEmm zWtAq(SM%u+-p_r$UWTu#!P_gm?^-%hhV^+MSsDG%rW`*y8aBVAS157)p(pp5ng?w@ z8OF1~03s7qRj9V^n3Oh`@-TwO?{^=uW9*+2{UnL;&(Xt zh*^#uF?XmZUFq{gnAI{z@ulI@Z_kbJWyQWL+}SPWqDOp9il^oHnalpX9MRh`@m92T z(tPNU_Q8ITSZbbgg0{Xr(8sxH-%D{{ulh*!OX45_|1k)7ZejGHiXzr{hstNskC*r) zj`c5dS0XL%BhL}Ta}zvgk0r>bDjiU+JcZk7=t9n#;nmJ$UF|$AgFI)NA2~ z>TAUDsF$JVIfK|l71ZCBiUH*$WqK5*vlY+gnmo?@Aho$0Xc&42&x6@74gYu)-oKpe zpURb~tum(wYHc4M-@g`Cx60{b`NeP_LE%TP?_JEZNqbk*HA%mPljcF&GY4tz z49?{&BJz4uet7M?pxtwv7rvM26kkL1Jw9RmjCd(QnZNzsP_w>7aw?#V6@92TB35<|;*6(}#-PX@!mhGE-hA=|u zy~1ym`G)6)uF#rC%5N{?`}`QKTt314=|V3%)nYAp9_?8pF8raM;nT(HrghG*@>-09 zh)FPF9-{Qj#L;B?%7~>fFf`SeC^oD@{`$Bdsjdyj44vKxA2s2#tH(GHJrMqYsZE>g zO&0>|53#n_9hvKBKr($B?o95VrT^Car$~oEeo)XR>eLqvlD$Lyy!JrjcJ0_$`FgQ^ z53)kyk>V$sl;;>^!zt|rB^Pm;A;&ZD=AUE!TjibZuhoy|Ss&qF-9L?FT=X-Vpx+(4 z!;SBRe51|?tH<+Pt2fMU#oB3RFYXxb?zlaB3Tm;=4A;wO7kyA-Aa77!tp&FWa9g$h zPWz^F9pIWS+Yu(0^ZA~F96JWy=e~Aee9Z}!6+UQPUzu9fC{s4tj#VZN%6HH5qCvTN zCs$}`r+Hbwx`1d`#tqF#MND7p7tbUEjXYGQr|K*FCRn zy+*A@wnfBov*mHNucnotO-_un|?Pp~Ii2X~n($D-|=fmyPBJWSQZf+JG4>JrmyWK3T zI(6amO8F0U+xVl_4(SWg&Q18I6jN4?04+P+UJvv00{!vVvk{(Z?=#}-HC^ufl>9_S zZ2mKKx`=x&;&J>~5gm3%9>4E1L}T=FKD>7oH%Yo6H)isvf3}O!Ug)5H2G2zGz+EnB zVSsmJ1o4bDU*ZXjCEjVe`vv7|=oi|tU>>}BToJFb>@lq39{*;;V*lXY0{M#jt{Bgb z>Y|VHV@qx9C#;bg`!o15)rQNPl~jI25x4JRn^&8ZLk|6BOdc+xt;Lu4-fQEkn0bn{ zy>Y5PzH#qM-sTH^=_5UuAGnhc>qXqzD~x#~Uh9RtlIOmsy{M0;@AGHpJPg*0wp!JG zO7ACpS90!at$lu{JNNdZ>z9Hw-SLT%x?xx+Zo6_Z{{8+@Q}b@SE)&-Mr>g6}6n-ZK zYxHxg0Kd>j8w|45D?Yqy-(HsRB$-)Z8RnP+gP%7%~6)TuRN!dF%3L)CAn>%csnn(GAZ zbf??D6#v%#50Ci2J&$;~C{aJ8ALhRfugHAv)^HA{UBsnnK9PQZFiT=w2E!YqxOrxq z)pU4FpUC~BY@5faeg-;jW4ODd)XZmZYd*u0ib0`)Qs|)y`YbWoa%xy^iBP6%i%^VSF zPcB21yZn?Kf=BXp%ez$NgG0NDe}0rbrByca4XeINdkd$Dfs+SQ+|NKhMOv zIwA*IdoN^O4*1`x90{k#rsn)S;|Z~jo-+AhhL?_5 zwd4n)eS^7x(Kj389{k^F{zgoXsrv@`;#LuB7ieQ_P=K+lIqxrYbXS-w1@5JJwFPt0 zGGqZa-qh6ZY0sUQ(Uap>L-b=~Hx^&;V!E%7cxLC;mSsbIK6IN#NDdy|mUMADNty9Q z8eSKUL&Pgtxt>SLMuPD_5)<>iW518Bmz^ss*R%Kh|9<>u$KKaA&*jGqa$+>}bKu5O z3zUr>q8V9{B$v`h_NB8;rO0f&y)L;2T z|8Wg-L(7dPbJd;ZGmg1@*cg`1+z=m#_!6lttwEaQYU2I?a=tOPtE24C%)c=!{T6}N zr=ob?SpFDBztI1`gP1)i8zD~9e7aO^MqzIa$oCF?^xDlt0`F~|E;i72t69K&!mt<6 z_b$7~7%|MT*3UJBJw9k7#=PR~xSyiIlj%ACPQgp1y9maBV-dWb&Wk}GIbQm``3+*w z!1_LRB7E!?KV!eYHFXsC2JLTjmi<^T!5qiXRzR_bhHvfR`LgPsOWUoLXGq*vg}sAc zI%jr$x??nd3Db{Bw{v;wAbk|&8rg^YLSb8$Khzv^gKKNB83ONS{BA^zIzCtJewCSC z&B1Fm#+9vS%h$gCh<(Q9-dhj1xmIXwdf)Wec;Iu9hd_*;co$@Dn-7-v3Fl=kjM!89 zF|S1mH^nSWS>=N+W`V{3mG`my%g`q8(ZP2%_k+D&#hH?w znz3MD?LWJG6Ls?KS+MH1DhZCG8}@$bm5;BZ-ZSCwCaTZM#uhxoj#FoPX^B7CIzo2?Zs44;+@sB? zTdv(|P@E^!$L>XD4`5iWO22#z_tJ-T>A^TFtk^k|Ij=p~ZW>0VB~!U^LNCFVv*fKH zsr0kxThpT4J%kH)a{dfUhDZG4-=VM64&swPqi$En9fsk@aPLmSemfxh9l#+xy?$5r zMPIut%UAp5`gx;|9r7330&T%Qu9MH1OY1B-ac$fu%NLh89<(t34ANhcS(t8y(;HiV zq31$kIGPm4OW2rpS&*@!y@1gGJx=2k9Y#Z=VJGV^4&+1B?NP7>b(zP>nJ1A0%Jr@A z<$+>&prLJjL!3(1r_Lg2fC70H7j4gmVynZCUwW5%IQxQ`oCmG@+&aAkv}$XO?Gj!40!#%4P0N}UFXH%CcOm1!mPl0Mp2d+w91Q{>{{TDKZAZ%2FLu=eReJ8 z!@%*JJ@dtR5*??+!AI3|1s=gS9Ua}5S8Kzz$8wE~B_2DE*P#0|fBp0^Z{wrJ6`yuP z{%n_HPoD%o<=8A=fP?DW=bn2-$ig1{VQ;&K@lgly0_N%qI+y)(?~NP2x=Y+vDVBxXnpxgj9>)^7t&NtUcpxzoOPb<= zuXygGnz=`{`&IHyby&ke6Lk-beK$Ssy@Z~%?0iRQ9*;!#0L5;g?RO*cWgxaM;*uj~ zri}R$y4z~hy8BHX4L>6@#L5Al&*l?g4P@TVseRutdTU{C*A^N!dx88jc^g*Ub*Yaw z*CFEO#+B_E7(qP7W{kOz;Ovzt2O-Wu+r^n7y)x#JWjSK&0$VhSw2AGff-x_Ak8Nz8 z%fy~PZG5)f`1v*g+c(0_h2@W{S27aDk<}N9Mpk%v;z2EaAmL)aKZa@TTr_OwZ^K0S`+KL=*;kmWK#!vQkcfY)3+?vm*q=lxQkFO)} z)ABB~FsRJ+v~a0x{v7TyPL~ha74`fJOUCp2bsd^sbDh7+FyET{$f$I+8g;9YwRLB) zoM3w1`!GJRvDW;vB|oirAT38_ab8|@o1KU*bBXibjEQp)*-)#5B3q55ItMjhf$ z$;WhXItIJaiJjovBIST*__IiSILC+OdNr!cdH17j2fTmcg}T!QvYhp!(My0-&bj2 zV2y$VK^i!4l`WZ1N#&^Eh z6SanB{E2*S?JrkvZ|JKr7G=HH;~coY-HMUmxdVLPMmg?%NbC#wWHk)Ex9qDgZx@e2 zKFOzpmkr%#>a3ntU)S*^8=LpU3GpuWcu(=yv%Y!8eqn1W_og>CS@p$?PnOSLw$^$Z z5<4ZK#mF1<^hkV+q>m+ryMFq9@#c90dUV&SpdZ*|K)O%U-tFj}zv7;2H!D*~10DZ% ziAxc#pVDX-oL$T_s$-YHI^F5{UrfJRFAjqI){v1LUnR^fm>$iI{ZbS$DLfIDtwz+yo2tGkezn2!Y8_nI4!78LTsjh?w#hH zqa)CCWiRwkC;dTaADjEspg1$;0iNH5`3N7jH(WQi9rT-$JcVPklWTO6zD2`I`NXhG zTr3*tcfECWcQf;>dGQ;RKOyGe1liIa1Mo$bzCg3_BhHb+Oflx^nK2CPP7?D^u{4J; zKL;)HZ42tcryTD4Pdj6sqy1b3^(4kxQw}H1XWZv6A>uN8}i94axJ`JQvWVlW1BP-4V3z0PRtJN!MuOR(?^x1I-cRKR|bYcgQs& zoyH$ddz`+0Rr-_TI0Fl>L>xi0H_`MDU+k`iYoxnd!n#8eBUZNwIh1KzlxECijrIt(1dpxdz z@?BlScWEci+wbQCbg|2PL(%7S(u-Fjy;yYDZ4MSX?heQfJIpr?_x0AuL5{K{`b$rr zg3kQzeg5jw`Q~nxj0|$gwfDQAuz*l-C~LlYax{ zFPg5^d`8hv@Ufu9eqdRQ?HI!Tq?l&vW96}*_S#|B?N(vlZGt=!zdT$An;$KgsnSb| zd8)xa5w?813%jj0;uqaH zJgn7hrCcML)c@G7rjW;(eQLlS#+>0-i^pPo5FhLk6kCF}upYdlT!oM{jeY^=0rPat=|1GYZzuf` z%IsnEe=HMgdNZN(hwJDl&d=K**q5Ete?w=je z`jCPF!Y*lU!TmA$rk2&tB8|W4GnynWT)3_J}&sMb}SS?iqZayz9lwOSx__ zem}Pu@8ib!q}D*!y1f|jOi!MDI38x@K1{fF?{c&~tKfaNq%)FT@x9g95g(+{fI>9l z+PKYmqF5xn3k#vK?PhFHEmlTfXLrs}2Fqe>1;xh(WTS;Uzpl~in;opdF8QG!M>`?Q zg(Pw+5f4#Kio5=ibPZ{hlf1u6eu6QLdy`}f==Z9V<-da@(ePqK+C6|~C#h}NXYXmB zwIZ;_-Er-&eaCHKEzyp`^PFHFI~KdbbfP?e zKsCB*Hw!`Ux-`#IPHe^(;kPI6n^~6T1bBap!JVVuB+TjkH`+f!$L-rcw{4b};>r^F7Eu33{XE&C!qF3u#tPh;|tYpjU|04Pn`GrL9;N0 z`USpfkJF5Re8JKKZLS6bcfXo+mTYixZMTF?E_oiHM-|#X@Gs6qys$=FLp9T=R^Z=8 zJ&~=aqpiD0^s1OnHR_Q;4gS5oYm`&)Z?+!Etn!&?wvm~_zlrKyBzp_buPgP!RSof~ zr^(bE)C1!{fATf%+kEzNbcgX_>5EhOv`74duXXm_zJ%3De{h@iZ_{!IO8 zy!;;h&)#HvQ|v#n=k$Gu=f2kp3cVTd6YzWc+jLZmr-EL<N# zY22PQR_Ec?v*5ap@nUgU?>J)Vryk+mxHscDn=<5A*q~UR4CQc)_GUpuVAqLp==eAW zu1tpcOZMkMiSO?}K)0{s`$*jc!=ue*cZh}30$vQB-NE^w{rvAq+rIkV{rzcMqq0LC z7unEqSw2s{`#ovggHm^XT^RS~WwMuX``dr^(VuJ|)nnr^@Uhc6$b4|_XMe!n5%j0l z&1I*ZX63W!%fBnnUUK#9-;8H(G|JcY-HCTow!CNqPl3M6z~=;==^v*H(DQ65eE`E% zZ==1URsM{zv8^cVOPrTzGSx#&-B|+f%zslllmC~cGY#^G%`TCj`{QiOyboVs^ZO5d z@zEEd-#(SjP&_yG<vQtGu)M~d{o2fTj2QlDmRA|$3OaDV zlTY9*pj?~z>%kJSIyi2}mM~gz>=aAK>)gqB5)+>Zaegs}du|;JMSkK~a?+hO?qN+S zMu_@7H}^WjIK^)g-tpv_9(LAk5~krpr={n<<9I(Dj|#DmF<&~iBl0Qt;}yb0FYG9` z!1jIIFdxQp55H+yu`Y6st|FtmS#}Ti{kWfD`F)B(rBKT>YRwq*UBeXhVh~+d7H|i| zx!--3#So0xN6G~ZV{N4iHQ1j4 z?74j_onPg%+XV}2ZS=QqF4S!WZS75it;&@vHSyt)^oO-1ms*btLFb1SQuP_XqfR_m@c_8fh z)T%p>_dE0}g)tubGp*1413A?RYds*G5uh<0?Tk{+pWH`&w$xb??~U`z_=ZpNTLTYA z#`21Dq51D`N0#5TIHSj~KZ*X=yx&rc55**LOdx|cX*rW08TOR!N1TfEc8DW!H|oHh z3hRdLVLth2U(ngicGJMSw9e1fobk{MH#}jqCF1%7&W1RjHcdHUJj)J`ox->!?!U%y zI|9lVBl89CEZy#eji(F$8?;ge4V3+vnRfSJXXb6F=ILz7MEZpb$& z_t)ocF1sf_oxSs8`>~jZ4aQtIavxcndVFTiTNlNJAf}D?{Dxo}_7USt-e)4-hS~NC z7IwJ6vH^Or9At?%T!gF@|#DZn*`?PZdMX-?t)J90?!<^CGn*6br5?Qc?4_iTQQl#IT7I78ell}9-&_S8=^^Yx8CkBzO0P8 zoy0B1hOs_PFeax9Jazv5!jH#k%@xD$+&*HCiXMDp&>btT%9=xGEn6|d8^2?^uW;NR zgWd*7l{b~>SQveq`r`db&!%H^vHdPEEg60D;FjWZBhHnzk=VmNULg*vEoWmJg&4)3 z%@2I{zDoJQM!3JCrK`&iKG}($Wkc^(8}kA2_VhDA7!Likzyu}i=+p2tEjiK7E5Yy! zSUfPUm%@-;89FD0b8GnN?-lmDj!UTLYM>maTiCnz`Kzt%=f5W%!CcHoa%bisEO~Me ziaa|Me@o*+`~o4qj ziZhI*93yrC#c~^Cs3tH5^rE@X4(vRVqOINxZJ}ezr+RW*!J)RwzP1!rxwVEIOVzO< z_ar~&WQMrvHB2VpjkGSDomZx@w z@v9&UE-K9|;_mtSpv8rx?it+&xwD=HdY0J?QNL8jyv|PU9y4ado$vQpXRVpNu-p9X z~%?YdG`|}{@!FRLzs0im(%(01;Y+;<9z_aK$h@T~< z&D7-~vj_NBJ3pL(sblbdB$Mg6+1UMK_DSIbkbWm@fBWvYO{X=d#DeRrH6Q1{2 z$5@wl>mA>x7EUCcYuZ;;4UaM=a~#uNWZ#6*^r@ifOQh+cdqiMm5=~vX*f?wqmK>}1 z$>zyin#lDM$Y;5Cz$9VO2=iOcllbNv!kWn<_7cb*4708t zYpf722I%~vAg~W?9)8!iaHOqyonjqP;Pvh{K!af)6!MKsv_v`z&z$OXDr{Uj9>q}0 zZGPjPGnGp`efeAd>T*-QuP=!=kEbpQhK}5W)otuoP8*wdEsb!Mnjy#sl(7axq#_k(a@?z1)) zm={B#2JIoHJB*X)PA!MN436LUyp-;vuSFF0Zltuk*p~LCMCrbtxUEeSw}#ED|AhJf z%KOo-yw7aPwM^``*4|UOtEqt(UfAd7&{ueu*_W#q@p5exxxLD7LAKi7n*L$)(vI3s zlxyvH@qQG)t>q)7t0}g>HEnYJ2)2J)>t8@W6Q%t$R=UT008{wZZoiK0Lz~m5;{6o* zIeIEx<*_W(Z`c9n4P?L?mK`N-4eV>6P=16{SmewE7f40uCSkZ_#gCPKY}?h{8r|-n7i?+w555vf-<$zQ~ByL3UjtCP0aZh zYX$9Jl=pXAn6qeke;I*x%sH)Pu>E*>auF%*`&(#xcY9UemiMJ6d;BmSwpQtjU8y#L zvEM=a`Dkh1j=~&RWihAc<sd*m^-< zZ)h{^H4M6x1sC>l}%s3nEOxV`#b1w3D#hG0qr^GfUVi(rgT4r`bImN zv-`Vv`5w=NHD~vib9QcV-1$VQb{Q{S!8iMn)rb5O?*q)~T@3aktU(>uHesCu*nhnJ zt5UqQ&%=3a!@ONW-|M@wU3MqRW-eg-xCi&J7O-CZSjoO86iqp3CwA|IOP!W^bGcc$ z2-F>=<*Q?OG0(^)7h;3P_WM>ICgxYcbLQB6r90d27w6;$SGdzj>;AB?g)a1aU-|+N z9%_d9mDO`7BPJp`2DWK$xBa^~54THIJIz6MczwBG{(P9PQ($*TdB&8baXS0%ToXP9SuOTO||q=O%sj}YNUUTVL~=yNhR?JJu8 zQ1|6S-Zi_Lm#XMj(PwxGdsbgLJs3R4?&8lS@DVL(o8}xS}_Rp_i&*c3k+a=ohd^s7deC~Bo){}n?{gVir%8Mh4 z{Y0KRjd?V=AEVF@t39&9az>6#xfZ4ON`AyV_8M-+WX$}R$UpOLsngFP$p1IGEr(+5 z4B36vixGd;)5lPpF9!_!(fT&K*4x?)gUCqwPl;#1Z=$UV^JWvK2($N4t{>7Jp{=TU zG3w6IZ;Eijqllq~`S|kJOm6HkzDyhcNc#7YK0BQ-?zN%v3FZ9{bev6lzb`%OD{{Ee z8oN0XDTg=G+9_hnIX*ztH^L@{_vL7>iMfmtqE0DCfsBJVbaUGdRe>|j^z(OQr)2(v zh&lN5*kHY;5qE%7?xbPO;_kN$bPo(&ouodVpe7)otN~)%HQPX*V6B9 z9fufc)R*{(FrN+MTp~Y#eiv~5uj)Z*Q)#4Xm3;|#dFD^(uAAQRBKFKl8Cqdf#Y?`bzaD+%X=|xtsmhZKhL?%`|-MBxmV$dF_tue?-gD zV?ORFtl>rI_)ly&whqwv2Xs%zv}c$A~^Ss;?I-t1r?|Mw4Yib!s=&u(|f1^=7QRY>^zs<*mrm zr%F1(_Ux5^-q~Kjxye4Z@3sHwHhle=XFr?y0u>!!I&FsK&tvt(VXim8zX2ac zerX%`91!0T?Z?RHa!eS%ljvHW4Wvn&mLM%xu_YIydc3jadQ;$)r=vF9>Fri$+@&~( zr-1u3M?1062;&sG_mz^+`Q~$oU3rOE#vCh|_DZxp0r^KfYogAf1M6}32=c`k`4_@8 zhWoA9L_b>0?+CnI3*@I5`J0o?r+Zyl_q=muu8SGRqx;OcJR96E#A6GeaE`Z2{^WSy z;vHtoYP!#%#!jW^~?6xrvOAhTMxL%lFOy94>TY+5E znUUX26LVoE#_f4&ag)n{ypWpQR4Ip~uW$T2tNzpTmeD#9@5$pr^1^rQc>aaD{jJD< zeR3W%rhlOO?n`WP#9PE8rd>_ae{M&c(>#Ad-xu_YTrtdc83B?@g#{J`o zfzo+*u23h(WjVf8gHV=rM&I!VqS2uHqXh z&-E4hE;8S+g0fS3?D}x_R_ZX?w+L!?E*F4spzzIUaY? zr1#;y)SHav?bs9Wohv;qX3l6CoYxHLV!Zj^O@Ala!&8u1?t8%Nb$5Dv2BWQY z>QAaRARCBZR(NTQj3F~Sa~h(rGU8VRZxC9CcRfs59qmYs?V-KW1DPA<$(Td71JG_~nN~<@niPG=9$4&Fxdjcd48<9`vhHJd(?^{EMBx6J(0(#^%ua zhM&s=x?>jevI71oVEuII*nzRrUj0h*NOg5`z-PPlF`ku=yH5E+>VDn5$y02p59DjX zaxk1MzvT*KyK3Z;IpVPn<|TJzO%;cV`&991Uqm;ZdwXW}F+K9l#WB6fq>p=5z1R=#hiL|FJBrfXzN@;W8mC<1NTWr zhWy^u7cqY%n1>+Z=(&{4;PTgct~l|1mH8kUZ5`Tg^Rhm+g{nt=d&)XAa>2UOD2!oE z561e*y3hy08UvH%J$Z-cmB*H=yBwYSKNIfz$19bJsFXtv3zeKtIkP22B~;!*&gPJu z&1q&^5^}DTGb6F&OwNZnZqDcP`80Ffn8R!{KEB`o;Qr-)JnrkdU$5tLO5W=G`!l6H z?f!0VcEf^q>erw|Emw@ZMa!+Rd&A8H?ydRvk(*mu_|!Ie?-Zm%eO`fh86kdSW*W-q zq$&R9G2|A`$~;i_oQaFbRb~|0dELgY3+kV)iBkyUNgsEGy|v6|wKQ1U?f)etvW8Jo z9OfP&C7Po@D$GNVs^)?lQH{q+-3KG4S}8buye%TdAZX`mz2W|Z?9IpVpW&CiERnyx z?(hv!`t)K*2-wXE~MBncj{uMP4iXLP7f-fl^g1b1EA zxL{X2W719fZu8n^bHsR%-d+!Rg%+CHoto7;8eO?kW@v3Okfw%738S6gMm#`VUvleb z_E;B1eQHp6rG0hRbN-(udEBY)lu}2gTkyqD_Es0ntBvS$xq%aB5rgI8Xf5we^gsH& z0Oe|j*X)wlfrcGMVMu3MPDsCcY$29tCVlYG$NL-2{1AToee8$1LDdhK*!|~Od4e=) z*Zj;~J8TVL8pG`4I+?WB+Ak8lqqea`^ZN(i`Q#+rFr(|*!LJUC2zl{Ye@WA((YUo>t(Ji=0D!C7KA}oN)!e1ilBB_*8$SKHGurA>yv9 zPqi1jC#pZ@1Yf*M^^Z?+3o#R72Hsp}+Um*fm1X_HbyK##fp7bq$ijaNCICAoffqfctUtxhdQxoP zI%{yT=gjKaN^u86aNd9qu2Z`GBjyCn&z>$us^@X7|*}k#4b|ho;cQ$R;*D3F{9p%8PA!t>uN!V zf_^VSfBZR{g|Uh*$LFDMzT>z_IG?^N=&ym9OYN}Ba|Ri4uYczToA{#oWZ{YviTPBO(!BW{q~2KvLI*@moMqM11px*KQQg;j6|eCu+QHnRj1uYeWC~a@Q>W_rvko< zp3fFcqiwGbCn>txy^dz9f?)@o)KtT3`WkpE8U$wY_h15)rJv$C#*XC3@wmswIw#jh zDMw;Ofxs7XE2{Sy+uey98$ZElCGw;W%eZep!521#K2N#0!mJIrUuyrM;a<0N(9w(E zs4H=Tw-qvjWx>q~tS$&?K;-Vq@g0X$ztPRzj)se4=Qu(-a7f?X#)XRqr$#eX6BGf9$#n{qAp6VGo_Xg)RJn0ONyRi4B=B~_kavGN$-2|_#A@DxABA zTX(&@=MXNEZc}-EOW>bgNKx!&WnL||K42=+zhqbONX5qeoBJ7bEZilM;G^m~b4X!h z%WO%BP<*b_b#nYmVWa0e&+x9i#O(v6$!F{8ihYfBAGiZ~+(Bj;e0L$GOfnMd;bXwu zoyCRSY)UZwy{jktKOggF_0m=W4f1u;(&|&cikLSJqIOjfi$of1ix9rMwAW|go)yb5@tug_{5a=L zMEOWt3NW#2&%rkBYF_4!1v?HN9vt%9krK2Rsw0Xn!wXHX%a4-Sc30Fdvh1(gnJEQI zvo8i&3eUQN6{@6mFoxV<`>DO>evKGYp*~6cf`wSew%o82~YT{BxJz1eq%5M=J{kuTMoO5Pa2ukh+g zsXTqF=y@d@)PH5i?*)SOahlRng?dxUMWY|V7eYnmq$4OH^{a3s3G3l+~he5U^?I+@9(H#k&1D2U->G>y{>5K zH6GGchWezr6mODUjyBaKPE7#RyL8jzq;WQOU*`*ITKHsoc}WCSc#$9)_jgR_r$Hs3 zuoXJ8IBZ9~p{pfL=9zqyhrLL)3Zj+UY)|teRCjOjH~0}|&Z2gNP`AYizHM9;yHy40 zGgtlBkCg&FMEejdx2;8L{lZ>j)?(L)xJAAdJGq?1&x$n8YUq`RwWf|2$ld8SZ!%77 zP#T1WpqO43`0o@0L)n-bviLulZG*9U?`y0v$6I$!sB(OIq4uvW*&KaHO8X|;v&+yb zi?O!pf3{tsy^Bgw!S&x%8(SUu!^TGCDNArP``c;eHn!4KrNP24$G>8q#qr9va(Rw& zA3Rl=bUf&m-K6-3$*6H#A^=3bZz59Cy9%Td^-3a zP!3hfa>XTY%Fua+Mmq4j6j!fKQS!4_FS)j&pEUo|F&j*szDeyX;=+#N3*yM0zrHAA=480W&T&2x2Z z>FaEpv;39aorwcm150Q{tn7ZzpJqZ&=8Wbt;?h3Pn|=PutTn==64!nVG!|m$epa&U zn}Pi^RC6b6>}Ic{w{D#y>+a0g`qu4zb(?}ZRWY~$Pe3Nq9LO>H^ECfxPT|<45zrxI z=yQIHld6CfKs|t!1XM91Ets+Q7!S6=Su{45wQ_BiL^X;zxEQG#Y6LPnHJW3N*Eh7D z_WA!&uGX_G0s6Fk!%6?qV_Ex8U(1%;DN6g#$ebk!xij3I2Iwwc+N3Cd=sZ7v{TJuT zaxm+%x&Xy&WUXpD!S*1&!ItK+?{)QmH9yh!{J>N0cG(TA@(I!TuMdC?`LA6*IYEj7+>&H&M9p4KGaq;{gthxswmmM*s>u?RjXDO zkr?~zDg9f1f%56Cdsv%S33aCSK>fLM)tu;wz76w)XKK7gk&u^x_CLn{xv7`9T%5D; zYeMMOL_G(W^B6?=;`f1={pW@ z4DmDjz0XI*mKLQp7|Kj17sG4EN1c$A*;!B{3T+aGTSqXE+X*`Qr*4b=y>~%`;UVJ zvzbclhIrpDdw>ft87Pz}H<256CslNc{U%s8S~m5Q>{hi>i_7EE&G&3D=$tF(+q6lc zyK{dYq#R!LAt?QhOcmG-+L^3tWt^9D%byaHzP?m)?GtVXU^a^REa|M@V0H)KBOfih z5>=I}3J`@T^(81ewe8^z*FcJ8Nc)rt6fVan?VW95R%v?Cn}@s z($|v5M`{K{mJTHynwGu(Xnh~+1VN=jC=OG(RQq{$=DU`D<>kaV>h8=DeO&kCPD<>L z%GLmAiK4RAe+#NFaHRk8%X73UmmbV0e2_PPoe7(SGNKfYz#VgvS7fgPb^$4;5da5G zM=ff*d_LQB?Nv9(RL6K*wx0x=a3hVjheuC|i-ikxGvz06g7LNhK!@o122<~e6F2tJ zNqB6}r)kxqjIHC_EAKl?!clo746~_|5kdWFb^L1z|>_n>0I?#6H2oGbG&%&o>7B2dm;SZR=TESC>I_V0v1u;G&>n* z@pn1VI-(f6423E@`_yYrh)1eC{xPEBdbKgwFxUJct? zjfoU{eC*d9*NY7j2V9gxm|wK_>`$*u8S{H>q*4Zx->v>zE$GNC@eJvArWI_rq>+D* zLZKiH6O+?q_AJD^gH!*}B}<~bce?G>>lAmmOCO-o49?cT**4o^$wMJ1=Ipj}k#zAL zO1JUqQOrJ+qHzj(SOgmw;w>S;*}(6dAMny~XQ2!hf4-2TDEPp1aHOc15k;27uYEdB zC`_&Sl7681_9=j@W&dFpOY03@cocAR)BXPStr3PY+h~JJ(@b5xr|Vbrz_TDmI{)UQ z7|=t)T{O$>+@Y7cel5lGJiXrwc0KGMgO&6AAYoqD`PGj;FU{kpn8$+1DKLVhZcR=| zCX;>XjWzR&r?n1&NBlWl28Q*xaVPoSbb{%}T4m}bLYz&-b-tR-8n909LT^8x9hvA*Sl*O56R(zX!a|SgPC<%!=mwYTe&7FtKGSdGTWgih^ zX{poi)onLEO8lmj&D8ADn93K)8ikI1Utk?~eA_RLZmnHEd|TNkTaTG|20=ZpAC0G( zm($GQ?--4ng|F0Gr<*&HXqa|J&8%{f^>lw97b!xLtbgDA7LoCMW%zQFT69(!mAPq6Dk%c`SsPuj7@q-FWO zmrvXtKi)2i>slByG!=fFyZ|jV2eayGwNx-e3$9aAxBlgTv4JUdMc^5~cdIuSq^ifg zy);?(cl~zPnw7z2y;pWwlM|6|5aW$UmN!qSLcvaG%V*Qvus5lYLc-PNL%z@(^J9EQc(av1mqYGA=G33V2Jyc-5n9lvV=Di`In9E7y8a_D z7g~6-oahnN`~BtoI+bTM#-MNR?k4|+K$e14V?$DBeby$%#j0ew;PVuY{=y$BfxO#3 ztPFsMrge}VOBJT&QPSb2j{~+-rklB0W}_d;1DAJH7Nwq9AidR}Fo;t7Q$23>r`>=$ zs714x3}s>agTf~QphwXCq& z-PJ?!z18#=6<-<8KL{Wud@IAq^1Xe5zs^-icjISS@O7R(qe6<%=L?}r9Q$2?pL)~m zkXq2&(){p9i2lQdNc=(@--PJygsi1x{fmftVSjbCF=voA?Y#Cz;p?%HOC}9QqgG9h zw#3J&YU*ly8*;17bMFm@a!9{FXSoe>HjksIea>pl&4_h`!E_I1>^A7u28J+4$%U;dkggJqrb`( zrKvrpXn1?$*YcT3E&D%}>^|smDy;F$Xf^l#osl*B5J{FHeAh(PTglby^FXcLCNzhMu@!HY*~JmG#OE4y)ODv$l{AAljHG_xE?oRij_kVT>q& zjaxnbb6xdySngvt@$%b~fmvG|*PP$ai7f7$dxb;iz5#zpWYNk;mRqomg=i&`ZqmC> zAgflahV%OIwbHboqXde8)ulC5ey<`i1(-m%T@zSKddQ7@^U(j>+F%}gmrJ(6$7$XE zA|YDhTZ^(~j zfgItef(_g=DZ4klX|tIW1MeQSUZf znI{RS%Un6$d@UycmT$>bYcjob$85?q8ULA2yvs8=bAiuF$9yU~_vC)yhm&J|_(X$7 zb8v*h_oJp+>e~cUt%eahYU3jKf`D3DIQk5{uUW zAGgE$;@#CAA!Yk6tebI@I;rLvyrXFxtUcz}+E2`P;A~{U2GF>EYh7&;fX&@-W@+K! z`fQGfi{yU|;cmL*Ykc5?7;<%-m1KKdqWC#G+d6mU=)bX{daK3(-S$h3ry@YB=e?Z* zzukd#;%UA{pIs0i8+PP?w3UG_lj@6~dpP0Re-k4Mf?z1`t6@6>DqDd&JRbD^2zyVA zF3cm2_+;? z$9UJIbX|ed(c_l3JZpe>FArXyBe2M%>=B0P@ybTKI*%%6d|BuW2VNk}a8P&fC~=?n z_>+AU`b)9GL?}@!2X-s)OS#f8LIxfYWq#RGqoRKek*yYA5QpI8t9#wTrsdW9bFxdv z{+xx?_kXV7&rS_PUK|_+dQV_R7F=cf<6NTd^jo**` zK|KeZ{;g+YVVedC!e)e=siH)7%1tQBp54EGv5wERPy7dJ{eEpg^Y}+jTdbv|cD>5_ z^RckNxl`=BV^qzRDXXa7O*^##pL{?0A7w1z0r|4TzRpN7>aCbBm?y}$J<>7sZxMuU z#FN0eQ=;|bZuBjpNtBkGws4Js`EAN8q`>gUi(4PvxcaR;5)~nhyWHyLYVxCBi?@Hc zG#M^TC5Wf;){fZLo8g8QJc zHzmt6MrH5^d*bh+C@vkV+pj^BFMzA0$%2vq+|+fGPi+&1X9!AzdRB#+@ne`FFXR5i zI+B>)VMBNo@e>Z0db#PZ;Zv(DYhgn0T7uM}dvM{qt&D=E!vhC&>{(ZOf=5nejY0Gj zpwA@b`bu6u8WLF9?{#gUq1x%e+?gDZC2Sp!m`nuSt>=Vw&fkmjG@jX+*_1*xd!^0& zQ8zW69~nJN8&CP8gb6RhNX`zLFQvviM`{>4r?BmA{UkJDh{-R7ccWkM15(C(%Zf48 z`m4_SoASe0Rd93$&P&<(P-q;Z`SEz;k#Q2nQZ)pDynl6`^p8rYW2Q-M`>fcvnl2uP zd@=O-f_P;{PPY!cxhwMDoM32kJpPURdKN*Ds>}SY;mRm#+&?@~OX=V^It48Lc89Is zE91d!hXe8d6I5QeG&prtxACpQg-$eNXWMDZh_-(vImYAh0=iA4k6uMuCRXdL|NfFC z?qwPX2NqFu#7{iRDp%8caeqCt`k+BWBw;u=`*3yherCP5Eyl-+U*RBSCSs`l54r8( z(pDS1YRxb`nbw@TTL5(MHTIhM(4O`(fT}6QqnWCfiZyP3;6S5eSiKzpU(r8D=!lR?ABONmn6vBD`1m?Yk-d)5sH@OKM`?gT8g$VV# zz^2CVz#J2x{@P)~C!Nn{s%(6dfIDr)2@CqmHtWLDL`zexin4@toJJBw3DKO zEaC2`0wEMnlSMq}jD_%a_?R!bB-kZo>IL;OQK-9|CNR3TW+<7po#~Z!Z`<%U$9p0T zbL-dj5b>wbYKyvDP2v))L|P$LG)kn~Cnfq8_Dt2>9mI3TiCQc-dKJtpOCMs200mPA zw*Pik6^gh1_ow?6bNn<9^n1~O6{hYkYcIX+51+DP>73g+S;s#`8OrSs+CRiH8k4#R zxOo%u9V+qh3{yAMP>*~6EQ7D*_UBgoGt6xkj>yB;P)@geb)DpxmDjP<{A}6yqF;+D zJg(l0c@q4UL6x@cOg&WO1DvU!YDrj)!rkw)!G2teBja&2#)t z0B_%V`Hvh_E*5Alzy}y8{2|;y@!X#u_lnt93q26}A$;1&_xAFSd!Cawgf$Z8umd`( zhIH-^p+D4P?6#IX8YP`_fk5|$<>9OYzbsa|wruMmrmkK`msrPY0$yy-PGds`2OU$uLMyk~B z^(_0m6G+A^Vq5e1FFpGpRlD%#k4zp`-Tw#5=cB~%TiMQCLrL!I)d2bym1Z$>WIo-i z2O<;c^HTL(vfZkH{uBo^KW=V_7eM)vcu7t>cCn_7FItu|{&y(DACv)^&=Yy9w0P5k z=V+e4o%U1zT0?A2*dMFjDw|kiXpFB&<<}%k3hrr}s(gmk=ZU<;+js=$U2*(9;Zmtum|SF#4ygzz z-Xgpr#dvhB;4dv4Tta9qAK4^2z*Z70H8)uS*iZieqZd}r(7eC)!LhnSpEZ(>GCK%o z`cU>t8b9WENBK+aUNIBVextw}DzRnCQhR0p0rTz{xJ&T7T`_rc1n5>v6>e~hUHLso zmL1^FVQ5d!(DlpC$~lD)s)%<4Wcm;9+*rW~t>i&0xY=#<^Zydu5bem2QRu-y*saP+ zdYZde{-r?>O%~5qFW&p#OsCZRw&`cbP|7nxvX^G270Zqwzt6?5BAT^#37}VsPZ0Nm zR3xkP{|0m436ixEOSdF0s2%0>c7C98hey4JsYR-| zMnw|Ebz@+sN|lt5mLQV4aZ2;xfI5%UGEV+FP(}$+6EEsW7pr5BOL~60YjP`Qu(w?9 zohms3<|7QIBMXPzchvr|mL8nLiV-vCA|B5QOMIyC5wh8IPs2>U+Cz|7=zP4 zQnQuiYQG@Ah@~qa%kfob5mcdCj&4d0qrj#dB)F zQ)KX>FaEh)(!UE+ic)PYSLRe)W77Tf=Tr5|t3Rn#mypC%v}t3xa<|lZ1rHl&)j8t> z**RQgGF>h&EhsOa0q#}kC~GsvvG0vLS@Hc9x%k@JSMAUq2fkBRkqoXeiE=fgu2D;B z4<8-hT+rSARVR962@J$>SfTp7tf(&^ehd)!sqekBx(snDE)~I_=_u4XyaRB53w5bJ zlAoN+jos&&(B*@E-;R2YmGK@EcZ+;-n}A(vQTZc-khm#45z(hJ`5%c|QY~CxZ;C;! z@S4E#Q#-TUz3rYYDWIU0sf*cF(vSU#?2?Whxim>Dq`zqq!$=Jv-^<|`_IdXlSjju4 z5oxcCc~NJAFKOQaPfSjfn4;&30tC1R!$C_8j2p?wsF*MtC~^^Du87F$zzhLldp2U9 zHp?HI*=H+gv;LPVY;p31{t!p_Nito4ggO$l25`a^;1B50R=#W9>=oCzpuC&vF47nl zYyQgjR!_S1dU}N!AMi7MixMi)qolTNZr?~0{e|DBoY<%?jg_IZMdRi!^@Op3l3Kad z%l?1)m#w(M-j_5PG|oH+3J8|OauysK*9FHCgw6;=Y+4}9AMCZX`MWd^h>n|V+E9OF zfKF+O#2{WPOI4i%Im-2oxCeQ5g2OzMz5)QLfZ5)nn}3Bl8-k))TBn;Kevhm+vPIe< z#>#q47~at1Pje;apo{b;hy2BdJU*0PQlH13d({arp?eMQj;{uWk)*0MCr+-R0&h(! zEeyeJr|y8YpG-Y)e>_zv6-j7sRECiItQ)+Nmb+E0VtT7vcc^x3hU&aMoqK=SdGmsC z-;56fm6Y}6*9HEAclLdv-nU`91OZBg=F!1olLH;z_J&|Y87s(cjKR@X1c`P6)^{#efu^N0^v2t2tN939he0BL=+;1`B$Hw5!Q7B-tN+oh*c4e(z`_th z6rAQi^W}1I;QQr^^d_&PEjSPvD$xT!zfbqs?)F^w%FRPwW5Cl3&r-tro5F!tcul_a zT9DNaUEk|h<)7AmAg;s3IDl!PH7>^%e7Q^QE%1ctKy>l_US{2w*NVLjUrxZ_-sZH5 zjpp>?K8xALmb>a|oln8I{_n^8mecaz%5{vz8B==!9y9s$k6Z3}R<`vsusa!iT&f0O zTfbt3Chqj9%ez4ZuhP%kJK8nG{z)m6c2GPH zRrW8gJPoEwKwZ1P6Gh(%EzWbUr=i)9F}jm#JiPep*2B<*fyfBWETh2XM45@TLWkXd%O-V4)Oc?_X$tSc zKSh3rsZnAt&kjFvTt)Bim!qd^`w4?^X?Du3bsSyDE?q~+L6t*pPW>RQNPfo|kl?|L zJW6dazt$%*I}_>OEsB#Joed|k**@>5#RCP(N?XKXMvo{EMi?UaFTG%!h)T3_({0yYv8;Y>P~Wf**IJQ&&;1Kn z``Z{vD3P8urC_YEqQrPkVH&hMq zXzi^;AAF`%IG%9G?VE@|#BvV_=?E>-OUA343ulsV95npe&wYFWa)HS4e@eO|Oj zhsU))sYPtfH%4|ir+Uc04E;R$UHRXRr-rOKcp}tcmR1|W2w}m%c&D(RJG3yD;;pw# zjN~2tdYl?|r`i_!ADmlH%y;}R6Smc>EIl3PdXIctQVEG%tP|ruNf={PH;C?AACRP9=0YZKUvG^p>uL zO43ww$Ln69Ak&5)(kfW{_?O=SLa%g*X7}ub1ECt_I_XPcgz(FzX*Zc4AD{D>n>^N$ z1N6uy4PbA5rF@fhw`#Cb25_ywzB;NNd4eo0edoL1Zk)6FOcv0Ajrnahe8_%w|C~xZ z{%*`I1h^s0kFV$v0xiSk^?~0NRr<l+sk_@)`fZeNq#WSy-DPc49L-M6XA0?nSw(A;dp2@jz zZc80&*0bchoGmB_yit*6R*ObAf-cfh)l@Df`}OTSA3MC6uJ&k)%W{mXAd3T+H}Gv} zOu2C7CE6&_?|ZR!vkz7}{Au8*iiYS#S;xKt=P^Op;B$gZDrV!1`}sia40`N#01AqN z+L{&ZD}41$AO#{EnLS**RV8=(sgPa%uRUeXM(lWnq4$VUjwQq+H)>Vkb4Y%8#|8eAF zSyX{;CDnD3j9cHIRs&45S#jg1EE2stg&Zqr$ZpGr@&Dcd0vSr%^eELl#ojOBe)is}-EBm3B$JX%A-ES?DaAMj1ZfG9CT!jiohCJCJu?_*{2+ zyH{CWfV!;H`tgE~kYswfS@g&qVG2`)@X_4OgLK_7(Ur`;j0U7D1XoxS0|?FkfK>-&S<4Y$$%b1aea0DEIq{&N6P*2by) z?&zgXrYYaN?)~7OIuY3%DnpC+3>CjBn~np%>bCp7s~8g-46fh@ozo&{SIa^z6_M#G zm3(-+hohJRa(sB8i!bZ3#&FVn;u~#hVyemP)RPeyvyM0ijU8U=RD=IyvU8{ zgO7#7GQf=2+GfhO=iyB?HlX2jBX7@|lGO_XFC;(_+-xLP|)#sDg!;`cF!t%ly#rC@Pv=%QbuB5-lwZ43My&_ zO}!S5EyBfVZpTYlc`v5%)!wq#WRP0nM@q|;qv`hq8X<1%vZ;{Rm5_B#_aw9il$u+ zPkVIoH;C+BS)$?)U6tq=kZ?m0J$1p3IwK-ib8nH-u|=9I>GpsM*Uole8h@G^t=xk; z*qFS(HPS%jVh?O8rnZ7L0$t~*GD?r6aMN;zXn=3Jjy@8vUPC2H`7ju;6QC=%YoOv@ zAW>ae@i@G(-3wydq`uH#`AwP~?|3Q4wudHhag2n?>ZRP+jiOvnV1mE=k4=3|>j}`t z=;sp0hIQh%$GuGz9I?yjpq-BDiz^%yH`GM079cuV$J%L5a+OvKd58JP&0v7#6I^b zr6{Nm1L~ui?E%nm4x@kYJi|f}-^$d@)cSe+t=G~mew^s--TZpGjeX&vNMg%H5Tld`x+BKbtS`S9g0~Wyi7E?n;N@ zues+$zN%xnNey8cxuDqn4(E#+m!t1VY%$CQ zDThRL_zAP!BVq1Qwq;SO(l28wA=33{=Cr8nqUx6$99Uu*A10o=hcqm*5Sl?G0ni_< z1IrT7P03N8JU;hNYwF&&iIWW3QTD@NHIt2yG)!yBj=)!io3R5`+^>#k<0ZGae#X36 zS;>RC^w*F!9<}k0jQe8+odxkkFmSa&p^_?>70p$|M3L5+x{LkZ4v$iiJH?;XZv~pU z7<^@SUQPeUDA+pvo$4WUyQ4-{hZpg?PJ_?LO}!VsEeM)Vra~=e5=SCs0;`xxBoXOX z*2z@$>J5jb2k8|Ftm?_aj^o&Kd!2jlW;jZbH;!-g`y zPn4U%+4(&e_2O+zh>w;YV3H#_`bIan?`OB>l2^;kSx*doUaA9)*Y$2$e!~iXUiQEA zAncWN1s0iL(d}dM6q(-~Tq^mw>&i3KU%d}QytUJP_g-7R0_xufIgb-2cd&@BE&lyp zzs5fA_uM0VVfc2xB}@`z*lmTHHwP`#QWB*H{7`_t_`o-%b}1E`*4}`kbiCgU3ynB-h(WzhH!OCKId*oZoOn@b_B2?j${-o|F!p@Whdr@9-Bn$AZniBImw|G9+ z-aztmz@4j1+O(*95Bj|8KAJ=-yVF;IYW-U!VO=>Fl>`Do)j97lY9FMA(}x*KY?CwI zFyQ256@RrTG!V7_2f(9T&0sCQ@a!uB+uJw)!&%BzXKPswH3D#tZSyF9&KtKQr&m0lC{&^nD<_QWwQNh z?O;CWtg5_bnl%7F@9*TL)`6^=DT+FodD@vfNzC;y?&FL|y5nPvDir(X^0yRL^U2Y; z?F0$48k=n`abYB26_@#>dfU#r06(?vguUEUbJ=yf5qEXst~GrOGw9vtUGUdvMC1FV zy9>4;wb#q94g7rIh40EiRtQD9f2p#+zgH>#B`z(HO~WdcFcKg-zU_F8T-LUo6nKm*IHv9&+n>x~_ti}iq>%fJ?|4GNI|9N84Hk$4-^0!K)cUNW`UJncK28)Fb27KxAhM=}k^;eKUi(q?gxEpS zCOZ-}Ct83(_Qj2qtrU$=$nI!Tnj}c=^hs5VJcOK_9&DfDtVcf~uO=LuQZZW;m}lbX zVX>7#C8_~QzKSTC8#1KLS@KDM)Y9PU7Qm&wgB5G)MAP;$*_@2nN2*zMzCKC8wNQps z940#FFz*n)Dyd4qu>^|)I>V9L4PbW+_mb$<)u8xOCrW6n7~|QE^?<-4DtV3|eE^U+ znL@V6(|k5(0ro{F?u_GJ$E?(XS!wve%Z}NT=SlkH5hN+#aP|SD%MTdvq?dZQVn?0m z@NlD6gCs%p=M7yO8%e6dJ1Lc?CqOKhIl_J%A6P@<(FuF*yVd)Y(h7`wAy-TCVD$oI zK_XazC(YY*wtO{=XtmB5GVLUM(0DULpO3jp_~v6dTZyklNe%L3W46dNz^8Q8258CA zW=M_v+bvDG#`2-s3Kdjz$e zJK?rVCx&aFH+BFy! ziujWbHpi_awbjxZP(Jzy?FKUs>DC%jsa45<{2;C9p!{m^e()@o5bW->RQx)gK?r9Y zns|GVbxPq0bA76I=I)rv4#hxiE15Q6jKvLEr%9ZZ$W*!r``ZeFVTp$4rnl1(xu8wo z@CXI?chcel@i0!b`UcLi-cn7kO^MwxM}+Os+tSBeo(C7+-RV9^ckHFuBBMOLr0(Lr zE(XS-c0KkW0aSgmpGmBE+)Dv*(7n0qxnSCUDp-FB^A-dDr);;=jcYr-HCsKsV#eO( zdydatRNBM8bi^Ly!c|O;D~DvI?MCm}ZjHj`y9BY{OxfU2d#|3w2pWTUI=F6=bb9tGB~XKNTX)R93qvzE2(nZP*Q?8I!a= zK7Mh?^d$Rpng*3G*zz~@7j=I(`&a|nx+k{W2AORS*EL8$rLobW1Cl7}dXw-i_ZIo* zbu+&(Iw>E?mz>=r=nlbK3k_fdYHz}}Iz42M%MI|OPJFraCD7<_cw~3F)qzGmlvVO9 zCfmD3Am8`;j&+nYO+1eN-J*V(HbkW=B08Wpu6_k+>nKbMCINo_x>Z2+bLjmJM`#;k zRqx2UKhjmmvLZk90%PUqcBDM^*PgJR;|)4D6Jwbik+ z<)|;k2Y=IEVhq+%SK8jPmr~lO8o=6N&Wxt)uipj8O;B&t683Z8QWfe9_~^Hnn22#o z;|}}xnSzo3{CnFDYcbIk_drTTk|<0`3Mh&qhP0Z_lbs{s@}7t4ub0ce!~CQ>*e>6t zFV)+UqUD4bWl2RG(DVm2aRFE5W?Sc2=2SXpP*Ryibm`K1q_I*gFH!Z7^;M;QRfJlc z$oZ+2vGc*^U(0VHX4jO`rkJ3=eJXRRh_Q=WK^C-ss(F!KZzl@Nrtb~_R6*a52L2wu zFO{urV{am?lnqgZUW0n(NO&m?=V8D4`j^L3C%?KysOe8B(x}>2vsF4XNuQWPlfXAj zr@rfz{ZY2NRI(hrk&Ku$yI=HR4DVv)J*l|w{BobH^Ixc!B&JeOB`nWFNCoqKZs=$1 zrZnhcn&^p{AG`M(OP!Mx^j}4B@8Sc$Mv|%-f+RtGse~o1pI;G~spm5WTUx9S#>o^; zKCb%=6P;^o62LP)@>S)=2CBO>KF-*D8%R@&<_RV^XvC$9gL4-2iAT`Z4| zK6%*$(lpS%KM)*C=ll!%H!9zql=>;k=Jz{wBVRdo?TO~=&`RVXePa>Qg2(S8q)CPT zdct3%%dAS$4!tN_h&}phnSaAtZiNDe?Gu~GGL52%^ZY{xrE$x!CYRZ}YT|Y-kv^Q& zF;S7OeP_w)10!Om$X`NuJS~L~e#cjiUIWY8l{dvSA}*9`ZRo}TZ8kS1ZVL}oCo-kq zA;6krr0mi@*K@5-7hsdQ=whS4OO%d)u%hJNvGS!OvyXFb5h1hxhP&x~%7{1XwrMAE zw92!fBqEiJDG2;wd^_*eG6GlfKZedckO?;q<39oz+Ub&eg zHd_eES(1CJlp{B}$K1Cqxx?ljhPh^DhhKlc|Ge)%@Av&a-{*ZkRWqrOcinA>fSfaw z@07Bmus^xMIIZ8#rSct~bW5h5_d9)6Yb+&BA4j`BQ@SF2>=?zf^uDQWKDFX7tQDY? zqskq;uv{F^?AH3U&tK#=iw=22BS1gx>LYU)p#|nWG)I_u4pF{g@ z+Q(qSo*>%o5jU9_2gLget}SM_O`g_GIjvL!bCziyKO__cG!6SO&QG>pwxYKkIP}Ev zas(N-M4fz64`zCdl~jID?BgU$$YqRhfDnVim13CF86xQ)TH)Ugf38FCdk=2&9GNxLrvlkf9BD$YIewLlho-B<Z zYuojbeNcH8@s!v!iBh~*6`P&%Yi3=oMxhsc>smRi0-QJ$=iHbs%>Sqt8mTbsQZ8Kg zn533a5o9btyxXI|L#jA_cGb}sb{Q+PL^42iLQ5VWnoT}Jmxa1B{3B6D{UX|9RHf9b z5kQNGldfX~B?&vdEX7O&%hz6tOe$%WK@`K`h4aIXLBIuuIjLpT zd=q^#{$v7nt9JeZ#ybOG*aL&C+uX3H=lg&Z;`-fyw}~L3yJM!~feq50HT~Ns!kc)C~k|3E=gJch>Z2g_rbKuQjFh_ek=ajXzwn>k({I+SI zL9b_@O+t5%sDC^*@ySOCUr)|@qlQit*77!~UC$7DT2%FYBeQ+CSmoTO|eKo~&OXBa$LqMJB#wieDx-c<8aO{Bc6`Fja9f>q~D> z8GR@J!$Lrp4xo+NKJ~v~gHYK%zvqcJd*sEXW-H`0-|n=LA@B*86D9Uk4atL&zq^}5 zR!qvq30BKT&6DuG3O53Ai%>sSD!@=j+7nZBvyO%Vzepcf>L?F#1(lIuRSFfs@vTZNL7XA(XO7WCdkWQVv{)Dh6e@e%)1(3er#@=1_ z@E4iWM(dWYixlnDluZFnB2?w#an=2J}iHMcmz#z%UKA=SY9ZL;xutn}j3>(@ z^@G_{2#>XRHV1_O&auP7@U&{kyB~2a(U2rGcd+JH_Md?`JhDx!fuzZZ&gC{xVo3`I(dnNR!zvmeS5uO|&Vsb;TuKTdh{lC-n! z3AwU}DyE4{bH`Sd5_sH^Grxfq%XfCXE&{F{SA1fgLf0Y+W5{c{Is`G+j8PBe&vY@bQZI%OnfBb}NQV*zQqsr}@LZunh%xQKlb)hx3 zes$Ni{{Kw;($sjW)Dg8?N@igArngw0o)feUj=iscVD7R%%^|V4&A)U1N@HL^ z@HdeB(qqMp(_YHhmOGgyZR3jKp&>v)Nda}cKUsNTu7@ad4M{e<-de&BYVrn3IWc+) z#g(C~g&qWNUa)MuIIGvwyErBiLLx#i#}9qVlgFcnjg&3{ikZCWcxD7Sm-Bs%e9Ny3 z>S=V0kpfF7i_^#J0x5{}ZbU-3^t#zPRs(7b!?aI^o(An*q#cQ@GD*+-GVp#Rgnw z4k=E)+joAVleYK@aneWZt5x_mBaT!cO*6NZsyHerq+-zR)}C`l{vD1gbHFC2gKh&1`difhg9TS{8M zR1d=6|tM zHg>1}3hp$9S8A0F=JU!5D`aUN0R0v**qD}%Ixi?>5$7CG`Ri(v<(uG~18Ahs>^Qk< z%A=iWiy=hP9+FQ(RO$BPA$K{rf^on*Arptr(t6%Y%uIu%-eTO1D0i_{r$RK@^Iz$( zh5?vwrHJn_CY)C@+XO8@W_Mzm-3shbBLWvk&>q)`0bx z3&ABPfxn3&33zMyYo%h5;$`!G2c^mJU{fy*l{w<#yu%IbRAv1i{%cIdTyEBoOCCXA zNzRJrC}i<@8_~WjHxI6yEwe*x=CG)X%44`G_qfoR^R;{RrxH1G3NO;^R2rknQJ7dt z2lz@Rh6`*yPLzW$J-kSH;=>LYF-Z^;euH(8ddmVlQ7m=@Axi9P|5i!`%WYbb( z%c>koSaFG@4H1@JOo|L0|J?`&1|{%|B->l{_vj-oEv1~T?VRB-Y02nj)8}f|Qp`1y zpLj&!zBfcXVW)|Y!XwL0BV~Fyu}8E{F)T4A_u>xVYWXyBp=V<@&?8|X=qVmVyLj}4 zICeTHSz?|39p8vJ7bw?2NvK0L4eP&hTy_K{5n|9cTxZ=;$m^V5#IS5wU zO6z9A^z4Kw}t4#{_NXQK91%9TN@c<35r zNg!U(VlfswPWkOI0&986Jr4^HSbVC?dO1kUpH!J0w-*yNb!xG3mRl3^XF+H1|s(p?e9@*hf}r!?eACR5YV@YOtZhq-t$6t6hUX;>>#wX=~o zFk~MImnuIFACsPqf0{%)qT%CP#`79Fv_^c^O`ge$9cR9hOEf*dTJ6uQiid{YUgabq z2Ni~pgHX%WP)-fyrpXfql&Py1+r6TKU=Xk+HOQ^bX*_txdsA26$ntpld&*3CzCZE; z@|CxqbYY3PIln0D%t)|osC)RV&a7=PaMqEeRc?TO!*H1jiYL9C)DeuXd3||zm@@%z zqecBI-M0ZCo3hw5MAeODyp=_C{u3@5%kshJ)i-&L$;Pz9UNg6ZUD&$g6U($$TFPXM zWO+-Dmhx2Hdd85s>D0F|g}hvygu$=;PCL$_;4&|Ib7XG9_}?=J`M>Exxk66PyNN~$ zG=Sk&6TjlFe?bs%dRi^O@hn$E*{s*=(8a$hogggjb(3TvEcqr>;K0LH6ZjTOB6VUy$~F1dOmbpM)ht#zx8f`2%$3mYIhmPy-Hr!DH7eyNw-eDx z+^@biE2xL9llE}7f+bnd3%S?$dQ!;o%rUnN1vu7zw+@AyodPar*4Vb@^tDk1GFblc z2A$f)W^+hZl?~X{vTY))R+USbY(GR&@)lhBd=2(IFQ+-GFr0bb`_x3NHAZfT<&U`L zLA*}xU_>Fpyc--I0_7*<*uc-x`IjV0Xyg?NFjMSqrJg?;6;t}@ypaN}iKJnV#y97iywl!oRRgnZbVXlvnFn7~9NK51Wq zAek`;72&TLK*1B>T?Dp)S@X1(8?c<$J-%TNUw}^|M@lrZQB+%v(Xr6x(U0h%P__*# z>(NU(yPa_Jy1Mr{oO>@Lby78i;xaxm_z!lgju&(~LH2G8&?j=pkgUt4m|;a|@jQG* z5J7z=*(>34DQf0bTabanIf{u3Nadl;VcCt7=7T$m+myWy!X&-SyEg9 zZMDgyLAV{A&UQFJ;j=)zOj2H*{krX~KfF}kFIGAX?NiANCS8G&zLC76wrhoke z@)c(SJbqN-2SWaxVgfc3{_NkM66o3s+U0(+1PTIC&Ya;Q7;2uF=@<@4iZMhpz~Xow z=!3YD_T{D19;X*W8kCJd1Iq6ED*vW4FEP%sX6($b23-=by>t_{d3V125H-Qrc;N;8 zaZx9~mxZrZn5i$WKnn5l!SK0B5IRBQZsb#YfgDYq{jiY=a(lzX0zUXeb8qxKG^~F@ zy-_Cxi$9uwmczF{VvOMcv$=1_>d0g^S{-Nlh&z{LPNpa6281`&0*aI>tnmt&RytTV zrL`4E6j+tSauEF<_Xn~oepv|Wv+6mWo6g+2NMj?M7c|SMf7$--Tb`4$;3>e9G4gBt z{Z!Vd?5chXM+ag}nQq2z`rQh68yqk%>85?M5&)H_IObODM#MXnTZ&=z!~LGYE45{d zDYeKSoj@*99ASxB7Y>RJXri%uo#3HdV$8asJHboUo(?`Ifi+Ekn_5MW&KI1lr>$Dw zo!-G34hWD}%2QSc0I&8|Hglc&KnIPQ%2HBmy+L8U?Avcuz|d0I8%?$ycjIGM1|mv@ z_UmOzcBv`2)tO)6nDP0$saIiNY&p77+3o@|Oajf`>WcQ5%V>>7pTo;K&Vd;P{%#H!2gOeD}THQNi$M>*Q;i${#237kjstz#AbBN3L9T zqDyAKSujQ-S_bthehaJDqp0Ff*h@{-Sd_7znU~{Gm6;I}0!gIKqpDo{rR_K=3$*hk z7~f%Edv;nT$MSj15(M4V!+?K5Mr!qTUPh~ud*aDQp7v*GHc6b)ak&j~jk;gm8;|Xy zlD;b`me`!G`d~f!nKrRz)1jhc={OcIQ;^;(?y1y zY(r8?4&z_4hT1<1od|I0_acdwOJR$YdqY!pzwOU`G!LYfl;&>H6*fNmw&cbp7t2~L z(5wDfeeoK=_g0m(MPy6`Qw$aa+Yu6yDSOEpUV9o3okFVGyoF8*r!wt(HN*&_BAc3v zD+BZ}EpFQA6Mp$7GyYgOR<{i1>m?_>hfPvoJ}Em(ygc_VlD0rvKk1~LpQM-OvMe!b zs`R%_N7XsU8iSd5Izl2gWm{}zU5?7q{^8ojWIk-CVTmhU``4l)jN~pr{dzJLSRpfH z&lh|@jiYE$_(lqP9iLoTxxw`$&-qARwIl2yZGPO`*tfKm``flhgF`-qODV29^wJz; z`j;NCt{0RhuGkHzG~u2ql;~O?4{v)&f6C{T+$y(H`&<1?3eCM>iz`7uCQ~NC$^`pn zmP6OTB~Tg84}ZAu;A*S*Qu1^QX=vf1Zt+4Vd$}eL=Xw}#Dv3|7Xv_P>wY z(m#V%lv#BIkAC~=on6Bb*@2TTEHDeND4ayQ+O18CKaH29Dt50?(MpajqC}$2l|Q&7 zFL_<7VvEx-RNGH(MyluVJ79Hn1*CWiadES-9DmooGbnzi_dSANFmLo-C*H1p=V^4~ zWHh|B+E8IVqJz+B@7DF>+ziBP-y)>$!qW6xI@^>bzf2`55*gJJ#$|YYt&)yOWWBWk zjtkwb`XpKLA6mi%VXo^{xTen_RdP_hul8Qt(a5R^Z*2G;97QHU(w+ox6d$40cd73NqrXTFa ziq%~wJK;2^RoO9?n3MGdhZ>(4`-Fa_zq+aoNJV8V=BhIB&`bIypt4|kSNkKuuUhmL zM*L^bxqt`|#RI+KU4@le^0?xQZ1aTi#ZjmDg?(ca_z^31P#_VaL$y7$+K7aPT(C*>R9K;~8D`>^n%M6_P+C{o2>c{CH*o|Tq^ zy(qK^UQ-w%72Bddr70OA-EZr4CRx?j7L>C9e#0m3;D4^^{mK!UH4K17(azCz^w{s) zyeeVcic_u{k?d%36MeX2v!nANMc6H!;FP7;w>{^2!?X`@DvUqY4EJ#^%6`OU)9?8# zYhpdm1f=$-2IJ1+qf{&RQjsX++$~-f)2u^>2XL+9_VN=&m&wZ>=RwY$e#)Csq_~CV zyZ>mS!ID(*E$aa>Nv(*Yg9BTJ&9*Eh?GHFHVvfb+pGW;qHA z4Td_Vyd4pFJcKF0MBMu7kLBhBh|ZCTj4W|~#KQ&Hs->nj6Wm_YyH~oXt4_X^)J|r+ zFQD_~!rOEEXA_ZwWEkz|1q#P)IT&q%>eF-M6`ZEY-13<2$Sv${>DFm|<`n`Nmo_FOTzQIwB_!`YaViZNndR-Z+Hq@zAOOFd$lR@_H}vy_7+fm-s3)?ftUJym0YcficV{USSdQ> zCG?hzmCU@3u9gq>a#t~;q<6Z0+Im*b{pP$S@k!WW`S@_fX$8sI##g(gzo*{_fON|4 z0T}aRUxdMFaxm?&mMp0LP@8}9OOeN|(~AtemUdc*;~>+6k()Sr-CCi9rgnfkZV60> zhD!)E{YIlQU?Nj_DsF;%*_YJz$z<)GIU_7bRb@UQ6tBy8AKuE}T)!UH-m=?GhDxcs z3F_I`h8ALSz8`)hmv0FJe=O~{#FR%)Rg?i49({2S7#qMxu{!AG4X@)H_)1i{PzE3F za>eS}uJwweZMVf{8O7H+u1gl1fzBti7;ZXZ8m^3vs9Lc%Z4jV!fc#HW?mX zi~fkt@70+2LssJjWICGurhZC^Jh1S9KOi7&U`DegamV#rrCwzTHt_2MyhphY0K*{< zY1-PXn-7a0V4lL=yZ{!-@t>>1&e?y5zr>$|@q*X144(wcXTP*G^qp+I|UF z2_+~_M)Dsy$atY+f_)abE$@mL-TY>6h4G0~mR#5r*RyAyFbVlXMD*@-+1{B8xw`P~noitP%N!#L&+2r7 zh6fQpY`k}I-$Hy*o^aJSNPLkt7qq>)v=15#-V`rvrcz%IH%nLX{`DOrtBcEFgQWhh%5hp))A31ODg58I@qRmra+I86G&?olH(f8Agj~rq zTuEsqyhY_cYkzmnq$oaM5FRe>(Nv3d%I|iQ&5F^kF)9KLt}R7-n&7Mx=52ESw;fAF zI6t?qdMgV-c9+E_xdi?p2JY&AWTyB!eT=t zn$KVHU8gi8%=xv~8|2yW1VL2cV=~_?BZXIFoF{SMF*ueM%ZUo^?TAsTvmHoRYOw3Gpu{5RgAp$ z&UIUMBKgb?xEe1C$&Q~*sZ(0++>~WHx>N?wwkqO~-;IbQzg$2 zD%F;xf5-n3kBxZ!<^e3c@?*WoFk4U11$y3AS+h=K_r7D9J~7cdbk8*o&dGMK&P z+RolL;D;@983CXLRv0~w(RO+raY6~OG$8(KP9gaO7Bh!a8mlNtWr0PKF z*l==6B#)%j<=MATnF@VO4RcWdiy2~%-ITbr1y;@H!yW0Y%5_@&=d7u7*x7527;l|_xsOg&fPYipPj$4)3=Gh*sWkv%LI!-W)->{D2|wU?919f2*iDch4x)or1C-E zyyN{LmqC=augc5t@|n-*)DoF8fuz*P{ecD~p71ujGwb;Ul+oC6C{No%T%V9t4l!a{ z?0k-tRl-~J`I)1>MR@c(m@OXC-D#<^>~{%Ikf446r!|7eF9Lgoq4}8-{QgEq zu#8FNl2Mh65zapizD?a8V!+rv`KuE314bLf@0O9xV_(>0SGl4{dxztSYxGx>no zE1_?IKg5>|$}a}yWXilHDG6~fVsjsilOF4>8(Kv7lR76b;b!Z)#--*RdG}g{vuc9K zLl>}L)5Au_X&l3c)wAHnXwc%b50gPug=}z55y+>-d59y9EWX1lSfPTd*)tA=XOw$Y z&Q`6J{0#7XgnEm%v>XlbQV`c=CqCp?-e26MdW!F~#s6%G6c|x12@B$e@AVX?S2E6f zDq1VpoGDd5u5-a7iANbatV{QHKD6mN;bx9yH7#dK4`-!uJncXe!cG0n`}BijzpPLm zQSD8Ko2#rYQ(uxr$2|O*Y#%s)rU&89lr_N!f=4URrbcf>L*lpJe2I(CQd^l1dsV{9 z!ENPtSNs;RdsU5tCX)z7c>7*^Tfcyl-8|F=sukb)o+(F7%7u(+zfLW=jva4l_6F)d z>=suYzTj5PLa0>buGLDA?t0<^JF|QVe7MY{cxg5M3E_0Tvmac+2lz6F9i0Mwk@_!O=`6}s#j4%oF&oKXS#tU~V^yp!&Z>T!kMJR0^u*`GA5 z2%VF}^W}<^keg}g5aHmt-d=HMKk(bH61rxGBL(}0;nruh?4lMZ)^z6pXP!9kVPv1q zkE>j~uGh=~%^*eYR^Vut1@l_DMrPx$&sMBKk~OXpYKrADlOsPO!UJmuP8iKyI=7{A z!l8Vw$8D)xfm7_ z^kt$>T>R~tG##y z2kGLkO1heps(Zb0aZD6{{`ng9cxtRZm;V0m_t4+Wmz+UzS?jmDq;7--?zRbYI=Yql zE1rwcK!sv-5|J5y`?sz0A2Tdp0pSIdBJqTH+nmhCDKhzq(o*HYKY|`GSgl0kyRt{; zLwV~+*Dwo$(#-oZucT)5HCXd)JwkM{N>l?cCS7N;hb1rhLn(J(Sa-d$*H4@u&w|Cb ztjAyQr?;2CZl5^qUlrt1?TGdU*V$gwiU#VFe1cRjhVqoYY9%D2+Gm9-4J;>hyg%41 z&mXS5A@8w4PQ!C{**Ce4!Ypnt$@RYf8DfhSQ$3J=;adEK+ick{H@v5baul2r4=Yp} z8LG1r$%VWRR=Du*u~Q|UBv6L?fjp~YrkHX7vjIHW$9k*kE!@RaIXC<#gw(dwWDUBs z^s0C{yqn(coV4F7Fo`CqjpYl9=is({x}uASa&^Ff({>t-qdK6WZPtgbB_St^w$qGp zJ)*AP0X0VMw(|C=^Vdg%El>V5>#uUXl6_8uIh#xa3sWC_<+xv3wCblQD|oE>W~oyr zQu|g~$&=Y41P8;+*WO}v_=q8y7HrsJC4%{jDS$2wP4j^&K#13<^OGBp2_$L>cE0Bk z8#)5B|18#ExfT)sBoLR)ojg2!neb;_#YHF0IU}18V2fiPzREv!UmU6zaCa@ zmqI}CyzrGJnYwSQmw=3{XSQb)L*FwZBn2p~rE(j+?$t76vyWMv$}(C1LYTaab1mio zzp3qvf!nJS#eqIoHq*Kg8q!|+x=)911;Ooh$j05K#zdtQOh+KAATvtgM#%*_e>wM8 zAI=ruohANUA;MN1a`JERvDUPB#2QhMOweo}R2pbhyQluLk1OiQy`%T~KLX z*?OZMK6uk|U-9iynZt>1h)H5jJk_itMLMhxUX8J5cnlSvp4EA%_iK5euPc{+)lbFVxuTG0m5?0qJ6mE26!|ERA?^WyV%Jw;kf03zlAkm>iRNF;YKZCt7IG0Ut z%Wo1hh;D5aJ(M9D)~VsNw|Jouq;C&x;8oE+^{>p!Ow@W2xq;HP4i=kaH zQGVXL`rU;_V8%z79<7nt8VPfvTkhc!8=LLn=UlWJAZ1hHyD&A59ax}b`8;1mx$7u> zA2-teHo_xU#SvF9WfrpC-c+^f5HvX0U1YZ*`23f2Y3l#VjMn`jc`K7gE=j@_GT`B0PK7zI#-K9%`&u9Q^ zD-N$0El^?AeY=^co6Q;SK!)&jn%Ex!1Y`Vxf%gRs!xQ-l3U+EbAwnmmd$H@6Y44^i z3UCOmY<*D#u5u)=XZB8;jA(hcN)Og>Q1kyt@%8>ppAGnsLH4I53Unnn82jA^_$8Cr zXj&W5z9Ha0Nr8#rCapNVfK4`JBIIrM+cvN5?CjIaXTt%86nB$u>49dch)JYfkiY^5 zmfG5{qxxnp7Uf}XymA*4&ePzb?E1sjyd5Q5=1gBvN1j4SxonnU9>ZYvXlFs}lk&}9 zqh9xCUX-2mhJoAHwZ;#hoHrff9@XHTUUAJ zJQ{>~c{}c07MtKe6`=mNs7i!<=gUga_h!MN!JXCX5zke&iU>}5$3IId&SNe7CCg&aUXMepRa0EWS^4NB+E9?bJ6ubz$rm8#W^%?K+E zm$T}Z4YU!_$QAdqrhhI@qd}r_d!7|O39KqkLhR|f1A!v;4}*cjf7v*mT?f7a4eS2Q zDx6p?Nque9^R|HF&W@o^dDU6YEAA|cG3*((bEeAq^&^yRg7->b{#Ae|22w^sZ8axM)e?;9dCEU7CyS6ORymvxk8qeLAs>P{Pa$>?u=mo=~ zq3c4~30$lCl?eChde_p?wwyu@WTM}*_DA>p3L%H)-l#?Ek4^j65L+#WP$6u=X>$BS z(JOHIK=BvI97-CQwGt}7tourgHG=22^!Q(q{Uz4YbB(43x_hase{6J$n^Zf?EbI(^ zUR4j^?Ygb+14U`cCSRL%?c5|ruQ}{;wS%4+y5L;{00(w)yP|7?mK<;BfU3y9K<}dX z$W5yHJK>&`nIoqjof?ZM*W|nzQ|>%4uM$BqA(0|_MJk&i7LydK5(OA**zP;|K(Xp= z_da}6w)7HX5oj1w;S*@bA{8_4V*)GXd-@lS-HE9Ve$=WZHW>|&@p{r1kWhDYBO}Xr zr@+#(8aCPDe%{rZ5JYkPvJsXq_Mc7gZhMURSDdNHltfm}@9>)>)-~g0!cSebK45wO zs2^xMs}bi9lTY~%US6c({d->yn-%~(x2;p>VQxyM2>GmE5$U!2aKW5Vt)Z2g6ukQ6 zrReO#YUkZUcGIq%bHSoXJG@}O$)&Bnp6GOM=&9+8>V|b5d7OEl3v)te(vwPQO{~ku zC9{v0E4_$u5-oeALjQAP`@X*l-}h_Ga|nu;3#T=xKFD-r5vKg;x>d&NlV7uy z@BGs=arZ;D^ah6lPNw*2m>U@)B`1Ah-)srL2F~_<9Z@;;blUbrV$Tp_crhd3i~6Jo zWGSy_)^2n*gH^xi|a!`cS~2{WHL1?Xh=~M*0l9I#%lPuehSYzpF1k(=nAj1m#!ZN)>LCYO0#QsSXEWCp%xi z;u1594zHlJ*qUZE4GwJ|H;-4HNLt4VPY~|wm4tIRoX4ETB`RRte`9LR%Mx;ChaQMv z{_~HuImw}aSYba?*_fA^@vC2zX~js7FB#0Ud}dm#{zsDx8dg)r&(k*J{Vq%FFV78d!Ec7Bze}nr7`rTzBQ*B? z;q0?eUc!s*n?!{U^~;CdJy+9p-UU9@C&}*|Uj!IWdV4a^dggg=cg0q7_}Tq_dIqKI z7L)x|>K~X0gS{sRQ={a;L=G49g`*V9L?xI)xfHsw2bHs#A#cAt9vmJqe~pVXu;Sf~ zC>mzRz8C{np5dV6LKy8{+lQj9Kwd1iYqw={FtKDemx%2%7lwKIcDtbGzxe z@C1=94Y>T;JMs>DYvR&*tB<@(dppAw#la8nzj3%XGbMJ$S03JaVdH*6w4lbZ(020v z`4_uZo~sM7>Lm~5qx!82g5W>_oqinO;YVkWDJYM?C<`-u=oN7lG?r!M!DqbKpFw_> zG~xtSXN5HLZ%elAo^Jh|H4VnMdo{Mc|NB%De+Te}?7Hjtlfduw#e(axhKSh-Kj!K# z((K4>HoV$~1ldA=LEZ$TgcamADT}zVroV?973r||YIYr8yknJj!nkZ32en0MPlrWX zS7}*@X@~rhO2bm#Fwu>gN(gcF`(3!t*^1wa|CCOV)tU;6B}1-TS^Lu_NoXqM7-7fg zJLV$ptjcgr8M#bMn*x*5SBD_j7qYaat-4lvDilenr@fWrKJI~v`C$1!UZ+SLOrCgCm z;d6CV14~`~MNV5T5wkSEmC8t3uhQ{jNq=_xX?S}IrCX8BTR~Ca0%c@@J(mw=nJsZD zOSK7Fm+3fY4gM@m-1-1}z)1*KA&4(aM=_uLo|S0*y4^OYHE$A3{=Q zh}y92rEf?-)c(5-ol*x{<32NjI~V#cC+&~d+!Hb6^3CA$eaG6Rn-?Ok-|D$P`>8us zeb?|x!VRq4wueD(_JkktM9sK5nt5h9-5q0yAGsp6-51kc#d`f%)6 zIY=K1yMfEPi_F2pMm_59>c!JsSKF&~Uw35KX04yocm^iOVN$3in9}5d(yyf;ZD!Vh zW3z4o&Z}12u@WDt6cKPJZ5F(dkxIEHOP~!DKzKDdP>c zY}=ifHA(v*1F_k#kqzZp{xF?g&>!r;)t8vKjDO|*gzBgDUM8H3_1TZD?@M?|vJr9Q zgt|ns-qy8m16*~Px@y?Jac8u#*DiqLBKGVIdjCdH_zQUX?&Rc8yD%oBt=0qH{7o1{2hhJbcqpNz=-)$q0vZy}o{ekj zS(*>OVu*h;SXb+p9C^F(-GKL>V1Knv?c*Jkpekm^Ek%ii5brDsVCsCWi(dc;a>Y2a zT~EnE)C_I@g!fJ%zQDX90Os5Z|2iP}TZZnYlwDdQ=RH^r;!K09n>W(!{t=Cd0xUc1 zA3aIXORD9QtnqbhJ$e$6T%tE)UJ8Cze%yx~6b#jpaoFu3G^7v*M57nAsAOc94fyhg zL$0&iY7ef5x{N{`2sx3IfhLLY11!6u2~Jiyk`#*)o1J#*G0-7w4`YwsK!xkOdUBZ+ zA6fCeJrq`Xcmd#ns5M6Q9cxw!>A1E4@LenOj%$&s@^!*hu`KW9<2{;8?W|cA2*$gX z>Th|irfR77yYAE7ttQA5f|A2orq=O+Q%S+Ju7|ng-fdnikNY&qYD{h`KwgC7D}7{Zu^xCi#?9Wv=|P6>N3jPs`E05NY6~;&t#rkbgF}zNofP6frPb zIj!@qe(kbpOc7Rb`ZB7!fO)L4swW}&yMOqTdNr;l(OSBi^h#_Am8KGgOCYTgOJBHZ zChaFJQzYlEj>oMHd7U}FVCxf8IT>ESrW4nQP=oPK(DGXWG8xzPUfXV3A@Pq0sMq&N z8j#S@&g&kFZZnouHghzYoG8DQ!95Z*RxyahfkboB%3O!NHE7X|Bynsu7l9O-6# zni4nd3iniwzbN&*{_yaEe(LV;Rl=QifbzbF$3qW>@Wc5OYH-not@H!)pk#kz;QRh3 zyW^)ZL&OUj7AiI4AmjbK4_0?wDP!`KW67I|OJ+<69nuC1NsNoS(y`A?OkM zN-a?}E`!lG;@Ad%3fcYsO5qv)hv*rMy;_4>q)ZIhBh$JHnGTbK;LO#PY$AF$o{!LO zFz%qa@8_`|INrZ~mUfK>>I{BVY7a9V!Lq17f443-nYWMEAdfd|dyQ`f-t!{f**uF0b0}hUA;GP7zGi2zlHUT+ z70xktu;wMqcETl%pg3vaetE(`o~~Cu(opQ;_)Y6_T?nxyGBRApWVt zD@>NWF8^$Cjsb2=A~)}Tt}-q~wpSwbQGB|MufS^NicU8S?A-jg)y%)YN#mObI&F(D zf!EsTl{+Ya(53c}-_fVjkE2{Tsl=K2C8;7P+4~z8?z7QdU5UZB&=gV5dORTUD$ArB zDJDAoY`AI`VCcYW+I86PAEZHyuyRZDW54EBhh1RaoDz3nV;dX_jm) z1PKh^fX8P#xHW*jfGX=NOh`BOILxM<&~v#mZ|sXTiEda6@$^0COh=bA<%}A!Pupia zh5dDXleUtQ8__#PKibdzV83UE4<7PKr7+JeyIm+;&f89(aYJX~wP%3GO;X&3K&#pAsHfOa z0Sb2Po?ijwr~dFATKz@fL-M_;Xeu*q1tQAm+q3Vj9}(VQ1h$La%@yfOP~Z?W72Mn= zED}Cu-_F^c->JJEQ9--w?2x!`H7V&}vdyE)Ap;pez! zsE`rvKBg}Cnr7p(5A`$ew;sUzIumnrQ~n1}K(N0+*Fo=g%pqj!fFn1)I-jh^0Qbvk zO{|v6dK_%d@O(eo*9ee$R{y6BP`fLQon^R=KuoVdoe#wH{EA#`wMU{Q#$ddd7AFaPttHRQY_Ed{tYFp-9=FJ0L!XM` z@IA16yEco?*2 zpog_Rley!Ji#wxx#_E;%cWzeCyd0i6_;K8aWO_lz2~u~4ILoL%8U4=mS{;+xGY5aAr{>-_(SsrE>;yh2J3m3kvdN!pow3w}K^49FQ)lVAGY@qCKx+>Os|VV9 z^gQ$%Ct=OQUMEsB8hA!^ez0@%Sxo;1yfF4osPD;pvd`}c#2(CUL+;A*>l%)U(9Yw1 zv^~4}%qI2+RQE;ZSQVyd!`zd=62?AuXmiE-cEk0>`39y(gSj5k=L!4xqyAijo%L|p zm@oG8b0+sF=1J#R0P^*w2Sv^RN#BQ@YjCDyrp-+0e}8^eJO^H4*)r}C^jK@YQsyMQ z+1UQGWL?U+bFf#fIgHjih47E}j<%Bn&d*Q&75b-vj5Y3;(WiF@Pon**&yr%kVfFXT zeQliimY=0-Eppz;R`NPvTq0tTOxiuIeEzV!5)c~P zQ~9Q_FHYrponBMG9f7aWlp_J(5d0kU``}(1j?N!+?GN)^6a9+7mjl`8MxE08HVWSq z#q4g}C-^+!EV8`WJvmW68jbZwo)e3SQMs3IJU<1s7SIW|(KF@}hv7Y=bDm*x8sdzS zuNdSs0565_BJvLf=h@5c9pd$a**HcfFI4=^_+_fKn^z$h2i)j0#0RM!E(?>2X2-i3CI<%@P!y6?(h1}j+ofMZYicj@=s z`m>zd#p)p~KAfz7C4ZuI1|#X4%zHSC_Ha#KpcBCu?OOv${7oMQI$)Ssb>n28q&c3>^~q;cW--?adtUa7* zBF8*g&X^sf7;=`oD(^mDf9?*)n)oq-u@$X(aH$7FT@STb+$WhQ3G2u>*9_!J=FQMP z1b(sH_v;PxRm?*na)JTQ!^W8LTr+vUf920_t*e4h5@4hu_iB2dE(>-L&JKAU7|w~s z@PHZfeO2DC;?IY8vi#du`;lFZar}3uIwuDHS1>op!92_aFK~M2fak^c^|0S~`g`gA z8n2I~b8$S3OJGYlo)3D@k#`5~b+rf0@sVUqTaOc9wsOD55icEKNVE;`dQnaPCX4BN zyTD^-GjsQ~GfVm#=`XAHGe-|2n`V2go}Cw;tg{%P)jz*ddy77W$yt@$EB1r4UT4{ZqxX{e z6oJhIy*$yj+BmM%#^L*A-*!eWo7P;bZ-co{IH9-G&!t6mQ`z6C-UI_}S3*;#18-ee6KC_q?zYRS3pWTZyo%fjU%=p2VTzH#^!7WUeeE1 z*}(5HelphQ2l}S2$82v2@rOPhDfwG{uZ>4v)K_x-UDetn&KS0Ci3!*JaxSwh=DA@p}=s5z{$lZinat$NI5fr*wI!{a%&doZ5pw zw-)_cZ|;_2>t5yw-NT)%8>4(d{gbE%xmNuDxC>K%KBKy^jsGJ<{W1XB2om zaiAMXudS}tF-`%$e&^;AihN+q7h~;(d{3R*%6NSM8&K*0^5%Hw_q2TmQM`t+1Kc5l zTQitQlw(-ozzJLC}| zeZM>o8MqSscK{u8w)~qjk#x+!O}b!qTFEx#nb_RU)ZW|r zW^*j)05bonx^<&=V2!&Ikb4>j^Zf8aSyzka#1n6EC5*J1@`Z}9O ziE=(vM|V7Ld==+`CilCp$#=|f=s|ug;;8~X26*_Op5f{n9hWq4y8?!t&Gf9t(k_>G zQ|~U!>%jPuawVZ3m2DK*66RZ_eoLzBD*K#s5So_;xQ7r22>D!tg|s2b#6zEpjYpl)k@mVEbr8|E!V9GNU%0sXQeR*Tie34TlFLGE;J zEx;!rKFhs(StfL^T$aO954q4hskGM5?#NtXNw|yX*$X7cEroWnmTkn zZ@i6p2{un=c)|j{2Jlt3>c5B{m$iHj7newEi#N-!8N)(tz2V+@AKpWfZ_-$`>OGvi z#`XM>)!$CWYjVsytC1P3oUr|Y9|t@LwHg(@r25>;yOP4kCj4%zdEzC11$^iSKoO;NWa zaX7QTe1<89vSoHqs_zfF&xRFX3+a= z3ftc2d9t4SIXwU3^OoL6+zXb+1HD*}-<|s7Zo%jFxuu+oAMtnjH(TTW?C&}6CuU9L z_oF>U6K!d(3o+~-@>_M)TxYJk5uXwFzMh{a&3eLPCKN0nQCf_y0 zS&6>u1I}?y_uG%P0H4r5_bRmM5K|EBMz*z1Y?hv(XX8xgXPtd2@j<08CY{O8>YcXV zmuTY7Nu1xP+r@tL`)TKTZv9NKZtmiNRDRcsDIaQXqE<|$%O#@kTa^1#vzr*FmyYd` zccW{}yMY~-G5X}^X5Ghp`@pvpcRcS8pG9VKBEKqG2>faA4cYuUCJPRRV*Z0OGXe7X zBu`4~1*?C)Qrx8~-r0&g0jE6Wi8A}^@e!^wKSS=H!PBBX%lVnKSF-oR$vuEwz`2*c zPNq4yIu8fPM>JOo*2ZEIPZq??m#xdfbh`~$8rFwnu(nrbMv7mJt%0iJ%1I+8aR8SpIb+}?bSqrQzW-N@s^eC%qR zU}SjYBnYumRbCg`w}5%l##v%CR%iSG;8#wudvjJr9{elFi}h<_KI8y5?&g6aX9mWNCABFJ*IbX)SDJVP^y6C+cvV__gBz7Jw9X%(Q=#HyQRYTq>h`WYu9e-} zx(xcygU|a1Uj_&L^x*I5^XI{v)5~7}Kl}Y4I)8l`|1EeH9Etf-@|&p+qET$2kBeI_ zMKNQArg?C&RGQ6H@Qx`)vza!^FF-xpl6D0K4- z<2VgHg$k)fw7YA66FM6o+Q;ZBbf`j7;ur#BDT^YVoMiCt;bFBV@SC7OGyj0CF*e8R zNKd&Ut$8gJ3zU`|<~HzM0k@qKA){L=1D^E<{Dn?(R@~_6fbZ?ad=lv^KHSMN20yW6 zdLfIQgMoYKuS;Ai((%eRBi^h2kmxIqt9LMrA0BivU#O|+16He{0*4|4i~tKn!9S7t zp+si-N(~3dq#B6c!Amtzz!}5ly@Mg)ds)N)WltjBXYhP5+>`JphM{cWS$dh(n3Xtj z!ilnUMHVTdg^Izo$1w6j=jTHM-ZJU5y@q?E4`2 z!tzKnv0soplluksP?*o|?!n89?(XLPIgiVA@her$xp-``dk1E@eJ3ozK)qm9r?R>r zjW)o-a+ExSb-_RI9G8>_o0Msr^3DM)a_^wI%CNM9y*>3p3}mL_2p1j1@FGKr?C#>< z7y3$K8)%Y!Xmy$aF~0VPFCqhDgsg@Q*;=su$RR0P_8jEyZUijyxKy2LCb^x7orM)B z%*4zON%*-(V2(Q~uEs4;!~OhG@g$+y)sQUk&lH3`t;}u;qBayp8Q9d-beO1|k66@? zjY{l9BM157d5mi!z!%y9^XzIg98haz^LWj2F#3gk9RW9v{uqc37M>g!Z3Zx69>oLf zox$oDV`CYu)}Mij4Op*-1bIfU7z&Ey5zGXLt*n9jpP zjdQ~MEC+rK3y@3kf_rHeUS}xMxGL&8Lo3{%*&?D~A#@WtjpMZ!5Ub`hYG|&V(?*o2 z+{V;6h!`weRjVj)6$PxKVG+b|B`O97<>Wf3&ns!J*5%}Rz>7e~I+;>+c2}HBF=tXQ zBMvi*FivHLiNPkmaov6aqlE~I#q65NDn9Gv9s>Sm>k?fy@cv91Z3SUEa2ZYRlC!VBJ3hL6`?}Tq&D+;7shaPfS>0h7 zdw2-_pwKukNF=h=-3LBSpMUZBmut{|&@FYx^$6_2%sgI=sA5iOQjy#PQ#FC3R};yy z)p&r73RZ&C{2iMx$%+xnl=X50gRrJjfYmBd6HDcPp2AgA2gHR6fC}A(>mwQK!uThd z^Nttr7|laZ(~0S6R1HU7;v4;Gd|s#1N_WxGRti3=X*H-2VyqMmZLL&rqtn%EoSIah zj}5+t5@*;Pcd&6J@|@XvBSnWP>OOm7VN~6D3+sQ8N#Bh*9`ISm{>JhDD0(+ZzLh`) z;7E9%FDg5mSUYna*6OO>n?~=r)w}$}@#4M5$1_NVsXi%yezKhL0+!_-elY!O^w4|L zL+>keuKQ~N6(mGwQcnzTYgLoZTA(^6D)|aOk2g%nm?TOVMy_Z2pqtw2yulM?)xW^+&5~z_Zsr$ELTb2wlW5c^ zT~pSJ(z?pv){JWq;Bj@luduD#!c_~{bj>$L)I-Py`h1x~_a=ouI;ac=9l+SWJ$h^z z(2>esMj$IuD3P<>UH6dOQCT$K5;~vf%g8kmDsL9Jw^jEUZ!0Gkh6B(>)JVulepAS5 z%jp>#+wgmKyutz;9kI;LjD=$8(E{xt(ZUKa8PPnC1g7a$wa{gPUhRhH`ob$~+QBO+ z>2ipsC=bg3{V5WX6=DH{i0GBm)B%uGa(;;&@Fusg!KE9WWx%gFOdnsl)(ZAaJ|_rCy25 zNO?}NV8m_(f>G>}-Gg@+QFH_al&zUbz-89K;gMM6kT%U0iFl2xXic)o>oWHJKj7aH`qhXE5z2|WylWrKnH_r1HjyB_$AS#Ke8 ztNY{7qAAAF+sLG=)nwm&++^Pz<6QT`!*CB#ke&Yj#JquFyV^B|kJ=0yex&0YcV#V` zA}&+bN%T4U;$;So`4@8;>nh+ z&j0-}AU?5pkHD{7)6oZ&J=TfmHUqmY7LLNbUkBVcB<#z=#|9?ho+OU}T*+bO!60LR zb$kLGv96e~6c8R>iKs_beA9=aHzG#?(WhBeS1TC=)0vjSy?kV2u> z3Bk*yeIq|u)Kv?iZrD>Vfp5qC!rZCJV_SYM@=WCV`C z_z~>xgmCrBl)z^N)`aOjxnTm!C=Ab+0{Y&(y+|)enemE^-GTJF9OL09#Maf90?I;k zUg-_FHaj|(;`koJe|k%pdAJmIt0#TGCckEVqIKp%>AUo7pmlW9^3;OBG#Kd&xfIx^mGICqPa7b&x(_JtP z@~a$>DR0U>EaMWdVcntj!q#IEuFs)1hH7E?>%7X9zwEx$eO(GV#w!H zHX~{*pV8gJ%_b9E+Y7zN(#N@rY`I^3l`2Dxoj7-VPWx1rLo`5rpm3e8WrCb%SN2vf&CyDI6bg=42r?xv6wr{O_%5E9_< zLYnJt-sTO#(P zMvn9+CiJrrQ%MA?81|`Y99gWMh!%^{^pg|0v{*e6am!>*=bxI&nM3Qz6pYI2Wp{Ye zwKJF|{_+eCx5kSbh#LSm>;$gq60}_rZeC7)q(!D232lJ`Wu>#b@)JPnIoo z_Jr&doJvBkl{x3r?hGr&XL~l)+i17vPh}ZZXJuXEr4U1!Gk?P(X}5-@!E z%%>Sbj+y+r&6Ceu%yIpzi=(E%-5Be}vaLObTYL6G5~krJNcTXPgbm#Wb`Zus3@;vA zjQ1uvJvaDZ2|i1j8EVuHYVl!I=U|eBE*o{6`H);vG&^CIl$LaU@xzHJpA{CTZZFgZ zVMs}AX5ymzpT@Mi`&sfx0v)NiqJ_?PQ9PQXGzCz*;jb`b%Z|tSvFq7bI9EYvT*79-68SE> zc*y0P-?RLpo#@v*w5ibA4!Rsw-JNoVlGA0Q9BF$kJ;jZceV4@8F-=Wu490BldB1N@ zi*dgMCxsPZ6hd_vjKpk)x0sg@`|s_!0%rFHyWe0`0apQoDq8X4Ca{N2fi18Rb}Sa) ztYC=Hra@^&#{ure0$kYr3}B!ZlAnqvwIF0B zg>ecm#wRDWy9!M=R7Ty;l4jwHtB*UwozR;B__(-bxtKG&MsK5vrHN%4MF6ecfo%zjnS2FZ+kfyk$k3~5 z(d4OoM+uY{k&KGtn38jMqmDQslmHMKYiH&4W`B}hwrySEjtM@##E;L?9UXYvB>G3p(SY6Gy!9>UsF5C;m_0a_U=7Lvk~|{t19Bf%17v6*}R?xGF-G zt1(NVLcH26Og$6j<7v8c;6lc0HhC;oI*lwrv(DDT&epwfu#xmtosEPqEfc=~lR5L_ zS?I^)1|OBwF=IEfVK;Wwx!Dt*fYN@_3I(VYI+Gn%+P0;~Z9t2hNoowTe0qBflFeulzODFh@-muqP&4HEdibIOUlO_4;%VrHc zqjQTtyJF^EBZzisfABJ)d879}GoyN2iud1JgjWXs|MtDbzN3R4`?yN8+s5%b8-KcQ z;&9FA&3hkjd)S*4PkDfW@|PpC@~Qgnq`asmv;IK75F2-srT?a-$g0jOIUE#rP2P?x zw9xDu*Coe}UxA*;_#xWu8Q|emD9T6g7CG4atbB$*j2AcxsOlj-vc0nYY5>m5x+g4) z8Sg5NsHVBNd5a&VdUsK8`vWee?J*Aif*rOl&8_fGu(=+b>ZdOQKa#(0H{6?sjB6!N zmztM=W?XXt9v|9R9W(lTvnuTzSuWkDh>iX@#9N0?(wkcyn*bdF02V~p3qr=%k7~+8 zRI}kHh+Wq_=lJCSeu84Als2z5hr};f`bb#>ULRfl5Vxt72RuH%c!Ocnf1Kd1aj=cA zBN9}W^|}G-FI%V8WpIL*vf&+nh>7E=i|x4gQUhGC2j;l2!iOh@)m!qDDZ$MRF*E0S zpF98VfRF8Vi}x&McwM|t_%|Ng9TMxUpiF9xZo9KMuKZo?QoF=U;j-6@w~R)|R^z;D zwU?Rkisg-QFwh)*fH?_g-w)ZxT0dE`+wzj^?Lq|N-BOYdLkHbH9ECSaDZ#$aYHoiLWEKz`w(J?I7W7~F3 z-XZZo0h`UV`myfzgOyEzH)L2p{{>=;!mL*mS3ddDt@{?=*t#sZ#&EYW#NRY&0cZM& zBVIFTV*a-TzrUub1UanmPSobVYAokL8^F-UX;wEL6FdGMOI5i?4 zza>%-8n1SWhll51eTDysabCOll01+J8I6 zI$%Mg34WyKKCkyzZrtZI_IxE?cSbLanBcGSsxIC8VWZL5y{Q{QiPB|88< zH~=6zZ4iBG0C|L~|Kjdho7+Zm{C>YeVO=HCnx;j)AE8~2(A@yK8$kavt#qPQDwV!J-524b zgEaJQJ({LFopR$RBgNAoOn%^C`BO7-F4I**!1I*WeLr?*@EJ`)bVH*|>p^Teor@d6$mC!#nQp?7x+{-b}!pfU?* z-q6^6>)%{e&^@0jiJ_L?VjdBT)$BAayGel}JG6%y@7%ca9pvG5d}GaLS4PE!br!6j z?_t?XVQT28U)tJ^yZgpWaJ)#gWBnjI^_(r@JQ&ZYrO&*Zd4Lwr6pzYxzQs#UVMy*IL?=6c+kuIc>~NRQ zc<0wJ3Z`RL)%XJt4*z&yFpM&9=iAri&bI~pdsrH#NK63eqg%D)C&NtTsREg6!Z78W zxdv5t44lSADsud!WDfbW{|I50*m&^8e)Y}x_JYL*fiN~=LK!B4Aj}x4*bWTpvgOi* zfgWB(?)=)HJO|^jx))`eXy6ZJ+NX)<&Nd%t>_vuOR0k)DevjX|vG)ReODn&5Cbo5c zh;7I2g%> z8Z(Bhn|^=52oUsEQi4s=8fN7^pb*`7X63JkpAXH-FCPz2wtqeNZ~#9~e?B!UANNo9 z0T%!F;qdGTUVJ{-|7cczK74oZ37$Uf!xw)B>K|ieDkl|K>CZ7T+I;UuUw)3<#gDP} zz@6Q>LcC#>W2|%iWc`EYnc$;jE8uvuIGRm;*R1^S|5QHBy%|$I@S%dv22?(bVwGi2 zoTE=++@EWrKJ)lFMr{8-51~;IF?uxxMhFD9GRM3vs@G`0ogjfGslj(M@gNi$Ep#0Cx2ANBrN3S&8rc zI8MOQGkHwBR{_3Me!-adgYf1CLkkuPgP&u>r6Y?moLm!J%-A&s9L6Vsi%>5->Na5i z#-r{m0%HqPDwFPgUgqd^|0%d~dhJfV>1QwSy~}4=B2s;0R^dxe%jS1YOPq08(to$9 zGTsjoFT!*6mmVIC=NKMmUKBwE&$0$)RsAj+{`&_8Go2OEUt(m)=P`?Fd$Rs|>R8x- zAM3}$FQ@ys&G2KafJ)?M#gp~MQ-?wO$Jb+(({SQ@$wKOF;KZ`TD?;Y~!eiy!%>fkG zuCPuCbFaltB9rSF%n>V1-IF{%zPd>)+Ri&qMz!QR3hyaz!Xc%fdc!jQTYN8rb^`~M zBkm|qhj18SXrZA{!Ppk4)8M;;hFLL`y)JxY+Y#w6HUaQCzdXmcXn=~pDXdsBslU^& zTo)@pbKi7biXT*YoqbM=^J#0K*S?|6VdG707&{6lm+UM+kM@_l&6tU?#9t*uSL1Z& zHO+{V4htoYD^`0Q%f^!Beg7^bfrU%N3Sn4#xt+8Q3HorQFmrvW*X%S)9S7$TziFt~WP1*-`egz^NPPAovh zxC!q(Iz(pQ*})cw1%(mpytstpM4H0vgvkBuVZC{Zi4uVeQ8ng)1s-M$!W0x(kRRSC z)aR+TiGs_^=OBTho1sD<4eA+B)@el~T(3+p>j(3~+*W{Mc_@Lhdi&a= z(*@jVkH5*j6oA?&PSGF;*`!Wdc2VM~P^VpAvmHTTy@wTC@i8q*q z_aGF86$u8zYU<5~l_~Q!ANZsiwl9Kk@?~i3zS$}xV#|2DgZS?n@^ETt%Au3t#4E;i z5PayhLSrj8`fB1_EQMv~VkO|i!sIfJfoC^{Jf`{ztAFpoY1iwZ5DF%*HvBL**texw z=n_MUgGdp>RP8Lhok35Ai^p2&{(|t2j+Mmwp`*j##T>$~dV(DUB6c4*Q0!c-L7YdR zBvTjSnRRgyKG3ZT>=)jv66C%&UP5Z3J>SPnO&t!E#&C~gP;ha zXy)P&6k-TRqksj1vg#dU7^dfFLtg|9pkJ{19(hs4!IPR#JZtepAlZMVxteYg8spaF>Wuw^r<#9 z-?$R?D015(mz7fw9dUs@hLsn0wc$)TElw~E8$W1%_|=~#*N)X`|3zaO51@G1GUgA4 z=1`W_%Q~B!$&}tsD79M6yevMQl~yf|O%}AlVmQ#P-m;gbJih(lMH3e&LS`L%ceDtp zgH79Mx0+VH+3YuZrakEP8eQ9J+ns)=*@yqk#-Q1^n{BJx?zMWDO3^l(1H0eubgf>u z-)Pkdsx|0$drhm~>~|XV7QE@0?Ln*8x2=As-?Qrtc-J#KgGQ^>w)(wRzuva-o!Nzj zWusyBp{91D-GO&zZ_u%As|7VRI*p#)?3w*Rvkn-vdbZuPTlIDuFh$fGfC4;r+TD7~ zwoMz*?^vy7x8CSAdhL3**)VOuzh^b6kVWVA=J40}6KSMyJ;_ZJ@wv zw_DI+yV>qETVU+lK!VlncA?Eir`vD!n_bfe8mwlo2W{HGvu>*cxBwBB-ETFaY^T#} zx9d>0H?Z3MuH9)hdd+qlcmQSl1FO;RwR;V~rPJzm;9a8*z0~SA`gXlr?=_k|+icha zs}2>n+JFhr)rVINc+~`Y8r@E}TW|M)S7xILFYR8Z11xIx+Kqm<(=1y`U<84hpURXe zzRP^4aRCJeqC@aoMt(g-P$H4mFVZVZCXSj;NzI+O5yh3ENE`BtjbN$q*}FP?m{)0? zCfp*bY_V6{qm1D@SGA$flY|q_IKwr}lm{@h=C~hHH3mDZPRyUdf5K`Kqp7TP@#dTx zHUKo>Ulabdj8Uz?wK>xuNS8h4#hdY-<$kiPq9*exOMK*SB^J`c^v(i&z zAnpEBK`Qpk*MTrRryo*1!Jf_&>+5JQ_htb9Gcj!Efr54xON~9Ko0!3aNEfYG(=2-o zj_25`8vf0dp}|lqR`8V zaht%53m0DsH8EbLXB~V#wJ@Fr#6nlcRat}Kqa#8tL^wglg5g%AxS}E#ii5*3PJaF3 zPahvkB6V={0u+Ei^T#Zk*a_5)S2|vKU|~jH90trx4D``apj2z=(vN!E9XT_=2hbB2 zKr9vY&byf3m3CG&_}&WkEEXqefoVT(Dd&fa?p)h9oN$?eKxPlNDyO$|+{CEdxC=@} zaOe5~#%oq^7w7isx^fbQzqNQe*G;k$dk-#16))aVTiyow^&1OB;)#l-Rr-W=^9CU* zLR-k;M_1k@6hE@UA6Y9a;Hu?b(;7U&R9ARVYrq6lT@^9IZ%Rm2gBDt=DJxB3>=o*- zo&V$&RjsYs&Xr7lD0GmwA_S)-XQRknlO6dvM_4u&(~#mFZ`)39Dcq&#_bW6UXiJT6 zHK&$n@utu?3FpkI(-Ps5G8~yjfNQm_9#I(5=xO0ZsgpDZ73+zHe{SBfB8;}9$eQh#u`4gS!_X#ZY|lAD{5E~*i`fr zm-lOmakW5!vAH72$}(~=Ym}t*q=o^H)BTM1_T&*d*D8nZy2)A~BN?}wsUm0XskH!p z|B|W5@ib{5S^a}{89or4Hdx4&Ee3Q$E+z}w3$IOP-rNTgcr%YLGlUz4H;KSaU$x<-GicF5p)Nicl z>N2$*^ZXACrVv0Nkp1G<^d%_v>^E`bv6OoW85p{zR|S*j4`n9~`BSj;c%bAkf!#39 zKDjfnYcUWTi-=tcgdf8Qr{j9+W0gVr7d-wwLAORP24)ayyIM!_qXDS4Il(eBd`qRihf+KlN#*^#4+<$Wjxbz)0Q5P@}{^!R!hb zO5?;?6oeS-YmkB6uA6w9l?zLq-{w~sF=r;^m=+p#DC(2d))V2Qi>^y9^?XDDe zzHYQ>UY_J+Dbqt?cBHk2!CXK}(;%Z~uL^5hQyC%g&Yew?1Q!xFSIn0wviK8F5v|tu#c0qf&rx7m`w|P{> z5!?SyOnvJ?A*HN_50AiclF(CMS zcBpZ;v8~Q?6{FL=Orwnp0T2M(uEj@T(StePXss~lzr)<#%tys!nIIn)=)KGa-|N?` zRZMwiU6NlfaFkxHw9bKP@3ma#Ype_{6FONrCB;h&e69QnBY!h&f)tGn+YdHsSkIrn zq9z1Po6n?OUsG-c5@*VQ+aNC?2bFuAxuPYgC}qo#dHF@@Q;x&`EOu?E?m(=ta@lCy z6F;iP9cDDe9Lrk;aH*A48{~=@e?Ie<7Jl4HMLTJ|35>N1Qx!{u-)V@hw}=(}{4y8357F)xboF+pfBe_d~Gv-Q=*1%=20R!`X z?FcWZ1%+l>5sA=MCXa;5R;GwOY2OPmxT-=0E?eabFCKoxDt!rK?{~KI)|+@2EBsa_ zUcj=Sx9x_RH~Lnjd-h5_kH_eB$MOxAd$54O$f(sH_GaNM1GI8Gj73fus_zjyBp_Sz z*vBlU;;;ZOT%cedUS--0#f1U)V!j#0FP6@!g>T$bVxWG= z13Dyhr%qjem$-rU>f`MVQ?pzLK_?ujudCXa_%(9p)uIuaeqN!|QID(2lg`1=Is6hQ zh`i22Lxf+t;#n96$1fYB@BG<0Cs)18APgh6Xdz90UN>ct^ZIC1vmSQ9ZXwu-=Lcn= zwg4T~#9KGf+jNt%He~^f)~z8Sd9A%54$mAa_#X^z_CdOCN6`ceTW5zTh#cOH3%LVt17quSdbhCs1McPJH+Y$ zui%K~4V#G)hM|Q)7FDW+<5BYVT!pK+XJ(9AF?(^Z-MYCA5`P{nVE)8478W?2R?lM- zItT`~WDA~2`_}DDNRkj{-&fpmD+h@fNC}~sKs`gs-@Rf7D_ks~S&fk}<1gOgEIg2< ziU?QMML@e;Nckupagh|N@7TgAMN&+(ka;}o0z_*~1Uz^c@Sx0|T4IR{?)Xg0;9T`; zwbZH({UHz2c38YDd6BoZSi$^b9kJGa<>*LV6~p#m{s|B4eEO zHt}HFe|!Wb^i4pDSnL&YO0(^#mXgZ(K%+a78}JK>)pBl#p3?H;*S*!wQ?hpfF? z8WeGEoA#(yqbLPfOb-91#9q+Wrc)wg04d6cpy(-j&n{eo?p~T|T>{+6O`oYB;RzgD za-%7cUJXaLr@)$kYe`mhdMiY@>%_wv=vmLH##>=+r}0=9Oyg*fg&QH8Kz5GIEuVdO zyOq?ye%!KU7M@pC@og8r3C}Zc2!_?Ry%d)_h|rt=M$xa5$1kyTbTdfNvI@I|vX!qq za=WAOyVtMrk1!H=CWxU*k-u$^IJcBH>^E*?07JI7^Tpz=Y%zQzi+RHum|#U68E1Sc!q`SYt5{i(gRrQjN9PL{&eaT z+oWmj+Nc73JaJ(@jKr_x@$r0w@pOC2&>W;gR_rM2Z6ladvNjSlmD$T%{65p|EpZWA zExj+%R9ogg{iJJ-6X&AfgfAC@bPpDaH!y6+mX{Hq8-FoIChp16Nna?=`{;J!^Z_&2 zeZZS%WJWD<=jD8z)0QX-a0SPn&=#yF#*C<+?67Nm56%Wtvf6T&Z+t{P+iQ^Ze7Tp|8AN^Z#t(}+I?!Em%CAl%Z83><^{{t9#q{?}ODslC8USy2? zH@l{8_B~4ddb_J@S&~k>qXYdXb1}6vtyTNd^Z1f=y(ysuj4|FB%6pBT@7`L~)vOAF z9ME0FAFa}VL%C1v9jheH%Adgv_&%=!tqSU}Cgdbl~XHssUvy0mq{8jCQ^MM;xs~taslelgfC| zOJHr2pUk=tSPzQ(7riA6-8v~HzO3%>-zJgX8c38$y9{yBmu=N$jqD1N*9KM+N!gks)6CL$9`(uGIft zHmNidBvC-2)(DoMRrVqi`geFk|LE|NcXQo$y09 z)dcSm)-ie&8jWgy4C+kOctK~PQB-X?qHxjiX0yNzR|;&GfFrAiOplt}aWJl&0h}OrQJ8TZVv{Jy%iXf`eWP zz>obdz;EiE(&C3=OcIP`%T~lnL<_lpEp}bA6QX@^`cwGf^wSXfo0lkfvuhL*z~?3Z z1#)SWc*GJ^jT2TTq&JOYZ4i~`RV1o-|4_FbUVm&R@G}e-P={OurH(yd%vcw@Ipc-} zI@rDQ zBopb+0UsO8UZky^nHV=;FW5b}7vN6pBEak+I`*8h-COe5PUo7%YmEIQ8`OmBDl6)L zHUA?}XDN57CB@btOh5&MpvqNi4st48CI4VaS0;g3;FE5DogXPhbKNhg3d}ClRn_xh z)BuKOmAtJ~toO9?Y%71MWb?M1xg^Ig=waFcI`acmkV?mu^43%CDP1~5hzvgh0aa3; zf&&}dmDa)UKHS;}1dRLckP#vF%oF765D>4v_yxxwF#H0vw!Q>j()A51?wMFc$2gp` zU&gMF4OoGp9dD=kw|D#(C{JJf3Hv4Cqity(kQXc7yAjb&j}-@pFiMqKtQ8H&Jozxa zy;)$ej?EnPI#{{Q>W3W~PfLTVPdqNoh__nklWvNmE`#pOQRmwYkq<+b!YBD!-VH~F z`HRnss6Qi+VjenI!Rm|Qu~LH-b5VEg>T63UKLJ`yF3Jnz59$k^L}H>h(v*cOotk>{ zB?B!aH@B;mH>Vy)0@J6Sk*17y?4D*#hb;_@&c<#~xs$yA6EF@mr4vQn8ZSl04uFd>+w46mUAlw~owt_C~gO_PJ~WA1RQ3sR{980^?<%&G&N2 zU^q?0WEPy$HkO+P&)!7$uW&Ktv|OjBqzj_33Nl-#2Ey~kzZc`*F8R0j4E4vtQyM;C z_7TRvVOW+AFv@&2eA&WumHqi*spPxgEh*qoOa3j4*ovH9c~r=3KP@_R8)e|t4L3@w zvwF<=Q)C4sacrL^V`@1pc={QZX@pRDvYl}(S>vQw<^wM^tmj#&S3sqM)wbw8D)5x^ zDqAR_jorKD^^i=D_`GF}$Y>?vPadj!Lki~WkTIT`?5U3RdaMp?%+7Uc7X~kM*gufm zi#m?+T2^PCwdi?!*C*jIviEwX!TLx@I*e)Lz?jJ+ObwfcrbbS8I78M1~N=hDae5H1i9CoAcZ^#Q^5?vY6d zlF_Y3n7z|M0rg_{S783TL3(+xm?7f^S(sr8RpQnGF#amAVHmOpXzaRjl`jEdV07ek zMLsk%LmRvFuM=Aqvj>sbq^o2|{+pMSZG~Tp!DY6_541EX%YziZPT7DJsg+}>nHy%& z(rjSpA)s%~dhm#}*U?T8CYAeRYqE>CrS0NltuT7J)*t?yXA)|$1RgKk-k|*95%4Sh zPsWI_-)P^sxhk4%6xvNx0vW_SGmf8l!}lEErcY$kI!!CqTUw228g}$kwoX(Obp^wn zd&VMsyM$AmYUP|oN-#(X+Lam~{@?O(Ks!QhMxRrVETf7iwWs{bF7$OWTqAU!NsKf7Z-?x)J<r_psX0K?dFx8f~xBf;Mabyv$(@f*&tHy+{mt7w{w8=Htnk)e@!hy1vGl)Oc`31Lgsb7cENU;6dn8_f5H8EJ+5P)gFHF5- zp7H=iyht zfBvA3=0u!`l+&KNr5%;?j!u1Cj#yt_H|w|T2@sMEluD!%6J2`$wX5g=kO?V=-p_SU zrng8)8Z>U`UmyZM-e<`ZDKg2q2g$p0Dq}|G9mFbR!5a6LG>`XUH_vV=S|-SaZei)% zhU@x|leGDe=RuCVHi{c1{(3a&mS$iA+DT%Ee`uB}BSJ5pY?+d%$CeDplyT5eI%8Gz z$r9VC!U(hO3%9I3D1THTQ@w4_b#|yfJB#0ILMB&fuj~w((od2kNjh>{V(WG6L1&_5 z%V-J7p=lAs@QJ=j1T0?*yB~4%?XSqYwFqGy%6({>*!zlE$C^-0e6r@1Yr?`Rf7W#) zLG%~3wSPb@L|*Nn`^4&<6KrnC&|72udgMNYf8g39h;a# z$=0^&+`K!ukgSu(OyJYY3guV^QK2$s*9_S`yqxCdk~GMJ9!MK# zDiDc`rYWQ}$Hlo%`TwM);ftQo_i;35hEQLfhAP$Mr8;YAtA7$Xjg+A$w8H7O!?@> zIiU)k@1IJP4yfwf9G}gCoPsauM?~_>LcW%Ye?+SYgY6eQhW5MyWXP00yX@~WwDJCM2D4yrtfgS7z21UsmcS1(6M_DR0c^5kfZK1R zIFa)8><)4Lly6CexKF^S(xs)`^P(;GZtf6hwyKp$0b zK#TAwm;r(7(EU*PoCr#TO=sKBe3g>`%c;n{0dBs zVPOHgIAAoOSc9V}0`pn{Xp{!d3)ii}0ox2P+&p*QJk|>*Ipm&Q9g2c8(I!l91KAm^ z*ueydBb4zt`{a0b*C4f2NjwvbTwF=cj&yd!nY6fOx}>ffBDtQIZuR!`#&_d|dI z9O&q%r$6Sq4m;Qu=vW1!whDCk2*!{Ss-+L)igMpB(*Z_k!eaXq6DROSw3KQi%+@~i z243nhbwdHBFy9aBm>q5}L&Tz_-{JVHaK^U=vYHA|4*Wj1FZCXJT3j(cfw^^+^Gl%` zX;D_&*ql5^>86|ZvF7Yli0&T_gQbQr#^;Ozd1;nqz}-3?awN$6;7>CQsRs6vj3a}f z^R^_ev<_c7bn5L!y;98+@bH^oUU1aOt?H-El5x}6$li)u#CDw_12^J97(y;ayt{-Z z8_tN=+<~2k=XixI$UIsR>OCK4D&fob25#pen`un+mz)o33v5GEg1nA?K1Va(yRl_Gk zNR39d#9iFo-Nn@-nTMG`y+qu;A;*qX6uBtT?r}E5k2Ds#r`8%FtoOmeYnA{*@T8Qp zfS8ncj}0aKlT~C-LT>J0^B7qmZOZ$U zZ8s3938beq_|Rpx+HWoz`!7Or0tcJvfCT33e*mQ*8fun;Xy3C)E$5&}0boh;EMR4} zWk;CA1%p}Xj3<*L4LaahQU{TdlKe49E;zv5hd5$1hPIYNP4*ROFW$#FK3A+zort() znl<-2s3~aV>1?*?kVW2Shra_)hD3$uA zNKA5@@suxE^dDpp@LB|=_IM98xdQ#s0Y=7=pL5TykH4+LeSJOroOX$M_VRUnoL_f9 zzkctJ#)sd~$;TCFeNDv8@AUI^a&mgZ+u5)0fB4t+<#zjT83BueD-BkdkAWmoDbx@x zG4r4g5(7su`l?GaCMt6P{3mMyI3~?9Hb^y!Xhp$pA<{Jr1I0XyIukhOD`!pRRIgUV z|I?ylLijpWXXG^bx~*wj(}K!i(){)lWcEvyC5#hNExE?j)=Ycb^i;3lRbCfyN-%`< zB7Q$5Js=zo)8r3t9gTOdG7r<}`cc+z05g;`@}%&>sG(SGhsX{#jY_clvCS1-&ol#l z@v&Qozm_opiwCk=%^VCe06|S?h6Pb+5@kr{1V#N5xOQDH$&2SG;+7=z5pD$Pn^lOy z;c);t2-3OLearZ|<-vAr2!O3~m#)(dFfBY~wK2)d1IY0cheI3zRRF432<$P%sy811 zd$=Az{u|gjb|V!8uM#girUASGN-ZKure;6QE8(Sd}WmCBLjVDS(bmw+NlFNdstQn|E4(T+!Jk>Se!C zsn-Rp2HU=AYnb*ia0R~N_W3Gankiw6helozY)=TFBRql^JcSXwP{J3+0O?Rbz<_5a zCJR_x-ZscOV7xV80ngl`Nu^_ZY31V&Wap0STJ+!Cw?w1Mpb-;eOee!FUt`)HqSO)% zRl^^*zAh@Qjub0rU(y81mx`(MJlufX25=v?0GS{$f6 z3kBJMYRB6u89=dk{&q|OuU4$a^xuQA&Y*{g?V>bummW>(nuUD9KM^Rt;JEa8`rZm( zXW6vRqxh91k8g_rZ=&KzLtlKpng&P_re^$w9g{tD`Z&Y?tQ1Px$iS-m}3AgL{+eGCa;s#dN0pyg7Ru z+0;_PV2;i0Xnu#~q62K15p0bySSk8kNx?>%DyPWH--9PKdxX-2)>>P+iUyn_l~|3& z3P_UDp%UDC)B~!9xsoG7nQq4JoUHHoffp);%c9?K7Q=fWmV?p0a!5!o%bEKX(f>|o zdwKc2Yn_EoX?d&R0S1Wl)h=?(*Q`6S828kGd1scZ0s_6sMAHTL?n*XnXz%UsBS%0j z#7^Y*VFtp;7=wTiYXSlnHc3w7@n&3BrWtlb*ruXsoQlx^h);s5Zx)I=W^08*NZ23X{zT;7k$u~btNMa36p6=XX#jA~>> z_Byak(i~aGZ_ru<1w*q|n>1ve7)HEy09;skwZ2PfCf3sw&XUSXmM9-bE6x`Imi-Je zCDV1Yl@`}ILI*W+8S%#JBq|itgfgJIoiHp7q57pFrEYr)?3N$ku>Rw!DpznzaUSdu zIIOmTyn^ZN8a7a=W2Bl?Yu}{_dyCZNn**L{{3P25KvRQRu#(<-C5EMFslmQTEN%+E zi=#$R!_%i4+vGs{Z6$4{LJMWVkR15wgpPAvI{8X@q|%Adp$}zj3*(t9?rJ!ET)p30oOF@nh>@lRq|K`Lf5#E|JFJu?TQD~Pzi zb;(jAYAYXhwDVV#tDo?An6R4U!e`yc)knFN=3{m-t#`9MT^`RwlVdydQy=Q=x&y&` zr(WnT|n!ZKj2m_S;7HP7!Wt zggMnGE?fFdcx`610=W8R^NDb;gO$f=u6?}xjGW5C@tU+I^*7=c^vMzP2*|2n!mffp#*gF2`=&m}wNFCrRGeUOL`07Qz&1s00(rz6_ zE5m5`c6PtUR`msCDyq33u+e8{3G>LR)8OtI%z(VeJQJ>|>^Y1mzmwJlE+nEISH2bFAh8w&WTkmY~LP0=u;_Hb%KhDeo*8GjX*5Ic6}Vztfc`_G zuYN$fo;&BnCSwMF9>(CY>Fa8r9)IX~PG7pUl!M4F$`P`2%`1Lz7jwyQJ4WC-1$VKo zT+OOse)nu(DYrt8yeQ5nmaW<%*(=Z{u_yvFQOFP!|2>FHYnuMUPT$#ftE=~nye0zous|MvPvr7kA){xtdPoHV2Sh6sH#kcyX?TlZjXP0|o@(+#bRTjb10e2^EWwu^<$)z9wj zP)!chu@AsuA<)*SVow#`MiO7T=xF0=Jlz$d#+}vpu2wjDPX}W?mt3f}FFx%j%<*1$ z-h!N1HFK3>YUaH@HQK89Or3nZ9FuLaos#pH7OIt|w-n*mbpLN0Qpj3${AB%G#<=~e z^iotbs_7y1`ZmL{==f$!D0G!~)iYTh8zqDH-yaDk8^j*3h*XO9D zg67^>_H$j;<5zPFgZw3H)FyFhxRL4;eU_Em%@X}8t;rZo?@!45FLi7@4&UHame{*Z zg^pq%@4B(bh+T()A`6eG3E!>LxWQL0Ti}HYpzGrgb`CoRyZ7MHu5yRF8#`lD*D#L_ zz~8L%fCvoy^1D~gSL6K9uTQo(h-KF3R_pcbgsV z$i$r8p8KN4k@qI$^F0^r4Szfz?}@y})&Zr@OXePyy6ehtaC;uJrP?9u277ChNhYOJ z65BD{)#kiZ7Q)t&d>)J9czi9zQkV&UwT66)$7L&&WhrbweIa!?ye%KbZaO z-fL4K062OC$B;!Cxj2bU9z%$u{qmGh6;Hkm_Hv?0aa>i^Zf@-{{glhFNCB9s{cEPJ z+{VUx6To?4UE&@ISKdU`Y9T>B)mU-YaCg(q=z27l3(Pw8(}FG;TFrzpFGQ$8`!Vtt zBU}8Q|Je!isI4}N6K_>^Ff|I|E@D~M3rJGp5qJLrh=~|58n27Um!H^);ZOykY7p&$ zMXO(US(#}upK3o{I{-9NSX`>VDd62AOmR|>x^#aK7Ro!kUjfKxT_F|7*NDFNoprxijkveJ~IZ8C(RS9_PutB zcinnaeeMy&4=$hItm4k)t-fyPDfKY5Ou&$MeT=8o`L7N8NPX)ylI;#0(9^5an7wTA z(bbC%Tj}_mqHT8>o5ir5EHXUv?!PwA?7_Dk^$(^^_s^Dd=#DKnl3QV?9h?Oy;!<4NW|2Y4^yyd!qZ(`dyp76FdY zWYw<-?GqGq7@5qzZKxiN5uOsQ`q_0YSIGNV??ea0-ojP`eyL`2^3>MW18(#Ebei9IvNqB1Gziar~qEGAHEGY*!IPda6S+yW|~py`O}%*s)q-{hxV8?s&FQ< zr#zXFRH3C;UiL{!OSG+8|6oRYrFL1)7E<}4Y$Nce->TX|6{6-F^s0P!<%YRml4`}p zqsib}n>L38MqB+Sw>o|lS45K2a281kz&Q)~#FtBQZbJ#S6W-i4AX` zKC+cJCf>lU6|uwXM|{_o-iiBo=>R~M*l#iRlK@nFy$kwpow4uE3Me5k9#FBAl8Pj` zOshjOs`2_XO(aZL^9lyh9D+3d`r^qW$qV{W&bP5zyr8`04BResi#gIg&zw zmienH@EE-FAH5WYiGKk6g7Ucl`)8obGNzwJ@wMfKB75Ec&Xo)!_wXRn+1FF7UjW}l zfh6G(_^+-SW^TKClwivAN>Cap#f$<|k6^NTZDbrZ39grJg?`Xas{nSj2S2esT!I7zQJVps2{$ z6QOOOEygr>w)Xn%V(py#syUol@=*Xr)3d*?Qw=Q5Wz6?=!+ajxIZ#5SS^Vv7k9jM> zQ`{h9CITwcY>_jY^W9c1^33R>fA;tHVe{6;3zPoosbU`gkC~mAIBo=FA{~&@0K^Rj zVlgNfn^g<`H%^g3h1zD3bU_KVFHX8KTEaV zI$|=AEaZ6Z#v_@JhWD02Zrm_T0yY_M29nta!HC2Og;p$JOrYTgR;c2$Hg^b%YbK#X z(DuC9DNb{i;bIjS2e^#+;(v=BPlGl_7(Z-DWJ@)+RopjksYmjHatl&rx#@StaO&1W z!f~e?cH-Cq>xvvSzyBU%Wa%Y0gfV43X#@I|^n4jy6dp-aw3ffiHiR@c9ne?ai=_Qq zO#n%yGDh4_(gJXZ(aowmY(6GX9P8DT>@pu?No#92Zb~S9WS&f#QdA5}r`*%7vzD=D z(k)~&SF_ezpB^b9{{4*+{t{x_Jm+CIL(G?EY(kJwatsp{S5+P(aAU-C zte~U^HBPd5G)F6=4aDbf4&vsS8*7^ltCZvNG{XX?rKS94--F}tP2<~uVFh29&t%dZ zG&9a{reXRr)E)mpR9C>zSB_y?k}*q3e!-wCI;8G>h!Uxj>r@A5Z{M&MSs>HO+74)D z5H#OLp%7C)?q8rNk+I3FQl-6E*s!VXK15fM>->hY2zx@m#z0$cfnO&!T#8y8;2~gg!l&tNKMC) ztR4qaNKMINCg-0#2MaQgVVS`x53J67hA1T6EqDt_4CTNy2ckH_W(eqoxkDf-M*P6h z83ukpMZx$&f+Yl^l3#J=cN+bW@C~}IIG!7Ygs`Zi1QEw8J(MVhA5#; z?+~Kxe8=IGr&0EUI!4J_N}MiGsxzyJ zXG(Ok&ncxSEwTk?h4wAz+rpC~OsqAv^a7u>1Qa{#@^T=yy^7s`4^TOKs#)3maZpS># zB^uJYv}L8v_MYI|t2$S=(Ukwtn(l`560{0hPn)pIT?cbJ&u-Rw_yG7P`BZE4kG$%Q z+kxUUpGBKi9u+3-6UJGhNY1z;@!csj8n8=}YdW2j^ocx3QdeLvrbTUi2pxTNDN*m6 zKivvvalnQfnaz@|Y$Ixf9q8yYN8I95`arTYQYj0?1igX>iXU-v{gGrKMlTI`7lFv_ zvnplHPe^c8bi}kD?Bsg9z4m^R{&X+~GWV3@KeBdy8+}Z^N8lZ|7aC{>Ll9dooFwGb zE=#X~aQ>upV!oQM%p#bSuA!zx_9lWR4h^_}8vci7S9>@>+`m`r4LLBCRt2lb4(uxv?sK+*!A`@GUynubCT+$JjvOKr|quRMB{?kN%Osf#Q0uE#K9& zvVuLwiP}5bV{pC}DMg*&&txDt|Gd9QhNmJnUe$PIZH%!H8KYV#R04IeEwMgkL{z7I z{4L46wh>z5Jl|6|Y56S)+%2d;uZ;k@wMGkBe*^^`BqjYfpVcDWORF8_$YJUF*CME^ zXg>`G>e=QMdyvmsh2`FEqmck&BpH-o(o`O!Z%O%LbNUlYRwC7@Xk-~bwH`rmd!F?V9U6G(!iGe^m1gLzU ziofA*$IR_2+PdjLO{8Ya#IdzJJUA?yJMLH7QxL)cfPO>9 zEBOf2=fhQ!A2G_wEltQRdl+_Rx0tn!MOYv;(w%(}Th>N(5dXRj3o!-s4B7ZjZ}1)p zary^s@?-4b&SINDKO=3x8LJMElCT<-htrCwTALcU>Q(nFCW%TJBOS4vLur7q?7iGr zyzPQIt|yp$1}wmDkhgu|ZCN2ZyA(_e65b*o6(&(@83HNWE>z&b&7<7@Tmbz;qQCDr zUVUc94z;L64vZQyLZm`*(IF1Fk-6G22Y#hNpiL@@Q87?t;H3~j-16E41oo8DTDB!7 z1S@J=eGhF|pc9GiO=#Xa6~lM~K;}?c3M*`_+6;o>CAP)kk)p9iKgVbgVrqL+P@T!X z1heaRVJbXSMn*Fx^1_sbrp&U0myPAAa5S|N)q~=xZA>-7Z}E~E7(0ThqaykUg+=#H zH>tspcs61#jGBsbiLoP2B!m?mi#D*@U=x!sy@ahsqZ0$D!W2aKk`&;WPN*&S=Z63S z(Xl@Qh*XR(D25-T|JpG}T0X2EROW{&f?fw>Sl5 z(hB(C^4*HD7}(a3KpW_O#=}}xsT{jt)g};F#PYdvUx|@(Tg-_hoLU3gs)8a%i{^Lc zASs1w>3Ob+qGOD?q1Ep< za?yxS)3c!@V{dO-s>;Z&9)>W3F5Ore6vL%Lx;UqK`GO{$z)%M?n1gJImMQ6{q<2QZ z^+j1G!?1?FM8jcxE0Zy=@l=4NP78i2hJJ@XdPsTa>=FAl;;&3{DgyKYij51 z2<)Urf1tGU2)p5ITb*Fbwerp}bkQ}4Kk+Q-scs6-;l$BtFY-5M zycF~fZn>|FX{bU{53PcCWUZ(pG%1I7RxJ=?RPe7-r06~SD)pNGdt%+Dws!ji(H(}T z{6o47?G(X(odU{&PjSbb3@1}7en(TJKRS7FuiPclF+scGy<7@&gNPf}= zW$yfGH}>fH`cU zfY9Rl=H8mXxh>sj5v|U{SwkmQt(+3Zk~Xq3p$LV^o_6t%bzF4%Q*T+H$L{BW|9i9e zjmMw0=KKc@|IF_z5Ukm@_qHWyeElXc|3s1@6Ez;n60RVRCc8vK&wZdu;+oYvhp-fL z5CWemI00quh$NEv1sOIbg6!Co7;||AlkXx)&;&rKnXuTLUN>i{A>7KGly#x?u6lW+ zZn?%oD}l*HpX|w_eDO`@B4>#Qa5dtvmbyiG6c#=BUaj~PUutbbV`s!s`Ko!klGbP; z_?@9Q=R8qV{fO7}?H>nDS)6ID3MSH15vE9Np)2P#A@cmP6h`MvsdX<1l0GW73SE5M z*%B;BX^IlM-^s>$#TkJJT(j629ODj>YJeW61lVpqM2{UjU6tG*!s(EU6xU5FM7p$0_NIh@=1_v<6N2 zpVMQ1!aYpJAZCI~dG_sMv=*{tjU^f*R>A@6mAxp?z83czjpf4LHOP61syw8(y%E7r zmC|rR*tVwWB$7y6WXO}eq~*%k9aiz9(;Svhx%a)V5P zzIhJc8H}|bJy%ihELU}o>s3Ke-!?7Cyc@)dZieXHXfETvELbGnk*cOcj#|9maWdlK zuSnnCPvj453q-sU9x!+&=^FCkE6D874O7Oz<`zQ2*o23gj=uD7T~2H2Bal ziPUUCjx=ZJ#E6ktdxQuMeY$RH_qTHJ-4)fqx9ft}km4R*>{yx?{bbiGe}id$^%>*E zqj{)BA*q&;--~Y0`lUgQShANNIh2A0TkBYKySWu41K@$ z9lz*4-NgbddLEunA5fAOMjD#zOi>Q319UZwvVMf7?l?_n=&`(XUb(Ap*{s8aW~F8a z28O?MFdy+Jc4r5aSpNW0OJ^6$vXJp^F2}=ev`#`X!#kzklH=~9J`E=(q-11@FCJ^S za4+q`(*!KoK4myUvi7^{k%o4cA`)$^5L=!%fg*eCpya@a2t7#B_JS;zo*M42`qa$k zEM@Z;}zK=)!H;NL7K$3B0mT`a(0 zyc*)vzcNQIHGa?c5wv)Hk_geMMvlSKZ`7xhfwiGucRAsD-6<+qBW#1w#Ccrz&jzDl zsTCxuIqKBhrjm0Ms^(2y52i<^T1aIev0*BF^`=F$W!T%Xuovj81aL6@RuLn3^#-CB zG-=JJT2ZDPm%hXZ_zcrFLc8@Dgn{6pm6;k|VjSpx{ zgptq%b4oQZoK&PD*H*^mMb^Kl$yKMCXpP5rpVg!e2w|<|k=&AIH`binA}@`BnhpW) z#kJ<#{&y^r=~aF9H(&~ZtQ^j(czks|pDh~*)%4n%tHSOFuMz^%lvbgq7VXmv^mT_= zBk7xVv5h;8(p0xCfAZUDIYqCH+szjF1ze8}tWj6(vC#HA*xZkJTdYb7H8^0e z)`<911dawe1^KnlYIRZ$_}WnxsUvd!}sTR z)qhW5re&tLlW^l<{F1TsiwKO?%OtVCA8SO0e8q(Gh{;y6-XO`4fz8|j9Sa+w~YpJiAQ(Zyw+g4J-TCmlG)~qTX-(NBd zzZ+KqJ7u-OFDGlY!adpfjc|?Up{cCn^;(hVs?va`eiMg;qxqXaL)-?Q`j_5J5Y z|CK>`PJi@{cXDa^mv?!!kA{&JGe(GVL-LaEB_pBY26Ikt(i&YulmYBPIF{iDj_dd! zIdxB@XYBn2M^rf1C|57n%e~m6JDeJPe{aZ}(HfJ3f(1GA^9QM=eM(m0J`Z>|sHdRV zJujoWDSvg8^_a2dy#C5D+%=?Xc;~8tp2e$ybk0}Rj{$qF?jfKH^jXQ*jQ6{HfL^+a!It#0}5)8bQ*!5_KJQ^92b$T zSUeY3JU(GRMu?kGmW}Ao8MfcT|Kgp|Ji+D9zU6MAB53D6gJHne@iz^sHH+(2Mm?Tq zBAOPnhpQJ;sr*W?^Hm65av#Jk?Bba&+U&aQ1ovC~;oibpgjrzkOduyz%qe^KRTNr8 zJ$h*V{o?iRe%R!|a>S3LMueDyKQ5%7L*!du&NNH-_a^;WLsp%OyFA3A*|;Ws`j3Sr3d~th*c147CQ?R4#t;mjH@aWgn$*qrJnh+S zS5f<|O25R;Xcp=rm>%R;xvQel)9nmxh?O04+R5^)KpjdmAS{AzBP4OocN|!Bbb8E2 z$Nm$Rlo;$cE8Pj(hdhCV()A7Q(-U_6o7ZsB($`XJodN>*(ezw^!@|z|yZa+o#{L98 zJRSi@*=Y=PK&fpD;*T8aGsFE$pP3_VhEBhh-*hMksQBA)txV*AFUvFgvur*S1~^={UXeY9#1P4|;=? ziV4MFfgvy!9>j-)gOFi8S;YKy?n{i!3#Pz=esCAot%pH7wsx>_9`?hp6UwM<+3j}< zzKoT)itmKODjtaMi&XUIzGE#|*7r^RMPT~QlJ#OmDk3`n!eZ&>H-5P0`*UB>YqWZ? zE52!`|Iq`8RP-z4LjC#>!~J=wyq=pcYZ4Gp*N^<;IQddLhrAAA*y;ba+x&&TDWmph zu>$FjxMZv?ruz+#0PZ)zPs}qZO?_u(PxAT|OSk!;<{LU&x zilvU8nLoVrJE)udQ_?jp!)pWb=TVmNyBu18N3CU{k9r@>zrfI2G6Z5)aZeG=ZN6K= zeYyvQ0!?6!QL_EF6O53}2gOhdj>=STHP+F&fxy%dtw$*qvxFBM9q-X@Nf6_c+H;(h z{fo=j%nTgvSn`74xNH3{$FgTvB>5R#@!DEz$vJ9sr_$=^mcmC&91#9HaCJ8?=_q7l z>Pse*S;m+LbQ`xFQV8`l1|9f!4Vx|M?`k&8gF&Y1Imm|N)V?V8naq;C;H{u#p??NT z$=s4ZlT?GC0Z*xKYlhpG$+PenyBV?U>CX$8Gh?Ng=3zCWUcmzb($FU}PkXHE>1H46 z;kVJ5 zzte)`Oc>Mr&2}JOHh^Y!*Wl9^As#^EuNi!7uqsfOaZa7zAweg_FlC`^5QuTKn3ar$ z;JD8w+s4TCwK#sdbEMI+4#sjLpTJ75`0d&KcsZNWohh0U?|bcbM8G#7dSv9#-9h0`su8nPXoH?2-zP<;3=PnWsN^(?bWb?)E>NBT zVNOp$AQv3C)!o-&@_eEG3NX&^sOBY&^!Hku3y$!6=6|xXD#GuJ;lHPVm~A3!;Pdkd zbS<&}>Gs$l=vn}fNp9?)_xmw!8J-zjyCmf(%ha@R{a! z46gskx~xC$zzIXN{3j}mjJjKY2E%2t7f<@&6VShFH=woQ_czibRN2c3-zWOb4e|aw zs@GtCCuWShYCttw{ZEHdEQZ+S{GzmJ8|C*#0c5<{i>;H=FLI`!pbsK-Ic&-K8zuJl z-q~u8r9Bs3%ZnuZtfzCjvJ8`evYm4=Sg?2CDRJ*%?V_e|372DWO@IrxH)Z zR58&gr7ITZ(M~XIO@HlNTP?G~RHFW=(Tq|&)ixDaSlMCgYnjoNw4juWSt=?URPVb% zIfySL!IYb6PWUm`XL_V5%h2P>jqPAZ>8VZ<%xY!NnsNLzy|@x5`(!gWiA{ik2hm>% z-R_OT+Lg0)AX_tZ#-P002NIACWGu1s*{rJ;sX_cBUPZXqt;y*rP>>5{#-VPoJ%{X% zR#g?sUYU&cP=!4lR!q`qvN5(o`xypFp!A*{|DKhISy)$(jg?`hg%?W(Ncf-~E?5`@ zHLLjjHkNP(^C1`&YFxUc;WG>~gR0yz-XO^r? zoZqB^sz#!Rh;DzSi|xVq;x@HBwf#?Zm04qBZ=S+2Vrh|FF#GN(@^|2f96V{(&uHhm zMxi1;kV4ReS)o0(HshA$8%>X7!Uf(6iZiZelv1)v zsQK~so;_=^h*I>i+18si*3g6Zq43j(um^K%j~py<#b*KzLg>RhxY)z$NVJiP3Xh0= z7Y@2&@;s_SW~txYkceC^&+I>KV|#nD2e`zP(-&)RBxg{RT@H&iy<>p5wvIsyRG4P$ zx1hM>aw@+Bf{BPwMm0?LNyxiDVe>s4CHcKiRu?<-DB>%&-V+z}KLAxgs=tuBLLDxj zh+Y6byj@)$z7SU(!lt3r_>?Ih6D4nL=1h7T4|%BiqgF%UA?&PEA>LbB?6+HQK~1=q z-`&~V+SxhW-amx@)G_onC%*3=Z13kb^SQmly&duK;83f3-)@WVJBPWQ{N{fCVE15q zOZ;cn-+}fI^LzW72m6QHyIauumR483-4)*t_YZb94|fjtwzqc0=e*f|UVPs@ILvJx z?j0WFwzfrq{lk6zeNTMf-rdb_9vIVrALMopwzjk-=_aK+s$?b0C^9Sbl9071!Oiz5<%kOXP z=8Wm(5Po}`yF2?^+XveR`K|q(oH_m+0`OpSJ9m)J?dEp3^E-Qaa{@Vn;AU>?a9gy# zpWEI$*tS*(LAaUE?~38)ck+8XqM5@zqX5EibAMlSy}P})f4FV_Vy0)`K`RUhB*M@)@J^2KexBLeXx@k6Uf;;9Ab&>!-M?6 zwwUJL?*5)AVRW*+g(bwuw-0k$`&$RwI|oJ=+d2HaB}TTJ7n2k~J~TgX)90Q2o$c-Y zz5V^I{GnKEqreUo$Q|tMi6!1S$ZsF+@9m_BE3e9N8BZ*k$SG-N!(1V8rBYHz6}M<8 zGSpF^O1s7`?SwgR6ZVG>MlG4v<#&T#nL%Xnf}ll0!SB2=f@^4OEdrj7hOvZ>sLZ9` z@utHyw1mhQyEQ8D?w|kq7n)R5B6(mmEQ8A!ay6RJi|d*6%+1Hmkv{}8^V-|@S?U=W z1Nr;Eqd$xrk!9=J3Iej9AaEN%#WsLcZ2&#`s?V%Bij8>UK5Kx;o%|Dv{GQMlP|Xxo zGGHBFW8Ivg))q9d>QIQ1`rAb+opjx-Im}qPR4dIS7O?X}_WX0}j&M6U+?Z9pYjzK( z)=>ukMenszwl0^!XkP8tm-kxD2Ir)yXoKf3s?O%iSCw8c?PG@Ree{TTF2bb+q9k58 zj<@v!X#4?Pjv}~*NkecAX0a zoQf|rR_d7a_3DD2)YfFWwUp*O($1u|H)lJwMqw1yMnNaAHkGJlelletG?#S5@x zjSk#ei=;Em2%H?x)GSIeJU%jcEyP_Fq6RBwN{SW3!vR`Wt%cCma}fEN=SD!e3rVd_?Fa}oeK9RR(|BqGJ+PN1 zRE)gW{{8PIn~(4mc3ynFqESmyXiZ8OuNB!#*en4T20+9``xqFPCj7suk66|>17l>C zi6C~X#!}M^YTgybMrav1-E=SOn{Z)(U?}!=c2NdYiirl{`Mb`B&0l1q zrT@~@GI~4<^sI@&gPuiIjB8e{u37=yB$6C|N)Pd=qBb{P?@KHAnwXeeIKn?5Cc)rb zz(de;NIj;83bz|@LmNihv3y1;;^({6;bvk4Blv2~~X3xKgGvS^uEbET@ zz4!#vv|@9J;`drxUzeZV5-}9To0E}!ek$};66{%B$qH+)OS@>bfjJmonSar0fbzZeW7BA!oP3rVR0%Rkd)r|iG}#f`3QuD{E6He`42WD0I2+sH3wr%SWk zE2+|$?wTbD&0FdO!7`x)_KJWU^r1_$`x*b&4hbZnQ%qn5(NC zTU3FJm2;Jq774M-&e2v{&9ADioPXyC=Q`(B)Wu`W*+B^=AnyW*ka$heBQHvCQL7b*d(~>yO=gcqEuLXv2mM zC>X}0Mr&*<-w{+K%B;P6w^%U_Yj)XywANZd99ItGlEu`+;jqyP#xv~?YUIBX*rD&x zx`PX{F@q|eyJ${d-A2GiG-E0i!RUzcSHMJ|V)uzc%>&M`b9FKdfP2kTl zMuc9LVIWV9Ufj=RvExy^G)ZE38)_RQFN6yUS$-P@!T?V4ajPr%ExpEsl}%k7y;1#@qmQ0i9bn6pu%-6nFAY%hl5 z=|f3KE!u-=S-Y8(Ie>al;7*+7Fjr(PMLF;d?&M2KP;zNoy`c4=78bS_6bIjuc>a02 zUc1?|t0ED=%Jp#~d;K3aDlc{|`{~e3x#wd6P{1kdyPyIUUkw&>5tsO+rKMj7wGp;% zC14ez2TrgSQ?^rUVuMY3ZMsYo>!w|~^Q|YyrVCR^{W|1&rlpeg;OBhyX);KKbNY#zI+a#0jC^dsLcn=w^ylGUa!Jj_o(GU7C0`fIpmyJOu-QklfezArGjD3s&8i!xw z6HRTHtA^=wMTy~e6dckeIuz$D02n9sqKW=TGy|`=z3m5NQo5NLF(Bs0x{;CYPfG}_ z){Hh#Ok|dkr8M9<1rrB+Cx?=V+D27~)PM`pkVi%9hU7YpLK2OGD6<7_&wR%Z^(0<$ zU0DNlpORe@BVuvMoR#JMqa=;34gJ!v*2J%MA@RZ}i?V`E3VLJXI|T*W6b_u4|NU>J z`lqM^qmCt*SXGTLviKkGI9Nh2kfA*V2!i!T!wdkX9Gmc!GFqT%&CuK@boFUCAfYax zE%{`BlTzD$h?fa_ZCNHshGIHjeFGE=CLxE}&@>E5Miv-%8{=3DCX#2K8xdNhg*Zgk zD1o0SEneWrIHu@moENrn+fH7GUP^`;lC@MBSpWCby67$`Cqzr+pcMy?yBP4 zG1@-2wv?L0>~vt5CuZ8A`>JUq$FQ=Lx?rwqtC{Y_b0-(?RMviVSMv9~?yT>tcDW3Y z>2r|iy2zZMA1pgdBXPl<^plU%1jAqbkGMi6(I|w?TJ5H{`bVnR&K%1M;WY->?Yk~b z&!>f6-m=hAukkp0&=?4U1=k$L+@I6OVQWIaiE|M{Ux{>BZt?av2-Z7?JWGBQt<(v* zaN9>I`)I>KOfKB9&*b5~SiX4GW}UwlbRV1ob8`~(+8%09&+&@^YAID>HghVoChvu0 z@}I`#C1mGbW88y$Rn~P2QOZRVRL~4|p*N-n+&sO8_P3DA40#N38#XHmyds=?BnfMl zQLueJ2RHV^NyG;^GzW@Jb>z!fCDX;-(tfPXovd0T4#$NyQf~6Z)`0e(T9AM@E>%*M z1s?f>+Q4SYEDH2TY?&-Q!TVG;?0fY`=qw>dN|?b)`jreamiAuXqGi0bN=yIIwA-=d zrD)~_U`bzd^Wv}c3(pL1b7L4w3<|cM9UPq{zke5w1jTxvd3!(X41qo~5HSWH-A1i^ zBVcfV=)Tuo#$}0WX%^I+OF3ZepB=A(+l4i$w!SZ^RzfE1OK2lYtC$ z@CmqHPHeB^k@+E=Dp*DEl3L?=K6NmrH@EkN^Gfz(OsE=0ji428udm*wPep$RF9!9n z(j?M*TsVVR4`xifvW=uOEy$M1>$-nm91B064V@Pd4}9Y@Iyd)vcoF#9ai$$+8UxP# zf}CS>GPZQ8;F@e+xSe?pdOf@|U3SK5=x{P#OCN9wcW7|hYm(zyz+flj#*NI*)>b^k z_=71Y$V30qzK~h-0-KGo>N*jILra($0m^{$rmU73H=+jsZ!nf_=kOVWIAT105*y3~ zvPZXRq4wPR3JhYD|Myj`SbGn>qrW<0p;)g*FYJiH`F*(jJ^W`(fYS9~Skci$x86Q0-{3 zHP+l{GSFA;#g`UDqq|}y`C?P5u(aK>zZ3*Aq1mj%PCrv0fT%bht@br?7j+7&cWE6#nWtB_uMUOB4wtC z_2F=Hmib2po#UxR@%(pOsLh$N>*)pXjdAl)Kz!MGVwl>C6;y^7yVRkS|Xb(9xZB@rJO{wN_-qVR^uNEkE7o_ngX3 zakmzqzo^e7PZf_9qZZ@pVMCK_=~rx}a>5fpQ5CZBp-wC=!OC^uPS)O%F0V`uyBXQV zDz_c~$^5^~)8l~E?a7;PsjIDRM`*`?qG z_W{u|s~V`6ck$6JNm~+FdetSN0G1MVrBDE?`Tv~e`FnGm6e)}6Pu4r5coo@x=lHJZ z-^E_TVP2CBn;(?!dN}B8?|zr+`WGvVe@31L*!Zd|!KhDXz>~(#128=+iu7M;6v-f1 z{L$8yy-F)BwjHCzsa(g^^eAn!R$LP_w@Is3x<1G%0x|Z9j$W@2eC6DFsgp`J(pxZ% zo*aMghX>9Z=@ny#8mYsNH>FB1m;`*5^H2@Hekxbi=3i|x2Em9=XHIiQjr1uQ1%S(n zb@0k*{dMeRKN>svll7l>enWKYyJ4?K0kQuFYC;#y@t5dCL(>YMt|3iuwJ{QvRL4<) zwYN_}6f}GO`-CJ-1+?N}9$&bm;bgw{|5XhBfMO60RID>wduMgDvT_hcAeCmZHhzM7 z>wndZKdxr{lhlLlVemdLLwBf?jeLik*84#Ai8`T&*LE z^RoM5u4|E^L^rXtw=}lM(y?lmXi<-5GfVsYYv_1?ncD3yri=PtHPm;hp?MFhzJ7*50M`6cf49!q=1IX0L42DxC&mgAJs2 zw!l}q3}WqF`Z(~46S0O-(s70=&gE)-dC7#@ZX8Me-kOlk4k?xgBjDZ}>xD0@B1QuU zrTDqe8-sechKzw>^VT?#V_})tPM|p&K_374O~&2fm&PF)P?)=-8j+P)V!KW+s2g8V z^Be5d$joC$uPMULP5+2>1d|Kd3n9r`$~VE3r+zw{^c`FB5lH2lA5vWX#q4fIjp5qr zTU%F}i>kD>)pjxXdQ3!&w>HuaG1@tHxr+SYjJ3Kj?^kEW;=Ka+P*Ve zQ_$yC*9$32H>L|pC#eI_wi-l_5`ohrvdM)Y^l1f*A{3^E1WewO5Yu(aHZ1RTn0*jzh{fOB5g2 zJ*tRlEbsNeV6|o+GWT$$hp{B^%1WAv^#Z%z6ccV*^`^;Wn>21t-U2!jF_(KYNKvMx z6-59bYU*;w5O{*y4 zB(FW&l#N`4Yt#lL;cKS6mQ+jQtily}5tcEn7;Q#u+rT;Q+2ZjFN}1*rMvU3!ShB&n&(zsKe#ViaZmWY(W0z_*78;S*@Cr`K>%`ZuV>z( z5?SudB_o0!aUekWad-`Zn1n;(^;PJqk;Ja>wy@`+Fap*EF3;AM8w2E1)9eF)NcY)tF_f4E# zT)@ex^xgozU|=54F;nz^F>T~)!(@(;7<>_^Hir@y&#_1f<+KD_S$NTU;o_?+<+Lm> zZydKd7-LLrzvp9`_k|S=E)43Q`i&<)IWhGKJK2=EhwvehLVD5&v)MTF z_}=VC^^(p;82XV^A#F8Gm~+Gv=y;eP%)*KdP83#*{r7=eLHcI^c|Lqs0WI@!3kV$8 z4FsJwC};%J9r!IjiW;L?X07cH{Q;)O64l+y`a6?dhPu4J^mJ9r9ngBpdke4!0bhfx z`Loo+Uy$VV*2cOa)R*Ivr0OYKuVwBXZbe>}js?l@0CLNNc~EfKV)BuoX|(k+GtuK3 zG1c)+Yur&0-={J1q_D#yracXD@KbD`u8ci6!0+0kNfe5S0kN57NFqw%3Muig;0?!Q z`_~}G4a>_!03|v3oyqmvRFKy&A+pL5ZzLzWjDu8@Ow6%0XLieBkX&S(m}^f)uCn^} zy~|83{G@eGk_x?(7f=hu2mNmBe~^v-DUC7kLWosLP};ByLMD9q>4Vkg%x+U~6Z6`f zZP*2kHWU1qq#2!F*c2@Mib^)ndLU5Z+VNNV6QNe{CLHzJ%RGzH)q?WkU~2rINey4R zjxS2p@1<+_s4Qx4-|2+wUvh#qgjzvaGj@z7OvG8b0Ls`zkF5Z)I?)O3VL+W1XF}s9c+TTK{q|VTV0yqumvuK z(=+wS)c+T(14jo@jYR{HEt+Fc@2tTnYS9*8i=|FQP0%|DZ8>zYwz6%q=#W4;Et^xK zA+wSUZf8&>Wiluz9e>F;pE1HwcFQ%@-`{^%-DnD6v?lu2h1ZR;+01t4-^%=C_hk?G z3mOkbfS7A$)9>Vo4d7b0TcE0$zh~A>xWa!1q^xnSGdMD4!uIr5|B=$F2DR1dZ}C>+ z8k7X&wHtzgaq4P~|F;6*N+{R#$Im`Gzv%0K`PCZPa5I8$GqwP}ET`@R{Pa#?hp3lc z4jN=+!CS117D4?AOp&h33R#Pku}=OE3*k(BFq#zb{i+<1(m(T}L02>d*_|%;+iy#H zR0Cd5>CgIT^rj)3Q8Qj&H+xe1Jl4|OE@I6u9LbWtleBCz>Ol;Q2Fr%3x*E0#x!NC% zO=ROYYmgWrNzYMH(el@9{DHDm;N3=MYXg%iB*^b-*gxq#6xwYI`}r02B3LV+rl|*w zIZQrr^w~ps9_Z+?a6KHw^DG zW!4+?lZN(gbL2mP!j$J@%|I)Z)5acS1`<>Guv)wwd*!3sMj}ei43s-c7EBGq+rT@> z%y7J9M4stgWex1NC;IYRM|?6WBpDj2HVy`}-Ti>P2l%{h5hpOZ*RZKcjQcC2K$A{ z;J+iNnfAITB+qKthK?e13YUFF0o?m}H#-vCWH{2>6LgV~r}W9%Zi4h})u#F&c&~#gbV+ zFsHC8|2xmhYLMBUJ!(9wJ1~2*&9`ZK>^aM; zcK9Y`!%z5rtM4Y)qe6F}4n$~4juHH06LiwZk4@D?Q>#~sU$c}LSz=V<)!UA_380=T z>2pV{e0|UuM%{2s-X&=8!SdmqAh->_csw%Hie{>OQ=i1aQ<0MCl7x^Pk-C zQ(%$rth@q;T{qQLFx|$W-Sfen#qEOHBOcAhr+YdHU4Dn=CoZK|qQKwF$8_V^-mBy>qNj3Y7n z)R&vG5k6b3@qq`EpjvIn=^_pwIAvsUaoh+NIYYNUOvTDmK6T(5MuKP1ZLn&VQKBG< z9YKLrVss5BBZcPkCy-Q;>lTJ#G(I1NV5*937|YX)3CeQFi(lUX{Qr6#^j9CcF-$Y+ z=O;9kpa$@td})%>d0QsQUZmYlmo~HoCV%iQ@`FKZ6riFIkWiAGmM97Sn*)p>rnpoz zG!3bBU}UY8OCv_83Q}FETT{SmL9Bc~9QiRy7a^(3G|1fv;~Usk5JZM2?p)&ccT)ql z@thm! zp4%gZLb3E45`?B}A2*>sq0+-%1$?DTkQA0CRO&KHM-j_5C|@r~+hD6bjD^QZsLwhy zKNhAItG^!m@m5g{2AoVYn}9y^BZ%;A`CkmOeVaW`z+nk|SJ zBBhna5nMgZyw17s&RT0QO3@E7SNx$4;eYZ)9;_Bq%g8r_*}|RvB;?0=pV%`dAARf-+U^JRQvq{a{yvCqBoHf*}NRP3_uWOr8Z>8GsL>Ld<+fWA2aoUjZSQOga1<8 z3e&t$t@0^8iwm9LmnjNF2ODwPvPf=@D@qbHc%g~}3F;hD4;)SgFH%jV_y4ggTo;`u zd=wmwbR3x3^9QTcRTwX$?s)xE4~HK<2~51YLw3TO1`%ANrqGLlvO)9S$f)~pKderN zRTeUFGB2gcuOd71s7jInTIG^nQ&jnGaJ+_Bi-+~CNQf4ZqSq6n?`AZ`yMg)~0!7em4do zU9V)L^KwV2sxceyg8q^WKI}JYXa#{ntP2SeRKpfW<7ZY7yErbP=Q9zZlF-ky(X|954Pp@=5y9M|LIIe&)$z1penLOC z_mr0l(lyCq!%;Z&M`O|6mqoDq`c60Yhe^V0DEwJt61~nDQH)WK?^yDFT#LhUk>iD` zWKVV8{==-DemzK zT@byGbcKYV^+dCYoQ#yCHBmN}z0sggv!Nf}%^^c9?qG_(xceAqb6a11kv_yGyM|5t zgJe6*#ZPbk{(B}xOa1eSY4No)V9FCGy032ss6_%AYkE)?O!R943}mJdrDexfS^1Jn zreZXwhz8G{RJjb?qtJ&AazFb%Xy3u&nh3SZ^!z7ZnYAEQLJ(!1ai8EDns%d?K~D;B zH4X;sxd@+4kKp*mNloiyc`5#(v3=>4^grz?_q1^^v9&gE4B&B3sbx8>j0IXt+&OEp z!l^P*!U~$^1ebnPWdCNK3*cKmGr~b*;<+Zdxy?*TM)|7T2`V~|#CAp#XiZn#-prKm zlBQ%I#Lx&5lwfL8aL5~E8sLHn&B)WIT#Pn#Q#+d(P*cREfOy;QFh>acD&vS`bL5yQ zzRLUL*((sWS+XC{f@%OUXS!71lcK#a<5L48cHOM9f??hwjMg-hN`nPJSu6pjX^Ew? zf0~NeOjc{%7GWg=wyecw6)yL|;?fhErM^FIv}3m?EHOCB&Sce;@=H4X@f#>W*sLxX zxUnA`b7b6PdoNq)? z&>3XF^BovWx@{O~;1HOYQGn^Dn~?qoVr`Hm#F8>BLc+^zH-!z7#Wty}a+?@J17Xw` z!}!31d=})t7lq2Dh7$>6d^m|8;4y@;5~f!RQhEuZwDF;vQCk1HXwp~a3)ha*%(<9h zHaEvO5?{SkY8>Aksj4gj%@6DpiF#H;y7npOg~kdY0^Xb~vW&RM%LYT*Z9${LV= z#8m2Os{dG>q~3qwVgTbecRl7sIQ_b%;Y1OuU9%XAi_|wQ+8^e{Q%d`XU3yuDd|+7R zy>I}nbk;O26miu+#MpRV5sRqS`dc^(I)RXT>*HB3ksmOEmsW9g*9pfiy*8w1arjP} zn3A}4B`yEDESBbW!<%p}uvUuhA=-ZCKVzTElk?@#K1Z+k?Tn)1jCcZjbC}@lorvf)=Y{rm+bIz-nbqX@6xX z>mmud*#TVd(WZw;wKxHObnX9k4yl<#ajt`Rf{d++;`$~YU}I2 z|82nE{-)SAoc3^rN?a8mDb`=mE>1nDgpaO zvTTm+d&e;V_bukNeEVM0Qw^+n^G&vFEUZbzX&P#=*0^c2NK@>DhY$9UPJ@9@SEIac zT+zaTVfF^Q!h*3zs}8mb2~B_1h;zSU#OGme)(Hpy14fFl{UyWQ{+Yv_qb5p5TBd4@ zOg=v?ZYAwFdv#ceq`+2ei6L&9$BcCXN-zd(TlGKSv+IK`g`_BPfxo1tb^bv(bi0j+ z4lnZbNz<*Ex2;gAH0cNO3D5~3*V;-4X%0_~!{$q@5C*(j59|qXG=L)@_AYJI#z`4J z9_Pt!|CMxhlJJ%5VRH;?i57JYd2Hyj!cr>;Xf-EIu{!eV9b{gE0j5`j%MY0+6X$9| zL!8pt!b}eqR!C@v15Z1Ar3nnF1=r%!+fZYetBp{x?nv$on(@8XF#QmD}!+_QefmAFX~AEYIZ2I?NPS0(JJL_5HQBbs0<(l;;W zTa0cQg7ubS*8*@QiFX1(rkWt36A_$lzcCP)^rPTHy(fX^!wO)01qf;UuY#iG|DmS% zUjJMX%%=F74(ZtGmjoyLXJztE0YTcTsZ78tWQ#DYyz(Y4wIywv_YVXc(beH(FI>fd zC=)POR!Zz_)>66))1oMQGF^h=vDRex6~ZLn-?c(NXHg7$ zp0&>3vtZx5WUpK_bq7Z5#*g%CxAinr5^OJBX&FBQq0&uKn~^J&U1+}l^#T>FHSsus zQ(7*2=5j8IUJ%t%(}q_HGG=gdtlV1SB&Gk%ncCU65~!^n?H82kgj-4JW1i#mM$8S( z(5k-sutJ}6Ym*Xv{(vmnx(Mr%g)JOfTs95slG93kSdEw%J`jRu1qz-f(c)E#$o$T~ zV$$M$6<%8EV^dSST8s!Udz=HG7by}83Yq8lkTw}&*%!_zq3wRf9G1;sBco)7S4<=U z8Jo{a)j7}M2FQOz8=7%T)ttsq@lnE-5KBS5k*dayxqHRImITz&m7WhC z+0-kbWcZjeu)w8MHflPRT1aCrcWmqmZkrM>6MAF$VeK_@*IOIbAQ;b5x3+=9mab}$ zv{tTUeYqRN%y#q5FN+4Rqgdvkw3T%$wobB+r)a2j7F_vA@OxB zDIUE`8{W|<94xrH_dCajtb%0uBnsnG^@+)$^A}q=MUgjOH{M__;y3TVyurneyvIqS_h#cwL;T+a7ZUM5 zNo3+js~1N8rJ$nlTQ8+}g76^m2PkYga(iLx;W>zWesdLG2`L*&jkm?WW4PWGKAp;T zhvS_17fkH_w5&w1kN6B@fv*jy+Js+C_%&%zvA`1J!qG5 z{G!PihQNR2Ep{;N)C#UO?{Ffz0Wb{){8x5MZNZ!XU_z8<;~v8VzE5QX4AO4c^UYTg zzk|Oct|$KBT>>~{#95g3fQRk3kGcFX9O~KlZKzEt=3xN@8wdT20)H@;9YJf<`EUY& zh`PZY{Jj&KU9hmG`BGMix`N#apT%+yu)QXLc-$C?oeLvxM78I^IhponxGt?uU;%>O z0NC0xK`b=HJ4O7O$(6woik%wKXQU?3fO1TL@5+k+TNMAui+@f5 zuaJ7e?D_#ra!P*?hO>TSim&jGc?l;VKK{50J=tVaegRr3R<3(P`>cn}i`w+*Opt)C z*T7HGhfMH6@w89IS6WT&;TwNG6GQ_bgQ?rz5E0RkiZ?0180oJ_M<};Dpf3IkY&zi1 zDCh%V#hwMks11M=!+V;RTs?ul#tMqJC;V2SR7v_2(Mw1dPP-wZE!G$gdxVmm2^g~x zoBa_vh9Rnr8hv;P&dxA&@&AJlH8A*2mH-q(un_iomMtF+A3+|8} zg}Ce-%?Fqwc5&OkzAU?8U#tQxF6@3AB&!ltVTkH)=iXr!eluuTnhzpeyTP!#jwu^OsfTW6Sfes zaFe!Sxua1F5Uxo>`DU!+xDmmhEBb@MCgSe}|Gf)v>PPe^XhU=j;!j!sly8qTr79<1 z$x`J$tz$X%%x<^6|%^HuB_M`b*hW6$lGAXP!jcvDQgNhGV6yOhuLR%0BSVQgw|_|Wo4=uQwB z_`tVaAt{*k=&*w)w{}@)GI1{c>Mc8@?c(+tkvdJg;bM)$NvlhIn&5qU zjUk>@Vqu$5i9DfT2#t0yF*ys~;1dBkT)aTgNa78G0gfq>#D-H};Hw7iY+4?mX7G}| zacCzYc?FS<9&ds+!mmnTY&7{KcZ^g0MxK0QKEDNHPynV2bn`U{WH|n5eFbmoj~t>K z`kcnM`l|xxXo9fB=2dEdq(vCl6~k^U3PPX=SPQZ77+lbPs_UO};%{8n-b`WrDU z{CNnsGV*YHyj@OhMyDfvlGG>hL$i(ec}6%oHrPo%4Wp54Inp~`RiF`lR==vyV7n=V z4aQEaS@iFy^`6*MwDkBfqH!acDF)H7*Wk5PJQ)%P*#;sJJDAAVc&vzZtA^{C}?odNj2y+eQp! z1v$r|Vk`6m_&ESQ5vV@&+pa#0ztIuSr<3tP2l3IvrQ&O?7%TOxzguA~>Uqw0cma~; zCK`!d`+`>ugyb?*zfb+Uv3hXA@i^?O$IGD8B|fasZX*eMdc#uc@m2No4V|Rt zz_YffC;b!7RC$g8a~QN>P*>$s4~{6oXZb$Od(^w~1%0E#z__i0IQy>PH~3746aL(o z3I*g7HRE5=q}dMpEO{GkLC@hZ?1+Wx2EakpT7pc?rL>Gw!FL{Z_aLCFdP{^~l# z#^|9$S^)V|)#LZpJLDShVBuf!FL?O`aFudr)VqRH6*$ogaMPQQs_vDbs0}>5_?P-} zT`#~Sk=73G0>EgGxo=n|eKvoyuTm*8$}&^vkds7HJf z$GBL4f@nR8Jp&FIB5<=ALXQJO^o<1nkHZldSH*R}Unpru#FiTa(sLg8&jov+FNCw4 zp91lC-0Bh*N2n4o8qzEuvi5bq=PMpyDtQ2Ck&bgZ-Ra1w`XfQ&!V&ax3J#3W`Ih(} z)L@_m+Y$foivRQC|2^^lzWDz@{C@~#uppGoLD3wP%|YQDl+Ho%9F)&Ng&fq_h8o-0 zHq_YOVf>^0YD`zIo5PTqIF#o0DuM|H8A!H zm!P3HtdJv)np6Y)8p~)<3y};53k~5G8k~lWwtkY^3wgyFntNeJJ))U7co#Wx@4Q~x zImiQ`V8GG%hO|R8`O{i4;z5)LcSP#igqe61m>}|DPoa&f0|f%B6pW0R+jFtzV&GEL zmi3`&z<@W*jb9+mGt0IE+?zGzbQSH=kKe}OkdF*`>??+gG*I7ATm6Pu4^6JW1yVrd z`>Bl<6zDGT=7Lkj&(Ys-*l5vdj^YscbZ9aJlj(|sXWY~0CMs^9P(ds+o=5@po6>jr zprwuoDP>=Viwu+Bsx$m?#2S2<)4*&T_2=@zG)L-3hq#RnNMsUrk@;ZeZHDoVkN}OtH;TiNpS}^d zC!r@-QIIqFD(tltY&qNGpu;5Xn>bMMnA2zg%G{0sAHoE)>v?Ei(4vD(4?Ja!3lBlf zA2e12#xTX$i{GyL0D7Ss3W?#UkG%94&ss@zBv;HL+R*sju|J8DPGis}Ii#t61E*gp^>h5V`x`;Jjo{Z5pU>J~$mABC(e{AQj@-^_Dsj0_$re%bOSiDpx> zc&KwL6F7u;DUZAQrCeqDg#!wEig^$F5V!|Y&V|@LgiYO%&jj*9F@#$ik6V83V&fj$~{&cOuyo)T2prBiKtB=)C5PWOp#0fAZSUcNCC z1FmF1JLG$KNzyvBCgt~U<^$iAr@A?!-A0aVxNEeRntCsmjn5i>95Xc&PiK?9BDz4C z-1s}BPB$Yw_yWNT3f9dx%JTd{ZlTTdP5->>g>0M8<}}$y?)eujX-+&O4V+QbY$xR=H8o~N zt9ZIug%u`&yphUHeO1OAJd%y4SXOyGK*_Ymvbn#pcpsB1l1fC~DHAYE#tnl`PZy3Y zV#0U)1x`u;KJAW0(B}7?g`0k1v!r~JnVp$@rKDyyiZT{b-fVzXJi#@>4^;9J&oNgq z;ko=7PrjK8@kJFS;S$0nnE%b5+jG2-S>OE}mu8&_o$pDZ{-QzE}>XZ;+Yf zPj+nN8$%}@DjSC7Hu^?!)ABn<_`Z?Ck_-z@yig~zd>H6%Wkf3=iy6B}RZQ0##8{5O zku#+&!EW0~tA>jDDc5rRE!|_}L#$=v^Es)>H73z#aH)F31{V#Zj{0DDUIBu&BnKy( zHJydPA4Uvyi2e=l-+cJ+p?~fLPGO^7DAWrZr9z?MZg_=4$rZodCugHvC{*Be*~NeH zTLJzpAHly~X`@ysTogq)H}7B(dhcyi3WZt`e`8xsC|KKY3#CsR7x2p~l&|1d-Ggd3 zP^jEwK?swepBO#JJO9PAK>Q=C@X{yDGGin;~&v&Q@ic3g!4xu0-Y{KkbK7p_mX92<_tZY@x~uI&#KjVBMzc!f#OqMwV*98{j}F&@lAqw! z#A$LNb5~3JEYsGWP}AJr#8F5)D$4y{X~yBEqMECxW%GNOCg|i_TuOc zw;W^WL0McNTd3sd4HYgSGM2~Ch5J%Oe7HS^)&Qpp)n_bK#ox5YaH&VsMc?YPW)ELBS6l$_UT6>Jv3tE6~O0hxoPG(phX=thI;Nk#& znlyNw=tm84Zr|1D)31F)~R??9}%I#NllO( zUmU9A<+O;6B2A`$fj(F8ccoCRxRO9i1V(~d%{qhyj69RTPc*9Oje*n7(tf~9^9T~T;iL7tM_n+ zC>4WA9E4+dQKXaZ7Tdi!mRRGC9R%V5t?G@Mr`IdGM$vuha~=24z^Nk^5pk>u>IZXj zkB{i&8@swJ>_ouU8hv`vGd+|uYn;7{iL~mCJb)G=KA6;nCmIx zKFk%Emom>4j|W(CK%{lVt;+SrZK0e4=B2QOZH%2OIpm9i_h}CSQ{A{0G))}Fx1!mA zIu`HCQ|FpK`_^Z%L-=&RVa5!w)?oy%ip_z1%Qb?ra;Xq|L<@V{CG?*VqfTNj#Jc90xBPf8PZsoohr#l_jBs?$|uWQts;jpiXbG^f&_*t-nwBF?l0~YC+ zOu)$#aFA#bNw~N~kkkkw9`M_^8RaAqjzHRBlGl2Ycto^Z!VE?pL0M1ql8uW*zKT%h zk|yd2WGwhk@I_RM5D>L-5r_InU>U(vX-H>DgbznH%k3enT2f059rs1gwZgqC&bW?K zC^V074#=4oBA4Dh<5LZf-fj_lyJ#Xc5$(Ho4T52DqalXKLz~ipPbVkVER9{{&}wCI z6uDPNW-AS|6|vn~+)5eeGI9vUqK&B=P>U7lxsOC@>YVZ`D79b2F>MuBX}==TS&WW5 zsT90CG;Gv&Junh+5S)e*a=BulmMDE47~`>>{7 zIR~GQ3K8P&qr>!C5P=;BHn89%FAyvQ9Pz$QTU9{)n8Ex+JDi?)Vg( zs@f9uE>hbA63V##U1-Nix;EgmxUcu`JC#wT&TPh<@xO%Ueg9YHaB?3p≧=)k#m^q0~d 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