frontend/node_modules/.vite/deps/leaflet.js

import { t as __commonJSMin } from "./chunk-CYJPkc-J.js";
//#region ../node_modules/leaflet/dist/leaflet-src.js
var require_leaflet_src = /* @__PURE__ */ __commonJSMin(((exports, module) => {
	/* @preserve
	* Leaflet 1.9.4, a JS library for interactive maps. https://leafletjs.com
	* (c) 2010-2023 Vladimir Agafonkin, (c) 2010-2011 CloudMade
	*/
	(function(global, factory) {
		typeof exports === "object" && typeof module !== "undefined" ? factory(exports) : typeof define === "function" && define.amd ? define(["exports"], factory) : (global = typeof globalThis !== "undefined" ? globalThis : global || self, factory(global.leaflet = {}));
	})(exports, (function(exports$1) {
		"use strict";
		var version = "1.9.4";
		function extend(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;
		}
		var create$2 = Object.create || (function() {
			function F() {}
			return function(proto) {
				F.prototype = proto;
				return new F();
			};
		})();
		function bind(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);
			};
		}
		var lastId = 0;
		function stamp(obj) {
			if (!("_leaflet_id" in obj)) obj["_leaflet_id"] = ++lastId;
			return obj._leaflet_id;
		}
		function throttle(fn, time, context) {
			var lock, args, wrapperFn, later = function() {
				lock = false;
				if (args) {
					wrapperFn.apply(context, args);
					args = false;
				}
			};
			wrapperFn = function() {
				if (lock) args = arguments;
				else {
					fn.apply(context, arguments);
					setTimeout(later, time);
					lock = true;
				}
			};
			return wrapperFn;
		}
		function wrapNum(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() {
			return false;
		}
		function formatNum(num, precision) {
			if (precision === false) return num;
			var pow = Math.pow(10, precision === void 0 ? 6 : precision);
			return Math.round(num * pow) / pow;
		}
		function trim(str) {
			return str.trim ? str.trim() : str.replace(/^\s+|\s+$/g, "");
		}
		function splitWords(str) {
			return trim(str).split(/\s+/);
		}
		function setOptions(obj, options) {
			if (!Object.prototype.hasOwnProperty.call(obj, "options")) obj.options = obj.options ? create$2(obj.options) : {};
			for (var i in options) obj.options[i] = options[i];
			return obj.options;
		}
		function getParamString(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("&");
		}
		var templateRe = /\{ *([\w_ -]+) *\}/g;
		function template(str, data) {
			return str.replace(templateRe, function(str, key) {
				var value = data[key];
				if (value === void 0) throw new Error("No value provided for variable " + str);
				else if (typeof value === "function") value = value(data);
				return value;
			});
		}
		var isArray = Array.isArray || function(obj) {
			return Object.prototype.toString.call(obj) === "[object Array]";
		};
		function indexOf(array, el) {
			for (var i = 0; i < array.length; i++) if (array[i] === el) return i;
			return -1;
		}
		var emptyImageUrl = "data:image/gif;base64,R0lGODlhAQABAAD/ACwAAAAAAQABAAACADs=";
		function getPrefixed(name) {
			return window["webkit" + name] || window["moz" + name] || window["ms" + name];
		}
		var lastTime = 0;
		function timeoutDefer(fn) {
			var time = +/* @__PURE__ */ new Date(), timeToCall = Math.max(0, 16 - (time - lastTime));
			lastTime = time + timeToCall;
			return window.setTimeout(fn, timeToCall);
		}
		var requestFn = window.requestAnimationFrame || getPrefixed("RequestAnimationFrame") || timeoutDefer;
		var cancelFn = window.cancelAnimationFrame || getPrefixed("CancelAnimationFrame") || getPrefixed("CancelRequestAnimationFrame") || function(id) {
			window.clearTimeout(id);
		};
		function requestAnimFrame(fn, context, immediate) {
			if (immediate && requestFn === timeoutDefer) fn.call(context);
			else return requestFn.call(window, bind(fn, context));
		}
		function cancelAnimFrame(id) {
			if (id) cancelFn.call(window, id);
		}
		var Util = {
			__proto__: null,
			extend,
			create: create$2,
			bind,
			get lastId() {
				return lastId;
			},
			stamp,
			throttle,
			wrapNum,
			falseFn,
			formatNum,
			trim,
			splitWords,
			setOptions,
			getParamString,
			template,
			isArray,
			indexOf,
			emptyImageUrl,
			requestFn,
			cancelFn,
			requestAnimFrame,
			cancelAnimFrame
		};
		function Class() {}
		Class.extend = function(props) {
			var NewClass = function() {
				setOptions(this);
				if (this.initialize) this.initialize.apply(this, arguments);
				this.callInitHooks();
			};
			var parentProto = NewClass.__super__ = this.prototype;
			var proto = create$2(parentProto);
			proto.constructor = NewClass;
			NewClass.prototype = proto;
			for (var i in this) if (Object.prototype.hasOwnProperty.call(this, i) && i !== "prototype" && i !== "__super__") NewClass[i] = this[i];
			if (props.statics) extend(NewClass, props.statics);
			if (props.includes) {
				checkDeprecatedMixinEvents(props.includes);
				extend.apply(null, [proto].concat(props.includes));
			}
			extend(proto, props);
			delete proto.statics;
			delete proto.includes;
			if (proto.options) {
				proto.options = parentProto.options ? create$2(parentProto.options) : {};
				extend(proto.options, props.options);
			}
			proto._initHooks = [];
			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;
		};
		Class.include = function(props) {
			var parentOptions = this.prototype.options;
			extend(this.prototype, props);
			if (props.options) {
				this.prototype.options = parentOptions;
				this.mergeOptions(props.options);
			}
			return this;
		};
		Class.mergeOptions = function(options) {
			extend(this.prototype.options, options);
			return this;
		};
		Class.addInitHook = function(fn) {
			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;
		};
		function checkDeprecatedMixinEvents(includes) {
			if (typeof L === "undefined" || !L || !L.Mixin) return;
			includes = isArray(includes) ? includes : [includes];
			for (var i = 0; i < includes.length; i++) if (includes[i] === L.Mixin.Events) console.warn("Deprecated include of L.Mixin.Events: this property will be removed in future releases, please inherit from L.Evented instead.", (/* @__PURE__ */ new Error()).stack);
		}
		var Events = {
			on: function(types, fn, context) {
				if (typeof types === "object") for (var type in types) this._on(type, types[type], fn);
				else {
					types = splitWords(types);
					for (var i = 0, len = types.length; i < len; i++) this._on(types[i], fn, context);
				}
				return this;
			},
			off: function(types, fn, context) {
				if (!arguments.length) delete this._events;
				else if (typeof types === "object") for (var type in types) this._off(type, types[type], fn);
				else {
					types = splitWords(types);
					var removeAll = arguments.length === 1;
					for (var i = 0, len = types.length; i < len; i++) if (removeAll) this._off(types[i]);
					else this._off(types[i], fn, context);
				}
				return this;
			},
			_on: function(type, fn, context, _once) {
				if (typeof fn !== "function") {
					console.warn("wrong listener type: " + typeof fn);
					return;
				}
				if (this._listens(type, fn, context) !== false) return;
				if (context === this) context = void 0;
				var newListener = {
					fn,
					ctx: context
				};
				if (_once) newListener.once = true;
				this._events = this._events || {};
				this._events[type] = this._events[type] || [];
				this._events[type].push(newListener);
			},
			_off: function(type, fn, context) {
				var listeners, i, len;
				if (!this._events) return;
				listeners = this._events[type];
				if (!listeners) return;
				if (arguments.length === 1) {
					if (this._firingCount) for (i = 0, len = listeners.length; i < len; i++) listeners[i].fn = falseFn;
					delete this._events[type];
					return;
				}
				if (typeof fn !== "function") {
					console.warn("wrong listener type: " + typeof fn);
					return;
				}
				var index = this._listens(type, fn, context);
				if (index !== false) {
					var listener = listeners[index];
					if (this._firingCount) {
						listener.fn = falseFn;
						this._events[type] = listeners = listeners.slice();
					}
					listeners.splice(index, 1);
				}
			},
			fire: function(type, data, propagate) {
				if (!this.listens(type, propagate)) return this;
				var event = extend({}, data, {
					type,
					target: this,
					sourceTarget: data && data.sourceTarget || 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];
							var fn = l.fn;
							if (l.once) this.off(type, fn, l.ctx);
							fn.call(l.ctx || this, event);
						}
						this._firingCount--;
					}
				}
				if (propagate) this._propagateEvent(event);
				return this;
			},
			listens: function(type, fn, context, propagate) {
				if (typeof type !== "string") console.warn("\"string\" type argument expected");
				var _fn = fn;
				if (typeof fn !== "function") {
					propagate = !!fn;
					_fn = void 0;
					context = void 0;
				}
				var listeners = this._events && this._events[type];
				if (listeners && listeners.length) {
					if (this._listens(type, _fn, context) !== false) return true;
				}
				if (propagate) {
					for (var id in this._eventParents) if (this._eventParents[id].listens(type, fn, context, propagate)) return true;
				}
				return false;
			},
			_listens: function(type, fn, context) {
				if (!this._events) return false;
				var listeners = this._events[type] || [];
				if (!fn) return !!listeners.length;
				if (context === this) context = void 0;
				for (var i = 0, len = listeners.length; i < len; i++) if (listeners[i].fn === fn && listeners[i].ctx === context) return i;
				return false;
			},
			once: function(types, fn, context) {
				if (typeof types === "object") for (var type in types) this._on(type, types[type], fn, true);
				else {
					types = splitWords(types);
					for (var i = 0, len = types.length; i < len; i++) this._on(types[i], fn, context, true);
				}
				return this;
			},
			addEventParent: function(obj) {
				this._eventParents = this._eventParents || {};
				this._eventParents[stamp(obj)] = obj;
				return this;
			},
			removeEventParent: function(obj) {
				if (this._eventParents) delete this._eventParents[stamp(obj)];
				return this;
			},
			_propagateEvent: function(e) {
				for (var id in this._eventParents) this._eventParents[id].fire(e.type, extend({
					layer: e.target,
					propagatedFrom: e.target
				}, e), true);
			}
		};
		Events.addEventListener = Events.on;
		Events.removeEventListener = Events.clearAllEventListeners = Events.off;
		Events.addOneTimeEventListener = Events.once;
		Events.fireEvent = Events.fire;
		Events.hasEventListeners = Events.listens;
		var Evented = Class.extend(Events);
		function Point(x, y, round) {
			this.x = round ? Math.round(x) : x;
			this.y = round ? Math.round(y) : y;
		}
		var trunc = Math.trunc || function(v) {
			return v > 0 ? Math.floor(v) : Math.ceil(v);
		};
		Point.prototype = {
			clone: function() {
				return new Point(this.x, this.y);
			},
			add: function(point) {
				return this.clone()._add(toPoint(point));
			},
			_add: function(point) {
				this.x += point.x;
				this.y += point.y;
				return this;
			},
			subtract: function(point) {
				return this.clone()._subtract(toPoint(point));
			},
			_subtract: function(point) {
				this.x -= point.x;
				this.y -= point.y;
				return this;
			},
			divideBy: function(num) {
				return this.clone()._divideBy(num);
			},
			_divideBy: function(num) {
				this.x /= num;
				this.y /= num;
				return this;
			},
			multiplyBy: function(num) {
				return this.clone()._multiplyBy(num);
			},
			_multiplyBy: function(num) {
				this.x *= num;
				this.y *= num;
				return this;
			},
			scaleBy: function(point) {
				return new Point(this.x * point.x, this.y * point.y);
			},
			unscaleBy: function(point) {
				return new Point(this.x / point.x, this.y / point.y);
			},
			round: function() {
				return this.clone()._round();
			},
			_round: function() {
				this.x = Math.round(this.x);
				this.y = Math.round(this.y);
				return this;
			},
			floor: function() {
				return this.clone()._floor();
			},
			_floor: function() {
				this.x = Math.floor(this.x);
				this.y = Math.floor(this.y);
				return this;
			},
			ceil: function() {
				return this.clone()._ceil();
			},
			_ceil: function() {
				this.x = Math.ceil(this.x);
				this.y = Math.ceil(this.y);
				return this;
			},
			trunc: function() {
				return this.clone()._trunc();
			},
			_trunc: function() {
				this.x = trunc(this.x);
				this.y = trunc(this.y);
				return this;
			},
			distanceTo: function(point) {
				point = toPoint(point);
				var x = point.x - this.x, y = point.y - this.y;
				return Math.sqrt(x * x + y * y);
			},
			equals: function(point) {
				point = toPoint(point);
				return point.x === this.x && point.y === this.y;
			},
			contains: function(point) {
				point = toPoint(point);
				return Math.abs(point.x) <= Math.abs(this.x) && Math.abs(point.y) <= Math.abs(this.y);
			},
			toString: function() {
				return "Point(" + formatNum(this.x) + ", " + formatNum(this.y) + ")";
			}
		};
		function toPoint(x, y, round) {
			if (x instanceof Point) return x;
			if (isArray(x)) return new Point(x[0], x[1]);
			if (x === void 0 || x === null) return x;
			if (typeof x === "object" && "x" in x && "y" in x) return new Point(x.x, x.y);
			return new Point(x, y, round);
		}
		function Bounds(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]);
		}
		Bounds.prototype = {
			extend: function(obj) {
				var min2, max2;
				if (!obj) return this;
				if (obj instanceof Point || typeof obj[0] === "number" || "x" in obj) min2 = max2 = toPoint(obj);
				else {
					obj = toBounds(obj);
					min2 = obj.min;
					max2 = obj.max;
					if (!min2 || !max2) return this;
				}
				if (!this.min && !this.max) {
					this.min = min2.clone();
					this.max = max2.clone();
				} else {
					this.min.x = Math.min(min2.x, this.min.x);
					this.max.x = Math.max(max2.x, this.max.x);
					this.min.y = Math.min(min2.y, this.min.y);
					this.max.y = Math.max(max2.y, this.max.y);
				}
				return this;
			},
			getCenter: function(round) {
				return toPoint((this.min.x + this.max.x) / 2, (this.min.y + this.max.y) / 2, round);
			},
			getBottomLeft: function() {
				return toPoint(this.min.x, this.max.y);
			},
			getTopRight: function() {
				return toPoint(this.max.x, this.min.y);
			},
			getTopLeft: function() {
				return this.min;
			},
			getBottomRight: function() {
				return this.max;
			},
			getSize: function() {
				return this.max.subtract(this.min);
			},
			contains: function(obj) {
				var min, max;
				if (typeof obj[0] === "number" || obj instanceof Point) obj = toPoint(obj);
				else obj = toBounds(obj);
				if (obj instanceof 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;
			},
			intersects: function(bounds) {
				bounds = toBounds(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;
			},
			overlaps: function(bounds) {
				bounds = toBounds(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);
			},
			pad: function(bufferRatio) {
				var min = this.min, max = this.max, heightBuffer = Math.abs(min.x - max.x) * bufferRatio, widthBuffer = Math.abs(min.y - max.y) * bufferRatio;
				return toBounds(toPoint(min.x - heightBuffer, min.y - widthBuffer), toPoint(max.x + heightBuffer, max.y + widthBuffer));
			},
			equals: function(bounds) {
				if (!bounds) return false;
				bounds = toBounds(bounds);
				return this.min.equals(bounds.getTopLeft()) && this.max.equals(bounds.getBottomRight());
			}
		};
		function toBounds(a, b) {
			if (!a || a instanceof Bounds) return a;
			return new Bounds(a, b);
		}
		function LatLngBounds(corner1, corner2) {
			if (!corner1) return;
			var latlngs = corner2 ? [corner1, corner2] : corner1;
			for (var i = 0, len = latlngs.length; i < len; i++) this.extend(latlngs[i]);
		}
		LatLngBounds.prototype = {
			extend: function(obj) {
				var sw = this._southWest, ne = this._northEast, sw2, ne2;
				if (obj instanceof LatLng) {
					sw2 = obj;
					ne2 = obj;
				} else if (obj instanceof LatLngBounds) {
					sw2 = obj._southWest;
					ne2 = obj._northEast;
					if (!sw2 || !ne2) return this;
				} else return obj ? this.extend(toLatLng(obj) || toLatLngBounds(obj)) : this;
				if (!sw && !ne) {
					this._southWest = new LatLng(sw2.lat, sw2.lng);
					this._northEast = new 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;
			},
			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 LatLngBounds(new LatLng(sw.lat - heightBuffer, sw.lng - widthBuffer), new LatLng(ne.lat + heightBuffer, ne.lng + widthBuffer));
			},
			getCenter: function() {
				return new LatLng((this._southWest.lat + this._northEast.lat) / 2, (this._southWest.lng + this._northEast.lng) / 2);
			},
			getSouthWest: function() {
				return this._southWest;
			},
			getNorthEast: function() {
				return this._northEast;
			},
			getNorthWest: function() {
				return new LatLng(this.getNorth(), this.getWest());
			},
			getSouthEast: function() {
				return new LatLng(this.getSouth(), this.getEast());
			},
			getWest: function() {
				return this._southWest.lng;
			},
			getSouth: function() {
				return this._southWest.lat;
			},
			getEast: function() {
				return this._northEast.lng;
			},
			getNorth: function() {
				return this._northEast.lat;
			},
			contains: function(obj) {
				if (typeof obj[0] === "number" || obj instanceof LatLng || "lat" in obj) obj = toLatLng(obj);
				else obj = toLatLngBounds(obj);
				var sw = this._southWest, ne = this._northEast, sw2, ne2;
				if (obj instanceof 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;
			},
			intersects: function(bounds) {
				bounds = toLatLngBounds(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;
			},
			overlaps: function(bounds) {
				bounds = toLatLngBounds(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;
			},
			toBBoxString: function() {
				return [
					this.getWest(),
					this.getSouth(),
					this.getEast(),
					this.getNorth()
				].join(",");
			},
			equals: function(bounds, maxMargin) {
				if (!bounds) return false;
				bounds = toLatLngBounds(bounds);
				return this._southWest.equals(bounds.getSouthWest(), maxMargin) && this._northEast.equals(bounds.getNorthEast(), maxMargin);
			},
			isValid: function() {
				return !!(this._southWest && this._northEast);
			}
		};
		function toLatLngBounds(a, b) {
			if (a instanceof LatLngBounds) return a;
			return new LatLngBounds(a, b);
		}
		function LatLng(lat, lng, alt) {
			if (isNaN(lat) || isNaN(lng)) throw new Error("Invalid LatLng object: (" + lat + ", " + lng + ")");
			this.lat = +lat;
			this.lng = +lng;
			if (alt !== void 0) this.alt = +alt;
		}
		LatLng.prototype = {
			equals: function(obj, maxMargin) {
				if (!obj) return false;
				obj = toLatLng(obj);
				return Math.max(Math.abs(this.lat - obj.lat), Math.abs(this.lng - obj.lng)) <= (maxMargin === void 0 ? 1e-9 : maxMargin);
			},
			toString: function(precision) {
				return "LatLng(" + formatNum(this.lat, precision) + ", " + formatNum(this.lng, precision) + ")";
			},
			distanceTo: function(other) {
				return Earth.distance(this, toLatLng(other));
			},
			wrap: function() {
				return Earth.wrapLatLng(this);
			},
			toBounds: function(sizeInMeters) {
				var latAccuracy = 180 * sizeInMeters / 40075017, lngAccuracy = latAccuracy / Math.cos(Math.PI / 180 * this.lat);
				return toLatLngBounds([this.lat - latAccuracy, this.lng - lngAccuracy], [this.lat + latAccuracy, this.lng + lngAccuracy]);
			},
			clone: function() {
				return new LatLng(this.lat, this.lng, this.alt);
			}
		};
		function toLatLng(a, b, c) {
			if (a instanceof LatLng) return a;
			if (isArray(a) && typeof a[0] !== "object") {
				if (a.length === 3) return new LatLng(a[0], a[1], a[2]);
				if (a.length === 2) return new LatLng(a[0], a[1]);
				return null;
			}
			if (a === void 0 || a === null) return a;
			if (typeof a === "object" && "lat" in a) return new LatLng(a.lat, "lng" in a ? a.lng : a.lon, a.alt);
			if (b === void 0) return null;
			return new LatLng(a, b, c);
		}
		var CRS = {
			latLngToPoint: function(latlng, zoom) {
				var projectedPoint = this.projection.project(latlng), scale = this.scale(zoom);
				return this.transformation._transform(projectedPoint, scale);
			},
			pointToLatLng: function(point, zoom) {
				var scale = this.scale(zoom), untransformedPoint = this.transformation.untransform(point, scale);
				return this.projection.unproject(untransformedPoint);
			},
			project: function(latlng) {
				return this.projection.project(latlng);
			},
			unproject: function(point) {
				return this.projection.unproject(point);
			},
			scale: function(zoom) {
				return 256 * Math.pow(2, zoom);
			},
			zoom: function(scale) {
				return Math.log(scale / 256) / Math.LN2;
			},
			getProjectedBounds: function(zoom) {
				if (this.infinite) return null;
				var b = this.projection.bounds, s = this.scale(zoom);
				return new Bounds(this.transformation.transform(b.min, s), this.transformation.transform(b.max, s));
			},
			infinite: false,
			wrapLatLng: function(latlng) {
				var lng = this.wrapLng ? wrapNum(latlng.lng, this.wrapLng, true) : latlng.lng, lat = this.wrapLat ? wrapNum(latlng.lat, this.wrapLat, true) : latlng.lat, alt = latlng.alt;
				return new LatLng(lat, lng, alt);
			},
			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();
				return new LatLngBounds(new LatLng(sw.lat - latShift, sw.lng - lngShift), new LatLng(ne.lat - latShift, ne.lng - lngShift));
			}
		};
		var Earth = extend({}, CRS, {
			wrapLng: [-180, 180],
			R: 6371e3,
			distance: function(latlng1, latlng2) {
				var rad = Math.PI / 180, lat1 = latlng1.lat * rad, lat2 = latlng2.lat * rad, sinDLat = Math.sin((latlng2.lat - latlng1.lat) * rad / 2), sinDLon = Math.sin((latlng2.lng - latlng1.lng) * rad / 2), a = sinDLat * sinDLat + Math.cos(lat1) * Math.cos(lat2) * sinDLon * sinDLon, c = 2 * Math.atan2(Math.sqrt(a), Math.sqrt(1 - a));
				return this.R * c;
			}
		});
		var earthRadius = 6378137;
		var SphericalMercator = {
			R: earthRadius,
			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 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 LatLng((2 * Math.atan(Math.exp(point.y / this.R)) - Math.PI / 2) * d, point.x * d / this.R);
			},
			bounds: (function() {
				var d = earthRadius * Math.PI;
				return new Bounds([-d, -d], [d, d]);
			})()
		};
		function Transformation(a, b, c, d) {
			if (isArray(a)) {
				this._a = a[0];
				this._b = a[1];
				this._c = a[2];
				this._d = a[3];
				return;
			}
			this._a = a;
			this._b = b;
			this._c = c;
			this._d = d;
		}
		Transformation.prototype = {
			transform: function(point, scale) {
				return this._transform(point.clone(), scale);
			},
			_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;
			},
			untransform: function(point, scale) {
				scale = scale || 1;
				return new Point((point.x / scale - this._b) / this._a, (point.y / scale - this._d) / this._c);
			}
		};
		function toTransformation(a, b, c, d) {
			return new Transformation(a, b, c, d);
		}
		var EPSG3857 = extend({}, Earth, {
			code: "EPSG:3857",
			projection: SphericalMercator,
			transformation: function() {
				var scale = .5 / (Math.PI * SphericalMercator.R);
				return toTransformation(scale, .5, -scale, .5);
			}()
		});
		var EPSG900913 = extend({}, EPSG3857, { code: "EPSG:900913" });
		function svgCreate(name) {
			return document.createElementNS("http://www.w3.org/2000/svg", name);
		}
		function pointsToPath(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;
				}
				str += closed ? Browser.svg ? "z" : "x" : "";
			}
			return str || "M0 0";
		}
		var style = document.documentElement.style;
		var ie = "ActiveXObject" in window;
		var ielt9 = ie && !document.addEventListener;
		var edge = "msLaunchUri" in navigator && !("documentMode" in document);
		var webkit = userAgentContains("webkit");
		var android = userAgentContains("android");
		var android23 = userAgentContains("android 2") || userAgentContains("android 3");
		var webkitVer = parseInt(/WebKit\/([0-9]+)|$/.exec(navigator.userAgent)[1], 10);
		var androidStock = android && userAgentContains("Google") && webkitVer < 537 && !("AudioNode" in window);
		var opera = !!window.opera;
		var chrome = !edge && userAgentContains("chrome");
		var gecko = userAgentContains("gecko") && !webkit && !opera && !ie;
		var safari = !chrome && userAgentContains("safari");
		var phantom = userAgentContains("phantom");
		var opera12 = "OTransition" in style;
		var win = navigator.platform.indexOf("Win") === 0;
		var ie3d = ie && "transition" in style;
		var webkit3d = "WebKitCSSMatrix" in window && "m11" in new window.WebKitCSSMatrix() && !android23;
		var gecko3d = "MozPerspective" in style;
		var any3d = !window.L_DISABLE_3D && (ie3d || webkit3d || gecko3d) && !opera12 && !phantom;
		var mobile = typeof orientation !== "undefined" || userAgentContains("mobile");
		var mobileWebkit = mobile && webkit;
		var mobileWebkit3d = mobile && webkit3d;
		var msPointer = !window.PointerEvent && window.MSPointerEvent;
		var pointer = !!(window.PointerEvent || msPointer);
		var touchNative = "ontouchstart" in window || !!window.TouchEvent;
		var touch = !window.L_NO_TOUCH && (touchNative || pointer);
		var mobileOpera = mobile && opera;
		var mobileGecko = mobile && gecko;
		var retina = (window.devicePixelRatio || window.screen.deviceXDPI / window.screen.logicalXDPI) > 1;
		var passiveEvents = function() {
			var supportsPassiveOption = false;
			try {
				var opts = Object.defineProperty({}, "passive", { get: function() {
					supportsPassiveOption = true;
				} });
				window.addEventListener("testPassiveEventSupport", falseFn, opts);
				window.removeEventListener("testPassiveEventSupport", falseFn, opts);
			} catch (e) {}
			return supportsPassiveOption;
		}();
		var canvas$1 = function() {
			return !!document.createElement("canvas").getContext;
		}();
		var svg$1 = !!(document.createElementNS && svgCreate("svg").createSVGRect);
		var inlineSvg = !!svg$1 && (function() {
			var div = document.createElement("div");
			div.innerHTML = "<svg/>";
			return (div.firstChild && div.firstChild.namespaceURI) === "http://www.w3.org/2000/svg";
		})();
		var vml = !svg$1 && function() {
			try {
				var div = document.createElement("div");
				div.innerHTML = "<v:shape adj=\"1\"/>";
				var shape = div.firstChild;
				shape.style.behavior = "url(#default#VML)";
				return shape && typeof shape.adj === "object";
			} catch (e) {
				return false;
			}
		}();
		var mac = navigator.platform.indexOf("Mac") === 0;
		var linux = navigator.platform.indexOf("Linux") === 0;
		function userAgentContains(str) {
			return navigator.userAgent.toLowerCase().indexOf(str) >= 0;
		}
		var Browser = {
			ie,
			ielt9,
			edge,
			webkit,
			android,
			android23,
			androidStock,
			opera,
			chrome,
			gecko,
			safari,
			phantom,
			opera12,
			win,
			ie3d,
			webkit3d,
			gecko3d,
			any3d,
			mobile,
			mobileWebkit,
			mobileWebkit3d,
			msPointer,
			pointer,
			touch,
			touchNative,
			mobileOpera,
			mobileGecko,
			retina,
			passiveEvents,
			canvas: canvas$1,
			svg: svg$1,
			vml,
			inlineSvg,
			mac,
			linux
		};
		var POINTER_DOWN = Browser.msPointer ? "MSPointerDown" : "pointerdown";
		var POINTER_MOVE = Browser.msPointer ? "MSPointerMove" : "pointermove";
		var POINTER_UP = Browser.msPointer ? "MSPointerUp" : "pointerup";
		var POINTER_CANCEL = Browser.msPointer ? "MSPointerCancel" : "pointercancel";
		var pEvent = {
			touchstart: POINTER_DOWN,
			touchmove: POINTER_MOVE,
			touchend: POINTER_UP,
			touchcancel: POINTER_CANCEL
		};
		var handle = {
			touchstart: _onPointerStart,
			touchmove: _handlePointer,
			touchend: _handlePointer,
			touchcancel: _handlePointer
		};
		var _pointers = {};
		var _pointerDocListener = false;
		function addPointerListener(obj, type, handler) {
			if (type === "touchstart") _addPointerDocListener();
			if (!handle[type]) {
				console.warn("wrong event specified:", type);
				return falseFn;
			}
			handler = handle[type].bind(this, handler);
			obj.addEventListener(pEvent[type], handler, false);
			return handler;
		}
		function removePointerListener(obj, type, handler) {
			if (!pEvent[type]) {
				console.warn("wrong event specified:", type);
				return;
			}
			obj.removeEventListener(pEvent[type], handler, false);
		}
		function _globalPointerDown(e) {
			_pointers[e.pointerId] = e;
		}
		function _globalPointerMove(e) {
			if (_pointers[e.pointerId]) _pointers[e.pointerId] = e;
		}
		function _globalPointerUp(e) {
			delete _pointers[e.pointerId];
		}
		function _addPointerDocListener() {
			if (!_pointerDocListener) {
				document.addEventListener(POINTER_DOWN, _globalPointerDown, true);
				document.addEventListener(POINTER_MOVE, _globalPointerMove, true);
				document.addEventListener(POINTER_UP, _globalPointerUp, true);
				document.addEventListener(POINTER_CANCEL, _globalPointerUp, true);
				_pointerDocListener = true;
			}
		}
		function _handlePointer(handler, e) {
			if (e.pointerType === (e.MSPOINTER_TYPE_MOUSE || "mouse")) return;
			e.touches = [];
			for (var i in _pointers) e.touches.push(_pointers[i]);
			e.changedTouches = [e];
			handler(e);
		}
		function _onPointerStart(handler, e) {
			if (e.MSPOINTER_TYPE_TOUCH && e.pointerType === e.MSPOINTER_TYPE_TOUCH) preventDefault(e);
			_handlePointer(handler, e);
		}
		function makeDblclick(event) {
			var newEvent = {}, prop, i;
			for (i in event) {
				prop = event[i];
				newEvent[i] = prop && prop.bind ? prop.bind(event) : prop;
			}
			event = newEvent;
			newEvent.type = "dblclick";
			newEvent.detail = 2;
			newEvent.isTrusted = false;
			newEvent._simulated = true;
			return newEvent;
		}
		var delay = 200;
		function addDoubleTapListener(obj, handler) {
			obj.addEventListener("dblclick", handler);
			var last = 0, detail;
			function simDblclick(e) {
				if (e.detail !== 1) {
					detail = e.detail;
					return;
				}
				if (e.pointerType === "mouse" || e.sourceCapabilities && !e.sourceCapabilities.firesTouchEvents) return;
				var path = getPropagationPath(e);
				if (path.some(function(el) {
					return el instanceof HTMLLabelElement && el.attributes.for;
				}) && !path.some(function(el) {
					return el instanceof HTMLInputElement || el instanceof HTMLSelectElement;
				})) return;
				var now = Date.now();
				if (now - last <= delay) {
					detail++;
					if (detail === 2) handler(makeDblclick(e));
				} else detail = 1;
				last = now;
			}
			obj.addEventListener("click", simDblclick);
			return {
				dblclick: handler,
				simDblclick
			};
		}
		function removeDoubleTapListener(obj, handlers) {
			obj.removeEventListener("dblclick", handlers.dblclick);
			obj.removeEventListener("click", handlers.simDblclick);
		}
		var TRANSFORM = testProp([
			"transform",
			"webkitTransform",
			"OTransform",
			"MozTransform",
			"msTransform"
		]);
		var TRANSITION = testProp([
			"webkitTransition",
			"transition",
			"OTransition",
			"MozTransition",
			"msTransition"
		]);
		var TRANSITION_END = TRANSITION === "webkitTransition" || TRANSITION === "OTransition" ? TRANSITION + "End" : "transitionend";
		function get(id) {
			return typeof id === "string" ? document.getElementById(id) : id;
		}
		function getStyle(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$1(tagName, className, container) {
			var el = document.createElement(tagName);
			el.className = className || "";
			if (container) container.appendChild(el);
			return el;
		}
		function remove(el) {
			var parent = el.parentNode;
			if (parent) parent.removeChild(el);
		}
		function empty(el) {
			while (el.firstChild) el.removeChild(el.firstChild);
		}
		function toFront(el) {
			var parent = el.parentNode;
			if (parent && parent.lastChild !== el) parent.appendChild(el);
		}
		function toBack(el) {
			var parent = el.parentNode;
			if (parent && parent.firstChild !== el) parent.insertBefore(el, parent.firstChild);
		}
		function hasClass(el, name) {
			if (el.classList !== void 0) return el.classList.contains(name);
			var className = getClass(el);
			return className.length > 0 && new RegExp("(^|\\s)" + name + "(\\s|$)").test(className);
		}
		function addClass(el, name) {
			if (el.classList !== void 0) {
				var classes = splitWords(name);
				for (var i = 0, len = classes.length; i < len; i++) el.classList.add(classes[i]);
			} else if (!hasClass(el, name)) {
				var className = getClass(el);
				setClass(el, (className ? className + " " : "") + name);
			}
		}
		function removeClass(el, name) {
			if (el.classList !== void 0) el.classList.remove(name);
			else setClass(el, trim((" " + getClass(el) + " ").replace(" " + name + " ", " ")));
		}
		function setClass(el, name) {
			if (el.className.baseVal === void 0) el.className = name;
			else el.className.baseVal = name;
		}
		function getClass(el) {
			if (el.correspondingElement) el = el.correspondingElement;
			return el.className.baseVal === void 0 ? el.className : el.className.baseVal;
		}
		function setOpacity(el, value) {
			if ("opacity" in el.style) el.style.opacity = value;
			else if ("filter" in el.style) _setOpacityIE(el, value);
		}
		function _setOpacityIE(el, value) {
			var filter = false, filterName = "DXImageTransform.Microsoft.Alpha";
			try {
				filter = el.filters.item(filterName);
			} catch (e) {
				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) {
			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, offset, scale) {
			var pos = offset || new Point(0, 0);
			el.style[TRANSFORM] = (Browser.ie3d ? "translate(" + pos.x + "px," + pos.y + "px)" : "translate3d(" + pos.x + "px," + pos.y + "px,0)") + (scale ? " scale(" + scale + ")" : "");
		}
		function setPosition(el, point) {
			el._leaflet_pos = point;
			if (Browser.any3d) setTransform(el, point);
			else {
				el.style.left = point.x + "px";
				el.style.top = point.y + "px";
			}
		}
		function getPosition(el) {
			return el._leaflet_pos || new Point(0, 0);
		}
		var disableTextSelection;
		var enableTextSelection;
		var _userSelect;
		if ("onselectstart" in document) {
			disableTextSelection = function() {
				on(window, "selectstart", preventDefault);
			};
			enableTextSelection = function() {
				off(window, "selectstart", preventDefault);
			};
		} else {
			var userSelectProperty = testProp([
				"userSelect",
				"WebkitUserSelect",
				"OUserSelect",
				"MozUserSelect",
				"msUserSelect"
			]);
			disableTextSelection = function() {
				if (userSelectProperty) {
					var style = document.documentElement.style;
					_userSelect = style[userSelectProperty];
					style[userSelectProperty] = "none";
				}
			};
			enableTextSelection = function() {
				if (userSelectProperty) {
					document.documentElement.style[userSelectProperty] = _userSelect;
					_userSelect = void 0;
				}
			};
		}
		function disableImageDrag() {
			on(window, "dragstart", preventDefault);
		}
		function enableImageDrag() {
			off(window, "dragstart", preventDefault);
		}
		var _outlineElement, _outlineStyle;
		function preventOutline(element) {
			while (element.tabIndex === -1) element = element.parentNode;
			if (!element.style) return;
			restoreOutline();
			_outlineElement = element;
			_outlineStyle = element.style.outlineStyle;
			element.style.outlineStyle = "none";
			on(window, "keydown", restoreOutline);
		}
		function restoreOutline() {
			if (!_outlineElement) return;
			_outlineElement.style.outlineStyle = _outlineStyle;
			_outlineElement = void 0;
			_outlineStyle = void 0;
			off(window, "keydown", restoreOutline);
		}
		function getSizedParentNode(element) {
			do
				element = element.parentNode;
			while ((!element.offsetWidth || !element.offsetHeight) && element !== document.body);
			return element;
		}
		function getScale(element) {
			var rect = element.getBoundingClientRect();
			return {
				x: rect.width / element.offsetWidth || 1,
				y: rect.height / element.offsetHeight || 1,
				boundingClientRect: rect
			};
		}
		var DomUtil = {
			__proto__: null,
			TRANSFORM,
			TRANSITION,
			TRANSITION_END,
			get,
			getStyle,
			create: create$1,
			remove,
			empty,
			toFront,
			toBack,
			hasClass,
			addClass,
			removeClass,
			setClass,
			getClass,
			setOpacity,
			testProp,
			setTransform,
			setPosition,
			getPosition,
			get disableTextSelection() {
				return disableTextSelection;
			},
			get enableTextSelection() {
				return enableTextSelection;
			},
			disableImageDrag,
			enableImageDrag,
			preventOutline,
			restoreOutline,
			getSizedParentNode,
			getScale
		};
		function on(obj, types, fn, context) {
			if (types && typeof types === "object") for (var type in types) addOne(obj, type, types[type], fn);
			else {
				types = splitWords(types);
				for (var i = 0, len = types.length; i < len; i++) addOne(obj, types[i], fn, context);
			}
			return this;
		}
		var eventsKey = "_leaflet_events";
		function off(obj, types, fn, context) {
			if (arguments.length === 1) {
				batchRemove(obj);
				delete obj[eventsKey];
			} else if (types && typeof types === "object") for (var type in types) removeOne(obj, type, types[type], fn);
			else {
				types = splitWords(types);
				if (arguments.length === 2) batchRemove(obj, function(type) {
					return indexOf(types, type) !== -1;
				});
				else for (var i = 0, len = types.length; i < len; i++) removeOne(obj, types[i], fn, context);
			}
			return this;
		}
		function batchRemove(obj, filterFn) {
			for (var id in obj[eventsKey]) {
				var type = id.split(/\d/)[0];
				if (!filterFn || filterFn(type)) removeOne(obj, type, null, null, id);
			}
		}
		var mouseSubst = {
			mouseenter: "mouseover",
			mouseleave: "mouseout",
			wheel: !("onwheel" in window) && "mousewheel"
		};
		function addOne(obj, type, fn, context) {
			var id = type + stamp(fn) + (context ? "_" + stamp(context) : "");
			if (obj[eventsKey] && obj[eventsKey][id]) return this;
			var handler = function(e) {
				return fn.call(context || obj, e || window.event);
			};
			var originalHandler = handler;
			if (!Browser.touchNative && Browser.pointer && type.indexOf("touch") === 0) handler = addPointerListener(obj, type, handler);
			else if (Browser.touch && type === "dblclick") handler = addDoubleTapListener(obj, handler);
			else if ("addEventListener" in obj) if (type === "touchstart" || type === "touchmove" || type === "wheel" || type === "mousewheel") obj.addEventListener(mouseSubst[type] || type, handler, Browser.passiveEvents ? { passive: false } : false);
			else if (type === "mouseenter" || type === "mouseleave") {
				handler = function(e) {
					e = e || window.event;
					if (isExternalTarget(obj, e)) originalHandler(e);
				};
				obj.addEventListener(mouseSubst[type], handler, false);
			} else obj.addEventListener(type, originalHandler, false);
			else obj.attachEvent("on" + type, handler);
			obj[eventsKey] = obj[eventsKey] || {};
			obj[eventsKey][id] = handler;
		}
		function removeOne(obj, type, fn, context, id) {
			id = id || type + stamp(fn) + (context ? "_" + stamp(context) : "");
			var handler = obj[eventsKey] && obj[eventsKey][id];
			if (!handler) return this;
			if (!Browser.touchNative && Browser.pointer && type.indexOf("touch") === 0) removePointerListener(obj, type, handler);
			else if (Browser.touch && type === "dblclick") removeDoubleTapListener(obj, handler);
			else if ("removeEventListener" in obj) obj.removeEventListener(mouseSubst[type] || type, handler, false);
			else obj.detachEvent("on" + type, handler);
			obj[eventsKey][id] = null;
		}
		function stopPropagation(e) {
			if (e.stopPropagation) e.stopPropagation();
			else if (e.originalEvent) e.originalEvent._stopped = true;
			else e.cancelBubble = true;
			return this;
		}
		function disableScrollPropagation(el) {
			addOne(el, "wheel", stopPropagation);
			return this;
		}
		function disableClickPropagation(el) {
			on(el, "mousedown touchstart dblclick contextmenu", stopPropagation);
			el["_leaflet_disable_click"] = true;
			return this;
		}
		function preventDefault(e) {
			if (e.preventDefault) e.preventDefault();
			else e.returnValue = false;
			return this;
		}
		function stop(e) {
			preventDefault(e);
			stopPropagation(e);
			return this;
		}
		function getPropagationPath(ev) {
			if (ev.composedPath) return ev.composedPath();
			var path = [];
			var el = ev.target;
			while (el) {
				path.push(el);
				el = el.parentNode;
			}
			return path;
		}
		function getMousePosition(e, container) {
			if (!container) return new Point(e.clientX, e.clientY);
			var scale = getScale(container), offset = scale.boundingClientRect;
			return new Point((e.clientX - offset.left) / scale.x - container.clientLeft, (e.clientY - offset.top) / scale.y - container.clientTop);
		}
		var wheelPxFactor = Browser.linux && Browser.chrome ? window.devicePixelRatio : Browser.mac ? window.devicePixelRatio * 3 : window.devicePixelRatio > 0 ? 2 * window.devicePixelRatio : 1;
		function getWheelDelta(e) {
			return Browser.edge ? e.wheelDeltaY / 2 : e.deltaY && e.deltaMode === 0 ? -e.deltaY / wheelPxFactor : e.deltaY && e.deltaMode === 1 ? -e.deltaY * 20 : e.deltaY && e.deltaMode === 2 ? -e.deltaY * 60 : e.deltaX || e.deltaZ ? 0 : e.wheelDelta ? (e.wheelDeltaY || e.wheelDelta) / 2 : e.detail && Math.abs(e.detail) < 32765 ? -e.detail * 20 : e.detail ? e.detail / -32765 * 60 : 0;
		}
		function isExternalTarget(el, e) {
			var related = e.relatedTarget;
			if (!related) return true;
			try {
				while (related && related !== el) related = related.parentNode;
			} catch (err) {
				return false;
			}
			return related !== el;
		}
		var DomEvent = {
			__proto__: null,
			on,
			off,
			stopPropagation,
			disableScrollPropagation,
			disableClickPropagation,
			preventDefault,
			stop,
			getPropagationPath,
			getMousePosition,
			getWheelDelta,
			isExternalTarget,
			addListener: on,
			removeListener: off
		};
		var PosAnimation = Evented.extend({
			run: function(el, newPos, duration, easeLinearity) {
				this.stop();
				this._el = el;
				this._inProgress = true;
				this._duration = duration || .25;
				this._easeOutPower = 1 / Math.max(easeLinearity || .5, .2);
				this._startPos = getPosition(el);
				this._offset = newPos.subtract(this._startPos);
				this._startTime = +/* @__PURE__ */ new Date();
				this.fire("start");
				this._animate();
			},
			stop: function() {
				if (!this._inProgress) return;
				this._step(true);
				this._complete();
			},
			_animate: function() {
				this._animId = requestAnimFrame(this._animate, this);
				this._step();
			},
			_step: function(round) {
				var elapsed = +/* @__PURE__ */ new Date() - this._startTime, duration = this._duration * 1e3;
				if (elapsed < duration) this._runFrame(this._easeOut(elapsed / duration), round);
				else {
					this._runFrame(1);
					this._complete();
				}
			},
			_runFrame: function(progress, round) {
				var pos = this._startPos.add(this._offset.multiplyBy(progress));
				if (round) pos._round();
				setPosition(this._el, pos);
				this.fire("step");
			},
			_complete: function() {
				cancelAnimFrame(this._animId);
				this._inProgress = false;
				this.fire("end");
			},
			_easeOut: function(t) {
				return 1 - Math.pow(1 - t, this._easeOutPower);
			}
		});
		var Map = Evented.extend({
			options: {
				crs: EPSG3857,
				center: void 0,
				zoom: void 0,
				minZoom: void 0,
				maxZoom: void 0,
				layers: [],
				maxBounds: void 0,
				renderer: void 0,
				zoomAnimation: true,
				zoomAnimationThreshold: 4,
				fadeAnimation: true,
				markerZoomAnimation: true,
				transform3DLimit: 8388608,
				zoomSnap: 1,
				zoomDelta: 1,
				trackResize: true
			},
			initialize: function(id, options) {
				options = setOptions(this, options);
				this._handlers = [];
				this._layers = {};
				this._zoomBoundLayers = {};
				this._sizeChanged = true;
				this._initContainer(id);
				this._initLayout();
				this._onResize = bind(this._onResize, this);
				this._initEvents();
				if (options.maxBounds) this.setMaxBounds(options.maxBounds);
				if (options.zoom !== void 0) this._zoom = this._limitZoom(options.zoom);
				if (options.center && options.zoom !== void 0) this.setView(toLatLng(options.center), options.zoom, { reset: true });
				this.callInitHooks();
				this._zoomAnimated = TRANSITION && Browser.any3d && !Browser.mobileOpera && this.options.zoomAnimation;
				if (this._zoomAnimated) {
					this._createAnimProxy();
					on(this._proxy, TRANSITION_END, this._catchTransitionEnd, this);
				}
				this._addLayers(this.options.layers);
			},
			setView: function(center, zoom, options) {
				zoom = zoom === void 0 ? this._zoom : this._limitZoom(zoom);
				center = this._limitCenter(toLatLng(center), zoom, this.options.maxBounds);
				options = options || {};
				this._stop();
				if (this._loaded && !options.reset && options !== true) {
					if (options.animate !== void 0) {
						options.zoom = extend({ animate: options.animate }, options.zoom);
						options.pan = extend({
							animate: options.animate,
							duration: options.duration
						}, options.pan);
					}
					if (this._zoom !== zoom ? this._tryAnimatedZoom && this._tryAnimatedZoom(center, zoom, options.zoom) : this._tryAnimatedPan(center, options.pan)) {
						clearTimeout(this._sizeTimer);
						return this;
					}
				}
				this._resetView(center, zoom, options.pan && options.pan.noMoveStart);
				return this;
			},
			setZoom: function(zoom, options) {
				if (!this._loaded) {
					this._zoom = zoom;
					return this;
				}
				return this.setView(this.getCenter(), zoom, { zoom: options });
			},
			zoomIn: function(delta, options) {
				delta = delta || (Browser.any3d ? this.options.zoomDelta : 1);
				return this.setZoom(this._zoom + delta, options);
			},
			zoomOut: function(delta, options) {
				delta = delta || (Browser.any3d ? this.options.zoomDelta : 1);
				return this.setZoom(this._zoom - delta, options);
			},
			setZoomAround: function(latlng, zoom, options) {
				var scale = this.getZoomScale(zoom), viewHalf = this.getSize().divideBy(2), centerOffset = (latlng instanceof Point ? latlng : this.latLngToContainerPoint(latlng)).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() : toLatLngBounds(bounds);
				var paddingTL = toPoint(options.paddingTopLeft || options.padding || [0, 0]), paddingBR = toPoint(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;
				if (zoom === Infinity) return {
					center: bounds.getCenter(),
					zoom
				};
				var paddingOffset = paddingBR.subtract(paddingTL).divideBy(2), swPoint = this.project(bounds.getSouthWest(), zoom), nePoint = this.project(bounds.getNorthEast(), zoom);
				return {
					center: this.unproject(swPoint.add(nePoint).divideBy(2).add(paddingOffset), zoom),
					zoom
				};
			},
			fitBounds: function(bounds, options) {
				bounds = toLatLngBounds(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);
			},
			fitWorld: function(options) {
				return this.fitBounds([[-90, -180], [90, 180]], options);
			},
			panTo: function(center, options) {
				return this.setView(center, this._zoom, { pan: options });
			},
			panBy: function(offset, options) {
				offset = toPoint(offset).round();
				options = options || {};
				if (!offset.x && !offset.y) return this.fire("moveend");
				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 PosAnimation();
					this._panAnim.on({
						"step": this._onPanTransitionStep,
						"end": this._onPanTransitionEnd
					}, this);
				}
				if (!options.noMoveStart) this.fire("movestart");
				if (options.animate !== false) {
					addClass(this._mapPane, "leaflet-pan-anim");
					var newPos = this._getMapPanePos().subtract(offset).round();
					this._panAnim.run(this._mapPane, newPos, options.duration || .25, options.easeLinearity);
				} else {
					this._rawPanBy(offset);
					this.fire("move").fire("moveend");
				}
				return this;
			},
			flyTo: function(targetCenter, targetZoom, options) {
				options = options || {};
				if (options.animate === false || !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 = toLatLng(targetCenter);
				targetZoom = targetZoom === void 0 ? 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, b = (w1 * w1 - w0 * w0 + s1 * rho2 * rho2 * u1 * u1) / (2 * s2 * rho2 * u1), sq = Math.sqrt(b * b + 1) - b;
					return sq < 1e-9 ? -18 : Math.log(sq);
				}
				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 ? 1e3 * options.duration : 1e3 * S * .8;
				function frame() {
					var t = (Date.now() - start) / duration, s = easeOut(t) * S;
					if (t <= 1) {
						this._flyToFrame = 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, options.noMoveStart);
				frame.call(this);
				return this;
			},
			flyToBounds: function(bounds, options) {
				var target = this._getBoundsCenterZoom(bounds, options);
				return this.flyTo(target.center, target.zoom, options);
			},
			setMaxBounds: function(bounds) {
				bounds = toLatLngBounds(bounds);
				if (this.listens("moveend", this._panInsideMaxBounds)) this.off("moveend", this._panInsideMaxBounds);
				if (!bounds.isValid()) {
					this.options.maxBounds = null;
					return this;
				}
				this.options.maxBounds = bounds;
				if (this._loaded) this._panInsideMaxBounds();
				return this.on("moveend", this._panInsideMaxBounds);
			},
			setMinZoom: function(zoom) {
				var oldZoom = this.options.minZoom;
				this.options.minZoom = zoom;
				if (this._loaded && oldZoom !== zoom) {
					this.fire("zoomlevelschange");
					if (this.getZoom() < this.options.minZoom) return this.setZoom(zoom);
				}
				return this;
			},
			setMaxZoom: function(zoom) {
				var oldZoom = this.options.maxZoom;
				this.options.maxZoom = zoom;
				if (this._loaded && oldZoom !== zoom) {
					this.fire("zoomlevelschange");
					if (this.getZoom() > this.options.maxZoom) return this.setZoom(zoom);
				}
				return this;
			},
			panInsideBounds: function(bounds, options) {
				this._enforcingBounds = true;
				var center = this.getCenter(), newCenter = this._limitCenter(center, this._zoom, toLatLngBounds(bounds));
				if (!center.equals(newCenter)) this.panTo(newCenter, options);
				this._enforcingBounds = false;
				return this;
			},
			panInside: function(latlng, options) {
				options = options || {};
				var paddingTL = toPoint(options.paddingTopLeft || options.padding || [0, 0]), paddingBR = toPoint(options.paddingBottomRight || options.padding || [0, 0]), pixelCenter = this.project(this.getCenter()), pixelPoint = this.project(latlng), pixelBounds = this.getPixelBounds(), paddedBounds = toBounds([pixelBounds.min.add(paddingTL), pixelBounds.max.subtract(paddingBR)]), paddedSize = paddedBounds.getSize();
				if (!paddedBounds.contains(pixelPoint)) {
					this._enforcingBounds = true;
					var centerOffset = pixelPoint.subtract(paddedBounds.getCenter());
					var offset = paddedBounds.extend(pixelPoint).getSize().subtract(paddedSize);
					pixelCenter.x += centerOffset.x < 0 ? -offset.x : offset.x;
					pixelCenter.y += centerOffset.y < 0 ? -offset.y : offset.y;
					this.panTo(this.unproject(pixelCenter), options);
					this._enforcingBounds = false;
				}
				return this;
			},
			invalidateSize: function(options) {
				if (!this._loaded) return this;
				options = 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(bind(this.fire, this, "moveend"), 200);
					} else this.fire("moveend");
				}
				return this.fire("resize", {
					oldSize,
					newSize
				});
			},
			stop: function() {
				this.setZoom(this._limitZoom(this._zoom));
				if (!this.options.zoomSnap) this.fire("viewreset");
				return this._stop();
			},
			locate: function(options) {
				options = this._locateOptions = extend({
					timeout: 1e4,
					watch: false
				}, options);
				if (!("geolocation" in navigator)) {
					this._handleGeolocationError({
						code: 0,
						message: "Geolocation not supported."
					});
					return this;
				}
				var onResponse = bind(this._handleGeolocationResponse, this), onError = bind(this._handleGeolocationError, this);
				if (options.watch) this._locationWatchId = navigator.geolocation.watchPosition(onResponse, onError, options);
				else navigator.geolocation.getCurrentPosition(onResponse, onError, options);
				return this;
			},
			stopLocate: function() {
				if (navigator.geolocation && navigator.geolocation.clearWatch) navigator.geolocation.clearWatch(this._locationWatchId);
				if (this._locateOptions) this._locateOptions.setView = false;
				return this;
			},
			_handleGeolocationError: function(error) {
				if (!this._container._leaflet_id) return;
				var c = error.code, message = error.message || (c === 1 ? "permission denied" : c === 2 ? "position unavailable" : "timeout");
				if (this._locateOptions.setView && !this._loaded) this.fitWorld();
				this.fire("locationerror", {
					code: c,
					message: "Geolocation error: " + message + "."
				});
			},
			_handleGeolocationResponse: function(pos) {
				if (!this._container._leaflet_id) return;
				var lat = pos.coords.latitude, lng = pos.coords.longitude, latlng = new LatLng(lat, lng), bounds = latlng.toBounds(pos.coords.accuracy * 2), options = this._locateOptions;
				if (options.setView) {
					var zoom = this.getBoundsZoom(bounds);
					this.setView(latlng, options.maxZoom ? Math.min(zoom, options.maxZoom) : zoom);
				}
				var data = {
					latlng,
					bounds,
					timestamp: pos.timestamp
				};
				for (var i in pos.coords) if (typeof pos.coords[i] === "number") data[i] = pos.coords[i];
				this.fire("locationfound", data);
			},
			addHandler: function(name, HandlerClass) {
				if (!HandlerClass) return this;
				var handler = this[name] = new HandlerClass(this);
				this._handlers.push(handler);
				if (this.options[name]) handler.enable();
				return this;
			},
			remove: function() {
				this._initEvents(true);
				if (this.options.maxBounds) this.off("moveend", this._panInsideMaxBounds);
				if (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 (e) {
					this._container._leaflet_id = void 0;
					this._containerId = void 0;
				}
				if (this._locationWatchId !== void 0) this.stopLocate();
				this._stop();
				remove(this._mapPane);
				if (this._clearControlPos) this._clearControlPos();
				if (this._resizeRequest) {
					cancelAnimFrame(this._resizeRequest);
					this._resizeRequest = null;
				}
				this._clearHandlers();
				if (this._loaded) this.fire("unload");
				var i;
				for (i in this._layers) this._layers[i].remove();
				for (i in this._panes) remove(this._panes[i]);
				this._layers = [];
				this._panes = [];
				delete this._mapPane;
				delete this._renderer;
				return this;
			},
			createPane: function(name, container) {
				var pane = create$1("div", "leaflet-pane" + (name ? " leaflet-" + name.replace("Pane", "") + "-pane" : ""), container || this._mapPane);
				if (name) this._panes[name] = pane;
				return pane;
			},
			getCenter: function() {
				this._checkIfLoaded();
				if (this._lastCenter && !this._moved()) return this._lastCenter.clone();
				return this.layerPointToLatLng(this._getCenterLayerPoint());
			},
			getZoom: function() {
				return this._zoom;
			},
			getBounds: function() {
				var bounds = this.getPixelBounds();
				return new LatLngBounds(this.unproject(bounds.getBottomLeft()), this.unproject(bounds.getTopRight()));
			},
			getMinZoom: function() {
				return this.options.minZoom === void 0 ? this._layersMinZoom || 0 : this.options.minZoom;
			},
			getMaxZoom: function() {
				return this.options.maxZoom === void 0 ? this._layersMaxZoom === void 0 ? Infinity : this._layersMaxZoom : this.options.maxZoom;
			},
			getBoundsZoom: function(bounds, inside, padding) {
				bounds = toLatLngBounds(bounds);
				padding = toPoint(padding || [0, 0]);
				var zoom = this.getZoom() || 0, min = this.getMinZoom(), max = this.getMaxZoom(), nw = bounds.getNorthWest(), se = bounds.getSouthEast(), size = this.getSize().subtract(padding), boundsSize = toBounds(this.project(se, zoom), this.project(nw, zoom)).getSize(), snap = Browser.any3d ? this.options.zoomSnap : 1, scalex = size.x / boundsSize.x, scaley = size.y / boundsSize.y, scale = inside ? Math.max(scalex, scaley) : Math.min(scalex, scaley);
				zoom = this.getScaleZoom(scale, zoom);
				if (snap) {
					zoom = Math.round(zoom / (snap / 100)) * (snap / 100);
					zoom = inside ? Math.ceil(zoom / snap) * snap : Math.floor(zoom / snap) * snap;
				}
				return Math.max(min, Math.min(max, zoom));
			},
			getSize: function() {
				if (!this._size || this._sizeChanged) {
					this._size = new Point(this._container.clientWidth || 0, this._container.clientHeight || 0);
					this._sizeChanged = false;
				}
				return this._size.clone();
			},
			getPixelBounds: function(center, zoom) {
				var topLeftPoint = this._getTopLeftPoint(center, zoom);
				return new Bounds(topLeftPoint, topLeftPoint.add(this.getSize()));
			},
			getPixelOrigin: function() {
				this._checkIfLoaded();
				return this._pixelOrigin;
			},
			getPixelWorldBounds: function(zoom) {
				return this.options.crs.getProjectedBounds(zoom === void 0 ? this.getZoom() : zoom);
			},
			getPane: function(pane) {
				return typeof pane === "string" ? this._panes[pane] : pane;
			},
			getPanes: function() {
				return this._panes;
			},
			getContainer: function() {
				return this._container;
			},
			getZoomScale: function(toZoom, fromZoom) {
				var crs = this.options.crs;
				fromZoom = fromZoom === void 0 ? this._zoom : fromZoom;
				return crs.scale(toZoom) / crs.scale(fromZoom);
			},
			getScaleZoom: function(scale, fromZoom) {
				var crs = this.options.crs;
				fromZoom = fromZoom === void 0 ? this._zoom : fromZoom;
				var zoom = crs.zoom(scale * crs.scale(fromZoom));
				return isNaN(zoom) ? Infinity : zoom;
			},
			project: function(latlng, zoom) {
				zoom = zoom === void 0 ? this._zoom : zoom;
				return this.options.crs.latLngToPoint(toLatLng(latlng), zoom);
			},
			unproject: function(point, zoom) {
				zoom = zoom === void 0 ? this._zoom : zoom;
				return this.options.crs.pointToLatLng(toPoint(point), zoom);
			},
			layerPointToLatLng: function(point) {
				var projectedPoint = toPoint(point).add(this.getPixelOrigin());
				return this.unproject(projectedPoint);
			},
			latLngToLayerPoint: function(latlng) {
				return this.project(toLatLng(latlng))._round()._subtract(this.getPixelOrigin());
			},
			wrapLatLng: function(latlng) {
				return this.options.crs.wrapLatLng(toLatLng(latlng));
			},
			wrapLatLngBounds: function(latlng) {
				return this.options.crs.wrapLatLngBounds(toLatLngBounds(latlng));
			},
			distance: function(latlng1, latlng2) {
				return this.options.crs.distance(toLatLng(latlng1), toLatLng(latlng2));
			},
			containerPointToLayerPoint: function(point) {
				return toPoint(point).subtract(this._getMapPanePos());
			},
			layerPointToContainerPoint: function(point) {
				return toPoint(point).add(this._getMapPanePos());
			},
			containerPointToLatLng: function(point) {
				var layerPoint = this.containerPointToLayerPoint(toPoint(point));
				return this.layerPointToLatLng(layerPoint);
			},
			latLngToContainerPoint: function(latlng) {
				return this.layerPointToContainerPoint(this.latLngToLayerPoint(toLatLng(latlng)));
			},
			mouseEventToContainerPoint: function(e) {
				return getMousePosition(e, this._container);
			},
			mouseEventToLayerPoint: function(e) {
				return this.containerPointToLayerPoint(this.mouseEventToContainerPoint(e));
			},
			mouseEventToLatLng: function(e) {
				return this.layerPointToLatLng(this.mouseEventToLayerPoint(e));
			},
			_initContainer: function(id) {
				var container = this._container = get(id);
				if (!container) throw new Error("Map container not found.");
				else if (container._leaflet_id) throw new Error("Map container is already initialized.");
				on(container, "scroll", this._onScroll, this);
				this._containerId = stamp(container);
			},
			_initLayout: function() {
				var container = this._container;
				this._fadeAnimated = this.options.fadeAnimation && Browser.any3d;
				addClass(container, "leaflet-container" + (Browser.touch ? " leaflet-touch" : "") + (Browser.retina ? " leaflet-retina" : "") + (Browser.ielt9 ? " leaflet-oldie" : "") + (Browser.safari ? " leaflet-safari" : "") + (this._fadeAnimated ? " leaflet-fade-anim" : ""));
				var position = getStyle(container, "position");
				if (position !== "absolute" && position !== "relative" && position !== "fixed" && position !== "sticky") container.style.position = "relative";
				this._initPanes();
				if (this._initControlPos) this._initControlPos();
			},
			_initPanes: function() {
				var panes = this._panes = {};
				this._paneRenderers = {};
				this._mapPane = this.createPane("mapPane", this._container);
				setPosition(this._mapPane, new Point(0, 0));
				this.createPane("tilePane");
				this.createPane("overlayPane");
				this.createPane("shadowPane");
				this.createPane("markerPane");
				this.createPane("tooltipPane");
				this.createPane("popupPane");
				if (!this.options.markerZoomAnimation) {
					addClass(panes.markerPane, "leaflet-zoom-hide");
					addClass(panes.shadowPane, "leaflet-zoom-hide");
				}
			},
			_resetView: function(center, zoom, noMoveStart) {
				setPosition(this._mapPane, new Point(0, 0));
				var loading = !this._loaded;
				this._loaded = true;
				zoom = this._limitZoom(zoom);
				this.fire("viewprereset");
				var zoomChanged = this._zoom !== zoom;
				this._moveStart(zoomChanged, noMoveStart)._move(center, zoom)._moveEnd(zoomChanged);
				this.fire("viewreset");
				if (loading) this.fire("load");
			},
			_moveStart: function(zoomChanged, noMoveStart) {
				if (zoomChanged) this.fire("zoomstart");
				if (!noMoveStart) this.fire("movestart");
				return this;
			},
			_move: function(center, zoom, data, supressEvent) {
				if (zoom === void 0) zoom = this._zoom;
				var zoomChanged = this._zoom !== zoom;
				this._zoom = zoom;
				this._lastCenter = center;
				this._pixelOrigin = this._getNewPixelOrigin(center);
				if (!supressEvent) {
					if (zoomChanged || data && data.pinch) this.fire("zoom", data);
					this.fire("move", data);
				} else if (data && data.pinch) this.fire("zoom", data);
				return this;
			},
			_moveEnd: function(zoomChanged) {
				if (zoomChanged) this.fire("zoomend");
				return this.fire("moveend");
			},
			_stop: function() {
				cancelAnimFrame(this._flyToFrame);
				if (this._panAnim) this._panAnim.stop();
				return this;
			},
			_rawPanBy: function(offset) {
				setPosition(this._mapPane, this._getMapPanePos().subtract(offset));
			},
			_getZoomSpan: function() {
				return this.getMaxZoom() - this.getMinZoom();
			},
			_panInsideMaxBounds: function() {
				if (!this._enforcingBounds) this.panInsideBounds(this.options.maxBounds);
			},
			_checkIfLoaded: function() {
				if (!this._loaded) throw new Error("Set map center and zoom first.");
			},
			_initEvents: function(remove) {
				this._targets = {};
				this._targets[stamp(this._container)] = this;
				var onOff = remove ? off : on;
				onOff(this._container, "click dblclick mousedown mouseup mouseover mouseout mousemove contextmenu keypress keydown keyup", this._handleDOMEvent, this);
				if (this.options.trackResize) onOff(window, "resize", this._onResize, this);
				if (Browser.any3d && this.options.transform3DLimit) (remove ? this.off : this.on).call(this, "moveend", this._onMoveEnd);
			},
			_onResize: function() {
				cancelAnimFrame(this._resizeRequest);
				this._resizeRequest = requestAnimFrame(function() {
					this.invalidateSize({ debounceMoveend: true });
				}, this);
			},
			_onScroll: function() {
				this._container.scrollTop = 0;
				this._container.scrollLeft = 0;
			},
			_onMoveEnd: function() {
				var pos = this._getMapPanePos();
				if (Math.max(Math.abs(pos.x), Math.abs(pos.y)) >= this.options.transform3DLimit) this._resetView(this.getCenter(), this.getZoom());
			},
			_findEventTargets: function(e, type) {
				var targets = [], target, isHover = type === "mouseout" || type === "mouseover", src = e.target || e.srcElement, dragging = false;
				while (src) {
					target = this._targets[stamp(src)];
					if (target && (type === "click" || type === "preclick") && this._draggableMoved(target)) {
						dragging = true;
						break;
					}
					if (target && target.listens(type, true)) {
						if (isHover && !isExternalTarget(src, e)) break;
						targets.push(target);
						if (isHover) break;
					}
					if (src === this._container) break;
					src = src.parentNode;
				}
				if (!targets.length && !dragging && !isHover && this.listens(type, true)) targets = [this];
				return targets;
			},
			_isClickDisabled: function(el) {
				while (el && el !== this._container) {
					if (el["_leaflet_disable_click"]) return true;
					el = el.parentNode;
				}
			},
			_handleDOMEvent: function(e) {
				var el = e.target || e.srcElement;
				if (!this._loaded || el["_leaflet_disable_events"] || e.type === "click" && this._isClickDisabled(el)) return;
				var type = e.type;
				if (type === "mousedown") preventOutline(el);
				this._fireDOMEvent(e, type);
			},
			_mouseEvents: [
				"click",
				"dblclick",
				"mouseover",
				"mouseout",
				"contextmenu"
			],
			_fireDOMEvent: function(e, type, canvasTargets) {
				if (e.type === "click") {
					var synth = extend({}, e);
					synth.type = "preclick";
					this._fireDOMEvent(synth, synth.type, canvasTargets);
				}
				var targets = this._findEventTargets(e, type);
				if (canvasTargets) {
					var filtered = [];
					for (var i = 0; i < canvasTargets.length; i++) if (canvasTargets[i].listens(type, true)) filtered.push(canvasTargets[i]);
					targets = filtered.concat(targets);
				}
				if (!targets.length) return;
				if (type === "contextmenu") preventDefault(e);
				var target = targets[0];
				var data = { originalEvent: e };
				if (e.type !== "keypress" && e.type !== "keydown" && e.type !== "keyup") {
					var isMarker = target.getLatLng && (!target._radius || target._radius <= 10);
					data.containerPoint = isMarker ? this.latLngToContainerPoint(target.getLatLng()) : this.mouseEventToContainerPoint(e);
					data.layerPoint = this.containerPointToLayerPoint(data.containerPoint);
					data.latlng = isMarker ? target.getLatLng() : this.layerPointToLatLng(data.layerPoint);
				}
				for (i = 0; i < targets.length; i++) {
					targets[i].fire(type, data, true);
					if (data.originalEvent._stopped || targets[i].options.bubblingMouseEvents === false && indexOf(this._mouseEvents, type) !== -1) return;
				}
			},
			_draggableMoved: function(obj) {
				obj = obj.dragging && obj.dragging.enabled() ? obj : this;
				return obj.dragging && obj.dragging.moved() || this.boxZoom && this.boxZoom.moved();
			},
			_clearHandlers: function() {
				for (var i = 0, len = this._handlers.length; i < len; i++) this._handlers[i].disable();
			},
			whenReady: function(callback, context) {
				if (this._loaded) callback.call(context || this, { target: this });
				else this.on("load", callback, context);
				return this;
			},
			_getMapPanePos: function() {
				return getPosition(this._mapPane) || new Point(0, 0);
			},
			_moved: function() {
				var pos = this._getMapPanePos();
				return pos && !pos.equals([0, 0]);
			},
			_getTopLeftPoint: function(center, zoom) {
				return (center && zoom !== void 0 ? this._getNewPixelOrigin(center, zoom) : this.getPixelOrigin()).subtract(this._getMapPanePos());
			},
			_getNewPixelOrigin: function(center, zoom) {
				var viewHalf = this.getSize()._divideBy(2);
				return this.project(center, zoom)._subtract(viewHalf)._add(this._getMapPanePos())._round();
			},
			_latLngToNewLayerPoint: function(latlng, zoom, center) {
				var topLeft = this._getNewPixelOrigin(center, zoom);
				return this.project(latlng, zoom)._subtract(topLeft);
			},
			_latLngBoundsToNewLayerBounds: function(latLngBounds, zoom, center) {
				var topLeft = this._getNewPixelOrigin(center, zoom);
				return toBounds([
					this.project(latLngBounds.getSouthWest(), zoom)._subtract(topLeft),
					this.project(latLngBounds.getNorthWest(), zoom)._subtract(topLeft),
					this.project(latLngBounds.getSouthEast(), zoom)._subtract(topLeft),
					this.project(latLngBounds.getNorthEast(), zoom)._subtract(topLeft)
				]);
			},
			_getCenterLayerPoint: function() {
				return this.containerPointToLayerPoint(this.getSize()._divideBy(2));
			},
			_getCenterOffset: function(latlng) {
				return this.latLngToLayerPoint(latlng).subtract(this._getCenterLayerPoint());
			},
			_limitCenter: function(center, zoom, bounds) {
				if (!bounds) return center;
				var centerPoint = this.project(center, zoom), viewHalf = this.getSize().divideBy(2), viewBounds = new Bounds(centerPoint.subtract(viewHalf), centerPoint.add(viewHalf)), offset = this._getBoundsOffset(viewBounds, bounds, zoom);
				if (Math.abs(offset.x) <= 1 && Math.abs(offset.y) <= 1) return center;
				return this.unproject(centerPoint.add(offset), zoom);
			},
			_limitOffset: function(offset, bounds) {
				if (!bounds) return offset;
				var viewBounds = this.getPixelBounds(), newBounds = new Bounds(viewBounds.min.add(offset), viewBounds.max.add(offset));
				return offset.add(this._getBoundsOffset(newBounds, bounds));
			},
			_getBoundsOffset: function(pxBounds, maxBounds, zoom) {
				var projectedMaxBounds = toBounds(this.project(maxBounds.getNorthEast(), zoom), this.project(maxBounds.getSouthWest(), zoom)), minOffset = projectedMaxBounds.min.subtract(pxBounds.min), maxOffset = projectedMaxBounds.max.subtract(pxBounds.max);
				return new Point(this._rebound(minOffset.x, -maxOffset.x), this._rebound(minOffset.y, -maxOffset.y));
			},
			_rebound: function(left, right) {
				return left + right > 0 ? Math.round(left - right) / 2 : Math.max(0, Math.ceil(left)) - Math.max(0, Math.floor(right));
			},
			_limitZoom: function(zoom) {
				var min = this.getMinZoom(), max = this.getMaxZoom(), snap = Browser.any3d ? this.options.zoomSnap : 1;
				if (snap) zoom = Math.round(zoom / snap) * snap;
				return Math.max(min, Math.min(max, zoom));
			},
			_onPanTransitionStep: function() {
				this.fire("move");
			},
			_onPanTransitionEnd: function() {
				removeClass(this._mapPane, "leaflet-pan-anim");
				this.fire("moveend");
			},
			_tryAnimatedPan: function(center, options) {
				var offset = this._getCenterOffset(center)._trunc();
				if ((options && options.animate) !== true && !this.getSize().contains(offset)) return false;
				this.panBy(offset, options);
				return true;
			},
			_createAnimProxy: function() {
				var proxy = this._proxy = create$1("div", "leaflet-proxy leaflet-zoom-animated");
				this._panes.mapPane.appendChild(proxy);
				this.on("zoomanim", function(e) {
					var prop = TRANSFORM, transform = this._proxy.style[prop];
					setTransform(this._proxy, this.project(e.center, e.zoom), this.getZoomScale(e.zoom, 1));
					if (transform === this._proxy.style[prop] && this._animatingZoom) this._onZoomTransitionEnd();
				}, this);
				this.on("load moveend", this._animMoveEnd, this);
				this._on("unload", this._destroyAnimProxy, this);
			},
			_destroyAnimProxy: function() {
				remove(this._proxy);
				this.off("load moveend", this._animMoveEnd, this);
				delete this._proxy;
			},
			_animMoveEnd: function() {
				var c = this.getCenter(), z = this.getZoom();
				setTransform(this._proxy, this.project(c, z), this.getZoomScale(z, 1));
			},
			_catchTransitionEnd: function(e) {
				if (this._animatingZoom && e.propertyName.indexOf("transform") >= 0) this._onZoomTransitionEnd();
			},
			_nothingToAnimate: function() {
				return !this._container.getElementsByClassName("leaflet-zoom-animated").length;
			},
			_tryAnimatedZoom: function(center, zoom, options) {
				if (this._animatingZoom) return true;
				options = options || {};
				if (!this._zoomAnimated || options.animate === false || this._nothingToAnimate() || Math.abs(zoom - this._zoom) > this.options.zoomAnimationThreshold) return false;
				var scale = this.getZoomScale(zoom), offset = this._getCenterOffset(center)._divideBy(1 - 1 / scale);
				if (options.animate !== true && !this.getSize().contains(offset)) return false;
				requestAnimFrame(function() {
					this._moveStart(true, options.noMoveStart || false)._animateZoom(center, zoom, true);
				}, this);
				return true;
			},
			_animateZoom: function(center, zoom, startAnim, noUpdate) {
				if (!this._mapPane) return;
				if (startAnim) {
					this._animatingZoom = true;
					this._animateToCenter = center;
					this._animateToZoom = zoom;
					addClass(this._mapPane, "leaflet-zoom-anim");
				}
				this.fire("zoomanim", {
					center,
					zoom,
					noUpdate
				});
				if (!this._tempFireZoomEvent) this._tempFireZoomEvent = this._zoom !== this._animateToZoom;
				this._move(this._animateToCenter, this._animateToZoom, void 0, true);
				setTimeout(bind(this._onZoomTransitionEnd, this), 250);
			},
			_onZoomTransitionEnd: function() {
				if (!this._animatingZoom) return;
				if (this._mapPane) removeClass(this._mapPane, "leaflet-zoom-anim");
				this._animatingZoom = false;
				this._move(this._animateToCenter, this._animateToZoom, void 0, true);
				if (this._tempFireZoomEvent) this.fire("zoom");
				delete this._tempFireZoomEvent;
				this.fire("move");
				this._moveEnd(true);
			}
		});
		function createMap(id, options) {
			return new Map(id, options);
		}
		var Control = Class.extend({
			options: { position: "topright" },
			initialize: function(options) {
				setOptions(this, options);
			},
			getPosition: function() {
				return this.options.position;
			},
			setPosition: function(position) {
				var map = this._map;
				if (map) map.removeControl(this);
				this.options.position = position;
				if (map) map.addControl(this);
				return this;
			},
			getContainer: function() {
				return this._container;
			},
			addTo: function(map) {
				this.remove();
				this._map = map;
				var container = this._container = this.onAdd(map), pos = this.getPosition(), corner = map._controlCorners[pos];
				addClass(container, "leaflet-control");
				if (pos.indexOf("bottom") !== -1) corner.insertBefore(container, corner.firstChild);
				else corner.appendChild(container);
				this._map.on("unload", this.remove, this);
				return this;
			},
			remove: function() {
				if (!this._map) return this;
				remove(this._container);
				if (this.onRemove) this.onRemove(this._map);
				this._map.off("unload", this.remove, this);
				this._map = null;
				return this;
			},
			_refocusOnMap: function(e) {
				if (this._map && e && e.screenX > 0 && e.screenY > 0) this._map.getContainer().focus();
			}
		});
		var control = function(options) {
			return new Control(options);
		};
		Map.include({
			addControl: function(control) {
				control.addTo(this);
				return this;
			},
			removeControl: function(control) {
				control.remove();
				return this;
			},
			_initControlPos: function() {
				var corners = this._controlCorners = {}, l = "leaflet-", container = this._controlContainer = create$1("div", l + "control-container", this._container);
				function createCorner(vSide, hSide) {
					var className = l + vSide + " " + l + hSide;
					corners[vSide + hSide] = create$1("div", className, container);
				}
				createCorner("top", "left");
				createCorner("top", "right");
				createCorner("bottom", "left");
				createCorner("bottom", "right");
			},
			_clearControlPos: function() {
				for (var i in this._controlCorners) remove(this._controlCorners[i]);
				remove(this._controlContainer);
				delete this._controlCorners;
				delete this._controlContainer;
			}
		});
		var Layers = Control.extend({
			options: {
				collapsed: true,
				position: "topright",
				autoZIndex: true,
				hideSingleBase: false,
				sortLayers: false,
				sortFunction: function(layerA, layerB, nameA, nameB) {
					return nameA < nameB ? -1 : nameB < nameA ? 1 : 0;
				}
			},
			initialize: function(baseLayers, overlays, options) {
				setOptions(this, options);
				this._layerControlInputs = [];
				this._layers = [];
				this._lastZIndex = 0;
				this._handlingClick = false;
				this._preventClick = 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);
				for (var i = 0; i < this._layers.length; i++) this._layers[i].layer.on("add remove", this._onLayerChange, this);
				return this._container;
			},
			addTo: function(map) {
				Control.prototype.addTo.call(this, map);
				return this._expandIfNotCollapsed();
			},
			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);
			},
			addBaseLayer: function(layer, name) {
				this._addLayer(layer, name);
				return this._map ? this._update() : this;
			},
			addOverlay: function(layer, name) {
				this._addLayer(layer, name, true);
				return this._map ? this._update() : this;
			},
			removeLayer: function(layer) {
				layer.off("add remove", this._onLayerChange, this);
				var obj = this._getLayer(stamp(layer));
				if (obj) this._layers.splice(this._layers.indexOf(obj), 1);
				return this._map ? this._update() : this;
			},
			expand: function() {
				addClass(this._container, "leaflet-control-layers-expanded");
				this._section.style.height = null;
				var acceptableHeight = this._map.getSize().y - (this._container.offsetTop + 50);
				if (acceptableHeight < this._section.clientHeight) {
					addClass(this._section, "leaflet-control-layers-scrollbar");
					this._section.style.height = acceptableHeight + "px";
				} else removeClass(this._section, "leaflet-control-layers-scrollbar");
				this._checkDisabledLayers();
				return this;
			},
			collapse: function() {
				removeClass(this._container, "leaflet-control-layers-expanded");
				return this;
			},
			_initLayout: function() {
				var className = "leaflet-control-layers", container = this._container = create$1("div", className), collapsed = this.options.collapsed;
				container.setAttribute("aria-haspopup", true);
				disableClickPropagation(container);
				disableScrollPropagation(container);
				var section = this._section = create$1("section", className + "-list");
				if (collapsed) {
					this._map.on("click", this.collapse, this);
					on(container, {
						mouseenter: this._expandSafely,
						mouseleave: this.collapse
					}, this);
				}
				var link = this._layersLink = create$1("a", className + "-toggle", container);
				link.href = "#";
				link.title = "Layers";
				link.setAttribute("role", "button");
				on(link, {
					keydown: function(e) {
						if (e.keyCode === 13) this._expandSafely();
					},
					click: function(e) {
						preventDefault(e);
						this._expandSafely();
					}
				}, this);
				if (!collapsed) this.expand();
				this._baseLayersList = create$1("div", className + "-base", section);
				this._separator = create$1("div", className + "-separator", section);
				this._overlaysList = create$1("div", className + "-overlays", section);
				container.appendChild(section);
			},
			_getLayer: function(id) {
				for (var i = 0; i < this._layers.length; i++) if (this._layers[i] && stamp(this._layers[i].layer) === id) return this._layers[i];
			},
			_addLayer: function(layer, name, overlay) {
				if (this._map) layer.on("add remove", this._onLayerChange, this);
				this._layers.push({
					layer,
					name,
					overlay
				});
				if (this.options.sortLayers) this._layers.sort(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);
				}
				this._expandIfNotCollapsed();
			},
			_update: function() {
				if (!this._container) return this;
				empty(this._baseLayersList);
				empty(this._overlaysList);
				this._layerControlInputs = [];
				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;
				}
				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(stamp(e.target));
				var type = obj.overlay ? e.type === "add" ? "overlayadd" : "overlayremove" : e.type === "add" ? "baselayerchange" : null;
				if (type) this._map.fire(type, obj);
			},
			_createRadioElement: function(name, checked) {
				var radioHtml = "<input type=\"radio\" class=\"leaflet-control-layers-selector\" name=\"" + name + "\"" + (checked ? " checked=\"checked\"" : "") + "/>";
				var radioFragment = document.createElement("div");
				radioFragment.innerHTML = radioHtml;
				return radioFragment.firstChild;
			},
			_addItem: function(obj) {
				var label = document.createElement("label"), checked = this._map.hasLayer(obj.layer), input;
				if (obj.overlay) {
					input = document.createElement("input");
					input.type = "checkbox";
					input.className = "leaflet-control-layers-selector";
					input.defaultChecked = checked;
				} else input = this._createRadioElement("leaflet-base-layers_" + stamp(this), checked);
				this._layerControlInputs.push(input);
				input.layerId = stamp(obj.layer);
				on(input, "click", this._onInputClick, this);
				var name = document.createElement("span");
				name.innerHTML = " " + obj.name;
				var holder = document.createElement("span");
				label.appendChild(holder);
				holder.appendChild(input);
				holder.appendChild(name);
				(obj.overlay ? this._overlaysList : this._baseLayersList).appendChild(label);
				this._checkDisabledLayers();
				return label;
			},
			_onInputClick: function() {
				if (this._preventClick) return;
				var inputs = this._layerControlInputs, input, layer;
				var addedLayers = [], removedLayers = [];
				this._handlingClick = true;
				for (var i = inputs.length - 1; i >= 0; i--) {
					input = inputs[i];
					layer = this._getLayer(input.layerId).layer;
					if (input.checked) addedLayers.push(layer);
					else if (!input.checked) removedLayers.push(layer);
				}
				for (i = 0; i < removedLayers.length; i++) if (this._map.hasLayer(removedLayers[i])) this._map.removeLayer(removedLayers[i]);
				for (i = 0; i < addedLayers.length; i++) if (!this._map.hasLayer(addedLayers[i])) this._map.addLayer(addedLayers[i]);
				this._handlingClick = false;
				this._refocusOnMap();
			},
			_checkDisabledLayers: function() {
				var inputs = this._layerControlInputs, input, layer, zoom = this._map.getZoom();
				for (var i = inputs.length - 1; i >= 0; i--) {
					input = inputs[i];
					layer = this._getLayer(input.layerId).layer;
					input.disabled = layer.options.minZoom !== void 0 && zoom < layer.options.minZoom || layer.options.maxZoom !== void 0 && zoom > layer.options.maxZoom;
				}
			},
			_expandIfNotCollapsed: function() {
				if (this._map && !this.options.collapsed) this.expand();
				return this;
			},
			_expandSafely: function() {
				var section = this._section;
				this._preventClick = true;
				on(section, "click", preventDefault);
				this.expand();
				var that = this;
				setTimeout(function() {
					off(section, "click", preventDefault);
					that._preventClick = false;
				});
			}
		});
		var layers = function(baseLayers, overlays, options) {
			return new Layers(baseLayers, overlays, options);
		};
		var Zoom = Control.extend({
			options: {
				position: "topleft",
				zoomInText: "<span aria-hidden=\"true\">+</span>",
				zoomInTitle: "Zoom in",
				zoomOutText: "<span aria-hidden=\"true\">&#x2212;</span>",
				zoomOutTitle: "Zoom out"
			},
			onAdd: function(map) {
				var zoomName = "leaflet-control-zoom", container = create$1("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 = create$1("a", className, container);
				link.innerHTML = html;
				link.href = "#";
				link.title = title;
				link.setAttribute("role", "button");
				link.setAttribute("aria-label", title);
				disableClickPropagation(link);
				on(link, "click", stop);
				on(link, "click", fn, this);
				on(link, "click", this._refocusOnMap, this);
				return link;
			},
			_updateDisabled: function() {
				var map = this._map, className = "leaflet-disabled";
				removeClass(this._zoomInButton, className);
				removeClass(this._zoomOutButton, className);
				this._zoomInButton.setAttribute("aria-disabled", "false");
				this._zoomOutButton.setAttribute("aria-disabled", "false");
				if (this._disabled || map._zoom === map.getMinZoom()) {
					addClass(this._zoomOutButton, className);
					this._zoomOutButton.setAttribute("aria-disabled", "true");
				}
				if (this._disabled || map._zoom === map.getMaxZoom()) {
					addClass(this._zoomInButton, className);
					this._zoomInButton.setAttribute("aria-disabled", "true");
				}
			}
		});
		Map.mergeOptions({ zoomControl: true });
		Map.addInitHook(function() {
			if (this.options.zoomControl) {
				this.zoomControl = new Zoom();
				this.addControl(this.zoomControl);
			}
		});
		var zoom = function(options) {
			return new Zoom(options);
		};
		var Scale = Control.extend({
			options: {
				position: "bottomleft",
				maxWidth: 100,
				metric: true,
				imperial: true
			},
			onAdd: function(map) {
				var className = "leaflet-control-scale", container = create$1("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 = create$1("div", className, container);
				if (options.imperial) this._iScale = create$1("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 < 1e3 ? meters + " m" : meters / 1e3 + " 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;
			}
		});
		var scale = function(options) {
			return new Scale(options);
		};
		var Attribution = Control.extend({
			options: {
				position: "bottomright",
				prefix: "<a href=\"https://leafletjs.com\" title=\"A JavaScript library for interactive maps\">" + (Browser.inlineSvg ? "<svg aria-hidden=\"true\" xmlns=\"http://www.w3.org/2000/svg\" width=\"12\" height=\"8\" viewBox=\"0 0 12 8\" class=\"leaflet-attribution-flag\"><path fill=\"#4C7BE1\" d=\"M0 0h12v4H0z\"/><path fill=\"#FFD500\" d=\"M0 4h12v3H0z\"/><path fill=\"#E0BC00\" d=\"M0 7h12v1H0z\"/></svg> " : "") + "Leaflet</a>"
			},
			initialize: function(options) {
				setOptions(this, options);
				this._attributions = {};
			},
			onAdd: function(map) {
				map.attributionControl = this;
				this._container = create$1("div", "leaflet-control-attribution");
				disableClickPropagation(this._container);
				for (var i in map._layers) if (map._layers[i].getAttribution) this.addAttribution(map._layers[i].getAttribution());
				this._update();
				map.on("layeradd", this._addAttribution, this);
				return this._container;
			},
			onRemove: function(map) {
				map.off("layeradd", this._addAttribution, this);
			},
			_addAttribution: function(ev) {
				if (ev.layer.getAttribution) {
					this.addAttribution(ev.layer.getAttribution());
					ev.layer.once("remove", function() {
						this.removeAttribution(ev.layer.getAttribution());
					}, this);
				}
			},
			setPrefix: function(prefix) {
				this.options.prefix = prefix;
				this._update();
				return this;
			},
			addAttribution: function(text) {
				if (!text) return this;
				if (!this._attributions[text]) this._attributions[text] = 0;
				this._attributions[text]++;
				this._update();
				return this;
			},
			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(" <span aria-hidden=\"true\">|</span> ");
			}
		});
		Map.mergeOptions({ attributionControl: true });
		Map.addInitHook(function() {
			if (this.options.attributionControl) new Attribution().addTo(this);
		});
		var attribution = function(options) {
			return new Attribution(options);
		};
		Control.Layers = Layers;
		Control.Zoom = Zoom;
		Control.Scale = Scale;
		Control.Attribution = Attribution;
		control.layers = layers;
		control.zoom = zoom;
		control.scale = scale;
		control.attribution = attribution;
		var Handler = Class.extend({
			initialize: function(map) {
				this._map = map;
			},
			enable: function() {
				if (this._enabled) return this;
				this._enabled = true;
				this.addHooks();
				return this;
			},
			disable: function() {
				if (!this._enabled) return this;
				this._enabled = false;
				this.removeHooks();
				return this;
			},
			enabled: function() {
				return !!this._enabled;
			}
		});
		Handler.addTo = function(map, name) {
			map.addHandler(name, this);
			return this;
		};
		var Mixin = { Events };
		var START = Browser.touch ? "touchstart mousedown" : "mousedown";
		var Draggable = Evented.extend({
			options: { clickTolerance: 3 },
			initialize: function(element, dragStartTarget, preventOutline, options) {
				setOptions(this, options);
				this._element = element;
				this._dragStartTarget = dragStartTarget || element;
				this._preventOutline = preventOutline;
			},
			enable: function() {
				if (this._enabled) return;
				on(this._dragStartTarget, START, this._onDown, this);
				this._enabled = true;
			},
			disable: function() {
				if (!this._enabled) return;
				if (Draggable._dragging === this) this.finishDrag(true);
				off(this._dragStartTarget, START, this._onDown, this);
				this._enabled = false;
				this._moved = false;
			},
			_onDown: function(e) {
				if (!this._enabled) return;
				this._moved = false;
				if (hasClass(this._element, "leaflet-zoom-anim")) return;
				if (e.touches && e.touches.length !== 1) {
					if (Draggable._dragging === this) this.finishDrag();
					return;
				}
				if (Draggable._dragging || e.shiftKey || e.which !== 1 && e.button !== 1 && !e.touches) return;
				Draggable._dragging = this;
				if (this._preventOutline) preventOutline(this._element);
				disableImageDrag();
				disableTextSelection();
				if (this._moving) return;
				this.fire("down");
				var first = e.touches ? e.touches[0] : e, sizedParent = getSizedParentNode(this._element);
				this._startPoint = new Point(first.clientX, first.clientY);
				this._startPos = getPosition(this._element);
				this._parentScale = getScale(sizedParent);
				var mouseevent = e.type === "mousedown";
				on(document, mouseevent ? "mousemove" : "touchmove", this._onMove, this);
				on(document, mouseevent ? "mouseup" : "touchend touchcancel", this._onUp, this);
			},
			_onMove: function(e) {
				if (!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, offset = new Point(first.clientX, first.clientY)._subtract(this._startPoint);
				if (!offset.x && !offset.y) return;
				if (Math.abs(offset.x) + Math.abs(offset.y) < this.options.clickTolerance) return;
				offset.x /= this._parentScale.x;
				offset.y /= this._parentScale.y;
				preventDefault(e);
				if (!this._moved) {
					this.fire("dragstart");
					this._moved = true;
					addClass(document.body, "leaflet-dragging");
					this._lastTarget = e.target || e.srcElement;
					if (window.SVGElementInstance && this._lastTarget instanceof window.SVGElementInstance) this._lastTarget = this._lastTarget.correspondingUseElement;
					addClass(this._lastTarget, "leaflet-drag-target");
				}
				this._newPos = this._startPos.add(offset);
				this._moving = true;
				this._lastEvent = e;
				this._updatePosition();
			},
			_updatePosition: function() {
				var e = { originalEvent: this._lastEvent };
				this.fire("predrag", e);
				setPosition(this._element, this._newPos);
				this.fire("drag", e);
			},
			_onUp: function() {
				if (!this._enabled) return;
				this.finishDrag();
			},
			finishDrag: function(noInertia) {
				removeClass(document.body, "leaflet-dragging");
				if (this._lastTarget) {
					removeClass(this._lastTarget, "leaflet-drag-target");
					this._lastTarget = null;
				}
				off(document, "mousemove touchmove", this._onMove, this);
				off(document, "mouseup touchend touchcancel", this._onUp, this);
				enableImageDrag();
				enableTextSelection();
				var fireDragend = this._moved && this._moving;
				this._moving = false;
				Draggable._dragging = false;
				if (fireDragend) this.fire("dragend", {
					noInertia,
					distance: this._newPos.distanceTo(this._startPos)
				});
			}
		});
		function clipPolygon(points, bounds, round) {
			var clippedPoints, edges = [
				1,
				4,
				2,
				8
			], i, j, k, a, b, len, edge, p;
			for (i = 0, len = points.length; i < len; i++) points[i]._code = _getBitCode(points[i], bounds);
			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._code & edge)) {
						if (b._code & edge) {
							p = _getEdgeIntersection(b, a, edge, bounds, round);
							p._code = _getBitCode(p, bounds);
							clippedPoints.push(p);
						}
						clippedPoints.push(a);
					} else if (!(b._code & edge)) {
						p = _getEdgeIntersection(b, a, edge, bounds, round);
						p._code = _getBitCode(p, bounds);
						clippedPoints.push(p);
					}
				}
				points = clippedPoints;
			}
			return points;
		}
		function polygonCenter(latlngs, crs) {
			var i, j, p1, p2, f, area, x, y, center;
			if (!latlngs || latlngs.length === 0) throw new Error("latlngs not passed");
			if (!isFlat(latlngs)) {
				console.warn("latlngs are not flat! Only the first ring will be used");
				latlngs = latlngs[0];
			}
			var centroidLatLng = toLatLng([0, 0]);
			var bounds = toLatLngBounds(latlngs);
			if (bounds.getNorthWest().distanceTo(bounds.getSouthWest()) * bounds.getNorthEast().distanceTo(bounds.getNorthWest()) < 1700) centroidLatLng = centroid(latlngs);
			var len = latlngs.length;
			var points = [];
			for (i = 0; i < len; i++) {
				var latlng = toLatLng(latlngs[i]);
				points.push(crs.project(toLatLng([latlng.lat - centroidLatLng.lat, latlng.lng - centroidLatLng.lng])));
			}
			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) center = points[0];
			else center = [x / area, y / area];
			var latlngCenter = crs.unproject(toPoint(center));
			return toLatLng([latlngCenter.lat + centroidLatLng.lat, latlngCenter.lng + centroidLatLng.lng]);
		}
		function centroid(coords) {
			var latSum = 0;
			var lngSum = 0;
			var len = 0;
			for (var i = 0; i < coords.length; i++) {
				var latlng = toLatLng(coords[i]);
				latSum += latlng.lat;
				lngSum += latlng.lng;
				len++;
			}
			return toLatLng([latSum / len, lngSum / len]);
		}
		var PolyUtil = {
			__proto__: null,
			clipPolygon,
			polygonCenter,
			centroid
		};
		function simplify(points, tolerance) {
			if (!tolerance || !points.length) return points.slice();
			var sqTolerance = tolerance * tolerance;
			points = _reducePoints(points, sqTolerance);
			points = _simplifyDP(points, sqTolerance);
			return points;
		}
		function pointToSegmentDistance(p, p1, p2) {
			return Math.sqrt(_sqClosestPointOnSegment(p, p1, p2, true));
		}
		function closestPointOnSegment(p, p1, p2) {
			return _sqClosestPointOnSegment(p, p1, p2);
		}
		function _simplifyDP(points, sqTolerance) {
			var len = points.length, markers = new (typeof Uint8Array !== "undefined" ? Uint8Array : Array)(len);
			markers[0] = markers[len - 1] = 1;
			_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;
		}
		function _simplifyDPStep(points, markers, sqTolerance, first, last) {
			var maxSqDist = 0, index, i, sqDist;
			for (i = first + 1; i <= last - 1; i++) {
				sqDist = _sqClosestPointOnSegment(points[i], points[first], points[last], true);
				if (sqDist > maxSqDist) {
					index = i;
					maxSqDist = sqDist;
				}
			}
			if (maxSqDist > sqTolerance) {
				markers[index] = 1;
				_simplifyDPStep(points, markers, sqTolerance, first, index);
				_simplifyDPStep(points, markers, sqTolerance, index, last);
			}
		}
		function _reducePoints(points, sqTolerance) {
			var reducedPoints = [points[0]];
			for (var i = 1, prev = 0, len = points.length; i < len; i++) if (_sqDist(points[i], points[prev]) > sqTolerance) {
				reducedPoints.push(points[i]);
				prev = i;
			}
			if (prev < len - 1) reducedPoints.push(points[len - 1]);
			return reducedPoints;
		}
		var _lastCode;
		function clipSegment(a, b, bounds, useLastCode, round) {
			var codeA = useLastCode ? _lastCode : _getBitCode(a, bounds), codeB = _getBitCode(b, bounds), codeOut, p, newCode;
			_lastCode = codeB;
			while (true) {
				if (!(codeA | codeB)) return [a, b];
				if (codeA & codeB) return false;
				codeOut = codeA || codeB;
				p = _getEdgeIntersection(a, b, codeOut, bounds, round);
				newCode = _getBitCode(p, bounds);
				if (codeOut === codeA) {
					a = p;
					codeA = newCode;
				} else {
					b = p;
					codeB = newCode;
				}
			}
		}
		function _getEdgeIntersection(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) {
				x = a.x + dx * (max.y - a.y) / dy;
				y = max.y;
			} else if (code & 4) {
				x = a.x + dx * (min.y - a.y) / dy;
				y = min.y;
			} else if (code & 2) {
				x = max.x;
				y = a.y + dy * (max.x - a.x) / dx;
			} else if (code & 1) {
				x = min.x;
				y = a.y + dy * (min.x - a.x) / dx;
			}
			return new Point(x, y, round);
		}
		function _getBitCode(p, bounds) {
			var code = 0;
			if (p.x < bounds.min.x) code |= 1;
			else if (p.x > bounds.max.x) code |= 2;
			if (p.y < bounds.min.y) code |= 4;
			else if (p.y > bounds.max.y) code |= 8;
			return code;
		}
		function _sqDist(p1, p2) {
			var dx = p2.x - p1.x, dy = p2.y - p1.y;
			return dx * dx + dy * dy;
		}
		function _sqClosestPointOnSegment(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 Point(x, y);
		}
		function isFlat(latlngs) {
			return !isArray(latlngs[0]) || typeof latlngs[0][0] !== "object" && typeof latlngs[0][0] !== "undefined";
		}
		function _flat(latlngs) {
			console.warn("Deprecated use of _flat, please use L.LineUtil.isFlat instead.");
			return isFlat(latlngs);
		}
		function polylineCenter(latlngs, crs) {
			var i, halfDist, segDist, dist, p1, p2, ratio, center;
			if (!latlngs || latlngs.length === 0) throw new Error("latlngs not passed");
			if (!isFlat(latlngs)) {
				console.warn("latlngs are not flat! Only the first ring will be used");
				latlngs = latlngs[0];
			}
			var centroidLatLng = toLatLng([0, 0]);
			var bounds = toLatLngBounds(latlngs);
			if (bounds.getNorthWest().distanceTo(bounds.getSouthWest()) * bounds.getNorthEast().distanceTo(bounds.getNorthWest()) < 1700) centroidLatLng = centroid(latlngs);
			var len = latlngs.length;
			var points = [];
			for (i = 0; i < len; i++) {
				var latlng = toLatLng(latlngs[i]);
				points.push(crs.project(toLatLng([latlng.lat - centroidLatLng.lat, latlng.lng - centroidLatLng.lng])));
			}
			for (i = 0, halfDist = 0; i < len - 1; i++) halfDist += points[i].distanceTo(points[i + 1]) / 2;
			if (halfDist === 0) center = points[0];
			else 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;
					center = [p2.x - ratio * (p2.x - p1.x), p2.y - ratio * (p2.y - p1.y)];
					break;
				}
			}
			var latlngCenter = crs.unproject(toPoint(center));
			return toLatLng([latlngCenter.lat + centroidLatLng.lat, latlngCenter.lng + centroidLatLng.lng]);
		}
		var LineUtil = {
			__proto__: null,
			simplify,
			pointToSegmentDistance,
			closestPointOnSegment,
			clipSegment,
			_getEdgeIntersection,
			_getBitCode,
			_sqClosestPointOnSegment,
			isFlat,
			_flat,
			polylineCenter
		};
		var LonLat = {
			project: function(latlng) {
				return new Point(latlng.lng, latlng.lat);
			},
			unproject: function(point) {
				return new LatLng(point.y, point.x);
			},
			bounds: new Bounds([-180, -90], [180, 90])
		};
		var Mercator = {
			R: 6378137,
			R_MINOR: 6356752.314245179,
			bounds: new Bounds([-20037508.34279, -15496570.73972], [20037508.34279, 18764656.23138]),
			project: function(latlng) {
				var d = Math.PI / 180, r = this.R, y = latlng.lat * d, tmp = this.R_MINOR / r, e = Math.sqrt(1 - tmp * tmp), con = e * Math.sin(y);
				var ts = Math.tan(Math.PI / 4 - y / 2) / Math.pow((1 - con) / (1 + con), e / 2);
				y = -r * Math.log(Math.max(ts, 1e-10));
				return new Point(latlng.lng * d * r, y);
			},
			unproject: function(point) {
				var d = 180 / Math.PI, r = this.R, tmp = this.R_MINOR / r, e = Math.sqrt(1 - tmp * tmp), ts = Math.exp(-point.y / r), phi = Math.PI / 2 - 2 * Math.atan(ts);
				for (var i = 0, dphi = .1, con; i < 15 && Math.abs(dphi) > 1e-7; i++) {
					con = e * Math.sin(phi);
					con = Math.pow((1 - con) / (1 + con), e / 2);
					dphi = Math.PI / 2 - 2 * Math.atan(ts * con) - phi;
					phi += dphi;
				}
				return new LatLng(phi * d, point.x * d / r);
			}
		};
		var index = {
			__proto__: null,
			LonLat,
			Mercator,
			SphericalMercator
		};
		var EPSG3395 = extend({}, Earth, {
			code: "EPSG:3395",
			projection: Mercator,
			transformation: function() {
				var scale = .5 / (Math.PI * Mercator.R);
				return toTransformation(scale, .5, -scale, .5);
			}()
		});
		var EPSG4326 = extend({}, Earth, {
			code: "EPSG:4326",
			projection: LonLat,
			transformation: toTransformation(1 / 180, 1, -1 / 180, .5)
		});
		var Simple = extend({}, CRS, {
			projection: LonLat,
			transformation: toTransformation(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
		});
		CRS.Earth = Earth;
		CRS.EPSG3395 = EPSG3395;
		CRS.EPSG3857 = EPSG3857;
		CRS.EPSG900913 = EPSG900913;
		CRS.EPSG4326 = EPSG4326;
		CRS.Simple = Simple;
		var Layer = Evented.extend({
			options: {
				pane: "overlayPane",
				attribution: null,
				bubblingMouseEvents: true
			},
			addTo: function(map) {
				map.addLayer(this);
				return this;
			},
			remove: function() {
				return this.removeFrom(this._map || this._mapToAdd);
			},
			removeFrom: function(obj) {
				if (obj) obj.removeLayer(this);
				return this;
			},
			getPane: function(name) {
				return this._map.getPane(name ? this.options[name] || name : this.options.pane);
			},
			addInteractiveTarget: function(targetEl) {
				this._map._targets[stamp(targetEl)] = this;
				return this;
			},
			removeInteractiveTarget: function(targetEl) {
				delete this._map._targets[stamp(targetEl)];
				return this;
			},
			getAttribution: function() {
				return this.options.attribution;
			},
			_layerAdd: function(e) {
				var map = e.target;
				if (!map.hasLayer(this)) return;
				this._map = map;
				this._zoomAnimated = map._zoomAnimated;
				if (this.getEvents) {
					var events = this.getEvents();
					map.on(events, this);
					this.once("remove", function() {
						map.off(events, this);
					}, this);
				}
				this.onAdd(map);
				this.fire("add");
				map.fire("layeradd", { layer: this });
			}
		});
		Map.include({
			addLayer: function(layer) {
				if (!layer._layerAdd) throw new Error("The provided object is not a Layer.");
				var id = stamp(layer);
				if (this._layers[id]) return this;
				this._layers[id] = layer;
				layer._mapToAdd = this;
				if (layer.beforeAdd) layer.beforeAdd(this);
				this.whenReady(layer._layerAdd, layer);
				return this;
			},
			removeLayer: function(layer) {
				var id = stamp(layer);
				if (!this._layers[id]) return this;
				if (this._loaded) layer.onRemove(this);
				delete this._layers[id];
				if (this._loaded) {
					this.fire("layerremove", { layer });
					layer.fire("remove");
				}
				layer._map = layer._mapToAdd = null;
				return this;
			},
			hasLayer: function(layer) {
				return stamp(layer) in this._layers;
			},
			eachLayer: function(method, context) {
				for (var i in this._layers) method.call(context, this._layers[i]);
				return this;
			},
			_addLayers: function(layers) {
				layers = layers ? isArray(layers) ? layers : [layers] : [];
				for (var i = 0, len = layers.length; i < len; i++) this.addLayer(layers[i]);
			},
			_addZoomLimit: function(layer) {
				if (!isNaN(layer.options.maxZoom) || !isNaN(layer.options.minZoom)) {
					this._zoomBoundLayers[stamp(layer)] = layer;
					this._updateZoomLevels();
				}
			},
			_removeZoomLimit: function(layer) {
				var id = stamp(layer);
				if (this._zoomBoundLayers[id]) {
					delete this._zoomBoundLayers[id];
					this._updateZoomLevels();
				}
			},
			_updateZoomLevels: function() {
				var minZoom = Infinity, maxZoom = -Infinity, oldZoomSpan = this._getZoomSpan();
				for (var i in this._zoomBoundLayers) {
					var options = this._zoomBoundLayers[i].options;
					minZoom = options.minZoom === void 0 ? minZoom : Math.min(minZoom, options.minZoom);
					maxZoom = options.maxZoom === void 0 ? maxZoom : Math.max(maxZoom, options.maxZoom);
				}
				this._layersMaxZoom = maxZoom === -Infinity ? void 0 : maxZoom;
				this._layersMinZoom = minZoom === Infinity ? void 0 : minZoom;
				if (oldZoomSpan !== this._getZoomSpan()) this.fire("zoomlevelschange");
				if (this.options.maxZoom === void 0 && this._layersMaxZoom && this.getZoom() > this._layersMaxZoom) this.setZoom(this._layersMaxZoom);
				if (this.options.minZoom === void 0 && this._layersMinZoom && this.getZoom() < this._layersMinZoom) this.setZoom(this._layersMinZoom);
			}
		});
		var LayerGroup = Layer.extend({
			initialize: function(layers, options) {
				setOptions(this, options);
				this._layers = {};
				var i, len;
				if (layers) for (i = 0, len = layers.length; i < len; i++) this.addLayer(layers[i]);
			},
			addLayer: function(layer) {
				var id = this.getLayerId(layer);
				this._layers[id] = layer;
				if (this._map) this._map.addLayer(layer);
				return this;
			},
			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;
			},
			hasLayer: function(layer) {
				return (typeof layer === "number" ? layer : this.getLayerId(layer)) in this._layers;
			},
			clearLayers: function() {
				return this.eachLayer(this.removeLayer, this);
			},
			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) {
				this.eachLayer(map.addLayer, map);
			},
			onRemove: function(map) {
				this.eachLayer(map.removeLayer, map);
			},
			eachLayer: function(method, context) {
				for (var i in this._layers) method.call(context, this._layers[i]);
				return this;
			},
			getLayer: function(id) {
				return this._layers[id];
			},
			getLayers: function() {
				var layers = [];
				this.eachLayer(layers.push, layers);
				return layers;
			},
			setZIndex: function(zIndex) {
				return this.invoke("setZIndex", zIndex);
			},
			getLayerId: function(layer) {
				return stamp(layer);
			}
		});
		var layerGroup = function(layers, options) {
			return new LayerGroup(layers, options);
		};
		var FeatureGroup = LayerGroup.extend({
			addLayer: function(layer) {
				if (this.hasLayer(layer)) return this;
				layer.addEventParent(this);
				LayerGroup.prototype.addLayer.call(this, layer);
				return this.fire("layeradd", { layer });
			},
			removeLayer: function(layer) {
				if (!this.hasLayer(layer)) return this;
				if (layer in this._layers) layer = this._layers[layer];
				layer.removeEventParent(this);
				LayerGroup.prototype.removeLayer.call(this, layer);
				return this.fire("layerremove", { layer });
			},
			setStyle: function(style) {
				return this.invoke("setStyle", style);
			},
			bringToFront: function() {
				return this.invoke("bringToFront");
			},
			bringToBack: function() {
				return this.invoke("bringToBack");
			},
			getBounds: function() {
				var bounds = new LatLngBounds();
				for (var id in this._layers) {
					var layer = this._layers[id];
					bounds.extend(layer.getBounds ? layer.getBounds() : layer.getLatLng());
				}
				return bounds;
			}
		});
		var featureGroup = function(layers, options) {
			return new FeatureGroup(layers, options);
		};
		var Icon = Class.extend({
			options: {
				popupAnchor: [0, 0],
				tooltipAnchor: [0, 0],
				crossOrigin: false
			},
			initialize: function(options) {
				setOptions(this, options);
			},
			createIcon: function(oldIcon) {
				return this._createIcon("icon", oldIcon);
			},
			createShadow: function(oldIcon) {
				return this._createIcon("shadow", oldIcon);
			},
			_createIcon: function(name, oldIcon) {
				var src = this._getIconUrl(name);
				if (!src) {
					if (name === "icon") throw new Error("iconUrl not set in Icon options (see the docs).");
					return null;
				}
				var img = this._createImg(src, oldIcon && oldIcon.tagName === "IMG" ? oldIcon : null);
				this._setIconStyles(img, name);
				if (this.options.crossOrigin || this.options.crossOrigin === "") img.crossOrigin = this.options.crossOrigin === true ? "" : this.options.crossOrigin;
				return img;
			},
			_setIconStyles: function(img, name) {
				var options = this.options;
				var sizeOption = options[name + "Size"];
				if (typeof sizeOption === "number") sizeOption = [sizeOption, sizeOption];
				var size = toPoint(sizeOption), anchor = toPoint(name === "shadow" && options.shadowAnchor || options.iconAnchor || size && size.divideBy(2, true));
				img.className = "leaflet-marker-" + name + " " + (options.className || "");
				if (anchor) {
					img.style.marginLeft = -anchor.x + "px";
					img.style.marginTop = -anchor.y + "px";
				}
				if (size) {
					img.style.width = size.x + "px";
					img.style.height = size.y + "px";
				}
			},
			_createImg: function(src, el) {
				el = el || document.createElement("img");
				el.src = src;
				return el;
			},
			_getIconUrl: function(name) {
				return Browser.retina && this.options[name + "RetinaUrl"] || this.options[name + "Url"];
			}
		});
		function icon(options) {
			return new Icon(options);
		}
		var IconDefault = 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(name) {
				if (typeof IconDefault.imagePath !== "string") IconDefault.imagePath = this._detectIconPath();
				return (this.options.imagePath || IconDefault.imagePath) + Icon.prototype._getIconUrl.call(this, name);
			},
			_stripUrl: function(path) {
				var strip = function(str, re, idx) {
					var match = re.exec(str);
					return match && match[idx];
				};
				path = strip(path, /^url\((['"])?(.+)\1\)$/, 2);
				return path && strip(path, /^(.*)marker-icon\.png$/, 1);
			},
			_detectIconPath: function() {
				var el = create$1("div", "leaflet-default-icon-path", document.body);
				var path = getStyle(el, "background-image") || getStyle(el, "backgroundImage");
				document.body.removeChild(el);
				path = this._stripUrl(path);
				if (path) return path;
				var link = document.querySelector("link[href$=\"leaflet.css\"]");
				if (!link) return "";
				return link.href.substring(0, link.href.length - 11 - 1);
			}
		});
		var MarkerDrag = Handler.extend({
			initialize: function(marker) {
				this._marker = marker;
			},
			addHooks: function() {
				var icon = this._marker._icon;
				if (!this._draggable) this._draggable = new Draggable(icon, icon, true);
				this._draggable.on({
					dragstart: this._onDragStart,
					predrag: this._onPreDrag,
					drag: this._onDrag,
					dragend: this._onDragEnd
				}, this).enable();
				addClass(icon, "leaflet-marker-draggable");
			},
			removeHooks: function() {
				this._draggable.off({
					dragstart: this._onDragStart,
					predrag: this._onPreDrag,
					drag: this._onDrag,
					dragend: this._onDragEnd
				}, this).disable();
				if (this._marker._icon) removeClass(this._marker._icon, "leaflet-marker-draggable");
			},
			moved: function() {
				return this._draggable && this._draggable._moved;
			},
			_adjustPan: function(e) {
				var marker = this._marker, map = marker._map, speed = this._marker.options.autoPanSpeed, padding = this._marker.options.autoPanPadding, iconPos = getPosition(marker._icon), bounds = map.getPixelBounds(), origin = map.getPixelOrigin();
				var panBounds = toBounds(bounds.min._subtract(origin).add(padding), bounds.max._subtract(origin).subtract(padding));
				if (!panBounds.contains(iconPos)) {
					var movement = toPoint((Math.max(panBounds.max.x, iconPos.x) - panBounds.max.x) / (bounds.max.x - panBounds.max.x) - (Math.min(panBounds.min.x, iconPos.x) - panBounds.min.x) / (bounds.min.x - panBounds.min.x), (Math.max(panBounds.max.y, iconPos.y) - panBounds.max.y) / (bounds.max.y - panBounds.max.y) - (Math.min(panBounds.min.y, iconPos.y) - panBounds.min.y) / (bounds.min.y - panBounds.min.y)).multiplyBy(speed);
					map.panBy(movement, { animate: false });
					this._draggable._newPos._add(movement);
					this._draggable._startPos._add(movement);
					setPosition(marker._icon, this._draggable._newPos);
					this._onDrag(e);
					this._panRequest = requestAnimFrame(this._adjustPan.bind(this, e));
				}
			},
			_onDragStart: function() {
				this._oldLatLng = this._marker.getLatLng();
				this._marker.closePopup && this._marker.closePopup();
				this._marker.fire("movestart").fire("dragstart");
			},
			_onPreDrag: function(e) {
				if (this._marker.options.autoPan) {
					cancelAnimFrame(this._panRequest);
					this._panRequest = requestAnimFrame(this._adjustPan.bind(this, e));
				}
			},
			_onDrag: function(e) {
				var marker = this._marker, shadow = marker._shadow, iconPos = getPosition(marker._icon), latlng = marker._map.layerPointToLatLng(iconPos);
				if (shadow) setPosition(shadow, iconPos);
				marker._latlng = latlng;
				e.latlng = latlng;
				e.oldLatLng = this._oldLatLng;
				marker.fire("move", e).fire("drag", e);
			},
			_onDragEnd: function(e) {
				cancelAnimFrame(this._panRequest);
				delete this._oldLatLng;
				this._marker.fire("moveend").fire("dragend", e);
			}
		});
		var Marker = Layer.extend({
			options: {
				icon: new IconDefault(),
				interactive: true,
				keyboard: true,
				title: "",
				alt: "Marker",
				zIndexOffset: 0,
				opacity: 1,
				riseOnHover: false,
				riseOffset: 250,
				pane: "markerPane",
				shadowPane: "shadowPane",
				bubblingMouseEvents: false,
				autoPanOnFocus: true,
				draggable: false,
				autoPan: false,
				autoPanPadding: [50, 50],
				autoPanSpeed: 10
			},
			initialize: function(latlng, options) {
				setOptions(this, options);
				this._latlng = toLatLng(latlng);
			},
			onAdd: function(map) {
				this._zoomAnimated = this._zoomAnimated && map.options.markerZoomAnimation;
				if (this._zoomAnimated) map.on("zoomanim", this._animateZoom, this);
				this._initIcon();
				this.update();
			},
			onRemove: function(map) {
				if (this.dragging && this.dragging.enabled()) {
					this.options.draggable = true;
					this.dragging.removeHooks();
				}
				delete this.dragging;
				if (this._zoomAnimated) map.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(latlng) {
				var oldLatLng = this._latlng;
				this._latlng = toLatLng(latlng);
				this.update();
				return this.fire("move", {
					oldLatLng,
					latlng: this._latlng
				});
			},
			setZIndexOffset: function(offset) {
				this.options.zIndexOffset = offset;
				return this.update();
			},
			getIcon: function() {
				return this.options.icon;
			},
			setIcon: function(icon) {
				this.options.icon = icon;
				if (this._map) {
					this._initIcon();
					this.update();
				}
				if (this._popup) this.bindPopup(this._popup, this._popup.options);
				return this;
			},
			getElement: function() {
				return this._icon;
			},
			update: function() {
				if (this._icon && this._map) {
					var pos = this._map.latLngToLayerPoint(this._latlng).round();
					this._setPos(pos);
				}
				return this;
			},
			_initIcon: function() {
				var options = this.options, classToAdd = "leaflet-zoom-" + (this._zoomAnimated ? "animated" : "hide");
				var icon = options.icon.createIcon(this._icon), addIcon = false;
				if (icon !== this._icon) {
					if (this._icon) this._removeIcon();
					addIcon = true;
					if (options.title) icon.title = options.title;
					if (icon.tagName === "IMG") icon.alt = options.alt || "";
				}
				addClass(icon, classToAdd);
				if (options.keyboard) {
					icon.tabIndex = "0";
					icon.setAttribute("role", "button");
				}
				this._icon = icon;
				if (options.riseOnHover) this.on({
					mouseover: this._bringToFront,
					mouseout: this._resetZIndex
				});
				if (this.options.autoPanOnFocus) on(icon, "focus", this._panOnFocus, this);
				var newShadow = options.icon.createShadow(this._shadow), addShadow = false;
				if (newShadow !== this._shadow) {
					this._removeShadow();
					addShadow = true;
				}
				if (newShadow) {
					addClass(newShadow, classToAdd);
					newShadow.alt = "";
				}
				this._shadow = newShadow;
				if (options.opacity < 1) this._updateOpacity();
				if (addIcon) this.getPane().appendChild(this._icon);
				this._initInteraction();
				if (newShadow && addShadow) this.getPane(options.shadowPane).appendChild(this._shadow);
			},
			_removeIcon: function() {
				if (this.options.riseOnHover) this.off({
					mouseover: this._bringToFront,
					mouseout: this._resetZIndex
				});
				if (this.options.autoPanOnFocus) off(this._icon, "focus", this._panOnFocus, this);
				remove(this._icon);
				this.removeInteractiveTarget(this._icon);
				this._icon = null;
			},
			_removeShadow: function() {
				if (this._shadow) remove(this._shadow);
				this._shadow = null;
			},
			_setPos: function(pos) {
				if (this._icon) setPosition(this._icon, pos);
				if (this._shadow) setPosition(this._shadow, pos);
				this._zIndex = pos.y + this.options.zIndexOffset;
				this._resetZIndex();
			},
			_updateZIndex: function(offset) {
				if (this._icon) this._icon.style.zIndex = this._zIndex + offset;
			},
			_animateZoom: function(opt) {
				var pos = this._map._latLngToNewLayerPoint(this._latlng, opt.zoom, opt.center).round();
				this._setPos(pos);
			},
			_initInteraction: function() {
				if (!this.options.interactive) return;
				addClass(this._icon, "leaflet-interactive");
				this.addInteractiveTarget(this._icon);
				if (MarkerDrag) {
					var draggable = this.options.draggable;
					if (this.dragging) {
						draggable = this.dragging.enabled();
						this.dragging.disable();
					}
					this.dragging = new MarkerDrag(this);
					if (draggable) this.dragging.enable();
				}
			},
			setOpacity: function(opacity) {
				this.options.opacity = opacity;
				if (this._map) this._updateOpacity();
				return this;
			},
			_updateOpacity: function() {
				var opacity = this.options.opacity;
				if (this._icon) setOpacity(this._icon, opacity);
				if (this._shadow) setOpacity(this._shadow, opacity);
			},
			_bringToFront: function() {
				this._updateZIndex(this.options.riseOffset);
			},
			_resetZIndex: function() {
				this._updateZIndex(0);
			},
			_panOnFocus: function() {
				var map = this._map;
				if (!map) return;
				var iconOpts = this.options.icon.options;
				var size = iconOpts.iconSize ? toPoint(iconOpts.iconSize) : toPoint(0, 0);
				var anchor = iconOpts.iconAnchor ? toPoint(iconOpts.iconAnchor) : toPoint(0, 0);
				map.panInside(this._latlng, {
					paddingTopLeft: anchor,
					paddingBottomRight: size.subtract(anchor)
				});
			},
			_getPopupAnchor: function() {
				return this.options.icon.options.popupAnchor;
			},
			_getTooltipAnchor: function() {
				return this.options.icon.options.tooltipAnchor;
			}
		});
		function marker(latlng, options) {
			return new Marker(latlng, options);
		}
		var Path = Layer.extend({
			options: {
				stroke: true,
				color: "#3388ff",
				weight: 3,
				opacity: 1,
				lineCap: "round",
				lineJoin: "round",
				dashArray: null,
				dashOffset: null,
				fill: false,
				fillColor: null,
				fillOpacity: .2,
				fillRule: "evenodd",
				interactive: true,
				bubblingMouseEvents: true
			},
			beforeAdd: function(map) {
				this._renderer = map.getRenderer(this);
			},
			onAdd: function() {
				this._renderer._initPath(this);
				this._reset();
				this._renderer._addPath(this);
			},
			onRemove: function() {
				this._renderer._removePath(this);
			},
			redraw: function() {
				if (this._map) this._renderer._updatePath(this);
				return this;
			},
			setStyle: function(style) {
				setOptions(this, style);
				if (this._renderer) {
					this._renderer._updateStyle(this);
					if (this.options.stroke && style && Object.prototype.hasOwnProperty.call(style, "weight")) this._updateBounds();
				}
				return this;
			},
			bringToFront: function() {
				if (this._renderer) this._renderer._bringToFront(this);
				return this;
			},
			bringToBack: function() {
				if (this._renderer) this._renderer._bringToBack(this);
				return this;
			},
			getElement: function() {
				return this._path;
			},
			_reset: function() {
				this._project();
				this._update();
			},
			_clickTolerance: function() {
				return (this.options.stroke ? this.options.weight / 2 : 0) + (this._renderer.options.tolerance || 0);
			}
		});
		var CircleMarker = Path.extend({
			options: {
				fill: true,
				radius: 10
			},
			initialize: function(latlng, options) {
				setOptions(this, options);
				this._latlng = toLatLng(latlng);
				this._radius = this.options.radius;
			},
			setLatLng: function(latlng) {
				var oldLatLng = this._latlng;
				this._latlng = toLatLng(latlng);
				this.redraw();
				return this.fire("move", {
					oldLatLng,
					latlng: this._latlng
				});
			},
			getLatLng: function() {
				return this._latlng;
			},
			setRadius: function(radius) {
				this.options.radius = this._radius = radius;
				return this.redraw();
			},
			getRadius: function() {
				return this._radius;
			},
			setStyle: function(options) {
				var radius = options && options.radius || this._radius;
				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 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);
			},
			_containsPoint: function(p) {
				return p.distanceTo(this._point) <= this._radius + this._clickTolerance();
			}
		});
		function circleMarker(latlng, options) {
			return new CircleMarker(latlng, options);
		}
		var Circle = CircleMarker.extend({
			initialize: function(latlng, options, legacyOptions) {
				if (typeof options === "number") options = extend({}, legacyOptions, { radius: options });
				setOptions(this, options);
				this._latlng = toLatLng(latlng);
				if (isNaN(this.options.radius)) throw new Error("Circle radius cannot be NaN");
				this._mRadius = this.options.radius;
			},
			setRadius: function(radius) {
				this._mRadius = radius;
				return this.redraw();
			},
			getRadius: function() {
				return this._mRadius;
			},
			getBounds: function() {
				var half = [this._radius, this._radiusY || this._radius];
				return new LatLngBounds(this._map.layerPointToLatLng(this._point.subtract(half)), this._map.layerPointToLatLng(this._point.add(half)));
			},
			setStyle: Path.prototype.setStyle,
			_project: function() {
				var lng = this._latlng.lng, lat = this._latlng.lat, map = this._map, crs = map.options.crs;
				if (crs.distance === Earth.distance) {
					var d = Math.PI / 180, latR = this._mRadius / 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);
					this._point = p.subtract(map.getPixelOrigin());
					this._radius = isNaN(lngR) ? 0 : p.x - map.project([lat2, lng - lngR]).x;
					this._radiusY = p.y - top.y;
				} 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();
			}
		});
		function circle(latlng, options, legacyOptions) {
			return new Circle(latlng, options, legacyOptions);
		}
		var Polyline = Path.extend({
			options: {
				smoothFactor: 1,
				noClip: false
			},
			initialize: function(latlngs, options) {
				setOptions(this, options);
				this._setLatLngs(latlngs);
			},
			getLatLngs: function() {
				return this._latlngs;
			},
			setLatLngs: function(latlngs) {
				this._setLatLngs(latlngs);
				return this.redraw();
			},
			isEmpty: function() {
				return !this._latlngs.length;
			},
			closestLayerPoint: function(p) {
				var minDistance = Infinity, minPoint = null, closest = _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;
			},
			getCenter: function() {
				if (!this._map) throw new Error("Must add layer to map before using getCenter()");
				return polylineCenter(this._defaultShape(), this._map.options.crs);
			},
			getBounds: function() {
				return this._bounds;
			},
			addLatLng: function(latlng, latlngs) {
				latlngs = latlngs || this._defaultShape();
				latlng = toLatLng(latlng);
				latlngs.push(latlng);
				this._bounds.extend(latlng);
				return this.redraw();
			},
			_setLatLngs: function(latlngs) {
				this._bounds = new LatLngBounds();
				this._latlngs = this._convertLatLngs(latlngs);
			},
			_defaultShape: function() {
				return isFlat(this._latlngs) ? this._latlngs : this._latlngs[0];
			},
			_convertLatLngs: function(latlngs) {
				var result = [], flat = isFlat(latlngs);
				for (var i = 0, len = latlngs.length; i < len; i++) if (flat) {
					result[i] = toLatLng(latlngs[i]);
					this._bounds.extend(result[i]);
				} else result[i] = this._convertLatLngs(latlngs[i]);
				return result;
			},
			_project: function() {
				var pxBounds = new Bounds();
				this._rings = [];
				this._projectLatlngs(this._latlngs, this._rings, pxBounds);
				if (this._bounds.isValid() && pxBounds.isValid()) {
					this._rawPxBounds = pxBounds;
					this._updateBounds();
				}
			},
			_updateBounds: function() {
				var w = this._clickTolerance(), p = new Point(w, w);
				if (!this._rawPxBounds) return;
				this._pxBounds = new Bounds([this._rawPxBounds.min.subtract(p), this._rawPxBounds.max.add(p)]);
			},
			_projectLatlngs: function(latlngs, result, projectedBounds) {
				var flat = latlngs[0] instanceof 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);
			},
			_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 = clipSegment(points[j], points[j + 1], bounds, j, true);
						if (!segment) continue;
						parts[k] = parts[k] || [];
						parts[k].push(segment[0]);
						if (segment[1] !== points[j + 1] || j === len2 - 2) {
							parts[k].push(segment[1]);
							k++;
						}
					}
				}
			},
			_simplifyPoints: function() {
				var parts = this._parts, tolerance = this.options.smoothFactor;
				for (var i = 0, len = parts.length; i < len; i++) parts[i] = simplify(parts[i], tolerance);
			},
			_update: function() {
				if (!this._map) return;
				this._clipPoints();
				this._simplifyPoints();
				this._updatePath();
			},
			_updatePath: function() {
				this._renderer._updatePoly(this);
			},
			_containsPoint: function(p, closed) {
				var i, j, k, len, len2, part, w = this._clickTolerance();
				if (!this._pxBounds || !this._pxBounds.contains(p)) return false;
				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 (pointToSegmentDistance(p, part[k], part[j]) <= w) return true;
					}
				}
				return false;
			}
		});
		function polyline(latlngs, options) {
			return new Polyline(latlngs, options);
		}
		Polyline._flat = _flat;
		var Polygon = Polyline.extend({
			options: { fill: true },
			isEmpty: function() {
				return !this._latlngs.length || !this._latlngs[0].length;
			},
			getCenter: function() {
				if (!this._map) throw new Error("Must add layer to map before using getCenter()");
				return polygonCenter(this._defaultShape(), this._map.options.crs);
			},
			_convertLatLngs: function(latlngs) {
				var result = Polyline.prototype._convertLatLngs.call(this, latlngs), len = result.length;
				if (len >= 2 && result[0] instanceof LatLng && result[0].equals(result[len - 1])) result.pop();
				return result;
			},
			_setLatLngs: function(latlngs) {
				Polyline.prototype._setLatLngs.call(this, latlngs);
				if (isFlat(this._latlngs)) this._latlngs = [this._latlngs];
			},
			_defaultShape: function() {
				return isFlat(this._latlngs[0]) ? this._latlngs[0] : this._latlngs[0][0];
			},
			_clipPoints: function() {
				var bounds = this._renderer._bounds, w = this.options.weight, p = new Point(w, w);
				bounds = new 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 = clipPolygon(this._rings[i], bounds, true);
					if (clipped.length) this._parts.push(clipped);
				}
			},
			_updatePath: function() {
				this._renderer._updatePoly(this, true);
			},
			_containsPoint: function(p) {
				var inside = false, part, p1, p2, i, j, k, len, len2;
				if (!this._pxBounds || !this._pxBounds.contains(p)) return false;
				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;
					}
				}
				return inside || Polyline.prototype._containsPoint.call(this, p, true);
			}
		});
		function polygon(latlngs, options) {
			return new Polygon(latlngs, options);
		}
		var GeoJSON = FeatureGroup.extend({
			initialize: function(geojson, options) {
				setOptions(this, options);
				this._layers = {};
				if (geojson) this.addData(geojson);
			},
			addData: function(geojson) {
				var features = isArray(geojson) ? geojson : geojson.features, i, len, feature;
				if (features) {
					for (i = 0, len = features.length; i < len; i++) {
						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 = geometryToLayer(geojson, options);
				if (!layer) return this;
				layer.feature = asFeature(geojson);
				layer.defaultOptions = layer.options;
				this.resetStyle(layer);
				if (options.onEachFeature) options.onEachFeature(geojson, layer);
				return this.addLayer(layer);
			},
			resetStyle: function(layer) {
				if (layer === void 0) return this.eachLayer(this.resetStyle, this);
				layer.options = extend({}, layer.defaultOptions);
				this._setLayerStyle(layer, this.options.style);
				return this;
			},
			setStyle: function(style) {
				return this.eachLayer(function(layer) {
					this._setLayerStyle(layer, style);
				}, this);
			},
			_setLayerStyle: function(layer, style) {
				if (layer.setStyle) {
					if (typeof style === "function") style = style(layer.feature);
					layer.setStyle(style);
				}
			}
		});
		function geometryToLayer(geojson, options) {
			var geometry = geojson.type === "Feature" ? geojson.geometry : geojson, coords = geometry ? geometry.coordinates : null, layers = [], pointToLayer = options && options.pointToLayer, _coordsToLatLng = options && options.coordsToLatLng || coordsToLatLng, latlng, latlngs, i, len;
			if (!coords && !geometry) return null;
			switch (geometry.type) {
				case "Point":
					latlng = _coordsToLatLng(coords);
					return _pointToLayer(pointToLayer, geojson, latlng, options);
				case "MultiPoint":
					for (i = 0, len = coords.length; i < len; i++) {
						latlng = _coordsToLatLng(coords[i]);
						layers.push(_pointToLayer(pointToLayer, geojson, latlng, options));
					}
					return new FeatureGroup(layers);
				case "LineString":
				case "MultiLineString":
					latlngs = coordsToLatLngs(coords, geometry.type === "LineString" ? 0 : 1, _coordsToLatLng);
					return new Polyline(latlngs, options);
				case "Polygon":
				case "MultiPolygon":
					latlngs = coordsToLatLngs(coords, geometry.type === "Polygon" ? 1 : 2, _coordsToLatLng);
					return new Polygon(latlngs, options);
				case "GeometryCollection":
					for (i = 0, len = geometry.geometries.length; i < len; i++) {
						var geoLayer = geometryToLayer({
							geometry: geometry.geometries[i],
							type: "Feature",
							properties: geojson.properties
						}, options);
						if (geoLayer) layers.push(geoLayer);
					}
					return new FeatureGroup(layers);
				case "FeatureCollection":
					for (i = 0, len = geometry.features.length; i < len; i++) {
						var featureLayer = geometryToLayer(geometry.features[i], options);
						if (featureLayer) layers.push(featureLayer);
					}
					return new FeatureGroup(layers);
				default: throw new Error("Invalid GeoJSON object.");
			}
		}
		function _pointToLayer(pointToLayerFn, geojson, latlng, options) {
			return pointToLayerFn ? pointToLayerFn(geojson, latlng) : new Marker(latlng, options && options.markersInheritOptions && options);
		}
		function coordsToLatLng(coords) {
			return new LatLng(coords[1], coords[0], coords[2]);
		}
		function coordsToLatLngs(coords, levelsDeep, _coordsToLatLng) {
			var latlngs = [];
			for (var i = 0, len = coords.length, latlng; i < len; i++) {
				latlng = levelsDeep ? coordsToLatLngs(coords[i], levelsDeep - 1, _coordsToLatLng) : (_coordsToLatLng || coordsToLatLng)(coords[i]);
				latlngs.push(latlng);
			}
			return latlngs;
		}
		function latLngToCoords(latlng, precision) {
			latlng = toLatLng(latlng);
			return latlng.alt !== void 0 ? [
				formatNum(latlng.lng, precision),
				formatNum(latlng.lat, precision),
				formatNum(latlng.alt, precision)
			] : [formatNum(latlng.lng, precision), formatNum(latlng.lat, precision)];
		}
		function latLngsToCoords(latlngs, levelsDeep, closed, precision) {
			var coords = [];
			for (var i = 0, len = latlngs.length; i < len; i++) coords.push(levelsDeep ? latLngsToCoords(latlngs[i], isFlat(latlngs[i]) ? 0 : levelsDeep - 1, closed, precision) : latLngToCoords(latlngs[i], precision));
			if (!levelsDeep && closed && coords.length > 0) coords.push(coords[0].slice());
			return coords;
		}
		function getFeature(layer, newGeometry) {
			return layer.feature ? extend({}, layer.feature, { geometry: newGeometry }) : asFeature(newGeometry);
		}
		function asFeature(geojson) {
			if (geojson.type === "Feature" || geojson.type === "FeatureCollection") return geojson;
			return {
				type: "Feature",
				properties: {},
				geometry: geojson
			};
		}
		var PointToGeoJSON = { toGeoJSON: function(precision) {
			return getFeature(this, {
				type: "Point",
				coordinates: latLngToCoords(this.getLatLng(), precision)
			});
		} };
		Marker.include(PointToGeoJSON);
		Circle.include(PointToGeoJSON);
		CircleMarker.include(PointToGeoJSON);
		Polyline.include({ toGeoJSON: function(precision) {
			var multi = !isFlat(this._latlngs);
			var coords = latLngsToCoords(this._latlngs, multi ? 1 : 0, false, precision);
			return getFeature(this, {
				type: (multi ? "Multi" : "") + "LineString",
				coordinates: coords
			});
		} });
		Polygon.include({ toGeoJSON: function(precision) {
			var holes = !isFlat(this._latlngs), multi = holes && !isFlat(this._latlngs[0]);
			var coords = latLngsToCoords(this._latlngs, multi ? 2 : holes ? 1 : 0, true, precision);
			if (!holes) coords = [coords];
			return getFeature(this, {
				type: (multi ? "Multi" : "") + "Polygon",
				coordinates: coords
			});
		} });
		LayerGroup.include({
			toMultiPoint: function(precision) {
				var coords = [];
				this.eachLayer(function(layer) {
					coords.push(layer.toGeoJSON(precision).geometry.coordinates);
				});
				return getFeature(this, {
					type: "MultiPoint",
					coordinates: coords
				});
			},
			toGeoJSON: function(precision) {
				var type = this.feature && this.feature.geometry && this.feature.geometry.type;
				if (type === "MultiPoint") return this.toMultiPoint(precision);
				var isGeometryCollection = type === "GeometryCollection", jsons = [];
				this.eachLayer(function(layer) {
					if (layer.toGeoJSON) {
						var json = layer.toGeoJSON(precision);
						if (isGeometryCollection) jsons.push(json.geometry);
						else {
							var feature = asFeature(json);
							if (feature.type === "FeatureCollection") jsons.push.apply(jsons, feature.features);
							else jsons.push(feature);
						}
					}
				});
				if (isGeometryCollection) return getFeature(this, {
					geometries: jsons,
					type: "GeometryCollection"
				});
				return {
					type: "FeatureCollection",
					features: jsons
				};
			}
		});
		function geoJSON(geojson, options) {
			return new GeoJSON(geojson, options);
		}
		var geoJson = geoJSON;
		var ImageOverlay = Layer.extend({
			options: {
				opacity: 1,
				alt: "",
				interactive: false,
				crossOrigin: false,
				errorOverlayUrl: "",
				zIndex: 1,
				className: ""
			},
			initialize: function(url, bounds, options) {
				this._url = url;
				this._bounds = toLatLngBounds(bounds);
				setOptions(this, options);
			},
			onAdd: function() {
				if (!this._image) {
					this._initImage();
					if (this.options.opacity < 1) this._updateOpacity();
				}
				if (this.options.interactive) {
					addClass(this._image, "leaflet-interactive");
					this.addInteractiveTarget(this._image);
				}
				this.getPane().appendChild(this._image);
				this._reset();
			},
			onRemove: function() {
				remove(this._image);
				if (this.options.interactive) this.removeInteractiveTarget(this._image);
			},
			setOpacity: function(opacity) {
				this.options.opacity = opacity;
				if (this._image) this._updateOpacity();
				return this;
			},
			setStyle: function(styleOpts) {
				if (styleOpts.opacity) this.setOpacity(styleOpts.opacity);
				return this;
			},
			bringToFront: function() {
				if (this._map) toFront(this._image);
				return this;
			},
			bringToBack: function() {
				if (this._map) toBack(this._image);
				return this;
			},
			setUrl: function(url) {
				this._url = url;
				if (this._image) this._image.src = url;
				return this;
			},
			setBounds: function(bounds) {
				this._bounds = toLatLngBounds(bounds);
				if (this._map) this._reset();
				return this;
			},
			getEvents: function() {
				var events = {
					zoom: this._reset,
					viewreset: this._reset
				};
				if (this._zoomAnimated) events.zoomanim = this._animateZoom;
				return events;
			},
			setZIndex: function(value) {
				this.options.zIndex = value;
				this._updateZIndex();
				return this;
			},
			getBounds: function() {
				return this._bounds;
			},
			getElement: function() {
				return this._image;
			},
			_initImage: function() {
				var wasElementSupplied = this._url.tagName === "IMG";
				var img = this._image = wasElementSupplied ? this._url : create$1("img");
				addClass(img, "leaflet-image-layer");
				if (this._zoomAnimated) addClass(img, "leaflet-zoom-animated");
				if (this.options.className) addClass(img, this.options.className);
				img.onselectstart = falseFn;
				img.onmousemove = falseFn;
				img.onload = bind(this.fire, this, "load");
				img.onerror = bind(this._overlayOnError, this, "error");
				if (this.options.crossOrigin || this.options.crossOrigin === "") img.crossOrigin = this.options.crossOrigin === true ? "" : this.options.crossOrigin;
				if (this.options.zIndex) this._updateZIndex();
				if (wasElementSupplied) {
					this._url = img.src;
					return;
				}
				img.src = this._url;
				img.alt = this.options.alt;
			},
			_animateZoom: function(e) {
				var scale = this._map.getZoomScale(e.zoom), offset = this._map._latLngBoundsToNewLayerBounds(this._bounds, e.zoom, e.center).min;
				setTransform(this._image, offset, scale);
			},
			_reset: function() {
				var image = this._image, bounds = new Bounds(this._map.latLngToLayerPoint(this._bounds.getNorthWest()), this._map.latLngToLayerPoint(this._bounds.getSouthEast())), size = bounds.getSize();
				setPosition(image, bounds.min);
				image.style.width = size.x + "px";
				image.style.height = size.y + "px";
			},
			_updateOpacity: function() {
				setOpacity(this._image, this.options.opacity);
			},
			_updateZIndex: function() {
				if (this._image && this.options.zIndex !== void 0 && this.options.zIndex !== null) this._image.style.zIndex = this.options.zIndex;
			},
			_overlayOnError: function() {
				this.fire("error");
				var errorUrl = this.options.errorOverlayUrl;
				if (errorUrl && this._url !== errorUrl) {
					this._url = errorUrl;
					this._image.src = errorUrl;
				}
			},
			getCenter: function() {
				return this._bounds.getCenter();
			}
		});
		var imageOverlay = function(url, bounds, options) {
			return new ImageOverlay(url, bounds, options);
		};
		var VideoOverlay = ImageOverlay.extend({
			options: {
				autoplay: true,
				loop: true,
				keepAspectRatio: true,
				muted: false,
				playsInline: true
			},
			_initImage: function() {
				var wasElementSupplied = this._url.tagName === "VIDEO";
				var vid = this._image = wasElementSupplied ? this._url : create$1("video");
				addClass(vid, "leaflet-image-layer");
				if (this._zoomAnimated) addClass(vid, "leaflet-zoom-animated");
				if (this.options.className) addClass(vid, this.options.className);
				vid.onselectstart = falseFn;
				vid.onmousemove = falseFn;
				vid.onloadeddata = bind(this.fire, this, "load");
				if (wasElementSupplied) {
					var sourceElements = vid.getElementsByTagName("source");
					var sources = [];
					for (var j = 0; j < sourceElements.length; j++) sources.push(sourceElements[j].src);
					this._url = sourceElements.length > 0 ? sources : [vid.src];
					return;
				}
				if (!isArray(this._url)) this._url = [this._url];
				if (!this.options.keepAspectRatio && Object.prototype.hasOwnProperty.call(vid.style, "objectFit")) vid.style["objectFit"] = "fill";
				vid.autoplay = !!this.options.autoplay;
				vid.loop = !!this.options.loop;
				vid.muted = !!this.options.muted;
				vid.playsInline = !!this.options.playsInline;
				for (var i = 0; i < this._url.length; i++) {
					var source = create$1("source");
					source.src = this._url[i];
					vid.appendChild(source);
				}
			}
		});
		function videoOverlay(video, bounds, options) {
			return new VideoOverlay(video, bounds, options);
		}
		var SVGOverlay = ImageOverlay.extend({ _initImage: function() {
			var el = this._image = this._url;
			addClass(el, "leaflet-image-layer");
			if (this._zoomAnimated) addClass(el, "leaflet-zoom-animated");
			if (this.options.className) addClass(el, this.options.className);
			el.onselectstart = falseFn;
			el.onmousemove = falseFn;
		} });
		function svgOverlay(el, bounds, options) {
			return new SVGOverlay(el, bounds, options);
		}
		var DivOverlay = Layer.extend({
			options: {
				interactive: false,
				offset: [0, 0],
				className: "",
				pane: void 0,
				content: ""
			},
			initialize: function(options, source) {
				if (options && (options instanceof LatLng || isArray(options))) {
					this._latlng = toLatLng(options);
					setOptions(this, source);
				} else {
					setOptions(this, options);
					this._source = source;
				}
				if (this.options.content) this._content = this.options.content;
			},
			openOn: function(map) {
				map = arguments.length ? map : this._source._map;
				if (!map.hasLayer(this)) map.addLayer(this);
				return this;
			},
			close: function() {
				if (this._map) this._map.removeLayer(this);
				return this;
			},
			toggle: function(layer) {
				if (this._map) this.close();
				else {
					if (arguments.length) this._source = layer;
					else layer = this._source;
					this._prepareOpen();
					this.openOn(layer._map);
				}
				return this;
			},
			onAdd: function(map) {
				this._zoomAnimated = map._zoomAnimated;
				if (!this._container) this._initLayout();
				if (map._fadeAnimated) setOpacity(this._container, 0);
				clearTimeout(this._removeTimeout);
				this.getPane().appendChild(this._container);
				this.update();
				if (map._fadeAnimated) setOpacity(this._container, 1);
				this.bringToFront();
				if (this.options.interactive) {
					addClass(this._container, "leaflet-interactive");
					this.addInteractiveTarget(this._container);
				}
			},
			onRemove: function(map) {
				if (map._fadeAnimated) {
					setOpacity(this._container, 0);
					this._removeTimeout = setTimeout(bind(remove, void 0, this._container), 200);
				} else remove(this._container);
				if (this.options.interactive) {
					removeClass(this._container, "leaflet-interactive");
					this.removeInteractiveTarget(this._container);
				}
			},
			getLatLng: function() {
				return this._latlng;
			},
			setLatLng: function(latlng) {
				this._latlng = toLatLng(latlng);
				if (this._map) {
					this._updatePosition();
					this._adjustPan();
				}
				return this;
			},
			getContent: function() {
				return this._content;
			},
			setContent: function(content) {
				this._content = content;
				this.update();
				return this;
			},
			getElement: function() {
				return this._container;
			},
			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;
			},
			isOpen: function() {
				return !!this._map && this._map.hasLayer(this);
			},
			bringToFront: function() {
				if (this._map) toFront(this._container);
				return this;
			},
			bringToBack: function() {
				if (this._map) toBack(this._container);
				return this;
			},
			_prepareOpen: function(latlng) {
				var source = this._source;
				if (!source._map) return false;
				if (source instanceof FeatureGroup) {
					source = null;
					var layers = this._source._layers;
					for (var id in layers) if (layers[id]._map) {
						source = layers[id];
						break;
					}
					if (!source) return false;
					this._source = source;
				}
				if (!latlng) if (source.getCenter) latlng = source.getCenter();
				else if (source.getLatLng) latlng = source.getLatLng();
				else if (source.getBounds) latlng = source.getBounds().getCenter();
				else throw new Error("Unable to get source layer LatLng.");
				this.setLatLng(latlng);
				if (this._map) this.update();
				return true;
			},
			_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 = toPoint(this.options.offset), anchor = this._getAnchor();
				if (this._zoomAnimated) 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;
				this._container.style.bottom = bottom + "px";
				this._container.style.left = left + "px";
			},
			_getAnchor: function() {
				return [0, 0];
			}
		});
		Map.include({ _initOverlay: function(OverlayClass, content, latlng, options) {
			var overlay = content;
			if (!(overlay instanceof OverlayClass)) overlay = new OverlayClass(options).setContent(content);
			if (latlng) overlay.setLatLng(latlng);
			return overlay;
		} });
		Layer.include({ _initOverlay: function(OverlayClass, old, content, options) {
			var overlay = content;
			if (overlay instanceof OverlayClass) {
				setOptions(overlay, options);
				overlay._source = this;
			} else {
				overlay = old && !options ? old : new OverlayClass(options, this);
				overlay.setContent(content);
			}
			return overlay;
		} });
		var Popup = DivOverlay.extend({
			options: {
				pane: "popupPane",
				offset: [0, 7],
				maxWidth: 300,
				minWidth: 50,
				maxHeight: null,
				autoPan: true,
				autoPanPaddingTopLeft: null,
				autoPanPaddingBottomRight: null,
				autoPanPadding: [5, 5],
				keepInView: false,
				closeButton: true,
				autoClose: true,
				closeOnEscapeKey: true,
				className: ""
			},
			openOn: function(map) {
				map = arguments.length ? map : this._source._map;
				if (!map.hasLayer(this) && map._popup && map._popup.options.autoClose) map.removeLayer(map._popup);
				map._popup = this;
				return DivOverlay.prototype.openOn.call(this, map);
			},
			onAdd: function(map) {
				DivOverlay.prototype.onAdd.call(this, map);
				map.fire("popupopen", { popup: this });
				if (this._source) {
					this._source.fire("popupopen", { popup: this }, true);
					if (!(this._source instanceof Path)) this._source.on("preclick", stopPropagation);
				}
			},
			onRemove: function(map) {
				DivOverlay.prototype.onRemove.call(this, map);
				map.fire("popupclose", { popup: this });
				if (this._source) {
					this._source.fire("popupclose", { popup: this }, true);
					if (!(this._source instanceof Path)) this._source.off("preclick", stopPropagation);
				}
			},
			getEvents: function() {
				var events = DivOverlay.prototype.getEvents.call(this);
				if (this.options.closeOnClick !== void 0 ? this.options.closeOnClick : this._map.options.closePopupOnClick) events.preclick = this.close;
				if (this.options.keepInView) events.moveend = this._adjustPan;
				return events;
			},
			_initLayout: function() {
				var prefix = "leaflet-popup", container = this._container = create$1("div", prefix + " " + (this.options.className || "") + " leaflet-zoom-animated");
				var wrapper = this._wrapper = create$1("div", prefix + "-content-wrapper", container);
				this._contentNode = create$1("div", prefix + "-content", wrapper);
				disableClickPropagation(container);
				disableScrollPropagation(this._contentNode);
				on(container, "contextmenu", stopPropagation);
				this._tipContainer = create$1("div", prefix + "-tip-container", container);
				this._tip = create$1("div", prefix + "-tip", this._tipContainer);
				if (this.options.closeButton) {
					var closeButton = this._closeButton = create$1("a", prefix + "-close-button", container);
					closeButton.setAttribute("role", "button");
					closeButton.setAttribute("aria-label", "Close popup");
					closeButton.href = "#close";
					closeButton.innerHTML = "<span aria-hidden=\"true\">&#215;</span>";
					on(closeButton, "click", function(ev) {
						preventDefault(ev);
						this.close();
					}, this);
				}
			},
			_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";
					addClass(container, scrolledClass);
				} else 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();
				setPosition(this._container, pos.add(anchor));
			},
			_adjustPan: function() {
				if (!this.options.autoPan) return;
				if (this._map._panAnim) this._map._panAnim.stop();
				if (this._autopanning) {
					this._autopanning = false;
					return;
				}
				var map = this._map, marginBottom = parseInt(getStyle(this._container, "marginBottom"), 10) || 0, containerHeight = this._container.offsetHeight + marginBottom, containerWidth = this._containerWidth, layerPos = new Point(this._containerLeft, -containerHeight - this._containerBottom);
				layerPos._add(getPosition(this._container));
				var containerPos = map.layerPointToContainerPoint(layerPos), padding = toPoint(this.options.autoPanPadding), paddingTL = toPoint(this.options.autoPanPaddingTopLeft || padding), paddingBR = toPoint(this.options.autoPanPaddingBottomRight || padding), size = map.getSize(), dx = 0, dy = 0;
				if (containerPos.x + containerWidth + paddingBR.x > size.x) dx = containerPos.x + containerWidth - size.x + paddingBR.x;
				if (containerPos.x - dx - paddingTL.x < 0) dx = containerPos.x - paddingTL.x;
				if (containerPos.y + containerHeight + paddingBR.y > size.y) dy = containerPos.y + containerHeight - size.y + paddingBR.y;
				if (containerPos.y - dy - paddingTL.y < 0) dy = containerPos.y - paddingTL.y;
				if (dx || dy) {
					if (this.options.keepInView) this._autopanning = true;
					map.fire("autopanstart").panBy([dx, dy]);
				}
			},
			_getAnchor: function() {
				return toPoint(this._source && this._source._getPopupAnchor ? this._source._getPopupAnchor() : [0, 0]);
			}
		});
		var popup = function(options, source) {
			return new Popup(options, source);
		};
		Map.mergeOptions({ closePopupOnClick: true });
		Map.include({
			openPopup: function(popup, latlng, options) {
				this._initOverlay(Popup, popup, latlng, options).openOn(this);
				return this;
			},
			closePopup: function(popup) {
				popup = arguments.length ? popup : this._popup;
				if (popup) popup.close();
				return this;
			}
		});
		Layer.include({
			bindPopup: function(content, options) {
				this._popup = this._initOverlay(Popup, this._popup, content, options);
				if (!this._popupHandlersAdded) {
					this.on({
						click: this._openPopup,
						keypress: this._onKeyPress,
						remove: this.closePopup,
						move: this._movePopup
					});
					this._popupHandlersAdded = true;
				}
				return this;
			},
			unbindPopup: function() {
				if (this._popup) {
					this.off({
						click: this._openPopup,
						keypress: this._onKeyPress,
						remove: this.closePopup,
						move: this._movePopup
					});
					this._popupHandlersAdded = false;
					this._popup = null;
				}
				return this;
			},
			openPopup: function(latlng) {
				if (this._popup) {
					if (!(this instanceof FeatureGroup)) this._popup._source = this;
					if (this._popup._prepareOpen(latlng || this._latlng)) this._popup.openOn(this._map);
				}
				return this;
			},
			closePopup: function() {
				if (this._popup) this._popup.close();
				return this;
			},
			togglePopup: function() {
				if (this._popup) this._popup.toggle(this);
				return this;
			},
			isPopupOpen: function() {
				return this._popup ? this._popup.isOpen() : false;
			},
			setPopupContent: function(content) {
				if (this._popup) this._popup.setContent(content);
				return this;
			},
			getPopup: function() {
				return this._popup;
			},
			_openPopup: function(e) {
				if (!this._popup || !this._map) return;
				stop(e);
				var target = e.layer || e.target;
				if (this._popup._source === target && !(target instanceof Path)) {
					if (this._map.hasLayer(this._popup)) this.closePopup();
					else this.openPopup(e.latlng);
					return;
				}
				this._popup._source = target;
				this.openPopup(e.latlng);
			},
			_movePopup: function(e) {
				this._popup.setLatLng(e.latlng);
			},
			_onKeyPress: function(e) {
				if (e.originalEvent.keyCode === 13) this._openPopup(e);
			}
		});
		var Tooltip = DivOverlay.extend({
			options: {
				pane: "tooltipPane",
				offset: [0, 0],
				direction: "auto",
				permanent: false,
				sticky: false,
				opacity: .9
			},
			onAdd: function(map) {
				DivOverlay.prototype.onAdd.call(this, map);
				this.setOpacity(this.options.opacity);
				map.fire("tooltipopen", { tooltip: this });
				if (this._source) {
					this.addEventParent(this._source);
					this._source.fire("tooltipopen", { tooltip: this }, true);
				}
			},
			onRemove: function(map) {
				DivOverlay.prototype.onRemove.call(this, map);
				map.fire("tooltipclose", { tooltip: this });
				if (this._source) {
					this.removeEventParent(this._source);
					this._source.fire("tooltipclose", { tooltip: this }, true);
				}
			},
			getEvents: function() {
				var events = DivOverlay.prototype.getEvents.call(this);
				if (!this.options.permanent) events.preclick = this.close;
				return events;
			},
			_initLayout: function() {
				var className = "leaflet-tooltip " + (this.options.className || "") + " leaflet-zoom-" + (this._zoomAnimated ? "animated" : "hide");
				this._contentNode = this._container = create$1("div", className);
				this._container.setAttribute("role", "tooltip");
				this._container.setAttribute("id", "leaflet-tooltip-" + stamp(this));
			},
			_updateLayout: function() {},
			_adjustPan: function() {},
			_setPosition: function(pos) {
				var subX, subY, 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 = toPoint(this.options.offset), anchor = this._getAnchor();
				if (direction === "top") {
					subX = tooltipWidth / 2;
					subY = tooltipHeight;
				} else if (direction === "bottom") {
					subX = tooltipWidth / 2;
					subY = 0;
				} else if (direction === "center") {
					subX = tooltipWidth / 2;
					subY = tooltipHeight / 2;
				} else if (direction === "right") {
					subX = 0;
					subY = tooltipHeight / 2;
				} else if (direction === "left") {
					subX = tooltipWidth;
					subY = tooltipHeight / 2;
				} else if (tooltipPoint.x < centerPoint.x) {
					direction = "right";
					subX = 0;
					subY = tooltipHeight / 2;
				} else {
					direction = "left";
					subX = tooltipWidth + (offset.x + anchor.x) * 2;
					subY = tooltipHeight / 2;
				}
				pos = pos.subtract(toPoint(subX, subY, true)).add(offset).add(anchor);
				removeClass(container, "leaflet-tooltip-right");
				removeClass(container, "leaflet-tooltip-left");
				removeClass(container, "leaflet-tooltip-top");
				removeClass(container, "leaflet-tooltip-bottom");
				addClass(container, "leaflet-tooltip-" + direction);
				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) setOpacity(this._container, opacity);
			},
			_animateZoom: function(e) {
				var pos = this._map._latLngToNewLayerPoint(this._latlng, e.zoom, e.center);
				this._setPosition(pos);
			},
			_getAnchor: function() {
				return toPoint(this._source && this._source._getTooltipAnchor && !this.options.sticky ? this._source._getTooltipAnchor() : [0, 0]);
			}
		});
		var tooltip = function(options, source) {
			return new Tooltip(options, source);
		};
		Map.include({
			openTooltip: function(tooltip, latlng, options) {
				this._initOverlay(Tooltip, tooltip, latlng, options).openOn(this);
				return this;
			},
			closeTooltip: function(tooltip) {
				tooltip.close();
				return this;
			}
		});
		Layer.include({
			bindTooltip: function(content, options) {
				if (this._tooltip && this.isTooltipOpen()) this.unbindTooltip();
				this._tooltip = this._initOverlay(Tooltip, this._tooltip, content, options);
				this._initTooltipInteractions();
				if (this._tooltip.options.permanent && this._map && this._map.hasLayer(this)) this.openTooltip();
				return this;
			},
			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;
					events.click = this._openTooltip;
					if (this._map) this._addFocusListeners();
					else events.add = this._addFocusListeners;
				} else events.add = this._openTooltip;
				if (this._tooltip.options.sticky) events.mousemove = this._moveTooltip;
				this[onOff](events);
				this._tooltipHandlersAdded = !remove;
			},
			openTooltip: function(latlng) {
				if (this._tooltip) {
					if (!(this instanceof FeatureGroup)) this._tooltip._source = this;
					if (this._tooltip._prepareOpen(latlng)) {
						this._tooltip.openOn(this._map);
						if (this.getElement) this._setAriaDescribedByOnLayer(this);
						else if (this.eachLayer) this.eachLayer(this._setAriaDescribedByOnLayer, this);
					}
				}
				return this;
			},
			closeTooltip: function() {
				if (this._tooltip) return this._tooltip.close();
			},
			toggleTooltip: function() {
				if (this._tooltip) this._tooltip.toggle(this);
				return this;
			},
			isTooltipOpen: function() {
				return this._tooltip.isOpen();
			},
			setTooltipContent: function(content) {
				if (this._tooltip) this._tooltip.setContent(content);
				return this;
			},
			getTooltip: function() {
				return this._tooltip;
			},
			_addFocusListeners: function() {
				if (this.getElement) this._addFocusListenersOnLayer(this);
				else if (this.eachLayer) this.eachLayer(this._addFocusListenersOnLayer, this);
			},
			_addFocusListenersOnLayer: function(layer) {
				var el = typeof layer.getElement === "function" && layer.getElement();
				if (el) {
					on(el, "focus", function() {
						this._tooltip._source = layer;
						this.openTooltip();
					}, this);
					on(el, "blur", this.closeTooltip, this);
				}
			},
			_setAriaDescribedByOnLayer: function(layer) {
				var el = typeof layer.getElement === "function" && layer.getElement();
				if (el) el.setAttribute("aria-describedby", this._tooltip._container.id);
			},
			_openTooltip: function(e) {
				if (!this._tooltip || !this._map) return;
				if (this._map.dragging && this._map.dragging.moving() && !this._openOnceFlag) {
					this._openOnceFlag = true;
					var that = this;
					this._map.once("moveend", function() {
						that._openOnceFlag = false;
						that._openTooltip(e);
					});
					return;
				}
				this._tooltip._source = e.layer || e.target;
				this.openTooltip(this._tooltip.options.sticky ? e.latlng : void 0);
			},
			_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);
			}
		});
		var DivIcon = Icon.extend({
			options: {
				iconSize: [12, 12],
				html: false,
				bgPos: null,
				className: "leaflet-div-icon"
			},
			createIcon: function(oldIcon) {
				var div = oldIcon && oldIcon.tagName === "DIV" ? oldIcon : document.createElement("div"), options = this.options;
				if (options.html instanceof Element) {
					empty(div);
					div.appendChild(options.html);
				} else div.innerHTML = options.html !== false ? options.html : "";
				if (options.bgPos) {
					var bgPos = toPoint(options.bgPos);
					div.style.backgroundPosition = -bgPos.x + "px " + -bgPos.y + "px";
				}
				this._setIconStyles(div, "icon");
				return div;
			},
			createShadow: function() {
				return null;
			}
		});
		function divIcon(options) {
			return new DivIcon(options);
		}
		Icon.Default = IconDefault;
		var GridLayer = Layer.extend({
			options: {
				tileSize: 256,
				opacity: 1,
				updateWhenIdle: Browser.mobile,
				updateWhenZooming: true,
				updateInterval: 200,
				zIndex: 1,
				bounds: null,
				minZoom: 0,
				maxZoom: void 0,
				maxNativeZoom: void 0,
				minNativeZoom: void 0,
				noWrap: false,
				pane: "tilePane",
				className: "",
				keepBuffer: 2
			},
			initialize: function(options) {
				setOptions(this, options);
			},
			onAdd: function() {
				this._initContainer();
				this._levels = {};
				this._tiles = {};
				this._resetView();
			},
			beforeAdd: function(map) {
				map._addZoomLimit(this);
			},
			onRemove: function(map) {
				this._removeAllTiles();
				remove(this._container);
				map._removeZoomLimit(this);
				this._container = null;
				this._tileZoom = void 0;
			},
			bringToFront: function() {
				if (this._map) {
					toFront(this._container);
					this._setAutoZIndex(Math.max);
				}
				return this;
			},
			bringToBack: function() {
				if (this._map) {
					toBack(this._container);
					this._setAutoZIndex(Math.min);
				}
				return this;
			},
			getContainer: function() {
				return this._container;
			},
			setOpacity: function(opacity) {
				this.options.opacity = opacity;
				this._updateOpacity();
				return this;
			},
			setZIndex: function(zIndex) {
				this.options.zIndex = zIndex;
				this._updateZIndex();
				return this;
			},
			isLoading: function() {
				return this._loading;
			},
			redraw: function() {
				if (this._map) {
					this._removeAllTiles();
					var tileZoom = this._clampZoom(this._map.getZoom());
					if (tileZoom !== this._tileZoom) {
						this._tileZoom = tileZoom;
						this._updateLevels();
					}
					this._update();
				}
				return this;
			},
			getEvents: function() {
				var events = {
					viewprereset: this._invalidateAll,
					viewreset: this._resetView,
					zoom: this._resetView,
					moveend: this._onMoveEnd
				};
				if (!this.options.updateWhenIdle) {
					if (!this._onMove) this._onMove = throttle(this._onMoveEnd, this.options.updateInterval, this);
					events.move = this._onMove;
				}
				if (this._zoomAnimated) events.zoomanim = this._animateZoom;
				return events;
			},
			createTile: function() {
				return document.createElement("div");
			},
			getTileSize: function() {
				var s = this.options.tileSize;
				return s instanceof Point ? s : new Point(s, s);
			},
			_updateZIndex: function() {
				if (this._container && this.options.zIndex !== void 0 && this.options.zIndex !== null) this._container.style.zIndex = this.options.zIndex;
			},
			_setAutoZIndex: function(compare) {
				var layers = this.getPane().children, edgeZIndex = -compare(-Infinity, Infinity);
				for (var i = 0, len = layers.length, zIndex; i < len; i++) {
					zIndex = layers[i].style.zIndex;
					if (layers[i] !== this._container && zIndex) edgeZIndex = compare(edgeZIndex, +zIndex);
				}
				if (isFinite(edgeZIndex)) {
					this.options.zIndex = edgeZIndex + compare(-1, 1);
					this._updateZIndex();
				}
			},
			_updateOpacity: function() {
				if (!this._map) return;
				if (Browser.ielt9) return;
				setOpacity(this._container, this.options.opacity);
				var now = +/* @__PURE__ */ new Date(), nextFrame = false, willPrune = false;
				for (var key in this._tiles) {
					var tile = this._tiles[key];
					if (!tile.current || !tile.loaded) continue;
					var fade = Math.min(1, (now - tile.loaded) / 200);
					setOpacity(tile.el, fade);
					if (fade < 1) nextFrame = true;
					else {
						if (tile.active) willPrune = true;
						else this._onOpaqueTile(tile);
						tile.active = true;
					}
				}
				if (willPrune && !this._noPrune) this._pruneTiles();
				if (nextFrame) {
					cancelAnimFrame(this._fadeFrame);
					this._fadeFrame = requestAnimFrame(this._updateOpacity, this);
				}
			},
			_onOpaqueTile: falseFn,
			_initContainer: function() {
				if (this._container) return;
				this._container = create$1("div", "leaflet-layer " + (this.options.className || ""));
				this._updateZIndex();
				if (this.options.opacity < 1) this._updateOpacity();
				this.getPane().appendChild(this._container);
			},
			_updateLevels: function() {
				var zoom = this._tileZoom, maxZoom = this.options.maxZoom;
				if (zoom === void 0) return;
				for (var z in this._levels) {
					z = Number(z);
					if (this._levels[z].el.children.length || z === zoom) {
						this._levels[z].el.style.zIndex = maxZoom - Math.abs(zoom - z);
						this._onUpdateLevel(z);
					} else {
						remove(this._levels[z].el);
						this._removeTilesAtZoom(z);
						this._onRemoveLevel(z);
						delete this._levels[z];
					}
				}
				var level = this._levels[zoom], map = this._map;
				if (!level) {
					level = this._levels[zoom] = {};
					level.el = create$1("div", "leaflet-tile-container leaflet-zoom-animated", this._container);
					level.el.style.zIndex = maxZoom;
					level.origin = map.project(map.unproject(map.getPixelOrigin()), zoom).round();
					level.zoom = zoom;
					this._setZoomTransform(level, map.getCenter(), map.getZoom());
					level.el.offsetWidth;
					this._onCreateLevel(level);
				}
				this._level = level;
				return level;
			},
			_onUpdateLevel: falseFn,
			_onRemoveLevel: falseFn,
			_onCreateLevel: falseFn,
			_pruneTiles: function() {
				if (!this._map) return;
				var key, tile;
				var zoom = this._map.getZoom();
				if (zoom > this.options.maxZoom || zoom < this.options.minZoom) {
					this._removeAllTiles();
					return;
				}
				for (key in this._tiles) {
					tile = this._tiles[key];
					tile.retain = tile.current;
				}
				for (key in this._tiles) {
					tile = this._tiles[key];
					if (tile.current && !tile.active) {
						var coords = tile.coords;
						if (!this._retainParent(coords.x, coords.y, coords.z, coords.z - 5)) this._retainChildren(coords.x, coords.y, coords.z, coords.z + 2);
					}
				}
				for (key in this._tiles) if (!this._tiles[key].retain) this._removeTile(key);
			},
			_removeTilesAtZoom: function(zoom) {
				for (var key in this._tiles) {
					if (this._tiles[key].coords.z !== zoom) continue;
					this._removeTile(key);
				}
			},
			_removeAllTiles: function() {
				for (var key in this._tiles) this._removeTile(key);
			},
			_invalidateAll: function() {
				for (var z in this._levels) {
					remove(this._levels[z].el);
					this._onRemoveLevel(Number(z));
					delete this._levels[z];
				}
				this._removeAllTiles();
				this._tileZoom = void 0;
			},
			_retainParent: function(x, y, z, minZoom) {
				var x2 = Math.floor(x / 2), y2 = Math.floor(y / 2), z2 = z - 1, coords2 = new Point(+x2, +y2);
				coords2.z = +z2;
				var key = this._tileCoordsToKey(coords2), tile = this._tiles[key];
				if (tile && tile.active) {
					tile.retain = true;
					return true;
				} else if (tile && tile.loaded) tile.retain = true;
				if (z2 > minZoom) return this._retainParent(x2, y2, z2, minZoom);
				return false;
			},
			_retainChildren: function(x, y, z, maxZoom) {
				for (var i = 2 * x; i < 2 * x + 2; i++) for (var j = 2 * y; j < 2 * y + 2; j++) {
					var coords = new Point(i, j);
					coords.z = z + 1;
					var key = this._tileCoordsToKey(coords), tile = this._tiles[key];
					if (tile && tile.active) {
						tile.retain = true;
						continue;
					} else if (tile && tile.loaded) tile.retain = true;
					if (z + 1 < maxZoom) this._retainChildren(i, j, z + 1, maxZoom);
				}
			},
			_resetView: function(e) {
				var animating = e && (e.pinch || e.flyTo);
				this._setView(this._map.getCenter(), this._map.getZoom(), animating, animating);
			},
			_animateZoom: function(e) {
				this._setView(e.center, e.zoom, true, e.noUpdate);
			},
			_clampZoom: function(zoom) {
				var options = this.options;
				if (void 0 !== options.minNativeZoom && zoom < options.minNativeZoom) return options.minNativeZoom;
				if (void 0 !== options.maxNativeZoom && options.maxNativeZoom < zoom) return options.maxNativeZoom;
				return zoom;
			},
			_setView: function(center, zoom, noPrune, noUpdate) {
				var tileZoom = Math.round(zoom);
				if (this.options.maxZoom !== void 0 && tileZoom > this.options.maxZoom || this.options.minZoom !== void 0 && tileZoom < this.options.minZoom) tileZoom = void 0;
				else tileZoom = this._clampZoom(tileZoom);
				var tileZoomChanged = this.options.updateWhenZooming && tileZoom !== this._tileZoom;
				if (!noUpdate || tileZoomChanged) {
					this._tileZoom = tileZoom;
					if (this._abortLoading) this._abortLoading();
					this._updateLevels();
					this._resetGrid();
					if (tileZoom !== void 0) this._update(center);
					if (!noPrune) this._pruneTiles();
					this._noPrune = !!noPrune;
				}
				this._setZoomTransforms(center, zoom);
			},
			_setZoomTransforms: function(center, zoom) {
				for (var i in this._levels) this._setZoomTransform(this._levels[i], center, zoom);
			},
			_setZoomTransform: function(level, center, zoom) {
				var scale = this._map.getZoomScale(zoom, level.zoom), translate = level.origin.multiplyBy(scale).subtract(this._map._getNewPixelOrigin(center, zoom)).round();
				if (Browser.any3d) setTransform(level.el, translate, scale);
				else setPosition(level.el, translate);
			},
			_resetGrid: function() {
				var map = this._map, crs = map.options.crs, tileSize = this._tileSize = this.getTileSize(), tileZoom = this._tileZoom;
				var bounds = this._map.getPixelWorldBounds(this._tileZoom);
				if (bounds) this._globalTileRange = this._pxBoundsToTileRange(bounds);
				this._wrapX = crs.wrapLng && !this.options.noWrap && [Math.floor(map.project([0, crs.wrapLng[0]], tileZoom).x / tileSize.x), Math.ceil(map.project([0, crs.wrapLng[1]], tileZoom).x / tileSize.y)];
				this._wrapY = crs.wrapLat && !this.options.noWrap && [Math.floor(map.project([crs.wrapLat[0], 0], tileZoom).y / tileSize.x), Math.ceil(map.project([crs.wrapLat[1], 0], tileZoom).y / tileSize.y)];
			},
			_onMoveEnd: function() {
				if (!this._map || this._map._animatingZoom) return;
				this._update();
			},
			_getTiledPixelBounds: function(center) {
				var map = this._map, mapZoom = map._animatingZoom ? Math.max(map._animateToZoom, map.getZoom()) : map.getZoom(), scale = map.getZoomScale(mapZoom, this._tileZoom), pixelCenter = map.project(center, this._tileZoom).floor(), halfSize = map.getSize().divideBy(scale * 2);
				return new Bounds(pixelCenter.subtract(halfSize), pixelCenter.add(halfSize));
			},
			_update: function(center) {
				var map = this._map;
				if (!map) return;
				var zoom = this._clampZoom(map.getZoom());
				if (center === void 0) center = map.getCenter();
				if (this._tileZoom === void 0) return;
				var pixelBounds = this._getTiledPixelBounds(center), tileRange = this._pxBoundsToTileRange(pixelBounds), tileCenter = tileRange.getCenter(), queue = [], margin = this.options.keepBuffer, noPruneRange = new Bounds(tileRange.getBottomLeft().subtract([margin, -margin]), tileRange.getTopRight().add([margin, -margin]));
				if (!(isFinite(tileRange.min.x) && isFinite(tileRange.min.y) && isFinite(tileRange.max.x) && isFinite(tileRange.max.y))) throw new Error("Attempted to load an infinite number of tiles");
				for (var key in this._tiles) {
					var c = this._tiles[key].coords;
					if (c.z !== this._tileZoom || !noPruneRange.contains(new Point(c.x, c.y))) this._tiles[key].current = false;
				}
				if (Math.abs(zoom - this._tileZoom) > 1) {
					this._setView(center, zoom);
					return;
				}
				for (var j = tileRange.min.y; j <= tileRange.max.y; j++) for (var i = tileRange.min.x; i <= tileRange.max.x; i++) {
					var coords = new Point(i, j);
					coords.z = this._tileZoom;
					if (!this._isValidTile(coords)) continue;
					var tile = this._tiles[this._tileCoordsToKey(coords)];
					if (tile) tile.current = true;
					else queue.push(coords);
				}
				queue.sort(function(a, b) {
					return a.distanceTo(tileCenter) - b.distanceTo(tileCenter);
				});
				if (queue.length !== 0) {
					if (!this._loading) {
						this._loading = true;
						this.fire("loading");
					}
					var fragment = document.createDocumentFragment();
					for (i = 0; i < queue.length; i++) this._addTile(queue[i], fragment);
					this._level.el.appendChild(fragment);
				}
			},
			_isValidTile: function(coords) {
				var crs = this._map.options.crs;
				if (!crs.infinite) {
					var bounds = this._globalTileRange;
					if (!crs.wrapLng && (coords.x < bounds.min.x || coords.x > bounds.max.x) || !crs.wrapLat && (coords.y < bounds.min.y || coords.y > bounds.max.y)) return false;
				}
				if (!this.options.bounds) return true;
				var tileBounds = this._tileCoordsToBounds(coords);
				return toLatLngBounds(this.options.bounds).overlaps(tileBounds);
			},
			_keyToBounds: function(key) {
				return this._tileCoordsToBounds(this._keyToTileCoords(key));
			},
			_tileCoordsToNwSe: function(coords) {
				var map = this._map, tileSize = this.getTileSize(), nwPoint = coords.scaleBy(tileSize), sePoint = nwPoint.add(tileSize);
				return [map.unproject(nwPoint, coords.z), map.unproject(sePoint, coords.z)];
			},
			_tileCoordsToBounds: function(coords) {
				var bp = this._tileCoordsToNwSe(coords), bounds = new LatLngBounds(bp[0], bp[1]);
				if (!this.options.noWrap) bounds = this._map.wrapLatLngBounds(bounds);
				return bounds;
			},
			_tileCoordsToKey: function(coords) {
				return coords.x + ":" + coords.y + ":" + coords.z;
			},
			_keyToTileCoords: function(key) {
				var k = key.split(":"), coords = new Point(+k[0], +k[1]);
				coords.z = +k[2];
				return coords;
			},
			_removeTile: function(key) {
				var tile = this._tiles[key];
				if (!tile) return;
				remove(tile.el);
				delete this._tiles[key];
				this.fire("tileunload", {
					tile: tile.el,
					coords: this._keyToTileCoords(key)
				});
			},
			_initTile: function(tile) {
				addClass(tile, "leaflet-tile");
				var tileSize = this.getTileSize();
				tile.style.width = tileSize.x + "px";
				tile.style.height = tileSize.y + "px";
				tile.onselectstart = falseFn;
				tile.onmousemove = falseFn;
				if (Browser.ielt9 && this.options.opacity < 1) setOpacity(tile, this.options.opacity);
			},
			_addTile: function(coords, container) {
				var tilePos = this._getTilePos(coords), key = this._tileCoordsToKey(coords);
				var tile = this.createTile(this._wrapCoords(coords), bind(this._tileReady, this, coords));
				this._initTile(tile);
				if (this.createTile.length < 2) requestAnimFrame(bind(this._tileReady, this, coords, null, tile));
				setPosition(tile, tilePos);
				this._tiles[key] = {
					el: tile,
					coords,
					current: true
				};
				container.appendChild(tile);
				this.fire("tileloadstart", {
					tile,
					coords
				});
			},
			_tileReady: function(coords, err, tile) {
				if (err) this.fire("tileerror", {
					error: err,
					tile,
					coords
				});
				var key = this._tileCoordsToKey(coords);
				tile = this._tiles[key];
				if (!tile) return;
				tile.loaded = +/* @__PURE__ */ new Date();
				if (this._map._fadeAnimated) {
					setOpacity(tile.el, 0);
					cancelAnimFrame(this._fadeFrame);
					this._fadeFrame = requestAnimFrame(this._updateOpacity, this);
				} else {
					tile.active = true;
					this._pruneTiles();
				}
				if (!err) {
					addClass(tile.el, "leaflet-tile-loaded");
					this.fire("tileload", {
						tile: tile.el,
						coords
					});
				}
				if (this._noTilesToLoad()) {
					this._loading = false;
					this.fire("load");
					if (Browser.ielt9 || !this._map._fadeAnimated) requestAnimFrame(this._pruneTiles, this);
					else setTimeout(bind(this._pruneTiles, this), 250);
				}
			},
			_getTilePos: function(coords) {
				return coords.scaleBy(this.getTileSize()).subtract(this._level.origin);
			},
			_wrapCoords: function(coords) {
				var newCoords = new Point(this._wrapX ? wrapNum(coords.x, this._wrapX) : coords.x, this._wrapY ? wrapNum(coords.y, this._wrapY) : coords.y);
				newCoords.z = coords.z;
				return newCoords;
			},
			_pxBoundsToTileRange: function(bounds) {
				var tileSize = this.getTileSize();
				return new Bounds(bounds.min.unscaleBy(tileSize).floor(), bounds.max.unscaleBy(tileSize).ceil().subtract([1, 1]));
			},
			_noTilesToLoad: function() {
				for (var key in this._tiles) if (!this._tiles[key].loaded) return false;
				return true;
			}
		});
		function gridLayer(options) {
			return new GridLayer(options);
		}
		var TileLayer = GridLayer.extend({
			options: {
				minZoom: 0,
				maxZoom: 18,
				subdomains: "abc",
				errorTileUrl: "",
				zoomOffset: 0,
				tms: false,
				zoomReverse: false,
				detectRetina: false,
				crossOrigin: false,
				referrerPolicy: false
			},
			initialize: function(url, options) {
				this._url = url;
				options = setOptions(this, options);
				if (options.detectRetina && Browser.retina && options.maxZoom > 0) {
					options.tileSize = Math.floor(options.tileSize / 2);
					if (!options.zoomReverse) {
						options.zoomOffset++;
						options.maxZoom = Math.max(options.minZoom, options.maxZoom - 1);
					} else {
						options.zoomOffset--;
						options.minZoom = Math.min(options.maxZoom, options.minZoom + 1);
					}
					options.minZoom = Math.max(0, options.minZoom);
				} else if (!options.zoomReverse) options.maxZoom = Math.max(options.minZoom, options.maxZoom);
				else options.minZoom = Math.min(options.maxZoom, options.minZoom);
				if (typeof options.subdomains === "string") options.subdomains = options.subdomains.split("");
				this.on("tileunload", this._onTileRemove);
			},
			setUrl: function(url, noRedraw) {
				if (this._url === url && noRedraw === void 0) noRedraw = true;
				this._url = url;
				if (!noRedraw) this.redraw();
				return this;
			},
			createTile: function(coords, done) {
				var tile = document.createElement("img");
				on(tile, "load", bind(this._tileOnLoad, this, done, tile));
				on(tile, "error", bind(this._tileOnError, this, done, tile));
				if (this.options.crossOrigin || this.options.crossOrigin === "") tile.crossOrigin = this.options.crossOrigin === true ? "" : this.options.crossOrigin;
				if (typeof this.options.referrerPolicy === "string") tile.referrerPolicy = this.options.referrerPolicy;
				tile.alt = "";
				tile.src = this.getTileUrl(coords);
				return tile;
			},
			getTileUrl: function(coords) {
				var data = {
					r: Browser.retina ? "@2x" : "",
					s: this._getSubdomain(coords),
					x: coords.x,
					y: coords.y,
					z: this._getZoomForUrl()
				};
				if (this._map && !this._map.options.crs.infinite) {
					var invertedY = this._globalTileRange.max.y - coords.y;
					if (this.options.tms) data["y"] = invertedY;
					data["-y"] = invertedY;
				}
				return template(this._url, extend(data, this.options));
			},
			_tileOnLoad: function(done, tile) {
				if (Browser.ielt9) setTimeout(bind(done, this, null, tile), 0);
				else done(null, tile);
			},
			_tileOnError: function(done, tile, e) {
				var errorUrl = this.options.errorTileUrl;
				if (errorUrl && tile.getAttribute("src") !== errorUrl) tile.src = errorUrl;
				done(e, tile);
			},
			_onTileRemove: function(e) {
				e.tile.onload = null;
			},
			_getZoomForUrl: function() {
				var zoom = this._tileZoom, maxZoom = this.options.maxZoom, zoomReverse = this.options.zoomReverse, zoomOffset = this.options.zoomOffset;
				if (zoomReverse) zoom = maxZoom - zoom;
				return zoom + zoomOffset;
			},
			_getSubdomain: function(tilePoint) {
				var index = Math.abs(tilePoint.x + tilePoint.y) % this.options.subdomains.length;
				return this.options.subdomains[index];
			},
			_abortLoading: function() {
				var i, tile;
				for (i in this._tiles) if (this._tiles[i].coords.z !== this._tileZoom) {
					tile = this._tiles[i].el;
					tile.onload = falseFn;
					tile.onerror = falseFn;
					if (!tile.complete) {
						tile.src = emptyImageUrl;
						var coords = this._tiles[i].coords;
						remove(tile);
						delete this._tiles[i];
						this.fire("tileabort", {
							tile,
							coords
						});
					}
				}
			},
			_removeTile: function(key) {
				var tile = this._tiles[key];
				if (!tile) return;
				tile.el.setAttribute("src", emptyImageUrl);
				return GridLayer.prototype._removeTile.call(this, key);
			},
			_tileReady: function(coords, err, tile) {
				if (!this._map || tile && tile.getAttribute("src") === emptyImageUrl) return;
				return GridLayer.prototype._tileReady.call(this, coords, err, tile);
			}
		});
		function tileLayer(url, options) {
			return new TileLayer(url, options);
		}
		var TileLayerWMS = TileLayer.extend({
			defaultWmsParams: {
				service: "WMS",
				request: "GetMap",
				layers: "",
				styles: "",
				format: "image/jpeg",
				transparent: false,
				version: "1.1.1"
			},
			options: {
				crs: null,
				uppercase: false
			},
			initialize: function(url, options) {
				this._url = url;
				var wmsParams = extend({}, this.defaultWmsParams);
				for (var i in options) if (!(i in this.options)) wmsParams[i] = options[i];
				options = setOptions(this, options);
				var realRetina = options.detectRetina && Browser.retina ? 2 : 1;
				var tileSize = this.getTileSize();
				wmsParams.width = tileSize.x * realRetina;
				wmsParams.height = tileSize.y * realRetina;
				this.wmsParams = wmsParams;
			},
			onAdd: function(map) {
				this._crs = this.options.crs || map.options.crs;
				this._wmsVersion = parseFloat(this.wmsParams.version);
				var projectionKey = this._wmsVersion >= 1.3 ? "crs" : "srs";
				this.wmsParams[projectionKey] = this._crs.code;
				TileLayer.prototype.onAdd.call(this, map);
			},
			getTileUrl: function(coords) {
				var tileBounds = this._tileCoordsToNwSe(coords), crs = this._crs, bounds = toBounds(crs.project(tileBounds[0]), crs.project(tileBounds[1])), min = bounds.min, max = bounds.max, bbox = (this._wmsVersion >= 1.3 && this._crs === EPSG4326 ? [
					min.y,
					min.x,
					max.y,
					max.x
				] : [
					min.x,
					min.y,
					max.x,
					max.y
				]).join(","), url = TileLayer.prototype.getTileUrl.call(this, coords);
				return url + getParamString(this.wmsParams, url, this.options.uppercase) + (this.options.uppercase ? "&BBOX=" : "&bbox=") + bbox;
			},
			setParams: function(params, noRedraw) {
				extend(this.wmsParams, params);
				if (!noRedraw) this.redraw();
				return this;
			}
		});
		function tileLayerWMS(url, options) {
			return new TileLayerWMS(url, options);
		}
		TileLayer.WMS = TileLayerWMS;
		tileLayer.wms = tileLayerWMS;
		var Renderer = Layer.extend({
			options: { padding: .1 },
			initialize: function(options) {
				setOptions(this, options);
				stamp(this);
				this._layers = this._layers || {};
			},
			onAdd: function() {
				if (!this._container) {
					this._initContainer();
					addClass(this._container, "leaflet-zoom-animated");
				}
				this.getPane().appendChild(this._container);
				this._update();
				this.on("update", this._updatePaths, this);
			},
			onRemove: function() {
				this.off("update", this._updatePaths, this);
				this._destroyContainer();
			},
			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), viewHalf = this._map.getSize().multiplyBy(.5 + this.options.padding), currentCenterPoint = this._map.project(this._center, zoom), topLeftOffset = viewHalf.multiplyBy(-scale).add(currentCenterPoint).subtract(this._map._getNewPixelOrigin(center, zoom));
				if (Browser.any3d) setTransform(this._container, topLeftOffset, scale);
				else 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() {
				var p = this.options.padding, size = this._map.getSize(), min = this._map.containerPointToLayerPoint(size.multiplyBy(-p)).round();
				this._bounds = new Bounds(min, min.add(size.multiplyBy(1 + p * 2)).round());
				this._center = this._map.getCenter();
				this._zoom = this._map.getZoom();
			}
		});
		var Canvas = Renderer.extend({
			options: { tolerance: 0 },
			getEvents: function() {
				var events = Renderer.prototype.getEvents.call(this);
				events.viewprereset = this._onViewPreReset;
				return events;
			},
			_onViewPreReset: function() {
				this._postponeUpdatePaths = true;
			},
			onAdd: function() {
				Renderer.prototype.onAdd.call(this);
				this._draw();
			},
			_initContainer: function() {
				var container = this._container = document.createElement("canvas");
				on(container, "mousemove", this._onMouseMove, this);
				on(container, "click dblclick mousedown mouseup contextmenu", this._onClick, this);
				on(container, "mouseout", this._handleMouseOut, this);
				container["_leaflet_disable_events"] = true;
				this._ctx = container.getContext("2d");
			},
			_destroyContainer: function() {
				cancelAnimFrame(this._redrawRequest);
				delete this._ctx;
				remove(this._container);
				off(this._container);
				delete this._container;
			},
			_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;
				Renderer.prototype._update.call(this);
				var b = this._bounds, container = this._container, size = b.getSize(), m = Browser.retina ? 2 : 1;
				setPosition(container, b.min);
				container.width = m * size.x;
				container.height = m * size.y;
				container.style.width = size.x + "px";
				container.style.height = size.y + "px";
				if (Browser.retina) this._ctx.scale(2, 2);
				this._ctx.translate(-b.min.x, -b.min.y);
				this.fire("update");
			},
			_reset: function() {
				Renderer.prototype._reset.call(this);
				if (this._postponeUpdatePaths) {
					this._postponeUpdatePaths = false;
					this._updatePaths();
				}
			},
			_initPath: function(layer) {
				this._updateDashArray(layer);
				this._layers[stamp(layer)] = layer;
				var order = layer._order = {
					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[stamp(layer)];
				this._requestRedraw(layer);
			},
			_updatePath: function(layer) {
				this._extendRedrawBounds(layer);
				layer._project();
				layer._update();
				this._requestRedraw(layer);
			},
			_updateStyle: function(layer) {
				this._updateDashArray(layer);
				this._requestRedraw(layer);
			},
			_updateDashArray: function(layer) {
				if (typeof layer.options.dashArray === "string") {
					var parts = layer.options.dashArray.split(/[, ]+/), dashArray = [], dashValue, i;
					for (i = 0; i < parts.length; i++) {
						dashValue = Number(parts[i]);
						if (isNaN(dashValue)) return;
						dashArray.push(dashValue);
					}
					layer.options._dashArray = dashArray;
				} else layer.options._dashArray = layer.options.dashArray;
			},
			_requestRedraw: function(layer) {
				if (!this._map) return;
				this._extendRedrawBounds(layer);
				this._redrawRequest = this._redrawRequest || requestAnimFrame(this._redraw, this);
			},
			_extendRedrawBounds: function(layer) {
				if (layer._pxBounds) {
					var padding = (layer.options.weight || 0) + 1;
					this._redrawBounds = this._redrawBounds || new 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();
				this._draw();
				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.save();
					this._ctx.setTransform(1, 0, 0, 1, 0, 0);
					this._ctx.clearRect(0, 0, this._container.width, this._container.height);
					this._ctx.restore();
				}
			},
			_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();
			},
			_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;
				ctx.beginPath();
				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);
			},
			_updateCircle: function(layer) {
				if (!this._drawing || layer._empty()) return;
				var p = layer._point, ctx = this._ctx, r = Math.max(Math.round(layer._radius), 1), s = (Math.max(Math.round(layer._radiusY), 1) || r) / r;
				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) {
					if (ctx.setLineDash) ctx.setLineDash(layer.options && layer.options._dashArray || []);
					ctx.globalAlpha = options.opacity;
					ctx.lineWidth = options.weight;
					ctx.strokeStyle = options.color;
					ctx.lineCap = options.lineCap;
					ctx.lineJoin = options.lineJoin;
					ctx.stroke();
				}
			},
			_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)) {
						if (!(e.type === "click" || e.type === "preclick") || !this._map._draggableMoved(layer)) clickedLayer = layer;
					}
				}
				this._fireEvent(clickedLayer ? [clickedLayer] : false, 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) {
					removeClass(this._container, "leaflet-interactive");
					this._fireEvent([layer], e, "mouseout");
					this._hoveredLayer = null;
					this._mouseHoverThrottled = false;
				}
			},
			_handleMouseHover: function(e, point) {
				if (this._mouseHoverThrottled) return;
				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) {
						addClass(this._container, "leaflet-interactive");
						this._fireEvent([candidateHoveredLayer], e, "mouseover");
						this._hoveredLayer = candidateHoveredLayer;
					}
				}
				this._fireEvent(this._hoveredLayer ? [this._hoveredLayer] : false, e);
				this._mouseHoverThrottled = true;
				setTimeout(bind(function() {
					this._mouseHoverThrottled = false;
				}, this), 32);
			},
			_fireEvent: function(layers, e, type) {
				this._map._fireDOMEvent(e, type || e.type, layers);
			},
			_bringToFront: function(layer) {
				var order = layer._order;
				if (!order) return;
				var next = order.next;
				var prev = order.prev;
				if (next) next.prev = prev;
				else return;
				if (prev) prev.next = next;
				else if (next) 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;
				if (!order) return;
				var next = order.next;
				var prev = order.prev;
				if (prev) prev.next = next;
				else return;
				if (next) next.prev = prev;
				else if (prev) this._drawLast = prev;
				order.prev = null;
				order.next = this._drawFirst;
				this._drawFirst.prev = order;
				this._drawFirst = order;
				this._requestRedraw(layer);
			}
		});
		function canvas(options) {
			return Browser.canvas ? new Canvas(options) : null;
		}
		var vmlCreate = (function() {
			try {
				document.namespaces.add("lvml", "urn:schemas-microsoft-com:vml");
				return function(name) {
					return document.createElement("<lvml:" + name + " class=\"lvml\">");
				};
			} catch (e) {}
			return function(name) {
				return document.createElement("<" + name + " xmlns=\"urn:schemas-microsoft.com:vml\" class=\"lvml\">");
			};
		})();
		var vmlMixin = {
			_initContainer: function() {
				this._container = create$1("div", "leaflet-vml-container");
			},
			_update: function() {
				if (this._map._animatingZoom) return;
				Renderer.prototype._update.call(this);
				this.fire("update");
			},
			_initPath: function(layer) {
				var container = layer._container = vmlCreate("shape");
				addClass(container, "leaflet-vml-shape " + (this.options.className || ""));
				container.coordsize = "1 1";
				layer._path = vmlCreate("path");
				container.appendChild(layer._path);
				this._updateStyle(layer);
				this._layers[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;
				remove(container);
				layer.removeInteractiveTarget(container);
				delete this._layers[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 = vmlCreate("stroke");
					container.appendChild(stroke);
					stroke.weight = options.weight + "px";
					stroke.color = options.color;
					stroke.opacity = options.opacity;
					if (options.dashArray) stroke.dashStyle = 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 = vmlCreate("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,23592600");
			},
			_setPath: function(layer, path) {
				layer._path.v = path;
			},
			_bringToFront: function(layer) {
				toFront(layer._container);
			},
			_bringToBack: function(layer) {
				toBack(layer._container);
			}
		};
		var create = Browser.vml ? vmlCreate : svgCreate;
		var SVG = Renderer.extend({
			_initContainer: function() {
				this._container = create("svg");
				this._container.setAttribute("pointer-events", "none");
				this._rootGroup = create("g");
				this._container.appendChild(this._rootGroup);
			},
			_destroyContainer: function() {
				remove(this._container);
				off(this._container);
				delete this._container;
				delete this._rootGroup;
				delete this._svgSize;
			},
			_update: function() {
				if (this._map._animatingZoom && this._bounds) return;
				Renderer.prototype._update.call(this);
				var b = this._bounds, size = b.getSize(), container = this._container;
				if (!this._svgSize || !this._svgSize.equals(size)) {
					this._svgSize = size;
					container.setAttribute("width", size.x);
					container.setAttribute("height", size.y);
				}
				setPosition(container, b.min);
				container.setAttribute("viewBox", [
					b.min.x,
					b.min.y,
					size.x,
					size.y
				].join(" "));
				this.fire("update");
			},
			_initPath: function(layer) {
				var path = layer._path = create("path");
				if (layer.options.className) addClass(path, layer.options.className);
				if (layer.options.interactive) addClass(path, "leaflet-interactive");
				this._updateStyle(layer);
				this._layers[stamp(layer)] = layer;
			},
			_addPath: function(layer) {
				if (!this._rootGroup) this._initContainer();
				this._rootGroup.appendChild(layer._path);
				layer.addInteractiveTarget(layer._path);
			},
			_removePath: function(layer) {
				remove(layer._path);
				layer.removeInteractiveTarget(layer._path);
				delete this._layers[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, pointsToPath(layer._parts, closed));
			},
			_updateCircle: function(layer) {
				var p = layer._point, r = Math.max(Math.round(layer._radius), 1), r2 = Math.max(Math.round(layer._radiusY), 1) || r, arc = "a" + r + "," + r2 + " 0 1,0 ";
				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);
			},
			_bringToFront: function(layer) {
				toFront(layer._path);
			},
			_bringToBack: function(layer) {
				toBack(layer._path);
			}
		});
		if (Browser.vml) SVG.include(vmlMixin);
		function svg(options) {
			return Browser.svg || Browser.vml ? new SVG(options) : null;
		}
		Map.include({
			getRenderer: function(layer) {
				var renderer = layer.options.renderer || this._getPaneRenderer(layer.options.pane) || this.options.renderer || this._renderer;
				if (!renderer) renderer = this._renderer = this._createRenderer();
				if (!this.hasLayer(renderer)) this.addLayer(renderer);
				return renderer;
			},
			_getPaneRenderer: function(name) {
				if (name === "overlayPane" || name === void 0) return false;
				var renderer = this._paneRenderers[name];
				if (renderer === void 0) {
					renderer = this._createRenderer({ pane: name });
					this._paneRenderers[name] = renderer;
				}
				return renderer;
			},
			_createRenderer: function(options) {
				return this.options.preferCanvas && canvas(options) || svg(options);
			}
		});
		var Rectangle = Polygon.extend({
			initialize: function(latLngBounds, options) {
				Polygon.prototype.initialize.call(this, this._boundsToLatLngs(latLngBounds), options);
			},
			setBounds: function(latLngBounds) {
				return this.setLatLngs(this._boundsToLatLngs(latLngBounds));
			},
			_boundsToLatLngs: function(latLngBounds) {
				latLngBounds = toLatLngBounds(latLngBounds);
				return [
					latLngBounds.getSouthWest(),
					latLngBounds.getNorthWest(),
					latLngBounds.getNorthEast(),
					latLngBounds.getSouthEast()
				];
			}
		});
		function rectangle(latLngBounds, options) {
			return new Rectangle(latLngBounds, options);
		}
		SVG.create = create;
		SVG.pointsToPath = pointsToPath;
		GeoJSON.geometryToLayer = geometryToLayer;
		GeoJSON.coordsToLatLng = coordsToLatLng;
		GeoJSON.coordsToLatLngs = coordsToLatLngs;
		GeoJSON.latLngToCoords = latLngToCoords;
		GeoJSON.latLngsToCoords = latLngsToCoords;
		GeoJSON.getFeature = getFeature;
		GeoJSON.asFeature = asFeature;
		Map.mergeOptions({ boxZoom: true });
		var BoxZoom = Handler.extend({
			initialize: function(map) {
				this._map = map;
				this._container = map._container;
				this._pane = map._panes.overlayPane;
				this._resetStateTimeout = 0;
				map.on("unload", this._destroy, this);
			},
			addHooks: function() {
				on(this._container, "mousedown", this._onMouseDown, this);
			},
			removeHooks: function() {
				off(this._container, "mousedown", this._onMouseDown, this);
			},
			moved: function() {
				return this._moved;
			},
			_destroy: function() {
				remove(this._pane);
				delete this._pane;
			},
			_resetState: function() {
				this._resetStateTimeout = 0;
				this._moved = false;
			},
			_clearDeferredResetState: function() {
				if (this._resetStateTimeout !== 0) {
					clearTimeout(this._resetStateTimeout);
					this._resetStateTimeout = 0;
				}
			},
			_onMouseDown: function(e) {
				if (!e.shiftKey || e.which !== 1 && e.button !== 1) return false;
				this._clearDeferredResetState();
				this._resetState();
				disableTextSelection();
				disableImageDrag();
				this._startPoint = this._map.mouseEventToContainerPoint(e);
				on(document, {
					contextmenu: stop,
					mousemove: this._onMouseMove,
					mouseup: this._onMouseUp,
					keydown: this._onKeyDown
				}, this);
			},
			_onMouseMove: function(e) {
				if (!this._moved) {
					this._moved = true;
					this._box = create$1("div", "leaflet-zoom-box", this._container);
					addClass(this._container, "leaflet-crosshair");
					this._map.fire("boxzoomstart");
				}
				this._point = this._map.mouseEventToContainerPoint(e);
				var bounds = new Bounds(this._point, this._startPoint), size = bounds.getSize();
				setPosition(this._box, bounds.min);
				this._box.style.width = size.x + "px";
				this._box.style.height = size.y + "px";
			},
			_finish: function() {
				if (this._moved) {
					remove(this._box);
					removeClass(this._container, "leaflet-crosshair");
				}
				enableTextSelection();
				enableImageDrag();
				off(document, {
					contextmenu: 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;
				this._clearDeferredResetState();
				this._resetStateTimeout = setTimeout(bind(this._resetState, this), 0);
				var bounds = new 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();
					this._clearDeferredResetState();
					this._resetState();
				}
			}
		});
		Map.addInitHook("addHandler", "boxZoom", BoxZoom);
		Map.mergeOptions({ doubleClickZoom: true });
		var DoubleClickZoom = 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);
			}
		});
		Map.addInitHook("addHandler", "doubleClickZoom", DoubleClickZoom);
		Map.mergeOptions({
			dragging: true,
			inertia: true,
			inertiaDeceleration: 3400,
			inertiaMaxSpeed: Infinity,
			easeLinearity: .2,
			worldCopyJump: false,
			maxBoundsViscosity: 0
		});
		var Drag = Handler.extend({
			addHooks: function() {
				if (!this._draggable) {
					var map = this._map;
					this._draggable = new Draggable(map._mapPane, map._container);
					this._draggable.on({
						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);
					}
				}
				addClass(this._map._container, "leaflet-grab leaflet-touch-drag");
				this._draggable.enable();
				this._positions = [];
				this._times = [];
			},
			removeHooks: function() {
				removeClass(this._map._container, "leaflet-grab");
				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;
			},
			_onDragStart: function() {
				var map = this._map;
				map._stop();
				if (this._map.options.maxBounds && this._map.options.maxBoundsViscosity) {
					var bounds = toLatLngBounds(this._map.options.maxBounds);
					this._offsetLimit = toBounds(this._map.latLngToContainerPoint(bounds.getNorthWest()).multiplyBy(-1), this._map.latLngToContainerPoint(bounds.getSouthEast()).multiplyBy(-1).add(this._map.getSize()));
					this._viscosity = Math.min(1, Math.max(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 = +/* @__PURE__ */ new Date(), pos = this._lastPos = this._draggable._absPos || this._draggable._newPos;
					this._positions.push(pos);
					this._times.push(time);
					this._prunePositions(time);
				}
				this._map.fire("move", e).fire("drag", e);
			},
			_prunePositions: function(time) {
				while (this._positions.length > 1 && time - this._times[0] > 50) {
					this._positions.shift();
					this._times.shift();
				}
			},
			_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() {
				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 || e.noInertia || this._times.length < 2;
				map.fire("dragend", e);
				if (noInertia) map.fire("moveend");
				else {
					this._prunePositions(+/* @__PURE__ */ new Date());
					var direction = this._lastPos.subtract(this._positions[0]), duration = (this._lastTime - this._times[0]) / 1e3, 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);
						requestAnimFrame(function() {
							map.panBy(offset, {
								duration: decelerationDuration,
								easeLinearity: ease,
								noMoveStart: true,
								animate: true
							});
						});
					}
				}
			}
		});
		Map.addInitHook("addHandler", "dragging", Drag);
		Map.mergeOptions({
			keyboard: true,
			keyboardPanDelta: 80
		});
		var Keyboard = 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;
				if (container.tabIndex <= 0) container.tabIndex = "0";
				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();
				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() {
				on(document, "keydown", this._onKeyDown, this);
			},
			_removeHooks: function() {
				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) {
						offset = this._panKeys[key];
						if (e.shiftKey) offset = toPoint(offset).multiplyBy(3);
						if (map.options.maxBounds) offset = map._limitOffset(toPoint(offset), map.options.maxBounds);
						if (map.options.worldCopyJump) {
							var newLatLng = map.wrapLatLng(map.unproject(map.project(map.getCenter()).add(offset)));
							map.panTo(newLatLng);
						} else map.panBy(offset);
					}
				} else if (key in this._zoomKeys) map.setZoom(map.getZoom() + (e.shiftKey ? 3 : 1) * this._zoomKeys[key]);
				else if (key === 27 && map._popup && map._popup.options.closeOnEscapeKey) map.closePopup();
				else return;
				stop(e);
			}
		});
		Map.addInitHook("addHandler", "keyboard", Keyboard);
		Map.mergeOptions({
			scrollWheelZoom: true,
			wheelDebounceTime: 40,
			wheelPxPerZoomLevel: 60
		});
		var ScrollWheelZoom = Handler.extend({
			addHooks: function() {
				on(this._map._container, "wheel", this._onWheelScroll, this);
				this._delta = 0;
			},
			removeHooks: function() {
				off(this._map._container, "wheel", this._onWheelScroll, this);
			},
			_onWheelScroll: function(e) {
				var delta = getWheelDelta(e);
				var debounce = this._map.options.wheelDebounceTime;
				this._delta += delta;
				this._lastMousePos = this._map.mouseEventToContainerPoint(e);
				if (!this._startTime) this._startTime = +/* @__PURE__ */ new Date();
				var left = Math.max(debounce - (+/* @__PURE__ */ new Date() - this._startTime), 0);
				clearTimeout(this._timer);
				this._timer = setTimeout(bind(this._performZoom, this), left);
				stop(e);
			},
			_performZoom: function() {
				var map = this._map, zoom = map.getZoom(), snap = this._map.options.zoomSnap || 0;
				map._stop();
				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);
			}
		});
		Map.addInitHook("addHandler", "scrollWheelZoom", ScrollWheelZoom);
		var tapHoldDelay = 600;
		Map.mergeOptions({
			tapHold: Browser.touchNative && Browser.safari && Browser.mobile,
			tapTolerance: 15
		});
		var TapHold = Handler.extend({
			addHooks: function() {
				on(this._map._container, "touchstart", this._onDown, this);
			},
			removeHooks: function() {
				off(this._map._container, "touchstart", this._onDown, this);
			},
			_onDown: function(e) {
				clearTimeout(this._holdTimeout);
				if (e.touches.length !== 1) return;
				var first = e.touches[0];
				this._startPos = this._newPos = new Point(first.clientX, first.clientY);
				this._holdTimeout = setTimeout(bind(function() {
					this._cancel();
					if (!this._isTapValid()) return;
					on(document, "touchend", preventDefault);
					on(document, "touchend touchcancel", this._cancelClickPrevent);
					this._simulateEvent("contextmenu", first);
				}, this), tapHoldDelay);
				on(document, "touchend touchcancel contextmenu", this._cancel, this);
				on(document, "touchmove", this._onMove, this);
			},
			_cancelClickPrevent: function cancelClickPrevent() {
				off(document, "touchend", preventDefault);
				off(document, "touchend touchcancel", cancelClickPrevent);
			},
			_cancel: function() {
				clearTimeout(this._holdTimeout);
				off(document, "touchend touchcancel contextmenu", this._cancel, this);
				off(document, "touchmove", this._onMove, this);
			},
			_onMove: function(e) {
				var first = e.touches[0];
				this._newPos = new Point(first.clientX, first.clientY);
			},
			_isTapValid: function() {
				return this._newPos.distanceTo(this._startPos) <= this._map.options.tapTolerance;
			},
			_simulateEvent: function(type, e) {
				var simulatedEvent = new MouseEvent(type, {
					bubbles: true,
					cancelable: true,
					view: window,
					screenX: e.screenX,
					screenY: e.screenY,
					clientX: e.clientX,
					clientY: e.clientY
				});
				simulatedEvent._simulated = true;
				e.target.dispatchEvent(simulatedEvent);
			}
		});
		Map.addInitHook("addHandler", "tapHold", TapHold);
		Map.mergeOptions({
			touchZoom: Browser.touch,
			bounceAtZoomLimits: true
		});
		var TouchZoom = Handler.extend({
			addHooks: function() {
				addClass(this._map._container, "leaflet-touch-zoom");
				on(this._map._container, "touchstart", this._onTouchStart, this);
			},
			removeHooks: function() {
				removeClass(this._map._container, "leaflet-touch-zoom");
				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();
				on(document, "touchmove", this._onTouchMove, this);
				on(document, "touchend touchcancel", this._onTouchEnd, this);
				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 {
					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, false);
					this._moved = true;
				}
				cancelAnimFrame(this._animRequest);
				var moveFn = bind(map._move, map, this._center, this._zoom, {
					pinch: true,
					round: false
				}, void 0);
				this._animRequest = requestAnimFrame(moveFn, this, true);
				preventDefault(e);
			},
			_onTouchEnd: function() {
				if (!this._moved || !this._zooming) {
					this._zooming = false;
					return;
				}
				this._zooming = false;
				cancelAnimFrame(this._animRequest);
				off(document, "touchmove", this._onTouchMove, this);
				off(document, "touchend touchcancel", this._onTouchEnd, this);
				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));
			}
		});
		Map.addInitHook("addHandler", "touchZoom", TouchZoom);
		Map.BoxZoom = BoxZoom;
		Map.DoubleClickZoom = DoubleClickZoom;
		Map.Drag = Drag;
		Map.Keyboard = Keyboard;
		Map.ScrollWheelZoom = ScrollWheelZoom;
		Map.TapHold = TapHold;
		Map.TouchZoom = TouchZoom;
		exports$1.Bounds = Bounds;
		exports$1.Browser = Browser;
		exports$1.CRS = CRS;
		exports$1.Canvas = Canvas;
		exports$1.Circle = Circle;
		exports$1.CircleMarker = CircleMarker;
		exports$1.Class = Class;
		exports$1.Control = Control;
		exports$1.DivIcon = DivIcon;
		exports$1.DivOverlay = DivOverlay;
		exports$1.DomEvent = DomEvent;
		exports$1.DomUtil = DomUtil;
		exports$1.Draggable = Draggable;
		exports$1.Evented = Evented;
		exports$1.FeatureGroup = FeatureGroup;
		exports$1.GeoJSON = GeoJSON;
		exports$1.GridLayer = GridLayer;
		exports$1.Handler = Handler;
		exports$1.Icon = Icon;
		exports$1.ImageOverlay = ImageOverlay;
		exports$1.LatLng = LatLng;
		exports$1.LatLngBounds = LatLngBounds;
		exports$1.Layer = Layer;
		exports$1.LayerGroup = LayerGroup;
		exports$1.LineUtil = LineUtil;
		exports$1.Map = Map;
		exports$1.Marker = Marker;
		exports$1.Mixin = Mixin;
		exports$1.Path = Path;
		exports$1.Point = Point;
		exports$1.PolyUtil = PolyUtil;
		exports$1.Polygon = Polygon;
		exports$1.Polyline = Polyline;
		exports$1.Popup = Popup;
		exports$1.PosAnimation = PosAnimation;
		exports$1.Projection = index;
		exports$1.Rectangle = Rectangle;
		exports$1.Renderer = Renderer;
		exports$1.SVG = SVG;
		exports$1.SVGOverlay = SVGOverlay;
		exports$1.TileLayer = TileLayer;
		exports$1.Tooltip = Tooltip;
		exports$1.Transformation = Transformation;
		exports$1.Util = Util;
		exports$1.VideoOverlay = VideoOverlay;
		exports$1.bind = bind;
		exports$1.bounds = toBounds;
		exports$1.canvas = canvas;
		exports$1.circle = circle;
		exports$1.circleMarker = circleMarker;
		exports$1.control = control;
		exports$1.divIcon = divIcon;
		exports$1.extend = extend;
		exports$1.featureGroup = featureGroup;
		exports$1.geoJSON = geoJSON;
		exports$1.geoJson = geoJson;
		exports$1.gridLayer = gridLayer;
		exports$1.icon = icon;
		exports$1.imageOverlay = imageOverlay;
		exports$1.latLng = toLatLng;
		exports$1.latLngBounds = toLatLngBounds;
		exports$1.layerGroup = layerGroup;
		exports$1.map = createMap;
		exports$1.marker = marker;
		exports$1.point = toPoint;
		exports$1.polygon = polygon;
		exports$1.polyline = polyline;
		exports$1.popup = popup;
		exports$1.rectangle = rectangle;
		exports$1.setOptions = setOptions;
		exports$1.stamp = stamp;
		exports$1.svg = svg;
		exports$1.svgOverlay = svgOverlay;
		exports$1.tileLayer = tileLayer;
		exports$1.tooltip = tooltip;
		exports$1.transformation = toTransformation;
		exports$1.version = version;
		exports$1.videoOverlay = videoOverlay;
		var oldL = window.L;
		exports$1.noConflict = function() {
			window.L = oldL;
			return this;
		};
		window.L = exports$1;
	}));
}));
//#endregion
export default require_leaflet_src();

//# sourceMappingURL=leaflet.js.map