https://benais.fr/wp-content/themes/cctoval/js/leaflet-src.js

1/* @preserve
2 * Leaflet 1.7.1+master.0a61e90, a JS library for interactive maps. http://leafletjs.com
3 * (c) 2010-2021 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.7.1+master.0a61e906";
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  	if (!('_leaflet_id' in obj)) {
69  		obj['_leaflet_id'] = ++lastId;
70  	}
71  	return obj._leaflet_id;
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, precision?: Number|false): Number
125  // Returns the number `num` rounded with specified `precision`.
126  // The default `precision` value is 6 decimal places.
127  // `false` can be passed to skip any processing (can be useful to avoid round-off errors).
128  function formatNum(num, precision) {
129  	if (precision === false) { return num; }
130  	var pow = Math.pow(10, precision === undefined ? 6 : precision);
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)
136  function 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.
142  function 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.
148  function setOptions(obj, options) {
149  	if (!Object.prototype.hasOwnProperty.call(obj, 'options')) {
150  		obj.options = obj.options ? create$2(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'`)
163  function 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
171  var 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.
178  function 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)
194  var 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)
200  function 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).
211  var emptyImageUrl = 'data:image/gif;base64,R0lGODlhAQABAAD/ACwAAAAAAQABAAACADs=';
212
213  // inspired by http://paulirish.com/2011/requestanimationframe-for-smart-animating/
214
215  function getPrefixed(name) {
216  	return window['webkit' + name] || window['moz' + name] || window['ms' + name];
217  }
218
219  var lastTime = 0;
220
221  // fallback for IE 7-8
222  function 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
230  var requestFn = window.requestAnimationFrame || getPrefixed('RequestAnimationFrame') || timeoutDefer;
231  var cancelFn = window.cancelAnimationFrame || getPrefixed('CancelAnimationFrame') ||
232  		getPrefixed('CancelRequestAnimationFrame') || function (id) { window.clearTimeout(id); };
233
234  // @function requestAnimFrame(fn: Function, context?: Object, immediate?: Boolean): Number
235  // Schedules `fn` to be executed when the browser repaints. `fn` is bound to
236  // `context` if given. When `immediate` is set, `fn` is called immediately if
237  // the browser doesn't have native support for
238  // [`window.requestAnimationFrame`](https://developer.mozilla.org/docs/Web/API/window/requestAnimationFrame),
239  // otherwise it's delayed. Returns a request ID that can be used to cancel the request.
240  function requestAnimFrame(fn, context, immediate) {
241  	if (immediate && requestFn === timeoutDefer) {
242  		fn.call(context);
243  	} else {
244  		return requestFn.call(window, bind(fn, context));
245  	}
246  }
247
248  // @function cancelAnimFrame(id: Number): undefined
249  // Cancels a previous `requestAnimFrame`. See also [window.cancelAnimationFrame](https://developer.mozilla.org/docs/Web/API/window/cancelAnimationFrame).
250  function cancelAnimFrame(id) {
251  	if (id) {
252  		cancelFn.call(window, id);
253  	}
254  }
255
256  var Util = {
257    __proto__: null,
258    extend: extend,
259    create: create$2,
260    bind: bind,
261    get lastId () { return lastId; },
262    stamp: stamp,
263    throttle: throttle,
264    wrapNum: wrapNum,
265    falseFn: falseFn,
266    formatNum: formatNum,
267    trim: trim,
268    splitWords: splitWords,
269    setOptions: setOptions,
270    getParamString: getParamString,
271    template: template,
272    isArray: isArray,
273    indexOf: indexOf,
274    emptyImageUrl: emptyImageUrl,
275    requestFn: requestFn,
276    cancelFn: cancelFn,
277    requestAnimFrame: requestAnimFrame,
278    cancelAnimFrame: cancelAnimFrame
279  };
280
281  // @class Class
282  // @aka L.Class
283
284  // @section
285  // @uninheritable
286
287  // Thanks to John Resig and Dean Edwards for inspiration!
288
289  function Class() {}
290
291  Class.extend = function (props) {
292
293  	// @function extend(props: Object): Function
294  	// [Extends the current class](#class-inheritance) given the properties to be included.
295  	// Returns a Javascript function that is a class constructor (to be called with `new`).
296  	var NewClass = function () {
297
298  		// call the constructor
299  		if (this.initialize) {
300  			this.initialize.apply(this, arguments);
301  		}
302
303  		// call all constructor hooks
304  		this.callInitHooks();
305  	};
306
307  	var parentProto = NewClass.__super__ = this.prototype;
308
309  	var proto = create$2(parentProto);
310  	proto.constructor = NewClass;
311
312  	NewClass.prototype = proto;
313
314  	// inherit parent's statics
315  	for (var i in this) {
316  		if (Object.prototype.hasOwnProperty.call(this, i) && i !== 'prototype' && i !== '__super__') {
317  			NewClass[i] = this[i];
318  		}
319  	}
320
321  	// mix static properties into the class
322  	if (props.statics) {
323  		extend(NewClass, props.statics);
324  	}
325
326  	// mix includes into the prototype
327  	if (props.includes) {
328  		checkDeprecatedMixinEvents(props.includes);
329  		extend.apply(null, [proto].concat(props.includes));
330  	}
331
332  	// mix given properties into the prototype
333  	extend(proto, props);
334  	delete proto.statics;
335  	delete proto.includes;
336
337  	// merge options
338  	if (proto.options) {
339  		proto.options = parentProto.options ? create$2(parentProto.options) : {};
340  		extend(proto.options, props.options);
341  	}
342
343  	proto._initHooks = [];
344
345  	// add method for calling all hooks
346  	proto.callInitHooks = function () {
347
348  		if (this._initHooksCalled) { return; }
349
350  		if (parentProto.callInitHooks) {
351  			parentProto.callInitHooks.call(this);
352  		}
353
354  		this._initHooksCalled = true;
355
356  		for (var i = 0, len = proto._initHooks.length; i < len; i++) {
357  			proto._initHooks[i].call(this);
358  		}
359  	};
360
361  	return NewClass;
362  };
363
364
365  // @function include(properties: Object): this
366  // [Includes a mixin](#class-includes) into the current class.
367  Class.include = function (props) {
368  	var parentOptions = this.prototype.options;
369  	extend(this.prototype, props);
370  	if (props.options) {
371  		this.prototype.options = parentOptions;
372  		this.mergeOptions(props.options);
373  	}
374  	return this;
375  };
376
377  // @function mergeOptions(options: Object): this
378  // [Merges `options`](#class-options) into the defaults of the class.
379  Class.mergeOptions = function (options) {
380  	extend(this.prototype.options, options);
381  	return this;
382  };
383
384  // @function addInitHook(fn: Function): this
385  // Adds a [constructor hook](#class-constructor-hooks) to the class.
386  Class.addInitHook = function (fn) { // (Function) || (String, args...)
387  	var args = Array.prototype.slice.call(arguments, 1);
388
389  	var init = typeof fn === 'function' ? fn : function () {
390  		this[fn].apply(this, args);
391  	};
392
393  	this.prototype._initHooks = this.prototype._initHooks || [];
394  	this.prototype._initHooks.push(init);
395  	return this;
396  };
397
398  function checkDeprecatedMixinEvents(includes) {
399  	if (typeof L === 'undefined' || !L || !L.Mixin) { return; }
400
401  	includes = isArray(includes) ? includes : [includes];
402
403  	for (var i = 0; i < includes.length; i++) {
404  		if (includes[i] === L.Mixin.Events) {

596  		if (!this.listens(type, propagate)) { return this; }
597
598  		var event = extend({}, data, {
599  			type: type,
600  			target: this,
601  			sourceTarget: data && data.sourceTarget || this
602  		});
603
604  		if (this._events) {
605  			var listeners = this._events[type];
606
607  			if (listeners) {
608  				this._firingCount = (this._firingCount + 1) || 1;
609  				for (var i = 0, len = listeners.length; i < len; i++) {
610  					var l = listeners[i];
611  					l.fn.call(l.ctx || this, event);
612  				}
613
614  				this._firingCount--;
615  			}
616  		}
617
618  		if (propagate) {
619  			// propagate the event to parents (set with addEventParent)
620  			this._propagateEvent(event);
621  		}
622
623  		return this;
624  	},
625
626  	// @method listens(type: String, propagate?: Boolean): Boolean
627  	// Returns `true` if a particular event type has any listeners attached to it.
628  	// The verification can optionally be propagated, it will return `true` if parents have the listener attached to it.
629  	listens: function (type, propagate) {
630  		if (typeof type !== 'string') {
631  			console.warn('"string" type argument expected');
632  		}
633  		var listeners = this._events && this._events[type];
634  		if (listeners && listeners.length) { return true; }
635
636  		if (propagate) {
637  			// also check parents for listeners if event propagates
638  			for (var id in this._eventParents) {
639  				if (this._eventParents[id].listens(type, propagate)) { return true; }
640  			}
641  		}
642  		return false;
643  	},
644
645  	// @method once(…): this
646  	// Behaves as [`on(…)`](#evented-on), except the listener will only get fired once and then removed.
647  	once: function (types, fn, context) {
648
649  		if (typeof types === 'object') {
650  			for (var type in types) {
651  				this.once(type, types[type], fn);
652  			}
653  			return this;
654  		}
655
656  		var handler = bind(function () {
657  			this
658  			    .off(types, fn, context)
659  			    .off(types, handler, context);
660  		}, this);
661
662  		// add a listener that's executed once and removed after that
663  		return this
664  		    .on(types, fn, context)
665  		    .on(types, handler, context);
666  	},
667
668  	// @method addEventParent(obj: Evented): this
669  	// Adds an event parent - an `Evented` that will receive propagated events
670  	addEventParent: function (obj) {
671  		this._eventParents = this._eventParents || {};
672  		this._eventParents[stamp(obj)] = obj;
673  		return this;
674  	},
675
676  	// @method removeEventParent(obj: Evented): this
677  	// Removes an event parent, so it will stop receiving propagated events
678  	removeEventParent: function (obj) {
679  		if (this._eventParents) {
680  			delete this._eventParents[stamp(obj)];
681  		}
682  		return this;
683  	},
684
685  	_propagateEvent: function (e) {
686  		for (var id in this._eventParents) {
687  			this._eventParents[id].fire(e.type, extend({
688  				layer: e.target,
689  				propagatedFrom: e.target
690  			}, e), true);
691  		}
692  	}
693  };
694
695  // aliases; we should ditch those eventually
696
697  // @method addEventListener(…): this
698  // Alias to [`on(…)`](#evented-on)
699  Events.addEventListener = Events.on;
700
701  // @method removeEventListener(…): this
702  // Alias to [`off(…)`](#evented-off)
703
704  // @method clearAllEventListeners(…): this
705  // Alias to [`off()`](#evented-off)
706  Events.removeEventListener = Events.clearAllEventListeners = Events.off;
707
708  // @method addOneTimeEventListener(…): this
709  // Alias to [`once(…)`](#evented-once)
710  Events.addOneTimeEventListener = Events.once;
711
712  // @method fireEvent(…): this
713  // Alias to [`fire(…)`](#evented-fire)
714  Events.fireEvent = Events.fire;
715
716  // @method hasEventListeners(…): Boolean
717  // Alias to [`listens(…)`](#evented-listens)
718  Events.hasEventListeners = Events.listens;
719
720  var Evented = Class.extend(Events);
721
722  /*
723   * @class Point
724   * @aka L.Point
725   *
726   * Represents a point with `x` and `y` coordinates in pixels.
727   *
728   * @example
729   *
730   * ```js
731   * var point = L.point(200, 300);
732   * ```
733   *
734   * 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:
735   *
736   * ```js
737   * map.panBy([200, 300]);
738   * map.panBy(L.point(200, 300));
739   * ```
740   *
741   * Note that `Point` does not inherit from Leaflet's `Class` object,
742   * which means new classes can't inherit from it, and new methods
743   * can't be added to it with the `include` function.
744   */
745
746  function Point(x, y, round) {
747  	// @property x: Number; The `x` coordinate of the point
748  	this.x = (round ? Math.round(x) : x);
749  	// @property y: Number; The `y` coordinate of the point
750  	this.y = (round ? Math.round(y) : y);
751  }
752
753  var trunc = Math.trunc || function (v) {
754  	return v > 0 ? Math.floor(v) : Math.ceil(v);
755  };
756
757  Point.prototype = {
758
759  	// @method clone(): Point
760  	// Returns a copy of the current point.
761  	clone: function () {
762  		return new Point(this.x, this.y);
763  	},
764
765  	// @method add(otherPoint: Point): Point
766  	// Returns the result of addition of the current and the given points.
767  	add: function (point) {
768  		// non-destructive, returns a new point
769  		return this.clone()._add(toPoint(point));
770  	},
771
772  	_add: function (point) {
773  		// destructive, used directly for performance in situations where it's safe to modify existing point
774  		this.x += point.x;
775  		this.y += point.y;
776  		return this;
777  	},
778
779  	// @method subtract(otherPoint: Point): Point
780  	// Returns the result of subtraction of the given point from the current.
781  	subtract: function (point) {
782  		return this.clone()._subtract(toPoint(point));
783  	},
784
785  	_subtract: function (point) {
786  		this.x -= point.x;
787  		this.y -= point.y;
788  		return this;
789  	},
790
791  	// @method divideBy(num: Number): Point
792  	// Returns the result of division of the current point by the given number.
793  	divideBy: function (num) {
794  		return this.clone()._divideBy(num);
795  	},
796
797  	_divideBy: function (num) {
798  		this.x /= num;
799  		this.y /= num;
800  		return this;
801  	},
802
803  	// @method multiplyBy(num: Number): Point
804  	// Returns the result of multiplication of the current point by the given number.
805  	multiplyBy: function (num) {
806  		return this.clone()._multiplyBy(num);
807  	},
808
809  	_multiplyBy: function (num) {
810  		this.x *= num;
811  		this.y *= num;
812  		return this;
813  	},
814
815  	// @method scaleBy(scale: Point): Point
816  	// Multiply each coordinate of the current point by each coordinate of
817  	// `scale`. In linear algebra terms, multiply the point by the
818  	// [scaling matrix](https://en.wikipedia.org/wiki/Scaling_%28geometry%29#Matrix_representation)
819  	// defined by `scale`.
820  	scaleBy: function (point) {
821  		return new Point(this.x * point.x, this.y * point.y);
822  	},
823
824  	// @method unscaleBy(scale: Point): Point
825  	// Inverse of `scaleBy`. Divide each coordinate of the current point by
826  	// each coordinate of `scale`.
827  	unscaleBy: function (point) {
828  		return new Point(this.x / point.x, this.y / point.y);
829  	},
830
831  	// @method round(): Point
832  	// Returns a copy of the current point with rounded coordinates.
833  	round: function () {
834  		return this.clone()._round();
835  	},
836
837  	_round: function () {
838  		this.x = Math.round(this.x);
839  		this.y = Math.round(this.y);
840  		return this;
841  	},
842
843  	// @method floor(): Point
844  	// Returns a copy of the current point with floored coordinates (rounded down).
845  	floor: function () {
846  		return this.clone()._floor();
847  	},
848
849  	_floor: function () {
850  		this.x = Math.floor(this.x);
851  		this.y = Math.floor(this.y);
852  		return this;
853  	},
854
855  	// @method ceil(): Point
856  	// Returns a copy of the current point with ceiled coordinates (rounded up).
857  	ceil: function () {
858  		return this.clone()._ceil();
859  	},
860
861  	_ceil: function () {
862  		this.x = Math.ceil(this.x);
863  		this.y = Math.ceil(this.y);
864  		return this;
865  	},
866
867  	// @method trunc(): Point
868  	// Returns a copy of the current point with truncated coordinates (rounded towards zero).
869  	trunc: function () {
870  		return this.clone()._trunc();
871  	},
872
873  	_trunc: function () {
874  		this.x = trunc(this.x);
875  		this.y = trunc(this.y);
876  		return this;
877  	},
878
879  	// @method distanceTo(otherPoint: Point): Number
880  	// Returns the cartesian distance between the current and the given points.
881  	distanceTo: function (point) {
882  		point = toPoint(point);
883
884  		var x = point.x - this.x,
885  		    y = point.y - this.y;
886
887  		return Math.sqrt(x * x + y * y);
888  	},
889
890  	// @method equals(otherPoint: Point): Boolean
891  	// Returns `true` if the given point has the same coordinates.
892  	equals: function (point) {
893  		point = toPoint(point);
894
895  		return point.x === this.x &&
896  		       point.y === this.y;
897  	},
898
899  	// @method contains(otherPoint: Point): Boolean
900  	// Returns `true` if both coordinates of the given point are less than the corresponding current point coordinates (in absolute values).
901  	contains: function (point) {
902  		point = toPoint(point);
903
904  		return Math.abs(point.x) <= Math.abs(this.x) &&
905  		       Math.abs(point.y) <= Math.abs(this.y);
906  	},
907
908  	// @method toString(): String
909  	// Returns a string representation of the point for debugging purposes.
910  	toString: function () {
911  		return 'Point(' +
912  		        formatNum(this.x) + ', ' +
913  		        formatNum(this.y) + ')';
914  	}
915  };
916
917  // @factory L.point(x: Number, y: Number, round?: Boolean)
918  // Creates a Point object with the given `x` and `y` coordinates. If optional `roun

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

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

2064
2065  // Provides a touch events wrapper for (ms)pointer events.
2066  // ref http://www.w3.org/TR/pointerevents/ https://www.w3.org/Bugs/Public/show_bug.cgi?id=22890
2067
2068  function addPointerListener(obj, type, handler) {
2069  	if (type === 'touchstart') {
2070  		_addPointerDocListener();
2071  	}
2072  	if (!handle[type]) {
2073  		console.warn('wrong event specified:', type);
2074  		return L.Util.falseFn;
2075  	}
2076  	handler = handle[type].bind(this, handler);
2077  	obj.addEventListener(pEvent[type], handler, false);
2078  	return handler;
2079  }
2080
2081  function removePointerListener(obj, type, handler) {
2082  	if (!pEvent[type]) {
2083  		console.warn('wrong event specified:', type);
2084  		return;
2085  	}
2086  	obj.removeEventListener(pEvent[type], handler, false);
2087  }
2088
2089  function _globalPointerDown(e) {
2090  	_pointers[e.pointerId] = e;
2091  }
2092
2093  function _globalPointerMove(e) {
2094  	if (_pointers[e.pointerId]) {
2095  		_pointers[e.pointerId] = e;
2096  	}
2097  }
2098
2099  function _globalPointerUp(e) {
2100  	delete _pointers[e.pointerId];
2101  }
2102
2103  function _addPointerDocListener() {
2104  	// need to keep track of what pointers and how many are active to provide e.touches emulation
2105  	if (!_pointerDocListener) {
2106  		// we listen document as any drags that end by moving the touch off the screen get fired there
2107  		document.addEventListener(POINTER_DOWN, _globalPointerDown, true);
2108  		document.addEventListener(POINTER_MOVE, _globalPointerMove, true);
2109  		document.addEventListener(POINTER_UP, _globalPointerUp, true);
2110  		document.addEventListener(POINTER_CANCEL, _globalPointerUp, true);
2111
2112  		_pointerDocListener = true;
2113  	}
2114  }
2115
2116  function _handlePointer(handler, e) {
2117  	if (e.pointerType === (e.MSPOINTER_TYPE_MOUSE || 'mouse')) { return; }
2118
2119  	e.touches = [];
2120  	for (var i in _pointers) {
2121  		e.touches.push(_pointers[i]);
2122  	}
2123  	e.changedTouches = [e];
2124
2125  	handler(e);
2126  }
2127
2128  function _onPointerStart(handler, e) {
2129  	// IE10 specific: MsTouch needs preventDefault. See #2000
2130  	if (e.MSPOINTER_TYPE_TOUCH && e.pointerType === e.MSPOINTER_TYPE_TOUCH) {
2131  		preventDefault(e);
2132  	}
2133  	_handlePointer(handler, e);
2134  }
2135
2136  /*
2137   * Extends the event handling code with double tap support for mobile browsers.
2138   *
2139   * Note: currently most browsers fire native dblclick, with only a few exceptions
2140   * (see https://github.com/Leaflet/Leaflet/issues/7012#issuecomment-595087386)
2141   */
2142
2143  function makeDblclick(event) {
2144  	// in modern browsers `type` cannot be just overridden:
2145  	// https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Errors/Getter_only
2146  	var newEvent = {},
2147  	    prop, i;
2148  	for (i in event) {
2149  		prop = event[i];
2150  		newEvent[i] = prop && prop.bind ? prop.bind(event) : prop;
2151  	}
2152  	event = newEvent;
2153  	newEvent.type = 'dblclick';
2154  	newEvent.detail = 2;
2155  	newEvent.isTrusted = false;
2156  	newEvent._simulated = true; // for debug purposes
2157  	return newEvent;
2158  }
2159
2160  var delay = 200;
2161  function addDoubleTapListener(obj, handler) {
2162  	// Most browsers handle double tap natively
2163  	obj.addEventListener('dblclick', handler);
2164
2165  	// On some platforms the browser doesn't fire native dblclicks for touch events.
2166  	// It seems that in all such cases `detail` property of `click` event is always `1`.
2167  	// So here we rely on that fact to avoid excessive 'dblclick' simulation when not needed.
2168  	var last = 0,
2169  	    detail;
2170  	function simDblclick(e) {
2171  		if (e.detail !== 1) {
2172  			detail = e.detail; // keep in sync to avoid false dblclick in some cases
2173  			return;
2174  		}
2175
2176  		if (e.pointerType === 'mouse' ||
2177  			(e.sourceCapabilities && !e.sourceCapabilities.firesTouchEvents)) {
2178
2179  			return;
2180  		}
2181
2182  		var now = Date.now();
2183  		if (now - last <= delay) {
2184  			detail++;
2185  			if (detail === 2) {
2186  				handler(makeDblclick(e));
2187  			}
2188  		} else {
2189  			detail = 1;
2190  		}
2191  		last = now;
2192  	}
2193
2194  	obj.addEventListener('click', simDblclick);
2195
2196  	return {
2197  		dblclick: handler,
2198  		simDblclick: simDblclick
2199  	};
2200  }
2201
2202  function removeDoubleTapListener(obj, handlers) {
2203  	obj.removeEventListener('dblclick', handlers.dblclick);
2204  	obj.removeEventListener('click', handlers.simDblclick);
2205  }
2206
2207  /*
2208   * @namespace DomUtil
2209   *
2210   * Utility functions to work with the [DOM](https://developer.mozilla.org/docs/Web/API/Document_Object_Model)
2211   * tree, used by Leaflet internally.
2212   *
2213   * Most functions expecting or returning a `HTMLElement` also work for
2214   * SVG elements. The only difference is that classes refer to CSS classes
2215   * in HTML and SVG classes in SVG.
2216   */
2217
2218
2219  // @property TRANSFORM: String
2220  // Vendor-prefixed transform style name (e.g. `'webkitTransform'` for WebKit).
2221  var TRANSFORM = testProp(
2222  	['transform', 'webkitTransform', 'OTransform', 'MozTransform', 'msTransform']);
2223
2224  // webkitTransition comes first because some browser versions that drop vendor prefix don't do
2225  // the same for the transitionend event, in particular the Android 4.1 stock browser
2226
2227  // @property TRANSITION: String
2228  // Vendor-prefixed transition style name.
2229  var TRANSITION = testProp(
2230  	['webkitTransition', 'transition', 'OTransition', 'MozTransition', 'msTransition']);
2231
2232  // @property TRANSITION_END: String
2233  // Vendor-prefixed transitionend event name.
2234  var TRANSITION_END =
2235  	TRANSITION === 'webkitTransition' || TRANSITION === 'OTransition' ? TRANSITION + 'End' : 'transitionend';
2236
2237
2238  // @function get(id: String|HTMLElement): HTMLElement
2239  // Returns an element given its DOM id, or returns the element itself
2240  // if it was passed directly.
2241  function get(id) {
2242  	return typeof id === 'string' ? document.getElementById(id) : id;
2243  }
2244
2245  // @function getStyle(el: HTMLElement, styleAttrib: String): String
2246  // Returns the value for a certain style attribute on an element,
2247  // including computed values or values set through CSS.
2248  function getStyle(el, style) {
2249  	var value = el.style[style] || (el.currentStyle && el.currentStyle[style]);
2250
2251  	if ((!value || value === 'auto') && document.defaultView) {
2252  		var css = document.defaultView.getComputedStyle(el, null);
2253  		value = css ? css[style] : null;
2254  	}
2255  	return value === 'auto' ? null : value;
2256  }
2257
2258  // @function create(tagName: String, className?: String, container?: HTMLElement): HTMLElement
2259  // Creates an HTML element with `tagName`, sets its class to `className`, and optionally appends it to `container` element.
2260  function create$1(tagName, className, container) {
2261  	var el = document.createElement(tagName);
2262  	el.className = className || '';
2263
2264  	if (container) {
2265  		container.appendChild(el);
2266  	}
2267  	return el;
2268  }
2269
2270  // @function remove(el: HTMLElement)
2271  // Removes `el` from its parent element
2272  function remove(el) {
2273  	var parent = el.parentNode;
2274  	if (parent) {
2275  		parent.removeChild(el);
2276  	}
2277  }
2278
2279  // @function empty(el: HTMLElement)
2280  // Removes all of `el`'s children elements from `el`
2281  function empty(el) {
2282  	while (el.firstChild) {
2283  		el.removeChild(el.firstChild);
2284  	}
2285  }
2286
2287  // @function toFront(el: HTMLElement)
2288  // Makes `el` the last child of its parent, so it renders in front of the other children.
2289  function toFront(el) {
2290  	var parent = el.parentNode;
2291  	if (parent && parent.lastChild !== el) {
2292  		parent.appendChild(el);
2293  	}
2294  }
2295
2296  // @function toBack(el: HTMLElement)
2297  // Makes `el` the first child of its parent, so it renders behind the other children.
2298  function toBack(el) {
2299  	var parent = el.parentNode;
2300  	if (parent && parent.firstChild !== el) {
2301  		parent.insertBefore(el, parent.firstChild);
2302  	}
2303  }
2304
2305  // @function hasClass(el: HTMLElement, name: String): Boolean
2306  // Returns `true` if the element's class attribute contains `name`.
2307  function hasClass(el, name) {
2308  	if (el.classList !== undefined) {
2309  		return el.classList.contains(name);
2310  	}
2311  	var className = getClass(el);
2312  	return className.length > 0 && new RegExp('(^|\\s)' + name + '(\\s|$)').test(className);
2313  }
2314
2315  // @function addClass(el: HTMLElement, name: String)
2316  // Adds `name` to the element's class attribute.
2317  function addClass(el, name) {
2318  	if (el.classList !== undefined) {
2319  		var classes = splitWords(name);
2320  		for (var i = 0, len = classes.length; i < len; i++) {
2321  			el.classList.add(classes[i]);
2322  		}
2323  	} else if (!hasClass(el, name)) {
2324  		var className = getClass(el);
2325  		setClass(el, (className ? className + ' ' : '') + name);
2326  	}
2327  }
2328
2329  // @function removeClass(el: HTMLElement, name: String)
2330  // Removes `name` from the element's class attribute.
2331  function removeClass(el, name) {
2332  	if (el.classList !== undefined) {
2333  		el.classList.remove(name);
2334  	} else {
2335  		setClass(el, trim((' ' + getClass(el) + ' ').replace(' ' + name + ' ', ' ')));
2336  	}
2337  }
2338
2339  // @function setClass(el: HTMLElement, name: String)
2340  // Sets the element's class.
2341  function setClass(el, name) {
2342  	if (el.className.baseVal === undefined) {
2343  		el.className = name;
2344  	} else {
2345  		// in case of SVG element
2346  		el.className.baseVal = name;
2347  	}
2348  }
2349
2350  // @function getClass(el: HTMLElement): String
2351  // Returns the element's class.
2352  function getClass(el) {
2353  	// Check if the element is an SVGElementInstance and use the correspondingElement instead
2354  	// (Required for linked SVG elements in IE11.)
2355  	if (el.correspondingElement) {
2356  		el = el.correspondingElement;
2357  	}
2358  	return el.className.baseVal === undefined ? el.className : el.className.baseVal;
2359  }
2360
2361  // @function setOpacity(el: HTMLElement, opacity: Number)
2362  // Set the opacity of an element (including old IE support).
2363  // `opacity` must be a number from `0` to `1`.
2364  function setOpacity(el, value) {
2365  	if ('opacity' in el.style) {
2366  		el.style.opacity = value;
2367  	} else if ('filter' in el.style) {
2368  		_setOpacityIE(el, value);
2369  	}
2370  }
2371
2372  function _setOpacityIE(el, value) {
2373  	var filter = false,
2374  	    filterName = 'DXImageTransform.Microsoft.Alpha';
2375
2376  	// filters collection throws an error if we try to retrieve a filter that doesn't exist
2377  	try {
2378  		filter = el.filters.item(filterName);
2379  	} catch (e) {
2380  		// don't set opacity to 1 if we haven't already set an opacity,
2381  		// it isn't needed and breaks transparent pngs.
2382  		if (value === 1) { return; }
2383  	}
2384
2385  	value = Math.round(value * 100);
2386
2387  	if (filter) {
2388  		filter.Enabled = (value !== 100);
2389  		filter.Opacity = value;
2390  	} else {
2391  		el.style.filter += ' progid:' + filterName + '(opacity=' + value + ')';
2392  	}
2393  }
2394
2395  // @function testProp(props: String[]): String|false
2396  // Goes through the array of style names and returns the first name
2397  // that is a valid style name for an element. If no such name is found,
2398  // it returns false. Useful for vendor-prefixed styles like `transform`.
2399  function testProp(props) {
2400  	var style = document.documentElement.style;
2401
2402  	for (var i = 0; i < props.length; i++) {
2403  		if (props[i] in style) {
2404  			return props[i];
2405  		}
2406  	}
2407  	return false;
2408  }
2409
2410  // @function setTransform(el: HTMLElement, offset: Point, scale?: Number)
2411  // Resets the 3D CSS transform of `el` so it is translated by `offset` pixels
2412  // and optionally scaled by `scale`. Does not have an effect if the
2413  // browser doesn't support 3D CSS transforms.
2414  function setTransform(el, offset, scale) {
2415  	var pos = offset || new Point(0, 0);
2416
2417  	el.style[TRANSFORM] =
2418  		(ie3d ?
2419  			'translate(' + pos.x + 'px,' + pos.y + 'px)' :
2420  			'translate3d(' + pos.x + 'px,' + pos.y + 'px,0)') +
2421  		(scale ? ' scale(' + scale + ')' : '');
2422  }
2423
2424  // @function setPosition(el: HTMLElement, position: Point)
2425  // Sets the position of `el` to coordinates specified by `position`,
2426  // using CSS translate or top/left positioning depending on the browser
2427  // (used by Leaflet internally to position its layers).
2428  function setPosition(el, point) {
2429
2430  	/*eslint-disable */
2431  	el._leaflet_pos = point;
2432  	/* eslint-enable */
2433
2434  	if (any3d) {
2435  		setTransform(el, point);
2436  	} else {
2437  		el.style.left = point.x + 'px';
2438  		el.style.top = point.y + 'px';
2439  	}
2440  }
2441
2442  // @function getPosition(el: HTMLElement): Point
2443  // Returns the coordinates of an element previously positioned with setPosition.
2444  function getPosition(el) {
2445  	// this method is only used for elements previously positioned using setPosition,
2446  	// so it's safe to cache the position for performance
2447
2448  	return el._leaflet_pos || new Point(0, 0);
2449  }
2450
2451  // @function disableTextSelection()
2452  // Prevents the user from generating `selectstart` DOM events, usually generated
2453  // when the user drags the mouse through a page with text. Used internally
2454  // by Leaflet to override the behaviour of any click-and-drag interaction on
2455  // the map. Affects drag interactions on the whole document.
2456
2457  // @function enableTextSelection()
2458  // Cancels the effects of a previous [`L.DomUtil.disableTextSelection`](#domutil-disabletextselection).
2459  var disableTextSelection;
2460  var enableTextSelection;
2461  var _userSelect;
2462  if ('onselectstart' in document) {
2463  	disableTextSelection = function () {
2464  		on(window, 'selectstart', preventDefault);
2465  	};
2466  	enableTextSelection = function () {
2467  		off(window, 'selectstart', preventDefault);
2468  	};
2469  } else {
2470  	var userSelectProperty = testProp(
2471  		['userSelect', 'WebkitUserSelect', 'OUserSelect', 'MozUserSelect', 'msUserSelect']);
2472
2473  	disableTextSelection = function () {
2474  		if (userSelectProperty) {
2475  			var style = document.documentElement.style;
2476  			_userSelect = style[userSelectProperty];
2477  			style[userSelectProperty] = 'none';
2478  		}
2479  	};
2480  	enableTextSelection = function () {
2481  		if (userSelectProperty) {
2482  			document.documentElement.style[userSelectProperty] = _userSelect;
2483  			_userSelect = undefined;
2484  		}
2485  	};
2486  }
2487
2488  // @function disableImageDrag()
2489  // As [`L.DomUtil.disableTextSelection`](#domutil-disabletextselection), but
2490  // for `dragstart` DOM events, usually generated when the user drags an image.
2491  function disableImageDrag() {
2492  	on(window, 'dragstart', preventDefault);
2493  }
2494
2495  // @function enableImageDrag()
2496  // Cancels the effects of a previous [`L.DomUtil.disableImageDrag`](#domutil-disabletextselection).
2497  function enableImageDrag() {
2498  	off(window, 'dragstart', preventDefault);
2499  }
2500
2501  var _outlineElement, _outlineStyle;
2502  // @function preventOutline(el: HTMLElement)
2503  // Makes the [outline](https://developer.mozilla.org/docs/Web/CSS/outline)
2504  // of the element `el` invisible. Used internally by Leaflet to prevent
2505  // focusable elements from displaying an outline when the user performs a
2506  // drag interaction on them.
2507  function preventOutline(element) {
2508  	while (element.tabIndex === -1) {
2509  		element = element.parentNode;
2510  	}
2511  	if (!element.style) { return; }
2512  	restoreOutline();
2513  	_outlineElement = element;
2514  	_outlineStyle = element.style.outline;
2515  	element.style.outline = 'none';
2516  	on(window, 'keydown', restoreOutline);
2517  }
2518
2519  // @function restoreOutline()
2520  // Cancels the effects of a previous [`L.DomUtil.preventOutline`]().
2521  function restoreOutline() {
2522  	if (!_outlineElement) { return; }
2523  	_outlineElement.style.outline = _outlineStyle;
2524  	_outlineElement = undefined;
2525  	_outlineStyle = undefined;
2526  	off(window, 'keydown', restoreOutline);
2527  }
2528
2529  // @function getSizedParentNode(el: HTMLElement): HTMLElement
2530  // Finds the closest parent node which size (width and height) is not null.
2531  function getSizedParentNode(element) {
2532  	do {
2533  		element = element.parentNode;
2534  	} while ((!element.offsetWidth || !element.offsetHeight) && element !== document.body);
2535  	return element;
2536  }
2537
2538  // @function getScale(el: HTMLElement): Object
2539  // Computes the CSS scale currently applied on the element.
2540  // Returns an object with `x` and `y` members as horizontal and vertical scales respectively,
2541  // and `boundingClientRect` as the result of [`getBoundingClientRect()`](https://developer.mozilla.org/en-US/docs/Web/API/Element/getBoundingClientRect).
2542  function getScale(element) {
2543  	var rect = element.getBoundingClientRect(); // Read-only in old browsers.
2544
2545  	return {
2546  		x: rect.width / element.offsetWidth || 1,
2547  		y: rect.height / element.offsetHeight || 1,
2548  		boundingClientRect: rect
2549  	};
2550  }
2551
2552  var DomUtil = {
2553    __proto__: null,
2554    TRANSFORM: TRANSFORM,
2555    TRANSITION: TRANSITION,
2556    TRANSITION_END: TRANSITION_END,
2557    get: get,
2558    getStyle: getStyle,
2559    create: create$1,
2560    remove: remove,
2561    empty: empty,
2562    toFront: toFront,
2563    toBack: toBack,
2564    hasClass: hasClass,
2565    addClass: addClass,
2566    removeClass: removeClass,
2567    setClass: setClass,
2568    getClass: getClass,
2569    setOpacity: setOpacity,
2570    testProp: testProp,
2571    setTransform: setTransform,
2572    setPosition: setPosition,
2573    getPosition: getPosition,
2574    get disableTextSelection () { return disableTextSelection; },
2575    get enableTextSelection () { return enableTextSelection; },
2576    disableImageDrag: disableImageDrag,
2577    enableImageDrag: enableImageDrag,
2578    preventOutline: preventOutline,
2579    restoreOutline: restoreOutline,
2580    getSizedParentNode: getSizedParentNode,
2581    getScale: getScale
2582  };
2583
2584  /*
2585   * @namespace DomEvent
2586   * Utility functions to work with the [DOM events](https://developer.mozilla.org/docs/Web/API/Event), used by Leaflet internally.
2587   */
2588
2589  // Inspired by John Resig, Dean Edwards and YUI addEvent implementations.
2590
2591  // @function on(el: HTMLElement, types: String, fn: Function, context?: Object): this
2592  // Adds a listener function (`fn`) to a particular DOM event type of the
2593  // element `el`. You can optionally specify the context of the listener
2594  // (object the `this` keyword will point to). You can also pass several
2595  // space-separated types (e.g. `'click dblclick'`).
2596
2597  // @alternative
2598  // @function on(el: HTMLElement, eventMap: Object, context?: Object): this
2599  // Adds a set of type/listener pairs, e.g. `{click: onClick, mousemove: onMouseMove}`
2600  function on(obj, types, fn, context) {
2601
2602  	if (types && typeof types === 'object') {
2603  		for (var type in types) {
2604  			addOne(obj, type, types[type], fn);
2605  		}
2606  	} else {
2607  		types = splitWords(types);
2608
2609  		for (var i = 0, len = types.length; i < len; i++) {
2610  			addOne(obj, types[i], fn, context);
2611  		}
2612  	}
2613
2614  	return this;
2615  }
2616
2617  var eventsKey = '_leaflet_events';
2618
2619  // @function off(el: HTMLElement, types: String, fn: Function, context?: Object): this
2620  // Removes a previously added listener function.
2621  // Note that if you passed a custom context to on, you must pass the same
2622  // context to `off` in order to remove the listener.
2623
2624  // @alternative
2625  // @function off(el: HTMLElement, eventMap: Object, context?: Object): this
2626  // Removes a set of type/listener pairs, e.g. `{click: onClick, mousemove: onMouseMove}`
2627
2628  // @alternative
2629  // @function off(el: HTMLElement, types: String): this
2630  // Removes all previously added listeners of given types.
2631
2632  // @alternative
2633  // @function off(el: HTMLElement): this
2634  // Removes all previously added listeners from given HTMLElement
2635  function off(obj, types, fn, context) {
2636
2637  	if (arguments.length === 1) {
2638  		batchRemove(obj);
2639  		delete obj[eventsKey];
2640
2641  	} else if (types && typeof types === 'object') {
2642  		for (var type in types) {
2643  			removeOne(obj, type, types[type], fn);
2644  		}
2645
2646  	} else {
2647  		types = splitWords(types);
2648
2649  		if (arguments.length === 2) {
2650  			batchRemove(obj, function (type) {
2651  				return indexOf(types, type) !== -1;
2652  			});
2653  		} else {
2654  			for (var i = 0, len = types.length; i < len; i++) {
2655  				removeOne(obj, types[i], fn, context);
2656  			}
2657  		}
2658  	}
2659
2660  	return this;
2661  }
2662
2663  function batchRemove(obj, filterFn) {
2664  	for (var id in obj[eventsKey]) {
2665  		var type = id.split(/\d/)[0];
2666  		if (!filterFn || filterFn(type)) {
2667  			removeOne(obj, type, null, null, id);
2668  		}
2669  	}
2670  }
2671
2672  var mouseSubst = {
2673  	mouseenter: 'mouseover',
2674  	mouseleave: 'mouseout',
2675  	wheel: !('onwheel' in window) && 'mousewheel'
2676  };
2677
2678  function addOne(obj, type, fn, context) {
2679  	var id = type + stamp(fn) + (context ? '_' + stamp(context) : '');
2680
2681  	if (obj[eventsKey] && obj[eventsKey][id]) { return this; }
2682
2683  	var handler = function (e) {
2684  		return fn.call(context || obj, e || window.event);
2685  	};
2686
2687  	var originalHandler = handler;
2688
2689  	if (!touchNative && pointer && type.indexOf('touch') === 0) {
2690  		// Needs DomEvent.Pointer.js
2691  		handler = addPointerListener(obj, type, handler);
2692
2693  	} else if (touch && (type === 'dblclick')) {
2694  		handler = addDoubleTapListener(obj, handler);
2695
2696  	} else if ('addEventListener' in obj) {
2697
2698  		if (type === 'touchstart' || type === 'touchmove' || type === 'wheel' ||  type === 'mousewheel') {
2699  			obj.addEventListener(mouseSubst[type] || type, handler, passiveEvents ? {passive: false} : false);
2700
2701  		} else if (type === 'mouseenter' || type === 'mouseleave') {
2702  			handler = function (e) {
2703  				e = e || window.event;
2704  				if (isExternalTarget(obj, e)) {
2705  					originalHandler(e);
2706  				}
2707  			};
2708  			obj.addEventListener(mouseSubst[type], handler, false);
2709
2710  		} else {
2711  			obj.addEventListener(type, originalHandler, false);
2712  		}
2713
2714  	} else {
2715  		obj.attachEvent('on' + type, handler);
2716  	}
2717
2718  	obj[eventsKey] = obj[eventsKey] || {};
2719  	obj[eventsKey][id] = handler;
2720  }
2721
2722  function removeOne(obj, type, fn, context, id) {
2723  	id = id || type + stamp(fn) + (context ? '_' + stamp(context) : '');
2724  	var handler = obj[eventsKey] && obj[eventsKey][id];
2725
2726  	if (!handler) { return this; }
2727
2728  	if (!touchNative && pointer && type.indexOf('touch') === 0) {
2729  		removePointerListener(obj, type, handler);
2730
2731  	} else if (touch && (type === 'dblclick')) {
2732  		removeDoubleTapListener(obj, handler);
2733
2734  	} else if ('removeEventListener' in obj) {
2735
2736  		obj.removeEventListener(mouseSubst[type] || type, handler, false);
2737
2738  	} else {
2739  		obj.detachEvent('on' + type, handler);
2740  	}
2741
2742  	obj[eventsKey][id] = null;
2743  }
2744
2745  // @function stopPropagation(ev: DOMEvent): this
2746  // Stop the given event from propagation to parent elements. Used inside the listener functions:
2747  // ```js
2748  // L.DomEvent.on(div, 'click', function (ev) {
2749  // 	L.DomEvent.stopPropagation(ev);
2750  // });
2751  // ```
2752  function stopPropagation(e) {
2753
2754  	if (e.stopPropagation) {
2755  		e.stopPropagation();
2756  	} else if (e.originalEvent) {  // In case of Leaflet event.
2757  		e.originalEvent._stopped = true;
2758  	} else {
2759  		e.cancelBubble = true;
2760  	}
2761
2762  	return this;
2763  }
2764
2765  // @function disableScrollPropagation(el: HTMLElement): this
2766  // Adds `stopPropagation` to the element's `'wheel'` events (plus browser variants).
2767  function disableScrollPropagation(el) {
2768  	addOne(el, 'wheel', stopPropagation);
2769  	return this;
2770  }
2771
2772  // @function disableClickPropagation(el: HTMLElement): this
2773  // Adds `stopPropagation` to the element's `'click'`, `'dblclick'`, `'contextmenu'`,
2774  // `'mousedown'` and `'touchstart'` events (plus browser variants).
2775  function disableClickPropagation(el) {
2776  	on(el, 'mousedown touchstart dblclick contextmenu', stopPropagation);
2777  	el['_leaflet_disable_click'] = true;
2778  	return this;
2779  }
2780
2781  // @function preventDefault(ev: DOMEvent): this
2782  // Prevents the default action of the DOM Event `ev` from happening (such as
2783  // following a link in the href of the a element, or doing a POST request
2784  // with page reload when a `<form>` is submitted).
2785  // Use it inside listener functions.
2786  function preventDefault(e) {
2787  	if (e.preventDefault) {
2788  		e.preventDefault();
2789  	} else {
2790  		e.returnValue = false;
2791  	}
2792  	return this;
2793  }
2794
2795  // @function stop(ev: DOMEvent): this
2796  // Does `stopPropagation` and `preventDefault` at the same time.
2797  function stop(e) {
2798  	preventDefault(e);
2799  	stopPropagation(e);
2800  	return this;
2801  }
2802
2803  // @function getMousePosition(ev: DOMEvent, container?: HTMLElement): Point
2804  // Gets normalized mouse position from a DOM event relative to the
2805  // `container` (border excluded) or to the whole page if not specified.
2806  function getMousePosition(e, container) {
2807  	if (!container) {
2808  		return new Point(e.clientX, e.clientY);
2809  	}
2810
2811  	var scale = getScale(container),
2812  	    offset = scale.boundingClientRect; // left and top  values are in page scale (like the event clientX/Y)
2813
2814  	return new Point(
2815  		// offset.left/top values are in page scale (like clientX/Y),
2816  		// whereas clientLeft/Top (border width) values are the original values (before CSS scale applies).
2817  		(e.clientX - offset.left) / scale.x - container.clientLeft,
2818  		(e.clientY - offset.top) / scale.y - container.clientTop
2819  	);
2820  }
2821
2822  // Chrome on Win scrolls double the pixels as in other platforms (see #4538),
2823  // and Firefox scrolls device pixels, not CSS pixels
2824  var wheelPxFactor =
2825  	(win && chrome) ? 2 * window.devicePixelRatio :
2826  	gecko ? window.devicePixelRatio : 1;
2827
2828  // @function getWheelDelta(ev: DOMEvent): Number
2829  // Gets normalized wheel delta from a wheel DOM event, in vertical
2830  // pixels scrolled (negative if scrolling down).
2831  // Events from pointing devices without precise scrolling are mapped to
2832  // a best guess of 60 pixels.
2833  function getWheelDelta(e) {
2834  	return (edge) ? e.wheelDeltaY / 2 : // Don't trust window-geometry-based delta
2835  	       (e.deltaY && e.deltaMode === 0) ? -e.deltaY / wheelPxFactor : // Pixels
2836  	       (e.deltaY && e.deltaMode === 1) ? -e.deltaY * 20 : // Lines
2837  	       (e.deltaY && e.deltaMode === 2) ? -e.deltaY * 60 : // Pages
2838  	       (e.deltaX || e.deltaZ) ? 0 :	// Skip horizontal/depth wheel events
2839  	       e.wheelDelta ? (e.wheelDeltaY || e.wheelDelta) / 2 : // Legacy IE pixels
2840  	       (e.detail && Math.abs(e.detail) < 32765) ? -e.detail * 20 : // Legacy Moz lines
2841  	       e.detail ? e.detail / -32765 * 60 : // Legacy Moz pages
2842  	       0;
2843  }
2844
2845  // check if element really left/entered the event target (for mouseenter/mouseleave)
2846  function isExternalTarget(el, e) {
2847
2848  	var related = e.relatedTarget;
2849
2850  	if (!related) { return true; }
2851
2852  	try {
2853  		while (related && (related !== el)) {
2854  			related = related.parentNode;
2855  		}
2856  	} catch (err) {
2857  		return false;
2858  	}
2859  	return (related !== el);
2860  }
2861
2862  var DomEvent = {
2863    __proto__: null,
2864    on: on,
2865    off: off,
2866    stopPropagation: stopPropagation,
2867    disableScrollPropagation: disableScrollPropagation,
2868    disableClickPropagation: disableClickPropagation,
2869    preventDefault: preventDefault,
2870    stop: stop,
2871    getMousePosition: getMousePosition,
2872    getWheelDelta: getWheelDelta,
2873    isExternalTarget: isExternalTarget,
2874    addListener: on,
2875    removeListener: off
2876  };
2877
2878  /*
2879   * @class PosAnimation
2880   * @aka L.PosAnimation
2881   * @inherits Evented
2882   * Used internally for panning animations, utilizing CSS3 Transitions for modern browsers and a timer fallback for IE6-9.
2883   *
2884   * @example
2885   * ```js
2886   * var fx = new L.PosAnimation();
2887   * fx.run(el, [300, 500], 0.5);
2888   * ```
2889   *
2890   * @constructor L.PosAnimation()
2891   * Creates a `PosAnimation` object.
2892   *
2893   */
2894
2895  var PosAnimation = Evented.extend({
2896
2897  	// @method run(el: HTMLElement, newPos: Point, duration?: Number, easeLinearity?: Number)
2898  	// Run an animation of a given element to a new position, optionally setting
2899  	// duration in seconds (`0.25` by default) and easing linearity factor (3rd
2900  	// argument of the [cubic bezier curve](http://cubic-bezier.com/#0,0,.5,1),
2901  	// `0.5` by default).
2902  	run: function (el, newPos, duration, easeLinearity) {
2903  		this.stop();
2904
2905  		this._el = el;
2906  		this._inProgress = true;
2907  		this._duration = duration || 0.25;
2908  		this._easeOutPower = 1 / Math.max(easeLinearity || 0.5, 0.2);
2909
2910  		this._startPos = getPosition(el);
2911  		this._offset = newPos.subtract(this._startPos);
2912  		this._startTime = +new Date();
2913
2914  		// @event start: Event
2915  		// Fired when the animation starts
2916  		this.fire('start');
2917
2918  		this._animate();
2919  	},
2920
2921  	// @method stop()
2922  	// Stops the animation (if currently running).
2923  	stop: function () {
2924  		if (!this._inProgress) { return; }
2925
2926  		this._step(true);
2927  		this._complete();
2928  	},
2929
2930  	_animate: function () {
2931  		// animation loop
2932  		this._animId = requestAnimFrame(this._animate, this);
2933  		this._step();
2934  	},
2935
2936  	_step: function (round) {
2937  		var elapsed = (+new Date()) - this._startTime,
2938  		    duration = this._duration * 1000;
2939
2940  		if (elapsed < duration) {
2941  			this._runFrame(this._easeOut(elapsed / duration), round);
2942  		} else {
2943  			this._runFrame(1);
2944  			this._complete();
2945  		}
2946  	},
2947
2948  	_runFrame: function (progress, round) {
2949  		var pos = this._startPos.add(this._offset.multiplyBy(progress));
2950  		if (round) {
2951  			pos._round();
2952  		}
2953  		setPosition(this._el, pos);
2954
2955  		// @event step: Event
2956  		// Fired continuously during the animation.
2957  		this.fire('step');
2958  	},
2959
2960  	_complete: function () {
2961  		cancelAnimFrame(this._animId);
2962
2963  		this._inProgress = false;
2964  		// @event end: Event
2965  		// Fired when the animation ends.
2966  		this.fire('end');
2967  	},
2968
2969  	_easeOut: function (t) {
2970  		return 1 - Math.pow(1 - t, this._easeOutPower);
2971  	}
2972  });
2973
2974  /*
2975   * @class Map
2976   * @aka L.Map
2977   * @inherits Evented
2978   *
2979   * The central class of the API — it is used to create a map on a page and manipulate it.
2980   *
2981   * @example
2982   *
2983   * ```js
2984   * // initialize the map on the "map" div with a given center and zoom
2985   * var map = L.map('map', {
2986   * 	center: [51.505, -0.09],
2987   * 	zoom: 13
2988   * });
2989   * ```
2990   *
2991   */
2992
2993  var Map = Evented.extend({
2994
2995  	options: {
2996  		// @section Map State Options
2997  		// @option crs: CRS = L.CRS.EPSG3857
2998  		// The [Coordinate Reference System](#crs) to use. Don't change this if you're not
2999  		// sure what it means.
3000  		crs: EPSG3857,
3001
3002  		// @option center: LatLng = undefined
3003  		// Initial geographic center of the map
3004  		center: undefined,
3005
3006  		// @option zoom: Number = undefined
3007  		// Initial map zoom level
3008  		zoom: undefined,
3009
3010  		// @option minZoom: Number = *
3011  		// Minimum zoom level of the map.
3012  		// If not specified and at least one `GridLayer` or `TileLayer` is in the map,
3013  		// the lowest of their `minZoom` options will be used instead.
3014  		minZoom: undefined,
3015
3016  		// @option maxZoom: Number = *
3017  		// Maximum zoom level of the map.
3018  		// If not specified and at least one `GridLayer` or `TileLayer` is in the map,
3019  		// the highest of their `maxZoom` options will be used instead.
3020  		maxZoom: undefined,
3021
3022  		// @option layers: Layer[] = []
3023  		// Array of layers that will be added to the map initially
3024  		layers: [],
3025
3026  		// @option maxBounds: LatLngBounds = null
3027  		// When this option is set, the map restricts the view to the given
3028  		// geographical bounds, bouncing the user back if the user tries to pan
3029  		// outside the view. To set the restriction dynamically, use
3030  		// [`setMaxBounds`](#map-setmaxbounds) method.
3031  		maxBounds: undefined,
3032
3033  		// @option renderer: Renderer = *
3034  		// The default method for drawing vector layers on the map. `L.SVG`
3035  		// or `L.Canvas` by default depending on browser support.
3036  		renderer: undefined,
3037
3038
3039  		// @section Animation Options
3040  		// @option zoomAnimation: Boolean = true
3041  		// Whether the map zoom animation is enabled. By default it's enabled
3042  		// in all browsers that support CSS3 Transitions except Android.
3043  		zoomAnimation: true,
3044
3045  		// @option zoomAnimationThreshold: Number = 4
3046  		// Won't animate zoom if the zoom difference exceeds this value.
3047  		zoomAnimationThreshold: 4,
3048
3049  		// @option fadeAnimation: Boolean = true
3050  		// Whether the tile fade animation is enabled. By default it's enabled
3051  		// in all browsers that support CSS3 Transitions except Android.
3052  		fadeAnimation: true,
3053
3054  		// @option markerZoomAnimation: Boolean = true
3055  		// Whether markers animate their zoom with the zoom animation, if disabled
3056  		// they will disappear for the length of the animation. By default it's
3057  		// enabled in all browsers that support CSS3 Transitions except Android.
3058  		markerZoomAnimation: true,
3059
3060  		// @option transform3DLimit: Number = 2^23
3061  		// Defines the maximum size of a CSS translation transform. The default
3062  		// value should not be changed unless a web browser positions layers in
3063  		// the wrong place after doing a large `panBy`.
3064  		transform3DLimit: 8388608, // Precision limit of a 32-bit float
3065
3066  		// @section Interaction Options
3067  		// @option zoomSnap: Number = 1
3068  		// Forces the map's zoom level to always be a multiple of this, particularly
3069  		// right after a [`fitBounds()`](#map-fitbounds) or a pinch-zoom.
3070  		// By default, the zoom level snaps to the nearest integer; lower values
3071  		// (e.g. `0.5` or `0.1`) allow for greater granularity. A value of `0`
3072  		// means the zoom level will not be snapped after `fitBounds` or a pinch-zoom.
3073  		zoomSnap: 1,
3074
3075  		// @option zoomDelta: Number = 1
3076  		// Controls how much the map's zoom level will change after a
3077  		// [`zoomIn()`](#map-zoomin), [`zoomOut()`](#map-zoomout), pressing `+`
3078  		// or `-` on the keyboard, or using the [zoom controls](#control-zoom).
3079  		// Values smaller than `1` (e.g. `0.5`) allow for greater granularity.
3080  		zoomDelta: 1,
3081
3082  		// @option trackResize: Boolean = true
3083  		// Whether the map automatically handles browser window resize to update itself.
3084  		trackResize: true
3085  	},
3086
3087  	initialize: function (id, options) { // (HTMLElement or String, Object)
3088  		options = setOptions(this, options);
3089
3090  		// Make sure to assign internal flags at the beginning,
3091  		// to avoid inconsistent state in some edge cases.
3092  		this._handlers = [];
3093  		this._layers = {};
3094  		this._zoomBoundLayers = {};
3095  		this._sizeChanged = true;
3096
3097  		this._initContainer(id);
3098  		this._initLayout();
3099
3100  		// hack for https://github.com/Leaflet/Leaflet/issues/1980
3101  		this._onResize = bind(this._onResize, this);
3102
3103  		this._initEvents();
3104
3105  		if (options.maxBounds) {
3106  			this.setMaxBounds(options.maxBounds);
3107  		}
3108
3109  		if (options.zoom !== undefined) {
3110  			this._zoom = this._limitZoom(options.zoom);
3111  		}
3112
3113  		if (options.center && options.zoom !== undefined) {
3114  			this.setView(toLatLng(options.center), options.zoom, {reset: true});
3115  		}
3116
3117  		this.callInitHooks();
3118
3119  		// don't animate on browsers without hardware-accelerated transitions or old Android/Opera
3120  		this._zoomAnimated = TRANSITION && any3d && !mobileOpera &&
3121  				this.options.zoomAnimation;
3122
3123  		// zoom transitions run with the same duration for all layers, so if one of transitionend events
3124  		// happens after starting zoom animation (propagating to the map pane), we know that it ended globally
3125  		if (this._zoomAnimated) {
3126  			this._createAnimProxy();
3127  			on(this._proxy, TRANSITION_END, this._catchTransitionEnd, this);
3128  		}
3129
3130  		this._addLayers(this.options.layers);
3131  	},
3132
3133
3134  	// @section Methods for modifying map state
3135
3136  	// @method setView(center: LatLng, zoom: Number, options?: Zoom/pan options): this
3137  	// Sets the view of the map (geographical center and zoom) with the given
3138  	// animation options.
3139  	setView: function (center, zoom, options) {
3140
3141  		zoom = zoom === undefined ? this._zoom : this._limitZoom(zoom);
3142  		center = this._limitCenter(toLatLng(center), zoom, this.options.maxBounds);
3143  		options = options || {};
3144
3145  		this._stop();
3146
3147  		if (this._loaded && !options.reset && options !== true) {
3148
3149  			if (options.animate !== undefined) {
3150  				options.zoom = extend({animate: options.animate}, options.zoom);
3151  				options.pan = extend({animate: options.animate, duration: options.duration}, options.pan);
3152  			}
3153
3154  			// try animating pan or zoom
3155  			var moved = (this._zoom !== zoom) ?
3156  				this._tryAnimatedZoom && this._tryAnimatedZoom(center, zoom, options.zoom) :
3157  				this._tryAnimatedPan(center, options.pan);
3158
3159  			if (moved) {
3160  				// prevent resize handler call, the view will refresh after animation anyway
3161  				clearTimeout(this._sizeTimer);
3162  				return this;
3163  			}
3164  		}
3165
3166  		// animation didn't start, just reset the map view
3167  		this._resetView(center, zoom);
3168
3169  		return this;
3170  	},
3171
3172  	// @method setZoom(zoom: Number, options?: Zoom/pan options): this
3173  	// Sets the zoom of the map.
3174  	setZoom: function (zoom, options) {
3175  		if (!this._loaded) {
3176  			this._zoom = zoom;
3177  			return this;
3178  		}
3179  		return this.setView(this.getCenter(), zoom, {zoom: options});
3180  	},
3181
3182  	// @method zoomIn(delta?: Number, options?: Zoom options): this
3183  	// Increases the zoom of the map by `delta` ([`zoomDelta`](#map-zoomdelta) by default).
3184  	zoomIn: function (delta, options) {
3185  		delta = delta || (any3d ? this.options.zoomDelta : 1);
3186  		return this.setZoom(this._zoom + delta, options);
3187  	},
3188
3189  	// @method zoomOut(delta?: Number, options?: Zoom options): this
3190  	// Decreases the zoom of the map by `delta` ([`zoomDelta`](#map-zoomdelta) by default).
3191  	zoomOut: function (delta, options) {
3192  		delta = delta || (any3d ? this.options.zoomDelta : 1);
3193  		return this.setZoom(this._zoom - delta, options);
3194  	},
3195
3196  	// @method setZoomAround(latlng: LatLng, zoom: Number, options: Zoom options): this
3197  	// Zooms the map while keeping a specified geographical point on the map
3198  	// stationary (e.g. used internally for scroll zoom and double-click zoom).
3199  	// @alternative
3200  	// @method setZoomAround(offset: Point, zoom: Number, options: Zoom options): this
3201  	// Zooms the map while keeping a specified pixel on the map (relative to the top-left corner) stationary.
3202  	setZoomAround: function (latlng, zoom, options) {
3203  		var scale = this.getZoomScale(zoom),
3204  		    viewHalf = this.getSize().divideBy(2),
3205  		    containerPoint = latlng instanceof Point ? latlng : this.latLngToContainerPoint(latlng),
3206
3207  		    centerOffset = containerPoint.subtract(viewHalf).multiplyBy(1 - 1 / scale),
3208  		    newCenter = this.containerPointToLatLng(viewHalf.add(centerOffset));
3209
3210  		return this.setView(newCenter, zoom, {zoom: options});
3211  	},
3212
3213  	_getBoundsCenterZoom: function (bounds, options) {
3214
3215  		options = options || {};
3216  		bounds = bounds.getBounds ? bounds.getBounds() : toLatLngBounds(bounds);
3217
3218  		var paddingTL = toPoint(options.paddingTopLeft || options.padding || [0, 0]),
3219  		    paddingBR = toPoint(options.paddingBottomRight || options.padding || [0, 0]),
3220
3221  		    zoom = this.getBoundsZoom(bounds, false, paddingTL.add(paddingBR));
3222
3223  		zoom = (typeof options.maxZoom === 'number') ? Math.min(options.maxZoom, zoom) : zoom;
3224
3225  		if (zoom === Infinity) {
3226  			return {
3227  				center: bounds.getCenter(),
3228  				zoom: zoom
3229  			};
3230  		}
3231
3232  		var paddingOffset = paddingBR.subtract(paddingTL).divideBy(2),
3233
3234  		    swPoint = this.project(bounds.getSouthWest(), zoom),
3235  		    nePoint = this.project(bounds.getNorthEast(), zoom),
3236  		    center = this.unproject(swPoint.add(nePoint).divideBy(2).add(paddingOffset), zoom);
3237
3238  		return {
3239  			center: center,
3240  			zoom: zoom
3241  		};
3242  	},
3243
3244  	// @method fitBounds(bounds: LatLngBounds, options?: fitBounds options): this
3245  	// Sets a map view that contains the given geographical bounds with the
3246  	// maximum zoom level possible.
3247  	fitBounds: function (bounds, options) {
3248
3249  		bounds = toLatLngBounds(bounds);
3250
3251  		if (!bounds.isValid()) {
3252  			throw new Error('Bounds are not valid.');
3253  		}
3254
3255  		var target = this._getBoundsCenterZoom(bounds, options);
3256  		return this.setView(target.center, target.zoom, options);
3257  	},
3258
3259  	// @method fitWorld(options?: fitBounds options): this
3260  	// Sets a map view that mostly contains the whole world with the maximum
3261  	// zoom level possible.
3262  	fitWorld: function (options) {
3263  		return this.fitBounds([[-90, -180], [90, 180]], options);
3264  	},
3265
3266  	// @method panTo(latlng: LatLng, options?: Pan options): this
3267  	// Pans the map to a given center.
3268  	panTo: function (center, options) { // (LatLng)
3269  		return this.setView(center, this._zoom, {pan: options});
3270  	},
3271
3272  	// @method panBy(offset: Point, options?: Pan options): this
3273  	// Pans the map by a given number of pixels (animated).
3274  	panBy: function (offset, options) {
3275  		offset = toPoint(offset).round();
3276  		options = options || {};
3277
3278  		if (!offset.x && !offset.y) {
3279  			return this.fire('moveend');
3280  		}
3281  		// If we pan too far, Chrome gets issues with tiles
3282  		// and makes them disappear or appear in the wrong place (slightly offset) #2602
3283  		if (options.animate !== true && !this.getSize().contains(offset)) {
3284  			this._resetView(this.unproject(this.project(this.getCenter()).add(offset)), this.getZoom());
3285  			return this;
3286  		}
3287
3288  		if (!this._panAnim) {
3289  			this._panAnim = new PosAnimation();
3290
3291  			this._panAnim.on({
3292  				'step': this._onPanTransitionStep,
3293  				'end': this._onPanTransitionEnd
3294  			}, this);
3295  		}
3296
3297  		// don't fire movestart if animating inertia
3298  		if (!options.noMoveStart) {
3299  			this.fire('movestart');
3300  		}
3301
3302  		// animate pan unless animate: false specified
3303  		if (options.animate !== false) {
3304  			addClass(this._mapPane, 'leaflet-pan-anim');
3305
3306  			var newPos = this._getMapPanePos().subtract(offset).round();
3307  			this._panAnim.run(this._mapPane, newPos, options.duration || 0.25, options.easeLinearity);
3308  		} else {
3309  			this._rawPanBy(offset);
3310  			this.fire('move').fire('moveend');
3311  		}
3312
3313  		return this;
3314  	},
3315
3316  	// @method flyTo(latlng: LatLng, zoom?: Number, options?: Zoom/pan options): this
3317  	// Sets the view of the map (geographical center and zoom) performing a smooth
3318  	// pan-zoom animation.
3319  	flyTo: function (targetCenter, targetZoom, options) {
3320
3321  		options = options || {};
3322  		if (options.animate === false || !any3d) {
3323  			return this.setView(targetCenter, targetZoom, options);
3324  		}
3325
3326  		this._stop();
3327
3328  		var from = this.project(this.getCenter()),
3329  		    to = this.project(targetCenter),
3330  		    size = this.getSize(),
3331  		    startZoom = this._zoom;
3332
3333  		targetCenter = toLatLng(targetCenter);
3334  		targetZoom = targetZoom === undefined ? startZoom : targetZoom;
3335
3336  		var w0 = Math.max(size.x, size.y),
3337  		    w1 = w0 * this.getZoomScale(startZoom, targetZoom),
3338  		    u1 = (to.distanceTo(from)) || 1,
3339  		    rho = 1.42,
3340  		    rho2 = rho * rho;
3341
3342  		function r(i) {
3343  			var s1 = i ? -1 : 1,
3344  			    s2 = i ? w1 : w0,
3345  			    t1 = w1 * w1 - w0 * w0 + s1 * rho2 * rho2 * u1 * u1,
3346  			    b1 = 2 * s2 * rho2 * u1,
3347  			    b = t1 / b1,
3348  			    sq = Math.sqrt(b * b + 1) - b;
3349
3350  			    // workaround for floating point precision bug when sq = 0, log = -Infinite,
3351  			    // thus triggering an infinite loop in flyTo
3352  			    var log = sq < 0.000000001 ? -18 : Math.log(sq);
3353
3354  			return log;
3355  		}
3356
3357  		function sinh(n) { return (Math.exp(n) - Math.exp(-n)) / 2; }
3358  		function cosh(n) { return (Math.exp(n) + Math.exp(-n)) / 2; }
3359  		function tanh(n) { return sinh(n) / cosh(n); }
3360
3361  		var r0 = r(0);
3362
3363  		function w(s) { return w0 * (cosh(r0) / cosh(r0 + rho * s)); }
3364  		function u(s) { return w0 * (cosh(r0) * tanh(r0 + rho * s) - sinh(r0)) / rho2; }
3365
3366  		function easeOut(t) { return 1 - Math.pow(1 - t, 1.5); }
3367
3368  		var start = Date.now(),
3369  		    S = (r(1) - r0) / rho,
3370  		    duration = options.duration ? 1000 * options.duration : 1000 * S * 0.8;
3371
3372  		function frame() {
3373  			var t = (Date.now() - start) / duration,
3374  			    s = easeOut(t) * S;
3375
3376  			if (t <= 1) {
3377  				this._flyToFrame = requestAnimFrame(frame, this);
3378
3379  				this._move(
3380  					this.unproject(from.add(to.subtract(from).multiplyBy(u(s) / u1)), startZoom),
3381  					this.getScaleZoom(w0 / w(s), startZoom),
3382  					{flyTo: true});
3383
3384  			} else {
3385  				this
3386  					._move(targetCenter, targetZoom)
3387  					._moveEnd(true);
3388  			}
3389  		}
3390
3391  		this._moveStart(true, options.noMoveStart);
3392
3393  		frame.call(this);
3394  		return this;
3395  	},
3396
3397  	// @method flyToBounds(bounds: LatLngBounds, options?: fitBounds options): this
3398  	// Sets the view of the map with a smooth animation like [`flyTo`](#map-flyto),
3399  	// but takes a bounds parameter like [`fitBounds`](#map-fitbounds).
3400  	flyToBounds: function (bounds, options) {
3401  		var target = this._getBoundsCenterZoom(bounds, options);
3402  		return this.flyTo(target.center, target.zoom, options);
3403  	},
3404
3405  	// @method setMaxBounds(bounds: LatLngBounds): this
3406  	// Restricts the map view to the given bounds (see the [maxBounds](#map-maxbounds) option).
3407  	setMaxBounds: function (bounds) {
3408  		bounds = toLatLngBounds(bounds);
3409
3410  		if (!bounds.isValid()) {
3411  			this.options.maxBounds = null;
3412  			return this.off('moveend', this._panInsideMaxBounds);
3413  		} else if (this.options.maxBounds) {
3414  			this.off('moveend', this._panInsideMaxBounds);
3415  		}
3416
3417  		this.options.maxBounds = bounds;
3418
3419  		if (this._loaded) {
3420  			this._panInsideMaxBounds();
3421  		}
3422
3423  		return this.on('moveend', this._panInsideMaxBounds);
3424  	},
3425
3426  	// @method setMinZoom(zoom: Number): this
3427  	// Sets the lower limit for the available zoom levels (see the [minZoom](#map-minzoom) option).
3428  	setMinZoom: function (zoom) {
3429  		var oldZoom = this.options.minZoom;
3430  		this.options.minZoom = zoom;
3431
3432  		if (this._loaded && oldZoom !== zoom) {
3433  			this.fire('zoomlevelschange');
3434
3435  			if (this.getZoom() < this.options.minZoom) {
3436  				return this.setZoom(zoom);
3437  			}
3438  		}
3439
3440  		return this;
3441  	},
3442
3443  	// @method setMaxZoom(zoom: Number): this
3444  	// Sets the upper limit for the available zoom levels (see the [maxZoom](#map-maxzoom) option).
3445  	setMaxZoom: function (zoom) {
3446  		var oldZoom = this.options.maxZoom;
3447  		this.options.maxZoom = zoom;
3448
3449  		if (this._loaded && oldZoom !== zoom) {
3450  			this.fire('zoomlevelschange');
3451
3452  			if (this.getZoom() > this.options.maxZoom) {
3453  				return this.setZoom(zoom);
3454  			}
3455  		}
3456
3457  		return this;
3458  	},
3459
3460  	// @method panInsideBounds(bounds: LatLngBounds, options?: Pan options): this
3461  	// Pans the map to the closest view that would lie inside the given bounds (if it's not already), controlling the animation using the options specific, if any.
3462  	panInsideBounds: function (bounds, options) {
3463  		this._enforcingBounds = true;
3464  		var center = this.getCenter(),
3465  		    newCenter = this._limitCenter(center, this._zoom, toLatLngBounds(bounds));
3466
3467  		if (!center.equals(newCenter)) {
3468  			this.panTo(newCenter, options);
3469  		}
3470
3471  		this._enforcingBounds = false;
3472  		return this;
3473  	},
3474
3475  	// @method panInside(latlng: LatLng, options?: padding options): this
3476  	// Pans the map the minimum amount to make the `latlng` visible. Use
3477  	// padding options to fit the display to more restricted bounds.
3478  	// If `latlng` is already within the (optionally padded) display bounds,
3479  	// the map will not be panned.
3480  	panInside: function (latlng, options) {
3481  		options = options || {};
3482
3483  		var paddingTL = toPoint(options.paddingTopLeft || options.padding || [0, 0]),
3484  		    paddingBR = toPoint(options.paddingBottomRight || options.padding || [0, 0]),
3485  		    pixelCenter = this.project(this.getCenter()),
3486  		    pixelPoint = this.project(latlng),
3487  		    pixelBounds = this.getPixelBounds(),
3488  		    paddedBounds = toBounds([pixelBounds.min.add(paddingTL), pixelBounds.max.subtract(paddingBR)]),
3489  		    paddedSize = paddedBounds.getSize();
3490
3491  		if (!paddedBounds.contains(pixelPoint)) {
3492  			this._enforcingBounds = true;
3493  			var centerOffset = pixelPoint.subtract(paddedBounds.getCenter());
3494  			var offset = paddedBounds.extend(pixelPoint).getSize().subtract(paddedSize);
3495  			pixelCenter.x += centerOffset.x < 0 ? -offset.x : offset.x;
3496  			pixelCenter.y += centerOffset.y < 0 ? -offset.y : offset.y;
3497  			this.panTo(this.unproject(pixelCenter), options);
3498  			this._enforcingBounds = false;
3499  		}
3500  		return this;
3501  	},
3502
3503  	// @method invalidateSize(options: Zoom/pan options): this
3504  	// Checks if the map container size changed and updates the map if so —
3505  	// call it after you've changed the map size dynamically, also animating
3506  	// pan by default. If `options.pan` is `false`, panning will not occur.
3507  	// If `options.debounceMoveend` is `true`, it will delay `moveend` event so
3508  	// that it doesn't happen often even if the method is called many
3509  	// times in a row.
3510
3511  	// @alternative
3512  	// @method invalidateSize(animate: Boolean): this
3513  	// Checks if the map container size changed and updates the map if so —
3514  	// call it after you've changed the map size dynamically, also animating
3515  	// pan by default.
3516  	invalidateSize: function (options) {
3517  		if (!this._loaded) { return this; }
3518
3519  		options = extend({
3520  			animate: false,
3521  			pan: true
3522  		}, options === true ? {animate: true} : options);
3523
3524  		var oldSize = this.getSize();
3525  		this._sizeChanged = true;
3526  		this._lastCenter = null;
3527
3528  		var newSize = this.getSize(),
3529  		    oldCenter = oldSize.divideBy(2).round(),
3530  		    newCenter = newSize.divideBy(2).round(),
3531  		    offset = oldCenter.subtract(newCenter);
3532
3533  		if (!offset.x && !offset.y) { return this; }
3534
3535  		if (options.animate && options.pan) {
3536  			this.panBy(offset);
3537
3538  		} else {
3539  			if (options.pan) {
3540  				this._rawPanBy(offset);
3541  			}
3542
3543  			this.fire('move');
3544
3545  			if (options.debounceMoveend) {
3546  				clearTimeout(this._sizeTimer);
3547  				this._sizeTimer = setTimeout(bind(this.fire, this, 'moveend'), 200);
3548  			} else {
3549  				this.fire('moveend');
3550  			}
3551  		}
3552
3553  		// @section Map state change events
3554  		// @event resize: ResizeEvent
3555  		// Fired when the map is resized.
3556  		return this.fire('resize', {
3557  			oldSize: oldSize,
3558  			newSize: newSize
3559  		});
3560  	},
3561
3562  	// @section Methods for modifying map state
3563  	// @method stop(): this
3564  	// Stops the currently running `panTo` or `flyTo` animation, if any.
3565  	stop: function () {
3566  		this.setZoom(this._limitZoom(this._zoom));
3567  		if (!this.options.zoomSnap) {
3568  			this.fire('viewreset');
3569  		}
3570  		return this._stop();
3571  	},
3572
3573  	// @section Geolocation methods
3574  	// @method locate(options?: Locate options): this
3575  	// Tries to locate the user using the Geolocation API, firing a [`locationfound`](#map-locationfound)
3576  	// event with location data on success or a [`locationerror`](#map-locationerror) event on failure,
3577  	// and optionally sets the map view to the user's location with respect to
3578  	// detection accuracy (or to the world view if geolocation failed).
3579  	// Note that, if your page doesn't use HTTPS, this method will fail in
3580  	// modern browsers ([Chrome 50 and newer](https://sites.google.com/a/chromium.org/dev/Home/chromium-security/deprecating-powerful-features-on-insecure-origins))
3581  	// See `Locate options` for more details.
3582  	locate: function (options) {
3583
3584  		options = this._locateOptions = extend({
3585  			timeout: 10000,
3586  			watch: false
3587  			// setView: false
3588  			// maxZoom: <Number>
3589  			// maximumAge: 0
3590  			// enableHighAccuracy: false
3591  		}, options);
3592
3593  		if (!('geolocation' in navigator)) {
3594  			this._handleGeolocationError({
3595  				code: 0,
3596  				message: 'Geolocation not supported.'
3597  			});
3598  			return this;
3599  		}
3600
3601  		var onResponse = bind(this._handleGeolocationResponse, this),
3602  		    onError = bind(this._handleGeolocationError, this);
3603
3604  		if (options.watch) {
3605  			this._locationWatchId =
3606  			        navigator.geolocation.watchPosition(onResponse, onError, options);
3607  		} else {
3608  			navigator.geolocation.getCurrentPosition(onResponse, onError, options);
3609  		}
3610  		return this;
3611  	},
3612
3613  	// @method stopLocate(): this
3614  	// Stops watching location previously initiated by `map.locate({watch: true})`
3615  	// and aborts resetting the map view if map.locate was called with
3616  	// `{setView: true}`.
3617  	stopLocate: function () {
3618  		if (navigator.geolocation && navigator.geolocation.clearWatch) {
3619  			navigator.geolocation.clearWatch(this._locationWatchId);
3620  		}
3621  		if (this._locateOptions) {
3622  			this._locateOptions.setView = false;
3623  		}
3624  		return this;
3625  	},
3626
3627  	_handleGeolocationError: function (error) {
3628  		var c = error.code,
3629  		    message = error.message ||
3630  		            (c === 1 ? 'permission denied' :
3631  		            (c === 2 ? 'position unavailable' : 'timeout'));
3632
3633  		if (this._locateOptions.setView && !this._loaded) {
3634  			this.fitWorld();
3635  		}
3636
3637  		// @section Location events
3638  		// @event locationerror: ErrorEvent
3639  		// Fired when geolocation (using the [`locate`](#map-locate) method) failed.
3640  		this.fire('locationerror', {
3641  			code: c,
3642  			message: 'Geolocation error: ' + message + '.'
3643  		});
3644  	},
3645
3646  	_handleGeolocationResponse: function (pos) {
3647  		var lat = pos.coords.latitude,
3648  		    lng = pos.coords.longitude,
3649  		    latlng = new LatLng(lat, lng),
3650  		    bounds = latlng.toBounds(pos.coords.accuracy * 2),
3651  		    options = this._locateOptions;
3652
3653  		if (options.setView) {
3654  			var zoom = this.getBoundsZoom(bounds);
3655  			this.setView(latlng, options.maxZoom ? Math.min(zoom, options.maxZoom) : zoom);
3656  		}
3657
3658  		var data = {
3659  			latlng: latlng,
3660  			bounds: bounds,
3661  			timestamp: pos.timestamp
3662  		};
3663
3664  		for (var i in pos.coords) {
3665  			if (typeof pos.coords[i] === 'number') {
3666  				data[i] = pos.coords[i];
3667  			}
3668  		}
3669
3670  		// @event locationfound: LocationEvent
3671  		// Fired when geolocation (using the [`locate`](#map-locate) method)
3672  		// went successfully.
3673  		this.fire('locationfound', data);
3674  	},
3675
3676  	// TODO Appropriate docs section?
3677  	// @section Other Methods
3678  	// @method addHandler(name: String, HandlerClass: Function): this
3679  	// Adds a new `Handler` to the map, given its name and constructor function.
3680  	addHandler: function (name, HandlerClass) {
3681  		if (!HandlerClass) { return this; }
3682
3683  		var handler = this[name] = new HandlerClass(this);
3684
3685  		this._handlers.push(handler);
3686
3687  		if (this.options[name]) {
3688  			handler.enable();
3689  		}
3690
3691  		return this;
3692  	},
3693
3694  	// @method remove(): this
3695  	// Destroys the map and clears all related event listeners.
3696  	remove: function () {
3697
3698  		this._initEvents(true);
3699  		if (this.options.maxBounds) { this.off('moveend', this._panInsideMaxBounds); }
3700
3701  		if (this._containerId !== this._container._leaflet_id) {
3702  			throw new Error('Map container is being reused by another instance');
3703  		}
3704
3705  		try {
3706  			// throws error in IE6-8
3707  			delete this._container._leaflet_id;
3708  			delete this._containerId;
3709  		} catch (e) {
3710  			/*eslint-disable */
3711  			this._container._leaflet_id = undefined;
3712  			/* eslint-enable */
3713  			this._containerId = undefined;
3714  		}
3715
3716  		if (this._locationWatchId !== undefined) {
3717  			this.stopLocate();
3718  		}
3719
3720  		this._stop();
3721
3722  		remove(this._mapPane);
3723
3724  		if (this._clearControlPos) {
3725  			this._clearControlPos();
3726  		}
3727  		if (this._resizeRequest) {
3728  			cancelAnimFrame(this._resizeRequest);
3729  			this._resizeRequest = null;
3730  		}
3731
3732  		this._clearHandlers();
3733
3734  		if (this._loaded) {
3735  			// @section Map state change events
3736  			// @event unload: Event
3737  			// Fired when the map is destroyed with [remove](#map-remove) method.
3738  			this.fire('unload');
3739  		}
3740
3741  		var i;
3742  		for (i in this._layers) {
3743  			this._layers[i].remove();
3744  		}
3745  		for (i in this._panes) {
3746  			remove(this._panes[i]);
3747  		}
3748
3749  		this._layers = [];
3750  		this._panes = [];
3751  		delete this._mapPane;
3752  		delete this._renderer;
3753
3754  		return this;
3755  	},
3756
3757  	// @section Other Methods
3758  	// @method createPane(name: String, container?: HTMLElement): HTMLElement
3759  	// Creates a new [map pane](#map-pane) with the given name if it doesn't exist already,
3760  	// then returns it. The pane is created as a child of `container`, or
3761  	// as a child of the main map pane if not set.
3762  	createPane: function (name, container) {
3763  		var className = 'leaflet-pane' + (name ? ' leaflet-' + name.replace('Pane', '') + '-pane' : ''),
3764  		    pane = create$1('div', className, container || this._mapPane);
3765
3766  		if (name) {
3767  			this._panes[name] = pane;
3768  		}
3769  		return pane;
3770  	},
3771
3772  	// @section Methods for Getting Map State
3773
3774  	// @method getCenter(): LatLng
3775  	// Returns the geographical center of the map view
3776  	getCenter: function () {
3777  		this._checkIfLoaded();
3778
3779  		if (this._lastCenter && !this._moved()) {
3780  			return this._lastCenter;
3781  		}
3782  		return this.layerPointToLatLng(this._getCenterLayerPoint());
3783  	},
3784
3785  	// @method getZoom(): Number
3786  	// Returns the current zoom level of the map view
3787  	getZoom: function () {
3788  		return this._zoom;
3789  	},
3790
3791  	// @method getBounds(): LatLngBounds
3792  	// Returns the geographical bounds visible in the current map view
3793  	getBounds: function () {
3794  		var bounds = this.getPixelBounds(),
3795  		    sw = this.unproject(bounds.getBottomLeft()),
3796  		    ne = this.unproject(bounds.getTopRight());
3797
3798  		return new LatLngBounds(sw, ne);
3799  	},
3800
3801  	// @method getMinZoom(): Number
3802  	// Returns the minimum zoom level of the map (if set in the `minZoom` option of the map or of any layers), or `0` by default.
3803  	getMinZoom: function () {
3804  		return this.options.minZoom === undefined ? this._layersMinZoom || 0 : this.options.minZoom;
3805  	},
3806
3807  	// @method getMaxZoom(): Number
3808  	// Returns the maximum zoom level of the map (if set in the `maxZoom` option of the map or of any layers).
3809  	getMaxZoom: function () {
3810  		return this.options.maxZoom === undefined ?
3811  			(this._layersMaxZoom === undefined ? Infinity : this._layersMaxZoom) :
3812  			this.options.maxZoom;
3813  	},
3814
3815  	// @method getBoundsZoom(bounds: LatLngBounds, inside?: Boolean, padding?: Point): Number
3816  	// Returns the maximum zoom level on which the given bounds fit to the map
3817  	// view in its entirety. If `inside` (optional) is set to `true`, the method
3818  	// instead returns the minimum zoom level on which the map view fits into
3819  	// the given bounds in its entirety.
3820  	getBoundsZoom: function (bounds, inside, padding) { // (LatLngBounds[, Boolean, Point]) -> Number
3821  		bounds = toLatLngBounds(bounds);
3822  		padding = toPoint(padding || [0, 0]);
3823
3824  		var zoom = this.getZoom() || 0,
3825  		    min = this.getMinZoom(),
3826  		    max = this.getMaxZoom(),
3827  		    nw = bounds.getNorthWest(),
3828  		    se = bounds.getSouthEast(),
3829  		    size = this.getSize().subtract(padding),
3830  		    boundsSize = toBounds(this.project(se, zoom), this.project(nw, zoom)).getSize(),
3831  		    snap = any3d ? this.options.zoomSnap : 1,
3832  		    scalex = size.x / boundsSize.x,
3833  		    scaley = size.y / boundsSize.y,
3834  		    scale = inside ? Math.max(scalex, scaley) : Math.min(scalex, scaley);
3835
3836  		zoom = this.getScaleZoom(scale, zoom);
3837
3838  		if (snap) {
3839  			zoom = Math.round(zoom / (snap / 100)) * (snap / 100); // don't jump if within 1% of a snap level
3840  			zoom = inside ? Math.ceil(zoom / snap) * snap : Math.floor(zoom / snap) * snap;
3841  		}
3842
3843  		return Math.max(min, Math.min(max, zoom));
3844  	},
3845
3846  	// @method getSize(): Point
3847  	// Returns the current size of the map container (in pixels).
3848  	getSize: function () {
3849  		if (!this._size || this._sizeChanged) {
3850  			this._size = new Point(
3851  				this._container.clientWidth || 0,
3852  				this._container.clientHeight || 0);
3853
3854  			this._sizeChanged = false;
3855  		}
3856  		return this._size.clone();
3857  	},
3858
3859  	// @method getPixelBounds(): Bounds
3860  	// Returns the bounds of the current map view in projected pixel
3861  	// coordinates (sometimes useful in layer and overlay implementations).
3862  	getPixelBounds: function (center, zoom) {
3863  		var topLeftPoint = this._getTopLeftPoint(center, zoom);
3864  		return new Bounds(topLeftPoint, topLeftPoint.add(this.getSize()));
3865  	},
3866
3867  	// TODO: Check semantics - isn't the pixel origin the 0,0 coord relative to
3868  	// the map pane? "left point of the map layer" can be confusing, specially
3869  	// since there can be negative offsets.
3870  	// @method getPixelOrigin(): Point
3871  	// Returns the projected pixel coordinates of the top left point of
3872  	// the map layer (useful in custom layer and overlay implementations).
3873  	getPixelOrigin: function () {
3874  		this._checkIfLoaded();
3875  		return this._pixelOrigin;
3876  	},
3877
3878  	// @method getPixelWorldBounds(zoom?: Number): Bounds
3879  	// Returns the world's bounds in pixel coordinates for zoom level `zoom`.
3880  	// If `zoom` is omitted, the map's current zoom level is used.
3881  	getPixelWorldBounds: function (zoom) {
3882  		return this.options.crs.getProjectedBounds(zoom === undefined ? this.getZoom() : zoom);
3883  	},
3884
3885  	// @section Other Methods
3886
3887  	// @method getPane(pane: String|HTMLElement): HTMLElement
3888  	// Returns a [map pane](#map-pane), given its name or its HTML element (its identity).
3889  	getPane: function (pane) {
3890  		return typeof pane === 'string' ? this._panes[pane] : pane;
3891  	},
3892
3893  	// @method getPanes(): Object
3894  	// Returns a plain object containing the names of all [panes](#map-pane) as keys and
3895  	// the panes as values.
3896  	getPanes: function () {
3897  		return this._panes;
3898  	},
3899
3900  	// @method getContainer: HTMLElement
3901  	// Returns the HTML element that contains the map.
3902  	getContainer: function () {
3903  		return this._container;
3904  	},
3905
3906
3907  	// @section Conversion Methods
3908
3909  	// @method getZoomScale(toZoom: Number, fromZoom: Number): Number
3910  	// Returns the scale factor to be applied to a map transition from zoom level
3911  	// `fromZoom` to `toZoom`. Used internally to help with zoom animations.
3912  	getZoomScale: function (toZoom, fromZoom) {
3913  		// TODO replace with universal implementation after refactoring projections
3914  		var crs = this.options.crs;
3915  		fromZoom = fromZoom === undefined ? this._zoom : fromZoom;
3916  		return crs.scale(toZoom) / crs.scale(fromZoom);
3917  	},
3918
3919  	// @method getScaleZoom(scale: Number, fromZoom: Number): Number
3920  	// Returns the zoom level that the map would end up at, if it is at `fromZoom`
3921  	// level and everything is scaled by a factor of `scale`. Inverse of
3922  	// [`getZoomScale`](#map-getZoomScale).
3923  	getScaleZoom: function (scale, fromZoom) {
3924  		var crs = this.options.crs;
3925  		fromZoom = fromZoom === undefined ? this._zoom : fromZoom;
3926  		var zoom = crs.zoom(scale * crs.scale(fromZoom));
3927  		return isNaN(zoom) ? Infinity : zoom;
3928  	},
3929
3930  	// @method project(latlng: LatLng, zoom: Number): Point
3931  	// Projects a geographical coordinate `LatLng` according to the projection
3932  	// of the map's CRS, then scales it according to `zoom` and the CRS's
3933  	// `Transformation`. The result is pixel coordinate relative to
3934  	// the CRS origin.
3935  	project: function (latlng, zoom) {
3936  		zoom = zoom === undefined ? this._zoom : zoom;
3937  		return this.options.crs.latLngToPoint(toLatLng(latlng), zoom);
3938  	},
3939
3940  	// @method unproject(point: Point, zoom: Number): LatLng
3941  	// Inverse of [`project`](#map-project).
3942  	unproject: function (point, zoom) {
3943  		zoom = zoom === undefined ? this._zoom : zoom;
3944  		return this.options.crs.pointToLatLng(toPoint(point), zoom);
3945  	},
3946
3947  	// @method layerPointToLatLng(point: Point): LatLng
3948  	// Given a pixel coordinate relative to the [origin pixel](#map-getpixelorigin),
3949  	// returns the corresponding geographical coordinate (for the current zoom level).
3950  	layerPointToLatLng: function (point) {
3951  		var projectedPoint = toPoint(point).add(this.getPixelOrigin());
3952  		return this.unproject(projectedPoint);
3953  	},
3954
3955  	// @method latLngToLayerPoint(latlng: LatLng): Point
3956  	// Given a geographical coordinate, returns the corresponding pixel coordinate
3957  	// relative to the [origin pixel](#map-getpixelorigin).
3958  	latLngToLayerPoint: function (latlng) {
3959  		var projectedPoint = this.project(toLatLng(latlng))._round();
3960  		return projectedPoint._subtract(this.getPixelOrigin());
3961  	},
3962
3963  	// @method wrapLatLng(latlng: LatLng): LatLng
3964  	// Returns a `LatLng` where `lat` and `lng` has been wrapped according to the
3965  	// map's CRS's `wrapLat` and `wrapLng` properties, if they are outside the
3966  	// CRS's bounds.
3967  	// By default this means longitude is wrapped around the dateline so its
3968  	// value is between -180 and +180 degrees.
3969  	wrapLatLng: function (latlng) {
3970  		return this.options.crs.wrapLatLng(toLatLng(latlng));
3971  	},
3972
3973  	// @method wrapLatLngBounds(bounds: LatLngBounds): LatLngBounds
3974  	// Returns a `LatLngBounds` with the same size as the given one, ensuring that
3975  	// its center is within the CRS's bounds.
3976  	// By default this means the center longitude is wrapped around the dateline so its
3977  	// value is between -180 and +180 degrees, and the majority of the bounds
3978  	// overlaps the CRS's bounds.
3979  	wrapLatLngBounds: function (latlng) {
3980  		return this.options.crs.wrapLatLngBounds(toLatLngBounds(latlng));
3981  	},
3982
3983  	// @method distance(latlng1: LatLng, latlng2: LatLng): Number
3984  	// Returns the distance between two geographical coordinates according to
3985  	// the map's CRS. By default this measures distance in meters.
3986  	distance: function (latlng1, latlng2) {
3987  		return this.options.crs.distance(toLatLng(latlng1), toLatLng(latlng2));
3988  	},
3989
3990  	// @method containerPointToLayerPoint(point: Point): Point
3991  	// Given a pixel coordinate relative to the map container, returns the corresponding
3992  	// pixel coordinate relative to the [origin pixel](#map-getpixelorigin).
3993  	containerPointToLayerPoint: function (point) { // (Point)
3994  		return toPoint(point).subtract(this._getMapPanePos());
3995  	},
3996
3997  	// @method layerPointToContainerPoint(point: Point): Point
3998  	// Given a pixel coordinate relative to the [origin pixel](#map-getpixelorigin),
3999  	// returns the corresponding pixel coordinate relative to the map container.
4000  	layerPointToContainerPoint: function (point) { // (Point)
4001  		return toPoint(point).add(this._getMapPanePos());
4002  	},
4003
4004  	// @method containerPointToLatLng(point: Point): LatLng
4005  	// Given a pixel coordinate relative to the map container, returns
4006  	// the corresponding geographical coordinate (for the current zoom level).
4007  	containerPointToLatLng: function (point) {
4008  		var layerPoint = this.containerPointToLayerPoint(toPoint(point));
4009  		return this.layerPointToLatLng(layerPoint);
4010  	},
4011
4012  	// @method latLngToContainerPoint(latlng: LatLng): Point
4013  	// Given a geographical coordinate, returns the corresponding pixel coordinate
4014  	// relative to the map container.
4015  	latLngToContainerPoint: function (latlng) {
4016  		return this.layerPointToContainerPoint(this.latLngToLayerPoint(toLatLng(latlng)));
4017  	},
4018
4019  	// @method mouseEventToContainerPoint(ev: MouseEvent): Point
4020  	// Given a MouseEvent object, returns the pixel coordinate relative to the
4021  	// map container where the event took place.
4022  	mouseEventToContainerPoint: function (e) {
4023  		return getMousePosition(e, this._container);
4024  	},
4025
4026  	// @method mouseEventToLayerPoint(ev: MouseEvent): Point
4027  	// Given a MouseEvent object, returns the pixel coordinate relative to
4028  	// the [origin pixel](#map-getpixelorigin) where the event took place.
4029  	mouseEventToLayerPoint: function (e) {
4030  		return this.containerPointToLayerPoint(this.mouseEventToContainerPoint(e));
4031  	},
4032
4033  	// @method mouseEventToLatLng(ev: MouseEvent): LatLng
4034  	// Given a MouseEvent object, returns geographical coordinate where the
4035  	// event took place.
4036  	mouseEventToLatLng: function (e) { // (MouseEvent)
4037  		return this.layerPointToLatLng(this.mouseEventToLayerPoint(e));
4038  	},
4039
4040
4041  	// map initialization methods
4042
4043  	_initContainer: function (id) {
4044  		var container = this._container = get(id);
4045
4046  		if (!container) {
4047  			throw new Error('Map container not found.');
4048  		} else if (container._leaflet_id) {
4049  			throw new Error('Map container is already initialized.');
4050  		}
4051
4052  		on(container, 'scroll', this._onScroll, this);
4053  		this._containerId = stamp(container);
4054  	},
4055
4056  	_initLayout: function () {
4057  		var container = this._container;
4058
4059  		this._fadeAnimated = this.options.fadeAnimation && any3d;
4060
4061  		addClass(container, 'leaflet-container' +
4062  			(touch ? ' leaflet-touch' : '') +
4063  			(retina ? ' leaflet-retina' : '') +
4064  			(ielt9 ? ' leaflet-oldie' : '') +
4065  			(safari ? ' leaflet-safari' : '') +
4066  			(this._fadeAnimated ? ' leaflet-fade-anim' : ''));
4067
4068  		var position = getStyle(container, 'position');
4069
4070  		if (position !== 'absolute' && position !== 'relative' && position !== 'fixed') {
4071  			container.style.position = 'relative';
4072  		}
4073
4074  		this._initPanes();
4075
4076  		if (this._initControlPos) {
4077  			this._initControlPos();
4078  		}
4079  	},
4080
4081  	_initPanes: function () {
4082  		var panes = this._panes = {};
4083  		this._paneRenderers = {};
4084
4085  		// @section
4086  		//
4087  		// Panes are DOM elements used to control the ordering of layers on the map. You
4088  		// can access panes with [`map.getPane`](#map-getpane) or
4089  		// [`map.getPanes`](#map-getpanes) methods. New panes can be created with the
4090  		// [`map.createPane`](#map-createpane) method.
4091  		//
4092  		// Every map has the following default panes that differ only in zIndex.
4093  		//
4094  		// @pane mapPane: HTMLElement = 'auto'
4095  		// Pane that contains all other map panes
4096
4097  		this._mapPane = this.createPane('mapPane', this._container);
4098  		setPosition(this._mapPane, new Point(0, 0));
4099
4100  		// @pane tilePane: HTMLElement = 200
4101  		// Pane for `GridLayer`s and `TileLayer`s
4102  		this.createPane('tilePane');
4103  		// @pane overlayPane: HTMLElement = 400
4104  		// Pane for vectors (`Path`s, like `Polyline`s and `Polygon`s), `ImageOverlay`s and `VideoOverlay`s
4105  		this.createPane('overlayPane');
4106  		// @pane shadowPane: HTMLElement = 500
4107  		// Pane for overlay shadows (e.g. `Marker` shadows)
4108  		this.createPane('shadowPane');
4109  		// @pane markerPane: HTMLElement = 600
4110  		// Pane for `Icon`s of `Marker`s
4111  		this.createPane('markerPane');
4112  		// @pane tooltipPane: HTMLElement = 650
4113  		// Pane for `Tooltip`s.
4114  		this.createPane('tooltipPane');
4115  		// @pane popupPane: HTMLElement = 700
4116  		// Pane for `Popup`s.
4117  		this.createPane('popupPane');
4118
4119  		if (!this.options.markerZoomAnimation) {
4120  			addClass(panes.markerPane, 'leaflet-zoom-hide');
4121  			addClass(panes.shadowPane, 'leaflet-zoom-hide');
4122  		}
4123  	},
4124
4125
4126  	// private methods that modify map state
4127
4128  	// @section Map state change events
4129  	_resetView: function (center, zoom) {
4130  		setPosition(this._mapPane, new Point(0, 0));
4131
4132  		var loading = !this._loaded;
4133  		this._loaded = true;
4134  		zoom = this._limitZoom(zoom);
4135
4136  		this.fire('viewprereset');
4137
4138  		var zoomChanged = this._zoom !== zoom;
4139  		this
4140  			._moveStart(zoomChanged, false)
4141  			._move(center, zoom)
4142  			._moveEnd(zoomChanged);
4143
4144  		// @event viewreset: Event
4145  		// Fired when the map needs to redraw its content (this usually happens
4146  		// on map zoom or load). Very useful for creating custom overlays.
4147  		this.fire('viewreset');
4148
4149  		// @event load: Event
4150  		// Fired when the map is initialized (when its center and zoom are set
4151  		// for the first time).
4152  		if (loading) {
4153  			this.fire('load');
4154  		}
4155  	},
4156
4157  	_moveStart: function (zoomChanged, noMoveStart) {
4158  		// @event zoomstart: Event
4159  		// Fired when the map zoom is about to change (e.g. before zoom animation).
4160  		// @event movestart: Event
4161  		// Fired when the view of the map starts changing (e.g. user starts dragging the map).
4162  		if (zoomChanged) {
4163  			this.fire('zoomstart');
4164  		}
4165  		if (!noMoveStart) {
4166  			this.fire('movestart');
4167  		}
4168  		return this;
4169  	},
4170
4171  	_move: function (center, zoom, data) {
4172  		if (zoom === undefined) {
4173  			zoom = this._zoom;
4174  		}
4175  		var zoomChanged = this._zoom !== zoom;
4176
4177  		this._zoom = zoom;
4178  		this._lastCenter = center;
4179  		this._pixelOrigin = this._getNewPixelOrigin(center);
4180
4181  		// @event zoom: Event
4182  		// Fired repeatedly during any change in zoom level,
4183  		// including zoom and fly animations.
4184  		if (zoomChanged || (data && data.pinch)) {	// Always fire 'zoom' if pinching because #3530
4185  			this.fire('zoom', data);
4186  		}
4187
4188  		// @event move: Event
4189  		// Fired repeatedly during any movement of the map,
4190  		// including pan and fly animations.
4191  		return this.fire('move', data);
4192  	},
4193
4194  	_moveEnd: function (zoomChanged) {
4195  		// @event zoomend: Event
4196  		// Fired when the map zoom changed, after any animations.
4197  		if (zoomChanged) {
4198  			this.fire('zoomend');
4199  		}
4200
4201  		// @event moveend: Event
4202  		// Fired when the center of the map stops changing
4203  		// (e.g. user stopped dragging the map or after non-centered zoom).
4204  		return this.fire('moveend');
4205  	},
4206
4207  	_stop: function () {
4208  		cancelAnimFrame(this._flyToFrame);
4209  		if (this._panAnim) {
4210  			this._panAnim.stop();
4211  		}
4212  		return this;
4213  	},
4214
4215  	_rawPanBy: function (offset) {
4216  		setPosition(this._mapPane, this._getMapPanePos().subtract(offset));
4217  	},
4218
4219  	_getZoomSpan: function () {
4220  		return this.getMaxZoom() - this.getMinZoom();
4221  	},
4222
4223  	_panInsideMaxBounds: function () {
4224  		if (!this._enforcingBounds) {
4225  			this.panInsideBounds(this.options.maxBounds);
4226  		}
4227  	},
4228
4229  	_checkIfLoaded: function () {
4230  		if (!this._loaded) {
4231  			throw new Error('Set map center and zoom first.');
4232  		}
4233  	},
4234
4235  	// DOM event handling
4236
4237  	// @section Interaction events
4238  	_initEvents: function (remove) {
4239  		this._targets = {};
4240  		this._targets[stamp(this._container)] = this;
4241
4242  		var onOff = remove ? off : on;
4243
4244  		// @event click: MouseEvent
4245  		// Fired when the user clicks (or taps) the map.
4246  		// @event dblclick: MouseEvent
4247  		// Fired when the user double-clicks (or double-taps) the map.
4248  		// @event mousedown: MouseEvent
4249  		// Fired when the user pushes the mouse button on the map.
4250  		// @event mouseup: MouseEvent
4251  		// Fired when the user releases the mouse button on the map.
4252  		// @event mouseover: MouseEvent
4253  		// Fired when the mouse enters the map.
4254  		// @event mouseout: MouseEvent
4255  		// Fired when the mouse leaves the map.
4256  		// @event mousemove: MouseEvent
4257  		// Fired while the mouse moves over the map.
4258  		// @event contextmenu: MouseEvent
4259  		// Fired when the user pushes the right mouse button on the map, prevents
4260  		// default browser context menu from showing if there are listeners on
4261  		// this event. Also fired on mobile when the user holds a single touch
4262  		// for a second (also called long press).
4263  		// @event keypress: KeyboardEvent
4264  		// Fired when the user presses a key from the keyboard that produces a character value while the map is focused.
4265  		// @event keydown: KeyboardEvent
4266  		// Fired when the user presses a key from the keyboard while the map is focused. Unlike the `keypress` event,
4267  		// the `keydown` event is fired for keys that produce a character value and for keys
4268  		// that do not produce a character value.
4269  		// @event keyup: KeyboardEvent
4270  		// Fired when the user releases a key from the keyboard while the map is focused.
4271  		onOff(this._container, 'click dblclick mousedown mouseup ' +
4272  			'mouseover mouseout mousemove contextmenu keypress keydown keyup', this._handleDOMEvent, this);
4273
4274  		if (this.options.trackResize) {
4275  			onOff(window, 'resize', this._onResize, this);
4276  		}
4277
4278  		if (any3d && this.options.transform3DLimit) {
4279  			(remove ? this.off : this.on).call(this, 'moveend', this._onMoveEnd);
4280  		}
4281  	},
4282
4283  	_onResize: function () {
4284  		cancelAnimFrame(this._resizeRequest);
4285  		this._resizeRequest = requestAnimFrame(
4286  		        function () { this.invalidateSize({debounceMoveend: true}); }, this);
4287  	},
4288
4289  	_onScroll: function () {
4290  		this._container.scrollTop  = 0;
4291  		this._container.scrollLeft = 0;
4292  	},
4293
4294  	_onMoveEnd: function () {
4295  		var pos = this._getMapPanePos();
4296  		if (Math.max(Math.abs(pos.x), Math.abs(pos.y)) >= this.options.transform3DLimit) {
4297  			// https://bugzilla.mozilla.org/show_bug.cgi?id=1203873 but Webkit also have
4298  			// a pixel offset on very high values, see: http://jsfiddle.net/dg6r5hhb/
4299  			this._resetView(this.getCenter(), this.getZoom());
4300  		}
4301  	},
4302
4303  	_findEventTargets: function (e, type) {
4304  		var targets = [],
4305  		    target,
4306  		    isHover = type === 'mouseout' || type === 'mouseover',
4307  		    src = e.target || e.srcElement,
4308  		    dragging = false;
4309
4310  		while (src) {
4311  			target = this._targets[stamp(src)];
4312  			if (target && (type === 'click' || type === 'preclick') && this._draggableMoved(target)) {
4313  				// Prevent firing click after you just dragged an object.
4314  				dragging = true;
4315  				break;
4316  			}
4317  			if (target && target.listens(type, true)) {
4318  				if (isHover && !isExternalTarget(src, e)) { break; }
4319  				targets.push(target);
4320  				if (isHover) { break; }
4321  			}
4322  			if (src === this._container) { break; }
4323  			src = src.parentNode;
4324  		}
4325  		if (!targets.length && !dragging && !isHover && isExternalTarget(src, e)) {
4326  			targets = [this];
4327  		}
4328  		return targets;
4329  	},
4330
4331  	_isClickDisabled: function (el) {
4332  		while (el !== this._container) {
4333  			if (el['_leaflet_disable_click']) { return true; }
4334  			el = el.parentNode;
4335  		}
4336  	},
4337
4338  	_handleDOMEvent: function (e) {
4339  		var el = (e.target || e.srcElement);
4340  		if (!this._loaded || el['_leaflet_disable_events'] || e.type === 'click' && this._isClickDisabled(el)) {
4341  			return;
4342  		}
4343
4344  		var type = e.type;
4345
4346  		if (type === 'mousedown') {
4347  			// prevents outline when clicking on keyboard-focusable element
4348  			preventOutline(el);
4349  		}
4350
4351  		this._fireDOMEvent(e, type);
4352  	},
4353
4354  	_mouseEvents: ['click', 'dblclick', 'mouseover', 'mouseout', 'contextmenu'],
4355
4356  	_fireDOMEvent: function (e, type, canvasTargets) {
4357
4358  		if (e.type === 'click') {
4359  			// Fire a synthetic 'preclick' event which propagates up (mainly for closing popups).
4360  			// @event preclick: MouseEvent
4361  			// Fired before mouse click on the map (sometimes useful when you
4362  			// want something to happen on click before any existing click
4363  			// handlers start running).
4364  			var synth = extend({}, e);
4365  			synth.type = 'preclick';
4366  			this._fireDOMEvent(synth, synth.type, canvasTargets);
4367  		}
4368
4369  		// Find the layer the event is propagating from and its parents.
4370  		var targets = this._findEventTargets(e, type);
4371
4372  		if (canvasTargets) {
4373  			var filtered = []; // pick only targets with listeners
4374  			for (var i = 0; i < canvasTargets.length; i++) {
4375  				if (canvasTargets[i].listens(type, true)) {
4376  					filtered.push(canvasTargets[i]);
4377  				}
4378  			}
4379  			targets = filtered.concat(targets);
4380  		}
4381
4382  		if (!targets.length) { return; }
4383
4384  		if (type === 'contextmenu') {
4385  			preventDefault(e);
4386  		}
4387
4388  		var target = targets[0];
4389  		var data = {
4390  			originalEvent: e
4391  		};
4392
4393  		if (e.type !== 'keypress' && e.type !== 'keydown' && e.type !== 'keyup') {
4394  			var isMarker = target.getLatLng && (!target._radius || target._radius <= 10);
4395  			data.containerPoint = isMarker ?
4396  				this.latLngToContainerPoint(target.getLatLng()) : this.mouseEventToContainerPoint(e);
4397  			data.layerPoint = this.containerPointToLayerPoint(data.containerPoint);
4398  			data.latlng = isMarker ? target.getLatLng() : this.layerPointToLatLng(data.layerPoint);
4399  		}
4400
4401  		for (i = 0; i < targets.length; i++) {
4402  			targets[i].fire(type, data, true);
4403  			if (data.originalEvent._stopped ||
4404  				(targets[i].options.bubblingMouseEvents === false && indexOf(this._mouseEvents, type) !== -1)) { return; }
4405  		}
4406  	},
4407
4408  	_draggableMoved: function (obj) {
4409  		obj = obj.dragging && obj.dragging.enabled() ? obj : this;
4410  		return (obj.dragging && obj.dragging.moved()) || (this.boxZoom && this.boxZoom.moved());
4411  	},
4412
4413  	_clearHandlers: function () {
4414  		for (var i = 0, len = this._handlers.length; i < len; i++) {
4415  			this._handlers[i].disable();
4416  		}
4417  	},
4418
4419  	// @section Other Methods
4420
4421  	// @method whenReady(fn: Function, context?: Object): this
4422  	// Runs the given function `fn` when the map gets initialized with
4423  	// a view (center and zoom) and at least one layer, or immediately
4424  	// if it's already initialized, optionally passing a function context.
4425  	whenReady: function (callback, context) {
4426  		if (this._loaded) {
4427  			callback.call(context || this, {target: this});
4428  		} else {
4429  			this.on('load', callback, context);
4430  		}
4431  		return this;
4432  	},
4433
4434
4435  	// private methods for getting map state
4436
4437  	_getMapPanePos: function () {
4438  		return getPosition(this._mapPane) || new Point(0, 0);
4439  	},
4440
4441  	_moved: function () {
4442  		var pos = this._getMapPanePos();
4443  		return pos && !pos.equals([0, 0]);
4444  	},
4445
4446  	_getTopLeftPoint: function (center, zoom) {
4447  		var pixelOrigin = center && zoom !== undefined ?
4448  			this._getNewPixelOrigin(center, zoom) :
4449  			this.getPixelOrigin();
4450  		return pixelOrigin.subtract(this._getMapPanePos());
4451  	},
4452
4453  	_getNewPixelOrigin: function (center, zoom) {
4454  		var viewHalf = this.getSize()._divideBy(2);
4455  		return this.project(center, zoom)._subtract(viewHalf)._add(this._getMapPanePos())._round();
4456  	},
4457
4458  	_latLngToNewLayerPoint: function (latlng, zoom, center) {
4459  		var topLeft = this._getNewPixelOrigin(center, zoom);
4460  		return this.project(latlng, zoom)._subtract(topLeft);
4461  	},
4462
4463  	_latLngBoundsToNewLayerBounds: function (latLngBounds, zoom, center) {
4464  		var topLeft = this._getNewPixelOrigin(center, zoom);
4465  		return toBounds([
4466  			this.project(latLngBounds.getSouthWest(), zoom)._subtract(topLeft),
4467  			this.project(latLngBounds.getNorthWest(), zoom)._subtract(topLeft),
4468  			this.project(latLngBounds.getSouthEast(), zoom)._subtract(topLeft),
4469  			this.project(latLngBounds.getNorthEast(), zoom)._subtract(topLeft)
4470  		]);
4471  	},
4472
4473  	// layer point of the current center
4474  	_getCenterLayerPoint: function () {
4475  		return this.containerPointToLayerPoint(this.getSize()._divideBy(2));
4476  	},
4477
4478  	// offset of the specified place to the current center in pixels
4479  	_getCenterOffset: function (latlng) {
4480  		return this.latLngToLayerPoint(latlng).subtract(this._getCenterLayerPoint());
4481  	},
4482
4483  	// adjust center for view to get inside bounds
4484  	_limitCenter: function (center, zoom, bounds) {
4485
4486  		if (!bounds) { return center; }
4487
4488  		var centerPoint = this.project(center, zoom),
4489  		    viewHalf = this.getSize().divideBy(2),
4490  		    viewBounds = new Bounds(centerPoint.subtract(viewHalf), centerPoint.add(viewHalf)),
4491  		    offset = this._getBoundsOffset(viewBounds, bounds, zoom);
4492
4493  		// If offset is less than a pixel, ignore.
4494  		// This prevents unstable projections from getting into
4495  		// an infinite loop of tiny offsets.
4496  		if (offset.round().equals([0, 0])) {
4497  			return center;
4498  		}
4499
4500  		return this.unproject(centerPoint.add(offset), zoom);
4501  	},
4502
4503  	// adjust offset for view to get inside bounds
4504  	_limitOffset: function (offset, bounds) {
4505  		if (!bounds) { return offset; }
4506
4507  		var viewBounds = this.getPixelBounds(),
4508  		    newBounds = new Bounds(viewBounds.min.add(offset), viewBounds.max.add(offset));
4509
4510  		return offset.add(this._getBoundsOffset(newBounds, bounds));
4511  	},
4512
4513  	// returns offset needed for pxBounds to get inside maxBounds at a specified zoom
4514  	_getBoundsOffset: function (pxBounds, maxBounds, zoom) {
4515  		var projectedMaxBounds = toBounds(
4516  		        this.project(maxBounds.getNorthEast(), zoom),
4517  		        this.project(maxBounds.getSouthWest(), zoom)
4518  		    ),
4519  		    minOffset = projectedMaxBounds.min.subtract(pxBounds.min),
4520  		    maxOffset = projectedMaxBounds.max.subtract(pxBounds.max),
4521
4522  		    dx = this._rebound(minOffset.x, -maxOffset.x),
4523  		    dy = this._rebound(minOffset.y, -maxOffset.y);
4524
4525  		return new Point(dx, dy);
4526  	},
4527
4528  	_rebound: function (left, right) {
4529  		return left + right > 0 ?
4530  			Math.round(left - right) / 2 :
4531  			Math.max(0, Math.ceil(left)) - Math.max(0, Math.floor(right));
4532  	},
4533
4534  	_limitZoom: function (zoom) {
4535  		var min = this.getMinZoom(),
4536  		    max = this.getMaxZoom(),
4537  		    snap = any3d ? this.options.zoomSnap : 1;
4538  		if (snap) {
4539  			zoom = Math.round(zoom / snap) * snap;
4540  		}
4541  		return Math.max(min, Math.min(max, zoom));
4542  	},
4543
4544  	_onPanTransitionStep: function () {
4545  		this.fire('move');
4546  	},
4547
4548  	_onPanTransitionEnd: function () {
4549  		removeClass(this._mapPane, 'leaflet-pan-anim');
4550  		this.fire('moveend');
4551  	},
4552
4553  	_tryAnimatedPan: function (center, options) {
4554  		// difference between the new and current centers in pixels
4555  		var offset = this._getCenterOffset(center)._trunc();
4556
4557  		// don't animate too far unless animate: true specified in options
4558  		if ((options && options.animate) !== true && !this.getSize().contains(offset)) { return false; }
4559
4560  		this.panBy(offset, options);
4561
4562  		return true;
4563  	},
4564
4565  	_createAnimProxy: function () {
4566
4567  		var proxy = this._proxy = create$1('div', 'leaflet-proxy leaflet-zoom-animated');
4568  		this._panes.mapPane.appendChild(proxy);
4569
4570  		this.on('zoomanim', function (e) {
4571  			var prop = TRANSFORM,
4572  			    transform = this._proxy.style[prop];
4573
4574  			setTransform(this._proxy, this.project(e.center, e.zoom), this.getZoomScale(e.zoom, 1));
4575
4576  			// workaround for case when transform is the same and so transitionend event is not fired
4577  			if (transform === this._proxy.style[prop] && this._animatingZoom) {
4578  				this._onZoomTransitionEnd();
4579  			}
4580  		}, this);
4581
4582  		this.on('load moveend', this._animMoveEnd, this);
4583
4584  		this._on('unload', this._destroyAnimProxy, this);
4585  	},
4586
4587  	_destroyAnimProxy: function () {
4588  		remove(this._proxy);
4589  		this.off('load moveend', this._animMoveEnd, this);
4590  		delete this._proxy;
4591  	},
4592
4593  	_animMoveEnd: function () {
4594  		var c = this.getCenter(),
4595  		    z = this.getZoom();
4596  		setTransform(this._proxy, this.project(c, z), this.getZoomScale(z, 1));
4597  	},
4598
4599  	_catchTransitionEnd: function (e) {
4600  		if (this._animatingZoom && e.propertyName.indexOf('transform') >= 0) {
4601  			this._onZoomTransitionEnd();
4602  		}
4603  	},
4604
4605  	_nothingToAnimate: function () {
4606  		return !this._container.getElementsByClassName('leaflet-zoom-animated').length;
4607  	},
4608
4609  	_tryAnimatedZoom: function (center, zoom, options) {
4610
4611  		if (this._animatingZoom) { return true; }
4612
4613  		options = options || {};
4614
4615  		// don't animate if disabled, not supported or zoom difference is too large
4616  		if (!this._zoomAnimated || options.animate === false || this._nothingToAnimate() ||
4617  		        Math.abs(zoom - this._zoom) > this.options.zoomAnimationThreshold) { return false; }
4618
4619  		// offset is the pixel coords of the zoom origin relative to the current center
4620  		var scale = this.getZoomScale(zoom),
4621  		    offset = this._getCenterOffset(center)._divideBy(1 - 1 / scale);
4622
4623  		// don't animate if the zoom origin isn't within one screen from the current center, unless forced
4624  		if (options.animate !== true && !this.getSize().contains(offset)) { return false; }
4625
4626  		requestAnimFrame(function () {
4627  			this
4628  			    ._moveStart(true, false)
4629  			    ._animateZoom(center, zoom, true);
4630  		}, this);
4631
4632  		return true;
4633  	},
4634
4635  	_animateZoom: function (center, zoom, startAnim, noUpdate) {
4636  		if (!this._mapPane) { return; }
4637
4638  		if (startAnim) {
4639  			this._animatingZoom = true;
4640
4641  			// remember what center/zoom to set after animation
4642  			this._animateToCenter = center;
4643  			this._animateToZoom = zoom;
4644
4645  			addClass(this._mapPane, 'leaflet-zoom-anim');
4646  		}
4647
4648  		// @section Other Events
4649  		// @event zoomanim: ZoomAnimEvent
4650  		// Fired at least once per zoom animation. For continuous zoom, like pinch zooming, fired once per frame during zoom.
4651  		this.fire('zoomanim', {
4652  			center: center,
4653  			zoom: zoom,
4654  			noUpdate: noUpdate
4655  		});
4656
4657  		// Work around webkit not firing 'transitionend', see https://github.com/Leaflet/Leaflet/issues/3689, 2693
4658  		setTimeout(bind(this._onZoomTransitionEnd, this), 250);
4659  	},
4660
4661  	_onZoomTransitionEnd: function () {
4662  		if (!this._animatingZoom) { return; }
4663
4664  		if (this._mapPane) {
4665  			removeClass(this._mapPane, 'leaflet-zoom-anim');
4666  		}
4667
4668  		this._animatingZoom = false;
4669
4670  		this._move(this._animateToCenter, this._animateToZoom);
4671
4672  		// This anim frame should prevent an obscure iOS webkit tile loading race condition.
4673  		requestAnimFrame(function () {
4674  			this._moveEnd(true);
4675  		}, this);
4676  	}
4677  });
4678
4679  // @section
4680
4681  // @factory L.map(id: String, options?: Map options)
4682  // Instantiates a map object given the DOM ID of a `<div>` element
4683  // and optionally an object literal with `Map options`.
4684  //
4685  // @alternative
4686  // @factory L.map(el: HTMLElement, options?: Map options)
4687  // Instantiates a map object given an instance of a `<div>` HTML element
4688  // and optionally an object literal with `Map options`.
4689  function createMap(id, options) {
4690  	return new Map(id, options);
4691  }
4692
4693  /*
4694   * @class Control
4695   * @aka L.Control
4696   * @inherits Class
4697   *
4698   * L.Control is a base class for implementing map controls. Handles positioning.
4699   * All other controls extend from this class.
4700   */
4701
4702  var Control = Class.extend({
4703  	// @section
4704  	// @aka Control Options
4705  	options: {
4706  		// @option position: String = 'topright'
4707  		// The position of the control (one of the map corners). Possible values are `'topleft'`,
4708  		// `'topright'`, `'bottomleft'` or `'bottomright'`
4709  		position: 'topright'
4710  	},
4711
4712  	initialize: function (options) {
4713  		setOptions(this, options);
4714  	},
4715
4716  	/* @section
4717  	 * Classes extending L.Control will inherit the following methods:
4718  	 *
4719  	 * @method getPosition: string
4720  	 * Returns the position of the control.
4721  	 */
4722  	getPosition: function () {
4723  		return this.options.position;
4724  	},
4725
4726  	// @method setPosition(position: string): this
4727  	// Sets the position of the control.
4728  	setPosition: function (position) {
4729  		var map = this._map;
4730
4731  		if (map) {
4732  			map.removeControl(this);
4733  		}
4734
4735  		this.options.position = position;
4736
4737  		if (map) {
4738  			map.addControl(this);
4739  		}
4740
4741  		return this;
4742  	},
4743
4744  	// @method getContainer: HTMLElement
4745  	// Returns the HTMLElement that contains the control.
4746  	getContainer: function () {
4747  		return this._container;
4748  	},
4749
4750  	// @method addTo(map: Map): this
4751  	// Adds the control to the given map.
4752  	addTo: function (map) {
4753  		this.remove();
4754  		this._map = map;
4755
4756  		var container = this._container = this.onAdd(map),
4757  		    pos = this.getPosition(),
4758  		    corner = map._controlCorners[pos];
4759
4760  		addClass(container, 'leaflet-control');
4761
4762  		if (pos.indexOf('bottom') !== -1) {
4763  			corner.insertBefore(container, corner.firstChild);
4764  		} else {
4765  			corner.appendChild(container);
4766  		}
4767
4768  		this._map.on('unload', this.remove, this);
4769
4770  		return this;
4771  	},
4772
4773  	// @method remove: this
4774  	// Removes the control from the map it is currently active on.
4775  	remove: function () {
4776  		if (!this._map) {
4777  			return this;
4778  		}
4779
4780  		remove(this._container);
4781
4782  		if (this.onRemove) {
4783  			this.onRemove(this._map);
4784  		}
4785
4786  		this._map.off('unload', this.remove, this);
4787  		this._map = null;
4788
4789  		return this;
4790  	},
4791
4792  	_refocusOnMap: function (e) {
4793  		// if map exists and event is not a keyboard event
4794  		if (this._map && e && e.screenX > 0 && e.screenY > 0) {
4795  			this._map.getContainer().focus();
4796  		}
4797  	}
4798  });
4799
4800  var control = function (options) {
4801  	return new Control(options);
4802  };
4803
4804  /* @section Extension methods
4805   * @uninheritable
4806   *
4807   * Every control should extend from `L.Control` and (re-)implement the following methods.
4808   *
4809   * @method onAdd(map: Map): HTMLElement
4810   * Should return the container DOM element for the control and add listeners on relevant map events. Called on [`control.addTo(map)`](#control-addTo).
4811   *
4812   * @method onRemove(map: Map)
4813   * Optional method. Should contain all clean up code that removes the listeners previously added in [`onAdd`](#control-onadd). Called on [`control.remove()`](#control-remove).
4814   */
4815
4816  /* @namespace Map
4817   * @section Methods for Layers and Controls
4818   */
4819  Map.include({
4820  	// @method addControl(control: Control): this
4821  	// Adds the given control to the map
4822  	addControl: function (control) {
4823  		control.addTo(this);
4824  		return this;
4825  	},
4826
4827  	// @method removeControl(control: Control): this
4828  	// Removes the given control from the map
4829  	removeControl: function (control) {
4830  		control.remove();
4831  		return this;
4832  	},
4833
4834  	_initControlPos: function () {
4835  		var corners = this._controlCorners = {},
4836  		    l = 'leaflet-',
4837  		    container = this._controlContainer =
4838  		            create$1('div', l + 'control-container', this._container);
4839
4840  		function createCorner(vSide, hSide) {
4841  			var className = l + vSide + ' ' + l + hSide;
4842
4843  			corners[vSide + hSide] = create$1('div', className, container);
4844  		}
4845
4846  		createCorner('top', 'left');
4847  		createCorner('top', 'right');
4848  		createCorner('bottom', 'left');
4849  		createCorner('bottom', 'right');
4850  	},
4851
4852  	_clearControlPos: function () {
4853  		for (var i in this._controlCorners) {
4854  			remove(this._controlCorners[i]);
4855  		}
4856  		remove(this._controlContainer);
4857  		delete this._controlCorners;
4858  		delete this._controlContainer;
4859  	}
4860  });
4861
4862  /*
4863   * @class Control.Layers
4864   * @aka L.Control.Layers
4865   * @inherits Control
4866   *
4867   * The layers control gives users the ability to switch between different base layers and switch overlays on/off (check out the [detailed example](http://leafletjs.com/examples/layers-control/)). Extends `Control`.
4868   *
4869   * @example
4870   *
4871   * ```js
4872   * var baseLayers = {
4873   * 	"Mapbox": mapbox,
4874   * 	"OpenStreetMap": osm
4875   * };
4876   *
4877   * var overlays = {
4878   * 	"Marker": marker,
4879   * 	"Roads": roadsLayer
4880   * };
4881   *
4882   * L.control.layers(baseLayers, overlays).addTo(map);
4883   * ```
4884   *
4885   * The `baseLayers` and `overlays` parameters are object literals with layer names as keys and `Layer` objects as values:
4886   *
4887   * ```js
4888   * {
4889   *     "<someName1>": layer1,
4890   *     "<someName2>": layer2
4891   * }
4892   * ```
4893   *
4894   * The layer names can contain HTML, which allows you to add additional styling to the items:
4895   *
4896   * ```js
4897   * {"<img src='my-layer-icon' /> <span class='my-layer-item'>My Layer</span>": myLayer}
4898   * ```
4899   */
4900
4901  var Layers = Control.extend({
4902  	// @section
4903  	// @aka Control.Layers options
4904  	options: {
4905  		// @option collapsed: Boolean = true
4906  		// If `true`, the control will be collapsed into an icon and expanded on mouse hover or touch.
4907  		collapsed: true,
4908  		position: 'topright',
4909
4910  		// @option autoZIndex: Boolean = true
4911  		// If `true`, the control will assign zIndexes in increasing order to all of its layers so that the order is preserved when switching them on/off.
4912  		autoZIndex: true,
4913
4914  		// @option hideSingleBase: Boolean = false
4915  		// If `true`, the base layers in the control will be hidden when there is only one.
4916  		hideSingleBase: false,
4917
4918  		// @option sortLayers: Boolean = false
4919  		// Whether to sort the layers. When `false`, layers will keep the order
4920  		// in which they were added to the control.
4921  		sortLayers: false,
4922
4923  		// @option sortFunction: Function = *
4924  		// A [compare function](https://developer.mozilla.org/docs/Web/JavaScript/Reference/Global_Objects/Array/sort)
4925  		// that will be used for sorting the layers, when `sortLayers` is `true`.
4926  		// The function receives both the `L.Layer` instances and their names, as in
4927  		// `sortFunction(layerA, layerB, nameA, nameB)`.
4928  		// By default, it sorts layers alphabetically by their name.
4929  		sortFunction: function (layerA, layerB, nameA, nameB) {
4930  			return nameA < nameB ? -1 : (nameB < nameA ? 1 : 0);
4931  		}
4932  	},
4933
4934  	initialize: function (baseLayers, overlays, options) {
4935  		setOptions(this, options);
4936
4937  		this._layerControlInputs = [];
4938  		this._layers = [];
4939  		this._lastZIndex = 0;
4940  		this._handlingClick = false;
4941
4942  		for (var i in baseLayers) {
4943  			this._addLayer(baseLayers[i], i);
4944  		}
4945
4946  		for (i in overlays) {
4947  			this._addLayer(overlays[i], i, true);
4948  		}
4949  	},
4950
4951  	onAdd: function (map) {
4952  		this._initLayout();
4953  		this._update();
4954
4955  		this._map = map;
4956  		map.on('zoomend', this._checkDisabledLayers, this);
4957
4958  		for (var i = 0; i < this._layers.length; i++) {
4959  			this._layers[i].layer.on('add remove', this._onLayerChange, this);
4960  		}
4961
4962  		return this._container;
4963  	},
4964
4965  	addTo: function (map) {
4966  		Control.prototype.addTo.call(this, map);
4967  		// Trigger expand after Layers Control has been inserted into DOM so that is now has an actual height.
4968  		return this._expandIfNotCollapsed();
4969  	},
4970
4971  	onRemove: function () {
4972  		this._map.off('zoomend', this._checkDisabledLayers, this);
4973
4974  		for (var i = 0; i < this._layers.length; i++) {
4975  			this._layers[i].layer.off('add remove', this._onLayerChange, this);
4976  		}
4977  	},
4978
4979  	// @method addBaseLayer(layer: Layer, name: String): this
4980  	// Adds a base layer (radio button entry) with the given name to the control.
4981  	addBaseLayer: function (layer, name) {
4982  		this._addLayer(layer, name);
4983  		return (this._map) ? this._update() : this;
4984  	},
4985
4986  	// @method addOverlay(layer: Layer, name: String): this
4987  	// Adds an overlay (checkbox entry) with the given name to the control.
4988  	addOverlay: function (layer, name) {
4989  		this._addLayer(layer, name, true);
4990  		return (this._map) ? this._update() : this;
4991  	},
4992
4993  	// @method removeLayer(layer: Layer): this
4994  	// Remove the given layer from the control.
4995  	removeLayer: function (layer) {
4996  		layer.off('add remove', this._onLayerChange, this);
4997
4998  		var obj = this._getLayer(stamp(layer));
4999  		if (obj) {
5000  			this._layers.splice(this._layers.indexOf(obj), 1);
5001  		}
5002  		return (this._map) ? this._update() : this;
5003  	},
5004
5005  	// @method expand(): this
5006  	// Expand the control container if collapsed.
5007  	expand: function () {
5008  		addClass(this._container, 'leaflet-control-layers-expanded');
5009  		this._section.style.height = null;
5010  		var acceptableHeight = this._map.getSize().y - (this._container.offsetTop + 50);
5011  		if (acceptableHeight < this._section.clientHeight) {
5012  			addClass(this._section, 'leaflet-control-layers-scrollbar');
5013  			this._section.style.height = acceptableHeight + 'px';
5014  		} else {
5015  			removeClass(this._section, 'leaflet-control-layers-scrollbar');
5016  		}
5017  		this._checkDisabledLayers();
5018  		return this;
5019  	},
5020
5021  	// @method collapse(): this
5022  	// Collapse the control container if expanded.
5023  	collapse: function () {
5024  		removeClass(this._container, 'leaflet-control-layers-expanded');
5025  		return this;
5026  	},
5027
5028  	_initLayout: function () {
5029  		var className = 'leaflet-control-layers',
5030  		    container = this._container = create$1('div', className),
5031  		    collapsed = this.options.collapsed;
5032
5033  		// makes this work on IE touch devices by stopping it from firing a mouseout event when the touch is released
5034  		container.setAttribute('aria-haspopup', true);
5035
5036  		disableClickPropagation(container);
5037  		disableScrollPropagation(container);
5038
5039  		var section = this._section = create$1('section', className + '-list');
5040
5041  		if (collapsed) {
5042  			this._map.on('click', this.collapse, this);
5043
5044  			on(container, {
5045  				mouseenter: function () {
5046  					on(section, 'click', preventDefault);
5047  					this.expand();
5048  					setTimeout(function () {
5049  						off(section, 'click', preventDefault);
5050  					});
5051  				},
5052  				mouseleave: this.collapse
5053  			}, this);
5054  		}
5055
5056  		var link = this._layersLink = create$1('a', className + '-toggle', container);
5057  		link.href = '#';
5058  		link.title = 'Layers';
5059
5060  		on(link, 'click', preventDefault); // prevent link function
5061  		on(link, 'focus', this.expand, this);
5062
5063  		if (!collapsed) {
5064  			this.expand();
5065  		}
5066
5067  		this._baseLayersList = create$1('div', className + '-base', section);
5068  		this._separator = create$1('div', className + '-separator', section);
5069  		this._overlaysList = create$1('div', className + '-overlays', section);
5070
5071  		container.appendChild(section);
5072  	},
5073
5074  	_getLayer: function (id) {
5075  		for (var i = 0; i < this._layers.length; i++) {
5076
5077  			if (this._layers[i] && stamp(this._layers[i].layer) === id) {
5078  				return this._layers[i];
5079  			}
5080  		}
5081  	},
5082
5083  	_addLayer: function (layer, name, overlay) {
5084  		if (this._map) {
5085  			layer.on('add remove', this._onLayerChange, this);
5086  		}
5087
5088  		this._layers.push({
5089  			layer: layer,
5090  			name: name,
5091  			overlay: overlay
5092  		});
5093
5094  		if (this.options.sortLayers) {
5095  			this._layers.sort(bind(function (a, b) {
5096  				return this.options.sortFunction(a.layer, b.layer, a.name, b.name);
5097  			}, this));
5098  		}
5099
5100  		if (this.options.autoZIndex && layer.setZIndex) {
5101  			this._lastZIndex++;
5102  			layer.setZIndex(this._lastZIndex);
5103  		}
5104
5105  		this._expandIfNotCollapsed();
5106  	},
5107
5108  	_update: function () {
5109  		if (!this._container) { return this; }
5110
5111  		empty(this._baseLayersList);
5112  		empty(this._overlaysList);
5113
5114  		this._layerControlInputs = [];
5115  		var baseLayersPresent, overlaysPresent, i, obj, baseLayersCount = 0;
5116
5117  		for (i = 0; i < this._layers.length; i++) {
5118  			obj = this._layers[i];
5119  			this._addItem(obj);
5120  			overlaysPresent = overlaysPresent || obj.overlay;
5121  			baseLayersPresent = baseLayersPresent || !obj.overlay;
5122  			baseLayersCount += !obj.overlay ? 1 : 0;
5123  		}
5124
5125  		// Hide base layers section if there's only one layer.
5126  		if (this.options.hideSingleBase) {
5127  			baseLayersPresent = baseLayersPresent && baseLayersCount > 1;
5128  			this._baseLayersList.style.display = baseLayersPresent ? '' : 'none';
5129  		}
5130
5131  		this._separator.style.display = overlaysPresent && baseLayersPresent ? '' : 'none';
5132
5133  		return this;
5134  	},
5135
5136  	_onLayerChange: function (e) {
5137  		if (!this._handlingClick) {
5138  			this._update();
5139  		}
5140
5141  		var obj = this._getLayer(stamp(e.target));
5142
5143  		// @namespace Map
5144  		// @section Layer events
5145  		// @event baselayerchange: LayersControlEvent
5146  		// Fired when the base layer is changed through the [layers control](#control-layers).
5147  		// @event overlayadd: LayersControlEvent
5148  		// Fired when an overlay is selected through the [layers control](#control-layers).
5149  		// @event overlayremove: LayersControlEvent
5150  		// Fired when an overlay is deselected through the [layers control](#control-layers).
5151  		// @namespace Control.Layers
5152  		var type = obj.overlay ?
5153  			(e.type === 'add' ? 'overlayadd' : 'overlayremove') :
5154  			(e.type === 'add' ? 'baselayerchange' : null);
5155
5156  		if (type) {
5157  			this._map.fire(type, obj);
5158  		}
5159  	},
5160
5161  	// IE7 bugs out if you create a radio dynamically, so you have to do it this hacky way (see https://stackoverflow.com/a/119079)
5162  	_createRadioElement: function (name, checked) {
5163
5164  		var radioHtml = '<input type="radio" class="leaflet-control-layers-selector" name="' +
5165  				name + '"' + (checked ? ' checked="checked"' : '') + '/>';
5166
5167  		var radioFragment = document.createElement('div');
5168  		radioFragment.innerHTML = radioHtml;
5169
5170  		return radioFragment.firstChild;
5171  	},
5172
5173  	_addItem: function (obj) {
5174  		var label = document.createElement('label'),
5175  		    checked = this._map.hasLayer(obj.layer),
5176  		    input;
5177
5178  		if (obj.overlay) {
5179  			input = document.createElement('input');
5180  			input.type = 'checkbox';
5181  			input.className = 'leaflet-control-layers-selector';
5182  			input.defaultChecked = checked;
5183  		} else {
5184  			input = this._createRadioElement('leaflet-base-layers_' + stamp(this), checked);
5185  		}
5186
5187  		this._layerControlInputs.push(input);
5188  		input.layerId = stamp(obj.layer);
5189
5190  		on(input, 'click', this._onInputClick, this);
5191
5192  		var name = document.createElement('span');
5193  		name.innerHTML = ' ' + obj.name;
5194
5195  		// Helps from preventing layer control flicker when checkboxes are disabled
5196  		// https://github.com/Leaflet/Leaflet/issues/2771
5197  		var holder = document.createElement('div');
5198
5199  		label.appendChild(holder);
5200  		holder.appendChild(input);
5201  		holder.appendChild(name);
5202
5203  		var container = obj.overlay ? this._overlaysList : this._baseLayersList;
5204  		container.appendChild(label);
5205
5206  		this._checkDisabledLayers();
5207  		return label;
5208  	},
5209
5210  	_onInputClick: function () {
5211  		var inputs = this._layerControlInputs,
5212  		    input, layer;
5213  		var addedLayers = [],
5214  		    removedLayers = [];
5215
5216  		this._handlingClick = true;
5217
5218  		for (var i = inputs.length - 1; i >= 0; i--) {
5219  			input = inputs[i];
5220  			layer = this._getLayer(input.layerId).layer;
5221
5222  			if (input.checked) {
5223  				addedLayers.push(layer);
5224  			} else if (!input.checked) {
5225  				removedLayers.push(layer);
5226  			}
5227  		}
5228
5229  		// Bugfix issue 2318: Should remove all old layers before readding new ones
5230  		for (i = 0; i < removedLayers.length; i++) {
5231  			if (this._map.hasLayer(removedLayers[i])) {
5232  				this._map.removeLayer(removedLayers[i]);
5233  			}
5234  		}
5235  		for (i = 0; i < addedLayers.length; i++) {
5236  			if (!this._map.hasLayer(addedLayers[i])) {
5237  				this._map.addLayer(addedLayers[i]);
5238  			}
5239  		}
5240
5241  		this._handlingClick = false;
5242
5243  		this._refocusOnMap();
5244  	},
5245
5246  	_checkDisabledLayers: function () {
5247  		var inputs = this._layerControlInputs,
5248  		    input,
5249  		    layer,
5250  		    zoom = this._map.getZoom();
5251
5252  		for (var i = inputs.length - 1; i >= 0; i--) {
5253  			input = inputs[i];
5254  			layer = this._getLayer(input.layerId).layer;
5255  			input.disabled = (layer.options.minZoom !== undefined && zoom < layer.options.minZoom) ||
5256  			                 (layer.options.maxZoom !== undefined && zoom > layer.options.maxZoom);
5257
5258  		}
5259  	},
5260
5261  	_expandIfNotCollapsed: function () {
5262  		if (this._map && !this.options.collapsed) {
5263  			this.expand();
5264  		}
5265  		return this;
5266  	}
5267
5268  });
5269
5270
5271  // @factory L.control.layers(baselayers?: Object, overlays?: Object, options?: Control.Layers options)
5272  // Creates a layers control with the given layers. Base layers will be switched with radio buttons, while overlays will be switched with checkboxes. Note that all base layers should be passed in the base layers object, but only one should be added to the map during map instantiation.
5273  var layers = function (baseLayers, overlays, options) {
5274  	return new Layers(baseLayers, overlays, options);
5275  };
5276
5277  /*
5278   * @class Control.Zoom
5279   * @aka L.Control.Zoom
5280   * @inherits Control
5281   *
5282   * A basic zoom control with two buttons (zoom in and zoom out). It is put on the map by default unless you set its [`zoomControl` option](#map-zoomcontrol) to `false`. Extends `Control`.
5283   */
5284
5285  var Zoom = Control.extend({
5286  	// @section
5287  	// @aka Control.Zoom options
5288  	options: {
5289  		position: 'topleft',
5290
5291  		// @option zoomInText: String = '+'
5292  		// The text set on the 'zoom in' button.
5293  		zoomInText: '<span aria-hidden="true">+</span>',
5294
5295  		// @option zoomInTitle: String = 'Zoom in'
5296  		// The title set on the 'zoom in' button.
5297  		zoomInTitle: 'Zoom in',
5298
5299  		// @option zoomOutText: String = '&#x2212;'
5300  		// The text set on the 'zoom out' button.
5301  		zoomOutText: '<span aria-hidden="true">&#x2212;</span>',
5302
5303  		// @option zoomOutTitle: String = 'Zoom out'
5304  		// The title set on the 'zoom out' button.
5305  		zoomOutTitle: 'Zoom out'
5306  	},
5307
5308  	onAdd: function (map) {
5309  		var zoomName = 'leaflet-control-zoom',
5310  		    container = create$1('div', zoomName + ' leaflet-bar'),
5311  		    options = this.options;
5312
5313  		this._zoomInButton  = this._createButton(options.zoomInText, options.zoomInTitle,
5314  		        zoomName + '-in',  container, this._zoomIn);
5315  		this._zoomOutButton = this._createButton(options.zoomOutText, options.zoomOutTitle,
5316  		        zoomName + '-out', container, this._zoomOut);
5317
5318  		this._updateDisabled();
5319  		map.on('zoomend zoomlevelschange', this._updateDisabled, this);
5320
5321  		return container;
5322  	},
5323
5324  	onRemove: function (map) {
5325  		map.off('zoomend zoomlevelschange', this._updateDisabled, this);
5326  	},
5327
5328  	disable: function () {
5329  		this._disabled = true;
5330  		this._updateDisabled();
5331  		return this;
5332  	},
5333
5334  	enable: function () {
5335  		this._disabled = false;
5336  		this._updateDisabled();
5337  		return this;
5338  	},
5339
5340  	_zoomIn: function (e) {
5341  		if (!this._disabled && this._map._zoom < this._map.getMaxZoom()) {
5342  			this._map.zoomIn(this._map.options.zoomDelta * (e.shiftKey ? 3 : 1));
5343  		}
5344  	},
5345
5346  	_zoomOut: function (e) {
5347  		if (!this._disabled && this._map._zoom > this._map.getMinZoom()) {
5348  			this._map.zoomOut(this._map.options.zoomDelta * (e.shiftKey ? 3 : 1));
5349  		}
5350  	},
5351
5352  	_createButton: function (html, title, className, container, fn) {
5353  		var link = create$1('a', className, container);
5354  		link.innerHTML = html;
5355  		link.href = '#';
5356  		link.title = title;
5357
5358  		/*
5359  		 * Will force screen readers like VoiceOver to read this as "Zoom in - button"
5360  		 */
5361  		link.setAttribute('role', 'button');
5362  		link.setAttribute('aria-label', title);
5363
5364  		disableClickPropagation(link);
5365  		on(link, 'click', stop);
5366  		on(link, 'click', fn, this);
5367  		on(link, 'click', this._refocusOnMap, this);
5368
5369  		return link;
5370  	},
5371
5372  	_updateDisabled: function () {
5373  		var map = this._map,
5374  		    className = 'leaflet-disabled';
5375
5376  		removeClass(this._zoomInButton, className);
5377  		removeClass(this._zoomOutButton, className);
5378  		this._zoomInButton.setAttribute('aria-disabled', 'false');
5379  		this._zoomOutButton.setAttribute('aria-disabled', 'false');
5380
5381  		if (this._disabled || map._zoom === map.getMinZoom()) {
5382  			addClass(this._zoomOutButton, className);
5383  			this._zoomOutButton.setAttribute('aria-disabled', 'true');
5384  		}
5385  		if (this._disabled || map._zoom === map.getMaxZoom()) {
5386  			addClass(this._zoomInButton, className);
5387  			this._zoomInButton.setAttribute('aria-disabled', 'true');
5388  		}
5389  	}
5390  });
5391
5392  // @namespace Map
5393  // @section Control options
5394  // @option zoomControl: Boolean = true
5395  // Whether a [zoom control](#control-zoom) is added to the map by default.
5396  Map.mergeOptions({
5397  	zoomControl: true
5398  });
5399
5400  Map.addInitHook(function () {
5401  	if (this.options.zoomControl) {
5402  		// @section Controls
5403  		// @property zoomControl: Control.Zoom
5404  		// The default zoom control (only available if the
5405  		// [`zoomControl` option](#map-zoomcontrol) was `true` when creating the map).
5406  		this.zoomControl = new Zoom();
5407  		this.addControl(this.zoomControl);
5408  	}
5409  });
5410
5411  // @namespace Control.Zoom
5412  // @factory L.control.zoom(options: Control.Zoom options)
5413  // Creates a zoom control
5414  var zoom = function (options) {
5415  	return new Zoom(options);
5416  };
5417
5418  /*
5419   * @class Control.Scale
5420   * @aka L.Control.Scale
5421   * @inherits Control
5422   *
5423   * A simple scale control that shows the scale of the current center of screen in metric (m/km) and imperial (mi/ft) systems. Extends `Control`.
5424   *
5425   * @example
5426   *
5427   * ```js
5428   * L.control.scale().addTo(map);
5429   * ```
5430   */
5431
5432  var Scale = Control.extend({
5433  	// @section
5434  	// @aka Control.Scale options
5435  	options: {
5436  		position: 'bottomleft',
5437
5438  		// @option maxWidth: Number = 100
5439  		// Maximum width of the control in pixels. The width is set dynamically to show round values (e.g. 100, 200, 500).
5440  		maxWidth: 100,
5441
5442  		// @option metric: Boolean = True
5443  		// Whether to show the metric scale line (m/km).
5444  		metric: true,
5445
5446  		// @option imperial: Boolean = True
5447  		// Whether to show the imperial scale line (mi/ft).
5448  		imperial: true
5449
5450  		// @option updateWhenIdle: Boolean = false
5451  		// If `true`, the control is updated on [`moveend`](#map-moveend), otherwise it's always up-to-date (updated on [`move`](#map-move)).
5452  	},
5453
5454  	onAdd: function (map) {
5455  		var className = 'leaflet-control-scale',
5456  		    container = create$1('div', className),
5457  		    options = this.options;
5458
5459  		this._addScales(options, className + '-line', container);
5460
5461  		map.on(options.updateWhenIdle ? 'moveend' : 'move', this._update, this);
5462  		map.whenReady(this._update, this);
5463
5464  		return container;
5465  	},
5466
5467  	onRemove: function (map) {
5468  		map.off(this.options.updateWhenIdle ? 'moveend' : 'move', this._update, this);
5469  	},
5470
5471  	_addScales: function (options, className, container) {
5472  		if (options.metric) {
5473  			this._mScale = create$1('div', className, container);
5474  		}
5475  		if (options.imperial) {
5476  			this._iScale = create$1('div', className, container);
5477  		}
5478  	},
5479
5480  	_update: function () {
5481  		var map = this._map,
5482  		    y = map.getSize().y / 2;
5483
5484  		var maxMeters = map.distance(
5485  			map.containerPointToLatLng([0, y]),
5486  			map.containerPointToLatLng([this.options.maxWidth, y]));
5487
5488  		this._updateScales(maxMeters);
5489  	},
5490
5491  	_updateScales: function (maxMeters) {
5492  		if (this.options.metric && maxMeters) {
5493  			this._updateMetric(maxMeters);
5494  		}
5495  		if (this.options.imperial && maxMeters) {
5496  			this._updateImperial(maxMeters);
5497  		}
5498  	},
5499
5500  	_updateMetric: function (maxMeters) {
5501  		var meters = this._getRoundNum(maxMeters),
5502  		    label = meters < 1000 ? meters + ' m' : (meters / 1000) + ' km';
5503
5504  		this._updateScale(this._mScale, label, meters / maxMeters);
5505  	},
5506
5507  	_updateImperial: function (maxMeters) {
5508  		var maxFeet = maxMeters * 3.2808399,
5509  		    maxMiles, miles, feet;
5510
5511  		if (maxFeet > 5280) {
5512  			maxMiles = maxFeet / 5280;
5513  			miles = this._getRoundNum(maxMiles);
5514  			this._updateScale(this._iScale, miles + ' mi', miles / maxMiles);
5515
5516  		} else {
5517  			feet = this._getRoundNum(maxFeet);
5518  			this._updateScale(this._iScale, feet + ' ft', feet / maxFeet);
5519  		}
5520  	},
5521
5522  	_updateScale: function (scale, text, ratio) {
5523  		scale.style.width = Math.round(this.options.maxWidth * ratio) + 'px';
5524  		scale.innerHTML = text;
5525  	},
5526
5527  	_getRoundNum: function (num) {
5528  		var pow10 = Math.pow(10, (Math.floor(num) + '').length - 1),
5529  		    d = num / pow10;
5530
5531  		d = d >= 10 ? 10 :
5532  		    d >= 5 ? 5 :
5533  		    d >= 3 ? 3 :
5534  		    d >= 2 ? 2 : 1;
5535
5536  		return pow10 * d;
5537  	}
5538  });
5539
5540
5541  // @factory L.control.scale(options?: Control.Scale options)
5542  // Creates an scale control with the given options.
5543  var scale = function (options) {
5544  	return new Scale(options);
5545  };
5546
5547  /*
5548   * @class Control.Attribution
5549   * @aka L.Control.Attribution
5550   * @inherits Control
5551   *
5552   * The attribution control allows you to display attribution data in a small text box on a map. It is put on the map by default unless you set its [`attributionControl` option](#map-attributioncontrol) to `false`, and it fetches attribution texts from layers with the [`getAttribution` method](#layer-getattribution) automatically. Extends Control.
5553   */
5554
5555  var Attribution = Control.extend({
5556  	// @section
5557  	// @aka Control.Attribution options
5558  	options: {
5559  		position: 'bottomright',
5560
5561  		// @option prefix: String = 'Leaflet'
5562  		// The HTML text shown before the attributions. Pass `false` to disable.
5563  		prefix: '<a href="https://leafletjs.com" title="A JavaScript library for interactive maps">Leaflet</a>'
5564
5565  	},
5566
5567  	initialize: function (options) {
5568  		setOptions(this, options);
5569
5570  		this._attributions = {};
5571  	},
5572
5573  	onAdd: function (map) {
5574  		map.attributionControl = this;
5575  		this._container = create$1('div', 'leaflet-control-attribution');
5576  		disableClickPropagation(this._container);
5577
5578  		// TODO ugly, refactor
5579  		for (var i in map._layers) {
5580  			if (map._layers[i].getAttribution) {
5581  				this.addAttribution(map._layers[i].getAttribution());
5582  			}
5583  		}
5584
5585  		this._update();
5586
5587  		map.on('layeradd', this._addAttribution, this);
5588
5589  		return this._container;
5590  	},
5591
5592  	onRemove: function (map) {
5593  		map.off('layeradd', this._addAttribution, this);
5594  	},
5595
5596  	_addAttribution: function (ev) {
5597  		if (ev.layer.getAttribution) {
5598  			this.addAttribution(ev.layer.getAttribution());
5599  			ev.layer.once('remove', function () {
5600  				this.removeAttribution(ev.layer.getAttribution());
5601  			}, this);
5602  		}
5603  	},
5604
5605  	// @method setPrefix(prefix: String): this
5606  	// Sets the text before the attributions.
5607  	setPrefix: function (prefix) {
5608  		this.options.prefix = prefix;
5609  		this._update();
5610  		return this;
5611  	},
5612
5613  	// @method addAttribution(text: String): this
5614  	// Adds an attribution text (e.g. `'Vector data &copy; Mapbox'`).
5615  	addAttribution: function (text) {
5616  		if (!text) { return this; }
5617
5618  		if (!this._attributions[text]) {
5619  			this._attributions[text] = 0;
5620  		}
5621  		this._attributions[text]++;
5622
5623  		this._update();
5624
5625  		return this;
5626  	},
5627
5628  	// @method removeAttribution(text: String): this
5629  	// Removes an attribution text.
5630  	removeAttribution: function (text) {
5631  		if (!text) { return this; }
5632
5633  		if (this._attributions[text]) {
5634  			this._attributions[text]--;
5635  			this._update();
5636  		}
5637
5638  		return this;
5639  	},
5640
5641  	_update: function () {
5642  		if (!this._map) { return; }
5643
5644  		var attribs = [];
5645
5646  		for (var i in this._attributions) {
5647  			if (this._attributions[i]) {
5648  				attribs.push(i);
5649  			}
5650  		}
5651
5652  		var prefixAndAttribs = [];
5653
5654  		if (this.options.prefix) {
5655  			prefixAndAttribs.push(this.options.prefix);
5656  		}
5657  		if (attribs.length) {
5658  			prefixAndAttribs.push(attribs.join(', '));
5659  		}
5660
5661  		this._container.innerHTML = prefixAndAttribs.join(' | ');
5662  	}
5663  });
5664
5665  // @namespace Map
5666  // @section Control options
5667  // @option attributionControl: Boolean = true
5668  // Whether a [attribution control](#control-attribution) is added to the map by default.
5669  Map.mergeOptions({
5670  	attributionControl: true
5671  });
5672
5673  Map.addInitHook(function () {
5674  	if (this.options.attributionControl) {
5675  		new Attribution().addTo(this);
5676  	}
5677  });
5678
5679  // @namespace Control.Attribution
5680  // @factory L.control.attribution(options: Control.Attribution options)
5681  // Creates an attribution control.
5682  var attribution = function (options) {
5683  	return new Attribution(options);
5684  };
5685
5686  Control.Layers = Layers;
5687  Control.Zoom = Zoom;
5688  Control.Scale = Scale;
5689  Control.Attribution = Attribution;
5690
5691  control.layers = layers;
5692  control.zoom = zoom;
5693  control.scale = scale;
5694  control.attribution = attribution;
5695
5696  /*
5697  	L.Handler is a base class for handler classes that are used internally to inject
5698  	interaction features like dragging to classes like Map and Marker.
5699  */
5700
5701  // @class Handler
5702  // @aka L.Handler
5703  // Abstract class for map interaction handlers
5704
5705  var Handler = Class.extend({
5706  	initialize: function (map) {
5707  		this._map = map;
5708  	},
5709
5710  	// @method enable(): this
5711  	// Enables the handler
5712  	enable: function () {
5713  		if (this._enabled) { return this; }
5714
5715  		this._enabled = true;
5716  		this.addHooks();
5717  		return this;
5718  	},
5719
5720  	// @method disable(): this
5721  	// Disables the handler
5722  	disable: function () {
5723  		if (!this._enabled) { return this; }
5724
5725  		this._enabled = false;
5726  		this.removeHooks();
5727  		return this;
5728  	},
5729
5730  	// @method enabled(): Boolean
5731  	// Returns `true` if the handler is enabled
5732  	enabled: function () {
5733  		return !!this._enabled;
5734  	}
5735
5736  	// @section Extension methods
5737  	// Classes inheriting from `Handler` must implement the two following methods:
5738  	// @method addHooks()
5739  	// Called when the handler is enabled, should add event hooks.
5740  	// @method removeHooks()
5741  	// Called when the handler is disabled, should remove the event hooks added previously.
5742  });
5743
5744  // @section There is static function which can be called without instantiating L.Handler:
5745  // @function addTo(map: Map, name: String): this
5746  // Adds a new Handler to the given map with the given name.
5747  Handler.addTo = function (map, name) {
5748  	map.addHandler(name, this);
5749  	return this;
5750  };
5751
5752  var Mixin = {Events: Events};
5753
5754  /*
5755   * @class Draggable
5756   * @aka L.Draggable
5757   * @inherits Evented
5758   *
5759   * A class for making DOM elements draggable (including touch support).
5760   * Used internally for map and marker dragging. Only works for elements
5761   * that were positioned with [`L.DomUtil.setPosition`](#domutil-setposition).
5762   *
5763   * @example
5764   * ```js
5765   * var draggable = new L.Draggable(elementToDrag);
5766   * draggable.enable();
5767   * ```
5768   */
5769
5770  var START = touch ? 'touchstart mousedown' : 'mousedown';
5771
5772  var Draggable = Evented.extend({
5773
5774  	options: {
5775  		// @section
5776  		// @aka Draggable options
5777  		// @option clickTolerance: Number = 3
5778  		// The max number of pixels a user can shift the mouse pointer during a click
5779  		// for it to be considered a valid click (as opposed to a mouse drag).
5780  		clickTolerance: 3
5781  	},
5782
5783  	// @constructor L.Draggable(el: HTMLElement, dragHandle?: HTMLElement, preventOutline?: Boolean, options?: Draggable options)
5784  	// Creates a `Draggable` object for moving `el` when you start dragging the `dragHandle` element (equals `el` itself by default).
5785  	initialize: function (element, dragStartTarget, preventOutline, options) {
5786  		setOptions(this, options);
5787
5788  		this._element = element;
5789  		this._dragStartTarget = dragStartTarget || element;
5790  		this._preventOutline = preventOutline;
5791  	},
5792
5793  	// @method enable()
5794  	// Enables the dragging ability
5795  	enable: function () {
5796  		if (this._enabled) { return; }
5797
5798  		on(this._dragStartTarget, START, this._onDown, this);
5799
5800  		this._enabled = true;
5801  	},
5802
5803  	// @method disable()
5804  	// Disables the dragging ability
5805  	disable: function () {
5806  		if (!this._enabled) { return; }
5807
5808  		// If we're currently dragging this draggable,
5809  		// disabling it counts as first ending the drag.
5810  		if (Draggable._dragging === this) {
5811  			this.finishDrag();
5812  		}
5813
5814  		off(this._dragStartTarget, START, this._onDown, this);
5815
5816  		this._enabled = false;
5817  		this._moved = false;
5818  	},
5819
5820  	_onDown: function (e) {
5821  		// Ignore the event if disabled; this happens in IE11
5822  		// under some circumstances, see #3666.
5823  		if (!this._enabled) { return; }
5824
5825  		this._moved = false;
5826
5827  		if (hasClass(this._element, 'leaflet-zoom-anim')) { return; }
5828
5829  		if (Draggable._dragging || e.shiftKey || ((e.which !== 1) && (e.button !== 1) && !e.touches)) { return; }
5830  		Draggable._dragging = this;  // Prevent dragging multiple objects at once.
5831
5832  		if (this._preventOutline) {
5833  			preventOutline(this._element);
5834  		}
5835
5836  		disableImageDrag();
5837  		disableTextSelection();
5838
5839  		if (this._moving) { return; }
5840
5841  		// @event down: Event
5842  		// Fired when a drag is about to start.
5843  		this.fire('down');
5844
5845  		var first = e.touches ? e.touches[0] : e,
5846  		    sizedParent = getSizedParentNode(this._element);
5847
5848  		this._startPoint = new Point(first.clientX, first.clientY);
5849
5850  		// Cache the scale, so that we can continuously compensate for it during drag (_onMove).
5851  		this._parentScale = getScale(sizedParent);
5852
5853  		var mouseevent = e.type === 'mousedown';
5854  		on(document, mouseevent ? 'mousemove' : 'touchmove', this._onMove, this);
5855  		on(document, mouseevent ? 'mouseup' : 'touchend touchcancel', this._onUp, this);
5856  	},
5857
5858  	_onMove: function (e) {
5859  		// Ignore the event if disabled; this happens in IE11
5860  		// under some circumstances, see #3666.
5861  		if (!this._enabled) { return; }
5862
5863  		if (e.touches && e.touches.length > 1) {
5864  			this._moved = true;
5865  			return;
5866  		}
5867
5868  		var first = (e.touches && e.touches.length === 1 ? e.touches[0] : e),
5869  		    offset = new Point(first.clientX, first.clientY)._subtract(this._startPoint);
5870
5871  		if (!offset.x && !offset.y) { return; }
5872  		if (Math.abs(offset.x) + Math.abs(offset.y) < this.options.clickTolerance) { return; }
5873
5874  		// We assume that the parent container's position, border and scale do not change for the duration of the drag.
5875  		// Therefore there is no need to account for the position and border (they are eliminated by the subtraction)
5876  		// and we can use the cached value for the scale.
5877  		offset.x /= this._parentScale.x;
5878  		offset.y /= this._parentScale.y;
5879
5880  		preventDefault(e);
5881
5882  		if (!this._moved) {
5883  			// @event dragstart: Event
5884  			// Fired when a drag starts
5885  			this.fire('dragstart');
5886
5887  			this._moved = true;
5888  			this._startPos = getPosition(this._element).subtract(offset);
5889
5890  			addClass(document.body, 'leaflet-dragging');
5891
5892  			this._lastTarget = e.target || e.srcElement;
5893  			// IE and Edge do not give the <use> element, so fetch it
5894  			// if necessary
5895  			if (window.SVGElementInstance && this._lastTarget instanceof window.SVGElementInstance) {
5896  				this._lastTarget = this._lastTarget.correspondingUseElement;
5897  			}
5898  			addClass(this._lastTarget, 'leaflet-drag-target');
5899  		}
5900
5901  		this._newPos = this._startPos.add(offset);
5902  		this._moving = true;
5903
5904  		cancelAnimFrame(this._animRequest);
5905  		this._lastEvent = e;
5906  		this._animRequest = requestAnimFrame(this._updatePosition, this, true);
5907  	},
5908
5909  	_updatePosition: function () {
5910  		var e = {originalEvent: this._lastEvent};
5911
5912  		// @event predrag: Event
5913  		// Fired continuously during dragging *before* each corresponding
5914  		// update of the element's position.
5915  		this.fire('predrag', e);
5916  		setPosition(this._element, this._newPos);
5917
5918  		// @event drag: Event
5919  		// Fired continuously during dragging.
5920  		this.fire('drag', e);
5921  	},
5922
5923  	_onUp: function () {
5924  		// Ignore the event if disabled; this happens in IE11
5925  		// under some circumstances, see #3666.
5926  		if (!this._enabled) { return; }
5927  		this.finishDrag();
5928  	},
5929
5930  	finishDrag: function () {
5931  		removeClass(document.body, 'leaflet-dragging');
5932
5933  		if (this._lastTarget) {
5934  			removeClass(this._lastTarget, 'leaflet-drag-target');
5935  			this._lastTarget = null;
5936  		}
5937
5938  		off(document, 'mousemove touchmove', this._onMove, this);
5939  		off(document, 'mouseup touchend touchcancel', this._onUp, this);
5940
5941  		enableImageDrag();
5942  		enableTextSelection();
5943
5944  		if (this._moved && this._moving) {
5945  			// ensure drag is not fired after dragend
5946  			cancelAnimFrame(this._animRequest);
5947
5948  			// @event dragend: DragEndEvent
5949  			// Fired when the drag ends.
5950  			this.fire('dragend', {
5951  				distance: this._newPos.distanceTo(this._startPos)
5952  			});
5953  		}
5954
5955  		this._moving = false;
5956  		Draggable._dragging = false;
5957  	}
5958
5959  });
5960
5961  /*
5962   * @namespace LineUtil
5963   *
5964   * Various utility functions for polyline points processing, used by Leaflet internally to make polylines lightning-fast.
5965   */
5966
5967  // Simplify polyline with vertex reduction and Douglas-Peucker simplification.
5968  // Improves rendering performance dramatically by lessening the number of points to draw.
5969
5970  // @function simplify(points: Point[], tolerance: Number): Point[]
5971  // Dramatically reduces the number of points in a polyline while retaining
5972  // its shape and returns a new array of simplified points, using the
5973  // [Douglas-Peucker algorithm](http://en.wikipedia.org/wiki/Douglas-Peucker_algorithm).
5974  // Used for a huge performance boost when processing/displaying Leaflet polylines for
5975  // each zoom level and also reducing visual noise. tolerance affects the amount of
5976  // simplification (lesser value means higher quality but slower and with more points).
5977  // Also released as a separated micro-library [Simplify.js](http://mourner.github.com/simplify-js/).
5978  function simplify(points, tolerance) {
5979  	if (!tolerance || !points.length) {
5980  		return points.slice();
5981  	}
5982
5983  	var sqTolerance = tolerance * tolerance;
5984
5985  	    // stage 1: vertex reduction
5986  	    points = _reducePoints(points, sqTolerance);
5987
5988  	    // stage 2: Douglas-Peucker simplification
5989  	    points = _simplifyDP(points, sqTolerance);
5990
5991  	return points;
5992  }
5993
5994  // @function pointToSegmentDistance(p: Point, p1: Point, p2: Point): Number
5995  // Returns the distance between point `p` and segment `p1` to `p2`.
5996  function pointToSegmentDistance(p, p1, p2) {
5997  	return Math.sqrt(_sqClosestPointOnSegment(p, p1, p2, true));
5998  }
5999
6000  // @function closestPointOnSegment(p: Point, p1: Point, p2: Point): Number
6001  // Returns the closest point from a point `p` on a segment `p1` to `p2`.
6002  function closestPointOnSegment(p, p1, p2) {
6003  	return _sqClosestPointOnSegment(p, p1, p2);
6004  }
6005
6006  // Douglas-Peucker simplification, see http://en.wikipedia.org/wiki/Douglas-Peucker_algorithm
6007  function _simplifyDP(points, sqTolerance) {
6008
6009  	var len = points.length,
6010  	    ArrayConstructor = typeof Uint8Array !== undefined + '' ? Uint8Array : Array,
6011  	    markers = new ArrayConstructor(len);
6012
6013  	    markers[0] = markers[len - 1] = 1;
6014
6015  	_simplifyDPStep(points, markers, sqTolerance, 0, len - 1);
6016
6017  	var i,
6018  	    newPoints = [];
6019
6020  	for (i = 0; i < len; i++) {
6021  		if (markers[i]) {
6022  			newPoints.push(points[i]);
6023  		}
6024  	}
6025
6026  	return newPoints;
6027  }
6028
6029  function _simplifyDPStep(points, markers, sqTolerance, first, last) {
6030
6031  	var maxSqDist = 0,
6032  	index, i, sqDist;
6033
6034  	for (i = first + 1; i <= last - 1; i++) {
6035  		sqDist = _sqClosestPointOnSegment(points[i], points[first], points[last], true);
6036
6037  		if (sqDist > maxSqDist) {
6038  			index = i;
6039  			maxSqDist = sqDist;
6040  		}
6041  	}
6042
6043  	if (maxSqDist > sqTolerance) {
6044  		markers[index] = 1;
6045
6046  		_simplifyDPStep(points, markers, sqTolerance, first, index);
6047  		_simplifyDPStep(points, markers, sqTolerance, index, last);
6048  	}
6049  }
6050
6051  // reduce points that are too close to each other to a single point
6052  function _reducePoints(points, sqTolerance) {
6053  	var reducedPoints = [points[0]];
6054
6055  	for (var i = 1, prev = 0, len = points.length; i < len; i++) {
6056  		if (_sqDist(points[i], points[prev]) > sqTolerance) {
6057  			reducedPoints.push(points[i]);
6058  			prev = i;
6059  		}
6060  	}
6061  	if (prev < len - 1) {
6062  		reducedPoints.push(points[len - 1]);
6063  	}
6064  	return reducedPoints;
6065  }
6066
6067  var _lastCode;
6068
6069  // @function clipSegment(a: Point, b: Point, bounds: Bounds, useLastCode?: Boolean, round?: Boolean): Point[]|Boolean
6070  // Clips the segment a to b by rectangular bounds with the
6071  // [Cohen-Sutherland algorithm](https://en.wikipedia.org/wiki/Cohen%E2%80%93Sutherland_algorithm)
6072  // (modifying the segment points directly!). Used by Leaflet to only show polyline
6073  // points that are on the screen or near, increasing performance.
6074  function clipSegment(a, b, bounds, useLastCode, round) {
6075  	var codeA = useLastCode ? _lastCode : _getBitCode(a, bounds),
6076  	    codeB = _getBitCode(b, bounds),
6077
6078  	    codeOut, p, newCode;
6079
6080  	    // save 2nd code to avoid calculating it on the next segment
6081  	    _lastCode = codeB;
6082
6083  	while (true) {
6084  		// if a,b is inside the clip window (trivial accept)
6085  		if (!(codeA | codeB)) {
6086  			return [a, b];
6087  		}
6088
6089  		// if a,b is outside the clip window (trivial reject)
6090  		if (codeA & codeB) {
6091  			return false;
6092  		}
6093
6094  		// other cases
6095  		codeOut = codeA || codeB;
6096  		p = _getEdgeIntersection(a, b, codeOut, bounds, round);
6097  		newCode = _getBitCode(p, bounds);
6098
6099  		if (codeOut === codeA) {
6100  			a = p;
6101  			codeA = newCode;
6102  		} else {
6103  			b = p;
6104  			codeB = newCode;
6105  		}
6106  	}
6107  }
6108
6109  function _getEdgeIntersection(a, b, code, bounds, round) {
6110  	var dx = b.x - a.x,
6111  	    dy = b.y - a.y,
6112  	    min = bounds.min,
6113  	    max = bounds.max,
6114  	    x, y;
6115
6116  	if (code & 8) { // top
6117  		x = a.x + dx * (max.y - a.y) / dy;
6118  		y = max.y;
6119
6120  	} else if (code & 4) { // bottom
6121  		x = a.x + dx * (min.y - a.y) / dy;
6122  		y = min.y;
6123
6124  	} else if (code & 2) { // right
6125  		x = max.x;
6126  		y = a.y + dy * (max.x - a.x) / dx;
6127
6128  	} else if (code & 1) { // left
6129  		x = min.x;
6130  		y = a.y + dy * (min.x - a.x) / dx;
6131  	}
6132
6133  	return new Point(x, y, round);
6134  }
6135
6136  function _getBitCode(p, bounds) {
6137  	var code = 0;
6138
6139  	if (p.x < bounds.min.x) { // left
6140  		code |= 1;
6141  	} else if (p.x > bounds.max.x) { // right
6142  		code |= 2;
6143  	}
6144
6145  	if (p.y < bounds.min.y) { // bottom
6146  		code |= 4;
6147  	} else if (p.y > bounds.max.y) { // top
6148  		code |= 8;
6149  	}
6150
6151  	return code;
6152  }
6153
6154  // square distance (to avoid unnecessary Math.sqrt calls)
6155  function _sqDist(p1, p2) {
6156  	var dx = p2.x - p1.x,
6157  	    dy = p2.y - p1.y;
6158  	return dx * dx + dy * dy;
6159  }
6160
6161  // return closest point on segment or distance to that point
6162  function _sqClosestPointOnSegment(p, p1, p2, sqDist) {
6163  	var x = p1.x,
6164  	    y = p1.y,
6165  	    dx = p2.x - x,
6166  	    dy = p2.y - y,
6167  	    dot = dx * dx + dy * dy,
6168  	    t;
6169
6170  	if (dot > 0) {
6171  		t = ((p.x - x) * dx + (p.y - y) * dy) / dot;
6172
6173  		if (t > 1) {
6174  			x = p2.x;
6175  			y = p2.y;
6176  		} else if (t > 0) {
6177  			x += dx * t;
6178  			y += dy * t;
6179  		}
6180  	}
6181
6182  	dx = p.x - x;
6183  	dy = p.y - y;
6184
6185  	return sqDist ? dx * dx + dy * dy : new Point(x, y);
6186  }
6187
6188
6189  // @function isFlat(latlngs: LatLng[]): Boolean
6190  // Returns true if `latlngs` is a flat array, false is nested.
6191  function isFlat(latlngs) {
6192  	return !isArray(latlngs[0]) || (typeof latlngs[0][0] !== 'object' && typeof latlngs[0][0] !== 'undefined');
6193  }
6194
6195  function _flat(latlngs) {
6196  	console.warn('Deprecated use of _flat, please use L.LineUtil.isFlat instead.');
6197  	return isFlat(latlngs);
6198  }
6199
6200  var LineUtil = {
6201    __proto__: null,
6202    simplify: simplify,
6203    pointToSegmentDistance: pointToSegmentDistance,
6204    closestPointOnSegment: closestPointOnSegment,
6205    clipSegment: clipSegment,
6206    _getEdgeIntersection: _getEdgeIntersection,
6207    _getBitCode: _getBitCode,
6208    _sqClosestPointOnSegment: _sqClosestPointOnSegment,
6209    isFlat: isFlat,
6210    _flat: _flat
6211  };
6212
6213  /*
6214   * @namespace PolyUtil
6215   * Various utility functions for polygon geometries.
6216   */
6217
6218  /* @function clipPolygon(points: Point[], bounds: Bounds, round?: Boolean): Point[]
6219   * Clips the polygon geometry defined by the given `points` by the given bounds (using the [Sutherland-Hodgman algorithm](https://en.wikipedia.org/wiki/Sutherland%E2%80%93Hodgman_algorithm)).
6220   * Used by Leaflet to only show polygon points that are on the screen or near, increasing
6221   * performance. Note that polygon points needs different algorithm for clipping
6222   * than polyline, so there's a separate method for it.
6223   */
6224  function clipPolygon(points, bounds, round) {
6225  	var clippedPoints,
6226  	    edges = [1, 4, 2, 8],
6227  	    i, j, k,
6228  	    a, b,
6229  	    len, edge, p;
6230
6231  	for (i = 0, len = points.length; i < len; i++) {
6232  		points[i]._code = _getBitCode(points[i], bounds);
6233  	}
6234
6235  	// for each edge (left, bottom, right, top)
6236  	for (k = 0; k < 4; k++) {
6237  		edge = edges[k];
6238  		clippedPoints = [];
6239
6240  		for (i = 0, len = points.length, j = len - 1; i < len; j = i++) {
6241  			a = points[i];
6242  			b = points[j];
6243
6244  			// if a is inside the clip window
6245  			if (!(a._code & edge)) {
6246  				// if b is outside the clip window (a->b goes out of screen)
6247  				if (b._code & edge) {
6248  					p = _getEdgeIntersection(b, a, edge, bounds, round);
6249  					p._code = _getBitCode(p, bounds);
6250  					clippedPoints.push(p);
6251  				}
6252  				clippedPoints.push(a);
6253
6254  			// else if b is inside the clip window (a->b enters the screen)
6255  			} else if (!(b._code & edge)) {
6256  				p = _getEdgeIntersection(b, a, edge, bounds, round);
6257  				p._code = _getBitCode(p, bounds);
6258  				clippedPoints.push(p);
6259  			}
6260  		}
6261  		points = clippedPoints;
6262  	}
6263
6264  	return points;
6265  }
6266
6267  var PolyUtil = {
6268    __proto__: null,
6269    clipPolygon: clipPolygon
6270  };
6271
6272  /*
6273   * @namespace Projection
6274   * @section
6275   * Leaflet comes with a set of already defined Projections out of the box:
6276   *
6277   * @projection L.Projection.LonLat
6278   *
6279   * Equirectangular, or Plate Carree projection — the most simple projection,
6280   * mostly used by GIS enthusiasts. Directly maps `x` as longitude, and `y` as
6281   * latitude. Also suitable for flat worlds, e.g. game maps. Used by the
6282   * `EPSG:4326` and `Simple` CRS.
6283   */
6284
6285  var LonLat = {
6286  	project: function (latlng) {
6287  		return new Point(latlng.lng, latlng.lat);
6288  	},
6289
6290  	unproject: function (point) {
6291  		return new LatLng(point.y, point.x);
6292  	},
6293
6294  	bounds: new Bounds([-180, -90], [180, 90])
6295  };
6296
6297  /*
6298   * @namespace Projection
6299   * @projection L.Projection.Mercator
6300   *
6301   * Elliptical Mercator projection — more complex than Spherical Mercator. Assumes that Earth is an ellipsoid. Used by the EPSG:3395 CRS.
6302   */
6303
6304  var Mercator = {
6305  	R: 6378137,
6306  	R_MINOR: 6356752.314245179,
6307
6308  	bounds: new Bounds([-20037508.34279, -15496570.73972], [20037508.34279, 18764656.23138]),
6309
6310  	project: function (latlng) {
6311  		var d = Math.PI / 180,
6312  		    r = this.R,
6313  		    y = latlng.lat * d,
6314  		    tmp = this.R_MINOR / r,
6315  		    e = Math.sqrt(1 - tmp * tmp),
6316  		    con = e * Math.sin(y);
6317
6318  		var ts = Math.tan(Math.PI / 4 - y / 2) / Math.pow((1 - con) / (1 + con), e / 2);
6319  		y = -r * Math.log(Math.max(ts, 1E-10));
6320
6321  		return new Point(latlng.lng * d * r, y);
6322  	},
6323
6324  	unproject: function (point) {
6325  		var d = 180 / Math.PI,
6326  		    r = this.R,
6327  		    tmp = this.R_MINOR / r,
6328  		    e = Math.sqrt(1 - tmp * tmp),
6329  		    ts = Math.exp(-point.y / r),
6330  		    phi = Math.PI / 2 - 2 * Math.atan(ts);
6331
6332  		for (var i = 0, dphi = 0.1, con; i < 15 && Math.abs(dphi) > 1e-7; i++) {
6333  			con = e * Math.sin(phi);
6334  			con = Math.pow((1 - con) / (1 + con), e / 2);
6335  			dphi = Math.PI / 2 - 2 * Math.atan(ts * con) - phi;
6336  			phi += dphi;
6337  		}
6338
6339  		return new LatLng(phi * d, point.x * d / r);
6340  	}
6341  };
6342
6343  /*
6344   * @class Projection
6345
6346   * An object with methods for projecting geographical coordinates of the world onto
6347   * a flat surface (and back). See [Map projection](http://en.wikipedia.org/wiki/Map_projection).
6348
6349   * @property bounds: Bounds
6350   * The bounds (specified in CRS units) where the projection is valid
6351
6352   * @method project(latlng: LatLng): Point
6353   * Projects geographical coordinates into a 2D point.
6354   * Only accepts actual `L.LatLng` instances, not arrays.
6355
6356   * @method unproject(point: Point): LatLng
6357   * The inverse of `project`. Projects a 2D point into a geographical location.
6358   * Only accepts actual `L.Point` instances, not arrays.
6359
6360   * Note that the projection instances do not inherit from Leaflet's `Class` object,
6361   * and can't be instantiated. Also, new classes can't inherit from them,
6362   * and methods can't be added to them with the `include` function.
6363
6364   */
6365
6366  var index = {
6367    __proto__: null,
6368    LonLat: LonLat,
6369    Mercator: Mercator,
6370    SphericalMercator: SphericalMercator
6371  };
6372
6373  /*
6374   * @namespace CRS
6375   * @crs L.CRS.EPSG3395
6376   *
6377   * Rarely used by some commercial tile providers. Uses Elliptical Mercator projection.
6378   */
6379  var EPSG3395 = extend({}, Earth, {
6380  	code: 'EPSG:3395',
6381  	projection: Mercator,
6382
6383  	transformation: (function () {
6384  		var scale = 0.5 / (Math.PI * Mercator.R);
6385  		return toTransformation(scale, 0.5, -scale, 0.5);
6386  	}())
6387  });
6388
6389  /*
6390   * @namespace CRS
6391   * @crs L.CRS.EPSG4326
6392   *
6393   * A common CRS among GIS enthusiasts. Uses simple Equirectangular projection.
6394   *
6395   * Leaflet 1.0.x complies with the [TMS coordinate scheme for EPSG:4326](https://wiki.osgeo.org/wiki/Tile_Map_Service_Specification#global-geodetic),
6396   * which is a breaking change from 0.7.x behaviour.  If you are using a `TileLayer`
6397   * with this CRS, ensure that there are two 256x256 pixel tiles covering the
6398   * whole earth at zoom level zero, and that the tile coordinate origin is (-180,+90),
6399   * or (-180,-90) for `TileLayer`s with [the `tms` option](#tilelayer-tms) set.
6400   */
6401
6402  var EPSG4326 = extend({}, Earth, {
6403  	code: 'EPSG:4326',
6404  	projection: LonLat,
6405  	transformation: toTransformation(1 / 180, 1, -1 / 180, 0.5)
6406  });
6407
6408  /*
6409   * @namespace CRS
6410   * @crs L.CRS.Simple
6411   *
6412   * A simple CRS that maps longitude and latitude into `x` and `y` directly.
6413   * May be used for maps of flat surfaces (e.g. game maps). Note that the `y`
6414   * axis should still be inverted (going from bottom to top). `distance()` returns
6415   * simple euclidean distance.
6416   */
6417
6418  var Simple = extend({}, CRS, {
6419  	projection: LonLat,
6420  	transformation: toTransformation(1, 0, -1, 0),
6421
6422  	scale: function (zoom) {
6423  		return Math.pow(2, zoom);
6424  	},
6425
6426  	zoom: function (scale) {
6427  		return Math.log(scale) / Math.LN2;
6428  	},
6429
6430  	distance: function (latlng1, latlng2) {
6431  		var dx = latlng2.lng - latlng1.lng,
6432  		    dy = latlng2.lat - latlng1.lat;
6433
6434  		return Math.sqrt(dx * dx + dy * dy);
6435  	},
6436
6437  	infinite: true
6438  });
6439
6440  CRS.Earth = Earth;
6441  CRS.EPSG3395 = EPSG3395;
6442  CRS.EPSG3857 = EPSG3857;
6443  CRS.EPSG900913 = EPSG900913;
6444  CRS.EPSG4326 = EPSG4326;
6445  CRS.Simple = Simple;
6446
6447  /*
6448   * @class Layer
6449   * @inherits Evented
6450   * @aka L.Layer
6451   * @aka ILayer
6452   *
6453   * A set of methods from the Layer base class that all Leaflet layers use.
6454   * Inherits all methods, options and events from `L.Evented`.
6455   *
6456   * @example
6457   *
6458   * ```js
6459   * var layer = L.marker(latlng).addTo(map);
6460   * layer.addTo(map);
6461   * layer.remove();
6462   * ```
6463   *
6464   * @event add: Event
6465   * Fired after the layer is added to a map
6466   *
6467   * @event remove: Event
6468   * Fired after the layer is removed from a map
6469   */
6470
6471
6472  var Layer = Evented.extend({
6473
6474  	// Classes extending `L.Layer` will inherit the following options:
6475  	options: {
6476  		// @option pane: String = 'overlayPane'
6477  		// By default the layer will be added to the map's [overlay pane](#map-overlaypane). Overriding this option will cause the layer to be placed on another pane by default.
6478  		pane: 'overlayPane',
6479
6480  		// @option attribution: String = null
6481  		// String to be shown in the attribution control, e.g. "© OpenStreetMap contributors". It describes the layer data and is often a legal obligation towards copyright holders and tile providers.
6482  		attribution: null,
6483
6484  		bubblingMouseEvents: true
6485  	},
6486
6487  	/* @section
6488  	 * Classes extending `L.Layer` will inherit the following methods:
6489  	 *
6490  	 * @method addTo(map: Map|LayerGroup): this
6491  	 * Adds the layer to the given map or layer group.
6492  	 */
6493  	addTo: function (map) {
6494  		map.addLayer(this);
6495  		return this;
6496  	},
6497
6498  	// @method remove: this
6499  	// Removes the layer from the map it is currently active on.
6500  	remove: function () {
6501  		return this.removeFrom(this._map || this._mapToAdd);
6502  	},
6503
6504  	// @method removeFrom(map: Map): this
6505  	// Removes the layer from the given map
6506  	//
6507  	// @alternative
6508  	// @method removeFrom(group: LayerGroup): this
6509  	// Removes the layer from the given `LayerGroup`
6510  	removeFrom: function (obj) {
6511  		if (obj) {
6512  			obj.removeLayer(this);
6513  		}
6514  		return this;
6515  	},
6516
6517  	// @method getPane(name? : String): HTMLElement
6518  	// Returns the `HTMLElement` representing the named pane on the map. If `name` is omitted, returns the pane for this layer.
6519  	getPane: function (name) {
6520  		return this._map.getPane(name ? (this.options[name] || name) : this.options.pane);
6521  	},
6522
6523  	addInteractiveTarget: function (targetEl) {
6524  		this._map._targets[stamp(targetEl)] = this;
6525  		return this;
6526  	},
6527
6528  	removeInteractiveTarget: function (targetEl) {
6529  		delete this._map._targets[stamp(targetEl)];
6530  		return this;
6531  	},
6532
6533  	// @method getAttribution: String
6534  	// Used by the `attribution control`, returns the [attribution option](#gridlayer-attribution).
6535  	getAttribution: function () {
6536  		return this.options.attribution;
6537  	},
6538
6539  	_layerAdd: function (e) {
6540  		var map = e.target;
6541
6542  		// check in case layer gets added and then removed before the map is ready
6543  		if (!map.hasLayer(this)) { return; }
6544
6545  		this._map = map;
6546  		this._zoomAnimated = map._zoomAnimated;
6547
6548  		if (this.getEvents) {
6549  			var events = this.getEvents();
6550  			map.on(events, this);
6551  			this.once('remove', function () {
6552  				map.off(events, this);
6553  			}, this);
6554  		}
6555
6556  		this.onAdd(map);
6557
6558  		this.fire('add');
6559  		map.fire('layeradd', {layer: this});
6560  	}
6561  });
6562
6563  /* @section Extension methods
6564   * @uninheritable
6565   *
6566   * Every layer should extend from `L.Layer` and (re-)implement the following methods.
6567   *
6568   * @method onAdd(map: Map): this
6569   * Should contain code that creates DOM elements for the layer, adds them to `map panes` where they should belong and puts listeners on relevant map events. Called on [`map.addLayer(layer)`](#map-addlayer).
6570   *
6571   * @method onRemove(map: Map): this
6572   * Should contain all clean up code that removes the layer's elements from the DOM and removes listeners previously added in [`onAdd`](#layer-onadd). Called on [`map.removeLayer(layer)`](#map-removelayer).
6573   *
6574   * @method getEvents(): Object
6575   * This optional method should return an object like `{ viewreset: this._reset }` for [`addEventListener`](#evented-addeventlistener). The event handlers in this object will be automatically added and removed from the map with your layer.
6576   *
6577   * @method getAttribution(): String
6578   * This optional method should return a string containing HTML to be shown on the `Attribution control` whenever the layer is visible.
6579   *
6580   * @method beforeAdd(map: Map): this
6581   * Optional method. Called on [`map.addLayer(layer)`](#map-addlayer), before the layer is added to the map, before events are initialized, without waiting until the map is in a usable state. Use for early initialization only.
6582   */
6583
6584
6585  /* @namespace Map
6586   * @section Layer events
6587   *
6588   * @event layeradd: LayerEvent
6589   * Fired when a new layer is added to the map.
6590   *
6591   * @event layerremove: LayerEvent
6592   * Fired when some layer is removed from the map
6593   *
6594   * @section Methods for Layers and Controls
6595   */
6596  Map.include({
6597  	// @method addLayer(layer: Layer): this
6598  	// Adds the given layer to the map
6599  	addLayer: function (layer) {
6600  		if (!layer._layerAdd) {
6601  			throw new Error('The provided object is not a Layer.');
6602  		}
6603
6604  		var id = stamp(layer);
6605  		if (this._layers[id]) { return this; }
6606  		this._layers[id] = layer;
6607
6608  		layer._mapToAdd = this;
6609
6610  		if (layer.beforeAdd) {
6611  			layer.beforeAdd(this);
6612  		}
6613
6614  		this.whenReady(layer._layerAdd, layer);
6615
6616  		return this;
6617  	},
6618
6619  	// @method removeLayer(layer: Layer): this
6620  	// Removes the given layer from the map.
6621  	removeLayer: function (layer) {
6622  		var id = stamp(layer);
6623
6624  		if (!this._layers[id]) { return this; }
6625
6626  		if (this._loaded) {
6627  			layer.onRemove(this);
6628  		}
6629
6630  		delete this._layers[id];
6631
6632  		if (this._loaded) {
6633  			this.fire('layerremove', {layer: layer});
6634  			layer.fire('remove');
6635  		}
6636
6637  		layer._map = layer._mapToAdd = null;
6638
6639  		return this;
6640  	},
6641
6642  	// @method hasLayer(layer: Layer): Boolean
6643  	// Returns `true` if the given layer is currently added to the map
6644  	hasLayer: function (layer) {
6645  		return stamp(layer) in this._layers;
6646  	},
6647
6648  	/* @method eachLayer(fn: Function, context?: Object): this
6649  	 * Iterates over the layers of the map, optionally specifying context of the iterator function.
6650  	 * ```
6651  	 * map.eachLayer(function(layer){
6652  	 *     layer.bindPopup('Hello');
6653  	 * });
6654  	 * ```
6655  	 */
6656  	eachLayer: function (method, context) {
6657  		for (var i in this._layers) {
6658  			method.call(context, this._layers[i]);
6659  		}
6660  		return this;
6661  	},
6662
6663  	_addLayers: function (layers) {
6664  		layers = layers ? (isArray(layers) ? layers : [layers]) : [];
6665
6666  		for (var i = 0, len = layers.length; i < len; i++) {
6667  			this.addLayer(layers[i]);
6668  		}
6669  	},
6670
6671  	_addZoomLimit: function (layer) {
6672  		if (isNaN(layer.options.maxZoom) || !isNaN(layer.options.minZoom)) {
6673  			this._zoomBoundLayers[stamp(layer)] = layer;
6674  			this._updateZoomLevels();
6675  		}
6676  	},
6677
6678  	_removeZoomLimit: function (layer) {
6679  		var id = stamp(layer);
6680
6681  		if (this._zoomBoundLayers[id]) {
6682  			delete this._zoomBoundLayers[id];
6683  			this._updateZoomLevels();
6684  		}
6685  	},
6686
6687  	_updateZoomLevels: function () {
6688  		var minZoom = Infinity,
6689  		    maxZoom = -Infinity,
6690  		    oldZoomSpan = this._getZoomSpan();
6691
6692  		for (var i in this._zoomBoundLayers) {
6693  			var options = this._zoomBoundLayers[i].options;
6694
6695  			minZoom = options.minZoom === undefined ? minZoom : Math.min(minZoom, options.minZoom);
6696  			maxZoom = options.maxZoom === undefined ? maxZoom : Math.max(maxZoom, options.maxZoom);
6697  		}
6698
6699  		this._layersMaxZoom = maxZoom === -Infinity ? undefined : maxZoom;
6700  		this._layersMinZoom = minZoom === Infinity ? undefined : minZoom;
6701
6702  		// @section Map state change events
6703  		// @event zoomlevelschange: Event
6704  		// Fired when the number of zoomlevels on the map is changed due
6705  		// to adding or removing a layer.
6706  		if (oldZoomSpan !== this._getZoomSpan()) {
6707  			this.fire('zoomlevelschange');
6708  		}
6709
6710  		if (this.options.maxZoom === undefined && this._layersMaxZoom && this.getZoom() > this._layersMaxZoom) {
6711  			this.setZoom(this._layersMaxZoom);
6712  		}
6713  		if (this.options.minZoom === undefined && this._layersMinZoom && this.getZoom() < this._layersMinZoom) {
6714  			this.setZoom(this._layersMinZoom);
6715  		}
6716  	}
6717  });
6718
6719  /*
6720   * @class LayerGroup
6721   * @aka L.LayerGroup
6722   * @inherits Layer
6723   *
6724   * Used to group several layers and handle them as one. If you add it to the map,
6725   * any layers added or removed from the group will be added/removed on the map as
6726   * well. Extends `Layer`.
6727   *
6728   * @example
6729   *
6730   * ```js
6731   * L.layerGroup([marker1, marker2])
6732   * 	.addLayer(polyline)
6733   * 	.addTo(map);
6734   * ```
6735   */
6736
6737  var LayerGroup = Layer.extend({
6738
6739  	initialize: function (layers, options) {
6740  		setOptions(this, options);
6741
6742  		this._layers = {};
6743
6744  		var i, len;
6745
6746  		if (layers) {
6747  			for (i = 0, len = layers.length; i < len; i++) {
6748  				this.addLayer(layers[i]);
6749  			}
6750  		}
6751  	},
6752
6753  	// @method addLayer(layer: Layer): this
6754  	// Adds the given layer to the group.
6755  	addLayer: function (layer) {
6756  		var id = this.getLayerId(layer);
6757
6758  		this._layers[id] = layer;
6759
6760  		if (this._map) {
6761  			this._map.addLayer(layer);
6762  		}
6763
6764  		return this;
6765  	},
6766
6767  	// @method removeLayer(layer: Layer): this
6768  	// Removes the given layer from the group.
6769  	// @alternative
6770  	// @method removeLayer(id: Number): this
6771  	// Removes the layer with the given internal ID from the group.
6772  	removeLayer: function (layer) {
6773  		var id = layer in this._layers ? layer : this.getLayerId(layer);
6774
6775  		if (this._map && this._layers[id]) {
6776  			this._map.removeLayer(this._layers[id]);
6777  		}
6778
6779  		delete this._layers[id];
6780
6781  		return this;
6782  	},
6783
6784  	// @method hasLayer(layer: Layer): Boolean
6785  	// Returns `true` if the given layer is currently added to the group.
6786  	// @alternative
6787  	// @method hasLayer(id: Number): Boolean
6788  	// Returns `true` if the given internal ID is currently added to the group.
6789  	hasLayer: function (layer) {
6790  		var layerId = typeof layer === 'number' ? layer : this.getLayerId(layer);
6791  		return layerId in this._layers;
6792  	},
6793
6794  	// @method clearLayers(): this
6795  	// Removes all the layers from the group.
6796  	clearLayers: function () {
6797  		return this.eachLayer(this.removeLayer, this);
6798  	},
6799
6800  	// @method invoke(methodName: String, …): this
6801  	// Calls `methodName` on every layer contained in this group, passing any
6802  	// additional parameters. Has no effect if the layers contained do not
6803  	// implement `methodName`.
6804  	invoke: function (methodName) {
6805  		var args = Array.prototype.slice.call(arguments, 1),
6806  		    i, layer;
6807
6808  		for (i in this._layers) {
6809  			layer = this._layers[i];
6810
6811  			if (layer[methodName]) {
6812  				layer[methodName].apply(layer, args);
6813  			}
6814  		}
6815
6816  		return this;
6817  	},
6818
6819  	onAdd: function (map) {
6820  		this.eachLayer(map.addLayer, map);
6821  	},
6822
6823  	onRemove: function (map) {
6824  		this.eachLayer(map.removeLayer, map);
6825  	},
6826
6827  	// @method eachLayer(fn: Function, context?: Object): this
6828  	// Iterates over the layers of the group, optionally specifying context of the iterator function.
6829  	// ```js
6830  	// group.eachLayer(function (layer) {
6831  	// 	layer.bindPopup('Hello');
6832  	// });
6833  	// ```
6834  	eachLayer: function (method, context) {
6835  		for (var i in this._layers) {
6836  			method.call(context, this._layers[i]);
6837  		}
6838  		return this;
6839  	},
6840
6841  	// @method getLayer(id: Number): Layer
6842  	// Returns the layer with the given internal ID.
6843  	getLayer: function (id) {
6844  		return this._layers[id];
6845  	},
6846
6847  	// @method getLayers(): Layer[]
6848  	// Returns an array of all the layers added to the group.
6849  	getLayers: function () {
6850  		var layers = [];
6851  		this.eachLayer(layers.push, layers);
6852  		return layers;
6853  	},
6854
6855  	// @method setZIndex(zIndex: Number): this
6856  	// Calls `setZIndex` on every layer contained in this group, passing the z-index.
6857  	setZIndex: function (zIndex) {
6858  		return this.invoke('setZIndex', zIndex);
6859  	},
6860
6861  	// @method getLayerId(layer: Layer): Number
6862  	// Returns the internal ID for a layer
6863  	getLayerId: function (layer) {
6864  		return stamp(layer);
6865  	}
6866  });
6867
6868
6869  // @factory L.layerGroup(layers?: Layer[], options?: Object)
6870  // Create a layer group, optionally given an initial set of layers and an `options` object.
6871  var layerGroup = function (layers, options) {
6872  	return new LayerGroup(layers, options);
6873  };
6874
6875  /*
6876   * @class FeatureGroup
6877   * @aka L.FeatureGroup
6878   * @inherits LayerGroup
6879   *
6880   * Extended `LayerGroup` that makes it easier to do the same thing to all its member layers:
6881   *  * [`bindPopup`](#layer-bindpopup) binds a popup to all of the layers at once (likewise with [`bindTooltip`](#layer-bindtooltip))
6882   *  * Events are propagated to the `FeatureGroup`, so if the group has an event
6883   * handler, it will handle events from any of the layers. This includes mouse events
6884   * and custom events.
6885   *  * Has `layeradd` and `layerremove` events
6886   *
6887   * @example
6888   *
6889   * ```js
6890   * L.featureGroup([marker1, marker2, polyline])
6891   * 	.bindPopup('Hello world!')
6892   * 	.on('click', function() { alert('Clicked on a member of the group!'); })
6893   * 	.addTo(map);
6894   * ```
6895   */
6896
6897  var FeatureGroup = LayerGroup.extend({
6898
6899  	addLayer: function (layer) {
6900  		if (this.hasLayer(layer)) {
6901  			return this;
6902  		}
6903
6904  		layer.addEventParent(this);
6905
6906  		LayerGroup.prototype.addLayer.call(this, layer);
6907
6908  		// @event layeradd: LayerEvent
6909  		// Fired when a layer is added to this `FeatureGroup`
6910  		return this.fire('layeradd', {layer: layer});
6911  	},
6912
6913  	removeLayer: function (layer) {
6914  		if (!this.hasLayer(layer)) {
6915  			return this;
6916  		}
6917  		if (layer in this._layers) {
6918  			layer = this._layers[layer];
6919  		}
6920
6921  		layer.removeEventParent(this);
6922
6923  		LayerGroup.prototype.removeLayer.call(this, layer);
6924
6925  		// @event layerremove: LayerEvent
6926  		// Fired when a layer is removed from this `FeatureGroup`
6927  		return this.fire('layerremove', {layer: layer});
6928  	},
6929
6930  	// @method setStyle(style: Path options): this
6931  	// Sets the given path options to each layer of the group that has a `setStyle` method.
6932  	setStyle: function (style) {
6933  		return this.invoke('setStyle', style);
6934  	},
6935
6936  	// @method bringToFront(): this
6937  	// Brings the layer group to the top of all other layers
6938  	bringToFront: function () {
6939  		return this.invoke('bringToFront');
6940  	},
6941
6942  	// @method bringToBack(): this
6943  	// Brings the layer group to the back of all other layers
6944  	bringToBack: function () {
6945  		return this.invoke('bringToBack');
6946  	},
6947
6948  	// @method getBounds(): LatLngBounds
6949  	// Returns the LatLngBounds of the Feature Group (created from bounds and coordinates of its children).
6950  	getBounds: function () {
6951  		var bounds = new LatLngBounds();
6952
6953  		for (var id in this._layers) {
6954  			var layer = this._layers[id];
6955  			bounds.extend(layer.getBounds ? layer.getBounds() : layer.getLatLng());
6956  		}
6957  		return bounds;
6958  	}
6959  });
6960
6961  // @factory L.featureGroup(layers?: Layer[], options?: Object)
6962  // Create a feature group, optionally given an initial set of layers and an `options` object.
6963  var featureGroup = function (layers, options) {
6964  	return new FeatureGroup(layers, options);
6965  };
6966
6967  /*
6968   * @class Icon
6969   * @aka L.Icon
6970   *
6971   * Represents an icon to provide when creating a marker.
6972   *
6973   * @example
6974   *
6975   * ```js
6976   * var myIcon = L.icon({
6977   *     iconUrl: 'my-icon.png',
6978   *     iconRetinaUrl: '[email protected]',
6979   *     iconSize: [38, 95],
6980   *     iconAnchor: [22, 94],
6981   *     popupAnchor: [-3, -76],
6982   *     shadowUrl: 'my-icon-shadow.png',
6983   *     shadowRetinaUrl: '[email protected]',
6984   *     shadowSize: [68, 95],
6985   *     shadowAnchor: [22, 94]
6986   * });
6987   *
6988   * L.marker([50.505, 30.57], {icon: myIcon}).addTo(map);
6989   * ```
6990   *
6991   * `L.Icon.Default` extends `L.Icon` and is the blue icon Leaflet uses for markers by default.
6992   *
6993   */
6994
6995  var Icon = Class.extend({
6996
6997  	/* @section
6998  	 * @aka Icon options
6999  	 *
7000  	 * @option iconUrl: String = null
7001  	 * **(required)** The URL to the icon image (absolute or relative to your script path).
7002  	 *
7003  	 * @option iconRetinaUrl: String = null
7004  	 * The URL to a retina sized version of the icon image (absolute or relative to your
7005  	 * script path). Used for Retina screen devices.
7006  	 *
7007  	 * @option iconSize: Point = null
7008  	 * Size of the icon image in pixels.
7009  	 *
7010  	 * @option iconAnchor: Point = null
7011  	 * The coordinates of the "tip" of the icon (relative to its top left corner). The icon
7012  	 * will be aligned so that this point is at the marker's geographical location. Centered
7013  	 * by default if size is specified, also can be set in CSS with