https://4brewers.ru/public/js/leaflet.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 earthRadius = 6378137;
1652
1653var SphericalMercator = {
1654
1655	R: earthRadius,
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 = earthRadius * 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;

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