https://tianjara.net/javascript/leaflet/leaflet.js

1/* @preserve
2 * Leaflet 1.6.0, a JS library for interactive maps. http://leafletjs.com
3 * (c) 2010-2019 Vladimir Agafonkin, (c) 2010-2011 CloudMade
4 */
5
6(function (global, factory) {
7  typeof exports === 'object' && typeof module !== 'undefined' ? factory(exports) :
8  typeof define === 'function' && define.amd ? define(['exports'], factory) :
9  (global = typeof globalThis !== 'undefined' ? globalThis : global || self, factory(global.L = {}));
10})(this, (function (exports) { 'use strict';
11
12  var version = "1.6.0";
13
14  /*
15   * @namespace Util
16   *
17   * Various utility functions, used by Leaflet internally.
18   */
19
20  // @function extend(dest: Object, src?: Object): Object
21  // Merges the properties of the `src` object (or multiple objects) into `dest` object and returns the latter. Has an `L.extend` shortcut.
22  function extend(dest) {
23  	var i, j, len, src;
24
25  	for (j = 1, len = arguments.length; j < len; j++) {
26  		src = arguments[j];
27  		for (i in src) {
28  			dest[i] = src[i];
29  		}
30  	}
31  	return dest;
32  }
33
34  // @function create(proto: Object, properties?: Object): Object
35  // Compatibility polyfill for [Object.create](https://developer.mozilla.org/docs/Web/JavaScript/Reference/Global_Objects/Object/create)
36  var create$2 = Object.create || (function () {
37  	function F() {}
38  	return function (proto) {
39  		F.prototype = proto;
40  		return new F();
41  	};
42  })();
43
44  // @function bind(fn: Function, …): Function
45  // Returns a new function bound to the arguments passed, like [Function.prototype.bind](https://developer.mozilla.org/docs/Web/JavaScript/Reference/Global_Objects/Function/bind).
46  // Has a `L.bind()` shortcut.
47  function bind(fn, obj) {
48  	var slice = Array.prototype.slice;
49
50  	if (fn.bind) {
51  		return fn.bind.apply(fn, slice.call(arguments, 1));
52  	}
53
54  	var args = slice.call(arguments, 2);
55
56  	return function () {
57  		return fn.apply(obj, args.length ? args.concat(slice.call(arguments)) : arguments);
58  	};
59  }
60
61  // @property lastId: Number
62  // Last unique ID used by [`stamp()`](#util-stamp)
63  var lastId = 0;
64
65  // @function stamp(obj: Object): Number
66  // Returns the unique ID of an object, assigning it one if it doesn't have it.
67  function stamp(obj) {
68  	/*eslint-disable */
69  	obj._leaflet_id = obj._leaflet_id || ++lastId;
70  	return obj._leaflet_id;
71  	/* eslint-enable */
72  }
73

74  // @function throttle(fn: Function, time: Number, context: Object): Function
75  // Returns a function which executes function `fn` with the given scope `context`
76  // (so that the `this` keyword refers to `context` inside `fn`'s code). The function
77  // `fn` will be called no more than one time per given amount of `time`. The arguments
78  // received by the bound function will be any arguments passed when binding the
79  // function, followed by any arguments passed when invoking the bound function.
80  // Has an `L.throttle` shortcut.
81  function throttle(fn, time, context) {
82  	var lock, args, wrapperFn, later;
83
84  	later = function () {
85  		// reset lock and call if queued
86  		lock = false;
87  		if (args) {
88  			wrapperFn.apply(context, args);
89  			args = false;
90  		}
91  	};
92
93  	wrapperFn = function () {
94  		if (lock) {
95  			// called too soon, queue to call later
96  			args = arguments;
97
98  		} else {
99  			// call and lock until later
100  			fn.apply(context, arguments);
101  			setTimeout(later, time);
102  			lock = true;
103  		}
104  	};
105
106  	return wrapperFn;
107  }
108
109  // @function wrapNum(num: Number, range: Number[], includeMax?: Boolean): Number
110  // Returns the number `num` modulo `range` in such a way so it lies within
111  // `range[0]` and `range[1]`. The returned value will be always smaller than
112  // `range[1]` unless `includeMax` is set to `true`.
113  function wrapNum(x, range, includeMax) {
114  	var max = range[1],
115  	    min = range[0],
116  	    d = max - min;
117  	return x === max && includeMax ? x : ((x - min) % d + d) % d + min;
118  }
119
120  // @function falseFn(): Function
121  // Returns a function which always returns `false`.
122  function falseFn() { return false; }
123
124  // @function formatNum(num: Number, digits?: Number): Number
125  // Returns the number `num` rounded to `digits` decimals, or to 6 decimals by default.
126  function formatNum(num, digits) {
127  	var pow = Math.pow(10, (digits === undefined ? 6 : digits));
128  	return Math.round(num * pow) / pow;
129  }
130
131  // @function trim(str: String): String
132  // Compatibility polyfill for [String.prototype.trim](https://developer.mozilla.org/docs/Web/JavaScript/Reference/Global_Objects/String/Trim)
133  function trim(str) {
134  	return str.trim ? str.trim() : str.replace(/^\s+|\s+$/g, '');
135  }
136
137  // @function splitWords(str: String): String[]
138  // Trims and splits the string on whitespace and returns the array of parts.
139  function splitWords(str) {
140  	return trim(str).split(/\s+/);
141  }
142
143  // @function setOptions(obj: Object, options: Object): Object
144  // Merges the given properties to the `options` of the `obj` object, returning the resulting options. See `Class options`. Has an `L.setOptions` shortcut.
145  function setOptions(obj, options) {
146  	if (!Object.prototype.hasOwnProperty.call(obj, 'options')) {
147  		obj.options = obj.options ? create$2(obj.options) : {};
148  	}
149  	for (var i in options) {
150  		obj.options[i] = options[i];
151  	}
152  	return obj.options;
153  }
154
155  // @function getParamString(obj: Object, existingUrl?: String, uppercase?: Boolean): String
156  // Converts an object into a parameter URL string, e.g. `{a: "foo", b: "bar"}`
157  // translates to `'?a=foo&b=bar'`. If `existingUrl` is set, the parameters will
158  // be appended at the end. If `uppercase` is `true`, the parameter names will
159  // be uppercased (e.g. `'?A=foo&B=bar'`)
160  function getParamString(obj, existingUrl, uppercase) {
161  	var params = [];
162  	for (var i in obj) {
163  		params.push(encodeURIComponent(uppercase ? i.toUpperCase() : i) + '=' + encodeURIComponent(obj[i]));
164  	}
165  	return ((!existingUrl || existingUrl.indexOf('?') === -1) ? '?' : '&') + params.join('&');
166  }
167
168  var templateRe = /\{ *([\w_-]+) *\}/g;
169
170  // @function template(str: String, data: Object): String
171  // Simple templating facility, accepts a template string of the form `'Hello {a}, {b}'`
172  // and a data object like `{a: 'foo', b: 'bar'}`, returns evaluated string
173  // `('Hello foo, bar')`. You can also specify functions instead of strings for
174  // data values — they will be evaluated passing `data` as an argument.
175  function template(str, data) {
176  	return str.replace(templateRe, function (str, key) {
177  		var value = data[key];
178
179  		if (value === undefined) {
180  			throw new Error('No value provided for variable ' + str);
181
182  		} else if (typeof value === 'function') {
183  			value = value(data);
184  		}
185  		return value;
186  	});
187  }
188
189  // @function isArray(obj): Boolean
190  // Compatibility polyfill for [Array.isArray](https://developer.mozilla.org/docs/Web/JavaScript/Reference/Global_Objects/Array/isArray)
191  var isArray = Array.isArray || function (obj) {
192  	return (Object.prototype.toString.call(obj) === '[object Array]');
193  };
194
195  // @function indexOf(array: Array, el: Object): Number
196  // Compatibility polyfill for [Array.prototype.indexOf](https://developer.mozilla.org/docs/Web/JavaScript/Reference/Global_Objects/Array/indexOf)
197  function indexOf(array, el) {
198  	for (var i = 0; i < array.length; i++) {
199  		if (array[i] === el) { return i; }
200  	}
201  	return -1;
202  }
203
204  // @property emptyImageUrl: String
205  // Data URI string containing a base64-encoded empty GIF image.
206  // Used as a hack to free memory from unused images on WebKit-powered
207  // mobile devices (by setting image `src` to this string).
208  var emptyImageUrl = 'data:image/gif;base64,R0lGODlhAQABAAD/ACwAAAAAAQABAAACADs=';
209
210  // inspired by http://paulirish.com/2011/requestanimationframe-for-smart-animating/
211
212  function getPrefixed(name) {
213  	return window['webkit' + name] || window['moz' + name] || window['ms' + name];
214  }
215
216  var lastTime = 0;
217
218  // fallback for IE 7-8
219  function timeoutDefer(fn) {
220  	var time = +new Date(),
221  	    timeToCall = Math.max(0, 16 - (time - lastTime));
222
223  	lastTime = time + timeToCall;
224  	return window.setTimeout(fn, timeToCall);
225  }
226
227  var requestFn = window.requestAnimationFrame || getPrefixed('RequestAnimationFrame') || timeoutDefer;
228  var cancelFn = window.cancelAnimationFrame || getPrefixed('CancelAnimationFrame') ||
229  		getPrefixed('CancelRequestAnimationFrame') || function (id) { window.clearTimeout(id); };
230
231  // @function requestAnimFrame(fn: Function, context?: Object, immediate?: Boolean): Number
232  // Schedules `fn` to be executed when the browser repaints. `fn` is bound to
233  // `context` if given. When `immediate` is set, `fn` is called immediately if
234  // the browser doesn't have native support for
235  // [`window.requestAnimationFrame`](https://developer.mozilla.org/docs/Web/API/window/requestAnimationFrame),
236  // otherwise it's delayed. Returns a request ID that can be used to cancel the request.
237  function requestAnimFrame(fn, context, immediate) {
238  	if (immediate && requestFn === timeoutDefer) {
239  		fn.call(context);
240  	} else {
241  		return requestFn.call(window, bind(fn, context));
242  	}
243  }
244
245  // @function cancelAnimFrame(id: Number): undefined
246  // Cancels a previous `requestAnimFrame`. See also [window.cancelAnimationFrame](https://developer.mozilla.org/docs/Web/API/window/cancelAnimationFrame).
247  function cancelAnimFrame(id) {
248  	if (id) {
249  		cancelFn.call(window, id);
250  	}
251  }
252
253  var Util = {
254    __proto__: null,
255    extend: extend,
256    create: create$2,
257    bind: bind,
258    get lastId () { return lastId; },
259    stamp: stamp,
260    throttle: throttle,
261    wrapNum: wrapNum,
262    falseFn: falseFn,
263    formatNum: formatNum,
264    trim: trim,
265    splitWords: splitWords,
266    setOptions: setOptions,
267    getParamString: getParamString,
268    template: template,
269    isArray: isArray,
270    indexOf: indexOf,
271    emptyImageUrl: emptyImageUrl,
272    requestFn: requestFn,
273    cancelFn: cancelFn,
274    requestAnimFrame: requestAnimFrame,
275    cancelAnimFrame: cancelAnimFrame
276  };
277
278  // @class Class
279  // @aka L.Class
280
281  // @section
282  // @uninheritable
283
284  // Thanks to John Resig and Dean Edwards for inspiration!
285
286  function Class() {}
287
288  Class.extend = function (props) {
289
290  	// @function extend(props: Object): Function
291  	// [Extends the current class](#class-inheritance) given the properties to be included.
292  	// Returns a Javascript function that is a class constructor (to be called with `new`).
293  	var NewClass = function () {
294
295  		// call the constructor
296  		if (this.initialize) {
297  			this.initialize.apply(this, arguments);
298  		}
299
300  		// call all constructor hooks
301  		this.callInitHooks();
302  	};
303
304  	var parentProto = NewClass.__super__ = this.prototype;
305
306  	var proto = create$2(parentProto);
307  	proto.constructor = NewClass;
308
309  	NewClass.prototype = proto;
310
311  	// inherit parent's statics
312  	for (var i in this) {
313  		if (Object.prototype.hasOwnProperty.call(this, i) && i !== 'prototype' && i !== '__super__') {
314  			NewClass[i] = this[i];
315  		}
316  	}
317
318  	// mix static properties into the class
319  	if (props.statics) {
320  		extend(NewClass, props.statics);
321  		delete props.statics;
322  	}
323
324  	// mix includes into the prototype
325  	if (props.includes) {
326  		checkDeprecatedMixinEvents(props.includes);
327  		extend.apply(null, [proto].concat(props.includes));
328  		delete props.includes;
329  	}
330
331  	// merge options
332  	if (proto.options) {
333  		props.options = extend(create$2(proto.options), props.options);
334  	}
335
336  	// mix given properties into the prototype
337  	extend(proto, props);
338
339  	proto._initHooks = [];
340
341  	// add method for calling all hooks
342  	proto.callInitHooks = function () {
343
344  		if (this._initHooksCalled) { return; }
345
346  		if (parentProto.callInitHooks) {
347  			parentProto.callInitHooks.call(this);
348  		}
349
350  		this._initHooksCalled = true;
351
352  		for (var i = 0, len = proto._initHooks.length; i < len; i++) {
353  			proto._initHooks[i].call(this);
354  		}
355  	};
356
357  	return NewClass;
358  };
359
360
361  // @function include(properties: Object): this
362  // [Includes a mixin](#class-includes) into the current class.
363  Class.include = function (props) {
364  	extend(this.prototype, props);
365  	return this;
366  };
367
368  // @function mergeOptions(options: Object): this
369  // [Merges `options`](#class-options) into the defaults of the class.
370  Class.mergeOptions = function (options) {
371  	extend(this.prototype.options, options);
372  	return this;
373  };
374
375  // @function addInitHook(fn: Function): this
376  // Adds a [constructor hook](#class-constructor-hooks) to the class.
377  Class.addInitHook = function (fn) { // (Function) || (String, args...)
378  	var args = Array.prototype.slice.call(arguments, 1);
379
380  	var init = typeof fn === 'function' ? fn : function () {
381  		this[fn].apply(this, args);
382  	};
383
384  	this.prototype._initHooks = this.prototype._initHooks || [];
385  	this.prototype._initHooks.push(init);
386  	return this;
387  };
388
389  function checkDeprecatedMixinEvents(includes) {
390  	if (typeof L === 'undefined' || !L || !L.Mixin) { return; }
391
392  	includes = isArray(includes) ? includes : [includes];
393
394  	for (var i = 0; i < includes.length; i++) {
395  		if (includes[i] === L.Mixin.Events) {

639;
640  	},
641
642  	// @method addEventParent(obj: Evented): this
643  	// Adds an event parent - an `Evented` that will receive propagated events
644  	addEventParent: function (obj) {
645  		this._eventParents = this._eventParents || {};
646  		this._eventParents[stamp(obj)] = obj;
647  		return this;
648  	},
649
650  	// @method removeEventParent(obj: Evented): this
651  	// Removes an event parent, so it will stop receiving propagated events
652  	removeEventParent: function (obj) {
653  		if (this._eventParents) {
654  			delete this._eventParents[stamp(obj)];
655  		}
656  		return this;
657  	},
658
659  	_propagateEvent: function (e) {
660  		for (var id in this._eventParents) {
661  			this._eventParents[id].fire(e.type, extend({
662  				layer: e.target,
663  				propagatedFrom: e.target
664  			}, e), true);
665  		}
666  	}
667  };
668
669  // aliases; we should ditch those eventually
670
671  // @method addEventListener(…): this
672  // Alias to [`on(…)`](#evented-on)
673  Events.addEventListener = Events.on;
674
675  // @method removeEventListener(…): this
676  // Alias to [`off(…)`](#evented-off)
677
678  // @method clearAllEventListeners(…): this
679  // Alias to [`off()`](#evented-off)
680  Events.removeEventListener = Events.clearAllEventListeners = Events.off;
681
682  // @method addOneTimeEventListener(…): this
683  // Alias to [`once(…)`](#evented-once)
684  Events.addOneTimeEventListener = Events.once;
685
686  // @method fireEvent(…): this
687  // Alias to [`fire(…)`](#evented-fire)
688  Events.fireEvent = Events.fire;
689
690  // @method hasEventListeners(…): Boolean
691  // Alias to [`listens(…)`](#evented-listens)
692  Events.hasEventListeners = Events.listens;
693
694  var Evented = Class.extend(Events);
695
696  /*
697   * @class Point
698   * @aka L.Point
699   *
700   * Represents a point with `x` and `y` coordinates in pixels.
701   *
702   * @example
703   *
704   * ```js
705   * var point = L.point(200, 300);
706   * ```
707   *
708   * 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:
709   *
710   * ```js
711   * map.panBy([200, 300]);
712   * map.panBy(L.point(200, 300));
713   * ```
714   *
715   * Note that `Point` does not inherit from Leaflet's `Class` object,
716   * which means new classes can't inherit from it, and new methods
717   * can't be added to it with the `include` function.
718   */
719
720  function Point(x, y, round) {
721  	// @property x: Number; The `x` coordinate of the point
722  	this.x = (round ? Math.round(x) : x);
723  	// @property y: Number; The `y` coordinate of the point
724  	this.y = (round ? Math.round(y) : y);
725  }
726
727  var trunc = Math.trunc || function (v) {
728  	return v > 0 ? Math.floor(v) : Math.ceil(v);
729  };
730
731  Point.prototype = {
732
733  	// @method clone(): Point
734  	// Returns a copy of the current point.
735  	clone: function () {
736  		return new Point(this.x, this.y);
737  	},
738
739  	// @method add(otherPoint: Point): Point
740  	// Returns the result of addition of the current and the given points.
741  	add: function (point) {
742  		// non-destructive, returns a new point
743  		return this.clone()._add(toPoint(point));
744  	},
745
746  	_add: function (point) {
747  		// destructive, used directly for performance in situations where it's safe to modify existing point
748  		this.x += point.x;
749  		this.y += point.y;
750  		return this;
751  	},
752
753  	// @method subtract(otherPoint: Point): Point
754  	// Returns the result of subtraction of the given point from the current.
755  	subtract: function (point) {
756  		return this.clone()._subtract(toPoint(point));
757  	},
758
759  	_subtract: function (point) {
760  		this.x -= point.x;
761  		this.y -= point.y;
762  		return this;
763  	},
764
765  	// @method divideBy(num: Number): Point
766  	// Returns the result of division of the current point by the given number.
767  	divideBy: function (num) {
768  		return this.clone()._divideBy(num);
769  	},
770
771  	_divideBy: function (num) {
772  		this.x /= num;
773  		this.y /= num;
774  		return this;
775  	},
776
777  	// @method multiplyBy(num: Number): Point
778  	// Returns the result of multiplication of the current point by the given number.
779  	multiplyBy: function (num) {
780  		return this.clone()._multiplyBy(num);
781  	},
782
783  	_multiplyBy: function (num) {
784  		this.x *= num;
785  		this.y *= num;
786  		return this;
787  	},
788
789  	// @method scaleBy(scale: Point): Point
790  	// Multiply each coordinate of the current point by each coordinate of
791  	// `scale`. In linear algebra terms, multiply the point by the
792  	// [scaling matrix](https://en.wikipedia.org/wiki/Scaling_%28geometry%29#Matrix_representation)
793  	// defined by `scale`.
794  	scaleBy: function (point) {
795  		return new Point(this.x * point.x, this.y * point.y);
796  	},
797
798  	// @method unscaleBy(scale: Point): Point
799  	// Inverse of `scaleBy`. Divide each coordinate of the current point by
800  	// each coordinate of `scale`.
801  	unscaleBy: function (point) {
802  		return new Point(this.x / point.x, this.y / point.y);
803  	},
804
805  	// @method round(): Point
806  	// Returns a copy of the current point with rounded coordinates.
807  	round: function () {
808  		return this.clone()._round();
809  	},
810
811  	_round: function () {
812  		this.x = Math.round(this.x);
813  		this.y = Math.round(this.y);
814  		return this;
815  	},
816
817  	// @method floor(): Point
818  	// Returns a copy of the current point with floored coordinates (rounded down).
819  	floor: function () {
820  		return this.clone()._floor();
821  	},
822
823  	_floor: function () {
824  		this.x = Math.floor(this.x);
825  		this.y = Math.floor(this.y);
826  		return this;
827  	},
828
829  	// @method ceil(): Point
830  	// Returns a copy of the current point with ceiled coordinates (rounded up).
831  	ceil: function () {
832  		return this.clone()._ceil();
833  	},
834
835  	_ceil: function () {
836  		this.x = Math.ceil(this.x);
837  		this.y = Math.ceil(this.y);
838  		return this;
839  	},
840
841  	// @method trunc(): Point
842  	// Returns a copy of the current point with truncated coordinates (rounded towards zero).
843  	trunc: function () {
844  		return this.clone()._trunc();
845  	},
846
847  	_trunc: function () {
848  		this.x = trunc(this.x);
849  		this.y = trunc(this.y);
850  		return this;
851  	},
852
853  	// @method distanceTo(otherPoint: Point): Number
854  	// Returns the cartesian distance between the current and the given points.
855  	distanceTo: function (point) {
856  		point = toPoint(point);
857
858  		var x = point.x - this.x,
859  		    y = point.y - this.y;
860
861  		return Math.sqrt(x * x + y * y);
862  	},
863
864  	// @method equals(otherPoint: Point): Boolean
865  	// Returns `true` if the given point has the same coordinates.
866  	equals: function (point) {
867  		point = toPoint(point);
868
869  		return point.x === this.x &&
870  		       point.y === this.y;
871  	},
872
873  	// @method contains(otherPoint: Point): Boolean
874  	// Returns `true` if both coordinates of the given point are less than the corresponding current point coordinates (in absolute values).
875  	contains: function (point) {
876  		point = toPoint(point);
877
878  		return Math.abs(point.x) <= Math.abs(this.x) &&
879  		       Math.abs(point.y) <= Math.abs(this.y);
880  	},
881
882  	// @method toString(): String
883  	// Returns a string representation of the point for debugging purposes.
884  	toString: function () {
885  		return 'Point(' +
886  		        formatNum(this.x) + ', ' +
887  		        formatNum(this.y) + ')';
888  	}
889  };
890
891  // @factory L.point(x: Number, y: Number, round?: Boolean)
892  // Creates a Point object with the given `x` and `y` coordinates. If optional `round` is set to true, rounds the `x` and `y` values.
893
894  // @alternative
895  // @factory L.point(coords: Number[])
896  // Expects an array of the form `[x, y]` instead.
897
898  // @alternative
899  // @factory L.point(coords: Object)
900  // Expects a plain object of the form `{x: Number, y: Number}` instead.
901  function toPoint(x, y, round) {
902  	if (x instanceof Point) {
903  		return x;
904  	}
905  	if (isArray(x)) {
906  		return new Point(x[0], x[1]);
907  	}
908  	if (x === undefined || x === null) {
909  		return x;
910  	}
911  	if (typeof x === 'object' && 'x' in x && 'y' in x) {
912  		return new Point(x.x, x.y);
913  	}
914  	return new Point(x, y, round);
915  }
916
917  /*
918   * @class Bounds
919   * @aka L.Bounds
920   *
921   * Represents a rectangular area in pixel coordinates.
922   *
923   * @example
924   *
925   * ```js
926   * var p1 = L.point(10, 10),
927   * p2 = L.point(40, 60),
928   * bounds = L.bounds(p1, p2);
929   * ```
930   *
931   * 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:
932   *
933   * ```js
934   * otherBounds.intersects([[10, 10], [40, 60]]);
935   * ```
936   *
937   * Note that `Bounds` does not inherit from Leaflet's `Class` object,
938   * which means new classes can't inherit from it, and new methods
939   * can't be added to it with the `include` function.
940   */
941
942  function Bounds(a, b) {
943  	if (!a) { return; }
944
945  	var points = b ? [a, b] : a;
946
947  	for (var i = 0, len = points.length; i < len; i++) {
948  		this.extend(points[i]);
949  	}
950  }
951
952  Bounds.prototype = {
953  	// @method extend(point: Point): this
954  	// Extends the bounds to contain the given point.

955  	extend: function (point) { // (Point)
956  		point = toPoint(point);
957
958  		// @property min: Point
959  		// The top left corner of the rectangle.
960  		// @property max: Point
961  		// The bottom right corner of the rectangle.
962  		if (!this.min && !this.max) {
963  			this.min = point.clone();
964  			this.max = point.clone();
965  		} else {
966  			this.min.x = Math.min(point.x, this.min.x);
967  			this.max.x = Math.max(point.x, this.max.x);
968  			this.min.y = Math.min(point.y, this.min.y);
969  			this.max.y = Math.max(point.y, this.max.y);
970  		}
971  		return this;
972  	},
973
974  	// @method getCenter(round?: Boolean): Point
975  	// Returns the center point of the bounds.
976  	getCenter: function (round) {
977  		return new Point(
978  		        (this.min.x + this.max.x) / 2,
979  		        (this.min.y + this.max.y) / 2, round);
980  	},
981
982  	// @method getBottomLeft(): Point
983  	// Returns the bottom-left point of the bounds.
984  	getBottomLeft: function () {
985  		return new Point(this.min.x, this.max.y);
986  	},
987
988  	// @method getTopRight(): Point
989  	// Returns the top-right point of the bounds.
990  	getTopRight: function () { // -> Point
991  		return new Point(this.max.x, this.min.y);
992  	},
993
994  	// @method getTopLeft(): Point
995  	// Returns the top-left point of the bounds (i.e. [`this.min`](#bounds-min)).
996  	getTopLeft: function () {
997  		return this.min; // left, top
998  	},
999
1000  	// @method getBottomRight(): Point
1001  	// Returns the bottom-right point of the bounds (i.e. [`this.max`](#bounds-max)).
1002  	getBottomRight: function () {
1003  		return this.max; // right, bottom
1004  	},
1005
1006  	// @method getSize(): Point
1007  	// Returns the size of the given bounds
1008  	getSize: function () {
1009  		return this.max.subtract(this.min);
1010  	},
1011
1012  	// @method contains(otherBounds: Bounds): Boolean
1013  	// Returns `true` if the rectangle contains the given one.
1014  	// @alternative
1015  	// @method contains(point: Point): Boolean
1016  	// Returns `true` if the rectangle contains the given point.
1017  	contains: function (obj) {
1018  		var min, max;
1019
1020  		if (typeof obj[0] === 'number' || obj instanceof Point) {
1021  			obj = toPoint(obj);
1022  		} else {
1023  			obj = toBounds(obj);
1024  		}
1025
1026  		if (obj instanceof Bounds) {
1027  			min = obj.min;
1028  			max = obj.max;
1029  		} else {
1030  			min = max = obj;
1031  		}
1032
1033  		return (min.x >= this.min.x) &&
1034  		       (max.x <= this.max.x) &&
1035  		       (min.y >= this.min.y) &&
1036  		       (max.y <= this.max.y);
1037  	},
1038
1039  	// @method intersects(otherBounds: Bounds): Boolean
1040  	// Returns `true` if the rectangle intersects the given bounds. Two bounds
1041  	// intersect if they have at least one point in common.
1042  	intersects: function (bounds) { // (Bounds) -> Boolean
1043  		bounds = toBounds(bounds);
1044
1045  		var min = this.min,
1046  		    max = this.max,
1047  		    min2 = bounds.min,
1048  		    max2 = bounds.max,
1049  		    xIntersects = (max2.x >= min.x) && (min2.x <= max.x),
1050  		    yIntersects = (max2.y >= min.y) && (min2.y <= max.y);
1051
1052  		return xIntersects && yIntersects;
1053  	},
1054
1055  	// @method overlaps(otherBounds: Bounds): Boolean
1056  	// Returns `true` if the rectangle overlaps the given bounds. Two bounds
1057  	// overlap if their intersection is an area.
1058  	overlaps: function (bounds) { // (Bounds) -> Boolean
1059  		bounds = toBounds(bounds);
1060
1061  		var min = this.min,
1062  		    max = this.max,
1063  		    min2 = bounds.min,
1064  		    max2 = bounds.max,
1065  		    xOverlaps = (max2.x > min.x) && (min2.x < max.x),
1066  		    yOverlaps = (max2.y > min.y) && (min2.y < max.y);
1067
1068  		return xOverlaps && yOverlaps;
1069  	},
1070
1071  	isValid: function () {
1072  		return !!(this.min && this.max);
1073  	}

1073
1074  };
1075
1076
1077  // @factory L.bounds(corner1: Point, corner2: Point)
1078  // Creates a Bounds object from two corners coordinate pairs.
1079  // @alternative
1080  // @factory L.bounds(points: Point[])
1081  // Creates a Bounds object from the given array of points.
1082  function toBounds(a, b) {
1083  	if (!a || a instanceof Bounds) {
1084  		return a;
1085  	}
1086  	return new Bounds(a, b);
1087  }
1088
1089  /*
1090   * @class LatLngBounds
1091   * @aka L.LatLngBounds
1092   *
1093   * Represents a rectangular geographical area on a map.
1094   *
1095   * @example
1096   *
1097   * ```js
1098   * var corner1 = L.latLng(40.712, -74.227),
1099   * corner2 = L.latLng(40.774, -74.125),
1100   * bounds = L.latLngBounds(corner1, corner2);
1101   * ```
1102   *
1103   * 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:
1104   *
1105   * ```js
1106   * map.fitBounds([
1107   * 	[40.712, -74.227],
1108   * 	[40.774, -74.125]
1109   * ]);
1110   * ```
1111   *
1112   * 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.
1113   *
1114   * Note that `LatLngBounds` does not inherit from Leaflet's `Class` object,
1115   * which means new classes can't inherit from it, and new methods
1116   * can't be added to it with the `include` function.
1117   */
1118
1119  function LatLngBounds(corner1, corner2) { // (LatLng, LatLng) or (LatLng[])
1120  	if (!corner1) { return; }
1121
1122  	var latlngs = corner2 ? [corner1, corner2] : corner1;
1123
1124  	for (var i = 0, len = latlngs.length; i < len; i++) {
1125  		this.extend(latlngs[i]);
1126  	}
1127  }
1128
1129  LatLngBounds.prototype = {
1130
1131  	// @method extend(latlng: LatLng): this
1132  	// Extend the bounds to contain the given point
1133
1134  	// @alternative
1135  	// @method extend(otherBounds: LatLngBounds): this
1136  	// Extend the bounds to contain the given bounds
1137  	extend: function (obj) {
1138  		var sw = this._southWest,
1139  		    ne = this._northEast,
1140  		    sw2, ne2;
1141
1142  		if (obj instanceof LatLng) {
1143  			sw2 = obj;
1144  			ne2 = obj;
1145
1146  		} else if (obj instanceof LatLngBounds) {
1147  			sw2 = obj._southWest;
1148  			ne2 = obj._northEast;
1149
1150  			if (!sw2 || !ne2) { return this; }
1151
1152  		} else {
1153  			return obj ? this.extend(toLatLng(obj) || toLatLngBounds(obj)) : this;
1154  		}
1155
1156  		if (!sw && !ne) {
1157  			this._southWest = new LatLng(sw2.lat, sw2.lng);
1158  			this._northEast = new LatLng(ne2.lat, ne2.lng);
1159  		} else {
1160  			sw.lat = Math.min(sw2.lat, sw.lat);
1161  			sw.lng = Math.min(sw2.lng, sw.lng);
1162  			ne.lat = Math.max(ne2.lat, ne.lat);
1163  			ne.lng = Math.max(ne2.lng, ne.lng);
1164  		}
1165
1166  		return this;
1167  	},
1168
1169  	// @method pad(bufferRatio: Number): LatLngBounds
1170  	// Returns bounds created by extending or retracting the current bounds by a given ratio in each direction.
1171  	// For example, a ratio of 0.5 extends the bounds by 50% in each direction.
1172  	// Negative values will retract the bounds.
1173  	pad: function (bufferRatio) {
1174  		var sw = this._southWest,
1175  		    ne = this._northEast,
1176  		    heightBuffer = Math.abs(sw.lat - ne.lat) * bufferRatio,
1177  		    widthBuffer = Math.abs(sw.lng - ne.lng) * bufferRatio;
1178
1179  		return new LatLngBounds(
1180  		        new LatLng(sw.lat - heightBuffer, sw.lng - widthBuffer),
1181  		        new LatLng(ne.lat + heightBuffer, ne.lng + widthBuffer));
1182  	},
1183
1184  	// @method getCenter(): LatLng
1185  	// Returns the center point of the bounds.
1186  	getCenter: function () {
1187  		return new LatLng(
1188  		        (this._southWest.lat + this._northEast.lat) / 2,
1189  		        (this._southWest.lng + this._northEast.lng) / 2);
1190  	},
1191
1192  	// @method getSouthWest(): LatLng
1193  	// Returns the south-west point of the bounds.
1194  	getSouthWest: function () {
1195  		return this._southWest;
1196  	},
1197
1198  	// @method getNorthEast(): LatLng
1199  	// Returns the north-east point of the bounds.
1200  	getNorthEast: function () {
1201  		return this._northEast;
1202  	},
1203
1204  	// @method getNorthWest(): LatLng
1205  	// Returns the north-west point of the bounds.
1206  	getNorthWest: function () {
1207  		return new LatLng(this.getNorth(), this.getWest());
1208  	},
1209
1210  	// @method getSouthEast(): LatLng
1211  	// Returns the south-east point of the bounds.
1212  	getSouthEast: function () {
1213  		return new LatLng(this.getSouth(), this.getEast());
1214  	},
1215
1216  	// @method getWest(): Number
1217  	// Returns the west longitude of the bounds
1218  	getWest: function () {
1219  		return this._southWest.lng;
1220  	},
1221
1222  	// @method getSouth(): Number
1223  	// Returns the south latitude of the bounds
1224  	getSouth: function () {
1225  		return this._southWest.lat;
1226  	},
1227
1228  	// @method getEast(): Number
1229  	// Returns the east longitude of the bounds
1230  	getEast: function () {
1231  		return this._northEast.lng;
1232  	},
1233
1234  	// @method getNorth(): Number
1235  	// Returns the north latitude of the bounds
1236  	getNorth: function () {
1237  		return this._northEast.lat;
1238  	},
1239
1240  	// @method contains(otherBounds: LatLngBounds): Boolean
1241  	// Returns `true` if the rectangle contains the given one.
1242
1243  	// @alternative
1244  	// @method contains (latlng: LatLng): Boolean
1245  	// Returns `true` if the rectangle contains the given point.
1246  	contains: function (obj) { // (LatLngBounds) or (LatLng) -> Boolean
1247  		if (typeof obj[0] === 'number' || obj instanceof LatLng || 'lat' in obj) {
1248  			obj = toLatLng(obj);
1249  		} else {
1250  			obj = toLatLngBounds(obj);
1251  		}
1252
1253  		var sw = this._southWest,
1254  		    ne = this._northEast,
1255  		    sw2, ne2;
1256
1257  		if (obj instanceof LatLngBounds) {
1258  			sw2 = obj.getSouthWest();
1259  			ne2 = obj.getNorthEast();
1260  		} else {
1261  			sw2 = ne2 = obj;
1262  		}
1263
1264  		return (sw2.lat >= sw.lat) && (ne2.lat <= ne.lat) &&
1265  		       (sw2.lng >= sw.lng) && (ne2.lng <= ne.lng);
1266  	},
1267
1268  	// @method intersects(otherBounds: LatLngBounds): Boolean
1269  	// Returns `true` if the rectangle intersects the given bounds. Two bounds intersect if they have at least one point in common.
1270  	intersects: function (bounds) {
1271  		bounds = toLatLngBounds(bounds);
1272
1273  		var sw = this._southWest,
1274  		    ne = this._northEast,
1275  		    sw2 = bounds.getSouthWest(),
1276  		    ne2 = bounds.getNorthEast(),
1277
1278  		    latIntersects = (ne2.lat >= sw.lat) && (sw2.lat <= ne.lat),
1279  		    lngIntersects = (ne2.lng >= sw.lng) && (sw2.lng <= ne.lng);
1280
1281  		return latIntersects && lngIntersects;
1282  	},
1283
1284  	// @method overlaps(otherBounds: LatLngBounds): Boolean
1285  	// Returns `true` if the rectangle overlaps the given bounds. Two bounds overlap if their intersection is an area.
1286  	overlaps: function (bounds) {
1287  		bounds = toLatLngBounds(bounds);
1288
1289  		var sw = this._southWest,
1290  		    ne = this._northEast,
1291  		    sw2 = bounds.getSouthWest(),
1292  		    ne2 = bounds.getNorthEast(),
1293
1294  		    latOverlaps = (ne2.lat > sw.lat) && (sw2.lat < ne.lat),
1295  		    lngOverlaps = (ne2.lng > sw.lng) && (sw2.lng < ne.lng);
1296
1297  		return latOverlaps && lngOverlaps;
1298  	},
1299
1300  	// @method toBBoxString(): String
1301  	// 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.
1302  	toBBoxString: function () {
1303  		return [this.getWest(), this.getSouth(), this.getEast(), this.getNorth()].join(',');
1304  	},
1305
1306  	// @method equals(otherBounds: LatLngBounds, maxMargin?: Number): Boolean
1307  	// 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.
1308  	equals: function (bounds, maxMargin) {
1309  		if (!bounds) { return false; }
1310
1311  		bounds = toLatLngBounds(bounds);
1312
1313  		return this._southWest.equals(bounds.getSouthWest(), maxMargin) &&
1314  		       this._northEast.equals(bounds.getNorthEast(), maxMargin);
1315  	},
1316
1317  	// @method isValid(): Boolean
1318  	// Returns `true` if the bounds are properly initialized.
1319  	isValid: function () {
1320  		return !!(this._southWest && this._northEast);
1321  	}
1322  };
1323
1324  // TODO International date line?
1325
1326  // @factory L.latLngBounds(corner1: LatLng, corner2: LatLng)
1327  // Creates a `LatLngBounds` object by defining two diagonally opposite corners of the rectangle.
1328
1329  // @alternative
1330  // @factory L.latLngBounds(latlngs: LatLng[])
1331  // 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).
1332  function toLatLngBounds(a, b) {
1333  	if (a instanceof LatLngBounds) {
1334  		return a;
1335  	}
1336  	return new LatLngBounds(a, b);
1337  }
1338
1339  /* @class LatLng
1340   * @aka L.LatLng
1341   *
1342   * Represents a geographical point with a certain latitude and longitude.
1343   *
1344   * @example
1345   *
1346   * ```
1347   * var latlng = L.latLng(50.5, 30.5);
1348   * ```
1349   *
1350   * 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:
1351   *
1352   * ```
1353   * map.panTo([50, 30]);
1354   * map.panTo({lon: 30, lat: 50});
1355   * map.panTo({lat: 50, lng: 30});
1356   * map.panTo(L.latLng(50, 30));
1357   * ```
1358   *
1359   * Note that `LatLng` does not inherit from Leaflet's `Class` object,
1360   * which means new classes can't inherit from it, and new methods
1361   * can't be added to it with the `include` function.
1362   */
1363
1364  function LatLng(lat, lng, alt) {
1365  	if (isNaN(lat) || isNaN(lng)) {
1366  		throw new Error('Invalid LatLng object: (' + lat + ', ' + lng + ')');
1367  	}
1368
1369  	// @property lat: Number
1370  	// Latitude in degrees
1371  	this.lat = +lat;
1372
1373  	// @property lng: Number
1374  	// Longitude in degrees
1375  	this.lng = +lng;
1376
1377  	// @property alt: Number
1378  	// Altitude in meters (optional)
1379  	if (alt !== undefined) {
1380  		this.alt = +alt;
1381  	}
1382  }
1383
1384  LatLng.prototype = {
1385  	// @method equals(otherLatLng: LatLng, maxMargin?: Number): Boolean
1386  	// 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.
1387  	equals: function (obj, maxMargin) {
1388  		if (!obj) { return false; }
1389
1390  		obj = toLatLng(obj);
1391
1392  		var margin = Math.max(
1393  		        Math.abs(this.lat - obj.lat),
1394  		        Math.abs(this.lng - obj.lng));
1395
1396  		return margin <= (maxMargin === undefined ? 1.0E-9 : maxMargin);
1397  	},
1398
1399  	// @method toString(): String
1400  	// Returns a string representation of the point (for debugging purposes).
1401  	toString: function (precision) {
1402  		return 'LatLng(' +
1403  		        formatNum(this.lat, precision) + ', ' +
1404  		        formatNum(this.lng, precision) + ')';
1405  	},
1406
1407  	// @method distanceTo(otherLatLng: LatLng): Number
1408  	// 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).
1409  	distanceTo: function (other) {
1410  		return Earth.distance(this, toLatLng(other));
1411  	},
1412
1413  	// @method wrap(): LatLng
1414  	// Returns a new `LatLng` object with the longitude wrapped so it's always between -180 and +180 degrees.
1415  	wrap: function () {
1416  		return Earth.wrapLatLng(this);
1417  	},
1418
1419  	// @method toBounds(sizeInMeters: Number): LatLngBounds
1420  	// Returns a new `LatLngBounds` object in which each boundary is `sizeInMeters/2` meters apart from the `LatLng`.
1421  	toBounds: function (sizeInMeters) {
1422  		var latAccuracy = 180 * sizeInMeters / 40075017,
1423  		    lngAccuracy = latAccuracy / Math.cos((Math.PI / 180) * this.lat);
1424
1425  		return toLatLngBounds(
1426  		        [this.lat - latAccuracy, this.lng - lngAccuracy],
1427  		        [this.lat + latAccuracy, this.lng + lngAccuracy]);
1428  	},
1429
1430  	clone: function () {
1431  		return new LatLng(this.lat, this.lng, this.alt);
1432  	}
1433  };
1434
1435
1436
1437  // @factory L.latLng(latitude: Number, longitude: Number, altitude?: Number): LatLng
1438  // Creates an object representing a geographical point with the given latitude and longitude (and optionally altitude).
1439
1440  // @alternative
1441  // @factory L.latLng(coords: Array): LatLng
1442  // Expects an array of the form `[Number, Number]` or `[Number, Number, Number]` instead.
1443
1444  // @alternative
1445  // @factory L.latLng(coords: Object): LatLng
1446  // Expects an plain object of the form `{lat: Number, lng: Number}` or `{lat: Number, lng: Number, alt: Number}` instead.
1447
1448  function toLatLng(a, b, c) {
1449  	if (a instanceof LatLng) {
1450  		return a;
1451  	}
1452  	if (isArray(a) && typeof a[0] !== 'object') {
1453  		if (a.length === 3) {
1454  			return new LatLng(a[0], a[1], a[2]);
1455  		}
1456  		if (a.length === 2) {
1457  			return new LatLng(a[0], a[1]);
1458  		}
1459  		return null;
1460  	}
1461  	if (a === undefined || a === null) {
1462  		return a;
1463  	}
1464  	if (typeof a === 'object' && 'lat' in a) {
1465  		return new LatLng(a.lat, 'lng' in a ? a.lng : a.lon, a.alt);
1466  	}
1467  	if (b === undefined) {
1468  		return null;
1469  	}
1470  	return new LatLng(a, b, c);
1471  }
1472
1473  /*
1474   * @namespace CRS
1475   * @crs L.CRS.Base
1476   * Object that defines coordinate reference systems for projecting
1477   * geographical points into pixel (screen) coordinates and back (and to
1478   * coordinates in other units for [WMS](https://en.wikipedia.org/wiki/Web_Map_Service) services). See
1479   * [spatial reference system](http

1581  		return new LatLng(lat, lng, alt);
1582  	},
1583
1584  	// @method wrapLatLngBounds(bounds: LatLngBounds): LatLngBounds
1585  	// Returns a `LatLngBounds` with the same size as the given one, ensuring
1586  	// that its center is within the CRS's bounds.
1587  	// Only accepts actual `L.LatLngBounds` instances, not arrays.
1588  	wrapLatLngBounds: function (bounds) {
1589  		var center = bounds.getCenter(),
1590  		    newCenter = this.wrapLatLng(center),
1591  		    latShift = center.lat - newCenter.lat,
1592  		    lngShift = center.lng - newCenter.lng;
1593
1594  		if (latShift === 0 && lngShift === 0) {
1595  			return bounds;
1596  		}
1597
1598  		var sw = bounds.getSouthWest(),
1599  		    ne = bounds.getNorthEast(),
1600  		    newSw = new LatLng(sw.lat - latShift, sw.lng - lngShift),
1601  		    newNe = new LatLng(ne.lat - latShift, ne.lng - lngShift);
1602
1603  		return new LatLngBounds(newSw, newNe);
1604  	}
1605  };
1606
1607  /*
1608   * @namespace CRS
1609   * @crs L.CRS.Earth
1610   *
1611   * Serves as the base for CRS that are global such that they cover the earth.
1612   * Can only be used as the base for other CRS and cannot be used directly,
1613   * since it does not have a `code`, `projection` or `transformation`. `distance()` returns
1614   * meters.
1615   */
1616
1617  var Earth = extend({}, CRS, {
1618  	wrapLng: [-180, 180],
1619
1620  	// Mean Earth Radius, as recommended for use by
1621  	// the International Union of Geodesy and Geophysics,
1622  	// see http://rosettacode.org/wiki/Haversine_formula
1623  	R: 6371000,
1624
1625  	// distance between two geographical points using spherical law of cosines approximation
1626  	distance: function (latlng1, latlng2) {
1627  		var rad = Math.PI / 180,
1628  		    lat1 = latlng1.lat * rad,
1629  		    lat2 = latlng2.lat * rad,
1630  		    sinDLat = Math.sin((latlng2.lat - latlng1.lat) * rad / 2),
1631  		    sinDLon = Math.sin((latlng2.lng - latlng1.lng) * rad / 2),
1632  		    a = sinDLat * sinDLat + Math.cos(lat1) * Math.cos(lat2) * sinDLon * sinDLon,
1633  		    c = 2 * Math.atan2(Math.sqrt(a), Math.sqrt(1 - a));
1634  		return this.R * c;
1635  	}
1636  });
1637
1638  /*
1639   * @namespace Projection
1640   * @projection L.Projection.SphericalMercator
1641   *
1642   * Spherical Mercator projection — the most common projection for online maps,
1643   * used by almost all free and commercial tile providers. Assumes that Earth is
1644   * a sphere. Used by the `EPSG:3857` CRS.
1645   */
1646
1647  var earthRadius = 6378137;
1648
1649  var SphericalMercator = {
1650
1651  	R: earthRadius,
1652  	MAX_LATITUDE: 85.0511287798,
1653
1654  	project: function (latlng) {
1655  		var d = Math.PI / 180,
1656  		    max = this.MAX_LATITUDE,
1657  		    lat = Math.max(Math.min(max, latlng.lat), -max),
1658  		    sin = Math.sin(lat * d);
1659
1660  		return new Point(
1661  			this.R * latlng.lng * d,
1662  			this.R * Math.log((1 + sin) / (1 - sin)) / 2);
1663  	},
1664
1665  	unproject: function (point) {
1666  		var d = 180 / Math.PI;
1667
1668  		return new LatLng(
1669  			(2 * Math.atan(Math.exp(point.y / this.R)) - (Math.PI / 2)) * d,
1670  			point.x * d / this.R);
1671  	},
1672
1673  	bounds: (function () {
1674  		var d = earthRadius * Math.PI;
1675  		return new Bounds([-d, -d], [d, d]);
1676  	})()
1677  };
1678
1679  /*
1680   * @class Transformation
1681   * @aka L.Transformation
1682   *
1683   * Represents an affine transformation: a set of coefficients `a`, `b`, `c`, `d`
1684   * for transforming a point of a form `(x, y)` into `(a*x + b, c*y + d)` and doing
1685   * the reverse. Used by Leaflet in its projections code.
1686   *
1687   * @example
1688   *
1689   * ```js
1690   * var transformation = L.transformation(2, 5, -1, 10),
1691   * 	p = L.point(1, 2),
1692   * 	p2 = transformation.transform(p), //  L.point(7, 8)
1693   * 	p3 = transformation.untransform(p2); //  L.point(1, 2)
1694   * ```
1695   */
1696
1697
1698  // factory new L.Transformation(a: Number, b: Number, c: Number, d: Number)
1699  // Creates a `Transformation` object with the given coefficients.
1700  function Transformation(a, b, c, d) {
1701  	if (isArray(a)) {
1702  		// use array properties
1703  		this._a = a[0];
1704  		this._b = a[1];
1705  		this._c = a[2];
1706  		this._d = a[3];
1707  		return;
1708  	}
1709  	this._a = a;
1710  	this._b = b;
1711  	this._c = c;
1712  	this._d = d;
1713  }
1714
1715  Transformation.prototype = {
1716  	// @method transform(point: Point, scale?: Number): Point
1717  	// Returns a transformed point, optionally multiplied by the given scale.
1718  	// Only accepts actual `L.Point` instances, not arrays.
1719  	transform: function (point, scale) { // (Point, Number) -> Point
1720  		return this._transform(point.clone(), scale);
1721  	},
1722
1723  	// destructive transform (faster)
1724  	_transform: function (point, scale) {
1725  		scale = scale || 1;
1726  		point.x = scale * (this._a * point.x + this._b);
1727  		point.y = scale * (this._c * point.y + this._d);
1728  		return point;
1729  	},
1730
1731  	// @method untransform(point: Point, scale?: Number): Point
1732  	// Returns the reverse transformation of the given point, optionally divided
1733  	// by the given scale. Only accepts actual `L.Point` instances, not arrays.
1734  	untransform: function (point, scale) {
1735  		scale = scale || 1;
1736  		return new Point(
1737  		        (point.x / scale - this._b) / this._a,
1738  		        (point.y / scale - this._d) / this._c);
1739  	}
1740  };
1741
1742  // factory L.transformation(a: Number, b: Number, c: Number, d: Number)
1743
1744  // @factory L.transformation(a: Number, b: Number, c: Number, d: Number)
1745  // Instantiates a Transformation object with the given coefficients.
1746
1747  // @alternative
1748  // @factory L.transformation(coefficients: Array): Transformation
1749  // Expects an coefficients array of the form
1750  // `[a: Number, b: Number, c: Number, d: Number]`.
1751
1752  function toTransformation(a, b, c, d) {
1753  	return new Transformation(a, b, c, d);
1754  }
1755
1756  /*
1757   * @namespace CRS
1758   * @crs L.CRS.EPSG3857
1759   *
1760   * The most common CRS for online maps, used by almost all free and commercial
1761   * tile providers. Uses Spherical Mercator projection. Set in by default in
1762   * Map's `crs` option.
1763   */
1764
1765  var EPSG3857 = extend({}, Earth, {
1766  	code: 'EPSG:3857',
1767  	projection: SphericalMercator,
1768
1769  	transformation: (function () {
1770  		var scale = 0.5 / (Math.PI * SphericalMercator.R);
1771  		return toTransformation(scale, 0.5, -scale, 0.5);
1772  	}())
1773  });
1774
1775  var EPSG900913 = extend({}, EPSG3857, {
1776  	code: 'EPSG:900913'
1777  });
1778
1779  // @namespace SVG; @section
1780  // There are several static functions which can be called without instantiating L.SVG:
1781
1782  // @function create(name: String): SVGElement
1783  // Returns a instance of [SVGElement](https://developer.mozilla.org/docs/Web/API/SVGElement),
1784  // corresponding to the class name passed. For example, using 'line' will return
1785  // an instance of [SVGLineElement](https://developer.mozilla.org/docs/Web/API/SVGLineElement).
1786  function svgCreate(name) {
1787  	return document.createElementNS('http://www.w3.org/2000/svg', name);
1788  }
1789
1790  // @function pointsToPath(rings: Point[], closed: Boolean): String
1791  // Generates a SVG path string for multiple rings, with each ring turning
1792  // into "M..L..L.." instructions
1793  function pointsToPath(rings, closed) {
1794  	var str = '',
1795  	i, j, len, len2, points, p;
1796
1797  	for (i = 0, len = rings.length; i < len; i++) {
1798  		points = rings[i];
1799
1800  		for (j = 0, len2 = points.length; j < len2; j++) {
1801  			p = points[j];
1802  			str += (j ? 'L' : 'M') + p.x + ' ' + p.y;
1803  		}
1804
1805  		// closes the ring for polygons; "x" is VML syntax
1806  		str += closed ? (svg$1 ? 'z' : 'x') : '';
1807  	}
1808
1809  	// SVG complains about empty path strings
1810  	return str || 'M0 0';
1811  }
1812
1813  /*
1814   * @namespace Browser
1815   * @aka L.Browser
1816   *
1817   * A namespace with static properties for browser/feature detection used by Leaflet internally.
1818   *
1819   * @example
1820   *
1821   * ```js
1822   * if (L.Browser.ielt9) {
1823   *   alert('Upgrade your browser, dude!');
1824   * }
1825   * ```
1826   */
1827
1828  var style = document.documentElement.style;
1829
1830  // @property ie: Boolean; `true` for all Internet Explorer versions (not Edge).
1831  var ie = 'ActiveXObject' in window;
1832
1833  // @property ielt9: Boolean; `true` for Internet Explorer versions less than 9.
1834  var ielt9 = ie && !document.addEventListener;
1835
1836  // @property edge: Boolean; `true` for the Edge web browser.
1837  var edge = 'msLaunchUri' in navigator && !('documentMode' in document);
1838
1839  // @property webkit: Boolean;
1840  // `true` for webkit-based browsers like Chrome and Safari (including mobile versions).
1841  var webkit = userAgentContains('webkit');
1842
1843  // @property android: Boolean
1844  // `true` for any browser running on an Android platform.
1845  var android = userAgentContains('android');
1846
1847  // @property android23: Boolean; `true` for browsers running on Android 2 or Android 3.
1848  var android23 = userAgentContains('android 2') || userAgentContains('android 3');
1849
1850  /* See https://stackoverflow.com/a/17961266 for details on detecting stock Android */
1851  var webkitVer = parseInt(/WebKit\/([0-9]+)|$/.exec(navigator.userAgent)[1], 10); // also matches AppleWebKit
1852  // @property androidStock: Boolean; `true` for the Android stock browser (i.e. not Chrome)
1853  var androidStock = android && userAgentContains('Google') && webkitVer < 537 && !('AudioNode' in window);
1854
1855  // @property opera: Boolean; `true` for the Opera browser
1856  var opera = !!window.opera;
1857
1858  // @property chrome: Boolean; `true` for the Chrome browser.
1859  var chrome = !edge && userAgentContains('chrome');
1860
1861  // @property gecko: Boolean; `true` for gecko-based browsers like Firefox.
1862  var gecko = userAgentContains('gecko') && !webkit && !opera && !ie;
1863
1864  // @property safari: Boolean; `true` for the Safari browser.
1865  var safari = !chrome && userAgentContains('safari');
1866
1867  var phantom = userAgentContains('phantom');
1868
1869  // @property opera12: Boolean
1870  // `true` for the Opera browser supporting CSS transforms (version 12 or later).
1871  var opera12 = 'OTransition' in style;
1872
1873  // @property win: Boolean; `true` when the browser is running in a Windows platform
1874  var win = navigator.platform.indexOf('Win') === 0;
1875
1876  // @property ie3d: Boolean; `true` for all Internet Explorer versions supporting CSS transforms.
1877  var ie3d = ie && ('transition' in style);
1878
1879  // @property webkit3d: Boolean; `true` for webkit-based browsers supporting CSS transforms.
1880  var webkit3d = ('WebKitCSSMatrix' in window) && ('m11' in new window.WebKitCSSMatrix()) && !android23;
1881
1882  // @property gecko3d: Boolean; `true` for gecko-based browsers supporting CSS transforms.
1883  var gecko3d = 'MozPerspective' in style;
1884
1885  // @property any3d: Boolean
1886  // `true` for all browsers supporting CSS transforms.
1887  var any3d = !window.L_DISABLE_3D && (ie3d || webkit3d || gecko3d) && !opera12 && !phantom;
1888
1889  // @property mobile: Boolean; `true` for all browsers running in a mobile device.
1890  var mobile = typeof orientation !== 'undefined' || userAgentContains('mobile');
1891
1892  // @property mobileWebkit: Boolean; `true` for all webkit-based browsers in a mobile device.
1893  var mobileWebkit = mobile && webkit;
1894
1895  // @property mobileWebkit3d: Boolean
1896  // `true` for all webkit-based browsers in a mobile device supporting CSS transforms.
1897  var mobileWebkit3d = mobile && webkit3d;
1898
1899  // @property msPointer: Boolean
1900  // `true` for browsers implementing the Microsoft touch events model (notably IE10).
1901  var msPointer = !window.PointerEvent && window.MSPointerEvent;
1902
1903  // @property pointer: Boolean
1904  // `true` for all browsers supporting [pointer events](https://msdn.microsoft.com/en-us/library/dn433244%28v=vs.85%29.aspx).
1905  var pointer = !!(window.PointerEvent || msPointer);
1906
1907  // @property touch: Boolean
1908  // `true` for all browsers supporting [touch events](https://developer.mozilla.org/docs/Web/API/Touch_events).
1909  // This does not necessarily mean that the browser is running in a computer with
1910  // a touchscreen, it only means that the browser is capable of understanding
1911  // touch events.
1912  var touch = !window.L_NO_TOUCH && (pointer || 'ontouchstart' in window ||
1913  		(window.DocumentTouch && document instanceof window.DocumentTouch));
1914
1915  // @property mobileOpera: Boolean; `true` for the Opera browser in a mobile device.
1916  var mobileOpera = mobile && opera;
1917
1918  // @property mobileGecko: Boolean
1919  // `true` for gecko-based browsers running in a mobile device.
1920  var mobileGecko = mobile && gecko;
1921
1922  // @property retina: Boolean
1923  // `true` for browsers on a high-resolution "retina" screen or on any screen when browser's display zoom is more than 100%.
1924  var retina = (window.devicePixelRatio || (window.screen.deviceXDPI / window.screen.logicalXDPI)) > 1;
1925
1926  // @property passiveEvents: Boolean
1927  // `true` for browsers that support passive events.
1928  var passiveEvents = (function () {
1929  	var supportsPassiveOption = false;
1930  	try {
1931  		var opts = Object.defineProperty({}, 'passive', {
1932  			get: function () { // eslint-disable-line getter-return
1933  				supportsPassiveOption = true;
1934  			}
1935  		});
1936  		window.addEventListener('testPassiveEventSupport', falseFn, opts);
1937  		window.removeEventListener('testPassiveEventSupport', falseFn, opts);
1938  	} catch (e) {
1939  		// Errors can safely be ignored since this is only a browser support test.
1940  	}
1941  	return supportsPassiveOption;
1942  }());
1943
1944  // @property canvas: Boolean
1945  // `true` when the browser supports [`<canvas>`](https://developer.mozilla.org/docs/Web/API/Canvas_API).
1946  var canvas$1 = (function () {
1947  	return !!document.createElement('canvas').getContext;
1948  }());
1949
1950  // @property svg: Boolean
1951  // `true` when the browser supports [SVG](https://developer.mozilla.org/docs/Web/SVG).
1952  var svg$1 = !!(document.createElementNS && svgCreate('svg').createSVGRect);
1953
1954  // @property vml: Boolean
1955  // `true` if the browser supports [VML](https://en.wikipedia.org/wiki/Vector_Markup_Language).
1956  var vml = !svg$1 && (function () {
1957  	try {
1958  		var div = document.createElement('div');
1959  		div.innerHTML = '<v:shape adj="1"/>';
1960
1961  		var shape = div.firstChild;
1962  		shape.style.behavior = 'url(#default#VML)';
1963
1964  		return shape && (typeof shape.adj === 'object');
1965
1966  	} catch (e) {
1967  		return false;
1968  	}
1969  }());
1970
1971
1972  function userAgentContains(str) {
1973  	return navigator.userAgent.toLowerCase().indexOf(str) >= 0;
1974  }
1975
1976  var Browser = {
1977    __proto__: null,
1978    ie: ie,
1979    ielt9: ielt9,
1980    edge: edge,
1981    webkit: webkit,
1982    android: android,
1983    android23: android23,
1984    androidStock: androidStock,
1985    opera: opera,
1986    chrome: chrome,
1987    gecko: gecko,
1988    safari: safari,
1989    phantom: phantom,
1990    opera12: opera12,
1991    win: win,
1992    ie3d: ie3d,
1993    webkit3d: webkit3d,
1994    gecko3d: gecko3d,
1995    any3d: any3d,
1996    mobile: mobile,
1997    mobileWebkit: mobileWebkit,
1998    mobileWebkit3d: mobileWebkit3d,

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