https://saii.kr/assets/leaflet-40e7db45.js

1/* @preserve
2 * Leaflet 1.9.4, a JS library for interactive maps. https://leafletjs.com
3 * (c) 2010-2023 Vladimir Agafonkin, (c) 2010-2011 CloudMade
4 */
5
6var version = "1.9.4";
7
8/*
9 * @namespace Util
10 *
11 * Various utility functions, used by Leaflet internally.
12 */
13
14// @function extend(dest: Object, src?: Object): Object
15// Merges the properties of the `src` object (or multiple objects) into `dest` object and returns the latter. Has an `L.extend` shortcut.
16function extend(dest) {
17	var i, j, len, src;
18
19	for (j = 1, len = arguments.length; j < len; j++) {
20		src = arguments[j];
21		for (i in src) {
22			dest[i] = src[i];
23		}
24	}
25	return dest;
26}
27
28// @function create(proto: Object, properties?: Object): Object
29// Compatibility polyfill for [Object.create](https://developer.mozilla.org/docs/Web/JavaScript/Reference/Global_Objects/Object/create)
30var create$2 = Object.create || (function () {
31	function F() {}
32	return function (proto) {
33		F.prototype = proto;
34		return new F();
35	};
36})();
37
38// @function bind(fn: Function, …): Function
39// 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).
40// Has a `L.bind()` shortcut.
41function bind(fn, obj) {
42	var slice = Array.prototype.slice;
43
44	if (fn.bind) {
45		return fn.bind.apply(fn, slice.call(arguments, 1));
46	}
47
48	var args = slice.call(arguments, 2);
49
50	return function () {
51		return fn.apply(obj, args.length ? args.concat(slice.call(arguments)) : arguments);
52	};
53}
54
55// @property lastId: Number
56// Last unique ID used by [`stamp()`](#util-stamp)
57var lastId = 0;
58
59// @function stamp(obj: Object): Number
60// Returns the unique ID of an object, assigning it one if it doesn't have it.
61function stamp(obj) {
62	if (!('_leaflet_id' in obj)) {
63		obj['_leaflet_id'] = ++lastId;
64	}
65	return obj._leaflet_id;
66}
67
68// @function throttle(fn: Function, time: Number, context: Object): Function
69// Returns a function which executes function `fn` with the given scope `context`
70// (so that the `this` keyword refers to `context` inside `fn`'s code). The function
71// `fn` will be called no more than one time per given amount of `time`. The arguments
72// received by the bound function will be any arguments passed when binding the
73// function, followed by any arguments passed when invoking the bound function.
74// Has an `L.throttle` shortcut.
75function throttle(fn, time, context) {
76	var lock, args, wrapperFn, later;
77
78	later = function () {
79		// reset lock and call if queued
80		lock = false;
81		if (args) {
82			wrapperFn.apply(context, args);
83			args = false;
84		}
85	};
86
87	wrapperFn = function () {
88		if (lock) {
89			// called too soon, queue to call later
90			args = arguments;
91
92		} else {
93			// call and lock until later
94			fn.apply(context, arguments);
95			setTimeout(later, time);
96			lock = true;
97		}
98	};
99
100	return wrapperFn;
101}
102
103// @function wrapNum(num: Number, range: Number[], includeMax?: Boolean): Number
104// Returns the number `num` modulo `range` in such a way so it lies within
105// `range[0]` and `range[1]`. The returned value will be always smaller than
106// `range[1]` unless `includeMax` is set to `true`.
107function wrapNum(x, range, includeMax) {
108	var max = range[1],
109	    min = range[0],
110	    d = max - min;
111	return x === max && includeMax ? x : ((x - min) % d + d) % d + min;
112}
113
114// @function falseFn(): Function
115// Returns a function which always returns `false`.
116function falseFn() { return false; }
117
118// @function formatNum(num: Number, precision?: Number|false): Number
119// Returns the number `num` rounded with specified `precision`.
120// The default `precision` value is 6 decimal places.
121// `false` can be passed to skip any processing (can be useful to avoid round-off errors).
122function formatNum(num, precision) {
123	if (precision === false) { return num; }
124	var pow = Math.pow(10, precision === undefined ? 6 : precision);
125	return Math.round(num * pow) / pow;
126}
127
128// @function trim(str: String): String
129// Compatibility polyfill for [String.prototype.trim](https://developer.mozilla.org/docs/Web/JavaScript/Reference/Global_Objects/String/Trim)
130function trim(str) {
131	return str.trim ? str.trim() : str.replace(/^\s+|\s+$/g, '');
132}
133
134// @function splitWords(str: String): String[]
135// Trims and splits the string on whitespace and returns the array of parts.
136function splitWords(str) {
137	return trim(str).split(/\s+/);
138}
139
140// @function setOptions(obj: Object, options: Object): Object
141// Merges the given properties to the `options` of the `obj` object, returning the resulting options. See `Class options`. Has an `L.setOptions` shortcut.
142function setOptions(obj, options) {
143	if (!Object.prototype.hasOwnProperty.call(obj, 'options')) {
144		obj.options = obj.options ? create$2(obj.options) : {};
145	}
146	for (var i in options) {
147		obj.options[i] = options[i];
148	}
149	return obj.options;
150}
151
152// @function getParamString(obj: Object, existingUrl?: String, uppercase?: Boolean): String
153// Converts an object into a parameter URL string, e.g. `{a: "foo", b: "bar"}`
154// translates to `'?a=foo&b=bar'`. If `existingUrl` is set, the parameters will
155// be appended at the end. If `uppercase` is `true`, the parameter names will
156// be uppercased (e.g. `'?A=foo&B=bar'`)
157function getParamString(obj, existingUrl, uppercase) {
158	var params = [];
159	for (var i in obj) {
160		params.push(encodeURIComponent(uppercase ? i.toUpperCase() : i) + '=' + encodeURIComponent(obj[i]));
161	}
162	return ((!existingUrl || existingUrl.indexOf('?') === -1) ? '?' : '&') + params.join('&');
163}
164
165var templateRe = /\{ *([\w_ -]+) *\}/g;
166
167// @function template(str: String, data: Object): String
168// Simple templating facility, accepts a template string of the form `'Hello {a}, {b}'`
169// and a data object like `{a: 'foo', b: 'bar'}`, returns evaluated string
170// `('Hello foo, bar')`. You can also specify functions instead of strings for
171// data values — they will be evaluated passing `data` as an argument.
172function template(str, data) {
173	return str.replace(templateRe, function (str, key) {
174		var value = data[key];
175
176		if (value === undefined) {
177			throw new Error('No value provided for variable ' + str);
178
179		} else if (typeof value === 'function') {
180			value = value(data);
181		}
182		return value;
183	});
184}
185
186// @function isArray(obj): Boolean
187// Compatibility polyfill for [Array.isArray](https://developer.mozilla.org/docs/Web/JavaScript/Reference/Global_Objects/Array/isArray)
188var isArray = Array.isArray || function (obj) {
189	return (Object.prototype.toString.call(obj) === '[object Array]');
190};
191
192// @function indexOf(array: Array, el: Object): Number
193// Compatibility polyfill for [Array.prototype.indexOf](https://developer.mozilla.org/docs/Web/JavaScript/Reference/Global_Objects/Array/indexOf)
194function indexOf(array, el) {
195	for (var i = 0; i < array.length; i++) {
196		if (array[i] === el) { return i; }
197	}
198	return -1;
199}
200
201// @property emptyImageUrl: String
202// Data URI string containing a base64-encoded empty GIF image.
203// Used as a hack to free memory from unused images on WebKit-powered
204// mobile devices (by setting image `src` to this string).
205var emptyImageUrl = 'data:image/gif;base64,R0lGODlhAQABAAD/ACwAAAAAAQABAAACADs=';
206
207// inspired by https://paulirish.com/2011/requestanimationframe-for-smart-animating/
208
209function getPrefixed(name) {
210	return window['webkit' + name] || window['moz' + name] || window['ms' + name];
211}
212
213var lastTime = 0;
214
215// fallback for IE 7-8
216function timeoutDefer(fn) {
217	var time = +new Date(),
218	    timeToCall = Math.max(0, 16 - (time - lastTime));
219
220	lastTime = time + timeToCall;
221	return window.setTimeout(fn, timeToCall);
222}
223
224var requestFn = window.requestAnimationFrame || getPrefixed('RequestAnimationFrame') || timeoutDefer;
225var cancelFn = window.cancelAnimationFrame || getPrefixed('CancelAnimationFrame') ||
226		getPrefixed('CancelRequestAnimationFrame') || function (id) { window.clearTimeout(id); };
227
228// @function requestAnimFrame(fn: Function, context?: Object, immediate?: Boolean): Number
229// Schedules `fn` to be executed when the browser repaints. `fn` is bound to
230// `context` if given. When `immediate` is set, `fn` is called immediately if
231// the browser doesn't have native support for
232// [`window.requestAnimationFrame`](https://developer.mozilla.org/docs/Web/API/window/requestAnimationFrame),
233// otherwise it's delayed. Returns a request ID that can be used to cancel the request.
234function requestAnimFrame(fn, context, immediate) {
235	if (immediate && requestFn === timeoutDefer) {
236		fn.call(context);
237	} else {
238		return requestFn.call(window, bind(fn, context));
239	}
240}
241
242// @function cancelAnimFrame(id: Number): undefined
243// Cancels a previous `requestAnimFrame`. See also [window.cancelAnimationFrame](https://developer.mozilla.org/docs/Web/API/window/cancelAnimationFrame).
244function cancelAnimFrame(id) {
245	if (id) {
246		cancelFn.call(window, id);
247	}
248}
249
250var Util = {
251  __proto__: null,
252  extend: extend,
253  create: create$2,
254  bind: bind,
255  get lastId () { return lastId; },
256  stamp: stamp,
257  throttle: throttle,
258  wrapNum: wrapNum,
259  falseFn: falseFn,
260  formatNum: formatNum,
261  trim: trim,
262  splitWords: splitWords,
263  setOptions: setOptions,
264  getParamString: getParamString,
265  template: template,
266  isArray: isArray,
267  indexOf: indexOf,
268  emptyImageUrl: emptyImageUrl,
269  requestFn: requestFn,
270  cancelFn: cancelFn,
271  requestAnimFrame: requestAnimFrame,
272  cancelAnimFrame: cancelAnimFrame
273};
274
275// @class Class
276// @aka L.Class
277
278// @section
279// @uninheritable
280
281// Thanks to John Resig and Dean Edwards for inspiration!
282
283function Class() {}
284
285Class.extend = function (props) {
286
287	// @function extend(props: Object): Function
288	// [Extends the current class](#class-inheritance) given the properties to be included.
289	// Returns a Javascript function that is a class constructor (to be called with `new`).
290	var NewClass = function () {
291
292		setOptions(this);
293
294		// call the constructor
295		if (this.initialize) {
296			this.initialize.apply(this, arguments);
297		}
298
299		// call all constructor hooks
300		this.callInitHooks();
301	};
302
303	var parentProto = NewClass.__super__ = this.prototype;
304
305	var proto = create$2(parentProto);
306	proto.constructor = NewClass;
307
308	NewClass.prototype = proto;
309
310	// inherit parent's statics
311	for (var i in this) {
312		if (Object.prototype.hasOwnProperty.call(this, i) && i !== 'prototype' && i !== '__super__') {
313			NewClass[i] = this[i];
314		}
315	}
316
317	// mix static properties into the class
318	if (props.statics) {
319		extend(NewClass, props.statics);
320	}
321
322	// mix includes into the prototype
323	if (props.includes) {
324		checkDeprecatedMixinEvents(props.includes);
325		extend.apply(null, [proto].concat(props.includes));
326	}
327
328	// mix given properties into the prototype
329	extend(proto, props);
330	delete proto.statics;
331	delete proto.includes;
332
333	// merge options
334	if (proto.options) {
335		proto.options = parentProto.options ? create$2(parentProto.options) : {};
336		extend(proto.options, props.options);
337	}
338
339	proto._initHooks = [];
340
341	// add method for calling all hooks
342	proto.callInitHooks = function () {
343
344		if (this._initHooksCalled) { return; }
345
346		if (parentProto.callInitHooks) {
347			parentProto.callInitHooks.call(this);
348		}
349
350		this._initHooksCalled = true;
351
352		for (var i = 0, len = proto._initHooks.length; i < len; i++) {
353			proto._initHooks[i].call(this);
354		}
355	};
356
357	return NewClass;
358};
359
360
361// @function include(properties: Object): this
362// [Includes a mixin](#class-includes) into the current class.
363Class.include = function (props) {
364	var parentOptions = this.prototype.options;
365	extend(this.prototype, props);
366	if (props.options) {
367		this.prototype.options = parentOptions;
368		this.mergeOptions(props.options);
369	}
370	return this;
371};
372
373// @function mergeOptions(options: Object): this
374// [Merges `options`](#class-options) into the defaults of the class.
375Class.mergeOptions = function (options) {
376	extend(this.prototype.options, options);
377	return this;
378};
379
380// @function addInitHook(fn: Function): this
381// Adds a [constructor hook](#class-constructor-hooks) to the class.
382Class.addInitHook = function (fn) { // (Function) || (String, args...)
383	var args = Array.prototype.slice.call(arguments, 1);
384
385	var init = typeof fn === 'function' ? fn : function () {
386		this[fn].apply(this, args);
387	};
388
389	this.prototype._initHooks = this.prototype._initHooks || [];
390	this.prototype._initHooks.push(init);
391	return this;
392};
393
394function checkDeprecatedMixinEvents(includes) {
395	/* global L: true */
396	if (typeof L === 'undefined' || !L || !L.Mixin) { return; }
397
398	includes = isArray(includes) ? includes : [includes];
399
400	for (var i = 0; i < includes.length; i++) {
401		if (includes[i] === L.Mixin.Events) {
402			console.warn('Deprecated include of L.Mixin.Events: ' +
403				'this property will be removed in future releases, ' +
404				'please inherit from L.Evented instead.', new Error().stack);
405		}
406	}
407}
408
409/*
410 * @class Evented
411 * @aka L.Evented
412 * @inherits Class
413 *
414 * A set of methods shared between event-powered classes (like `Map` and `Marker`). Generally, events allow you to execute some function when something happens with an object (e.g. the user clicks on the map, causing the map to fire `'click'` event).
415 *
416 * @example
417 *
418 * ```js
419 * map.on('click', function(e) {
420 * 	alert(e.latlng);
421 * } );
422 * ```
423 *
424 * Leaflet deals with event listeners by reference, so if you want to add a listener and then remove it, define it as a function:
425 *
426 * ```js
427 * function onClick(e) { ... }
428 *
429 * map.on('click', onClick);
430 * map.off('click', onClick);
431 * ```
432 */
433
434var Events = {
435	/* @method on(type: String, fn: Function, context?: Object): this
436	 * Adds a listener function (`fn`) to a particular event type of the object. You can optionally specify the context of the listener (object the this keyword will point to). You can also pass several space-separated types (e.g. `'click dblclick'`).
437	 *
438	 * @alternative
439	 * @method on(eventMap: Object): this
440	 * Adds a set of type/listener pairs, e.g. `{click: onClick, mousemove: onMouseMove}`
441	 */
442	on: function (types, fn, context) {
443
444		// types can be a map of types/handlers
445		if (typeof types === 'object') {
446			for (var type in types) {
447				// we don't process space-separated events here for performance;
448				// it's a hot path since Layer uses the on(obj) syntax
449				this._on(type, types[type], fn);
450			}
451
452		} else {
453			// types can be a string of space-separated words
454			types = splitWords(types);
455
456			for (var i = 0, len = types.length; i < len; i++) {
457				this._on(types[i], fn, context);
458			}
459		}
460
461		return this;
462	},
463
464	/* @method off(type: String, fn?: Function, context?: Object): this
465	 * Removes a previously added listener function. If no function is specified, it will remove all the listeners of that particular event from the object. Note that if you passed a custom context to `on`, you must pass the same context to `off` in order to remove the listener.
466	 *
467	 * @alternative
468	 * @method off(eventMap: Object): this
469	 * Removes a set of type/listener pairs.
470	 *
471	 * @alternative
472	 * @method off: this
473	 * Removes all listeners to all events on the object. This includes implicitly attached events.
474	 */
475	off: function (types, fn, context) {
476
477		if (!arguments.length) {
478			// clear all listeners if called without arguments
479			delete this._events;
480
481		} else if (typeof types === 'object') {
482			for (var type in types) {
483				this._off(type, types[type], fn);
484			}
485
486		} else {
487			types = splitWords(types);
488
489			var removeAll = arguments.length === 1;
490			for (var i = 0, len = types.length; i < len; i++) {
491				if (removeAll) {
492					this._off(types[i]);
493				} else {
494					this._off(types[i], fn, context);
495				}
496			}
497		}
498
499		return this;
500	},
501
502	// attach listener (without syntactic sugar now)
503	_on: function (type, fn, context, _once) {
504		if (typeof fn !== 'function') {
505			console.warn('wrong listener type: ' + typeof fn);
506			return;
507		}
508
509		// check if fn already there
510		if (this._listens(type, fn, context) !== false) {
511			return;
512		}
513
514		if (context === this) {
515			// Less memory footprint.
516			context = undefined;
517		}
518
519		var newListener = {fn: fn, ctx: context};
520		if (_once) {
521			newListener.once = true;
522		}
523
524		this._events = this._events || {};
525		this._events[type] = this._events[type] || [];
526		this._events[type].push(newListener);
527	},
528
529	_off: function (type, fn, context) {
530		var listeners,
531		    i,
532		    len;
533
534		if (!this._events) {
535			return;
536		}
537
538		listeners = this._events[type];
539		if (!listeners) {
540			return;
541		}
542
543		if (arguments.length === 1) { // remove all
544			if (this._firingCount) {
545				// Set all removed listeners to noop
546				// so they are not called if remove happens in fire
547				for (i = 0, len = listeners.length; i < len; i++) {
548					listeners[i].fn = falseFn;
549				}
550			}
551			// clear all listeners for a type if function isn't specified
552			delete this._events[type];
553			return;
554		}
555
556		if (typeof fn !== 'function') {
557			console.warn('wrong listener type: ' + typeof fn);
558			return;
559		}
560
561		// find fn and remove it
562		var index = this._listens(type, fn, context);
563		if (index !== false) {
564			var listener = listeners[index];
565			if (this._firingCount) {
566				// set the removed listener to noop so that's not called if remove happens in fire
567				listener.fn = falseFn;
568
569				/* copy array in case events are being fired */
570				this._events[type] = listeners = listeners.slice();
571			}
572			listeners.splice(index, 1);
573		}
574	},
575
576	// @method fire(type: String, data?: Object, propagate?: Boolean): this
577	// Fires an event of the specified type. You can optionally provide a data
578	// object — the first argument of the listener function will contain its
579	// properties. The event can optionally be propagated to event parents.
580	fire: function (type, data, propagate) {
581		if (!this.listens(type, propagate)) { return this; }
582
583		var event = extend({}, data, {
584			type: type,
585			target: this,
586			sourceTarget: data && data.sourceTarget || this
587		});
588
589		if (this._events) {
590			var listeners = this._events[type];
591			if (listeners) {
592				this._firingCount = (this._firingCount + 1) || 1;
593				for (var i = 0, len = listeners.length; i < len; i++) {
594					var l = listeners[i];
595					// off overwrites l.fn, so we need to copy fn to a var
596					var fn = l.fn;
597					if (l.once) {
598						this.off(type, fn, l.ctx);
599					}
600					fn.call(l.ctx || this, event);
601				}
602
603				this._firingCount--;
604			}
605		}
606
607		if (propagate) {
608			// propagate the event to parents (set with addEventParent)
609			this._propagateEvent(event);
610		}
611
612		return this;
613	},
614
615	// @method listens(type: String, propagate?: Boolean): Boolean
616	// @method listens(type: String, fn: Function, context?: Object, propagate?: Boolean): Boolean
617	// Returns `true` if a particular event type has any listeners attached to it.
618	// The verification can optionally be propagated, it will return `true` if parents have the listener attached to it.
619	listens: function (type, fn, context, propagate) {
620		if (typeof type !== 'string') {
621			console.warn('"string" type argument expected');
622		}
623
624		// we don't overwrite the input `fn` value, because we need to use it for propagation
625		var _fn = fn;
626		if (typeof fn !== 'function') {
627			propagate = !!fn;
628			_fn = undefined;
629			context = undefined;
630		}
631
632		var listeners = this._events && this._events[type];
633		if (listeners && listeners.length) {
634			if (this._listens(type, _fn, context) !== false) {
635				return true;
636			}
637		}
638
639		if (propagate) {
640			// also check parents for listeners if event propagates
641			for (var id in this._eventParents) {
642				if (this._eventParents[id].listens(type, fn, context, propagate)) { return true; }
643			}
644		}
645		return false;
646	},
647
648	// returns the index (number) or false
649	_listens: function (type, fn, context) {
650		if (!this._events) {
651			return false;
652		}
653
654		var listeners = this._events[type] || [];
655		if (!fn) {
656			return !!listeners.length;
657		}
658
659		if (context === this) {
660			// Less memory footprint.
661			context = undefined;
662		}
663
664		for (var i = 0, len = listeners.length; i < len; i++) {
665			if (listeners[i].fn === fn && listeners[i].ctx === context) {
666				return i;
667			}
668		}
669		return false;
670
671	},
672
673	// @method once(…): this
674	// Behaves as [`on(…)`](#evented-on), except the listener will only get fired once and then removed.
675	once: function (types, fn, context) {
676
677		// types can be a map of types/handlers
678		if (typeof types === 'object') {
679			for (var type in types) {
680				// we don't process space-separated events here for performance;
681				// it's a hot path since Layer uses the on(obj) syntax
682				this._on(type, types[type], fn, true);
683			}
684
685		} else {
686			// types can be a string of space-separated words
687			types = splitWords(types);
688
689			for (var i = 0, len = types.length; i < len; i++) {
690				this._on(types[i], fn, context, true);
691			}
692		}
693
694		return this;
695	},
696
697	// @method addEventParent(obj: Evented): this
698	// Adds an event parent - an `Evented` that will receive propagated events
699	addEventParent: function (obj) {
700		this._eventParents = this._eventParents || {};
701		this._eventParents[stamp(obj)] = obj;
702		return this;
703	},
704
705	// @method removeEventParent(obj: Evented): this
706	// Removes an event parent, so it will stop receiving propagated events
707	removeEventParent: function (obj) {
708		if (this._eventParents) {
709			delete this._eventParents[stamp(obj)];
710		}
711		return this;
712	},
713
714	_propagateEvent: function (e) {
715		for (var id in this._eventParents) {
716			this._eventParents[id].fire(e.type, extend({
717				layer: e.target,
718				propagatedFrom: e.target
719			}, e), true);
720		}
721	}
722};
723
724// aliases; we should ditch those eventually
725
726// @method addEventListener(…): this
727// Alias to [`on(…)`](#evented-on)
728Events.addEventListener = Events.on;
729
730// @method removeEventListener(…): this
731// Alias to [`off(…)`](#evented-off)
732
733// @method clearAllEventListeners(…): this
734// Alias to [`off()`](#evented-off)
735Events.removeEventListener = Events.clearAllEventListeners = Events.off;
736
737// @method addOneTimeEventListener(…): this
738// Alias to [`once(…)`](#evented-once)
739Events.addOneTimeEventListener = Events.once;
740
741// @method fireEvent(…): this
742// Alias to [`fire(…)`](#evented-fire)
743Events.fireEvent = Events.fire;
744
745// @method hasEventListeners(…): Boolean
746// Alias to [`listens(…)`](#evented-listens)
747Events.hasEventListeners = Events.listens;
748
749var Evented = Class.extend(Events);
750
751/*
752 * @class Point
753 * @aka L.Point
754 *
755 * Represents a point with `x` and `y` coordinates in pixels.
756 *
757 * @example
758 *
759 * ```js
760 * var point = L.point(200, 300);
761 * ```
762 *
763 * 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:
764 *
765 * ```js
766 * map.panBy([200, 300]);
767 * map.panBy(L.point(200, 300));
768 * ```
769 *
770 * Note that `Point` does not inherit from Leaflet's `Class` object,
771 * which means new classes can't inherit from it, and new methods
772 * can't be added to it with the `include` function.
773 */
774
775function Point(x, y, round) {
776	// @property x: Number; The `x` coordinate of the point
777	this.x = (round ? Math.round(x) : x);
778	// @property y: Number; The `y` coordinate of the point
779	this.y = (round ? Math.round(y) : y);
780}
781
782var trunc = Math.trunc || function (v) {
783	return v > 0 ? Math.floor(v) : Math.ceil(v);
784};
785
786Point.prototype = {
787
788	// @method clone(): Point
789	// Returns a copy of the current point.
790	clone: function () {
791		return new Point(this.x, this.y);
792	},
793
794	// @method add(otherPoint: Point): Point
795	// Returns the result of addition of the current and the given points.
796	add: function (point) {
797		// non-destructive, returns a new point
798		return this.clone()._add(toPoint(point));
799	},
800
801	_add: function (point) {
802		// destructive, used directly for performance in situations where it's safe to modify existing point
803		this.x += point.x;
804		this.y += point.y;
805		return this;
806	},
807
808	// @method subtract(otherPoint: Point): Point
809	// Returns the result of subtraction of the given point from the current.
810	subtract: function (point) {
811		return this.clone()._subtract(toPoint(point));
812	},
813
814	_subtract: function (point) {
815		this.x -= point.x;
816		this.y -= point.y;
817		return this;
818	},
819
820	// @method divideBy(num: Number): Point
821	// Returns the result of division of the current point by the given number.
822	divideBy: function (num) {
823		return this.clone()._divideBy(num);
824	},
825
826	_divideBy: function (num) {
827		this.x /= num;
828		this.y /= num;
829		return this;
830	},
831
832	// @method multiplyBy(num: Number): Point
833	// Returns the result of multiplication of the current point by the given number.
834	multiplyBy: function (num) {
835		return this.clone()._multiplyBy(num);
836	},
837
838	_multiplyBy: function (num) {
839		this.x *= num;
840		this.y *= num;
841		return this;
842	},
843
844	// @method scaleBy(scale: Point): Point
845	// Multiply each coordinate of the current point by each coordinate of
846	// `scale`. In linear algebra terms, multiply the point by the
847	// [scaling matrix](https://en.wikipedia.org/wiki/Scaling_%28geometry%29#Matrix_representation)
848	// defined by `scale`.
849	scaleBy: function (point) {
850		return new Point(this.x * point.x, this.y * point.y);
851	},
852
853	// @method unscaleBy(scale: Point): Point
854	// Inverse of `scaleBy`. Divide each coordinate of the current point by
855	// each coordinate of `scale`.
856	unscaleBy: function (point) {
857		return new Point(this.x / point.x, this.y / point.y);
858	},
859
860	// @method round(): Point
861	// Returns a copy of the current point with rounded coordinates.
862	round: function () {
863		return this.clone()._round();
864	},
865
866	_round: function () {
867		this.x = Math.round(this.x);
868		this.y = Math.round(this.y);
869		return this;
870	},
871
872	// @method floor(): Point
873	// Returns a copy of the current point with floored coordinates (rounded down).
874	floor: function () {
875		return this.clone()._floor();
876	},
877
878	_floor: function () {
879		this.x = Math.floor(this.x);
880		this.y = Math.floor(this.y);
881		return this;
882	},
883
884	// @method ceil(): Point
885	// Returns a copy of the current point with ceiled coordinates (rounded up).
886	ceil: function () {
887		return this.clone()._ceil();
888	},
889
890	_ceil: function () {
891		this.x = Math.ceil(this.x);
892		this.y = Math.ceil(this.y);
893		return this;
894	},
895
896	// @method trunc(): Point
897	// Returns a copy of the current point with truncated coordinates (rounded towards zero).
898	trunc: function () {
899		return this.clone()._trunc();
900	},
901
902	_trunc: function () {
903		this.x = trunc(this.x);
904		this.y = trunc(this.y);
905		return this;
906	},
907
908	// @method distanceTo(otherPoint: Point): Number
909	// Returns the cartesian distance between the current and the given points.
910	distanceTo: function (point) {
911		point = toPoint(point);
912
913		var x = point.x - this.x,
914		    y = point.y - this.y;
915
916		return Math.sqrt(x * x + y * y);
917	},
918
919	// @method equals(otherPoint: Point): Boolean
920	// Returns `true` if the given point has the same coordinates.
921	equals: function (point) {
922		point = toPoint(point);
923
924		return point.x === this.x &&
925		       point.y === this.y;
926	},
927
928	// @method contains(otherPoint: Point): Boolean
929	// Returns `true` if both coordinates of the given point are less than the corresponding current point coordinates (in absolute values).
930	contains: function (point) {
931		point = toPoint(point);
932
933		return Math.abs(point.x) <= Math.abs(this.x) &&
934		       Math.abs(point.y) <= Math.abs(this.y);
935	},
936
937	// @method toString(): String
938	// Returns a string representation of the point for debugging purposes.
939	toString: function () {
940		return 'Point(' +
941		        formatNum(this.x) + ', ' +
942		        formatNum(this.y) + ')';
943	}
944};
945
946// @factory L.point(x: Number, y: Number, round?: Boolean)
947// Creates a Point object with the given `x` and `y` coordinates. If optional `round` is set to true, rounds the `x` and `y` values.
948
949// @alternative
950// @factory L.point(coords: Number[])
951// Expects an array of the form `[x, y]` instead.
952
953// @alternative
954// @factory L.point(coords: Object)
955// Expects a plain object of the form `{x: Number, y: Number}` instead.
956function toPoint(x, y, round) {
957	if (x instanceof Point) {
958		return x;
959	}
960	if (isArray(x)) {
961		return new Point(x[0], x[1]);
962	}
963	if (x === undefined || x === null) {
964		return x;
965	}
966	if (typeof x === 'object' && 'x' in x && 'y' in x) {
967		return new Point(x.x, x.y);
968	}
969	return new Point(x, y, round);
970}
971
972/*
973 * @class Bounds
974 * @aka L.Bounds
975 *
976 * Represents a rectangular area in pixel coordinates.
977 *
978 * @example
979 *
980 * ```js
981 * var p1 = L.point(10, 10),
982 * p2 = L.point(40, 60),
983 * bounds = L.bounds(p1, p2);
984 * ```
985 *
986 * All Leaflet methods that accept `Bounds` objects also accept them in a simple Array form (unless noted otherwise), so the bounds example above can be passed like this:
987 *
988 * ```js
989 * otherBounds.intersects([[10, 10], [40, 60]]);
990 * ```
991 *
992 * Note that `Bounds` does not inherit from Leaflet's `Class` object,
993 * which means new classes can't inherit from it, and new methods
994 * can't be added to it with the `include` function.
995 */
996
997function Bounds(a, b) {
998	if (!a) { return; }
999
1000	var points = b ? [a, b] : a;
1001
1002	for (var i = 0, len = points.length; i < len; i++) {
1003		this.extend(points[i]);
1004	}
1005}
1006
1007Bounds.prototype = {
1008	// @method extend(point: Point): this
1009	// Extends the bounds to contain the given point.
1010
1011	// @alternative
1012	// @method extend(otherBounds: Bounds): this
1013	// Extend the bounds to contain the given bounds
1014	extend: function (obj) {
1015		var min2, max2;
1016		if (!obj) { return this; }
1017
1018		if (obj instanceof Point || typeof obj[0] === 'number' || 'x' in obj) {
1019			min2 = max2 = toPoint(obj);
1020		} else {
1021			obj = toBounds(obj);
1022			min2 = obj.min;
1023			max2 = obj.max;
1024
1025			if (!min2 || !max2) { return this; }
1026		}
1027
1028		// @property min: Point
1029		// The top left corner of the rectangle.
1030		// @property max: Point
1031		// The bottom right corner of the rectangle.
1032		if (!this.min && !this.max) {
1033			this.min = min2.clone();
1034			this.max = max2.clone();
1035		} else {
1036			this.min.x = Math.min(min2.x, this.min.x);
1037			this.max.x = Math.max(max2.x, this.max.x);
1038			this.min.y = Math.min(min2.y, this.min.y);
1039			this.max.y = Math.max(max2.y, this.max.y);
1040		}
1041		return this;
1042	},
1043
1044	// @method getCenter(round?: Boolean): Point
1045	// Returns the center point of the bounds.
1046	getCenter: function (round) {
1047		return toPoint(
1048		        (this.min.x + this.max.x) / 2,
1049		        (this.min.y + this.max.y) / 2, round);
1050	},
1051
1052	// @method getBottomLeft(): Point
1053	// Returns the bottom-left point of the bounds.
1054	getBottomLeft: function () {
1055		return toPoint(this.min.x, this.max.y);
1056	},
1057
1058	// @method getTopRight(): Point
1059	// Returns the top-right point of the bounds.
1060	getTopRight: function () { // -> Point
1061		return toPoint(this.max.x, this.min.y);
1062	},
1063
1064	// @method getTopLeft(): Point
1065	// Returns the top-left point of the bounds (i.e. [`this.min`](#bounds-min)).
1066	getTopLeft: function () {
1067		return this.min; // left, top
1068	},
1069
1070	// @method getBottomRight(): Point
1071	// Returns the bottom-right point of the bounds (i.e. [`this.max`](#bounds-max)).
1072	getBottomRight: function () {
1073		return this.max; // right, bottom
1074	},
1075
1076	// @method getSize(): Point
1077	// Returns the size of the given bounds
1078	getSize: function () {
1079		return this.max.subtract(this.min);
1080	},
1081
1082	// @method contains(otherBounds: Bounds): Boolean
1083	// Returns `true` if the rectangle contains the given one.
1084	// @alternative
1085	// @method contains(point: Point): Boolean
1086	// Returns `true` if the rectangle contains the given point.
1087	contains: function (obj) {
1088		var min, max;
1089
1090		if (typeof obj[0] === 'number' || obj instanceof Point) {
1091			obj = toPoint(obj);
1092		} else {
1093			obj = toBounds(obj);
1094		}
1095
1096		if (obj instanceof Bounds) {
1097			min = obj.min;
1098			max = obj.max;
1099		} else {
1100			min = max = obj;
1101		}
1102
1103		return (min.x >= this.min.x) &&
1104		       (max.x <= this.max.x) &&
1105		       (min.y >= this.min.y) &&
1106		       (max.y <= this.max.y);
1107	},
1108
1109	// @method intersects(otherBounds: Bounds): Boolean
1110	// Returns `true` if the rectangle intersects the given bounds. Two bounds
1111	// intersect if they have at least one point in common.
1112	intersects: function (bounds) { // (Bounds) -> Boolean
1113		bounds = toBounds(bounds);
1114
1115		var min = this.min,
1116		    max = this.max,
1117		    min2 = bounds.min,
1118		    max2 = bounds.max,
1119		    xIntersects = (max2.x >= min.x) && (min2.x <= max.x),
1120		    yIntersects = (max2.y >= min.y) && (min2.y <= max.y);
1121
1122		return xIntersects && yIntersects;
1123	},
1124
1125	// @method overlaps(otherBounds: Bounds): Boolean
1126	// Returns `true` if the rectangle overlaps the given bounds. Two bounds
1127	// overlap if their intersection is an area.
1128	overlaps: function (bounds) { // (Bounds) -> Boolean
1129		bounds = toBounds(bounds);
1130
1131		var min = this.min,
1132		    max = this.max,
1133		    min2 = bounds.min,
1134		    max2 = bounds.max,
1135		    xOverlaps = (max2.x > min.x) && (min2.x < max.x),
1136		    yOverlaps = (max2.y > min.y) && (min2.y < max.y);
1137
1138		return xOverlaps && yOverlaps;
1139	},
1140
1141	// @method isValid(): Boolean
1142	// Returns `true` if the bounds are properly initialized.
1143	isValid: function () {
1144		return !!(this.min && this.max);
1145	},
1146
1147
1148	// @method pad(bufferRatio: Number): Bounds
1149	// Returns bounds created by extending or retracting the current bounds by a given ratio in each direction.
1150	// For example, a ratio of 0.5 extends the bounds by 50% in each direction.
1151	// Negative values will retract the bounds.
1152	pad: function (bufferRatio) {
1153		var min = this.min,
1154		max = this.max,
1155		heightBuffer = Math.abs(min.x - max.x) * bufferRatio,
1156		widthBuffer = Math.abs(min.y - max.y) * bufferRatio;
1157
1158
1159		return toBounds(
1160			toPoint(min.x - heightBuffer, min.y - widthBuffer),
1161			toPoint(max.x + heightBuffer, max.y + widthBuffer));
1162	},
1163
1164
1165	// @method equals(otherBounds: Bounds): Boolean
1166	// Returns `true` if the rectangle is equivalent to the given bounds.
1167	equals: function (bounds) {
1168		if (!bounds) { return false; }
1169
1170		bounds = toBounds(bounds);
1171
1172		return this.min.equals(bounds.getTopLeft()) &&
1173			this.max.equals(bounds.getBottomRight());
1174	},
1175};
1176
1177
1178// @factory L.bounds(corner1: Point, corner2: Point)
1179// Creates a Bounds object from two corners coordinate pairs.
1180// @alternative
1181// @factory L.bounds(points: Point[])
1182// Creates a Bounds object from the given array of points.
1183function toBounds(a, b) {
1184	if (!a || a instanceof Bounds) {
1185		return a;
1186	}
1187	return new Bounds(a, b);
1188}
1189
1190/*
1191 * @class LatLngBounds
1192 * @aka L.LatLngBounds
1193 *
1194 * Represents a rectangular geographical area on a map.
1195 *
1196 * @example
1197 *
1198 * ```js
1199 * var corner1 = L.latLng(40.712, -74.227),
1200 * corner2 = L.latLng(40.774, -74.125),
1201 * bounds = L.latLngBounds(corner1, corner2);
1202 * ```
1203 *
1204 * 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:
1205 *
1206 * ```js
1207 * map.fitBounds([
1208 * 	[40.712, -74.227],
1209 * 	[40.774, -74.125]
1210 * ]);
1211 * ```
1212 *
1213 * 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.
1214 *
1215 * Note that `LatLngBounds` does not inherit from Leaflet's `Class` object,
1216 * which means new classes can't inherit from it, and new methods
1217 * can't be added to it with the `include` function.
1218 */
1219
1220function LatLngBounds(corner1, corner2) { // (LatLng, LatLng) or (LatLng[])
1221	if (!corner1) { return; }
1222
1223	var latlngs = corner2 ? [corner1, corner2] : corner1;
1224
1225	for (var i = 0, len = latlngs.length; i < len; i++) {
1226		this.extend(latlngs[i]);
1227	}
1228}
1229
1230LatLngBounds.prototype = {
1231
1232	// @method extend(latlng: LatLng): this
1233	// Extend the bounds to contain the given point
1234
1235	// @alternative
1236	// @method extend(otherBounds: LatLngBounds): this
1237	// Extend the bounds to contain the given bounds
1238	extend: function (obj) {
1239		var sw = this._southWest,
1240		    ne = this._northEast,
1241		    sw2, ne2;
1242
1243		if (obj instanceof LatLng) {
1244			sw2 = obj;
1245			ne2 = obj;
1246
1247		} else if (obj instanceof LatLngBounds) {
1248			sw2 = obj._southWest;
1249			ne2 = obj._northEast;
1250
1251			if (!sw2 || !ne2) { return this; }
1252
1253		} else {
1254			return obj ? this.extend(toLatLng(obj) || toLatLngBounds(obj)) : this;
1255		}
1256
1257		if (!sw && !ne) {
1258			this._southWest = new LatLng(sw2.lat, sw2.lng);
1259			this._northEast = new LatLng(ne2.lat, ne2.lng);
1260		} else {
1261			sw.lat = Math.min(sw2.lat, sw.lat);
1262			sw.lng = Math.min(sw2.lng, sw.lng);
1263			ne.lat = Math.max(ne2.lat, ne.lat);
1264			ne.lng = Math.max(ne2.lng, ne.lng);
1265		}
1266
1267		return this;
1268	},
1269
1270	// @method pad(bufferRatio: Number): LatLngBounds
1271	// Returns bounds created by extending or retracting the current bounds by a given ratio in each direction.
1272	// For example, a ratio of 0.5 extends the bounds by 50% in each direction.
1273	// Negative values will retract the bounds.
1274	pad: function (bufferRatio) {
1275		var sw = this._southWest,
1276		    ne = this._northEast,
1277		    heightBuffer = Math.abs(sw.lat - ne.lat) * bufferRatio,
1278		    widthBuffer = Math.abs(sw.lng - ne.lng) * bufferRatio;
1279
1280		return new LatLngBounds(
1281		        new LatLng(sw.lat - heightBuffer, sw.lng - widthBuffer),
1282		        new LatLng(ne.lat + heightBuffer, ne.lng + widthBuffer));
1283	},
1284
1285	// @method getCenter(): LatLng
1286	// Returns the center point of the bounds.
1287	getCenter: function () {
1288		return new LatLng(
1289		        (this._southWest.lat + this._northEast.lat) / 2,
1290		        (this._southWest.lng + this._northEast.lng) / 2);
1291	},
1292
1293	// @method getSouthWest(): LatLng
1294	// Returns the south-west point of the bounds.
1295	getSouthWest: function () {
1296		return this._southWest;
1297	},
1298
1299	// @method getNorthEast(): LatLng
1300	// Returns the north-east point of the bounds.
1301	getNorthEast: function () {
1302		return this._northEast;
1303	},
1304
1305	// @method getNorthWest(): LatLng
1306	// Returns the north-west point of the bounds.
1307	getNorthWest: function () {
1308		return new LatLng(this.getNorth(), this.getWest());
1309	},
1310
1311	// @method getSouthEast(): LatLng
1312	// Returns the south-east point of the bounds.
1313	getSouthEast: function () {
1314		return new LatLng(this.getSouth(), this.getEast());
1315	},
1316
1317	// @method getWest(): Number
1318	// Returns the west longitude of the bounds
1319	getWest: function () {
1320		return this._southWest.lng;
1321	},
1322
1323	// @method getSouth(): Number
1324	// Returns the south latitude of the bounds
1325	getSouth: function () {
1326		return this._southWest.lat;
1327	},
1328
1329	// @method getEast(): Number
1330	// Returns the east longitude of the bounds
1331	getEast: function () {
1332		return this._northEast.lng;
1333	},
1334
1335	// @method getNorth(): Number
1336	// Returns the north latitude of the bounds
1337	getNorth: function () {
1338		return this._northEast.lat;
1339	},
1340
1341	// @method contains(otherBounds: LatLngBounds): Boolean
1342	// Returns `true` if the rectangle contains the given one.
1343
1344	// @alternative
1345	// @method contains (latlng: LatLng): Boolean
1346	// Returns `true` if the rectangle contains the given point.
1347	contains: function (obj) { // (LatLngBounds) or (LatLng) -> Boolean
1348		if (typeof obj[0] === 'number' || obj instanceof LatLng || 'lat' in obj) {
1349			obj = toLatLng(obj);
1350		} else {
1351			obj = toLatLngBounds(obj);
1352		}
1353
1354		var sw = this._southWest,
1355		    ne = this._northEast,
1356		    sw2, ne2;
1357
1358		if (obj instanceof LatLngBounds) {
1359			sw2 = obj.getSouthWest();
1360			ne2 = obj.getNorthEast();
1361		} else {
1362			sw2 = ne2 = obj;
1363		}
1364
1365		return (sw2.lat >= sw.lat) && (ne2.lat <= ne.lat) &&
1366		       (sw2.lng >= sw.lng) && (ne2.lng <= ne.lng);
1367	},
1368
1369	// @method intersects(otherBounds: LatLngBounds): Boolean
1370	// Returns `true` if the rectangle intersects the given bounds. Two bounds intersect if they have at least one point in common.
1371	intersects: function (bounds) {
1372		bounds = toLatLngBounds(bounds);
1373
1374		var sw = this._southWest,
1375		    ne = this._northEast,
1376		    sw2 = bounds.getSouthWest(),
1377		    ne2 = bounds.getNorthEast(),
1378
1379		    latIntersects = (ne2.lat >= sw.lat) && (sw2.lat <= ne.lat),
1380		    lngIntersects = (ne2.lng >= sw.lng) && (sw2.lng <= ne.lng);
1381
1382		return latIntersects && lngIntersects;
1383	},
1384
1385	// @method overlaps(otherBounds: LatLngBounds): Boolean
1386	// Returns `true` if the rectangle overlaps the given bounds. Two bounds overlap if their intersection is an area.
1387	overlaps: function (bounds) {
1388		bounds = toLatLngBounds(bounds);
1389
1390		var sw = this._southWest,
1391		    ne = this._northEast,
1392		    sw2 = bounds.getSouthWest(),
1393		    ne2 = bounds.getNorthEast(),
1394
1395		    latOverlaps = (ne2.lat > sw.lat) && (sw2.lat < ne.lat),
1396		    lngOverlaps = (ne2.lng > sw.lng) && (sw2.lng < ne.lng);
1397
1398		return latOverlaps && lngOverlaps;
1399	},
1400
1401	// @method toBBoxString(): String
1402	// 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.
1403	toBBoxString: function () {
1404		return [this.getWest(), this.getSouth(), this.getEast(), this.getNorth()].join(',');
1405	},
1406
1407	// @method equals(otherBounds: LatLngBounds, maxMargin?: Number): Boolean
1408	// 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.
1409	equals: function (bounds, maxMargin) {
1410		if (!bounds) { return false; }
1411
1412		bounds = toLatLngBounds(bounds);
1413
1414		return this._southWest.equals(bounds.getSouthWest(), maxMargin) &&
1415		       this._northEast.equals(bounds.getNorthEast(), maxMargin);
1416	},
1417
1418	// @method isValid(): Boolean
1419	// Returns `true` if the bounds are properly initialized.
1420	isValid: function () {
1421		return !!(this._southWest && this._northEast);
1422	}
1423};
1424
1425// TODO International date line?
1426
1427// @factory L.latLngBounds(corner1: LatLng, corner2: LatLng)
1428// Creates a `LatLngBounds` object by defining two diagonally opposite corners of the rectangle.
1429
1430// @alternative
1431// @factory L.latLngBounds(latlngs: LatLng[])
1432// 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).
1433function toLatLngBounds(a, b) {
1434	if (a instanceof LatLngBounds) {
1435		return a;
1436	}
1437	return new LatLngBounds(a, b);
1438}
1439
1440/* @class LatLng
1441 * @aka L.LatLng
1442 *
1443 * Represents a geographical point with a certain latitude and longitude.
1444 *
1445 * @example
1446 *
1447 * ```
1448 * var latlng = L.latLng(50.5, 30.5);
1449 * ```
1450 *
1451 * 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:
1452 *
1453 * ```
1454 * map.panTo([50, 30]);
1455 * map.panTo({lon: 30, lat: 50});
1456 * map.panTo({lat: 50, lng: 30});
1457 * map.panTo(L.latLng(50, 30));
1458 * ```
1459 *
1460 * Note that `LatLng` does not inherit from Leaflet's `Class` object,
1461 * which means new classes can't inherit from it, and new methods
1462 * can't be added to it with the `include` function.
1463 */
1464
1465function LatLng(lat, lng, alt) {
1466	if (isNaN(lat) || isNaN(lng)) {
1467		throw new Error('Invalid LatLng object: (' + lat + ', ' + lng + ')');
1468	}
1469
1470	// @property lat: Number
1471	// Latitude in degrees
1472	this.lat = +lat;
1473
1474	// @property lng: Number
1475	// Longitude in degrees
1476	this.lng = +lng;
1477
1478	// @property alt: Number
1479	// Altitude in meters (optional)
1480	if (alt !== undefined) {
1481		this.alt = +alt;
1482	}
1483}
1484
1485LatLng.prototype = {
1486	// @method equals(otherLatLng: LatLng, maxMargin?: Number): Boolean
1487	// 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.
1488	equals: function (obj, maxMargin) {
1489		if (!obj) { return false; }
1490
1491		obj = toLatLng(obj);
1492
1493		var margin = Math.max(
1494		        Math.abs(this.lat - obj.lat),
1495		        Math.abs(this.lng - obj.lng));
1496
1497		return margin <= (maxMargin === undefined ? 1.0E-9 : maxMargin);
1498	},
1499
1500	// @method toString(): String
1501	// Returns a string representation of the point (for debugging purposes).
1502	toString: function (precision) {
1503		return 'LatLng(' +
1504		        formatNum(this.lat, precision) + ', ' +
1505		        formatNum(this.lng, precision) + ')';
1506	},
1507
1508	// @method distanceTo(otherLatLng: LatLng): Number
1509	// 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).
1510	distanceTo: function (other) {
1511		return Earth.distance(this, toLatLng(other));
1512	},
1513
1514	// @method wrap(): LatLng
1515	// Returns a new `LatLng` object with the longitude wrapped so it's always between -180 and +180 degrees.
1516	wrap: function () {
1517		return Earth.wrapLatLng(this);
1518	},
1519
1520	// @method toBounds(sizeInMeters: Number): LatLngBounds
1521	// Returns a new `LatLngBounds` object in which each boundary is `sizeInMeters/2` meters apart from the `LatLng`.
1522	toBounds: function (sizeInMeters) {
1523		var latAccuracy = 180 * sizeInMeters / 40075017,
1524		    lngAccuracy = latAccuracy / Math.cos((Math.PI / 180) * this.lat);
1525
1526		return toLatLngBounds(
1527		        [this.lat - latAccuracy, this.lng - lngAccuracy],
1528		        [this.lat + latAccuracy, this.lng + lngAccuracy]);
1529	},
1530
1531	clone: function () {
1532		return new LatLng(this.lat, this.lng, this.alt);
1533	}
1534};
1535
1536
1537
1538// @factory L.latLng(latitude: Number, longitude: Number, altitude?: Number): LatLng
1539// Creates an object representing a geographical point with the given latitude and longitude (and optionally altitude).
1540
1541// @alternative
1542// @factory L.latLng(coords: Array): LatLng
1543// Expects an array of the form `[Number, Number]` or `[Number, Number, Number]` instead.
1544
1545// @alternative
1546// @factory L.latLng(coords: Object): LatLng
1547// Expects an plain object of the form `{lat: Number, lng: Number}` or `{lat: Number, lng: Number, alt: Number}` instead.
1548
1549function toLatLng(a, b, c) {
1550	if (a instanceof LatLng) {
1551		return a;
1552	}
1553	if (isArray(a) && typeof a[0] !== 'object') {
1554		if (a.length === 3) {
1555			return new LatLng(a[0], a[1], a[2]);
1556		}
1557		if (a.length === 2) {
1558			return new LatLng(a[0], a[1]);
1559		}
1560		return null;
1561	}
1562	if (a === undefined || a === null) {
1563		return a;
1564	}
1565	if (typeof a === 'object' && 'lat' in a) {
1566		return new LatLng(a.lat, 'lng' in a ? a.lng : a.lon, a.alt);
1567	}
1568	if (b === undefined) {
1569		return null;
1570	}
1571	return new LatLng(a, b, c);
1572}
1573
1574/*
1575 * @namespace CRS
1576 * @crs L.CRS.Base
1577 * Object that defines coordinate reference systems for projecting
1578 * geographical points into pixel (screen) coordinates and back (and to

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