`
+ * element instead of an image. Inherits from `Icon` but ignores the `iconUrl` and shadow options.
+ *
+ * @example
+ * ```js
+ * var myIcon = L.divIcon({className: 'my-div-icon'});
+ * // you can set .my-div-icon styles in CSS
+ *
+ * L.marker([50.505, 30.57], {icon: myIcon}).addTo(map);
+ * ```
+ *
+ * By default, it has a 'leaflet-div-icon' CSS class and is styled as a little white square with a shadow.
+ */
+
+L.DivIcon = L.Icon.extend({
+ options: {
+ // @section
+ // @aka DivIcon options
+ iconSize: [12, 12], // also can be set through CSS
+
+ // iconAnchor: (Point),
+ // popupAnchor: (Point),
+
+ // @option html: String = ''
+ // Custom HTML code to put inside the div element, empty by default.
+ html: false,
+
+ // @option bgPos: Point = [0, 0]
+ // Optional relative position of the background, in pixels
+ bgPos: null,
+
+ className: 'leaflet-div-icon'
+ },
+
+ createIcon: function (oldIcon) {
+ var div = (oldIcon && oldIcon.tagName === 'DIV') ? oldIcon : document.createElement('div'),
+ options = this.options;
+
+ div.innerHTML = options.html !== false ? options.html : '';
+
+ if (options.bgPos) {
+ var bgPos = L.point(options.bgPos);
+ div.style.backgroundPosition = (-bgPos.x) + 'px ' + (-bgPos.y) + 'px';
+ }
+ this._setIconStyles(div, 'icon');
+
+ return div;
+ },
+
+ createShadow: function () {
+ return null;
+ }
+});
+
+// @factory L.divIcon(options: DivIcon options)
+// Creates a `DivIcon` instance with the given options.
+L.divIcon = function (options) {
+ return new L.DivIcon(options);
+};
+
+
+
+/*
+ * @class DivOverlay
+ * @inherits Layer
+ * @aka L.DivOverlay
+ * Base model for L.Popup and L.Tooltip. Inherit from it for custom popup like plugins.
+ */
+
+// @namespace DivOverlay
+L.DivOverlay = L.Layer.extend({
+
+ // @section
+ // @aka DivOverlay options
+ options: {
+ // @option offset: Point = Point(0, 7)
+ // The offset of the popup position. Useful to control the anchor
+ // of the popup when opening it on some overlays.
+ offset: [0, 7],
+
+ // @option className: String = ''
+ // A custom CSS class name to assign to the popup.
+ className: '',
+
+ // @option pane: String = 'popupPane'
+ // `Map pane` where the popup will be added.
+ pane: 'popupPane'
+ },
+
+ initialize: function (options, source) {
+ L.setOptions(this, options);
+
+ this._source = source;
+ },
+
+ onAdd: function (map) {
+ this._zoomAnimated = map._zoomAnimated;
+
+ if (!this._container) {
+ this._initLayout();
+ }
+
+ if (map._fadeAnimated) {
+ L.DomUtil.setOpacity(this._container, 0);
+ }
+
+ clearTimeout(this._removeTimeout);
+ this.getPane().appendChild(this._container);
+ this.update();
+
+ if (map._fadeAnimated) {
+ L.DomUtil.setOpacity(this._container, 1);
+ }
+
+ this.bringToFront();
+ },
+
+ onRemove: function (map) {
+ if (map._fadeAnimated) {
+ L.DomUtil.setOpacity(this._container, 0);
+ this._removeTimeout = setTimeout(L.bind(L.DomUtil.remove, L.DomUtil, this._container), 200);
+ } else {
+ L.DomUtil.remove(this._container);
+ }
+ },
+
+ // @namespace Popup
+ // @method getLatLng: LatLng
+ // Returns the geographical point of popup.
+ getLatLng: function () {
+ return this._latlng;
+ },
+
+ // @method setLatLng(latlng: LatLng): this
+ // Sets the geographical point where the popup will open.
+ setLatLng: function (latlng) {
+ this._latlng = L.latLng(latlng);
+ if (this._map) {
+ this._updatePosition();
+ this._adjustPan();
+ }
+ return this;
+ },
+
+ // @method getContent: String|HTMLElement
+ // Returns the content of the popup.
+ getContent: function () {
+ return this._content;
+ },
+
+ // @method setContent(htmlContent: String|HTMLElement|Function): this
+ // Sets the HTML content of the popup. If a function is passed the source layer will be passed to the function. The function should return a `String` or `HTMLElement` to be used in the popup.
+ setContent: function (content) {
+ this._content = content;
+ this.update();
+ return this;
+ },
+
+ // @method getElement: String|HTMLElement
+ // Alias for [getContent()](#popup-getcontent)
+ getElement: function () {
+ return this._container;
+ },
+
+ // @method update: null
+ // Updates the popup content, layout and position. Useful for updating the popup after something inside changed, e.g. image loaded.
+ update: function () {
+ if (!this._map) { return; }
+
+ this._container.style.visibility = 'hidden';
+
+ this._updateContent();
+ this._updateLayout();
+ this._updatePosition();
+
+ this._container.style.visibility = '';
+
+ this._adjustPan();
+ },
+
+ getEvents: function () {
+ var events = {
+ zoom: this._updatePosition,
+ viewreset: this._updatePosition
+ };
+
+ if (this._zoomAnimated) {
+ events.zoomanim = this._animateZoom;
+ }
+ return events;
+ },
+
+ // @method isOpen: Boolean
+ // Returns `true` when the popup is visible on the map.
+ isOpen: function () {
+ return !!this._map && this._map.hasLayer(this);
+ },
+
+ // @method bringToFront: this
+ // Brings this popup in front of other popups (in the same map pane).
+ bringToFront: function () {
+ if (this._map) {
+ L.DomUtil.toFront(this._container);
+ }
+ return this;
+ },
+
+ // @method bringToBack: this
+ // Brings this popup to the back of other popups (in the same map pane).
+ bringToBack: function () {
+ if (this._map) {
+ L.DomUtil.toBack(this._container);
+ }
+ return this;
+ },
+
+ _updateContent: function () {
+ if (!this._content) { return; }
+
+ var node = this._contentNode;
+ var content = (typeof this._content === 'function') ? this._content(this._source || this) : this._content;
+
+ if (typeof content === 'string') {
+ node.innerHTML = content;
+ } else {
+ while (node.hasChildNodes()) {
+ node.removeChild(node.firstChild);
+ }
+ node.appendChild(content);
+ }
+ this.fire('contentupdate');
+ },
+
+ _updatePosition: function () {
+ if (!this._map) { return; }
+
+ var pos = this._map.latLngToLayerPoint(this._latlng),
+ offset = L.point(this.options.offset),
+ anchor = this._getAnchor();
+
+ if (this._zoomAnimated) {
+ L.DomUtil.setPosition(this._container, pos.add(anchor));
+ } else {
+ offset = offset.add(pos).add(anchor);
+ }
+
+ var bottom = this._containerBottom = -offset.y,
+ left = this._containerLeft = -Math.round(this._containerWidth / 2) + offset.x;
+
+ // bottom position the popup in case the height of the popup changes (images loading etc)
+ this._container.style.bottom = bottom + 'px';
+ this._container.style.left = left + 'px';
+ },
+
+ _getAnchor: function () {
+ return [0, 0];
+ }
+
+});
+
+
+
+/*
+ * @class Popup
+ * @inherits DivOverlay
+ * @aka L.Popup
+ * Used to open popups in certain places of the map. Use [Map.openPopup](#map-openpopup) to
+ * open popups while making sure that only one popup is open at one time
+ * (recommended for usability), or use [Map.addLayer](#map-addlayer) to open as many as you want.
+ *
+ * @example
+ *
+ * If you want to just bind a popup to marker click and then open it, it's really easy:
+ *
+ * ```js
+ * marker.bindPopup(popupContent).openPopup();
+ * ```
+ * Path overlays like polylines also have a `bindPopup` method.
+ * Here's a more complicated way to open a popup on a map:
+ *
+ * ```js
+ * var popup = L.popup()
+ * .setLatLng(latlng)
+ * .setContent('
Hello world!
')
+ * .openOn(map);
+ * ```
+ */
+
+
+// @namespace Popup
+L.Popup = L.DivOverlay.extend({
+
+ // @section
+ // @aka Popup options
+ options: {
+ // @option maxWidth: Number = 300
+ // Max width of the popup, in pixels.
+ maxWidth: 300,
+
+ // @option minWidth: Number = 50
+ // Min width of the popup, in pixels.
+ minWidth: 50,
+
+ // @option maxHeight: Number = null
+ // If set, creates a scrollable container of the given height
+ // inside a popup if its content exceeds it.
+ maxHeight: null,
+
+ // @option autoPan: Boolean = true
+ // Set it to `false` if you don't want the map to do panning animation
+ // to fit the opened popup.
+ autoPan: true,
+
+ // @option autoPanPaddingTopLeft: Point = null
+ // The margin between the popup and the top left corner of the map
+ // view after autopanning was performed.
+ autoPanPaddingTopLeft: null,
+
+ // @option autoPanPaddingBottomRight: Point = null
+ // The margin between the popup and the bottom right corner of the map
+ // view after autopanning was performed.
+ autoPanPaddingBottomRight: null,
+
+ // @option autoPanPadding: Point = Point(5, 5)
+ // Equivalent of setting both top left and bottom right autopan padding to the same value.
+ autoPanPadding: [5, 5],
+
+ // @option keepInView: Boolean = false
+ // Set it to `true` if you want to prevent users from panning the popup
+ // off of the screen while it is open.
+ keepInView: false,
+
+ // @option closeButton: Boolean = true
+ // Controls the presence of a close button in the popup.
+ closeButton: true,
+
+ // @option autoClose: Boolean = true
+ // Set it to `false` if you want to override the default behavior of
+ // the popup closing when user clicks the map (set globally by
+ // the Map's [closePopupOnClick](#map-closepopuponclick) option).
+ autoClose: true,
+
+ // @option className: String = ''
+ // A custom CSS class name to assign to the popup.
+ className: ''
+ },
+
+ // @namespace Popup
+ // @method openOn(map: Map): this
+ // Adds the popup to the map and closes the previous one. The same as `map.openPopup(popup)`.
+ openOn: function (map) {
+ map.openPopup(this);
+ return this;
+ },
+
+ onAdd: function (map) {
+ L.DivOverlay.prototype.onAdd.call(this, map);
+
+ // @namespace Map
+ // @section Popup events
+ // @event popupopen: PopupEvent
+ // Fired when a popup is opened in the map
+ map.fire('popupopen', {popup: this});
+
+ if (this._source) {
+ // @namespace Layer
+ // @section Popup events
+ // @event popupopen: PopupEvent
+ // Fired when a popup bound to this layer is opened
+ this._source.fire('popupopen', {popup: this}, true);
+ // For non-path layers, we toggle the popup when clicking
+ // again the layer, so prevent the map to reopen it.
+ if (!(this._source instanceof L.Path)) {
+ this._source.on('preclick', L.DomEvent.stopPropagation);
+ }
+ }
+ },
+
+ onRemove: function (map) {
+ L.DivOverlay.prototype.onRemove.call(this, map);
+
+ // @namespace Map
+ // @section Popup events
+ // @event popupclose: PopupEvent
+ // Fired when a popup in the map is closed
+ map.fire('popupclose', {popup: this});
+
+ if (this._source) {
+ // @namespace Layer
+ // @section Popup events
+ // @event popupclose: PopupEvent
+ // Fired when a popup bound to this layer is closed
+ this._source.fire('popupclose', {popup: this}, true);
+ if (!(this._source instanceof L.Path)) {
+ this._source.off('preclick', L.DomEvent.stopPropagation);
+ }
+ }
+ },
+
+ getEvents: function () {
+ var events = L.DivOverlay.prototype.getEvents.call(this);
+
+ if ('closeOnClick' in this.options ? this.options.closeOnClick : this._map.options.closePopupOnClick) {
+ events.preclick = this._close;
+ }
+
+ if (this.options.keepInView) {
+ events.moveend = this._adjustPan;
+ }
+
+ return events;
+ },
+
+ _close: function () {
+ if (this._map) {
+ this._map.closePopup(this);
+ }
+ },
+
+ _initLayout: function () {
+ var prefix = 'leaflet-popup',
+ container = this._container = L.DomUtil.create('div',
+ prefix + ' ' + (this.options.className || '') +
+ ' leaflet-zoom-animated');
+
+ if (this.options.closeButton) {
+ var closeButton = this._closeButton = L.DomUtil.create('a', prefix + '-close-button', container);
+ closeButton.href = '#close';
+ closeButton.innerHTML = '×';
+
+ L.DomEvent.on(closeButton, 'click', this._onCloseButtonClick, this);
+ }
+
+ var wrapper = this._wrapper = L.DomUtil.create('div', prefix + '-content-wrapper', container);
+ this._contentNode = L.DomUtil.create('div', prefix + '-content', wrapper);
+
+ L.DomEvent
+ .disableClickPropagation(wrapper)
+ .disableScrollPropagation(this._contentNode)
+ .on(wrapper, 'contextmenu', L.DomEvent.stopPropagation);
+
+ this._tipContainer = L.DomUtil.create('div', prefix + '-tip-container', container);
+ this._tip = L.DomUtil.create('div', prefix + '-tip', this._tipContainer);
+ },
+
+ _updateLayout: function () {
+ var container = this._contentNode,
+ style = container.style;
+
+ style.width = '';
+ style.whiteSpace = 'nowrap';
+
+ var width = container.offsetWidth;
+ width = Math.min(width, this.options.maxWidth);
+ width = Math.max(width, this.options.minWidth);
+
+ style.width = (width + 1) + 'px';
+ style.whiteSpace = '';
+
+ style.height = '';
+
+ var height = container.offsetHeight,
+ maxHeight = this.options.maxHeight,
+ scrolledClass = 'leaflet-popup-scrolled';
+
+ if (maxHeight && height > maxHeight) {
+ style.height = maxHeight + 'px';
+ L.DomUtil.addClass(container, scrolledClass);
+ } else {
+ L.DomUtil.removeClass(container, scrolledClass);
+ }
+
+ this._containerWidth = this._container.offsetWidth;
+ },
+
+ _animateZoom: function (e) {
+ var pos = this._map._latLngToNewLayerPoint(this._latlng, e.zoom, e.center),
+ anchor = this._getAnchor();
+ L.DomUtil.setPosition(this._container, pos.add(anchor));
+ },
+
+ _adjustPan: function () {
+ if (!this.options.autoPan || (this._map._panAnim && this._map._panAnim._inProgress)) { return; }
+
+ var map = this._map,
+ marginBottom = parseInt(L.DomUtil.getStyle(this._container, 'marginBottom'), 10) || 0,
+ containerHeight = this._container.offsetHeight + marginBottom,
+ containerWidth = this._containerWidth,
+ layerPos = new L.Point(this._containerLeft, -containerHeight - this._containerBottom);
+
+ layerPos._add(L.DomUtil.getPosition(this._container));
+
+ var containerPos = map.layerPointToContainerPoint(layerPos),
+ padding = L.point(this.options.autoPanPadding),
+ paddingTL = L.point(this.options.autoPanPaddingTopLeft || padding),
+ paddingBR = L.point(this.options.autoPanPaddingBottomRight || padding),
+ size = map.getSize(),
+ dx = 0,
+ dy = 0;
+
+ if (containerPos.x + containerWidth + paddingBR.x > size.x) { // right
+ dx = containerPos.x + containerWidth - size.x + paddingBR.x;
+ }
+ if (containerPos.x - dx - paddingTL.x < 0) { // left
+ dx = containerPos.x - paddingTL.x;
+ }
+ if (containerPos.y + containerHeight + paddingBR.y > size.y) { // bottom
+ dy = containerPos.y + containerHeight - size.y + paddingBR.y;
+ }
+ if (containerPos.y - dy - paddingTL.y < 0) { // top
+ dy = containerPos.y - paddingTL.y;
+ }
+
+ // @namespace Map
+ // @section Popup events
+ // @event autopanstart: Event
+ // Fired when the map starts autopanning when opening a popup.
+ if (dx || dy) {
+ map
+ .fire('autopanstart')
+ .panBy([dx, dy]);
+ }
+ },
+
+ _onCloseButtonClick: function (e) {
+ this._close();
+ L.DomEvent.stop(e);
+ },
+
+ _getAnchor: function () {
+ // Where should we anchor the popup on the source layer?
+ return L.point(this._source && this._source._getPopupAnchor ? this._source._getPopupAnchor() : [0, 0]);
+ }
+
+});
+
+// @namespace Popup
+// @factory L.popup(options?: Popup options, source?: Layer)
+// Instantiates a `Popup` object given an optional `options` object that describes its appearance and location and an optional `source` object that is used to tag the popup with a reference to the Layer to which it refers.
+L.popup = function (options, source) {
+ return new L.Popup(options, source);
+};
+
+
+/* @namespace Map
+ * @section Interaction Options
+ * @option closePopupOnClick: Boolean = true
+ * Set it to `false` if you don't want popups to close when user clicks the map.
+ */
+L.Map.mergeOptions({
+ closePopupOnClick: true
+});
+
+
+// @namespace Map
+// @section Methods for Layers and Controls
+L.Map.include({
+ // @method openPopup(popup: Popup): this
+ // Opens the specified popup while closing the previously opened (to make sure only one is opened at one time for usability).
+ // @alternative
+ // @method openPopup(content: String|HTMLElement, latlng: LatLng, options?: Popup options): this
+ // Creates a popup with the specified content and options and opens it in the given point on a map.
+ openPopup: function (popup, latlng, options) {
+ if (!(popup instanceof L.Popup)) {
+ popup = new L.Popup(options).setContent(popup);
+ }
+
+ if (latlng) {
+ popup.setLatLng(latlng);
+ }
+
+ if (this.hasLayer(popup)) {
+ return this;
+ }
+
+ if (this._popup && this._popup.options.autoClose) {
+ this.closePopup();
+ }
+
+ this._popup = popup;
+ return this.addLayer(popup);
+ },
+
+ // @method closePopup(popup?: Popup): this
+ // Closes the popup previously opened with [openPopup](#map-openpopup) (or the given one).
+ closePopup: function (popup) {
+ if (!popup || popup === this._popup) {
+ popup = this._popup;
+ this._popup = null;
+ }
+ if (popup) {
+ this.removeLayer(popup);
+ }
+ return this;
+ }
+});
+
+/*
+ * @namespace Layer
+ * @section Popup methods example
+ *
+ * All layers share a set of methods convenient for binding popups to it.
+ *
+ * ```js
+ * var layer = L.Polygon(latlngs).bindPopup('Hi There!').addTo(map);
+ * layer.openPopup();
+ * layer.closePopup();
+ * ```
+ *
+ * Popups will also be automatically opened when the layer is clicked on and closed when the layer is removed from the map or another popup is opened.
+ */
+
+// @section Popup methods
+L.Layer.include({
+
+ // @method bindPopup(content: String|HTMLElement|Function|Popup, options?: Popup options): this
+ // Binds a popup to the layer with the passed `content` and sets up the
+ // neccessary event listeners. If a `Function` is passed it will receive
+ // the layer as the first argument and should return a `String` or `HTMLElement`.
+ bindPopup: function (content, options) {
+
+ if (content instanceof L.Popup) {
+ L.setOptions(content, options);
+ this._popup = content;
+ content._source = this;
+ } else {
+ if (!this._popup || options) {
+ this._popup = new L.Popup(options, this);
+ }
+ this._popup.setContent(content);
+ }
+
+ if (!this._popupHandlersAdded) {
+ this.on({
+ click: this._openPopup,
+ remove: this.closePopup,
+ move: this._movePopup
+ });
+ this._popupHandlersAdded = true;
+ }
+
+ return this;
+ },
+
+ // @method unbindPopup(): this
+ // Removes the popup previously bound with `bindPopup`.
+ unbindPopup: function () {
+ if (this._popup) {
+ this.off({
+ click: this._openPopup,
+ remove: this.closePopup,
+ move: this._movePopup
+ });
+ this._popupHandlersAdded = false;
+ this._popup = null;
+ }
+ return this;
+ },
+
+ // @method openPopup(latlng?: LatLng): this
+ // Opens the bound popup at the specificed `latlng` or at the default popup anchor if no `latlng` is passed.
+ openPopup: function (layer, latlng) {
+ if (!(layer instanceof L.Layer)) {
+ latlng = layer;
+ layer = this;
+ }
+
+ if (layer instanceof L.FeatureGroup) {
+ for (var id in this._layers) {
+ layer = this._layers[id];
+ break;
+ }
+ }
+
+ if (!latlng) {
+ latlng = layer.getCenter ? layer.getCenter() : layer.getLatLng();
+ }
+
+ if (this._popup && this._map) {
+ // set popup source to this layer
+ this._popup._source = layer;
+
+ // update the popup (content, layout, ect...)
+ this._popup.update();
+
+ // open the popup on the map
+ this._map.openPopup(this._popup, latlng);
+ }
+
+ return this;
+ },
+
+ // @method closePopup(): this
+ // Closes the popup bound to this layer if it is open.
+ closePopup: function () {
+ if (this._popup) {
+ this._popup._close();
+ }
+ return this;
+ },
+
+ // @method togglePopup(): this
+ // Opens or closes the popup bound to this layer depending on its current state.
+ togglePopup: function (target) {
+ if (this._popup) {
+ if (this._popup._map) {
+ this.closePopup();
+ } else {
+ this.openPopup(target);
+ }
+ }
+ return this;
+ },
+
+ // @method isPopupOpen(): boolean
+ // Returns `true` if the popup bound to this layer is currently open.
+ isPopupOpen: function () {
+ return (this._popup ? this._popup.isOpen() : false);
+ },
+
+ // @method setPopupContent(content: String|HTMLElement|Popup): this
+ // Sets the content of the popup bound to this layer.
+ setPopupContent: function (content) {
+ if (this._popup) {
+ this._popup.setContent(content);
+ }
+ return this;
+ },
+
+ // @method getPopup(): Popup
+ // Returns the popup bound to this layer.
+ getPopup: function () {
+ return this._popup;
+ },
+
+ _openPopup: function (e) {
+ var layer = e.layer || e.target;
+
+ if (!this._popup) {
+ return;
+ }
+
+ if (!this._map) {
+ return;
+ }
+
+ // prevent map click
+ L.DomEvent.stop(e);
+
+ // if this inherits from Path its a vector and we can just
+ // open the popup at the new location
+ if (layer instanceof L.Path) {
+ this.openPopup(e.layer || e.target, e.latlng);
+ return;
+ }
+
+ // otherwise treat it like a marker and figure out
+ // if we should toggle it open/closed
+ if (this._map.hasLayer(this._popup) && this._popup._source === layer) {
+ this.closePopup();
+ } else {
+ this.openPopup(layer, e.latlng);
+ }
+ },
+
+ _movePopup: function (e) {
+ this._popup.setLatLng(e.latlng);
+ }
+});
+
+
+
+/*
+ * @class Tooltip
+ * @inherits DivOverlay
+ * @aka L.Tooltip
+ * Used to display small texts on top of map layers.
+ *
+ * @example
+ *
+ * ```js
+ * marker.bindTooltip("my tooltip text").openTooltip();
+ * ```
+ * Note about tooltip offset. Leaflet takes two options in consideration
+ * for computing tooltip offseting:
+ * - the `offset` Tooltip option: it defaults to [0, 0], and it's specific to one tooltip.
+ * Add a positive x offset to move the tooltip to the right, and a positive y offset to
+ * move it to the bottom. Negatives will move to the left and top.
+ * - the `tooltipAnchor` Icon option: this will only be considered for Marker. You
+ * should adapt this value if you use a custom icon.
+ */
+
+
+// @namespace Tooltip
+L.Tooltip = L.DivOverlay.extend({
+
+ // @section
+ // @aka Tooltip options
+ options: {
+ // @option pane: String = 'tooltipPane'
+ // `Map pane` where the tooltip will be added.
+ pane: 'tooltipPane',
+
+ // @option offset: Point = Point(0, 0)
+ // Optional offset of the tooltip position.
+ offset: [0, 0],
+
+ // @option direction: String = 'auto'
+ // Direction where to open the tooltip. Possible values are: `right`, `left`,
+ // `top`, `bottom`, `center`, `auto`.
+ // `auto` will dynamicaly switch between `right` and `left` according to the tooltip
+ // position on the map.
+ direction: 'auto',
+
+ // @option permanent: Boolean = false
+ // Whether to open the tooltip permanently or only on mouseover.
+ permanent: false,
+
+ // @option sticky: Boolean = false
+ // If true, the tooltip will follow the mouse instead of being fixed at the feature center.
+ sticky: false,
+
+ // @option interactive: Boolean = false
+ // If true, the tooltip will listen to the feature events.
+ interactive: false,
+
+ // @option opacity: Number = 0.9
+ // Tooltip container opacity.
+ opacity: 0.9
+ },
+
+ onAdd: function (map) {
+ L.DivOverlay.prototype.onAdd.call(this, map);
+ this.setOpacity(this.options.opacity);
+
+ // @namespace Map
+ // @section Tooltip events
+ // @event tooltipopen: TooltipEvent
+ // Fired when a tooltip is opened in the map.
+ map.fire('tooltipopen', {tooltip: this});
+
+ if (this._source) {
+ // @namespace Layer
+ // @section Tooltip events
+ // @event tooltipopen: TooltipEvent
+ // Fired when a tooltip bound to this layer is opened.
+ this._source.fire('tooltipopen', {tooltip: this}, true);
+ }
+ },
+
+ onRemove: function (map) {
+ L.DivOverlay.prototype.onRemove.call(this, map);
+
+ // @namespace Map
+ // @section Tooltip events
+ // @event tooltipclose: TooltipEvent
+ // Fired when a tooltip in the map is closed.
+ map.fire('tooltipclose', {tooltip: this});
+
+ if (this._source) {
+ // @namespace Layer
+ // @section Tooltip events
+ // @event tooltipclose: TooltipEvent
+ // Fired when a tooltip bound to this layer is closed.
+ this._source.fire('tooltipclose', {tooltip: this}, true);
+ }
+ },
+
+ getEvents: function () {
+ var events = L.DivOverlay.prototype.getEvents.call(this);
+
+ if (L.Browser.touch && !this.options.permanent) {
+ events.preclick = this._close;
+ }
+
+ return events;
+ },
+
+ _close: function () {
+ if (this._map) {
+ this._map.closeTooltip(this);
+ }
+ },
+
+ _initLayout: function () {
+ var prefix = 'leaflet-tooltip',
+ className = prefix + ' ' + (this.options.className || '') + ' leaflet-zoom-' + (this._zoomAnimated ? 'animated' : 'hide');
+
+ this._contentNode = this._container = L.DomUtil.create('div', className);
+ },
+
+ _updateLayout: function () {},
+
+ _adjustPan: function () {},
+
+ _setPosition: function (pos) {
+ var map = this._map,
+ container = this._container,
+ centerPoint = map.latLngToContainerPoint(map.getCenter()),
+ tooltipPoint = map.layerPointToContainerPoint(pos),
+ direction = this.options.direction,
+ tooltipWidth = container.offsetWidth,
+ tooltipHeight = container.offsetHeight,
+ offset = L.point(this.options.offset),
+ anchor = this._getAnchor();
+
+ if (direction === 'top') {
+ pos = pos.add(L.point(-tooltipWidth / 2 + offset.x, -tooltipHeight + offset.y + anchor.y, true));
+ } else if (direction === 'bottom') {
+ pos = pos.subtract(L.point(tooltipWidth / 2 - offset.x, -offset.y, true));
+ } else if (direction === 'center') {
+ pos = pos.subtract(L.point(tooltipWidth / 2 + offset.x, tooltipHeight / 2 - anchor.y + offset.y, true));
+ } else if (direction === 'right' || direction === 'auto' && tooltipPoint.x < centerPoint.x) {
+ direction = 'right';
+ pos = pos.add(L.point(offset.x + anchor.x, anchor.y - tooltipHeight / 2 + offset.y, true));
+ } else {
+ direction = 'left';
+ pos = pos.subtract(L.point(tooltipWidth + anchor.x - offset.x, tooltipHeight / 2 - anchor.y - offset.y, true));
+ }
+
+ L.DomUtil.removeClass(container, 'leaflet-tooltip-right');
+ L.DomUtil.removeClass(container, 'leaflet-tooltip-left');
+ L.DomUtil.removeClass(container, 'leaflet-tooltip-top');
+ L.DomUtil.removeClass(container, 'leaflet-tooltip-bottom');
+ L.DomUtil.addClass(container, 'leaflet-tooltip-' + direction);
+ L.DomUtil.setPosition(container, pos);
+ },
+
+ _updatePosition: function () {
+ var pos = this._map.latLngToLayerPoint(this._latlng);
+ this._setPosition(pos);
+ },
+
+ setOpacity: function (opacity) {
+ this.options.opacity = opacity;
+
+ if (this._container) {
+ L.DomUtil.setOpacity(this._container, opacity);
+ }
+ },
+
+ _animateZoom: function (e) {
+ var pos = this._map._latLngToNewLayerPoint(this._latlng, e.zoom, e.center);
+ this._setPosition(pos);
+ },
+
+ _getAnchor: function () {
+ // Where should we anchor the tooltip on the source layer?
+ return L.point(this._source && this._source._getTooltipAnchor && !this.options.sticky ? this._source._getTooltipAnchor() : [0, 0]);
+ }
+
+});
+
+// @namespace Tooltip
+// @factory L.tooltip(options?: Tooltip options, source?: Layer)
+// Instantiates a Tooltip object given an optional `options` object that describes its appearance and location and an optional `source` object that is used to tag the tooltip with a reference to the Layer to which it refers.
+L.tooltip = function (options, source) {
+ return new L.Tooltip(options, source);
+};
+
+// @namespace Map
+// @section Methods for Layers and Controls
+L.Map.include({
+
+ // @method openTooltip(tooltip: Tooltip): this
+ // Opens the specified tooltip.
+ // @alternative
+ // @method openTooltip(content: String|HTMLElement, latlng: LatLng, options?: Tooltip options): this
+ // Creates a tooltip with the specified content and options and open it.
+ openTooltip: function (tooltip, latlng, options) {
+ if (!(tooltip instanceof L.Tooltip)) {
+ tooltip = new L.Tooltip(options).setContent(tooltip);
+ }
+
+ if (latlng) {
+ tooltip.setLatLng(latlng);
+ }
+
+ if (this.hasLayer(tooltip)) {
+ return this;
+ }
+
+ return this.addLayer(tooltip);
+ },
+
+ // @method closeTooltip(tooltip?: Tooltip): this
+ // Closes the tooltip given as parameter.
+ closeTooltip: function (tooltip) {
+ if (tooltip) {
+ this.removeLayer(tooltip);
+ }
+ return this;
+ }
+
+});
+
+/*
+ * @namespace Layer
+ * @section Tooltip methods example
+ *
+ * All layers share a set of methods convenient for binding tooltips to it.
+ *
+ * ```js
+ * var layer = L.Polygon(latlngs).bindTooltip('Hi There!').addTo(map);
+ * layer.openTooltip();
+ * layer.closeTooltip();
+ * ```
+ */
+
+// @section Tooltip methods
+L.Layer.include({
+
+ // @method bindTooltip(content: String|HTMLElement|Function|Tooltip, options?: Tooltip options): this
+ // Binds a tooltip to the layer with the passed `content` and sets up the
+ // neccessary event listeners. If a `Function` is passed it will receive
+ // the layer as the first argument and should return a `String` or `HTMLElement`.
+ bindTooltip: function (content, options) {
+
+ if (content instanceof L.Tooltip) {
+ L.setOptions(content, options);
+ this._tooltip = content;
+ content._source = this;
+ } else {
+ if (!this._tooltip || options) {
+ this._tooltip = L.tooltip(options, this);
+ }
+ this._tooltip.setContent(content);
+
+ }
+
+ this._initTooltipInteractions();
+
+ if (this._tooltip.options.permanent && this._map && this._map.hasLayer(this)) {
+ this.openTooltip();
+ }
+
+ return this;
+ },
+
+ // @method unbindTooltip(): this
+ // Removes the tooltip previously bound with `bindTooltip`.
+ unbindTooltip: function () {
+ if (this._tooltip) {
+ this._initTooltipInteractions(true);
+ this.closeTooltip();
+ this._tooltip = null;
+ }
+ return this;
+ },
+
+ _initTooltipInteractions: function (remove) {
+ if (!remove && this._tooltipHandlersAdded) { return; }
+ var onOff = remove ? 'off' : 'on',
+ events = {
+ remove: this.closeTooltip,
+ move: this._moveTooltip
+ };
+ if (!this._tooltip.options.permanent) {
+ events.mouseover = this._openTooltip;
+ events.mouseout = this.closeTooltip;
+ if (this._tooltip.options.sticky) {
+ events.mousemove = this._moveTooltip;
+ }
+ if (L.Browser.touch) {
+ events.click = this._openTooltip;
+ }
+ } else {
+ events.add = this._openTooltip;
+ }
+ this[onOff](events);
+ this._tooltipHandlersAdded = !remove;
+ },
+
+ // @method openTooltip(latlng?: LatLng): this
+ // Opens the bound tooltip at the specificed `latlng` or at the default tooltip anchor if no `latlng` is passed.
+ openTooltip: function (layer, latlng) {
+ if (!(layer instanceof L.Layer)) {
+ latlng = layer;
+ layer = this;
+ }
+
+ if (layer instanceof L.FeatureGroup) {
+ for (var id in this._layers) {
+ layer = this._layers[id];
+ break;
+ }
+ }
+
+ if (!latlng) {
+ latlng = layer.getCenter ? layer.getCenter() : layer.getLatLng();
+ }
+
+ if (this._tooltip && this._map) {
+
+ // set tooltip source to this layer
+ this._tooltip._source = layer;
+
+ // update the tooltip (content, layout, ect...)
+ this._tooltip.update();
+
+ // open the tooltip on the map
+ this._map.openTooltip(this._tooltip, latlng);
+
+ // Tooltip container may not be defined if not permanent and never
+ // opened.
+ if (this._tooltip.options.interactive && this._tooltip._container) {
+ L.DomUtil.addClass(this._tooltip._container, 'leaflet-clickable');
+ this.addInteractiveTarget(this._tooltip._container);
+ }
+ }
+
+ return this;
+ },
+
+ // @method closeTooltip(): this
+ // Closes the tooltip bound to this layer if it is open.
+ closeTooltip: function () {
+ if (this._tooltip) {
+ this._tooltip._close();
+ if (this._tooltip.options.interactive && this._tooltip._container) {
+ L.DomUtil.removeClass(this._tooltip._container, 'leaflet-clickable');
+ this.removeInteractiveTarget(this._tooltip._container);
+ }
+ }
+ return this;
+ },
+
+ // @method toggleTooltip(): this
+ // Opens or closes the tooltip bound to this layer depending on its current state.
+ toggleTooltip: function (target) {
+ if (this._tooltip) {
+ if (this._tooltip._map) {
+ this.closeTooltip();
+ } else {
+ this.openTooltip(target);
+ }
+ }
+ return this;
+ },
+
+ // @method isTooltipOpen(): boolean
+ // Returns `true` if the tooltip bound to this layer is currently open.
+ isTooltipOpen: function () {
+ return this._tooltip.isOpen();
+ },
+
+ // @method setTooltipContent(content: String|HTMLElement|Tooltip): this
+ // Sets the content of the tooltip bound to this layer.
+ setTooltipContent: function (content) {
+ if (this._tooltip) {
+ this._tooltip.setContent(content);
+ }
+ return this;
+ },
+
+ // @method getTooltip(): Tooltip
+ // Returns the tooltip bound to this layer.
+ getTooltip: function () {
+ return this._tooltip;
+ },
+
+ _openTooltip: function (e) {
+ var layer = e.layer || e.target;
+
+ if (!this._tooltip || !this._map) {
+ return;
+ }
+ this.openTooltip(layer, this._tooltip.options.sticky ? e.latlng : undefined);
+ },
+
+ _moveTooltip: function (e) {
+ var latlng = e.latlng, containerPoint, layerPoint;
+ if (this._tooltip.options.sticky && e.originalEvent) {
+ containerPoint = this._map.mouseEventToContainerPoint(e.originalEvent);
+ layerPoint = this._map.containerPointToLayerPoint(containerPoint);
+ latlng = this._map.layerPointToLatLng(layerPoint);
+ }
+ this._tooltip.setLatLng(latlng);
+ }
+});
+
+
+
+/*
+ * @class LayerGroup
+ * @aka L.LayerGroup
+ * @inherits Layer
+ *
+ * Used to group several layers and handle them as one. If you add it to the map,
+ * any layers added or removed from the group will be added/removed on the map as
+ * well. Extends `Layer`.
+ *
+ * @example
+ *
+ * ```js
+ * L.layerGroup([marker1, marker2])
+ * .addLayer(polyline)
+ * .addTo(map);
+ * ```
+ */
+
+L.LayerGroup = L.Layer.extend({
+
+ initialize: function (layers) {
+ this._layers = {};
+
+ var i, len;
+
+ if (layers) {
+ for (i = 0, len = layers.length; i < len; i++) {
+ this.addLayer(layers[i]);
+ }
+ }
+ },
+
+ // @method addLayer(layer: Layer): this
+ // Adds the given layer to the group.
+ addLayer: function (layer) {
+ var id = this.getLayerId(layer);
+
+ this._layers[id] = layer;
+
+ if (this._map) {
+ this._map.addLayer(layer);
+ }
+
+ return this;
+ },
+
+ // @method removeLayer(layer: Layer): this
+ // Removes the given layer from the group.
+ // @alternative
+ // @method removeLayer(id: Number): this
+ // Removes the layer with the given internal ID from the group.
+ removeLayer: function (layer) {
+ var id = layer in this._layers ? layer : this.getLayerId(layer);
+
+ if (this._map && this._layers[id]) {
+ this._map.removeLayer(this._layers[id]);
+ }
+
+ delete this._layers[id];
+
+ return this;
+ },
+
+ // @method hasLayer(layer: Layer): Boolean
+ // Returns `true` if the given layer is currently added to the group.
+ hasLayer: function (layer) {
+ return !!layer && (layer in this._layers || this.getLayerId(layer) in this._layers);
+ },
+
+ // @method clearLayers(): this
+ // Removes all the layers from the group.
+ clearLayers: function () {
+ for (var i in this._layers) {
+ this.removeLayer(this._layers[i]);
+ }
+ return this;
+ },
+
+ // @method invoke(methodName: String, …): this
+ // Calls `methodName` on every layer contained in this group, passing any
+ // additional parameters. Has no effect if the layers contained do not
+ // implement `methodName`.
+ invoke: function (methodName) {
+ var args = Array.prototype.slice.call(arguments, 1),
+ i, layer;
+
+ for (i in this._layers) {
+ layer = this._layers[i];
+
+ if (layer[methodName]) {
+ layer[methodName].apply(layer, args);
+ }
+ }
+
+ return this;
+ },
+
+ onAdd: function (map) {
+ for (var i in this._layers) {
+ map.addLayer(this._layers[i]);
+ }
+ },
+
+ onRemove: function (map) {
+ for (var i in this._layers) {
+ map.removeLayer(this._layers[i]);
+ }
+ },
+
+ // @method eachLayer(fn: Function, context?: Object): this
+ // Iterates over the layers of the group, optionally specifying context of the iterator function.
+ // ```js
+ // group.eachLayer(function (layer) {
+ // layer.bindPopup('Hello');
+ // });
+ // ```
+ eachLayer: function (method, context) {
+ for (var i in this._layers) {
+ method.call(context, this._layers[i]);
+ }
+ return this;
+ },
+
+ // @method getLayer(id: Number): Layer
+ // Returns the layer with the given internal ID.
+ getLayer: function (id) {
+ return this._layers[id];
+ },
+
+ // @method getLayers(): Layer[]
+ // Returns an array of all the layers added to the group.
+ getLayers: function () {
+ var layers = [];
+
+ for (var i in this._layers) {
+ layers.push(this._layers[i]);
+ }
+ return layers;
+ },
+
+ // @method setZIndex(zIndex: Number): this
+ // Calls `setZIndex` on every layer contained in this group, passing the z-index.
+ setZIndex: function (zIndex) {
+ return this.invoke('setZIndex', zIndex);
+ },
+
+ // @method getLayerId(layer: Layer): Number
+ // Returns the internal ID for a layer
+ getLayerId: function (layer) {
+ return L.stamp(layer);
+ }
+});
+
+
+// @factory L.layerGroup(layers: Layer[])
+// Create a layer group, optionally given an initial set of layers.
+L.layerGroup = function (layers) {
+ return new L.LayerGroup(layers);
+};
+
+
+
+/*
+ * @class FeatureGroup
+ * @aka L.FeatureGroup
+ * @inherits LayerGroup
+ *
+ * Extended `LayerGroup` that makes it easier to do the same thing to all its member layers:
+ * * [`bindPopup`](#layer-bindpopup) binds a popup to all of the layers at once (likewise with [`bindTooltip`](#layer-bindtooltip))
+ * * Events are propagated to the `FeatureGroup`, so if the group has an event
+ * handler, it will handle events from any of the layers. This includes mouse events
+ * and custom events.
+ * * Has `layeradd` and `layerremove` events
+ *
+ * @example
+ *
+ * ```js
+ * L.featureGroup([marker1, marker2, polyline])
+ * .bindPopup('Hello world!')
+ * .on('click', function() { alert('Clicked on a member of the group!'); })
+ * .addTo(map);
+ * ```
+ */
+
+L.FeatureGroup = L.LayerGroup.extend({
+
+ addLayer: function (layer) {
+ if (this.hasLayer(layer)) {
+ return this;
+ }
+
+ layer.addEventParent(this);
+
+ L.LayerGroup.prototype.addLayer.call(this, layer);
+
+ // @event layeradd: LayerEvent
+ // Fired when a layer is added to this `FeatureGroup`
+ return this.fire('layeradd', {layer: layer});
+ },
+
+ removeLayer: function (layer) {
+ if (!this.hasLayer(layer)) {
+ return this;
+ }
+ if (layer in this._layers) {
+ layer = this._layers[layer];
+ }
+
+ layer.removeEventParent(this);
+
+ L.LayerGroup.prototype.removeLayer.call(this, layer);
+
+ // @event layerremove: LayerEvent
+ // Fired when a layer is removed from this `FeatureGroup`
+ return this.fire('layerremove', {layer: layer});
+ },
+
+ // @method setStyle(style: Path options): this
+ // Sets the given path options to each layer of the group that has a `setStyle` method.
+ setStyle: function (style) {
+ return this.invoke('setStyle', style);
+ },
+
+ // @method bringToFront(): this
+ // Brings the layer group to the top of all other layers
+ bringToFront: function () {
+ return this.invoke('bringToFront');
+ },
+
+ // @method bringToBack(): this
+ // Brings the layer group to the top of all other layers
+ bringToBack: function () {
+ return this.invoke('bringToBack');
+ },
+
+ // @method getBounds(): LatLngBounds
+ // Returns the LatLngBounds of the Feature Group (created from bounds and coordinates of its children).
+ getBounds: function () {
+ var bounds = new L.LatLngBounds();
+
+ for (var id in this._layers) {
+ var layer = this._layers[id];
+ bounds.extend(layer.getBounds ? layer.getBounds() : layer.getLatLng());
+ }
+ return bounds;
+ }
+});
+
+// @factory L.featureGroup(layers: Layer[])
+// Create a feature group, optionally given an initial set of layers.
+L.featureGroup = function (layers) {
+ return new L.FeatureGroup(layers);
+};
+
+
+
+/*
+ * @class Renderer
+ * @inherits Layer
+ * @aka L.Renderer
+ *
+ * Base class for vector renderer implementations (`SVG`, `Canvas`). Handles the
+ * DOM container of the renderer, its bounds, and its zoom animation.
+ *
+ * A `Renderer` works as an implicit layer group for all `Path`s - the renderer
+ * itself can be added or removed to the map. All paths use a renderer, which can
+ * be implicit (the map will decide the type of renderer and use it automatically)
+ * or explicit (using the [`renderer`](#path-renderer) option of the path).
+ *
+ * Do not use this class directly, use `SVG` and `Canvas` instead.
+ *
+ * @event update: Event
+ * Fired when the renderer updates its bounds, center and zoom, for example when
+ * its map has moved
+ */
+
+L.Renderer = L.Layer.extend({
+
+ // @section
+ // @aka Renderer options
+ options: {
+ // @option padding: Number = 0.1
+ // How much to extend the clip area around the map view (relative to its size)
+ // e.g. 0.1 would be 10% of map view in each direction
+ padding: 0.1
+ },
+
+ initialize: function (options) {
+ L.setOptions(this, options);
+ L.stamp(this);
+ this._layers = this._layers || {};
+ },
+
+ onAdd: function () {
+ if (!this._container) {
+ this._initContainer(); // defined by renderer implementations
+
+ if (this._zoomAnimated) {
+ L.DomUtil.addClass(this._container, 'leaflet-zoom-animated');
+ }
+ }
+
+ this.getPane().appendChild(this._container);
+ this._update();
+ this.on('update', this._updatePaths, this);
+ },
+
+ onRemove: function () {
+ L.DomUtil.remove(this._container);
+ this.off('update', this._updatePaths, this);
+ },
+
+ getEvents: function () {
+ var events = {
+ viewreset: this._reset,
+ zoom: this._onZoom,
+ moveend: this._update,
+ zoomend: this._onZoomEnd
+ };
+ if (this._zoomAnimated) {
+ events.zoomanim = this._onAnimZoom;
+ }
+ return events;
+ },
+
+ _onAnimZoom: function (ev) {
+ this._updateTransform(ev.center, ev.zoom);
+ },
+
+ _onZoom: function () {
+ this._updateTransform(this._map.getCenter(), this._map.getZoom());
+ },
+
+ _updateTransform: function (center, zoom) {
+ var scale = this._map.getZoomScale(zoom, this._zoom),
+ position = L.DomUtil.getPosition(this._container),
+ viewHalf = this._map.getSize().multiplyBy(0.5 + this.options.padding),
+ currentCenterPoint = this._map.project(this._center, zoom),
+ destCenterPoint = this._map.project(center, zoom),
+ centerOffset = destCenterPoint.subtract(currentCenterPoint),
+
+ topLeftOffset = viewHalf.multiplyBy(-scale).add(position).add(viewHalf).subtract(centerOffset);
+
+ if (L.Browser.any3d) {
+ L.DomUtil.setTransform(this._container, topLeftOffset, scale);
+ } else {
+ L.DomUtil.setPosition(this._container, topLeftOffset);
+ }
+ },
+
+ _reset: function () {
+ this._update();
+ this._updateTransform(this._center, this._zoom);
+
+ for (var id in this._layers) {
+ this._layers[id]._reset();
+ }
+ },
+
+ _onZoomEnd: function () {
+ for (var id in this._layers) {
+ this._layers[id]._project();
+ }
+ },
+
+ _updatePaths: function () {
+ for (var id in this._layers) {
+ this._layers[id]._update();
+ }
+ },
+
+ _update: function () {
+ // Update pixel bounds of renderer container (for positioning/sizing/clipping later)
+ // Subclasses are responsible of firing the 'update' event.
+ var p = this.options.padding,
+ size = this._map.getSize(),
+ min = this._map.containerPointToLayerPoint(size.multiplyBy(-p)).round();
+
+ this._bounds = new L.Bounds(min, min.add(size.multiplyBy(1 + p * 2)).round());
+
+ this._center = this._map.getCenter();
+ this._zoom = this._map.getZoom();
+ }
+});
+
+
+L.Map.include({
+ // @namespace Map; @method getRenderer(layer: Path): Renderer
+ // Returns the instance of `Renderer` that should be used to render the given
+ // `Path`. It will ensure that the `renderer` options of the map and paths
+ // are respected, and that the renderers do exist on the map.
+ getRenderer: function (layer) {
+ // @namespace Path; @option renderer: Renderer
+ // Use this specific instance of `Renderer` for this path. Takes
+ // precedence over the map's [default renderer](#map-renderer).
+ var renderer = layer.options.renderer || this._getPaneRenderer(layer.options.pane) || this.options.renderer || this._renderer;
+
+ if (!renderer) {
+ // @namespace Map; @option preferCanvas: Boolean = false
+ // Whether `Path`s should be rendered on a `Canvas` renderer.
+ // By default, all `Path`s are rendered in a `SVG` renderer.
+ renderer = this._renderer = (this.options.preferCanvas && L.canvas()) || L.svg();
+ }
+
+ if (!this.hasLayer(renderer)) {
+ this.addLayer(renderer);
+ }
+ return renderer;
+ },
+
+ _getPaneRenderer: function (name) {
+ if (name === 'overlayPane' || name === undefined) {
+ return false;
+ }
+
+ var renderer = this._paneRenderers[name];
+ if (renderer === undefined) {
+ renderer = (L.SVG && L.svg({pane: name})) || (L.Canvas && L.canvas({pane: name}));
+ this._paneRenderers[name] = renderer;
+ }
+ return renderer;
+ }
+});
+
+
+
+/*
+ * @class Path
+ * @aka L.Path
+ * @inherits Interactive layer
+ *
+ * An abstract class that contains options and constants shared between vector
+ * overlays (Polygon, Polyline, Circle). Do not use it directly. Extends `Layer`.
+ */
+
+L.Path = L.Layer.extend({
+
+ // @section
+ // @aka Path options
+ options: {
+ // @option stroke: Boolean = true
+ // Whether to draw stroke along the path. Set it to `false` to disable borders on polygons or circles.
+ stroke: true,
+
+ // @option color: String = '#3388ff'
+ // Stroke color
+ color: '#3388ff',
+
+ // @option weight: Number = 3
+ // Stroke width in pixels
+ weight: 3,
+
+ // @option opacity: Number = 1.0
+ // Stroke opacity
+ opacity: 1,
+
+ // @option lineCap: String= 'round'
+ // A string that defines [shape to be used at the end](https://developer.mozilla.org/docs/Web/SVG/Attribute/stroke-linecap) of the stroke.
+ lineCap: 'round',
+
+ // @option lineJoin: String = 'round'
+ // A string that defines [shape to be used at the corners](https://developer.mozilla.org/docs/Web/SVG/Attribute/stroke-linejoin) of the stroke.
+ lineJoin: 'round',
+
+ // @option dashArray: String = null
+ // A string that defines the stroke [dash pattern](https://developer.mozilla.org/docs/Web/SVG/Attribute/stroke-dasharray). Doesn't work on `Canvas`-powered layers in [some old browsers](https://developer.mozilla.org/docs/Web/API/CanvasRenderingContext2D/setLineDash#Browser_compatibility).
+ dashArray: null,
+
+ // @option dashOffset: String = null
+ // A string that defines the [distance into the dash pattern to start the dash](https://developer.mozilla.org/docs/Web/SVG/Attribute/stroke-dashoffset). Doesn't work on `Canvas`-powered layers in [some old browsers](https://developer.mozilla.org/docs/Web/API/CanvasRenderingContext2D/setLineDash#Browser_compatibility).
+ dashOffset: null,
+
+ // @option fill: Boolean = depends
+ // Whether to fill the path with color. Set it to `false` to disable filling on polygons or circles.
+ fill: false,
+
+ // @option fillColor: String = *
+ // Fill color. Defaults to the value of the [`color`](#path-color) option
+ fillColor: null,
+
+ // @option fillOpacity: Number = 0.2
+ // Fill opacity.
+ fillOpacity: 0.2,
+
+ // @option fillRule: String = 'evenodd'
+ // A string that defines [how the inside of a shape](https://developer.mozilla.org/docs/Web/SVG/Attribute/fill-rule) is determined.
+ fillRule: 'evenodd',
+
+ // className: '',
+
+ // Option inherited from "Interactive layer" abstract class
+ interactive: true
+ },
+
+ beforeAdd: function (map) {
+ // Renderer is set here because we need to call renderer.getEvents
+ // before this.getEvents.
+ this._renderer = map.getRenderer(this);
+ },
+
+ onAdd: function () {
+ this._renderer._initPath(this);
+ this._reset();
+ this._renderer._addPath(this);
+ },
+
+ onRemove: function () {
+ this._renderer._removePath(this);
+ },
+
+ // @method redraw(): this
+ // Redraws the layer. Sometimes useful after you changed the coordinates that the path uses.
+ redraw: function () {
+ if (this._map) {
+ this._renderer._updatePath(this);
+ }
+ return this;
+ },
+
+ // @method setStyle(style: Path options): this
+ // Changes the appearance of a Path based on the options in the `Path options` object.
+ setStyle: function (style) {
+ L.setOptions(this, style);
+ if (this._renderer) {
+ this._renderer._updateStyle(this);
+ }
+ return this;
+ },
+
+ // @method bringToFront(): this
+ // Brings the layer to the top of all path layers.
+ bringToFront: function () {
+ if (this._renderer) {
+ this._renderer._bringToFront(this);
+ }
+ return this;
+ },
+
+ // @method bringToBack(): this
+ // Brings the layer to the bottom of all path layers.
+ bringToBack: function () {
+ if (this._renderer) {
+ this._renderer._bringToBack(this);
+ }
+ return this;
+ },
+
+ getElement: function () {
+ return this._path;
+ },
+
+ _reset: function () {
+ // defined in children classes
+ this._project();
+ this._update();
+ },
+
+ _clickTolerance: function () {
+ // used when doing hit detection for Canvas layers
+ return (this.options.stroke ? this.options.weight / 2 : 0) + (L.Browser.touch ? 10 : 0);
+ }
+});
+
+
+
+/*
+ * @namespace LineUtil
+ *
+ * Various utility functions for polyine points processing, used by Leaflet internally to make polylines lightning-fast.
+ */
+
+L.LineUtil = {
+
+ // Simplify polyline with vertex reduction and Douglas-Peucker simplification.
+ // Improves rendering performance dramatically by lessening the number of points to draw.
+
+ // @function simplify(points: Point[], tolerance: Number): Point[]
+ // Dramatically reduces the number of points in a polyline while retaining
+ // its shape and returns a new array of simplified points, using the
+ // [Douglas-Peucker algorithm](http://en.wikipedia.org/wiki/Douglas-Peucker_algorithm).
+ // Used for a huge performance boost when processing/displaying Leaflet polylines for
+ // each zoom level and also reducing visual noise. tolerance affects the amount of
+ // simplification (lesser value means higher quality but slower and with more points).
+ // Also released as a separated micro-library [Simplify.js](http://mourner.github.com/simplify-js/).
+ simplify: function (points, tolerance) {
+ if (!tolerance || !points.length) {
+ return points.slice();
+ }
+
+ var sqTolerance = tolerance * tolerance;
+
+ // stage 1: vertex reduction
+ points = this._reducePoints(points, sqTolerance);
+
+ // stage 2: Douglas-Peucker simplification
+ points = this._simplifyDP(points, sqTolerance);
+
+ return points;
+ },
+
+ // @function pointToSegmentDistance(p: Point, p1: Point, p2: Point): Number
+ // Returns the distance between point `p` and segment `p1` to `p2`.
+ pointToSegmentDistance: function (p, p1, p2) {
+ return Math.sqrt(this._sqClosestPointOnSegment(p, p1, p2, true));
+ },
+
+ // @function closestPointOnSegment(p: Point, p1: Point, p2: Point): Number
+ // Returns the closest point from a point `p` on a segment `p1` to `p2`.
+ closestPointOnSegment: function (p, p1, p2) {
+ return this._sqClosestPointOnSegment(p, p1, p2);
+ },
+
+ // Douglas-Peucker simplification, see http://en.wikipedia.org/wiki/Douglas-Peucker_algorithm
+ _simplifyDP: function (points, sqTolerance) {
+
+ var len = points.length,
+ ArrayConstructor = typeof Uint8Array !== undefined + '' ? Uint8Array : Array,
+ markers = new ArrayConstructor(len);
+
+ markers[0] = markers[len - 1] = 1;
+
+ this._simplifyDPStep(points, markers, sqTolerance, 0, len - 1);
+
+ var i,
+ newPoints = [];
+
+ for (i = 0; i < len; i++) {
+ if (markers[i]) {
+ newPoints.push(points[i]);
+ }
+ }
+
+ return newPoints;
+ },
+
+ _simplifyDPStep: function (points, markers, sqTolerance, first, last) {
+
+ var maxSqDist = 0,
+ index, i, sqDist;
+
+ for (i = first + 1; i <= last - 1; i++) {
+ sqDist = this._sqClosestPointOnSegment(points[i], points[first], points[last], true);
+
+ if (sqDist > maxSqDist) {
+ index = i;
+ maxSqDist = sqDist;
+ }
+ }
+
+ if (maxSqDist > sqTolerance) {
+ markers[index] = 1;
+
+ this._simplifyDPStep(points, markers, sqTolerance, first, index);
+ this._simplifyDPStep(points, markers, sqTolerance, index, last);
+ }
+ },
+
+ // reduce points that are too close to each other to a single point
+ _reducePoints: function (points, sqTolerance) {
+ var reducedPoints = [points[0]];
+
+ for (var i = 1, prev = 0, len = points.length; i < len; i++) {
+ if (this._sqDist(points[i], points[prev]) > sqTolerance) {
+ reducedPoints.push(points[i]);
+ prev = i;
+ }
+ }
+ if (prev < len - 1) {
+ reducedPoints.push(points[len - 1]);
+ }
+ return reducedPoints;
+ },
+
+
+ // @function clipSegment(a: Point, b: Point, bounds: Bounds, useLastCode?: Boolean, round?: Boolean): Point[]|Boolean
+ // Clips the segment a to b by rectangular bounds with the
+ // [Cohen-Sutherland algorithm](https://en.wikipedia.org/wiki/Cohen%E2%80%93Sutherland_algorithm)
+ // (modifying the segment points directly!). Used by Leaflet to only show polyline
+ // points that are on the screen or near, increasing performance.
+ clipSegment: function (a, b, bounds, useLastCode, round) {
+ var codeA = useLastCode ? this._lastCode : this._getBitCode(a, bounds),
+ codeB = this._getBitCode(b, bounds),
+
+ codeOut, p, newCode;
+
+ // save 2nd code to avoid calculating it on the next segment
+ this._lastCode = codeB;
+
+ while (true) {
+ // if a,b is inside the clip window (trivial accept)
+ if (!(codeA | codeB)) {
+ return [a, b];
+ }
+
+ // if a,b is outside the clip window (trivial reject)
+ if (codeA & codeB) {
+ return false;
+ }
+
+ // other cases
+ codeOut = codeA || codeB;
+ p = this._getEdgeIntersection(a, b, codeOut, bounds, round);
+ newCode = this._getBitCode(p, bounds);
+
+ if (codeOut === codeA) {
+ a = p;
+ codeA = newCode;
+ } else {
+ b = p;
+ codeB = newCode;
+ }
+ }
+ },
+
+ _getEdgeIntersection: function (a, b, code, bounds, round) {
+ var dx = b.x - a.x,
+ dy = b.y - a.y,
+ min = bounds.min,
+ max = bounds.max,
+ x, y;
+
+ if (code & 8) { // top
+ x = a.x + dx * (max.y - a.y) / dy;
+ y = max.y;
+
+ } else if (code & 4) { // bottom
+ x = a.x + dx * (min.y - a.y) / dy;
+ y = min.y;
+
+ } else if (code & 2) { // right
+ x = max.x;
+ y = a.y + dy * (max.x - a.x) / dx;
+
+ } else if (code & 1) { // left
+ x = min.x;
+ y = a.y + dy * (min.x - a.x) / dx;
+ }
+
+ return new L.Point(x, y, round);
+ },
+
+ _getBitCode: function (p, bounds) {
+ var code = 0;
+
+ if (p.x < bounds.min.x) { // left
+ code |= 1;
+ } else if (p.x > bounds.max.x) { // right
+ code |= 2;
+ }
+
+ if (p.y < bounds.min.y) { // bottom
+ code |= 4;
+ } else if (p.y > bounds.max.y) { // top
+ code |= 8;
+ }
+
+ return code;
+ },
+
+ // square distance (to avoid unnecessary Math.sqrt calls)
+ _sqDist: function (p1, p2) {
+ var dx = p2.x - p1.x,
+ dy = p2.y - p1.y;
+ return dx * dx + dy * dy;
+ },
+
+ // return closest point on segment or distance to that point
+ _sqClosestPointOnSegment: function (p, p1, p2, sqDist) {
+ var x = p1.x,
+ y = p1.y,
+ dx = p2.x - x,
+ dy = p2.y - y,
+ dot = dx * dx + dy * dy,
+ t;
+
+ if (dot > 0) {
+ t = ((p.x - x) * dx + (p.y - y) * dy) / dot;
+
+ if (t > 1) {
+ x = p2.x;
+ y = p2.y;
+ } else if (t > 0) {
+ x += dx * t;
+ y += dy * t;
+ }
+ }
+
+ dx = p.x - x;
+ dy = p.y - y;
+
+ return sqDist ? dx * dx + dy * dy : new L.Point(x, y);
+ }
+};
+
+
+
+/*
+ * @class Polyline
+ * @aka L.Polyline
+ * @inherits Path
+ *
+ * A class for drawing polyline overlays on a map. Extends `Path`.
+ *
+ * @example
+ *
+ * ```js
+ * // create a red polyline from an array of LatLng points
+ * var latlngs = [
+ * [45.51, -122.68],
+ * [37.77, -122.43],
+ * [34.04, -118.2]
+ * ];
+ *
+ * var polyline = L.polyline(latlngs, {color: 'red'}).addTo(map);
+ *
+ * // zoom the map to the polyline
+ * map.fitBounds(polyline.getBounds());
+ * ```
+ *
+ * You can also pass a multi-dimensional array to represent a `MultiPolyline` shape:
+ *
+ * ```js
+ * // create a red polyline from an array of arrays of LatLng points
+ * var latlngs = [
+ * [[45.51, -122.68],
+ * [37.77, -122.43],
+ * [34.04, -118.2]],
+ * [[40.78, -73.91],
+ * [41.83, -87.62],
+ * [32.76, -96.72]]
+ * ];
+ * ```
+ */
+
+L.Polyline = L.Path.extend({
+
+ // @section
+ // @aka Polyline options
+ options: {
+ // @option smoothFactor: Number = 1.0
+ // How much to simplify the polyline on each zoom level. More means
+ // better performance and smoother look, and less means more accurate representation.
+ smoothFactor: 1.0,
+
+ // @option noClip: Boolean = false
+ // Disable polyline clipping.
+ noClip: false
+ },
+
+ initialize: function (latlngs, options) {
+ L.setOptions(this, options);
+ this._setLatLngs(latlngs);
+ },
+
+ // @method getLatLngs(): LatLng[]
+ // Returns an array of the points in the path, or nested arrays of points in case of multi-polyline.
+ getLatLngs: function () {
+ return this._latlngs;
+ },
+
+ // @method setLatLngs(latlngs: LatLng[]): this
+ // Replaces all the points in the polyline with the given array of geographical points.
+ setLatLngs: function (latlngs) {
+ this._setLatLngs(latlngs);
+ return this.redraw();
+ },
+
+ // @method isEmpty(): Boolean
+ // Returns `true` if the Polyline has no LatLngs.
+ isEmpty: function () {
+ return !this._latlngs.length;
+ },
+
+ closestLayerPoint: function (p) {
+ var minDistance = Infinity,
+ minPoint = null,
+ closest = L.LineUtil._sqClosestPointOnSegment,
+ p1, p2;
+
+ for (var j = 0, jLen = this._parts.length; j < jLen; j++) {
+ var points = this._parts[j];
+
+ for (var i = 1, len = points.length; i < len; i++) {
+ p1 = points[i - 1];
+ p2 = points[i];
+
+ var sqDist = closest(p, p1, p2, true);
+
+ if (sqDist < minDistance) {
+ minDistance = sqDist;
+ minPoint = closest(p, p1, p2);
+ }
+ }
+ }
+ if (minPoint) {
+ minPoint.distance = Math.sqrt(minDistance);
+ }
+ return minPoint;
+ },
+
+ // @method getCenter(): LatLng
+ // Returns the center ([centroid](http://en.wikipedia.org/wiki/Centroid)) of the polyline.
+ getCenter: function () {
+ // throws error when not yet added to map as this center calculation requires projected coordinates
+ if (!this._map) {
+ throw new Error('Must add layer to map before using getCenter()');
+ }
+
+ var i, halfDist, segDist, dist, p1, p2, ratio,
+ points = this._rings[0],
+ len = points.length;
+
+ if (!len) { return null; }
+
+ // polyline centroid algorithm; only uses the first ring if there are multiple
+
+ for (i = 0, halfDist = 0; i < len - 1; i++) {
+ halfDist += points[i].distanceTo(points[i + 1]) / 2;
+ }
+
+ // The line is so small in the current view that all points are on the same pixel.
+ if (halfDist === 0) {
+ return this._map.layerPointToLatLng(points[0]);
+ }
+
+ for (i = 0, dist = 0; i < len - 1; i++) {
+ p1 = points[i];
+ p2 = points[i + 1];
+ segDist = p1.distanceTo(p2);
+ dist += segDist;
+
+ if (dist > halfDist) {
+ ratio = (dist - halfDist) / segDist;
+ return this._map.layerPointToLatLng([
+ p2.x - ratio * (p2.x - p1.x),
+ p2.y - ratio * (p2.y - p1.y)
+ ]);
+ }
+ }
+ },
+
+ // @method getBounds(): LatLngBounds
+ // Returns the `LatLngBounds` of the path.
+ getBounds: function () {
+ return this._bounds;
+ },
+
+ // @method addLatLng(latlng: LatLng, latlngs? LatLng[]): this
+ // Adds a given point to the polyline. By default, adds to the first ring of
+ // the polyline in case of a multi-polyline, but can be overridden by passing
+ // a specific ring as a LatLng array (that you can earlier access with [`getLatLngs`](#polyline-getlatlngs)).
+ addLatLng: function (latlng, latlngs) {
+ latlngs = latlngs || this._defaultShape();
+ latlng = L.latLng(latlng);
+ latlngs.push(latlng);
+ this._bounds.extend(latlng);
+ return this.redraw();
+ },
+
+ _setLatLngs: function (latlngs) {
+ this._bounds = new L.LatLngBounds();
+ this._latlngs = this._convertLatLngs(latlngs);
+ },
+
+ _defaultShape: function () {
+ return L.Polyline._flat(this._latlngs) ? this._latlngs : this._latlngs[0];
+ },
+
+ // recursively convert latlngs input into actual LatLng instances; calculate bounds along the way
+ _convertLatLngs: function (latlngs) {
+ var result = [],
+ flat = L.Polyline._flat(latlngs);
+
+ for (var i = 0, len = latlngs.length; i < len; i++) {
+ if (flat) {
+ result[i] = L.latLng(latlngs[i]);
+ this._bounds.extend(result[i]);
+ } else {
+ result[i] = this._convertLatLngs(latlngs[i]);
+ }
+ }
+
+ return result;
+ },
+
+ _project: function () {
+ var pxBounds = new L.Bounds();
+ this._rings = [];
+ this._projectLatlngs(this._latlngs, this._rings, pxBounds);
+
+ var w = this._clickTolerance(),
+ p = new L.Point(w, w);
+
+ if (this._bounds.isValid() && pxBounds.isValid()) {
+ pxBounds.min._subtract(p);
+ pxBounds.max._add(p);
+ this._pxBounds = pxBounds;
+ }
+ },
+
+ // recursively turns latlngs into a set of rings with projected coordinates
+ _projectLatlngs: function (latlngs, result, projectedBounds) {
+ var flat = latlngs[0] instanceof L.LatLng,
+ len = latlngs.length,
+ i, ring;
+
+ if (flat) {
+ ring = [];
+ for (i = 0; i < len; i++) {
+ ring[i] = this._map.latLngToLayerPoint(latlngs[i]);
+ projectedBounds.extend(ring[i]);
+ }
+ result.push(ring);
+ } else {
+ for (i = 0; i < len; i++) {
+ this._projectLatlngs(latlngs[i], result, projectedBounds);
+ }
+ }
+ },
+
+ // clip polyline by renderer bounds so that we have less to render for performance
+ _clipPoints: function () {
+ var bounds = this._renderer._bounds;
+
+ this._parts = [];
+ if (!this._pxBounds || !this._pxBounds.intersects(bounds)) {
+ return;
+ }
+
+ if (this.options.noClip) {
+ this._parts = this._rings;
+ return;
+ }
+
+ var parts = this._parts,
+ i, j, k, len, len2, segment, points;
+
+ for (i = 0, k = 0, len = this._rings.length; i < len; i++) {
+ points = this._rings[i];
+
+ for (j = 0, len2 = points.length; j < len2 - 1; j++) {
+ segment = L.LineUtil.clipSegment(points[j], points[j + 1], bounds, j, true);
+
+ if (!segment) { continue; }
+
+ parts[k] = parts[k] || [];
+ parts[k].push(segment[0]);
+
+ // if segment goes out of screen, or it's the last one, it's the end of the line part
+ if ((segment[1] !== points[j + 1]) || (j === len2 - 2)) {
+ parts[k].push(segment[1]);
+ k++;
+ }
+ }
+ }
+ },
+
+ // simplify each clipped part of the polyline for performance
+ _simplifyPoints: function () {
+ var parts = this._parts,
+ tolerance = this.options.smoothFactor;
+
+ for (var i = 0, len = parts.length; i < len; i++) {
+ parts[i] = L.LineUtil.simplify(parts[i], tolerance);
+ }
+ },
+
+ _update: function () {
+ if (!this._map) { return; }
+
+ this._clipPoints();
+ this._simplifyPoints();
+ this._updatePath();
+ },
+
+ _updatePath: function () {
+ this._renderer._updatePoly(this);
+ }
+});
+
+// @factory L.polyline(latlngs: LatLng[], options?: Polyline options)
+// Instantiates a polyline object given an array of geographical points and
+// optionally an options object. You can create a `Polyline` object with
+// multiple separate lines (`MultiPolyline`) by passing an array of arrays
+// of geographic points.
+L.polyline = function (latlngs, options) {
+ return new L.Polyline(latlngs, options);
+};
+
+L.Polyline._flat = function (latlngs) {
+ // true if it's a flat array of latlngs; false if nested
+ return !L.Util.isArray(latlngs[0]) || (typeof latlngs[0][0] !== 'object' && typeof latlngs[0][0] !== 'undefined');
+};
+
+
+
+/*
+ * @namespace PolyUtil
+ * Various utility functions for polygon geometries.
+ */
+
+L.PolyUtil = {};
+
+/* @function clipPolygon(points: Point[], bounds: Bounds, round?: Boolean): Point[]
+ * Clips the polygon geometry defined by the given `points` by the given bounds (using the [Sutherland-Hodgeman algorithm](https://en.wikipedia.org/wiki/Sutherland%E2%80%93Hodgman_algorithm)).
+ * Used by Leaflet to only show polygon points that are on the screen or near, increasing
+ * performance. Note that polygon points needs different algorithm for clipping
+ * than polyline, so there's a seperate method for it.
+ */
+L.PolyUtil.clipPolygon = function (points, bounds, round) {
+ var clippedPoints,
+ edges = [1, 4, 2, 8],
+ i, j, k,
+ a, b,
+ len, edge, p,
+ lu = L.LineUtil;
+
+ for (i = 0, len = points.length; i < len; i++) {
+ points[i]._code = lu._getBitCode(points[i], bounds);
+ }
+
+ // for each edge (left, bottom, right, top)
+ for (k = 0; k < 4; k++) {
+ edge = edges[k];
+ clippedPoints = [];
+
+ for (i = 0, len = points.length, j = len - 1; i < len; j = i++) {
+ a = points[i];
+ b = points[j];
+
+ // if a is inside the clip window
+ if (!(a._code & edge)) {
+ // if b is outside the clip window (a->b goes out of screen)
+ if (b._code & edge) {
+ p = lu._getEdgeIntersection(b, a, edge, bounds, round);
+ p._code = lu._getBitCode(p, bounds);
+ clippedPoints.push(p);
+ }
+ clippedPoints.push(a);
+
+ // else if b is inside the clip window (a->b enters the screen)
+ } else if (!(b._code & edge)) {
+ p = lu._getEdgeIntersection(b, a, edge, bounds, round);
+ p._code = lu._getBitCode(p, bounds);
+ clippedPoints.push(p);
+ }
+ }
+ points = clippedPoints;
+ }
+
+ return points;
+};
+
+
+
+/*
+ * @class Polygon
+ * @aka L.Polygon
+ * @inherits Polyline
+ *
+ * A class for drawing polygon overlays on a map. Extends `Polyline`.
+ *
+ * Note that points you pass when creating a polygon shouldn't have an additional last point equal to the first one — it's better to filter out such points.
+ *
+ *
+ * @example
+ *
+ * ```js
+ * // create a red polygon from an array of LatLng points
+ * var latlngs = [[37, -109.05],[41, -109.03],[41, -102.05],[37, -102.04]];
+ *
+ * var polygon = L.polygon(latlngs, {color: 'red'}).addTo(map);
+ *
+ * // zoom the map to the polygon
+ * map.fitBounds(polygon.getBounds());
+ * ```
+ *
+ * You can also pass an array of arrays of latlngs, with the first array representing the outer shape and the other arrays representing holes in the outer shape:
+ *
+ * ```js
+ * var latlngs = [
+ * [[37, -109.05],[41, -109.03],[41, -102.05],[37, -102.04]], // outer ring
+ * [[37.29, -108.58],[40.71, -108.58],[40.71, -102.50],[37.29, -102.50]] // hole
+ * ];
+ * ```
+ *
+ * Additionally, you can pass a multi-dimensional array to represent a MultiPolygon shape.
+ *
+ * ```js
+ * var latlngs = [
+ * [ // first polygon
+ * [[37, -109.05],[41, -109.03],[41, -102.05],[37, -102.04]], // outer ring
+ * [[37.29, -108.58],[40.71, -108.58],[40.71, -102.50],[37.29, -102.50]] // hole
+ * ],
+ * [ // second polygon
+ * [[41, -111.03],[45, -111.04],[45, -104.05],[41, -104.05]]
+ * ]
+ * ];
+ * ```
+ */
+
+L.Polygon = L.Polyline.extend({
+
+ options: {
+ fill: true
+ },
+
+ isEmpty: function () {
+ return !this._latlngs.length || !this._latlngs[0].length;
+ },
+
+ getCenter: function () {
+ // throws error when not yet added to map as this center calculation requires projected coordinates
+ if (!this._map) {
+ throw new Error('Must add layer to map before using getCenter()');
+ }
+
+ var i, j, p1, p2, f, area, x, y, center,
+ points = this._rings[0],
+ len = points.length;
+
+ if (!len) { return null; }
+
+ // polygon centroid algorithm; only uses the first ring if there are multiple
+
+ area = x = y = 0;
+
+ for (i = 0, j = len - 1; i < len; j = i++) {
+ p1 = points[i];
+ p2 = points[j];
+
+ f = p1.y * p2.x - p2.y * p1.x;
+ x += (p1.x + p2.x) * f;
+ y += (p1.y + p2.y) * f;
+ area += f * 3;
+ }
+
+ if (area === 0) {
+ // Polygon is so small that all points are on same pixel.
+ center = points[0];
+ } else {
+ center = [x / area, y / area];
+ }
+ return this._map.layerPointToLatLng(center);
+ },
+
+ _convertLatLngs: function (latlngs) {
+ var result = L.Polyline.prototype._convertLatLngs.call(this, latlngs),
+ len = result.length;
+
+ // remove last point if it equals first one
+ if (len >= 2 && result[0] instanceof L.LatLng && result[0].equals(result[len - 1])) {
+ result.pop();
+ }
+ return result;
+ },
+
+ _setLatLngs: function (latlngs) {
+ L.Polyline.prototype._setLatLngs.call(this, latlngs);
+ if (L.Polyline._flat(this._latlngs)) {
+ this._latlngs = [this._latlngs];
+ }
+ },
+
+ _defaultShape: function () {
+ return L.Polyline._flat(this._latlngs[0]) ? this._latlngs[0] : this._latlngs[0][0];
+ },
+
+ _clipPoints: function () {
+ // polygons need a different clipping algorithm so we redefine that
+
+ var bounds = this._renderer._bounds,
+ w = this.options.weight,
+ p = new L.Point(w, w);
+
+ // increase clip padding by stroke width to avoid stroke on clip edges
+ bounds = new L.Bounds(bounds.min.subtract(p), bounds.max.add(p));
+
+ this._parts = [];
+ if (!this._pxBounds || !this._pxBounds.intersects(bounds)) {
+ return;
+ }
+
+ if (this.options.noClip) {
+ this._parts = this._rings;
+ return;
+ }
+
+ for (var i = 0, len = this._rings.length, clipped; i < len; i++) {
+ clipped = L.PolyUtil.clipPolygon(this._rings[i], bounds, true);
+ if (clipped.length) {
+ this._parts.push(clipped);
+ }
+ }
+ },
+
+ _updatePath: function () {
+ this._renderer._updatePoly(this, true);
+ }
+});
+
+
+// @factory L.polygon(latlngs: LatLng[], options?: Polyline options)
+L.polygon = function (latlngs, options) {
+ return new L.Polygon(latlngs, options);
+};
+
+
+
+/*
+ * L.Rectangle extends Polygon and creates a rectangle when passed a LatLngBounds object.
+ */
+
+/*
+ * @class Rectangle
+ * @aka L.Retangle
+ * @inherits Polygon
+ *
+ * A class for drawing rectangle overlays on a map. Extends `Polygon`.
+ *
+ * @example
+ *
+ * ```js
+ * // define rectangle geographical bounds
+ * var bounds = [[54.559322, -5.767822], [56.1210604, -3.021240]];
+ *
+ * // create an orange rectangle
+ * L.rectangle(bounds, {color: "#ff7800", weight: 1}).addTo(map);
+ *
+ * // zoom the map to the rectangle bounds
+ * map.fitBounds(bounds);
+ * ```
+ *
+ */
+
+
+L.Rectangle = L.Polygon.extend({
+ initialize: function (latLngBounds, options) {
+ L.Polygon.prototype.initialize.call(this, this._boundsToLatLngs(latLngBounds), options);
+ },
+
+ // @method setBounds(latLngBounds: LatLngBounds): this
+ // Redraws the rectangle with the passed bounds.
+ setBounds: function (latLngBounds) {
+ return this.setLatLngs(this._boundsToLatLngs(latLngBounds));
+ },
+
+ _boundsToLatLngs: function (latLngBounds) {
+ latLngBounds = L.latLngBounds(latLngBounds);
+ return [
+ latLngBounds.getSouthWest(),
+ latLngBounds.getNorthWest(),
+ latLngBounds.getNorthEast(),
+ latLngBounds.getSouthEast()
+ ];
+ }
+});
+
+
+// @factory L.rectangle(latLngBounds: LatLngBounds, options?: Polyline options)
+L.rectangle = function (latLngBounds, options) {
+ return new L.Rectangle(latLngBounds, options);
+};
+
+
+
+/*
+ * @class CircleMarker
+ * @aka L.CircleMarker
+ * @inherits Path
+ *
+ * A circle of a fixed size with radius specified in pixels. Extends `Path`.
+ */
+
+L.CircleMarker = L.Path.extend({
+
+ // @section
+ // @aka CircleMarker options
+ options: {
+ fill: true,
+
+ // @option radius: Number = 10
+ // Radius of the circle marker, in pixels
+ radius: 10
+ },
+
+ initialize: function (latlng, options) {
+ L.setOptions(this, options);
+ this._latlng = L.latLng(latlng);
+ this._radius = this.options.radius;
+ },
+
+ // @method setLatLng(latLng: LatLng): this
+ // Sets the position of a circle marker to a new location.
+ setLatLng: function (latlng) {
+ this._latlng = L.latLng(latlng);
+ this.redraw();
+ return this.fire('move', {latlng: this._latlng});
+ },
+
+ // @method getLatLng(): LatLng
+ // Returns the current geographical position of the circle marker
+ getLatLng: function () {
+ return this._latlng;
+ },
+
+ // @method setRadius(radius: Number): this
+ // Sets the radius of a circle marker. Units are in pixels.
+ setRadius: function (radius) {
+ this.options.radius = this._radius = radius;
+ return this.redraw();
+ },
+
+ // @method getRadius(): Number
+ // Returns the current radius of the circle
+ getRadius: function () {
+ return this._radius;
+ },
+
+ setStyle : function (options) {
+ var radius = options && options.radius || this._radius;
+ L.Path.prototype.setStyle.call(this, options);
+ this.setRadius(radius);
+ return this;
+ },
+
+ _project: function () {
+ this._point = this._map.latLngToLayerPoint(this._latlng);
+ this._updateBounds();
+ },
+
+ _updateBounds: function () {
+ var r = this._radius,
+ r2 = this._radiusY || r,
+ w = this._clickTolerance(),
+ p = [r + w, r2 + w];
+ this._pxBounds = new L.Bounds(this._point.subtract(p), this._point.add(p));
+ },
+
+ _update: function () {
+ if (this._map) {
+ this._updatePath();
+ }
+ },
+
+ _updatePath: function () {
+ this._renderer._updateCircle(this);
+ },
+
+ _empty: function () {
+ return this._radius && !this._renderer._bounds.intersects(this._pxBounds);
+ }
+});
+
+
+// @factory L.circleMarker(latlng: LatLng, options?: CircleMarker options)
+// Instantiates a circle marker object given a geographical point, and an optional options object.
+L.circleMarker = function (latlng, options) {
+ return new L.CircleMarker(latlng, options);
+};
+
+
+
+/*
+ * @class Circle
+ * @aka L.Circle
+ * @inherits CircleMarker
+ *
+ * A class for drawing circle overlays on a map. Extends `CircleMarker`.
+ *
+ * It's an approximation and starts to diverge from a real circle closer to poles (due to projection distortion).
+ *
+ * @example
+ *
+ * ```js
+ * L.circle([50.5, 30.5], {radius: 200}).addTo(map);
+ * ```
+ */
+
+L.Circle = L.CircleMarker.extend({
+
+ initialize: function (latlng, options, legacyOptions) {
+ if (typeof options === 'number') {
+ // Backwards compatibility with 0.7.x factory (latlng, radius, options?)
+ options = L.extend({}, legacyOptions, {radius: options});
+ }
+ L.setOptions(this, options);
+ this._latlng = L.latLng(latlng);
+
+ if (isNaN(this.options.radius)) { throw new Error('Circle radius cannot be NaN'); }
+
+ // @section
+ // @aka Circle options
+ // @option radius: Number; Radius of the circle, in meters.
+ this._mRadius = this.options.radius;
+ },
+
+ // @method setRadius(radius: Number): this
+ // Sets the radius of a circle. Units are in meters.
+ setRadius: function (radius) {
+ this._mRadius = radius;
+ return this.redraw();
+ },
+
+ // @method getRadius(): Number
+ // Returns the current radius of a circle. Units are in meters.
+ getRadius: function () {
+ return this._mRadius;
+ },
+
+ // @method getBounds(): LatLngBounds
+ // Returns the `LatLngBounds` of the path.
+ getBounds: function () {
+ var half = [this._radius, this._radiusY || this._radius];
+
+ return new L.LatLngBounds(
+ this._map.layerPointToLatLng(this._point.subtract(half)),
+ this._map.layerPointToLatLng(this._point.add(half)));
+ },
+
+ setStyle: L.Path.prototype.setStyle,
+
+ _project: function () {
+
+ var lng = this._latlng.lng,
+ lat = this._latlng.lat,
+ map = this._map,
+ crs = map.options.crs;
+
+ if (crs.distance === L.CRS.Earth.distance) {
+ var d = Math.PI / 180,
+ latR = (this._mRadius / L.CRS.Earth.R) / d,
+ top = map.project([lat + latR, lng]),
+ bottom = map.project([lat - latR, lng]),
+ p = top.add(bottom).divideBy(2),
+ lat2 = map.unproject(p).lat,
+ lngR = Math.acos((Math.cos(latR * d) - Math.sin(lat * d) * Math.sin(lat2 * d)) /
+ (Math.cos(lat * d) * Math.cos(lat2 * d))) / d;
+
+ if (isNaN(lngR) || lngR === 0) {
+ lngR = latR / Math.cos(Math.PI / 180 * lat); // Fallback for edge case, #2425
+ }
+
+ this._point = p.subtract(map.getPixelOrigin());
+ this._radius = isNaN(lngR) ? 0 : Math.max(Math.round(p.x - map.project([lat2, lng - lngR]).x), 1);
+ this._radiusY = Math.max(Math.round(p.y - top.y), 1);
+
+ } else {
+ var latlng2 = crs.unproject(crs.project(this._latlng).subtract([this._mRadius, 0]));
+
+ this._point = map.latLngToLayerPoint(this._latlng);
+ this._radius = this._point.x - map.latLngToLayerPoint(latlng2).x;
+ }
+
+ this._updateBounds();
+ }
+});
+
+// @factory L.circle(latlng: LatLng, options?: Circle options)
+// Instantiates a circle object given a geographical point, and an options object
+// which contains the circle radius.
+// @alternative
+// @factory L.circle(latlng: LatLng, radius: Number, options?: Circle options)
+// Obsolete way of instantiating a circle, for compatibility with 0.7.x code.
+// Do not use in new applications or plugins.
+L.circle = function (latlng, options, legacyOptions) {
+ return new L.Circle(latlng, options, legacyOptions);
+};
+
+
+
+/*
+ * @class SVG
+ * @inherits Renderer
+ * @aka L.SVG
+ *
+ * Allows vector layers to be displayed with [SVG](https://developer.mozilla.org/docs/Web/SVG).
+ * Inherits `Renderer`.
+ *
+ * Due to [technical limitations](http://caniuse.com/#search=svg), SVG is not
+ * available in all web browsers, notably Android 2.x and 3.x.
+ *
+ * Although SVG is not available on IE7 and IE8, these browsers support
+ * [VML](https://en.wikipedia.org/wiki/Vector_Markup_Language)
+ * (a now deprecated technology), and the SVG renderer will fall back to VML in
+ * this case.
+ *
+ * @example
+ *
+ * Use SVG by default for all paths in the map:
+ *
+ * ```js
+ * var map = L.map('map', {
+ * renderer: L.svg()
+ * });
+ * ```
+ *
+ * Use a SVG renderer with extra padding for specific vector geometries:
+ *
+ * ```js
+ * var map = L.map('map');
+ * var myRenderer = L.svg({ padding: 0.5 });
+ * var line = L.polyline( coordinates, { renderer: myRenderer } );
+ * var circle = L.circle( center, { renderer: myRenderer } );
+ * ```
+ */
+
+L.SVG = L.Renderer.extend({
+
+ getEvents: function () {
+ var events = L.Renderer.prototype.getEvents.call(this);
+ events.zoomstart = this._onZoomStart;
+ return events;
+ },
+
+ _initContainer: function () {
+ this._container = L.SVG.create('svg');
+
+ // makes it possible to click through svg root; we'll reset it back in individual paths
+ this._container.setAttribute('pointer-events', 'none');
+
+ this._rootGroup = L.SVG.create('g');
+ this._container.appendChild(this._rootGroup);
+ },
+
+ _onZoomStart: function () {
+ // Drag-then-pinch interactions might mess up the center and zoom.
+ // In this case, the easiest way to prevent this is re-do the renderer
+ // bounds and padding when the zooming starts.
+ this._update();
+ },
+
+ _update: function () {
+ if (this._map._animatingZoom && this._bounds) { return; }
+
+ L.Renderer.prototype._update.call(this);
+
+ var b = this._bounds,
+ size = b.getSize(),
+ container = this._container;
+
+ // set size of svg-container if changed
+ if (!this._svgSize || !this._svgSize.equals(size)) {
+ this._svgSize = size;
+ container.setAttribute('width', size.x);
+ container.setAttribute('height', size.y);
+ }
+
+ // movement: update container viewBox so that we don't have to change coordinates of individual layers
+ L.DomUtil.setPosition(container, b.min);
+ container.setAttribute('viewBox', [b.min.x, b.min.y, size.x, size.y].join(' '));
+
+ this.fire('update');
+ },
+
+ // methods below are called by vector layers implementations
+
+ _initPath: function (layer) {
+ var path = layer._path = L.SVG.create('path');
+
+ // @namespace Path
+ // @option className: String = null
+ // Custom class name set on an element. Only for SVG renderer.
+ if (layer.options.className) {
+ L.DomUtil.addClass(path, layer.options.className);
+ }
+
+ if (layer.options.interactive) {
+ L.DomUtil.addClass(path, 'leaflet-interactive');
+ }
+
+ this._updateStyle(layer);
+ this._layers[L.stamp(layer)] = layer;
+ },
+
+ _addPath: function (layer) {
+ this._rootGroup.appendChild(layer._path);
+ layer.addInteractiveTarget(layer._path);
+ },
+
+ _removePath: function (layer) {
+ L.DomUtil.remove(layer._path);
+ layer.removeInteractiveTarget(layer._path);
+ delete this._layers[L.stamp(layer)];
+ },
+
+ _updatePath: function (layer) {
+ layer._project();
+ layer._update();
+ },
+
+ _updateStyle: function (layer) {
+ var path = layer._path,
+ options = layer.options;
+
+ if (!path) { return; }
+
+ if (options.stroke) {
+ path.setAttribute('stroke', options.color);
+ path.setAttribute('stroke-opacity', options.opacity);
+ path.setAttribute('stroke-width', options.weight);
+ path.setAttribute('stroke-linecap', options.lineCap);
+ path.setAttribute('stroke-linejoin', options.lineJoin);
+
+ if (options.dashArray) {
+ path.setAttribute('stroke-dasharray', options.dashArray);
+ } else {
+ path.removeAttribute('stroke-dasharray');
+ }
+
+ if (options.dashOffset) {
+ path.setAttribute('stroke-dashoffset', options.dashOffset);
+ } else {
+ path.removeAttribute('stroke-dashoffset');
+ }
+ } else {
+ path.setAttribute('stroke', 'none');
+ }
+
+ if (options.fill) {
+ path.setAttribute('fill', options.fillColor || options.color);
+ path.setAttribute('fill-opacity', options.fillOpacity);
+ path.setAttribute('fill-rule', options.fillRule || 'evenodd');
+ } else {
+ path.setAttribute('fill', 'none');
+ }
+ },
+
+ _updatePoly: function (layer, closed) {
+ this._setPath(layer, L.SVG.pointsToPath(layer._parts, closed));
+ },
+
+ _updateCircle: function (layer) {
+ var p = layer._point,
+ r = layer._radius,
+ r2 = layer._radiusY || r,
+ arc = 'a' + r + ',' + r2 + ' 0 1,0 ';
+
+ // drawing a circle with two half-arcs
+ var d = layer._empty() ? 'M0 0' :
+ 'M' + (p.x - r) + ',' + p.y +
+ arc + (r * 2) + ',0 ' +
+ arc + (-r * 2) + ',0 ';
+
+ this._setPath(layer, d);
+ },
+
+ _setPath: function (layer, path) {
+ layer._path.setAttribute('d', path);
+ },
+
+ // SVG does not have the concept of zIndex so we resort to changing the DOM order of elements
+ _bringToFront: function (layer) {
+ L.DomUtil.toFront(layer._path);
+ },
+
+ _bringToBack: function (layer) {
+ L.DomUtil.toBack(layer._path);
+ }
+});
+
+
+// @namespace SVG; @section
+// There are several static functions which can be called without instantiating L.SVG:
+L.extend(L.SVG, {
+ // @function create(name: String): SVGElement
+ // Returns a instance of [SVGElement](https://developer.mozilla.org/docs/Web/API/SVGElement),
+ // corresponding to the class name passed. For example, using 'line' will return
+ // an instance of [SVGLineElement](https://developer.mozilla.org/docs/Web/API/SVGLineElement).
+ create: function (name) {
+ return document.createElementNS('http://www.w3.org/2000/svg', name);
+ },
+
+ // @function pointsToPath(rings: Point[], closed: Boolean): String
+ // Generates a SVG path string for multiple rings, with each ring turning
+ // into "M..L..L.." instructions
+ pointsToPath: function (rings, closed) {
+ var str = '',
+ i, j, len, len2, points, p;
+
+ for (i = 0, len = rings.length; i < len; i++) {
+ points = rings[i];
+
+ for (j = 0, len2 = points.length; j < len2; j++) {
+ p = points[j];
+ str += (j ? 'L' : 'M') + p.x + ' ' + p.y;
+ }
+
+ // closes the ring for polygons; "x" is VML syntax
+ str += closed ? (L.Browser.svg ? 'z' : 'x') : '';
+ }
+
+ // SVG complains about empty path strings
+ return str || 'M0 0';
+ }
+});
+
+// @namespace Browser; @property svg: Boolean
+// `true` when the browser supports [SVG](https://developer.mozilla.org/docs/Web/SVG).
+L.Browser.svg = !!(document.createElementNS && L.SVG.create('svg').createSVGRect);
+
+
+// @namespace SVG
+// @factory L.svg(options?: Renderer options)
+// Creates a SVG renderer with the given options.
+L.svg = function (options) {
+ return L.Browser.svg || L.Browser.vml ? new L.SVG(options) : null;
+};
+
+
+
+/*
+ * Thanks to Dmitry Baranovsky and his Raphael library for inspiration!
+ */
+
+/*
+ * @class SVG
+ *
+ * Although SVG is not available on IE7 and IE8, these browsers support [VML](https://en.wikipedia.org/wiki/Vector_Markup_Language), and the SVG renderer will fall back to VML in this case.
+ *
+ * VML was deprecated in 2012, which means VML functionality exists only for backwards compatibility
+ * with old versions of Internet Explorer.
+ */
+
+// @namespace Browser; @property vml: Boolean
+// `true` if the browser supports [VML](https://en.wikipedia.org/wiki/Vector_Markup_Language).
+L.Browser.vml = !L.Browser.svg && (function () {
+ try {
+ var div = document.createElement('div');
+ div.innerHTML = '
';
+
+ var shape = div.firstChild;
+ shape.style.behavior = 'url(#default#VML)';
+
+ return shape && (typeof shape.adj === 'object');
+
+ } catch (e) {
+ return false;
+ }
+}());
+
+// redefine some SVG methods to handle VML syntax which is similar but with some differences
+L.SVG.include(!L.Browser.vml ? {} : {
+
+ _initContainer: function () {
+ this._container = L.DomUtil.create('div', 'leaflet-vml-container');
+ },
+
+ _update: function () {
+ if (this._map._animatingZoom) { return; }
+ L.Renderer.prototype._update.call(this);
+ this.fire('update');
+ },
+
+ _initPath: function (layer) {
+ var container = layer._container = L.SVG.create('shape');
+
+ L.DomUtil.addClass(container, 'leaflet-vml-shape ' + (this.options.className || ''));
+
+ container.coordsize = '1 1';
+
+ layer._path = L.SVG.create('path');
+ container.appendChild(layer._path);
+
+ this._updateStyle(layer);
+ this._layers[L.stamp(layer)] = layer;
+ },
+
+ _addPath: function (layer) {
+ var container = layer._container;
+ this._container.appendChild(container);
+
+ if (layer.options.interactive) {
+ layer.addInteractiveTarget(container);
+ }
+ },
+
+ _removePath: function (layer) {
+ var container = layer._container;
+ L.DomUtil.remove(container);
+ layer.removeInteractiveTarget(container);
+ delete this._layers[L.stamp(layer)];
+ },
+
+ _updateStyle: function (layer) {
+ var stroke = layer._stroke,
+ fill = layer._fill,
+ options = layer.options,
+ container = layer._container;
+
+ container.stroked = !!options.stroke;
+ container.filled = !!options.fill;
+
+ if (options.stroke) {
+ if (!stroke) {
+ stroke = layer._stroke = L.SVG.create('stroke');
+ }
+ container.appendChild(stroke);
+ stroke.weight = options.weight + 'px';
+ stroke.color = options.color;
+ stroke.opacity = options.opacity;
+
+ if (options.dashArray) {
+ stroke.dashStyle = L.Util.isArray(options.dashArray) ?
+ options.dashArray.join(' ') :
+ options.dashArray.replace(/( *, *)/g, ' ');
+ } else {
+ stroke.dashStyle = '';
+ }
+ stroke.endcap = options.lineCap.replace('butt', 'flat');
+ stroke.joinstyle = options.lineJoin;
+
+ } else if (stroke) {
+ container.removeChild(stroke);
+ layer._stroke = null;
+ }
+
+ if (options.fill) {
+ if (!fill) {
+ fill = layer._fill = L.SVG.create('fill');
+ }
+ container.appendChild(fill);
+ fill.color = options.fillColor || options.color;
+ fill.opacity = options.fillOpacity;
+
+ } else if (fill) {
+ container.removeChild(fill);
+ layer._fill = null;
+ }
+ },
+
+ _updateCircle: function (layer) {
+ var p = layer._point.round(),
+ r = Math.round(layer._radius),
+ r2 = Math.round(layer._radiusY || r);
+
+ this._setPath(layer, layer._empty() ? 'M0 0' :
+ 'AL ' + p.x + ',' + p.y + ' ' + r + ',' + r2 + ' 0,' + (65535 * 360));
+ },
+
+ _setPath: function (layer, path) {
+ layer._path.v = path;
+ },
+
+ _bringToFront: function (layer) {
+ L.DomUtil.toFront(layer._container);
+ },
+
+ _bringToBack: function (layer) {
+ L.DomUtil.toBack(layer._container);
+ }
+});
+
+if (L.Browser.vml) {
+ L.SVG.create = (function () {
+ try {
+ document.namespaces.add('lvml', 'urn:schemas-microsoft-com:vml');
+ return function (name) {
+ return document.createElement('
');
+ };
+ } catch (e) {
+ return function (name) {
+ return document.createElement('<' + name + ' xmlns="urn:schemas-microsoft.com:vml" class="lvml">');
+ };
+ }
+ })();
+}
+
+
+
+/*
+ * @class Canvas
+ * @inherits Renderer
+ * @aka L.Canvas
+ *
+ * Allows vector layers to be displayed with [``](https://developer.mozilla.org/docs/Web/API/Canvas_API).
+ * Inherits `Renderer`.
+ *
+ * Due to [technical limitations](http://caniuse.com/#search=canvas), Canvas is not
+ * available in all web browsers, notably IE8, and overlapping geometries might
+ * not display properly in some edge cases.
+ *
+ * @example
+ *
+ * Use Canvas by default for all paths in the map:
+ *
+ * ```js
+ * var map = L.map('map', {
+ * renderer: L.canvas()
+ * });
+ * ```
+ *
+ * Use a Canvas renderer with extra padding for specific vector geometries:
+ *
+ * ```js
+ * var map = L.map('map');
+ * var myRenderer = L.canvas({ padding: 0.5 });
+ * var line = L.polyline( coordinates, { renderer: myRenderer } );
+ * var circle = L.circle( center, { renderer: myRenderer } );
+ * ```
+ */
+
+L.Canvas = L.Renderer.extend({
+ getEvents: function () {
+ var events = L.Renderer.prototype.getEvents.call(this);
+ events.viewprereset = this._onViewPreReset;
+ return events;
+ },
+
+ _onViewPreReset: function () {
+ // Set a flag so that a viewprereset+moveend+viewreset only updates&redraws once
+ this._postponeUpdatePaths = true;
+ },
+
+ onAdd: function () {
+ L.Renderer.prototype.onAdd.call(this);
+
+ // Redraw vectors since canvas is cleared upon removal,
+ // in case of removing the renderer itself from the map.
+ this._draw();
+ },
+
+ _initContainer: function () {
+ var container = this._container = document.createElement('canvas');
+
+ L.DomEvent
+ .on(container, 'mousemove', L.Util.throttle(this._onMouseMove, 32, this), this)
+ .on(container, 'click dblclick mousedown mouseup contextmenu', this._onClick, this)
+ .on(container, 'mouseout', this._handleMouseOut, this);
+
+ this._ctx = container.getContext('2d');
+ },
+
+ _updatePaths: function () {
+ if (this._postponeUpdatePaths) { return; }
+
+ var layer;
+ this._redrawBounds = null;
+ for (var id in this._layers) {
+ layer = this._layers[id];
+ layer._update();
+ }
+ this._redraw();
+ },
+
+ _update: function () {
+ if (this._map._animatingZoom && this._bounds) { return; }
+
+ this._drawnLayers = {};
+
+ L.Renderer.prototype._update.call(this);
+
+ var b = this._bounds,
+ container = this._container,
+ size = b.getSize(),
+ m = L.Browser.retina ? 2 : 1;
+
+ L.DomUtil.setPosition(container, b.min);
+
+ // set canvas size (also clearing it); use double size on retina
+ container.width = m * size.x;
+ container.height = m * size.y;
+ container.style.width = size.x + 'px';
+ container.style.height = size.y + 'px';
+
+ if (L.Browser.retina) {
+ this._ctx.scale(2, 2);
+ }
+
+ // translate so we use the same path coordinates after canvas element moves
+ this._ctx.translate(-b.min.x, -b.min.y);
+
+ // Tell paths to redraw themselves
+ this.fire('update');
+ },
+
+ _reset: function () {
+ L.Renderer.prototype._reset.call(this);
+
+ if (this._postponeUpdatePaths) {
+ this._postponeUpdatePaths = false;
+ this._updatePaths();
+ }
+ },
+
+ _initPath: function (layer) {
+ this._updateDashArray(layer);
+ this._layers[L.stamp(layer)] = layer;
+
+ var order = layer._order = {
+ layer: layer,
+ prev: this._drawLast,
+ next: null
+ };
+ if (this._drawLast) { this._drawLast.next = order; }
+ this._drawLast = order;
+ this._drawFirst = this._drawFirst || this._drawLast;
+ },
+
+ _addPath: function (layer) {
+ this._requestRedraw(layer);
+ },
+
+ _removePath: function (layer) {
+ var order = layer._order;
+ var next = order.next;
+ var prev = order.prev;
+
+ if (next) {
+ next.prev = prev;
+ } else {
+ this._drawLast = prev;
+ }
+ if (prev) {
+ prev.next = next;
+ } else {
+ this._drawFirst = next;
+ }
+
+ delete layer._order;
+
+ delete this._layers[L.stamp(layer)];
+
+ this._requestRedraw(layer);
+ },
+
+ _updatePath: function (layer) {
+ // Redraw the union of the layer's old pixel
+ // bounds and the new pixel bounds.
+ this._extendRedrawBounds(layer);
+ layer._project();
+ layer._update();
+ // The redraw will extend the redraw bounds
+ // with the new pixel bounds.
+ this._requestRedraw(layer);
+ },
+
+ _updateStyle: function (layer) {
+ this._updateDashArray(layer);
+ this._requestRedraw(layer);
+ },
+
+ _updateDashArray: function (layer) {
+ if (layer.options.dashArray) {
+ var parts = layer.options.dashArray.split(','),
+ dashArray = [],
+ i;
+ for (i = 0; i < parts.length; i++) {
+ dashArray.push(Number(parts[i]));
+ }
+ layer.options._dashArray = dashArray;
+ }
+ },
+
+ _requestRedraw: function (layer) {
+ if (!this._map) { return; }
+
+ this._extendRedrawBounds(layer);
+ this._redrawRequest = this._redrawRequest || L.Util.requestAnimFrame(this._redraw, this);
+ },
+
+ _extendRedrawBounds: function (layer) {
+ var padding = (layer.options.weight || 0) + 1;
+ this._redrawBounds = this._redrawBounds || new L.Bounds();
+ this._redrawBounds.extend(layer._pxBounds.min.subtract([padding, padding]));
+ this._redrawBounds.extend(layer._pxBounds.max.add([padding, padding]));
+ },
+
+ _redraw: function () {
+ this._redrawRequest = null;
+
+ if (this._redrawBounds) {
+ this._redrawBounds.min._floor();
+ this._redrawBounds.max._ceil();
+ }
+
+ this._clear(); // clear layers in redraw bounds
+ this._draw(); // draw layers
+
+ this._redrawBounds = null;
+ },
+
+ _clear: function () {
+ var bounds = this._redrawBounds;
+ if (bounds) {
+ var size = bounds.getSize();
+ this._ctx.clearRect(bounds.min.x, bounds.min.y, size.x, size.y);
+ } else {
+ this._ctx.clearRect(0, 0, this._container.width, this._container.height);
+ }
+ },
+
+ _draw: function () {
+ var layer, bounds = this._redrawBounds;
+ this._ctx.save();
+ if (bounds) {
+ var size = bounds.getSize();
+ this._ctx.beginPath();
+ this._ctx.rect(bounds.min.x, bounds.min.y, size.x, size.y);
+ this._ctx.clip();
+ }
+
+ this._drawing = true;
+
+ for (var order = this._drawFirst; order; order = order.next) {
+ layer = order.layer;
+ if (!bounds || (layer._pxBounds && layer._pxBounds.intersects(bounds))) {
+ layer._updatePath();
+ }
+ }
+
+ this._drawing = false;
+
+ this._ctx.restore(); // Restore state before clipping.
+ },
+
+ _updatePoly: function (layer, closed) {
+ if (!this._drawing) { return; }
+
+ var i, j, len2, p,
+ parts = layer._parts,
+ len = parts.length,
+ ctx = this._ctx;
+
+ if (!len) { return; }
+
+ this._drawnLayers[layer._leaflet_id] = layer;
+
+ ctx.beginPath();
+
+ if (ctx.setLineDash) {
+ ctx.setLineDash(layer.options && layer.options._dashArray || []);
+ }
+
+ for (i = 0; i < len; i++) {
+ for (j = 0, len2 = parts[i].length; j < len2; j++) {
+ p = parts[i][j];
+ ctx[j ? 'lineTo' : 'moveTo'](p.x, p.y);
+ }
+ if (closed) {
+ ctx.closePath();
+ }
+ }
+
+ this._fillStroke(ctx, layer);
+
+ // TODO optimization: 1 fill/stroke for all features with equal style instead of 1 for each feature
+ },
+
+ _updateCircle: function (layer) {
+
+ if (!this._drawing || layer._empty()) { return; }
+
+ var p = layer._point,
+ ctx = this._ctx,
+ r = layer._radius,
+ s = (layer._radiusY || r) / r;
+
+ this._drawnLayers[layer._leaflet_id] = layer;
+
+ if (s !== 1) {
+ ctx.save();
+ ctx.scale(1, s);
+ }
+
+ ctx.beginPath();
+ ctx.arc(p.x, p.y / s, r, 0, Math.PI * 2, false);
+
+ if (s !== 1) {
+ ctx.restore();
+ }
+
+ this._fillStroke(ctx, layer);
+ },
+
+ _fillStroke: function (ctx, layer) {
+ var options = layer.options;
+
+ if (options.fill) {
+ ctx.globalAlpha = options.fillOpacity;
+ ctx.fillStyle = options.fillColor || options.color;
+ ctx.fill(options.fillRule || 'evenodd');
+ }
+
+ if (options.stroke && options.weight !== 0) {
+ ctx.globalAlpha = options.opacity;
+ ctx.lineWidth = options.weight;
+ ctx.strokeStyle = options.color;
+ ctx.lineCap = options.lineCap;
+ ctx.lineJoin = options.lineJoin;
+ ctx.stroke();
+ }
+ },
+
+ // Canvas obviously doesn't have mouse events for individual drawn objects,
+ // so we emulate that by calculating what's under the mouse on mousemove/click manually
+
+ _onClick: function (e) {
+ var point = this._map.mouseEventToLayerPoint(e), layer, clickedLayer;
+
+ for (var order = this._drawFirst; order; order = order.next) {
+ layer = order.layer;
+ if (layer.options.interactive && layer._containsPoint(point) && !this._map._draggableMoved(layer)) {
+ clickedLayer = layer;
+ }
+ }
+ if (clickedLayer) {
+ L.DomEvent._fakeStop(e);
+ this._fireEvent([clickedLayer], e);
+ }
+ },
+
+ _onMouseMove: function (e) {
+ if (!this._map || this._map.dragging.moving() || this._map._animatingZoom) { return; }
+
+ var point = this._map.mouseEventToLayerPoint(e);
+ this._handleMouseHover(e, point);
+ },
+
+
+ _handleMouseOut: function (e) {
+ var layer = this._hoveredLayer;
+ if (layer) {
+ // if we're leaving the layer, fire mouseout
+ L.DomUtil.removeClass(this._container, 'leaflet-interactive');
+ this._fireEvent([layer], e, 'mouseout');
+ this._hoveredLayer = null;
+ }
+ },
+
+ _handleMouseHover: function (e, point) {
+ var layer, candidateHoveredLayer;
+
+ for (var order = this._drawFirst; order; order = order.next) {
+ layer = order.layer;
+ if (layer.options.interactive && layer._containsPoint(point)) {
+ candidateHoveredLayer = layer;
+ }
+ }
+
+ if (candidateHoveredLayer !== this._hoveredLayer) {
+ this._handleMouseOut(e);
+
+ if (candidateHoveredLayer) {
+ L.DomUtil.addClass(this._container, 'leaflet-interactive'); // change cursor
+ this._fireEvent([candidateHoveredLayer], e, 'mouseover');
+ this._hoveredLayer = candidateHoveredLayer;
+ }
+ }
+
+ if (this._hoveredLayer) {
+ this._fireEvent([this._hoveredLayer], e);
+ }
+ },
+
+ _fireEvent: function (layers, e, type) {
+ this._map._fireDOMEvent(e, type || e.type, layers);
+ },
+
+ _bringToFront: function (layer) {
+ var order = layer._order;
+ var next = order.next;
+ var prev = order.prev;
+
+ if (next) {
+ next.prev = prev;
+ } else {
+ // Already last
+ return;
+ }
+ if (prev) {
+ prev.next = next;
+ } else if (next) {
+ // Update first entry unless this is the
+ // signle entry
+ this._drawFirst = next;
+ }
+
+ order.prev = this._drawLast;
+ this._drawLast.next = order;
+
+ order.next = null;
+ this._drawLast = order;
+
+ this._requestRedraw(layer);
+ },
+
+ _bringToBack: function (layer) {
+ var order = layer._order;
+ var next = order.next;
+ var prev = order.prev;
+
+ if (prev) {
+ prev.next = next;
+ } else {
+ // Already first
+ return;
+ }
+ if (next) {
+ next.prev = prev;
+ } else if (prev) {
+ // Update last entry unless this is the
+ // signle entry
+ this._drawLast = prev;
+ }
+
+ order.prev = null;
+
+ order.next = this._drawFirst;
+ this._drawFirst.prev = order;
+ this._drawFirst = order;
+
+ this._requestRedraw(layer);
+ }
+});
+
+// @namespace Browser; @property canvas: Boolean
+// `true` when the browser supports [``](https://developer.mozilla.org/docs/Web/API/Canvas_API).
+L.Browser.canvas = (function () {
+ return !!document.createElement('canvas').getContext;
+}());
+
+// @namespace Canvas
+// @factory L.canvas(options?: Renderer options)
+// Creates a Canvas renderer with the given options.
+L.canvas = function (options) {
+ return L.Browser.canvas ? new L.Canvas(options) : null;
+};
+
+L.Polyline.prototype._containsPoint = function (p, closed) {
+ var i, j, k, len, len2, part,
+ w = this._clickTolerance();
+
+ if (!this._pxBounds.contains(p)) { return false; }
+
+ // hit detection for polylines
+ for (i = 0, len = this._parts.length; i < len; i++) {
+ part = this._parts[i];
+
+ for (j = 0, len2 = part.length, k = len2 - 1; j < len2; k = j++) {
+ if (!closed && (j === 0)) { continue; }
+
+ if (L.LineUtil.pointToSegmentDistance(p, part[k], part[j]) <= w) {
+ return true;
+ }
+ }
+ }
+ return false;
+};
+
+L.Polygon.prototype._containsPoint = function (p) {
+ var inside = false,
+ part, p1, p2, i, j, k, len, len2;
+
+ if (!this._pxBounds.contains(p)) { return false; }
+
+ // ray casting algorithm for detecting if point is in polygon
+ for (i = 0, len = this._parts.length; i < len; i++) {
+ part = this._parts[i];
+
+ for (j = 0, len2 = part.length, k = len2 - 1; j < len2; k = j++) {
+ p1 = part[j];
+ p2 = part[k];
+
+ if (((p1.y > p.y) !== (p2.y > p.y)) && (p.x < (p2.x - p1.x) * (p.y - p1.y) / (p2.y - p1.y) + p1.x)) {
+ inside = !inside;
+ }
+ }
+ }
+
+ // also check if it's on polygon stroke
+ return inside || L.Polyline.prototype._containsPoint.call(this, p, true);
+};
+
+L.CircleMarker.prototype._containsPoint = function (p) {
+ return p.distanceTo(this._point) <= this._radius + this._clickTolerance();
+};
+
+
+
+/*
+ * @class GeoJSON
+ * @aka L.GeoJSON
+ * @inherits FeatureGroup
+ *
+ * Represents a GeoJSON object or an array of GeoJSON objects. Allows you to parse
+ * GeoJSON data and display it on the map. Extends `FeatureGroup`.
+ *
+ * @example
+ *
+ * ```js
+ * L.geoJSON(data, {
+ * style: function (feature) {
+ * return {color: feature.properties.color};
+ * }
+ * }).bindPopup(function (layer) {
+ * return layer.feature.properties.description;
+ * }).addTo(map);
+ * ```
+ */
+
+L.GeoJSON = L.FeatureGroup.extend({
+
+ /* @section
+ * @aka GeoJSON options
+ *
+ * @option pointToLayer: Function = *
+ * A `Function` defining how GeoJSON points spawn Leaflet layers. It is internally
+ * called when data is added, passing the GeoJSON point feature and its `LatLng`.
+ * The default is to spawn a default `Marker`:
+ * ```js
+ * function(geoJsonPoint, latlng) {
+ * return L.marker(latlng);
+ * }
+ * ```
+ *
+ * @option style: Function = *
+ * A `Function` defining the `Path options` for styling GeoJSON lines and polygons,
+ * called internally when data is added.
+ * The default value is to not override any defaults:
+ * ```js
+ * function (geoJsonFeature) {
+ * return {}
+ * }
+ * ```
+ *
+ * @option onEachFeature: Function = *
+ * A `Function` that will be called once for each created `Feature`, after it has
+ * been created and styled. Useful for attaching events and popups to features.
+ * The default is to do nothing with the newly created layers:
+ * ```js
+ * function (feature, layer) {}
+ * ```
+ *
+ * @option filter: Function = *
+ * A `Function` that will be used to decide whether to include a feature or not.
+ * The default is to include all features:
+ * ```js
+ * function (geoJsonFeature) {
+ * return true;
+ * }
+ * ```
+ * Note: dynamically changing the `filter` option will have effect only on newly
+ * added data. It will _not_ re-evaluate already included features.
+ *
+ * @option coordsToLatLng: Function = *
+ * A `Function` that will be used for converting GeoJSON coordinates to `LatLng`s.
+ * The default is the `coordsToLatLng` static method.
+ */
+
+ initialize: function (geojson, options) {
+ L.setOptions(this, options);
+
+ this._layers = {};
+
+ if (geojson) {
+ this.addData(geojson);
+ }
+ },
+
+ // @method addData( data ): this
+ // Adds a GeoJSON object to the layer.
+ addData: function (geojson) {
+ var features = L.Util.isArray(geojson) ? geojson : geojson.features,
+ i, len, feature;
+
+ if (features) {
+ for (i = 0, len = features.length; i < len; i++) {
+ // only add this if geometry or geometries are set and not null
+ feature = features[i];
+ if (feature.geometries || feature.geometry || feature.features || feature.coordinates) {
+ this.addData(feature);
+ }
+ }
+ return this;
+ }
+
+ var options = this.options;
+
+ if (options.filter && !options.filter(geojson)) { return this; }
+
+ var layer = L.GeoJSON.geometryToLayer(geojson, options);
+ if (!layer) {
+ return this;
+ }
+ layer.feature = L.GeoJSON.asFeature(geojson);
+
+ layer.defaultOptions = layer.options;
+ this.resetStyle(layer);
+
+ if (options.onEachFeature) {
+ options.onEachFeature(geojson, layer);
+ }
+
+ return this.addLayer(layer);
+ },
+
+ // @method resetStyle( layer ): this
+ // Resets the given vector layer's style to the original GeoJSON style, useful for resetting style after hover events.
+ resetStyle: function (layer) {
+ // reset any custom styles
+ layer.options = L.Util.extend({}, layer.defaultOptions);
+ this._setLayerStyle(layer, this.options.style);
+ return this;
+ },
+
+ // @method setStyle( style ): this
+ // Changes styles of GeoJSON vector layers with the given style function.
+ setStyle: function (style) {
+ return this.eachLayer(function (layer) {
+ this._setLayerStyle(layer, style);
+ }, this);
+ },
+
+ _setLayerStyle: function (layer, style) {
+ if (typeof style === 'function') {
+ style = style(layer.feature);
+ }
+ if (layer.setStyle) {
+ layer.setStyle(style);
+ }
+ }
+});
+
+// @section
+// There are several static functions which can be called without instantiating L.GeoJSON:
+L.extend(L.GeoJSON, {
+ // @function geometryToLayer(featureData: Object, options?: GeoJSON options): Layer
+ // Creates a `Layer` from a given GeoJSON feature. Can use a custom
+ // [`pointToLayer`](#geojson-pointtolayer) and/or [`coordsToLatLng`](#geojson-coordstolatlng)
+ // functions if provided as options.
+ geometryToLayer: function (geojson, options) {
+
+ var geometry = geojson.type === 'Feature' ? geojson.geometry : geojson,
+ coords = geometry ? geometry.coordinates : null,
+ layers = [],
+ pointToLayer = options && options.pointToLayer,
+ coordsToLatLng = options && options.coordsToLatLng || this.coordsToLatLng,
+ latlng, latlngs, i, len;
+
+ if (!coords && !geometry) {
+ return null;
+ }
+
+ switch (geometry.type) {
+ case 'Point':
+ latlng = coordsToLatLng(coords);
+ return pointToLayer ? pointToLayer(geojson, latlng) : new L.Marker(latlng);
+
+ case 'MultiPoint':
+ for (i = 0, len = coords.length; i < len; i++) {
+ latlng = coordsToLatLng(coords[i]);
+ layers.push(pointToLayer ? pointToLayer(geojson, latlng) : new L.Marker(latlng));
+ }
+ return new L.FeatureGroup(layers);
+
+ case 'LineString':
+ case 'MultiLineString':
+ latlngs = this.coordsToLatLngs(coords, geometry.type === 'LineString' ? 0 : 1, coordsToLatLng);
+ return new L.Polyline(latlngs, options);
+
+ case 'Polygon':
+ case 'MultiPolygon':
+ latlngs = this.coordsToLatLngs(coords, geometry.type === 'Polygon' ? 1 : 2, coordsToLatLng);
+ return new L.Polygon(latlngs, options);
+
+ case 'GeometryCollection':
+ for (i = 0, len = geometry.geometries.length; i < len; i++) {
+ var layer = this.geometryToLayer({
+ geometry: geometry.geometries[i],
+ type: 'Feature',
+ properties: geojson.properties
+ }, options);
+
+ if (layer) {
+ layers.push(layer);
+ }
+ }
+ return new L.FeatureGroup(layers);
+
+ default:
+ throw new Error('Invalid GeoJSON object.');
+ }
+ },
+
+ // @function coordsToLatLng(coords: Array): LatLng
+ // Creates a `LatLng` object from an array of 2 numbers (longitude, latitude)
+ // or 3 numbers (longitude, latitude, altitude) used in GeoJSON for points.
+ coordsToLatLng: function (coords) {
+ return new L.LatLng(coords[1], coords[0], coords[2]);
+ },
+
+ // @function coordsToLatLngs(coords: Array, levelsDeep?: Number, coordsToLatLng?: Function): Array
+ // Creates a multidimensional array of `LatLng`s from a GeoJSON coordinates array.
+ // `levelsDeep` specifies the nesting level (0 is for an array of points, 1 for an array of arrays of points, etc., 0 by default).
+ // Can use a custom [`coordsToLatLng`](#geojson-coordstolatlng) function.
+ coordsToLatLngs: function (coords, levelsDeep, coordsToLatLng) {
+ var latlngs = [];
+
+ for (var i = 0, len = coords.length, latlng; i < len; i++) {
+ latlng = levelsDeep ?
+ this.coordsToLatLngs(coords[i], levelsDeep - 1, coordsToLatLng) :
+ (coordsToLatLng || this.coordsToLatLng)(coords[i]);
+
+ latlngs.push(latlng);
+ }
+
+ return latlngs;
+ },
+
+ // @function latLngToCoords(latlng: LatLng): Array
+ // Reverse of [`coordsToLatLng`](#geojson-coordstolatlng)
+ latLngToCoords: function (latlng) {
+ return latlng.alt !== undefined ?
+ [latlng.lng, latlng.lat, latlng.alt] :
+ [latlng.lng, latlng.lat];
+ },
+
+ // @function latLngsToCoords(latlngs: Array, levelsDeep?: Number, closed?: Boolean): Array
+ // Reverse of [`coordsToLatLngs`](#geojson-coordstolatlngs)
+ // `closed` determines whether the first point should be appended to the end of the array to close the feature, only used when `levelsDeep` is 0. False by default.
+ latLngsToCoords: function (latlngs, levelsDeep, closed) {
+ var coords = [];
+
+ for (var i = 0, len = latlngs.length; i < len; i++) {
+ coords.push(levelsDeep ?
+ L.GeoJSON.latLngsToCoords(latlngs[i], levelsDeep - 1, closed) :
+ L.GeoJSON.latLngToCoords(latlngs[i]));
+ }
+
+ if (!levelsDeep && closed) {
+ coords.push(coords[0]);
+ }
+
+ return coords;
+ },
+
+ getFeature: function (layer, newGeometry) {
+ return layer.feature ?
+ L.extend({}, layer.feature, {geometry: newGeometry}) :
+ L.GeoJSON.asFeature(newGeometry);
+ },
+
+ // @function asFeature(geojson: Object): Object
+ // Normalize GeoJSON geometries/features into GeoJSON features.
+ asFeature: function (geojson) {
+ if (geojson.type === 'Feature' || geojson.type === 'FeatureCollection') {
+ return geojson;
+ }
+
+ return {
+ type: 'Feature',
+ properties: {},
+ geometry: geojson
+ };
+ }
+});
+
+var PointToGeoJSON = {
+ toGeoJSON: function () {
+ return L.GeoJSON.getFeature(this, {
+ type: 'Point',
+ coordinates: L.GeoJSON.latLngToCoords(this.getLatLng())
+ });
+ }
+};
+
+// @namespace Marker
+// @method toGeoJSON(): Object
+// Returns a [`GeoJSON`](http://en.wikipedia.org/wiki/GeoJSON) representation of the marker (as a GeoJSON `Point` Feature).
+L.Marker.include(PointToGeoJSON);
+
+// @namespace CircleMarker
+// @method toGeoJSON(): Object
+// Returns a [`GeoJSON`](http://en.wikipedia.org/wiki/GeoJSON) representation of the circle marker (as a GeoJSON `Point` Feature).
+L.Circle.include(PointToGeoJSON);
+L.CircleMarker.include(PointToGeoJSON);
+
+
+// @namespace Polyline
+// @method toGeoJSON(): Object
+// Returns a [`GeoJSON`](http://en.wikipedia.org/wiki/GeoJSON) representation of the polyline (as a GeoJSON `LineString` or `MultiLineString` Feature).
+L.Polyline.prototype.toGeoJSON = function () {
+ var multi = !L.Polyline._flat(this._latlngs);
+
+ var coords = L.GeoJSON.latLngsToCoords(this._latlngs, multi ? 1 : 0);
+
+ return L.GeoJSON.getFeature(this, {
+ type: (multi ? 'Multi' : '') + 'LineString',
+ coordinates: coords
+ });
+};
+
+// @namespace Polygon
+// @method toGeoJSON(): Object
+// Returns a [`GeoJSON`](http://en.wikipedia.org/wiki/GeoJSON) representation of the polygon (as a GeoJSON `Polygon` or `MultiPolygon` Feature).
+L.Polygon.prototype.toGeoJSON = function () {
+ var holes = !L.Polyline._flat(this._latlngs),
+ multi = holes && !L.Polyline._flat(this._latlngs[0]);
+
+ var coords = L.GeoJSON.latLngsToCoords(this._latlngs, multi ? 2 : holes ? 1 : 0, true);
+
+ if (!holes) {
+ coords = [coords];
+ }
+
+ return L.GeoJSON.getFeature(this, {
+ type: (multi ? 'Multi' : '') + 'Polygon',
+ coordinates: coords
+ });
+};
+
+
+// @namespace LayerGroup
+L.LayerGroup.include({
+ toMultiPoint: function () {
+ var coords = [];
+
+ this.eachLayer(function (layer) {
+ coords.push(layer.toGeoJSON().geometry.coordinates);
+ });
+
+ return L.GeoJSON.getFeature(this, {
+ type: 'MultiPoint',
+ coordinates: coords
+ });
+ },
+
+ // @method toGeoJSON(): Object
+ // Returns a [`GeoJSON`](http://en.wikipedia.org/wiki/GeoJSON) representation of the layer group (as a GeoJSON `GeometryCollection`).
+ toGeoJSON: function () {
+
+ var type = this.feature && this.feature.geometry && this.feature.geometry.type;
+
+ if (type === 'MultiPoint') {
+ return this.toMultiPoint();
+ }
+
+ var isGeometryCollection = type === 'GeometryCollection',
+ jsons = [];
+
+ this.eachLayer(function (layer) {
+ if (layer.toGeoJSON) {
+ var json = layer.toGeoJSON();
+ jsons.push(isGeometryCollection ? json.geometry : L.GeoJSON.asFeature(json));
+ }
+ });
+
+ if (isGeometryCollection) {
+ return L.GeoJSON.getFeature(this, {
+ geometries: jsons,
+ type: 'GeometryCollection'
+ });
+ }
+
+ return {
+ type: 'FeatureCollection',
+ features: jsons
+ };
+ }
+});
+
+// @namespace GeoJSON
+// @factory L.geoJSON(geojson?: Object, options?: GeoJSON options)
+// Creates a GeoJSON layer. Optionally accepts an object in
+// [GeoJSON format](http://geojson.org/geojson-spec.html) to display on the map
+// (you can alternatively add it later with `addData` method) and an `options` object.
+L.geoJSON = function (geojson, options) {
+ return new L.GeoJSON(geojson, options);
+};
+// Backward compatibility.
+L.geoJson = L.geoJSON;
+
+
+
+/*
+ * @class Draggable
+ * @aka L.Draggable
+ * @inherits Evented
+ *
+ * A class for making DOM elements draggable (including touch support).
+ * Used internally for map and marker dragging. Only works for elements
+ * that were positioned with [`L.DomUtil.setPosition`](#domutil-setposition).
+ *
+ * @example
+ * ```js
+ * var draggable = new L.Draggable(elementToDrag);
+ * draggable.enable();
+ * ```
+ */
+
+L.Draggable = L.Evented.extend({
+
+ options: {
+ // @option clickTolerance: Number = 3
+ // The max number of pixels a user can shift the mouse pointer during a click
+ // for it to be considered a valid click (as opposed to a mouse drag).
+ clickTolerance: 3
+ },
+
+ statics: {
+ START: L.Browser.touch ? ['touchstart', 'mousedown'] : ['mousedown'],
+ END: {
+ mousedown: 'mouseup',
+ touchstart: 'touchend',
+ pointerdown: 'touchend',
+ MSPointerDown: 'touchend'
+ },
+ MOVE: {
+ mousedown: 'mousemove',
+ touchstart: 'touchmove',
+ pointerdown: 'touchmove',
+ MSPointerDown: 'touchmove'
+ }
+ },
+
+ // @constructor L.Draggable(el: HTMLElement, dragHandle?: HTMLElement, preventOutline: Boolean)
+ // Creates a `Draggable` object for moving `el` when you start dragging the `dragHandle` element (equals `el` itself by default).
+ initialize: function (element, dragStartTarget, preventOutline) {
+ this._element = element;
+ this._dragStartTarget = dragStartTarget || element;
+ this._preventOutline = preventOutline;
+ },
+
+ // @method enable()
+ // Enables the dragging ability
+ enable: function () {
+ if (this._enabled) { return; }
+
+ L.DomEvent.on(this._dragStartTarget, L.Draggable.START.join(' '), this._onDown, this);
+
+ this._enabled = true;
+ },
+
+ // @method disable()
+ // Disables the dragging ability
+ disable: function () {
+ if (!this._enabled) { return; }
+
+ // If we're currently dragging this draggable,
+ // disabling it counts as first ending the drag.
+ if (L.Draggable._dragging === this) {
+ this.finishDrag();
+ }
+
+ L.DomEvent.off(this._dragStartTarget, L.Draggable.START.join(' '), this._onDown, this);
+
+ this._enabled = false;
+ this._moved = false;
+ },
+
+ _onDown: function (e) {
+ // Ignore simulated events, since we handle both touch and
+ // mouse explicitly; otherwise we risk getting duplicates of
+ // touch events, see #4315.
+ // Also ignore the event if disabled; this happens in IE11
+ // under some circumstances, see #3666.
+ if (e._simulated || !this._enabled) { return; }
+
+ this._moved = false;
+
+ if (L.DomUtil.hasClass(this._element, 'leaflet-zoom-anim')) { return; }
+
+ if (L.Draggable._dragging || e.shiftKey || ((e.which !== 1) && (e.button !== 1) && !e.touches)) { return; }
+ L.Draggable._dragging = this; // Prevent dragging multiple objects at once.
+
+ if (this._preventOutline) {
+ L.DomUtil.preventOutline(this._element);
+ }
+
+ L.DomUtil.disableImageDrag();
+ L.DomUtil.disableTextSelection();
+
+ if (this._moving) { return; }
+
+ // @event down: Event
+ // Fired when a drag is about to start.
+ this.fire('down');
+
+ var first = e.touches ? e.touches[0] : e;
+
+ this._startPoint = new L.Point(first.clientX, first.clientY);
+
+ L.DomEvent
+ .on(document, L.Draggable.MOVE[e.type], this._onMove, this)
+ .on(document, L.Draggable.END[e.type], this._onUp, this);
+ },
+
+ _onMove: function (e) {
+ // Ignore simulated events, since we handle both touch and
+ // mouse explicitly; otherwise we risk getting duplicates of
+ // touch events, see #4315.
+ // Also ignore the event if disabled; this happens in IE11
+ // under some circumstances, see #3666.
+ if (e._simulated || !this._enabled) { return; }
+
+ if (e.touches && e.touches.length > 1) {
+ this._moved = true;
+ return;
+ }
+
+ var first = (e.touches && e.touches.length === 1 ? e.touches[0] : e),
+ newPoint = new L.Point(first.clientX, first.clientY),
+ offset = newPoint.subtract(this._startPoint);
+
+ if (!offset.x && !offset.y) { return; }
+ if (Math.abs(offset.x) + Math.abs(offset.y) < this.options.clickTolerance) { return; }
+
+ L.DomEvent.preventDefault(e);
+
+ if (!this._moved) {
+ // @event dragstart: Event
+ // Fired when a drag starts
+ this.fire('dragstart');
+
+ this._moved = true;
+ this._startPos = L.DomUtil.getPosition(this._element).subtract(offset);
+
+ L.DomUtil.addClass(document.body, 'leaflet-dragging');
+
+ this._lastTarget = e.target || e.srcElement;
+ // IE and Edge do not give the element, so fetch it
+ // if necessary
+ if ((window.SVGElementInstance) && (this._lastTarget instanceof SVGElementInstance)) {
+ this._lastTarget = this._lastTarget.correspondingUseElement;
+ }
+ L.DomUtil.addClass(this._lastTarget, 'leaflet-drag-target');
+ }
+
+ this._newPos = this._startPos.add(offset);
+ this._moving = true;
+
+ L.Util.cancelAnimFrame(this._animRequest);
+ this._lastEvent = e;
+ this._animRequest = L.Util.requestAnimFrame(this._updatePosition, this, true);
+ },
+
+ _updatePosition: function () {
+ var e = {originalEvent: this._lastEvent};
+
+ // @event predrag: Event
+ // Fired continuously during dragging *before* each corresponding
+ // update of the element's position.
+ this.fire('predrag', e);
+ L.DomUtil.setPosition(this._element, this._newPos);
+
+ // @event drag: Event
+ // Fired continuously during dragging.
+ this.fire('drag', e);
+ },
+
+ _onUp: function (e) {
+ // Ignore simulated events, since we handle both touch and
+ // mouse explicitly; otherwise we risk getting duplicates of
+ // touch events, see #4315.
+ // Also ignore the event if disabled; this happens in IE11
+ // under some circumstances, see #3666.
+ if (e._simulated || !this._enabled) { return; }
+ this.finishDrag();
+ },
+
+ finishDrag: function () {
+ L.DomUtil.removeClass(document.body, 'leaflet-dragging');
+
+ if (this._lastTarget) {
+ L.DomUtil.removeClass(this._lastTarget, 'leaflet-drag-target');
+ this._lastTarget = null;
+ }
+
+ for (var i in L.Draggable.MOVE) {
+ L.DomEvent
+ .off(document, L.Draggable.MOVE[i], this._onMove, this)
+ .off(document, L.Draggable.END[i], this._onUp, this);
+ }
+
+ L.DomUtil.enableImageDrag();
+ L.DomUtil.enableTextSelection();
+
+ if (this._moved && this._moving) {
+ // ensure drag is not fired after dragend
+ L.Util.cancelAnimFrame(this._animRequest);
+
+ // @event dragend: DragEndEvent
+ // Fired when the drag ends.
+ this.fire('dragend', {
+ distance: this._newPos.distanceTo(this._startPos)
+ });
+ }
+
+ this._moving = false;
+ L.Draggable._dragging = false;
+ }
+
+});
+
+
+
+/*
+ L.Handler is a base class for handler classes that are used internally to inject
+ interaction features like dragging to classes like Map and Marker.
+*/
+
+// @class Handler
+// @aka L.Handler
+// Abstract class for map interaction handlers
+
+L.Handler = L.Class.extend({
+ initialize: function (map) {
+ this._map = map;
+ },
+
+ // @method enable(): this
+ // Enables the handler
+ enable: function () {
+ if (this._enabled) { return this; }
+
+ this._enabled = true;
+ this.addHooks();
+ return this;
+ },
+
+ // @method disable(): this
+ // Disables the handler
+ disable: function () {
+ if (!this._enabled) { return this; }
+
+ this._enabled = false;
+ this.removeHooks();
+ return this;
+ },
+
+ // @method enabled(): Boolean
+ // Returns `true` if the handler is enabled
+ enabled: function () {
+ return !!this._enabled;
+ }
+
+ // @section Extension methods
+ // Classes inheriting from `Handler` must implement the two following methods:
+ // @method addHooks()
+ // Called when the handler is enabled, should add event hooks.
+ // @method removeHooks()
+ // Called when the handler is disabled, should remove the event hooks added previously.
+});
+
+
+
+/*
+ * L.Handler.MapDrag is used to make the map draggable (with panning inertia), enabled by default.
+ */
+
+// @namespace Map
+// @section Interaction Options
+L.Map.mergeOptions({
+ // @option dragging: Boolean = true
+ // Whether the map be draggable with mouse/touch or not.
+ dragging: true,
+
+ // @section Panning Inertia Options
+ // @option inertia: Boolean = *
+ // If enabled, panning of the map will have an inertia effect where
+ // the map builds momentum while dragging and continues moving in
+ // the same direction for some time. Feels especially nice on touch
+ // devices. Enabled by default unless running on old Android devices.
+ inertia: !L.Browser.android23,
+
+ // @option inertiaDeceleration: Number = 3000
+ // The rate with which the inertial movement slows down, in pixels/second².
+ inertiaDeceleration: 3400, // px/s^2
+
+ // @option inertiaMaxSpeed: Number = Infinity
+ // Max speed of the inertial movement, in pixels/second.
+ inertiaMaxSpeed: Infinity, // px/s
+
+ // @option easeLinearity: Number = 0.2
+ easeLinearity: 0.2,
+
+ // TODO refactor, move to CRS
+ // @option worldCopyJump: Boolean = false
+ // With this option enabled, the map tracks when you pan to another "copy"
+ // of the world and seamlessly jumps to the original one so that all overlays
+ // like markers and vector layers are still visible.
+ worldCopyJump: false,
+
+ // @option maxBoundsViscosity: Number = 0.0
+ // If `maxBounds` is set, this option will control how solid the bounds
+ // are when dragging the map around. The default value of `0.0` allows the
+ // user to drag outside the bounds at normal speed, higher values will
+ // slow down map dragging outside bounds, and `1.0` makes the bounds fully
+ // solid, preventing the user from dragging outside the bounds.
+ maxBoundsViscosity: 0.0
+});
+
+L.Map.Drag = L.Handler.extend({
+ addHooks: function () {
+ if (!this._draggable) {
+ var map = this._map;
+
+ this._draggable = new L.Draggable(map._mapPane, map._container);
+
+ this._draggable.on({
+ down: this._onDown,
+ dragstart: this._onDragStart,
+ drag: this._onDrag,
+ dragend: this._onDragEnd
+ }, this);
+
+ this._draggable.on('predrag', this._onPreDragLimit, this);
+ if (map.options.worldCopyJump) {
+ this._draggable.on('predrag', this._onPreDragWrap, this);
+ map.on('zoomend', this._onZoomEnd, this);
+
+ map.whenReady(this._onZoomEnd, this);
+ }
+ }
+ L.DomUtil.addClass(this._map._container, 'leaflet-grab leaflet-touch-drag');
+ this._draggable.enable();
+ this._positions = [];
+ this._times = [];
+ },
+
+ removeHooks: function () {
+ L.DomUtil.removeClass(this._map._container, 'leaflet-grab');
+ L.DomUtil.removeClass(this._map._container, 'leaflet-touch-drag');
+ this._draggable.disable();
+ },
+
+ moved: function () {
+ return this._draggable && this._draggable._moved;
+ },
+
+ moving: function () {
+ return this._draggable && this._draggable._moving;
+ },
+
+ _onDown: function () {
+ this._map._stop();
+ },
+
+ _onDragStart: function () {
+ var map = this._map;
+
+ if (this._map.options.maxBounds && this._map.options.maxBoundsViscosity) {
+ var bounds = L.latLngBounds(this._map.options.maxBounds);
+
+ this._offsetLimit = L.bounds(
+ this._map.latLngToContainerPoint(bounds.getNorthWest()).multiplyBy(-1),
+ this._map.latLngToContainerPoint(bounds.getSouthEast()).multiplyBy(-1)
+ .add(this._map.getSize()));
+
+ this._viscosity = Math.min(1.0, Math.max(0.0, this._map.options.maxBoundsViscosity));
+ } else {
+ this._offsetLimit = null;
+ }
+
+ map
+ .fire('movestart')
+ .fire('dragstart');
+
+ if (map.options.inertia) {
+ this._positions = [];
+ this._times = [];
+ }
+ },
+
+ _onDrag: function (e) {
+ if (this._map.options.inertia) {
+ var time = this._lastTime = +new Date(),
+ pos = this._lastPos = this._draggable._absPos || this._draggable._newPos;
+
+ this._positions.push(pos);
+ this._times.push(time);
+
+ if (time - this._times[0] > 50) {
+ this._positions.shift();
+ this._times.shift();
+ }
+ }
+
+ this._map
+ .fire('move', e)
+ .fire('drag', e);
+ },
+
+ _onZoomEnd: function () {
+ var pxCenter = this._map.getSize().divideBy(2),
+ pxWorldCenter = this._map.latLngToLayerPoint([0, 0]);
+
+ this._initialWorldOffset = pxWorldCenter.subtract(pxCenter).x;
+ this._worldWidth = this._map.getPixelWorldBounds().getSize().x;
+ },
+
+ _viscousLimit: function (value, threshold) {
+ return value - (value - threshold) * this._viscosity;
+ },
+
+ _onPreDragLimit: function () {
+ if (!this._viscosity || !this._offsetLimit) { return; }
+
+ var offset = this._draggable._newPos.subtract(this._draggable._startPos);
+
+ var limit = this._offsetLimit;
+ if (offset.x < limit.min.x) { offset.x = this._viscousLimit(offset.x, limit.min.x); }
+ if (offset.y < limit.min.y) { offset.y = this._viscousLimit(offset.y, limit.min.y); }
+ if (offset.x > limit.max.x) { offset.x = this._viscousLimit(offset.x, limit.max.x); }
+ if (offset.y > limit.max.y) { offset.y = this._viscousLimit(offset.y, limit.max.y); }
+
+ this._draggable._newPos = this._draggable._startPos.add(offset);
+ },
+
+ _onPreDragWrap: function () {
+ // TODO refactor to be able to adjust map pane position after zoom
+ var worldWidth = this._worldWidth,
+ halfWidth = Math.round(worldWidth / 2),
+ dx = this._initialWorldOffset,
+ x = this._draggable._newPos.x,
+ newX1 = (x - halfWidth + dx) % worldWidth + halfWidth - dx,
+ newX2 = (x + halfWidth + dx) % worldWidth - halfWidth - dx,
+ newX = Math.abs(newX1 + dx) < Math.abs(newX2 + dx) ? newX1 : newX2;
+
+ this._draggable._absPos = this._draggable._newPos.clone();
+ this._draggable._newPos.x = newX;
+ },
+
+ _onDragEnd: function (e) {
+ var map = this._map,
+ options = map.options,
+
+ noInertia = !options.inertia || this._times.length < 2;
+
+ map.fire('dragend', e);
+
+ if (noInertia) {
+ map.fire('moveend');
+
+ } else {
+
+ var direction = this._lastPos.subtract(this._positions[0]),
+ duration = (this._lastTime - this._times[0]) / 1000,
+ ease = options.easeLinearity,
+
+ speedVector = direction.multiplyBy(ease / duration),
+ speed = speedVector.distanceTo([0, 0]),
+
+ limitedSpeed = Math.min(options.inertiaMaxSpeed, speed),
+ limitedSpeedVector = speedVector.multiplyBy(limitedSpeed / speed),
+
+ decelerationDuration = limitedSpeed / (options.inertiaDeceleration * ease),
+ offset = limitedSpeedVector.multiplyBy(-decelerationDuration / 2).round();
+
+ if (!offset.x && !offset.y) {
+ map.fire('moveend');
+
+ } else {
+ offset = map._limitOffset(offset, map.options.maxBounds);
+
+ L.Util.requestAnimFrame(function () {
+ map.panBy(offset, {
+ duration: decelerationDuration,
+ easeLinearity: ease,
+ noMoveStart: true,
+ animate: true
+ });
+ });
+ }
+ }
+ }
+});
+
+// @section Handlers
+// @property dragging: Handler
+// Map dragging handler (by both mouse and touch).
+L.Map.addInitHook('addHandler', 'dragging', L.Map.Drag);
+
+
+
+/*
+ * L.Handler.DoubleClickZoom is used to handle double-click zoom on the map, enabled by default.
+ */
+
+// @namespace Map
+// @section Interaction Options
+
+L.Map.mergeOptions({
+ // @option doubleClickZoom: Boolean|String = true
+ // Whether the map can be zoomed in by double clicking on it and
+ // zoomed out by double clicking while holding shift. If passed
+ // `'center'`, double-click zoom will zoom to the center of the
+ // view regardless of where the mouse was.
+ doubleClickZoom: true
+});
+
+L.Map.DoubleClickZoom = L.Handler.extend({
+ addHooks: function () {
+ this._map.on('dblclick', this._onDoubleClick, this);
+ },
+
+ removeHooks: function () {
+ this._map.off('dblclick', this._onDoubleClick, this);
+ },
+
+ _onDoubleClick: function (e) {
+ var map = this._map,
+ oldZoom = map.getZoom(),
+ delta = map.options.zoomDelta,
+ zoom = e.originalEvent.shiftKey ? oldZoom - delta : oldZoom + delta;
+
+ if (map.options.doubleClickZoom === 'center') {
+ map.setZoom(zoom);
+ } else {
+ map.setZoomAround(e.containerPoint, zoom);
+ }
+ }
+});
+
+// @section Handlers
+//
+// Map properties include interaction handlers that allow you to control
+// interaction behavior in runtime, enabling or disabling certain features such
+// as dragging or touch zoom (see `Handler` methods). For example:
+//
+// ```js
+// map.doubleClickZoom.disable();
+// ```
+//
+// @property doubleClickZoom: Handler
+// Double click zoom handler.
+L.Map.addInitHook('addHandler', 'doubleClickZoom', L.Map.DoubleClickZoom);
+
+
+
+/*
+ * L.Handler.ScrollWheelZoom is used by L.Map to enable mouse scroll wheel zoom on the map.
+ */
+
+// @namespace Map
+// @section Interaction Options
+L.Map.mergeOptions({
+ // @section Mousewheel options
+ // @option scrollWheelZoom: Boolean|String = true
+ // Whether the map can be zoomed by using the mouse wheel. If passed `'center'`,
+ // it will zoom to the center of the view regardless of where the mouse was.
+ scrollWheelZoom: true,
+
+ // @option wheelDebounceTime: Number = 40
+ // Limits the rate at which a wheel can fire (in milliseconds). By default
+ // user can't zoom via wheel more often than once per 40 ms.
+ wheelDebounceTime: 40,
+
+ // @option wheelPxPerZoomLevel: Number = 60
+ // How many scroll pixels (as reported by [L.DomEvent.getWheelDelta](#domevent-getwheeldelta))
+ // mean a change of one full zoom level. Smaller values will make wheel-zooming
+ // faster (and vice versa).
+ wheelPxPerZoomLevel: 60
+});
+
+L.Map.ScrollWheelZoom = L.Handler.extend({
+ addHooks: function () {
+ L.DomEvent.on(this._map._container, 'mousewheel', this._onWheelScroll, this);
+
+ this._delta = 0;
+ },
+
+ removeHooks: function () {
+ L.DomEvent.off(this._map._container, 'mousewheel', this._onWheelScroll, this);
+ },
+
+ _onWheelScroll: function (e) {
+ var delta = L.DomEvent.getWheelDelta(e);
+
+ var debounce = this._map.options.wheelDebounceTime;
+
+ this._delta += delta;
+ this._lastMousePos = this._map.mouseEventToContainerPoint(e);
+
+ if (!this._startTime) {
+ this._startTime = +new Date();
+ }
+
+ var left = Math.max(debounce - (+new Date() - this._startTime), 0);
+
+ clearTimeout(this._timer);
+ this._timer = setTimeout(L.bind(this._performZoom, this), left);
+
+ L.DomEvent.stop(e);
+ },
+
+ _performZoom: function () {
+ var map = this._map,
+ zoom = map.getZoom(),
+ snap = this._map.options.zoomSnap || 0;
+
+ map._stop(); // stop panning and fly animations if any
+
+ // map the delta with a sigmoid function to -4..4 range leaning on -1..1
+ var d2 = this._delta / (this._map.options.wheelPxPerZoomLevel * 4),
+ d3 = 4 * Math.log(2 / (1 + Math.exp(-Math.abs(d2)))) / Math.LN2,
+ d4 = snap ? Math.ceil(d3 / snap) * snap : d3,
+ delta = map._limitZoom(zoom + (this._delta > 0 ? d4 : -d4)) - zoom;
+
+ this._delta = 0;
+ this._startTime = null;
+
+ if (!delta) { return; }
+
+ if (map.options.scrollWheelZoom === 'center') {
+ map.setZoom(zoom + delta);
+ } else {
+ map.setZoomAround(this._lastMousePos, zoom + delta);
+ }
+ }
+});
+
+// @section Handlers
+// @property scrollWheelZoom: Handler
+// Scroll wheel zoom handler.
+L.Map.addInitHook('addHandler', 'scrollWheelZoom', L.Map.ScrollWheelZoom);
+
+
+
+/*
+ * Extends the event handling code with double tap support for mobile browsers.
+ */
+
+L.extend(L.DomEvent, {
+
+ _touchstart: L.Browser.msPointer ? 'MSPointerDown' : L.Browser.pointer ? 'pointerdown' : 'touchstart',
+ _touchend: L.Browser.msPointer ? 'MSPointerUp' : L.Browser.pointer ? 'pointerup' : 'touchend',
+
+ // inspired by Zepto touch code by Thomas Fuchs
+ addDoubleTapListener: function (obj, handler, id) {
+ var last, touch,
+ doubleTap = false,
+ delay = 250;
+
+ function onTouchStart(e) {
+ var count;
+
+ if (L.Browser.pointer) {
+ if ((!L.Browser.edge) || e.pointerType === 'mouse') { return; }
+ count = L.DomEvent._pointersCount;
+ } else {
+ count = e.touches.length;
+ }
+
+ if (count > 1) { return; }
+
+ var now = Date.now(),
+ delta = now - (last || now);
+
+ touch = e.touches ? e.touches[0] : e;
+ doubleTap = (delta > 0 && delta <= delay);
+ last = now;
+ }
+
+ function onTouchEnd(e) {
+ if (doubleTap && !touch.cancelBubble) {
+ if (L.Browser.pointer) {
+ if ((!L.Browser.edge) || e.pointerType === 'mouse') { return; }
+
+ // work around .type being readonly with MSPointer* events
+ var newTouch = {},
+ prop, i;
+
+ for (i in touch) {
+ prop = touch[i];
+ newTouch[i] = prop && prop.bind ? prop.bind(touch) : prop;
+ }
+ touch = newTouch;
+ }
+ touch.type = 'dblclick';
+ handler(touch);
+ last = null;
+ }
+ }
+
+ var pre = '_leaflet_',
+ touchstart = this._touchstart,
+ touchend = this._touchend;
+
+ obj[pre + touchstart + id] = onTouchStart;
+ obj[pre + touchend + id] = onTouchEnd;
+ obj[pre + 'dblclick' + id] = handler;
+
+ obj.addEventListener(touchstart, onTouchStart, false);
+ obj.addEventListener(touchend, onTouchEnd, false);
+
+ // On some platforms (notably, chrome<55 on win10 + touchscreen + mouse),
+ // the browser doesn't fire touchend/pointerup events but does fire
+ // native dblclicks. See #4127.
+ // Edge 14 also fires native dblclicks, but only for pointerType mouse, see #5180.
+ obj.addEventListener('dblclick', handler, false);
+
+ return this;
+ },
+
+ removeDoubleTapListener: function (obj, id) {
+ var pre = '_leaflet_',
+ touchstart = obj[pre + this._touchstart + id],
+ touchend = obj[pre + this._touchend + id],
+ dblclick = obj[pre + 'dblclick' + id];
+
+ obj.removeEventListener(this._touchstart, touchstart, false);
+ obj.removeEventListener(this._touchend, touchend, false);
+ if (!L.Browser.edge) {
+ obj.removeEventListener('dblclick', dblclick, false);
+ }
+
+ return this;
+ }
+});
+
+
+
+/*
+ * Extends L.DomEvent to provide touch support for Internet Explorer and Windows-based devices.
+ */
+
+L.extend(L.DomEvent, {
+
+ POINTER_DOWN: L.Browser.msPointer ? 'MSPointerDown' : 'pointerdown',
+ POINTER_MOVE: L.Browser.msPointer ? 'MSPointerMove' : 'pointermove',
+ POINTER_UP: L.Browser.msPointer ? 'MSPointerUp' : 'pointerup',
+ POINTER_CANCEL: L.Browser.msPointer ? 'MSPointerCancel' : 'pointercancel',
+ TAG_WHITE_LIST: ['INPUT', 'SELECT', 'OPTION'],
+
+ _pointers: {},
+ _pointersCount: 0,
+
+ // Provides a touch events wrapper for (ms)pointer events.
+ // ref http://www.w3.org/TR/pointerevents/ https://www.w3.org/Bugs/Public/show_bug.cgi?id=22890
+
+ addPointerListener: function (obj, type, handler, id) {
+
+ if (type === 'touchstart') {
+ this._addPointerStart(obj, handler, id);
+
+ } else if (type === 'touchmove') {
+ this._addPointerMove(obj, handler, id);
+
+ } else if (type === 'touchend') {
+ this._addPointerEnd(obj, handler, id);
+ }
+
+ return this;
+ },
+
+ removePointerListener: function (obj, type, id) {
+ var handler = obj['_leaflet_' + type + id];
+
+ if (type === 'touchstart') {
+ obj.removeEventListener(this.POINTER_DOWN, handler, false);
+
+ } else if (type === 'touchmove') {
+ obj.removeEventListener(this.POINTER_MOVE, handler, false);
+
+ } else if (type === 'touchend') {
+ obj.removeEventListener(this.POINTER_UP, handler, false);
+ obj.removeEventListener(this.POINTER_CANCEL, handler, false);
+ }
+
+ return this;
+ },
+
+ _addPointerStart: function (obj, handler, id) {
+ var onDown = L.bind(function (e) {
+ if (e.pointerType !== 'mouse' && e.MSPOINTER_TYPE_MOUSE && e.pointerType !== e.MSPOINTER_TYPE_MOUSE) {
+ // In IE11, some touch events needs to fire for form controls, or
+ // the controls will stop working. We keep a whitelist of tag names that
+ // need these events. For other target tags, we prevent default on the event.
+ if (this.TAG_WHITE_LIST.indexOf(e.target.tagName) < 0) {
+ L.DomEvent.preventDefault(e);
+ } else {
+ return;
+ }
+ }
+
+ this._handlePointer(e, handler);
+ }, this);
+
+ obj['_leaflet_touchstart' + id] = onDown;
+ obj.addEventListener(this.POINTER_DOWN, onDown, false);
+
+ // need to keep track of what pointers and how many are active to provide e.touches emulation
+ if (!this._pointerDocListener) {
+ var pointerUp = L.bind(this._globalPointerUp, this);
+
+ // we listen documentElement as any drags that end by moving the touch off the screen get fired there
+ document.documentElement.addEventListener(this.POINTER_DOWN, L.bind(this._globalPointerDown, this), true);
+ document.documentElement.addEventListener(this.POINTER_MOVE, L.bind(this._globalPointerMove, this), true);
+ document.documentElement.addEventListener(this.POINTER_UP, pointerUp, true);
+ document.documentElement.addEventListener(this.POINTER_CANCEL, pointerUp, true);
+
+ this._pointerDocListener = true;
+ }
+ },
+
+ _globalPointerDown: function (e) {
+ this._pointers[e.pointerId] = e;
+ this._pointersCount++;
+ },
+
+ _globalPointerMove: function (e) {
+ if (this._pointers[e.pointerId]) {
+ this._pointers[e.pointerId] = e;
+ }
+ },
+
+ _globalPointerUp: function (e) {
+ delete this._pointers[e.pointerId];
+ this._pointersCount--;
+ },
+
+ _handlePointer: function (e, handler) {
+ e.touches = [];
+ for (var i in this._pointers) {
+ e.touches.push(this._pointers[i]);
+ }
+ e.changedTouches = [e];
+
+ handler(e);
+ },
+
+ _addPointerMove: function (obj, handler, id) {
+ var onMove = L.bind(function (e) {
+ // don't fire touch moves when mouse isn't down
+ if ((e.pointerType === e.MSPOINTER_TYPE_MOUSE || e.pointerType === 'mouse') && e.buttons === 0) { return; }
+
+ this._handlePointer(e, handler);
+ }, this);
+
+ obj['_leaflet_touchmove' + id] = onMove;
+ obj.addEventListener(this.POINTER_MOVE, onMove, false);
+ },
+
+ _addPointerEnd: function (obj, handler, id) {
+ var onUp = L.bind(function (e) {
+ this._handlePointer(e, handler);
+ }, this);
+
+ obj['_leaflet_touchend' + id] = onUp;
+ obj.addEventListener(this.POINTER_UP, onUp, false);
+ obj.addEventListener(this.POINTER_CANCEL, onUp, false);
+ }
+});
+
+
+
+/*
+ * L.Handler.TouchZoom is used by L.Map to add pinch zoom on supported mobile browsers.
+ */
+
+// @namespace Map
+// @section Interaction Options
+L.Map.mergeOptions({
+ // @section Touch interaction options
+ // @option touchZoom: Boolean|String = *
+ // Whether the map can be zoomed by touch-dragging with two fingers. If
+ // passed `'center'`, it will zoom to the center of the view regardless of
+ // where the touch events (fingers) were. Enabled for touch-capable web
+ // browsers except for old Androids.
+ touchZoom: L.Browser.touch && !L.Browser.android23,
+
+ // @option bounceAtZoomLimits: Boolean = true
+ // Set it to false if you don't want the map to zoom beyond min/max zoom
+ // and then bounce back when pinch-zooming.
+ bounceAtZoomLimits: true
+});
+
+L.Map.TouchZoom = L.Handler.extend({
+ addHooks: function () {
+ L.DomUtil.addClass(this._map._container, 'leaflet-touch-zoom');
+ L.DomEvent.on(this._map._container, 'touchstart', this._onTouchStart, this);
+ },
+
+ removeHooks: function () {
+ L.DomUtil.removeClass(this._map._container, 'leaflet-touch-zoom');
+ L.DomEvent.off(this._map._container, 'touchstart', this._onTouchStart, this);
+ },
+
+ _onTouchStart: function (e) {
+ var map = this._map;
+ if (!e.touches || e.touches.length !== 2 || map._animatingZoom || this._zooming) { return; }
+
+ var p1 = map.mouseEventToContainerPoint(e.touches[0]),
+ p2 = map.mouseEventToContainerPoint(e.touches[1]);
+
+ this._centerPoint = map.getSize()._divideBy(2);
+ this._startLatLng = map.containerPointToLatLng(this._centerPoint);
+ if (map.options.touchZoom !== 'center') {
+ this._pinchStartLatLng = map.containerPointToLatLng(p1.add(p2)._divideBy(2));
+ }
+
+ this._startDist = p1.distanceTo(p2);
+ this._startZoom = map.getZoom();
+
+ this._moved = false;
+ this._zooming = true;
+
+ map._stop();
+
+ L.DomEvent
+ .on(document, 'touchmove', this._onTouchMove, this)
+ .on(document, 'touchend', this._onTouchEnd, this);
+
+ L.DomEvent.preventDefault(e);
+ },
+
+ _onTouchMove: function (e) {
+ if (!e.touches || e.touches.length !== 2 || !this._zooming) { return; }
+
+ var map = this._map,
+ p1 = map.mouseEventToContainerPoint(e.touches[0]),
+ p2 = map.mouseEventToContainerPoint(e.touches[1]),
+ scale = p1.distanceTo(p2) / this._startDist;
+
+
+ this._zoom = map.getScaleZoom(scale, this._startZoom);
+
+ if (!map.options.bounceAtZoomLimits && (
+ (this._zoom < map.getMinZoom() && scale < 1) ||
+ (this._zoom > map.getMaxZoom() && scale > 1))) {
+ this._zoom = map._limitZoom(this._zoom);
+ }
+
+ if (map.options.touchZoom === 'center') {
+ this._center = this._startLatLng;
+ if (scale === 1) { return; }
+ } else {
+ // Get delta from pinch to center, so centerLatLng is delta applied to initial pinchLatLng
+ var delta = p1._add(p2)._divideBy(2)._subtract(this._centerPoint);
+ if (scale === 1 && delta.x === 0 && delta.y === 0) { return; }
+ this._center = map.unproject(map.project(this._pinchStartLatLng, this._zoom).subtract(delta), this._zoom);
+ }
+
+ if (!this._moved) {
+ map._moveStart(true);
+ this._moved = true;
+ }
+
+ L.Util.cancelAnimFrame(this._animRequest);
+
+ var moveFn = L.bind(map._move, map, this._center, this._zoom, {pinch: true, round: false});
+ this._animRequest = L.Util.requestAnimFrame(moveFn, this, true);
+
+ L.DomEvent.preventDefault(e);
+ },
+
+ _onTouchEnd: function () {
+ if (!this._moved || !this._zooming) {
+ this._zooming = false;
+ return;
+ }
+
+ this._zooming = false;
+ L.Util.cancelAnimFrame(this._animRequest);
+
+ L.DomEvent
+ .off(document, 'touchmove', this._onTouchMove)
+ .off(document, 'touchend', this._onTouchEnd);
+
+ // Pinch updates GridLayers' levels only when zoomSnap is off, so zoomSnap becomes noUpdate.
+ if (this._map.options.zoomAnimation) {
+ this._map._animateZoom(this._center, this._map._limitZoom(this._zoom), true, this._map.options.zoomSnap);
+ } else {
+ this._map._resetView(this._center, this._map._limitZoom(this._zoom));
+ }
+ }
+});
+
+// @section Handlers
+// @property touchZoom: Handler
+// Touch zoom handler.
+L.Map.addInitHook('addHandler', 'touchZoom', L.Map.TouchZoom);
+
+
+
+/*
+ * L.Map.Tap is used to enable mobile hacks like quick taps and long hold.
+ */
+
+// @namespace Map
+// @section Interaction Options
+L.Map.mergeOptions({
+ // @section Touch interaction options
+ // @option tap: Boolean = true
+ // Enables mobile hacks for supporting instant taps (fixing 200ms click
+ // delay on iOS/Android) and touch holds (fired as `contextmenu` events).
+ tap: true,
+
+ // @option tapTolerance: Number = 15
+ // The max number of pixels a user can shift his finger during touch
+ // for it to be considered a valid tap.
+ tapTolerance: 15
+});
+
+L.Map.Tap = L.Handler.extend({
+ addHooks: function () {
+ L.DomEvent.on(this._map._container, 'touchstart', this._onDown, this);
+ },
+
+ removeHooks: function () {
+ L.DomEvent.off(this._map._container, 'touchstart', this._onDown, this);
+ },
+
+ _onDown: function (e) {
+ if (!e.touches) { return; }
+
+ L.DomEvent.preventDefault(e);
+
+ this._fireClick = true;
+
+ // don't simulate click or track longpress if more than 1 touch
+ if (e.touches.length > 1) {
+ this._fireClick = false;
+ clearTimeout(this._holdTimeout);
+ return;
+ }
+
+ var first = e.touches[0],
+ el = first.target;
+
+ this._startPos = this._newPos = new L.Point(first.clientX, first.clientY);
+
+ // if touching a link, highlight it
+ if (el.tagName && el.tagName.toLowerCase() === 'a') {
+ L.DomUtil.addClass(el, 'leaflet-active');
+ }
+
+ // simulate long hold but setting a timeout
+ this._holdTimeout = setTimeout(L.bind(function () {
+ if (this._isTapValid()) {
+ this._fireClick = false;
+ this._onUp();
+ this._simulateEvent('contextmenu', first);
+ }
+ }, this), 1000);
+
+ this._simulateEvent('mousedown', first);
+
+ L.DomEvent.on(document, {
+ touchmove: this._onMove,
+ touchend: this._onUp
+ }, this);
+ },
+
+ _onUp: function (e) {
+ clearTimeout(this._holdTimeout);
+
+ L.DomEvent.off(document, {
+ touchmove: this._onMove,
+ touchend: this._onUp
+ }, this);
+
+ if (this._fireClick && e && e.changedTouches) {
+
+ var first = e.changedTouches[0],
+ el = first.target;
+
+ if (el && el.tagName && el.tagName.toLowerCase() === 'a') {
+ L.DomUtil.removeClass(el, 'leaflet-active');
+ }
+
+ this._simulateEvent('mouseup', first);
+
+ // simulate click if the touch didn't move too much
+ if (this._isTapValid()) {
+ this._simulateEvent('click', first);
+ }
+ }
+ },
+
+ _isTapValid: function () {
+ return this._newPos.distanceTo(this._startPos) <= this._map.options.tapTolerance;
+ },
+
+ _onMove: function (e) {
+ var first = e.touches[0];
+ this._newPos = new L.Point(first.clientX, first.clientY);
+ this._simulateEvent('mousemove', first);
+ },
+
+ _simulateEvent: function (type, e) {
+ var simulatedEvent = document.createEvent('MouseEvents');
+
+ simulatedEvent._simulated = true;
+ e.target._simulatedClick = true;
+
+ simulatedEvent.initMouseEvent(
+ type, true, true, window, 1,
+ e.screenX, e.screenY,
+ e.clientX, e.clientY,
+ false, false, false, false, 0, null);
+
+ e.target.dispatchEvent(simulatedEvent);
+ }
+});
+
+// @section Handlers
+// @property tap: Handler
+// Mobile touch hacks (quick tap and touch hold) handler.
+if (L.Browser.touch && !L.Browser.pointer) {
+ L.Map.addInitHook('addHandler', 'tap', L.Map.Tap);
+}
+
+
+
+/*
+ * L.Handler.BoxZoom is used to add shift-drag zoom interaction to the map
+ * (zoom to a selected bounding box), enabled by default.
+ */
+
+// @namespace Map
+// @section Interaction Options
+L.Map.mergeOptions({
+ // @option boxZoom: Boolean = true
+ // Whether the map can be zoomed to a rectangular area specified by
+ // dragging the mouse while pressing the shift key.
+ boxZoom: true
+});
+
+L.Map.BoxZoom = L.Handler.extend({
+ initialize: function (map) {
+ this._map = map;
+ this._container = map._container;
+ this._pane = map._panes.overlayPane;
+ },
+
+ addHooks: function () {
+ L.DomEvent.on(this._container, 'mousedown', this._onMouseDown, this);
+ },
+
+ removeHooks: function () {
+ L.DomEvent.off(this._container, 'mousedown', this._onMouseDown, this);
+ },
+
+ moved: function () {
+ return this._moved;
+ },
+
+ _resetState: function () {
+ this._moved = false;
+ },
+
+ _onMouseDown: function (e) {
+ if (!e.shiftKey || ((e.which !== 1) && (e.button !== 1))) { return false; }
+
+ this._resetState();
+
+ L.DomUtil.disableTextSelection();
+ L.DomUtil.disableImageDrag();
+
+ this._startPoint = this._map.mouseEventToContainerPoint(e);
+
+ L.DomEvent.on(document, {
+ contextmenu: L.DomEvent.stop,
+ mousemove: this._onMouseMove,
+ mouseup: this._onMouseUp,
+ keydown: this._onKeyDown
+ }, this);
+ },
+
+ _onMouseMove: function (e) {
+ if (!this._moved) {
+ this._moved = true;
+
+ this._box = L.DomUtil.create('div', 'leaflet-zoom-box', this._container);
+ L.DomUtil.addClass(this._container, 'leaflet-crosshair');
+
+ this._map.fire('boxzoomstart');
+ }
+
+ this._point = this._map.mouseEventToContainerPoint(e);
+
+ var bounds = new L.Bounds(this._point, this._startPoint),
+ size = bounds.getSize();
+
+ L.DomUtil.setPosition(this._box, bounds.min);
+
+ this._box.style.width = size.x + 'px';
+ this._box.style.height = size.y + 'px';
+ },
+
+ _finish: function () {
+ if (this._moved) {
+ L.DomUtil.remove(this._box);
+ L.DomUtil.removeClass(this._container, 'leaflet-crosshair');
+ }
+
+ L.DomUtil.enableTextSelection();
+ L.DomUtil.enableImageDrag();
+
+ L.DomEvent.off(document, {
+ contextmenu: L.DomEvent.stop,
+ mousemove: this._onMouseMove,
+ mouseup: this._onMouseUp,
+ keydown: this._onKeyDown
+ }, this);
+ },
+
+ _onMouseUp: function (e) {
+ if ((e.which !== 1) && (e.button !== 1)) { return; }
+
+ this._finish();
+
+ if (!this._moved) { return; }
+ // Postpone to next JS tick so internal click event handling
+ // still see it as "moved".
+ setTimeout(L.bind(this._resetState, this), 0);
+
+ var bounds = new L.LatLngBounds(
+ this._map.containerPointToLatLng(this._startPoint),
+ this._map.containerPointToLatLng(this._point));
+
+ this._map
+ .fitBounds(bounds)
+ .fire('boxzoomend', {boxZoomBounds: bounds});
+ },
+
+ _onKeyDown: function (e) {
+ if (e.keyCode === 27) {
+ this._finish();
+ }
+ }
+});
+
+// @section Handlers
+// @property boxZoom: Handler
+// Box (shift-drag with mouse) zoom handler.
+L.Map.addInitHook('addHandler', 'boxZoom', L.Map.BoxZoom);
+
+
+
+/*
+ * L.Map.Keyboard is handling keyboard interaction with the map, enabled by default.
+ */
+
+// @namespace Map
+// @section Keyboard Navigation Options
+L.Map.mergeOptions({
+ // @option keyboard: Boolean = true
+ // Makes the map focusable and allows users to navigate the map with keyboard
+ // arrows and `+`/`-` keys.
+ keyboard: true,
+
+ // @option keyboardPanDelta: Number = 80
+ // Amount of pixels to pan when pressing an arrow key.
+ keyboardPanDelta: 80
+});
+
+L.Map.Keyboard = L.Handler.extend({
+
+ keyCodes: {
+ left: [37],
+ right: [39],
+ down: [40],
+ up: [38],
+ zoomIn: [187, 107, 61, 171],
+ zoomOut: [189, 109, 54, 173]
+ },
+
+ initialize: function (map) {
+ this._map = map;
+
+ this._setPanDelta(map.options.keyboardPanDelta);
+ this._setZoomDelta(map.options.zoomDelta);
+ },
+
+ addHooks: function () {
+ var container = this._map._container;
+
+ // make the container focusable by tabbing
+ if (container.tabIndex <= 0) {
+ container.tabIndex = '0';
+ }
+
+ L.DomEvent.on(container, {
+ focus: this._onFocus,
+ blur: this._onBlur,
+ mousedown: this._onMouseDown
+ }, this);
+
+ this._map.on({
+ focus: this._addHooks,
+ blur: this._removeHooks
+ }, this);
+ },
+
+ removeHooks: function () {
+ this._removeHooks();
+
+ L.DomEvent.off(this._map._container, {
+ focus: this._onFocus,
+ blur: this._onBlur,
+ mousedown: this._onMouseDown
+ }, this);
+
+ this._map.off({
+ focus: this._addHooks,
+ blur: this._removeHooks
+ }, this);
+ },
+
+ _onMouseDown: function () {
+ if (this._focused) { return; }
+
+ var body = document.body,
+ docEl = document.documentElement,
+ top = body.scrollTop || docEl.scrollTop,
+ left = body.scrollLeft || docEl.scrollLeft;
+
+ this._map._container.focus();
+
+ window.scrollTo(left, top);
+ },
+
+ _onFocus: function () {
+ this._focused = true;
+ this._map.fire('focus');
+ },
+
+ _onBlur: function () {
+ this._focused = false;
+ this._map.fire('blur');
+ },
+
+ _setPanDelta: function (panDelta) {
+ var keys = this._panKeys = {},
+ codes = this.keyCodes,
+ i, len;
+
+ for (i = 0, len = codes.left.length; i < len; i++) {
+ keys[codes.left[i]] = [-1 * panDelta, 0];
+ }
+ for (i = 0, len = codes.right.length; i < len; i++) {
+ keys[codes.right[i]] = [panDelta, 0];
+ }
+ for (i = 0, len = codes.down.length; i < len; i++) {
+ keys[codes.down[i]] = [0, panDelta];
+ }
+ for (i = 0, len = codes.up.length; i < len; i++) {
+ keys[codes.up[i]] = [0, -1 * panDelta];
+ }
+ },
+
+ _setZoomDelta: function (zoomDelta) {
+ var keys = this._zoomKeys = {},
+ codes = this.keyCodes,
+ i, len;
+
+ for (i = 0, len = codes.zoomIn.length; i < len; i++) {
+ keys[codes.zoomIn[i]] = zoomDelta;
+ }
+ for (i = 0, len = codes.zoomOut.length; i < len; i++) {
+ keys[codes.zoomOut[i]] = -zoomDelta;
+ }
+ },
+
+ _addHooks: function () {
+ L.DomEvent.on(document, 'keydown', this._onKeyDown, this);
+ },
+
+ _removeHooks: function () {
+ L.DomEvent.off(document, 'keydown', this._onKeyDown, this);
+ },
+
+ _onKeyDown: function (e) {
+ if (e.altKey || e.ctrlKey || e.metaKey) { return; }
+
+ var key = e.keyCode,
+ map = this._map,
+ offset;
+
+ if (key in this._panKeys) {
+
+ if (map._panAnim && map._panAnim._inProgress) { return; }
+
+ offset = this._panKeys[key];
+ if (e.shiftKey) {
+ offset = L.point(offset).multiplyBy(3);
+ }
+
+ map.panBy(offset);
+
+ if (map.options.maxBounds) {
+ map.panInsideBounds(map.options.maxBounds);
+ }
+
+ } else if (key in this._zoomKeys) {
+ map.setZoom(map.getZoom() + (e.shiftKey ? 3 : 1) * this._zoomKeys[key]);
+
+ } else if (key === 27) {
+ map.closePopup();
+
+ } else {
+ return;
+ }
+
+ L.DomEvent.stop(e);
+ }
+});
+
+// @section Handlers
+// @section Handlers
+// @property keyboard: Handler
+// Keyboard navigation handler.
+L.Map.addInitHook('addHandler', 'keyboard', L.Map.Keyboard);
+
+
+
+/*
+ * L.Handler.MarkerDrag is used internally by L.Marker to make the markers draggable.
+ */
+
+
+/* @namespace Marker
+ * @section Interaction handlers
+ *
+ * Interaction handlers are properties of a marker instance that allow you to control interaction behavior in runtime, enabling or disabling certain features such as dragging (see `Handler` methods). Example:
+ *
+ * ```js
+ * marker.dragging.disable();
+ * ```
+ *
+ * @property dragging: Handler
+ * Marker dragging handler (by both mouse and touch).
+ */
+
+L.Handler.MarkerDrag = L.Handler.extend({
+ initialize: function (marker) {
+ this._marker = marker;
+ },
+
+ addHooks: function () {
+ var icon = this._marker._icon;
+
+ if (!this._draggable) {
+ this._draggable = new L.Draggable(icon, icon, true);
+ }
+
+ this._draggable.on({
+ dragstart: this._onDragStart,
+ drag: this._onDrag,
+ dragend: this._onDragEnd
+ }, this).enable();
+
+ L.DomUtil.addClass(icon, 'leaflet-marker-draggable');
+ },
+
+ removeHooks: function () {
+ this._draggable.off({
+ dragstart: this._onDragStart,
+ drag: this._onDrag,
+ dragend: this._onDragEnd
+ }, this).disable();
+
+ if (this._marker._icon) {
+ L.DomUtil.removeClass(this._marker._icon, 'leaflet-marker-draggable');
+ }
+ },
+
+ moved: function () {
+ return this._draggable && this._draggable._moved;
+ },
+
+ _onDragStart: function () {
+ // @section Dragging events
+ // @event dragstart: Event
+ // Fired when the user starts dragging the marker.
+
+ // @event movestart: Event
+ // Fired when the marker starts moving (because of dragging).
+
+ this._oldLatLng = this._marker.getLatLng();
+ this._marker
+ .closePopup()
+ .fire('movestart')
+ .fire('dragstart');
+ },
+
+ _onDrag: function (e) {
+ var marker = this._marker,
+ shadow = marker._shadow,
+ iconPos = L.DomUtil.getPosition(marker._icon),
+ latlng = marker._map.layerPointToLatLng(iconPos);
+
+ // update shadow position
+ if (shadow) {
+ L.DomUtil.setPosition(shadow, iconPos);
+ }
+
+ marker._latlng = latlng;
+ e.latlng = latlng;
+ e.oldLatLng = this._oldLatLng;
+
+ // @event drag: Event
+ // Fired repeatedly while the user drags the marker.
+ marker
+ .fire('move', e)
+ .fire('drag', e);
+ },
+
+ _onDragEnd: function (e) {
+ // @event dragend: DragEndEvent
+ // Fired when the user stops dragging the marker.
+
+ // @event moveend: Event
+ // Fired when the marker stops moving (because of dragging).
+ delete this._oldLatLng;
+ this._marker
+ .fire('moveend')
+ .fire('dragend', e);
+ }
+});
+
+
+
+/*
+ * @class Control
+ * @aka L.Control
+ * @inherits Class
+ *
+ * L.Control is a base class for implementing map controls. Handles positioning.
+ * All other controls extend from this class.
+ */
+
+L.Control = L.Class.extend({
+ // @section
+ // @aka Control options
+ options: {
+ // @option position: String = 'topright'
+ // The position of the control (one of the map corners). Possible values are `'topleft'`,
+ // `'topright'`, `'bottomleft'` or `'bottomright'`
+ position: 'topright'
+ },
+
+ initialize: function (options) {
+ L.setOptions(this, options);
+ },
+
+ /* @section
+ * Classes extending L.Control will inherit the following methods:
+ *
+ * @method getPosition: string
+ * Returns the position of the control.
+ */
+ getPosition: function () {
+ return this.options.position;
+ },
+
+ // @method setPosition(position: string): this
+ // Sets the position of the control.
+ setPosition: function (position) {
+ var map = this._map;
+
+ if (map) {
+ map.removeControl(this);
+ }
+
+ this.options.position = position;
+
+ if (map) {
+ map.addControl(this);
+ }
+
+ return this;
+ },
+
+ // @method getContainer: HTMLElement
+ // Returns the HTMLElement that contains the control.
+ getContainer: function () {
+ return this._container;
+ },
+
+ // @method addTo(map: Map): this
+ // Adds the control to the given map.
+ addTo: function (map) {
+ this.remove();
+ this._map = map;
+
+ var container = this._container = this.onAdd(map),
+ pos = this.getPosition(),
+ corner = map._controlCorners[pos];
+
+ L.DomUtil.addClass(container, 'leaflet-control');
+
+ if (pos.indexOf('bottom') !== -1) {
+ corner.insertBefore(container, corner.firstChild);
+ } else {
+ corner.appendChild(container);
+ }
+
+ return this;
+ },
+
+ // @method remove: this
+ // Removes the control from the map it is currently active on.
+ remove: function () {
+ if (!this._map) {
+ return this;
+ }
+
+ L.DomUtil.remove(this._container);
+
+ if (this.onRemove) {
+ this.onRemove(this._map);
+ }
+
+ this._map = null;
+
+ return this;
+ },
+
+ _refocusOnMap: function (e) {
+ // if map exists and event is not a keyboard event
+ if (this._map && e && e.screenX > 0 && e.screenY > 0) {
+ this._map.getContainer().focus();
+ }
+ }
+});
+
+L.control = function (options) {
+ return new L.Control(options);
+};
+
+/* @section Extension methods
+ * @uninheritable
+ *
+ * Every control should extend from `L.Control` and (re-)implement the following methods.
+ *
+ * @method onAdd(map: Map): HTMLElement
+ * Should return the container DOM element for the control and add listeners on relevant map events. Called on [`control.addTo(map)`](#control-addTo).
+ *
+ * @method onRemove(map: Map)
+ * Optional method. Should contain all clean up code that removes the listeners previously added in [`onAdd`](#control-onadd). Called on [`control.remove()`](#control-remove).
+ */
+
+/* @namespace Map
+ * @section Methods for Layers and Controls
+ */
+L.Map.include({
+ // @method addControl(control: Control): this
+ // Adds the given control to the map
+ addControl: function (control) {
+ control.addTo(this);
+ return this;
+ },
+
+ // @method removeControl(control: Control): this
+ // Removes the given control from the map
+ removeControl: function (control) {
+ control.remove();
+ return this;
+ },
+
+ _initControlPos: function () {
+ var corners = this._controlCorners = {},
+ l = 'leaflet-',
+ container = this._controlContainer =
+ L.DomUtil.create('div', l + 'control-container', this._container);
+
+ function createCorner(vSide, hSide) {
+ var className = l + vSide + ' ' + l + hSide;
+
+ corners[vSide + hSide] = L.DomUtil.create('div', className, container);
+ }
+
+ createCorner('top', 'left');
+ createCorner('top', 'right');
+ createCorner('bottom', 'left');
+ createCorner('bottom', 'right');
+ },
+
+ _clearControlPos: function () {
+ L.DomUtil.remove(this._controlContainer);
+ }
+});
+
+
+
+/*
+ * @class Control.Zoom
+ * @aka L.Control.Zoom
+ * @inherits Control
+ *
+ * A basic zoom control with two buttons (zoom in and zoom out). It is put on the map by default unless you set its [`zoomControl` option](#map-zoomcontrol) to `false`. Extends `Control`.
+ */
+
+L.Control.Zoom = L.Control.extend({
+ // @section
+ // @aka Control.Zoom options
+ options: {
+ position: 'topleft',
+
+ // @option zoomInText: String = '+'
+ // The text set on the 'zoom in' button.
+ zoomInText: '+',
+
+ // @option zoomInTitle: String = 'Zoom in'
+ // The title set on the 'zoom in' button.
+ zoomInTitle: 'Zoom in',
+
+ // @option zoomOutText: String = '-'
+ // The text set on the 'zoom out' button.
+ zoomOutText: '-',
+
+ // @option zoomOutTitle: String = 'Zoom out'
+ // The title set on the 'zoom out' button.
+ zoomOutTitle: 'Zoom out'
+ },
+
+ onAdd: function (map) {
+ var zoomName = 'leaflet-control-zoom',
+ container = L.DomUtil.create('div', zoomName + ' leaflet-bar'),
+ options = this.options;
+
+ this._zoomInButton = this._createButton(options.zoomInText, options.zoomInTitle,
+ zoomName + '-in', container, this._zoomIn);
+ this._zoomOutButton = this._createButton(options.zoomOutText, options.zoomOutTitle,
+ zoomName + '-out', container, this._zoomOut);
+
+ this._updateDisabled();
+ map.on('zoomend zoomlevelschange', this._updateDisabled, this);
+
+ return container;
+ },
+
+ onRemove: function (map) {
+ map.off('zoomend zoomlevelschange', this._updateDisabled, this);
+ },
+
+ disable: function () {
+ this._disabled = true;
+ this._updateDisabled();
+ return this;
+ },
+
+ enable: function () {
+ this._disabled = false;
+ this._updateDisabled();
+ return this;
+ },
+
+ _zoomIn: function (e) {
+ if (!this._disabled && this._map._zoom < this._map.getMaxZoom()) {
+ this._map.zoomIn(this._map.options.zoomDelta * (e.shiftKey ? 3 : 1));
+ }
+ },
+
+ _zoomOut: function (e) {
+ if (!this._disabled && this._map._zoom > this._map.getMinZoom()) {
+ this._map.zoomOut(this._map.options.zoomDelta * (e.shiftKey ? 3 : 1));
+ }
+ },
+
+ _createButton: function (html, title, className, container, fn) {
+ var link = L.DomUtil.create('a', className, container);
+ link.innerHTML = html;
+ link.href = '#';
+ link.title = title;
+
+ /*
+ * Will force screen readers like VoiceOver to read this as "Zoom in - button"
+ */
+ link.setAttribute('role', 'button');
+ link.setAttribute('aria-label', title);
+
+ L.DomEvent
+ .on(link, 'mousedown dblclick', L.DomEvent.stopPropagation)
+ .on(link, 'click', L.DomEvent.stop)
+ .on(link, 'click', fn, this)
+ .on(link, 'click', this._refocusOnMap, this);
+
+ return link;
+ },
+
+ _updateDisabled: function () {
+ var map = this._map,
+ className = 'leaflet-disabled';
+
+ L.DomUtil.removeClass(this._zoomInButton, className);
+ L.DomUtil.removeClass(this._zoomOutButton, className);
+
+ if (this._disabled || map._zoom === map.getMinZoom()) {
+ L.DomUtil.addClass(this._zoomOutButton, className);
+ }
+ if (this._disabled || map._zoom === map.getMaxZoom()) {
+ L.DomUtil.addClass(this._zoomInButton, className);
+ }
+ }
+});
+
+// @namespace Map
+// @section Control options
+// @option zoomControl: Boolean = true
+// Whether a [zoom control](#control-zoom) is added to the map by default.
+L.Map.mergeOptions({
+ zoomControl: true
+});
+
+L.Map.addInitHook(function () {
+ if (this.options.zoomControl) {
+ this.zoomControl = new L.Control.Zoom();
+ this.addControl(this.zoomControl);
+ }
+});
+
+// @namespace Control.Zoom
+// @factory L.control.zoom(options: Control.Zoom options)
+// Creates a zoom control
+L.control.zoom = function (options) {
+ return new L.Control.Zoom(options);
+};
+
+
+
+/*
+ * @class Control.Attribution
+ * @aka L.Control.Attribution
+ * @inherits Control
+ *
+ * The attribution control allows you to display attribution data in a small text box on a map. It is put on the map by default unless you set its [`attributionControl` option](#map-attributioncontrol) to `false`, and it fetches attribution texts from layers with the [`getAttribution` method](#layer-getattribution) automatically. Extends Control.
+ */
+
+L.Control.Attribution = L.Control.extend({
+ // @section
+ // @aka Control.Attribution options
+ options: {
+ position: 'bottomright',
+
+ // @option prefix: String = 'Leaflet'
+ // The HTML text shown before the attributions. Pass `false` to disable.
+ prefix: 'Leaflet '
+ },
+
+ initialize: function (options) {
+ L.setOptions(this, options);
+
+ this._attributions = {};
+ },
+
+ onAdd: function (map) {
+ map.attributionControl = this;
+ this._container = L.DomUtil.create('div', 'leaflet-control-attribution');
+ if (L.DomEvent) {
+ L.DomEvent.disableClickPropagation(this._container);
+ }
+
+ // TODO ugly, refactor
+ for (var i in map._layers) {
+ if (map._layers[i].getAttribution) {
+ this.addAttribution(map._layers[i].getAttribution());
+ }
+ }
+
+ this._update();
+
+ return this._container;
+ },
+
+ // @method setPrefix(prefix: String): this
+ // Sets the text before the attributions.
+ setPrefix: function (prefix) {
+ this.options.prefix = prefix;
+ this._update();
+ return this;
+ },
+
+ // @method addAttribution(text: String): this
+ // Adds an attribution text (e.g. `'Vector data © Mapbox'`).
+ addAttribution: function (text) {
+ if (!text) { return this; }
+
+ if (!this._attributions[text]) {
+ this._attributions[text] = 0;
+ }
+ this._attributions[text]++;
+
+ this._update();
+
+ return this;
+ },
+
+ // @method removeAttribution(text: String): this
+ // Removes an attribution text.
+ removeAttribution: function (text) {
+ if (!text) { return this; }
+
+ if (this._attributions[text]) {
+ this._attributions[text]--;
+ this._update();
+ }
+
+ return this;
+ },
+
+ _update: function () {
+ if (!this._map) { return; }
+
+ var attribs = [];
+
+ for (var i in this._attributions) {
+ if (this._attributions[i]) {
+ attribs.push(i);
+ }
+ }
+
+ var prefixAndAttribs = [];
+
+ if (this.options.prefix) {
+ prefixAndAttribs.push(this.options.prefix);
+ }
+ if (attribs.length) {
+ prefixAndAttribs.push(attribs.join(', '));
+ }
+
+ this._container.innerHTML = prefixAndAttribs.join(' | ');
+ }
+});
+
+// @namespace Map
+// @section Control options
+// @option attributionControl: Boolean = true
+// Whether a [attribution control](#control-attribution) is added to the map by default.
+L.Map.mergeOptions({
+ attributionControl: true
+});
+
+L.Map.addInitHook(function () {
+ if (this.options.attributionControl) {
+ new L.Control.Attribution().addTo(this);
+ }
+});
+
+// @namespace Control.Attribution
+// @factory L.control.attribution(options: Control.Attribution options)
+// Creates an attribution control.
+L.control.attribution = function (options) {
+ return new L.Control.Attribution(options);
+};
+
+
+
+/*
+ * @class Control.Scale
+ * @aka L.Control.Scale
+ * @inherits Control
+ *
+ * A simple scale control that shows the scale of the current center of screen in metric (m/km) and imperial (mi/ft) systems. Extends `Control`.
+ *
+ * @example
+ *
+ * ```js
+ * L.control.scale().addTo(map);
+ * ```
+ */
+
+L.Control.Scale = L.Control.extend({
+ // @section
+ // @aka Control.Scale options
+ options: {
+ position: 'bottomleft',
+
+ // @option maxWidth: Number = 100
+ // Maximum width of the control in pixels. The width is set dynamically to show round values (e.g. 100, 200, 500).
+ maxWidth: 100,
+
+ // @option metric: Boolean = True
+ // Whether to show the metric scale line (m/km).
+ metric: true,
+
+ // @option imperial: Boolean = True
+ // Whether to show the imperial scale line (mi/ft).
+ imperial: true
+
+ // @option updateWhenIdle: Boolean = false
+ // If `true`, the control is updated on [`moveend`](#map-moveend), otherwise it's always up-to-date (updated on [`move`](#map-move)).
+ },
+
+ onAdd: function (map) {
+ var className = 'leaflet-control-scale',
+ container = L.DomUtil.create('div', className),
+ options = this.options;
+
+ this._addScales(options, className + '-line', container);
+
+ map.on(options.updateWhenIdle ? 'moveend' : 'move', this._update, this);
+ map.whenReady(this._update, this);
+
+ return container;
+ },
+
+ onRemove: function (map) {
+ map.off(this.options.updateWhenIdle ? 'moveend' : 'move', this._update, this);
+ },
+
+ _addScales: function (options, className, container) {
+ if (options.metric) {
+ this._mScale = L.DomUtil.create('div', className, container);
+ }
+ if (options.imperial) {
+ this._iScale = L.DomUtil.create('div', className, container);
+ }
+ },
+
+ _update: function () {
+ var map = this._map,
+ y = map.getSize().y / 2;
+
+ var maxMeters = map.distance(
+ map.containerPointToLatLng([0, y]),
+ map.containerPointToLatLng([this.options.maxWidth, y]));
+
+ this._updateScales(maxMeters);
+ },
+
+ _updateScales: function (maxMeters) {
+ if (this.options.metric && maxMeters) {
+ this._updateMetric(maxMeters);
+ }
+ if (this.options.imperial && maxMeters) {
+ this._updateImperial(maxMeters);
+ }
+ },
+
+ _updateMetric: function (maxMeters) {
+ var meters = this._getRoundNum(maxMeters),
+ label = meters < 1000 ? meters + ' m' : (meters / 1000) + ' km';
+
+ this._updateScale(this._mScale, label, meters / maxMeters);
+ },
+
+ _updateImperial: function (maxMeters) {
+ var maxFeet = maxMeters * 3.2808399,
+ maxMiles, miles, feet;
+
+ if (maxFeet > 5280) {
+ maxMiles = maxFeet / 5280;
+ miles = this._getRoundNum(maxMiles);
+ this._updateScale(this._iScale, miles + ' mi', miles / maxMiles);
+
+ } else {
+ feet = this._getRoundNum(maxFeet);
+ this._updateScale(this._iScale, feet + ' ft', feet / maxFeet);
+ }
+ },
+
+ _updateScale: function (scale, text, ratio) {
+ scale.style.width = Math.round(this.options.maxWidth * ratio) + 'px';
+ scale.innerHTML = text;
+ },
+
+ _getRoundNum: function (num) {
+ var pow10 = Math.pow(10, (Math.floor(num) + '').length - 1),
+ d = num / pow10;
+
+ d = d >= 10 ? 10 :
+ d >= 5 ? 5 :
+ d >= 3 ? 3 :
+ d >= 2 ? 2 : 1;
+
+ return pow10 * d;
+ }
+});
+
+
+// @factory L.control.scale(options?: Control.Scale options)
+// Creates an scale control with the given options.
+L.control.scale = function (options) {
+ return new L.Control.Scale(options);
+};
+
+
+
+/*
+ * @class Control.Layers
+ * @aka L.Control.Layers
+ * @inherits Control
+ *
+ * The layers control gives users the ability to switch between different base layers and switch overlays on/off (check out the [detailed example](http://leafletjs.com/examples/layers-control.html)). Extends `Control`.
+ *
+ * @example
+ *
+ * ```js
+ * var baseLayers = {
+ * "Mapbox": mapbox,
+ * "OpenStreetMap": osm
+ * };
+ *
+ * var overlays = {
+ * "Marker": marker,
+ * "Roads": roadsLayer
+ * };
+ *
+ * L.control.layers(baseLayers, overlays).addTo(map);
+ * ```
+ *
+ * The `baseLayers` and `overlays` parameters are object literals with layer names as keys and `Layer` objects as values:
+ *
+ * ```js
+ * {
+ * "": layer1,
+ * "": layer2
+ * }
+ * ```
+ *
+ * The layer names can contain HTML, which allows you to add additional styling to the items:
+ *
+ * ```js
+ * {"My Layer ": myLayer}
+ * ```
+ */
+
+
+L.Control.Layers = L.Control.extend({
+ // @section
+ // @aka Control.Layers options
+ options: {
+ // @option collapsed: Boolean = true
+ // If `true`, the control will be collapsed into an icon and expanded on mouse hover or touch.
+ collapsed: true,
+ position: 'topright',
+
+ // @option autoZIndex: Boolean = true
+ // If `true`, the control will assign zIndexes in increasing order to all of its layers so that the order is preserved when switching them on/off.
+ autoZIndex: true,
+
+ // @option hideSingleBase: Boolean = false
+ // If `true`, the base layers in the control will be hidden when there is only one.
+ hideSingleBase: false,
+
+ // @option sortLayers: Boolean = false
+ // Whether to sort the layers. When `false`, layers will keep the order
+ // in which they were added to the control.
+ sortLayers: false,
+
+ // @option sortFunction: Function = *
+ // A [compare function](https://developer.mozilla.org/docs/Web/JavaScript/Reference/Global_Objects/Array/sort)
+ // that will be used for sorting the layers, when `sortLayers` is `true`.
+ // The function receives both the `L.Layer` instances and their names, as in
+ // `sortFunction(layerA, layerB, nameA, nameB)`.
+ // By default, it sorts layers alphabetically by their name.
+ sortFunction: function (layerA, layerB, nameA, nameB) {
+ return nameA < nameB ? -1 : (nameB < nameA ? 1 : 0);
+ }
+ },
+
+ initialize: function (baseLayers, overlays, options) {
+ L.setOptions(this, options);
+
+ this._layers = [];
+ this._lastZIndex = 0;
+ this._handlingClick = false;
+
+ for (var i in baseLayers) {
+ this._addLayer(baseLayers[i], i);
+ }
+
+ for (i in overlays) {
+ this._addLayer(overlays[i], i, true);
+ }
+ },
+
+ onAdd: function (map) {
+ this._initLayout();
+ this._update();
+
+ this._map = map;
+ map.on('zoomend', this._checkDisabledLayers, this);
+
+ return this._container;
+ },
+
+ onRemove: function () {
+ this._map.off('zoomend', this._checkDisabledLayers, this);
+
+ for (var i = 0; i < this._layers.length; i++) {
+ this._layers[i].layer.off('add remove', this._onLayerChange, this);
+ }
+ },
+
+ // @method addBaseLayer(layer: Layer, name: String): this
+ // Adds a base layer (radio button entry) with the given name to the control.
+ addBaseLayer: function (layer, name) {
+ this._addLayer(layer, name);
+ return (this._map) ? this._update() : this;
+ },
+
+ // @method addOverlay(layer: Layer, name: String): this
+ // Adds an overlay (checkbox entry) with the given name to the control.
+ addOverlay: function (layer, name) {
+ this._addLayer(layer, name, true);
+ return (this._map) ? this._update() : this;
+ },
+
+ // @method removeLayer(layer: Layer): this
+ // Remove the given layer from the control.
+ removeLayer: function (layer) {
+ layer.off('add remove', this._onLayerChange, this);
+
+ var obj = this._getLayer(L.stamp(layer));
+ if (obj) {
+ this._layers.splice(this._layers.indexOf(obj), 1);
+ }
+ return (this._map) ? this._update() : this;
+ },
+
+ // @method expand(): this
+ // Expand the control container if collapsed.
+ expand: function () {
+ L.DomUtil.addClass(this._container, 'leaflet-control-layers-expanded');
+ this._form.style.height = null;
+ var acceptableHeight = this._map.getSize().y - (this._container.offsetTop + 50);
+ if (acceptableHeight < this._form.clientHeight) {
+ L.DomUtil.addClass(this._form, 'leaflet-control-layers-scrollbar');
+ this._form.style.height = acceptableHeight + 'px';
+ } else {
+ L.DomUtil.removeClass(this._form, 'leaflet-control-layers-scrollbar');
+ }
+ this._checkDisabledLayers();
+ return this;
+ },
+
+ // @method collapse(): this
+ // Collapse the control container if expanded.
+ collapse: function () {
+ L.DomUtil.removeClass(this._container, 'leaflet-control-layers-expanded');
+ return this;
+ },
+
+ _initLayout: function () {
+ var className = 'leaflet-control-layers',
+ container = this._container = L.DomUtil.create('div', className),
+ collapsed = this.options.collapsed;
+
+ // makes this work on IE touch devices by stopping it from firing a mouseout event when the touch is released
+ container.setAttribute('aria-haspopup', true);
+
+ L.DomEvent.disableClickPropagation(container);
+ if (!L.Browser.touch) {
+ L.DomEvent.disableScrollPropagation(container);
+ }
+
+ var form = this._form = L.DomUtil.create('form', className + '-list');
+
+ if (collapsed) {
+ this._map.on('click', this.collapse, this);
+
+ if (!L.Browser.android) {
+ L.DomEvent.on(container, {
+ mouseenter: this.expand,
+ mouseleave: this.collapse
+ }, this);
+ }
+ }
+
+ var link = this._layersLink = L.DomUtil.create('a', className + '-toggle', container);
+ link.href = '#';
+ link.title = 'Layers';
+
+ if (L.Browser.touch) {
+ L.DomEvent
+ .on(link, 'click', L.DomEvent.stop)
+ .on(link, 'click', this.expand, this);
+ } else {
+ L.DomEvent.on(link, 'focus', this.expand, this);
+ }
+
+ // work around for Firefox Android issue https://github.com/Leaflet/Leaflet/issues/2033
+ L.DomEvent.on(form, 'click', function () {
+ setTimeout(L.bind(this._onInputClick, this), 0);
+ }, this);
+
+ // TODO keyboard accessibility
+
+ if (!collapsed) {
+ this.expand();
+ }
+
+ this._baseLayersList = L.DomUtil.create('div', className + '-base', form);
+ this._separator = L.DomUtil.create('div', className + '-separator', form);
+ this._overlaysList = L.DomUtil.create('div', className + '-overlays', form);
+
+ container.appendChild(form);
+ },
+
+ _getLayer: function (id) {
+ for (var i = 0; i < this._layers.length; i++) {
+
+ if (this._layers[i] && L.stamp(this._layers[i].layer) === id) {
+ return this._layers[i];
+ }
+ }
+ },
+
+ _addLayer: function (layer, name, overlay) {
+ layer.on('add remove', this._onLayerChange, this);
+
+ this._layers.push({
+ layer: layer,
+ name: name,
+ overlay: overlay
+ });
+
+ if (this.options.sortLayers) {
+ this._layers.sort(L.bind(function (a, b) {
+ return this.options.sortFunction(a.layer, b.layer, a.name, b.name);
+ }, this));
+ }
+
+ if (this.options.autoZIndex && layer.setZIndex) {
+ this._lastZIndex++;
+ layer.setZIndex(this._lastZIndex);
+ }
+ },
+
+ _update: function () {
+ if (!this._container) { return this; }
+
+ L.DomUtil.empty(this._baseLayersList);
+ L.DomUtil.empty(this._overlaysList);
+
+ var baseLayersPresent, overlaysPresent, i, obj, baseLayersCount = 0;
+
+ for (i = 0; i < this._layers.length; i++) {
+ obj = this._layers[i];
+ this._addItem(obj);
+ overlaysPresent = overlaysPresent || obj.overlay;
+ baseLayersPresent = baseLayersPresent || !obj.overlay;
+ baseLayersCount += !obj.overlay ? 1 : 0;
+ }
+
+ // Hide base layers section if there's only one layer.
+ if (this.options.hideSingleBase) {
+ baseLayersPresent = baseLayersPresent && baseLayersCount > 1;
+ this._baseLayersList.style.display = baseLayersPresent ? '' : 'none';
+ }
+
+ this._separator.style.display = overlaysPresent && baseLayersPresent ? '' : 'none';
+
+ return this;
+ },
+
+ _onLayerChange: function (e) {
+ if (!this._handlingClick) {
+ this._update();
+ }
+
+ var obj = this._getLayer(L.stamp(e.target));
+
+ // @namespace Map
+ // @section Layer events
+ // @event baselayerchange: LayersControlEvent
+ // Fired when the base layer is changed through the [layer control](#control-layers).
+ // @event overlayadd: LayersControlEvent
+ // Fired when an overlay is selected through the [layer control](#control-layers).
+ // @event overlayremove: LayersControlEvent
+ // Fired when an overlay is deselected through the [layer control](#control-layers).
+ // @namespace Control.Layers
+ var type = obj.overlay ?
+ (e.type === 'add' ? 'overlayadd' : 'overlayremove') :
+ (e.type === 'add' ? 'baselayerchange' : null);
+
+ if (type) {
+ this._map.fire(type, obj);
+ }
+ },
+
+ // IE7 bugs out if you create a radio dynamically, so you have to do it this hacky way (see http://bit.ly/PqYLBe)
+ _createRadioElement: function (name, checked) {
+
+ var radioHtml = '1}}(),o.Point=function(t,e,i){this.x=i?Math.round(t):t,this.y=i?Math.round(e):e},o.Point.prototype={clone:function(){return new o.Point(this.x,this.y)},add:function(t){return this.clone()._add(o.point(t))},_add:function(t){return this.x+=t.x,this.y+=t.y,this},subtract:function(t){return this.clone()._subtract(o.point(t))},_subtract:function(t){return this.x-=t.x,this.y-=t.y,this},divideBy:function(t){return this.clone()._divideBy(t)},_divideBy:function(t){return this.x/=t,this.y/=t,this},multiplyBy:function(t){return this.clone()._multiplyBy(t)},_multiplyBy:function(t){return this.x*=t,this.y*=t,this},scaleBy:function(t){return new o.Point(this.x*t.x,this.y*t.y)},unscaleBy:function(t){return new o.Point(this.x/t.x,this.y/t.y)},round:function(){return this.clone()._round()},_round:function(){return this.x=Math.round(this.x),this.y=Math.round(this.y),this},floor:function(){return this.clone()._floor()},_floor:function(){return this.x=Math.floor(this.x),this.y=Math.floor(this.y),this},ceil:function(){return this.clone()._ceil()},_ceil:function(){return this.x=Math.ceil(this.x),this.y=Math.ceil(this.y),this},distanceTo:function(t){t=o.point(t);var e=t.x-this.x,i=t.y-this.y;return Math.sqrt(e*e+i*i)},equals:function(t){return t=o.point(t),t.x===this.x&&t.y===this.y},contains:function(t){return t=o.point(t),Math.abs(t.x)<=Math.abs(this.x)&&Math.abs(t.y)<=Math.abs(this.y)},toString:function(){return"Point("+o.Util.formatNum(this.x)+", "+o.Util.formatNum(this.y)+")"}},o.point=function(t,e,n){return t instanceof o.Point?t:o.Util.isArray(t)?new o.Point(t[0],t[1]):t===i||null===t?t:"object"==typeof t&&"x"in t&&"y"in t?new o.Point(t.x,t.y):new o.Point(t,e,n)},o.Bounds=function(t,e){if(t)for(var i=e?[t,e]:t,n=0,o=i.length;n=this.min.x&&i.x<=this.max.x&&e.y>=this.min.y&&i.y<=this.max.y},intersects:function(t){t=o.bounds(t);var e=this.min,i=this.max,n=t.min,s=t.max,r=s.x>=e.x&&n.x<=i.x,a=s.y>=e.y&&n.y<=i.y;return r&&a},overlaps:function(t){t=o.bounds(t);var e=this.min,i=this.max,n=t.min,s=t.max,r=s.x>e.x&&n.xe.y&&n.y0&&new RegExp("(^|\\s)"+e+"(\\s|$)").test(n)},addClass:function(t,e){if(t.classList!==i)for(var n=o.Util.splitWords(e),s=0,r=n.length;s=n.lat&&i.lat<=s.lat&&e.lng>=n.lng&&i.lng<=s.lng},intersects:function(t){t=o.latLngBounds(t);var e=this._southWest,i=this._northEast,n=t.getSouthWest(),s=t.getNorthEast(),r=s.lat>=e.lat&&n.lat<=i.lat,a=s.lng>=e.lng&&n.lng<=i.lng;return r&&a},overlaps:function(t){t=o.latLngBounds(t);var e=this._southWest,i=this._northEast,n=t.getSouthWest(),s=t.getNorthEast(),r=s.lat>e.lat&&n.late.lng&&n.lngthis.options.maxZoom?this.setZoom(t):this},panInsideBounds:function(t,e){this._enforcingBounds=!0;var i=this.getCenter(),n=this._limitCenter(i,this._zoom,o.latLngBounds(t));return i.equals(n)||this.panTo(n,e),this._enforcingBounds=!1,this},invalidateSize:function(t){if(!this._loaded)return this;t=o.extend({animate:!1,pan:!0},t===!0?{animate:!0}:t);var e=this.getSize();this._sizeChanged=!0,this._lastCenter=null;var i=this.getSize(),n=e.divideBy(2).round(),s=i.divideBy(2).round(),r=n.subtract(s);return r.x||r.y?(t.animate&&t.pan?this.panBy(r):(t.pan&&this._rawPanBy(r),this.fire("move"),t.debounceMoveend?(clearTimeout(this._sizeTimer),this._sizeTimer=setTimeout(o.bind(this.fire,this,"moveend"),200)):this.fire("moveend")),this.fire("resize",{oldSize:e,newSize:i})):this},stop:function(){return this.setZoom(this._limitZoom(this._zoom)),this.options.zoomSnap||this.fire("viewreset"),this._stop()},locate:function(t){if(t=this._locateOptions=o.extend({timeout:1e4,watch:!1},t),!("geolocation"in navigator))return this._handleGeolocationError({code:0,message:"Geolocation not supported."}),this;var e=o.bind(this._handleGeolocationResponse,this),i=o.bind(this._handleGeolocationError,this);return t.watch?this._locationWatchId=navigator.geolocation.watchPosition(e,i,t):navigator.geolocation.getCurrentPosition(e,i,t),this},stopLocate:function(){return navigator.geolocation&&navigator.geolocation.clearWatch&&navigator.geolocation.clearWatch(this._locationWatchId),this._locateOptions&&(this._locateOptions.setView=!1),this},_handleGeolocationError:function(t){var e=t.code,i=t.message||(1===e?"permission denied":2===e?"position unavailable":"timeout");this._locateOptions.setView&&!this._loaded&&this.fitWorld(),this.fire("locationerror",{code:e,message:"Geolocation error: "+i+"."})},_handleGeolocationResponse:function(t){var e=t.coords.latitude,i=t.coords.longitude,n=new o.LatLng(e,i),s=n.toBounds(t.coords.accuracy),r=this._locateOptions;if(r.setView){var a=this.getBoundsZoom(s);this.setView(n,r.maxZoom?Math.min(a,r.maxZoom):a)}var h={latlng:n,bounds:s,timestamp:t.timestamp};for(var l in t.coords)"number"==typeof t.coords[l]&&(h[l]=t.coords[l]);this.fire("locationfound",h)},addHandler:function(t,e){if(!e)return this;var i=this[t]=new e(this);return this._handlers.push(i),this.options[t]&&i.enable(),this},remove:function(){if(this._initEvents(!0),this._containerId!==this._container._leaflet_id)throw new Error("Map container is being reused by another instance");try{delete this._container._leaflet_id,delete this._containerId}catch(t){this._container._leaflet_id=i,this._containerId=i}o.DomUtil.remove(this._mapPane),this._clearControlPos&&this._clearControlPos(),this._clearHandlers(),this._loaded&&this.fire("unload");for(var t in this._layers)this._layers[t].remove();return this},createPane:function(t,e){var i="leaflet-pane"+(t?" leaflet-"+t.replace("Pane","")+"-pane":""),n=o.DomUtil.create("div",i,e||this._mapPane);return t&&(this._panes[t]=n),n},getCenter:function(){return this._checkIfLoaded(),this._lastCenter&&!this._moved()?this._lastCenter:this.layerPointToLatLng(this._getCenterLayerPoint())},getZoom:function(){return this._zoom},getBounds:function(){var t=this.getPixelBounds(),e=this.unproject(t.getBottomLeft()),i=this.unproject(t.getTopRight());return new o.LatLngBounds(e,i)},getMinZoom:function(){return this.options.minZoom===i?this._layersMinZoom||0:this.options.minZoom},getMaxZoom:function(){return this.options.maxZoom===i?this._layersMaxZoom===i?1/0:this._layersMaxZoom:this.options.maxZoom},getBoundsZoom:function(t,e,i){t=o.latLngBounds(t),i=o.point(i||[0,0]);var n=this.getZoom()||0,s=this.getMinZoom(),r=this.getMaxZoom(),a=t.getNorthWest(),h=t.getSouthEast(),l=this.getSize().subtract(i),u=o.bounds(this.project(h,n),this.project(a,n)).getSize(),c=o.Browser.any3d?this.options.zoomSnap:1,d=Math.min(l.x/u.x,l.y/u.y);return n=this.getScaleZoom(d,n),c&&(n=Math.round(n/(c/100))*(c/100),n=e?Math.ceil(n/c)*c:Math.floor(n/c)*c),Math.max(s,Math.min(r,n))},getSize:function(){return this._size&&!this._sizeChanged||(this._size=new o.Point(this._container.clientWidth||0,this._container.clientHeight||0),this._sizeChanged=!1),this._size.clone()},getPixelBounds:function(t,e){var i=this._getTopLeftPoint(t,e);return new o.Bounds(i,i.add(this.getSize()))},getPixelOrigin:function(){return this._checkIfLoaded(),this._pixelOrigin},getPixelWorldBounds:function(t){return this.options.crs.getProjectedBounds(t===i?this.getZoom():t)},getPane:function(t){return"string"==typeof t?this._panes[t]:t},getPanes:function(){return this._panes},getContainer:function(){return this._container},getZoomScale:function(t,e){var n=this.options.crs;return e=e===i?this._zoom:e,n.scale(t)/n.scale(e)},getScaleZoom:function(t,e){var n=this.options.crs;e=e===i?this._zoom:e;var o=n.zoom(t*n.scale(e));return isNaN(o)?1/0:o},project:function(t,e){return e=e===i?this._zoom:e,this.options.crs.latLngToPoint(o.latLng(t),e)},unproject:function(t,e){return e=e===i?this._zoom:e,this.options.crs.pointToLatLng(o.point(t),e)},layerPointToLatLng:function(t){var e=o.point(t).add(this.getPixelOrigin());return this.unproject(e)},latLngToLayerPoint:function(t){var e=this.project(o.latLng(t))._round();return e._subtract(this.getPixelOrigin())},wrapLatLng:function(t){return this.options.crs.wrapLatLng(o.latLng(t))},wrapLatLngBounds:function(t){return this.options.crs.wrapLatLngBounds(o.latLngBounds(t))},distance:function(t,e){return this.options.crs.distance(o.latLng(t),o.latLng(e))},containerPointToLayerPoint:function(t){return o.point(t).subtract(this._getMapPanePos())},layerPointToContainerPoint:function(t){return o.point(t).add(this._getMapPanePos())},containerPointToLatLng:function(t){var e=this.containerPointToLayerPoint(o.point(t));return this.layerPointToLatLng(e)},latLngToContainerPoint:function(t){return this.layerPointToContainerPoint(this.latLngToLayerPoint(o.latLng(t)))},mouseEventToContainerPoint:function(t){return o.DomEvent.getMousePosition(t,this._container)},mouseEventToLayerPoint:function(t){return this.containerPointToLayerPoint(this.mouseEventToContainerPoint(t))},mouseEventToLatLng:function(t){return this.layerPointToLatLng(this.mouseEventToLayerPoint(t))},_initContainer:function(t){var e=this._container=o.DomUtil.get(t);if(!e)throw new Error("Map container not found.");if(e._leaflet_id)throw new Error("Map container is already initialized.");o.DomEvent.addListener(e,"scroll",this._onScroll,this),this._containerId=o.Util.stamp(e)},_initLayout:function(){var t=this._container;this._fadeAnimated=this.options.fadeAnimation&&o.Browser.any3d,o.DomUtil.addClass(t,"leaflet-container"+(o.Browser.touch?" leaflet-touch":"")+(o.Browser.retina?" leaflet-retina":"")+(o.Browser.ielt9?" leaflet-oldie":"")+(o.Browser.safari?" leaflet-safari":"")+(this._fadeAnimated?" leaflet-fade-anim":""));
+var e=o.DomUtil.getStyle(t,"position");"absolute"!==e&&"relative"!==e&&"fixed"!==e&&(t.style.position="relative"),this._initPanes(),this._initControlPos&&this._initControlPos()},_initPanes:function(){var t=this._panes={};this._paneRenderers={},this._mapPane=this.createPane("mapPane",this._container),o.DomUtil.setPosition(this._mapPane,new o.Point(0,0)),this.createPane("tilePane"),this.createPane("shadowPane"),this.createPane("overlayPane"),this.createPane("markerPane"),this.createPane("tooltipPane"),this.createPane("popupPane"),this.options.markerZoomAnimation||(o.DomUtil.addClass(t.markerPane,"leaflet-zoom-hide"),o.DomUtil.addClass(t.shadowPane,"leaflet-zoom-hide"))},_resetView:function(t,e){o.DomUtil.setPosition(this._mapPane,new o.Point(0,0));var i=!this._loaded;this._loaded=!0,e=this._limitZoom(e),this.fire("viewprereset");var n=this._zoom!==e;this._moveStart(n)._move(t,e)._moveEnd(n),this.fire("viewreset"),i&&this.fire("load")},_moveStart:function(t){return t&&this.fire("zoomstart"),this.fire("movestart")},_move:function(t,e,n){e===i&&(e=this._zoom);var o=this._zoom!==e;return this._zoom=e,this._lastCenter=t,this._pixelOrigin=this._getNewPixelOrigin(t),(o||n&&n.pinch)&&this.fire("zoom",n),this.fire("move",n)},_moveEnd:function(t){return t&&this.fire("zoomend"),this.fire("moveend")},_stop:function(){return o.Util.cancelAnimFrame(this._flyToFrame),this._panAnim&&this._panAnim.stop(),this},_rawPanBy:function(t){o.DomUtil.setPosition(this._mapPane,this._getMapPanePos().subtract(t))},_getZoomSpan:function(){return this.getMaxZoom()-this.getMinZoom()},_panInsideMaxBounds:function(){this._enforcingBounds||this.panInsideBounds(this.options.maxBounds)},_checkIfLoaded:function(){if(!this._loaded)throw new Error("Set map center and zoom first.")},_initEvents:function(e){if(o.DomEvent){this._targets={},this._targets[o.stamp(this._container)]=this;var i=e?"off":"on";o.DomEvent[i](this._container,"click dblclick mousedown mouseup mouseover mouseout mousemove contextmenu keypress",this._handleDOMEvent,this),this.options.trackResize&&o.DomEvent[i](t,"resize",this._onResize,this),o.Browser.any3d&&this.options.transform3DLimit&&this[i]("moveend",this._onMoveEnd)}},_onResize:function(){o.Util.cancelAnimFrame(this._resizeRequest),this._resizeRequest=o.Util.requestAnimFrame(function(){this.invalidateSize({debounceMoveend:!0})},this)},_onScroll:function(){this._container.scrollTop=0,this._container.scrollLeft=0},_onMoveEnd:function(){var t=this._getMapPanePos();Math.max(Math.abs(t.x),Math.abs(t.y))>=this.options.transform3DLimit&&this._resetView(this.getCenter(),this.getZoom())},_findEventTargets:function(t,e){for(var i,n=[],s="mouseout"===e||"mouseover"===e,r=t.target||t.srcElement,a=!1;r;){if(i=this._targets[o.stamp(r)],i&&("click"===e||"preclick"===e)&&!t._simulated&&this._draggableMoved(i)){a=!0;break}if(i&&i.listens(e,!0)){if(s&&!o.DomEvent._isExternalTarget(r,t))break;if(n.push(i),s)break}if(r===this._container)break;r=r.parentNode}return n.length||a||s||!o.DomEvent._isExternalTarget(r,t)||(n=[this]),n},_handleDOMEvent:function(t){if(this._loaded&&!o.DomEvent._skipped(t)){var e="keypress"===t.type&&13===t.keyCode?"click":t.type;"mousedown"===e&&o.DomUtil.preventOutline(t.target||t.srcElement),this._fireDOMEvent(t,e)}},_fireDOMEvent:function(t,e,i){if("click"===t.type){var n=o.Util.extend({},t);n.type="preclick",this._fireDOMEvent(n,n.type,i)}if(!t._stopped&&(i=(i||[]).concat(this._findEventTargets(t,e)),i.length)){var s=i[0];"contextmenu"===e&&s.listens(e,!0)&&o.DomEvent.preventDefault(t);var r={originalEvent:t};if("keypress"!==t.type){var a=s instanceof o.Marker;r.containerPoint=a?this.latLngToContainerPoint(s.getLatLng()):this.mouseEventToContainerPoint(t),r.layerPoint=this.containerPointToLayerPoint(r.containerPoint),r.latlng=a?s.getLatLng():this.layerPointToLatLng(r.layerPoint)}for(var h=0;h0?Math.round(t-e)/2:Math.max(0,Math.ceil(t))-Math.max(0,Math.floor(e))},_limitZoom:function(t){var e=this.getMinZoom(),i=this.getMaxZoom(),n=o.Browser.any3d?this.options.zoomSnap:1;return n&&(t=Math.round(t/n)*n),Math.max(e,Math.min(i,t))},_onPanTransitionStep:function(){this.fire("move")},_onPanTransitionEnd:function(){o.DomUtil.removeClass(this._mapPane,"leaflet-pan-anim"),this.fire("moveend")},_tryAnimatedPan:function(t,e){var i=this._getCenterOffset(t)._floor();return!((e&&e.animate)!==!0&&!this.getSize().contains(i))&&(this.panBy(i,e),!0)},_createAnimProxy:function(){var t=this._proxy=o.DomUtil.create("div","leaflet-proxy leaflet-zoom-animated");this._panes.mapPane.appendChild(t),this.on("zoomanim",function(e){var i=o.DomUtil.TRANSFORM,n=t.style[i];o.DomUtil.setTransform(t,this.project(e.center,e.zoom),this.getZoomScale(e.zoom,1)),n===t.style[i]&&this._animatingZoom&&this._onZoomTransitionEnd()},this),this.on("load moveend",function(){var e=this.getCenter(),i=this.getZoom();o.DomUtil.setTransform(t,this.project(e,i),this.getZoomScale(i,1))},this)},_catchTransitionEnd:function(t){this._animatingZoom&&t.propertyName.indexOf("transform")>=0&&this._onZoomTransitionEnd()},_nothingToAnimate:function(){return!this._container.getElementsByClassName("leaflet-zoom-animated").length},_tryAnimatedZoom:function(t,e,i){if(this._animatingZoom)return!0;if(i=i||{},!this._zoomAnimated||i.animate===!1||this._nothingToAnimate()||Math.abs(e-this._zoom)>this.options.zoomAnimationThreshold)return!1;var n=this.getZoomScale(e),s=this._getCenterOffset(t)._divideBy(1-1/n);return!(i.animate!==!0&&!this.getSize().contains(s))&&(o.Util.requestAnimFrame(function(){this._moveStart(!0)._animateZoom(t,e,!0)},this),!0)},_animateZoom:function(t,e,i,n){i&&(this._animatingZoom=!0,this._animateToCenter=t,this._animateToZoom=e,o.DomUtil.addClass(this._mapPane,"leaflet-zoom-anim")),this.fire("zoomanim",{center:t,zoom:e,noUpdate:n}),setTimeout(o.bind(this._onZoomTransitionEnd,this),250)},_onZoomTransitionEnd:function(){this._animatingZoom&&(o.DomUtil.removeClass(this._mapPane,"leaflet-zoom-anim"),this._animatingZoom=!1,this._move(this._animateToCenter,this._animateToZoom),o.Util.requestAnimFrame(function(){this._moveEnd(!0)},this))}}),o.map=function(t,e){return new o.Map(t,e)},o.Layer=o.Evented.extend({options:{pane:"overlayPane",nonBubblingEvents:[],attribution:null},addTo:function(t){return t.addLayer(this),this},remove:function(){return this.removeFrom(this._map||this._mapToAdd)},removeFrom:function(t){return t&&t.removeLayer(this),this},getPane:function(t){return this._map.getPane(t?this.options[t]||t:this.options.pane)},addInteractiveTarget:function(t){return this._map._targets[o.stamp(t)]=this,this},removeInteractiveTarget:function(t){return delete this._map._targets[o.stamp(t)],this},getAttribution:function(){return this.options.attribution},_layerAdd:function(t){var e=t.target;if(e.hasLayer(this)){if(this._map=e,this._zoomAnimated=e._zoomAnimated,this.getEvents){var i=this.getEvents();e.on(i,this),this.once("remove",function(){e.off(i,this)},this)}this.onAdd(e),this.getAttribution&&e.attributionControl&&e.attributionControl.addAttribution(this.getAttribution()),this.fire("add"),e.fire("layeradd",{layer:this})}}}),o.Map.include({addLayer:function(t){var e=o.stamp(t);return this._layers[e]?this:(this._layers[e]=t,t._mapToAdd=this,t.beforeAdd&&t.beforeAdd(this),this.whenReady(t._layerAdd,t),this)},removeLayer:function(t){var e=o.stamp(t);return this._layers[e]?(this._loaded&&t.onRemove(this),t.getAttribution&&this.attributionControl&&this.attributionControl.removeAttribution(t.getAttribution()),delete this._layers[e],this._loaded&&(this.fire("layerremove",{layer:t}),t.fire("remove")),t._map=t._mapToAdd=null,this):this},hasLayer:function(t){return!!t&&o.stamp(t)in this._layers},eachLayer:function(t,e){for(var i in this._layers)t.call(e,this._layers[i]);return this},_addLayers:function(t){t=t?o.Util.isArray(t)?t:[t]:[];for(var e=0,i=t.length;ethis._layersMaxZoom&&this.setZoom(this._layersMaxZoom),this.options.minZoom===i&&this._layersMinZoom&&this.getZoom()100&&n<500||t.target._simulatedClick&&!t._simulated?void o.DomEvent.stop(t):(o.DomEvent._lastClick=i,void e(t))}},o.DomEvent.addListener=o.DomEvent.on,o.DomEvent.removeListener=o.DomEvent.off,o.PosAnimation=o.Evented.extend({run:function(t,e,i,n){this.stop(),this._el=t,this._inProgress=!0,this._duration=i||.25,this._easeOutPower=1/Math.max(n||.5,.2),this._startPos=o.DomUtil.getPosition(t),this._offset=e.subtract(this._startPos),this._startTime=+new Date,this.fire("start"),this._animate()},stop:function(){this._inProgress&&(this._step(!0),this._complete())},_animate:function(){this._animId=o.Util.requestAnimFrame(this._animate,this),this._step()},_step:function(t){var e=+new Date-this._startTime,i=1e3*this._duration;e1e-7;l++)e=r*Math.sin(h),e=Math.pow((1-e)/(1+e),r/2),u=Math.PI/2-2*Math.atan(a*e)-h,h+=u;return new o.LatLng(h*i,t.x*i/n)}},o.CRS.EPSG3395=o.extend({},o.CRS.Earth,{code:"EPSG:3395",projection:o.Projection.Mercator,transformation:function(){var t=.5/(Math.PI*o.Projection.Mercator.R);return new o.Transformation(t,.5,-t,.5)}()}),o.GridLayer=o.Layer.extend({options:{tileSize:256,opacity:1,updateWhenIdle:o.Browser.mobile,updateWhenZooming:!0,updateInterval:200,zIndex:1,bounds:null,minZoom:0,maxZoom:i,noWrap:!1,pane:"tilePane",className:"",keepBuffer:2},initialize:function(t){o.setOptions(this,t)},onAdd:function(){this._initContainer(),this._levels={},this._tiles={},this._resetView(),this._update()},beforeAdd:function(t){t._addZoomLimit(this)},onRemove:function(t){this._removeAllTiles(),o.DomUtil.remove(this._container),t._removeZoomLimit(this),this._container=null,this._tileZoom=null},bringToFront:function(){return this._map&&(o.DomUtil.toFront(this._container),this._setAutoZIndex(Math.max)),this},bringToBack:function(){return this._map&&(o.DomUtil.toBack(this._container),this._setAutoZIndex(Math.min)),this},getContainer:function(){return this._container},setOpacity:function(t){return this.options.opacity=t,this._updateOpacity(),this},setZIndex:function(t){return this.options.zIndex=t,this._updateZIndex(),this},isLoading:function(){return this._loading},redraw:function(){return this._map&&(this._removeAllTiles(),this._update()),this},getEvents:function(){var t={viewprereset:this._invalidateAll,viewreset:this._resetView,zoom:this._resetView,moveend:this._onMoveEnd};return this.options.updateWhenIdle||(this._onMove||(this._onMove=o.Util.throttle(this._onMoveEnd,this.options.updateInterval,this)),t.move=this._onMove),this._zoomAnimated&&(t.zoomanim=this._animateZoom),t},createTile:function(){return e.createElement("div")},getTileSize:function(){var t=this.options.tileSize;return t instanceof o.Point?t:new o.Point(t,t)},_updateZIndex:function(){this._container&&this.options.zIndex!==i&&null!==this.options.zIndex&&(this._container.style.zIndex=this.options.zIndex)},_setAutoZIndex:function(t){for(var e,i=this.getPane().children,n=-t(-(1/0),1/0),o=0,s=i.length;othis.options.maxZoom||in&&this._retainParent(s,r,a,n))},_retainChildren:function(t,e,i,n){for(var s=2*t;s<2*t+2;s++)for(var r=2*e;r<2*e+2;r++){var a=new o.Point(s,r);a.z=i+1;var h=this._tileCoordsToKey(a),l=this._tiles[h];l&&l.active?l.retain=!0:(l&&l.loaded&&(l.retain=!0),i+1this.options.maxZoom||this.options.minZoom!==i&&s1)return void this._setView(t,s);for(var m=a.min.y;m<=a.max.y;m++)for(var p=a.min.x;p<=a.max.x;p++){var f=new o.Point(p,m);if(f.z=this._tileZoom,this._isValidTile(f)){var g=this._tiles[this._tileCoordsToKey(f)];g?g.current=!0:l.push(f)}}if(l.sort(function(t,e){return t.distanceTo(h)-e.distanceTo(h)}),0!==l.length){this._loading||(this._loading=!0,this.fire("loading"));var v=e.createDocumentFragment();for(p=0;pi.max.x)||!e.wrapLat&&(t.yi.max.y))return!1}if(!this.options.bounds)return!0;var n=this._tileCoordsToBounds(t);return o.latLngBounds(this.options.bounds).overlaps(n)},_keyToBounds:function(t){return this._tileCoordsToBounds(this._keyToTileCoords(t))},_tileCoordsToBounds:function(t){var e=this._map,i=this.getTileSize(),n=t.scaleBy(i),s=n.add(i),r=e.unproject(n,t.z),a=e.unproject(s,t.z),h=new o.LatLngBounds(r,a);return this.options.noWrap||e.wrapLatLngBounds(h),h},_tileCoordsToKey:function(t){return t.x+":"+t.y+":"+t.z},_keyToTileCoords:function(t){var e=t.split(":"),i=new o.Point(+e[0],+e[1]);return i.z=+e[2],i},_removeTile:function(t){var e=this._tiles[t];e&&(o.DomUtil.remove(e.el),delete this._tiles[t],this.fire("tileunload",{tile:e.el,coords:this._keyToTileCoords(t)}))},_initTile:function(t){o.DomUtil.addClass(t,"leaflet-tile");var e=this.getTileSize();t.style.width=e.x+"px",t.style.height=e.y+"px",t.onselectstart=o.Util.falseFn,t.onmousemove=o.Util.falseFn,o.Browser.ielt9&&this.options.opacity<1&&o.DomUtil.setOpacity(t,this.options.opacity),o.Browser.android&&!o.Browser.android23&&(t.style.WebkitBackfaceVisibility="hidden")},_addTile:function(t,e){var i=this._getTilePos(t),n=this._tileCoordsToKey(t),s=this.createTile(this._wrapCoords(t),o.bind(this._tileReady,this,t));this._initTile(s),this.createTile.length<2&&o.Util.requestAnimFrame(o.bind(this._tileReady,this,t,null,s)),o.DomUtil.setPosition(s,i),this._tiles[n]={el:s,coords:t,current:!0},e.appendChild(s),this.fire("tileloadstart",{tile:s,coords:t})},_tileReady:function(t,e,i){if(this._map){e&&this.fire("tileerror",{error:e,tile:i,coords:t});var n=this._tileCoordsToKey(t);i=this._tiles[n],i&&(i.loaded=+new Date,this._map._fadeAnimated?(o.DomUtil.setOpacity(i.el,0),o.Util.cancelAnimFrame(this._fadeFrame),this._fadeFrame=o.Util.requestAnimFrame(this._updateOpacity,this)):(i.active=!0,this._pruneTiles()),e||(o.DomUtil.addClass(i.el,"leaflet-tile-loaded"),this.fire("tileload",{tile:i.el,coords:t})),this._noTilesToLoad()&&(this._loading=!1,this.fire("load"),o.Browser.ielt9||!this._map._fadeAnimated?o.Util.requestAnimFrame(this._pruneTiles,this):setTimeout(o.bind(this._pruneTiles,this),250)))}},_getTilePos:function(t){return t.scaleBy(this.getTileSize()).subtract(this._level.origin)},_wrapCoords:function(t){var e=new o.Point(this._wrapX?o.Util.wrapNum(t.x,this._wrapX):t.x,this._wrapY?o.Util.wrapNum(t.y,this._wrapY):t.y);return e.z=t.z,e},_pxBoundsToTileRange:function(t){var e=this.getTileSize();return new o.Bounds(t.min.unscaleBy(e).floor(),t.max.unscaleBy(e).ceil().subtract([1,1]))},_noTilesToLoad:function(){for(var t in this._tiles)if(!this._tiles[t].loaded)return!1;return!0}}),o.gridLayer=function(t){return new o.GridLayer(t)},o.TileLayer=o.GridLayer.extend({options:{minZoom:0,maxZoom:18,maxNativeZoom:null,minNativeZoom:null,subdomains:"abc",errorTileUrl:"",zoomOffset:0,tms:!1,zoomReverse:!1,detectRetina:!1,crossOrigin:!1},initialize:function(t,e){this._url=t,e=o.setOptions(this,e),e.detectRetina&&o.Browser.retina&&e.maxZoom>0&&(e.tileSize=Math.floor(e.tileSize/2),e.zoomReverse?(e.zoomOffset--,e.minZoom++):(e.zoomOffset++,e.maxZoom--),e.minZoom=Math.max(0,e.minZoom)),"string"==typeof e.subdomains&&(e.subdomains=e.subdomains.split("")),o.Browser.android||this.on("tileunload",this._onTileRemove)},setUrl:function(t,e){return this._url=t,e||this.redraw(),this},createTile:function(t,i){var n=e.createElement("img");return o.DomEvent.on(n,"load",o.bind(this._tileOnLoad,this,i,n)),o.DomEvent.on(n,"error",o.bind(this._tileOnError,this,i,n)),this.options.crossOrigin&&(n.crossOrigin=""),n.alt="",n.setAttribute("role","presentation"),n.src=this.getTileUrl(t),n},getTileUrl:function(t){var e={r:o.Browser.retina?"@2x":"",s:this._getSubdomain(t),x:t.x,y:t.y,z:this._getZoomForUrl()};if(this._map&&!this._map.options.crs.infinite){var i=this._globalTileRange.max.y-t.y;this.options.tms&&(e.y=i),e["-y"]=i}return o.Util.template(this._url,o.extend(e,this.options))},_tileOnLoad:function(t,e){o.Browser.ielt9?setTimeout(o.bind(t,this,null,e),0):t(null,e)},_tileOnError:function(t,e,i){var n=this.options.errorTileUrl;n&&e.src!==n&&(e.src=n),t(i,e)},getTileSize:function(){var t=this._map,e=o.GridLayer.prototype.getTileSize.call(this),i=this._tileZoom+this.options.zoomOffset,n=this.options.minNativeZoom,s=this.options.maxNativeZoom;return null!==n&&is?e.divideBy(t.getZoomScale(s,i)).round():e},_onTileRemove:function(t){t.tile.onload=null},_getZoomForUrl:function(){var t=this._tileZoom,e=this.options.maxZoom,i=this.options.zoomReverse,n=this.options.zoomOffset,o=this.options.minNativeZoom,s=this.options.maxNativeZoom;return i&&(t=e-t),t+=n,null!==o&&ts?s:t},_getSubdomain:function(t){var e=Math.abs(t.x+t.y)%this.options.subdomains.length;return this.options.subdomains[e]},_abortLoading:function(){var t,e;for(t in this._tiles)this._tiles[t].coords.z!==this._tileZoom&&(e=this._tiles[t].el,e.onload=o.Util.falseFn,e.onerror=o.Util.falseFn,e.complete||(e.src=o.Util.emptyImageUrl,o.DomUtil.remove(e)))}}),o.tileLayer=function(t,e){return new o.TileLayer(t,e)},o.TileLayer.WMS=o.TileLayer.extend({defaultWmsParams:{service:"WMS",request:"GetMap",layers:"",styles:"",format:"image/jpeg",transparent:!1,version:"1.1.1"},options:{crs:null,uppercase:!1},initialize:function(t,e){this._url=t;var i=o.extend({},this.defaultWmsParams);for(var n in e)n in this.options||(i[n]=e[n]);e=o.setOptions(this,e),i.width=i.height=e.tileSize*(e.detectRetina&&o.Browser.retina?2:1),this.wmsParams=i},onAdd:function(t){this._crs=this.options.crs||t.options.crs,this._wmsVersion=parseFloat(this.wmsParams.version);var e=this._wmsVersion>=1.3?"crs":"srs";this.wmsParams[e]=this._crs.code,o.TileLayer.prototype.onAdd.call(this,t)},getTileUrl:function(t){var e=this._tileCoordsToBounds(t),i=this._crs.project(e.getNorthWest()),n=this._crs.project(e.getSouthEast()),s=(this._wmsVersion>=1.3&&this._crs===o.CRS.EPSG4326?[n.y,i.x,i.y,n.x]:[i.x,n.y,n.x,i.y]).join(","),r=o.TileLayer.prototype.getTileUrl.call(this,t);return r+o.Util.getParamString(this.wmsParams,r,this.options.uppercase)+(this.options.uppercase?"&BBOX=":"&bbox=")+s},setParams:function(t,e){return o.extend(this.wmsParams,t),e||this.redraw(),this}}),o.tileLayer.wms=function(t,e){return new o.TileLayer.WMS(t,e)},o.ImageOverlay=o.Layer.extend({options:{opacity:1,alt:"",interactive:!1,crossOrigin:!1},initialize:function(t,e,i){this._url=t,this._bounds=o.latLngBounds(e),o.setOptions(this,i)},onAdd:function(){this._image||(this._initImage(),this.options.opacity<1&&this._updateOpacity()),this.options.interactive&&(o.DomUtil.addClass(this._image,"leaflet-interactive"),this.addInteractiveTarget(this._image)),this.getPane().appendChild(this._image),this._reset()},onRemove:function(){o.DomUtil.remove(this._image),this.options.interactive&&this.removeInteractiveTarget(this._image)},setOpacity:function(t){return this.options.opacity=t,this._image&&this._updateOpacity(),this},setStyle:function(t){return t.opacity&&this.setOpacity(t.opacity),this},bringToFront:function(){return this._map&&o.DomUtil.toFront(this._image),this},bringToBack:function(){return this._map&&o.DomUtil.toBack(this._image),this},setUrl:function(t){return this._url=t,this._image&&(this._image.src=t),this},setBounds:function(t){return this._bounds=t,this._map&&this._reset(),this},getEvents:function(){var t={zoom:this._reset,viewreset:this._reset};return this._zoomAnimated&&(t.zoomanim=this._animateZoom),t},getBounds:function(){return this._bounds},getElement:function(){return this._image},_initImage:function(){var t=this._image=o.DomUtil.create("img","leaflet-image-layer "+(this._zoomAnimated?"leaflet-zoom-animated":""));t.onselectstart=o.Util.falseFn,t.onmousemove=o.Util.falseFn,t.onload=o.bind(this.fire,this,"load"),this.options.crossOrigin&&(t.crossOrigin=""),t.src=this._url,t.alt=this.options.alt},_animateZoom:function(t){var e=this._map.getZoomScale(t.zoom),i=this._map._latLngBoundsToNewLayerBounds(this._bounds,t.zoom,t.center).min;o.DomUtil.setTransform(this._image,i,e)},_reset:function(){var t=this._image,e=new o.Bounds(this._map.latLngToLayerPoint(this._bounds.getNorthWest()),this._map.latLngToLayerPoint(this._bounds.getSouthEast())),i=e.getSize();
+o.DomUtil.setPosition(t,e.min),t.style.width=i.x+"px",t.style.height=i.y+"px"},_updateOpacity:function(){o.DomUtil.setOpacity(this._image,this.options.opacity)}}),o.imageOverlay=function(t,e,i){return new o.ImageOverlay(t,e,i)},o.Icon=o.Class.extend({initialize:function(t){o.setOptions(this,t)},createIcon:function(t){return this._createIcon("icon",t)},createShadow:function(t){return this._createIcon("shadow",t)},_createIcon:function(t,e){var i=this._getIconUrl(t);if(!i){if("icon"===t)throw new Error("iconUrl not set in Icon options (see the docs).");return null}var n=this._createImg(i,e&&"IMG"===e.tagName?e:null);return this._setIconStyles(n,t),n},_setIconStyles:function(t,e){var i=this.options,n=i[e+"Size"];"number"==typeof n&&(n=[n,n]);var s=o.point(n),r=o.point("shadow"===e&&i.shadowAnchor||i.iconAnchor||s&&s.divideBy(2,!0));t.className="leaflet-marker-"+e+" "+(i.className||""),r&&(t.style.marginLeft=-r.x+"px",t.style.marginTop=-r.y+"px"),s&&(t.style.width=s.x+"px",t.style.height=s.y+"px")},_createImg:function(t,i){return i=i||e.createElement("img"),i.src=t,i},_getIconUrl:function(t){return o.Browser.retina&&this.options[t+"RetinaUrl"]||this.options[t+"Url"]}}),o.icon=function(t){return new o.Icon(t)},o.Icon.Default=o.Icon.extend({options:{iconUrl:"marker-icon.png",iconRetinaUrl:"marker-icon-2x.png",shadowUrl:"marker-shadow.png",iconSize:[25,41],iconAnchor:[12,41],popupAnchor:[1,-34],tooltipAnchor:[16,-28],shadowSize:[41,41]},_getIconUrl:function(t){return o.Icon.Default.imagePath||(o.Icon.Default.imagePath=this._detectIconPath()),(this.options.imagePath||o.Icon.Default.imagePath)+o.Icon.prototype._getIconUrl.call(this,t)},_detectIconPath:function(){var t=o.DomUtil.create("div","leaflet-default-icon-path",e.body),i=o.DomUtil.getStyle(t,"background-image")||o.DomUtil.getStyle(t,"backgroundImage");return e.body.removeChild(t),0===i.indexOf("url")?i.replace(/^url\([\"\']?/,"").replace(/marker-icon\.png[\"\']?\)$/,""):""}}),o.Marker=o.Layer.extend({options:{icon:new o.Icon.Default,interactive:!0,draggable:!1,keyboard:!0,title:"",alt:"",zIndexOffset:0,opacity:1,riseOnHover:!1,riseOffset:250,pane:"markerPane",nonBubblingEvents:["click","dblclick","mouseover","mouseout","contextmenu"]},initialize:function(t,e){o.setOptions(this,e),this._latlng=o.latLng(t)},onAdd:function(t){this._zoomAnimated=this._zoomAnimated&&t.options.markerZoomAnimation,this._zoomAnimated&&t.on("zoomanim",this._animateZoom,this),this._initIcon(),this.update()},onRemove:function(t){this.dragging&&this.dragging.enabled()&&(this.options.draggable=!0,this.dragging.removeHooks()),this._zoomAnimated&&t.off("zoomanim",this._animateZoom,this),this._removeIcon(),this._removeShadow()},getEvents:function(){return{zoom:this.update,viewreset:this.update}},getLatLng:function(){return this._latlng},setLatLng:function(t){var e=this._latlng;return this._latlng=o.latLng(t),this.update(),this.fire("move",{oldLatLng:e,latlng:this._latlng})},setZIndexOffset:function(t){return this.options.zIndexOffset=t,this.update()},setIcon:function(t){return this.options.icon=t,this._map&&(this._initIcon(),this.update()),this._popup&&this.bindPopup(this._popup,this._popup.options),this},getElement:function(){return this._icon},update:function(){if(this._icon){var t=this._map.latLngToLayerPoint(this._latlng).round();this._setPos(t)}return this},_initIcon:function(){var t=this.options,e="leaflet-zoom-"+(this._zoomAnimated?"animated":"hide"),i=t.icon.createIcon(this._icon),n=!1;i!==this._icon&&(this._icon&&this._removeIcon(),n=!0,t.title&&(i.title=t.title),t.alt&&(i.alt=t.alt)),o.DomUtil.addClass(i,e),t.keyboard&&(i.tabIndex="0"),this._icon=i,t.riseOnHover&&this.on({mouseover:this._bringToFront,mouseout:this._resetZIndex});var s=t.icon.createShadow(this._shadow),r=!1;s!==this._shadow&&(this._removeShadow(),r=!0),s&&(o.DomUtil.addClass(s,e),s.alt=""),this._shadow=s,t.opacity<1&&this._updateOpacity(),n&&this.getPane().appendChild(this._icon),this._initInteraction(),s&&r&&this.getPane("shadowPane").appendChild(this._shadow)},_removeIcon:function(){this.options.riseOnHover&&this.off({mouseover:this._bringToFront,mouseout:this._resetZIndex}),o.DomUtil.remove(this._icon),this.removeInteractiveTarget(this._icon),this._icon=null},_removeShadow:function(){this._shadow&&o.DomUtil.remove(this._shadow),this._shadow=null},_setPos:function(t){o.DomUtil.setPosition(this._icon,t),this._shadow&&o.DomUtil.setPosition(this._shadow,t),this._zIndex=t.y+this.options.zIndexOffset,this._resetZIndex()},_updateZIndex:function(t){this._icon.style.zIndex=this._zIndex+t},_animateZoom:function(t){var e=this._map._latLngToNewLayerPoint(this._latlng,t.zoom,t.center).round();this._setPos(e)},_initInteraction:function(){if(this.options.interactive&&(o.DomUtil.addClass(this._icon,"leaflet-interactive"),this.addInteractiveTarget(this._icon),o.Handler.MarkerDrag)){var t=this.options.draggable;this.dragging&&(t=this.dragging.enabled(),this.dragging.disable()),this.dragging=new o.Handler.MarkerDrag(this),t&&this.dragging.enable()}},setOpacity:function(t){return this.options.opacity=t,this._map&&this._updateOpacity(),this},_updateOpacity:function(){var t=this.options.opacity;o.DomUtil.setOpacity(this._icon,t),this._shadow&&o.DomUtil.setOpacity(this._shadow,t)},_bringToFront:function(){this._updateZIndex(this.options.riseOffset)},_resetZIndex:function(){this._updateZIndex(0)},_getPopupAnchor:function(){return this.options.icon.options.popupAnchor||[0,0]},_getTooltipAnchor:function(){return this.options.icon.options.tooltipAnchor||[0,0]}}),o.marker=function(t,e){return new o.Marker(t,e)},o.DivIcon=o.Icon.extend({options:{iconSize:[12,12],html:!1,bgPos:null,className:"leaflet-div-icon"},createIcon:function(t){var i=t&&"DIV"===t.tagName?t:e.createElement("div"),n=this.options;if(i.innerHTML=n.html!==!1?n.html:"",n.bgPos){var s=o.point(n.bgPos);i.style.backgroundPosition=-s.x+"px "+-s.y+"px"}return this._setIconStyles(i,"icon"),i},createShadow:function(){return null}}),o.divIcon=function(t){return new o.DivIcon(t)},o.DivOverlay=o.Layer.extend({options:{offset:[0,7],className:"",pane:"popupPane"},initialize:function(t,e){o.setOptions(this,t),this._source=e},onAdd:function(t){this._zoomAnimated=t._zoomAnimated,this._container||this._initLayout(),t._fadeAnimated&&o.DomUtil.setOpacity(this._container,0),clearTimeout(this._removeTimeout),this.getPane().appendChild(this._container),this.update(),t._fadeAnimated&&o.DomUtil.setOpacity(this._container,1),this.bringToFront()},onRemove:function(t){t._fadeAnimated?(o.DomUtil.setOpacity(this._container,0),this._removeTimeout=setTimeout(o.bind(o.DomUtil.remove,o.DomUtil,this._container),200)):o.DomUtil.remove(this._container)},getLatLng:function(){return this._latlng},setLatLng:function(t){return this._latlng=o.latLng(t),this._map&&(this._updatePosition(),this._adjustPan()),this},getContent:function(){return this._content},setContent:function(t){return this._content=t,this.update(),this},getElement:function(){return this._container},update:function(){this._map&&(this._container.style.visibility="hidden",this._updateContent(),this._updateLayout(),this._updatePosition(),this._container.style.visibility="",this._adjustPan())},getEvents:function(){var t={zoom:this._updatePosition,viewreset:this._updatePosition};return this._zoomAnimated&&(t.zoomanim=this._animateZoom),t},isOpen:function(){return!!this._map&&this._map.hasLayer(this)},bringToFront:function(){return this._map&&o.DomUtil.toFront(this._container),this},bringToBack:function(){return this._map&&o.DomUtil.toBack(this._container),this},_updateContent:function(){if(this._content){var t=this._contentNode,e="function"==typeof this._content?this._content(this._source||this):this._content;if("string"==typeof e)t.innerHTML=e;else{for(;t.hasChildNodes();)t.removeChild(t.firstChild);t.appendChild(e)}this.fire("contentupdate")}},_updatePosition:function(){if(this._map){var t=this._map.latLngToLayerPoint(this._latlng),e=o.point(this.options.offset),i=this._getAnchor();this._zoomAnimated?o.DomUtil.setPosition(this._container,t.add(i)):e=e.add(t).add(i);var n=this._containerBottom=-e.y,s=this._containerLeft=-Math.round(this._containerWidth/2)+e.x;this._container.style.bottom=n+"px",this._container.style.left=s+"px"}},_getAnchor:function(){return[0,0]}}),o.Popup=o.DivOverlay.extend({options:{maxWidth:300,minWidth:50,maxHeight:null,autoPan:!0,autoPanPaddingTopLeft:null,autoPanPaddingBottomRight:null,autoPanPadding:[5,5],keepInView:!1,closeButton:!0,autoClose:!0,className:""},openOn:function(t){return t.openPopup(this),this},onAdd:function(t){o.DivOverlay.prototype.onAdd.call(this,t),t.fire("popupopen",{popup:this}),this._source&&(this._source.fire("popupopen",{popup:this},!0),this._source instanceof o.Path||this._source.on("preclick",o.DomEvent.stopPropagation))},onRemove:function(t){o.DivOverlay.prototype.onRemove.call(this,t),t.fire("popupclose",{popup:this}),this._source&&(this._source.fire("popupclose",{popup:this},!0),this._source instanceof o.Path||this._source.off("preclick",o.DomEvent.stopPropagation))},getEvents:function(){var t=o.DivOverlay.prototype.getEvents.call(this);return("closeOnClick"in this.options?this.options.closeOnClick:this._map.options.closePopupOnClick)&&(t.preclick=this._close),this.options.keepInView&&(t.moveend=this._adjustPan),t},_close:function(){this._map&&this._map.closePopup(this)},_initLayout:function(){var t="leaflet-popup",e=this._container=o.DomUtil.create("div",t+" "+(this.options.className||"")+" leaflet-zoom-animated");if(this.options.closeButton){var i=this._closeButton=o.DomUtil.create("a",t+"-close-button",e);i.href="#close",i.innerHTML="×",o.DomEvent.on(i,"click",this._onCloseButtonClick,this)}var n=this._wrapper=o.DomUtil.create("div",t+"-content-wrapper",e);this._contentNode=o.DomUtil.create("div",t+"-content",n),o.DomEvent.disableClickPropagation(n).disableScrollPropagation(this._contentNode).on(n,"contextmenu",o.DomEvent.stopPropagation),this._tipContainer=o.DomUtil.create("div",t+"-tip-container",e),this._tip=o.DomUtil.create("div",t+"-tip",this._tipContainer)},_updateLayout:function(){var t=this._contentNode,e=t.style;e.width="",e.whiteSpace="nowrap";var i=t.offsetWidth;i=Math.min(i,this.options.maxWidth),i=Math.max(i,this.options.minWidth),e.width=i+1+"px",e.whiteSpace="",e.height="";var n=t.offsetHeight,s=this.options.maxHeight,r="leaflet-popup-scrolled";s&&n>s?(e.height=s+"px",o.DomUtil.addClass(t,r)):o.DomUtil.removeClass(t,r),this._containerWidth=this._container.offsetWidth},_animateZoom:function(t){var e=this._map._latLngToNewLayerPoint(this._latlng,t.zoom,t.center),i=this._getAnchor();o.DomUtil.setPosition(this._container,e.add(i))},_adjustPan:function(){if(!(!this.options.autoPan||this._map._panAnim&&this._map._panAnim._inProgress)){var t=this._map,e=parseInt(o.DomUtil.getStyle(this._container,"marginBottom"),10)||0,i=this._container.offsetHeight+e,n=this._containerWidth,s=new o.Point(this._containerLeft,-i-this._containerBottom);s._add(o.DomUtil.getPosition(this._container));var r=t.layerPointToContainerPoint(s),a=o.point(this.options.autoPanPadding),h=o.point(this.options.autoPanPaddingTopLeft||a),l=o.point(this.options.autoPanPaddingBottomRight||a),u=t.getSize(),c=0,d=0;r.x+n+l.x>u.x&&(c=r.x+n-u.x+l.x),r.x-c-h.x<0&&(c=r.x-h.x),r.y+i+l.y>u.y&&(d=r.y+i-u.y+l.y),r.y-d-h.y<0&&(d=r.y-h.y),(c||d)&&t.fire("autopanstart").panBy([c,d])}},_onCloseButtonClick:function(t){this._close(),o.DomEvent.stop(t)},_getAnchor:function(){return o.point(this._source&&this._source._getPopupAnchor?this._source._getPopupAnchor():[0,0])}}),o.popup=function(t,e){return new o.Popup(t,e)},o.Map.mergeOptions({closePopupOnClick:!0}),o.Map.include({openPopup:function(t,e,i){return t instanceof o.Popup||(t=new o.Popup(i).setContent(t)),e&&t.setLatLng(e),this.hasLayer(t)?this:(this._popup&&this._popup.options.autoClose&&this.closePopup(),this._popup=t,this.addLayer(t))},closePopup:function(t){return t&&t!==this._popup||(t=this._popup,this._popup=null),t&&this.removeLayer(t),this}}),o.Layer.include({bindPopup:function(t,e){return t instanceof o.Popup?(o.setOptions(t,e),this._popup=t,t._source=this):(this._popup&&!e||(this._popup=new o.Popup(e,this)),this._popup.setContent(t)),this._popupHandlersAdded||(this.on({click:this._openPopup,remove:this.closePopup,move:this._movePopup}),this._popupHandlersAdded=!0),this},unbindPopup:function(){return this._popup&&(this.off({click:this._openPopup,remove:this.closePopup,move:this._movePopup}),this._popupHandlersAdded=!1,this._popup=null),this},openPopup:function(t,e){if(t instanceof o.Layer||(e=t,t=this),t instanceof o.FeatureGroup)for(var i in this._layers){t=this._layers[i];break}return e||(e=t.getCenter?t.getCenter():t.getLatLng()),this._popup&&this._map&&(this._popup._source=t,this._popup.update(),this._map.openPopup(this._popup,e)),this},closePopup:function(){return this._popup&&this._popup._close(),this},togglePopup:function(t){return this._popup&&(this._popup._map?this.closePopup():this.openPopup(t)),this},isPopupOpen:function(){return!!this._popup&&this._popup.isOpen()},setPopupContent:function(t){return this._popup&&this._popup.setContent(t),this},getPopup:function(){return this._popup},_openPopup:function(t){var e=t.layer||t.target;if(this._popup&&this._map)return o.DomEvent.stop(t),e instanceof o.Path?void this.openPopup(t.layer||t.target,t.latlng):void(this._map.hasLayer(this._popup)&&this._popup._source===e?this.closePopup():this.openPopup(e,t.latlng))},_movePopup:function(t){this._popup.setLatLng(t.latlng)}}),o.Tooltip=o.DivOverlay.extend({options:{pane:"tooltipPane",offset:[0,0],direction:"auto",permanent:!1,sticky:!1,interactive:!1,opacity:.9},onAdd:function(t){o.DivOverlay.prototype.onAdd.call(this,t),this.setOpacity(this.options.opacity),t.fire("tooltipopen",{tooltip:this}),this._source&&this._source.fire("tooltipopen",{tooltip:this},!0)},onRemove:function(t){o.DivOverlay.prototype.onRemove.call(this,t),t.fire("tooltipclose",{tooltip:this}),this._source&&this._source.fire("tooltipclose",{tooltip:this},!0)},getEvents:function(){var t=o.DivOverlay.prototype.getEvents.call(this);return o.Browser.touch&&!this.options.permanent&&(t.preclick=this._close),t},_close:function(){this._map&&this._map.closeTooltip(this)},_initLayout:function(){var t="leaflet-tooltip",e=t+" "+(this.options.className||"")+" leaflet-zoom-"+(this._zoomAnimated?"animated":"hide");this._contentNode=this._container=o.DomUtil.create("div",e)},_updateLayout:function(){},_adjustPan:function(){},_setPosition:function(t){var e=this._map,i=this._container,n=e.latLngToContainerPoint(e.getCenter()),s=e.layerPointToContainerPoint(t),r=this.options.direction,a=i.offsetWidth,h=i.offsetHeight,l=o.point(this.options.offset),u=this._getAnchor();"top"===r?t=t.add(o.point(-a/2+l.x,-h+l.y+u.y,!0)):"bottom"===r?t=t.subtract(o.point(a/2-l.x,-l.y,!0)):"center"===r?t=t.subtract(o.point(a/2+l.x,h/2-u.y+l.y,!0)):"right"===r||"auto"===r&&s.xh&&(s=r,h=a);h>i&&(e[s]=1,this._simplifyDPStep(t,e,i,n,s),this._simplifyDPStep(t,e,i,s,o))},_reducePoints:function(t,e){for(var i=[t[0]],n=1,o=0,s=t.length;ne&&(i.push(t[n]),o=n);return oe.max.x&&(i|=2),t.ye.max.y&&(i|=8),i},_sqDist:function(t,e){var i=e.x-t.x,n=e.y-t.y;return i*i+n*n},_sqClosestPointOnSegment:function(t,e,i,n){var s,r=e.x,a=e.y,h=i.x-r,l=i.y-a,u=h*h+l*l;return u>0&&(s=((t.x-r)*h+(t.y-a)*l)/u,s>1?(r=i.x,a=i.y):s>0&&(r+=h*s,a+=l*s)),h=t.x-r,l=t.y-a,n?h*h+l*l:new o.Point(r,a)}},o.Polyline=o.Path.extend({options:{smoothFactor:1,noClip:!1},initialize:function(t,e){o.setOptions(this,e),this._setLatLngs(t)},getLatLngs:function(){return this._latlngs},setLatLngs:function(t){return this._setLatLngs(t),this.redraw()},isEmpty:function(){return!this._latlngs.length},closestLayerPoint:function(t){for(var e,i,n=1/0,s=null,r=o.LineUtil._sqClosestPointOnSegment,a=0,h=this._parts.length;ae)return r=(n-e)/i,this._map.layerPointToLatLng([s.x-r*(s.x-o.x),s.y-r*(s.y-o.y)])},getBounds:function(){return this._bounds},addLatLng:function(t,e){return e=e||this._defaultShape(),t=o.latLng(t),e.push(t),this._bounds.extend(t),this.redraw()},_setLatLngs:function(t){this._bounds=new o.LatLngBounds,this._latlngs=this._convertLatLngs(t)},_defaultShape:function(){return o.Polyline._flat(this._latlngs)?this._latlngs:this._latlngs[0]},_convertLatLngs:function(t){for(var e=[],i=o.Polyline._flat(t),n=0,s=t.length;n=2&&e[0]instanceof o.LatLng&&e[0].equals(e[i-1])&&e.pop(),e},_setLatLngs:function(t){o.Polyline.prototype._setLatLngs.call(this,t),o.Polyline._flat(this._latlngs)&&(this._latlngs=[this._latlngs])},_defaultShape:function(){return o.Polyline._flat(this._latlngs[0])?this._latlngs[0]:this._latlngs[0][0]},_clipPoints:function(){var t=this._renderer._bounds,e=this.options.weight,i=new o.Point(e,e);if(t=new o.Bounds(t.min.subtract(i),t.max.add(i)),this._parts=[],this._pxBounds&&this._pxBounds.intersects(t)){if(this.options.noClip)return void(this._parts=this._rings);for(var n,s=0,r=this._rings.length;s')}}catch(t){return function(t){return e.createElement("<"+t+' xmlns="urn:schemas-microsoft.com:vml" class="lvml">')}}}()),o.Canvas=o.Renderer.extend({getEvents:function(){var t=o.Renderer.prototype.getEvents.call(this);return t.viewprereset=this._onViewPreReset,t},_onViewPreReset:function(){this._postponeUpdatePaths=!0},onAdd:function(){o.Renderer.prototype.onAdd.call(this),this._draw()},_initContainer:function(){var t=this._container=e.createElement("canvas");o.DomEvent.on(t,"mousemove",o.Util.throttle(this._onMouseMove,32,this),this).on(t,"click dblclick mousedown mouseup contextmenu",this._onClick,this).on(t,"mouseout",this._handleMouseOut,this),this._ctx=t.getContext("2d")},_updatePaths:function(){if(!this._postponeUpdatePaths){var t;this._redrawBounds=null;for(var e in this._layers)t=this._layers[e],t._update();this._redraw()}},_update:function(){if(!this._map._animatingZoom||!this._bounds){this._drawnLayers={},o.Renderer.prototype._update.call(this);var t=this._bounds,e=this._container,i=t.getSize(),n=o.Browser.retina?2:1;o.DomUtil.setPosition(e,t.min),e.width=n*i.x,e.height=n*i.y,e.style.width=i.x+"px",e.style.height=i.y+"px",o.Browser.retina&&this._ctx.scale(2,2),this._ctx.translate(-t.min.x,-t.min.y),this.fire("update")}},_reset:function(){o.Renderer.prototype._reset.call(this),this._postponeUpdatePaths&&(this._postponeUpdatePaths=!1,this._updatePaths())},_initPath:function(t){this._updateDashArray(t),this._layers[o.stamp(t)]=t;var e=t._order={layer:t,prev:this._drawLast,next:null};this._drawLast&&(this._drawLast.next=e),this._drawLast=e,this._drawFirst=this._drawFirst||this._drawLast},_addPath:function(t){this._requestRedraw(t)},_removePath:function(t){var e=t._order,i=e.next,n=e.prev;i?i.prev=n:this._drawLast=n,n?n.next=i:this._drawFirst=i,delete t._order,delete this._layers[o.stamp(t)],this._requestRedraw(t)},_updatePath:function(t){this._extendRedrawBounds(t),t._project(),t._update(),this._requestRedraw(t)},_updateStyle:function(t){this._updateDashArray(t),this._requestRedraw(t)},_updateDashArray:function(t){if(t.options.dashArray){var e,i=t.options.dashArray.split(","),n=[];for(e=0;et.y!=n.y>t.y&&t.x<(n.x-i.x)*(t.y-i.y)/(n.y-i.y)+i.x&&(u=!u);return u||o.Polyline.prototype._containsPoint.call(this,t,!0)},o.CircleMarker.prototype._containsPoint=function(t){return t.distanceTo(this._point)<=this._radius+this._clickTolerance()},o.GeoJSON=o.FeatureGroup.extend({initialize:function(t,e){o.setOptions(this,e),this._layers={},t&&this.addData(t)},addData:function(t){var e,i,n,s=o.Util.isArray(t)?t:t.features;if(s){for(e=0,i=s.length;e1)return void(this._moved=!0);var n=i.touches&&1===i.touches.length?i.touches[0]:i,s=new o.Point(n.clientX,n.clientY),r=s.subtract(this._startPoint);(r.x||r.y)&&(Math.abs(r.x)+Math.abs(r.y)50&&(this._positions.shift(),this._times.shift())}this._map.fire("move",t).fire("drag",t)},_onZoomEnd:function(){var t=this._map.getSize().divideBy(2),e=this._map.latLngToLayerPoint([0,0]);this._initialWorldOffset=e.subtract(t).x,this._worldWidth=this._map.getPixelWorldBounds().getSize().x},_viscousLimit:function(t,e){return t-(t-e)*this._viscosity},_onPreDragLimit:function(){if(this._viscosity&&this._offsetLimit){var t=this._draggable._newPos.subtract(this._draggable._startPos),e=this._offsetLimit;t.xe.max.x&&(t.x=this._viscousLimit(t.x,e.max.x)),t.y>e.max.y&&(t.y=this._viscousLimit(t.y,e.max.y)),this._draggable._newPos=this._draggable._startPos.add(t)}},_onPreDragWrap:function(){var t=this._worldWidth,e=Math.round(t/2),i=this._initialWorldOffset,n=this._draggable._newPos.x,o=(n-e+i)%t+e-i,s=(n+e+i)%t-e-i,r=Math.abs(o+i)0?s:-s))-e;this._delta=0,this._startTime=null,r&&("center"===t.options.scrollWheelZoom?t.setZoom(e+r):t.setZoomAround(this._lastMousePos,e+r))}}),o.Map.addInitHook("addHandler","scrollWheelZoom",o.Map.ScrollWheelZoom),o.extend(o.DomEvent,{_touchstart:o.Browser.msPointer?"MSPointerDown":o.Browser.pointer?"pointerdown":"touchstart",_touchend:o.Browser.msPointer?"MSPointerUp":o.Browser.pointer?"pointerup":"touchend",addDoubleTapListener:function(t,e,i){function n(t){var e;if(o.Browser.pointer){if(!o.Browser.edge||"mouse"===t.pointerType)return;e=o.DomEvent._pointersCount}else e=t.touches.length;if(!(e>1)){var i=Date.now(),n=i-(r||i);a=t.touches?t.touches[0]:t,h=n>0&&n<=l,r=i}}function s(t){if(h&&!a.cancelBubble){if(o.Browser.pointer){if(!o.Browser.edge||"mouse"===t.pointerType)return;var i,n,s={};for(n in a)i=a[n],s[n]=i&&i.bind?i.bind(a):i;a=s}a.type="dblclick",e(a),r=null}}var r,a,h=!1,l=250,u="_leaflet_",c=this._touchstart,d=this._touchend;return t[u+c+i]=n,t[u+d+i]=s,t[u+"dblclick"+i]=e,t.addEventListener(c,n,!1),t.addEventListener(d,s,!1),t.addEventListener("dblclick",e,!1),this},removeDoubleTapListener:function(t,e){var i="_leaflet_",n=t[i+this._touchstart+e],s=t[i+this._touchend+e],r=t[i+"dblclick"+e];return t.removeEventListener(this._touchstart,n,!1),t.removeEventListener(this._touchend,s,!1),o.Browser.edge||t.removeEventListener("dblclick",r,!1),this}}),o.extend(o.DomEvent,{POINTER_DOWN:o.Browser.msPointer?"MSPointerDown":"pointerdown",POINTER_MOVE:o.Browser.msPointer?"MSPointerMove":"pointermove",POINTER_UP:o.Browser.msPointer?"MSPointerUp":"pointerup",POINTER_CANCEL:o.Browser.msPointer?"MSPointerCancel":"pointercancel",TAG_WHITE_LIST:["INPUT","SELECT","OPTION"],_pointers:{},_pointersCount:0,addPointerListener:function(t,e,i,n){return"touchstart"===e?this._addPointerStart(t,i,n):"touchmove"===e?this._addPointerMove(t,i,n):"touchend"===e&&this._addPointerEnd(t,i,n),this},removePointerListener:function(t,e,i){var n=t["_leaflet_"+e+i];return"touchstart"===e?t.removeEventListener(this.POINTER_DOWN,n,!1):"touchmove"===e?t.removeEventListener(this.POINTER_MOVE,n,!1):"touchend"===e&&(t.removeEventListener(this.POINTER_UP,n,!1),t.removeEventListener(this.POINTER_CANCEL,n,!1)),this},_addPointerStart:function(t,i,n){var s=o.bind(function(t){if("mouse"!==t.pointerType&&t.MSPOINTER_TYPE_MOUSE&&t.pointerType!==t.MSPOINTER_TYPE_MOUSE){if(!(this.TAG_WHITE_LIST.indexOf(t.target.tagName)<0))return;o.DomEvent.preventDefault(t)}this._handlePointer(t,i)},this);if(t["_leaflet_touchstart"+n]=s,t.addEventListener(this.POINTER_DOWN,s,!1),!this._pointerDocListener){var r=o.bind(this._globalPointerUp,this);e.documentElement.addEventListener(this.POINTER_DOWN,o.bind(this._globalPointerDown,this),!0),e.documentElement.addEventListener(this.POINTER_MOVE,o.bind(this._globalPointerMove,this),!0),e.documentElement.addEventListener(this.POINTER_UP,r,!0),e.documentElement.addEventListener(this.POINTER_CANCEL,r,!0),this._pointerDocListener=!0}},_globalPointerDown:function(t){this._pointers[t.pointerId]=t,this._pointersCount++},_globalPointerMove:function(t){this._pointers[t.pointerId]&&(this._pointers[t.pointerId]=t)},_globalPointerUp:function(t){delete this._pointers[t.pointerId],this._pointersCount--},_handlePointer:function(t,e){t.touches=[];for(var i in this._pointers)t.touches.push(this._pointers[i]);t.changedTouches=[t],e(t)},_addPointerMove:function(t,e,i){var n=o.bind(function(t){(t.pointerType!==t.MSPOINTER_TYPE_MOUSE&&"mouse"!==t.pointerType||0!==t.buttons)&&this._handlePointer(t,e)},this);t["_leaflet_touchmove"+i]=n,t.addEventListener(this.POINTER_MOVE,n,!1)},_addPointerEnd:function(t,e,i){var n=o.bind(function(t){this._handlePointer(t,e)},this);t["_leaflet_touchend"+i]=n,t.addEventListener(this.POINTER_UP,n,!1),t.addEventListener(this.POINTER_CANCEL,n,!1)}}),o.Map.mergeOptions({touchZoom:o.Browser.touch&&!o.Browser.android23,bounceAtZoomLimits:!0}),o.Map.TouchZoom=o.Handler.extend({addHooks:function(){o.DomUtil.addClass(this._map._container,"leaflet-touch-zoom"),o.DomEvent.on(this._map._container,"touchstart",this._onTouchStart,this)},removeHooks:function(){o.DomUtil.removeClass(this._map._container,"leaflet-touch-zoom"),o.DomEvent.off(this._map._container,"touchstart",this._onTouchStart,this)},_onTouchStart:function(t){var i=this._map;if(t.touches&&2===t.touches.length&&!i._animatingZoom&&!this._zooming){var n=i.mouseEventToContainerPoint(t.touches[0]),s=i.mouseEventToContainerPoint(t.touches[1]);this._centerPoint=i.getSize()._divideBy(2),this._startLatLng=i.containerPointToLatLng(this._centerPoint),"center"!==i.options.touchZoom&&(this._pinchStartLatLng=i.containerPointToLatLng(n.add(s)._divideBy(2))),this._startDist=n.distanceTo(s),this._startZoom=i.getZoom(),this._moved=!1,this._zooming=!0,i._stop(),o.DomEvent.on(e,"touchmove",this._onTouchMove,this).on(e,"touchend",this._onTouchEnd,this),o.DomEvent.preventDefault(t)}},_onTouchMove:function(t){if(t.touches&&2===t.touches.length&&this._zooming){var e=this._map,i=e.mouseEventToContainerPoint(t.touches[0]),n=e.mouseEventToContainerPoint(t.touches[1]),s=i.distanceTo(n)/this._startDist;if(this._zoom=e.getScaleZoom(s,this._startZoom),!e.options.bounceAtZoomLimits&&(this._zoome.getMaxZoom()&&s>1)&&(this._zoom=e._limitZoom(this._zoom)),"center"===e.options.touchZoom){if(this._center=this._startLatLng,1===s)return}else{var r=i._add(n)._divideBy(2)._subtract(this._centerPoint);if(1===s&&0===r.x&&0===r.y)return;this._center=e.unproject(e.project(this._pinchStartLatLng,this._zoom).subtract(r),this._zoom)}this._moved||(e._moveStart(!0),this._moved=!0),o.Util.cancelAnimFrame(this._animRequest);var a=o.bind(e._move,e,this._center,this._zoom,{pinch:!0,round:!1});this._animRequest=o.Util.requestAnimFrame(a,this,!0),o.DomEvent.preventDefault(t)}},_onTouchEnd:function(){return this._moved&&this._zooming?(this._zooming=!1,o.Util.cancelAnimFrame(this._animRequest),o.DomEvent.off(e,"touchmove",this._onTouchMove).off(e,"touchend",this._onTouchEnd),void(this._map.options.zoomAnimation?this._map._animateZoom(this._center,this._map._limitZoom(this._zoom),!0,this._map.options.zoomSnap):this._map._resetView(this._center,this._map._limitZoom(this._zoom)))):void(this._zooming=!1)}}),o.Map.addInitHook("addHandler","touchZoom",o.Map.TouchZoom),o.Map.mergeOptions({tap:!0,tapTolerance:15}),o.Map.Tap=o.Handler.extend({addHooks:function(){o.DomEvent.on(this._map._container,"touchstart",this._onDown,this)},removeHooks:function(){o.DomEvent.off(this._map._container,"touchstart",this._onDown,this)},_onDown:function(t){if(t.touches){if(o.DomEvent.preventDefault(t),this._fireClick=!0,t.touches.length>1)return this._fireClick=!1,void clearTimeout(this._holdTimeout);var i=t.touches[0],n=i.target;this._startPos=this._newPos=new o.Point(i.clientX,i.clientY),n.tagName&&"a"===n.tagName.toLowerCase()&&o.DomUtil.addClass(n,"leaflet-active"),this._holdTimeout=setTimeout(o.bind(function(){this._isTapValid()&&(this._fireClick=!1,this._onUp(),this._simulateEvent("contextmenu",i))},this),1e3),this._simulateEvent("mousedown",i),o.DomEvent.on(e,{touchmove:this._onMove,touchend:this._onUp},this)}},_onUp:function(t){if(clearTimeout(this._holdTimeout),o.DomEvent.off(e,{touchmove:this._onMove,touchend:this._onUp},this),this._fireClick&&t&&t.changedTouches){var i=t.changedTouches[0],n=i.target;n&&n.tagName&&"a"===n.tagName.toLowerCase()&&o.DomUtil.removeClass(n,"leaflet-active"),this._simulateEvent("mouseup",i),this._isTapValid()&&this._simulateEvent("click",i)}},_isTapValid:function(){return this._newPos.distanceTo(this._startPos)<=this._map.options.tapTolerance},_onMove:function(t){var e=t.touches[0];this._newPos=new o.Point(e.clientX,e.clientY),
+this._simulateEvent("mousemove",e)},_simulateEvent:function(i,n){var o=e.createEvent("MouseEvents");o._simulated=!0,n.target._simulatedClick=!0,o.initMouseEvent(i,!0,!0,t,1,n.screenX,n.screenY,n.clientX,n.clientY,!1,!1,!1,!1,0,null),n.target.dispatchEvent(o)}}),o.Browser.touch&&!o.Browser.pointer&&o.Map.addInitHook("addHandler","tap",o.Map.Tap),o.Map.mergeOptions({boxZoom:!0}),o.Map.BoxZoom=o.Handler.extend({initialize:function(t){this._map=t,this._container=t._container,this._pane=t._panes.overlayPane},addHooks:function(){o.DomEvent.on(this._container,"mousedown",this._onMouseDown,this)},removeHooks:function(){o.DomEvent.off(this._container,"mousedown",this._onMouseDown,this)},moved:function(){return this._moved},_resetState:function(){this._moved=!1},_onMouseDown:function(t){return!(!t.shiftKey||1!==t.which&&1!==t.button)&&(this._resetState(),o.DomUtil.disableTextSelection(),o.DomUtil.disableImageDrag(),this._startPoint=this._map.mouseEventToContainerPoint(t),void o.DomEvent.on(e,{contextmenu:o.DomEvent.stop,mousemove:this._onMouseMove,mouseup:this._onMouseUp,keydown:this._onKeyDown},this))},_onMouseMove:function(t){this._moved||(this._moved=!0,this._box=o.DomUtil.create("div","leaflet-zoom-box",this._container),o.DomUtil.addClass(this._container,"leaflet-crosshair"),this._map.fire("boxzoomstart")),this._point=this._map.mouseEventToContainerPoint(t);var e=new o.Bounds(this._point,this._startPoint),i=e.getSize();o.DomUtil.setPosition(this._box,e.min),this._box.style.width=i.x+"px",this._box.style.height=i.y+"px"},_finish:function(){this._moved&&(o.DomUtil.remove(this._box),o.DomUtil.removeClass(this._container,"leaflet-crosshair")),o.DomUtil.enableTextSelection(),o.DomUtil.enableImageDrag(),o.DomEvent.off(e,{contextmenu:o.DomEvent.stop,mousemove:this._onMouseMove,mouseup:this._onMouseUp,keydown:this._onKeyDown},this)},_onMouseUp:function(t){if((1===t.which||1===t.button)&&(this._finish(),this._moved)){setTimeout(o.bind(this._resetState,this),0);var e=new o.LatLngBounds(this._map.containerPointToLatLng(this._startPoint),this._map.containerPointToLatLng(this._point));this._map.fitBounds(e).fire("boxzoomend",{boxZoomBounds:e})}},_onKeyDown:function(t){27===t.keyCode&&this._finish()}}),o.Map.addInitHook("addHandler","boxZoom",o.Map.BoxZoom),o.Map.mergeOptions({keyboard:!0,keyboardPanDelta:80}),o.Map.Keyboard=o.Handler.extend({keyCodes:{left:[37],right:[39],down:[40],up:[38],zoomIn:[187,107,61,171],zoomOut:[189,109,54,173]},initialize:function(t){this._map=t,this._setPanDelta(t.options.keyboardPanDelta),this._setZoomDelta(t.options.zoomDelta)},addHooks:function(){var t=this._map._container;t.tabIndex<=0&&(t.tabIndex="0"),o.DomEvent.on(t,{focus:this._onFocus,blur:this._onBlur,mousedown:this._onMouseDown},this),this._map.on({focus:this._addHooks,blur:this._removeHooks},this)},removeHooks:function(){this._removeHooks(),o.DomEvent.off(this._map._container,{focus:this._onFocus,blur:this._onBlur,mousedown:this._onMouseDown},this),this._map.off({focus:this._addHooks,blur:this._removeHooks},this)},_onMouseDown:function(){if(!this._focused){var i=e.body,n=e.documentElement,o=i.scrollTop||n.scrollTop,s=i.scrollLeft||n.scrollLeft;this._map._container.focus(),t.scrollTo(s,o)}},_onFocus:function(){this._focused=!0,this._map.fire("focus")},_onBlur:function(){this._focused=!1,this._map.fire("blur")},_setPanDelta:function(t){var e,i,n=this._panKeys={},o=this.keyCodes;for(e=0,i=o.left.length;e0&&t.screenY>0&&this._map.getContainer().focus()}}),o.control=function(t){return new o.Control(t)},o.Map.include({addControl:function(t){return t.addTo(this),this},removeControl:function(t){return t.remove(),this},_initControlPos:function(){function t(t,s){var r=i+t+" "+i+s;e[t+s]=o.DomUtil.create("div",r,n)}var e=this._controlCorners={},i="leaflet-",n=this._controlContainer=o.DomUtil.create("div",i+"control-container",this._container);t("top","left"),t("top","right"),t("bottom","left"),t("bottom","right")},_clearControlPos:function(){o.DomUtil.remove(this._controlContainer)}}),o.Control.Zoom=o.Control.extend({options:{position:"topleft",zoomInText:"+",zoomInTitle:"Zoom in",zoomOutText:"-",zoomOutTitle:"Zoom out"},onAdd:function(t){var e="leaflet-control-zoom",i=o.DomUtil.create("div",e+" leaflet-bar"),n=this.options;return this._zoomInButton=this._createButton(n.zoomInText,n.zoomInTitle,e+"-in",i,this._zoomIn),this._zoomOutButton=this._createButton(n.zoomOutText,n.zoomOutTitle,e+"-out",i,this._zoomOut),this._updateDisabled(),t.on("zoomend zoomlevelschange",this._updateDisabled,this),i},onRemove:function(t){t.off("zoomend zoomlevelschange",this._updateDisabled,this)},disable:function(){return this._disabled=!0,this._updateDisabled(),this},enable:function(){return this._disabled=!1,this._updateDisabled(),this},_zoomIn:function(t){!this._disabled&&this._map._zoomthis._map.getMinZoom()&&this._map.zoomOut(this._map.options.zoomDelta*(t.shiftKey?3:1))},_createButton:function(t,e,i,n,s){var r=o.DomUtil.create("a",i,n);return r.innerHTML=t,r.href="#",r.title=e,r.setAttribute("role","button"),r.setAttribute("aria-label",e),o.DomEvent.on(r,"mousedown dblclick",o.DomEvent.stopPropagation).on(r,"click",o.DomEvent.stop).on(r,"click",s,this).on(r,"click",this._refocusOnMap,this),r},_updateDisabled:function(){var t=this._map,e="leaflet-disabled";o.DomUtil.removeClass(this._zoomInButton,e),o.DomUtil.removeClass(this._zoomOutButton,e),(this._disabled||t._zoom===t.getMinZoom())&&o.DomUtil.addClass(this._zoomOutButton,e),(this._disabled||t._zoom===t.getMaxZoom())&&o.DomUtil.addClass(this._zoomInButton,e)}}),o.Map.mergeOptions({zoomControl:!0}),o.Map.addInitHook(function(){this.options.zoomControl&&(this.zoomControl=new o.Control.Zoom,this.addControl(this.zoomControl))}),o.control.zoom=function(t){return new o.Control.Zoom(t)},o.Control.Attribution=o.Control.extend({options:{position:"bottomright",prefix:'Leaflet '},initialize:function(t){o.setOptions(this,t),this._attributions={}},onAdd:function(t){t.attributionControl=this,this._container=o.DomUtil.create("div","leaflet-control-attribution"),o.DomEvent&&o.DomEvent.disableClickPropagation(this._container);for(var e in t._layers)t._layers[e].getAttribution&&this.addAttribution(t._layers[e].getAttribution());return this._update(),this._container},setPrefix:function(t){return this.options.prefix=t,this._update(),this},addAttribution:function(t){return t?(this._attributions[t]||(this._attributions[t]=0),this._attributions[t]++,this._update(),this):this},removeAttribution:function(t){return t?(this._attributions[t]&&(this._attributions[t]--,this._update()),this):this},_update:function(){if(this._map){var t=[];for(var e in this._attributions)this._attributions[e]&&t.push(e);var i=[];this.options.prefix&&i.push(this.options.prefix),t.length&&i.push(t.join(", ")),this._container.innerHTML=i.join(" | ")}}}),o.Map.mergeOptions({attributionControl:!0}),o.Map.addInitHook(function(){this.options.attributionControl&&(new o.Control.Attribution).addTo(this)}),o.control.attribution=function(t){return new o.Control.Attribution(t)},o.Control.Scale=o.Control.extend({options:{position:"bottomleft",maxWidth:100,metric:!0,imperial:!0},onAdd:function(t){var e="leaflet-control-scale",i=o.DomUtil.create("div",e),n=this.options;return this._addScales(n,e+"-line",i),t.on(n.updateWhenIdle?"moveend":"move",this._update,this),t.whenReady(this._update,this),i},onRemove:function(t){t.off(this.options.updateWhenIdle?"moveend":"move",this._update,this)},_addScales:function(t,e,i){t.metric&&(this._mScale=o.DomUtil.create("div",e,i)),t.imperial&&(this._iScale=o.DomUtil.create("div",e,i))},_update:function(){var t=this._map,e=t.getSize().y/2,i=t.distance(t.containerPointToLatLng([0,e]),t.containerPointToLatLng([this.options.maxWidth,e]));this._updateScales(i)},_updateScales:function(t){this.options.metric&&t&&this._updateMetric(t),this.options.imperial&&t&&this._updateImperial(t)},_updateMetric:function(t){var e=this._getRoundNum(t),i=e<1e3?e+" m":e/1e3+" km";this._updateScale(this._mScale,i,e/t)},_updateImperial:function(t){var e,i,n,o=3.2808399*t;o>5280?(e=o/5280,i=this._getRoundNum(e),this._updateScale(this._iScale,i+" mi",i/e)):(n=this._getRoundNum(o),this._updateScale(this._iScale,n+" ft",n/o))},_updateScale:function(t,e,i){t.style.width=Math.round(this.options.maxWidth*i)+"px",t.innerHTML=e},_getRoundNum:function(t){var e=Math.pow(10,(Math.floor(t)+"").length-1),i=t/e;return i=i>=10?10:i>=5?5:i>=3?3:i>=2?2:1,e*i}}),o.control.scale=function(t){return new o.Control.Scale(t)},o.Control.Layers=o.Control.extend({options:{collapsed:!0,position:"topright",autoZIndex:!0,hideSingleBase:!1,sortLayers:!1,sortFunction:function(t,e,i,n){return i1,this._baseLayersList.style.display=t?"":"none"),this._separator.style.display=e&&t?"":"none",this},_onLayerChange:function(t){this._handlingClick||this._update();var e=this._getLayer(o.stamp(t.target)),i=e.overlay?"add"===t.type?"overlayadd":"overlayremove":"add"===t.type?"baselayerchange":null;i&&this._map.fire(i,e)},_createRadioElement:function(t,i){var n='=0;s--)t=n[s],e=this._getLayer(t.layerId).layer,t.disabled=e.options.minZoom!==i&&oe.options.maxZoom},_expand:function(){return this.expand()},_collapse:function(){return this.collapse()}}),o.control.layers=function(t,e,i){return new o.Control.Layers(t,e,i)}}(window,document);
\ No newline at end of file
diff --git a/sandbox/lines-polygons/leaflet/Proj4Leaflet-1.0.1/lib/proj4-compressed.js b/sandbox/lines-polygons/leaflet/Proj4Leaflet-1.0.1/lib/proj4-compressed.js
new file mode 100644
index 0000000..b777613
--- /dev/null
+++ b/sandbox/lines-polygons/leaflet/Proj4Leaflet-1.0.1/lib/proj4-compressed.js
@@ -0,0 +1,3 @@
+!function(a){if("object"==typeof exports)module.exports=a();else if("function"==typeof define&&define.amd)define(a);else{var b;"undefined"!=typeof window?b=window:"undefined"!=typeof global?b=global:"undefined"!=typeof self&&(b=self),b.proj4=a()}}(function(){return function a(b,c,d){function e(g,h){if(!c[g]){if(!b[g]){var i="function"==typeof require&&require;if(!h&&i)return i(g,!0);if(f)return f(g,!0);throw new Error("Cannot find module '"+g+"'")}var j=c[g]={exports:{}};b[g][0].call(j.exports,function(a){var c=b[g][1][a];return e(c?c:a)},j,j.exports,a,b,c,d)}return c[g].exports}for(var f="function"==typeof require&&require,g=0;gf;f++)if(!b||2!==f||void 0!==c.z)switch(0===f?(d=g,e="x"):1===f?(d=h,e="y"):(d=i,e="z"),a.axis[f]){case"e":c[e]=d;break;case"w":c[e]=-d;break;case"n":c[e]=d;break;case"s":c[e]=-d;break;case"u":void 0!==c[e]&&(c.z=d);break;case"d":void 0!==c[e]&&(c.z=-d);break;default:return null}return c}},{}],4:[function(a,b,c){var d=Math.PI/2,e=a("./sign");b.exports=function(a){return Math.abs(a)1&&(a=a>1?1:-1),Math.asin(a)}},{}],7:[function(a,b,c){b.exports=function(a){return 1-.25*a*(1+a/16*(3+1.25*a))}},{}],8:[function(a,b,c){b.exports=function(a){return.375*a*(1+.25*a*(1+.46875*a))}},{}],9:[function(a,b,c){b.exports=function(a){return.05859375*a*a*(1+.75*a)}},{}],10:[function(a,b,c){b.exports=function(a){return a*a*a*(35/3072)}},{}],11:[function(a,b,c){b.exports=function(a,b,c){var d=b*c;return a/Math.sqrt(1-d*d)}},{}],12:[function(a,b,c){b.exports=function(a,b,c,d,e){var f,g;f=a/b;for(var h=0;15>h;h++)if(g=(a-(b*f-c*Math.sin(2*f)+d*Math.sin(4*f)-e*Math.sin(6*f)))/(b-2*c*Math.cos(2*f)+4*d*Math.cos(4*f)-6*e*Math.cos(6*f)),f+=g,Math.abs(g)<=1e-10)return f;return NaN}},{}],13:[function(a,b,c){var d=Math.PI/2;b.exports=function(a,b){var c=1-(1-a*a)/(2*a)*Math.log((1-a)/(1+a));if(Math.abs(Math.abs(b)-c)<1e-6)return 0>b?-1*d:d;for(var e,f,g,h,i=Math.asin(.5*b),j=0;30>j;j++)if(f=Math.sin(i),g=Math.cos(i),h=a*f,e=Math.pow(1-h*h,2)/(2*g)*(b/(1-a*a)-f/(1-h*h)+.5/a*Math.log((1-h)/(1+h))),i+=e,Math.abs(e)<=1e-10)return i;return NaN}},{}],14:[function(a,b,c){b.exports=function(a,b,c,d,e){return a*e-b*Math.sin(2*e)+c*Math.sin(4*e)-d*Math.sin(6*e)}},{}],15:[function(a,b,c){b.exports=function(a,b,c){var d=a*b;return c/Math.sqrt(1-d*d)}},{}],16:[function(a,b,c){var d=Math.PI/2;b.exports=function(a,b){for(var c,e,f=.5*a,g=d-2*Math.atan(b),h=0;15>=h;h++)if(c=a*Math.sin(g),e=d-2*Math.atan(b*Math.pow((1-c)/(1+c),f))-g,g+=e,Math.abs(e)<=1e-10)return g;return-9999}},{}],17:[function(a,b,c){var d=1,e=.25,f=.046875,g=.01953125,h=.01068115234375,i=.75,j=.46875,k=.013020833333333334,l=.007120768229166667,m=.3645833333333333,n=.005696614583333333,o=.3076171875;b.exports=function(a){var b=[];b[0]=d-a*(e+a*(f+a*(g+a*h))),b[1]=a*(i-a*(f+a*(g+a*h)));var c=a*a;return b[2]=c*(j-a*(k+a*l)),c*=a,b[3]=c*(m-a*n),b[4]=c*a*o,b}},{}],18:[function(a,b,c){var d=a("./pj_mlfn"),e=1e-10,f=20;b.exports=function(a,b,c){for(var g=1/(1-b),h=a,i=f;i;--i){var j=Math.sin(h),k=1-b*j*j;if(k=(d(h,j,Math.cos(h),c)-a)*(k*Math.sqrt(k))*g,h-=k,Math.abs(k)1e-7?(c=a*b,(1-a*a)*(b/(1-c*c)-.5/a*Math.log((1-c)/(1+c)))):2*b}},{}],21:[function(a,b,c){b.exports=function(a){return 0>a?-1:1}},{}],22:[function(a,b,c){b.exports=function(a,b){return Math.pow((1-a)/(1+a),b)}},{}],23:[function(a,b,c){b.exports=function(a){var b={x:a[0],y:a[1]};return a.length>2&&(b.z=a[2]),a.length>3&&(b.m=a[3]),b}},{}],24:[function(a,b,c){var d=Math.PI/2;b.exports=function(a,b,c){var e=a*c,f=.5*a;return e=Math.pow((1-e)/(1+e),f),Math.tan(.5*(d-b))/e}},{}],25:[function(a,b,c){c.wgs84={towgs84:"0,0,0",ellipse:"WGS84",datumName:"WGS84"},c.ch1903={towgs84:"674.374,15.056,405.346",ellipse:"bessel",datumName:"swiss"},c.ggrs87={towgs84:"-199.87,74.79,246.62",ellipse:"GRS80",datumName:"Greek_Geodetic_Reference_System_1987"},c.nad83={towgs84:"0,0,0",ellipse:"GRS80",datumName:"North_American_Datum_1983"},c.nad27={nadgrids:"@conus,@alaska,@ntv2_0.gsb,@ntv1_can.dat",ellipse:"clrk66",datumName:"North_American_Datum_1927"},c.potsdam={towgs84:"606.0,23.0,413.0",ellipse:"bessel",datumName:"Potsdam Rauenberg 1950 DHDN"},c.carthage={towgs84:"-263.0,6.0,431.0",ellipse:"clark80",datumName:"Carthage 1934 Tunisia"},c.hermannskogel={towgs84:"653.0,-212.0,449.0",ellipse:"bessel",datumName:"Hermannskogel"},c.ire65={towgs84:"482.530,-130.596,564.557,-1.042,-0.214,-0.631,8.15",ellipse:"mod_airy",datumName:"Ireland 1965"},c.rassadiran={towgs84:"-133.63,-157.5,-158.62",ellipse:"intl",datumName:"Rassadiran"},c.nzgd49={towgs84:"59.47,-5.04,187.44,0.47,-0.1,1.024,-4.5993",ellipse:"intl",datumName:"New Zealand Geodetic Datum 1949"},c.osgb36={towgs84:"446.448,-125.157,542.060,0.1502,0.2470,0.8421,-20.4894",ellipse:"airy",datumName:"Airy 1830"},c.s_jtsk={towgs84:"589,76,480",ellipse:"bessel",datumName:"S-JTSK (Ferro)"},c.beduaram={towgs84:"-106,-87,188",ellipse:"clrk80",datumName:"Beduaram"},c.gunung_segara={towgs84:"-403,684,41",ellipse:"bessel",datumName:"Gunung Segara Jakarta"},c.rnb72={towgs84:"106.869,-52.2978,103.724,-0.33657,0.456955,-1.84218,1",ellipse:"intl",datumName:"Reseau National Belge 1972"}},{}],26:[function(a,b,c){c.MERIT={a:6378137,rf:298.257,ellipseName:"MERIT 1983"},c.SGS85={a:6378136,rf:298.257,ellipseName:"Soviet Geodetic System 85"},c.GRS80={a:6378137,rf:298.257222101,ellipseName:"GRS 1980(IUGG, 1980)"},c.IAU76={a:6378140,rf:298.257,ellipseName:"IAU 1976"},c.airy={a:6377563.396,b:6356256.91,ellipseName:"Airy 1830"},c.APL4={a:6378137,rf:298.25,ellipseName:"Appl. Physics. 1965"},c.NWL9D={a:6378145,rf:298.25,ellipseName:"Naval Weapons Lab., 1965"},c.mod_airy={a:6377340.189,b:6356034.446,ellipseName:"Modified Airy"},c.andrae={a:6377104.43,rf:300,ellipseName:"Andrae 1876 (Den., Iclnd.)"},c.aust_SA={a:6378160,rf:298.25,ellipseName:"Australian Natl & S. Amer. 1969"},c.GRS67={a:6378160,rf:298.247167427,ellipseName:"GRS 67(IUGG 1967)"},c.bessel={a:6377397.155,rf:299.1528128,ellipseName:"Bessel 1841"},c.bess_nam={a:6377483.865,rf:299.1528128,ellipseName:"Bessel 1841 (Namibia)"},c.clrk66={a:6378206.4,b:6356583.8,ellipseName:"Clarke 1866"},c.clrk80={a:6378249.145,rf:293.4663,ellipseName:"Clarke 1880 mod."},c.clrk58={a:6378293.645208759,rf:294.2606763692654,ellipseName:"Clarke 1858"},c.CPM={a:6375738.7,rf:334.29,ellipseName:"Comm. des Poids et Mesures 1799"},c.delmbr={a:6376428,rf:311.5,ellipseName:"Delambre 1810 (Belgium)"},c.engelis={a:6378136.05,rf:298.2566,ellipseName:"Engelis 1985"},c.evrst30={a:6377276.345,rf:300.8017,ellipseName:"Everest 1830"},c.evrst48={a:6377304.063,rf:300.8017,ellipseName:"Everest 1948"},c.evrst56={a:6377301.243,rf:300.8017,ellipseName:"Everest 1956"},c.evrst69={a:6377295.664,rf:300.8017,ellipseName:"Everest 1969"},c.evrstSS={a:6377298.556,rf:300.8017,ellipseName:"Everest (Sabah & Sarawak)"},c.fschr60={a:6378166,rf:298.3,ellipseName:"Fischer (Mercury Datum) 1960"},c.fschr60m={a:6378155,rf:298.3,ellipseName:"Fischer 1960"},c.fschr68={a:6378150,rf:298.3,ellipseName:"Fischer 1968"},c.helmert={a:6378200,rf:298.3,ellipseName:"Helmert 1906"},c.hough={a:6378270,rf:297,ellipseName:"Hough"},c.intl={a:6378388,rf:297,ellipseName:"International 1909 (Hayford)"},c.kaula={a:6378163,rf:298.24,ellipseName:"Kaula 1961"},c.lerch={a:6378139,rf:298.257,ellipseName:"Lerch 1979"},c.mprts={a:6397300,rf:191,ellipseName:"Maupertius 1738"},c.new_intl={a:6378157.5,b:6356772.2,ellipseName:"New International 1967"},c.plessis={a:6376523,rf:6355863,ellipseName:"Plessis 1817 (France)"},c.krass={a:6378245,rf:298.3,ellipseName:"Krassovsky, 1942"},c.SEasia={a:6378155,b:6356773.3205,ellipseName:"Southeast Asia"},c.walbeck={a:6376896,b:6355834.8467,ellipseName:"Walbeck"},c.WGS60={a:6378165,rf:298.3,ellipseName:"WGS 60"},c.WGS66={a:6378145,rf:298.25,ellipseName:"WGS 66"},c.WGS7={a:6378135,rf:298.26,ellipseName:"WGS 72"},c.WGS84={a:6378137,rf:298.257223563,ellipseName:"WGS 84"},c.sphere={a:6370997,b:6370997,ellipseName:"Normal Sphere (r=6370997)"}},{}],27:[function(a,b,c){c.greenwich=0,c.lisbon=-9.131906111111,c.paris=2.337229166667,c.bogota=-74.080916666667,c.madrid=-3.687938888889,c.rome=12.452333333333,c.bern=7.439583333333,c.jakarta=106.807719444444,c.ferro=-17.666666666667,c.brussels=4.367975,c.stockholm=18.058277777778,c.athens=23.7163375,c.oslo=10.722916666667},{}],28:[function(a,b,c){c.ft={to_meter:.3048},c["us-ft"]={to_meter:1200/3937}},{}],29:[function(a,b,c){function d(a,b,c){var d;return Array.isArray(c)?(d=g(a,b,c),3===c.length?[d.x,d.y,d.z]:[d.x,d.y]):g(a,b,c)}function e(a){return a instanceof f?a:a.oProj?a.oProj:f(a)}function proj4(a,b,c){a=e(a);var f,g=!1;return"undefined"==typeof b?(b=a,a=h,g=!0):("undefined"!=typeof b.x||Array.isArray(b))&&(c=b,b=a,a=h,g=!0),b=e(b),c?d(a,b,c):(f={forward:function(c){return d(a,b,c)},inverse:function(c){return d(b,a,c)}},g&&(f.oProj=b),f)}var f=a("./Proj"),g=a("./transform"),h=f("WGS84");b.exports=proj4},{"./Proj":2,"./transform":65}],30:[function(a,b,c){var d=Math.PI/2,e=1,f=2,g=3,h=4,i=5,j=484813681109536e-20,k=1.0026,l=.3826834323650898,m=function(a){return this instanceof m?(this.datum_type=h,void(a&&(a.datumCode&&"none"===a.datumCode&&(this.datum_type=i),a.datum_params&&(this.datum_params=a.datum_params.map(parseFloat),(0!==this.datum_params[0]||0!==this.datum_params[1]||0!==this.datum_params[2])&&(this.datum_type=e),this.datum_params.length>3&&(0!==this.datum_params[3]||0!==this.datum_params[4]||0!==this.datum_params[5]||0!==this.datum_params[6])&&(this.datum_type=f,this.datum_params[3]*=j,this.datum_params[4]*=j,this.datum_params[5]*=j,this.datum_params[6]=this.datum_params[6]/1e6+1)),this.datum_type=a.grids?g:this.datum_type,this.a=a.a,this.b=a.b,this.es=a.es,this.ep2=a.ep2,this.datum_type===g&&(this.grids=a.grids)))):new m(a)};m.prototype={compare_datums:function(a){return this.datum_type!==a.datum_type?!1:this.a!==a.a||Math.abs(this.es-a.es)>5e-11?!1:this.datum_type===e?this.datum_params[0]===a.datum_params[0]&&this.datum_params[1]===a.datum_params[1]&&this.datum_params[2]===a.datum_params[2]:this.datum_type===f?this.datum_params[0]===a.datum_params[0]&&this.datum_params[1]===a.datum_params[1]&&this.datum_params[2]===a.datum_params[2]&&this.datum_params[3]===a.datum_params[3]&&this.datum_params[4]===a.datum_params[4]&&this.datum_params[5]===a.datum_params[5]&&this.datum_params[6]===a.datum_params[6]:this.datum_type===g||a.datum_type===g?this.nadgrids===a.nadgrids:!0},geodetic_to_geocentric:function(a){var b,c,e,f,g,h,i,j=a.x,k=a.y,l=a.z?a.z:0,m=0;if(-d>k&&k>-1.001*d)k=-d;else if(k>d&&1.001*d>k)k=d;else if(-d>k||k>d)return null;return j>Math.PI&&(j-=2*Math.PI),g=Math.sin(k),i=Math.cos(k),h=g*g,f=this.a/Math.sqrt(1-this.es*h),b=(f+l)*i*Math.cos(j),c=(f+l)*i*Math.sin(j),e=(f*(1-this.es)+l)*g,a.x=b,a.y=c,a.z=e,m},geocentric_to_geodetic:function(a){var b,c,e,f,g,h,i,j,k,l,m,n,o,p,q,r,s,t=1e-12,u=t*t,v=30,w=a.x,x=a.y,y=a.z?a.z:0;if(o=!1,b=Math.sqrt(w*w+x*x),c=Math.sqrt(w*w+x*x+y*y),b/this.au&&v>p);return r=Math.atan(m/Math.abs(l)),a.x=q,a.y=r,a.z=s,a},geocentric_to_geodetic_noniter:function(a){var b,c,e,f,g,h,i,j,m,n,o,p,q,r,s,t,u,v=a.x,w=a.y,x=a.z?a.z:0;if(v=parseFloat(v),w=parseFloat(w),x=parseFloat(x),u=!1,0!==v)b=Math.atan2(w,v);else if(w>0)b=d;else if(0>w)b=-d;else if(u=!0,b=0,x>0)c=d;else{if(!(0>x))return c=d,void(e=-this.b);c=-d}return g=v*v+w*w,f=Math.sqrt(g),h=x*k,j=Math.sqrt(h*h+g),n=h/j,p=f/j,o=n*n*n,i=x+this.b*this.ep2*o,t=f-this.a*this.es*p*p*p,m=Math.sqrt(i*i+t*t),q=i/m,r=t/m,s=this.a/Math.sqrt(1-this.es*q*q),e=r>=l?f/r-s:-l>=r?f/-r-s:x/q+s*(this.es-1),u===!1&&(c=Math.atan(q/r)),a.x=b,a.y=c,a.z=e,a},geocentric_to_wgs84:function(a){if(this.datum_type===e)a.x+=this.datum_params[0],a.y+=this.datum_params[1],a.z+=this.datum_params[2];else if(this.datum_type===f){var b=this.datum_params[0],c=this.datum_params[1],d=this.datum_params[2],g=this.datum_params[3],h=this.datum_params[4],i=this.datum_params[5],j=this.datum_params[6],k=j*(a.x-i*a.y+h*a.z)+b,l=j*(i*a.x+a.y-g*a.z)+c,m=j*(-h*a.x+g*a.y+a.z)+d;a.x=k,a.y=l,a.z=m}},geocentric_from_wgs84:function(a){if(this.datum_type===e)a.x-=this.datum_params[0],a.y-=this.datum_params[1],a.z-=this.datum_params[2];else if(this.datum_type===f){var b=this.datum_params[0],c=this.datum_params[1],d=this.datum_params[2],g=this.datum_params[3],h=this.datum_params[4],i=this.datum_params[5],j=this.datum_params[6],k=(a.x-b)/j,l=(a.y-c)/j,m=(a.z-d)/j;a.x=k+i*l-h*m,a.y=-i*k+l+g*m,a.z=h*k-g*l+m}}},b.exports=m},{}],31:[function(a,b,c){var d=1,e=2,f=3,g=5,h=6378137,i=.006694379990141316;b.exports=function(a,b,c){function j(a){return a===d||a===e}var k,l,m;if(a.compare_datums(b))return c;if(a.datum_type===g||b.datum_type===g)return c;var n=a.a,o=a.es,p=b.a,q=b.es,r=a.datum_type;if(r===f)if(0===this.apply_gridshift(a,0,c))a.a=h,a.es=i;else{if(!a.datum_params)return a.a=n,a.es=a.es,c;for(k=1,l=0,m=a.datum_params.length;m>l;l++)k*=a.datum_params[l];if(0===k)return a.a=n,a.es=a.es,c;r=a.datum_params.length>3?e:d}return b.datum_type===f&&(b.a=h,b.es=i),(a.es!==b.es||a.a!==b.a||j(r)||j(b.datum_type))&&(a.geodetic_to_geocentric(c),j(a.datum_type)&&a.geocentric_to_wgs84(c),j(b.datum_type)&&b.geocentric_from_wgs84(c),b.geocentric_to_geodetic(c)),b.datum_type===f&&this.apply_gridshift(b,1,c),a.a=n,a.es=o,b.a=p,b.es=q,c}},{}],32:[function(a,b,c){function d(a){var b=this;if(2===arguments.length){var c=arguments[1];"string"==typeof c?"+"===c.charAt(0)?d[a]=f(arguments[1]):d[a]=g(arguments[1]):d[a]=c}else if(1===arguments.length){if(Array.isArray(a))return a.map(function(a){Array.isArray(a)?d.apply(b,a):d(a)});if("string"==typeof a){if(a in d)return d[a]}else"EPSG"in a?d["EPSG:"+a.EPSG]=a:"ESRI"in a?d["ESRI:"+a.ESRI]=a:"IAU2000"in a?d["IAU2000:"+a.IAU2000]=a:console.log(a);return}}var e=a("./global"),f=a("./projString"),g=a("./wkt");e(d),b.exports=d},{"./global":35,"./projString":38,"./wkt":66}],33:[function(a,b,c){var d=a("./constants/Datum"),e=a("./constants/Ellipsoid"),f=a("./extend"),g=a("./datum"),h=1e-10,i=.16666666666666666,j=.04722222222222222,k=.022156084656084655;b.exports=function(a){if(a.datumCode&&"none"!==a.datumCode){var b=d[a.datumCode];b&&(a.datum_params=b.towgs84?b.towgs84.split(","):null,a.ellps=b.ellipse,a.datumName=b.datumName?b.datumName:a.datumCode)}if(!a.a){var c=e[a.ellps]?e[a.ellps]:e.WGS84;f(a,c)}return a.rf&&!a.b&&(a.b=(1-1/a.rf)*a.a),(0===a.rf||Math.abs(a.a-a.b)d?this.ns0=(this.ms1*this.ms1-this.ms2*this.ms2)/(this.qs2-this.qs1):this.ns0=this.con,this.c=this.ms1*this.ms1+this.ns0*this.qs1,this.rh=this.a*Math.sqrt(this.c-this.ns0*this.qs0)/this.ns0)},c.forward=function(a){var b=a.x,c=a.y;this.sin_phi=Math.sin(c),this.cos_phi=Math.cos(c);var d=f(this.e3,this.sin_phi,this.cos_phi),e=this.a*Math.sqrt(this.c-this.ns0*d)/this.ns0,h=this.ns0*g(b-this.long0),i=e*Math.sin(h)+this.x0,j=this.rh-e*Math.cos(h)+this.y0;return a.x=i,a.y=j,a},c.inverse=function(a){var b,c,d,e,f,h;return a.x-=this.x0,a.y=this.rh-a.y+this.y0,this.ns0>=0?(b=Math.sqrt(a.x*a.x+a.y*a.y),d=1):(b=-Math.sqrt(a.x*a.x+a.y*a.y),d=-1),e=0,0!==b&&(e=Math.atan2(d*a.x,d*a.y)),d=b*this.ns0/this.a,this.sphere?h=Math.asin((this.c-d*d)/(2*this.ns0)):(c=(this.c-d*d)/this.ns0,h=this.phi1z(this.e3,c)),f=g(e/this.ns0+this.long0),a.x=f,a.y=h,a},c.phi1z=function(a,b){var c,e,f,g,i,j=h(.5*b);if(d>a)return j;for(var k=a*a,l=1;25>=l;l++)if(c=Math.sin(j),e=Math.cos(j),f=a*c,g=1-f*f,i=.5*g*g/e*(b/(1-k)-c/g+.5/a*Math.log((1-f)/(1+f))),j+=i,Math.abs(i)<=1e-7)return j;return null},c.names=["Albers_Conic_Equal_Area","Albers","aea"]},{"../common/adjust_lon":5,"../common/asinz":6,"../common/msfnz":15,"../common/qsfnz":20}],41:[function(a,b,c){var d=a("../common/adjust_lon"),e=Math.PI/2,f=1e-10,g=a("../common/mlfn"),h=a("../common/e0fn"),i=a("../common/e1fn"),j=a("../common/e2fn"),k=a("../common/e3fn"),l=a("../common/gN"),m=a("../common/asinz"),n=a("../common/imlfn");c.init=function(){this.sin_p12=Math.sin(this.lat0),this.cos_p12=Math.cos(this.lat0)},c.forward=function(a){var b,c,m,n,o,p,q,r,s,t,u,v,w,x,y,z,A,B,C,D,E,F,G,H=a.x,I=a.y,J=Math.sin(a.y),K=Math.cos(a.y),L=d(H-this.long0);return this.sphere?Math.abs(this.sin_p12-1)<=f?(a.x=this.x0+this.a*(e-I)*Math.sin(L),a.y=this.y0-this.a*(e-I)*Math.cos(L),a):Math.abs(this.sin_p12+1)<=f?(a.x=this.x0+this.a*(e+I)*Math.sin(L),a.y=this.y0+this.a*(e+I)*Math.cos(L),a):(B=this.sin_p12*J+this.cos_p12*K*Math.cos(L),z=Math.acos(B),A=z/Math.sin(z),a.x=this.x0+this.a*A*K*Math.sin(L),a.y=this.y0+this.a*A*(this.cos_p12*J-this.sin_p12*K*Math.cos(L)),a):(b=h(this.es),c=i(this.es),m=j(this.es),n=k(this.es),Math.abs(this.sin_p12-1)<=f?(o=this.a*g(b,c,m,n,e),p=this.a*g(b,c,m,n,I),a.x=this.x0+(o-p)*Math.sin(L),a.y=this.y0-(o-p)*Math.cos(L),a):Math.abs(this.sin_p12+1)<=f?(o=this.a*g(b,c,m,n,e),p=this.a*g(b,c,m,n,I),a.x=this.x0+(o+p)*Math.sin(L),a.y=this.y0+(o+p)*Math.cos(L),a):(q=J/K,r=l(this.a,this.e,this.sin_p12),s=l(this.a,this.e,J),t=Math.atan((1-this.es)*q+this.es*r*this.sin_p12/(s*K)),u=Math.atan2(Math.sin(L),this.cos_p12*Math.tan(t)-this.sin_p12*Math.cos(L)),C=0===u?Math.asin(this.cos_p12*Math.sin(t)-this.sin_p12*Math.cos(t)):Math.abs(Math.abs(u)-Math.PI)<=f?-Math.asin(this.cos_p12*Math.sin(t)-this.sin_p12*Math.cos(t)):Math.asin(Math.sin(L)*Math.cos(t)/Math.sin(u)),v=this.e*this.sin_p12/Math.sqrt(1-this.es),w=this.e*this.cos_p12*Math.cos(u)/Math.sqrt(1-this.es),x=v*w,y=w*w,D=C*C,E=D*C,F=E*C,G=F*C,z=r*C*(1-D*y*(1-y)/6+E/8*x*(1-2*y)+F/120*(y*(4-7*y)-3*v*v*(1-7*y))-G/48*x),a.x=this.x0+z*Math.sin(u),a.y=this.y0+z*Math.cos(u),a))},c.inverse=function(a){a.x-=this.x0,a.y-=this.y0;var b,c,o,p,q,r,s,t,u,v,w,x,y,z,A,B,C,D,E,F,G,H,I;if(this.sphere){if(b=Math.sqrt(a.x*a.x+a.y*a.y),b>2*e*this.a)return;return c=b/this.a,o=Math.sin(c),p=Math.cos(c),q=this.long0,Math.abs(b)<=f?r=this.lat0:(r=m(p*this.sin_p12+a.y*o*this.cos_p12/b),s=Math.abs(this.lat0)-e,q=d(Math.abs(s)<=f?this.lat0>=0?this.long0+Math.atan2(a.x,-a.y):this.long0-Math.atan2(-a.x,a.y):this.long0+Math.atan2(a.x*o,b*this.cos_p12*p-a.y*this.sin_p12*o))),a.x=q,a.y=r,a}return t=h(this.es),u=i(this.es),v=j(this.es),w=k(this.es),Math.abs(this.sin_p12-1)<=f?(x=this.a*g(t,u,v,w,e),b=Math.sqrt(a.x*a.x+a.y*a.y),y=x-b,r=n(y/this.a,t,u,v,w),q=d(this.long0+Math.atan2(a.x,-1*a.y)),a.x=q,a.y=r,a):Math.abs(this.sin_p12+1)<=f?(x=this.a*g(t,u,v,w,e),b=Math.sqrt(a.x*a.x+a.y*a.y),y=b-x,r=n(y/this.a,t,u,v,w),q=d(this.long0+Math.atan2(a.x,a.y)),a.x=q,a.y=r,a):(b=Math.sqrt(a.x*a.x+a.y*a.y),B=Math.atan2(a.x,a.y),z=l(this.a,this.e,this.sin_p12),C=Math.cos(B),D=this.e*this.cos_p12*C,E=-D*D/(1-this.es),F=3*this.es*(1-E)*this.sin_p12*this.cos_p12*C/(1-this.es),G=b/z,H=G-E*(1+E)*Math.pow(G,3)/6-F*(1+3*E)*Math.pow(G,4)/24,I=1-E*H*H/2-G*H*H*H/6,A=Math.asin(this.sin_p12*Math.cos(H)+this.cos_p12*Math.sin(H)*C),q=d(this.long0+Math.asin(Math.sin(B)*Math.sin(H)/Math.cos(A))),r=Math.atan((1-this.es*I*this.sin_p12/Math.sin(A))*Math.tan(A)/(1-this.es)),a.x=q,a.y=r,a)},c.names=["Azimuthal_Equidistant","aeqd"]},{"../common/adjust_lon":5,"../common/asinz":6,"../common/e0fn":7,"../common/e1fn":8,"../common/e2fn":9,"../common/e3fn":10,"../common/gN":11,"../common/imlfn":12,"../common/mlfn":14}],42:[function(a,b,c){var d=a("../common/mlfn"),e=a("../common/e0fn"),f=a("../common/e1fn"),g=a("../common/e2fn"),h=a("../common/e3fn"),i=a("../common/gN"),j=a("../common/adjust_lon"),k=a("../common/adjust_lat"),l=a("../common/imlfn"),m=Math.PI/2,n=1e-10;c.init=function(){this.sphere||(this.e0=e(this.es),this.e1=f(this.es),this.e2=g(this.es),this.e3=h(this.es),this.ml0=this.a*d(this.e0,this.e1,this.e2,this.e3,this.lat0))},c.forward=function(a){var b,c,e=a.x,f=a.y;if(e=j(e-this.long0),this.sphere)b=this.a*Math.asin(Math.cos(f)*Math.sin(e)),c=this.a*(Math.atan2(Math.tan(f),Math.cos(e))-this.lat0);else{var g=Math.sin(f),h=Math.cos(f),k=i(this.a,this.e,g),l=Math.tan(f)*Math.tan(f),m=e*Math.cos(f),n=m*m,o=this.es*h*h/(1-this.es),p=this.a*d(this.e0,this.e1,this.e2,this.e3,f);b=k*m*(1-n*l*(1/6-(8-l+8*o)*n/120)),c=p-this.ml0+k*g/h*n*(.5+(5-l+6*o)*n/24)}return a.x=b+this.x0,a.y=c+this.y0,a},c.inverse=function(a){a.x-=this.x0,a.y-=this.y0;var b,c,d=a.x/this.a,e=a.y/this.a;if(this.sphere){var f=e+this.lat0;b=Math.asin(Math.sin(f)*Math.cos(d)),c=Math.atan2(Math.tan(d),Math.cos(f))}else{var g=this.ml0/this.a+e,h=l(g,this.e0,this.e1,this.e2,this.e3);if(Math.abs(Math.abs(h)-m)<=n)return a.x=this.long0,a.y=m,0>e&&(a.y*=-1),a;var o=i(this.a,this.e,Math.sin(h)),p=o*o*o/this.a/this.a*(1-this.es),q=Math.pow(Math.tan(h),2),r=d*this.a/o,s=r*r;b=h-o*Math.tan(h)/p*r*r*(.5-(1+3*q)*r*r/24),c=r*(1-s*(q/3+(1+3*q)*q*s/15))/Math.cos(h)}return a.x=j(c+this.long0),a.y=k(b),a},c.names=["Cassini","Cassini_Soldner","cass"]},{"../common/adjust_lat":4,"../common/adjust_lon":5,"../common/e0fn":7,"../common/e1fn":8,"../common/e2fn":9,"../common/e3fn":10,"../common/gN":11,"../common/imlfn":12,"../common/mlfn":14}],43:[function(a,b,c){var d=a("../common/adjust_lon"),e=a("../common/qsfnz"),f=a("../common/msfnz"),g=a("../common/iqsfnz");c.init=function(){this.sphere||(this.k0=f(this.e,Math.sin(this.lat_ts),Math.cos(this.lat_ts)))},c.forward=function(a){var b,c,f=a.x,g=a.y,h=d(f-this.long0);if(this.sphere)b=this.x0+this.a*h*Math.cos(this.lat_ts),c=this.y0+this.a*Math.sin(g)/Math.cos(this.lat_ts);else{var i=e(this.e,Math.sin(g));b=this.x0+this.a*this.k0*h,c=this.y0+this.a*i*.5/this.k0}return a.x=b,a.y=c,a},c.inverse=function(a){a.x-=this.x0,a.y-=this.y0;var b,c;return this.sphere?(b=d(this.long0+a.x/this.a/Math.cos(this.lat_ts)),c=Math.asin(a.y/this.a*Math.cos(this.lat_ts))):(c=g(this.e,2*a.y*this.k0/this.a),b=d(this.long0+a.x/(this.a*this.k0))),a.x=b,a.y=c,a},c.names=["cea"]},{"../common/adjust_lon":5,"../common/iqsfnz":13,"../common/msfnz":15,"../common/qsfnz":20}],44:[function(a,b,c){var d=a("../common/adjust_lon"),e=a("../common/adjust_lat");c.init=function(){this.x0=this.x0||0,this.y0=this.y0||0,this.lat0=this.lat0||0,this.long0=this.long0||0,this.lat_ts=this.lat_ts||0,this.title=this.title||"Equidistant Cylindrical (Plate Carre)",this.rc=Math.cos(this.lat_ts)},c.forward=function(a){var b=a.x,c=a.y,f=d(b-this.long0),g=e(c-this.lat0);return a.x=this.x0+this.a*f*this.rc,a.y=this.y0+this.a*g,a},c.inverse=function(a){var b=a.x,c=a.y;return a.x=d(this.long0+(b-this.x0)/(this.a*this.rc)),a.y=e(this.lat0+(c-this.y0)/this.a),a},c.names=["Equirectangular","Equidistant_Cylindrical","eqc"]},{"../common/adjust_lat":4,"../common/adjust_lon":5}],45:[function(a,b,c){var d=a("../common/e0fn"),e=a("../common/e1fn"),f=a("../common/e2fn"),g=a("../common/e3fn"),h=a("../common/msfnz"),i=a("../common/mlfn"),j=a("../common/adjust_lon"),k=a("../common/adjust_lat"),l=a("../common/imlfn"),m=1e-10;c.init=function(){Math.abs(this.lat1+this.lat2)=0?(c=Math.sqrt(a.x*a.x+a.y*a.y),b=1):(c=-Math.sqrt(a.x*a.x+a.y*a.y),b=-1);var f=0;if(0!==c&&(f=Math.atan2(b*a.x,b*a.y)),this.sphere)return e=j(this.long0+f/this.ns),d=k(this.g-c/this.a),a.x=e,a.y=d,a;var g=this.g-c/this.a;return d=l(g,this.e0,this.e1,this.e2,this.e3),e=j(this.long0+f/this.ns),a.x=e,a.y=d,a},c.names=["Equidistant_Conic","eqdc"]},{"../common/adjust_lat":4,"../common/adjust_lon":5,"../common/e0fn":7,"../common/e1fn":8,"../common/e2fn":9,"../common/e3fn":10,"../common/imlfn":12,"../common/mlfn":14,"../common/msfnz":15}],46:[function(a,b,c){var d=Math.PI/4,e=a("../common/srat"),f=Math.PI/2,g=20;c.init=function(){var a=Math.sin(this.lat0),b=Math.cos(this.lat0);b*=b,this.rc=Math.sqrt(1-this.es)/(1-this.es*a*a),this.C=Math.sqrt(1+this.es*b*b/(1-this.es)),this.phic0=Math.asin(a/this.C),this.ratexp=.5*this.C*this.e,this.K=Math.tan(.5*this.phic0+d)/(Math.pow(Math.tan(.5*this.lat0+d),this.C)*e(this.e*a,this.ratexp))},c.forward=function(a){var b=a.x,c=a.y;return a.y=2*Math.atan(this.K*Math.pow(Math.tan(.5*c+d),this.C)*e(this.e*Math.sin(c),this.ratexp))-f,a.x=this.C*b,a},c.inverse=function(a){for(var b=1e-14,c=a.x/this.C,h=a.y,i=Math.pow(Math.tan(.5*h+d)/this.K,1/this.C),j=g;j>0&&(h=2*Math.atan(i*e(this.e*Math.sin(a.y),-.5*this.e))-f,!(Math.abs(h-a.y)0||Math.abs(i)<=e?(j=this.x0+this.a*h*c*Math.sin(f)/i,k=this.y0+this.a*h*(this.cos_p14*b-this.sin_p14*c*g)/i):(j=this.x0+this.infinity_dist*c*Math.sin(f),k=this.y0+this.infinity_dist*(this.cos_p14*b-this.sin_p14*c*g)),a.x=j,a.y=k,a},c.inverse=function(a){var b,c,e,g,h,i;return a.x=(a.x-this.x0)/this.a,a.y=(a.y-this.y0)/this.a,a.x/=this.k0,a.y/=this.k0,(b=Math.sqrt(a.x*a.x+a.y*a.y))?(g=Math.atan2(b,this.rc),c=Math.sin(g),e=Math.cos(g),i=f(e*this.sin_p14+a.y*c*this.cos_p14/b),h=Math.atan2(a.x*c,b*this.cos_p14*e-a.y*this.sin_p14*c),h=d(this.long0+h)):(i=this.phic0,h=0),a.x=h,a.y=i,a},c.names=["gnom"]},{"../common/adjust_lon":5,"../common/asinz":6}],48:[function(a,b,c){var d=a("../common/adjust_lon");c.init=function(){this.a=6377397.155,this.es=.006674372230614,this.e=Math.sqrt(this.es),this.lat0||(this.lat0=.863937979737193),this.long0||(this.long0=.4334234309119251),this.k0||(this.k0=.9999),this.s45=.785398163397448,this.s90=2*this.s45,this.fi0=this.lat0,this.e2=this.es,this.e=Math.sqrt(this.e2),this.alfa=Math.sqrt(1+this.e2*Math.pow(Math.cos(this.fi0),4)/(1-this.e2)),this.uq=1.04216856380474,this.u0=Math.asin(Math.sin(this.fi0)/this.alfa),this.g=Math.pow((1+this.e*Math.sin(this.fi0))/(1-this.e*Math.sin(this.fi0)),this.alfa*this.e/2),this.k=Math.tan(this.u0/2+this.s45)/Math.pow(Math.tan(this.fi0/2+this.s45),this.alfa)*this.g,this.k1=this.k0,this.n0=this.a*Math.sqrt(1-this.e2)/(1-this.e2*Math.pow(Math.sin(this.fi0),2)),this.s0=1.37008346281555,this.n=Math.sin(this.s0),this.ro0=this.k1*this.n0/Math.tan(this.s0),this.ad=this.s90-this.uq},c.forward=function(a){var b,c,e,f,g,h,i,j=a.x,k=a.y,l=d(j-this.long0);return b=Math.pow((1+this.e*Math.sin(k))/(1-this.e*Math.sin(k)),this.alfa*this.e/2),c=2*(Math.atan(this.k*Math.pow(Math.tan(k/2+this.s45),this.alfa)/b)-this.s45),e=-l*this.alfa,f=Math.asin(Math.cos(this.ad)*Math.sin(c)+Math.sin(this.ad)*Math.cos(c)*Math.cos(e)),g=Math.asin(Math.cos(c)*Math.sin(e)/Math.cos(f)),h=this.n*g,i=this.ro0*Math.pow(Math.tan(this.s0/2+this.s45),this.n)/Math.pow(Math.tan(f/2+this.s45),this.n),a.y=i*Math.cos(h)/1,a.x=i*Math.sin(h)/1,this.czech||(a.y*=-1,a.x*=-1),a},c.inverse=function(a){var b,c,d,e,f,g,h,i,j=a.x;a.x=a.y,a.y=j,this.czech||(a.y*=-1,a.x*=-1),g=Math.sqrt(a.x*a.x+a.y*a.y),f=Math.atan2(a.y,a.x),e=f/Math.sin(this.s0),d=2*(Math.atan(Math.pow(this.ro0/g,1/this.n)*Math.tan(this.s0/2+this.s45))-this.s45),b=Math.asin(Math.cos(this.ad)*Math.sin(d)-Math.sin(this.ad)*Math.cos(d)*Math.cos(e)),c=Math.asin(Math.cos(d)*Math.sin(e)/Math.cos(b)),a.x=this.long0-c/this.alfa,h=b,i=0;var k=0;do a.y=2*(Math.atan(Math.pow(this.k,-1/this.alfa)*Math.pow(Math.tan(b/2+this.s45),1/this.alfa)*Math.pow((1+this.e*Math.sin(h))/(1-this.e*Math.sin(h)),this.e/2))-this.s45),Math.abs(h-a.y)<1e-10&&(i=1),h=a.y,k+=1;while(0===i&&15>k);return k>=15?null:a},c.names=["Krovak","krovak"]},{"../common/adjust_lon":5}],49:[function(a,b,c){var d=Math.PI/2,e=Math.PI/4,f=1e-10,g=a("../common/qsfnz"),h=a("../common/adjust_lon");c.S_POLE=1,c.N_POLE=2,c.EQUIT=3,c.OBLIQ=4,c.init=function(){var a=Math.abs(this.lat0);if(Math.abs(a-d)0){var b;switch(this.qp=g(this.e,1),this.mmf=.5/(1-this.es),this.apa=this.authset(this.es),this.mode){case this.N_POLE:this.dd=1;break;case this.S_POLE:this.dd=1;break;case this.EQUIT:this.rq=Math.sqrt(.5*this.qp),this.dd=1/this.rq,this.xmf=1,this.ymf=.5*this.qp;break;case this.OBLIQ:this.rq=Math.sqrt(.5*this.qp),b=Math.sin(this.lat0),this.sinb1=g(this.e,b)/this.qp,this.cosb1=Math.sqrt(1-this.sinb1*this.sinb1),this.dd=Math.cos(this.lat0)/(Math.sqrt(1-this.es*b*b)*this.rq*this.cosb1),this.ymf=(this.xmf=this.rq)/this.dd,this.xmf*=this.dd}}else this.mode===this.OBLIQ&&(this.sinph0=Math.sin(this.lat0),this.cosph0=Math.cos(this.lat0))},c.forward=function(a){var b,c,i,j,k,l,m,n,o,p,q=a.x,r=a.y;if(q=h(q-this.long0),this.sphere){if(k=Math.sin(r),p=Math.cos(r),i=Math.cos(q),this.mode===this.OBLIQ||this.mode===this.EQUIT){if(c=this.mode===this.EQUIT?1+p*i:1+this.sinph0*k+this.cosph0*p*i,f>=c)return null;c=Math.sqrt(2/c),b=c*p*Math.sin(q),c*=this.mode===this.EQUIT?k:this.cosph0*k-this.sinph0*p*i}else if(this.mode===this.N_POLE||this.mode===this.S_POLE){if(this.mode===this.N_POLE&&(i=-i),Math.abs(r+this.phi0)=0?(b=(o=Math.sqrt(l))*j,c=i*(this.mode===this.S_POLE?o:-o)):b=c=0}}return a.x=this.a*b+this.x0,a.y=this.a*c+this.y0,a},c.inverse=function(a){a.x-=this.x0,a.y-=this.y0;var b,c,e,g,i,j,k,l=a.x/this.a,m=a.y/this.a;if(this.sphere){var n,o=0,p=0;if(n=Math.sqrt(l*l+m*m),c=.5*n,c>1)return null;switch(c=2*Math.asin(c),(this.mode===this.OBLIQ||this.mode===this.EQUIT)&&(p=Math.sin(c),o=Math.cos(c)),this.mode){case this.EQUIT:c=Math.abs(n)<=f?0:Math.asin(m*p/n),l*=p,m=o*n;break;case this.OBLIQ:c=Math.abs(n)<=f?this.phi0:Math.asin(o*this.sinph0+m*p*this.cosph0/n),l*=p*this.cosph0,m=(o-Math.sin(c)*this.sinph0)*n;break;case this.N_POLE:m=-m,c=d-c;break;case this.S_POLE:c-=d}b=0!==m||this.mode!==this.EQUIT&&this.mode!==this.OBLIQ?Math.atan2(l,m):0}else{if(k=0,this.mode===this.OBLIQ||this.mode===this.EQUIT){if(l/=this.dd,m*=this.dd,j=Math.sqrt(l*l+m*m),f>j)return a.x=0,a.y=this.phi0,a;g=2*Math.asin(.5*j/this.rq),e=Math.cos(g),l*=g=Math.sin(g),this.mode===this.OBLIQ?(k=e*this.sinb1+m*g*this.cosb1/j,i=this.qp*k,m=j*this.cosb1*e-m*this.sinb1*g):(k=m*g/j,i=this.qp*k,m=j*e)}else if(this.mode===this.N_POLE||this.mode===this.S_POLE){if(this.mode===this.N_POLE&&(m=-m),i=l*l+m*m,!i)return a.x=0,a.y=this.phi0,a;k=1-i/this.qp,this.mode===this.S_POLE&&(k=-k)}b=Math.atan2(l,m),c=this.authlat(Math.asin(k),this.apa)}return a.x=h(this.long0+b),a.y=c,a},c.P00=.3333333333333333,c.P01=.17222222222222222,c.P02=.10257936507936508,c.P10=.06388888888888888,c.P11=.0664021164021164,c.P20=.016415012942191543,c.authset=function(a){var b,c=[];return c[0]=a*this.P00,b=a*a,c[0]+=b*this.P01,c[1]=b*this.P10,b*=a,c[0]+=b*this.P02,c[1]+=b*this.P11,c[2]=b*this.P20,c},c.authlat=function(a,b){var c=a+a;return a+b[0]*Math.sin(c)+b[1]*Math.sin(c+c)+b[2]*Math.sin(c+c+c)},c.names=["Lambert Azimuthal Equal Area","Lambert_Azimuthal_Equal_Area","laea"]},{"../common/adjust_lon":5,"../common/qsfnz":20}],50:[function(a,b,c){var d=1e-10,e=a("../common/msfnz"),f=a("../common/tsfnz"),g=Math.PI/2,h=a("../common/sign"),i=a("../common/adjust_lon"),j=a("../common/phi2z");c.init=function(){if(this.lat2||(this.lat2=this.lat1),this.k0||(this.k0=1),this.x0=this.x0||0,this.y0=this.y0||0,!(Math.abs(this.lat1+this.lat2)d?this.ns=Math.log(g/k)/Math.log(h/l):this.ns=b,isNaN(this.ns)&&(this.ns=b),this.f0=g/(this.ns*Math.pow(h,this.ns)),this.rh=this.a*this.f0*Math.pow(m,this.ns),this.title||(this.title="Lambert Conformal Conic")}},c.forward=function(a){var b=a.x,c=a.y;Math.abs(2*Math.abs(c)-Math.PI)<=d&&(c=h(c)*(g-2*d));var e,j,k=Math.abs(Math.abs(c)-g);if(k>d)e=f(this.e,c,Math.sin(c)),j=this.a*this.f0*Math.pow(e,this.ns);else{if(k=c*this.ns,0>=k)return null;j=0}var l=this.ns*i(b-this.long0);return a.x=this.k0*(j*Math.sin(l))+this.x0,a.y=this.k0*(this.rh-j*Math.cos(l))+this.y0,a},c.inverse=function(a){var b,c,d,e,f,h=(a.x-this.x0)/this.k0,k=this.rh-(a.y-this.y0)/this.k0;this.ns>0?(b=Math.sqrt(h*h+k*k),c=1):(b=-Math.sqrt(h*h+k*k),c=-1);var l=0;if(0!==b&&(l=Math.atan2(c*h,c*k)),0!==b||this.ns>0){if(c=1/this.ns,d=Math.pow(b/(this.a*this.f0),c),e=j(this.e,d),-9999===e)return null}else e=-g;return f=i(l/this.ns+this.long0),a.x=f,a.y=e,a},c.names=["Lambert Tangential Conformal Conic Projection","Lambert_Conformal_Conic","Lambert_Conformal_Conic_2SP","lcc"]},{"../common/adjust_lon":5,"../common/msfnz":15,"../common/phi2z":16,"../common/sign":21,"../common/tsfnz":24}],51:[function(a,b,c){function d(a){return a}c.init=function(){},c.forward=d,c.inverse=d,c.names=["longlat","identity"]},{}],52:[function(a,b,c){var d=a("../common/msfnz"),e=Math.PI/2,f=1e-10,g=57.29577951308232,h=a("../common/adjust_lon"),i=Math.PI/4,j=a("../common/tsfnz"),k=a("../common/phi2z");c.init=function(){var a=this.b/this.a;this.es=1-a*a,"x0"in this||(this.x0=0),"y0"in this||(this.y0=0),this.e=Math.sqrt(this.es),this.lat_ts?this.sphere?this.k0=Math.cos(this.lat_ts):this.k0=d(this.e,Math.sin(this.lat_ts),Math.cos(this.lat_ts)):this.k0||(this.k?this.k0=this.k:this.k0=1)},c.forward=function(a){var b=a.x,c=a.y;if(c*g>90&&-90>c*g&&b*g>180&&-180>b*g)return null;var d,k;if(Math.abs(Math.abs(c)-e)<=f)return null;if(this.sphere)d=this.x0+this.a*this.k0*h(b-this.long0),k=this.y0+this.a*this.k0*Math.log(Math.tan(i+.5*c));else{var l=Math.sin(c),m=j(this.e,c,l);d=this.x0+this.a*this.k0*h(b-this.long0),k=this.y0-this.a*this.k0*Math.log(m)}return a.x=d,a.y=k,a},c.inverse=function(a){var b,c,d=a.x-this.x0,f=a.y-this.y0;if(this.sphere)c=e-2*Math.atan(Math.exp(-f/(this.a*this.k0)));else{var g=Math.exp(-f/(this.a*this.k0));if(c=k(this.e,g),-9999===c)return null}return b=h(this.long0+d/(this.a*this.k0)),a.x=b,a.y=c,a},c.names=["Mercator","Popular Visualisation Pseudo Mercator","Mercator_1SP","Mercator_Auxiliary_Sphere","merc"]},{"../common/adjust_lon":5,"../common/msfnz":15,"../common/phi2z":16,"../common/tsfnz":24}],53:[function(a,b,c){var d=a("../common/adjust_lon");c.init=function(){},c.forward=function(a){var b=a.x,c=a.y,e=d(b-this.long0),f=this.x0+this.a*e,g=this.y0+this.a*Math.log(Math.tan(Math.PI/4+c/2.5))*1.25;return a.x=f,a.y=g,a},c.inverse=function(a){a.x-=this.x0,a.y-=this.y0;var b=d(this.long0+a.x/this.a),c=2.5*(Math.atan(Math.exp(.8*a.y/this.a))-Math.PI/4);return a.x=b,a.y=c,a},c.names=["Miller_Cylindrical","mill"]},{"../common/adjust_lon":5}],54:[function(a,b,c){var d=a("../common/adjust_lon"),e=1e-10;c.init=function(){},c.forward=function(a){for(var b=a.x,c=a.y,f=d(b-this.long0),g=c,h=Math.PI*Math.sin(c),i=0;!0;i++){var j=-(g+Math.sin(g)-h)/(1+Math.cos(g));if(g+=j,Math.abs(j).999999999999&&(c=.999999999999),b=Math.asin(c);var e=d(this.long0+a.x/(.900316316158*this.a*Math.cos(b)));e<-Math.PI&&(e=-Math.PI),e>Math.PI&&(e=Math.PI),c=(2*b+Math.sin(2*b))/Math.PI,Math.abs(c)>1&&(c=1);var f=Math.asin(c);return a.x=e,a.y=f,a},c.names=["Mollweide","moll"]},{"../common/adjust_lon":5}],55:[function(a,b,c){var d=484813681109536e-20;c.iterations=1,c.init=function(){this.A=[],this.A[1]=.6399175073,this.A[2]=-.1358797613,this.A[3]=.063294409,this.A[4]=-.02526853,this.A[5]=.0117879,this.A[6]=-.0055161,this.A[7]=.0026906,this.A[8]=-.001333,this.A[9]=67e-5,this.A[10]=-34e-5,this.B_re=[],this.B_im=[],this.B_re[1]=.7557853228,this.B_im[1]=0,this.B_re[2]=.249204646,this.B_im[2]=.003371507,this.B_re[3]=-.001541739,this.B_im[3]=.04105856,this.B_re[4]=-.10162907,this.B_im[4]=.01727609,this.B_re[5]=-.26623489,this.B_im[5]=-.36249218,this.B_re[6]=-.6870983,this.B_im[6]=-1.1651967,this.C_re=[],this.C_im=[],this.C_re[1]=1.3231270439,this.C_im[1]=0,this.C_re[2]=-.577245789,this.C_im[2]=-.007809598,this.C_re[3]=.508307513,this.C_im[3]=-.112208952,this.C_re[4]=-.15094762,this.C_im[4]=.18200602,this.C_re[5]=1.01418179,this.C_im[5]=1.64497696,this.C_re[6]=1.9660549,this.C_im[6]=2.5127645,this.D=[],this.D[1]=1.5627014243,this.D[2]=.5185406398,this.D[3]=-.03333098,this.D[4]=-.1052906,this.D[5]=-.0368594,this.D[6]=.007317,this.D[7]=.0122,this.D[8]=.00394,this.D[9]=-.0013},c.forward=function(a){var b,c=a.x,e=a.y,f=e-this.lat0,g=c-this.long0,h=f/d*1e-5,i=g,j=1,k=0;for(b=1;10>=b;b++)j*=h,k+=this.A[b]*j;var l,m,n=k,o=i,p=1,q=0,r=0,s=0;for(b=1;6>=b;b++)l=p*n-q*o,m=q*n+p*o,p=l,q=m,r=r+this.B_re[b]*p-this.B_im[b]*q,s=s+this.B_im[b]*p+this.B_re[b]*q;return a.x=s*this.a+this.x0,a.y=r*this.a+this.y0,a},c.inverse=function(a){var b,c,e,f=a.x,g=a.y,h=f-this.x0,i=g-this.y0,j=i/this.a,k=h/this.a,l=1,m=0,n=0,o=0;for(b=1;6>=b;b++)c=l*j-m*k,e=m*j+l*k,l=c,m=e,n=n+this.C_re[b]*l-this.C_im[b]*m,o=o+this.C_im[b]*l+this.C_re[b]*m;for(var p=0;p=b;b++)q=s*n-t*o,r=t*n+s*o,s=q,t=r,u+=(b-1)*(this.B_re[b]*s-this.B_im[b]*t),v+=(b-1)*(this.B_im[b]*s+this.B_re[b]*t);s=1,t=0;var w=this.B_re[1],x=this.B_im[1];for(b=2;6>=b;b++)q=s*n-t*o,r=t*n+s*o,s=q,t=r,w+=b*(this.B_re[b]*s-this.B_im[b]*t),x+=b*(this.B_im[b]*s+this.B_re[b]*t);var y=w*w+x*x;n=(u*w+v*x)/y,o=(v*w-u*x)/y}var z=n,A=o,B=1,C=0;for(b=1;9>=b;b++)B*=z,C+=this.D[b]*B;var D=this.lat0+C*d*1e5,E=this.long0+A;return a.x=E,a.y=D,a},c.names=["New_Zealand_Map_Grid","nzmg"]},{}],56:[function(a,b,c){var d=a("../common/tsfnz"),e=a("../common/adjust_lon"),f=a("../common/phi2z"),g=Math.PI/2,h=Math.PI/4,i=1e-10;c.init=function(){this.no_off=this.no_off||!1,this.no_rot=this.no_rot||!1,isNaN(this.k0)&&(this.k0=1);var a=Math.sin(this.lat0),b=Math.cos(this.lat0),c=this.e*a;this.bl=Math.sqrt(1+this.es/(1-this.es)*Math.pow(b,4)),this.al=this.a*this.bl*this.k0*Math.sqrt(1-this.es)/(1-c*c);var f=d(this.e,this.lat0,a),g=this.bl/b*Math.sqrt((1-this.es)/(1-c*c));1>g*g&&(g=1);var h,i;if(isNaN(this.longc)){var j=d(this.e,this.lat1,Math.sin(this.lat1)),k=d(this.e,this.lat2,Math.sin(this.lat2));this.lat0>=0?this.el=(g+Math.sqrt(g*g-1))*Math.pow(f,this.bl):this.el=(g-Math.sqrt(g*g-1))*Math.pow(f,this.bl);var l=Math.pow(j,this.bl),m=Math.pow(k,this.bl);h=this.el/l,i=.5*(h-1/h);var n=(this.el*this.el-m*l)/(this.el*this.el+m*l),o=(m-l)/(m+l),p=e(this.long1-this.long2);this.long0=.5*(this.long1+this.long2)-Math.atan(n*Math.tan(.5*this.bl*p)/o)/this.bl,this.long0=e(this.long0);var q=e(this.long1-this.long0);this.gamma0=Math.atan(Math.sin(this.bl*q)/i),this.alpha=Math.asin(g*Math.sin(this.gamma0))}else h=this.lat0>=0?g+Math.sqrt(g*g-1):g-Math.sqrt(g*g-1),this.el=h*Math.pow(f,this.bl),i=.5*(h-1/h),this.gamma0=Math.asin(Math.sin(this.alpha)/g),this.long0=this.longc-Math.asin(i*Math.tan(this.gamma0))/this.bl;this.no_off?this.uc=0:this.lat0>=0?this.uc=this.al/this.bl*Math.atan2(Math.sqrt(g*g-1),Math.cos(this.alpha)):this.uc=-1*this.al/this.bl*Math.atan2(Math.sqrt(g*g-1),Math.cos(this.alpha))},c.forward=function(a){var b,c,f,j=a.x,k=a.y,l=e(j-this.long0);if(Math.abs(Math.abs(k)-g)<=i)f=k>0?-1:1,c=this.al/this.bl*Math.log(Math.tan(h+f*this.gamma0*.5)),b=-1*f*g*this.al/this.bl;else{var m=d(this.e,k,Math.sin(k)),n=this.el/Math.pow(m,this.bl),o=.5*(n-1/n),p=.5*(n+1/n),q=Math.sin(this.bl*l),r=(o*Math.sin(this.gamma0)-q*Math.cos(this.gamma0))/p;c=Math.abs(Math.abs(r)-1)<=i?Number.POSITIVE_INFINITY:.5*this.al*Math.log((1-r)/(1+r))/this.bl,b=Math.abs(Math.cos(this.bl*l))<=i?this.al*this.bl*l:this.al*Math.atan2(o*Math.cos(this.gamma0)+q*Math.sin(this.gamma0),Math.cos(this.bl*l))/this.bl}return this.no_rot?(a.x=this.x0+b,a.y=this.y0+c):(b-=this.uc,a.x=this.x0+c*Math.cos(this.alpha)+b*Math.sin(this.alpha),a.y=this.y0+b*Math.cos(this.alpha)-c*Math.sin(this.alpha)),a},c.inverse=function(a){var b,c;this.no_rot?(c=a.y-this.y0,b=a.x-this.x0):(c=(a.x-this.x0)*Math.cos(this.alpha)-(a.y-this.y0)*Math.sin(this.alpha),b=(a.y-this.y0)*Math.cos(this.alpha)+(a.x-this.x0)*Math.sin(this.alpha),b+=this.uc);var d=Math.exp(-1*this.bl*c/this.al),h=.5*(d-1/d),j=.5*(d+1/d),k=Math.sin(this.bl*b/this.al),l=(k*Math.cos(this.gamma0)+h*Math.sin(this.gamma0))/j,m=Math.pow(this.el/Math.sqrt((1+l)/(1-l)),1/this.bl);return Math.abs(l-1)g?(g=Math.sin(b),c=this.long0+a.x*Math.sqrt(1-this.es*g*g)/(this.a*Math.cos(b)),f=d(c)):j>g-k&&(f=this.long0)),a.x=f,a.y=b,a},c.names=["Sinusoidal","sinu"]},{"../common/adjust_lat":4,"../common/adjust_lon":5,"../common/asinz":6,"../common/pj_enfn":17,"../common/pj_inv_mlfn":18,"../common/pj_mlfn":19}],59:[function(a,b,c){c.init=function(){var a=this.lat0;this.lambda0=this.long0;var b=Math.sin(a),c=this.a,d=this.rf,e=1/d,f=2*e-Math.pow(e,2),g=this.e=Math.sqrt(f);this.R=this.k0*c*Math.sqrt(1-f)/(1-f*Math.pow(b,2)),this.alpha=Math.sqrt(1+f/(1-f)*Math.pow(Math.cos(a),4)),this.b0=Math.asin(b/this.alpha);var h=Math.log(Math.tan(Math.PI/4+this.b0/2)),i=Math.log(Math.tan(Math.PI/4+a/2)),j=Math.log((1+g*b)/(1-g*b));this.K=h-this.alpha*i+this.alpha*g/2*j},c.forward=function(a){var b=Math.log(Math.tan(Math.PI/4-a.y/2)),c=this.e/2*Math.log((1+this.e*Math.sin(a.y))/(1-this.e*Math.sin(a.y))),d=-this.alpha*(b+c)+this.K,e=2*(Math.atan(Math.exp(d))-Math.PI/4),f=this.alpha*(a.x-this.lambda0),g=Math.atan(Math.sin(f)/(Math.sin(this.b0)*Math.tan(e)+Math.cos(this.b0)*Math.cos(f))),h=Math.asin(Math.cos(this.b0)*Math.sin(e)-Math.sin(this.b0)*Math.cos(e)*Math.cos(f));return a.y=this.R/2*Math.log((1+Math.sin(h))/(1-Math.sin(h)))+this.y0,a.x=this.R*g+this.x0,a},c.inverse=function(a){for(var b=a.x-this.x0,c=a.y-this.y0,d=b/this.R,e=2*(Math.atan(Math.exp(c/this.R))-Math.PI/4),f=Math.asin(Math.cos(this.b0)*Math.sin(e)+Math.sin(this.b0)*Math.cos(e)*Math.cos(d)),g=Math.atan(Math.sin(d)/(Math.cos(this.b0)*Math.cos(d)-Math.sin(this.b0)*Math.tan(e))),h=this.lambda0+g/this.alpha,i=0,j=f,k=-1e3,l=0;Math.abs(j-k)>1e-7;){if(++l>20)return;i=1/this.alpha*(Math.log(Math.tan(Math.PI/4+f/2))-this.K)+this.e*Math.log(Math.tan(Math.PI/4+Math.asin(this.e*Math.sin(j))/2)),k=j,j=2*Math.atan(Math.exp(i))-Math.PI/2}return a.x=h,a.y=j,a},c.names=["somerc"]},{}],60:[function(a,b,c){var d=Math.PI/2,e=1e-10,f=a("../common/sign"),g=a("../common/msfnz"),h=a("../common/tsfnz"),i=a("../common/phi2z"),j=a("../common/adjust_lon");c.ssfn_=function(a,b,c){return b*=c,Math.tan(.5*(d+a))*Math.pow((1-b)/(1+b),.5*c)},c.init=function(){this.coslat0=Math.cos(this.lat0),this.sinlat0=Math.sin(this.lat0),this.sphere?1===this.k0&&!isNaN(this.lat_ts)&&Math.abs(this.coslat0)<=e&&(this.k0=.5*(1+f(this.lat0)*Math.sin(this.lat_ts))):(Math.abs(this.coslat0)<=e&&(this.lat0>0?this.con=1:this.con=-1),this.cons=Math.sqrt(Math.pow(1+this.e,1+this.e)*Math.pow(1-this.e,1-this.e)),1===this.k0&&!isNaN(this.lat_ts)&&Math.abs(this.coslat0)<=e&&(this.k0=.5*this.cons*g(this.e,Math.sin(this.lat_ts),Math.cos(this.lat_ts))/h(this.e,this.con*this.lat_ts,this.con*Math.sin(this.lat_ts))),this.ms1=g(this.e,this.sinlat0,this.coslat0),this.X0=2*Math.atan(this.ssfn_(this.lat0,this.sinlat0,this.e))-d,this.cosX0=Math.cos(this.X0),this.sinX0=Math.sin(this.X0))},c.forward=function(a){var b,c,f,g,i,k,l=a.x,m=a.y,n=Math.sin(m),o=Math.cos(m),p=j(l-this.long0);return Math.abs(Math.abs(l-this.long0)-Math.PI)<=e&&Math.abs(m+this.lat0)<=e?(a.x=NaN,a.y=NaN,a):this.sphere?(b=2*this.k0/(1+this.sinlat0*n+this.coslat0*o*Math.cos(p)),a.x=this.a*b*o*Math.sin(p)+this.x0,a.y=this.a*b*(this.coslat0*n-this.sinlat0*o*Math.cos(p))+this.y0,a):(c=2*Math.atan(this.ssfn_(m,n,this.e))-d,g=Math.cos(c),f=Math.sin(c),Math.abs(this.coslat0)<=e?(i=h(this.e,m*this.con,this.con*n),k=2*this.a*this.k0*i/this.cons,a.x=this.x0+k*Math.sin(l-this.long0),a.y=this.y0-this.con*k*Math.cos(l-this.long0),a):(Math.abs(this.sinlat0)=k?(a.x=b,a.y=c,a):(c=Math.asin(Math.cos(l)*this.sinlat0+a.y*Math.sin(l)*this.coslat0/k),b=j(Math.abs(this.coslat0)0?this.long0+Math.atan2(a.x,-1*a.y):this.long0+Math.atan2(a.x,a.y):this.long0+Math.atan2(a.x*Math.sin(l),k*this.coslat0*Math.cos(l)-a.y*this.sinlat0*Math.sin(l))),a.x=b,a.y=c,a)}if(Math.abs(this.coslat0)<=e){if(e>=k)return c=this.lat0,b=this.long0,a.x=b,a.y=c,a;a.x*=this.con,a.y*=this.con,f=k*this.cons/(2*this.a*this.k0),c=this.con*i(this.e,f),b=this.con*j(this.con*this.long0+Math.atan2(a.x,-1*a.y))}else g=2*Math.atan(k*this.cosX0/(2*this.a*this.k0*this.ms1)),b=this.long0,e>=k?h=this.X0:(h=Math.asin(Math.cos(g)*this.sinX0+a.y*Math.sin(g)*this.cosX0/k),b=j(this.long0+Math.atan2(a.x*Math.sin(g),k*this.cosX0*Math.cos(g)-a.y*this.sinX0*Math.sin(g)))),c=-1*i(this.e,Math.tan(.5*(d+h)));return a.x=b,a.y=c,a},c.names=["stere","Stereographic_South_Pole","Polar Stereographic (variant B)"]},{"../common/adjust_lon":5,"../common/msfnz":15,"../common/phi2z":16,"../common/sign":21,"../common/tsfnz":24}],61:[function(a,b,c){var d=a("./gauss"),e=a("../common/adjust_lon");c.init=function(){d.init.apply(this),this.rc&&(this.sinc0=Math.sin(this.phic0),this.cosc0=Math.cos(this.phic0),this.R2=2*this.rc,this.title||(this.title="Oblique Stereographic Alternative"))},c.forward=function(a){var b,c,f,g;return a.x=e(a.x-this.long0),d.forward.apply(this,[a]),b=Math.sin(a.y),c=Math.cos(a.y),f=Math.cos(a.x),g=this.k0*this.R2/(1+this.sinc0*b+this.cosc0*c*f),a.x=g*c*Math.sin(a.x),a.y=g*(this.cosc0*b-this.sinc0*c*f),a.x=this.a*a.x+this.x0,a.y=this.a*a.y+this.y0,a},c.inverse=function(a){var b,c,f,g,h;if(a.x=(a.x-this.x0)/this.a,a.y=(a.y-this.y0)/this.a,a.x/=this.k0,a.y/=this.k0,h=Math.sqrt(a.x*a.x+a.y*a.y)){var i=2*Math.atan2(h,this.R2);b=Math.sin(i),c=Math.cos(i),g=Math.asin(c*this.sinc0+a.y*b*this.cosc0/h),f=Math.atan2(a.x*b,h*this.cosc0*c-a.y*this.sinc0*b)}else g=this.phic0,f=0;return a.x=f,a.y=g,d.inverse.apply(this,[a]),a.x=e(a.x+this.long0),a},c.names=["Stereographic_North_Pole","Oblique_Stereographic","Polar_Stereographic","sterea","Oblique Stereographic Alternative"]},{"../common/adjust_lon":5,"./gauss":46}],62:[function(a,b,c){var d=a("../common/e0fn"),e=a("../common/e1fn"),f=a("../common/e2fn"),g=a("../common/e3fn"),h=a("../common/mlfn"),i=a("../common/adjust_lon"),j=Math.PI/2,k=1e-10,l=a("../common/sign"),m=a("../common/asinz");c.init=function(){this.e0=d(this.es),this.e1=e(this.es),this.e2=f(this.es),this.e3=g(this.es),this.ml0=this.a*h(this.e0,this.e1,this.e2,this.e3,this.lat0)},c.forward=function(a){var b,c,d,e=a.x,f=a.y,g=i(e-this.long0),j=Math.sin(f),k=Math.cos(f);if(this.sphere){var l=k*Math.sin(g);if(Math.abs(Math.abs(l)-1)<1e-10)return 93;c=.5*this.a*this.k0*Math.log((1+l)/(1-l)),b=Math.acos(k*Math.cos(g)/Math.sqrt(1-l*l)),0>f&&(b=-b),d=this.a*this.k0*(b-this.lat0)}else{var m=k*g,n=Math.pow(m,2),o=this.ep2*Math.pow(k,2),p=Math.tan(f),q=Math.pow(p,2);b=1-this.es*Math.pow(j,2);var r=this.a/Math.sqrt(b),s=this.a*h(this.e0,this.e1,this.e2,this.e3,f);c=this.k0*r*m*(1+n/6*(1-q+o+n/20*(5-18*q+Math.pow(q,2)+72*o-58*this.ep2)))+this.x0,d=this.k0*(s-this.ml0+r*p*(n*(.5+n/24*(5-q+9*o+4*Math.pow(o,2)+n/30*(61-58*q+Math.pow(q,2)+600*o-330*this.ep2)))))+this.y0}return a.x=c,a.y=d,a},c.inverse=function(a){var b,c,d,e,f,g,h=6;if(this.sphere){var n=Math.exp(a.x/(this.a*this.k0)),o=.5*(n-1/n),p=this.lat0+a.y/(this.a*this.k0),q=Math.cos(p);b=Math.sqrt((1-q*q)/(1+o*o)),f=m(b),0>p&&(f=-f),g=0===o&&0===q?this.long0:i(Math.atan2(o,q)+this.long0)}else{var r=a.x-this.x0,s=a.y-this.y0;for(b=(this.ml0+s/this.k0)/this.a,c=b,e=0;!0&&(d=(b+this.e1*Math.sin(2*c)-this.e2*Math.sin(4*c)+this.e3*Math.sin(6*c))/this.e0-c,c+=d,!(Math.abs(d)<=k));e++)if(e>=h)return 95;if(Math.abs(c)=0?this.y0+Math.PI*this.R*Math.tan(.5*k):this.y0+Math.PI*this.R*-Math.tan(.5*k));var l=.5*Math.abs(Math.PI/j-j/Math.PI),m=l*l,n=Math.sin(k),o=Math.cos(k),p=o/(n+o-1),q=p*p,r=p*(2/n-1),s=r*r,t=Math.PI*this.R*(l*(p-s)+Math.sqrt(m*(p-s)*(p-s)-(s+m)*(q-s)))/(s+m);0>j&&(t=-t),b=this.x0+t;var u=m+p;return t=Math.PI*this.R*(r*u-l*Math.sqrt((s+m)*(m+1)-u*u))/(s+m),c=i>=0?this.y0+t:this.y0-t,a.x=b,a.y=c,a},c.inverse=function(a){var b,c,e,g,h,i,j,k,l,m,n,o,p;return a.x-=this.x0,a.y-=this.y0,n=Math.PI*this.R,e=a.x/n,g=a.y/n,h=e*e+g*g,i=-Math.abs(g)*(1+h),j=i-2*g*g+e*e,k=-2*i+1+2*g*g+h*h,p=g*g/k+(2*j*j*j/k/k/k-9*i*j/k/k)/27,l=(i-j*j/3/k)/k,m=2*Math.sqrt(-l/3),n=3*p/l/m,Math.abs(n)>1&&(n=n>=0?1:-1),o=Math.acos(n)/3,c=a.y>=0?(-m*Math.cos(o+Math.PI/3)-j/3/k)*Math.PI:-(-m*Math.cos(o+Math.PI/3)-j/3/k)*Math.PI,b=Math.abs(e)-1?(b[c]={name:a[0].toLowerCase(),convert:a[1]},3===a.length&&(b[c].auth=a[2])):"SPHEROID"===c?(b[c]={name:a[0],a:a[1],rf:a[2]},4===a.length&&(b[c].auth=a[3])):["GEOGCS","GEOCCS","DATUM","VERT_CS","COMPD_CS","LOCAL_CS","FITTED_CS","LOCAL_DATUM"].indexOf(c)>-1?(a[0]=["name",a[0]],d(b,c,a)):a.every(function(a){return Array.isArray(a)})?d(b,c,a):e(a,b[c])):b[c]=!0,void 0):void(b[a]=!0)}function f(a,b){var c=b[0],d=b[1];!(c in a)&&d in a&&(a[c]=a[d],3===b.length&&(a[c]=b[2](a[c])))}function g(a){return a*i}function h(a){function b(b){var c=a.to_meter||1;return parseFloat(b,10)*c}"GEOGCS"===a.type?a.projName="longlat":"LOCAL_CS"===a.type?(a.projName="identity",a.local=!0):"object"==typeof a.PROJECTION?a.projName=Object.keys(a.PROJECTION)[0]:a.projName=a.PROJECTION,a.UNIT&&(a.units=a.UNIT.name.toLowerCase(),"metre"===a.units&&(a.units="meter"),
+a.UNIT.convert&&("GEOGCS"===a.type?a.DATUM&&a.DATUM.SPHEROID&&(a.to_meter=parseFloat(a.UNIT.convert,10)*a.DATUM.SPHEROID.a):a.to_meter=parseFloat(a.UNIT.convert,10))),a.GEOGCS&&(a.GEOGCS.DATUM?a.datumCode=a.GEOGCS.DATUM.name.toLowerCase():a.datumCode=a.GEOGCS.name.toLowerCase(),"d_"===a.datumCode.slice(0,2)&&(a.datumCode=a.datumCode.slice(2)),("new_zealand_geodetic_datum_1949"===a.datumCode||"new_zealand_1949"===a.datumCode)&&(a.datumCode="nzgd49"),"wgs_1984"===a.datumCode&&("Mercator_Auxiliary_Sphere"===a.PROJECTION&&(a.sphere=!0),a.datumCode="wgs84"),"_ferro"===a.datumCode.slice(-6)&&(a.datumCode=a.datumCode.slice(0,-6)),"_jakarta"===a.datumCode.slice(-8)&&(a.datumCode=a.datumCode.slice(0,-8)),~a.datumCode.indexOf("belge")&&(a.datumCode="rnb72"),a.GEOGCS.DATUM&&a.GEOGCS.DATUM.SPHEROID&&(a.ellps=a.GEOGCS.DATUM.SPHEROID.name.replace("_19","").replace(/[Cc]larke\_18/,"clrk"),"international"===a.ellps.toLowerCase().slice(0,13)&&(a.ellps="intl"),a.a=a.GEOGCS.DATUM.SPHEROID.a,a.rf=parseFloat(a.GEOGCS.DATUM.SPHEROID.rf,10)),~a.datumCode.indexOf("osgb_1936")&&(a.datumCode="osgb36")),a.b&&!isFinite(a.b)&&(a.b=a.a);var c=function(b){return f(a,b)},d=[["standard_parallel_1","Standard_Parallel_1"],["standard_parallel_2","Standard_Parallel_2"],["false_easting","False_Easting"],["false_northing","False_Northing"],["central_meridian","Central_Meridian"],["latitude_of_origin","Latitude_Of_Origin"],["latitude_of_origin","Central_Parallel"],["scale_factor","Scale_Factor"],["k0","scale_factor"],["latitude_of_center","Latitude_of_center"],["lat0","latitude_of_center",g],["longitude_of_center","Longitude_Of_Center"],["longc","longitude_of_center",g],["x0","false_easting",b],["y0","false_northing",b],["long0","central_meridian",g],["lat0","latitude_of_origin",g],["lat0","standard_parallel_1",g],["lat1","standard_parallel_1",g],["lat2","standard_parallel_2",g],["alpha","azimuth",g],["srsCode","name"]];d.forEach(c),a.long0||!a.longc||"Albers_Conic_Equal_Area"!==a.projName&&"Lambert_Azimuthal_Equal_Area"!==a.projName||(a.long0=a.longc),a.lat_ts||!a.lat1||"Stereographic_South_Pole"!==a.projName&&"Polar Stereographic (variant B)"!==a.projName||(a.lat0=g(a.lat1>0?90:-90),a.lat_ts=a.lat1)}var i=.017453292519943295,j=a("./extend");b.exports=function(a,b){var c=JSON.parse((","+a).replace(/\s*\,\s*([A-Z_0-9]+?)(\[)/g,',["$1",').slice(1).replace(/\s*\,\s*([A-Z_0-9]+?)\]/g,',"$1"]').replace(/,\["VERTCS".+/,"")),d=c.shift(),f=c.shift();c.unshift(["name",f]),c.unshift(["type",d]),c.unshift("output");var g={};return e(c,g),h(g.output),j(b,g.output)}},{"./extend":34}],67:[function(a,b,c){function d(a){return a*(Math.PI/180)}function e(a){return 180*(a/Math.PI)}function f(a){var b,c,e,f,g,i,j,k,l,m=a.lat,n=a.lon,o=6378137,p=.00669438,q=.9996,r=d(m),s=d(n);l=Math.floor((n+180)/6)+1,180===n&&(l=60),m>=56&&64>m&&n>=3&&12>n&&(l=32),m>=72&&84>m&&(n>=0&&9>n?l=31:n>=9&&21>n?l=33:n>=21&&33>n?l=35:n>=33&&42>n&&(l=37)),b=6*(l-1)-180+3,k=d(b),c=p/(1-p),e=o/Math.sqrt(1-p*Math.sin(r)*Math.sin(r)),f=Math.tan(r)*Math.tan(r),g=c*Math.cos(r)*Math.cos(r),i=Math.cos(r)*(s-k),j=o*((1-p/4-3*p*p/64-5*p*p*p/256)*r-(3*p/8+3*p*p/32+45*p*p*p/1024)*Math.sin(2*r)+(15*p*p/256+45*p*p*p/1024)*Math.sin(4*r)-35*p*p*p/3072*Math.sin(6*r));var t=q*e*(i+(1-f+g)*i*i*i/6+(5-18*f+f*f+72*g-58*c)*i*i*i*i*i/120)+5e5,u=q*(j+e*Math.tan(r)*(i*i/2+(5-f+9*g+4*g*g)*i*i*i*i/24+(61-58*f+f*f+600*g-330*c)*i*i*i*i*i*i/720));return 0>m&&(u+=1e7),{northing:Math.round(u),easting:Math.round(t),zoneNumber:l,zoneLetter:h(m)}}function g(a){var b=a.northing,c=a.easting,d=a.zoneLetter,f=a.zoneNumber;if(0>f||f>60)return null;var h,i,j,k,l,m,n,o,p,q,r=.9996,s=6378137,t=.00669438,u=(1-Math.sqrt(1-t))/(1+Math.sqrt(1-t)),v=c-5e5,w=b;"N">d&&(w-=1e7),o=6*(f-1)-180+3,h=t/(1-t),n=w/r,p=n/(s*(1-t/4-3*t*t/64-5*t*t*t/256)),q=p+(3*u/2-27*u*u*u/32)*Math.sin(2*p)+(21*u*u/16-55*u*u*u*u/32)*Math.sin(4*p)+151*u*u*u/96*Math.sin(6*p),i=s/Math.sqrt(1-t*Math.sin(q)*Math.sin(q)),j=Math.tan(q)*Math.tan(q),k=h*Math.cos(q)*Math.cos(q),l=s*(1-t)/Math.pow(1-t*Math.sin(q)*Math.sin(q),1.5),m=v/(i*r);var x=q-i*Math.tan(q)/l*(m*m/2-(5+3*j+10*k-4*k*k-9*h)*m*m*m*m/24+(61+90*j+298*k+45*j*j-252*h-3*k*k)*m*m*m*m*m*m/720);x=e(x);var y=(m-(1+2*j+k)*m*m*m/6+(5-2*k+28*j-3*k*k+8*h+24*j*j)*m*m*m*m*m/120)/Math.cos(q);y=o+e(y);var z;if(a.accuracy){var A=g({northing:a.northing+a.accuracy,easting:a.easting+a.accuracy,zoneLetter:a.zoneLetter,zoneNumber:a.zoneNumber});z={top:A.lat,right:A.lon,bottom:x,left:y}}else z={lat:x,lon:y};return z}function h(a){var b="Z";return 84>=a&&a>=72?b="X":72>a&&a>=64?b="W":64>a&&a>=56?b="V":56>a&&a>=48?b="U":48>a&&a>=40?b="T":40>a&&a>=32?b="S":32>a&&a>=24?b="R":24>a&&a>=16?b="Q":16>a&&a>=8?b="P":8>a&&a>=0?b="N":0>a&&a>=-8?b="M":-8>a&&a>=-16?b="L":-16>a&&a>=-24?b="K":-24>a&&a>=-32?b="J":-32>a&&a>=-40?b="H":-40>a&&a>=-48?b="G":-48>a&&a>=-56?b="F":-56>a&&a>=-64?b="E":-64>a&&a>=-72?b="D":-72>a&&a>=-80&&(b="C"),b}function i(a,b){var c="00000"+a.easting,d="00000"+a.northing;return a.zoneNumber+a.zoneLetter+j(a.easting,a.northing,a.zoneNumber)+c.substr(c.length-5,b)+d.substr(d.length-5,b)}function j(a,b,c){var d=k(c),e=Math.floor(a/1e5),f=Math.floor(b/1e5)%20;return l(e,f,d)}function k(a){var b=a%q;return 0===b&&(b=q),b}function l(a,b,c){var d=c-1,e=r.charCodeAt(d),f=s.charCodeAt(d),g=e+a-1,h=f+b,i=!1;g>x&&(g=g-x+t-1,i=!0),(g===u||u>e&&g>u||(g>u||u>e)&&i)&&g++,(g===v||v>e&&g>v||(g>v||v>e)&&i)&&(g++,g===u&&g++),g>x&&(g=g-x+t-1),h>w?(h=h-w+t-1,i=!0):i=!1,(h===u||u>f&&h>u||(h>u||u>f)&&i)&&h++,(h===v||v>f&&h>v||(h>v||v>f)&&i)&&(h++,h===u&&h++),h>w&&(h=h-w+t-1);var j=String.fromCharCode(g)+String.fromCharCode(h);return j}function m(a){if(a&&0===a.length)throw"MGRSPoint coverting from nothing";for(var b,c=a.length,d=null,e="",f=0;!/[A-Z]/.test(b=a.charAt(f));){if(f>=2)throw"MGRSPoint bad conversion from: "+a;e+=b,f++}var g=parseInt(e,10);if(0===f||f+3>c)throw"MGRSPoint bad conversion from: "+a;var h=a.charAt(f++);if("A">=h||"B"===h||"Y"===h||h>="Z"||"I"===h||"O"===h)throw"MGRSPoint zone letter "+h+" not handled: "+a;d=a.substring(f,f+=2);for(var i=k(g),j=n(d.charAt(0),i),l=o(d.charAt(1),i);l0&&(q=1e5/Math.pow(10,v),r=a.substring(f,f+v),w=parseFloat(r)*q,s=a.substring(f+v),x=parseFloat(s)*q),t=w+j,u=x+l,{easting:t,northing:u,zoneLetter:h,zoneNumber:g,accuracy:q}}function n(a,b){for(var c=r.charCodeAt(b-1),d=1e5,e=!1;c!==a.charCodeAt(0);){if(c++,c===u&&c++,c===v&&c++,c>x){if(e)throw"Bad character: "+a;c=t,e=!0}d+=1e5}return d}function o(a,b){if(a>"V")throw"MGRSPoint given invalid Northing "+a;for(var c=s.charCodeAt(b-1),d=0,e=!1;c!==a.charCodeAt(0);){if(c++,c===u&&c++,c===v&&c++,c>w){if(e)throw"Bad character: "+a;c=t,e=!0}d+=1e5}return d}function p(a){var b;switch(a){case"C":b=11e5;break;case"D":b=2e6;break;case"E":b=28e5;break;case"F":b=37e5;break;case"G":b=46e5;break;case"H":b=55e5;break;case"J":b=64e5;break;case"K":b=73e5;break;case"L":b=82e5;break;case"M":b=91e5;break;case"N":b=0;break;case"P":b=8e5;break;case"Q":b=17e5;break;case"R":b=26e5;break;case"S":b=35e5;break;case"T":b=44e5;break;case"U":b=53e5;break;case"V":b=62e5;break;case"W":b=7e6;break;case"X":b=79e5;break;default:b=-1}if(b>=0)return b;throw"Invalid zone letter: "+a}var q=6,r="AJSAJS",s="AFAFAF",t=65,u=73,v=79,w=86,x=90;c.forward=function(a,b){return b=b||5,i(f({lat:a[1],lon:a[0]}),b)},c.inverse=function(a){var b=g(m(a.toUpperCase()));return b.lat&&b.lon?[b.lon,b.lat,b.lon,b.lat]:[b.left,b.bottom,b.right,b.top]},c.toPoint=function(a){var b=g(m(a.toUpperCase()));return b.lat&&b.lon?[b.lon,b.lat]:[(b.left+b.right)/2,(b.top+b.bottom)/2]}},{}],68:[function(a,b,c){b.exports={name:"proj4",version:"2.3.14",description:"Proj4js is a JavaScript library to transform point coordinates from one coordinate system to another, including datum transformations.",main:"lib/index.js",directories:{test:"test",doc:"docs"},scripts:{test:"./node_modules/istanbul/lib/cli.js test ./node_modules/mocha/bin/_mocha test/test.js"},repository:{type:"git",url:"git://github.com/proj4js/proj4js.git"},author:"",license:"MIT",jam:{main:"dist/proj4.js",include:["dist/proj4.js","README.md","AUTHORS","LICENSE.md"]},devDependencies:{"grunt-cli":"~0.1.13",grunt:"~0.4.2","grunt-contrib-connect":"~0.6.0","grunt-contrib-jshint":"~0.8.0",chai:"~1.8.1",mocha:"~1.17.1","grunt-mocha-phantomjs":"~0.4.0",browserify:"~12.0.1","grunt-browserify":"~4.0.1","grunt-contrib-uglify":"~0.11.1",curl:"git://github.com/cujojs/curl.git",istanbul:"~0.2.4",tin:"~0.4.0"},dependencies:{mgrs:"~0.0.2"}}},{}],"./includedProjections":[function(a,b,c){b.exports=a("hTEDpn")},{}],hTEDpn:[function(a,b,c){var d=[a("./lib/projections/tmerc"),a("./lib/projections/utm"),a("./lib/projections/sterea"),a("./lib/projections/stere"),a("./lib/projections/somerc"),a("./lib/projections/omerc"),a("./lib/projections/lcc"),a("./lib/projections/krovak"),a("./lib/projections/cass"),a("./lib/projections/laea"),a("./lib/projections/aea"),a("./lib/projections/gnom"),a("./lib/projections/cea"),a("./lib/projections/eqc"),a("./lib/projections/poly"),a("./lib/projections/nzmg"),a("./lib/projections/mill"),a("./lib/projections/sinu"),a("./lib/projections/moll"),a("./lib/projections/eqdc"),a("./lib/projections/vandg"),a("./lib/projections/aeqd")];b.exports=function(proj4){d.forEach(function(a){proj4.Proj.projections.add(a)})}},{"./lib/projections/aea":40,"./lib/projections/aeqd":41,"./lib/projections/cass":42,"./lib/projections/cea":43,"./lib/projections/eqc":44,"./lib/projections/eqdc":45,"./lib/projections/gnom":47,"./lib/projections/krovak":48,"./lib/projections/laea":49,"./lib/projections/lcc":50,"./lib/projections/mill":53,"./lib/projections/moll":54,"./lib/projections/nzmg":55,"./lib/projections/omerc":56,"./lib/projections/poly":57,"./lib/projections/sinu":58,"./lib/projections/somerc":59,"./lib/projections/stere":60,"./lib/projections/sterea":61,"./lib/projections/tmerc":62,"./lib/projections/utm":63,"./lib/projections/vandg":64}]},{},[36])(36)});
\ No newline at end of file
diff --git a/sandbox/lines-polygons/leaflet/Proj4Leaflet-1.0.1/lib/proj4.js b/sandbox/lines-polygons/leaflet/Proj4Leaflet-1.0.1/lib/proj4.js
new file mode 100644
index 0000000..0fdb880
--- /dev/null
+++ b/sandbox/lines-polygons/leaflet/Proj4Leaflet-1.0.1/lib/proj4.js
@@ -0,0 +1,5485 @@
+!function(e){if("object"==typeof exports)module.exports=e();else if("function"==typeof define&&define.amd)define(e);else{var f;"undefined"!=typeof window?f=window:"undefined"!=typeof global?f=global:"undefined"!=typeof self&&(f=self),f.proj4=e()}}(function(){var define,module,exports;return (function e(t,n,r){function s(o,u){if(!n[o]){if(!t[o]){var a=typeof require=="function"&&require;if(!u&&a)return a(o,!0);if(i)return i(o,!0);throw new Error("Cannot find module '"+o+"'")}var f=n[o]={exports:{}};t[o][0].call(f.exports,function(e){var n=t[o][1][e];return s(n?n:e)},f,f.exports,e,t,n,r)}return n[o].exports}var i=typeof require=="function"&&require;for(var o=0;o 1) {
+ x = (x > 1) ? 1 : -1;
+ }
+ return Math.asin(x);
+};
+},{}],7:[function(_dereq_,module,exports){
+module.exports = function(x) {
+ return (1 - 0.25 * x * (1 + x / 16 * (3 + 1.25 * x)));
+};
+},{}],8:[function(_dereq_,module,exports){
+module.exports = function(x) {
+ return (0.375 * x * (1 + 0.25 * x * (1 + 0.46875 * x)));
+};
+},{}],9:[function(_dereq_,module,exports){
+module.exports = function(x) {
+ return (0.05859375 * x * x * (1 + 0.75 * x));
+};
+},{}],10:[function(_dereq_,module,exports){
+module.exports = function(x) {
+ return (x * x * x * (35 / 3072));
+};
+},{}],11:[function(_dereq_,module,exports){
+module.exports = function(a, e, sinphi) {
+ var temp = e * sinphi;
+ return a / Math.sqrt(1 - temp * temp);
+};
+},{}],12:[function(_dereq_,module,exports){
+module.exports = function(ml, e0, e1, e2, e3) {
+ var phi;
+ var dphi;
+
+ phi = ml / e0;
+ for (var i = 0; i < 15; i++) {
+ dphi = (ml - (e0 * phi - e1 * Math.sin(2 * phi) + e2 * Math.sin(4 * phi) - e3 * Math.sin(6 * phi))) / (e0 - 2 * e1 * Math.cos(2 * phi) + 4 * e2 * Math.cos(4 * phi) - 6 * e3 * Math.cos(6 * phi));
+ phi += dphi;
+ if (Math.abs(dphi) <= 0.0000000001) {
+ return phi;
+ }
+ }
+
+ //..reportError("IMLFN-CONV:Latitude failed to converge after 15 iterations");
+ return NaN;
+};
+},{}],13:[function(_dereq_,module,exports){
+var HALF_PI = Math.PI/2;
+
+module.exports = function(eccent, q) {
+ var temp = 1 - (1 - eccent * eccent) / (2 * eccent) * Math.log((1 - eccent) / (1 + eccent));
+ if (Math.abs(Math.abs(q) - temp) < 1.0E-6) {
+ if (q < 0) {
+ return (-1 * HALF_PI);
+ }
+ else {
+ return HALF_PI;
+ }
+ }
+ //var phi = 0.5* q/(1-eccent*eccent);
+ var phi = Math.asin(0.5 * q);
+ var dphi;
+ var sin_phi;
+ var cos_phi;
+ var con;
+ for (var i = 0; i < 30; i++) {
+ sin_phi = Math.sin(phi);
+ cos_phi = Math.cos(phi);
+ con = eccent * sin_phi;
+ dphi = Math.pow(1 - con * con, 2) / (2 * cos_phi) * (q / (1 - eccent * eccent) - sin_phi / (1 - con * con) + 0.5 / eccent * Math.log((1 - con) / (1 + con)));
+ phi += dphi;
+ if (Math.abs(dphi) <= 0.0000000001) {
+ return phi;
+ }
+ }
+
+ //console.log("IQSFN-CONV:Latitude failed to converge after 30 iterations");
+ return NaN;
+};
+},{}],14:[function(_dereq_,module,exports){
+module.exports = function(e0, e1, e2, e3, phi) {
+ return (e0 * phi - e1 * Math.sin(2 * phi) + e2 * Math.sin(4 * phi) - e3 * Math.sin(6 * phi));
+};
+},{}],15:[function(_dereq_,module,exports){
+module.exports = function(eccent, sinphi, cosphi) {
+ var con = eccent * sinphi;
+ return cosphi / (Math.sqrt(1 - con * con));
+};
+},{}],16:[function(_dereq_,module,exports){
+var HALF_PI = Math.PI/2;
+module.exports = function(eccent, ts) {
+ var eccnth = 0.5 * eccent;
+ var con, dphi;
+ var phi = HALF_PI - 2 * Math.atan(ts);
+ for (var i = 0; i <= 15; i++) {
+ con = eccent * Math.sin(phi);
+ dphi = HALF_PI - 2 * Math.atan(ts * (Math.pow(((1 - con) / (1 + con)), eccnth))) - phi;
+ phi += dphi;
+ if (Math.abs(dphi) <= 0.0000000001) {
+ return phi;
+ }
+ }
+ //console.log("phi2z has NoConvergence");
+ return -9999;
+};
+},{}],17:[function(_dereq_,module,exports){
+var C00 = 1;
+var C02 = 0.25;
+var C04 = 0.046875;
+var C06 = 0.01953125;
+var C08 = 0.01068115234375;
+var C22 = 0.75;
+var C44 = 0.46875;
+var C46 = 0.01302083333333333333;
+var C48 = 0.00712076822916666666;
+var C66 = 0.36458333333333333333;
+var C68 = 0.00569661458333333333;
+var C88 = 0.3076171875;
+
+module.exports = function(es) {
+ var en = [];
+ en[0] = C00 - es * (C02 + es * (C04 + es * (C06 + es * C08)));
+ en[1] = es * (C22 - es * (C04 + es * (C06 + es * C08)));
+ var t = es * es;
+ en[2] = t * (C44 - es * (C46 + es * C48));
+ t *= es;
+ en[3] = t * (C66 - es * C68);
+ en[4] = t * es * C88;
+ return en;
+};
+},{}],18:[function(_dereq_,module,exports){
+var pj_mlfn = _dereq_("./pj_mlfn");
+var EPSLN = 1.0e-10;
+var MAX_ITER = 20;
+module.exports = function(arg, es, en) {
+ var k = 1 / (1 - es);
+ var phi = arg;
+ for (var i = MAX_ITER; i; --i) { /* rarely goes over 2 iterations */
+ var s = Math.sin(phi);
+ var t = 1 - es * s * s;
+ //t = this.pj_mlfn(phi, s, Math.cos(phi), en) - arg;
+ //phi -= t * (t * Math.sqrt(t)) * k;
+ t = (pj_mlfn(phi, s, Math.cos(phi), en) - arg) * (t * Math.sqrt(t)) * k;
+ phi -= t;
+ if (Math.abs(t) < EPSLN) {
+ return phi;
+ }
+ }
+ //..reportError("cass:pj_inv_mlfn: Convergence error");
+ return phi;
+};
+},{"./pj_mlfn":19}],19:[function(_dereq_,module,exports){
+module.exports = function(phi, sphi, cphi, en) {
+ cphi *= sphi;
+ sphi *= sphi;
+ return (en[0] * phi - cphi * (en[1] + sphi * (en[2] + sphi * (en[3] + sphi * en[4]))));
+};
+},{}],20:[function(_dereq_,module,exports){
+module.exports = function(eccent, sinphi) {
+ var con;
+ if (eccent > 1.0e-7) {
+ con = eccent * sinphi;
+ return ((1 - eccent * eccent) * (sinphi / (1 - con * con) - (0.5 / eccent) * Math.log((1 - con) / (1 + con))));
+ }
+ else {
+ return (2 * sinphi);
+ }
+};
+},{}],21:[function(_dereq_,module,exports){
+module.exports = function(x) {
+ return x<0 ? -1 : 1;
+};
+},{}],22:[function(_dereq_,module,exports){
+module.exports = function(esinp, exp) {
+ return (Math.pow((1 - esinp) / (1 + esinp), exp));
+};
+},{}],23:[function(_dereq_,module,exports){
+module.exports = function (array){
+ var out = {
+ x: array[0],
+ y: array[1]
+ };
+ if (array.length>2) {
+ out.z = array[2];
+ }
+ if (array.length>3) {
+ out.m = array[3];
+ }
+ return out;
+};
+},{}],24:[function(_dereq_,module,exports){
+var HALF_PI = Math.PI/2;
+
+module.exports = function(eccent, phi, sinphi) {
+ var con = eccent * sinphi;
+ var com = 0.5 * eccent;
+ con = Math.pow(((1 - con) / (1 + con)), com);
+ return (Math.tan(0.5 * (HALF_PI - phi)) / con);
+};
+},{}],25:[function(_dereq_,module,exports){
+exports.wgs84 = {
+ towgs84: "0,0,0",
+ ellipse: "WGS84",
+ datumName: "WGS84"
+};
+exports.ch1903 = {
+ towgs84: "674.374,15.056,405.346",
+ ellipse: "bessel",
+ datumName: "swiss"
+};
+exports.ggrs87 = {
+ towgs84: "-199.87,74.79,246.62",
+ ellipse: "GRS80",
+ datumName: "Greek_Geodetic_Reference_System_1987"
+};
+exports.nad83 = {
+ towgs84: "0,0,0",
+ ellipse: "GRS80",
+ datumName: "North_American_Datum_1983"
+};
+exports.nad27 = {
+ nadgrids: "@conus,@alaska,@ntv2_0.gsb,@ntv1_can.dat",
+ ellipse: "clrk66",
+ datumName: "North_American_Datum_1927"
+};
+exports.potsdam = {
+ towgs84: "606.0,23.0,413.0",
+ ellipse: "bessel",
+ datumName: "Potsdam Rauenberg 1950 DHDN"
+};
+exports.carthage = {
+ towgs84: "-263.0,6.0,431.0",
+ ellipse: "clark80",
+ datumName: "Carthage 1934 Tunisia"
+};
+exports.hermannskogel = {
+ towgs84: "653.0,-212.0,449.0",
+ ellipse: "bessel",
+ datumName: "Hermannskogel"
+};
+exports.ire65 = {
+ towgs84: "482.530,-130.596,564.557,-1.042,-0.214,-0.631,8.15",
+ ellipse: "mod_airy",
+ datumName: "Ireland 1965"
+};
+exports.rassadiran = {
+ towgs84: "-133.63,-157.5,-158.62",
+ ellipse: "intl",
+ datumName: "Rassadiran"
+};
+exports.nzgd49 = {
+ towgs84: "59.47,-5.04,187.44,0.47,-0.1,1.024,-4.5993",
+ ellipse: "intl",
+ datumName: "New Zealand Geodetic Datum 1949"
+};
+exports.osgb36 = {
+ towgs84: "446.448,-125.157,542.060,0.1502,0.2470,0.8421,-20.4894",
+ ellipse: "airy",
+ datumName: "Airy 1830"
+};
+exports.s_jtsk = {
+ towgs84: "589,76,480",
+ ellipse: 'bessel',
+ datumName: 'S-JTSK (Ferro)'
+};
+exports.beduaram = {
+ towgs84: '-106,-87,188',
+ ellipse: 'clrk80',
+ datumName: 'Beduaram'
+};
+exports.gunung_segara = {
+ towgs84: '-403,684,41',
+ ellipse: 'bessel',
+ datumName: 'Gunung Segara Jakarta'
+};
+exports.rnb72 = {
+ towgs84: "106.869,-52.2978,103.724,-0.33657,0.456955,-1.84218,1",
+ ellipse: "intl",
+ datumName: "Reseau National Belge 1972"
+};
+},{}],26:[function(_dereq_,module,exports){
+exports.MERIT = {
+ a: 6378137.0,
+ rf: 298.257,
+ ellipseName: "MERIT 1983"
+};
+exports.SGS85 = {
+ a: 6378136.0,
+ rf: 298.257,
+ ellipseName: "Soviet Geodetic System 85"
+};
+exports.GRS80 = {
+ a: 6378137.0,
+ rf: 298.257222101,
+ ellipseName: "GRS 1980(IUGG, 1980)"
+};
+exports.IAU76 = {
+ a: 6378140.0,
+ rf: 298.257,
+ ellipseName: "IAU 1976"
+};
+exports.airy = {
+ a: 6377563.396,
+ b: 6356256.910,
+ ellipseName: "Airy 1830"
+};
+exports.APL4 = {
+ a: 6378137,
+ rf: 298.25,
+ ellipseName: "Appl. Physics. 1965"
+};
+exports.NWL9D = {
+ a: 6378145.0,
+ rf: 298.25,
+ ellipseName: "Naval Weapons Lab., 1965"
+};
+exports.mod_airy = {
+ a: 6377340.189,
+ b: 6356034.446,
+ ellipseName: "Modified Airy"
+};
+exports.andrae = {
+ a: 6377104.43,
+ rf: 300.0,
+ ellipseName: "Andrae 1876 (Den., Iclnd.)"
+};
+exports.aust_SA = {
+ a: 6378160.0,
+ rf: 298.25,
+ ellipseName: "Australian Natl & S. Amer. 1969"
+};
+exports.GRS67 = {
+ a: 6378160.0,
+ rf: 298.2471674270,
+ ellipseName: "GRS 67(IUGG 1967)"
+};
+exports.bessel = {
+ a: 6377397.155,
+ rf: 299.1528128,
+ ellipseName: "Bessel 1841"
+};
+exports.bess_nam = {
+ a: 6377483.865,
+ rf: 299.1528128,
+ ellipseName: "Bessel 1841 (Namibia)"
+};
+exports.clrk66 = {
+ a: 6378206.4,
+ b: 6356583.8,
+ ellipseName: "Clarke 1866"
+};
+exports.clrk80 = {
+ a: 6378249.145,
+ rf: 293.4663,
+ ellipseName: "Clarke 1880 mod."
+};
+exports.clrk58 = {
+ a: 6378293.645208759,
+ rf: 294.2606763692654,
+ ellipseName: "Clarke 1858"
+};
+exports.CPM = {
+ a: 6375738.7,
+ rf: 334.29,
+ ellipseName: "Comm. des Poids et Mesures 1799"
+};
+exports.delmbr = {
+ a: 6376428.0,
+ rf: 311.5,
+ ellipseName: "Delambre 1810 (Belgium)"
+};
+exports.engelis = {
+ a: 6378136.05,
+ rf: 298.2566,
+ ellipseName: "Engelis 1985"
+};
+exports.evrst30 = {
+ a: 6377276.345,
+ rf: 300.8017,
+ ellipseName: "Everest 1830"
+};
+exports.evrst48 = {
+ a: 6377304.063,
+ rf: 300.8017,
+ ellipseName: "Everest 1948"
+};
+exports.evrst56 = {
+ a: 6377301.243,
+ rf: 300.8017,
+ ellipseName: "Everest 1956"
+};
+exports.evrst69 = {
+ a: 6377295.664,
+ rf: 300.8017,
+ ellipseName: "Everest 1969"
+};
+exports.evrstSS = {
+ a: 6377298.556,
+ rf: 300.8017,
+ ellipseName: "Everest (Sabah & Sarawak)"
+};
+exports.fschr60 = {
+ a: 6378166.0,
+ rf: 298.3,
+ ellipseName: "Fischer (Mercury Datum) 1960"
+};
+exports.fschr60m = {
+ a: 6378155.0,
+ rf: 298.3,
+ ellipseName: "Fischer 1960"
+};
+exports.fschr68 = {
+ a: 6378150.0,
+ rf: 298.3,
+ ellipseName: "Fischer 1968"
+};
+exports.helmert = {
+ a: 6378200.0,
+ rf: 298.3,
+ ellipseName: "Helmert 1906"
+};
+exports.hough = {
+ a: 6378270.0,
+ rf: 297.0,
+ ellipseName: "Hough"
+};
+exports.intl = {
+ a: 6378388.0,
+ rf: 297.0,
+ ellipseName: "International 1909 (Hayford)"
+};
+exports.kaula = {
+ a: 6378163.0,
+ rf: 298.24,
+ ellipseName: "Kaula 1961"
+};
+exports.lerch = {
+ a: 6378139.0,
+ rf: 298.257,
+ ellipseName: "Lerch 1979"
+};
+exports.mprts = {
+ a: 6397300.0,
+ rf: 191.0,
+ ellipseName: "Maupertius 1738"
+};
+exports.new_intl = {
+ a: 6378157.5,
+ b: 6356772.2,
+ ellipseName: "New International 1967"
+};
+exports.plessis = {
+ a: 6376523.0,
+ rf: 6355863.0,
+ ellipseName: "Plessis 1817 (France)"
+};
+exports.krass = {
+ a: 6378245.0,
+ rf: 298.3,
+ ellipseName: "Krassovsky, 1942"
+};
+exports.SEasia = {
+ a: 6378155.0,
+ b: 6356773.3205,
+ ellipseName: "Southeast Asia"
+};
+exports.walbeck = {
+ a: 6376896.0,
+ b: 6355834.8467,
+ ellipseName: "Walbeck"
+};
+exports.WGS60 = {
+ a: 6378165.0,
+ rf: 298.3,
+ ellipseName: "WGS 60"
+};
+exports.WGS66 = {
+ a: 6378145.0,
+ rf: 298.25,
+ ellipseName: "WGS 66"
+};
+exports.WGS7 = {
+ a: 6378135.0,
+ rf: 298.26,
+ ellipseName: "WGS 72"
+};
+exports.WGS84 = {
+ a: 6378137.0,
+ rf: 298.257223563,
+ ellipseName: "WGS 84"
+};
+exports.sphere = {
+ a: 6370997.0,
+ b: 6370997.0,
+ ellipseName: "Normal Sphere (r=6370997)"
+};
+},{}],27:[function(_dereq_,module,exports){
+exports.greenwich = 0.0; //"0dE",
+exports.lisbon = -9.131906111111; //"9d07'54.862\"W",
+exports.paris = 2.337229166667; //"2d20'14.025\"E",
+exports.bogota = -74.080916666667; //"74d04'51.3\"W",
+exports.madrid = -3.687938888889; //"3d41'16.58\"W",
+exports.rome = 12.452333333333; //"12d27'8.4\"E",
+exports.bern = 7.439583333333; //"7d26'22.5\"E",
+exports.jakarta = 106.807719444444; //"106d48'27.79\"E",
+exports.ferro = -17.666666666667; //"17d40'W",
+exports.brussels = 4.367975; //"4d22'4.71\"E",
+exports.stockholm = 18.058277777778; //"18d3'29.8\"E",
+exports.athens = 23.7163375; //"23d42'58.815\"E",
+exports.oslo = 10.722916666667; //"10d43'22.5\"E"
+},{}],28:[function(_dereq_,module,exports){
+exports.ft = {to_meter: 0.3048};
+exports['us-ft'] = {to_meter: 1200 / 3937};
+
+},{}],29:[function(_dereq_,module,exports){
+var proj = _dereq_('./Proj');
+var transform = _dereq_('./transform');
+var wgs84 = proj('WGS84');
+
+function transformer(from, to, coords) {
+ var transformedArray;
+ if (Array.isArray(coords)) {
+ transformedArray = transform(from, to, coords);
+ if (coords.length === 3) {
+ return [transformedArray.x, transformedArray.y, transformedArray.z];
+ }
+ else {
+ return [transformedArray.x, transformedArray.y];
+ }
+ }
+ else {
+ return transform(from, to, coords);
+ }
+}
+
+function checkProj(item) {
+ if (item instanceof proj) {
+ return item;
+ }
+ if (item.oProj) {
+ return item.oProj;
+ }
+ return proj(item);
+}
+function proj4(fromProj, toProj, coord) {
+ fromProj = checkProj(fromProj);
+ var single = false;
+ var obj;
+ if (typeof toProj === 'undefined') {
+ toProj = fromProj;
+ fromProj = wgs84;
+ single = true;
+ }
+ else if (typeof toProj.x !== 'undefined' || Array.isArray(toProj)) {
+ coord = toProj;
+ toProj = fromProj;
+ fromProj = wgs84;
+ single = true;
+ }
+ toProj = checkProj(toProj);
+ if (coord) {
+ return transformer(fromProj, toProj, coord);
+ }
+ else {
+ obj = {
+ forward: function(coords) {
+ return transformer(fromProj, toProj, coords);
+ },
+ inverse: function(coords) {
+ return transformer(toProj, fromProj, coords);
+ }
+ };
+ if (single) {
+ obj.oProj = toProj;
+ }
+ return obj;
+ }
+}
+module.exports = proj4;
+},{"./Proj":2,"./transform":65}],30:[function(_dereq_,module,exports){
+var HALF_PI = Math.PI/2;
+var PJD_3PARAM = 1;
+var PJD_7PARAM = 2;
+var PJD_GRIDSHIFT = 3;
+var PJD_WGS84 = 4; // WGS84 or equivalent
+var PJD_NODATUM = 5; // WGS84 or equivalent
+var SEC_TO_RAD = 4.84813681109535993589914102357e-6;
+var AD_C = 1.0026000;
+var COS_67P5 = 0.38268343236508977;
+var datum = function(proj) {
+ if (!(this instanceof datum)) {
+ return new datum(proj);
+ }
+ this.datum_type = PJD_WGS84; //default setting
+ if (!proj) {
+ return;
+ }
+ if (proj.datumCode && proj.datumCode === 'none') {
+ this.datum_type = PJD_NODATUM;
+ }
+
+ if (proj.datum_params) {
+ this.datum_params = proj.datum_params.map(parseFloat);
+ if (this.datum_params[0] !== 0 || this.datum_params[1] !== 0 || this.datum_params[2] !== 0) {
+ this.datum_type = PJD_3PARAM;
+ }
+ if (this.datum_params.length > 3) {
+ if (this.datum_params[3] !== 0 || this.datum_params[4] !== 0 || this.datum_params[5] !== 0 || this.datum_params[6] !== 0) {
+ this.datum_type = PJD_7PARAM;
+ this.datum_params[3] *= SEC_TO_RAD;
+ this.datum_params[4] *= SEC_TO_RAD;
+ this.datum_params[5] *= SEC_TO_RAD;
+ this.datum_params[6] = (this.datum_params[6] / 1000000.0) + 1.0;
+ }
+ }
+ }
+
+ // DGR 2011-03-21 : nadgrids support
+ this.datum_type = proj.grids ? PJD_GRIDSHIFT : this.datum_type;
+
+ this.a = proj.a; //datum object also uses these values
+ this.b = proj.b;
+ this.es = proj.es;
+ this.ep2 = proj.ep2;
+ if (this.datum_type === PJD_GRIDSHIFT) {
+ this.grids = proj.grids;
+ }
+};
+datum.prototype = {
+
+
+ /****************************************************************/
+ // cs_compare_datums()
+ // Returns TRUE if the two datums match, otherwise FALSE.
+ compare_datums: function(dest) {
+ if (this.datum_type !== dest.datum_type) {
+ return false; // false, datums are not equal
+ }
+ else if (this.a !== dest.a || Math.abs(this.es - dest.es) > 0.000000000050) {
+ // the tolerence for es is to ensure that GRS80 and WGS84
+ // are considered identical
+ return false;
+ }
+ else if (this.datum_type === PJD_3PARAM) {
+ return (this.datum_params[0] === dest.datum_params[0] && this.datum_params[1] === dest.datum_params[1] && this.datum_params[2] === dest.datum_params[2]);
+ }
+ else if (this.datum_type === PJD_7PARAM) {
+ return (this.datum_params[0] === dest.datum_params[0] && this.datum_params[1] === dest.datum_params[1] && this.datum_params[2] === dest.datum_params[2] && this.datum_params[3] === dest.datum_params[3] && this.datum_params[4] === dest.datum_params[4] && this.datum_params[5] === dest.datum_params[5] && this.datum_params[6] === dest.datum_params[6]);
+ }
+ else if (this.datum_type === PJD_GRIDSHIFT || dest.datum_type === PJD_GRIDSHIFT) {
+ //alert("ERROR: Grid shift transformations are not implemented.");
+ //return false
+ //DGR 2012-07-29 lazy ...
+ return this.nadgrids === dest.nadgrids;
+ }
+ else {
+ return true; // datums are equal
+ }
+ }, // cs_compare_datums()
+
+ /*
+ * The function Convert_Geodetic_To_Geocentric converts geodetic coordinates
+ * (latitude, longitude, and height) to geocentric coordinates (X, Y, Z),
+ * according to the current ellipsoid parameters.
+ *
+ * Latitude : Geodetic latitude in radians (input)
+ * Longitude : Geodetic longitude in radians (input)
+ * Height : Geodetic height, in meters (input)
+ * X : Calculated Geocentric X coordinate, in meters (output)
+ * Y : Calculated Geocentric Y coordinate, in meters (output)
+ * Z : Calculated Geocentric Z coordinate, in meters (output)
+ *
+ */
+ geodetic_to_geocentric: function(p) {
+ var Longitude = p.x;
+ var Latitude = p.y;
+ var Height = p.z ? p.z : 0; //Z value not always supplied
+ var X; // output
+ var Y;
+ var Z;
+
+ var Error_Code = 0; // GEOCENT_NO_ERROR;
+ var Rn; /* Earth radius at location */
+ var Sin_Lat; /* Math.sin(Latitude) */
+ var Sin2_Lat; /* Square of Math.sin(Latitude) */
+ var Cos_Lat; /* Math.cos(Latitude) */
+
+ /*
+ ** Don't blow up if Latitude is just a little out of the value
+ ** range as it may just be a rounding issue. Also removed longitude
+ ** test, it should be wrapped by Math.cos() and Math.sin(). NFW for PROJ.4, Sep/2001.
+ */
+ if (Latitude < -HALF_PI && Latitude > -1.001 * HALF_PI) {
+ Latitude = -HALF_PI;
+ }
+ else if (Latitude > HALF_PI && Latitude < 1.001 * HALF_PI) {
+ Latitude = HALF_PI;
+ }
+ else if ((Latitude < -HALF_PI) || (Latitude > HALF_PI)) {
+ /* Latitude out of range */
+ //..reportError('geocent:lat out of range:' + Latitude);
+ return null;
+ }
+
+ if (Longitude > Math.PI) {
+ Longitude -= (2 * Math.PI);
+ }
+ Sin_Lat = Math.sin(Latitude);
+ Cos_Lat = Math.cos(Latitude);
+ Sin2_Lat = Sin_Lat * Sin_Lat;
+ Rn = this.a / (Math.sqrt(1.0e0 - this.es * Sin2_Lat));
+ X = (Rn + Height) * Cos_Lat * Math.cos(Longitude);
+ Y = (Rn + Height) * Cos_Lat * Math.sin(Longitude);
+ Z = ((Rn * (1 - this.es)) + Height) * Sin_Lat;
+
+ p.x = X;
+ p.y = Y;
+ p.z = Z;
+ return Error_Code;
+ }, // cs_geodetic_to_geocentric()
+
+
+ geocentric_to_geodetic: function(p) {
+ /* local defintions and variables */
+ /* end-criterium of loop, accuracy of sin(Latitude) */
+ var genau = 1e-12;
+ var genau2 = (genau * genau);
+ var maxiter = 30;
+
+ var P; /* distance between semi-minor axis and location */
+ var RR; /* distance between center and location */
+ var CT; /* sin of geocentric latitude */
+ var ST; /* cos of geocentric latitude */
+ var RX;
+ var RK;
+ var RN; /* Earth radius at location */
+ var CPHI0; /* cos of start or old geodetic latitude in iterations */
+ var SPHI0; /* sin of start or old geodetic latitude in iterations */
+ var CPHI; /* cos of searched geodetic latitude */
+ var SPHI; /* sin of searched geodetic latitude */
+ var SDPHI; /* end-criterium: addition-theorem of sin(Latitude(iter)-Latitude(iter-1)) */
+ var At_Pole; /* indicates location is in polar region */
+ var iter; /* # of continous iteration, max. 30 is always enough (s.a.) */
+
+ var X = p.x;
+ var Y = p.y;
+ var Z = p.z ? p.z : 0.0; //Z value not always supplied
+ var Longitude;
+ var Latitude;
+ var Height;
+
+ At_Pole = false;
+ P = Math.sqrt(X * X + Y * Y);
+ RR = Math.sqrt(X * X + Y * Y + Z * Z);
+
+ /* special cases for latitude and longitude */
+ if (P / this.a < genau) {
+
+ /* special case, if P=0. (X=0., Y=0.) */
+ At_Pole = true;
+ Longitude = 0.0;
+
+ /* if (X,Y,Z)=(0.,0.,0.) then Height becomes semi-minor axis
+ * of ellipsoid (=center of mass), Latitude becomes PI/2 */
+ if (RR / this.a < genau) {
+ Latitude = HALF_PI;
+ Height = -this.b;
+ return;
+ }
+ }
+ else {
+ /* ellipsoidal (geodetic) longitude
+ * interval: -PI < Longitude <= +PI */
+ Longitude = Math.atan2(Y, X);
+ }
+
+ /* --------------------------------------------------------------
+ * Following iterative algorithm was developped by
+ * "Institut for Erdmessung", University of Hannover, July 1988.
+ * Internet: www.ife.uni-hannover.de
+ * Iterative computation of CPHI,SPHI and Height.
+ * Iteration of CPHI and SPHI to 10**-12 radian resp.
+ * 2*10**-7 arcsec.
+ * --------------------------------------------------------------
+ */
+ CT = Z / RR;
+ ST = P / RR;
+ RX = 1.0 / Math.sqrt(1.0 - this.es * (2.0 - this.es) * ST * ST);
+ CPHI0 = ST * (1.0 - this.es) * RX;
+ SPHI0 = CT * RX;
+ iter = 0;
+
+ /* loop to find sin(Latitude) resp. Latitude
+ * until |sin(Latitude(iter)-Latitude(iter-1))| < genau */
+ do {
+ iter++;
+ RN = this.a / Math.sqrt(1.0 - this.es * SPHI0 * SPHI0);
+
+ /* ellipsoidal (geodetic) height */
+ Height = P * CPHI0 + Z * SPHI0 - RN * (1.0 - this.es * SPHI0 * SPHI0);
+
+ RK = this.es * RN / (RN + Height);
+ RX = 1.0 / Math.sqrt(1.0 - RK * (2.0 - RK) * ST * ST);
+ CPHI = ST * (1.0 - RK) * RX;
+ SPHI = CT * RX;
+ SDPHI = SPHI * CPHI0 - CPHI * SPHI0;
+ CPHI0 = CPHI;
+ SPHI0 = SPHI;
+ }
+ while (SDPHI * SDPHI > genau2 && iter < maxiter);
+
+ /* ellipsoidal (geodetic) latitude */
+ Latitude = Math.atan(SPHI / Math.abs(CPHI));
+
+ p.x = Longitude;
+ p.y = Latitude;
+ p.z = Height;
+ return p;
+ }, // cs_geocentric_to_geodetic()
+
+ /** Convert_Geocentric_To_Geodetic
+ * The method used here is derived from 'An Improved Algorithm for
+ * Geocentric to Geodetic Coordinate Conversion', by Ralph Toms, Feb 1996
+ */
+ geocentric_to_geodetic_noniter: function(p) {
+ var X = p.x;
+ var Y = p.y;
+ var Z = p.z ? p.z : 0; //Z value not always supplied
+ var Longitude;
+ var Latitude;
+ var Height;
+
+ var W; /* distance from Z axis */
+ var W2; /* square of distance from Z axis */
+ var T0; /* initial estimate of vertical component */
+ var T1; /* corrected estimate of vertical component */
+ var S0; /* initial estimate of horizontal component */
+ var S1; /* corrected estimate of horizontal component */
+ var Sin_B0; /* Math.sin(B0), B0 is estimate of Bowring aux variable */
+ var Sin3_B0; /* cube of Math.sin(B0) */
+ var Cos_B0; /* Math.cos(B0) */
+ var Sin_p1; /* Math.sin(phi1), phi1 is estimated latitude */
+ var Cos_p1; /* Math.cos(phi1) */
+ var Rn; /* Earth radius at location */
+ var Sum; /* numerator of Math.cos(phi1) */
+ var At_Pole; /* indicates location is in polar region */
+
+ X = parseFloat(X); // cast from string to float
+ Y = parseFloat(Y);
+ Z = parseFloat(Z);
+
+ At_Pole = false;
+ if (X !== 0.0) {
+ Longitude = Math.atan2(Y, X);
+ }
+ else {
+ if (Y > 0) {
+ Longitude = HALF_PI;
+ }
+ else if (Y < 0) {
+ Longitude = -HALF_PI;
+ }
+ else {
+ At_Pole = true;
+ Longitude = 0.0;
+ if (Z > 0.0) { /* north pole */
+ Latitude = HALF_PI;
+ }
+ else if (Z < 0.0) { /* south pole */
+ Latitude = -HALF_PI;
+ }
+ else { /* center of earth */
+ Latitude = HALF_PI;
+ Height = -this.b;
+ return;
+ }
+ }
+ }
+ W2 = X * X + Y * Y;
+ W = Math.sqrt(W2);
+ T0 = Z * AD_C;
+ S0 = Math.sqrt(T0 * T0 + W2);
+ Sin_B0 = T0 / S0;
+ Cos_B0 = W / S0;
+ Sin3_B0 = Sin_B0 * Sin_B0 * Sin_B0;
+ T1 = Z + this.b * this.ep2 * Sin3_B0;
+ Sum = W - this.a * this.es * Cos_B0 * Cos_B0 * Cos_B0;
+ S1 = Math.sqrt(T1 * T1 + Sum * Sum);
+ Sin_p1 = T1 / S1;
+ Cos_p1 = Sum / S1;
+ Rn = this.a / Math.sqrt(1.0 - this.es * Sin_p1 * Sin_p1);
+ if (Cos_p1 >= COS_67P5) {
+ Height = W / Cos_p1 - Rn;
+ }
+ else if (Cos_p1 <= -COS_67P5) {
+ Height = W / -Cos_p1 - Rn;
+ }
+ else {
+ Height = Z / Sin_p1 + Rn * (this.es - 1.0);
+ }
+ if (At_Pole === false) {
+ Latitude = Math.atan(Sin_p1 / Cos_p1);
+ }
+
+ p.x = Longitude;
+ p.y = Latitude;
+ p.z = Height;
+ return p;
+ }, // geocentric_to_geodetic_noniter()
+
+ /****************************************************************/
+ // pj_geocentic_to_wgs84( p )
+ // p = point to transform in geocentric coordinates (x,y,z)
+ geocentric_to_wgs84: function(p) {
+
+ if (this.datum_type === PJD_3PARAM) {
+ // if( x[io] === HUGE_VAL )
+ // continue;
+ p.x += this.datum_params[0];
+ p.y += this.datum_params[1];
+ p.z += this.datum_params[2];
+
+ }
+ else if (this.datum_type === PJD_7PARAM) {
+ var Dx_BF = this.datum_params[0];
+ var Dy_BF = this.datum_params[1];
+ var Dz_BF = this.datum_params[2];
+ var Rx_BF = this.datum_params[3];
+ var Ry_BF = this.datum_params[4];
+ var Rz_BF = this.datum_params[5];
+ var M_BF = this.datum_params[6];
+ // if( x[io] === HUGE_VAL )
+ // continue;
+ var x_out = M_BF * (p.x - Rz_BF * p.y + Ry_BF * p.z) + Dx_BF;
+ var y_out = M_BF * (Rz_BF * p.x + p.y - Rx_BF * p.z) + Dy_BF;
+ var z_out = M_BF * (-Ry_BF * p.x + Rx_BF * p.y + p.z) + Dz_BF;
+ p.x = x_out;
+ p.y = y_out;
+ p.z = z_out;
+ }
+ }, // cs_geocentric_to_wgs84
+
+ /****************************************************************/
+ // pj_geocentic_from_wgs84()
+ // coordinate system definition,
+ // point to transform in geocentric coordinates (x,y,z)
+ geocentric_from_wgs84: function(p) {
+
+ if (this.datum_type === PJD_3PARAM) {
+ //if( x[io] === HUGE_VAL )
+ // continue;
+ p.x -= this.datum_params[0];
+ p.y -= this.datum_params[1];
+ p.z -= this.datum_params[2];
+
+ }
+ else if (this.datum_type === PJD_7PARAM) {
+ var Dx_BF = this.datum_params[0];
+ var Dy_BF = this.datum_params[1];
+ var Dz_BF = this.datum_params[2];
+ var Rx_BF = this.datum_params[3];
+ var Ry_BF = this.datum_params[4];
+ var Rz_BF = this.datum_params[5];
+ var M_BF = this.datum_params[6];
+ var x_tmp = (p.x - Dx_BF) / M_BF;
+ var y_tmp = (p.y - Dy_BF) / M_BF;
+ var z_tmp = (p.z - Dz_BF) / M_BF;
+ //if( x[io] === HUGE_VAL )
+ // continue;
+
+ p.x = x_tmp + Rz_BF * y_tmp - Ry_BF * z_tmp;
+ p.y = -Rz_BF * x_tmp + y_tmp + Rx_BF * z_tmp;
+ p.z = Ry_BF * x_tmp - Rx_BF * y_tmp + z_tmp;
+ } //cs_geocentric_from_wgs84()
+ }
+};
+
+/** point object, nothing fancy, just allows values to be
+ passed back and forth by reference rather than by value.
+ Other point classes may be used as long as they have
+ x and y properties, which will get modified in the transform method.
+*/
+module.exports = datum;
+
+},{}],31:[function(_dereq_,module,exports){
+var PJD_3PARAM = 1;
+var PJD_7PARAM = 2;
+var PJD_GRIDSHIFT = 3;
+var PJD_NODATUM = 5; // WGS84 or equivalent
+var SRS_WGS84_SEMIMAJOR = 6378137; // only used in grid shift transforms
+var SRS_WGS84_ESQUARED = 0.006694379990141316; //DGR: 2012-07-29
+module.exports = function(source, dest, point) {
+ var wp, i, l;
+
+ function checkParams(fallback) {
+ return (fallback === PJD_3PARAM || fallback === PJD_7PARAM);
+ }
+ // Short cut if the datums are identical.
+ if (source.compare_datums(dest)) {
+ return point; // in this case, zero is sucess,
+ // whereas cs_compare_datums returns 1 to indicate TRUE
+ // confusing, should fix this
+ }
+
+ // Explicitly skip datum transform by setting 'datum=none' as parameter for either source or dest
+ if (source.datum_type === PJD_NODATUM || dest.datum_type === PJD_NODATUM) {
+ return point;
+ }
+
+ //DGR: 2012-07-29 : add nadgrids support (begin)
+ var src_a = source.a;
+ var src_es = source.es;
+
+ var dst_a = dest.a;
+ var dst_es = dest.es;
+
+ var fallback = source.datum_type;
+ // If this datum requires grid shifts, then apply it to geodetic coordinates.
+ if (fallback === PJD_GRIDSHIFT) {
+ if (this.apply_gridshift(source, 0, point) === 0) {
+ source.a = SRS_WGS84_SEMIMAJOR;
+ source.es = SRS_WGS84_ESQUARED;
+ }
+ else {
+ // try 3 or 7 params transformation or nothing ?
+ if (!source.datum_params) {
+ source.a = src_a;
+ source.es = source.es;
+ return point;
+ }
+ wp = 1;
+ for (i = 0, l = source.datum_params.length; i < l; i++) {
+ wp *= source.datum_params[i];
+ }
+ if (wp === 0) {
+ source.a = src_a;
+ source.es = source.es;
+ return point;
+ }
+ if (source.datum_params.length > 3) {
+ fallback = PJD_7PARAM;
+ }
+ else {
+ fallback = PJD_3PARAM;
+ }
+ }
+ }
+ if (dest.datum_type === PJD_GRIDSHIFT) {
+ dest.a = SRS_WGS84_SEMIMAJOR;
+ dest.es = SRS_WGS84_ESQUARED;
+ }
+ // Do we need to go through geocentric coordinates?
+ if (source.es !== dest.es || source.a !== dest.a || checkParams(fallback) || checkParams(dest.datum_type)) {
+ //DGR: 2012-07-29 : add nadgrids support (end)
+ // Convert to geocentric coordinates.
+ source.geodetic_to_geocentric(point);
+ // CHECK_RETURN;
+ // Convert between datums
+ if (checkParams(source.datum_type)) {
+ source.geocentric_to_wgs84(point);
+ // CHECK_RETURN;
+ }
+ if (checkParams(dest.datum_type)) {
+ dest.geocentric_from_wgs84(point);
+ // CHECK_RETURN;
+ }
+ // Convert back to geodetic coordinates
+ dest.geocentric_to_geodetic(point);
+ // CHECK_RETURN;
+ }
+ // Apply grid shift to destination if required
+ if (dest.datum_type === PJD_GRIDSHIFT) {
+ this.apply_gridshift(dest, 1, point);
+ // CHECK_RETURN;
+ }
+
+ source.a = src_a;
+ source.es = src_es;
+ dest.a = dst_a;
+ dest.es = dst_es;
+
+ return point;
+};
+
+
+},{}],32:[function(_dereq_,module,exports){
+var globals = _dereq_('./global');
+var parseProj = _dereq_('./projString');
+var wkt = _dereq_('./wkt');
+
+function defs(name) {
+ /*global console*/
+ var that = this;
+ if (arguments.length === 2) {
+ var def = arguments[1];
+ if (typeof def === 'string') {
+ if (def.charAt(0) === '+') {
+ defs[name] = parseProj(arguments[1]);
+ }
+ else {
+ defs[name] = wkt(arguments[1]);
+ }
+ } else {
+ defs[name] = def;
+ }
+ }
+ else if (arguments.length === 1) {
+ if (Array.isArray(name)) {
+ return name.map(function(v) {
+ if (Array.isArray(v)) {
+ defs.apply(that, v);
+ }
+ else {
+ defs(v);
+ }
+ });
+ }
+ else if (typeof name === 'string') {
+ if (name in defs) {
+ return defs[name];
+ }
+ }
+ else if ('EPSG' in name) {
+ defs['EPSG:' + name.EPSG] = name;
+ }
+ else if ('ESRI' in name) {
+ defs['ESRI:' + name.ESRI] = name;
+ }
+ else if ('IAU2000' in name) {
+ defs['IAU2000:' + name.IAU2000] = name;
+ }
+ else {
+ console.log(name);
+ }
+ return;
+ }
+
+
+}
+globals(defs);
+module.exports = defs;
+
+},{"./global":35,"./projString":38,"./wkt":66}],33:[function(_dereq_,module,exports){
+var Datum = _dereq_('./constants/Datum');
+var Ellipsoid = _dereq_('./constants/Ellipsoid');
+var extend = _dereq_('./extend');
+var datum = _dereq_('./datum');
+var EPSLN = 1.0e-10;
+// ellipoid pj_set_ell.c
+var SIXTH = 0.1666666666666666667;
+/* 1/6 */
+var RA4 = 0.04722222222222222222;
+/* 17/360 */
+var RA6 = 0.02215608465608465608;
+module.exports = function(json) {
+ // DGR 2011-03-20 : nagrids -> nadgrids
+ if (json.datumCode && json.datumCode !== 'none') {
+ var datumDef = Datum[json.datumCode];
+ if (datumDef) {
+ json.datum_params = datumDef.towgs84 ? datumDef.towgs84.split(',') : null;
+ json.ellps = datumDef.ellipse;
+ json.datumName = datumDef.datumName ? datumDef.datumName : json.datumCode;
+ }
+ }
+ if (!json.a) { // do we have an ellipsoid?
+ var ellipse = Ellipsoid[json.ellps] ? Ellipsoid[json.ellps] : Ellipsoid.WGS84;
+ extend(json, ellipse);
+ }
+ if (json.rf && !json.b) {
+ json.b = (1.0 - 1.0 / json.rf) * json.a;
+ }
+ if (json.rf === 0 || Math.abs(json.a - json.b) < EPSLN) {
+ json.sphere = true;
+ json.b = json.a;
+ }
+ json.a2 = json.a * json.a; // used in geocentric
+ json.b2 = json.b * json.b; // used in geocentric
+ json.es = (json.a2 - json.b2) / json.a2; // e ^ 2
+ json.e = Math.sqrt(json.es); // eccentricity
+ if (json.R_A) {
+ json.a *= 1 - json.es * (SIXTH + json.es * (RA4 + json.es * RA6));
+ json.a2 = json.a * json.a;
+ json.b2 = json.b * json.b;
+ json.es = 0;
+ }
+ json.ep2 = (json.a2 - json.b2) / json.b2; // used in geocentric
+ if (!json.k0) {
+ json.k0 = 1.0; //default value
+ }
+ //DGR 2010-11-12: axis
+ if (!json.axis) {
+ json.axis = "enu";
+ }
+
+ if (!json.datum) {
+ json.datum = datum(json);
+ }
+ return json;
+};
+
+},{"./constants/Datum":25,"./constants/Ellipsoid":26,"./datum":30,"./extend":34}],34:[function(_dereq_,module,exports){
+module.exports = function(destination, source) {
+ destination = destination || {};
+ var value, property;
+ if (!source) {
+ return destination;
+ }
+ for (property in source) {
+ value = source[property];
+ if (value !== undefined) {
+ destination[property] = value;
+ }
+ }
+ return destination;
+};
+
+},{}],35:[function(_dereq_,module,exports){
+module.exports = function(defs) {
+ defs('EPSG:4326', "+title=WGS 84 (long/lat) +proj=longlat +ellps=WGS84 +datum=WGS84 +units=degrees");
+ defs('EPSG:4269', "+title=NAD83 (long/lat) +proj=longlat +a=6378137.0 +b=6356752.31414036 +ellps=GRS80 +datum=NAD83 +units=degrees");
+ defs('EPSG:3857', "+title=WGS 84 / Pseudo-Mercator +proj=merc +a=6378137 +b=6378137 +lat_ts=0.0 +lon_0=0.0 +x_0=0.0 +y_0=0 +k=1.0 +units=m +nadgrids=@null +no_defs");
+
+ defs.WGS84 = defs['EPSG:4326'];
+ defs['EPSG:3785'] = defs['EPSG:3857']; // maintain backward compat, official code is 3857
+ defs.GOOGLE = defs['EPSG:3857'];
+ defs['EPSG:900913'] = defs['EPSG:3857'];
+ defs['EPSG:102113'] = defs['EPSG:3857'];
+};
+
+},{}],36:[function(_dereq_,module,exports){
+var proj4 = _dereq_('./core');
+proj4.defaultDatum = 'WGS84'; //default datum
+proj4.Proj = _dereq_('./Proj');
+proj4.WGS84 = new proj4.Proj('WGS84');
+proj4.Point = _dereq_('./Point');
+proj4.toPoint = _dereq_("./common/toPoint");
+proj4.defs = _dereq_('./defs');
+proj4.transform = _dereq_('./transform');
+proj4.mgrs = _dereq_('mgrs');
+proj4.version = _dereq_('../package.json').version;
+_dereq_('./includedProjections')(proj4);
+module.exports = proj4;
+},{"../package.json":68,"./Point":1,"./Proj":2,"./common/toPoint":23,"./core":29,"./defs":32,"./includedProjections":"hTEDpn","./transform":65,"mgrs":67}],37:[function(_dereq_,module,exports){
+var defs = _dereq_('./defs');
+var wkt = _dereq_('./wkt');
+var projStr = _dereq_('./projString');
+function testObj(code){
+ return typeof code === 'string';
+}
+function testDef(code){
+ return code in defs;
+}
+function testWKT(code){
+ var codeWords = ['GEOGCS','GEOCCS','PROJCS','LOCAL_CS'];
+ return codeWords.reduce(function(a,b){
+ return a+1+code.indexOf(b);
+ },0);
+}
+function testProj(code){
+ return code[0] === '+';
+}
+function parse(code){
+ if (testObj(code)) {
+ //check to see if this is a WKT string
+ if (testDef(code)) {
+ return defs[code];
+ }
+ else if (testWKT(code)) {
+ return wkt(code);
+ }
+ else if (testProj(code)) {
+ return projStr(code);
+ }
+ }else{
+ return code;
+ }
+}
+
+module.exports = parse;
+},{"./defs":32,"./projString":38,"./wkt":66}],38:[function(_dereq_,module,exports){
+var D2R = 0.01745329251994329577;
+var PrimeMeridian = _dereq_('./constants/PrimeMeridian');
+var units = _dereq_('./constants/units');
+
+module.exports = function(defData) {
+ var self = {};
+ var paramObj = {};
+ defData.split("+").map(function(v) {
+ return v.trim();
+ }).filter(function(a) {
+ return a;
+ }).forEach(function(a) {
+ var split = a.split("=");
+ split.push(true);
+ paramObj[split[0].toLowerCase()] = split[1];
+ });
+ var paramName, paramVal, paramOutname;
+ var params = {
+ proj: 'projName',
+ datum: 'datumCode',
+ rf: function(v) {
+ self.rf = parseFloat(v);
+ },
+ lat_0: function(v) {
+ self.lat0 = v * D2R;
+ },
+ lat_1: function(v) {
+ self.lat1 = v * D2R;
+ },
+ lat_2: function(v) {
+ self.lat2 = v * D2R;
+ },
+ lat_ts: function(v) {
+ self.lat_ts = v * D2R;
+ },
+ lon_0: function(v) {
+ self.long0 = v * D2R;
+ },
+ lon_1: function(v) {
+ self.long1 = v * D2R;
+ },
+ lon_2: function(v) {
+ self.long2 = v * D2R;
+ },
+ alpha: function(v) {
+ self.alpha = parseFloat(v) * D2R;
+ },
+ lonc: function(v) {
+ self.longc = v * D2R;
+ },
+ x_0: function(v) {
+ self.x0 = parseFloat(v);
+ },
+ y_0: function(v) {
+ self.y0 = parseFloat(v);
+ },
+ k_0: function(v) {
+ self.k0 = parseFloat(v);
+ },
+ k: function(v) {
+ self.k0 = parseFloat(v);
+ },
+ a: function(v) {
+ self.a = parseFloat(v);
+ },
+ b: function(v) {
+ self.b = parseFloat(v);
+ },
+ r_a: function() {
+ self.R_A = true;
+ },
+ zone: function(v) {
+ self.zone = parseInt(v, 10);
+ },
+ south: function() {
+ self.utmSouth = true;
+ },
+ towgs84: function(v) {
+ self.datum_params = v.split(",").map(function(a) {
+ return parseFloat(a);
+ });
+ },
+ to_meter: function(v) {
+ self.to_meter = parseFloat(v);
+ },
+ units: function(v) {
+ self.units = v;
+ if (units[v]) {
+ self.to_meter = units[v].to_meter;
+ }
+ },
+ from_greenwich: function(v) {
+ self.from_greenwich = v * D2R;
+ },
+ pm: function(v) {
+ self.from_greenwich = (PrimeMeridian[v] ? PrimeMeridian[v] : parseFloat(v)) * D2R;
+ },
+ nadgrids: function(v) {
+ if (v === '@null') {
+ self.datumCode = 'none';
+ }
+ else {
+ self.nadgrids = v;
+ }
+ },
+ axis: function(v) {
+ var legalAxis = "ewnsud";
+ if (v.length === 3 && legalAxis.indexOf(v.substr(0, 1)) !== -1 && legalAxis.indexOf(v.substr(1, 1)) !== -1 && legalAxis.indexOf(v.substr(2, 1)) !== -1) {
+ self.axis = v;
+ }
+ }
+ };
+ for (paramName in paramObj) {
+ paramVal = paramObj[paramName];
+ if (paramName in params) {
+ paramOutname = params[paramName];
+ if (typeof paramOutname === 'function') {
+ paramOutname(paramVal);
+ }
+ else {
+ self[paramOutname] = paramVal;
+ }
+ }
+ else {
+ self[paramName] = paramVal;
+ }
+ }
+ if(typeof self.datumCode === 'string' && self.datumCode !== "WGS84"){
+ self.datumCode = self.datumCode.toLowerCase();
+ }
+ return self;
+};
+
+},{"./constants/PrimeMeridian":27,"./constants/units":28}],39:[function(_dereq_,module,exports){
+var projs = [
+ _dereq_('./projections/merc'),
+ _dereq_('./projections/longlat')
+];
+var names = {};
+var projStore = [];
+
+function add(proj, i) {
+ var len = projStore.length;
+ if (!proj.names) {
+ console.log(i);
+ return true;
+ }
+ projStore[len] = proj;
+ proj.names.forEach(function(n) {
+ names[n.toLowerCase()] = len;
+ });
+ return this;
+}
+
+exports.add = add;
+
+exports.get = function(name) {
+ if (!name) {
+ return false;
+ }
+ var n = name.toLowerCase();
+ if (typeof names[n] !== 'undefined' && projStore[names[n]]) {
+ return projStore[names[n]];
+ }
+};
+exports.start = function() {
+ projs.forEach(add);
+};
+
+},{"./projections/longlat":51,"./projections/merc":52}],40:[function(_dereq_,module,exports){
+var EPSLN = 1.0e-10;
+var msfnz = _dereq_('../common/msfnz');
+var qsfnz = _dereq_('../common/qsfnz');
+var adjust_lon = _dereq_('../common/adjust_lon');
+var asinz = _dereq_('../common/asinz');
+exports.init = function() {
+
+ if (Math.abs(this.lat1 + this.lat2) < EPSLN) {
+ return;
+ }
+ this.temp = this.b / this.a;
+ this.es = 1 - Math.pow(this.temp, 2);
+ this.e3 = Math.sqrt(this.es);
+
+ this.sin_po = Math.sin(this.lat1);
+ this.cos_po = Math.cos(this.lat1);
+ this.t1 = this.sin_po;
+ this.con = this.sin_po;
+ this.ms1 = msfnz(this.e3, this.sin_po, this.cos_po);
+ this.qs1 = qsfnz(this.e3, this.sin_po, this.cos_po);
+
+ this.sin_po = Math.sin(this.lat2);
+ this.cos_po = Math.cos(this.lat2);
+ this.t2 = this.sin_po;
+ this.ms2 = msfnz(this.e3, this.sin_po, this.cos_po);
+ this.qs2 = qsfnz(this.e3, this.sin_po, this.cos_po);
+
+ this.sin_po = Math.sin(this.lat0);
+ this.cos_po = Math.cos(this.lat0);
+ this.t3 = this.sin_po;
+ this.qs0 = qsfnz(this.e3, this.sin_po, this.cos_po);
+
+ if (Math.abs(this.lat1 - this.lat2) > EPSLN) {
+ this.ns0 = (this.ms1 * this.ms1 - this.ms2 * this.ms2) / (this.qs2 - this.qs1);
+ }
+ else {
+ this.ns0 = this.con;
+ }
+ this.c = this.ms1 * this.ms1 + this.ns0 * this.qs1;
+ this.rh = this.a * Math.sqrt(this.c - this.ns0 * this.qs0) / this.ns0;
+};
+
+/* Albers Conical Equal Area forward equations--mapping lat,long to x,y
+ -------------------------------------------------------------------*/
+exports.forward = function(p) {
+
+ var lon = p.x;
+ var lat = p.y;
+
+ this.sin_phi = Math.sin(lat);
+ this.cos_phi = Math.cos(lat);
+
+ var qs = qsfnz(this.e3, this.sin_phi, this.cos_phi);
+ var rh1 = this.a * Math.sqrt(this.c - this.ns0 * qs) / this.ns0;
+ var theta = this.ns0 * adjust_lon(lon - this.long0);
+ var x = rh1 * Math.sin(theta) + this.x0;
+ var y = this.rh - rh1 * Math.cos(theta) + this.y0;
+
+ p.x = x;
+ p.y = y;
+ return p;
+};
+
+
+exports.inverse = function(p) {
+ var rh1, qs, con, theta, lon, lat;
+
+ p.x -= this.x0;
+ p.y = this.rh - p.y + this.y0;
+ if (this.ns0 >= 0) {
+ rh1 = Math.sqrt(p.x * p.x + p.y * p.y);
+ con = 1;
+ }
+ else {
+ rh1 = -Math.sqrt(p.x * p.x + p.y * p.y);
+ con = -1;
+ }
+ theta = 0;
+ if (rh1 !== 0) {
+ theta = Math.atan2(con * p.x, con * p.y);
+ }
+ con = rh1 * this.ns0 / this.a;
+ if (this.sphere) {
+ lat = Math.asin((this.c - con * con) / (2 * this.ns0));
+ }
+ else {
+ qs = (this.c - con * con) / this.ns0;
+ lat = this.phi1z(this.e3, qs);
+ }
+
+ lon = adjust_lon(theta / this.ns0 + this.long0);
+ p.x = lon;
+ p.y = lat;
+ return p;
+};
+
+/* Function to compute phi1, the latitude for the inverse of the
+ Albers Conical Equal-Area projection.
+-------------------------------------------*/
+exports.phi1z = function(eccent, qs) {
+ var sinphi, cosphi, con, com, dphi;
+ var phi = asinz(0.5 * qs);
+ if (eccent < EPSLN) {
+ return phi;
+ }
+
+ var eccnts = eccent * eccent;
+ for (var i = 1; i <= 25; i++) {
+ sinphi = Math.sin(phi);
+ cosphi = Math.cos(phi);
+ con = eccent * sinphi;
+ com = 1 - con * con;
+ dphi = 0.5 * com * com / cosphi * (qs / (1 - eccnts) - sinphi / com + 0.5 / eccent * Math.log((1 - con) / (1 + con)));
+ phi = phi + dphi;
+ if (Math.abs(dphi) <= 1e-7) {
+ return phi;
+ }
+ }
+ return null;
+};
+exports.names = ["Albers_Conic_Equal_Area", "Albers", "aea"];
+
+},{"../common/adjust_lon":5,"../common/asinz":6,"../common/msfnz":15,"../common/qsfnz":20}],41:[function(_dereq_,module,exports){
+var adjust_lon = _dereq_('../common/adjust_lon');
+var HALF_PI = Math.PI/2;
+var EPSLN = 1.0e-10;
+var mlfn = _dereq_('../common/mlfn');
+var e0fn = _dereq_('../common/e0fn');
+var e1fn = _dereq_('../common/e1fn');
+var e2fn = _dereq_('../common/e2fn');
+var e3fn = _dereq_('../common/e3fn');
+var gN = _dereq_('../common/gN');
+var asinz = _dereq_('../common/asinz');
+var imlfn = _dereq_('../common/imlfn');
+exports.init = function() {
+ this.sin_p12 = Math.sin(this.lat0);
+ this.cos_p12 = Math.cos(this.lat0);
+};
+
+exports.forward = function(p) {
+ var lon = p.x;
+ var lat = p.y;
+ var sinphi = Math.sin(p.y);
+ var cosphi = Math.cos(p.y);
+ var dlon = adjust_lon(lon - this.long0);
+ var e0, e1, e2, e3, Mlp, Ml, tanphi, Nl1, Nl, psi, Az, G, H, GH, Hs, c, kp, cos_c, s, s2, s3, s4, s5;
+ if (this.sphere) {
+ if (Math.abs(this.sin_p12 - 1) <= EPSLN) {
+ //North Pole case
+ p.x = this.x0 + this.a * (HALF_PI - lat) * Math.sin(dlon);
+ p.y = this.y0 - this.a * (HALF_PI - lat) * Math.cos(dlon);
+ return p;
+ }
+ else if (Math.abs(this.sin_p12 + 1) <= EPSLN) {
+ //South Pole case
+ p.x = this.x0 + this.a * (HALF_PI + lat) * Math.sin(dlon);
+ p.y = this.y0 + this.a * (HALF_PI + lat) * Math.cos(dlon);
+ return p;
+ }
+ else {
+ //default case
+ cos_c = this.sin_p12 * sinphi + this.cos_p12 * cosphi * Math.cos(dlon);
+ c = Math.acos(cos_c);
+ kp = c / Math.sin(c);
+ p.x = this.x0 + this.a * kp * cosphi * Math.sin(dlon);
+ p.y = this.y0 + this.a * kp * (this.cos_p12 * sinphi - this.sin_p12 * cosphi * Math.cos(dlon));
+ return p;
+ }
+ }
+ else {
+ e0 = e0fn(this.es);
+ e1 = e1fn(this.es);
+ e2 = e2fn(this.es);
+ e3 = e3fn(this.es);
+ if (Math.abs(this.sin_p12 - 1) <= EPSLN) {
+ //North Pole case
+ Mlp = this.a * mlfn(e0, e1, e2, e3, HALF_PI);
+ Ml = this.a * mlfn(e0, e1, e2, e3, lat);
+ p.x = this.x0 + (Mlp - Ml) * Math.sin(dlon);
+ p.y = this.y0 - (Mlp - Ml) * Math.cos(dlon);
+ return p;
+ }
+ else if (Math.abs(this.sin_p12 + 1) <= EPSLN) {
+ //South Pole case
+ Mlp = this.a * mlfn(e0, e1, e2, e3, HALF_PI);
+ Ml = this.a * mlfn(e0, e1, e2, e3, lat);
+ p.x = this.x0 + (Mlp + Ml) * Math.sin(dlon);
+ p.y = this.y0 + (Mlp + Ml) * Math.cos(dlon);
+ return p;
+ }
+ else {
+ //Default case
+ tanphi = sinphi / cosphi;
+ Nl1 = gN(this.a, this.e, this.sin_p12);
+ Nl = gN(this.a, this.e, sinphi);
+ psi = Math.atan((1 - this.es) * tanphi + this.es * Nl1 * this.sin_p12 / (Nl * cosphi));
+ Az = Math.atan2(Math.sin(dlon), this.cos_p12 * Math.tan(psi) - this.sin_p12 * Math.cos(dlon));
+ if (Az === 0) {
+ s = Math.asin(this.cos_p12 * Math.sin(psi) - this.sin_p12 * Math.cos(psi));
+ }
+ else if (Math.abs(Math.abs(Az) - Math.PI) <= EPSLN) {
+ s = -Math.asin(this.cos_p12 * Math.sin(psi) - this.sin_p12 * Math.cos(psi));
+ }
+ else {
+ s = Math.asin(Math.sin(dlon) * Math.cos(psi) / Math.sin(Az));
+ }
+ G = this.e * this.sin_p12 / Math.sqrt(1 - this.es);
+ H = this.e * this.cos_p12 * Math.cos(Az) / Math.sqrt(1 - this.es);
+ GH = G * H;
+ Hs = H * H;
+ s2 = s * s;
+ s3 = s2 * s;
+ s4 = s3 * s;
+ s5 = s4 * s;
+ c = Nl1 * s * (1 - s2 * Hs * (1 - Hs) / 6 + s3 / 8 * GH * (1 - 2 * Hs) + s4 / 120 * (Hs * (4 - 7 * Hs) - 3 * G * G * (1 - 7 * Hs)) - s5 / 48 * GH);
+ p.x = this.x0 + c * Math.sin(Az);
+ p.y = this.y0 + c * Math.cos(Az);
+ return p;
+ }
+ }
+
+
+};
+
+exports.inverse = function(p) {
+ p.x -= this.x0;
+ p.y -= this.y0;
+ var rh, z, sinz, cosz, lon, lat, con, e0, e1, e2, e3, Mlp, M, N1, psi, Az, cosAz, tmp, A, B, D, Ee, F;
+ if (this.sphere) {
+ rh = Math.sqrt(p.x * p.x + p.y * p.y);
+ if (rh > (2 * HALF_PI * this.a)) {
+ return;
+ }
+ z = rh / this.a;
+
+ sinz = Math.sin(z);
+ cosz = Math.cos(z);
+
+ lon = this.long0;
+ if (Math.abs(rh) <= EPSLN) {
+ lat = this.lat0;
+ }
+ else {
+ lat = asinz(cosz * this.sin_p12 + (p.y * sinz * this.cos_p12) / rh);
+ con = Math.abs(this.lat0) - HALF_PI;
+ if (Math.abs(con) <= EPSLN) {
+ if (this.lat0 >= 0) {
+ lon = adjust_lon(this.long0 + Math.atan2(p.x, - p.y));
+ }
+ else {
+ lon = adjust_lon(this.long0 - Math.atan2(-p.x, p.y));
+ }
+ }
+ else {
+ /*con = cosz - this.sin_p12 * Math.sin(lat);
+ if ((Math.abs(con) < EPSLN) && (Math.abs(p.x) < EPSLN)) {
+ //no-op, just keep the lon value as is
+ } else {
+ var temp = Math.atan2((p.x * sinz * this.cos_p12), (con * rh));
+ lon = adjust_lon(this.long0 + Math.atan2((p.x * sinz * this.cos_p12), (con * rh)));
+ }*/
+ lon = adjust_lon(this.long0 + Math.atan2(p.x * sinz, rh * this.cos_p12 * cosz - p.y * this.sin_p12 * sinz));
+ }
+ }
+
+ p.x = lon;
+ p.y = lat;
+ return p;
+ }
+ else {
+ e0 = e0fn(this.es);
+ e1 = e1fn(this.es);
+ e2 = e2fn(this.es);
+ e3 = e3fn(this.es);
+ if (Math.abs(this.sin_p12 - 1) <= EPSLN) {
+ //North pole case
+ Mlp = this.a * mlfn(e0, e1, e2, e3, HALF_PI);
+ rh = Math.sqrt(p.x * p.x + p.y * p.y);
+ M = Mlp - rh;
+ lat = imlfn(M / this.a, e0, e1, e2, e3);
+ lon = adjust_lon(this.long0 + Math.atan2(p.x, - 1 * p.y));
+ p.x = lon;
+ p.y = lat;
+ return p;
+ }
+ else if (Math.abs(this.sin_p12 + 1) <= EPSLN) {
+ //South pole case
+ Mlp = this.a * mlfn(e0, e1, e2, e3, HALF_PI);
+ rh = Math.sqrt(p.x * p.x + p.y * p.y);
+ M = rh - Mlp;
+
+ lat = imlfn(M / this.a, e0, e1, e2, e3);
+ lon = adjust_lon(this.long0 + Math.atan2(p.x, p.y));
+ p.x = lon;
+ p.y = lat;
+ return p;
+ }
+ else {
+ //default case
+ rh = Math.sqrt(p.x * p.x + p.y * p.y);
+ Az = Math.atan2(p.x, p.y);
+ N1 = gN(this.a, this.e, this.sin_p12);
+ cosAz = Math.cos(Az);
+ tmp = this.e * this.cos_p12 * cosAz;
+ A = -tmp * tmp / (1 - this.es);
+ B = 3 * this.es * (1 - A) * this.sin_p12 * this.cos_p12 * cosAz / (1 - this.es);
+ D = rh / N1;
+ Ee = D - A * (1 + A) * Math.pow(D, 3) / 6 - B * (1 + 3 * A) * Math.pow(D, 4) / 24;
+ F = 1 - A * Ee * Ee / 2 - D * Ee * Ee * Ee / 6;
+ psi = Math.asin(this.sin_p12 * Math.cos(Ee) + this.cos_p12 * Math.sin(Ee) * cosAz);
+ lon = adjust_lon(this.long0 + Math.asin(Math.sin(Az) * Math.sin(Ee) / Math.cos(psi)));
+ lat = Math.atan((1 - this.es * F * this.sin_p12 / Math.sin(psi)) * Math.tan(psi) / (1 - this.es));
+ p.x = lon;
+ p.y = lat;
+ return p;
+ }
+ }
+
+};
+exports.names = ["Azimuthal_Equidistant", "aeqd"];
+
+},{"../common/adjust_lon":5,"../common/asinz":6,"../common/e0fn":7,"../common/e1fn":8,"../common/e2fn":9,"../common/e3fn":10,"../common/gN":11,"../common/imlfn":12,"../common/mlfn":14}],42:[function(_dereq_,module,exports){
+var mlfn = _dereq_('../common/mlfn');
+var e0fn = _dereq_('../common/e0fn');
+var e1fn = _dereq_('../common/e1fn');
+var e2fn = _dereq_('../common/e2fn');
+var e3fn = _dereq_('../common/e3fn');
+var gN = _dereq_('../common/gN');
+var adjust_lon = _dereq_('../common/adjust_lon');
+var adjust_lat = _dereq_('../common/adjust_lat');
+var imlfn = _dereq_('../common/imlfn');
+var HALF_PI = Math.PI/2;
+var EPSLN = 1.0e-10;
+exports.init = function() {
+ if (!this.sphere) {
+ this.e0 = e0fn(this.es);
+ this.e1 = e1fn(this.es);
+ this.e2 = e2fn(this.es);
+ this.e3 = e3fn(this.es);
+ this.ml0 = this.a * mlfn(this.e0, this.e1, this.e2, this.e3, this.lat0);
+ }
+};
+
+
+
+/* Cassini forward equations--mapping lat,long to x,y
+ -----------------------------------------------------------------------*/
+exports.forward = function(p) {
+
+ /* Forward equations
+ -----------------*/
+ var x, y;
+ var lam = p.x;
+ var phi = p.y;
+ lam = adjust_lon(lam - this.long0);
+
+ if (this.sphere) {
+ x = this.a * Math.asin(Math.cos(phi) * Math.sin(lam));
+ y = this.a * (Math.atan2(Math.tan(phi), Math.cos(lam)) - this.lat0);
+ }
+ else {
+ //ellipsoid
+ var sinphi = Math.sin(phi);
+ var cosphi = Math.cos(phi);
+ var nl = gN(this.a, this.e, sinphi);
+ var tl = Math.tan(phi) * Math.tan(phi);
+ var al = lam * Math.cos(phi);
+ var asq = al * al;
+ var cl = this.es * cosphi * cosphi / (1 - this.es);
+ var ml = this.a * mlfn(this.e0, this.e1, this.e2, this.e3, phi);
+
+ x = nl * al * (1 - asq * tl * (1 / 6 - (8 - tl + 8 * cl) * asq / 120));
+ y = ml - this.ml0 + nl * sinphi / cosphi * asq * (0.5 + (5 - tl + 6 * cl) * asq / 24);
+
+
+ }
+
+ p.x = x + this.x0;
+ p.y = y + this.y0;
+ return p;
+};
+
+/* Inverse equations
+ -----------------*/
+exports.inverse = function(p) {
+ p.x -= this.x0;
+ p.y -= this.y0;
+ var x = p.x / this.a;
+ var y = p.y / this.a;
+ var phi, lam;
+
+ if (this.sphere) {
+ var dd = y + this.lat0;
+ phi = Math.asin(Math.sin(dd) * Math.cos(x));
+ lam = Math.atan2(Math.tan(x), Math.cos(dd));
+ }
+ else {
+ /* ellipsoid */
+ var ml1 = this.ml0 / this.a + y;
+ var phi1 = imlfn(ml1, this.e0, this.e1, this.e2, this.e3);
+ if (Math.abs(Math.abs(phi1) - HALF_PI) <= EPSLN) {
+ p.x = this.long0;
+ p.y = HALF_PI;
+ if (y < 0) {
+ p.y *= -1;
+ }
+ return p;
+ }
+ var nl1 = gN(this.a, this.e, Math.sin(phi1));
+
+ var rl1 = nl1 * nl1 * nl1 / this.a / this.a * (1 - this.es);
+ var tl1 = Math.pow(Math.tan(phi1), 2);
+ var dl = x * this.a / nl1;
+ var dsq = dl * dl;
+ phi = phi1 - nl1 * Math.tan(phi1) / rl1 * dl * dl * (0.5 - (1 + 3 * tl1) * dl * dl / 24);
+ lam = dl * (1 - dsq * (tl1 / 3 + (1 + 3 * tl1) * tl1 * dsq / 15)) / Math.cos(phi1);
+
+ }
+
+ p.x = adjust_lon(lam + this.long0);
+ p.y = adjust_lat(phi);
+ return p;
+
+};
+exports.names = ["Cassini", "Cassini_Soldner", "cass"];
+},{"../common/adjust_lat":4,"../common/adjust_lon":5,"../common/e0fn":7,"../common/e1fn":8,"../common/e2fn":9,"../common/e3fn":10,"../common/gN":11,"../common/imlfn":12,"../common/mlfn":14}],43:[function(_dereq_,module,exports){
+var adjust_lon = _dereq_('../common/adjust_lon');
+var qsfnz = _dereq_('../common/qsfnz');
+var msfnz = _dereq_('../common/msfnz');
+var iqsfnz = _dereq_('../common/iqsfnz');
+/*
+ reference:
+ "Cartographic Projection Procedures for the UNIX Environment-
+ A User's Manual" by Gerald I. Evenden,
+ USGS Open File Report 90-284and Release 4 Interim Reports (2003)
+*/
+exports.init = function() {
+ //no-op
+ if (!this.sphere) {
+ this.k0 = msfnz(this.e, Math.sin(this.lat_ts), Math.cos(this.lat_ts));
+ }
+};
+
+
+/* Cylindrical Equal Area forward equations--mapping lat,long to x,y
+ ------------------------------------------------------------*/
+exports.forward = function(p) {
+ var lon = p.x;
+ var lat = p.y;
+ var x, y;
+ /* Forward equations
+ -----------------*/
+ var dlon = adjust_lon(lon - this.long0);
+ if (this.sphere) {
+ x = this.x0 + this.a * dlon * Math.cos(this.lat_ts);
+ y = this.y0 + this.a * Math.sin(lat) / Math.cos(this.lat_ts);
+ }
+ else {
+ var qs = qsfnz(this.e, Math.sin(lat));
+ x = this.x0 + this.a * this.k0 * dlon;
+ y = this.y0 + this.a * qs * 0.5 / this.k0;
+ }
+
+ p.x = x;
+ p.y = y;
+ return p;
+};
+
+/* Cylindrical Equal Area inverse equations--mapping x,y to lat/long
+ ------------------------------------------------------------*/
+exports.inverse = function(p) {
+ p.x -= this.x0;
+ p.y -= this.y0;
+ var lon, lat;
+
+ if (this.sphere) {
+ lon = adjust_lon(this.long0 + (p.x / this.a) / Math.cos(this.lat_ts));
+ lat = Math.asin((p.y / this.a) * Math.cos(this.lat_ts));
+ }
+ else {
+ lat = iqsfnz(this.e, 2 * p.y * this.k0 / this.a);
+ lon = adjust_lon(this.long0 + p.x / (this.a * this.k0));
+ }
+
+ p.x = lon;
+ p.y = lat;
+ return p;
+};
+exports.names = ["cea"];
+
+},{"../common/adjust_lon":5,"../common/iqsfnz":13,"../common/msfnz":15,"../common/qsfnz":20}],44:[function(_dereq_,module,exports){
+var adjust_lon = _dereq_('../common/adjust_lon');
+var adjust_lat = _dereq_('../common/adjust_lat');
+exports.init = function() {
+
+ this.x0 = this.x0 || 0;
+ this.y0 = this.y0 || 0;
+ this.lat0 = this.lat0 || 0;
+ this.long0 = this.long0 || 0;
+ this.lat_ts = this.lat_ts || 0;
+ this.title = this.title || "Equidistant Cylindrical (Plate Carre)";
+
+ this.rc = Math.cos(this.lat_ts);
+};
+
+
+// forward equations--mapping lat,long to x,y
+// -----------------------------------------------------------------
+exports.forward = function(p) {
+
+ var lon = p.x;
+ var lat = p.y;
+
+ var dlon = adjust_lon(lon - this.long0);
+ var dlat = adjust_lat(lat - this.lat0);
+ p.x = this.x0 + (this.a * dlon * this.rc);
+ p.y = this.y0 + (this.a * dlat);
+ return p;
+};
+
+// inverse equations--mapping x,y to lat/long
+// -----------------------------------------------------------------
+exports.inverse = function(p) {
+
+ var x = p.x;
+ var y = p.y;
+
+ p.x = adjust_lon(this.long0 + ((x - this.x0) / (this.a * this.rc)));
+ p.y = adjust_lat(this.lat0 + ((y - this.y0) / (this.a)));
+ return p;
+};
+exports.names = ["Equirectangular", "Equidistant_Cylindrical", "eqc"];
+
+},{"../common/adjust_lat":4,"../common/adjust_lon":5}],45:[function(_dereq_,module,exports){
+var e0fn = _dereq_('../common/e0fn');
+var e1fn = _dereq_('../common/e1fn');
+var e2fn = _dereq_('../common/e2fn');
+var e3fn = _dereq_('../common/e3fn');
+var msfnz = _dereq_('../common/msfnz');
+var mlfn = _dereq_('../common/mlfn');
+var adjust_lon = _dereq_('../common/adjust_lon');
+var adjust_lat = _dereq_('../common/adjust_lat');
+var imlfn = _dereq_('../common/imlfn');
+var EPSLN = 1.0e-10;
+exports.init = function() {
+
+ /* Place parameters in static storage for common use
+ -------------------------------------------------*/
+ // Standard Parallels cannot be equal and on opposite sides of the equator
+ if (Math.abs(this.lat1 + this.lat2) < EPSLN) {
+ return;
+ }
+ this.lat2 = this.lat2 || this.lat1;
+ this.temp = this.b / this.a;
+ this.es = 1 - Math.pow(this.temp, 2);
+ this.e = Math.sqrt(this.es);
+ this.e0 = e0fn(this.es);
+ this.e1 = e1fn(this.es);
+ this.e2 = e2fn(this.es);
+ this.e3 = e3fn(this.es);
+
+ this.sinphi = Math.sin(this.lat1);
+ this.cosphi = Math.cos(this.lat1);
+
+ this.ms1 = msfnz(this.e, this.sinphi, this.cosphi);
+ this.ml1 = mlfn(this.e0, this.e1, this.e2, this.e3, this.lat1);
+
+ if (Math.abs(this.lat1 - this.lat2) < EPSLN) {
+ this.ns = this.sinphi;
+ }
+ else {
+ this.sinphi = Math.sin(this.lat2);
+ this.cosphi = Math.cos(this.lat2);
+ this.ms2 = msfnz(this.e, this.sinphi, this.cosphi);
+ this.ml2 = mlfn(this.e0, this.e1, this.e2, this.e3, this.lat2);
+ this.ns = (this.ms1 - this.ms2) / (this.ml2 - this.ml1);
+ }
+ this.g = this.ml1 + this.ms1 / this.ns;
+ this.ml0 = mlfn(this.e0, this.e1, this.e2, this.e3, this.lat0);
+ this.rh = this.a * (this.g - this.ml0);
+};
+
+
+/* Equidistant Conic forward equations--mapping lat,long to x,y
+ -----------------------------------------------------------*/
+exports.forward = function(p) {
+ var lon = p.x;
+ var lat = p.y;
+ var rh1;
+
+ /* Forward equations
+ -----------------*/
+ if (this.sphere) {
+ rh1 = this.a * (this.g - lat);
+ }
+ else {
+ var ml = mlfn(this.e0, this.e1, this.e2, this.e3, lat);
+ rh1 = this.a * (this.g - ml);
+ }
+ var theta = this.ns * adjust_lon(lon - this.long0);
+ var x = this.x0 + rh1 * Math.sin(theta);
+ var y = this.y0 + this.rh - rh1 * Math.cos(theta);
+ p.x = x;
+ p.y = y;
+ return p;
+};
+
+/* Inverse equations
+ -----------------*/
+exports.inverse = function(p) {
+ p.x -= this.x0;
+ p.y = this.rh - p.y + this.y0;
+ var con, rh1, lat, lon;
+ if (this.ns >= 0) {
+ rh1 = Math.sqrt(p.x * p.x + p.y * p.y);
+ con = 1;
+ }
+ else {
+ rh1 = -Math.sqrt(p.x * p.x + p.y * p.y);
+ con = -1;
+ }
+ var theta = 0;
+ if (rh1 !== 0) {
+ theta = Math.atan2(con * p.x, con * p.y);
+ }
+
+ if (this.sphere) {
+ lon = adjust_lon(this.long0 + theta / this.ns);
+ lat = adjust_lat(this.g - rh1 / this.a);
+ p.x = lon;
+ p.y = lat;
+ return p;
+ }
+ else {
+ var ml = this.g - rh1 / this.a;
+ lat = imlfn(ml, this.e0, this.e1, this.e2, this.e3);
+ lon = adjust_lon(this.long0 + theta / this.ns);
+ p.x = lon;
+ p.y = lat;
+ return p;
+ }
+
+};
+exports.names = ["Equidistant_Conic", "eqdc"];
+
+},{"../common/adjust_lat":4,"../common/adjust_lon":5,"../common/e0fn":7,"../common/e1fn":8,"../common/e2fn":9,"../common/e3fn":10,"../common/imlfn":12,"../common/mlfn":14,"../common/msfnz":15}],46:[function(_dereq_,module,exports){
+var FORTPI = Math.PI/4;
+var srat = _dereq_('../common/srat');
+var HALF_PI = Math.PI/2;
+var MAX_ITER = 20;
+exports.init = function() {
+ var sphi = Math.sin(this.lat0);
+ var cphi = Math.cos(this.lat0);
+ cphi *= cphi;
+ this.rc = Math.sqrt(1 - this.es) / (1 - this.es * sphi * sphi);
+ this.C = Math.sqrt(1 + this.es * cphi * cphi / (1 - this.es));
+ this.phic0 = Math.asin(sphi / this.C);
+ this.ratexp = 0.5 * this.C * this.e;
+ this.K = Math.tan(0.5 * this.phic0 + FORTPI) / (Math.pow(Math.tan(0.5 * this.lat0 + FORTPI), this.C) * srat(this.e * sphi, this.ratexp));
+};
+
+exports.forward = function(p) {
+ var lon = p.x;
+ var lat = p.y;
+
+ p.y = 2 * Math.atan(this.K * Math.pow(Math.tan(0.5 * lat + FORTPI), this.C) * srat(this.e * Math.sin(lat), this.ratexp)) - HALF_PI;
+ p.x = this.C * lon;
+ return p;
+};
+
+exports.inverse = function(p) {
+ var DEL_TOL = 1e-14;
+ var lon = p.x / this.C;
+ var lat = p.y;
+ var num = Math.pow(Math.tan(0.5 * lat + FORTPI) / this.K, 1 / this.C);
+ for (var i = MAX_ITER; i > 0; --i) {
+ lat = 2 * Math.atan(num * srat(this.e * Math.sin(p.y), - 0.5 * this.e)) - HALF_PI;
+ if (Math.abs(lat - p.y) < DEL_TOL) {
+ break;
+ }
+ p.y = lat;
+ }
+ /* convergence failed */
+ if (!i) {
+ return null;
+ }
+ p.x = lon;
+ p.y = lat;
+ return p;
+};
+exports.names = ["gauss"];
+
+},{"../common/srat":22}],47:[function(_dereq_,module,exports){
+var adjust_lon = _dereq_('../common/adjust_lon');
+var EPSLN = 1.0e-10;
+var asinz = _dereq_('../common/asinz');
+
+/*
+ reference:
+ Wolfram Mathworld "Gnomonic Projection"
+ http://mathworld.wolfram.com/GnomonicProjection.html
+ Accessed: 12th November 2009
+ */
+exports.init = function() {
+
+ /* Place parameters in static storage for common use
+ -------------------------------------------------*/
+ this.sin_p14 = Math.sin(this.lat0);
+ this.cos_p14 = Math.cos(this.lat0);
+ // Approximation for projecting points to the horizon (infinity)
+ this.infinity_dist = 1000 * this.a;
+ this.rc = 1;
+};
+
+
+/* Gnomonic forward equations--mapping lat,long to x,y
+ ---------------------------------------------------*/
+exports.forward = function(p) {
+ var sinphi, cosphi; /* sin and cos value */
+ var dlon; /* delta longitude value */
+ var coslon; /* cos of longitude */
+ var ksp; /* scale factor */
+ var g;
+ var x, y;
+ var lon = p.x;
+ var lat = p.y;
+ /* Forward equations
+ -----------------*/
+ dlon = adjust_lon(lon - this.long0);
+
+ sinphi = Math.sin(lat);
+ cosphi = Math.cos(lat);
+
+ coslon = Math.cos(dlon);
+ g = this.sin_p14 * sinphi + this.cos_p14 * cosphi * coslon;
+ ksp = 1;
+ if ((g > 0) || (Math.abs(g) <= EPSLN)) {
+ x = this.x0 + this.a * ksp * cosphi * Math.sin(dlon) / g;
+ y = this.y0 + this.a * ksp * (this.cos_p14 * sinphi - this.sin_p14 * cosphi * coslon) / g;
+ }
+ else {
+
+ // Point is in the opposing hemisphere and is unprojectable
+ // We still need to return a reasonable point, so we project
+ // to infinity, on a bearing
+ // equivalent to the northern hemisphere equivalent
+ // This is a reasonable approximation for short shapes and lines that
+ // straddle the horizon.
+
+ x = this.x0 + this.infinity_dist * cosphi * Math.sin(dlon);
+ y = this.y0 + this.infinity_dist * (this.cos_p14 * sinphi - this.sin_p14 * cosphi * coslon);
+
+ }
+ p.x = x;
+ p.y = y;
+ return p;
+};
+
+
+exports.inverse = function(p) {
+ var rh; /* Rho */
+ var sinc, cosc;
+ var c;
+ var lon, lat;
+
+ /* Inverse equations
+ -----------------*/
+ p.x = (p.x - this.x0) / this.a;
+ p.y = (p.y - this.y0) / this.a;
+
+ p.x /= this.k0;
+ p.y /= this.k0;
+
+ if ((rh = Math.sqrt(p.x * p.x + p.y * p.y))) {
+ c = Math.atan2(rh, this.rc);
+ sinc = Math.sin(c);
+ cosc = Math.cos(c);
+
+ lat = asinz(cosc * this.sin_p14 + (p.y * sinc * this.cos_p14) / rh);
+ lon = Math.atan2(p.x * sinc, rh * this.cos_p14 * cosc - p.y * this.sin_p14 * sinc);
+ lon = adjust_lon(this.long0 + lon);
+ }
+ else {
+ lat = this.phic0;
+ lon = 0;
+ }
+
+ p.x = lon;
+ p.y = lat;
+ return p;
+};
+exports.names = ["gnom"];
+
+},{"../common/adjust_lon":5,"../common/asinz":6}],48:[function(_dereq_,module,exports){
+var adjust_lon = _dereq_('../common/adjust_lon');
+exports.init = function() {
+ this.a = 6377397.155;
+ this.es = 0.006674372230614;
+ this.e = Math.sqrt(this.es);
+ if (!this.lat0) {
+ this.lat0 = 0.863937979737193;
+ }
+ if (!this.long0) {
+ this.long0 = 0.7417649320975901 - 0.308341501185665;
+ }
+ /* if scale not set default to 0.9999 */
+ if (!this.k0) {
+ this.k0 = 0.9999;
+ }
+ this.s45 = 0.785398163397448; /* 45 */
+ this.s90 = 2 * this.s45;
+ this.fi0 = this.lat0;
+ this.e2 = this.es;
+ this.e = Math.sqrt(this.e2);
+ this.alfa = Math.sqrt(1 + (this.e2 * Math.pow(Math.cos(this.fi0), 4)) / (1 - this.e2));
+ this.uq = 1.04216856380474;
+ this.u0 = Math.asin(Math.sin(this.fi0) / this.alfa);
+ this.g = Math.pow((1 + this.e * Math.sin(this.fi0)) / (1 - this.e * Math.sin(this.fi0)), this.alfa * this.e / 2);
+ this.k = Math.tan(this.u0 / 2 + this.s45) / Math.pow(Math.tan(this.fi0 / 2 + this.s45), this.alfa) * this.g;
+ this.k1 = this.k0;
+ this.n0 = this.a * Math.sqrt(1 - this.e2) / (1 - this.e2 * Math.pow(Math.sin(this.fi0), 2));
+ this.s0 = 1.37008346281555;
+ this.n = Math.sin(this.s0);
+ this.ro0 = this.k1 * this.n0 / Math.tan(this.s0);
+ this.ad = this.s90 - this.uq;
+};
+
+/* ellipsoid */
+/* calculate xy from lat/lon */
+/* Constants, identical to inverse transform function */
+exports.forward = function(p) {
+ var gfi, u, deltav, s, d, eps, ro;
+ var lon = p.x;
+ var lat = p.y;
+ var delta_lon = adjust_lon(lon - this.long0);
+ /* Transformation */
+ gfi = Math.pow(((1 + this.e * Math.sin(lat)) / (1 - this.e * Math.sin(lat))), (this.alfa * this.e / 2));
+ u = 2 * (Math.atan(this.k * Math.pow(Math.tan(lat / 2 + this.s45), this.alfa) / gfi) - this.s45);
+ deltav = -delta_lon * this.alfa;
+ s = Math.asin(Math.cos(this.ad) * Math.sin(u) + Math.sin(this.ad) * Math.cos(u) * Math.cos(deltav));
+ d = Math.asin(Math.cos(u) * Math.sin(deltav) / Math.cos(s));
+ eps = this.n * d;
+ ro = this.ro0 * Math.pow(Math.tan(this.s0 / 2 + this.s45), this.n) / Math.pow(Math.tan(s / 2 + this.s45), this.n);
+ p.y = ro * Math.cos(eps) / 1;
+ p.x = ro * Math.sin(eps) / 1;
+
+ if (!this.czech) {
+ p.y *= -1;
+ p.x *= -1;
+ }
+ return (p);
+};
+
+/* calculate lat/lon from xy */
+exports.inverse = function(p) {
+ var u, deltav, s, d, eps, ro, fi1;
+ var ok;
+
+ /* Transformation */
+ /* revert y, x*/
+ var tmp = p.x;
+ p.x = p.y;
+ p.y = tmp;
+ if (!this.czech) {
+ p.y *= -1;
+ p.x *= -1;
+ }
+ ro = Math.sqrt(p.x * p.x + p.y * p.y);
+ eps = Math.atan2(p.y, p.x);
+ d = eps / Math.sin(this.s0);
+ s = 2 * (Math.atan(Math.pow(this.ro0 / ro, 1 / this.n) * Math.tan(this.s0 / 2 + this.s45)) - this.s45);
+ u = Math.asin(Math.cos(this.ad) * Math.sin(s) - Math.sin(this.ad) * Math.cos(s) * Math.cos(d));
+ deltav = Math.asin(Math.cos(s) * Math.sin(d) / Math.cos(u));
+ p.x = this.long0 - deltav / this.alfa;
+ fi1 = u;
+ ok = 0;
+ var iter = 0;
+ do {
+ p.y = 2 * (Math.atan(Math.pow(this.k, - 1 / this.alfa) * Math.pow(Math.tan(u / 2 + this.s45), 1 / this.alfa) * Math.pow((1 + this.e * Math.sin(fi1)) / (1 - this.e * Math.sin(fi1)), this.e / 2)) - this.s45);
+ if (Math.abs(fi1 - p.y) < 0.0000000001) {
+ ok = 1;
+ }
+ fi1 = p.y;
+ iter += 1;
+ } while (ok === 0 && iter < 15);
+ if (iter >= 15) {
+ return null;
+ }
+
+ return (p);
+};
+exports.names = ["Krovak", "krovak"];
+
+},{"../common/adjust_lon":5}],49:[function(_dereq_,module,exports){
+var HALF_PI = Math.PI/2;
+var FORTPI = Math.PI/4;
+var EPSLN = 1.0e-10;
+var qsfnz = _dereq_('../common/qsfnz');
+var adjust_lon = _dereq_('../common/adjust_lon');
+/*
+ reference
+ "New Equal-Area Map Projections for Noncircular Regions", John P. Snyder,
+ The American Cartographer, Vol 15, No. 4, October 1988, pp. 341-355.
+ */
+
+exports.S_POLE = 1;
+exports.N_POLE = 2;
+exports.EQUIT = 3;
+exports.OBLIQ = 4;
+
+
+/* Initialize the Lambert Azimuthal Equal Area projection
+ ------------------------------------------------------*/
+exports.init = function() {
+ var t = Math.abs(this.lat0);
+ if (Math.abs(t - HALF_PI) < EPSLN) {
+ this.mode = this.lat0 < 0 ? this.S_POLE : this.N_POLE;
+ }
+ else if (Math.abs(t) < EPSLN) {
+ this.mode = this.EQUIT;
+ }
+ else {
+ this.mode = this.OBLIQ;
+ }
+ if (this.es > 0) {
+ var sinphi;
+
+ this.qp = qsfnz(this.e, 1);
+ this.mmf = 0.5 / (1 - this.es);
+ this.apa = this.authset(this.es);
+ switch (this.mode) {
+ case this.N_POLE:
+ this.dd = 1;
+ break;
+ case this.S_POLE:
+ this.dd = 1;
+ break;
+ case this.EQUIT:
+ this.rq = Math.sqrt(0.5 * this.qp);
+ this.dd = 1 / this.rq;
+ this.xmf = 1;
+ this.ymf = 0.5 * this.qp;
+ break;
+ case this.OBLIQ:
+ this.rq = Math.sqrt(0.5 * this.qp);
+ sinphi = Math.sin(this.lat0);
+ this.sinb1 = qsfnz(this.e, sinphi) / this.qp;
+ this.cosb1 = Math.sqrt(1 - this.sinb1 * this.sinb1);
+ this.dd = Math.cos(this.lat0) / (Math.sqrt(1 - this.es * sinphi * sinphi) * this.rq * this.cosb1);
+ this.ymf = (this.xmf = this.rq) / this.dd;
+ this.xmf *= this.dd;
+ break;
+ }
+ }
+ else {
+ if (this.mode === this.OBLIQ) {
+ this.sinph0 = Math.sin(this.lat0);
+ this.cosph0 = Math.cos(this.lat0);
+ }
+ }
+};
+
+/* Lambert Azimuthal Equal Area forward equations--mapping lat,long to x,y
+ -----------------------------------------------------------------------*/
+exports.forward = function(p) {
+
+ /* Forward equations
+ -----------------*/
+ var x, y, coslam, sinlam, sinphi, q, sinb, cosb, b, cosphi;
+ var lam = p.x;
+ var phi = p.y;
+
+ lam = adjust_lon(lam - this.long0);
+
+ if (this.sphere) {
+ sinphi = Math.sin(phi);
+ cosphi = Math.cos(phi);
+ coslam = Math.cos(lam);
+ if (this.mode === this.OBLIQ || this.mode === this.EQUIT) {
+ y = (this.mode === this.EQUIT) ? 1 + cosphi * coslam : 1 + this.sinph0 * sinphi + this.cosph0 * cosphi * coslam;
+ if (y <= EPSLN) {
+ return null;
+ }
+ y = Math.sqrt(2 / y);
+ x = y * cosphi * Math.sin(lam);
+ y *= (this.mode === this.EQUIT) ? sinphi : this.cosph0 * sinphi - this.sinph0 * cosphi * coslam;
+ }
+ else if (this.mode === this.N_POLE || this.mode === this.S_POLE) {
+ if (this.mode === this.N_POLE) {
+ coslam = -coslam;
+ }
+ if (Math.abs(phi + this.phi0) < EPSLN) {
+ return null;
+ }
+ y = FORTPI - phi * 0.5;
+ y = 2 * ((this.mode === this.S_POLE) ? Math.cos(y) : Math.sin(y));
+ x = y * Math.sin(lam);
+ y *= coslam;
+ }
+ }
+ else {
+ sinb = 0;
+ cosb = 0;
+ b = 0;
+ coslam = Math.cos(lam);
+ sinlam = Math.sin(lam);
+ sinphi = Math.sin(phi);
+ q = qsfnz(this.e, sinphi);
+ if (this.mode === this.OBLIQ || this.mode === this.EQUIT) {
+ sinb = q / this.qp;
+ cosb = Math.sqrt(1 - sinb * sinb);
+ }
+ switch (this.mode) {
+ case this.OBLIQ:
+ b = 1 + this.sinb1 * sinb + this.cosb1 * cosb * coslam;
+ break;
+ case this.EQUIT:
+ b = 1 + cosb * coslam;
+ break;
+ case this.N_POLE:
+ b = HALF_PI + phi;
+ q = this.qp - q;
+ break;
+ case this.S_POLE:
+ b = phi - HALF_PI;
+ q = this.qp + q;
+ break;
+ }
+ if (Math.abs(b) < EPSLN) {
+ return null;
+ }
+ switch (this.mode) {
+ case this.OBLIQ:
+ case this.EQUIT:
+ b = Math.sqrt(2 / b);
+ if (this.mode === this.OBLIQ) {
+ y = this.ymf * b * (this.cosb1 * sinb - this.sinb1 * cosb * coslam);
+ }
+ else {
+ y = (b = Math.sqrt(2 / (1 + cosb * coslam))) * sinb * this.ymf;
+ }
+ x = this.xmf * b * cosb * sinlam;
+ break;
+ case this.N_POLE:
+ case this.S_POLE:
+ if (q >= 0) {
+ x = (b = Math.sqrt(q)) * sinlam;
+ y = coslam * ((this.mode === this.S_POLE) ? b : -b);
+ }
+ else {
+ x = y = 0;
+ }
+ break;
+ }
+ }
+
+ p.x = this.a * x + this.x0;
+ p.y = this.a * y + this.y0;
+ return p;
+};
+
+/* Inverse equations
+ -----------------*/
+exports.inverse = function(p) {
+ p.x -= this.x0;
+ p.y -= this.y0;
+ var x = p.x / this.a;
+ var y = p.y / this.a;
+ var lam, phi, cCe, sCe, q, rho, ab;
+
+ if (this.sphere) {
+ var cosz = 0,
+ rh, sinz = 0;
+
+ rh = Math.sqrt(x * x + y * y);
+ phi = rh * 0.5;
+ if (phi > 1) {
+ return null;
+ }
+ phi = 2 * Math.asin(phi);
+ if (this.mode === this.OBLIQ || this.mode === this.EQUIT) {
+ sinz = Math.sin(phi);
+ cosz = Math.cos(phi);
+ }
+ switch (this.mode) {
+ case this.EQUIT:
+ phi = (Math.abs(rh) <= EPSLN) ? 0 : Math.asin(y * sinz / rh);
+ x *= sinz;
+ y = cosz * rh;
+ break;
+ case this.OBLIQ:
+ phi = (Math.abs(rh) <= EPSLN) ? this.phi0 : Math.asin(cosz * this.sinph0 + y * sinz * this.cosph0 / rh);
+ x *= sinz * this.cosph0;
+ y = (cosz - Math.sin(phi) * this.sinph0) * rh;
+ break;
+ case this.N_POLE:
+ y = -y;
+ phi = HALF_PI - phi;
+ break;
+ case this.S_POLE:
+ phi -= HALF_PI;
+ break;
+ }
+ lam = (y === 0 && (this.mode === this.EQUIT || this.mode === this.OBLIQ)) ? 0 : Math.atan2(x, y);
+ }
+ else {
+ ab = 0;
+ if (this.mode === this.OBLIQ || this.mode === this.EQUIT) {
+ x /= this.dd;
+ y *= this.dd;
+ rho = Math.sqrt(x * x + y * y);
+ if (rho < EPSLN) {
+ p.x = 0;
+ p.y = this.phi0;
+ return p;
+ }
+ sCe = 2 * Math.asin(0.5 * rho / this.rq);
+ cCe = Math.cos(sCe);
+ x *= (sCe = Math.sin(sCe));
+ if (this.mode === this.OBLIQ) {
+ ab = cCe * this.sinb1 + y * sCe * this.cosb1 / rho;
+ q = this.qp * ab;
+ y = rho * this.cosb1 * cCe - y * this.sinb1 * sCe;
+ }
+ else {
+ ab = y * sCe / rho;
+ q = this.qp * ab;
+ y = rho * cCe;
+ }
+ }
+ else if (this.mode === this.N_POLE || this.mode === this.S_POLE) {
+ if (this.mode === this.N_POLE) {
+ y = -y;
+ }
+ q = (x * x + y * y);
+ if (!q) {
+ p.x = 0;
+ p.y = this.phi0;
+ return p;
+ }
+ ab = 1 - q / this.qp;
+ if (this.mode === this.S_POLE) {
+ ab = -ab;
+ }
+ }
+ lam = Math.atan2(x, y);
+ phi = this.authlat(Math.asin(ab), this.apa);
+ }
+
+
+ p.x = adjust_lon(this.long0 + lam);
+ p.y = phi;
+ return p;
+};
+
+/* determine latitude from authalic latitude */
+exports.P00 = 0.33333333333333333333;
+exports.P01 = 0.17222222222222222222;
+exports.P02 = 0.10257936507936507936;
+exports.P10 = 0.06388888888888888888;
+exports.P11 = 0.06640211640211640211;
+exports.P20 = 0.01641501294219154443;
+
+exports.authset = function(es) {
+ var t;
+ var APA = [];
+ APA[0] = es * this.P00;
+ t = es * es;
+ APA[0] += t * this.P01;
+ APA[1] = t * this.P10;
+ t *= es;
+ APA[0] += t * this.P02;
+ APA[1] += t * this.P11;
+ APA[2] = t * this.P20;
+ return APA;
+};
+
+exports.authlat = function(beta, APA) {
+ var t = beta + beta;
+ return (beta + APA[0] * Math.sin(t) + APA[1] * Math.sin(t + t) + APA[2] * Math.sin(t + t + t));
+};
+exports.names = ["Lambert Azimuthal Equal Area", "Lambert_Azimuthal_Equal_Area", "laea"];
+
+},{"../common/adjust_lon":5,"../common/qsfnz":20}],50:[function(_dereq_,module,exports){
+var EPSLN = 1.0e-10;
+var msfnz = _dereq_('../common/msfnz');
+var tsfnz = _dereq_('../common/tsfnz');
+var HALF_PI = Math.PI/2;
+var sign = _dereq_('../common/sign');
+var adjust_lon = _dereq_('../common/adjust_lon');
+var phi2z = _dereq_('../common/phi2z');
+exports.init = function() {
+
+ // array of: r_maj,r_min,lat1,lat2,c_lon,c_lat,false_east,false_north
+ //double c_lat; /* center latitude */
+ //double c_lon; /* center longitude */
+ //double lat1; /* first standard parallel */
+ //double lat2; /* second standard parallel */
+ //double r_maj; /* major axis */
+ //double r_min; /* minor axis */
+ //double false_east; /* x offset in meters */
+ //double false_north; /* y offset in meters */
+
+ if (!this.lat2) {
+ this.lat2 = this.lat1;
+ } //if lat2 is not defined
+ if (!this.k0) {
+ this.k0 = 1;
+ }
+ this.x0 = this.x0 || 0;
+ this.y0 = this.y0 || 0;
+ // Standard Parallels cannot be equal and on opposite sides of the equator
+ if (Math.abs(this.lat1 + this.lat2) < EPSLN) {
+ return;
+ }
+
+ var temp = this.b / this.a;
+ this.e = Math.sqrt(1 - temp * temp);
+
+ var sin1 = Math.sin(this.lat1);
+ var cos1 = Math.cos(this.lat1);
+ var ms1 = msfnz(this.e, sin1, cos1);
+ var ts1 = tsfnz(this.e, this.lat1, sin1);
+
+ var sin2 = Math.sin(this.lat2);
+ var cos2 = Math.cos(this.lat2);
+ var ms2 = msfnz(this.e, sin2, cos2);
+ var ts2 = tsfnz(this.e, this.lat2, sin2);
+
+ var ts0 = tsfnz(this.e, this.lat0, Math.sin(this.lat0));
+
+ if (Math.abs(this.lat1 - this.lat2) > EPSLN) {
+ this.ns = Math.log(ms1 / ms2) / Math.log(ts1 / ts2);
+ }
+ else {
+ this.ns = sin1;
+ }
+ if (isNaN(this.ns)) {
+ this.ns = sin1;
+ }
+ this.f0 = ms1 / (this.ns * Math.pow(ts1, this.ns));
+ this.rh = this.a * this.f0 * Math.pow(ts0, this.ns);
+ if (!this.title) {
+ this.title = "Lambert Conformal Conic";
+ }
+};
+
+
+// Lambert Conformal conic forward equations--mapping lat,long to x,y
+// -----------------------------------------------------------------
+exports.forward = function(p) {
+
+ var lon = p.x;
+ var lat = p.y;
+
+ // singular cases :
+ if (Math.abs(2 * Math.abs(lat) - Math.PI) <= EPSLN) {
+ lat = sign(lat) * (HALF_PI - 2 * EPSLN);
+ }
+
+ var con = Math.abs(Math.abs(lat) - HALF_PI);
+ var ts, rh1;
+ if (con > EPSLN) {
+ ts = tsfnz(this.e, lat, Math.sin(lat));
+ rh1 = this.a * this.f0 * Math.pow(ts, this.ns);
+ }
+ else {
+ con = lat * this.ns;
+ if (con <= 0) {
+ return null;
+ }
+ rh1 = 0;
+ }
+ var theta = this.ns * adjust_lon(lon - this.long0);
+ p.x = this.k0 * (rh1 * Math.sin(theta)) + this.x0;
+ p.y = this.k0 * (this.rh - rh1 * Math.cos(theta)) + this.y0;
+
+ return p;
+};
+
+// Lambert Conformal Conic inverse equations--mapping x,y to lat/long
+// -----------------------------------------------------------------
+exports.inverse = function(p) {
+
+ var rh1, con, ts;
+ var lat, lon;
+ var x = (p.x - this.x0) / this.k0;
+ var y = (this.rh - (p.y - this.y0) / this.k0);
+ if (this.ns > 0) {
+ rh1 = Math.sqrt(x * x + y * y);
+ con = 1;
+ }
+ else {
+ rh1 = -Math.sqrt(x * x + y * y);
+ con = -1;
+ }
+ var theta = 0;
+ if (rh1 !== 0) {
+ theta = Math.atan2((con * x), (con * y));
+ }
+ if ((rh1 !== 0) || (this.ns > 0)) {
+ con = 1 / this.ns;
+ ts = Math.pow((rh1 / (this.a * this.f0)), con);
+ lat = phi2z(this.e, ts);
+ if (lat === -9999) {
+ return null;
+ }
+ }
+ else {
+ lat = -HALF_PI;
+ }
+ lon = adjust_lon(theta / this.ns + this.long0);
+
+ p.x = lon;
+ p.y = lat;
+ return p;
+};
+
+exports.names = ["Lambert Tangential Conformal Conic Projection", "Lambert_Conformal_Conic", "Lambert_Conformal_Conic_2SP", "lcc"];
+
+},{"../common/adjust_lon":5,"../common/msfnz":15,"../common/phi2z":16,"../common/sign":21,"../common/tsfnz":24}],51:[function(_dereq_,module,exports){
+exports.init = function() {
+ //no-op for longlat
+};
+
+function identity(pt) {
+ return pt;
+}
+exports.forward = identity;
+exports.inverse = identity;
+exports.names = ["longlat", "identity"];
+
+},{}],52:[function(_dereq_,module,exports){
+var msfnz = _dereq_('../common/msfnz');
+var HALF_PI = Math.PI/2;
+var EPSLN = 1.0e-10;
+var R2D = 57.29577951308232088;
+var adjust_lon = _dereq_('../common/adjust_lon');
+var FORTPI = Math.PI/4;
+var tsfnz = _dereq_('../common/tsfnz');
+var phi2z = _dereq_('../common/phi2z');
+exports.init = function() {
+ var con = this.b / this.a;
+ this.es = 1 - con * con;
+ if(!('x0' in this)){
+ this.x0 = 0;
+ }
+ if(!('y0' in this)){
+ this.y0 = 0;
+ }
+ this.e = Math.sqrt(this.es);
+ if (this.lat_ts) {
+ if (this.sphere) {
+ this.k0 = Math.cos(this.lat_ts);
+ }
+ else {
+ this.k0 = msfnz(this.e, Math.sin(this.lat_ts), Math.cos(this.lat_ts));
+ }
+ }
+ else {
+ if (!this.k0) {
+ if (this.k) {
+ this.k0 = this.k;
+ }
+ else {
+ this.k0 = 1;
+ }
+ }
+ }
+};
+
+/* Mercator forward equations--mapping lat,long to x,y
+ --------------------------------------------------*/
+
+exports.forward = function(p) {
+ var lon = p.x;
+ var lat = p.y;
+ // convert to radians
+ if (lat * R2D > 90 && lat * R2D < -90 && lon * R2D > 180 && lon * R2D < -180) {
+ return null;
+ }
+
+ var x, y;
+ if (Math.abs(Math.abs(lat) - HALF_PI) <= EPSLN) {
+ return null;
+ }
+ else {
+ if (this.sphere) {
+ x = this.x0 + this.a * this.k0 * adjust_lon(lon - this.long0);
+ y = this.y0 + this.a * this.k0 * Math.log(Math.tan(FORTPI + 0.5 * lat));
+ }
+ else {
+ var sinphi = Math.sin(lat);
+ var ts = tsfnz(this.e, lat, sinphi);
+ x = this.x0 + this.a * this.k0 * adjust_lon(lon - this.long0);
+ y = this.y0 - this.a * this.k0 * Math.log(ts);
+ }
+ p.x = x;
+ p.y = y;
+ return p;
+ }
+};
+
+
+/* Mercator inverse equations--mapping x,y to lat/long
+ --------------------------------------------------*/
+exports.inverse = function(p) {
+
+ var x = p.x - this.x0;
+ var y = p.y - this.y0;
+ var lon, lat;
+
+ if (this.sphere) {
+ lat = HALF_PI - 2 * Math.atan(Math.exp(-y / (this.a * this.k0)));
+ }
+ else {
+ var ts = Math.exp(-y / (this.a * this.k0));
+ lat = phi2z(this.e, ts);
+ if (lat === -9999) {
+ return null;
+ }
+ }
+ lon = adjust_lon(this.long0 + x / (this.a * this.k0));
+
+ p.x = lon;
+ p.y = lat;
+ return p;
+};
+
+exports.names = ["Mercator", "Popular Visualisation Pseudo Mercator", "Mercator_1SP", "Mercator_Auxiliary_Sphere", "merc"];
+
+},{"../common/adjust_lon":5,"../common/msfnz":15,"../common/phi2z":16,"../common/tsfnz":24}],53:[function(_dereq_,module,exports){
+var adjust_lon = _dereq_('../common/adjust_lon');
+/*
+ reference
+ "New Equal-Area Map Projections for Noncircular Regions", John P. Snyder,
+ The American Cartographer, Vol 15, No. 4, October 1988, pp. 341-355.
+ */
+
+
+/* Initialize the Miller Cylindrical projection
+ -------------------------------------------*/
+exports.init = function() {
+ //no-op
+};
+
+
+/* Miller Cylindrical forward equations--mapping lat,long to x,y
+ ------------------------------------------------------------*/
+exports.forward = function(p) {
+ var lon = p.x;
+ var lat = p.y;
+ /* Forward equations
+ -----------------*/
+ var dlon = adjust_lon(lon - this.long0);
+ var x = this.x0 + this.a * dlon;
+ var y = this.y0 + this.a * Math.log(Math.tan((Math.PI / 4) + (lat / 2.5))) * 1.25;
+
+ p.x = x;
+ p.y = y;
+ return p;
+};
+
+/* Miller Cylindrical inverse equations--mapping x,y to lat/long
+ ------------------------------------------------------------*/
+exports.inverse = function(p) {
+ p.x -= this.x0;
+ p.y -= this.y0;
+
+ var lon = adjust_lon(this.long0 + p.x / this.a);
+ var lat = 2.5 * (Math.atan(Math.exp(0.8 * p.y / this.a)) - Math.PI / 4);
+
+ p.x = lon;
+ p.y = lat;
+ return p;
+};
+exports.names = ["Miller_Cylindrical", "mill"];
+
+},{"../common/adjust_lon":5}],54:[function(_dereq_,module,exports){
+var adjust_lon = _dereq_('../common/adjust_lon');
+var EPSLN = 1.0e-10;
+exports.init = function() {};
+
+/* Mollweide forward equations--mapping lat,long to x,y
+ ----------------------------------------------------*/
+exports.forward = function(p) {
+
+ /* Forward equations
+ -----------------*/
+ var lon = p.x;
+ var lat = p.y;
+
+ var delta_lon = adjust_lon(lon - this.long0);
+ var theta = lat;
+ var con = Math.PI * Math.sin(lat);
+
+ /* Iterate using the Newton-Raphson method to find theta
+ -----------------------------------------------------*/
+ for (var i = 0; true; i++) {
+ var delta_theta = -(theta + Math.sin(theta) - con) / (1 + Math.cos(theta));
+ theta += delta_theta;
+ if (Math.abs(delta_theta) < EPSLN) {
+ break;
+ }
+ }
+ theta /= 2;
+
+ /* If the latitude is 90 deg, force the x coordinate to be "0 + false easting"
+ this is done here because of precision problems with "cos(theta)"
+ --------------------------------------------------------------------------*/
+ if (Math.PI / 2 - Math.abs(lat) < EPSLN) {
+ delta_lon = 0;
+ }
+ var x = 0.900316316158 * this.a * delta_lon * Math.cos(theta) + this.x0;
+ var y = 1.4142135623731 * this.a * Math.sin(theta) + this.y0;
+
+ p.x = x;
+ p.y = y;
+ return p;
+};
+
+exports.inverse = function(p) {
+ var theta;
+ var arg;
+
+ /* Inverse equations
+ -----------------*/
+ p.x -= this.x0;
+ p.y -= this.y0;
+ arg = p.y / (1.4142135623731 * this.a);
+
+ /* Because of division by zero problems, 'arg' can not be 1. Therefore
+ a number very close to one is used instead.
+ -------------------------------------------------------------------*/
+ if (Math.abs(arg) > 0.999999999999) {
+ arg = 0.999999999999;
+ }
+ theta = Math.asin(arg);
+ var lon = adjust_lon(this.long0 + (p.x / (0.900316316158 * this.a * Math.cos(theta))));
+ if (lon < (-Math.PI)) {
+ lon = -Math.PI;
+ }
+ if (lon > Math.PI) {
+ lon = Math.PI;
+ }
+ arg = (2 * theta + Math.sin(2 * theta)) / Math.PI;
+ if (Math.abs(arg) > 1) {
+ arg = 1;
+ }
+ var lat = Math.asin(arg);
+
+ p.x = lon;
+ p.y = lat;
+ return p;
+};
+exports.names = ["Mollweide", "moll"];
+
+},{"../common/adjust_lon":5}],55:[function(_dereq_,module,exports){
+var SEC_TO_RAD = 4.84813681109535993589914102357e-6;
+/*
+ reference
+ Department of Land and Survey Technical Circular 1973/32
+ http://www.linz.govt.nz/docs/miscellaneous/nz-map-definition.pdf
+ OSG Technical Report 4.1
+ http://www.linz.govt.nz/docs/miscellaneous/nzmg.pdf
+ */
+
+/**
+ * iterations: Number of iterations to refine inverse transform.
+ * 0 -> km accuracy
+ * 1 -> m accuracy -- suitable for most mapping applications
+ * 2 -> mm accuracy
+ */
+exports.iterations = 1;
+
+exports.init = function() {
+ this.A = [];
+ this.A[1] = 0.6399175073;
+ this.A[2] = -0.1358797613;
+ this.A[3] = 0.063294409;
+ this.A[4] = -0.02526853;
+ this.A[5] = 0.0117879;
+ this.A[6] = -0.0055161;
+ this.A[7] = 0.0026906;
+ this.A[8] = -0.001333;
+ this.A[9] = 0.00067;
+ this.A[10] = -0.00034;
+
+ this.B_re = [];
+ this.B_im = [];
+ this.B_re[1] = 0.7557853228;
+ this.B_im[1] = 0;
+ this.B_re[2] = 0.249204646;
+ this.B_im[2] = 0.003371507;
+ this.B_re[3] = -0.001541739;
+ this.B_im[3] = 0.041058560;
+ this.B_re[4] = -0.10162907;
+ this.B_im[4] = 0.01727609;
+ this.B_re[5] = -0.26623489;
+ this.B_im[5] = -0.36249218;
+ this.B_re[6] = -0.6870983;
+ this.B_im[6] = -1.1651967;
+
+ this.C_re = [];
+ this.C_im = [];
+ this.C_re[1] = 1.3231270439;
+ this.C_im[1] = 0;
+ this.C_re[2] = -0.577245789;
+ this.C_im[2] = -0.007809598;
+ this.C_re[3] = 0.508307513;
+ this.C_im[3] = -0.112208952;
+ this.C_re[4] = -0.15094762;
+ this.C_im[4] = 0.18200602;
+ this.C_re[5] = 1.01418179;
+ this.C_im[5] = 1.64497696;
+ this.C_re[6] = 1.9660549;
+ this.C_im[6] = 2.5127645;
+
+ this.D = [];
+ this.D[1] = 1.5627014243;
+ this.D[2] = 0.5185406398;
+ this.D[3] = -0.03333098;
+ this.D[4] = -0.1052906;
+ this.D[5] = -0.0368594;
+ this.D[6] = 0.007317;
+ this.D[7] = 0.01220;
+ this.D[8] = 0.00394;
+ this.D[9] = -0.0013;
+};
+
+/**
+ New Zealand Map Grid Forward - long/lat to x/y
+ long/lat in radians
+ */
+exports.forward = function(p) {
+ var n;
+ var lon = p.x;
+ var lat = p.y;
+
+ var delta_lat = lat - this.lat0;
+ var delta_lon = lon - this.long0;
+
+ // 1. Calculate d_phi and d_psi ... // and d_lambda
+ // For this algorithm, delta_latitude is in seconds of arc x 10-5, so we need to scale to those units. Longitude is radians.
+ var d_phi = delta_lat / SEC_TO_RAD * 1E-5;
+ var d_lambda = delta_lon;
+ var d_phi_n = 1; // d_phi^0
+
+ var d_psi = 0;
+ for (n = 1; n <= 10; n++) {
+ d_phi_n = d_phi_n * d_phi;
+ d_psi = d_psi + this.A[n] * d_phi_n;
+ }
+
+ // 2. Calculate theta
+ var th_re = d_psi;
+ var th_im = d_lambda;
+
+ // 3. Calculate z
+ var th_n_re = 1;
+ var th_n_im = 0; // theta^0
+ var th_n_re1;
+ var th_n_im1;
+
+ var z_re = 0;
+ var z_im = 0;
+ for (n = 1; n <= 6; n++) {
+ th_n_re1 = th_n_re * th_re - th_n_im * th_im;
+ th_n_im1 = th_n_im * th_re + th_n_re * th_im;
+ th_n_re = th_n_re1;
+ th_n_im = th_n_im1;
+ z_re = z_re + this.B_re[n] * th_n_re - this.B_im[n] * th_n_im;
+ z_im = z_im + this.B_im[n] * th_n_re + this.B_re[n] * th_n_im;
+ }
+
+ // 4. Calculate easting and northing
+ p.x = (z_im * this.a) + this.x0;
+ p.y = (z_re * this.a) + this.y0;
+
+ return p;
+};
+
+
+/**
+ New Zealand Map Grid Inverse - x/y to long/lat
+ */
+exports.inverse = function(p) {
+ var n;
+ var x = p.x;
+ var y = p.y;
+
+ var delta_x = x - this.x0;
+ var delta_y = y - this.y0;
+
+ // 1. Calculate z
+ var z_re = delta_y / this.a;
+ var z_im = delta_x / this.a;
+
+ // 2a. Calculate theta - first approximation gives km accuracy
+ var z_n_re = 1;
+ var z_n_im = 0; // z^0
+ var z_n_re1;
+ var z_n_im1;
+
+ var th_re = 0;
+ var th_im = 0;
+ for (n = 1; n <= 6; n++) {
+ z_n_re1 = z_n_re * z_re - z_n_im * z_im;
+ z_n_im1 = z_n_im * z_re + z_n_re * z_im;
+ z_n_re = z_n_re1;
+ z_n_im = z_n_im1;
+ th_re = th_re + this.C_re[n] * z_n_re - this.C_im[n] * z_n_im;
+ th_im = th_im + this.C_im[n] * z_n_re + this.C_re[n] * z_n_im;
+ }
+
+ // 2b. Iterate to refine the accuracy of the calculation
+ // 0 iterations gives km accuracy
+ // 1 iteration gives m accuracy -- good enough for most mapping applications
+ // 2 iterations bives mm accuracy
+ for (var i = 0; i < this.iterations; i++) {
+ var th_n_re = th_re;
+ var th_n_im = th_im;
+ var th_n_re1;
+ var th_n_im1;
+
+ var num_re = z_re;
+ var num_im = z_im;
+ for (n = 2; n <= 6; n++) {
+ th_n_re1 = th_n_re * th_re - th_n_im * th_im;
+ th_n_im1 = th_n_im * th_re + th_n_re * th_im;
+ th_n_re = th_n_re1;
+ th_n_im = th_n_im1;
+ num_re = num_re + (n - 1) * (this.B_re[n] * th_n_re - this.B_im[n] * th_n_im);
+ num_im = num_im + (n - 1) * (this.B_im[n] * th_n_re + this.B_re[n] * th_n_im);
+ }
+
+ th_n_re = 1;
+ th_n_im = 0;
+ var den_re = this.B_re[1];
+ var den_im = this.B_im[1];
+ for (n = 2; n <= 6; n++) {
+ th_n_re1 = th_n_re * th_re - th_n_im * th_im;
+ th_n_im1 = th_n_im * th_re + th_n_re * th_im;
+ th_n_re = th_n_re1;
+ th_n_im = th_n_im1;
+ den_re = den_re + n * (this.B_re[n] * th_n_re - this.B_im[n] * th_n_im);
+ den_im = den_im + n * (this.B_im[n] * th_n_re + this.B_re[n] * th_n_im);
+ }
+
+ // Complex division
+ var den2 = den_re * den_re + den_im * den_im;
+ th_re = (num_re * den_re + num_im * den_im) / den2;
+ th_im = (num_im * den_re - num_re * den_im) / den2;
+ }
+
+ // 3. Calculate d_phi ... // and d_lambda
+ var d_psi = th_re;
+ var d_lambda = th_im;
+ var d_psi_n = 1; // d_psi^0
+
+ var d_phi = 0;
+ for (n = 1; n <= 9; n++) {
+ d_psi_n = d_psi_n * d_psi;
+ d_phi = d_phi + this.D[n] * d_psi_n;
+ }
+
+ // 4. Calculate latitude and longitude
+ // d_phi is calcuated in second of arc * 10^-5, so we need to scale back to radians. d_lambda is in radians.
+ var lat = this.lat0 + (d_phi * SEC_TO_RAD * 1E5);
+ var lon = this.long0 + d_lambda;
+
+ p.x = lon;
+ p.y = lat;
+
+ return p;
+};
+exports.names = ["New_Zealand_Map_Grid", "nzmg"];
+},{}],56:[function(_dereq_,module,exports){
+var tsfnz = _dereq_('../common/tsfnz');
+var adjust_lon = _dereq_('../common/adjust_lon');
+var phi2z = _dereq_('../common/phi2z');
+var HALF_PI = Math.PI/2;
+var FORTPI = Math.PI/4;
+var EPSLN = 1.0e-10;
+
+/* Initialize the Oblique Mercator projection
+ ------------------------------------------*/
+exports.init = function() {
+ this.no_off = this.no_off || false;
+ this.no_rot = this.no_rot || false;
+
+ if (isNaN(this.k0)) {
+ this.k0 = 1;
+ }
+ var sinlat = Math.sin(this.lat0);
+ var coslat = Math.cos(this.lat0);
+ var con = this.e * sinlat;
+
+ this.bl = Math.sqrt(1 + this.es / (1 - this.es) * Math.pow(coslat, 4));
+ this.al = this.a * this.bl * this.k0 * Math.sqrt(1 - this.es) / (1 - con * con);
+ var t0 = tsfnz(this.e, this.lat0, sinlat);
+ var dl = this.bl / coslat * Math.sqrt((1 - this.es) / (1 - con * con));
+ if (dl * dl < 1) {
+ dl = 1;
+ }
+ var fl;
+ var gl;
+ if (!isNaN(this.longc)) {
+ //Central point and azimuth method
+
+ if (this.lat0 >= 0) {
+ fl = dl + Math.sqrt(dl * dl - 1);
+ }
+ else {
+ fl = dl - Math.sqrt(dl * dl - 1);
+ }
+ this.el = fl * Math.pow(t0, this.bl);
+ gl = 0.5 * (fl - 1 / fl);
+ this.gamma0 = Math.asin(Math.sin(this.alpha) / dl);
+ this.long0 = this.longc - Math.asin(gl * Math.tan(this.gamma0)) / this.bl;
+
+ }
+ else {
+ //2 points method
+ var t1 = tsfnz(this.e, this.lat1, Math.sin(this.lat1));
+ var t2 = tsfnz(this.e, this.lat2, Math.sin(this.lat2));
+ if (this.lat0 >= 0) {
+ this.el = (dl + Math.sqrt(dl * dl - 1)) * Math.pow(t0, this.bl);
+ }
+ else {
+ this.el = (dl - Math.sqrt(dl * dl - 1)) * Math.pow(t0, this.bl);
+ }
+ var hl = Math.pow(t1, this.bl);
+ var ll = Math.pow(t2, this.bl);
+ fl = this.el / hl;
+ gl = 0.5 * (fl - 1 / fl);
+ var jl = (this.el * this.el - ll * hl) / (this.el * this.el + ll * hl);
+ var pl = (ll - hl) / (ll + hl);
+ var dlon12 = adjust_lon(this.long1 - this.long2);
+ this.long0 = 0.5 * (this.long1 + this.long2) - Math.atan(jl * Math.tan(0.5 * this.bl * (dlon12)) / pl) / this.bl;
+ this.long0 = adjust_lon(this.long0);
+ var dlon10 = adjust_lon(this.long1 - this.long0);
+ this.gamma0 = Math.atan(Math.sin(this.bl * (dlon10)) / gl);
+ this.alpha = Math.asin(dl * Math.sin(this.gamma0));
+ }
+
+ if (this.no_off) {
+ this.uc = 0;
+ }
+ else {
+ if (this.lat0 >= 0) {
+ this.uc = this.al / this.bl * Math.atan2(Math.sqrt(dl * dl - 1), Math.cos(this.alpha));
+ }
+ else {
+ this.uc = -1 * this.al / this.bl * Math.atan2(Math.sqrt(dl * dl - 1), Math.cos(this.alpha));
+ }
+ }
+
+};
+
+
+/* Oblique Mercator forward equations--mapping lat,long to x,y
+ ----------------------------------------------------------*/
+exports.forward = function(p) {
+ var lon = p.x;
+ var lat = p.y;
+ var dlon = adjust_lon(lon - this.long0);
+ var us, vs;
+ var con;
+ if (Math.abs(Math.abs(lat) - HALF_PI) <= EPSLN) {
+ if (lat > 0) {
+ con = -1;
+ }
+ else {
+ con = 1;
+ }
+ vs = this.al / this.bl * Math.log(Math.tan(FORTPI + con * this.gamma0 * 0.5));
+ us = -1 * con * HALF_PI * this.al / this.bl;
+ }
+ else {
+ var t = tsfnz(this.e, lat, Math.sin(lat));
+ var ql = this.el / Math.pow(t, this.bl);
+ var sl = 0.5 * (ql - 1 / ql);
+ var tl = 0.5 * (ql + 1 / ql);
+ var vl = Math.sin(this.bl * (dlon));
+ var ul = (sl * Math.sin(this.gamma0) - vl * Math.cos(this.gamma0)) / tl;
+ if (Math.abs(Math.abs(ul) - 1) <= EPSLN) {
+ vs = Number.POSITIVE_INFINITY;
+ }
+ else {
+ vs = 0.5 * this.al * Math.log((1 - ul) / (1 + ul)) / this.bl;
+ }
+ if (Math.abs(Math.cos(this.bl * (dlon))) <= EPSLN) {
+ us = this.al * this.bl * (dlon);
+ }
+ else {
+ us = this.al * Math.atan2(sl * Math.cos(this.gamma0) + vl * Math.sin(this.gamma0), Math.cos(this.bl * dlon)) / this.bl;
+ }
+ }
+
+ if (this.no_rot) {
+ p.x = this.x0 + us;
+ p.y = this.y0 + vs;
+ }
+ else {
+
+ us -= this.uc;
+ p.x = this.x0 + vs * Math.cos(this.alpha) + us * Math.sin(this.alpha);
+ p.y = this.y0 + us * Math.cos(this.alpha) - vs * Math.sin(this.alpha);
+ }
+ return p;
+};
+
+exports.inverse = function(p) {
+ var us, vs;
+ if (this.no_rot) {
+ vs = p.y - this.y0;
+ us = p.x - this.x0;
+ }
+ else {
+ vs = (p.x - this.x0) * Math.cos(this.alpha) - (p.y - this.y0) * Math.sin(this.alpha);
+ us = (p.y - this.y0) * Math.cos(this.alpha) + (p.x - this.x0) * Math.sin(this.alpha);
+ us += this.uc;
+ }
+ var qp = Math.exp(-1 * this.bl * vs / this.al);
+ var sp = 0.5 * (qp - 1 / qp);
+ var tp = 0.5 * (qp + 1 / qp);
+ var vp = Math.sin(this.bl * us / this.al);
+ var up = (vp * Math.cos(this.gamma0) + sp * Math.sin(this.gamma0)) / tp;
+ var ts = Math.pow(this.el / Math.sqrt((1 + up) / (1 - up)), 1 / this.bl);
+ if (Math.abs(up - 1) < EPSLN) {
+ p.x = this.long0;
+ p.y = HALF_PI;
+ }
+ else if (Math.abs(up + 1) < EPSLN) {
+ p.x = this.long0;
+ p.y = -1 * HALF_PI;
+ }
+ else {
+ p.y = phi2z(this.e, ts);
+ p.x = adjust_lon(this.long0 - Math.atan2(sp * Math.cos(this.gamma0) - vp * Math.sin(this.gamma0), Math.cos(this.bl * us / this.al)) / this.bl);
+ }
+ return p;
+};
+
+exports.names = ["Hotine_Oblique_Mercator", "Hotine Oblique Mercator", "Hotine_Oblique_Mercator_Azimuth_Natural_Origin", "Hotine_Oblique_Mercator_Azimuth_Center", "omerc"];
+},{"../common/adjust_lon":5,"../common/phi2z":16,"../common/tsfnz":24}],57:[function(_dereq_,module,exports){
+var e0fn = _dereq_('../common/e0fn');
+var e1fn = _dereq_('../common/e1fn');
+var e2fn = _dereq_('../common/e2fn');
+var e3fn = _dereq_('../common/e3fn');
+var adjust_lon = _dereq_('../common/adjust_lon');
+var adjust_lat = _dereq_('../common/adjust_lat');
+var mlfn = _dereq_('../common/mlfn');
+var EPSLN = 1.0e-10;
+var gN = _dereq_('../common/gN');
+var MAX_ITER = 20;
+exports.init = function() {
+ /* Place parameters in static storage for common use
+ -------------------------------------------------*/
+ this.temp = this.b / this.a;
+ this.es = 1 - Math.pow(this.temp, 2); // devait etre dans tmerc.js mais n y est pas donc je commente sinon retour de valeurs nulles
+ this.e = Math.sqrt(this.es);
+ this.e0 = e0fn(this.es);
+ this.e1 = e1fn(this.es);
+ this.e2 = e2fn(this.es);
+ this.e3 = e3fn(this.es);
+ this.ml0 = this.a * mlfn(this.e0, this.e1, this.e2, this.e3, this.lat0); //si que des zeros le calcul ne se fait pas
+};
+
+
+/* Polyconic forward equations--mapping lat,long to x,y
+ ---------------------------------------------------*/
+exports.forward = function(p) {
+ var lon = p.x;
+ var lat = p.y;
+ var x, y, el;
+ var dlon = adjust_lon(lon - this.long0);
+ el = dlon * Math.sin(lat);
+ if (this.sphere) {
+ if (Math.abs(lat) <= EPSLN) {
+ x = this.a * dlon;
+ y = -1 * this.a * this.lat0;
+ }
+ else {
+ x = this.a * Math.sin(el) / Math.tan(lat);
+ y = this.a * (adjust_lat(lat - this.lat0) + (1 - Math.cos(el)) / Math.tan(lat));
+ }
+ }
+ else {
+ if (Math.abs(lat) <= EPSLN) {
+ x = this.a * dlon;
+ y = -1 * this.ml0;
+ }
+ else {
+ var nl = gN(this.a, this.e, Math.sin(lat)) / Math.tan(lat);
+ x = nl * Math.sin(el);
+ y = this.a * mlfn(this.e0, this.e1, this.e2, this.e3, lat) - this.ml0 + nl * (1 - Math.cos(el));
+ }
+
+ }
+ p.x = x + this.x0;
+ p.y = y + this.y0;
+ return p;
+};
+
+
+/* Inverse equations
+ -----------------*/
+exports.inverse = function(p) {
+ var lon, lat, x, y, i;
+ var al, bl;
+ var phi, dphi;
+ x = p.x - this.x0;
+ y = p.y - this.y0;
+
+ if (this.sphere) {
+ if (Math.abs(y + this.a * this.lat0) <= EPSLN) {
+ lon = adjust_lon(x / this.a + this.long0);
+ lat = 0;
+ }
+ else {
+ al = this.lat0 + y / this.a;
+ bl = x * x / this.a / this.a + al * al;
+ phi = al;
+ var tanphi;
+ for (i = MAX_ITER; i; --i) {
+ tanphi = Math.tan(phi);
+ dphi = -1 * (al * (phi * tanphi + 1) - phi - 0.5 * (phi * phi + bl) * tanphi) / ((phi - al) / tanphi - 1);
+ phi += dphi;
+ if (Math.abs(dphi) <= EPSLN) {
+ lat = phi;
+ break;
+ }
+ }
+ lon = adjust_lon(this.long0 + (Math.asin(x * Math.tan(phi) / this.a)) / Math.sin(lat));
+ }
+ }
+ else {
+ if (Math.abs(y + this.ml0) <= EPSLN) {
+ lat = 0;
+ lon = adjust_lon(this.long0 + x / this.a);
+ }
+ else {
+
+ al = (this.ml0 + y) / this.a;
+ bl = x * x / this.a / this.a + al * al;
+ phi = al;
+ var cl, mln, mlnp, ma;
+ var con;
+ for (i = MAX_ITER; i; --i) {
+ con = this.e * Math.sin(phi);
+ cl = Math.sqrt(1 - con * con) * Math.tan(phi);
+ mln = this.a * mlfn(this.e0, this.e1, this.e2, this.e3, phi);
+ mlnp = this.e0 - 2 * this.e1 * Math.cos(2 * phi) + 4 * this.e2 * Math.cos(4 * phi) - 6 * this.e3 * Math.cos(6 * phi);
+ ma = mln / this.a;
+ dphi = (al * (cl * ma + 1) - ma - 0.5 * cl * (ma * ma + bl)) / (this.es * Math.sin(2 * phi) * (ma * ma + bl - 2 * al * ma) / (4 * cl) + (al - ma) * (cl * mlnp - 2 / Math.sin(2 * phi)) - mlnp);
+ phi -= dphi;
+ if (Math.abs(dphi) <= EPSLN) {
+ lat = phi;
+ break;
+ }
+ }
+
+ //lat=phi4z(this.e,this.e0,this.e1,this.e2,this.e3,al,bl,0,0);
+ cl = Math.sqrt(1 - this.es * Math.pow(Math.sin(lat), 2)) * Math.tan(lat);
+ lon = adjust_lon(this.long0 + Math.asin(x * cl / this.a) / Math.sin(lat));
+ }
+ }
+
+ p.x = lon;
+ p.y = lat;
+ return p;
+};
+exports.names = ["Polyconic", "poly"];
+},{"../common/adjust_lat":4,"../common/adjust_lon":5,"../common/e0fn":7,"../common/e1fn":8,"../common/e2fn":9,"../common/e3fn":10,"../common/gN":11,"../common/mlfn":14}],58:[function(_dereq_,module,exports){
+var adjust_lon = _dereq_('../common/adjust_lon');
+var adjust_lat = _dereq_('../common/adjust_lat');
+var pj_enfn = _dereq_('../common/pj_enfn');
+var MAX_ITER = 20;
+var pj_mlfn = _dereq_('../common/pj_mlfn');
+var pj_inv_mlfn = _dereq_('../common/pj_inv_mlfn');
+var HALF_PI = Math.PI/2;
+var EPSLN = 1.0e-10;
+var asinz = _dereq_('../common/asinz');
+exports.init = function() {
+ /* Place parameters in static storage for common use
+ -------------------------------------------------*/
+
+
+ if (!this.sphere) {
+ this.en = pj_enfn(this.es);
+ }
+ else {
+ this.n = 1;
+ this.m = 0;
+ this.es = 0;
+ this.C_y = Math.sqrt((this.m + 1) / this.n);
+ this.C_x = this.C_y / (this.m + 1);
+ }
+
+};
+
+/* Sinusoidal forward equations--mapping lat,long to x,y
+ -----------------------------------------------------*/
+exports.forward = function(p) {
+ var x, y;
+ var lon = p.x;
+ var lat = p.y;
+ /* Forward equations
+ -----------------*/
+ lon = adjust_lon(lon - this.long0);
+
+ if (this.sphere) {
+ if (!this.m) {
+ lat = this.n !== 1 ? Math.asin(this.n * Math.sin(lat)) : lat;
+ }
+ else {
+ var k = this.n * Math.sin(lat);
+ for (var i = MAX_ITER; i; --i) {
+ var V = (this.m * lat + Math.sin(lat) - k) / (this.m + Math.cos(lat));
+ lat -= V;
+ if (Math.abs(V) < EPSLN) {
+ break;
+ }
+ }
+ }
+ x = this.a * this.C_x * lon * (this.m + Math.cos(lat));
+ y = this.a * this.C_y * lat;
+
+ }
+ else {
+
+ var s = Math.sin(lat);
+ var c = Math.cos(lat);
+ y = this.a * pj_mlfn(lat, s, c, this.en);
+ x = this.a * lon * c / Math.sqrt(1 - this.es * s * s);
+ }
+
+ p.x = x;
+ p.y = y;
+ return p;
+};
+
+exports.inverse = function(p) {
+ var lat, temp, lon, s;
+
+ p.x -= this.x0;
+ lon = p.x / this.a;
+ p.y -= this.y0;
+ lat = p.y / this.a;
+
+ if (this.sphere) {
+ lat /= this.C_y;
+ lon = lon / (this.C_x * (this.m + Math.cos(lat)));
+ if (this.m) {
+ lat = asinz((this.m * lat + Math.sin(lat)) / this.n);
+ }
+ else if (this.n !== 1) {
+ lat = asinz(Math.sin(lat) / this.n);
+ }
+ lon = adjust_lon(lon + this.long0);
+ lat = adjust_lat(lat);
+ }
+ else {
+ lat = pj_inv_mlfn(p.y / this.a, this.es, this.en);
+ s = Math.abs(lat);
+ if (s < HALF_PI) {
+ s = Math.sin(lat);
+ temp = this.long0 + p.x * Math.sqrt(1 - this.es * s * s) / (this.a * Math.cos(lat));
+ //temp = this.long0 + p.x / (this.a * Math.cos(lat));
+ lon = adjust_lon(temp);
+ }
+ else if ((s - EPSLN) < HALF_PI) {
+ lon = this.long0;
+ }
+ }
+ p.x = lon;
+ p.y = lat;
+ return p;
+};
+exports.names = ["Sinusoidal", "sinu"];
+},{"../common/adjust_lat":4,"../common/adjust_lon":5,"../common/asinz":6,"../common/pj_enfn":17,"../common/pj_inv_mlfn":18,"../common/pj_mlfn":19}],59:[function(_dereq_,module,exports){
+/*
+ references:
+ Formules et constantes pour le Calcul pour la
+ projection cylindrique conforme à axe oblique et pour la transformation entre
+ des systèmes de référence.
+ http://www.swisstopo.admin.ch/internet/swisstopo/fr/home/topics/survey/sys/refsys/switzerland.parsysrelated1.31216.downloadList.77004.DownloadFile.tmp/swissprojectionfr.pdf
+ */
+exports.init = function() {
+ var phy0 = this.lat0;
+ this.lambda0 = this.long0;
+ var sinPhy0 = Math.sin(phy0);
+ var semiMajorAxis = this.a;
+ var invF = this.rf;
+ var flattening = 1 / invF;
+ var e2 = 2 * flattening - Math.pow(flattening, 2);
+ var e = this.e = Math.sqrt(e2);
+ this.R = this.k0 * semiMajorAxis * Math.sqrt(1 - e2) / (1 - e2 * Math.pow(sinPhy0, 2));
+ this.alpha = Math.sqrt(1 + e2 / (1 - e2) * Math.pow(Math.cos(phy0), 4));
+ this.b0 = Math.asin(sinPhy0 / this.alpha);
+ var k1 = Math.log(Math.tan(Math.PI / 4 + this.b0 / 2));
+ var k2 = Math.log(Math.tan(Math.PI / 4 + phy0 / 2));
+ var k3 = Math.log((1 + e * sinPhy0) / (1 - e * sinPhy0));
+ this.K = k1 - this.alpha * k2 + this.alpha * e / 2 * k3;
+};
+
+
+exports.forward = function(p) {
+ var Sa1 = Math.log(Math.tan(Math.PI / 4 - p.y / 2));
+ var Sa2 = this.e / 2 * Math.log((1 + this.e * Math.sin(p.y)) / (1 - this.e * Math.sin(p.y)));
+ var S = -this.alpha * (Sa1 + Sa2) + this.K;
+
+ // spheric latitude
+ var b = 2 * (Math.atan(Math.exp(S)) - Math.PI / 4);
+
+ // spheric longitude
+ var I = this.alpha * (p.x - this.lambda0);
+
+ // psoeudo equatorial rotation
+ var rotI = Math.atan(Math.sin(I) / (Math.sin(this.b0) * Math.tan(b) + Math.cos(this.b0) * Math.cos(I)));
+
+ var rotB = Math.asin(Math.cos(this.b0) * Math.sin(b) - Math.sin(this.b0) * Math.cos(b) * Math.cos(I));
+
+ p.y = this.R / 2 * Math.log((1 + Math.sin(rotB)) / (1 - Math.sin(rotB))) + this.y0;
+ p.x = this.R * rotI + this.x0;
+ return p;
+};
+
+exports.inverse = function(p) {
+ var Y = p.x - this.x0;
+ var X = p.y - this.y0;
+
+ var rotI = Y / this.R;
+ var rotB = 2 * (Math.atan(Math.exp(X / this.R)) - Math.PI / 4);
+
+ var b = Math.asin(Math.cos(this.b0) * Math.sin(rotB) + Math.sin(this.b0) * Math.cos(rotB) * Math.cos(rotI));
+ var I = Math.atan(Math.sin(rotI) / (Math.cos(this.b0) * Math.cos(rotI) - Math.sin(this.b0) * Math.tan(rotB)));
+
+ var lambda = this.lambda0 + I / this.alpha;
+
+ var S = 0;
+ var phy = b;
+ var prevPhy = -1000;
+ var iteration = 0;
+ while (Math.abs(phy - prevPhy) > 0.0000001) {
+ if (++iteration > 20) {
+ //...reportError("omercFwdInfinity");
+ return;
+ }
+ //S = Math.log(Math.tan(Math.PI / 4 + phy / 2));
+ S = 1 / this.alpha * (Math.log(Math.tan(Math.PI / 4 + b / 2)) - this.K) + this.e * Math.log(Math.tan(Math.PI / 4 + Math.asin(this.e * Math.sin(phy)) / 2));
+ prevPhy = phy;
+ phy = 2 * Math.atan(Math.exp(S)) - Math.PI / 2;
+ }
+
+ p.x = lambda;
+ p.y = phy;
+ return p;
+};
+
+exports.names = ["somerc"];
+
+},{}],60:[function(_dereq_,module,exports){
+var HALF_PI = Math.PI/2;
+var EPSLN = 1.0e-10;
+var sign = _dereq_('../common/sign');
+var msfnz = _dereq_('../common/msfnz');
+var tsfnz = _dereq_('../common/tsfnz');
+var phi2z = _dereq_('../common/phi2z');
+var adjust_lon = _dereq_('../common/adjust_lon');
+exports.ssfn_ = function(phit, sinphi, eccen) {
+ sinphi *= eccen;
+ return (Math.tan(0.5 * (HALF_PI + phit)) * Math.pow((1 - sinphi) / (1 + sinphi), 0.5 * eccen));
+};
+
+exports.init = function() {
+ this.coslat0 = Math.cos(this.lat0);
+ this.sinlat0 = Math.sin(this.lat0);
+ if (this.sphere) {
+ if (this.k0 === 1 && !isNaN(this.lat_ts) && Math.abs(this.coslat0) <= EPSLN) {
+ this.k0 = 0.5 * (1 + sign(this.lat0) * Math.sin(this.lat_ts));
+ }
+ }
+ else {
+ if (Math.abs(this.coslat0) <= EPSLN) {
+ if (this.lat0 > 0) {
+ //North pole
+ //trace('stere:north pole');
+ this.con = 1;
+ }
+ else {
+ //South pole
+ //trace('stere:south pole');
+ this.con = -1;
+ }
+ }
+ this.cons = Math.sqrt(Math.pow(1 + this.e, 1 + this.e) * Math.pow(1 - this.e, 1 - this.e));
+ if (this.k0 === 1 && !isNaN(this.lat_ts) && Math.abs(this.coslat0) <= EPSLN) {
+ this.k0 = 0.5 * this.cons * msfnz(this.e, Math.sin(this.lat_ts), Math.cos(this.lat_ts)) / tsfnz(this.e, this.con * this.lat_ts, this.con * Math.sin(this.lat_ts));
+ }
+ this.ms1 = msfnz(this.e, this.sinlat0, this.coslat0);
+ this.X0 = 2 * Math.atan(this.ssfn_(this.lat0, this.sinlat0, this.e)) - HALF_PI;
+ this.cosX0 = Math.cos(this.X0);
+ this.sinX0 = Math.sin(this.X0);
+ }
+};
+
+// Stereographic forward equations--mapping lat,long to x,y
+exports.forward = function(p) {
+ var lon = p.x;
+ var lat = p.y;
+ var sinlat = Math.sin(lat);
+ var coslat = Math.cos(lat);
+ var A, X, sinX, cosX, ts, rh;
+ var dlon = adjust_lon(lon - this.long0);
+
+ if (Math.abs(Math.abs(lon - this.long0) - Math.PI) <= EPSLN && Math.abs(lat + this.lat0) <= EPSLN) {
+ //case of the origine point
+ //trace('stere:this is the origin point');
+ p.x = NaN;
+ p.y = NaN;
+ return p;
+ }
+ if (this.sphere) {
+ //trace('stere:sphere case');
+ A = 2 * this.k0 / (1 + this.sinlat0 * sinlat + this.coslat0 * coslat * Math.cos(dlon));
+ p.x = this.a * A * coslat * Math.sin(dlon) + this.x0;
+ p.y = this.a * A * (this.coslat0 * sinlat - this.sinlat0 * coslat * Math.cos(dlon)) + this.y0;
+ return p;
+ }
+ else {
+ X = 2 * Math.atan(this.ssfn_(lat, sinlat, this.e)) - HALF_PI;
+ cosX = Math.cos(X);
+ sinX = Math.sin(X);
+ if (Math.abs(this.coslat0) <= EPSLN) {
+ ts = tsfnz(this.e, lat * this.con, this.con * sinlat);
+ rh = 2 * this.a * this.k0 * ts / this.cons;
+ p.x = this.x0 + rh * Math.sin(lon - this.long0);
+ p.y = this.y0 - this.con * rh * Math.cos(lon - this.long0);
+ //trace(p.toString());
+ return p;
+ }
+ else if (Math.abs(this.sinlat0) < EPSLN) {
+ //Eq
+ //trace('stere:equateur');
+ A = 2 * this.a * this.k0 / (1 + cosX * Math.cos(dlon));
+ p.y = A * sinX;
+ }
+ else {
+ //other case
+ //trace('stere:normal case');
+ A = 2 * this.a * this.k0 * this.ms1 / (this.cosX0 * (1 + this.sinX0 * sinX + this.cosX0 * cosX * Math.cos(dlon)));
+ p.y = A * (this.cosX0 * sinX - this.sinX0 * cosX * Math.cos(dlon)) + this.y0;
+ }
+ p.x = A * cosX * Math.sin(dlon) + this.x0;
+ }
+ //trace(p.toString());
+ return p;
+};
+
+
+//* Stereographic inverse equations--mapping x,y to lat/long
+exports.inverse = function(p) {
+ p.x -= this.x0;
+ p.y -= this.y0;
+ var lon, lat, ts, ce, Chi;
+ var rh = Math.sqrt(p.x * p.x + p.y * p.y);
+ if (this.sphere) {
+ var c = 2 * Math.atan(rh / (0.5 * this.a * this.k0));
+ lon = this.long0;
+ lat = this.lat0;
+ if (rh <= EPSLN) {
+ p.x = lon;
+ p.y = lat;
+ return p;
+ }
+ lat = Math.asin(Math.cos(c) * this.sinlat0 + p.y * Math.sin(c) * this.coslat0 / rh);
+ if (Math.abs(this.coslat0) < EPSLN) {
+ if (this.lat0 > 0) {
+ lon = adjust_lon(this.long0 + Math.atan2(p.x, - 1 * p.y));
+ }
+ else {
+ lon = adjust_lon(this.long0 + Math.atan2(p.x, p.y));
+ }
+ }
+ else {
+ lon = adjust_lon(this.long0 + Math.atan2(p.x * Math.sin(c), rh * this.coslat0 * Math.cos(c) - p.y * this.sinlat0 * Math.sin(c)));
+ }
+ p.x = lon;
+ p.y = lat;
+ return p;
+ }
+ else {
+ if (Math.abs(this.coslat0) <= EPSLN) {
+ if (rh <= EPSLN) {
+ lat = this.lat0;
+ lon = this.long0;
+ p.x = lon;
+ p.y = lat;
+ //trace(p.toString());
+ return p;
+ }
+ p.x *= this.con;
+ p.y *= this.con;
+ ts = rh * this.cons / (2 * this.a * this.k0);
+ lat = this.con * phi2z(this.e, ts);
+ lon = this.con * adjust_lon(this.con * this.long0 + Math.atan2(p.x, - 1 * p.y));
+ }
+ else {
+ ce = 2 * Math.atan(rh * this.cosX0 / (2 * this.a * this.k0 * this.ms1));
+ lon = this.long0;
+ if (rh <= EPSLN) {
+ Chi = this.X0;
+ }
+ else {
+ Chi = Math.asin(Math.cos(ce) * this.sinX0 + p.y * Math.sin(ce) * this.cosX0 / rh);
+ lon = adjust_lon(this.long0 + Math.atan2(p.x * Math.sin(ce), rh * this.cosX0 * Math.cos(ce) - p.y * this.sinX0 * Math.sin(ce)));
+ }
+ lat = -1 * phi2z(this.e, Math.tan(0.5 * (HALF_PI + Chi)));
+ }
+ }
+ p.x = lon;
+ p.y = lat;
+
+ //trace(p.toString());
+ return p;
+
+};
+exports.names = ["stere", "Stereographic_South_Pole", "Polar Stereographic (variant B)"];
+
+},{"../common/adjust_lon":5,"../common/msfnz":15,"../common/phi2z":16,"../common/sign":21,"../common/tsfnz":24}],61:[function(_dereq_,module,exports){
+var gauss = _dereq_('./gauss');
+var adjust_lon = _dereq_('../common/adjust_lon');
+exports.init = function() {
+ gauss.init.apply(this);
+ if (!this.rc) {
+ return;
+ }
+ this.sinc0 = Math.sin(this.phic0);
+ this.cosc0 = Math.cos(this.phic0);
+ this.R2 = 2 * this.rc;
+ if (!this.title) {
+ this.title = "Oblique Stereographic Alternative";
+ }
+};
+
+exports.forward = function(p) {
+ var sinc, cosc, cosl, k;
+ p.x = adjust_lon(p.x - this.long0);
+ gauss.forward.apply(this, [p]);
+ sinc = Math.sin(p.y);
+ cosc = Math.cos(p.y);
+ cosl = Math.cos(p.x);
+ k = this.k0 * this.R2 / (1 + this.sinc0 * sinc + this.cosc0 * cosc * cosl);
+ p.x = k * cosc * Math.sin(p.x);
+ p.y = k * (this.cosc0 * sinc - this.sinc0 * cosc * cosl);
+ p.x = this.a * p.x + this.x0;
+ p.y = this.a * p.y + this.y0;
+ return p;
+};
+
+exports.inverse = function(p) {
+ var sinc, cosc, lon, lat, rho;
+ p.x = (p.x - this.x0) / this.a;
+ p.y = (p.y - this.y0) / this.a;
+
+ p.x /= this.k0;
+ p.y /= this.k0;
+ if ((rho = Math.sqrt(p.x * p.x + p.y * p.y))) {
+ var c = 2 * Math.atan2(rho, this.R2);
+ sinc = Math.sin(c);
+ cosc = Math.cos(c);
+ lat = Math.asin(cosc * this.sinc0 + p.y * sinc * this.cosc0 / rho);
+ lon = Math.atan2(p.x * sinc, rho * this.cosc0 * cosc - p.y * this.sinc0 * sinc);
+ }
+ else {
+ lat = this.phic0;
+ lon = 0;
+ }
+
+ p.x = lon;
+ p.y = lat;
+ gauss.inverse.apply(this, [p]);
+ p.x = adjust_lon(p.x + this.long0);
+ return p;
+};
+
+exports.names = ["Stereographic_North_Pole", "Oblique_Stereographic", "Polar_Stereographic", "sterea","Oblique Stereographic Alternative"];
+
+},{"../common/adjust_lon":5,"./gauss":46}],62:[function(_dereq_,module,exports){
+var e0fn = _dereq_('../common/e0fn');
+var e1fn = _dereq_('../common/e1fn');
+var e2fn = _dereq_('../common/e2fn');
+var e3fn = _dereq_('../common/e3fn');
+var mlfn = _dereq_('../common/mlfn');
+var adjust_lon = _dereq_('../common/adjust_lon');
+var HALF_PI = Math.PI/2;
+var EPSLN = 1.0e-10;
+var sign = _dereq_('../common/sign');
+var asinz = _dereq_('../common/asinz');
+
+exports.init = function() {
+ this.e0 = e0fn(this.es);
+ this.e1 = e1fn(this.es);
+ this.e2 = e2fn(this.es);
+ this.e3 = e3fn(this.es);
+ this.ml0 = this.a * mlfn(this.e0, this.e1, this.e2, this.e3, this.lat0);
+};
+
+/**
+ Transverse Mercator Forward - long/lat to x/y
+ long/lat in radians
+ */
+exports.forward = function(p) {
+ var lon = p.x;
+ var lat = p.y;
+
+ var delta_lon = adjust_lon(lon - this.long0);
+ var con;
+ var x, y;
+ var sin_phi = Math.sin(lat);
+ var cos_phi = Math.cos(lat);
+
+ if (this.sphere) {
+ var b = cos_phi * Math.sin(delta_lon);
+ if ((Math.abs(Math.abs(b) - 1)) < 0.0000000001) {
+ return (93);
+ }
+ else {
+ x = 0.5 * this.a * this.k0 * Math.log((1 + b) / (1 - b));
+ con = Math.acos(cos_phi * Math.cos(delta_lon) / Math.sqrt(1 - b * b));
+ if (lat < 0) {
+ con = -con;
+ }
+ y = this.a * this.k0 * (con - this.lat0);
+ }
+ }
+ else {
+ var al = cos_phi * delta_lon;
+ var als = Math.pow(al, 2);
+ var c = this.ep2 * Math.pow(cos_phi, 2);
+ var tq = Math.tan(lat);
+ var t = Math.pow(tq, 2);
+ con = 1 - this.es * Math.pow(sin_phi, 2);
+ var n = this.a / Math.sqrt(con);
+ var ml = this.a * mlfn(this.e0, this.e1, this.e2, this.e3, lat);
+
+ x = this.k0 * n * al * (1 + als / 6 * (1 - t + c + als / 20 * (5 - 18 * t + Math.pow(t, 2) + 72 * c - 58 * this.ep2))) + this.x0;
+ y = this.k0 * (ml - this.ml0 + n * tq * (als * (0.5 + als / 24 * (5 - t + 9 * c + 4 * Math.pow(c, 2) + als / 30 * (61 - 58 * t + Math.pow(t, 2) + 600 * c - 330 * this.ep2))))) + this.y0;
+
+ }
+ p.x = x;
+ p.y = y;
+ return p;
+};
+
+/**
+ Transverse Mercator Inverse - x/y to long/lat
+ */
+exports.inverse = function(p) {
+ var con, phi;
+ var delta_phi;
+ var i;
+ var max_iter = 6;
+ var lat, lon;
+
+ if (this.sphere) {
+ var f = Math.exp(p.x / (this.a * this.k0));
+ var g = 0.5 * (f - 1 / f);
+ var temp = this.lat0 + p.y / (this.a * this.k0);
+ var h = Math.cos(temp);
+ con = Math.sqrt((1 - h * h) / (1 + g * g));
+ lat = asinz(con);
+ if (temp < 0) {
+ lat = -lat;
+ }
+ if ((g === 0) && (h === 0)) {
+ lon = this.long0;
+ }
+ else {
+ lon = adjust_lon(Math.atan2(g, h) + this.long0);
+ }
+ }
+ else { // ellipsoidal form
+ var x = p.x - this.x0;
+ var y = p.y - this.y0;
+
+ con = (this.ml0 + y / this.k0) / this.a;
+ phi = con;
+ for (i = 0; true; i++) {
+ delta_phi = ((con + this.e1 * Math.sin(2 * phi) - this.e2 * Math.sin(4 * phi) + this.e3 * Math.sin(6 * phi)) / this.e0) - phi;
+ phi += delta_phi;
+ if (Math.abs(delta_phi) <= EPSLN) {
+ break;
+ }
+ if (i >= max_iter) {
+ return (95);
+ }
+ } // for()
+ if (Math.abs(phi) < HALF_PI) {
+ var sin_phi = Math.sin(phi);
+ var cos_phi = Math.cos(phi);
+ var tan_phi = Math.tan(phi);
+ var c = this.ep2 * Math.pow(cos_phi, 2);
+ var cs = Math.pow(c, 2);
+ var t = Math.pow(tan_phi, 2);
+ var ts = Math.pow(t, 2);
+ con = 1 - this.es * Math.pow(sin_phi, 2);
+ var n = this.a / Math.sqrt(con);
+ var r = n * (1 - this.es) / con;
+ var d = x / (n * this.k0);
+ var ds = Math.pow(d, 2);
+ lat = phi - (n * tan_phi * ds / r) * (0.5 - ds / 24 * (5 + 3 * t + 10 * c - 4 * cs - 9 * this.ep2 - ds / 30 * (61 + 90 * t + 298 * c + 45 * ts - 252 * this.ep2 - 3 * cs)));
+ lon = adjust_lon(this.long0 + (d * (1 - ds / 6 * (1 + 2 * t + c - ds / 20 * (5 - 2 * c + 28 * t - 3 * cs + 8 * this.ep2 + 24 * ts))) / cos_phi));
+ }
+ else {
+ lat = HALF_PI * sign(y);
+ lon = this.long0;
+ }
+ }
+ p.x = lon;
+ p.y = lat;
+ return p;
+};
+exports.names = ["Transverse_Mercator", "Transverse Mercator", "tmerc"];
+
+},{"../common/adjust_lon":5,"../common/asinz":6,"../common/e0fn":7,"../common/e1fn":8,"../common/e2fn":9,"../common/e3fn":10,"../common/mlfn":14,"../common/sign":21}],63:[function(_dereq_,module,exports){
+var D2R = 0.01745329251994329577;
+var tmerc = _dereq_('./tmerc');
+exports.dependsOn = 'tmerc';
+exports.init = function() {
+ if (!this.zone) {
+ return;
+ }
+ this.lat0 = 0;
+ this.long0 = ((6 * Math.abs(this.zone)) - 183) * D2R;
+ this.x0 = 500000;
+ this.y0 = this.utmSouth ? 10000000 : 0;
+ this.k0 = 0.9996;
+
+ tmerc.init.apply(this);
+ this.forward = tmerc.forward;
+ this.inverse = tmerc.inverse;
+};
+exports.names = ["Universal Transverse Mercator System", "utm"];
+
+},{"./tmerc":62}],64:[function(_dereq_,module,exports){
+var adjust_lon = _dereq_('../common/adjust_lon');
+var HALF_PI = Math.PI/2;
+var EPSLN = 1.0e-10;
+var asinz = _dereq_('../common/asinz');
+/* Initialize the Van Der Grinten projection
+ ----------------------------------------*/
+exports.init = function() {
+ //this.R = 6370997; //Radius of earth
+ this.R = this.a;
+};
+
+exports.forward = function(p) {
+
+ var lon = p.x;
+ var lat = p.y;
+
+ /* Forward equations
+ -----------------*/
+ var dlon = adjust_lon(lon - this.long0);
+ var x, y;
+
+ if (Math.abs(lat) <= EPSLN) {
+ x = this.x0 + this.R * dlon;
+ y = this.y0;
+ }
+ var theta = asinz(2 * Math.abs(lat / Math.PI));
+ if ((Math.abs(dlon) <= EPSLN) || (Math.abs(Math.abs(lat) - HALF_PI) <= EPSLN)) {
+ x = this.x0;
+ if (lat >= 0) {
+ y = this.y0 + Math.PI * this.R * Math.tan(0.5 * theta);
+ }
+ else {
+ y = this.y0 + Math.PI * this.R * -Math.tan(0.5 * theta);
+ }
+ // return(OK);
+ }
+ var al = 0.5 * Math.abs((Math.PI / dlon) - (dlon / Math.PI));
+ var asq = al * al;
+ var sinth = Math.sin(theta);
+ var costh = Math.cos(theta);
+
+ var g = costh / (sinth + costh - 1);
+ var gsq = g * g;
+ var m = g * (2 / sinth - 1);
+ var msq = m * m;
+ var con = Math.PI * this.R * (al * (g - msq) + Math.sqrt(asq * (g - msq) * (g - msq) - (msq + asq) * (gsq - msq))) / (msq + asq);
+ if (dlon < 0) {
+ con = -con;
+ }
+ x = this.x0 + con;
+ //con = Math.abs(con / (Math.PI * this.R));
+ var q = asq + g;
+ con = Math.PI * this.R * (m * q - al * Math.sqrt((msq + asq) * (asq + 1) - q * q)) / (msq + asq);
+ if (lat >= 0) {
+ //y = this.y0 + Math.PI * this.R * Math.sqrt(1 - con * con - 2 * al * con);
+ y = this.y0 + con;
+ }
+ else {
+ //y = this.y0 - Math.PI * this.R * Math.sqrt(1 - con * con - 2 * al * con);
+ y = this.y0 - con;
+ }
+ p.x = x;
+ p.y = y;
+ return p;
+};
+
+/* Van Der Grinten inverse equations--mapping x,y to lat/long
+ ---------------------------------------------------------*/
+exports.inverse = function(p) {
+ var lon, lat;
+ var xx, yy, xys, c1, c2, c3;
+ var a1;
+ var m1;
+ var con;
+ var th1;
+ var d;
+
+ /* inverse equations
+ -----------------*/
+ p.x -= this.x0;
+ p.y -= this.y0;
+ con = Math.PI * this.R;
+ xx = p.x / con;
+ yy = p.y / con;
+ xys = xx * xx + yy * yy;
+ c1 = -Math.abs(yy) * (1 + xys);
+ c2 = c1 - 2 * yy * yy + xx * xx;
+ c3 = -2 * c1 + 1 + 2 * yy * yy + xys * xys;
+ d = yy * yy / c3 + (2 * c2 * c2 * c2 / c3 / c3 / c3 - 9 * c1 * c2 / c3 / c3) / 27;
+ a1 = (c1 - c2 * c2 / 3 / c3) / c3;
+ m1 = 2 * Math.sqrt(-a1 / 3);
+ con = ((3 * d) / a1) / m1;
+ if (Math.abs(con) > 1) {
+ if (con >= 0) {
+ con = 1;
+ }
+ else {
+ con = -1;
+ }
+ }
+ th1 = Math.acos(con) / 3;
+ if (p.y >= 0) {
+ lat = (-m1 * Math.cos(th1 + Math.PI / 3) - c2 / 3 / c3) * Math.PI;
+ }
+ else {
+ lat = -(-m1 * Math.cos(th1 + Math.PI / 3) - c2 / 3 / c3) * Math.PI;
+ }
+
+ if (Math.abs(xx) < EPSLN) {
+ lon = this.long0;
+ }
+ else {
+ lon = adjust_lon(this.long0 + Math.PI * (xys - 1 + Math.sqrt(1 + 2 * (xx * xx - yy * yy) + xys * xys)) / 2 / xx);
+ }
+
+ p.x = lon;
+ p.y = lat;
+ return p;
+};
+exports.names = ["Van_der_Grinten_I", "VanDerGrinten", "vandg"];
+},{"../common/adjust_lon":5,"../common/asinz":6}],65:[function(_dereq_,module,exports){
+var D2R = 0.01745329251994329577;
+var R2D = 57.29577951308232088;
+var PJD_3PARAM = 1;
+var PJD_7PARAM = 2;
+var datum_transform = _dereq_('./datum_transform');
+var adjust_axis = _dereq_('./adjust_axis');
+var proj = _dereq_('./Proj');
+var toPoint = _dereq_('./common/toPoint');
+module.exports = function transform(source, dest, point) {
+ var wgs84;
+ if (Array.isArray(point)) {
+ point = toPoint(point);
+ }
+ function checkNotWGS(source, dest) {
+ return ((source.datum.datum_type === PJD_3PARAM || source.datum.datum_type === PJD_7PARAM) && dest.datumCode !== "WGS84");
+ }
+
+ // Workaround for datum shifts towgs84, if either source or destination projection is not wgs84
+ if (source.datum && dest.datum && (checkNotWGS(source, dest) || checkNotWGS(dest, source))) {
+ wgs84 = new proj('WGS84');
+ transform(source, wgs84, point);
+ source = wgs84;
+ }
+ // DGR, 2010/11/12
+ if (source.axis !== "enu") {
+ adjust_axis(source, false, point);
+ }
+ // Transform source points to long/lat, if they aren't already.
+ if (source.projName === "longlat") {
+ point.x *= D2R; // convert degrees to radians
+ point.y *= D2R;
+ }
+ else {
+ if (source.to_meter) {
+ point.x *= source.to_meter;
+ point.y *= source.to_meter;
+ }
+ source.inverse(point); // Convert Cartesian to longlat
+ }
+ // Adjust for the prime meridian if necessary
+ if (source.from_greenwich) {
+ point.x += source.from_greenwich;
+ }
+
+ // Convert datums if needed, and if possible.
+ point = datum_transform(source.datum, dest.datum, point);
+
+ // Adjust for the prime meridian if necessary
+ if (dest.from_greenwich) {
+ point.x -= dest.from_greenwich;
+ }
+
+ if (dest.projName === "longlat") {
+ // convert radians to decimal degrees
+ point.x *= R2D;
+ point.y *= R2D;
+ }
+ else { // else project
+ dest.forward(point);
+ if (dest.to_meter) {
+ point.x /= dest.to_meter;
+ point.y /= dest.to_meter;
+ }
+ }
+
+ // DGR, 2010/11/12
+ if (dest.axis !== "enu") {
+ adjust_axis(dest, true, point);
+ }
+
+ return point;
+};
+},{"./Proj":2,"./adjust_axis":3,"./common/toPoint":23,"./datum_transform":31}],66:[function(_dereq_,module,exports){
+var D2R = 0.01745329251994329577;
+var extend = _dereq_('./extend');
+
+function mapit(obj, key, v) {
+ obj[key] = v.map(function(aa) {
+ var o = {};
+ sExpr(aa, o);
+ return o;
+ }).reduce(function(a, b) {
+ return extend(a, b);
+ }, {});
+}
+
+function sExpr(v, obj) {
+ var key;
+ if (!Array.isArray(v)) {
+ obj[v] = true;
+ return;
+ }
+ else {
+ key = v.shift();
+ if (key === 'PARAMETER') {
+ key = v.shift();
+ }
+ if (v.length === 1) {
+ if (Array.isArray(v[0])) {
+ obj[key] = {};
+ sExpr(v[0], obj[key]);
+ }
+ else {
+ obj[key] = v[0];
+ }
+ }
+ else if (!v.length) {
+ obj[key] = true;
+ }
+ else if (key === 'TOWGS84') {
+ obj[key] = v;
+ }
+ else {
+ obj[key] = {};
+ if (['UNIT', 'PRIMEM', 'VERT_DATUM'].indexOf(key) > -1) {
+ obj[key] = {
+ name: v[0].toLowerCase(),
+ convert: v[1]
+ };
+ if (v.length === 3) {
+ obj[key].auth = v[2];
+ }
+ }
+ else if (key === 'SPHEROID') {
+ obj[key] = {
+ name: v[0],
+ a: v[1],
+ rf: v[2]
+ };
+ if (v.length === 4) {
+ obj[key].auth = v[3];
+ }
+ }
+ else if (['GEOGCS', 'GEOCCS', 'DATUM', 'VERT_CS', 'COMPD_CS', 'LOCAL_CS', 'FITTED_CS', 'LOCAL_DATUM'].indexOf(key) > -1) {
+ v[0] = ['name', v[0]];
+ mapit(obj, key, v);
+ }
+ else if (v.every(function(aa) {
+ return Array.isArray(aa);
+ })) {
+ mapit(obj, key, v);
+ }
+ else {
+ sExpr(v, obj[key]);
+ }
+ }
+ }
+}
+
+function rename(obj, params) {
+ var outName = params[0];
+ var inName = params[1];
+ if (!(outName in obj) && (inName in obj)) {
+ obj[outName] = obj[inName];
+ if (params.length === 3) {
+ obj[outName] = params[2](obj[outName]);
+ }
+ }
+}
+
+function d2r(input) {
+ return input * D2R;
+}
+
+function cleanWKT(wkt) {
+ if (wkt.type === 'GEOGCS') {
+ wkt.projName = 'longlat';
+ }
+ else if (wkt.type === 'LOCAL_CS') {
+ wkt.projName = 'identity';
+ wkt.local = true;
+ }
+ else {
+ if (typeof wkt.PROJECTION === "object") {
+ wkt.projName = Object.keys(wkt.PROJECTION)[0];
+ }
+ else {
+ wkt.projName = wkt.PROJECTION;
+ }
+ }
+ if (wkt.UNIT) {
+ wkt.units = wkt.UNIT.name.toLowerCase();
+ if (wkt.units === 'metre') {
+ wkt.units = 'meter';
+ }
+ if (wkt.UNIT.convert) {
+ if (wkt.type === 'GEOGCS') {
+ if (wkt.DATUM && wkt.DATUM.SPHEROID) {
+ wkt.to_meter = parseFloat(wkt.UNIT.convert, 10)*wkt.DATUM.SPHEROID.a;
+ }
+ } else {
+ wkt.to_meter = parseFloat(wkt.UNIT.convert, 10);
+ }
+ }
+ }
+
+ if (wkt.GEOGCS) {
+ //if(wkt.GEOGCS.PRIMEM&&wkt.GEOGCS.PRIMEM.convert){
+ // wkt.from_greenwich=wkt.GEOGCS.PRIMEM.convert*D2R;
+ //}
+ if (wkt.GEOGCS.DATUM) {
+ wkt.datumCode = wkt.GEOGCS.DATUM.name.toLowerCase();
+ }
+ else {
+ wkt.datumCode = wkt.GEOGCS.name.toLowerCase();
+ }
+ if (wkt.datumCode.slice(0, 2) === 'd_') {
+ wkt.datumCode = wkt.datumCode.slice(2);
+ }
+ if (wkt.datumCode === 'new_zealand_geodetic_datum_1949' || wkt.datumCode === 'new_zealand_1949') {
+ wkt.datumCode = 'nzgd49';
+ }
+ if (wkt.datumCode === "wgs_1984") {
+ if (wkt.PROJECTION === 'Mercator_Auxiliary_Sphere') {
+ wkt.sphere = true;
+ }
+ wkt.datumCode = 'wgs84';
+ }
+ if (wkt.datumCode.slice(-6) === '_ferro') {
+ wkt.datumCode = wkt.datumCode.slice(0, - 6);
+ }
+ if (wkt.datumCode.slice(-8) === '_jakarta') {
+ wkt.datumCode = wkt.datumCode.slice(0, - 8);
+ }
+ if (~wkt.datumCode.indexOf('belge')) {
+ wkt.datumCode = "rnb72";
+ }
+ if (wkt.GEOGCS.DATUM && wkt.GEOGCS.DATUM.SPHEROID) {
+ wkt.ellps = wkt.GEOGCS.DATUM.SPHEROID.name.replace('_19', '').replace(/[Cc]larke\_18/, 'clrk');
+ if (wkt.ellps.toLowerCase().slice(0, 13) === "international") {
+ wkt.ellps = 'intl';
+ }
+
+ wkt.a = wkt.GEOGCS.DATUM.SPHEROID.a;
+ wkt.rf = parseFloat(wkt.GEOGCS.DATUM.SPHEROID.rf, 10);
+ }
+ if (~wkt.datumCode.indexOf('osgb_1936')) {
+ wkt.datumCode = "osgb36";
+ }
+ }
+ if (wkt.b && !isFinite(wkt.b)) {
+ wkt.b = wkt.a;
+ }
+
+ function toMeter(input) {
+ var ratio = wkt.to_meter || 1;
+ return parseFloat(input, 10) * ratio;
+ }
+ var renamer = function(a) {
+ return rename(wkt, a);
+ };
+ var list = [
+ ['standard_parallel_1', 'Standard_Parallel_1'],
+ ['standard_parallel_2', 'Standard_Parallel_2'],
+ ['false_easting', 'False_Easting'],
+ ['false_northing', 'False_Northing'],
+ ['central_meridian', 'Central_Meridian'],
+ ['latitude_of_origin', 'Latitude_Of_Origin'],
+ ['latitude_of_origin', 'Central_Parallel'],
+ ['scale_factor', 'Scale_Factor'],
+ ['k0', 'scale_factor'],
+ ['latitude_of_center', 'Latitude_of_center'],
+ ['lat0', 'latitude_of_center', d2r],
+ ['longitude_of_center', 'Longitude_Of_Center'],
+ ['longc', 'longitude_of_center', d2r],
+ ['x0', 'false_easting', toMeter],
+ ['y0', 'false_northing', toMeter],
+ ['long0', 'central_meridian', d2r],
+ ['lat0', 'latitude_of_origin', d2r],
+ ['lat0', 'standard_parallel_1', d2r],
+ ['lat1', 'standard_parallel_1', d2r],
+ ['lat2', 'standard_parallel_2', d2r],
+ ['alpha', 'azimuth', d2r],
+ ['srsCode', 'name']
+ ];
+ list.forEach(renamer);
+ if (!wkt.long0 && wkt.longc && (wkt.projName === 'Albers_Conic_Equal_Area' || wkt.projName === "Lambert_Azimuthal_Equal_Area")) {
+ wkt.long0 = wkt.longc;
+ }
+ if (!wkt.lat_ts && wkt.lat1 && (wkt.projName === 'Stereographic_South_Pole' || wkt.projName === 'Polar Stereographic (variant B)')) {
+ wkt.lat0 = d2r(wkt.lat1 > 0 ? 90 : -90);
+ wkt.lat_ts = wkt.lat1;
+ }
+}
+module.exports = function(wkt, self) {
+ var lisp = JSON.parse(("," + wkt).replace(/\s*\,\s*([A-Z_0-9]+?)(\[)/g, ',["$1",').slice(1).replace(/\s*\,\s*([A-Z_0-9]+?)\]/g, ',"$1"]').replace(/,\["VERTCS".+/,''));
+ var type = lisp.shift();
+ var name = lisp.shift();
+ lisp.unshift(['name', name]);
+ lisp.unshift(['type', type]);
+ lisp.unshift('output');
+ var obj = {};
+ sExpr(lisp, obj);
+ cleanWKT(obj.output);
+ return extend(self, obj.output);
+};
+
+},{"./extend":34}],67:[function(_dereq_,module,exports){
+
+
+
+/**
+ * UTM zones are grouped, and assigned to one of a group of 6
+ * sets.
+ *
+ * {int} @private
+ */
+var NUM_100K_SETS = 6;
+
+/**
+ * The column letters (for easting) of the lower left value, per
+ * set.
+ *
+ * {string} @private
+ */
+var SET_ORIGIN_COLUMN_LETTERS = 'AJSAJS';
+
+/**
+ * The row letters (for northing) of the lower left value, per
+ * set.
+ *
+ * {string} @private
+ */
+var SET_ORIGIN_ROW_LETTERS = 'AFAFAF';
+
+var A = 65; // A
+var I = 73; // I
+var O = 79; // O
+var V = 86; // V
+var Z = 90; // Z
+
+/**
+ * Conversion of lat/lon to MGRS.
+ *
+ * @param {object} ll Object literal with lat and lon properties on a
+ * WGS84 ellipsoid.
+ * @param {int} accuracy Accuracy in digits (5 for 1 m, 4 for 10 m, 3 for
+ * 100 m, 2 for 1000 m or 1 for 10000 m). Optional, default is 5.
+ * @return {string} the MGRS string for the given location and accuracy.
+ */
+exports.forward = function(ll, accuracy) {
+ accuracy = accuracy || 5; // default accuracy 1m
+ return encode(LLtoUTM({
+ lat: ll[1],
+ lon: ll[0]
+ }), accuracy);
+};
+
+/**
+ * Conversion of MGRS to lat/lon.
+ *
+ * @param {string} mgrs MGRS string.
+ * @return {array} An array with left (longitude), bottom (latitude), right
+ * (longitude) and top (latitude) values in WGS84, representing the
+ * bounding box for the provided MGRS reference.
+ */
+exports.inverse = function(mgrs) {
+ var bbox = UTMtoLL(decode(mgrs.toUpperCase()));
+ if (bbox.lat && bbox.lon) {
+ return [bbox.lon, bbox.lat, bbox.lon, bbox.lat];
+ }
+ return [bbox.left, bbox.bottom, bbox.right, bbox.top];
+};
+
+exports.toPoint = function(mgrs) {
+ var bbox = UTMtoLL(decode(mgrs.toUpperCase()));
+ if (bbox.lat && bbox.lon) {
+ return [bbox.lon, bbox.lat];
+ }
+ return [(bbox.left + bbox.right) / 2, (bbox.top + bbox.bottom) / 2];
+};
+/**
+ * Conversion from degrees to radians.
+ *
+ * @private
+ * @param {number} deg the angle in degrees.
+ * @return {number} the angle in radians.
+ */
+function degToRad(deg) {
+ return (deg * (Math.PI / 180.0));
+}
+
+/**
+ * Conversion from radians to degrees.
+ *
+ * @private
+ * @param {number} rad the angle in radians.
+ * @return {number} the angle in degrees.
+ */
+function radToDeg(rad) {
+ return (180.0 * (rad / Math.PI));
+}
+
+/**
+ * Converts a set of Longitude and Latitude co-ordinates to UTM
+ * using the WGS84 ellipsoid.
+ *
+ * @private
+ * @param {object} ll Object literal with lat and lon properties
+ * representing the WGS84 coordinate to be converted.
+ * @return {object} Object literal containing the UTM value with easting,
+ * northing, zoneNumber and zoneLetter properties, and an optional
+ * accuracy property in digits. Returns null if the conversion failed.
+ */
+function LLtoUTM(ll) {
+ var Lat = ll.lat;
+ var Long = ll.lon;
+ var a = 6378137.0; //ellip.radius;
+ var eccSquared = 0.00669438; //ellip.eccsq;
+ var k0 = 0.9996;
+ var LongOrigin;
+ var eccPrimeSquared;
+ var N, T, C, A, M;
+ var LatRad = degToRad(Lat);
+ var LongRad = degToRad(Long);
+ var LongOriginRad;
+ var ZoneNumber;
+ // (int)
+ ZoneNumber = Math.floor((Long + 180) / 6) + 1;
+
+ //Make sure the longitude 180.00 is in Zone 60
+ if (Long === 180) {
+ ZoneNumber = 60;
+ }
+
+ // Special zone for Norway
+ if (Lat >= 56.0 && Lat < 64.0 && Long >= 3.0 && Long < 12.0) {
+ ZoneNumber = 32;
+ }
+
+ // Special zones for Svalbard
+ if (Lat >= 72.0 && Lat < 84.0) {
+ if (Long >= 0.0 && Long < 9.0) {
+ ZoneNumber = 31;
+ }
+ else if (Long >= 9.0 && Long < 21.0) {
+ ZoneNumber = 33;
+ }
+ else if (Long >= 21.0 && Long < 33.0) {
+ ZoneNumber = 35;
+ }
+ else if (Long >= 33.0 && Long < 42.0) {
+ ZoneNumber = 37;
+ }
+ }
+
+ LongOrigin = (ZoneNumber - 1) * 6 - 180 + 3; //+3 puts origin
+ // in middle of
+ // zone
+ LongOriginRad = degToRad(LongOrigin);
+
+ eccPrimeSquared = (eccSquared) / (1 - eccSquared);
+
+ N = a / Math.sqrt(1 - eccSquared * Math.sin(LatRad) * Math.sin(LatRad));
+ T = Math.tan(LatRad) * Math.tan(LatRad);
+ C = eccPrimeSquared * Math.cos(LatRad) * Math.cos(LatRad);
+ A = Math.cos(LatRad) * (LongRad - LongOriginRad);
+
+ M = a * ((1 - eccSquared / 4 - 3 * eccSquared * eccSquared / 64 - 5 * eccSquared * eccSquared * eccSquared / 256) * LatRad - (3 * eccSquared / 8 + 3 * eccSquared * eccSquared / 32 + 45 * eccSquared * eccSquared * eccSquared / 1024) * Math.sin(2 * LatRad) + (15 * eccSquared * eccSquared / 256 + 45 * eccSquared * eccSquared * eccSquared / 1024) * Math.sin(4 * LatRad) - (35 * eccSquared * eccSquared * eccSquared / 3072) * Math.sin(6 * LatRad));
+
+ var UTMEasting = (k0 * N * (A + (1 - T + C) * A * A * A / 6.0 + (5 - 18 * T + T * T + 72 * C - 58 * eccPrimeSquared) * A * A * A * A * A / 120.0) + 500000.0);
+
+ var UTMNorthing = (k0 * (M + N * Math.tan(LatRad) * (A * A / 2 + (5 - T + 9 * C + 4 * C * C) * A * A * A * A / 24.0 + (61 - 58 * T + T * T + 600 * C - 330 * eccPrimeSquared) * A * A * A * A * A * A / 720.0)));
+ if (Lat < 0.0) {
+ UTMNorthing += 10000000.0; //10000000 meter offset for
+ // southern hemisphere
+ }
+
+ return {
+ northing: Math.round(UTMNorthing),
+ easting: Math.round(UTMEasting),
+ zoneNumber: ZoneNumber,
+ zoneLetter: getLetterDesignator(Lat)
+ };
+}
+
+/**
+ * Converts UTM coords to lat/long, using the WGS84 ellipsoid. This is a convenience
+ * class where the Zone can be specified as a single string eg."60N" which
+ * is then broken down into the ZoneNumber and ZoneLetter.
+ *
+ * @private
+ * @param {object} utm An object literal with northing, easting, zoneNumber
+ * and zoneLetter properties. If an optional accuracy property is
+ * provided (in meters), a bounding box will be returned instead of
+ * latitude and longitude.
+ * @return {object} An object literal containing either lat and lon values
+ * (if no accuracy was provided), or top, right, bottom and left values
+ * for the bounding box calculated according to the provided accuracy.
+ * Returns null if the conversion failed.
+ */
+function UTMtoLL(utm) {
+
+ var UTMNorthing = utm.northing;
+ var UTMEasting = utm.easting;
+ var zoneLetter = utm.zoneLetter;
+ var zoneNumber = utm.zoneNumber;
+ // check the ZoneNummber is valid
+ if (zoneNumber < 0 || zoneNumber > 60) {
+ return null;
+ }
+
+ var k0 = 0.9996;
+ var a = 6378137.0; //ellip.radius;
+ var eccSquared = 0.00669438; //ellip.eccsq;
+ var eccPrimeSquared;
+ var e1 = (1 - Math.sqrt(1 - eccSquared)) / (1 + Math.sqrt(1 - eccSquared));
+ var N1, T1, C1, R1, D, M;
+ var LongOrigin;
+ var mu, phi1Rad;
+
+ // remove 500,000 meter offset for longitude
+ var x = UTMEasting - 500000.0;
+ var y = UTMNorthing;
+
+ // We must know somehow if we are in the Northern or Southern
+ // hemisphere, this is the only time we use the letter So even
+ // if the Zone letter isn't exactly correct it should indicate
+ // the hemisphere correctly
+ if (zoneLetter < 'N') {
+ y -= 10000000.0; // remove 10,000,000 meter offset used
+ // for southern hemisphere
+ }
+
+ // There are 60 zones with zone 1 being at West -180 to -174
+ LongOrigin = (zoneNumber - 1) * 6 - 180 + 3; // +3 puts origin
+ // in middle of
+ // zone
+
+ eccPrimeSquared = (eccSquared) / (1 - eccSquared);
+
+ M = y / k0;
+ mu = M / (a * (1 - eccSquared / 4 - 3 * eccSquared * eccSquared / 64 - 5 * eccSquared * eccSquared * eccSquared / 256));
+
+ phi1Rad = mu + (3 * e1 / 2 - 27 * e1 * e1 * e1 / 32) * Math.sin(2 * mu) + (21 * e1 * e1 / 16 - 55 * e1 * e1 * e1 * e1 / 32) * Math.sin(4 * mu) + (151 * e1 * e1 * e1 / 96) * Math.sin(6 * mu);
+ // double phi1 = ProjMath.radToDeg(phi1Rad);
+
+ N1 = a / Math.sqrt(1 - eccSquared * Math.sin(phi1Rad) * Math.sin(phi1Rad));
+ T1 = Math.tan(phi1Rad) * Math.tan(phi1Rad);
+ C1 = eccPrimeSquared * Math.cos(phi1Rad) * Math.cos(phi1Rad);
+ R1 = a * (1 - eccSquared) / Math.pow(1 - eccSquared * Math.sin(phi1Rad) * Math.sin(phi1Rad), 1.5);
+ D = x / (N1 * k0);
+
+ var lat = phi1Rad - (N1 * Math.tan(phi1Rad) / R1) * (D * D / 2 - (5 + 3 * T1 + 10 * C1 - 4 * C1 * C1 - 9 * eccPrimeSquared) * D * D * D * D / 24 + (61 + 90 * T1 + 298 * C1 + 45 * T1 * T1 - 252 * eccPrimeSquared - 3 * C1 * C1) * D * D * D * D * D * D / 720);
+ lat = radToDeg(lat);
+
+ var lon = (D - (1 + 2 * T1 + C1) * D * D * D / 6 + (5 - 2 * C1 + 28 * T1 - 3 * C1 * C1 + 8 * eccPrimeSquared + 24 * T1 * T1) * D * D * D * D * D / 120) / Math.cos(phi1Rad);
+ lon = LongOrigin + radToDeg(lon);
+
+ var result;
+ if (utm.accuracy) {
+ var topRight = UTMtoLL({
+ northing: utm.northing + utm.accuracy,
+ easting: utm.easting + utm.accuracy,
+ zoneLetter: utm.zoneLetter,
+ zoneNumber: utm.zoneNumber
+ });
+ result = {
+ top: topRight.lat,
+ right: topRight.lon,
+ bottom: lat,
+ left: lon
+ };
+ }
+ else {
+ result = {
+ lat: lat,
+ lon: lon
+ };
+ }
+ return result;
+}
+
+/**
+ * Calculates the MGRS letter designator for the given latitude.
+ *
+ * @private
+ * @param {number} lat The latitude in WGS84 to get the letter designator
+ * for.
+ * @return {char} The letter designator.
+ */
+function getLetterDesignator(lat) {
+ //This is here as an error flag to show that the Latitude is
+ //outside MGRS limits
+ var LetterDesignator = 'Z';
+
+ if ((84 >= lat) && (lat >= 72)) {
+ LetterDesignator = 'X';
+ }
+ else if ((72 > lat) && (lat >= 64)) {
+ LetterDesignator = 'W';
+ }
+ else if ((64 > lat) && (lat >= 56)) {
+ LetterDesignator = 'V';
+ }
+ else if ((56 > lat) && (lat >= 48)) {
+ LetterDesignator = 'U';
+ }
+ else if ((48 > lat) && (lat >= 40)) {
+ LetterDesignator = 'T';
+ }
+ else if ((40 > lat) && (lat >= 32)) {
+ LetterDesignator = 'S';
+ }
+ else if ((32 > lat) && (lat >= 24)) {
+ LetterDesignator = 'R';
+ }
+ else if ((24 > lat) && (lat >= 16)) {
+ LetterDesignator = 'Q';
+ }
+ else if ((16 > lat) && (lat >= 8)) {
+ LetterDesignator = 'P';
+ }
+ else if ((8 > lat) && (lat >= 0)) {
+ LetterDesignator = 'N';
+ }
+ else if ((0 > lat) && (lat >= -8)) {
+ LetterDesignator = 'M';
+ }
+ else if ((-8 > lat) && (lat >= -16)) {
+ LetterDesignator = 'L';
+ }
+ else if ((-16 > lat) && (lat >= -24)) {
+ LetterDesignator = 'K';
+ }
+ else if ((-24 > lat) && (lat >= -32)) {
+ LetterDesignator = 'J';
+ }
+ else if ((-32 > lat) && (lat >= -40)) {
+ LetterDesignator = 'H';
+ }
+ else if ((-40 > lat) && (lat >= -48)) {
+ LetterDesignator = 'G';
+ }
+ else if ((-48 > lat) && (lat >= -56)) {
+ LetterDesignator = 'F';
+ }
+ else if ((-56 > lat) && (lat >= -64)) {
+ LetterDesignator = 'E';
+ }
+ else if ((-64 > lat) && (lat >= -72)) {
+ LetterDesignator = 'D';
+ }
+ else if ((-72 > lat) && (lat >= -80)) {
+ LetterDesignator = 'C';
+ }
+ return LetterDesignator;
+}
+
+/**
+ * Encodes a UTM location as MGRS string.
+ *
+ * @private
+ * @param {object} utm An object literal with easting, northing,
+ * zoneLetter, zoneNumber
+ * @param {number} accuracy Accuracy in digits (1-5).
+ * @return {string} MGRS string for the given UTM location.
+ */
+function encode(utm, accuracy) {
+ // prepend with leading zeroes
+ var seasting = "00000" + utm.easting,
+ snorthing = "00000" + utm.northing;
+
+ return utm.zoneNumber + utm.zoneLetter + get100kID(utm.easting, utm.northing, utm.zoneNumber) + seasting.substr(seasting.length - 5, accuracy) + snorthing.substr(snorthing.length - 5, accuracy);
+}
+
+/**
+ * Get the two letter 100k designator for a given UTM easting,
+ * northing and zone number value.
+ *
+ * @private
+ * @param {number} easting
+ * @param {number} northing
+ * @param {number} zoneNumber
+ * @return the two letter 100k designator for the given UTM location.
+ */
+function get100kID(easting, northing, zoneNumber) {
+ var setParm = get100kSetForZone(zoneNumber);
+ var setColumn = Math.floor(easting / 100000);
+ var setRow = Math.floor(northing / 100000) % 20;
+ return getLetter100kID(setColumn, setRow, setParm);
+}
+
+/**
+ * Given a UTM zone number, figure out the MGRS 100K set it is in.
+ *
+ * @private
+ * @param {number} i An UTM zone number.
+ * @return {number} the 100k set the UTM zone is in.
+ */
+function get100kSetForZone(i) {
+ var setParm = i % NUM_100K_SETS;
+ if (setParm === 0) {
+ setParm = NUM_100K_SETS;
+ }
+
+ return setParm;
+}
+
+/**
+ * Get the two-letter MGRS 100k designator given information
+ * translated from the UTM northing, easting and zone number.
+ *
+ * @private
+ * @param {number} column the column index as it relates to the MGRS
+ * 100k set spreadsheet, created from the UTM easting.
+ * Values are 1-8.
+ * @param {number} row the row index as it relates to the MGRS 100k set
+ * spreadsheet, created from the UTM northing value. Values
+ * are from 0-19.
+ * @param {number} parm the set block, as it relates to the MGRS 100k set
+ * spreadsheet, created from the UTM zone. Values are from
+ * 1-60.
+ * @return two letter MGRS 100k code.
+ */
+function getLetter100kID(column, row, parm) {
+ // colOrigin and rowOrigin are the letters at the origin of the set
+ var index = parm - 1;
+ var colOrigin = SET_ORIGIN_COLUMN_LETTERS.charCodeAt(index);
+ var rowOrigin = SET_ORIGIN_ROW_LETTERS.charCodeAt(index);
+
+ // colInt and rowInt are the letters to build to return
+ var colInt = colOrigin + column - 1;
+ var rowInt = rowOrigin + row;
+ var rollover = false;
+
+ if (colInt > Z) {
+ colInt = colInt - Z + A - 1;
+ rollover = true;
+ }
+
+ if (colInt === I || (colOrigin < I && colInt > I) || ((colInt > I || colOrigin < I) && rollover)) {
+ colInt++;
+ }
+
+ if (colInt === O || (colOrigin < O && colInt > O) || ((colInt > O || colOrigin < O) && rollover)) {
+ colInt++;
+
+ if (colInt === I) {
+ colInt++;
+ }
+ }
+
+ if (colInt > Z) {
+ colInt = colInt - Z + A - 1;
+ }
+
+ if (rowInt > V) {
+ rowInt = rowInt - V + A - 1;
+ rollover = true;
+ }
+ else {
+ rollover = false;
+ }
+
+ if (((rowInt === I) || ((rowOrigin < I) && (rowInt > I))) || (((rowInt > I) || (rowOrigin < I)) && rollover)) {
+ rowInt++;
+ }
+
+ if (((rowInt === O) || ((rowOrigin < O) && (rowInt > O))) || (((rowInt > O) || (rowOrigin < O)) && rollover)) {
+ rowInt++;
+
+ if (rowInt === I) {
+ rowInt++;
+ }
+ }
+
+ if (rowInt > V) {
+ rowInt = rowInt - V + A - 1;
+ }
+
+ var twoLetter = String.fromCharCode(colInt) + String.fromCharCode(rowInt);
+ return twoLetter;
+}
+
+/**
+ * Decode the UTM parameters from a MGRS string.
+ *
+ * @private
+ * @param {string} mgrsString an UPPERCASE coordinate string is expected.
+ * @return {object} An object literal with easting, northing, zoneLetter,
+ * zoneNumber and accuracy (in meters) properties.
+ */
+function decode(mgrsString) {
+
+ if (mgrsString && mgrsString.length === 0) {
+ throw ("MGRSPoint coverting from nothing");
+ }
+
+ var length = mgrsString.length;
+
+ var hunK = null;
+ var sb = "";
+ var testChar;
+ var i = 0;
+
+ // get Zone number
+ while (!(/[A-Z]/).test(testChar = mgrsString.charAt(i))) {
+ if (i >= 2) {
+ throw ("MGRSPoint bad conversion from: " + mgrsString);
+ }
+ sb += testChar;
+ i++;
+ }
+
+ var zoneNumber = parseInt(sb, 10);
+
+ if (i === 0 || i + 3 > length) {
+ // A good MGRS string has to be 4-5 digits long,
+ // ##AAA/#AAA at least.
+ throw ("MGRSPoint bad conversion from: " + mgrsString);
+ }
+
+ var zoneLetter = mgrsString.charAt(i++);
+
+ // Should we check the zone letter here? Why not.
+ if (zoneLetter <= 'A' || zoneLetter === 'B' || zoneLetter === 'Y' || zoneLetter >= 'Z' || zoneLetter === 'I' || zoneLetter === 'O') {
+ throw ("MGRSPoint zone letter " + zoneLetter + " not handled: " + mgrsString);
+ }
+
+ hunK = mgrsString.substring(i, i += 2);
+
+ var set = get100kSetForZone(zoneNumber);
+
+ var east100k = getEastingFromChar(hunK.charAt(0), set);
+ var north100k = getNorthingFromChar(hunK.charAt(1), set);
+
+ // We have a bug where the northing may be 2000000 too low.
+ // How
+ // do we know when to roll over?
+
+ while (north100k < getMinNorthing(zoneLetter)) {
+ north100k += 2000000;
+ }
+
+ // calculate the char index for easting/northing separator
+ var remainder = length - i;
+
+ if (remainder % 2 !== 0) {
+ throw ("MGRSPoint has to have an even number \nof digits after the zone letter and two 100km letters - front \nhalf for easting meters, second half for \nnorthing meters" + mgrsString);
+ }
+
+ var sep = remainder / 2;
+
+ var sepEasting = 0.0;
+ var sepNorthing = 0.0;
+ var accuracyBonus, sepEastingString, sepNorthingString, easting, northing;
+ if (sep > 0) {
+ accuracyBonus = 100000.0 / Math.pow(10, sep);
+ sepEastingString = mgrsString.substring(i, i + sep);
+ sepEasting = parseFloat(sepEastingString) * accuracyBonus;
+ sepNorthingString = mgrsString.substring(i + sep);
+ sepNorthing = parseFloat(sepNorthingString) * accuracyBonus;
+ }
+
+ easting = sepEasting + east100k;
+ northing = sepNorthing + north100k;
+
+ return {
+ easting: easting,
+ northing: northing,
+ zoneLetter: zoneLetter,
+ zoneNumber: zoneNumber,
+ accuracy: accuracyBonus
+ };
+}
+
+/**
+ * Given the first letter from a two-letter MGRS 100k zone, and given the
+ * MGRS table set for the zone number, figure out the easting value that
+ * should be added to the other, secondary easting value.
+ *
+ * @private
+ * @param {char} e The first letter from a two-letter MGRS 100´k zone.
+ * @param {number} set The MGRS table set for the zone number.
+ * @return {number} The easting value for the given letter and set.
+ */
+function getEastingFromChar(e, set) {
+ // colOrigin is the letter at the origin of the set for the
+ // column
+ var curCol = SET_ORIGIN_COLUMN_LETTERS.charCodeAt(set - 1);
+ var eastingValue = 100000.0;
+ var rewindMarker = false;
+
+ while (curCol !== e.charCodeAt(0)) {
+ curCol++;
+ if (curCol === I) {
+ curCol++;
+ }
+ if (curCol === O) {
+ curCol++;
+ }
+ if (curCol > Z) {
+ if (rewindMarker) {
+ throw ("Bad character: " + e);
+ }
+ curCol = A;
+ rewindMarker = true;
+ }
+ eastingValue += 100000.0;
+ }
+
+ return eastingValue;
+}
+
+/**
+ * Given the second letter from a two-letter MGRS 100k zone, and given the
+ * MGRS table set for the zone number, figure out the northing value that
+ * should be added to the other, secondary northing value. You have to
+ * remember that Northings are determined from the equator, and the vertical
+ * cycle of letters mean a 2000000 additional northing meters. This happens
+ * approx. every 18 degrees of latitude. This method does *NOT* count any
+ * additional northings. You have to figure out how many 2000000 meters need
+ * to be added for the zone letter of the MGRS coordinate.
+ *
+ * @private
+ * @param {char} n Second letter of the MGRS 100k zone
+ * @param {number} set The MGRS table set number, which is dependent on the
+ * UTM zone number.
+ * @return {number} The northing value for the given letter and set.
+ */
+function getNorthingFromChar(n, set) {
+
+ if (n > 'V') {
+ throw ("MGRSPoint given invalid Northing " + n);
+ }
+
+ // rowOrigin is the letter at the origin of the set for the
+ // column
+ var curRow = SET_ORIGIN_ROW_LETTERS.charCodeAt(set - 1);
+ var northingValue = 0.0;
+ var rewindMarker = false;
+
+ while (curRow !== n.charCodeAt(0)) {
+ curRow++;
+ if (curRow === I) {
+ curRow++;
+ }
+ if (curRow === O) {
+ curRow++;
+ }
+ // fixing a bug making whole application hang in this loop
+ // when 'n' is a wrong character
+ if (curRow > V) {
+ if (rewindMarker) { // making sure that this loop ends
+ throw ("Bad character: " + n);
+ }
+ curRow = A;
+ rewindMarker = true;
+ }
+ northingValue += 100000.0;
+ }
+
+ return northingValue;
+}
+
+/**
+ * The function getMinNorthing returns the minimum northing value of a MGRS
+ * zone.
+ *
+ * Ported from Geotrans' c Lattitude_Band_Value structure table.
+ *
+ * @private
+ * @param {char} zoneLetter The MGRS zone to get the min northing for.
+ * @return {number}
+ */
+function getMinNorthing(zoneLetter) {
+ var northing;
+ switch (zoneLetter) {
+ case 'C':
+ northing = 1100000.0;
+ break;
+ case 'D':
+ northing = 2000000.0;
+ break;
+ case 'E':
+ northing = 2800000.0;
+ break;
+ case 'F':
+ northing = 3700000.0;
+ break;
+ case 'G':
+ northing = 4600000.0;
+ break;
+ case 'H':
+ northing = 5500000.0;
+ break;
+ case 'J':
+ northing = 6400000.0;
+ break;
+ case 'K':
+ northing = 7300000.0;
+ break;
+ case 'L':
+ northing = 8200000.0;
+ break;
+ case 'M':
+ northing = 9100000.0;
+ break;
+ case 'N':
+ northing = 0.0;
+ break;
+ case 'P':
+ northing = 800000.0;
+ break;
+ case 'Q':
+ northing = 1700000.0;
+ break;
+ case 'R':
+ northing = 2600000.0;
+ break;
+ case 'S':
+ northing = 3500000.0;
+ break;
+ case 'T':
+ northing = 4400000.0;
+ break;
+ case 'U':
+ northing = 5300000.0;
+ break;
+ case 'V':
+ northing = 6200000.0;
+ break;
+ case 'W':
+ northing = 7000000.0;
+ break;
+ case 'X':
+ northing = 7900000.0;
+ break;
+ default:
+ northing = -1.0;
+ }
+ if (northing >= 0.0) {
+ return northing;
+ }
+ else {
+ throw ("Invalid zone letter: " + zoneLetter);
+ }
+
+}
+
+},{}],68:[function(_dereq_,module,exports){
+module.exports={
+ "name": "proj4",
+ "version": "2.3.14",
+ "description": "Proj4js is a JavaScript library to transform point coordinates from one coordinate system to another, including datum transformations.",
+ "main": "lib/index.js",
+ "directories": {
+ "test": "test",
+ "doc": "docs"
+ },
+ "scripts": {
+ "test": "./node_modules/istanbul/lib/cli.js test ./node_modules/mocha/bin/_mocha test/test.js"
+ },
+ "repository": {
+ "type": "git",
+ "url": "git://github.com/proj4js/proj4js.git"
+ },
+ "author": "",
+ "license": "MIT",
+ "jam": {
+ "main": "dist/proj4.js",
+ "include": [
+ "dist/proj4.js",
+ "README.md",
+ "AUTHORS",
+ "LICENSE.md"
+ ]
+ },
+ "devDependencies": {
+ "grunt-cli": "~0.1.13",
+ "grunt": "~0.4.2",
+ "grunt-contrib-connect": "~0.6.0",
+ "grunt-contrib-jshint": "~0.8.0",
+ "chai": "~1.8.1",
+ "mocha": "~1.17.1",
+ "grunt-mocha-phantomjs": "~0.4.0",
+ "browserify": "~12.0.1",
+ "grunt-browserify": "~4.0.1",
+ "grunt-contrib-uglify": "~0.11.1",
+ "curl": "git://github.com/cujojs/curl.git",
+ "istanbul": "~0.2.4",
+ "tin": "~0.4.0"
+ },
+ "dependencies": {
+ "mgrs": "~0.0.2"
+ }
+}
+},{}],"./includedProjections":[function(_dereq_,module,exports){
+module.exports=_dereq_('hTEDpn');
+},{}],"hTEDpn":[function(_dereq_,module,exports){
+var projs = [
+ _dereq_('./lib/projections/tmerc'),
+ _dereq_('./lib/projections/utm'),
+ _dereq_('./lib/projections/sterea'),
+ _dereq_('./lib/projections/stere'),
+ _dereq_('./lib/projections/somerc'),
+ _dereq_('./lib/projections/omerc'),
+ _dereq_('./lib/projections/lcc'),
+ _dereq_('./lib/projections/krovak'),
+ _dereq_('./lib/projections/cass'),
+ _dereq_('./lib/projections/laea'),
+ _dereq_('./lib/projections/aea'),
+ _dereq_('./lib/projections/gnom'),
+ _dereq_('./lib/projections/cea'),
+ _dereq_('./lib/projections/eqc'),
+ _dereq_('./lib/projections/poly'),
+ _dereq_('./lib/projections/nzmg'),
+ _dereq_('./lib/projections/mill'),
+ _dereq_('./lib/projections/sinu'),
+ _dereq_('./lib/projections/moll'),
+ _dereq_('./lib/projections/eqdc'),
+ _dereq_('./lib/projections/vandg'),
+ _dereq_('./lib/projections/aeqd')
+];
+module.exports = function(proj4){
+ projs.forEach(function(proj){
+ proj4.Proj.projections.add(proj);
+ });
+}
+},{"./lib/projections/aea":40,"./lib/projections/aeqd":41,"./lib/projections/cass":42,"./lib/projections/cea":43,"./lib/projections/eqc":44,"./lib/projections/eqdc":45,"./lib/projections/gnom":47,"./lib/projections/krovak":48,"./lib/projections/laea":49,"./lib/projections/lcc":50,"./lib/projections/mill":53,"./lib/projections/moll":54,"./lib/projections/nzmg":55,"./lib/projections/omerc":56,"./lib/projections/poly":57,"./lib/projections/sinu":58,"./lib/projections/somerc":59,"./lib/projections/stere":60,"./lib/projections/sterea":61,"./lib/projections/tmerc":62,"./lib/projections/utm":63,"./lib/projections/vandg":64}]},{},[36])
+(36)
+});
\ No newline at end of file
diff --git a/sandbox/lines-polygons/leaflet/Proj4Leaflet-1.0.1/package.json b/sandbox/lines-polygons/leaflet/Proj4Leaflet-1.0.1/package.json
new file mode 100644
index 0000000..4cf9bbb
--- /dev/null
+++ b/sandbox/lines-polygons/leaflet/Proj4Leaflet-1.0.1/package.json
@@ -0,0 +1,57 @@
+{
+ "name": "proj4leaflet",
+ "version": "1.0.1",
+ "description": "Smooth Proj4js integration with Leaflet",
+ "main": "src/proj4leaflet.js",
+ "directories": {
+ "test": "test",
+ "example": "examples"
+ },
+ "scripts": {
+ "test": "mocha-phantomjs test/mocha.html"
+ },
+ "repository": {
+ "type": "git",
+ "url": "git://github.com/kartena/Proj4Leaflet.git"
+ },
+ "keywords": [
+ "maps",
+ "proj4",
+ "projection",
+ "leaflet"
+ ],
+ "author": "Per Liedman (https://github.com/perliedman/)",
+ "contributors": [
+ "Peter Thorin (https://github.com/pthorin/)",
+ "Semone Kallin Thander (https://github.com/semone/)",
+ "S. Andrew Sheppard (https://github.com/sheppard)",
+ "Leigh Hunt (https://github.com/leighghunt/)",
+ "Andris Nolendorfs (https://github.com/theashyster)",
+ "Vladimir Agafonkin (https://github.com/mourner)",
+ "Juuso Lehtinen (https://github.com/jleh)",
+ "Mattias Bengtsson (https://github.com/moonlite/)",
+ "Denis Rykov (http://github.com/drnextgis) ",
+ "Jose manuel Vivó Arnal (Chema) (http://github.com/jmvivo) ",
+ "Daniel Garcia (http://github.com/keyjote) ",
+ "Mathieu Leplatre (https://github.com/leplatrem)",
+ "Benny Lichtner (http://github.com/bennlich) ",
+ "Christopher Fredén (https://github.com/icetan/)",
+ "dpzaba (http://github.com/dpzaba) ",
+ "Edward Mac Gillavry (http://github.com/emacgillavry) ",
+ "Emil Goude (http://github.com/Stockholmsnovis) ",
+ "Simon Legner (http://github.com/simon04) ",
+ "Tom Blackmore (http://github.com/tablackmore) ",
+ "Fabien NICOLLET (https://github.com/fnicollet)"
+ ],
+ "license": "BSD-2-Clause",
+ "bugs": {
+ "url": "https://github.com/kartena/Proj4Leaflet/issues"
+ },
+ "dependencies": {
+ "proj4": "^2.3.14"
+ },
+ "devDependencies": {
+ "mocha": "^3.2.0",
+ "mocha-phantomjs": "^4.1.0"
+ }
+}
diff --git a/sandbox/lines-polygons/leaflet/Proj4Leaflet-1.0.1/src/proj4leaflet.js b/sandbox/lines-polygons/leaflet/Proj4Leaflet-1.0.1/src/proj4leaflet.js
new file mode 100644
index 0000000..0a550b0
--- /dev/null
+++ b/sandbox/lines-polygons/leaflet/Proj4Leaflet-1.0.1/src/proj4leaflet.js
@@ -0,0 +1,263 @@
+(function (factory) {
+ var L, proj4;
+ if (typeof define === 'function' && define.amd) {
+ // AMD
+ define(['leaflet', 'proj4'], factory);
+ } else if (typeof module === 'object' && typeof module.exports === "object") {
+ // Node/CommonJS
+ L = require('leaflet');
+ proj4 = require('proj4');
+ module.exports = factory(L, proj4);
+ } else {
+ // Browser globals
+ if (typeof window.L === 'undefined' || typeof window.proj4 === 'undefined')
+ throw 'Leaflet and proj4 must be loaded first';
+ factory(window.L, window.proj4);
+ }
+}(function (L, proj4) {
+
+ L.Proj = {};
+
+ L.Proj._isProj4Obj = function(a) {
+ return (typeof a.inverse !== 'undefined' &&
+ typeof a.forward !== 'undefined');
+ };
+
+ L.Proj.Projection = L.Class.extend({
+ initialize: function(code, def, bounds) {
+ var isP4 = L.Proj._isProj4Obj(code);
+ this._proj = isP4 ? code : this._projFromCodeDef(code, def);
+ this.bounds = isP4 ? def : bounds;
+ },
+
+ project: function (latlng) {
+ var point = this._proj.forward([latlng.lng, latlng.lat]);
+ return new L.Point(point[0], point[1]);
+ },
+
+ unproject: function (point, unbounded) {
+ var point2 = this._proj.inverse([point.x, point.y]);
+ return new L.LatLng(point2[1], point2[0], unbounded);
+ },
+
+ _projFromCodeDef: function(code, def) {
+ if (def) {
+ proj4.defs(code, def);
+ } else if (proj4.defs[code] === undefined) {
+ var urn = code.split(':');
+ if (urn.length > 3) {
+ code = urn[urn.length - 3] + ':' + urn[urn.length - 1];
+ }
+ if (proj4.defs[code] === undefined) {
+ throw 'No projection definition for code ' + code;
+ }
+ }
+
+ return proj4(code);
+ }
+ });
+
+ L.Proj.CRS = L.Class.extend({
+ includes: L.CRS,
+
+ options: {
+ transformation: new L.Transformation(1, 0, -1, 0)
+ },
+
+ initialize: function(a, b, c) {
+ var code,
+ proj,
+ def,
+ options;
+
+ if (L.Proj._isProj4Obj(a)) {
+ proj = a;
+ code = proj.srsCode;
+ options = b || {};
+
+ this.projection = new L.Proj.Projection(proj, options.bounds);
+ } else {
+ code = a;
+ def = b;
+ options = c || {};
+ this.projection = new L.Proj.Projection(code, def, options.bounds);
+ }
+
+ L.Util.setOptions(this, options);
+ this.code = code;
+ this.transformation = this.options.transformation;
+
+ if (this.options.origin) {
+ this.transformation =
+ new L.Transformation(1, -this.options.origin[0],
+ -1, this.options.origin[1]);
+ }
+
+ if (this.options.scales) {
+ this._scales = this.options.scales;
+ } else if (this.options.resolutions) {
+ this._scales = [];
+ for (var i = this.options.resolutions.length - 1; i >= 0; i--) {
+ if (this.options.resolutions[i]) {
+ this._scales[i] = 1 / this.options.resolutions[i];
+ }
+ }
+ }
+
+ this.infinite = !this.options.bounds;
+
+ },
+
+ scale: function(zoom) {
+ var iZoom = Math.floor(zoom),
+ baseScale,
+ nextScale,
+ scaleDiff,
+ zDiff;
+ if (zoom === iZoom) {
+ return this._scales[zoom];
+ } else {
+ // Non-integer zoom, interpolate
+ baseScale = this._scales[iZoom];
+ nextScale = this._scales[iZoom + 1];
+ scaleDiff = nextScale - baseScale;
+ zDiff = (zoom - iZoom);
+ return baseScale + scaleDiff * zDiff;
+ }
+ },
+
+ zoom: function(scale) {
+ // Find closest number in this._scales, down
+ var downScale = this._closestElement(this._scales, scale),
+ downZoom = this._scales.indexOf(downScale),
+ nextScale,
+ nextZoom,
+ scaleDiff;
+ // Check if scale is downScale => return array index
+ if (scale === downScale) {
+ return downZoom;
+ }
+ // Interpolate
+ nextZoom = downZoom + 1;
+ nextScale = this._scales[nextZoom];
+ if (nextScale === undefined) {
+ return Infinity;
+ }
+ scaleDiff = nextScale - downScale;
+ return (scale - downScale) / scaleDiff + downZoom;
+ },
+
+ distance: L.CRS.Earth.distance,
+
+ R: L.CRS.Earth.R,
+
+ /* Get the closest lowest element in an array */
+ _closestElement: function(array, element) {
+ var low;
+ for (var i = array.length; i--;) {
+ if (array[i] <= element && (low === undefined || low < array[i])) {
+ low = array[i];
+ }
+ }
+ return low;
+ }
+ });
+
+ L.Proj.GeoJSON = L.GeoJSON.extend({
+ initialize: function(geojson, options) {
+ this._callLevel = 0;
+ L.GeoJSON.prototype.initialize.call(this, geojson, options);
+ },
+
+ addData: function(geojson) {
+ var crs;
+
+ if (geojson) {
+ if (geojson.crs && geojson.crs.type === 'name') {
+ crs = new L.Proj.CRS(geojson.crs.properties.name);
+ } else if (geojson.crs && geojson.crs.type) {
+ crs = new L.Proj.CRS(geojson.crs.type + ':' + geojson.crs.properties.code);
+ }
+
+ if (crs !== undefined) {
+ this.options.coordsToLatLng = function(coords) {
+ var point = L.point(coords[0], coords[1]);
+ return crs.projection.unproject(point);
+ };
+ }
+ }
+
+ // Base class' addData might call us recursively, but
+ // CRS shouldn't be cleared in that case, since CRS applies
+ // to the whole GeoJSON, inluding sub-features.
+ this._callLevel++;
+ try {
+ L.GeoJSON.prototype.addData.call(this, geojson);
+ } finally {
+ this._callLevel--;
+ if (this._callLevel === 0) {
+ delete this.options.coordsToLatLng;
+ }
+ }
+ }
+ });
+
+ L.Proj.geoJson = function(geojson, options) {
+ return new L.Proj.GeoJSON(geojson, options);
+ };
+
+ L.Proj.ImageOverlay = L.ImageOverlay.extend({
+ initialize: function (url, bounds, options) {
+ L.ImageOverlay.prototype.initialize.call(this, url, null, options);
+ this._projectedBounds = bounds;
+ },
+
+ // Danger ahead: Overriding internal methods in Leaflet.
+ // Decided to do this rather than making a copy of L.ImageOverlay
+ // and doing very tiny modifications to it.
+ // Future will tell if this was wise or not.
+ _animateZoom: function (event) {
+ var scale = this._map.getZoomScale(event.zoom);
+ var northWest = L.point(this._projectedBounds.min.x, this._projectedBounds.max.y);
+ var offset = this._projectedToNewLayerPoint(northWest, event.zoom, event.center);
+
+ L.DomUtil.setTransform(this._image, offset, scale);
+ },
+
+ _reset: function () {
+ var zoom = this._map.getZoom();
+ var pixelOrigin = this._map.getPixelOrigin();
+ var bounds = L.bounds(
+ this._transform(this._projectedBounds.min, zoom)._subtract(pixelOrigin),
+ this._transform(this._projectedBounds.max, zoom)._subtract(pixelOrigin)
+ );
+ var size = bounds.getSize();
+
+ L.DomUtil.setPosition(this._image, bounds.min);
+ this._image.style.width = size.x + 'px';
+ this._image.style.height = size.y + 'px';
+ },
+
+ _projectedToNewLayerPoint: function (point, zoom, center) {
+ var viewHalf = this._map.getSize()._divideBy(2);
+ var newTopLeft = this._map.project(center, zoom)._subtract(viewHalf)._round();
+ var topLeft = newTopLeft.add(this._map._getMapPanePos());
+
+ return this._transform(point, zoom)._subtract(topLeft);
+ },
+
+ _transform: function (point, zoom) {
+ var crs = this._map.options.crs;
+ var transformation = crs.transformation;
+ var scale = crs.scale(zoom);
+
+ return transformation.transform(point, scale);
+ }
+ });
+
+ L.Proj.imageOverlay = function (url, bounds, options) {
+ return new L.Proj.ImageOverlay(url, bounds, options);
+ };
+
+ return L.Proj;
+}));
diff --git a/sandbox/lines-polygons/leaflet/Proj4Leaflet-1.0.1/test/mocha.html b/sandbox/lines-polygons/leaflet/Proj4Leaflet-1.0.1/test/mocha.html
new file mode 100644
index 0000000..2a487c3
--- /dev/null
+++ b/sandbox/lines-polygons/leaflet/Proj4Leaflet-1.0.1/test/mocha.html
@@ -0,0 +1,29 @@
+
+ Mocha Tests
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ 
';
+
+L.tileLayer(
+ 'https://otile{s}.mqcdn.com/tiles/1.0.0/map/{z}/{x}/{y}.png',
+ {
+ attribution: 'Data by OpenStreetMap contributors'
+ }
+)
+.addTo(map);
+
+// GeoJSON layer (UTM15)
+proj4.defs('EPSG:26915', '+proj=utm +zone=15 +ellps=GRS80 +datum=NAD83 +units=m +no_defs');
+
+var geojson = {
+ 'type': 'Feature',
+ 'geometry': {
+ 'type': 'Point',
+ 'coordinates': [481650, 4980105],
+ },
+ 'properties': {
+ 'name': 'University of Minnesota'
+ },
+ 'crs': {
+ 'type': 'name',
+ 'properties': {
+ 'name': 'urn:ogc:def:crs:EPSG::26915'
+ }
+ }
+ };
+
+L.Proj.geoJson(geojson, {
+ 'pointToLayer': function(feature, latlng) {
+ return L.marker(latlng).bindPopup(feature.properties.name);
+ }
+}).addTo(map);
diff --git a/sandbox/lines-polygons/leaflet/Proj4Leaflet-1.0.1/examples/geojson-crs/style.css b/sandbox/lines-polygons/leaflet/Proj4Leaflet-1.0.1/examples/geojson-crs/style.css
new file mode 100644
index 0000000..01d5be9
--- /dev/null
+++ b/sandbox/lines-polygons/leaflet/Proj4Leaflet-1.0.1/examples/geojson-crs/style.css
@@ -0,0 +1,10 @@
+html, body {
+ height: 100%;
+ padding: 0;
+ margin: 0;
+}
+
+#map {
+ width: 100%;
+ height: 100%;
+}
diff --git a/sandbox/lines-polygons/leaflet/Proj4Leaflet-1.0.1/examples/image-overlay/index.html b/sandbox/lines-polygons/leaflet/Proj4Leaflet-1.0.1/examples/image-overlay/index.html
new file mode 100644
index 0000000..0e03bd3
--- /dev/null
+++ b/sandbox/lines-polygons/leaflet/Proj4Leaflet-1.0.1/examples/image-overlay/index.html
@@ -0,0 +1,15 @@
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
diff --git a/sandbox/lines-polygons/leaflet/Proj4Leaflet-1.0.1/examples/image-overlay/script.js b/sandbox/lines-polygons/leaflet/Proj4Leaflet-1.0.1/examples/image-overlay/script.js
new file mode 100644
index 0000000..c4c5344
--- /dev/null
+++ b/sandbox/lines-polygons/leaflet/Proj4Leaflet-1.0.1/examples/image-overlay/script.js
@@ -0,0 +1,20 @@
+var crs = new L.Proj.CRS('EPSG:25833', '+proj=utm +zone=33 +ellps=GRS80 +units=m +no_defs', {
+ resolutions: [21674.7100160867, 10837.35500804335, 5418.677504021675, 2709.3387520108377, 1354.6693760054188, 677.3346880027094,
+ 338.6673440013547, 169.33367200067735, 84.66683600033868, 42.33341800016934, 21.16670900008467, 10.583354500042335,
+ 5.291677250021167, 2.6458386250105836, 1.3229193125052918, 0.6614596562526459, 0.33072982812632296, 0.16536491406316148],
+ origin: [-2500000, 9045984]
+ }
+);
+
+var map = L.map('map', {
+ crs: crs,
+ center: [60, 10],
+ zoom: 14
+});
+
+L.tileLayer('https://services.geodataonline.no/arcgis/rest/services/Geocache_UTM33_EUREF89/GeocacheBasis/MapServer/tile/{z}/{y}/{x}').addTo(map);
+
+L.Proj.imageOverlay('https://services.geodataonline.no/arcgis/rest/services/Geocache_UTM33_EUREF89/GeocacheGraatone/MapServer/export' +
+ '?bbox=220461.84450009145,6661489.40861154,222115.49415195954,6662415.4521056535' +
+ '&size=1250,700&dpi=96&format=png24&transparent=true&bboxSR=25833&imageSR=25833&f=image',
+ L.bounds([220461.84450009145, 6661489.40861154], [222115.49415195954, 6662415.4521056535])).addTo(map);
diff --git a/sandbox/lines-polygons/leaflet/Proj4Leaflet-1.0.1/examples/image-overlay/style.css b/sandbox/lines-polygons/leaflet/Proj4Leaflet-1.0.1/examples/image-overlay/style.css
new file mode 100644
index 0000000..5896443
--- /dev/null
+++ b/sandbox/lines-polygons/leaflet/Proj4Leaflet-1.0.1/examples/image-overlay/style.css
@@ -0,0 +1,10 @@
+html, body {
+ height: 100%;
+ padding: 0;
+ margin: 0;
+}
+
+#map {
+ width: 100%;
+ height: 100%;
+}
diff --git a/sandbox/lines-polygons/leaflet/Proj4Leaflet-1.0.1/examples/local-projections/europe/index_austria.html b/sandbox/lines-polygons/leaflet/Proj4Leaflet-1.0.1/examples/local-projections/europe/index_austria.html
new file mode 100644
index 0000000..7591547
--- /dev/null
+++ b/sandbox/lines-polygons/leaflet/Proj4Leaflet-1.0.1/examples/local-projections/europe/index_austria.html
@@ -0,0 +1,15 @@
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
diff --git a/sandbox/lines-polygons/leaflet/Proj4Leaflet-1.0.1/examples/local-projections/europe/script_austria.js b/sandbox/lines-polygons/leaflet/Proj4Leaflet-1.0.1/examples/local-projections/europe/script_austria.js
new file mode 100644
index 0000000..508796b
--- /dev/null
+++ b/sandbox/lines-polygons/leaflet/Proj4Leaflet-1.0.1/examples/local-projections/europe/script_austria.js
@@ -0,0 +1,36 @@
+var crs31258 = new L.Proj.CRS('EPSG::31258',
+ "+proj=tmerc +lat_0=0 +lon_0=13.33333333333333 +k=1 +x_0=450000 +y_0=-5000000 +ellps=bessel +towgs84=577.326,90.129,463.919,5.137,1.474,5.297,2.4232 +units=m +no_defs",
+ {
+ origin: [-5172500.0, 5001000.0],
+ resolutions: [
+ 400.00079375158754,
+ 200.000529167725,
+ 100.0002645838625,
+ 50,
+ 25,
+ 15.000052916772502,
+ 9.9999470832275,
+ 5.000105833545001,
+ 3.0001164168995005,
+ 2.5000529167725003,
+ 1.9999894166455001,
+ 1.4999259165184997,
+ 1.0001270002540006,
+ 0.5000635001270003,
+ 0.25003175006350015],
+ });
+
+var map = L.map('map', {
+ crs: crs31258,
+});
+var attrib = "© KAGIS http://www.kagis.ktn.gv.at";
+var basemap = new L.TileLayer("http://gis.ktn.gv.at/arcgis/rest/services/tilecache/Ortho_2010_2012/MapServer/tile/{z}/{y}/{x}", {
+ tileSize: 512,
+ maxZoom: 14,
+ minZoom: 0,
+ attribution: attrib
+});
+
+map.addLayer(basemap);
+map.setView([46.66411, 14.63602], 12);
+
diff --git a/sandbox/lines-polygons/leaflet/Proj4Leaflet-1.0.1/examples/local-projections/nz/index_auckland.html b/sandbox/lines-polygons/leaflet/Proj4Leaflet-1.0.1/examples/local-projections/nz/index_auckland.html
new file mode 100644
index 0000000..4a604e6
--- /dev/null
+++ b/sandbox/lines-polygons/leaflet/Proj4Leaflet-1.0.1/examples/local-projections/nz/index_auckland.html
@@ -0,0 +1,15 @@
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
diff --git a/sandbox/lines-polygons/leaflet/Proj4Leaflet-1.0.1/examples/local-projections/nz/index_wellington.html b/sandbox/lines-polygons/leaflet/Proj4Leaflet-1.0.1/examples/local-projections/nz/index_wellington.html
new file mode 100644
index 0000000..525ef5e
--- /dev/null
+++ b/sandbox/lines-polygons/leaflet/Proj4Leaflet-1.0.1/examples/local-projections/nz/index_wellington.html
@@ -0,0 +1,15 @@
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
diff --git a/sandbox/lines-polygons/leaflet/Proj4Leaflet-1.0.1/examples/local-projections/nz/script_auckland.js b/sandbox/lines-polygons/leaflet/Proj4Leaflet-1.0.1/examples/local-projections/nz/script_auckland.js
new file mode 100644
index 0000000..6fc2e18
--- /dev/null
+++ b/sandbox/lines-polygons/leaflet/Proj4Leaflet-1.0.1/examples/local-projections/nz/script_auckland.js
@@ -0,0 +1,35 @@
+var crs = new L.Proj.CRS('EPSG:2193',
+ '+proj=tmerc +lat_0=0 +lon_0=173 +k=0.9996 +x_0=1600000 +y_0=10000000 +ellps=GRS80 +towgs84=0,0,0,0,0,0,0 +units=m +no_defs',
+ {
+ origin: [1565000, 6150000],
+ resolutions: [
+ 264.583862501058,
+ 201.083735500804,
+ 132.291931250529,
+ 66.1459656252646,
+ 26.4583862501058,
+ 13.2291931250529,
+ 6.61459656252646,
+ 3.96875793751588,
+ 2.11667090000847,
+ 1.32291931250529,
+ 0.661459656252646,
+ 0.264583862501058,
+ 0.132291931250529
+ ]
+ });
+
+var map = new L.Map('map', {
+ crs: crs,
+});
+
+var tileUrl = 'https://maps.aucklandcouncil.govt.nz/ArcGIS/rest/services/Aerials/MapServer/tile/{z}/{y}/{x}',
+ attrib = 'Auckland City Council © 2012',
+ tilelayer = new L.TileLayer(tileUrl, {
+ maxZoom: 12,
+ minZoom: 0,
+ attribution: attrib,
+ });
+
+map.addLayer(tilelayer);
+map.setView([-36.852931, 174.762057], 10);
diff --git a/sandbox/lines-polygons/leaflet/Proj4Leaflet-1.0.1/examples/local-projections/nz/script_wellington.js b/sandbox/lines-polygons/leaflet/Proj4Leaflet-1.0.1/examples/local-projections/nz/script_wellington.js
new file mode 100644
index 0000000..62b5e82
--- /dev/null
+++ b/sandbox/lines-polygons/leaflet/Proj4Leaflet-1.0.1/examples/local-projections/nz/script_wellington.js
@@ -0,0 +1,45 @@
+var crs = new L.Proj.CRS('EPSG:2193',
+ '+proj=tmerc +lat_0=0 +lon_0=173 +k=0.9996 +x_0=1600000 +y_0=10000000 +ellps=GRS80 +towgs84=0,0,0,0,0,0,0 +units=m +no_defs',
+ {
+ origin: [-5099531.19635, 57089446.18],
+ resolutions: [
+ 66.1459656252646,
+ 33.0729828126323,
+ 16.933367200067735,
+ 8.466683600033868,
+ 4.233341800016934,
+ 2.116670900008467,
+ 1.0583354500042335,
+ 0.5291677250021167,
+ 0.26458386250105836,
+ 0.13229193125052918,
+ 0.06614596562526459
+ ]
+ });
+
+var map = new L.Map('map', {
+ crs: crs,
+ continuousWorld: true,
+ worldCopyJump: false
+});
+
+/*
+Wellington City Council's GIS web services are available under the following terms and conditions:
+https://wellington.govt.nz/about-wellington/maps/gis-data-terms-and-conditions
+
+Aerial Imagery: Creative Commons Attribution 3.0 New Zealand Licence, https://creativecommons.org/licenses/by/3.0/nz/
+Additional services listed at https://wellington.govt.nz/~/media/maps/gis/ogc-services-list.pdf
+*/
+
+var tileUrl = 'https://gis.wcc.govt.nz/arcgis/rest/services/Basemap/Aerial_Photo/MapServer/tile/{z}/{y}/{x}',
+ attrib = 'Wellington City Council © 2012',
+ tilelayer = new L.TileLayer(tileUrl, {
+ maxZoom: 10,
+ minZoom: 0,
+ continuousWorld: true,
+ attribution: attrib,
+ tileSize: 512
+ });
+
+map.addLayer(tilelayer);
+map.setView([-41.288889, 174.777222], 5);
diff --git a/sandbox/lines-polygons/leaflet/Proj4Leaflet-1.0.1/examples/local-projections/style.css b/sandbox/lines-polygons/leaflet/Proj4Leaflet-1.0.1/examples/local-projections/style.css
new file mode 100644
index 0000000..5896443
--- /dev/null
+++ b/sandbox/lines-polygons/leaflet/Proj4Leaflet-1.0.1/examples/local-projections/style.css
@@ -0,0 +1,10 @@
+html, body {
+ height: 100%;
+ padding: 0;
+ margin: 0;
+}
+
+#map {
+ width: 100%;
+ height: 100%;
+}
diff --git a/sandbox/lines-polygons/leaflet/Proj4Leaflet-1.0.1/examples/osm-tiled/index.html b/sandbox/lines-polygons/leaflet/Proj4Leaflet-1.0.1/examples/osm-tiled/index.html
new file mode 100644
index 0000000..661c90c
--- /dev/null
+++ b/sandbox/lines-polygons/leaflet/Proj4Leaflet-1.0.1/examples/osm-tiled/index.html
@@ -0,0 +1,15 @@
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
diff --git a/sandbox/lines-polygons/leaflet/Proj4Leaflet-1.0.1/examples/osm-tiled/script.js b/sandbox/lines-polygons/leaflet/Proj4Leaflet-1.0.1/examples/osm-tiled/script.js
new file mode 100644
index 0000000..115e5fa
--- /dev/null
+++ b/sandbox/lines-polygons/leaflet/Proj4Leaflet-1.0.1/examples/osm-tiled/script.js
@@ -0,0 +1,21 @@
+var crs = new L.Proj.CRS('EPSG:3006',
+ '+proj=utm +zone=33 +ellps=GRS80 +towgs84=0,0,0,0,0,0,0 +units=m +no_defs',
+ {
+ resolutions: [
+ 8192, 4096, 2048, 1024, 512, 256, 128,
+ 64, 32, 16, 8, 4, 2, 1, 0.5
+ ],
+ origin: [0, 0],
+ bounds: L.bounds([218128.7031, 6126002.9379], [1083427.2970, 7692850.9468])
+ }),
+ map = new L.Map('map', {
+ crs: crs,
+ });
+
+L.tileLayer('https://api.geosition.com/tile/osm-bright-3006/{z}/{x}/{y}.png', {
+ maxZoom: 14,
+ minZoom: 0,
+ attribution: 'Map data © OpenStreetMap contributors, Imagery © Kartena'
+}).addTo(map);
+
+map.setView([57.704, 11.965], 13);
diff --git a/sandbox/lines-polygons/leaflet/Proj4Leaflet-1.0.1/examples/osm-tiled/style.css b/sandbox/lines-polygons/leaflet/Proj4Leaflet-1.0.1/examples/osm-tiled/style.css
new file mode 100644
index 0000000..01d5be9
--- /dev/null
+++ b/sandbox/lines-polygons/leaflet/Proj4Leaflet-1.0.1/examples/osm-tiled/style.css
@@ -0,0 +1,10 @@
+html, body {
+ height: 100%;
+ padding: 0;
+ margin: 0;
+}
+
+#map {
+ width: 100%;
+ height: 100%;
+}
diff --git a/sandbox/lines-polygons/leaflet/Proj4Leaflet-1.0.1/examples/tms-tiled/index.html b/sandbox/lines-polygons/leaflet/Proj4Leaflet-1.0.1/examples/tms-tiled/index.html
new file mode 100644
index 0000000..0f108ba
--- /dev/null
+++ b/sandbox/lines-polygons/leaflet/Proj4Leaflet-1.0.1/examples/tms-tiled/index.html
@@ -0,0 +1,15 @@
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
diff --git a/sandbox/lines-polygons/leaflet/Proj4Leaflet-1.0.1/examples/tms-tiled/script.js b/sandbox/lines-polygons/leaflet/Proj4Leaflet-1.0.1/examples/tms-tiled/script.js
new file mode 100644
index 0000000..d51d5f6
--- /dev/null
+++ b/sandbox/lines-polygons/leaflet/Proj4Leaflet-1.0.1/examples/tms-tiled/script.js
@@ -0,0 +1,27 @@
+var crs = new L.Proj.CRS('EPSG:5181',
+ '+proj=tmerc +lat_0=38 +lon_0=127 +k=1 +x_0=200000 +y_0=500000 +ellps=GRS80 +towgs84=0,0,0,0,0,0,0 +units=m +no_defs',
+ {
+ resolutions: [2048, 1024, 512, 256, 128, 64, 32, 16, 8, 4, 2, 1, 0.5, 0.25],
+ origin: [-30000, -60000],
+ bounds: L.bounds([-30000, -60000], [494288, 464288])
+ }),
+ map = L.map('map', {
+ crs: crs,
+ continuousWorld: true,
+ worldCopyJump: false,
+ });
+
+new L.TileLayer('http://i{s}.maps.daum-img.net/map/image/G03/i/1.20/L{z}/{y}/{x}.png', {
+ maxZoom: 14,
+ minZoom: 0,
+ zoomReverse: true,
+ subdomains: '0123',
+ continuousWorld: true,
+ attribution: 'ⓒ Daum',
+ tms: true
+}).addTo(map);
+
+//Gunsan Airport
+new L.marker([35.925937, 126.615810]).addTo(map);
+
+map.setView([36.0, 127.0], 0);
diff --git a/sandbox/lines-polygons/leaflet/Proj4Leaflet-1.0.1/examples/tms-tiled/style.css b/sandbox/lines-polygons/leaflet/Proj4Leaflet-1.0.1/examples/tms-tiled/style.css
new file mode 100644
index 0000000..01d5be9
--- /dev/null
+++ b/sandbox/lines-polygons/leaflet/Proj4Leaflet-1.0.1/examples/tms-tiled/style.css
@@ -0,0 +1,10 @@
+html, body {
+ height: 100%;
+ padding: 0;
+ margin: 0;
+}
+
+#map {
+ width: 100%;
+ height: 100%;
+}
diff --git a/sandbox/lines-polygons/leaflet/Proj4Leaflet-1.0.1/examples/wms/index.html b/sandbox/lines-polygons/leaflet/Proj4Leaflet-1.0.1/examples/wms/index.html
new file mode 100644
index 0000000..0f108ba
--- /dev/null
+++ b/sandbox/lines-polygons/leaflet/Proj4Leaflet-1.0.1/examples/wms/index.html
@@ -0,0 +1,15 @@
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
diff --git a/sandbox/lines-polygons/leaflet/Proj4Leaflet-1.0.1/examples/wms/script.js b/sandbox/lines-polygons/leaflet/Proj4Leaflet-1.0.1/examples/wms/script.js
new file mode 100644
index 0000000..5cd0663
--- /dev/null
+++ b/sandbox/lines-polygons/leaflet/Proj4Leaflet-1.0.1/examples/wms/script.js
@@ -0,0 +1,22 @@
+var crs = new L.Proj.CRS('EPSG:3006',
+ '+proj=utm +zone=33 +ellps=GRS80 +towgs84=0,0,0,0,0,0,0 +units=m +no_defs',
+ {
+ resolutions: [
+ 8192, 4096, 2048, 1024, 512, 256, 128,
+ 64, 32, 16, 8, 4, 2, 1, 0.5
+ ],
+ origin: [0, 0]
+ }),
+ map = new L.Map('map', {
+ crs: crs,
+ });
+
+L.tileLayer.wms('https://geodatatest.havochvatten.se/geoservices/ows', {
+ layers: 'hav-bakgrundskartor:hav-grundkarta',
+ format: 'image/png',
+ maxZoom: 14,
+ minZoom: 0,
+ attribution: '© OpenStreetMap contributors Havs- och vattenmyndigheten (Swedish Agency for Marine and Water Management)'
+}).addTo(map);
+
+map.setView([55.8, 14.3], 3);
diff --git a/sandbox/lines-polygons/leaflet/Proj4Leaflet-1.0.1/examples/wms/style.css b/sandbox/lines-polygons/leaflet/Proj4Leaflet-1.0.1/examples/wms/style.css
new file mode 100644
index 0000000..01d5be9
--- /dev/null
+++ b/sandbox/lines-polygons/leaflet/Proj4Leaflet-1.0.1/examples/wms/style.css
@@ -0,0 +1,10 @@
+html, body {
+ height: 100%;
+ padding: 0;
+ margin: 0;
+}
+
+#map {
+ width: 100%;
+ height: 100%;
+}
diff --git a/sandbox/lines-polygons/leaflet/Proj4Leaflet-1.0.1/examples/wmts/index.html b/sandbox/lines-polygons/leaflet/Proj4Leaflet-1.0.1/examples/wmts/index.html
new file mode 100644
index 0000000..0e03bd3
--- /dev/null
+++ b/sandbox/lines-polygons/leaflet/Proj4Leaflet-1.0.1/examples/wmts/index.html
@@ -0,0 +1,15 @@
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
diff --git a/sandbox/lines-polygons/leaflet/Proj4Leaflet-1.0.1/examples/wmts/script.js b/sandbox/lines-polygons/leaflet/Proj4Leaflet-1.0.1/examples/wmts/script.js
new file mode 100644
index 0000000..b2ca4e8
--- /dev/null
+++ b/sandbox/lines-polygons/leaflet/Proj4Leaflet-1.0.1/examples/wmts/script.js
@@ -0,0 +1,30 @@
+/*
+Example using Sweden Lantmäteriet Topografisk Webbkarta
+https://opendata.lantmateriet.se/#apis
+*/
+
+/*** INSERT YOUR LANTMÄTERIET API TOKEN BELOW ***/
+var token = '';
+
+var crs = new L.Proj.CRS('EPSG:3006',
+ '+proj=utm +zone=33 +ellps=GRS80 +towgs84=0,0,0,0,0,0,0 +units=m +no_defs',
+ {
+ resolutions: [
+ 4096, 2048, 1024, 512, 256, 128, 64, 32, 16, 8
+ ],
+ origin: [-1200000.000000, 8500000.000000 ],
+ bounds: L.bounds( [-1200000.000000, 8500000.000000], [4305696.000000, 2994304.000000])
+ }),
+ map = new L.Map('map', {
+ crs: crs,
+ continuousWorld: true,
+ });
+
+new L.TileLayer('https://api.lantmateriet.se/open/topowebb-ccby/v1/wmts/token/'+ token +'/?SERVICE=WMTS&REQUEST=GetTile&VERSION=1.0.0&LAYER=topowebb&STYLE=default&TILEMATRIXSET=3006&TILEMATRIX={z}&TILEROW={y}&TILECOL={x}&FORMAT=image%2Fpng', {
+ maxZoom: 9,
+ minZoom: 0,
+ continuousWorld: true,
+ attribution: '© Lantmäteriet Topografisk Webbkarta Visning, CCB',
+}).addTo(map);
+//Set view over Stockholm Södermalm
+map.setView([59.3167, 18.0667], 7);
diff --git a/sandbox/lines-polygons/leaflet/Proj4Leaflet-1.0.1/examples/wmts/style.css b/sandbox/lines-polygons/leaflet/Proj4Leaflet-1.0.1/examples/wmts/style.css
new file mode 100644
index 0000000..5896443
--- /dev/null
+++ b/sandbox/lines-polygons/leaflet/Proj4Leaflet-1.0.1/examples/wmts/style.css
@@ -0,0 +1,10 @@
+html, body {
+ height: 100%;
+ padding: 0;
+ margin: 0;
+}
+
+#map {
+ width: 100%;
+ height: 100%;
+}
diff --git a/sandbox/lines-polygons/leaflet/Proj4Leaflet-1.0.1/lib/leaflet/images/layers-2x.png b/sandbox/lines-polygons/leaflet/Proj4Leaflet-1.0.1/lib/leaflet/images/layers-2x.png
new file mode 100644
index 0000000..200c333
Binary files /dev/null and b/sandbox/lines-polygons/leaflet/Proj4Leaflet-1.0.1/lib/leaflet/images/layers-2x.png differ
diff --git a/sandbox/lines-polygons/leaflet/Proj4Leaflet-1.0.1/lib/leaflet/images/layers.png b/sandbox/lines-polygons/leaflet/Proj4Leaflet-1.0.1/lib/leaflet/images/layers.png
new file mode 100644
index 0000000..1a72e57
Binary files /dev/null and b/sandbox/lines-polygons/leaflet/Proj4Leaflet-1.0.1/lib/leaflet/images/layers.png differ
diff --git a/sandbox/lines-polygons/leaflet/Proj4Leaflet-1.0.1/lib/leaflet/images/marker-icon-2x.png b/sandbox/lines-polygons/leaflet/Proj4Leaflet-1.0.1/lib/leaflet/images/marker-icon-2x.png
new file mode 100644
index 0000000..e4abba3
Binary files /dev/null and b/sandbox/lines-polygons/leaflet/Proj4Leaflet-1.0.1/lib/leaflet/images/marker-icon-2x.png differ
diff --git a/sandbox/lines-polygons/leaflet/Proj4Leaflet-1.0.1/lib/leaflet/images/marker-icon.png b/sandbox/lines-polygons/leaflet/Proj4Leaflet-1.0.1/lib/leaflet/images/marker-icon.png
new file mode 100644
index 0000000..950edf2
Binary files /dev/null and b/sandbox/lines-polygons/leaflet/Proj4Leaflet-1.0.1/lib/leaflet/images/marker-icon.png differ
diff --git a/sandbox/lines-polygons/leaflet/Proj4Leaflet-1.0.1/lib/leaflet/images/marker-shadow.png b/sandbox/lines-polygons/leaflet/Proj4Leaflet-1.0.1/lib/leaflet/images/marker-shadow.png
new file mode 100644
index 0000000..9fd2979
Binary files /dev/null and b/sandbox/lines-polygons/leaflet/Proj4Leaflet-1.0.1/lib/leaflet/images/marker-shadow.png differ
diff --git a/sandbox/lines-polygons/leaflet/Proj4Leaflet-1.0.1/lib/leaflet/leaflet-src.js b/sandbox/lines-polygons/leaflet/Proj4Leaflet-1.0.1/lib/leaflet/leaflet-src.js
new file mode 100644
index 0000000..41003c0
--- /dev/null
+++ b/sandbox/lines-polygons/leaflet/Proj4Leaflet-1.0.1/lib/leaflet/leaflet-src.js
@@ -0,0 +1,13251 @@
+/*
+ Leaflet 1.0.3, a JS library for interactive maps. http://leafletjs.com
+ (c) 2010-2016 Vladimir Agafonkin, (c) 2010-2011 CloudMade
+*/
+(function (window, document, undefined) {
+var L = {
+ version: "1.0.3"
+};
+
+function expose() {
+ var oldL = window.L;
+
+ L.noConflict = function () {
+ window.L = oldL;
+ return this;
+ };
+
+ window.L = L;
+}
+
+// define Leaflet for Node module pattern loaders, including Browserify
+if (typeof module === 'object' && typeof module.exports === 'object') {
+ module.exports = L;
+
+// define Leaflet as an AMD module
+} else if (typeof define === 'function' && define.amd) {
+ define(L);
+}
+
+// define Leaflet as a global L variable, saving the original L to restore later if needed
+if (typeof window !== 'undefined') {
+ expose();
+}
+
+
+
+/*
+ * @namespace Util
+ *
+ * Various utility functions, used by Leaflet internally.
+ */
+
+L.Util = {
+
+ // @function extend(dest: Object, src?: Object): Object
+ // Merges the properties of the `src` object (or multiple objects) into `dest` object and returns the latter. Has an `L.extend` shortcut.
+ extend: function (dest) {
+ var i, j, len, src;
+
+ for (j = 1, len = arguments.length; j < len; j++) {
+ src = arguments[j];
+ for (i in src) {
+ dest[i] = src[i];
+ }
+ }
+ return dest;
+ },
+
+ // @function create(proto: Object, properties?: Object): Object
+ // Compatibility polyfill for [Object.create](https://developer.mozilla.org/docs/Web/JavaScript/Reference/Global_Objects/Object/create)
+ create: Object.create || (function () {
+ function F() {}
+ return function (proto) {
+ F.prototype = proto;
+ return new F();
+ };
+ })(),
+
+ // @function bind(fn: Function, …): Function
+ // Returns a new function bound to the arguments passed, like [Function.prototype.bind](https://developer.mozilla.org/docs/Web/JavaScript/Reference/Global_Objects/Function/bind).
+ // Has a `L.bind()` shortcut.
+ bind: function (fn, obj) {
+ var slice = Array.prototype.slice;
+
+ if (fn.bind) {
+ return fn.bind.apply(fn, slice.call(arguments, 1));
+ }
+
+ var args = slice.call(arguments, 2);
+
+ return function () {
+ return fn.apply(obj, args.length ? args.concat(slice.call(arguments)) : arguments);
+ };
+ },
+
+ // @function stamp(obj: Object): Number
+ // Returns the unique ID of an object, assiging it one if it doesn't have it.
+ stamp: function (obj) {
+ /*eslint-disable */
+ obj._leaflet_id = obj._leaflet_id || ++L.Util.lastId;
+ return obj._leaflet_id;
+ /*eslint-enable */
+ },
+
+ // @property lastId: Number
+ // Last unique ID used by [`stamp()`](#util-stamp)
+ lastId: 0,
+
+ // @function throttle(fn: Function, time: Number, context: Object): Function
+ // Returns a function which executes function `fn` with the given scope `context`
+ // (so that the `this` keyword refers to `context` inside `fn`'s code). The function
+ // `fn` will be called no more than one time per given amount of `time`. The arguments
+ // received by the bound function will be any arguments passed when binding the
+ // function, followed by any arguments passed when invoking the bound function.
+ // Has an `L.bind` shortcut.
+ throttle: function (fn, time, context) {
+ var lock, args, wrapperFn, later;
+
+ later = function () {
+ // reset lock and call if queued
+ lock = false;
+ if (args) {
+ wrapperFn.apply(context, args);
+ args = false;
+ }
+ };
+
+ wrapperFn = function () {
+ if (lock) {
+ // called too soon, queue to call later
+ args = arguments;
+
+ } else {
+ // call and lock until later
+ fn.apply(context, arguments);
+ setTimeout(later, time);
+ lock = true;
+ }
+ };
+
+ return wrapperFn;
+ },
+
+ // @function wrapNum(num: Number, range: Number[], includeMax?: Boolean): Number
+ // Returns the number `num` modulo `range` in such a way so it lies within
+ // `range[0]` and `range[1]`. The returned value will be always smaller than
+ // `range[1]` unless `includeMax` is set to `true`.
+ wrapNum: function (x, range, includeMax) {
+ var max = range[1],
+ min = range[0],
+ d = max - min;
+ return x === max && includeMax ? x : ((x - min) % d + d) % d + min;
+ },
+
+ // @function falseFn(): Function
+ // Returns a function which always returns `false`.
+ falseFn: function () { return false; },
+
+ // @function formatNum(num: Number, digits?: Number): Number
+ // Returns the number `num` rounded to `digits` decimals, or to 5 decimals by default.
+ formatNum: function (num, digits) {
+ var pow = Math.pow(10, digits || 5);
+ return Math.round(num * pow) / pow;
+ },
+
+ // @function trim(str: String): String
+ // Compatibility polyfill for [String.prototype.trim](https://developer.mozilla.org/docs/Web/JavaScript/Reference/Global_Objects/String/Trim)
+ trim: function (str) {
+ return str.trim ? str.trim() : str.replace(/^\s+|\s+$/g, '');
+ },
+
+ // @function splitWords(str: String): String[]
+ // Trims and splits the string on whitespace and returns the array of parts.
+ splitWords: function (str) {
+ return L.Util.trim(str).split(/\s+/);
+ },
+
+ // @function setOptions(obj: Object, options: Object): Object
+ // Merges the given properties to the `options` of the `obj` object, returning the resulting options. See `Class options`. Has an `L.setOptions` shortcut.
+ setOptions: function (obj, options) {
+ if (!obj.hasOwnProperty('options')) {
+ obj.options = obj.options ? L.Util.create(obj.options) : {};
+ }
+ for (var i in options) {
+ obj.options[i] = options[i];
+ }
+ return obj.options;
+ },
+
+ // @function getParamString(obj: Object, existingUrl?: String, uppercase?: Boolean): String
+ // Converts an object into a parameter URL string, e.g. `{a: "foo", b: "bar"}`
+ // translates to `'?a=foo&b=bar'`. If `existingUrl` is set, the parameters will
+ // be appended at the end. If `uppercase` is `true`, the parameter names will
+ // be uppercased (e.g. `'?A=foo&B=bar'`)
+ getParamString: function (obj, existingUrl, uppercase) {
+ var params = [];
+ for (var i in obj) {
+ params.push(encodeURIComponent(uppercase ? i.toUpperCase() : i) + '=' + encodeURIComponent(obj[i]));
+ }
+ return ((!existingUrl || existingUrl.indexOf('?') === -1) ? '?' : '&') + params.join('&');
+ },
+
+ // @function template(str: String, data: Object): String
+ // Simple templating facility, accepts a template string of the form `'Hello {a}, {b}'`
+ // and a data object like `{a: 'foo', b: 'bar'}`, returns evaluated string
+ // `('Hello foo, bar')`. You can also specify functions instead of strings for
+ // data values — they will be evaluated passing `data` as an argument.
+ template: function (str, data) {
+ return str.replace(L.Util.templateRe, function (str, key) {
+ var value = data[key];
+
+ if (value === undefined) {
+ throw new Error('No value provided for variable ' + str);
+
+ } else if (typeof value === 'function') {
+ value = value(data);
+ }
+ return value;
+ });
+ },
+
+ templateRe: /\{ *([\w_\-]+) *\}/g,
+
+ // @function isArray(obj): Boolean
+ // Compatibility polyfill for [Array.isArray](https://developer.mozilla.org/docs/Web/JavaScript/Reference/Global_Objects/Array/isArray)
+ isArray: Array.isArray || function (obj) {
+ return (Object.prototype.toString.call(obj) === '[object Array]');
+ },
+
+ // @function indexOf(array: Array, el: Object): Number
+ // Compatibility polyfill for [Array.prototype.indexOf](https://developer.mozilla.org/docs/Web/JavaScript/Reference/Global_Objects/Array/indexOf)
+ indexOf: function (array, el) {
+ for (var i = 0; i < array.length; i++) {
+ if (array[i] === el) { return i; }
+ }
+ return -1;
+ },
+
+ // @property emptyImageUrl: String
+ // Data URI string containing a base64-encoded empty GIF image.
+ // Used as a hack to free memory from unused images on WebKit-powered
+ // mobile devices (by setting image `src` to this string).
+ emptyImageUrl: 'data:image/gif;base64,R0lGODlhAQABAAD/ACwAAAAAAQABAAACADs='
+};
+
+(function () {
+ // inspired by http://paulirish.com/2011/requestanimationframe-for-smart-animating/
+
+ function getPrefixed(name) {
+ return window['webkit' + name] || window['moz' + name] || window['ms' + name];
+ }
+
+ var lastTime = 0;
+
+ // fallback for IE 7-8
+ function timeoutDefer(fn) {
+ var time = +new Date(),
+ timeToCall = Math.max(0, 16 - (time - lastTime));
+
+ lastTime = time + timeToCall;
+ return window.setTimeout(fn, timeToCall);
+ }
+
+ var requestFn = window.requestAnimationFrame || getPrefixed('RequestAnimationFrame') || timeoutDefer,
+ cancelFn = window.cancelAnimationFrame || getPrefixed('CancelAnimationFrame') ||
+ getPrefixed('CancelRequestAnimationFrame') || function (id) { window.clearTimeout(id); };
+
+
+ // @function requestAnimFrame(fn: Function, context?: Object, immediate?: Boolean): Number
+ // Schedules `fn` to be executed when the browser repaints. `fn` is bound to
+ // `context` if given. When `immediate` is set, `fn` is called immediately if
+ // the browser doesn't have native support for
+ // [`window.requestAnimationFrame`](https://developer.mozilla.org/docs/Web/API/window/requestAnimationFrame),
+ // otherwise it's delayed. Returns a request ID that can be used to cancel the request.
+ L.Util.requestAnimFrame = function (fn, context, immediate) {
+ if (immediate && requestFn === timeoutDefer) {
+ fn.call(context);
+ } else {
+ return requestFn.call(window, L.bind(fn, context));
+ }
+ };
+
+ // @function cancelAnimFrame(id: Number): undefined
+ // Cancels a previous `requestAnimFrame`. See also [window.cancelAnimationFrame](https://developer.mozilla.org/docs/Web/API/window/cancelAnimationFrame).
+ L.Util.cancelAnimFrame = function (id) {
+ if (id) {
+ cancelFn.call(window, id);
+ }
+ };
+})();
+
+// shortcuts for most used utility functions
+L.extend = L.Util.extend;
+L.bind = L.Util.bind;
+L.stamp = L.Util.stamp;
+L.setOptions = L.Util.setOptions;
+
+
+
+
+// @class Class
+// @aka L.Class
+
+// @section
+// @uninheritable
+
+// Thanks to John Resig and Dean Edwards for inspiration!
+
+L.Class = function () {};
+
+L.Class.extend = function (props) {
+
+ // @function extend(props: Object): Function
+ // [Extends the current class](#class-inheritance) given the properties to be included.
+ // Returns a Javascript function that is a class constructor (to be called with `new`).
+ var NewClass = function () {
+
+ // call the constructor
+ if (this.initialize) {
+ this.initialize.apply(this, arguments);
+ }
+
+ // call all constructor hooks
+ this.callInitHooks();
+ };
+
+ var parentProto = NewClass.__super__ = this.prototype;
+
+ var proto = L.Util.create(parentProto);
+ proto.constructor = NewClass;
+
+ NewClass.prototype = proto;
+
+ // inherit parent's statics
+ for (var i in this) {
+ if (this.hasOwnProperty(i) && i !== 'prototype') {
+ NewClass[i] = this[i];
+ }
+ }
+
+ // mix static properties into the class
+ if (props.statics) {
+ L.extend(NewClass, props.statics);
+ delete props.statics;
+ }
+
+ // mix includes into the prototype
+ if (props.includes) {
+ L.Util.extend.apply(null, [proto].concat(props.includes));
+ delete props.includes;
+ }
+
+ // merge options
+ if (proto.options) {
+ props.options = L.Util.extend(L.Util.create(proto.options), props.options);
+ }
+
+ // mix given properties into the prototype
+ L.extend(proto, props);
+
+ proto._initHooks = [];
+
+ // add method for calling all hooks
+ proto.callInitHooks = function () {
+
+ if (this._initHooksCalled) { return; }
+
+ if (parentProto.callInitHooks) {
+ parentProto.callInitHooks.call(this);
+ }
+
+ this._initHooksCalled = true;
+
+ for (var i = 0, len = proto._initHooks.length; i < len; i++) {
+ proto._initHooks[i].call(this);
+ }
+ };
+
+ return NewClass;
+};
+
+
+// @function include(properties: Object): this
+// [Includes a mixin](#class-includes) into the current class.
+L.Class.include = function (props) {
+ L.extend(this.prototype, props);
+ return this;
+};
+
+// @function mergeOptions(options: Object): this
+// [Merges `options`](#class-options) into the defaults of the class.
+L.Class.mergeOptions = function (options) {
+ L.extend(this.prototype.options, options);
+ return this;
+};
+
+// @function addInitHook(fn: Function): this
+// Adds a [constructor hook](#class-constructor-hooks) to the class.
+L.Class.addInitHook = function (fn) { // (Function) || (String, args...)
+ var args = Array.prototype.slice.call(arguments, 1);
+
+ var init = typeof fn === 'function' ? fn : function () {
+ this[fn].apply(this, args);
+ };
+
+ this.prototype._initHooks = this.prototype._initHooks || [];
+ this.prototype._initHooks.push(init);
+ return this;
+};
+
+
+
+/*
+ * @class Evented
+ * @aka L.Evented
+ * @inherits Class
+ *
+ * A set of methods shared between event-powered classes (like `Map` and `Marker`). Generally, events allow you to execute some function when something happens with an object (e.g. the user clicks on the map, causing the map to fire `'click'` event).
+ *
+ * @example
+ *
+ * ```js
+ * map.on('click', function(e) {
+ * alert(e.latlng);
+ * } );
+ * ```
+ *
+ * Leaflet deals with event listeners by reference, so if you want to add a listener and then remove it, define it as a function:
+ *
+ * ```js
+ * function onClick(e) { ... }
+ *
+ * map.on('click', onClick);
+ * map.off('click', onClick);
+ * ```
+ */
+
+
+L.Evented = L.Class.extend({
+
+ /* @method on(type: String, fn: Function, context?: Object): this
+ * Adds a listener function (`fn`) to a particular event type of the object. You can optionally specify the context of the listener (object the this keyword will point to). You can also pass several space-separated types (e.g. `'click dblclick'`).
+ *
+ * @alternative
+ * @method on(eventMap: Object): this
+ * Adds a set of type/listener pairs, e.g. `{click: onClick, mousemove: onMouseMove}`
+ */
+ on: function (types, fn, context) {
+
+ // types can be a map of types/handlers
+ if (typeof types === 'object') {
+ for (var type in types) {
+ // we don't process space-separated events here for performance;
+ // it's a hot path since Layer uses the on(obj) syntax
+ this._on(type, types[type], fn);
+ }
+
+ } else {
+ // types can be a string of space-separated words
+ types = L.Util.splitWords(types);
+
+ for (var i = 0, len = types.length; i < len; i++) {
+ this._on(types[i], fn, context);
+ }
+ }
+
+ return this;
+ },
+
+ /* @method off(type: String, fn?: Function, context?: Object): this
+ * Removes a previously added listener function. If no function is specified, it will remove all the listeners of that particular event from the object. Note that if you passed a custom context to `on`, you must pass the same context to `off` in order to remove the listener.
+ *
+ * @alternative
+ * @method off(eventMap: Object): this
+ * Removes a set of type/listener pairs.
+ *
+ * @alternative
+ * @method off: this
+ * Removes all listeners to all events on the object.
+ */
+ off: function (types, fn, context) {
+
+ if (!types) {
+ // clear all listeners if called without arguments
+ delete this._events;
+
+ } else if (typeof types === 'object') {
+ for (var type in types) {
+ this._off(type, types[type], fn);
+ }
+
+ } else {
+ types = L.Util.splitWords(types);
+
+ for (var i = 0, len = types.length; i < len; i++) {
+ this._off(types[i], fn, context);
+ }
+ }
+
+ return this;
+ },
+
+ // attach listener (without syntactic sugar now)
+ _on: function (type, fn, context) {
+ this._events = this._events || {};
+
+ /* get/init listeners for type */
+ var typeListeners = this._events[type];
+ if (!typeListeners) {
+ typeListeners = [];
+ this._events[type] = typeListeners;
+ }
+
+ if (context === this) {
+ // Less memory footprint.
+ context = undefined;
+ }
+ var newListener = {fn: fn, ctx: context},
+ listeners = typeListeners;
+
+ // check if fn already there
+ for (var i = 0, len = listeners.length; i < len; i++) {
+ if (listeners[i].fn === fn && listeners[i].ctx === context) {
+ return;
+ }
+ }
+
+ listeners.push(newListener);
+ },
+
+ _off: function (type, fn, context) {
+ var listeners,
+ i,
+ len;
+
+ if (!this._events) { return; }
+
+ listeners = this._events[type];
+
+ if (!listeners) {
+ return;
+ }
+
+ if (!fn) {
+ // Set all removed listeners to noop so they are not called if remove happens in fire
+ for (i = 0, len = listeners.length; i < len; i++) {
+ listeners[i].fn = L.Util.falseFn;
+ }
+ // clear all listeners for a type if function isn't specified
+ delete this._events[type];
+ return;
+ }
+
+ if (context === this) {
+ context = undefined;
+ }
+
+ if (listeners) {
+
+ // find fn and remove it
+ for (i = 0, len = listeners.length; i < len; i++) {
+ var l = listeners[i];
+ if (l.ctx !== context) { continue; }
+ if (l.fn === fn) {
+
+ // set the removed listener to noop so that's not called if remove happens in fire
+ l.fn = L.Util.falseFn;
+
+ if (this._firingCount) {
+ /* copy array in case events are being fired */
+ this._events[type] = listeners = listeners.slice();
+ }
+ listeners.splice(i, 1);
+
+ return;
+ }
+ }
+ }
+ },
+
+ // @method fire(type: String, data?: Object, propagate?: Boolean): this
+ // Fires an event of the specified type. You can optionally provide an data
+ // object — the first argument of the listener function will contain its
+ // properties. The event can optionally be propagated to event parents.
+ fire: function (type, data, propagate) {
+ if (!this.listens(type, propagate)) { return this; }
+
+ var event = L.Util.extend({}, data, {type: type, target: this});
+
+ if (this._events) {
+ var listeners = this._events[type];
+
+ if (listeners) {
+ this._firingCount = (this._firingCount + 1) || 1;
+ for (var i = 0, len = listeners.length; i < len; i++) {
+ var l = listeners[i];
+ l.fn.call(l.ctx || this, event);
+ }
+
+ this._firingCount--;
+ }
+ }
+
+ if (propagate) {
+ // propagate the event to parents (set with addEventParent)
+ this._propagateEvent(event);
+ }
+
+ return this;
+ },
+
+ // @method listens(type: String): Boolean
+ // Returns `true` if a particular event type has any listeners attached to it.
+ listens: function (type, propagate) {
+ var listeners = this._events && this._events[type];
+ if (listeners && listeners.length) { return true; }
+
+ if (propagate) {
+ // also check parents for listeners if event propagates
+ for (var id in this._eventParents) {
+ if (this._eventParents[id].listens(type, propagate)) { return true; }
+ }
+ }
+ return false;
+ },
+
+ // @method once(…): this
+ // Behaves as [`on(…)`](#evented-on), except the listener will only get fired once and then removed.
+ once: function (types, fn, context) {
+
+ if (typeof types === 'object') {
+ for (var type in types) {
+ this.once(type, types[type], fn);
+ }
+ return this;
+ }
+
+ var handler = L.bind(function () {
+ this
+ .off(types, fn, context)
+ .off(types, handler, context);
+ }, this);
+
+ // add a listener that's executed once and removed after that
+ return this
+ .on(types, fn, context)
+ .on(types, handler, context);
+ },
+
+ // @method addEventParent(obj: Evented): this
+ // Adds an event parent - an `Evented` that will receive propagated events
+ addEventParent: function (obj) {
+ this._eventParents = this._eventParents || {};
+ this._eventParents[L.stamp(obj)] = obj;
+ return this;
+ },
+
+ // @method removeEventParent(obj: Evented): this
+ // Removes an event parent, so it will stop receiving propagated events
+ removeEventParent: function (obj) {
+ if (this._eventParents) {
+ delete this._eventParents[L.stamp(obj)];
+ }
+ return this;
+ },
+
+ _propagateEvent: function (e) {
+ for (var id in this._eventParents) {
+ this._eventParents[id].fire(e.type, L.extend({layer: e.target}, e), true);
+ }
+ }
+});
+
+var proto = L.Evented.prototype;
+
+// aliases; we should ditch those eventually
+
+// @method addEventListener(…): this
+// Alias to [`on(…)`](#evented-on)
+proto.addEventListener = proto.on;
+
+// @method removeEventListener(…): this
+// Alias to [`off(…)`](#evented-off)
+
+// @method clearAllEventListeners(…): this
+// Alias to [`off()`](#evented-off)
+proto.removeEventListener = proto.clearAllEventListeners = proto.off;
+
+// @method addOneTimeEventListener(…): this
+// Alias to [`once(…)`](#evented-once)
+proto.addOneTimeEventListener = proto.once;
+
+// @method fireEvent(…): this
+// Alias to [`fire(…)`](#evented-fire)
+proto.fireEvent = proto.fire;
+
+// @method hasEventListeners(…): Boolean
+// Alias to [`listens(…)`](#evented-listens)
+proto.hasEventListeners = proto.listens;
+
+L.Mixin = {Events: proto};
+
+
+
+/*
+ * @namespace Browser
+ * @aka L.Browser
+ *
+ * A namespace with static properties for browser/feature detection used by Leaflet internally.
+ *
+ * @example
+ *
+ * ```js
+ * if (L.Browser.ielt9) {
+ * alert('Upgrade your browser, dude!');
+ * }
+ * ```
+ */
+
+(function () {
+
+ var ua = navigator.userAgent.toLowerCase(),
+ doc = document.documentElement,
+
+ ie = 'ActiveXObject' in window,
+
+ webkit = ua.indexOf('webkit') !== -1,
+ phantomjs = ua.indexOf('phantom') !== -1,
+ android23 = ua.search('android [23]') !== -1,
+ chrome = ua.indexOf('chrome') !== -1,
+ gecko = ua.indexOf('gecko') !== -1 && !webkit && !window.opera && !ie,
+
+ win = navigator.platform.indexOf('Win') === 0,
+
+ mobile = typeof orientation !== 'undefined' || ua.indexOf('mobile') !== -1,
+ msPointer = !window.PointerEvent && window.MSPointerEvent,
+ pointer = window.PointerEvent || msPointer,
+
+ ie3d = ie && ('transition' in doc.style),
+ webkit3d = ('WebKitCSSMatrix' in window) && ('m11' in new window.WebKitCSSMatrix()) && !android23,
+ gecko3d = 'MozPerspective' in doc.style,
+ opera12 = 'OTransition' in doc.style;
+
+
+ var touch = !window.L_NO_TOUCH && (pointer || 'ontouchstart' in window ||
+ (window.DocumentTouch && document instanceof window.DocumentTouch));
+
+ L.Browser = {
+
+ // @property ie: Boolean
+ // `true` for all Internet Explorer versions (not Edge).
+ ie: ie,
+
+ // @property ielt9: Boolean
+ // `true` for Internet Explorer versions less than 9.
+ ielt9: ie && !document.addEventListener,
+
+ // @property edge: Boolean
+ // `true` for the Edge web browser.
+ edge: 'msLaunchUri' in navigator && !('documentMode' in document),
+
+ // @property webkit: Boolean
+ // `true` for webkit-based browsers like Chrome and Safari (including mobile versions).
+ webkit: webkit,
+
+ // @property gecko: Boolean
+ // `true` for gecko-based browsers like Firefox.
+ gecko: gecko,
+
+ // @property android: Boolean
+ // `true` for any browser running on an Android platform.
+ android: ua.indexOf('android') !== -1,
+
+ // @property android23: Boolean
+ // `true` for browsers running on Android 2 or Android 3.
+ android23: android23,
+
+ // @property chrome: Boolean
+ // `true` for the Chrome browser.
+ chrome: chrome,
+
+ // @property safari: Boolean
+ // `true` for the Safari browser.
+ safari: !chrome && ua.indexOf('safari') !== -1,
+
+
+ // @property win: Boolean
+ // `true` when the browser is running in a Windows platform
+ win: win,
+
+
+ // @property ie3d: Boolean
+ // `true` for all Internet Explorer versions supporting CSS transforms.
+ ie3d: ie3d,
+
+ // @property webkit3d: Boolean
+ // `true` for webkit-based browsers supporting CSS transforms.
+ webkit3d: webkit3d,
+
+ // @property gecko3d: Boolean
+ // `true` for gecko-based browsers supporting CSS transforms.
+ gecko3d: gecko3d,
+
+ // @property opera12: Boolean
+ // `true` for the Opera browser supporting CSS transforms (version 12 or later).
+ opera12: opera12,
+
+ // @property any3d: Boolean
+ // `true` for all browsers supporting CSS transforms.
+ any3d: !window.L_DISABLE_3D && (ie3d || webkit3d || gecko3d) && !opera12 && !phantomjs,
+
+
+ // @property mobile: Boolean
+ // `true` for all browsers running in a mobile device.
+ mobile: mobile,
+
+ // @property mobileWebkit: Boolean
+ // `true` for all webkit-based browsers in a mobile device.
+ mobileWebkit: mobile && webkit,
+
+ // @property mobileWebkit3d: Boolean
+ // `true` for all webkit-based browsers in a mobile device supporting CSS transforms.
+ mobileWebkit3d: mobile && webkit3d,
+
+ // @property mobileOpera: Boolean
+ // `true` for the Opera browser in a mobile device.
+ mobileOpera: mobile && window.opera,
+
+ // @property mobileGecko: Boolean
+ // `true` for gecko-based browsers running in a mobile device.
+ mobileGecko: mobile && gecko,
+
+
+ // @property touch: Boolean
+ // `true` for all browsers supporting [touch events](https://developer.mozilla.org/docs/Web/API/Touch_events).
+ // This does not necessarily mean that the browser is running in a computer with
+ // a touchscreen, it only means that the browser is capable of understanding
+ // touch events.
+ touch: !!touch,
+
+ // @property msPointer: Boolean
+ // `true` for browsers implementing the Microsoft touch events model (notably IE10).
+ msPointer: !!msPointer,
+
+ // @property pointer: Boolean
+ // `true` for all browsers supporting [pointer events](https://msdn.microsoft.com/en-us/library/dn433244%28v=vs.85%29.aspx).
+ pointer: !!pointer,
+
+
+ // @property retina: Boolean
+ // `true` for browsers on a high-resolution "retina" screen.
+ retina: (window.devicePixelRatio || (window.screen.deviceXDPI / window.screen.logicalXDPI)) > 1
+ };
+
+}());
+
+
+
+/*
+ * @class Point
+ * @aka L.Point
+ *
+ * Represents a point with `x` and `y` coordinates in pixels.
+ *
+ * @example
+ *
+ * ```js
+ * var point = L.point(200, 300);
+ * ```
+ *
+ * All Leaflet methods and options that accept `Point` objects also accept them in a simple Array form (unless noted otherwise), so these lines are equivalent:
+ *
+ * ```js
+ * map.panBy([200, 300]);
+ * map.panBy(L.point(200, 300));
+ * ```
+ */
+
+L.Point = function (x, y, round) {
+ // @property x: Number; The `x` coordinate of the point
+ this.x = (round ? Math.round(x) : x);
+ // @property y: Number; The `y` coordinate of the point
+ this.y = (round ? Math.round(y) : y);
+};
+
+L.Point.prototype = {
+
+ // @method clone(): Point
+ // Returns a copy of the current point.
+ clone: function () {
+ return new L.Point(this.x, this.y);
+ },
+
+ // @method add(otherPoint: Point): Point
+ // Returns the result of addition of the current and the given points.
+ add: function (point) {
+ // non-destructive, returns a new point
+ return this.clone()._add(L.point(point));
+ },
+
+ _add: function (point) {
+ // destructive, used directly for performance in situations where it's safe to modify existing point
+ this.x += point.x;
+ this.y += point.y;
+ return this;
+ },
+
+ // @method subtract(otherPoint: Point): Point
+ // Returns the result of subtraction of the given point from the current.
+ subtract: function (point) {
+ return this.clone()._subtract(L.point(point));
+ },
+
+ _subtract: function (point) {
+ this.x -= point.x;
+ this.y -= point.y;
+ return this;
+ },
+
+ // @method divideBy(num: Number): Point
+ // Returns the result of division of the current point by the given number.
+ divideBy: function (num) {
+ return this.clone()._divideBy(num);
+ },
+
+ _divideBy: function (num) {
+ this.x /= num;
+ this.y /= num;
+ return this;
+ },
+
+ // @method multiplyBy(num: Number): Point
+ // Returns the result of multiplication of the current point by the given number.
+ multiplyBy: function (num) {
+ return this.clone()._multiplyBy(num);
+ },
+
+ _multiplyBy: function (num) {
+ this.x *= num;
+ this.y *= num;
+ return this;
+ },
+
+ // @method scaleBy(scale: Point): Point
+ // Multiply each coordinate of the current point by each coordinate of
+ // `scale`. In linear algebra terms, multiply the point by the
+ // [scaling matrix](https://en.wikipedia.org/wiki/Scaling_%28geometry%29#Matrix_representation)
+ // defined by `scale`.
+ scaleBy: function (point) {
+ return new L.Point(this.x * point.x, this.y * point.y);
+ },
+
+ // @method unscaleBy(scale: Point): Point
+ // Inverse of `scaleBy`. Divide each coordinate of the current point by
+ // each coordinate of `scale`.
+ unscaleBy: function (point) {
+ return new L.Point(this.x / point.x, this.y / point.y);
+ },
+
+ // @method round(): Point
+ // Returns a copy of the current point with rounded coordinates.
+ round: function () {
+ return this.clone()._round();
+ },
+
+ _round: function () {
+ this.x = Math.round(this.x);
+ this.y = Math.round(this.y);
+ return this;
+ },
+
+ // @method floor(): Point
+ // Returns a copy of the current point with floored coordinates (rounded down).
+ floor: function () {
+ return this.clone()._floor();
+ },
+
+ _floor: function () {
+ this.x = Math.floor(this.x);
+ this.y = Math.floor(this.y);
+ return this;
+ },
+
+ // @method ceil(): Point
+ // Returns a copy of the current point with ceiled coordinates (rounded up).
+ ceil: function () {
+ return this.clone()._ceil();
+ },
+
+ _ceil: function () {
+ this.x = Math.ceil(this.x);
+ this.y = Math.ceil(this.y);
+ return this;
+ },
+
+ // @method distanceTo(otherPoint: Point): Number
+ // Returns the cartesian distance between the current and the given points.
+ distanceTo: function (point) {
+ point = L.point(point);
+
+ var x = point.x - this.x,
+ y = point.y - this.y;
+
+ return Math.sqrt(x * x + y * y);
+ },
+
+ // @method equals(otherPoint: Point): Boolean
+ // Returns `true` if the given point has the same coordinates.
+ equals: function (point) {
+ point = L.point(point);
+
+ return point.x === this.x &&
+ point.y === this.y;
+ },
+
+ // @method contains(otherPoint: Point): Boolean
+ // Returns `true` if both coordinates of the given point are less than the corresponding current point coordinates (in absolute values).
+ contains: function (point) {
+ point = L.point(point);
+
+ return Math.abs(point.x) <= Math.abs(this.x) &&
+ Math.abs(point.y) <= Math.abs(this.y);
+ },
+
+ // @method toString(): String
+ // Returns a string representation of the point for debugging purposes.
+ toString: function () {
+ return 'Point(' +
+ L.Util.formatNum(this.x) + ', ' +
+ L.Util.formatNum(this.y) + ')';
+ }
+};
+
+// @factory L.point(x: Number, y: Number, round?: Boolean)
+// Creates a Point object with the given `x` and `y` coordinates. If optional `round` is set to true, rounds the `x` and `y` values.
+
+// @alternative
+// @factory L.point(coords: Number[])
+// Expects an array of the form `[x, y]` instead.
+
+// @alternative
+// @factory L.point(coords: Object)
+// Expects a plain object of the form `{x: Number, y: Number}` instead.
+L.point = function (x, y, round) {
+ if (x instanceof L.Point) {
+ return x;
+ }
+ if (L.Util.isArray(x)) {
+ return new L.Point(x[0], x[1]);
+ }
+ if (x === undefined || x === null) {
+ return x;
+ }
+ if (typeof x === 'object' && 'x' in x && 'y' in x) {
+ return new L.Point(x.x, x.y);
+ }
+ return new L.Point(x, y, round);
+};
+
+
+
+/*
+ * @class Bounds
+ * @aka L.Bounds
+ *
+ * Represents a rectangular area in pixel coordinates.
+ *
+ * @example
+ *
+ * ```js
+ * var p1 = L.point(10, 10),
+ * p2 = L.point(40, 60),
+ * bounds = L.bounds(p1, p2);
+ * ```
+ *
+ * All Leaflet methods that accept `Bounds` objects also accept them in a simple Array form (unless noted otherwise), so the bounds example above can be passed like this:
+ *
+ * ```js
+ * otherBounds.intersects([[10, 10], [40, 60]]);
+ * ```
+ */
+
+L.Bounds = function (a, b) {
+ if (!a) { return; }
+
+ var points = b ? [a, b] : a;
+
+ for (var i = 0, len = points.length; i < len; i++) {
+ this.extend(points[i]);
+ }
+};
+
+L.Bounds.prototype = {
+ // @method extend(point: Point): this
+ // Extends the bounds to contain the given point.
+ extend: function (point) { // (Point)
+ point = L.point(point);
+
+ // @property min: Point
+ // The top left corner of the rectangle.
+ // @property max: Point
+ // The bottom right corner of the rectangle.
+ if (!this.min && !this.max) {
+ this.min = point.clone();
+ this.max = point.clone();
+ } else {
+ this.min.x = Math.min(point.x, this.min.x);
+ this.max.x = Math.max(point.x, this.max.x);
+ this.min.y = Math.min(point.y, this.min.y);
+ this.max.y = Math.max(point.y, this.max.y);
+ }
+ return this;
+ },
+
+ // @method getCenter(round?: Boolean): Point
+ // Returns the center point of the bounds.
+ getCenter: function (round) {
+ return new L.Point(
+ (this.min.x + this.max.x) / 2,
+ (this.min.y + this.max.y) / 2, round);
+ },
+
+ // @method getBottomLeft(): Point
+ // Returns the bottom-left point of the bounds.
+ getBottomLeft: function () {
+ return new L.Point(this.min.x, this.max.y);
+ },
+
+ // @method getTopRight(): Point
+ // Returns the top-right point of the bounds.
+ getTopRight: function () { // -> Point
+ return new L.Point(this.max.x, this.min.y);
+ },
+
+ // @method getSize(): Point
+ // Returns the size of the given bounds
+ getSize: function () {
+ return this.max.subtract(this.min);
+ },
+
+ // @method contains(otherBounds: Bounds): Boolean
+ // Returns `true` if the rectangle contains the given one.
+ // @alternative
+ // @method contains(point: Point): Boolean
+ // Returns `true` if the rectangle contains the given point.
+ contains: function (obj) {
+ var min, max;
+
+ if (typeof obj[0] === 'number' || obj instanceof L.Point) {
+ obj = L.point(obj);
+ } else {
+ obj = L.bounds(obj);
+ }
+
+ if (obj instanceof L.Bounds) {
+ min = obj.min;
+ max = obj.max;
+ } else {
+ min = max = obj;
+ }
+
+ return (min.x >= this.min.x) &&
+ (max.x <= this.max.x) &&
+ (min.y >= this.min.y) &&
+ (max.y <= this.max.y);
+ },
+
+ // @method intersects(otherBounds: Bounds): Boolean
+ // Returns `true` if the rectangle intersects the given bounds. Two bounds
+ // intersect if they have at least one point in common.
+ intersects: function (bounds) { // (Bounds) -> Boolean
+ bounds = L.bounds(bounds);
+
+ var min = this.min,
+ max = this.max,
+ min2 = bounds.min,
+ max2 = bounds.max,
+ xIntersects = (max2.x >= min.x) && (min2.x <= max.x),
+ yIntersects = (max2.y >= min.y) && (min2.y <= max.y);
+
+ return xIntersects && yIntersects;
+ },
+
+ // @method overlaps(otherBounds: Bounds): Boolean
+ // Returns `true` if the rectangle overlaps the given bounds. Two bounds
+ // overlap if their intersection is an area.
+ overlaps: function (bounds) { // (Bounds) -> Boolean
+ bounds = L.bounds(bounds);
+
+ var min = this.min,
+ max = this.max,
+ min2 = bounds.min,
+ max2 = bounds.max,
+ xOverlaps = (max2.x > min.x) && (min2.x < max.x),
+ yOverlaps = (max2.y > min.y) && (min2.y < max.y);
+
+ return xOverlaps && yOverlaps;
+ },
+
+ isValid: function () {
+ return !!(this.min && this.max);
+ }
+};
+
+
+// @factory L.bounds(topLeft: Point, bottomRight: Point)
+// Creates a Bounds object from two coordinates (usually top-left and bottom-right corners).
+// @alternative
+// @factory L.bounds(points: Point[])
+// Creates a Bounds object from the points it contains
+L.bounds = function (a, b) {
+ if (!a || a instanceof L.Bounds) {
+ return a;
+ }
+ return new L.Bounds(a, b);
+};
+
+
+
+/*
+ * @class Transformation
+ * @aka L.Transformation
+ *
+ * Represents an affine transformation: a set of coefficients `a`, `b`, `c`, `d`
+ * for transforming a point of a form `(x, y)` into `(a*x + b, c*y + d)` and doing
+ * the reverse. Used by Leaflet in its projections code.
+ *
+ * @example
+ *
+ * ```js
+ * var transformation = new L.Transformation(2, 5, -1, 10),
+ * p = L.point(1, 2),
+ * p2 = transformation.transform(p), // L.point(7, 8)
+ * p3 = transformation.untransform(p2); // L.point(1, 2)
+ * ```
+ */
+
+
+// factory new L.Transformation(a: Number, b: Number, c: Number, d: Number)
+// Creates a `Transformation` object with the given coefficients.
+L.Transformation = function (a, b, c, d) {
+ this._a = a;
+ this._b = b;
+ this._c = c;
+ this._d = d;
+};
+
+L.Transformation.prototype = {
+ // @method transform(point: Point, scale?: Number): Point
+ // Returns a transformed point, optionally multiplied by the given scale.
+ // Only accepts actual `L.Point` instances, not arrays.
+ transform: function (point, scale) { // (Point, Number) -> Point
+ return this._transform(point.clone(), scale);
+ },
+
+ // destructive transform (faster)
+ _transform: function (point, scale) {
+ scale = scale || 1;
+ point.x = scale * (this._a * point.x + this._b);
+ point.y = scale * (this._c * point.y + this._d);
+ return point;
+ },
+
+ // @method untransform(point: Point, scale?: Number): Point
+ // Returns the reverse transformation of the given point, optionally divided
+ // by the given scale. Only accepts actual `L.Point` instances, not arrays.
+ untransform: function (point, scale) {
+ scale = scale || 1;
+ return new L.Point(
+ (point.x / scale - this._b) / this._a,
+ (point.y / scale - this._d) / this._c);
+ }
+};
+
+
+
+/*
+ * @namespace DomUtil
+ *
+ * Utility functions to work with the [DOM](https://developer.mozilla.org/docs/Web/API/Document_Object_Model)
+ * tree, used by Leaflet internally.
+ *
+ * Most functions expecting or returning a `HTMLElement` also work for
+ * SVG elements. The only difference is that classes refer to CSS classes
+ * in HTML and SVG classes in SVG.
+ */
+
+L.DomUtil = {
+
+ // @function get(id: String|HTMLElement): HTMLElement
+ // Returns an element given its DOM id, or returns the element itself
+ // if it was passed directly.
+ get: function (id) {
+ return typeof id === 'string' ? document.getElementById(id) : id;
+ },
+
+ // @function getStyle(el: HTMLElement, styleAttrib: String): String
+ // Returns the value for a certain style attribute on an element,
+ // including computed values or values set through CSS.
+ getStyle: function (el, style) {
+
+ var value = el.style[style] || (el.currentStyle && el.currentStyle[style]);
+
+ if ((!value || value === 'auto') && document.defaultView) {
+ var css = document.defaultView.getComputedStyle(el, null);
+ value = css ? css[style] : null;
+ }
+
+ return value === 'auto' ? null : value;
+ },
+
+ // @function create(tagName: String, className?: String, container?: HTMLElement): HTMLElement
+ // Creates an HTML element with `tagName`, sets its class to `className`, and optionally appends it to `container` element.
+ create: function (tagName, className, container) {
+
+ var el = document.createElement(tagName);
+ el.className = className || '';
+
+ if (container) {
+ container.appendChild(el);
+ }
+
+ return el;
+ },
+
+ // @function remove(el: HTMLElement)
+ // Removes `el` from its parent element
+ remove: function (el) {
+ var parent = el.parentNode;
+ if (parent) {
+ parent.removeChild(el);
+ }
+ },
+
+ // @function empty(el: HTMLElement)
+ // Removes all of `el`'s children elements from `el`
+ empty: function (el) {
+ while (el.firstChild) {
+ el.removeChild(el.firstChild);
+ }
+ },
+
+ // @function toFront(el: HTMLElement)
+ // Makes `el` the last children of its parent, so it renders in front of the other children.
+ toFront: function (el) {
+ el.parentNode.appendChild(el);
+ },
+
+ // @function toBack(el: HTMLElement)
+ // Makes `el` the first children of its parent, so it renders back from the other children.
+ toBack: function (el) {
+ var parent = el.parentNode;
+ parent.insertBefore(el, parent.firstChild);
+ },
+
+ // @function hasClass(el: HTMLElement, name: String): Boolean
+ // Returns `true` if the element's class attribute contains `name`.
+ hasClass: function (el, name) {
+ if (el.classList !== undefined) {
+ return el.classList.contains(name);
+ }
+ var className = L.DomUtil.getClass(el);
+ return className.length > 0 && new RegExp('(^|\\s)' + name + '(\\s|$)').test(className);
+ },
+
+ // @function addClass(el: HTMLElement, name: String)
+ // Adds `name` to the element's class attribute.
+ addClass: function (el, name) {
+ if (el.classList !== undefined) {
+ var classes = L.Util.splitWords(name);
+ for (var i = 0, len = classes.length; i < len; i++) {
+ el.classList.add(classes[i]);
+ }
+ } else if (!L.DomUtil.hasClass(el, name)) {
+ var className = L.DomUtil.getClass(el);
+ L.DomUtil.setClass(el, (className ? className + ' ' : '') + name);
+ }
+ },
+
+ // @function removeClass(el: HTMLElement, name: String)
+ // Removes `name` from the element's class attribute.
+ removeClass: function (el, name) {
+ if (el.classList !== undefined) {
+ el.classList.remove(name);
+ } else {
+ L.DomUtil.setClass(el, L.Util.trim((' ' + L.DomUtil.getClass(el) + ' ').replace(' ' + name + ' ', ' ')));
+ }
+ },
+
+ // @function setClass(el: HTMLElement, name: String)
+ // Sets the element's class.
+ setClass: function (el, name) {
+ if (el.className.baseVal === undefined) {
+ el.className = name;
+ } else {
+ // in case of SVG element
+ el.className.baseVal = name;
+ }
+ },
+
+ // @function getClass(el: HTMLElement): String
+ // Returns the element's class.
+ getClass: function (el) {
+ return el.className.baseVal === undefined ? el.className : el.className.baseVal;
+ },
+
+ // @function setOpacity(el: HTMLElement, opacity: Number)
+ // Set the opacity of an element (including old IE support).
+ // `opacity` must be a number from `0` to `1`.
+ setOpacity: function (el, value) {
+
+ if ('opacity' in el.style) {
+ el.style.opacity = value;
+
+ } else if ('filter' in el.style) {
+ L.DomUtil._setOpacityIE(el, value);
+ }
+ },
+
+ _setOpacityIE: function (el, value) {
+ var filter = false,
+ filterName = 'DXImageTransform.Microsoft.Alpha';
+
+ // filters collection throws an error if we try to retrieve a filter that doesn't exist
+ try {
+ filter = el.filters.item(filterName);
+ } catch (e) {
+ // don't set opacity to 1 if we haven't already set an opacity,
+ // it isn't needed and breaks transparent pngs.
+ if (value === 1) { return; }
+ }
+
+ value = Math.round(value * 100);
+
+ if (filter) {
+ filter.Enabled = (value !== 100);
+ filter.Opacity = value;
+ } else {
+ el.style.filter += ' progid:' + filterName + '(opacity=' + value + ')';
+ }
+ },
+
+ // @function testProp(props: String[]): String|false
+ // Goes through the array of style names and returns the first name
+ // that is a valid style name for an element. If no such name is found,
+ // it returns false. Useful for vendor-prefixed styles like `transform`.
+ testProp: function (props) {
+
+ var style = document.documentElement.style;
+
+ for (var i = 0; i < props.length; i++) {
+ if (props[i] in style) {
+ return props[i];
+ }
+ }
+ return false;
+ },
+
+ // @function setTransform(el: HTMLElement, offset: Point, scale?: Number)
+ // Resets the 3D CSS transform of `el` so it is translated by `offset` pixels
+ // and optionally scaled by `scale`. Does not have an effect if the
+ // browser doesn't support 3D CSS transforms.
+ setTransform: function (el, offset, scale) {
+ var pos = offset || new L.Point(0, 0);
+
+ el.style[L.DomUtil.TRANSFORM] =
+ (L.Browser.ie3d ?
+ 'translate(' + pos.x + 'px,' + pos.y + 'px)' :
+ 'translate3d(' + pos.x + 'px,' + pos.y + 'px,0)') +
+ (scale ? ' scale(' + scale + ')' : '');
+ },
+
+ // @function setPosition(el: HTMLElement, position: Point)
+ // Sets the position of `el` to coordinates specified by `position`,
+ // using CSS translate or top/left positioning depending on the browser
+ // (used by Leaflet internally to position its layers).
+ setPosition: function (el, point) { // (HTMLElement, Point[, Boolean])
+
+ /*eslint-disable */
+ el._leaflet_pos = point;
+ /*eslint-enable */
+
+ if (L.Browser.any3d) {
+ L.DomUtil.setTransform(el, point);
+ } else {
+ el.style.left = point.x + 'px';
+ el.style.top = point.y + 'px';
+ }
+ },
+
+ // @function getPosition(el: HTMLElement): Point
+ // Returns the coordinates of an element previously positioned with setPosition.
+ getPosition: function (el) {
+ // this method is only used for elements previously positioned using setPosition,
+ // so it's safe to cache the position for performance
+
+ return el._leaflet_pos || new L.Point(0, 0);
+ }
+};
+
+
+(function () {
+ // prefix style property names
+
+ // @property TRANSFORM: String
+ // Vendor-prefixed fransform style name (e.g. `'webkitTransform'` for WebKit).
+ L.DomUtil.TRANSFORM = L.DomUtil.testProp(
+ ['transform', 'WebkitTransform', 'OTransform', 'MozTransform', 'msTransform']);
+
+
+ // webkitTransition comes first because some browser versions that drop vendor prefix don't do
+ // the same for the transitionend event, in particular the Android 4.1 stock browser
+
+ // @property TRANSITION: String
+ // Vendor-prefixed transform style name.
+ var transition = L.DomUtil.TRANSITION = L.DomUtil.testProp(
+ ['webkitTransition', 'transition', 'OTransition', 'MozTransition', 'msTransition']);
+
+ L.DomUtil.TRANSITION_END =
+ transition === 'webkitTransition' || transition === 'OTransition' ? transition + 'End' : 'transitionend';
+
+ // @function disableTextSelection()
+ // Prevents the user from generating `selectstart` DOM events, usually generated
+ // when the user drags the mouse through a page with text. Used internally
+ // by Leaflet to override the behaviour of any click-and-drag interaction on
+ // the map. Affects drag interactions on the whole document.
+
+ // @function enableTextSelection()
+ // Cancels the effects of a previous [`L.DomUtil.disableTextSelection`](#domutil-disabletextselection).
+ if ('onselectstart' in document) {
+ L.DomUtil.disableTextSelection = function () {
+ L.DomEvent.on(window, 'selectstart', L.DomEvent.preventDefault);
+ };
+ L.DomUtil.enableTextSelection = function () {
+ L.DomEvent.off(window, 'selectstart', L.DomEvent.preventDefault);
+ };
+
+ } else {
+ var userSelectProperty = L.DomUtil.testProp(
+ ['userSelect', 'WebkitUserSelect', 'OUserSelect', 'MozUserSelect', 'msUserSelect']);
+
+ L.DomUtil.disableTextSelection = function () {
+ if (userSelectProperty) {
+ var style = document.documentElement.style;
+ this._userSelect = style[userSelectProperty];
+ style[userSelectProperty] = 'none';
+ }
+ };
+ L.DomUtil.enableTextSelection = function () {
+ if (userSelectProperty) {
+ document.documentElement.style[userSelectProperty] = this._userSelect;
+ delete this._userSelect;
+ }
+ };
+ }
+
+ // @function disableImageDrag()
+ // As [`L.DomUtil.disableTextSelection`](#domutil-disabletextselection), but
+ // for `dragstart` DOM events, usually generated when the user drags an image.
+ L.DomUtil.disableImageDrag = function () {
+ L.DomEvent.on(window, 'dragstart', L.DomEvent.preventDefault);
+ };
+
+ // @function enableImageDrag()
+ // Cancels the effects of a previous [`L.DomUtil.disableImageDrag`](#domutil-disabletextselection).
+ L.DomUtil.enableImageDrag = function () {
+ L.DomEvent.off(window, 'dragstart', L.DomEvent.preventDefault);
+ };
+
+ // @function preventOutline(el: HTMLElement)
+ // Makes the [outline](https://developer.mozilla.org/docs/Web/CSS/outline)
+ // of the element `el` invisible. Used internally by Leaflet to prevent
+ // focusable elements from displaying an outline when the user performs a
+ // drag interaction on them.
+ L.DomUtil.preventOutline = function (element) {
+ while (element.tabIndex === -1) {
+ element = element.parentNode;
+ }
+ if (!element || !element.style) { return; }
+ L.DomUtil.restoreOutline();
+ this._outlineElement = element;
+ this._outlineStyle = element.style.outline;
+ element.style.outline = 'none';
+ L.DomEvent.on(window, 'keydown', L.DomUtil.restoreOutline, this);
+ };
+
+ // @function restoreOutline()
+ // Cancels the effects of a previous [`L.DomUtil.preventOutline`]().
+ L.DomUtil.restoreOutline = function () {
+ if (!this._outlineElement) { return; }
+ this._outlineElement.style.outline = this._outlineStyle;
+ delete this._outlineElement;
+ delete this._outlineStyle;
+ L.DomEvent.off(window, 'keydown', L.DomUtil.restoreOutline, this);
+ };
+})();
+
+
+
+/* @class LatLng
+ * @aka L.LatLng
+ *
+ * Represents a geographical point with a certain latitude and longitude.
+ *
+ * @example
+ *
+ * ```
+ * var latlng = L.latLng(50.5, 30.5);
+ * ```
+ *
+ * All Leaflet methods that accept LatLng objects also accept them in a simple Array form and simple object form (unless noted otherwise), so these lines are equivalent:
+ *
+ * ```
+ * map.panTo([50, 30]);
+ * map.panTo({lon: 30, lat: 50});
+ * map.panTo({lat: 50, lng: 30});
+ * map.panTo(L.latLng(50, 30));
+ * ```
+ */
+
+L.LatLng = function (lat, lng, alt) {
+ if (isNaN(lat) || isNaN(lng)) {
+ throw new Error('Invalid LatLng object: (' + lat + ', ' + lng + ')');
+ }
+
+ // @property lat: Number
+ // Latitude in degrees
+ this.lat = +lat;
+
+ // @property lng: Number
+ // Longitude in degrees
+ this.lng = +lng;
+
+ // @property alt: Number
+ // Altitude in meters (optional)
+ if (alt !== undefined) {
+ this.alt = +alt;
+ }
+};
+
+L.LatLng.prototype = {
+ // @method equals(otherLatLng: LatLng, maxMargin?: Number): Boolean
+ // Returns `true` if the given `LatLng` point is at the same position (within a small margin of error). The margin of error can be overriden by setting `maxMargin` to a small number.
+ equals: function (obj, maxMargin) {
+ if (!obj) { return false; }
+
+ obj = L.latLng(obj);
+
+ var margin = Math.max(
+ Math.abs(this.lat - obj.lat),
+ Math.abs(this.lng - obj.lng));
+
+ return margin <= (maxMargin === undefined ? 1.0E-9 : maxMargin);
+ },
+
+ // @method toString(): String
+ // Returns a string representation of the point (for debugging purposes).
+ toString: function (precision) {
+ return 'LatLng(' +
+ L.Util.formatNum(this.lat, precision) + ', ' +
+ L.Util.formatNum(this.lng, precision) + ')';
+ },
+
+ // @method distanceTo(otherLatLng: LatLng): Number
+ // Returns the distance (in meters) to the given `LatLng` calculated using the [Haversine formula](http://en.wikipedia.org/wiki/Haversine_formula).
+ distanceTo: function (other) {
+ return L.CRS.Earth.distance(this, L.latLng(other));
+ },
+
+ // @method wrap(): LatLng
+ // Returns a new `LatLng` object with the longitude wrapped so it's always between -180 and +180 degrees.
+ wrap: function () {
+ return L.CRS.Earth.wrapLatLng(this);
+ },
+
+ // @method toBounds(sizeInMeters: Number): LatLngBounds
+ // Returns a new `LatLngBounds` object in which each boundary is `sizeInMeters/2` meters apart from the `LatLng`.
+ toBounds: function (sizeInMeters) {
+ var latAccuracy = 180 * sizeInMeters / 40075017,
+ lngAccuracy = latAccuracy / Math.cos((Math.PI / 180) * this.lat);
+
+ return L.latLngBounds(
+ [this.lat - latAccuracy, this.lng - lngAccuracy],
+ [this.lat + latAccuracy, this.lng + lngAccuracy]);
+ },
+
+ clone: function () {
+ return new L.LatLng(this.lat, this.lng, this.alt);
+ }
+};
+
+
+
+// @factory L.latLng(latitude: Number, longitude: Number, altitude?: Number): LatLng
+// Creates an object representing a geographical point with the given latitude and longitude (and optionally altitude).
+
+// @alternative
+// @factory L.latLng(coords: Array): LatLng
+// Expects an array of the form `[Number, Number]` or `[Number, Number, Number]` instead.
+
+// @alternative
+// @factory L.latLng(coords: Object): LatLng
+// Expects an plain object of the form `{lat: Number, lng: Number}` or `{lat: Number, lng: Number, alt: Number}` instead.
+
+L.latLng = function (a, b, c) {
+ if (a instanceof L.LatLng) {
+ return a;
+ }
+ if (L.Util.isArray(a) && typeof a[0] !== 'object') {
+ if (a.length === 3) {
+ return new L.LatLng(a[0], a[1], a[2]);
+ }
+ if (a.length === 2) {
+ return new L.LatLng(a[0], a[1]);
+ }
+ return null;
+ }
+ if (a === undefined || a === null) {
+ return a;
+ }
+ if (typeof a === 'object' && 'lat' in a) {
+ return new L.LatLng(a.lat, 'lng' in a ? a.lng : a.lon, a.alt);
+ }
+ if (b === undefined) {
+ return null;
+ }
+ return new L.LatLng(a, b, c);
+};
+
+
+
+/*
+ * @class LatLngBounds
+ * @aka L.LatLngBounds
+ *
+ * Represents a rectangular geographical area on a map.
+ *
+ * @example
+ *
+ * ```js
+ * var corner1 = L.latLng(40.712, -74.227),
+ * corner2 = L.latLng(40.774, -74.125),
+ * bounds = L.latLngBounds(corner1, corner2);
+ * ```
+ *
+ * All Leaflet methods that accept LatLngBounds objects also accept them in a simple Array form (unless noted otherwise), so the bounds example above can be passed like this:
+ *
+ * ```js
+ * map.fitBounds([
+ * [40.712, -74.227],
+ * [40.774, -74.125]
+ * ]);
+ * ```
+ *
+ * Caution: if the area crosses the antimeridian (often confused with the International Date Line), you must specify corners _outside_ the [-180, 180] degrees longitude range.
+ */
+
+L.LatLngBounds = function (corner1, corner2) { // (LatLng, LatLng) or (LatLng[])
+ if (!corner1) { return; }
+
+ var latlngs = corner2 ? [corner1, corner2] : corner1;
+
+ for (var i = 0, len = latlngs.length; i < len; i++) {
+ this.extend(latlngs[i]);
+ }
+};
+
+L.LatLngBounds.prototype = {
+
+ // @method extend(latlng: LatLng): this
+ // Extend the bounds to contain the given point
+
+ // @alternative
+ // @method extend(otherBounds: LatLngBounds): this
+ // Extend the bounds to contain the given bounds
+ extend: function (obj) {
+ var sw = this._southWest,
+ ne = this._northEast,
+ sw2, ne2;
+
+ if (obj instanceof L.LatLng) {
+ sw2 = obj;
+ ne2 = obj;
+
+ } else if (obj instanceof L.LatLngBounds) {
+ sw2 = obj._southWest;
+ ne2 = obj._northEast;
+
+ if (!sw2 || !ne2) { return this; }
+
+ } else {
+ return obj ? this.extend(L.latLng(obj) || L.latLngBounds(obj)) : this;
+ }
+
+ if (!sw && !ne) {
+ this._southWest = new L.LatLng(sw2.lat, sw2.lng);
+ this._northEast = new L.LatLng(ne2.lat, ne2.lng);
+ } else {
+ sw.lat = Math.min(sw2.lat, sw.lat);
+ sw.lng = Math.min(sw2.lng, sw.lng);
+ ne.lat = Math.max(ne2.lat, ne.lat);
+ ne.lng = Math.max(ne2.lng, ne.lng);
+ }
+
+ return this;
+ },
+
+ // @method pad(bufferRatio: Number): LatLngBounds
+ // Returns bigger bounds created by extending the current bounds by a given percentage in each direction.
+ pad: function (bufferRatio) {
+ var sw = this._southWest,
+ ne = this._northEast,
+ heightBuffer = Math.abs(sw.lat - ne.lat) * bufferRatio,
+ widthBuffer = Math.abs(sw.lng - ne.lng) * bufferRatio;
+
+ return new L.LatLngBounds(
+ new L.LatLng(sw.lat - heightBuffer, sw.lng - widthBuffer),
+ new L.LatLng(ne.lat + heightBuffer, ne.lng + widthBuffer));
+ },
+
+ // @method getCenter(): LatLng
+ // Returns the center point of the bounds.
+ getCenter: function () {
+ return new L.LatLng(
+ (this._southWest.lat + this._northEast.lat) / 2,
+ (this._southWest.lng + this._northEast.lng) / 2);
+ },
+
+ // @method getSouthWest(): LatLng
+ // Returns the south-west point of the bounds.
+ getSouthWest: function () {
+ return this._southWest;
+ },
+
+ // @method getNorthEast(): LatLng
+ // Returns the north-east point of the bounds.
+ getNorthEast: function () {
+ return this._northEast;
+ },
+
+ // @method getNorthWest(): LatLng
+ // Returns the north-west point of the bounds.
+ getNorthWest: function () {
+ return new L.LatLng(this.getNorth(), this.getWest());
+ },
+
+ // @method getSouthEast(): LatLng
+ // Returns the south-east point of the bounds.
+ getSouthEast: function () {
+ return new L.LatLng(this.getSouth(), this.getEast());
+ },
+
+ // @method getWest(): Number
+ // Returns the west longitude of the bounds
+ getWest: function () {
+ return this._southWest.lng;
+ },
+
+ // @method getSouth(): Number
+ // Returns the south latitude of the bounds
+ getSouth: function () {
+ return this._southWest.lat;
+ },
+
+ // @method getEast(): Number
+ // Returns the east longitude of the bounds
+ getEast: function () {
+ return this._northEast.lng;
+ },
+
+ // @method getNorth(): Number
+ // Returns the north latitude of the bounds
+ getNorth: function () {
+ return this._northEast.lat;
+ },
+
+ // @method contains(otherBounds: LatLngBounds): Boolean
+ // Returns `true` if the rectangle contains the given one.
+
+ // @alternative
+ // @method contains (latlng: LatLng): Boolean
+ // Returns `true` if the rectangle contains the given point.
+ contains: function (obj) { // (LatLngBounds) or (LatLng) -> Boolean
+ if (typeof obj[0] === 'number' || obj instanceof L.LatLng || 'lat' in obj) {
+ obj = L.latLng(obj);
+ } else {
+ obj = L.latLngBounds(obj);
+ }
+
+ var sw = this._southWest,
+ ne = this._northEast,
+ sw2, ne2;
+
+ if (obj instanceof L.LatLngBounds) {
+ sw2 = obj.getSouthWest();
+ ne2 = obj.getNorthEast();
+ } else {
+ sw2 = ne2 = obj;
+ }
+
+ return (sw2.lat >= sw.lat) && (ne2.lat <= ne.lat) &&
+ (sw2.lng >= sw.lng) && (ne2.lng <= ne.lng);
+ },
+
+ // @method intersects(otherBounds: LatLngBounds): Boolean
+ // Returns `true` if the rectangle intersects the given bounds. Two bounds intersect if they have at least one point in common.
+ intersects: function (bounds) {
+ bounds = L.latLngBounds(bounds);
+
+ var sw = this._southWest,
+ ne = this._northEast,
+ sw2 = bounds.getSouthWest(),
+ ne2 = bounds.getNorthEast(),
+
+ latIntersects = (ne2.lat >= sw.lat) && (sw2.lat <= ne.lat),
+ lngIntersects = (ne2.lng >= sw.lng) && (sw2.lng <= ne.lng);
+
+ return latIntersects && lngIntersects;
+ },
+
+ // @method overlaps(otherBounds: Bounds): Boolean
+ // Returns `true` if the rectangle overlaps the given bounds. Two bounds overlap if their intersection is an area.
+ overlaps: function (bounds) {
+ bounds = L.latLngBounds(bounds);
+
+ var sw = this._southWest,
+ ne = this._northEast,
+ sw2 = bounds.getSouthWest(),
+ ne2 = bounds.getNorthEast(),
+
+ latOverlaps = (ne2.lat > sw.lat) && (sw2.lat < ne.lat),
+ lngOverlaps = (ne2.lng > sw.lng) && (sw2.lng < ne.lng);
+
+ return latOverlaps && lngOverlaps;
+ },
+
+ // @method toBBoxString(): String
+ // Returns a string with bounding box coordinates in a 'southwest_lng,southwest_lat,northeast_lng,northeast_lat' format. Useful for sending requests to web services that return geo data.
+ toBBoxString: function () {
+ return [this.getWest(), this.getSouth(), this.getEast(), this.getNorth()].join(',');
+ },
+
+ // @method equals(otherBounds: LatLngBounds): Boolean
+ // Returns `true` if the rectangle is equivalent (within a small margin of error) to the given bounds.
+ equals: function (bounds) {
+ if (!bounds) { return false; }
+
+ bounds = L.latLngBounds(bounds);
+
+ return this._southWest.equals(bounds.getSouthWest()) &&
+ this._northEast.equals(bounds.getNorthEast());
+ },
+
+ // @method isValid(): Boolean
+ // Returns `true` if the bounds are properly initialized.
+ isValid: function () {
+ return !!(this._southWest && this._northEast);
+ }
+};
+
+// TODO International date line?
+
+// @factory L.latLngBounds(corner1: LatLng, corner2: LatLng)
+// Creates a `LatLngBounds` object by defining two diagonally opposite corners of the rectangle.
+
+// @alternative
+// @factory L.latLngBounds(latlngs: LatLng[])
+// Creates a `LatLngBounds` object defined by the geographical points it contains. Very useful for zooming the map to fit a particular set of locations with [`fitBounds`](#map-fitbounds).
+L.latLngBounds = function (a, b) {
+ if (a instanceof L.LatLngBounds) {
+ return a;
+ }
+ return new L.LatLngBounds(a, b);
+};
+
+
+
+/*
+ * @namespace Projection
+ * @section
+ * Leaflet comes with a set of already defined Projections out of the box:
+ *
+ * @projection L.Projection.LonLat
+ *
+ * Equirectangular, or Plate Carree projection — the most simple projection,
+ * mostly used by GIS enthusiasts. Directly maps `x` as longitude, and `y` as
+ * latitude. Also suitable for flat worlds, e.g. game maps. Used by the
+ * `EPSG:3395` and `Simple` CRS.
+ */
+
+L.Projection = {};
+
+L.Projection.LonLat = {
+ project: function (latlng) {
+ return new L.Point(latlng.lng, latlng.lat);
+ },
+
+ unproject: function (point) {
+ return new L.LatLng(point.y, point.x);
+ },
+
+ bounds: L.bounds([-180, -90], [180, 90])
+};
+
+
+
+/*
+ * @namespace Projection
+ * @projection L.Projection.SphericalMercator
+ *
+ * Spherical Mercator projection — the most common projection for online maps,
+ * used by almost all free and commercial tile providers. Assumes that Earth is
+ * a sphere. Used by the `EPSG:3857` CRS.
+ */
+
+L.Projection.SphericalMercator = {
+
+ R: 6378137,
+ MAX_LATITUDE: 85.0511287798,
+
+ project: function (latlng) {
+ var d = Math.PI / 180,
+ max = this.MAX_LATITUDE,
+ lat = Math.max(Math.min(max, latlng.lat), -max),
+ sin = Math.sin(lat * d);
+
+ return new L.Point(
+ this.R * latlng.lng * d,
+ this.R * Math.log((1 + sin) / (1 - sin)) / 2);
+ },
+
+ unproject: function (point) {
+ var d = 180 / Math.PI;
+
+ return new L.LatLng(
+ (2 * Math.atan(Math.exp(point.y / this.R)) - (Math.PI / 2)) * d,
+ point.x * d / this.R);
+ },
+
+ bounds: (function () {
+ var d = 6378137 * Math.PI;
+ return L.bounds([-d, -d], [d, d]);
+ })()
+};
+
+
+
+/*
+ * @class CRS
+ * @aka L.CRS
+ * Abstract class that defines coordinate reference systems for projecting
+ * geographical points into pixel (screen) coordinates and back (and to
+ * coordinates in other units for [WMS](https://en.wikipedia.org/wiki/Web_Map_Service) services). See
+ * [spatial reference system](http://en.wikipedia.org/wiki/Coordinate_reference_system).
+ *
+ * Leaflet defines the most usual CRSs by default. If you want to use a
+ * CRS not defined by default, take a look at the
+ * [Proj4Leaflet](https://github.com/kartena/Proj4Leaflet) plugin.
+ */
+
+L.CRS = {
+ // @method latLngToPoint(latlng: LatLng, zoom: Number): Point
+ // Projects geographical coordinates into pixel coordinates for a given zoom.
+ latLngToPoint: function (latlng, zoom) {
+ var projectedPoint = this.projection.project(latlng),
+ scale = this.scale(zoom);
+
+ return this.transformation._transform(projectedPoint, scale);
+ },
+
+ // @method pointToLatLng(point: Point, zoom: Number): LatLng
+ // The inverse of `latLngToPoint`. Projects pixel coordinates on a given
+ // zoom into geographical coordinates.
+ pointToLatLng: function (point, zoom) {
+ var scale = this.scale(zoom),
+ untransformedPoint = this.transformation.untransform(point, scale);
+
+ return this.projection.unproject(untransformedPoint);
+ },
+
+ // @method project(latlng: LatLng): Point
+ // Projects geographical coordinates into coordinates in units accepted for
+ // this CRS (e.g. meters for EPSG:3857, for passing it to WMS services).
+ project: function (latlng) {
+ return this.projection.project(latlng);
+ },
+
+ // @method unproject(point: Point): LatLng
+ // Given a projected coordinate returns the corresponding LatLng.
+ // The inverse of `project`.
+ unproject: function (point) {
+ return this.projection.unproject(point);
+ },
+
+ // @method scale(zoom: Number): Number
+ // Returns the scale used when transforming projected coordinates into
+ // pixel coordinates for a particular zoom. For example, it returns
+ // `256 * 2^zoom` for Mercator-based CRS.
+ scale: function (zoom) {
+ return 256 * Math.pow(2, zoom);
+ },
+
+ // @method zoom(scale: Number): Number
+ // Inverse of `scale()`, returns the zoom level corresponding to a scale
+ // factor of `scale`.
+ zoom: function (scale) {
+ return Math.log(scale / 256) / Math.LN2;
+ },
+
+ // @method getProjectedBounds(zoom: Number): Bounds
+ // Returns the projection's bounds scaled and transformed for the provided `zoom`.
+ getProjectedBounds: function (zoom) {
+ if (this.infinite) { return null; }
+
+ var b = this.projection.bounds,
+ s = this.scale(zoom),
+ min = this.transformation.transform(b.min, s),
+ max = this.transformation.transform(b.max, s);
+
+ return L.bounds(min, max);
+ },
+
+ // @method distance(latlng1: LatLng, latlng2: LatLng): Number
+ // Returns the distance between two geographical coordinates.
+
+ // @property code: String
+ // Standard code name of the CRS passed into WMS services (e.g. `'EPSG:3857'`)
+ //
+ // @property wrapLng: Number[]
+ // An array of two numbers defining whether the longitude (horizontal) coordinate
+ // axis wraps around a given range and how. Defaults to `[-180, 180]` in most
+ // geographical CRSs. If `undefined`, the longitude axis does not wrap around.
+ //
+ // @property wrapLat: Number[]
+ // Like `wrapLng`, but for the latitude (vertical) axis.
+
+ // wrapLng: [min, max],
+ // wrapLat: [min, max],
+
+ // @property infinite: Boolean
+ // If true, the coordinate space will be unbounded (infinite in both axes)
+ infinite: false,
+
+ // @method wrapLatLng(latlng: LatLng): LatLng
+ // Returns a `LatLng` where lat and lng has been wrapped according to the
+ // CRS's `wrapLat` and `wrapLng` properties, if they are outside the CRS's bounds.
+ // Only accepts actual `L.LatLng` instances, not arrays.
+ wrapLatLng: function (latlng) {
+ var lng = this.wrapLng ? L.Util.wrapNum(latlng.lng, this.wrapLng, true) : latlng.lng,
+ lat = this.wrapLat ? L.Util.wrapNum(latlng.lat, this.wrapLat, true) : latlng.lat,
+ alt = latlng.alt;
+
+ return L.latLng(lat, lng, alt);
+ },
+
+ // @method wrapLatLngBounds(bounds: LatLngBounds): LatLngBounds
+ // Returns a `LatLngBounds` with the same size as the given one, ensuring
+ // that its center is within the CRS's bounds.
+ // Only accepts actual `L.LatLngBounds` instances, not arrays.
+ wrapLatLngBounds: function (bounds) {
+ var center = bounds.getCenter(),
+ newCenter = this.wrapLatLng(center),
+ latShift = center.lat - newCenter.lat,
+ lngShift = center.lng - newCenter.lng;
+
+ if (latShift === 0 && lngShift === 0) {
+ return bounds;
+ }
+
+ var sw = bounds.getSouthWest(),
+ ne = bounds.getNorthEast(),
+ newSw = L.latLng({lat: sw.lat - latShift, lng: sw.lng - lngShift}),
+ newNe = L.latLng({lat: ne.lat - latShift, lng: ne.lng - lngShift});
+
+ return new L.LatLngBounds(newSw, newNe);
+ }
+};
+
+
+
+/*
+ * @namespace CRS
+ * @crs L.CRS.Simple
+ *
+ * A simple CRS that maps longitude and latitude into `x` and `y` directly.
+ * May be used for maps of flat surfaces (e.g. game maps). Note that the `y`
+ * axis should still be inverted (going from bottom to top). `distance()` returns
+ * simple euclidean distance.
+ */
+
+L.CRS.Simple = L.extend({}, L.CRS, {
+ projection: L.Projection.LonLat,
+ transformation: new L.Transformation(1, 0, -1, 0),
+
+ scale: function (zoom) {
+ return Math.pow(2, zoom);
+ },
+
+ zoom: function (scale) {
+ return Math.log(scale) / Math.LN2;
+ },
+
+ distance: function (latlng1, latlng2) {
+ var dx = latlng2.lng - latlng1.lng,
+ dy = latlng2.lat - latlng1.lat;
+
+ return Math.sqrt(dx * dx + dy * dy);
+ },
+
+ infinite: true
+});
+
+
+
+/*
+ * @namespace CRS
+ * @crs L.CRS.Earth
+ *
+ * Serves as the base for CRS that are global such that they cover the earth.
+ * Can only be used as the base for other CRS and cannot be used directly,
+ * since it does not have a `code`, `projection` or `transformation`. `distance()` returns
+ * meters.
+ */
+
+L.CRS.Earth = L.extend({}, L.CRS, {
+ wrapLng: [-180, 180],
+
+ // Mean Earth Radius, as recommended for use by
+ // the International Union of Geodesy and Geophysics,
+ // see http://rosettacode.org/wiki/Haversine_formula
+ R: 6371000,
+
+ // distance between two geographical points using spherical law of cosines approximation
+ distance: function (latlng1, latlng2) {
+ var rad = Math.PI / 180,
+ lat1 = latlng1.lat * rad,
+ lat2 = latlng2.lat * rad,
+ a = Math.sin(lat1) * Math.sin(lat2) +
+ Math.cos(lat1) * Math.cos(lat2) * Math.cos((latlng2.lng - latlng1.lng) * rad);
+
+ return this.R * Math.acos(Math.min(a, 1));
+ }
+});
+
+
+
+/*
+ * @namespace CRS
+ * @crs L.CRS.EPSG3857
+ *
+ * The most common CRS for online maps, used by almost all free and commercial
+ * tile providers. Uses Spherical Mercator projection. Set in by default in
+ * Map's `crs` option.
+ */
+
+L.CRS.EPSG3857 = L.extend({}, L.CRS.Earth, {
+ code: 'EPSG:3857',
+ projection: L.Projection.SphericalMercator,
+
+ transformation: (function () {
+ var scale = 0.5 / (Math.PI * L.Projection.SphericalMercator.R);
+ return new L.Transformation(scale, 0.5, -scale, 0.5);
+ }())
+});
+
+L.CRS.EPSG900913 = L.extend({}, L.CRS.EPSG3857, {
+ code: 'EPSG:900913'
+});
+
+
+
+/*
+ * @namespace CRS
+ * @crs L.CRS.EPSG4326
+ *
+ * A common CRS among GIS enthusiasts. Uses simple Equirectangular projection.
+ *
+ * Leaflet 1.0.x complies with the [TMS coordinate scheme for EPSG:4326](https://wiki.osgeo.org/wiki/Tile_Map_Service_Specification#global-geodetic),
+ * which is a breaking change from 0.7.x behaviour. If you are using a `TileLayer`
+ * with this CRS, ensure that there are two 256x256 pixel tiles covering the
+ * whole earth at zoom level zero, and that the tile coordinate origin is (-180,+90),
+ * or (-180,-90) for `TileLayer`s with [the `tms` option](#tilelayer-tms) set.
+ */
+
+L.CRS.EPSG4326 = L.extend({}, L.CRS.Earth, {
+ code: 'EPSG:4326',
+ projection: L.Projection.LonLat,
+ transformation: new L.Transformation(1 / 180, 1, -1 / 180, 0.5)
+});
+
+
+
+/*
+ * @class Map
+ * @aka L.Map
+ * @inherits Evented
+ *
+ * The central class of the API — it is used to create a map on a page and manipulate it.
+ *
+ * @example
+ *
+ * ```js
+ * // initialize the map on the "map" div with a given center and zoom
+ * var map = L.map('map', {
+ * center: [51.505, -0.09],
+ * zoom: 13
+ * });
+ * ```
+ *
+ */
+
+L.Map = L.Evented.extend({
+
+ options: {
+ // @section Map State Options
+ // @option crs: CRS = L.CRS.EPSG3857
+ // The [Coordinate Reference System](#crs) to use. Don't change this if you're not
+ // sure what it means.
+ crs: L.CRS.EPSG3857,
+
+ // @option center: LatLng = undefined
+ // Initial geographic center of the map
+ center: undefined,
+
+ // @option zoom: Number = undefined
+ // Initial map zoom level
+ zoom: undefined,
+
+ // @option minZoom: Number = undefined
+ // Minimum zoom level of the map. Overrides any `minZoom` option set on map layers.
+ minZoom: undefined,
+
+ // @option maxZoom: Number = undefined
+ // Maximum zoom level of the map. Overrides any `maxZoom` option set on map layers.
+ maxZoom: undefined,
+
+ // @option layers: Layer[] = []
+ // Array of layers that will be added to the map initially
+ layers: [],
+
+ // @option maxBounds: LatLngBounds = null
+ // When this option is set, the map restricts the view to the given
+ // geographical bounds, bouncing the user back if the user tries to pan
+ // outside the view. To set the restriction dynamically, use
+ // [`setMaxBounds`](#map-setmaxbounds) method.
+ maxBounds: undefined,
+
+ // @option renderer: Renderer = *
+ // The default method for drawing vector layers on the map. `L.SVG`
+ // or `L.Canvas` by default depending on browser support.
+ renderer: undefined,
+
+
+ // @section Animation Options
+ // @option zoomAnimation: Boolean = true
+ // Whether the map zoom animation is enabled. By default it's enabled
+ // in all browsers that support CSS3 Transitions except Android.
+ zoomAnimation: true,
+
+ // @option zoomAnimationThreshold: Number = 4
+ // Won't animate zoom if the zoom difference exceeds this value.
+ zoomAnimationThreshold: 4,
+
+ // @option fadeAnimation: Boolean = true
+ // Whether the tile fade animation is enabled. By default it's enabled
+ // in all browsers that support CSS3 Transitions except Android.
+ fadeAnimation: true,
+
+ // @option markerZoomAnimation: Boolean = true
+ // Whether markers animate their zoom with the zoom animation, if disabled
+ // they will disappear for the length of the animation. By default it's
+ // enabled in all browsers that support CSS3 Transitions except Android.
+ markerZoomAnimation: true,
+
+ // @option transform3DLimit: Number = 2^23
+ // Defines the maximum size of a CSS translation transform. The default
+ // value should not be changed unless a web browser positions layers in
+ // the wrong place after doing a large `panBy`.
+ transform3DLimit: 8388608, // Precision limit of a 32-bit float
+
+ // @section Interaction Options
+ // @option zoomSnap: Number = 1
+ // Forces the map's zoom level to always be a multiple of this, particularly
+ // right after a [`fitBounds()`](#map-fitbounds) or a pinch-zoom.
+ // By default, the zoom level snaps to the nearest integer; lower values
+ // (e.g. `0.5` or `0.1`) allow for greater granularity. A value of `0`
+ // means the zoom level will not be snapped after `fitBounds` or a pinch-zoom.
+ zoomSnap: 1,
+
+ // @option zoomDelta: Number = 1
+ // Controls how much the map's zoom level will change after a
+ // [`zoomIn()`](#map-zoomin), [`zoomOut()`](#map-zoomout), pressing `+`
+ // or `-` on the keyboard, or using the [zoom controls](#control-zoom).
+ // Values smaller than `1` (e.g. `0.5`) allow for greater granularity.
+ zoomDelta: 1,
+
+ // @option trackResize: Boolean = true
+ // Whether the map automatically handles browser window resize to update itself.
+ trackResize: true
+ },
+
+ initialize: function (id, options) { // (HTMLElement or String, Object)
+ options = L.setOptions(this, options);
+
+ this._initContainer(id);
+ this._initLayout();
+
+ // hack for https://github.com/Leaflet/Leaflet/issues/1980
+ this._onResize = L.bind(this._onResize, this);
+
+ this._initEvents();
+
+ if (options.maxBounds) {
+ this.setMaxBounds(options.maxBounds);
+ }
+
+ if (options.zoom !== undefined) {
+ this._zoom = this._limitZoom(options.zoom);
+ }
+
+ if (options.center && options.zoom !== undefined) {
+ this.setView(L.latLng(options.center), options.zoom, {reset: true});
+ }
+
+ this._handlers = [];
+ this._layers = {};
+ this._zoomBoundLayers = {};
+ this._sizeChanged = true;
+
+ this.callInitHooks();
+
+ // don't animate on browsers without hardware-accelerated transitions or old Android/Opera
+ this._zoomAnimated = L.DomUtil.TRANSITION && L.Browser.any3d && !L.Browser.mobileOpera &&
+ this.options.zoomAnimation;
+
+ // zoom transitions run with the same duration for all layers, so if one of transitionend events
+ // happens after starting zoom animation (propagating to the map pane), we know that it ended globally
+ if (this._zoomAnimated) {
+ this._createAnimProxy();
+ L.DomEvent.on(this._proxy, L.DomUtil.TRANSITION_END, this._catchTransitionEnd, this);
+ }
+
+ this._addLayers(this.options.layers);
+ },
+
+
+ // @section Methods for modifying map state
+
+ // @method setView(center: LatLng, zoom: Number, options?: Zoom/pan options): this
+ // Sets the view of the map (geographical center and zoom) with the given
+ // animation options.
+ setView: function (center, zoom, options) {
+
+ zoom = zoom === undefined ? this._zoom : this._limitZoom(zoom);
+ center = this._limitCenter(L.latLng(center), zoom, this.options.maxBounds);
+ options = options || {};
+
+ this._stop();
+
+ if (this._loaded && !options.reset && options !== true) {
+
+ if (options.animate !== undefined) {
+ options.zoom = L.extend({animate: options.animate}, options.zoom);
+ options.pan = L.extend({animate: options.animate, duration: options.duration}, options.pan);
+ }
+
+ // try animating pan or zoom
+ var moved = (this._zoom !== zoom) ?
+ this._tryAnimatedZoom && this._tryAnimatedZoom(center, zoom, options.zoom) :
+ this._tryAnimatedPan(center, options.pan);
+
+ if (moved) {
+ // prevent resize handler call, the view will refresh after animation anyway
+ clearTimeout(this._sizeTimer);
+ return this;
+ }
+ }
+
+ // animation didn't start, just reset the map view
+ this._resetView(center, zoom);
+
+ return this;
+ },
+
+ // @method setZoom(zoom: Number, options: Zoom/pan options): this
+ // Sets the zoom of the map.
+ setZoom: function (zoom, options) {
+ if (!this._loaded) {
+ this._zoom = zoom;
+ return this;
+ }
+ return this.setView(this.getCenter(), zoom, {zoom: options});
+ },
+
+ // @method zoomIn(delta?: Number, options?: Zoom options): this
+ // Increases the zoom of the map by `delta` ([`zoomDelta`](#map-zoomdelta) by default).
+ zoomIn: function (delta, options) {
+ delta = delta || (L.Browser.any3d ? this.options.zoomDelta : 1);
+ return this.setZoom(this._zoom + delta, options);
+ },
+
+ // @method zoomOut(delta?: Number, options?: Zoom options): this
+ // Decreases the zoom of the map by `delta` ([`zoomDelta`](#map-zoomdelta) by default).
+ zoomOut: function (delta, options) {
+ delta = delta || (L.Browser.any3d ? this.options.zoomDelta : 1);
+ return this.setZoom(this._zoom - delta, options);
+ },
+
+ // @method setZoomAround(latlng: LatLng, zoom: Number, options: Zoom options): this
+ // Zooms the map while keeping a specified geographical point on the map
+ // stationary (e.g. used internally for scroll zoom and double-click zoom).
+ // @alternative
+ // @method setZoomAround(offset: Point, zoom: Number, options: Zoom options): this
+ // Zooms the map while keeping a specified pixel on the map (relative to the top-left corner) stationary.
+ setZoomAround: function (latlng, zoom, options) {
+ var scale = this.getZoomScale(zoom),
+ viewHalf = this.getSize().divideBy(2),
+ containerPoint = latlng instanceof L.Point ? latlng : this.latLngToContainerPoint(latlng),
+
+ centerOffset = containerPoint.subtract(viewHalf).multiplyBy(1 - 1 / scale),
+ newCenter = this.containerPointToLatLng(viewHalf.add(centerOffset));
+
+ return this.setView(newCenter, zoom, {zoom: options});
+ },
+
+ _getBoundsCenterZoom: function (bounds, options) {
+
+ options = options || {};
+ bounds = bounds.getBounds ? bounds.getBounds() : L.latLngBounds(bounds);
+
+ var paddingTL = L.point(options.paddingTopLeft || options.padding || [0, 0]),
+ paddingBR = L.point(options.paddingBottomRight || options.padding || [0, 0]),
+
+ zoom = this.getBoundsZoom(bounds, false, paddingTL.add(paddingBR));
+
+ zoom = (typeof options.maxZoom === 'number') ? Math.min(options.maxZoom, zoom) : zoom;
+
+ var paddingOffset = paddingBR.subtract(paddingTL).divideBy(2),
+
+ swPoint = this.project(bounds.getSouthWest(), zoom),
+ nePoint = this.project(bounds.getNorthEast(), zoom),
+ center = this.unproject(swPoint.add(nePoint).divideBy(2).add(paddingOffset), zoom);
+
+ return {
+ center: center,
+ zoom: zoom
+ };
+ },
+
+ // @method fitBounds(bounds: LatLngBounds, options?: fitBounds options): this
+ // Sets a map view that contains the given geographical bounds with the
+ // maximum zoom level possible.
+ fitBounds: function (bounds, options) {
+
+ bounds = L.latLngBounds(bounds);
+
+ if (!bounds.isValid()) {
+ throw new Error('Bounds are not valid.');
+ }
+
+ var target = this._getBoundsCenterZoom(bounds, options);
+ return this.setView(target.center, target.zoom, options);
+ },
+
+ // @method fitWorld(options?: fitBounds options): this
+ // Sets a map view that mostly contains the whole world with the maximum
+ // zoom level possible.
+ fitWorld: function (options) {
+ return this.fitBounds([[-90, -180], [90, 180]], options);
+ },
+
+ // @method panTo(latlng: LatLng, options?: Pan options): this
+ // Pans the map to a given center.
+ panTo: function (center, options) { // (LatLng)
+ return this.setView(center, this._zoom, {pan: options});
+ },
+
+ // @method panBy(offset: Point): this
+ // Pans the map by a given number of pixels (animated).
+ panBy: function (offset, options) {
+ offset = L.point(offset).round();
+ options = options || {};
+
+ if (!offset.x && !offset.y) {
+ return this.fire('moveend');
+ }
+ // If we pan too far, Chrome gets issues with tiles
+ // and makes them disappear or appear in the wrong place (slightly offset) #2602
+ if (options.animate !== true && !this.getSize().contains(offset)) {
+ this._resetView(this.unproject(this.project(this.getCenter()).add(offset)), this.getZoom());
+ return this;
+ }
+
+ if (!this._panAnim) {
+ this._panAnim = new L.PosAnimation();
+
+ this._panAnim.on({
+ 'step': this._onPanTransitionStep,
+ 'end': this._onPanTransitionEnd
+ }, this);
+ }
+
+ // don't fire movestart if animating inertia
+ if (!options.noMoveStart) {
+ this.fire('movestart');
+ }
+
+ // animate pan unless animate: false specified
+ if (options.animate !== false) {
+ L.DomUtil.addClass(this._mapPane, 'leaflet-pan-anim');
+
+ var newPos = this._getMapPanePos().subtract(offset).round();
+ this._panAnim.run(this._mapPane, newPos, options.duration || 0.25, options.easeLinearity);
+ } else {
+ this._rawPanBy(offset);
+ this.fire('move').fire('moveend');
+ }
+
+ return this;
+ },
+
+ // @method flyTo(latlng: LatLng, zoom?: Number, options?: Zoom/pan options): this
+ // Sets the view of the map (geographical center and zoom) performing a smooth
+ // pan-zoom animation.
+ flyTo: function (targetCenter, targetZoom, options) {
+
+ options = options || {};
+ if (options.animate === false || !L.Browser.any3d) {
+ return this.setView(targetCenter, targetZoom, options);
+ }
+
+ this._stop();
+
+ var from = this.project(this.getCenter()),
+ to = this.project(targetCenter),
+ size = this.getSize(),
+ startZoom = this._zoom;
+
+ targetCenter = L.latLng(targetCenter);
+ targetZoom = targetZoom === undefined ? startZoom : targetZoom;
+
+ var w0 = Math.max(size.x, size.y),
+ w1 = w0 * this.getZoomScale(startZoom, targetZoom),
+ u1 = (to.distanceTo(from)) || 1,
+ rho = 1.42,
+ rho2 = rho * rho;
+
+ function r(i) {
+ var s1 = i ? -1 : 1,
+ s2 = i ? w1 : w0,
+ t1 = w1 * w1 - w0 * w0 + s1 * rho2 * rho2 * u1 * u1,
+ b1 = 2 * s2 * rho2 * u1,
+ b = t1 / b1,
+ sq = Math.sqrt(b * b + 1) - b;
+
+ // workaround for floating point precision bug when sq = 0, log = -Infinite,
+ // thus triggering an infinite loop in flyTo
+ var log = sq < 0.000000001 ? -18 : Math.log(sq);
+
+ return log;
+ }
+
+ function sinh(n) { return (Math.exp(n) - Math.exp(-n)) / 2; }
+ function cosh(n) { return (Math.exp(n) + Math.exp(-n)) / 2; }
+ function tanh(n) { return sinh(n) / cosh(n); }
+
+ var r0 = r(0);
+
+ function w(s) { return w0 * (cosh(r0) / cosh(r0 + rho * s)); }
+ function u(s) { return w0 * (cosh(r0) * tanh(r0 + rho * s) - sinh(r0)) / rho2; }
+
+ function easeOut(t) { return 1 - Math.pow(1 - t, 1.5); }
+
+ var start = Date.now(),
+ S = (r(1) - r0) / rho,
+ duration = options.duration ? 1000 * options.duration : 1000 * S * 0.8;
+
+ function frame() {
+ var t = (Date.now() - start) / duration,
+ s = easeOut(t) * S;
+
+ if (t <= 1) {
+ this._flyToFrame = L.Util.requestAnimFrame(frame, this);
+
+ this._move(
+ this.unproject(from.add(to.subtract(from).multiplyBy(u(s) / u1)), startZoom),
+ this.getScaleZoom(w0 / w(s), startZoom),
+ {flyTo: true});
+
+ } else {
+ this
+ ._move(targetCenter, targetZoom)
+ ._moveEnd(true);
+ }
+ }
+
+ this._moveStart(true);
+
+ frame.call(this);
+ return this;
+ },
+
+ // @method flyToBounds(bounds: LatLngBounds, options?: fitBounds options): this
+ // Sets the view of the map with a smooth animation like [`flyTo`](#map-flyto),
+ // but takes a bounds parameter like [`fitBounds`](#map-fitbounds).
+ flyToBounds: function (bounds, options) {
+ var target = this._getBoundsCenterZoom(bounds, options);
+ return this.flyTo(target.center, target.zoom, options);
+ },
+
+ // @method setMaxBounds(bounds: Bounds): this
+ // Restricts the map view to the given bounds (see the [maxBounds](#map-maxbounds) option).
+ setMaxBounds: function (bounds) {
+ bounds = L.latLngBounds(bounds);
+
+ if (!bounds.isValid()) {
+ this.options.maxBounds = null;
+ return this.off('moveend', this._panInsideMaxBounds);
+ } else if (this.options.maxBounds) {
+ this.off('moveend', this._panInsideMaxBounds);
+ }
+
+ this.options.maxBounds = bounds;
+
+ if (this._loaded) {
+ this._panInsideMaxBounds();
+ }
+
+ return this.on('moveend', this._panInsideMaxBounds);
+ },
+
+ // @method setMinZoom(zoom: Number): this
+ // Sets the lower limit for the available zoom levels (see the [minZoom](#map-minzoom) option).
+ setMinZoom: function (zoom) {
+ this.options.minZoom = zoom;
+
+ if (this._loaded && this.getZoom() < this.options.minZoom) {
+ return this.setZoom(zoom);
+ }
+
+ return this;
+ },
+
+ // @method setMaxZoom(zoom: Number): this
+ // Sets the upper limit for the available zoom levels (see the [maxZoom](#map-maxzoom) option).
+ setMaxZoom: function (zoom) {
+ this.options.maxZoom = zoom;
+
+ if (this._loaded && (this.getZoom() > this.options.maxZoom)) {
+ return this.setZoom(zoom);
+ }
+
+ return this;
+ },
+
+ // @method panInsideBounds(bounds: LatLngBounds, options?: Pan options): this
+ // Pans the map to the closest view that would lie inside the given bounds (if it's not already), controlling the animation using the options specific, if any.
+ panInsideBounds: function (bounds, options) {
+ this._enforcingBounds = true;
+ var center = this.getCenter(),
+ newCenter = this._limitCenter(center, this._zoom, L.latLngBounds(bounds));
+
+ if (!center.equals(newCenter)) {
+ this.panTo(newCenter, options);
+ }
+
+ this._enforcingBounds = false;
+ return this;
+ },
+
+ // @method invalidateSize(options: Zoom/Pan options): this
+ // Checks if the map container size changed and updates the map if so —
+ // call it after you've changed the map size dynamically, also animating
+ // pan by default. If `options.pan` is `false`, panning will not occur.
+ // If `options.debounceMoveend` is `true`, it will delay `moveend` event so
+ // that it doesn't happen often even if the method is called many
+ // times in a row.
+
+ // @alternative
+ // @method invalidateSize(animate: Boolean): this
+ // Checks if the map container size changed and updates the map if so —
+ // call it after you've changed the map size dynamically, also animating
+ // pan by default.
+ invalidateSize: function (options) {
+ if (!this._loaded) { return this; }
+
+ options = L.extend({
+ animate: false,
+ pan: true
+ }, options === true ? {animate: true} : options);
+
+ var oldSize = this.getSize();
+ this._sizeChanged = true;
+ this._lastCenter = null;
+
+ var newSize = this.getSize(),
+ oldCenter = oldSize.divideBy(2).round(),
+ newCenter = newSize.divideBy(2).round(),
+ offset = oldCenter.subtract(newCenter);
+
+ if (!offset.x && !offset.y) { return this; }
+
+ if (options.animate && options.pan) {
+ this.panBy(offset);
+
+ } else {
+ if (options.pan) {
+ this._rawPanBy(offset);
+ }
+
+ this.fire('move');
+
+ if (options.debounceMoveend) {
+ clearTimeout(this._sizeTimer);
+ this._sizeTimer = setTimeout(L.bind(this.fire, this, 'moveend'), 200);
+ } else {
+ this.fire('moveend');
+ }
+ }
+
+ // @section Map state change events
+ // @event resize: ResizeEvent
+ // Fired when the map is resized.
+ return this.fire('resize', {
+ oldSize: oldSize,
+ newSize: newSize
+ });
+ },
+
+ // @section Methods for modifying map state
+ // @method stop(): this
+ // Stops the currently running `panTo` or `flyTo` animation, if any.
+ stop: function () {
+ this.setZoom(this._limitZoom(this._zoom));
+ if (!this.options.zoomSnap) {
+ this.fire('viewreset');
+ }
+ return this._stop();
+ },
+
+ // @section Geolocation methods
+ // @method locate(options?: Locate options): this
+ // Tries to locate the user using the Geolocation API, firing a [`locationfound`](#map-locationfound)
+ // event with location data on success or a [`locationerror`](#map-locationerror) event on failure,
+ // and optionally sets the map view to the user's location with respect to
+ // detection accuracy (or to the world view if geolocation failed).
+ // Note that, if your page doesn't use HTTPS, this method will fail in
+ // modern browsers ([Chrome 50 and newer](https://sites.google.com/a/chromium.org/dev/Home/chromium-security/deprecating-powerful-features-on-insecure-origins))
+ // See `Locate options` for more details.
+ locate: function (options) {
+
+ options = this._locateOptions = L.extend({
+ timeout: 10000,
+ watch: false
+ // setView: false
+ // maxZoom: