https://www.conlins.com/js/libs/leaflet/leaflet-src.js

34		}
35	}
36	return dest;
37}
38
39// @function create(proto: Object, properties?: Object): Object
40// Compatibility polyfill for [Object.create](https://developer.mozilla.org/docs/Web/JavaScript/Reference/Global_Objects/Object/create)
41var create = Object.create || (function () {
42	function F() {}
43	return function (proto) {
44		F.prototype = proto;
45		return new F();
46	};
47})();
48
49// @function bind(fn: Function, …): Function
50// Returns a new function bound to the arguments passed, like [Function.prototype.bind](https://developer.mozilla.org/docs/Web/JavaScript/Reference/Global_Objects/Function/bind).
51// Has a `L.bind()` shortcut.
52function bind(fn, obj) {
53	var slice = Array.prototype.slice;
54
55	if (fn.bind) {
56		return fn.bind.apply(fn, slice.call(arguments, 1));
57	}
58
59	var args = slice.call(arguments, 2);
60
61	return function () {
62		return fn.apply(obj, args.length ? args.concat(slice.call(arguments)) : arguments);
63	};
64}
65
66// @property lastId: Number
67// Last unique ID used by [`stamp()`](#util-stamp)
68var lastId = 0;
69
70// @function stamp(obj: Object): Number
71// Returns the unique ID of an object, assigning it one if it doesn't have it.
72function stamp(obj) {
73	/*eslint-disable */
74	obj._leaflet_id = obj._leaflet_id || ++lastId;
75	return obj._leaflet_id;
76	/* eslint-enable */
77}
78
79// @function throttle(fn: Function, time: Number, context: Object): Function
80// Returns a function which executes function `fn` with the given scope `context`
81// (so that the `this` keyword refers to `context` inside `fn`'s code). The function
82// `fn` will be called no more than one time per given amount of `time`. The arguments
83// received by the bound function will be any arguments passed when binding the
84// function, followed by any arguments passed when invoking the bound function.
85// Has an `L.throttle` shortcut.
86function throttle(fn, time, context) {
87	var lock, args, wrapperFn, later;
88
89	later = function () {
90		// reset lock and call if queued
91		lock = false;
92		if (args) {
93			wrapperFn.apply(context, args);
94			args = false;
95		}
96	};
97
98	wrapperFn = function () {
99		if (lock) {
100			// called too soon, queue to call later
101			args = arguments;
102
103		} else {
104			// call and lock until later
105			fn.apply(context, arguments);
106			setTimeout(later, time);
107			lock = true;
108		}
109	};
110
111	return wrapperFn;
112}
113
114// @function wrapNum(num: Number, range: Number[], includeMax?: Boolean): Number
115// Returns the number `num` modulo `range` in such a way so it lies within
116// `range[0]` and `range[1]`. The returned value will be always smaller than
117// `range[1]` unless `includeMax` is set to `true`.
118function wrapNum(x, range, includeMax) {
119	var max = range[1],
120	    min = range[0],
121	    d = max - min;
122	return x === max && includeMax ? x : ((x - min) % d + d) % d + min;
123}
124
125// @function falseFn(): Function
126// Returns a function which always returns `false`.
127function falseFn() { return false; }
128
129// @function formatNum(num: Number, digits?: Number): Number
130// Returns the number `num` rounded to `digits` decimals, or to 6 decimals by default.
131function formatNum(num, digits) {
132	var pow = Math.pow(10, (digits === undefined ? 6 : digits));
133	return Math.round(num * pow) / pow;
134}
135
136// @function trim(str: String): String
137// Compatibility polyfill for [String.prototype.trim](https://developer.mozilla.org/docs/Web/JavaScript/Reference/Global_Objects/String/Trim)
138function trim(str) {
139	return str.trim ? str.trim() : str.replace(/^\s+|\s+$/g, '');
140}
141
142// @function splitWords(str: String): String[]
143// Trims and splits the string on whitespace and returns the array of parts.
144function splitWords(str) {
145	return trim(str).split(/\s+/);
146}
147
148// @function setOptions(obj: Object, options: Object): Object
149// Merges the given properties to the `options` of the `obj` object, returning the resulting options. See `Class options`. Has an `L.setOptions` shortcut.
150function setOptions(obj, options) {
151	if (!obj.hasOwnProperty('options')) {
152		obj.options = obj.options ? create(obj.options) : {};
153	}
154	for (var i in options) {
155		obj.options[i] = options[i];
156	}
157	return obj.options;
158}
159
160// @function getParamString(obj: Object, existingUrl?: String, uppercase?: Boolean): String
161// Converts an object into a parameter URL string, e.g. `{a: "foo", b: "bar"}`
162// translates to `'?a=foo&b=bar'`. If `existingUrl` is set, the parameters will
163// be appended at the end. If `uppercase` is `true`, the parameter names will
164// be uppercased (e.g. `'?A=foo&B=bar'`)
165function getParamString(obj, existingUrl, uppercase) {
166	var params = [];
167	for (var i in obj) {
168		params.push(encodeURIComponent(uppercase ? i.toUpperCase() : i) + '=' + encodeURIComponent(obj[i]));
169	}
170	return ((!existingUrl || existingUrl.indexOf('?') === -1) ? '?' : '&') + params.join('&');
171}
172
173var templateRe = /\{ *([\w_-]+) *\}/g;
174
175// @function template(str: String, data: Object): String
176// Simple templating facility, accepts a template string of the form `'Hello {a}, {b}'`
177// and a data object like `{a: 'foo', b: 'bar'}`, returns evaluated string
178// `('Hello foo, bar')`. You can also specify functions instead of strings for
179// data values — they will be evaluated passing `data` as an argument.
180function template(str, data) {
181	return str.replace(templateRe, function (str, key) {
182		var value = data[key];
183
184		if (value === undefined) {
185			throw new Error('No value provided for variable ' + str);
186
187		} else if (typeof value === 'function') {
188			value = value(data);
189		}
190		return value;
191	});
192}
193
194// @function isArray(obj): Boolean
195// Compatibility polyfill for [Array.isArray](https://developer.mozilla.org/docs/Web/JavaScript/Reference/Global_Objects/Array/isArray)
196var isArray = Array.isArray || function (obj) {
197	return (Object.prototype.toString.call(obj) === '[object Array]');
198};
199
200// @function indexOf(array: Array, el: Object): Number
201// Compatibility polyfill for [Array.prototype.indexOf](https://developer.mozilla.org/docs/Web/JavaScript/Reference/Global_Objects/Array/indexOf)
202function indexOf(array, el) {
203	for (var i = 0; i < array.length; i++) {
204		if (array[i] === el) { return i; }
205	}
206	return -1;
207}
208
209// @property emptyImageUrl: String
210// Data URI string containing a base64-encoded empty GIF image.
211// Used as a hack to free memory from unused images on WebKit-powered
212// mobile devices (by setting image `src` to this string).
213var emptyImageUrl = 'data:image/gif;base64,R0lGODlhAQABAAD/ACwAAAAAAQABAAACADs=';
214
215// inspired by http://paulirish.com/2011/requestanimationframe-for-smart-animating/
216
217function getPrefixed(name) {
218	return window['webkit' + name] || window['moz' + name] || window['ms' + name];
219}
220
221var lastTime = 0;
222
223// fallback for IE 7-8
224function timeoutDefer(fn) {
225	var time = +new Date(),
226	    timeToCall = Math.max(0, 16 - (time - lastTime));
227
228	lastTime = time + timeToCall;
229	return window.setTimeout(fn, timeToCall);
230}
231
232var requestFn = window.requestAnimationFrame || getPrefixed('RequestAnimationFrame') || timeoutDefer;
233var cancelFn = window.cancelAnimationFrame || getPrefixed('CancelAnimationFrame') ||
234		getPrefixed('CancelRequestAnimationFrame') || function (id) { window.clearTimeout(id); };
235

665	_propagateEvent: function (e) {
666		for (var id in this._eventParents) {
667			this._eventParents[id].fire(e.type, extend({
668				layer: e.target,
669				propagatedFrom: e.target
670			}, e), true);
671		}
672	}
673};
674
675// aliases; we should ditch those eventually
676
677// @method addEventListener(…): this
678// Alias to [`on(…)`](#evented-on)
679Events.addEventListener = Events.on;
680
681// @method removeEventListener(…): this
682// Alias to [`off(…)`](#evented-off)
683
684// @method clearAllEventListeners(…): this
685// Alias to [`off()`](#evented-off)
686Events.removeEventListener = Events.clearAllEventListeners = Events.off;
687
688// @method addOneTimeEventListener(…): this
689// Alias to [`once(…)`](#evented-once)
690Events.addOneTimeEventListener = Events.once;
691
692// @method fireEvent(…): this
693// Alias to [`fire(…)`](#evented-fire)
694Events.fireEvent = Events.fire;
695
696// @method hasEventListeners(…): Boolean
697// Alias to [`listens(…)`](#evented-listens)
698Events.hasEventListeners = Events.listens;
699
700var Evented = Class.extend(Events);
701
702/*
703 * @class Point
704 * @aka L.Point
705 *
706 * Represents a point with `x` and `y` coordinates in pixels.
707 *
708 * @example
709 *
710 * ```js
711 * var point = L.point(200, 300);
712 * ```
713 *
714 * All Leaflet methods and options that accept `Point` objects also accept them in a simple Array form (unless noted otherwise), so these lines are equivalent:
715 *
716 * ```js
717 * map.panBy([200, 300]);
718 * map.panBy(L.point(200, 300));
719 * ```
720 *
721 * Note that `Point` does not inherit from Leafet's `Class` object,
722 * which means new classes can't inherit from it, and new methods
723 * can't be added to it with the `include` function.
724 */
725
726function Point(x, y, round) {
727	// @property x: Number; The `x` coordinate of the point
728	this.x = (round ? Math.round(x) : x);
729	// @property y: Number; The `y` coordinate of the point
730	this.y = (round ? Math.round(y) : y);
731}
732
733var trunc = Math.trunc || function (v) {
734	return v > 0 ? Math.floor(v) : Math.ceil(v);
735};
736
737Point.prototype = {
738
739	// @method clone(): Point
740	// Returns a copy of the current point.
741	clone: function () {
742		return new Point(this.x, this.y);
743	},
744
745	// @method add(otherPoint: Point): Point
746	// Returns the result of addition of the current and the given points.
747	add: function (point) {
748		// non-destructive, returns a new point
749		return this.clone()._add(toPoint(point));
750	},
751
752	_add: function (point) {
753		// destructive, used directly for performance in situations where it's safe to modify existing point
754		this.x += point.x;
755		this.y += point.y;
756		return this;
757	},
758
759	// @method subtract(otherPoint: Point): Point
760	// Returns the result of subtraction of the given point from the current.
761	subtract: function (point) {
762		return this.clone()._subtract(toPoint(point));
763	},
764
765	_subtract: function (point) {
766		this.x -= point.x;
767		this.y -= point.y;
768		return this;
769	},
770
771	// @method divideBy(num: Number): Point
772	// Returns the result of division of the current point by the given number.
773	divideBy: function (num) {
774		return this.clone()._divideBy(num);
775	},
776
777	_divideBy: function (num) {
778		this.x /= num;
779		this.y /= num;
780		return this;
781	},
782
783	// @method multiplyBy(num: Number): Point
784	// Returns the result of multiplication of the current point by the given number.
785	multiplyBy: function (num) {
786		return this.clone()._multiplyBy(num);
787	},
788
789	_multiplyBy: function (num) {
790		this.x *= num;
791		this.y *= num;
792		return this;
793	},
794
795	// @method scaleBy(scale: Point): Point
796	// Multiply each coordinate of the current point by each coordinate of
797	// `scale`. In linear algebra terms, multiply the point by the
798	// [scaling matrix](https://en.wikipedia.org/wiki/Scaling_%28geometry%29#Matrix_representation)
799	// defined by `scale`.
800	scaleBy: function (point) {
801		return new Point(this.x * point.x, this.y * point.y);
802	},
803
804	// @method unscaleBy(scale: Point): Point
805	// Inverse of `scaleBy`. Divide each coordinate of the current point by
806	// each coordinate of `scale`.
807	unscaleBy: function (point) {
808		return new Point(this.x / point.x, this.y / point.y);
809	},
810
811	// @method round(): Point
812	// Returns a copy of the current point with rounded coordinates.
813	round: function () {
814		return this.clone()._round();
815	},
816
817	_round: function () {
818		this.x = Math.round(this.x);
819		this.y = Math.round(this.y);
820		return this;
821	},
822
823	// @method floor(): Point
824	// Returns a copy of the current point with floored coordinates (rounded down).
825	floor: function () {
826		return this.clone()._floor();
827	},
828
829	_floor: function () {
830		this.x = Math.floor(this.x);
831		this.y = Math.floor(this.y);
832		return this;
833	},
834
835	// @method ceil(): Point
836	// Returns a copy of the current point with ceiled coordinates (rounded up).
837	ceil: function () {
838		return this.clone()._ceil();
839	},
840
841	_ceil: function () {
842		this.x = Math.ceil(this.x);
843		this.y = Math.ceil(this.y);
844		return this;
845	},
846
847	// @method trunc(): Point
848	// Returns a copy of the current point with truncated coordinates (rounded towards zero).
849	trunc: function () {
850		return this.clone()._trunc();
851	},
852
853	_trunc: function () {
854		this.x = trunc(this.x);
855		this.y = trunc(this.y);
856		return this;
857	},
858
859	// @method distanceTo(otherPoint: Point): Number
860	// Returns the cartesian distance between the current and the given points.
861	distanceTo: function (point) {
862		point = toPoint(point);
863
864		var x = point.x - this.x,
865		    y = point.y - this.y;
866
867		return Math.sqrt(x * x + y * y);
868	},
869
870	// @method equals(otherPoint: Point): Boolean
871	// Returns `true` if the given point has the same coordinates.
872	equals: function (point) {
873		point = toPoint(point);
874
875		return point.x === this.x &&
876		       point.y === this.y;
877	},
878
879	// @method contains(otherPoint: Point): Boolean
880	// Returns `true` if both coordinates of the given point are less than the corresponding current point coordinates (in absolute values).
881	contains: function (point) {
882		point = toPoint(point);
883
884		return Math.abs(point.x) <= Math.abs(this.x) &&
885		       Math.abs(point.y) <= Math.abs(this.y);
886	},
887
888	// @method toString(): String
889	// Returns a string representation of the point for debugging purposes.
890	toString: function () {
891		return 'Point(' +
892		        formatNum(this.x) + ', ' +
893		        formatNum(this.y) + ')';
894	}
895};
896
897// @factory L.point(x: Number, y: Number, round?: Boolean)
898// Creates a Point object with the given `x` and `y` coordinates. If optional `round` is set to true, rounds the `x` and `y` values.
899
900// @alternative
901// @factory L.point(coords: Number[])
902// Expects an array of the form `[x, y]` instead.
903
904// @alternative
905// @factory L.point(coords: Object)
906// Expects a plain object of the form `{x: Number, y: Number}` instead.
907function toPoint(x, y, round) {
908	if (x instanceof Point) {
909		return x;
910	}
911	if (isArray(x)) {
912		return new Point(x[0], x[1]);
913	}
914	if (x === undefined || x === null) {
915		return x;
916	}
917	if (typeof x === 'object' && 'x' in x && 'y' in x) {
918		return new Point(x.x, x.y);
919	}
920	return new Point(x, y, round);
921}
922
923/*
924 * @class Bounds
925 * @aka L.Bounds
926 *
927 * Represents a rectangular area in pixel coordinates.
928 *
929 * @example
930 *
931 * ```js
932 * var p1 = L.point(10, 10),
933 * p2 = L.point(40, 60),
934 * bounds = L.bounds(p1, p2);
935 * ```
936 *
937 * All Leaflet methods that accept `Bounds` objects also accept them in a simple Array form (unless noted otherwise), so the bounds example above can be passed like this:
938 *
939 * ```js
940 * otherBounds.intersects([[10, 10], [40, 60]]);
941 * ```
942 *
943 * Note that `Bounds` does not inherit from Leafet's `Class` object,
944 * which means new classes can't inherit from it, and new methods
945 * can't be added to it with the `include` function.
946 */
947
948function Bounds(a, b) {
949	if (!a) { return; }
950
951	var points = b ? [a, b] : a;
952
953	for (var i = 0, len = points.length; i < len; i++) {
954		this.extend(points[i]);
955	}
956}
957
958Bounds.prototype = {
959	// @method extend(point: Point): this
960	// Extends the bounds to contain the given point.
961	extend: function (point) { // (Point)
962		point = toPoint(point);
963
964		// @property min: Point
965		// The top left corner of the rectangle.
966		// @property max: Point
967		// The bottom right corner of the rectangle.
968		if (!this.min && !this.max) {
969			this.min = point.clone();
970			this.max = point.clone();
971		} else {
972			this.min.x = Math.min(point.x, this.min.x);
973			this.max.x = Math.max(point.x, this.max.x);
974			this.min.y = Math.min(point.y, this.min.y);
975			this.max.y = Math.max(point.y, this.max.y);
976		}
977		return this;
978	},
979
980	// @method getCenter(round?: Boolean): Point
981	// Returns the center point of the bounds.
982	getCenter: function (round) {
983		return new Point(
984		        (this.min.x + this.max.x) / 2,
985		        (this.min.y + this.max.y) / 2, round);
986	},
987
988	// @method getBottomLeft(): Point
989	// Returns the bottom-left point of the bounds.
990	getBottomLeft: function () {
991		return new Point(this.min.x, this.max.y);
992	},
993
994	// @method getTopRight(): Point
995	// Returns the top-right point of the bounds.
996	getTopRight: function () { // -> Point
997		return new Point(this.max.x, this.min.y);
998	},
999
1000	// @method getTopLeft(): Point
1001	// Returns the top-left point of the bounds (i.e. [`this.min`](#bounds-min)).
1002	getTopLeft: function () {
1003		return this.min; // left, top
1004	},
1005
1006	// @method getBottomRight(): Point
1007	// Returns the bottom-right point of the bounds (i.e. [`this.max`](#bounds-max)).
1008	getBottomRight: function () {
1009		return this.max; // right, bottom
1010	},
1011
1012	// @method getSize(): Point
1013	// Returns the size of the given bounds
1014	getSize: function () {
1015		return this.max.subtract(this.min);
1016	},
1017
1018	// @method contains(otherBounds: Bounds): Boolean
1019	// Returns `true` if the rectangle contains the given one.
1020	// @alternative
1021	// @method contains(point: Point): Boolean
1022	// Returns `true` if the rectangle contains the given point.
1023	contains: function (obj) {
1024		var min, max;
1025
1026		if (typeof obj[0] === 'number' || obj instanceof Point) {
1027			obj = toPoint(obj);
1028		} else {
1029			obj = toBounds(obj);
1030		}
1031
1032		if (obj instanceof Bounds) {
1033			min = obj.min;
1034			max = obj.max;
1035		} else {
1036			min = max = obj;
1037		}
1038
1039		return (min.x >= this.min.x) &&
1040		       (max.x <= this.max.x) &&
1041		       (min.y >= this.min.y) &&
1042		       (max.y <= this.max.y);
1043	},
1044
1045	// @method intersects(otherBounds: Bounds): Boolean
1046	// Returns `true` if the rectangle intersects the given bounds. Two bounds
1047	// intersect if they have at least one point in common.
1048	intersects: function (bounds) { // (Bounds) -> Boolean
1049		bounds = toBounds(bounds);
1050
1051		var min = this.min,
1052		    max = this.max,
1053		    min2 = bounds.min,
1054		    max2 = bounds.max,
1055		    xIntersects = (max2.x >= min.x) && (min2.x <= max.x),
1056		    yIntersects = (max2.y >= min.y) && (min2.y <= max.y);
1057
1058		return xIntersects && yIntersects;
1059	},
1060
1061	// @method overlaps(otherBounds: Bounds): Boolean
1062	// Returns `true` if the rectangle overlaps the given bounds. Two bounds
1063	// overlap if their intersection is an area.
1064	overlaps: function (bounds) { // (Bounds) -> Boolean
1065		bounds = toBounds(bounds);
1066
1067		var min = this.min,
1068		    max = this.max,
1069		    min2 = bounds.min,
1070		    max2 = bounds.max,
1071		    xOverlaps = (max2.x > min.x) && (min2.x < max.x),
1072		    yOverlaps = (max2.y > min.y) && (min2.y < max.y);
1073
1074		return xOverlaps && yOverlaps;
1075	},
1076
1077	isValid: function () {
1078		return !!(this.min && this.max);
1079	}
1080};
1081
1082
1083// @factory L.bounds(corner1: Point, corner2: Point)
1084// Creates a Bounds object from two corners coordinate pairs.
1085// @alternative
1086// @factory L.bounds(points: Point[])
1087// Creates a Bounds object from the given array of points.
1088function toBounds(a, b) {
1089	if (!a || a instanceof Bounds) {
1090		return a;
1091	}
1092	return new Bounds(a, b);
1093}
1094
1095/*
1096 * @class LatLngBounds
1097 * @aka L.LatLngBounds
1098 *
1099 * Represents a rectangular geographical area on a map.
1100 *
1101 * @example
1102 *
1103 * ```js
1104 * var corner1 = L.latLng(40.712, -74.227),
1105 * corner2 = L.latLng(40.774, -74.125),
1106 * bounds = L.latLngBounds(corner1, corner2);
1107 * ```
1108 *
1109 * All Leaflet methods that accept LatLngBounds objects also accept them in a simple Array form (unless noted otherwise), so the bounds example above can be passed like this:
1110 *
1111 * ```js
1112 * map.fitBounds([
1113 * 	[40.712, -74.227],
1114 * 	[40.774, -74.125]
1115 * ]);
1116 * ```
1117 *
1118 * Caution: if the area crosses the antimeridian (often confused with the International Date Line), you must specify corners _outside_ the [-180, 180] degrees longitude range.
1119 *
1120 * Note that `LatLngBounds` does not inherit from Leaf

1120et's `Class` object,
1121 * which means new classes can't inherit from it, and new methods
1122 * can't be added to it with the `include` function.
1123 */
1124
1125function LatLngBounds(corner1, corner2) { // (LatLng, LatLng) or (LatLng[])
1126	if (!corner1) { return; }
1127
1128	var latlngs = corner2 ? [corner1, corner2] : corner1;
1129
1130	for (var i = 0, len = latlngs.length; i < len; i++) {
1131		this.extend(latlngs[i]);
1132	}
1133}
1134
1135LatLngBounds.prototype = {
1136
1137	// @method extend(latlng: LatLng): this
1138	// Extend the bounds to contain the given point
1139
1140	// @alternative
1141	// @method extend(otherBounds: LatLngBounds): this
1142	// Extend the bounds to contain the given bounds
1143	extend: function (obj) {
1144		var sw = this._southWest,
1145		    ne = this._northEast,
1146		    sw2, ne2;
1147
1148		if (obj instanceof LatLng) {
1149			sw2 = obj;
1150			ne2 = obj;
1151
1152		} else if (obj instanceof LatLngBounds) {
1153			sw2 = obj._southWest;
1154			ne2 = obj._northEast;
1155
1156			if (!sw2 || !ne2) { return this; }
1157
1158		} else {
1159			return obj ? this.extend(toLatLng(obj) || toLatLngBounds(obj)) : this;
1160		}
1161
1162		if (!sw && !ne) {
1163			this._southWest = new LatLng(sw2.lat, sw2.lng);
1164			this._northEast = new LatLng(ne2.lat, ne2.lng);
1165		} else {
1166			sw.lat = Math.min(sw2.lat, sw.lat);
1167			sw.lng = Math.min(sw2.lng, sw.lng);
1168			ne.lat = Math.max(ne2.lat, ne.lat);
1169			ne.lng = Math.max(ne2.lng, ne.lng);
1170		}
1171
1172		return this;
1173	},
1174
1175	// @method pad(bufferRatio: Number): LatLngBounds
1176	// Returns bounds created by extending or retracting the current bounds by a given ratio in each direction.
1177	// For example, a ratio of 0.5 extends the bounds by 50% in each direction.
1178	// Negative values will retract the bounds.
1179	pad: function (bufferRatio) {
1180		var sw = this._southWest,
1181		    ne = this._northEast,
1182		    heightBuffer = Math.abs(sw.lat - ne.lat) * bufferRatio,
1183		    widthBuffer = Math.abs(sw.lng - ne.lng) * bufferRatio;
1184
1185		return new LatLngBounds(
1186		        new LatLng(sw.lat - heightBuffer, sw.lng - widthBuffer),
1187		        new LatLng(ne.lat + heightBuffer, ne.lng + widthBuffer));
1188	},
1189
1190	// @method getCenter(): LatLng
1191	// Returns the center point of the bounds.
1192	getCenter: function () {
1193		return new LatLng(
1194		        (this._southWest.lat + this._northEast.lat) / 2,
1195		        (this._southWest.lng + this._northEast.lng) / 2);
1196	},
1197
1198	// @method getSouthWest(): LatLng
1199	// Returns the south-west point of the bounds.
1200	getSouthWest: function () {
1201		return this._southWest;
1202	},
1203
1204	// @method getNorthEast(): LatLng
1205	// Returns the north-east point of the bounds.
1206	getNorthEast: function () {
1207		return this._northEast;
1208	},
1209
1210	// @method getNorthWest(): LatLng
1211	// Returns the north-west point of the bounds.
1212	getNorthWest: function () {
1213		return new LatLng(this.getNorth(), this.getWest());
1214	},
1215
1216	// @method getSouthEast(): LatLng
1217	// Returns the south-east point of the bounds.
1218	getSouthEast: function () {
1219		return new LatLng(this.getSouth(), this.getEast());
1220	},
1221
1222	// @method getWest(): Number
1223	// Returns the west longitude of the bounds
1224	getWest: function () {
1225		return this._southWest.lng;
1226	},
1227
1228	// @method getSouth(): Number
1229	// Returns the south latitude of the bounds
1230	getSouth: function () {
1231		return this._southWest.lat;
1232	},
1233
1234	// @method getEast(): Number
1235	// Returns the east longitude of the bounds
1236	getEast: function () {
1237		return this._northEast.lng;
1238	},
1239
1240	// @method getNorth(): Number
1241	// Returns the north latitude of the bounds
1242	getNorth: function () {
1243		return this._northEast.lat;
1244	},
1245
1246	// @method contains(otherBounds: LatLngBounds): Boolean
1247	// Returns `true` if the rectangle contains the given one.
1248
1249	// @alternative
1250	// @method contains (latlng: LatLng): Boolean
1251	// Returns `true` if the rectangle contains the given point.
1252	contains: function (obj) { // (LatLngBounds) or (LatLng) -> Boolean
1253		if (typeof obj[0] === 'number' || obj instanceof LatLng || 'lat' in obj) {
1254			obj = toLatLng(obj);
1255		} else {
1256			obj = toLatLngBounds(obj);
1257		}
1258
1259		var sw = this._southWest,
1260		    ne = this._northEast,
1261		    sw2, ne2;
1262
1263		if (obj instanceof LatLngBounds) {
1264			sw2 = obj.getSouthWest();
1265			ne2 = obj.getNorthEast();
1266		} else {
1267			sw2 = ne2 = obj;
1268		}
1269
1270		return (sw2.lat >= sw.lat) && (ne2.lat <= ne.lat) &&
1271		       (sw2.lng >= sw.lng) && (ne2.lng <= ne.lng);
1272	},
1273
1274	// @method intersects(otherBounds: LatLngBounds): Boolean
1275	// Returns `true` if the rectangle intersects the given bounds. Two bounds intersect if they have at least one point in common.
1276	intersects: function (bounds) {
1277		bounds = toLatLngBounds(bounds);
1278
1279		var sw = this._southWest,
1280		    ne = this._northEast,
1281		    sw2 = bounds.getSouthWest(),
1282		    ne2 = bounds.getNorthEast(),
1283
1284		    latIntersects = (ne2.lat >= sw.lat) && (sw2.lat <= ne.lat),
1285		    lngIntersects = (ne2.lng >= sw.lng) && (sw2.lng <= ne.lng);
1286
1287		return latIntersects && lngIntersects;
1288	},
1289
1290	// @method overlaps(otherBounds: 

1297		    sw2 = bounds.getSouthWest(),
1298		    ne2 = bounds.getNorthEast(),
1299
1300		    latOverlaps = (ne2.lat > sw.lat) && (sw2.lat < ne.lat),
1301		    lngOverlaps = (ne2.lng > sw.lng) && (sw2.lng < ne.lng);
1302
1303		return latOverlaps && lngOverlaps;
1304	},
1305
1306	// @method toBBoxString(): String
1307	// Returns a string with bounding box coordinates in a 'southwest_lng,southwest_lat,northeast_lng,northeast_lat' format. Useful for sending requests to web services that return geo data.
1308	toBBoxString: function () {
1309		return [this.getWest(), this.getSouth(), this.getEast(), this.getNorth()].join(',');
1310	},
1311
1312	// @method equals(otherBounds: LatLngBounds, maxMargin?: Number): Boolean
1313	// Returns `true` if the rectangle is equivalent (within a small margin of error) to the given bounds. The margin of error can be overridden by setting `maxMargin` to a small number.
1314	equals: function (bounds, maxMargin) {
1315		if (!bounds) { return false; }
1316
1317		bounds = toLatLngBounds(bounds);
1318
1319		return this._southWest.equals(bounds.getSouthWest(), maxMargin) &&
1320		       this._northEast.equals(bounds.getNorthEast(), maxMargin);
1321	},
1322
1323	// @method isValid(): Boolean
1324	// Returns `true` if the bounds are properly initialized.
1325	isValid: function () {
1326		return !!(this._southWest && this._northEast);
1327	}
1328};
1329
1330// TODO International date line?
1331
1332// @factory L.latLngBounds(corner1: LatLng, corner2: LatLng)
1333// Creates a `LatLngBounds` object by defining two diagonally opposite corners of the rectangle.
1334
1335// @alternative
1336// @factory L.latLngBounds(latlngs: LatLng[])
1337// Creates a `LatLngBounds` object defined by the geographical points it contains. Very useful for zooming the map to fit a particular set of locations with [`fitBounds`](#map-fitbounds).
1338function toLatLngBounds(a, b) {
1339	if (a instanceof LatLngBounds) {
1340		return a;
1341	}
1342	return new LatLngBounds(a, b);
1343}
1344
1345/* @class LatLng
1346 * @aka L.LatLng
1347 *
1348 * Represents a geographical point with a certain latitude and longitude.
1349 *
1350 * @example
1351 *
1352 * ```
1353 * var latlng = L.latLng(50.5, 30.5);
1354 * ```
1355 *
1356 * All Leaflet methods that accept LatLng objects also accept them in a simple Array form and simple object form (unless noted otherwise), so these lines are equivalent:
1357 *
1358 * ```
1359 * map.panTo([50, 30]);
1360 * map.panTo({lon: 30, lat: 50});
1361 * map.panTo({lat: 50, lng: 30});
1362 * map.panTo(L.latLng(50, 30));
1363 * ```
1364 *
1365 * Note that `LatLng` does not inherit from Leaflet's `Class` object,
1366 * which means new classes can't inherit from it, and new methods
1367 * can't be added to it with the `include` function.
1368 */
1369
1370function LatLng(lat, lng, alt) {
1371	if (isNaN(lat) || isNaN(lng)) {
1372		throw new Error('Invalid LatLng object: (' + lat + ', ' + lng + ')');
1373	}
1374
1375	// @property lat: Number
1376	// Latitude in degrees
1377	this.lat = +lat;
1378
1379	// @property lng: Number
1380	// Longitude in degrees
1381	this.lng = +lng;
1382
1383	// @property alt: Number
1384	// Altitude in meters (optional)
1385	if (alt !== undefined) {
1386		this.alt = +alt;
1387	}
1388}
1389
1390LatLng.prototype = {
1391	// @method equals(otherLatLng: LatLng, maxMargin?: Number): Boolean
1392	// Returns `true` if the given `LatLng` point is at the same position (within a small margin of error). The margin of error can be overridden by setting `maxMargin` to a small number.
1393	equals: function (obj, maxMargin) {
1394		if (!obj) { return false; }
1395
1396		obj = toLatLng(obj);
1397
1398		var margin = Math.max(
1399		        Math.abs(this.lat - obj.lat),
1400		        Math.abs(this.lng - obj.lng));
1401
1402		return margin <= (maxMargin === undefined ? 1.0E-9 : maxMargin);
1403	},
1404
1405	// @method toString(): String
1406	// Returns a string representation of the point (for debugging purposes).
1407	toString: function (precision) {
1408		return 'LatLng(' +
1409		        formatNum(this.lat, precision) + ', ' +
1410		        formatNum(this.lng, precision) + ')';
1411	},
1412
1413	// @method distanceTo(otherLatLng: LatLng): Number
1414	// Returns the distance (in meters) to the given `LatLng` calculated using the [Spherical Law of Cosines](https://en.wikipedia.org/wiki/Spherical_law_of_cosines).
1415	distanceTo: function (other) {
1416		return Earth.distance(this, toLatLng(other));
1417	},
1418
1419	// @method wrap(): LatLng
1420	// Returns a new `LatLng` object with the longitude wrapped so it's always between -180 and +180 degrees.
1421	wrap: function () {
1422		return Earth.wrapLatLng(this);
1423	},
1424
1425	// @method toBounds(sizeInMeters: Number): LatLngBounds
1426	// Returns a new `LatLngBounds` object in which each boundary is `sizeInMeters/2` meters apart from the `LatLng`.
1427	toBounds: function (sizeInMeters) {
1428		var latAccuracy = 180 * sizeInMeters / 40075017,
1429		    lngAccuracy = latAccuracy / Math.cos((Math.PI / 180) * this.lat);
1430
1431		return toLatLngBounds(
1432		        [this.lat - latAccuracy, this.lng - lngAccuracy],
1433		        [this.lat + latAccuracy, this.lng + lngAccuracy]);
1434	},
1435
1436	clone: function () {
1437		return new LatLng(this.lat, this.lng, this.alt);
1438	}
1439};
1440
1441
1442
1443// @factory L.latLng(latitude: Number, longitude: Number, altitude?: Number): LatLng
1444// Creates an object representing a geographical point with the given latitude and longitude (and optionally altitude).
1445
1446// @alternative
1447// @factory L.latLng(coords: Array): LatLng
1448// Expects an array of the form `[Number, Number]` or `[Number, Number, Number]` instead.
1449
1450// @alternative
1451// @factory L.latLng(coords: Object): LatLng
1452// Expects an plain object of the form `{lat: Number, lng: Number}` or `{lat: Number, lng: Number, alt: Number}` instead.
1453
1454function toLatLng(a, b, c) {
1455	if (a instanceof LatLng) {
1456		return a;
1457	}
1458	if (isArray(a) && typeof a[0] !== 'object') {
1459		if (a.length === 3) {
1460			return new LatLng(a[0], a[1], a[2]);
1461		}
1462		if (a.length === 2) {
1463			return new LatLng(a[0], a[1]);
1464		}
1465		return null;
1466	}
1467	if (a === undefined || a === null) {
1468		return a;
1469	}
1470	if (typeof a === 'object' && 'lat' in a) {
1471		return new LatLng(a.lat, 'lng' in a ? a.lng : a.lon, a.alt);
1472	}
1473	if (b === undefined) {
1474		return null;
1475	}
1476	return new LatLng(a, b, c);
1477}
1478
1479/*
1480 * @namespace CRS
1481 * @crs L.CRS.Base
1482 * Object that defines coordinate reference systems for projecting
1483 * geographical points into pixel (screen) coordinates and back (and to

1604		var sw = bounds.getSouthWest(),
1605		    ne = bounds.getNorthEast(),
1606		    newSw = new LatLng(sw.lat - latShift, sw.lng - lngShift),
1607		    newNe = new LatLng(ne.lat - latShift, ne.lng - lngShift);
1608
1609		return new LatLngBounds(newSw, newNe);
1610	}
1611};
1612
1613/*
1614 * @namespace CRS
1615 * @crs L.CRS.Earth
1616 *
1617 * Serves as the base for CRS that are global such that they cover the earth.
1618 * Can only be used as the base for other CRS and cannot be used directly,
1619 * since it does not have a `code`, `projection` or `transformation`. `distance()` returns
1620 * meters.
1621 */
1622
1623var Earth = extend({}, CRS, {
1624	wrapLng: [-180, 180],
1625
1626	// Mean Earth Radius, as recommended for use by
1627	// the International Union of Geodesy and Geophysics,
1628	// see http://rosettacode.org/wiki/Haversine_formula
1629	R: 6371000,
1630
1631	// distance between two geographical points using spherical law of cosines approximation
1632	distance: function (latlng1, latlng2) {
1633		var rad = Math.PI / 180,
1634		    lat1 = latlng1.lat * rad,
1635		    lat2 = latlng2.lat * rad,
1636		    sinDLat = Math.sin((latlng2.lat - latlng1.lat) * rad / 2),
1637		    sinDLon = Math.sin((latlng2.lng - latlng1.lng) * rad / 2),
1638		    a = sinDLat * sinDLat + Math.cos(lat1) * Math.cos(lat2) * sinDLon * sinDLon,
1639		    c = 2 * Math.atan2(Math.sqrt(a), Math.sqrt(1 - a));
1640		return this.R * c;
1641	}
1642});
1643
1644/*
1645 * @namespace Projection
1646 * @projection L.Projection.SphericalMercator
1647 *
1648 * Spherical Mercator projection — the most common projection for online maps,
1649 * used by almost all free and commercial tile providers. Assumes that Earth is
1650 * a sphere. Used by the `EPSG:3857` CRS.
1651 */
1652
1653var SphericalMercator = {
1654
1655	R: 6378137,
1656	MAX_LATITUDE: 85.0511287798,
1657
1658	project: function (latlng) {
1659		var d = Math.PI / 180,
1660		    max = this.MAX_LATITUDE,
1661		    lat = Math.max(Math.min(max, latlng.lat), -max),
1662		    sin = Math.sin(lat * d);
1663
1664		return new Point(
1665			this.R * latlng.lng * d,
1666			this.R * Math.log((1 + sin) / (1 - sin)) / 2);
1667	},
1668
1669	unproject: function (point) {
1670		var d = 180 / Math.PI;
1671
1672		return new LatLng(
1673			(2 * Math.atan(Math.exp(point.y / this.R)) - (Math.PI / 2)) * d,
1674			point.x * d / this.R);
1675	},
1676
1677	bounds: (function () {
1678		var d = 6378137 * Math.PI;
1679		return new Bounds([-d, -d], [d, d]);
1680	})()
1681};
1682
1683/*
1684 * @class Transformation
1685 * @aka L.Transformation
1686 *
1687 * Represents an affine transformation: a set of coefficients `a`, `b`, `c`, `d`
1688 * for transforming a point of a form `(x, y)` into `(a*x + b, c*y + d)` and doing
1689 * the reverse. Used by Leaflet in its projections code.
1690 *
1691 * @example
1692 *
1693 * ```js
1694 * var transformation = L.transformation(2, 5, -1, 10),
1695 * 	p = L.point(1, 2),
1696 * 	p2 = transformation.transform(p), //  L.point(7, 8)
1697 * 	p3 = transformation.untransform(p2); //  L.point(1, 2)
1698 * ```
1699 */
1700
1701
1702// factory new L.Transformation(a: Number, b: Number, c: Number, d: Number)
1703// Creates a `Transformation` object with the given coefficients.
1704function Transformation(a, b, c, d) {
1705	if (isArray(a)) {
1706		// use array properties
1707		this._a = a[0];
1708		this._b = a[1];
1709		this._c = a[2];
1710		this._d = a[3];
1711		return;
1712	}
1713	this._a = a;
1714	this._b = b;
1715	this._c = c;
1716	this._d = d;
1717}
1718
1719Transformation.prototype = {
1720	// @method transform(point: Point, scale?: Number): Point
1721	// Returns a transformed point, optionally multiplied by the given scale.
1722	// Only accepts actual `L.Point` instances, not arrays.
1723	transform: function (point, scale) { // (Point, Number) -> Point
1724		return this._transform(point.clone(), scale);
1725	},
1726
1727	// destructive transform (faster)
1728	_transform: function (point, scale) {
1729		scale = scale || 1;
1730		point.x = scale * (this._a * point.x + this._b);
1731		point.y = scale * (this._c * point.y + this._d);
1732		return point;
1733	},
1734
1735	// @method untransform(point: Point, scale?: Number): Point
1736	// Returns the reverse transformation of the given point, optionally divided
1737	// by the given scale. Only accepts actual `L.Point` instances, not arrays.
1738	untransform: function (point, scale) {
1739		scale = scale || 1;
1740		return new Point(
1741		        (point.x / scale - this._b) / this._a,
1742		        (point.y / scale - this._d) / this._c);
1743	}
1744};
1745
1746// factory L.transformation(a: Number, b: Number, c: Number, d: Number)
1747
1748// @factory L.transformation(a: Number, b: Number, c: Number, d: Number)
1749// Instantiates a Transformation object with the given coefficients.
1750
1751// @alternative
1752// @factory L.transformation(coefficients: Array): Transformation
1753// Expects an coefficients array of the form
1754// `[a: Number, b: Number, c: Number, d: Number]`.
1755
1756function toTransformation(a, b, c, d) {
1757	return new Transformation(a, b, c, d);
1758}
1759
1760/*
1761 * @namespace CRS
1762 * @crs L.CRS.EPSG3857
1763 *
1764 * The most common CRS for online maps, used by almost all free and commercial
1765 * tile providers. Uses Spherical Mercator projection. Set in by default in
1766 * Map's `crs` option.
1767 */
1768
1769var EPSG3857 = extend({}, Earth, {
1770	code: 'EPSG:3857',
1771	projection: SphericalMercator,
1772
1773	transformation: (function () {
1774		var scale = 0.5 / (Math.PI * SphericalMercator.R);
1775		return toTransformation(scale, 0.5, -scale, 0.5);
1776	}())
1777});
1778
1779var EPSG900913 = extend({}, EPSG3857, {
1780	code: 'EPSG:900913'
1781});
1782
1783// @namespace SVG; @section
1784// There are several static functions which can be called without instantiating L.SVG:
1785
1786// @function create(name: String): SVGElement
1787// Returns a instance of [SVGElement](https://developer.mozilla.org/docs/Web/API/SVGElement),
1788// corresponding to the class name passed. For example, using 'line' will return
1789// an instance of [SVGLineElement](https://developer.mozilla.org/docs/Web/API/SVGLineElement).
1790function svgCreate(name) {
1791	return document.createElementNS('http://www.w3.org/2000/svg', name);
1792}
1793
1794// @function pointsToPath(rings: Point[], closed: Boolean): String
1795// Generates a SVG path string for multiple rings, with each ring turning
1796// into "M..L..L.." instructions
1797function pointsToPath(rings, closed) {
1798	var str = '',
1799	i, j, len, len2, points, p;
1800
1801	for (i = 0, len = rings.length; i < len; i++) {
1802		points = rings[i];
1803
1804		for (j = 0, len2 = points.length; j < len2; j++) {
1805			p = points[j];
1806			str += (j ? 'L' : 'M') + p.x + ' ' + p.y;
1807		}
1808
1809		// closes the ring for polygons; "x" is VML syntax
1810		str += closed ? (svg ? 'z' : 'x') : '';
1811	}
1812
1813	// SVG complains about empty path strings
1814	return str || 'M0 0';
1815}
1816
1817/*
1818 * @namespace Browser
1819 * @aka L.Browser
1820 *
1821 * A namespace with static properties for browser/feature detection used by Leaflet internally.
1822 *
1823 * @example
1824 *
1825 * ```js
1826 * if (L.Browser.ielt9) {
1827 *   alert('Upgrade your browser, dude!');
1828 * }
1829 * ```
1830 */
1831
1832var style$1 = document.documentElement.style;
1833
1834// @property ie: Boolean; `true` for all Internet Explorer versions (not Edge).
1835var ie = 'ActiveXObject' in window;
1836
1837// @property ielt9: Boolean; `true` for Internet Explorer versions less than 9.
1838var ielt9 = ie && !document.addEventListener;
1839
1840// @property edge: Boolean; `true` for the Edge web browser.
1841var edge = 'msLaunchUri' in navigator && !('documentMode' in document);
1842
1843// @property webkit: Boolean;
1844// `true` for webkit-based browsers like Chrome and Safari (including mobile versions).
1845var webkit = userAgentContains('webkit');
1846
1847// @property android: Boolean
1848// `true` for any browser running on an Android platform.
1849var android = userAgentContains('android');
1850
1851// @property android23: Boolean; `true` for browsers running on Android 2 or Android 3.
1852var android23 = userAgentContains('android 2') || userAgentContains('android 3');
1853
1854/* See https://stackoverflow.com/a/17961266 for details on detecting stock Android */
1855var webkitVer = parseInt(/WebKit\/([0-9]+)|$/.exec(navigator.userAgent)[1], 10); // also matches AppleWebKit
1856// @property androidStock: Boolean; `true` for the Android stock browser (i.e. not Chrome)
1857var androidStock = android && userAgentContains('Google') && webkitVer < 537 && !('AudioNode' in window);
1858
1859// @property opera: Boolean; `true` for the Opera browser
1860var opera = !!window.opera;
1861
1862// @property chrome: Boolean; `true` for the Chrome browser.
1863var chrome = userAgentContains('chrome');
1864
1865// @property gecko: Boolean; `true` for gecko-based browsers like Firefox.
1866var gecko = userAgentContains('gecko') && !webkit && !opera && !ie;
1867
1868// @property safari: Boolean; `true` for the Safari browser.
1869var safari = !chrome && userAgentContains('safari');
1870
1871var phantom = userAgentContains('phantom');
1872
1873// @property opera12: Boolean
1874// `true` for the Opera browser supporting CSS transforms (version 12 or later).
1875var opera12 = 'OTransition' in style$1;
1876
1877// @property win: Boolean; `true` when the browser is running in a Windows platform
1878var win = navigator.platform.indexOf('Win') === 0;
1879
1880// @property ie3d: Boolean;

2430// using CSS translate or top/left positioning depending on the browser
2431// (used by Leaflet internally to position its layers).
2432function setPosition(el, point) {
2433
2434	/*eslint-disable */
2435	el._leaflet_pos = point;
2436	/* eslint-enable */
2437
2438	if (any3d) {
2439		setTransform(el, point);
2440	} else {
2441		el.style.left = point.x + 'px';
2442		el.style.top = point.y + 'px';
2443	}
2444}
2445
2446// @function getPosition(el: HTMLElement): Point
2447// Returns the coordinates of an element previously positioned with setPosition.
2448function getPosition(el) {
2449	// this method is only used for elements previously positioned using setPosition,
2450	// so it's safe to cache the position for performance
2451
2452	return el._leaflet_pos || new Point(0, 0);
2453}
2454
2455// @function disableTextSelection()
2456// Prevents the user from generating `selectstart` DOM events, usually generated
2457// when the user drags the mouse through a page with text. Used internally
2458// by Leaflet to override the behaviour of any click-and-drag interaction on
2459// the map. Affects drag interactions on the whole document.
2460
2461// @function enableTextSelection()
2462// Cancels the effects of a previous [`L.DomUtil.disableTextSelection`](#domutil-disabletextselection).
2463var disableTextSelection;
2464var enableTextSelection;
2465var _userSelect;
2466if ('onselectstart' in document) {
2467	disableTextSelection = function () {
2468		on(window, 'selectstart', preventDefault);
2469	};
2470	enableTextSelection = function () {
2471		off(window, 'selectstart', preventDefault);
2472	};
2473} else {
2474	var userSelectProperty = testProp(
2475		['userSelect', 'WebkitUserSelect', 'OUserSelect', 'MozUserSelect', 'msUserSelect']);
2476
2477	disableTextSelection = function () {
2478		if (userSelectProperty) {
2479			var style = document.documentElement.style;
2480			_userSelect = style[userSelectProperty];
2481			style[userSelectProperty] = 'none';
2482		}
2483	};
2484	enableTextSelection = function () {
2485		if (userSelectProperty) {
2486			document.documentElement.style[userSelectProperty] = _userSelect;
2487			_userSelect = undefined;
2488		}
2489	};
2490}
2491
2492// @function disableImageDrag()
2493// As [`L.DomUtil.disableTextSelection`](#domutil-disabletextselection), but
2494// for `dragstart` DOM events, usually generated when the user drags an image.
2495function disableImageDrag() {
2496	on(window, 'dragstart', preventDefault);
2497}
2498
2499// @function enableImageDrag()
2500// Cancels the effects of a previous [`L.DomUtil.disableImageDrag`](#domutil-disabletextselection).
2501function enableImageDrag() {
2502	off(window, 'dragstart', preventDefault);
2503}
2504
2505var _outlineElement;
2506var _outlineStyle;
2507// @function preventOutline(el: HTMLElement)
2508// Makes the [outline](https://developer.mozilla.org/docs/Web/CSS/outline)
2509// of the element `el` invisible. Used internally by Leaflet to prevent
2510// focusable elements from displaying an outline when the user performs a
2511// drag interaction on them.
2512function preventOutline(element) {
2513	while (element.tabIndex === -1) {
2514		element = element.parentNode;
2515	}
2516	if (!element.style) { return; }
2517	restoreOutline();
2518	_outlineElement = element;
2519	_outlineStyle = element.style.outline;
2520	element.style.outline = 'none';
2521	on(window, 'keydown', restoreOutline);
2522}
2523
2524// @function restoreOutline()
2525// Cancels the effects of a previous [`L.DomUtil.preventOutline`]().
2526function restoreOutline() {
2527	if (!_outlineElement) { return; }
2528	_outlineElement.style.outline = _outlineStyle;
2529	_outlineElement = undefined;
2530	_outlineStyle = undefined;
2531	off(window, 'keydown', restoreOutline);
2532}
2533
2534// @function getSizedParentNode(el: HTMLElement): HTMLElement
2535// Finds the closest parent node which size (width and height) is not null.
2536function getSizedParentNode(element) {
2537	do {
2538		element = element.parentNode;
2539	} while ((!element.offsetWidth || !element.offsetHeight) && element !== document.body);
2540	return element;
2541}
2542
2543// @function getScale(el: HTMLElement): Object
2544// Computes the CSS scale currently applied on the element.
2545// Returns an object with `x` and `y` members as horizontal and vertical scales respectively,
2546// and `boundingClientRect` as the result of [`getBoundingClientRect()`](https://developer.mozilla.org/en-US/docs/Web/API/Element/getBoundingClientRect).
2547function getScale(element) {
2548	var rect = element.getBoundingClientRect(); // Read-only in old browsers.
2549
2550	return {
2551		x: rect.width / element.offsetWidth || 1,
2552		y: rect.height / element.offsetHeight || 1,
2553		boundingClientRect: rect
2554	};
2555}
2556
2557
2558var DomUtil = (Object.freeze || Object)({
2559	TRANSFORM: TRANSFORM,
2560	TRANSITION: TRANSITION,
2561	TRANSITION_END: TRANSITION_END,
2562	get: get,
2563	getStyle: getStyle,
2564	create: create$1,
2565	remove: remove,
2566	empty: empty,
2567	toFront: toFront,
2568	toBack: toBack,
2569	hasClass: hasClass,
2570	addClass: addClass,
2571	removeClass: removeClass,
2572	setClass: setClass,
2573	getClass: getClass,
2574	setOpacity: setOpacity,
2575	testProp: testProp,
2576	setTransform: setTransform,
2577	setPosition: setPosition,
2578	getPosition: getPosition,
2579	disableTextSelection: disableTextSelection,
2580	enableTextSelection: enableTextSelection,
2581	disableImageDrag: disableImageDrag,
2582	enableImageDrag: enableImageDrag,
2583	preventOutline: preventOutline,
2584	restoreOutline: restoreOutline,
2585	getSizedParentNode: getSizedParentNode,
2586	getScale: getScale
2587});
2588
2589/*
2590 * @namespace DomEvent
2591 * Utility functions to work with the [DOM events](https://developer.mozilla.org/docs/Web/API/Event), used by Leaflet internally.
2592 */
2593
2594// Inspired by John Resig, Dean Edwards and YUI addEvent implementations.
2595
2596// @function on(el: HTMLElement, types: String, fn: Function, context?: Object): this
2597// Adds a listener function (`fn`) to a particular DOM event type of the
2598// element `el`. You can optionally specify the context of the listener
2599// (object the `this` keyword will point to). You can also pass several
2600// space-separated types (e.g. `'click dblclick'`).
2601
2602// @alternative
2603// @function on(el: HTMLElement, eventMap: Object, context?: Object): this
2604// Adds a set of type/listener pairs, e.g. `{click: onClick, mousemove: onMouseMove}`
2605function on(obj, types, fn, context) {
2606
2607	if (typeof types === 'object') {
2608		for (var type in types) {
2609			addOne(obj, type, types[type], fn);
2610		}
2611	} else {
2612		types = splitWords(types);
2613
2614		for (var i = 0, len = types.length; i < len; i++) {
2615			addOne(obj, types[i], fn, context);
2616		}
2617	}
2618
2619	return this;
2620}
2621
2622var eventsKey = '_leaflet_events';
2623
2624// @function off(el: HTMLElement, types: String, fn: Function, context?: Object): this
2625// Removes a previously added listener function.
2626// Note that if you passed a custom context to on, you must pass the same
2627// context to `off` in order to remove the listener.
2628
2629// @alternative
2630// @function off(el: HTMLElement, eventMap: Object, context?: Object): this
2631// Removes a set of type/listener pairs, e.g. `{click: onClick, mousemove: onMouseMove}`
2632function off(obj, types, fn, context) {
2633
2634	if (typeof types === 'object') {
2635		for (var type in types) {
2636			removeOne(obj, type, types[type], fn);
2637		}
2638	} else if (types) {
2639		types = splitWords(types);
2640
2641		for (var i = 0, len = types.length; i < len; i++) {
2642			removeOne(obj, types[i], fn, context);
2643		}
2644	} else {
2645		for (var j in obj[eventsKey]) {
2646			removeOne(obj, j, obj[eventsKey][j]);
2647		}
2648		delete obj[eventsKey];
2649	}
2650
2651	return this;
2652}
2653
2654function addOne(obj, type, fn, context) {
2655	var id = type + stamp(fn) + (context ? '_' + stamp(context) : '');
2656
2657	if (obj[eventsKey] && obj[eventsKey][id]) { return this; }
2658
2659	var handler = function (e) {