https://villemoirieu.fr/lib/leaflet/leaflet-src.js

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

578		if (!this.listens(type, propagate)) { return this; }
579
580		var event = extend({}, data, {
581			type: type,
582			target: this,
583			sourceTarget: data && data.sourceTarget || this
584		});
585
586		if (this._events) {
587			var listeners = this._events[type];
588
589			if (listeners) {
590				this._firingCount = (this._firingCount + 1) || 1;
591				for (var i = 0, len = listeners.length; i < len; i++) {
592					var l = listeners[i];
593					l.fn.call(l.ctx || this, event);
594				}
595
596				this._firingCount--;
597			}
598		}
599
600		if (propagate) {
601			// propagate the event to parents (set with addEventParent)
602			this._propagateEvent(event);
603		}
604
605		return this;
606	},
607
608	// @method listens(type: String): Boolean
609	// Returns `true` if a particular event type has any listeners attached to it.
610	listens: function (type, propagate) {
611		var listeners = this._events && this._events[type];
612		if (listeners && listeners.length) { return true; }
613
614		if (propagate) {
615			// also check parents for listeners if event propagates
616			for (var id in this._eventParents) {
617				if (this._eventParents[id].listens(type, propagate)) { return true; }
618			}
619		}
620		return false;
621	},
622
623	// @method once(…): this
624	// Behaves as [`on(…)`](#evented-on), except the listener will only get fired once and then removed.
625	once: function (types, fn, context) {
626
627		if (typeof types === 'object') {
628			for (var type in types) {
629				this.once(type, types[type], fn);
630			}
631			return this;
632		}
633
634		var handler = bind(function () {
635			this
636			    .off(types, fn, context)
637			    .off(types, handler, context);
638		}, this);
639
640		// add a listener that's executed once and removed after that
641		return this
642		    .on(types, fn, context)
643		    .on(types, handler, context);
644	},
645
646	// @method addEventParent(obj: Evented): this
647	// Adds an event parent - an `Evented` that will receive propagated events
648	addEventParent: function (obj) {
649		this._eventParents = this._eventParents || {};
650		this._eventParents[stamp(obj)] = obj;
651		return this;
652	},
653
654	// @method removeEventParent(obj: Evented): this
655	// Removes an event parent, so it will stop receiving propagated events
656	removeEventParent: function (obj) {
657		if (this._eventParents) {
658			delete this._eventParents[stamp(obj)];
659		}
660		return this;
661	},
662
663	_propagateEvent: function (e) {
664		for (var id in this._eventParents) {
665			this._eventParents[id].fire(e.type, extend({
666				layer: e.target,
667				propagatedFrom: e.target
668			}, e), true);
669		}
670	}
671};
672
673// aliases; we should ditch those eventually
674
675// @method addEventListener(…): this
676// Alias to [`on(…)`](#evented-on)
677Events.addEventListener = Events.on;
678
679// @method removeEventListener(…): this
680// Alias to [`off(…)`](#evented-off)
681
682// @method clearAllEventListeners(…): this
683// Alias to [`off()`](#evented-off)
684Events.removeEventListener = Events.clearAllEventListeners = Events.off;
685
686// @method addOneTimeEventListener(…): this
687// Alias to [`once(…)`](#evented-once)
688Events.addOneTimeEventListener = Events.once;
689
690// @method fireEvent(…): this
691// Alias to [`fire(…)`](#evented-fire)
692Events.fireEvent = Events.fire;
693
694// @method hasEventListeners(…): Boolean
695// Alias to [`listens(…)`](#evented-listens)
696Events.hasEventListeners = Events.listens;
697
698var Evented = Class.extend(Events);
699
700/*
701 * @class Point
702 * @aka L.Point
703 *
704 * Represents a point with `x` and `y` coordinates in pixels.
705 *
706 * @example
707 *
708 * ```js
709 * var point = L.point(200, 300);
710 * ```
711 *
712 * 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:
713 *
714 * ```js
715 * map.panBy([200, 300]);
716 * map.panBy(L.point(200, 300));
717 * ```
718 *
719 * Note that `Point` does not inherit from Leafet's `Class` object,
720 * which means new classes can't inherit from it, and new methods
721 * can't be added to it with the `include` function.
722 */
723
724function Point(x, y, round) {
725	// @property x: Number; The `x` coordinate of the point
726	this.x = (round ? Math.round(x) : x);
727	// @property y: Number; The `y` coordinate of the point
728	this.y = (round ? Math.round(y) : y);
729}
730
731var trunc = Math.trunc || function (v) {
732	return v > 0 ? Math.floor(v) : Math.ceil(v);
733};
734
735Point.prototype = {
736
737	// @method clone(): Point
738	// Returns a copy of the current point.
739	clone: function () {
740		return new Point(this.x, this.y);
741	},
742
743	// @method add(otherPoint: Point): Point
744	// Returns the result of addition of the current and the given points.
745	add: function (point) {
746		// non-destructive, returns a new point
747		return this.clone()._add(toPoint(point));
748	},
749
750	_add: function (point) {
751		// destructive, used directly for performance in situations where it's safe to modify existing point
752		this.x += point.x;
753		this.y += point.y;
754		return this;
755	},
756
757	// @method subtract(otherPoint: Point): Point
758	// Returns the result of subtraction of the given point from the current.
759	subtract: function (point) {
760		return this.clone()._subtract(toPoint(point));
761	},
762
763	_subtract: function (point) {
764		this.x -= point.x;
765		this.y -= point.y;
766		return this;
767	},
768
769	// @method divideBy(num: Number): Point
770	// Returns the result of division of the current point by the given number.
771	divideBy: function (num) {
772		return this.clone()._divideBy(num);
773	},
774
775	_divideBy: function (num) {
776		this.x /= num;
777		this.y /= num;
778		return this;
779	},
780
781	// @method multiplyBy(num: Number): Point
782	// Returns the result of multiplication of the current point by the given number.
783	multiplyBy: function (num) {
784		return this.clone()._multiplyBy(num);
785	},
786
787	_multiplyBy: function (num) {
788		this.x *= num;
789		this.y *= num;
790		return this;
791	},
792
793	// @method scaleBy(scale: Point): Point
794	// Multiply each coordinate of the current point by each coordinate of
795	// `scale`. In linear algebra terms, multiply the point by the
796	// [scaling matrix](https://en.wikipedia.org/wiki/Scaling_%28geometry%29#Matrix_representation)
797	// defined by `scale`.
798	scaleBy: function (point) {
799		return new Point(this.x * point.x, this.y * point.y);
800	},
801
802	// @method unscaleBy(scale: Point): Point
803	// Inverse of `scaleBy`. Divide each coordinate of the current point by
804	// each coordinate of `scale`.
805	unscaleBy: function (point) {
806		return new Point(this.x / point.x, this.y / point.y);
807	},
808
809	// @method round(): Point
810	// Returns a copy of the current point with rounded coordinates.
811	round: function () {
812		return this.clone()._round();
813	},
814
815	_round: function () {
816		this.x = Math.round(this.x);
817		this.y = Math.round(this.y);
818		return this;
819	},
820
821	// @method floor(): Point
822	// Returns a copy of the current point with floored coordinates (rounded down).
823	floor: function () {
824		return this.clone()._floor();
825	},
826
827	_floor: function () {
828		this.x = Math.floor(this.x);
829		this.y = Math.floor(this.y);
830		return this;
831	},
832
833	// @method ceil(): Point
834	// Returns a copy of the current point with ceiled coordinates (rounded up).
835	ceil: function () {
836		return this.clone()._ceil();
837	},
838
839	_ceil: function () {
840		this.x = Math.ceil(this.x);
841		this.y = Math.ceil(this.y);
842		return this;
843	},
844
845	// @method trunc(): Point
846	// Returns a copy of the current point with truncated coordinates (rounded towards zero).
847	trunc: function () {
848		return this.clone()._trunc();
849	},
850
851	_trunc: function () {
852		this.x = trunc(this.x);
853		this.y = trunc(this.y);
854		return this;
855	},
856
857	// @method distanceTo(otherPoint: Point): Number
858	// Returns the cartesian distance between the current and the given points.
859	distanceTo: function (point) {
860		point = toPoint(point);
861
862		var x = point.x - this.x,
863		    y = point.y - this.y;
864
865		return Math.sqrt(x * x + y * y);
866	},
867
868	// @method equals(otherPoint: Point): Boolean
869	// Returns `true` if the given point has the same coordinates.
870	equals: function (point) {
871		point = toPoint(point);
872
873		return point.x === this.x &&
874		       point.y === this.y;
875	},
876
877	// @method contains(otherPoint: Point): Boolean
878	// Returns `true` if both coordinates of the given point are less than the corresponding current point coordinates (in absolute values).
879	contains: function (point) {
880		point = toPoint(point);
881
882		return Math.abs(point.x) <= Math.abs(this.x) &&
883		       Math.abs(point.y) <= Math.abs(this.y);
884	},
885
886	// @method toString(): String
887	// Returns a string representation of the point for debugging purposes.
888	toString: function () {
889		return 'Point(' +
890		        formatNum(this.x) + ', ' +
891		        formatNum(this.y) + ')';
892	}
893};
894
895// @factory L.point(x: Number, y: Number, round?: Boolean)
896// Creates a Point object with the given `x` and `y` coordinates. If optional `round` is set to true, rounds the `x` and `y` values.
897
898// @alternative
899// @factory L.point(coords: Number[])
900// Expects an array of the form `[x, y]` instead.
901
902// @alternative
903// @factory L.point(coords: Object)
904// Expects a plain object of the form `{x: Number, y: Number}` instead.
905function toPoint(x, y, round) {
906	if (x instanceof Point) {
907		return x;
908	}
909	if (isArray(x)) {
910		return new Point(x[0], x[1]);
911	}
912	if (x === undefined || x === null) {
913		return x;
914	}
915	if (typeof x === 'object' && 'x' in x && 'y' in x) {
916		return new Point(x.x, x.y);
917	}
918	return new Point(x, y, round);
919}
920
921/*
922 * @class Bounds
923 * @aka L.Bounds
924 *
925 * Represents a rectangular area in pixel coordinates.
926 *
927 * @example
928 *
929 * ```js
930 * var p1 = L.point(10, 10),
931 * p2 = L.point(40, 60),
932 * bounds = L.bounds(p1, p2);
933 * ```
934 *
935 * 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:
936 *
937 * ```js
938 * otherBounds.intersects([[10, 10], [40, 60]]);
939 * ```
940 *
941 * Note that `Bounds` does not inherit from Leafet's `Class` object,
942 * which means new classes can't inherit from it, and new methods
943 * can't be added to it with the `include` function.
944 */
945
946function Bounds(a, b) {
947	if (!a) { return; }
948
949	var points = b ? [a, b] : a;
950
951	for (var i = 0, len = points.length; i < len; i++) {
952		this.extend(points[i]);
953	}
954}
955
956Bounds.prototype = {
957	// @method extend(point: Point): this
958	// Extends the bounds to contain the given point.
959	extend: function (point) { // (Point)
960		point = toPoint(point);
961
962		// @property min: Point
963		// The top left corner of the rectangle.
964		// @property max: Point
965		// The bottom right corner of the rectangle.
966		if (!this.min && !this.max) {
967			this.min = point.clone();
968			this.max = point.clone();
969		} else {
970			this.min.x = Math.min(point.x, this.min.x);
971			this.max.x = Math.max(point.x, this.max.x);
972			this.min.y = Math.min(point.y, this.min.y);
973			this.max.y = Math.max(point.y, this.max.y);
974		}
975		return this;
976	},
977
978	// @method getCenter(round?: Boolean): Point
979	// Returns the center point of the bounds.
980	getCenter: function (round) {
981		return new Point(
982		        (this.min.x + this.max.x) / 2,
983		        (this.min.y + this.max.y) / 2, round);
984	},
985
986	// @method getBottomLeft(): Point
987	// Returns the bottom-left point of the bounds.
988	getBottomLeft: function () {
989		return new Point(this.min.x, this.max.y);
990	},
991
992	// @method getTopRight(): Point
993	// Returns the top-right point of the bounds.
994	getTopRight: function () { // -> Point
995		return new Point(this.max.x, this.min.y);
996	},
997
998	// @method getTopLeft(): Point
999	// Returns the top-left point of the bounds (i.e. [`this.min`](#bounds-min)).
1000	getTopLeft: function () {
1001		return this.min; // left, top
1002	},
1003
1004	// @method getBottomRight(): Point
1005	// Returns the bottom-right point of the bounds (i.e. [`this.max`](#bounds-max)).
1006	getBottomRight: function () {
1007		return this.max; // right, bottom
1008	},
1009
1010	// @method getSize(): Point
1011	// Returns the size of the given bounds
1012	getSize: function () {
1013		return this.max.subtract(this.min);
1014	},
1015
1016	// @method contains(otherBounds: Bounds): Boolean
1017	// Returns `true` if the rectangle contains the given one.
1018	// @alternative
1019	// @method contains(point: Point): Boolean
1020	// Returns `true` if the rectangle contains the given point.
1021	contains: function (obj) {
1022		var min, max;
1023
1024		if (typeof obj[0] === 'number' || obj instanceof Point) {
1025			obj = toPoint(obj);
1026		} else {
1027			obj = toBounds(obj);
1028		}
1029
1030		if (obj instanceof Bounds) {
1031			min = obj.min;
1032			max = obj.max;
1033		} else {
1034			min = max = obj;
1035		}
1036
1037		return (min.x >= this.min.x) &&
1038		       (max.x <= this.max.x) &&
1039		       (min.y >= this.min.y) &&
1040		       (max.y <= this.max.y);
1041	},
1042
1043	// @method intersects(otherBounds: Bounds): Boolean
1044	// Returns `true` if the rectangle intersects the given bounds. Two bounds
1045	// intersect if they have at least one point in common.
1046	intersects: function (bounds) { // (Bounds) -> Boolean
1047		bounds = toBounds(bounds);
1048
1049		var min = this.min,
1050		    max = this.max,
1051		    min2 = bounds.min,
1052		    max2 = bounds.max,
1053		    xIntersects = (max2.x >= min.x) && (min2.x <= max.x),
1054		    yIntersects = (max2.y >= min.y) && (min2.y <= max.y);
1055
1056		return xIntersects && yIntersects;
1057	},
1058
1059	// @method overlaps(otherBounds: Bounds): Boolean
1060	// Returns `true` if the rectangle overlaps the given bounds. Two bounds
1061	// overlap if their intersection is an area.
1062	overlaps: function (bounds) { // (Bounds) -> Boolean
1063		bounds = toBounds(bounds);
1064
1065		var min = this.min,
1066		    max = this.max,
1067		    min2 = bounds.min,
1068		    max2 = bounds.max,
1069		    xOverlaps = (max2.x > min.x) && (min2.x < max.x),
1070		    yOverlaps = (max2.y > min.y) && (min2.y < max.y);
1071
1072		return xOverlaps && yOverlaps;
1073	},
1074
1075	isValid: function () {
1076		return !!(this.min && this.max);
1077	}
1078};
1079
1080
1081// @factory L.bounds(corner1: Point, corner2: Point)
1082// Creates a Bounds object from two corners coordinate pairs.
1083// @alternative
1084// @factory L.bounds(points: Point[])
1085// Creates a Bounds object from the given array of points.
1086function toBounds(a, b) {
1087	if (!a || a instanceof Bounds) {
1088		return a;
1089	}
1090	return new Bounds(a, b);
1091}
1092
1093/*
1094 * @class LatLngBounds
1095 * @aka L.LatLngBounds
1096 *
1097 * Represents a rectangular geographical area on a map.
1098 *
1099 * @example
1100 *
1101 * ```js
1102 * var corner1 = L.latLng(40.712, -74.227),
1103 * corner2 = L.latLng(40.774, -74.125),
1104 * bounds = L.latLngBounds(corner1, corner2);
1105 * ```
1106 *
1107 * 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:
1108 *
1109 * ```js
1110 * map.fitBounds([
1111 * 	[40.712, -74.227],
1112 * 	[40.774, -74.125]
1113 * ]);
1114 * ```
1115 *
1116 * 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.
1117 *
1118 * Note that `LatLngBounds` does not inherit from Leafet's `Class` object,
1119 * which means new classes can't inherit from it, and new methods
1120 * can't be added to it with the `include` function.
1121 */
1122
1123function LatLngBounds(corner1, corner2) { // (LatLng, LatLng) or (LatLng[])
1124	if (!corner1) { return; }
1125
1126	var latlngs = corner2 ? [corner1, corner2] : corner1;
1127
1128	for (var i = 0, len = latlngs.length; i < len; i++) {
1129		this.extend(latlngs[i]);
1130	}
1131}
1132
1133LatLngBounds.prototype = {
1134
1135	// @method extend(latlng: LatLng): this
1136	// Extend the bounds to contain the given point
1137
1138	// @alternative
1139	// @method extend(otherBounds: LatLngBounds): this
1140	// Extend the bounds to contain the given bounds
1141	extend: function (obj) {
1142		var sw = this._southWest,
1143		    ne = this._northEast,
1144		    sw2, ne2;
1145
1146		if (obj instanceof LatLng) {
1147			sw2 = obj;
1148			ne2 = obj;
1149
1150		} else if (obj instanceof LatLngBounds) {
1151			sw2 = obj._southWest;
1152			ne2 = obj._northEast;
1153
1154			if (!sw2 || !ne2) { return this; }
1155
1156		} else {
1157			return obj ? this.extend(toLatLng(obj) || toLatLngBounds(obj)) : this;
1158		}
1159
1160		if (!sw && !ne) {
1161			this._southWest = new LatLng(sw2.lat, sw2.lng);
1162			this._northEast = new LatLng(ne2.lat, ne2.lng);
1163		} else {
1164			sw.lat = Math.min(sw2.lat, sw.lat);
1165			sw.lng = Math.min(sw2.lng, sw.lng);
1166			ne.lat = Math.max(ne2.lat, ne.lat);
1167			ne.lng = Math.max(ne2.lng, ne.lng);
1168		}
1169
1170		return this;
1171	},
1172
1173	// @method pad(bufferRatio: Number): LatLngBounds
1174	// Returns bounds created by extending or retracting the current bounds by a given ratio in each direction.
1175	// For example, a ratio of 0.5 extends the bounds by 50% in each direction.
1176	// Negative values will retract the bounds.
1177	pad: function (bufferRatio) {
1178		var sw = this._southWest,
1179		    ne = this._northEast,
1180		    heightBuffer = Math.abs(sw.lat - ne.lat) * bufferRatio,
1181		    widthBuffer = Math.abs(sw.lng - ne.lng) * bufferRatio;
1182
1183		return new LatLngBounds(
1184		        new LatLng(sw.lat - heightBuffer, sw.lng - widthBuffer),
1185		        new LatLng(ne.lat + heightBuffer, ne.lng + widthBuffer));
1186	},
1187
1188	// @method getCenter(): LatLng
1189	// Returns the center point of the bounds.
1190	getCenter: function () {
1191		return new LatLng(
1192		        (this._southWest.lat + this._northEast.lat) / 2,
1193		        (this._southWest.lng + this._northEast.lng) / 2);
1194	},
1195

1262			sw2 = obj.getSouthWest();
1263			ne2 = obj.getNorthEast();
1264		} else {
1265			sw2 = ne2 = obj;
1266		}
1267
1268		return (sw2.lat >= sw.lat) && (ne2.lat <= ne.lat) &&
1269		       (sw2.lng >= sw.lng) && (ne2.lng <= ne.lng);
1270	},
1271
1272	// @method intersects(otherBounds: LatLngBounds): Boolean
1273	// Returns `true` if the rectangle intersects the given bounds. Two bounds intersect if they have at least one point in common.
1274	intersects: function (bounds) {
1275		bounds = toLatLngBounds(bounds);
1276
1277		var sw = this._southWest,
1278		    ne = this._northEast,
1279		    sw2 = bounds.getSouthWest(),
1280		    ne2 = bounds.getNorthEast(),
1281
1282		    latIntersects = (ne2.lat >= sw.lat) && (sw2.lat <= ne.lat),
1283		    lngIntersects = (ne2.lng >= sw.lng) && (sw2.lng <= ne.lng);
1284
1285		return latIntersects && lngIntersects;
1286	},
1287
1288	// @method overlaps(otherBounds: Bounds): Boolean
1289	// Returns `true` if the rectangle overlaps the given bounds. Two bounds overlap if their intersection is an area.
1290	overlaps: function (bounds) {
1291		bounds = toLatLngBounds(bounds);
1292
1293		var sw = this._southWest,
1294		    ne = this._northEast,
1295		    sw2 = bounds.getSouthWest(),
1296		    ne2 = bounds.getNorthEast(),
1297
1298		    latOverlaps = (ne2.lat > sw.lat) && (sw2.lat < ne.lat),
1299		    lngOverlaps = (ne2.lng > sw.lng) && (sw2.lng < ne.lng);
1300
1301		return latOverlaps && lngOverlaps;
1302	},
1303
1304	// @method toBBoxString(): String
1305	// 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.
1306	toBBoxString: function () {
1307		return [this.getWest(), this.getSouth(), this.getEast(), this.getNorth()].join(',');
1308	},
1309
1310	// @method equals(otherBounds: LatLngBounds, maxMargin?: Number): Boolean
1311	// 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.
1312	equals: function (bounds, maxMargin) {
1313		if (!bounds) { return false; }
1314
1315		bounds = toLatLngBounds(bounds);
1316
1317		return this._southWest.equals(bounds.getSouthWest(), maxMargin) &&
1318		       this._northEast.equals(bounds.getNorthEast(), maxMargin);
1319	},
1320
1321	// @method isValid(): Boolean
1322	// Returns `true` if the bounds are properly initialized.
1323	isValid: function () {
1324		return !!(this._southWest && this._northEast);
1325	}
1326};
1327
1328// TODO International date line?
1329
1330// @factory L.latLngBounds(corner1: LatLng, corner2: LatLng)
1331// Creates a `LatLngBounds` object by defining two diagonally opposite corners of the rectangle.
1332
1333// @alternative
1334// @factory L.latLngBounds(latlngs: LatLng[])
1335// 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).
1336function toLatLngBounds(a, b) {
1337	if (a instanceof LatLngBounds) {
1338		return a;
1339	}
1340	return new LatLngBounds(a, b);
1341}
1342
1343/* @class LatLng
1344 * @aka L.LatLng
1345 *
1346 * Represents a geographical point with a certain latitude and longitude.
1347 *
1348 * @example
1349 *
1350 * ```
1351 * var latlng = L.latLng(50.5, 30.5);
1352 * ```
1353 *
1354 * 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:
1355 *
1356 * ```
1357 * map.panTo([50, 30]);
1358 * map.panTo({lon: 30, lat: 50});
1359 * map.panTo({lat: 50, lng: 30});
1360 * map.panTo(L.latLng(50, 30));
1361 * ```
1362 *
1363 * Note that `LatLng` does not inherit from Leaflet's `Class` object,
1364 * which means new classes can't inherit from it, and new methods
1365 * can't be added to it with the `include` function.
1366 */
1367
1368function LatLng(lat, lng, alt) {
1369	if (isNaN(lat) || isNaN(lng)) {
1370		throw new Error('Invalid LatLng object: (' + lat + ', ' + lng + ')');
1371	}
1372
1373	// @property lat: Number
1374	// Latitude in degrees
1375	this.lat = +lat;
1376
1377	// @property lng: Number
1378	// Longitude in degrees
1379	this.lng = +lng;
1380
1381	// @property alt: Number
1382	// Altitude in meters (optional)
1383	if (alt !== undefined) {
1384		this.alt = +alt;
1385	}
1386}
1387
1388LatLng.prototype = {
1389	// @method equals(otherLatLng: LatLng, maxMargin?: Number): Boolean
1390	// 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.
1391	equals: function (obj, maxMargin) {
1392		if (!obj) { return false; }
1393
1394		obj = toLatLng(obj);
1395
1396		var margin = Math.max(
1397		        Math.abs(this.lat - obj.lat),
1398		        Math.abs(this.lng - obj.lng));
1399
1400		return margin <= (maxMargin === undefined ? 1.0E-9 : maxMargin);
1401	},
1402
1403	// @method toString(): String
1404	// Returns a string representation of the point (for debugging purposes).
1405	toString: function (precision) {
1406		return 'LatLng(' +
1407		        formatNum(this.lat, precision) + ', ' +
1408		        formatNum(this.lng, precision) + ')';
1409	},
1410
1411	// @method distanceTo(otherLatLng: LatLng): Number
1412	// 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).
1413	distanceTo: function (other) {
1414		return Earth.distance(this, toLatLng(other));
1415	},
1416
1417	// @method wrap(): LatLng
1418	// Returns a new `LatLng` object with the longitude wrapped so it's always between -180 and +180 degrees.
1419	wrap: function () {
1420		return Earth.wrapLatLng(this);
1421	},
1422
1423	// @method toBounds(sizeInMeters: Number): LatLngBounds
1424	// Returns a new `LatLngBounds` object in which each boundary is `sizeInMeters/2` meters apart from the `LatLng`.
1425	toBounds: function (sizeInMeters) {
1426		var latAccuracy = 180 * sizeInMeters / 40075017,
1427		    lngAccuracy = latAccuracy / Math.cos((Math.PI / 180) * this.lat);
1428
1429		return toLatLngBounds(
1430		        [this.lat - latAccuracy, this.lng - lngAccuracy],
1431		        [this.lat + latAccuracy, this.lng + lngAccuracy]);
1432	},
1433
1434	clone: function () {
1435		return new LatLng(this.lat, this.lng, this.alt);
1436	}
1437};
1438
1439
1440
1441// @factory L.latLng(latitude: Number, longitude: Number, altitude?: Number): LatLng
1442// Creates an object representing a geographical point with the given latitude and longitude (and optionally altitude).
1443
1444// @alternative
1445// @factory L.latLng(coords: Array): LatLng
1446// Expects an array of the form `[Number, Number]` or `[Number, Number, Number]` instead.
1447
1448// @alternative
1449// @factory L.latLng(coords: Object): LatLng
1450// Expects an plain object of the form `{lat: Number, lng: Number}` or `{lat: Number, lng: Number, alt: Number}` instead.
1451
1452function toLatLng(a, b, c) {
1453	if (a instanceof LatLng) {
1454		return a;
1455	}
1456	if (isArray(a) && typeof a[0] !== 'object') {
1457		if (a.length === 3) {
1458			return new LatLng(a[0], a[1], a[2]);
1459		}
1460		if (a.length === 2) {
1461			return new LatLng(a[0], a[1]);
1462		}
1463		return null;
1464	}
1465	if (a === undefined || a === null) {
1466		return a;
1467	}
1468	if (typeof a === 'object' && 'lat' in a) {
1469		return new LatLng(a.lat, 'lng' in a ? a.lng : a.lon, a.alt);
1470	}
1471	if (b === undefined) {
1472		return null;
1473	}
1474	return new LatLng(a, b, c);
1475}
1476
1477/*
1478 * @namespace CRS
1479 * @crs L.CRS.Base
1480 * Object that defines coordinate reference systems for projecting
1481 * geographical points into pixel (screen) coordinates and back (and to

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

2290// Makes `el` the last child of its parent, so it renders in front of the other children.
2291function toFront(el) {
2292	var parent = el.parentNode;
2293	if (parent.lastChild !== el) {
2294		parent.appendChild(el);
2295	}
2296}
2297
2298// @function toBack(el: HTMLElement)
2299// Makes `el` the first child of its parent, so it renders behind the other children.
2300function toBack(el) {
2301	var parent = el.parentNode;
2302	if (parent.firstChild !== el) {
2303		parent.insertBefore(el, parent.firstChild);
2304	}
2305}
2306
2307// @function hasClass(el: HTMLElement, name: String): Boolean
2308// Returns `true` if the element's class attribute contains `name`.
2309function hasClass(el, name) {
2310	if (el.classList !== undefined) {
2311		return el.classList.contains(name);
2312	}
2313	var className = getClass(el);
2314	return className.length > 0 && new RegExp('(^|\\s)' + name + '(\\s|$)').test(className);
2315}
2316
2317// @function addClass(el: HTMLElement, name: String)
2318// Adds `name` to the element's class attribute.
2319function addClass(el, name) {
2320	if (el.classList !== undefined) {
2321		var classes = splitWords(name);
2322		for (var i = 0, len = classes.length; i < len; i++) {
2323			el.classList.add(classes[i]);
2324		}
2325	} else if (!hasClass(el, name)) {
2326		var className = getClass(el);
2327		setClass(el, (className ? className + ' ' : '') + name);
2328	}
2329}
2330
2331// @function removeClass(el: HTMLElement, name: String)
2332// Removes `name` from the element's class attribute.
2333function removeClass(el, name) {
2334	if (el.classList !== undefined) {
2335		el.classList.remove(name);
2336	} else {
2337		setClass(el, trim((' ' + getClass(el) + ' ').replace(' ' + name + ' ', ' ')));
2338	}
2339}
2340
2341// @function setClass(el: HTMLElement, name: String)
2342// Sets the element's class.
2343function setClass(el, name) {
2344	if (el.className.baseVal === undefined) {
2345		el.className = name;
2346	} else {
2347		// in case of SVG element
2348		el.className.baseVal = name;
2349	}
2350}
2351
2352// @function getClass(el: HTMLElement): String
2353// Returns the element's class.
2354function getClass(el) {
2355	return el.className.baseVal === undefined ? el.className : el.className.baseVal;
2356}
2357
2358// @function setOpacity(el: HTMLElement, opacity: Number)
2359// Set the opacity of an element (including old IE support).
2360// `opacity` must be a number from `0` to `1`.
2361function setOpacity(el, value) {
2362	if ('opacity' in el.style) {
2363		el.style.opacity = value;
2364	} else if ('filter' in el.style) {
2365		_setOpacityIE(el, value);
2366	}
2367}
2368
2369function _setOpacityIE(el, value) {
2370	var filter = false,
2371	    filterName = 'DXImageTransform.Microsoft.Alpha';
2372
2373	// filters collection throws an error if we try to retrieve a filter that doesn't exist
2374	try {
2375		filter = el.filters.item(filterName);
2376	} catch (e) {
2377		// don't set opacity to 1 if we haven't already set an opacity,
2378		// it isn't needed and breaks transparent pngs.
2379		if (value === 1) { return; }
2380	}
2381
2382	value = Math.round(value * 100);
2383
2384	if (filter) {
2385		filter.Enabled = (value !== 100);
2386		filter.Opacity = value;
2387	} else {
2388		el.style.filter += ' progid:' + filterName + '(opacity=' + value + ')';
2389	}
2390}
2391
2392// @function testProp(props: String[]): String|false
2393// Goes through the array of style names and returns the first name
2394// that is a valid style name for an element. If no such name is found,
2395// it returns false. Useful for vendor-prefixed styles like `transform`.
2396function testProp(props) {
2397	var style = document.documentElement.style;
2398
2399	for (var i = 0; i < props.length; i++) {
2400		if (props[i] in style) {
2401			return props[i];
2402		}
2403	}
2404	return false;
2405}
2406
2407// @function setTransform(el: HTMLElement, offset: Point, scale?: Number)
2408// Resets the 3D CSS transform of `el` so it is translated by `offset` pixels
2409// and optionally scaled by `scale`. Does not have an effect if the
2410// browser doesn't support 3D CSS transforms.
2411function setTransform(el, offset, scale) {
2412	var pos = offset || new Point(0, 0);
2413
2414	el.style[TRANSFORM] =
2415		(ie3d ?
2416			'translate(' + pos.x + 'px,' + pos.y + 'px)' :
2417			'translate3d(' + pos.x + 'px,' + pos.y + 'px,0)') +
2418		(scale ? ' scale(' + scale + ')' : '');
2419}
2420
2421// @function setPosition(el: HTMLElement, position: Point)
2422// Sets the position of `el` to coordinates specified by `position`,
2423// using CSS translate or top/left positioning depending on the browser
2424// (used by Leaflet internally to position its layers).
2425function setPosition(el, point) {
2426
2427	/*eslint-disable */
2428	el._leaflet_pos = point;
2429	/* eslint-enable */
2430
2431	if (any3d) {
2432		setTransform(el, point);
2433	} else {
2434		el.style.left = point.x + 'px';
2435		el.style.top = point.y + 'px';
2436	}
2437}
2438
2439// @function getPosition(el: HTMLElement): Point
2440// Returns the coordinates of an element previously positioned with setPosition.
2441function getPosition(el) {
2442	// this method is only used for elements previously positioned using setPosition,
2443	// so it's safe to cache the position for performance
2444
2445	return el._leaflet_pos || new Point(0, 0);
2446}
2447
2448// @function disableTextSelection()
2449// Prevents the user from generating `selectstart` DOM events, usually generated
2450// when the user drags the mouse through a page with text. Used internally
2451// by Leaflet to override the behaviour of any click-and-drag interaction on
2452// the map. Affects drag interactions on the whole document.
2453
2454// @function enableTextSelection()
2455// Cancels the effects of a previous [`L.DomUtil.disableTextSelection`](#domutil-disabletextselection).
2456var disableTextSelection;
2457var enableTextSelection;
2458var _userSelect;
2459if ('onselectstart' in document) {
2460	disableTextSelection = function () {
2461		on(window, 'selectstart', preventDefault);
2462	};
2463	enableTextSelection = function () {
2464		off(window, 'selectstart', preventDefault);
2465	};
2466} else {
2467	var userSelectProperty = testProp(
2468		['userSelect', 'WebkitUserSelect', 'OUserSelect', 'MozUserSelect', 'msUserSelect']);
2469
2470	disableTextSelection = function () {
2471		if (userSelectProperty) {
2472			var style = document.documentElement.style;
2473			_userSelect = style[userSelectProperty];
2474			style[userSelectProperty] = 'none';
2475		}
2476	};
2477	enableTextSelection = function () {
2478		if (userSelectProperty) {
2479			document.documentElement.style[userSelectProperty] = _userSelect;
2480			_userSelect = undefined;
2481		}
2482	};
2483}
2484
2485// @function disableImageDrag()
2486// As [`L.DomUtil.disableTextSelection`](#domutil-disabletextselection), but
2487// for `dragstart` DOM events, usually generated when the user drags an image.
2488function disableImageDrag() {
2489	on(window, 'dragstart', preventDefault);
2490}
2491
2492// @function enableImageDrag()
2493// Cancels the effects of a previous [`L.DomUtil.disableImageDrag`](#domutil-disabletextselection).
2494function enableImageDrag() {
2495	off(window, 'dragstart', preventDefault);
2496}
2497
2498var _outlineElement;
2499var _outlineStyle;
2500// @function preventOutline(el: HTMLElement)
2501// Makes the [outline](https://developer.mozilla.org/docs/Web/CSS/outline)
2502// of the element `el` invisible. Used internally by Leaflet to prevent
2503// focusable elements from displaying an outline when the user performs a
2504// drag interaction on them.
2505function preventOutline(element) {
2506	while (element.tabIndex === -1) {
2507		element = element.parentNode;
2508	}
2509	if (!element.style) { return; }
2510	restoreOutline();
2511	_outlineElement = element;
2512	_outlineStyle = element.style.outline;
2513	element.style.outline = 'none';
2514	on(window, 'keydown', restoreOutline);
2515}
2516
2517// @function restoreOutline()
2518// Cancels the effects of a previous [`L.DomUtil.preventOutline`]().
2519function restoreOutline() {
2520	if (!_outlineElement) { return; }
2521	_outlineElement.style.outline = _outlineStyle;
2522	_outlineElement = undefined;
2523	_outlineStyle = undefined;
2524	off(window, 'keydown', restoreOutline);
2525}
2526
2527// @function getSizedParentNode(el: HTMLElement): HTMLElement
2528// Finds the closest parent node which size (width and height) is not null.
2529function getSizedParentNode(element) {
2530	do {
2531		element = element.parentNode;
2532	} while ((!element.offsetWidth || !element.offsetHeight) && element !== document.body);
2533	return element;
2534}
2535
2536// @function getScale(el: HTMLElement): Object
2537// Computes the CSS scale currently applied on the element.
2538// Returns an object with `x` and `y` members as horizontal and vertical scales respectively,
2539// and `boundingClientRect` as the result of [`getBoundingClientRect()`](https://developer.mozilla.org/en-US/docs/Web/API/Element/getBoundingClientRect).
2540function getScale(element) {
2541	var rect = element.getBoundingClientRect(); // Read-only in old browsers.
2542
2543	return {
2544		x: rect.width / element.offsetWidth || 1,
2545		y: rect.height / element.offsetHeight || 1,
2546		boundingClientRect: rect
2547	};
2548}
2549
2550
2551var DomUtil = (Object.freeze || Object)({
2552	TRANSFORM: TRANSFORM,
2553	TRANSITION: TRANSITION,
2554	TRANSITION_END: TRANSITION_END,
2555	get: get,
2556	getStyle: getStyle,
2557	create: create$1,
2558	remove: remove,
2559	empty: empty,
2560	toFront: toFront,
2561	toBack: toBack,
2562	hasClass: hasClass,
2563	addClass: addClass,
2564	removeClass: removeClass,
2565	setClass: setClass,
2566	getClass: getClass,
2567	setOpacity: setOpacity,
2568	testProp: testProp,
2569	setTransform: setTransform,
2570	setPosition: setPosition,
2571	getPosition: getPosition,
2572	disableTextSelection: disableTextSelection,
2573	enableTextSelection: enableTextSelection,
2574	disableImageDrag: disableImageDrag,
2575	enableImageDrag: enableImageDrag,
2576	preventOutline: preventOutline,
2577	restoreOutline: restoreOutline,
2578	getSizedParentNode: getSizedParentNode,
2579	getScale: getScale
2580});
2581
2582/*
2583 * @namespace DomEvent
2584 * Utility functions to work with the [DOM events](https://developer.mozilla.org/docs/Web/API/Event), used by Leaflet internally.
2585 */
2586