https://khushiipropertiies.com/wp-content/plugins/wpdirectorykit/public/js/openstreetmap/leaflet.js?ver=1.7.1

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

775afe to modify existing point
776            this.x += point.x;
777            this.y += point.y;
778            return this;
779        },
780  
781        // @method subtract(otherPoint: Point): Point
782        // Returns the result of subtraction of the given point from the current.
783        subtract: function (point) {
784            return this.clone()._subtract(toPoint(point));
785        },
786  
787        _subtract: function (point) {
788            this.x -= point.x;
789            this.y -= point.y;
790            return this;
791        },
792  
793        // @method divideBy(num: Number): Point
794        // Returns the result of division of the current point by the given number.
795        divideBy: function (num) {
796            return this.clone()._divideBy(num);
797        },
798  
799        _divideBy: function (num) {
800            this.x /= num;
801            this.y /= num;
802            return this;
803        },
804  
805        // @method multiplyBy(num: Number): Point
806        // Returns the result of multiplication of the current point by the given number.
807        multiplyBy: function (num) {
808            return this.clone()._multiplyBy(num);
809        },
810  
811        _multiplyBy: function (num) {
812            this.x *= num;
813            this.y *= num;
814            return this;
815        },
816  
817        // @method scaleBy(scale: Point): Point
818        // Multiply each coordinate of the current point by each coordinate of
819        // `scale`. In linear algebra terms, multiply the point by the
820        // [scaling matrix](https://en.wikipedia.org/wiki/Scaling_%28geometry%29#Matrix_representation)
821        // defined by `scale`.
822        scaleBy: function (point) {
823            return new Point(this.x * point.x, this.y * point.y);
824        },
825  
826        // @method unscaleBy(scale: Point): Point
827        // Inverse of `scaleBy`. Divide each coordinate of the current point by
828        // each coordinate of `scale`.
829        unscaleBy: function (point) {
830            return new Point(this.x / point.x, this.y / point.y);
831        },
832  
833        // @method round(): Point
834        // Returns a copy of the current point with rounded coordinates.
835        round: function () {
836            return this.clone()._round();
837        },
838  
839        _round: function () {
840            this.x = Math.round(this.x);
841            this.y = Math.round(this.y);
842            return this;
843        },
844  
845        // @method floor(): Point
846        // Returns a copy of the current point with floored coordinates (rounded down).
847        floor: function () {
848            return this.clone()._floor();
849        },
850  
851        _floor: function () {
852            this.x = Math.floor(this.x);
853            this.y = Math.floor(this.y);
854            return this;
855        },
856  
857        // @method ceil(): Point
858        // Returns a copy of the current point with ceiled coordinates (rounded up).
859        ceil: function () {
860            return this.clone()._ceil();
861        },
862  
863        _ceil: function () {
864            this.x = Math.ceil(this.x);
865            this.y = Math.ceil(this.y);
866            return this;
867        },
868  
869        // @method trunc(): Point
870        // Returns a copy of the current point with truncated coordinates (rounded towards zero).
871        trunc: function () {
872            return this.clone()._trunc();
873        },
874  
875        _trunc: function () {
876            this.x = trunc(this.x);
877            this.y = trunc(this.y);
878            return this;
879        },
880  
881        // @method distanceTo(otherPoint: Point): Number
882        // Returns the cartesian distance between the current and the given points.
883        distanceTo: function (point) {
884            point = toPoint(point);
885  
886            var x = point.x - this.x,
887                y = point.y - this.y;
888  
889            return Math.sqrt(x * x + y * y);
890        },
891  
892        // @method equals(otherPoint: Point): Boolean
893        // Returns `true` if the given point has the same coordinates.
894        equals: function (point) {
895            point = toPoint(point);
896  
897            return point.x === this.x &&
898                   point.y === this.y;
899        },
900  
901        // @method contains(otherPoint: Point): Boolean
902        // Returns `true` if both coordinates of the given point are less than the corresponding current point coordinates (in absolute values).
903        contains: function (point) {
904            point = toPoint(point);
905  
906            return Math.abs(point.x) <= Math.abs(this.x) &&
907                   Math.abs(point.y) <= Math.abs(this.y);
908        },
909  
910        // @method toString(): String
911        // Returns a string representation of the point for debugging purposes.
912        toString: function () {
913            return 'Point(' +
914                    formatNum(this.x) + ', ' +
915                    formatNum(this.y) + ')';
916        }
917    };
918  
919    // @factory L.point(x: Number, y: Number, round?: Boolean)
920    // Creates a Point object with the given `x` and `y` coordinates. If optional `round` is set to true, rounds the `x` and `y` values.
921  
922    // @alternative
923    // @factory L.point(coords: Number[])
924    // Expects an array of the form `[x, y]` instead.
925  
926    // @alternative
927    // @factory L.point(coords: Object)
928    // Expects a plain object of the form `{x: Number, y: Number}` instead.
929    function toPoint(x, y, round) {
930        if (x instanceof Point) {
931            return x;
932        }
933        if (isArray(x)) {
934            return new Point(x[0], x[1]);
935        }
936        if (x === undefined || x === null) {
937            return x;
938        }
939        if (typeof x === 'object' && 'x' in x && 'y' in x) {
940            return new Point(x.x, x.y);
941        }
942        return new Point(x, y, round);
943    }
944  
945    /*
946     * @class Bounds
947     * @aka L.Bounds
948     *
949     * Represents a rectangular area in pixel coordinates.
950     *
951     * @example
952     *
953     * ```js
954     * var p1 = L.point(10, 10),
955     * p2 = L.point(40, 60),
956     * bounds = L.bounds(p1, p2);
957     * ```
958     *
959     * 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:
960     *
961     * ```js
962     * otherBounds.intersects([[10, 10], [40, 60]]);
963     * ```
964     *
965     * Note that `Bounds` does not inherit from Leaflet's `Class` object,
966     * which means new classes can't inherit from it, and new methods
967     * can't be added to it with the `include` function.
968     */
969  
970    function Bounds(a, b) {
971        if (!a) { return; }
972  
973        var points = b ? [a, b] : a;
974  
975        for (var i = 0, len = points.length; i < len; i++) {
976            this.extend(points[i]);
977        }
978    }
979  
980    Bounds.prototype = {
981        // @method extend(point: Point): this
982        // Extends the bounds to contain the given point.
983        extend: function (point) { // (Point)
984            point = toPoint(point);
985  
986            // @property min: Point
987            // The top left corner of the rectangle.
988            // @property max: Point
989            // The bottom right corner of the rectangle.
990            if (!this.min && !this.max) {
991                this.min = point.clone();
992                this.max = point.clone();
993            } else {
994                this.min.x = Math.min(point.x, this.min.x);
995                this.max.x = Math.max(point.x, this.max.x);
996                this.min.y = Math.min(point.y, this.min.y);
997                this.max.y = Math.max(point.y, this.max.y);
998            }
999            return this;
1000        },
1001  
1002        // @method getCenter(round?: Boolean): Point
1003        // Returns the center point of the bounds.
1004        getCenter: function (round) {
1005            return new Point(
1006                    (this.min.x + this.max.x) / 2,
1007                    (this.min.y + this.max.y) / 2, round);
1008        },
1009  
1010        // @method getBottomLeft(): Point
1011        // Returns the bottom-left point of the bounds.
1012        getBottomLeft: function () {
1013            return new Point(this.min.x, this.max.y);
1014        },
1015  
1016        // @method getTopRight(): Point
1017        // Returns the top-right point of the bounds.
1018        getTopRight: function () { // -> Point
1019            return new Point(this.max.x, this.min.y);
1020        },
1021  
1022        // @method getTopLeft(): Point
1023        // Returns the top-left point of the bounds (i.e. [`this.min`](#bounds-min)).
1024        getTopLeft: function () {
1025            return this.min; // left, top
1026        },
1027  
1028        // @method getBottomRight(): Point
1029        // Returns the bottom-right point of the bounds (i.e. [`this.max`](#bounds-max)).
1030        getBottomRight: function () {
1031            return this.max; // right, bottom
1032        },
1033  
1034        // @method getSize(): Point
1035        // Returns the size of the given bounds
1036        getSize: function () {
1037            return this.max.subtract(this.min);
1038        },
1039  
1040        // @method contains(otherBounds: Bounds): Boolean
1041        // Returns `true` if the rectangle contains the given one.
1042        // @alternative
1043        // @method contains(point: Point): Boolean
1044        // Returns `true` if the rectangle contains the given point.
1045        contains: function (obj) {
1046            var min, max;
1047  
1048            if (typeof obj[0] === 'number' || obj instanceof Point) {
1049                obj = toPoint(obj);
1050            } else {
1051                obj = toBounds(obj);
1052            }
1053  
1054            if (obj instanceof Bounds) {
1055                min = obj.min;
1056                max = obj.max;
1057            } else {
1058                min = max = obj;
1059            }
1060  
1061            return (min.x >= this.min.x) &&
1062                   (max.x <= this.max.x) &&
1063                   (min.y >= this.min.y) &&
1064                   (max.y <= this.max.y);
1065        },
1066  
1067        // @method intersects(otherBounds: Bounds): Boolean
1068        // Returns `true` if the rectangle intersects the given bounds. Two bounds
1069        // intersect if they have at least one point in common.
1070        intersects: function (bounds) { // (Bounds) -> Boolean
1071            bounds = toBounds(bounds);
1072  
1073            var min = this.min,
1074                max = this.max,
1075                min2 = bounds.min,
1076                max2 = bounds.max,
1077                xIntersects = (max2.x >= min.x) && (min2.x <= max.x),
1078                yIntersects = (max2.y >= min.y) && (min2.y <= max.y);
1079  
1080            return xIntersects && yIntersects;
1081        },
1082  
1083        // @method overlaps(otherBounds: Bounds): Boolean
1084        // Returns `true` if the rectangle overlaps the given bounds. Two bounds
1085        // overlap if their intersection is an area.
1086        overlaps: function (bounds) { // (Bounds) -> Boolean
1087            bounds = toBounds(bounds);
1088  
1089            var min = this.min,
1090                max = this.max,
1091                min2 = bounds.min,
1092                max2 = bounds.max,
1093                xOverlaps = (max2.x > min.x) && (min2.x < max.x),
1094                yOverlaps = (max2.y > min.y) && (min2.y < max.y);
1095  
1096            return xOverlaps && yOverlaps;
1097        },
1098  
1099        isValid: function () {
1100            return !!(this.min && this.max);
1101        }
1102    };
1103  
1104  
1105    // @factory L.bounds(corner1: Point, corner2: Point)
1106    // Creates a Bounds object from two corners coordinate pairs.
1107    // @alternative
1108    // @factory L.bounds(points: Point[])
1109    // Creates a Bounds object from the given array of points.
1110    function toBounds(a, b) {
1111        if (!a || a instanceof Bounds) {
1112            return a;
1113        }
1114        return new Bounds(a, b);
1115    }
1116  
1117    /*
1118     * @class LatLngBounds
1119     * @aka L.LatLngBounds
1120     *
1121     * Represents a rectangular geographical area on a map.
1122     *
1123     * @example
1124     *
1125     * ```js
1126     * var corner1 = L.latLng(40.712, -74.227),
1127     * corner2 = L.latLng(40.774, -74.125),
1128     * bounds = L.latLngBounds(corner1, corner2);
1129     * ```
1130     *
1131     * 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:
1132     *
1133     * ```js
1134     * map.fitBounds([
1135     * 	[40.712, -74.227],
1136     * 	[40.774, -74.125]
1137     * ]);
1138     * ```
1139     *
1140     * 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.
1141     *
1142     * Note that `LatLngBounds` does not inherit from Leaflet's `Class` object,
1143     * which means new classes can't inherit from it, and new methods
1144     * can't be added to it with the `include` function.
1145     */
1146  
1147    function LatLngBounds(corner1, corner2) { // (LatLng, LatLng) or (LatLng[])
1148        if (!corner1) { return; }
1149  
1150        var latlngs = corner2 ? [corner1, corner2] : corner1;
1151  
1152        for (var i = 0, len = latlngs.length; i < len; i++) {
1153            this.extend(latlngs[i]);
1154        }
1155    }
1156  
1157    LatLngBounds.prototype = {
1158  
1159        // @method extend(latlng: LatLng): this
1160        // Extend the bounds to contain the given point
1161  
1162        // @alternative
1163        // @method extend(otherBounds: LatLngBounds): this
1164        // Extend the bounds to contain the given bounds
1165        extend: function (obj) {
1166            var sw = this._southWest,
1167                ne = this._northEast,
1168                sw2, ne2;
1169  
1170            if (obj instanceof LatLng) {
1171                sw2 = obj;
1172                ne2 = obj;
1173  
1174            } else if (obj instanceof LatLngBounds) {
1175                sw2 = obj._southWest;
1176                ne2 = obj._northEast;
1177  
1178                if (!sw2 || !ne2) { return this; }
1179  
1180            } else {
1181                return obj ? this.extend(toLatLng(obj) || toLatLngBounds(obj)) : this;
1182            }
1183  
1184            if (!sw && !ne) {
1185                this._southWest = new LatLng(sw2.lat, sw2.lng);
1186                this._northEast = new LatLng(ne2.lat, ne2.lng);
1187            } else {
1188                sw.lat = Math.min(sw2.lat, sw.lat);
1189                sw.lng = Math.min(sw2.lng, sw.lng);
1190                ne.lat = Math.max(ne2.lat, ne.lat);
1191                ne.lng = Math.max(ne2.lng, ne.lng);
1192            }
1193  
1194            return this;
1195        },
1196  
1197        // @method pad(bufferRatio: Number): LatLngBounds
1198        // Returns bounds created by extending or retracting the current bounds by a given ratio in each direction.
1199        // For example, a ratio of 0.5 extends the bounds by 50% in each direction.
1200        // Negative values will retract the bounds.
1201        pad: function (bufferRatio) {
1202            var sw = this._southWest,
1203                ne = this._northEast,
1204                heightBuffer = Math.abs(sw.lat - ne.lat) * bufferRatio,
1205                widthBuffer = Math.abs(sw.lng - ne.lng) * bufferRatio;
1206  
1207            return new LatLngBounds(
1208                    new LatLng(sw.lat - heightBuffer, sw.lng - widthBuffer),
1209                    new LatLng(ne.lat + heightBuffer, ne.lng + widthBuffer));
1210        },
1211  
1212        // @method getCenter(): LatLng
1213        // Returns the center point of the bounds.
1214        getCenter: function () {
1215            return new LatLng(
1216                    (this._southWest.lat + this._northEast.lat) / 2,
1217                    (this._southWest.lng + this._northEast.lng) / 2);
1218        },
1219  
1220        // @method getSouthWest(): LatLng
1221        // Returns the south-west point of the bounds.
1222        getSouthWest: function () {
1223            return this._southWest;
1224        },
1225  
1226        // @method getNorthEast(): LatLng
1227        // Returns the north-east point of the bounds.
1228        getNorthEast: function () {
1229            return this._northEast;
1230        },
1231  
1232        // @method getNorthWest(): LatLng
1233        // Returns the north-west point of the bounds.
1234        getNorthWest: function () {
1235            return new LatLng(this.getNorth(), this.getWest());
1236        },
1237  
1238        // @method getSouthEast(): LatLng
1239        // Returns the south-east point of the bounds.
1240        getSouthEast: function () {
1241            return new LatLng(this.getSouth(), this.getEast());
1242        },
1243  
1244        // @method getWest(): Number
1245        // Returns the west longitude of the bounds
1246        getWest: function () {
1247            return this._southWest.lng;
1248        },
1249  
1250        // @method getSouth(): Number
1251        // Returns the south latitude of the bounds
1252        getSouth: function () {
1253            return this._southWest.lat;
1254        },
1255  
1256        // @method getEast(): Number
1257        // Returns the east longitude of the bounds
1258        getEast: function () {
1259            return this._northEast.lng;
1260        },
1261  
1262        // @method getNorth(): Number
1263        // Returns the north latitude of the bounds
1264        getNorth: function () {
1265            return this._northEast.lat;
1266        },
1267  
1268        // @method contains(otherBounds: LatLngBounds): Boolean
1269        // Returns `true` if the rectangle contains the given one.
1270  
1271        // @alternative
1272        // @method contains (latlng: LatLng): Boolean
1273        // Returns `true` if the rectangle contains the given point.
1274        contains: function (obj) { // (LatLngBounds) or (LatLng) -> Boolean
1275            if (typeof obj[0] === 'number' || obj instanceof LatLng || 'lat' in obj) {
1276                obj = toLatLng(obj);
1277            } else {
1278                obj = toLatLngBounds(obj);
1279            }
1280  
1281            var sw = this._southWest,
1282                ne = this._northEast,
1283                sw2, ne2;
1284  
1285            if (obj instanceof LatLngBounds) {
1286                sw2 = obj.getSouthWest();
1287                ne2 = obj.getNorthEast();
1288            } else {
1289                sw2 = ne2 = obj;
1290            }
1291  
1292            return (sw2.lat >= sw.lat) && (ne2.lat <= ne.lat) &&
1293                   (sw2.lng >= sw.lng) && (ne2.lng <= ne.lng);
1294        },
1295  
1296        // @method intersects(otherBounds: LatLngBounds): Boolean
1297        // Returns `true` if the rectangle intersects the given bounds. Two bounds intersect if they have at least one point in common.
1298        intersects: function (bounds) {
1299            bounds = toLatLngBounds(bounds);
1300  
1301            var sw = this._southWest,
1302                ne = this._northEast,
1303                sw2 = bounds.getSouthWest(),
1304                ne2 = bounds.getNorthEast(),
1305  
1306                latIntersects = (ne2.lat >= sw.lat) && (sw2.lat <= ne.lat),
1307                lngIntersects = (ne2.lng >= sw.lng) && (sw2.lng <= ne.lng);
1308  
1309            return latIntersects && lngIntersects;
1310        },
1311  
1312        // @method overlaps(otherBounds: LatLngBounds): Boolean
1313        // Returns `true` if the rectangle overlaps the given bounds. Two bounds overlap if their intersection is an area.
1314        overlaps: function (bounds) {
1315            bounds = toLatLngBounds(bounds);
1316  
1317            var sw = this._southWest,
1318                ne = this._northEast,
1319                sw2 = bounds.getSouthWest(),
1320                ne2 = bounds.getNorthEast(),
1321  
1322                latOverlaps = (ne2.lat > sw.lat) && (sw2.lat < ne.lat),
1323                lngOverlaps = (ne2.lng > sw.lng) && (sw2.lng < ne.lng);
1324  
1325            return latOverlaps && lngOverlaps;
1326        },
1327  
1328        // @method toBBoxString(): String
1329        // 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.
1330        toBBoxString: function () {
1331            return [this.getWest(), this.getSouth(), this.getEast(), this.getNorth()].join(',');
1332        },
1333  
1334        // @method equals(otherBounds: LatLngBounds, maxMargin?: Number): Boolean
1335        // 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.
1336        equals: function (bounds, maxMargin) {
1337            if (!bounds) { return false; }
1338  
1339            bounds = toLatLngBounds(bounds);
1340  
1341            return this._southWest.equals(bounds.getSouthWest(), maxMargin) &&
1342                   this._northEast.equals(bounds.getNorthEast(), maxMargin);
1343        },
1344  
1345        // @method isValid(): Boolean
1346        // Returns `true` if the bounds are properly initialized.
1347        isValid: function () {
1348            return !!(this._southWest && this._northEast);
1349        }
1350    };
1351  
1352    // TODO International date line?
1353  
1354    // @factory L.latLngBounds(corner1: LatLng, corner2: LatLng)
1355    // Creates a `LatLngBounds` object by defining two diagonally opposite corners of the rectangle.
1356  
1357    // @alternative
1358    // @factory L.latLngBounds(latlngs: LatLng[])
1359    // 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).
1360    function toLatLngBounds(a, b) {
1361        if (a instanceof LatLngBounds) {
1362            return a;
1363        }
1364        return new LatLngBounds(a, b);
1365    }
1366  
1367    /* @class LatLng
1368     * @aka L.LatLng
1369     *
1370     * Represents a geographical point with a certain latitude and longitude.
1371     *
1372     * @example
1373     *
1374     * ```
1375     * var latlng = L.latLng(50.5, 30.5);
1376     * ```
1377     *
1378     * 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:
1379     *
1380     * ```
1381     * map.panTo([50, 30]);
1382     * map.panTo({lon: 30, lat: 50});
1383     * map.panTo({lat: 50, lng: 30});
1384     * map.panTo(L.latLng(50, 30));
1385     * ```
1386     *
1387     * Note that `LatLng` does not inherit from Leaflet's `Class` object,
1388     * which means new classes can't inherit from it, and new methods
1389     * can't be added to it with the `include` function.
1390     */
1391  
1392    function LatLng(lat, lng, alt) {
1393        if (isNaN(lat) || isNaN(lng)) {
1394            throw new Error('Invalid LatLng object: (' + lat + ', ' + lng + ')');
1395        }
1396  
1397        // @property lat: Number
1398        // Latitude in degrees
1399        this.lat = +lat;
1400  
1401        // @property lng: Number
1402        // Longitude in degrees
1403        this.lng = +lng;
1404  
1405        // @property alt: Number
1406        // Altitude in meters (optional)
1407        if (alt !== undefined) {
1408            this.alt = +alt;
1409        }
1410    }
1411  
1412    LatLng.prototype = {
1413        // @method equals(otherLatLng: LatLng, maxMargin?: Number): Boolean
1414        // 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.
1415        equals: function (obj, maxMargin) {
1416            if (!obj) { return false; }
1417  
1418            obj = toLatLng(obj);
1419  
1420            var margin = Math.max(
1421                    Math.abs(this.lat - obj.lat),
1422                    Math.abs(this.lng - obj.lng));
1423  
1424            return margin <= (maxMargin === undefined ? 1.0E-9 : maxMargin);
1425        },
1426  
1427        // @method toString(): String
1428        // Returns a string representation of the point (for debugging purposes).
1429        toString: function (precision) {
1430            return 'LatLng(' +
1431                    formatNum(this.lat, precision) + ', ' +
1432                    formatNum(this.lng, precision) + ')';
1433        },
1434  
1435        // @method distanceTo(otherLatLng: LatLng): Number
1436        // 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).
1437        distanceTo: function (other) {
1438            return Earth.distance(this, toLatLng(other));
1439        },
1440  
1441        // @method wrap(): LatLng
1442        // Returns a new `LatLng` object with the longitude wrapped so it's always between -180 and +180 degrees.
1443        wrap: function () {
1444            return Earth.wrapLatLng(this);
1445        },
1446  
1447        // @method toBounds(sizeInMeters: Number): LatLngBounds
1448        // Returns a new `LatLngBounds` object in which each boundary is `sizeInMeters/2` meters apart from the `LatLng`.
1449        toBounds: function (sizeInMeters) {
1450            var latAccuracy = 180 * sizeInMeters / 40075017,
1451                lngAccuracy = latAccuracy / Math.cos((Math.PI / 180) * this.lat);
1452  
1453            return toLatLngBounds(
1454                    [this.lat - latAccuracy, this.lng - lngAccuracy],
1455                    [this.lat + latAccuracy, this.lng + lngAccuracy]);
1456        },
1457  
1458        clone: function () {
1459            return new LatLng(this.lat, this.lng, this.alt);
1460        }
1461    };
1462  
1463  
1464  
1465    // @factory L.latLng(latitude: Number, longitude: Number, altitude?: Number): LatLng
1466    // Creates an object representing a geographical point with the given latitude and longitude (and optionally altitude).
1467  
1468    // @alternative
1469    // @factory L.latLng(coords: Array): LatLng
1470    // Expects an array of the form `[Number, Number]` or `[Number, Number, Number]` instead.
1471  
1472    // @alternative
1473    // @factory L.latLng(coords: Object): LatLng
1474    // Expects an plain object of the form `{lat: Number, lng: Number}` or `{lat: Number, lng: Number, alt: Number}` instead.
1475  
1476    function toLatLng(a, b, c) {
1477        if (a instanceof LatLng) {
1478            return a;
1479        }
1480        if (isArray(a) && typeof a[0] !== 'object') {
1481            if (a.length === 3) {
1482                return new LatLng(a[0], a[1], a[2]);
1483            }
1484            if (a.length === 2) {
1485                return new LatLng(a[0], a[1]);
1486            }
1487            return null;
1488        }
1489        if (a === undefined || a === null) {
1490            return a;
1491        }
1492        if (typeof a === 'object' && 'lat' in a) {
1493            return new LatLng(a.lat, 'lng' in a ? a.lng : a.lon, a.alt);
1494        }
1495        if (b === undefined) {
1496            return null;
1497        }
1498        return new LatLng(a, b, c);
1499    }
1500  
1501    /*
1502     * @namespace CRS
1503     * @crs L.CRS.Base
1504     * Object that defines coordinate reference systems for projecting
1505     * geographical points into pixel (screen) coordinates and back (and to

1609            return new LatLng(lat, lng, alt);
1610        },
1611  
1612        // @method wrapLatLngBounds(bounds: LatLngBounds): LatLngBounds
1613        // Returns a `LatLngBounds` with the same size as the given one, ensuring
1614        // that its center is within the CRS's bounds.
1615        // Only accepts actual `L.LatLngBounds` instances, not arrays.
1616        wrapLatLngBounds: function (bounds) {
1617            var center = bounds.getCenter(),
1618                newCenter = this.wrapLatLng(center),
1619                latShift = center.lat - newCenter.lat,
1620                lngShift = center.lng - newCenter.lng;
1621  
1622            if (latShift === 0 && lngShift === 0) {
1623                return bounds;
1624            }
1625  
1626            var sw = bounds.getSouthWest(),
1627                ne = bounds.getNorthEast(),
1628                newSw = new LatLng(sw.lat - latShift, sw.lng - lngShift),
1629                newNe = new LatLng(ne.lat - latShift, ne.lng - lngShift);
1630  
1631            return new LatLngBounds(newSw, newNe);
1632        }
1633    };
1634  
1635    /*
1636     * @namespace CRS
1637     * @crs L.CRS.Earth
1638     *
1639     * Serves as the base for CRS that are global such that they cover the earth.
1640     * Can only be used as the base for other CRS and cannot be used directly,
1641     * since it does not have a `code`, `projection` or `transformation`. `distance()` returns
1642     * meters.
1643     */
1644  
1645    var Earth = extend({}, CRS, {
1646        wrapLng: [-180, 180],
1647  
1648        // Mean Earth Radius, as recommended for use by
1649        // the International Union of Geodesy and Geophysics,
1650        // see https://rosettacode.org/wiki/Haversine_formula
1651        R: 6371000,
1652  
1653        // distance between two geographical points using spherical law of cosines approximation
1654        distance: function (latlng1, latlng2) {
1655            var rad = Math.PI / 180,
1656                lat1 = latlng1.lat * rad,
1657                lat2 = latlng2.lat * rad,
1658                sinDLat = Math.sin((latlng2.lat - latlng1.lat) * rad / 2),
1659                sinDLon = Math.sin((latlng2.lng - latlng1.lng) * rad / 2),
1660                a = sinDLat * sinDLat + Math.cos(lat1) * Math.cos(lat2) * sinDLon * sinDLon,
1661                c = 2 * Math.atan2(Math.sqrt(a), Math.sqrt(1 - a));
1662            return this.R * c;
1663        }
1664    });
1665  
1666    /*
1667     * @namespace Projection
1668     * @projection L.Projection.SphericalMercator
1669     *
1670     * Spherical Mercator projection — the most common projection for online maps,
1671     * used by almost all free and commercial tile providers. Assumes that Earth is
1672     * a sphere. Used by the `EPSG:3857` CRS.
1673     */
1674  
1675    var earthRadius = 6378137;
1676  
1677    var SphericalMercator = {
1678  
1679        R: earthRadius,
1680        MAX_LATITUDE: 85.0511287798,
1681  
1682        project: function (latlng) {
1683            var d = Math.PI / 180,
1684                max = this.MAX_LATITUDE,
1685                lat = Math.max(Math.min(max, latlng.lat), -max),
1686                sin = Math.sin(lat * d);
1687  
1688            return new Point(
1689                this.R * latlng.lng * d,
1690                this.R * Math.log((1 + sin) / (1 - sin)) / 2);
1691        },
1692  
1693        unproject: function (point) {
1694            var d = 180 / Math.PI;
1695  
1696            return new LatLng(
1697                (2 * Math.atan(Math.exp(point.y / this.R)) - (Math.PI / 2)) * d,
1698                point.x * d / this.R);
1699        },
1700  
1701        bounds: (function () {
1702            var d = earthRadius * Math.PI;
1703            return new Bounds([-d, -d], [d, d]);
1704        })()
1705    };
1706  
1707    /*
1708     * @class Transformation
1709     * @aka L.Transformation
1710     *
1711     * Represents an affine transformation: a set of coefficients `a`, `b`, `c`, `d`
1712     * for transforming a point of a form `(x, y)` into `(a*x + b, c*y + d)` and doing
1713     * the reverse. Used by Leaflet in its projections code.
1714     *
1715     * @example
1716     *
1717     * ```js
1718     * var transformation = L.transformation(2, 5, -1, 10),
1719     * 	p = L.point(1, 2),
1720     * 	p2 = transformation.transform(p), //  L.point(7, 8)
1721     * 	p3 = transformation.untransform(p2); //  L.point(1, 2)
1722     * ```
1723     */
1724  
1725  
1726    // factory new L.Transformation(a: Number, b: Number, c: Number, d: Number)
1727    // Creates a `Transformation` object with the given coefficients.
1728    function Transformation(a, b, c, d) {
1729        if (isArray(a)) {
1730            // use array properties
1731            this._a = a[0];
1732            this._b = a[1];
1733            this._c = a[2];
1734            this._d = a[3];
1735            return;
1736        }
1737        this._a = a;
1738        this._b = b;
1739        this._c = c;
1740        this._d = d;
1741    }
1742  
1743    Transformation.prototype = {
1744        // @method transform(point: Point, scale?: Number): Point
1745        // Returns a transformed point, optionally multiplied by the given scale.
1746        // Only accepts actual `L.Point` instances, not arrays.
1747        transform: function (point, scale) { // (Point, Number) -> Point
1748            return this._transform(point.clone(), scale);
1749        },
1750  
1751        // destructive transform (faster)
1752        _transform: function (point, scale) {
1753            scale = scale || 1;
1754            point.x = scale * (this._a * point.x + this._b);
1755            point.y = scale * (this._c * point.y + this._d);
1756            return point;
1757        },
1758  
1759        // @method untransform(point: Point, scale?: Number): Point
1760        // Returns the reverse transformation of the given point, optionally divided
1761        // by the given scale. Only accepts actual `L.Point` instances, not arrays.
1762        untransform: function (point, scale) {
1763            scale = scale || 1;
1764            return new Point(
1765                    (point.x / scale - this._b) / this._a,
1766                    (point.y / scale - this._d) / this._c);
1767        }
1768    };
1769  
1770    // factory L.transformation(a: Number, b: Number, c: Number, d: Number)
1771  
1772    // @factory L.transformation(a: Number, b: Number, c: Number, d: Number)
1773    // Instantiates a Transformation object with the given coefficients.
1774  
1775    // @alternative
1776    // @factory L.transformation(coefficients: Array): Transformation
1777    // Expects an coefficients array of the form
1778    // `[a: Number, b: Number, c: Number, d: Number]`.
1779  
1780    function toTransformation(a, b, c, d) {
1781        return new Transformation(a, b, c, d);
1782    }
1783  
1784    /*
1785     * @namespace CRS
1786     * @crs L.CRS.EPSG3857
1787     *
1788     * The most common CRS for online maps, used by almost all free and commercial
1789     * tile providers. Uses Spherical Mercator projection. Set in by default in
1790     * Map's `crs` option.
1791     */
1792  
1793    var EPSG3857 = extend({}, Earth, {
1794        code: 'EPSG:3857',
1795        projection: SphericalMercator,
1796  
1797        transformation: (function () {
1798            var scale = 0.5 / (Math.PI * SphericalMercator.R);
1799            return toTransformation(scale, 0.5, -scale, 0.5);
1800        }())
1801    });
1802  
1803    var EPSG900913 = extend({}, EPSG3857, {
1804        code: 'EPSG:900913'
1805    });
1806  
1807    // @namespace SVG; @section
1808    // There are several static functions which can be called without instantiating L.SVG:
1809  
1810    // @function create(name: String): SVGElement
1811    // Returns a instance of [SVGElement](https://developer.mozilla.org/docs/Web/API/SVGElement),
1812    // corresponding to the class name passed. For example, using 'line' will return
1813    // an instance of [SVGLineElement](https://developer.mozilla.org/docs/Web/API/SVGLineElement).
1814    function svgCreate(name) {
1815        return document.createElementNS('http://www.w3.org/2000/svg', name);
1816    }
1817  
1818    // @function pointsToPath(rings: Point[], closed: Boolean): String
1819    // Generates a SVG path string for multiple rings, with each ring turning
1820    // into "M..L..L.." instructions
1821    function pointsToPath(rings, closed) {
1822        var str = '',
1823        i, j, len, len2, points, p;
1824  
1825        for (i = 0, len = rings.length; i < len; i++) {
1826            points = rings[i];
1827  
1828            for (j = 0, len2 = points.length; j < len2; j++) {
1829                p = points[j];
1830                str += (j ? 'L' : 'M') + p.x + ' ' + p.y;
1831            }
1832  
1833            // closes the ring for polygons; "x" is VML syntax
1834            str += closed ? (Browser.svg ? 'z' : 'x') : '';
1835        }
1836  
1837        // SVG complains about empty path strings
1838        return str || 'M0 0';
1839    }
1840  
1841    /*
1842     * @namespace Browser
1843     * @aka L.Browser
1844     *
1845     * A namespace with static properties for browser/feature detection used by Leaflet internally.
1846     *
1847     * @example
1848     *
1849     * ```js
1850     * if (L.Browser.ielt9) {
1851     *   alert('Upgrade your browser, dude!');
1852     * }
1853     * ```
1854     */
1855  
1856    var style = document.documentElement.style;
1857  
1858    // @property ie: Boolean; `true` for all Internet Explorer versions (not Edge).
1859    var ie = 'ActiveXObject' in window;
1860  
1861    // @property ielt9: Boolean; `true` for Internet Explorer versions less than 9.
1862    var ielt9 = ie && !document.addEventListener;
1863  
1864    // @property edge: Boolean; `true` for the Edge web browser.
1865    var edge = 'msLaunchUri' in navigator && !('documentMode' in document);
1866  
1867    // @property webkit: Boolean;
1868    // `true` for webkit-based browsers like Chrome and Safari (including mobile versions).
1869    var webkit = userAgentContains('webkit');
1870  
1871    // @property android: Boolean
1872    // **Deprecated.** `true` for any browser running on an Android platform.
1873    var android = userAgentContains('android');
1874  
1875    // @property android23: Boolean; **Deprecated.** `true` for browsers running on Android 2 or Android 3.
1876    var android23 = userAgentContains('android 2') || userAgentContains('android 3');
1877  
1878    /* See https://stackoverflow.com/a/17961266 for details on detecting stock Android */
1879    var webkitVer = parseInt(/WebKit\/([0-9]+)|$/.exec(navigator.userAgent)[1], 10); // also matches AppleWebKit
1880    // @property androidStock: Boolean; **Deprecated.** `true` for the Android stock browser (i.e. not Chrome)
1881    var androidStock = android && userAgentContains('Google') && webkitVer < 537 && !('AudioNode' in window);
1882  
1883    // @property opera: Boolean; `true` for the Opera browser
1884    var opera = !!window.opera;
1885  
1886    // @property chrome: Boolean; `true` for the Chrome browser.
1887    var chrome = !edge && userAgentContains('chrome');
1888  
1889    // @property gecko: Boolean; `true` for gecko-based browsers like Firefox.
1890    var gecko = userAgentContains('gecko') && !webkit && !opera && !ie;
1891  
1892    // @property safari: Boolean; `true` for the Safari browser.
1893    var safari = !chrome && userAgentContains('safari');
1894  
1895    var phantom = userAgentContains('phantom');
1896  
1897    // @property opera12: Boolean
1898    // `true` for the Opera browser supporting CSS transforms (version 12 or later).
1899    var opera12 = 'OTransition' in style;
1900  
1901    // @property win: Boolean; `true` when the browser is running in a Windows platform
1902    var win = navigator.platform.indexOf('Win') === 0;
1903  
1904    // @property ie3d: Boolean; `true` for all Internet Explorer versions supporting CSS transforms.
1905    var ie3d = ie && ('transition' in style);
1906  
1907    // @property webkit3d: Boolean; `true` for webkit-based browsers supporting CSS transforms.
1908    var webkit3d = ('WebKitCSSMatrix' in window) && ('m11' in new window.WebKitCSSMatrix()) && !android23;
1909  
1910    // @property gecko3d: Boolean; `true` for gecko-based browsers supporting CSS transforms.
1911    var gecko3d = 'MozPerspective' in style;
1912  
1913    // @property any3d: Boolean
1914    // `true` for all browsers supporting CSS transforms.
1915    var any3d = !window.L_DISABLE_3D && (ie3d || webkit3d || gecko3d) && !opera12 && !phantom;
1916  
1917    // @property mobile: Boolean; `true` for all browsers running in a mobile device.
1918    var mobile = typeof orientation !== 'undefined' || userAgentContains('mobile');
1919  
1920    // @property mobileWebkit: Boolean; `true` for all webkit-based browsers in a mobile device.
1921    var mobileWebkit = mobile && webkit;
1922  
1923    // @property mobileWebkit3d: Boolean
1924    // `true` for all webkit-based browsers in a mobile device supporting CSS transforms.
1925    var mobileWebkit3d = mobile && webkit3d;
1926  
1927    // @property msPointer: Boolean
1928    // `true` for browsers implementing the Microsoft touch events model (notably IE10).
1929    var msPointer = !window.PointerEvent && window.MSPointerEvent;
1930  
1931    // @property pointer: Boolean
1932    // `true` for all browsers supporting [pointer events](https://msdn.microsoft.com/en-us/library/dn433244%28v=vs.85%29.aspx).
1933    var pointer = !!(window.PointerEvent || msPointer);
1934  
1935    // @property touchNative: Boolean
1936    // `true` for all browsers supporting [touch events](https://developer.mozilla.org/docs/Web/API/Touch_events).
1937    // **This does not necessarily mean** that the browser is running in a computer with
1938    // a touchscreen, it only means that the browser is capable of understanding
1939    // touch events.
1940    var touchNative = 'ontouchstart' in window || !!window.TouchEvent;
1941  
1942    // @property touch: Boolean
1943    // `true` for all browsers supporting either [touch](#browser-touch) or [pointer](#browser-pointer) events.
1944    // Note: pointer events will be preferred (if available), and processed for all `touch*` listeners.
1945    var touch = !window.L_NO_TOUCH && (touchNative || pointer);
1946  
1947    // @property mobileOpera: Boolean; `true` for the Opera browser in a mobile device.
1948    var mobileOpera = mobile && opera;
1949  
1950    // @property mobileGecko: Boolean
1951    // `true` for gecko-based browsers running in a mobile device.
1952    var mobileGecko = mobile && gecko;
1953  
1954    // @property retina: Boolean
1955    // `true` for browsers on a high-resolution "retina" screen or on any screen when browser's display zoom is more than 100%.
1956    var retina = (window.devicePixelRatio || (window.screen.deviceXDPI / window.screen.logicalXDPI)) > 1;
1957  
1958    // @property passiveEvents: Boolean
1959    // `true` for browsers that support passive events.
1960    var passiveEvents = (function () {
1961        var supportsPassiveOption = false;
1962        try {
1963            var opts = Object.defineProperty({}, 'passive', {
1964                get: function () { // eslint-disable-line getter-return
1965                    supportsPassiveOption = true;
1966                }
1967            });
1968            window.addEventListener('testPassiveEventSupport', falseFn, opts);
1969            window.removeEventListener('testPassiveEventSupport', falseFn, opts);
1970        } catch (e) {
1971            // Errors can safely be ignored since this is only a browser support test.
1972        }
1973        return supportsPassiveOption;
1974    }());
1975  
1976    // @property canvas: Boolean
1977    // `true` when the browser supports [`<canvas>`](https://developer.mozilla.org/docs/Web/API/Canvas_API).
1978    var canvas$1 = (function () {
1979        return !!document.createElement('canvas').getContext;
1980    }());
1981  
1982    // @property svg: Boolean
1983    // `true` when the browser supports [SVG](https://developer.mozilla.org/docs/Web/SVG).
1984    var svg$1 = !!(document.createElementNS && svgCreate('svg').createSVGRect);
1985  
1986    // @property vml: Boolean
1987    // `true` if the browser supports [VML](https://en.wikipedia.org/wiki/Vector_Markup_Language).
1988    var vml = !svg$1 && (function () {
1989        try {
1990            var div = document.createElement('div');
1991            div.innerHTML = '<v:shape adj="1"/>';
1992  
1993            var shape = div.firstChild;
1994            shape.style.behavior = 'url(#default#VML)';
1995  
1996            return shape && (typeof shape.adj === 'object');
1997  
1998        } catch (e) {
1999            return false;
2000        }
2001    }());
2002  
2003  
2004    function userAgentContains(str) {
2005        return navigator.userAgent.toLowerCase().indexOf(str) >= 0;
2006    }
2007  
2008  
2009    var Browser = {
2010        ie: ie,
2011        ielt9: ielt9,
2012        edge: edge,
2013        webkit: webkit,
2014        android: android,
2015        android23: android23,
2016        androidStock: androidStock,
2017        opera: opera,
2018        chrome: chrome,
2019        gecko: gecko,
2020        safari: safari,
2021        phantom: phantom,
2022        opera12: opera12,
2023        win: win,
2024        ie3d: ie3d,
2025        webkit3d: webkit3d,
2026        gecko3d: gecko3d,
2027        any3d: any3d,
2028        mobile: mobile,
2029        mobileWebkit: mobileWebkit,
2030        mobileWebkit3d: mobileWebkit3d,
2031        msPointer: msPointer,
2032        pointer: pointer,
2033        touch: touch,
2034        touchNative: touchNative,
2035        mobileOpera: mobileOpera,
2036        mobileGecko: mobileGecko,
2037        retina: retina,
2038        passiveEvents: passiveEvents,
2039        canvas: canvas$1,
2040        svg: svg$1,
2041        vml: vml,
2042    };
2043  
2044    /*
2045     * Extends L.DomEvent to provide touch support for Internet Explorer and Windows-based devices.
2046     */
2047  
2048    var POINTER_DOWN =   Browser.msPointer ? 'MSPointerDown'   : 'pointerdown';
2049    var POINTER_MOVE =   Browser.msPointer ? 'MSPointerMove'   : 'pointermove';
2050    var POINTER_UP =     Browser.msPointer ? 'MSPointerUp'     : 'pointerup';
2051    var POINTER_CANCEL = Browser.msPointer ? 'MSPointerCancel' : 'pointercancel';
2052    var pEvent = {
2053        touchstart  : POINTER_DOWN,
2054        touchmove   : POINTER_MOVE,
2055        touchend    : POINTER_UP,
2056        touchcancel : POINTER_CANCEL
2057    };
2058    var handle = {
2059        touchstart  : _onPointerStart,
2060        touchmove   : _handlePointer,
2061        touchend    : _handlePointer,
2062        touchcancel : _handlePointer
2063    };
2064    var _pointers = {};
2065    var _pointerDocListener = false;
2066  
2067    // Provides a touch events wrapper for (ms)pointer events.
2068    // ref https://www.w3.org/TR/pointerevents/ https://www.w3.org/Bugs/Public/show_bug.cgi?id=22890
2069  
2070    function addPointerListener(obj, type, handler) {
2071        if (type === 'touchstart') {
2072            _addPointerDocListener();
2073        }
2074        if (!handle[type]) {
2075            console.warn('wrong event specified:', type);
2076            return L.Util.falseFn;
2077        }
2078        handler = handle[type].bind(this, handler);
2079        obj.addEventListener(pEvent[type], handler, false);
2080        return handler;
2081    }
2082  
2083    function removePointerListener(obj, type, handler) {
2084        if (!pEvent[type]) {
2085            console.warn('wrong event specified:', type);
2086            return;
2087        }
2088        obj.removeEventListener(pEvent[type], handler, false);
2089    }
2090  
2091    function _globalPointerDown(e) {
2092        _pointers[e.pointerId] = e;
2093    }
2094  
2095    function _globalPointerMove(e) {
2096        if (_pointers[e.pointerId]) {
2097            _pointers[e.pointerId] = e;
2098        }
2099    }
2100  
2101    function _globalPointerUp(e) {
2102        delete _pointers[e.pointerId];
2103    }
2104  
2105    function _addPointerDocListener() {
2106        // need to keep track of what pointers and how many are active to provide e.touches emulation
2107        if (!_pointerDocListener) {
2108            // we listen document as any drags that end by moving the touch off the screen get fired there
2109            document.addEventListener(POINTER_DOWN, _globalPointerDown, true);
2110            document.addEventListener(POINTER_MOVE, _globalPointerMove, true);
2111            document.addEventListener(POINTER_UP, _globalPointerUp, true);
2112            document.addEventListener(POINTER_CANCEL, _globalPointerUp, true);
2113  
2114            _pointerDocListener = true;
2115        }
2116    }
2117  
2118    function _handlePointer(handler, e) {
2119        if (e.pointerType === (e.MSPOINTER_TYPE_MOUSE || 'mouse')) { return; }
2120  
2121        e.touches = [];
2122        for (var i in _pointers) {
2123            e.touches.push(_pointers[i]);
2124        }
2125        e.changedTouches = [e];
2126  
2127        handler(e);
2128    }
2129  
2130    function _onPointerStart(handler, e) {
2131        // IE10 specific: MsTouch needs preventDefault. See #2000
2132        if (e.MSPOINTER_TYPE_TOUCH && e.pointerType === e.MSPOINTER_TYPE_TOUCH) {
2133            preventDefault(e);
2134        }
2135        _handlePointer(handler, e);
2136    }
2137  
2138    /*
2139     * Extends the event handling code with double tap support for mobile browsers.
2140     *
2141     * Note: currently most browsers fire native dblclick, with only a few exceptions
2142     * (see https://github.com/Leaflet/Leaflet/issues/7012#issuecomment-595087386)
2143     */
2144  
2145    function makeDblclick(event) {
2146        // in modern browsers `type` cannot be just overridden:
2147        // https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Errors/Getter_only
2148        var newEvent = {},
2149            prop, i;
2150        for (i in event) {
2151            prop = event[i];
2152            newEvent[i] = prop && prop.bind ? prop.bind(event) : prop;
2153        }
2154        event = newEvent;
2155        newEvent.type = 'dblclick';
2156        newEvent.detail = 2;
2157        newEvent.isTrusted = false;
2158        newEvent._simulated = true; // for debug purposes
2159        return newEvent;
2160    }
2161  
2162    var delay = 200;
2163    function addDoubleTapListener(obj, handler) {
2164        // Most browsers handle double tap natively
2165        obj.addEventListener('dblclick', handler);
2166  
2167        // On some platforms the browser doesn't fire native dblclicks for touch events.
2168        // It seems that in all such cases `detail` property of `click` event is always `1`.
2169        // So here we rely on that fact to avoid excessive 'dblclick' simulation when not needed.
2170        var last = 0,
2171            detail;
2172        function simDblclick(e) {
2173            if (e.detail !== 1) {
2174                detail = e.detail; // keep in sync to avoid false dblclick in some cases
2175                return;
2176            }
2177  
2178            if (e.pointerType === 'mouse' ||
2179                (e.sourceCapabilities && !e.sourceCapabilities.firesTouchEvents)) {
2180  
2181                return;
2182            }
2183  
2184            var now = Date.now();
2185            if (now - last <= delay) {
2186                detail++;
2187                if (detail === 2) {
2188                    handler(makeDblclick(e));
2189                }
2190            } else {
2191                detail = 1;
2192            }
2193            last = now;
2194        }
2195  
2196        obj.addEventListener('click', simDblclick);
2197  
2198        return {
2199            dblclick: handler,
2200            simDblclick: simDblclick
2201        };
2202    }
2203  
2204    function removeDoubleTapListener(obj, handlers) {
2205        obj.removeEventListener('dblclick', handlers.dblclick);
2206        obj.removeEventListener('click', handlers.simDblclick);
2207    }
2208  
2209    /*
2210     * @namespace DomUtil
2211     *
2212     * Utility functions to work with the [DOM](https://developer.mozilla.org/docs/Web/API/Document_Object_Model)
2213     * tree, used by Leaflet internally.
2214     *
2215     * Most functions expecting or returning a `HTMLElement` also work for
2216     * SVG elements. The only difference is that classes refer to CSS classes
2217     * in HTML and SVG classes in SVG.
2218     */
2219  
2220  
2221    // @property TRANSFORM: String
2222    // Vendor-prefixed transform style name (e.g. `'webkitTransform'` for WebKit).
2223    var TRANSFORM = testProp(
2224        ['transform', 'webkitTransform', 'OTransform', 'MozTransform', 'msTransform']);
2225  
2226    // webkitTransition comes first because some browser versions that drop vendor prefix don't do
2227    // the same for the transitionend event, in particular the Android 4.1 stock browser
2228  
2229    // @property TRANSITION: String
2230    // Vendor-prefixed transition style name.
2231    var TRANSITION = testProp(
2232        ['webkitTransition', 'transition', 'OTransition', 'MozTransition', 'msTransition']);
2233  
2234    // @property TRANSITION_END: String
2235    // Vendor-prefixed transitionend event name.
2236    var TRANSITION_END =
2237        TRANSITION === 'webkitTransition' || TRANSITION === 'OTransition' ? TRANSITION + 'End' : 'transitionend';
2238  
2239  
2240    // @function get(id: String|HTMLElement): HTMLElement
2241    // Returns an element given its DOM id, or returns the element itself
2242    // if it was passed directly.
2243    function get(id) {
2244        return typeof id === 'string' ? document.getElementById(id) : id;
2245    }
2246  
2247    // @function getStyle(el: HTMLElement, styleAttrib: String): String
2248    // Returns the value for a certain style attribute on an element,
2249    // including computed values or values set through CSS.
2250    function getStyle(el, style) {
2251        var value = el.style[style] || (el.currentStyle && el.currentStyle[style]);
2252  
2253        if ((!value || value === 'auto') && document.defaultView) {
2254            var css = document.defaultView.getComputedStyle(el, null);
2255            value = css ? css[style] : null;
2256        }
2257        return value === 'auto' ? null : value;
2258    }
2259  
2260    // @function create(tagName: String, className?: String, container?: HTMLElement): HTMLElement
2261    // Creates an HTML element with `tagName`, sets its class to `className`, and optionally appends it to `container` element.
2262    function create$1(tagName, className, container) {
2263        var el = document.createElement(tagName);
2264        el.className = className || '';
2265  
2266        if (container) {
2267            container.appendChild(el);
2268        }
2269        return el;
2270    }
2271  
2272    // @function remove(el: HTMLElement)
2273    // Removes `el` from its parent element
2274    function remove(el) {
2275        var parent = el.parentNode;
2276        if (parent) {
2277            parent.removeChild(el);
2278        }
2279    }
2280  
2281    // @function empty(el: HTMLElement)
2282    // Removes all of `el`'s children elements from `el`
2283    function empty(el) {
2284        while (el.firstChild) {
2285            el.removeChild(el.firstChild);
2286        }
2287    }
2288  
2289    // @function toFront(el: HTMLElement)
2290    // Makes `el` the last child of its parent, so it renders in front of the other children.
2291    function toFront(el) {
2292        var parent = el.parentNode;
2293        if (parent && parent.lastChild !== el) {
2294            parent.appendChild(el);
2295        }
2296    }
2297  
2298    // @function toBack(el: HTMLElement)
2299    // Makes `el` the first child of its parent, so it renders behind the other children.
2300    function toBack(el) {
2301        var parent = el.parentNode;
2302        if (parent && parent.firstChild !== el) {
2303            parent.insertBefore(el, parent.firstChild);
2304        }
2305    }
2306  
2307    // @function hasClass(el: HTMLElement, name: String): Boolean
2308    // Returns `true` if the element's class attribute contains `name`.
2309    function hasClass(el, name) {
2310        if (el.classList !== undefined) {
2311            return el.classList.contains(name);
2312        }
2313        var className = getClass(el);
2314        return className.length > 0 && new RegExp('(^|\\s)' + name + '(\\s|$)').test(className);
2315    }
2316  
2317    // @function addClass(el: HTMLElement, name: String)
2318    // Adds `name` to the element's class attribute.
2319    function addClass(el, name) {
2320        if (el.classList !== undefined) {
2321            var classes = splitWords(name);
2322            for (var i = 0, len = classes.length; i < len; i++) {
2323                el.classList.add(classes[i]);
2324            }
2325        } else if (!hasClass(el, name)) {
2326            var className = getClass(el);
2327            setClass(el, (className ? className + ' ' : '') + name);
2328        }
2329    }
2330  
2331    // @function removeClass(el: HTMLElement, name: String)
2332    // Removes `name` from the element's class attribute.
2333    function removeClass(el, name) {
2334        if (el.classList !== undefined) {
2335            el.classList.remove(name);
2336        } else {
2337            setClass(el, trim((' ' + getClass(el) + ' ').replace(' ' + name + ' ', ' ')));
2338        }
2339    }
2340  
2341    // @function setClass(el: HTMLElement, name: String)
2342    // Sets the element's class.
2343    function setClass(el, name) {
2344        if (el.className.baseVal === undefined) {
2345            el.className = name;
2346        } else {
2347            // in case of SVG element
2348            el.className.baseVal = name;
2349        }
2350    }
2351  
2352    // @function getClass(el: HTMLElement): String
2353    // Returns the element's class.
2354    function getClass(el) {
2355        // Check if the element is an SVGElementInstance and use the correspondingElement instead
2356        // (Required for linked SVG elements in IE11.)
2357        if (el.correspondingElement) {
2358            el = el.correspondingElement;
2359        }
2360        return el.className.baseVal === undefined ? el.className : el.className.baseVal;
2361    }
2362  
2363    // @function setOpacity(el: HTMLElement, opacity: Number)
2364    // Set the opacity of an element (including old IE support).
2365    // `opacity` must be a number from `0` to `1`.
2366    function setOpacity(el, value) {
2367        if ('opacity' in el.style) {
2368            el.style.opacity = value;
2369        } else if ('filter' in el.style) {
2370            _setOpacityIE(el, value);
2371        }
2372    }
2373  
2374    function _setOpacityIE(el, value) {
2375        var filter = false,
2376            filterName = 'DXImageTransform.Microsoft.Alpha';
2377  
2378        // filters collection throws an error if we try to retrieve a filter that doesn't exist
2379        try {
2380            filter = el.filters.item(filterName);
2381        } catch (e) {
2382            // don't set opacity to 1 if we haven't already set an opacity,
2383            // it isn't needed and breaks transparent pngs.
2384            if (value === 1) { return; }
2385        }
2386  
2387        value = Math.round(value * 100);
2388  
2389        if (filter) {
2390            filter.Enabled = (value !== 100);
2391            filter.Opacity = value;
2392        } else {
2393            el.style.filter += ' progid:' + filterName + '(opacity=' + value + ')';
2394        }
2395    }
2396  
2397    // @function testProp(props: String[]): String|false
2398    // Goes through the array of style names and returns the first name
2399    // that is a valid style name for an element. If no such name is found,
2400    // it returns false. Useful for vendor-prefixed styles like `transform`.
2401    function testProp(props) {
2402        var style = document.documentElement.style;
2403  
2404        for (var i = 0; i < props.length; i++) {
2405            if (props[i] in style) {
2406                return props[i];
2407            }
2408        }
2409        return false;
2410    }
2411  
2412    // @function setTransform(el: HTMLElement, offset: Point, scale?: Number)
2413    // Resets the 3D CSS transform of `el` so it is translated by `offset` pixels
2414    // and optionally scaled by `scale`. Does not have an effect if the
2415    // browser doesn't support 3D CSS transforms.
2416    function setTransform(el, offset, scale) {
2417        var pos = offset || new Point(0, 0);
2418  
2419        el.style[TRANSFORM] =
2420            (Browser.ie3d ?
2421                'translate(' + pos.x + 'px,' + pos.y + 'px)' :
2422                'translate3d(' + pos.x + 'px,' + pos.y + 'px,0)') +
2423            (scale ? ' scale(' + scale + ')' : '');
2424    }
2425  
2426    // @function setPosition(el: HTMLElement, position: Point)
2427    // Sets the position of `el` to coordinates specified by `position`,
2428    // using CSS translate or top/left positioning depending on the browser
2429    // (used by Leaflet internally to position its layers).
2430    function setPosition(el, point) {
2431  
2432        /*eslint-disable */
2433        el._leaflet_pos = point;
2434        /* eslint-enable */
2435  
2436        if (Browser.any3d) {
2437            setTransform(el, point);
2438        } else {
2439            el.style.left = point.x + 'px';
2440            el.style.top = point.y + 'px';
2441        }
2442    }
2443  
2444    // @function getPosition(el: HTMLElement): Point
2445    // Returns the coordinates of an element previously positioned with setPosition.
2446    function getPosition(el) {
2447        // this method is only used for elements previously positioned using setPosition,
2448        // so it's safe to cache the position for performance
2449  
2450        return el._leaflet_pos || new Point(0, 0);
2451    }
2452  
2453    // @function disableTextSelection()
2454    // Prevents the user from generating `selectstart` DOM events, usually generated
2455    // when the user drags the mouse through a page with text. Used internally
2456    // by Leaflet to override the behaviour of any click-and-drag interaction on
2457    // the map. Affects drag interactions on the whole document.
2458  
2459    // @function enableTextSelection()
2460    // Cancels the effects of a previous [`L.DomUtil.disableTextSelection`](#domutil-disabletextselection).
2461    var disableTextSelection;
2462    var enableTextSelection;
2463    var _userSelect;
2464    if ('onselectstart' in document) {
2465        disableTextSelection = function () {
2466            on(window, 'selectstart', preventDefault);
2467        };
2468        enableTextSelection = function () {
2469            off(window, 'selectstart', preventDefault);
2470        };
2471    } else {
2472        var userSelectProperty = testProp(
2473            ['userSelect', 'WebkitUserSelect', 'OUserSelect', 'MozUserSelect', 'msUserSelect']);
2474  
2475        disableTextSelection = function () {
2476            if (userSelectProperty) {
2477                var style = document.documentElement.style;
2478                _userSelect = style[userSelectProperty];
2479                style[userSelectProperty] = 'none';
2480            }
2481        };
2482        enableTextSelection = function () {
2483            if (userSelectProperty) {
2484                document.documentElement.style[userSelectProperty] = _userSelect;
2485                _userSelect = undefined;
2486            }
2487        };
2488    }
2489  
2490    // @function disableImageDrag()
2491    // As [`L.DomUtil.disableTextSelection`](#domutil-disabletextselection), but
2492    // for `dragstart` DOM events, usually generated when the user drags an image.
2493    function disableImageDrag() {
2494        on(window, 'dragstart', preventDefault);
2495    }
2496  
2497    // @function enableImageDrag()
2498    // Cancels the effects of a previous [`L.DomUtil.disableImageDrag`](#domutil-disabletextselection).
2499    function enableImageDrag() {
2500        off(window, 'dragstart', preventDefault);
2501    }
2502  
2503    var _outlineElement, _outlineStyle;
2504    // @function preventOutline(el: HTMLElement)
2505    // Makes the [outline](https://developer.mozilla.org/docs/Web/CSS/outline)
2506    // of the element `el` invisible. Used internally by Leaflet to prevent
2507    // focusable elements from displaying an outline when the user performs a
2508    // drag interaction on them.
2509    function preventOutline(element) {
2510        while (element.tabIndex === -1) {
2511            element = element.parentNode;
2512        }
2513        if (!element.style) { return; }
2514        restoreOutline();
2515        _outlineElement = element;
2516        _outlineStyle = element.style.outline;
2517        element.style.outline = 'none';
2518        on(window, 'keydown', restoreOutline);
2519    }
2520  
2521    // @function restoreOutline()
2522    // Cancels the effects of a previous [`L.DomUtil.preventOutline`]().
2523    function restoreOutline() {
2524        if (!_outlineElement) { return; }
2525        _outlineElement.style.outline = _outlineStyle;
2526        _outlineElement = undefined;
2527        _outlineStyle = undefined;
2528        off(window, 'keydown', restoreOutline);
2529    }
2530  
2531    // @function getSizedParentNode(el: HTMLElement): HTMLElement
2532    // Finds the closest parent node which size (width and height) is not null.
2533    function getSizedParentNode(element) {
2534        do {
2535            element = element.parentNode;
2536        } while ((!element.offsetWidth || !element.offsetHeight) && element !== document.body);
2537        return element;
2538    }
2539  
2540    // @function getScale(el: HTMLElement): Object
2541    // Computes the CSS scale currently applied on the element.
2542    // Returns an object with `x` and `y` members as horizontal and vertical scales respectively,
2543    // and `boundingClientRect` as the result of [`getBoundingClientRect()`](https://developer.mozilla.org/en-US/docs/Web/API/Element/getBoundingClientRect).
2544    function getScale(element) {
2545        var rect = element.getBoundingClientRect(); // Read-only in old browsers.
2546  
2547        return {
2548            x: rect.width / element.offsetWidth || 1,
2549            y: rect.height / element.offsetHeight || 1,
2550            boundingClientRect: rect
2551        };
2552    }
2553  
2554    var DomUtil = {
2555      __proto__: null,
2556      TRANSFORM: TRANSFORM,
2557      TRANSITION: TRANSITION,
2558      TRANSITION_END: TRANSITION_END,
2559      get: get,
2560      getStyle: getStyle,
2561      create: create$1,
2562      remove: remove,
2563      empty: empty,
2564      toFront: toFront,
2565      toBack: toBack,
2566      hasClass: hasClass,
2567      addClass: addClass,
2568      removeClass: removeClass,
2569      setClass: setClass,
2570      getClass: getClass,
2571      setOpacity: setOpacity,
2572      testProp: testProp,
2573      setTransform: setTransform,
2574      setPosition: setPosition,
2575      getPosition: getPosition,
2576      get disableTextSelection () { return disableTextSelection; },
2577      get enableTextSelection () { return enableTextSelection; },
2578      disableImageDrag: disableImageDrag,
2579      enableImageDrag: enableImageDrag,
2580      preventOutline: preventOutline,
2581      restoreOutline: restoreOutline,
2582      getSizedParentNode: getSizedParentNode,
2583      getScale: getScale
2584    };
2585  
2586    /*
2587     * @namespace DomEvent
2588     * Utility functions to work with the [DOM events](https://developer.mozilla.org/docs/Web/API/Event), used by Leaflet internally.
2589     */
2590  
2591    // Inspired by John Resig, Dean Edwards and YUI addEvent implementations.
2592  
2593    // @function on(el: HTMLElement, types: String, fn: Function, context?: Object): this
2594    // Adds a listener function (`fn`) to a particular DOM event type of the
2595    // element `el`. You can optionally specify the context of the listener
2596    // (object the `this` keyword will point to). You can also pass several
2597    // space-separated types (e.g. `'click dblclick'`).
2598  
2599    // @alternative
2600    // @function on(el: HTMLElement, eventMap: Object, context?: Object): this
2601    // Adds a set of type/listener pairs, e.g. `{click: onClick, mousemove: onMouseMove}`
2602    function on(obj, types, fn, context) {
2603  
2604        if (types && typeof types === 'object') {
2605            for (var type in types) {
2606                addOne(obj, type, types[type], fn);
2607            }
2608        } else {
2609            types = splitWords(types);
2610  
2611            for (var i = 0, len = types.length; i < len; i++) {
2612                addOne(obj, types[i], fn, context);
2613            }
2614        }
2615  
2616        return this;
2617    }
2618  
2619    var eventsKey = '_leaflet_events';
2620  
2621    // @function off(el: HTMLElement, types: String, fn: Function, context?: Object): this
2622    // Removes a previously added listener function.
2623    // Note that if you passed a custom context to on, you must pass the same
2624    // context to `off` in order to remove the listener.
2625  
2626    // @alternative
2627    // @function off(el: HTMLElement, eventMap: Object, context?: Object): this
2628    // Removes a set of type/listener pairs, e.g. `{click: onClick, mousemove: onMouseMove}`
2629  
2630    // @alternative
2631    // @function off(el: HTMLElement, types: String): this
2632    // Removes all previously added listeners of given types.
2633  
2634    // @alternative
2635    // @function off(el: HTMLElement): this
2636    // Removes all previously added listeners from given HTMLElement
2637    function off(obj, types, fn, context) {
2638  
2639        if (arguments.length === 1) {
2640            batchRemove(obj);
2641            delete obj[eventsKey];
2642  
2643        } else if (types && typeof types === 'object') {
2644            for (var type in types) {
2645                removeOne(obj, type, types[type], fn);
2646            }
2647  
2648        } else {
2649            types = splitWords(types);
2650  
2651            if (arguments.length === 2) {
2652                batchRemove(obj, function (type) {
2653                    return indexOf(types, type) !== -1;
2654                });
2655            } else {
2656                for (var i = 0, len = types.length; i < len; i++) {
2657                    removeOne(obj, types[i], fn, context);
2658                }
2659            }
2660        }
2661  
2662        return this;
2663    }
2664  
2665    function batchRemove(obj, filterFn) {
2666        for (var id in obj[eventsKey]) {
2667            var type = id.split(/\d/)[0];
2668            if (!filterFn || filterFn(type)) {
2669                removeOne(obj, type, null, null, id);
2670            }
2671        }
2672    }
2673  
2674    var mouseSubst = {
2675        mouseenter: 'mouseover',
2676        mouseleave: 'mouseout',
2677        wheel: !('onwheel' in window) && 'mousewheel'
2678    };
2679  
2680    function addOne(obj, type, fn, context) {
2681        var id = type + stamp(fn) + (context ? '_' + stamp(context) : '');
2682  
2683        if (obj[eventsKey] && obj[eventsKey][id]) { return this; }
2684  
2685        var handler = function (e) {
2686            return fn.call(context || obj, e || window.event);
2687        };
2688  
2689        var originalHandler = handler;
2690  
2691        if (!Browser.touchNative && Browser.pointer && type.indexOf('touch') === 0) {
2692            // Needs DomEvent.Pointer.js
2693            handler = addPointerListener(obj, type, handler);
2694  
2695        } else if (Browser.touch && (type === 'dblclick')) {
2696            handler = addDoubleTapListener(obj, handler);
2697  
2698        } else if ('addEventListener' in obj) {
2699  
2700            if (type === 'touchstart' || type === 'touchmove' || type === 'wheel' ||  type === 'mousewheel') {
2701                obj.addEventListener(mouseSubst[type] || type, handler, Browser.passiveEvents ? {passive: false} : false);
2702  
2703            } else if (type === 'mouseenter' || type === 'mouseleave') {
2704                handler = function (e) {
2705                    e = e || window.event;
2706                    if (isExternalTarget(obj, e)) {
2707                        originalHandler(e);
2708                    }
2709                };
2710                obj.addEventListener(mouseSubst[type], handler, false);
2711  
2712            } else {
2713                obj.addEventListener(type, originalHandler, false);
2714            }
2715  
2716        } else {
2717            obj.attachEvent('on' + type, handler);
2718        }
2719  
2720        obj[eventsKey] = obj[eventsKey] || {};
2721        obj[eventsKey][id] = handler;
2722    }
2723  
2724    function removeOne(obj, type, fn, context, id) {
2725        id = id || type + stamp(fn) + (context ? '_' + stamp(context) : '');
2726        var handler = obj[eventsKey] && obj[eventsKey][id];
2727  
2728        if (!handler) { return this; }
2729  
2730        if (!Browser.touchNative && Browser.pointer && type.indexOf('touch') === 0) {
2731            removePointerListener(obj, type, handler);
2732  
2733        } else if (Browser.touch && (type === 'dblclick')) {
2734            removeDoubleTapListener(obj, handler);
2735  
2736        } else if ('removeEventListener' in obj) {
2737  
2738            obj.removeEventListener(mouseSubst[type] || type, handler, false);
2739  
2740        } else {
2741            obj.detachEvent('on' + type, handler);
2742        }
2743  
2744        obj[eventsKey][id] = null;
2745    }
2746  
2747    // @function stopPropagation(ev: DOMEvent): this
2748    // Stop the given event from propagation to parent elements. Used inside the listener functions:
2749    // ```js
2750    // L.DomEvent.on(div, 'click', function (ev) {
2751    // 	L.DomEvent.stopPropagation(ev);
2752    // });
2753    // ```
2754    function stopPropagation(e) {
2755  
2756        if (e.stopPropagation) {
2757            e.stopPropagation();
2758        } else if (e.originalEvent) {  // In case of Leaflet event.
2759            e.originalEvent._stopped = true;
2760        } else {
2761            e.cancelBubble = true;
2762        }
2763  
2764        return this;
2765    }
2766  
2767    // @function disableScrollPropagation(el: HTMLElement): this
2768    // Adds `stopPropagation` to the element's `'wheel'` events (plus browser variants).
2769    function disableScrollPropagation(el) {
2770        addOne(el, 'wheel', stopPropagation);
2771        return this;
2772    }
2773  
2774    // @function disableClickPropagation(el: HTMLElement): this
2775    // Adds `stopPropagation` to the element's `'click'`, `'dblclick'`, `'contextmenu'`,
2776    // `'mousedown'` and `'touchstart'` events (plus browser variants).
2777    function disableClickPropagation(el) {
2778        on(el, 'mousedown touchstart dblclick contextmenu', stopPropagation);
2779        el['_leaflet_disable_click'] = true;
2780        return this;
2781    }
2782  
2783    // @function preventDefault(ev: DOMEvent): this
2784    // Prevents the default action of the DOM Event `ev` from happening (such as
2785    // following a link in the href of the a element, or doing a POST request
2786    // with page reload when a `<form>` is submitted).
2787    // Use it inside listener functions.
2788    function preventDefault(e) {
2789        if (e.preventDefault) {
2790            e.preventDefault();
2791        } else {
2792            e.returnValue = false;
2793        }
2794        return this;
2795    }
2796  
2797    // @function stop(ev: DOMEvent): this
2798    // Does `stopPropagation` and `preventDefault` at the same time.
2799    function stop(e) {
2800        preventDefault(e);
2801        stopPropagation(e);
2802        return this;
2803    }
2804  
2805    // @function getMousePosition(ev: DOMEvent, container?: HTMLElement): Point
2806    // Gets normalized mouse position from a DOM event relative to the
2807    // `container` (border excluded) or to the whole page if not specified.
2808    function getMousePosition(e, container) {
2809        if (!container) {
2810            return new Point(e.clientX, e.clientY);
2811        }
2812  
2813        var scale = getScale(container),
2814            offset = scale.boundingClientRect; // left and top  values are in page scale (like the event clientX/Y)
2815  
2816        return new Point(
2817            // offset.left/top values are in page scale (like clientX/Y),
2818            // whereas clientLeft/Top (border width) values are the original values (before CSS scale applies).
2819            (e.clientX - offset.left) / scale.x - container.clientLeft,
2820            (e.clientY - offset.top) / scale.y - container.clientTop
2821        );
2822    }
2823  
2824    // Chrome on Win scrolls double the pixels as in other platforms (see #4538),
2825    // and Firefox scrolls device pixels, not CSS pixels
2826    var wheelPxFactor =
2827        (Browser.win && Browser.chrome) ? 2 * window.devicePixelRatio :
2828        Browser.gecko ? window.devicePixelRatio : 1;
2829  
2830    // @function getWheelDelta(ev: DOMEvent): Number
2831    // Gets normalized wheel delta from a wheel DOM event, in vertical
2832    // pixels scrolled (negative if scrolling down).
2833    // Events from pointing devices without precise scrolling are mapped to
2834    // a best guess of 60 pixels.
2835    function getWheelDelta(e) {
2836        return (Browser.edge) ? e.wheelDeltaY / 2 : // Don't trust window-geometry-based delta
2837               (e.deltaY && e.deltaMode === 0) ? -e.deltaY / wheelPxFactor : // Pixels
2838               (e.deltaY && e.deltaMode === 1) ? -e.deltaY * 20 : // Lines
2839               (e.deltaY && e.deltaMode === 2) ? -e.deltaY * 60 : // Pages
2840               (e.deltaX || e.deltaZ) ? 0 :	// Skip horizontal/depth wheel events
2841               e.wheelDelta ? (e.wheelDeltaY || e.wheelDelta) / 2 : // Legacy IE pixels
2842               (e.detail && Math.abs(e.detail) < 32765) ? -e.detail * 20 : // Legacy Moz lines
2843               e.detail ? e.detail / -32765 * 60 : // Legacy Moz pages
2844               0;
2845    }
2846  
2847    // check if element really left/entered the event target (for mouseenter/mouseleave)
2848    function isExternalTarget(el, e) {
2849  
2850        var related = e.relatedTarget;
2851  
2852        if (!related) { return true; }
2853  
2854        try {
2855            while (related && (related !== el)) {
2856                related = related.parentNode;
2857            }
2858        } catch (err) {
2859            return false;
2860        }
2861        return (related !== el);
2862    }
2863  
2864    var DomEvent = {
2865      __proto__: null,
2866      on: on,
2867      off: off,
2868      stopPropagation: stopPropagation,
2869      disableScrollPropagation: disableScrollPropagation,
2870      disableClickPropagation: disableClickPropagation,
2871      preventDefault: preventDefault,
2872      stop: stop,
2873      getMousePosition: getMousePosition,
2874      getWheelDelta: getWheelDelta,
2875      isExternalTarget: isExternalTarget,
2876      addListener: on,
2877      removeListener: off
2878    };
2879  
2880    /*
2881     * @class PosAnimation
2882     * @aka L.PosAnimation
2883     * @inherits Evented
2884     * Used internally for panning animations, utilizing CSS3 Transitions for modern browsers and a timer fallback for IE6-9.
2885     *
2886     * @example
2887     * ```js
2888     * var fx = new L.PosAnimation();
2889     * fx.run(el, [300, 500], 0.5);
2890     * ```
2891     *
2892     * @constructor L.PosAnimation()
2893     * Creates a `PosAnimation` object.
2894     *
2895     */
2896  
2897    var PosAnimation = Evented.extend({
2898  
2899        // @method run(el: HTMLElement, newPos: Point, duration?: Number, easeLinearity?: Number)
2900        // Run an animation of a given element to a new position, optionally setting
2901        // duration in seconds (`0.25` by default) and easing linearity factor (3rd
2902        // argument of the [cubic bezier curve](https://cubic-bezier.com/#0,0,.5,1),
2903        // `0.5` by default).
2904        run: function (el, newPos, duration, easeLinearity) {
2905            this.stop();
2906  
2907            this._el = el;
2908            this._inProgress = true;
2909            this._duration = duration || 0.25;
2910            this._easeOutPower = 1 / Math.max(easeLinearity || 0.5, 0.2);
2911  
2912            this._startPos = getPosition(el);
2913            this._offset = newPos.subtract(this._startPos);
2914            this._startTime = +new Date();
2915  
2916            // @event start: Event
2917            // Fired when the animation starts
2918            this.fire('start');
2919  
2920            this._animate();
2921        },
2922  
2923        // @method stop()
2924        // Stops the animation (if currently running).
2925        stop: function () {
2926            if (!this._inProgress) { return; }
2927  
2928            this._step(true);
2929            this._complete();
2930        },
2931  
2932        _animate: function () {
2933            // animation loop
2934            this._animId = requestAnimFrame(this._animate, this);
2935            this._step();
2936        },
2937  
2938        _step: function (round) {
2939            var elapsed = (+new Date()) - this._startTime,
2940                duration = this._duration * 1000;
2941  
2942            if (elapsed < duration) {
2943                this._runFrame(this._easeOut(elapsed / duration), round);
2944            } else {
2945                this._runFrame(1);
2946                this._complete();
2947            }
2948        },
2949  
2950        _runFrame: function (progress, round) {
2951            var pos = this._startPos.add(this._offset.multiplyBy(progress));
2952            if (round) {
2953                pos._round();
2954            }
2955            setPosition(this._el, pos);
2956  
2957            // @event step: Event
2958            // Fired continuously during the animation.
2959            this.fire('step');
2960        },
2961  
2962        _complete: function () {
2963            cancelAnimFrame(this._animId);
2964  
2965            this._inProgress = false;
2966            // @event end: Event
2967            // Fired when the animation ends.
2968            this.fire('end');
2969        },
2970  
2971        _easeOut: function (t) {
2972            return 1 - Math.pow(1 - t, this._easeOutPower);
2973        }
2974    });
2975  
2976    /*
2977     * @class Map
2978     * @aka L.Map
2979     * @inherits Evented
2980     *
2981     * The central class of the API — it is used to create a map on a page and manipulate it.
2982     *
2983     * @example
2984     *
2985     * ```js
2986     * // initialize the map on the "map" div with a given center and zoom
2987     * var map = L.map('map', {
2988     * 	center: [51.505, -0.09],
2989     * 	zoom: 13
2990     * });
2991     * ```
2992     *
2993     */
2994  
2995    var Map = Evented.extend({
2996  
2997        options: {
2998            // @section Map State Options
2999            // @option crs: CRS = L.CRS.EPSG3857
3000            // The [Coordinate Reference System](#crs) to use. Don't change this if you're not
3001            // sure what it means.
3002            crs: EPSG3857,
3003  
3004            // @option center: LatLng = undefined
3005            // Initial geographic center of the map
3006            center: undefined,
3007  
3008            // @option zoom: Number = undefined
3009            // Initial map zoom level
3010            zoom: undefined,
3011  
3012            // @option minZoom: Number = *
3013            // Minimum zoom level of the map.
3014            // If not specified and at least one `GridLayer` or `TileLayer` is in the map,
3015            // the lowest of their `minZoom` options will be used instead.
3016            minZoom: undefined,
3017  
3018            // @option maxZoom: Number = *
3019            // Maximum zoom level of the map.
3020            // If not specified and at least one `GridLayer` or `TileLayer` is in the map,
3021            // the highest of their `maxZoom` options will be used instead.
3022            maxZoom: undefined,
3023  
3024            // @option layers: Layer[] = []
3025            // Array of layers that will be added to the map initially
3026            layers: [],
3027  
3028            // @option maxBounds: LatLngBounds = null
3029            // When this option is set, the map restricts the view to the given
3030            // geographical bounds, bouncing the user back if the user tries to pan
3031            // outside the view. To set the restriction dynamically, use
3032            // [`setMaxBounds`](#map-setmaxbounds) method.
3033            maxBounds: undefined,
3034  
3035            // @option renderer: Renderer = *
3036            // The default method for drawing vector layers on the map. `L.SVG`
3037            // or `L.Canvas` by default depending on browser support.
3038            renderer: undefined,
3039  
3040  
3041            // @section Animation Options
3042            // @option zoomAnimation: Boolean = true
3043            // Whether the map zoom animation is enabled. By default it's enabled
3044            // in all browsers that support CSS3 Transitions except Android.
3045            zoomAnimation: true,
3046  
3047            // @option zoomAnimationThreshold: Number = 4
3048            // Won't animate zoom if the zoom difference exceeds this value.
3049            zoomAnimationThreshold: 4,
3050  
3051            // @option fadeAnimation: Boolean = true
3052            // Whether the tile fade animation is enabled. By default it's enabled
3053            // in all browsers that support CSS3 Transitions except Android.
3054            fadeAnimation: true,
3055  
3056            // @option markerZoomAnimation: Boolean = true
3057            // Whether markers animate their zoom with the zoom animation, if disabled
3058            // they will disappear for the length of the animation. By default it's
3059            // enabled in all browsers that support CSS3 Transitions except Android.
3060            markerZoomAnimation: true,
3061  
3062            // @option transform3DLimit: Number = 2^23
3063            // Defines the maximum size of a CSS translation transform. The default
3064            // value should not be changed unless a web browser positions layers in
3065            // the wrong place after doing a large `panBy`.
3066            transform3DLimit: 8388608, // Precision limit of a 32-bit float
3067  
3068            // @section Interaction Options
3069            // @option zoomSnap: Number = 1
3070            // Forces the map's zoom level to always be a multiple of this, particularly
3071            // right after a [`fitBounds()`](#map-fitbounds) or a pinch-zoom.
3072            // By default, the zoom level snaps to the nearest integer; lower values
3073            // (e.g. `0.5` or `0.1`) allow for greater granularity. A value of `0`
3074            // means the zoom level will not be snapped after `fitBounds` or a pinch-zoom.
3075            zoomSnap: 1,
3076  
3077            // @option zoomDelta: Number = 1
3078            // Controls how much the map's zoom level will change after a
3079            // [`zoomIn()`](#map-zoomin), [`zoomOut()`](#map-zoomout), pressing `+`
3080            // or `-` on the keyboard, or using the [zoom controls](#control-zoom).
3081            // Values smaller than `1` (e.g. `0.5`) allow for greater granularity.
3082            zoomDelta: 1,
3083  
3084            // @option trackResize: Boolean = true
3085            // Whether the map automatically handles browser window resize to update itself.
3086            trackResize: true
3087        },
3088  
3089        initialize: function (id, options) { // (HTMLElement or String, Object)
3090            options = setOptions(this, options);
3091  
3092            // Make sure to assign internal flags at the beginning,
3093            // to avoid inconsistent state in some edge cases.
3094            this._handlers = [];
3095            this._layers = {};
3096            this._zoomBoundLayers = {};
3097            this._sizeChanged = true;
3098  
3099            this._initContainer(id);
3100            this._initLayout();
3101  
3102            // hack for https://github.com/Leaflet/Leaflet/issues/1980
3103            this._onResize = bind(this._onResize, this);
3104  
3105            this._initEvents();
3106  
3107            if (options.maxBounds) {
3108                this.setMaxBounds(options.maxBounds);
3109            }
3110  
3111            if (options.zoom !== undefined) {
3112                this._zoom = this._limitZoom(options.zoom);
3113            }
3114  
3115            if (options.center && options.zoom !== undefined) {
3116                this.setView(toLatLng(options.center), options.zoom, {reset: true});
3117            }
3118  
3119            this.callInitHooks();
3120  
3121            // don't animate on browsers without hardware-accelerated transitions or old Android/Opera
3122            this._zoomAnimated = TRANSITION && Browser.any3d && !Browser.mobileOpera &&
3123                    this.options.zoomAnimation;
3124  
3125            // zoom transitions run with the same duration for all layers, so if one of transitionend events
3126            // happens after starting zoom animation (propagating to the map pane), we know that it ended globally
3127            if (this._zoomAnimated) {
3128                this._createAnimProxy();
3129                on(this._proxy, TRANSITION_END, this._catchTransitionEnd, this);
3130            }
3131  
3132            this._addLayers(this.options.layers);
3133        },
3134  
3135  
3136        // @section Methods for modifying map state
3137  
3138        // @method setView(center: LatLng, zoom: Number, options?: Zoom/pan options): this
3139        // Sets the view of the map (geographical center and zoom) with the given
3140        // animation options.
3141        setView: function (center, zoom, options) {
3142  
3143            zoom = zoom === undefined ? this._zoom : this._limitZoom(zoom);
3144            center = this._limitCenter(toLatLng(center), zoom, this.options.maxBounds);
3145            options = options || {};
3146  
3147            this._stop();
3148  
3149            if (this._loaded && !options.reset && options !== true) {
3150  
3151                if (options.animate !== undefined) {
3152                    options.zoom = extend({animate: options.animate}, options.zoom);
3153                    options.pan = extend({animate: options.animate, duration: options.duration}, options.pan);
3154                }
3155  
3156                // try animating pan or zoom
3157                var moved = (this._zoom !== zoom) ?
3158                    this._tryAnimatedZoom && this._tryAnimatedZoom(center, zoom, options.zoom) :
3159                    this._tryAnimatedPan(center, options.pan);
3160  
3161                if (moved) {
3162                    // prevent resize handler call, the view will refresh after animation anyway
3163                    clearTimeout(this._sizeTimer);
3164                    return this;
3165                }
3166            }
3167  
3168            // animation didn't start, just reset the map view
3169            this._resetView(center, zoom);
3170  
3171            return this;
3172        },
3173  
3174        // @method setZoom(zoom: Number, options?: Zoom/pan options): this
3175        // Sets the zoom of the map.
3176        setZoom: function (zoom, options) {
3177            if (!this._loaded) {
3178                this._zoom = zoom;
3179                return this;
3180            }
3181            return this.setView(this.getCenter(), zoom, {zoom: options});
3182        },
3183  
3184        // @method zoomIn(delta?: Number, options?: Zoom options): this
3185        // Increases the zoom of the map by `delta` ([`zoomDelta`](#map-zoomdelta) by default).
3186        zoomIn: function (delta, options) {
3187            delta = delta || (Browser.any3d ? this.options.zoomDelta : 1);
3188            return this.setZoom(this._zoom + delta, options);
3189        },
3190  
3191        // @method zoomOut(delta?: Number, options?: Zoom options): this
3192        // Decreases the zoom of the map by `delta` ([`zoomDelta`](#map-zoomdelta) by default).
3193        zoomOut: function (delta, options) {
3194            delta = delta || (Browser.any3d ? this.options.zoomDelta : 1);
3195            return this.setZoom(this._zoom - delta, options);
3196        },
3197  
3198        // @method setZoomAround(latlng: LatLng, zoom: Number, options: Zoom options): this
3199        // Zooms the map while keeping a specified geographical point on the map
3200        // stationary (e.g. used internally for scroll zoom and double-click zoom).
3201        // @alternative
3202        // @method setZoomAround(offset: Point, zoom: Number, options: Zoom options): this
3203        // Zooms the map while keeping a specified pixel on the map (relative to the top-left corner) stationary.
3204        setZoomAround: function (latlng, zoom, options) {
3205            var scale = this.getZoomScale(zoom),
3206                viewHalf = this.getSize().divideBy(2),
3207                containerPoint = latlng instanceof Point ? latlng : this.latLngToContainerPoint(latlng),
3208  
3209                centerOffset = containerPoint.subtract(viewHalf).multiplyBy(1 - 1 / scale),
3210                newCenter = this.containerPointToLatLng(viewHalf.add(centerOffset));
3211  
3212            return this.setView(newCenter, zoom, {zoom: options});
3213        },
3214  
3215        _getBoundsCenterZoom: function (bounds, options) {
3216  
3217            options = options || {};
3218            bounds = bounds.getBounds ? bounds.getBounds() : toLatLngBounds(bounds);
3219  
3220            var paddingTL = toPoint(options.paddingTopLeft || options.padding || [0, 0]),
3221                paddingBR = toPoint(options.paddingBottomRight || options.padding || [0, 0]),
3222  
3223                zoom = this.getBoundsZoom(bounds, false, paddingTL.add(paddingBR));
3224  
3225            zoom = (typeof options.maxZoom === 'number') ? Math.min(options.maxZoom, zoom) : zoom;
3226  
3227            if (zoom === Infinity) {
3228                return {
3229                    center: bounds.getCenter(),
3230                    zoom: zoom
3231                };
3232            }
3233  
3234            var paddingOffset = paddingBR.subtract(paddingTL).divideBy(2),
3235  
3236                swPoint = this.project(bounds.getSouthWest(), zoom),
3237                nePoint = this.project(bounds.getNorthEast(), zoom),
3238                center = this.unproject(swPoint.add(nePoint).divideBy(2).add(paddingOffset), zoom);
3239  
3240            return {
3241                center: center,
3242                zoom: zoom
3243            };
3244        },
3245  
3246        // @method fitBounds(bounds: LatLngBounds, options?: fitBounds options): this
3247        // Sets a map view that contains the given geographical bounds with the
3248        // maximum zoom level possible.
3249        fitBounds: function (bounds, options) {
3250  
3251            bounds = toLatLngBounds(bounds);
3252  
3253            if (!bounds.isValid()) {
3254                throw new Error('Bounds are not valid.');
3255            }
3256  
3257            var target = this._getBoundsCenterZoom(bounds, options);
3258            return this.setView(target.center, target.zoom, options);
3259        },
3260  
3261        // @method fitWorld(options?: fitBounds options): this
3262        // Sets a map view that mostly contains the whole world with the maximum
3263        // zoom level possible.
3264        fitWorld: function (options) {
3265            return this.fitBounds([[-90, -180], [90, 180]], options);
3266        },
3267  
3268        // @method panTo(latlng: LatLng, options?: Pan options): this
3269        // Pans the map to a given center.
3270        panTo: function (center, options) { // (LatLng)
3271            return this.setView(center, this._zoom, {pan: options});
3272        },
3273  
3274        // @method panBy(offset: Point, options?: Pan options): this
3275        // Pans the map by a given number of pixels (animated).
3276        panBy: function (offset, options) {
3277            offset = toPoint(offset).round();
3278            options = options || {};
3279  
3280            if (!offset.x && !offset.y) {
3281                return this.fire('moveend');
3282            }
3283            // If we pan too far, Chrome gets issues with tiles
3284            // and makes them disappear or appear in the wrong place (slightly offset) #2602
3285            if (options.animate !== true && !this.getSize().contains(offset)) {
3286                this._resetView(this.unproject(this.project(this.getCenter()).add(offset)), this.getZoom());
3287                return this;
3288            }
3289  
3290            if (!this._panAnim) {
3291                this._panAnim = new PosAnimation();
3292  
3293                this._panAnim.on({
3294                    'step': this._onPanTransitionStep,
3295                    'end': this._onPanTransitionEnd
3296                }, this);
3297            }
3298  
3299            // don't fire movestart if animating inertia
3300            if (!options.noMoveStart) {
3301                this.fire('movestart');
3302            }
3303  
3304            // animate pan unless animate: false specified
3305            if (options.animate !== false) {
3306                addClass(this._mapPane, 'leaflet-pan-anim');
3307  
3308                var newPos = this._getMapPanePos().subtract(offset).round();
3309                this._panAnim.run(this._mapPane, newPos, options.duration || 0.25, options.easeLinearity);
3310            } else {
3311                this._rawPanBy(offset);
3312                this.fire('move').fire('moveend');
3313            }
3314  
3315            return this;
3316        },
3317  
3318        // @method flyTo(latlng: LatLng, zoom?: Number, options?: Zoom/pan options): this
3319        // Sets the view of the map (geographical center and zoom) performing a smooth
3320        // pan-zoom animation.
3321        flyTo: function (targetCenter, targetZoom, options) {
3322  
3323            options = options || {};
3324            if (options.animate === false || !Browser.any3d) {
3325                return this.setView(targetCenter, targetZoom, options);
3326            }
3327  
3328            this._stop();
3329  
3330            var from = this.project(this.getCenter()),
3331                to = this.project(targetCenter),
3332                size = this.getSize(),
3333                startZoom = this._zoom;
3334  
3335            targetCenter = toLatLng(targetCenter);
3336            targetZoom = targetZoom === undefined ? startZoom : targetZoom;
3337  
3338            var w0 = Math.max(size.x, size.y),
3339                w1 = w0 * this.getZoomScale(startZoom, targetZoom),
3340                u1 = (to.distanceTo(from)) || 1,
3341                rho = 1.42,
3342                rho2 = rho * rho;
3343  
3344            function r(i) {
3345                var s1 = i ? -1 : 1,
3346                    s2 = i ? w1 : w0,
3347                    t1 = w1 * w1 - w0 * w0 + s1 * rho2 * rho2 * u1 * u1,
3348                    b1 = 2 * s2 * rho2 * u1,
3349                    b = t1 / b1,
3350                    sq = Math.sqrt(b * b + 1) - b;
3351  
3352                    // workaround for floating point precision bug when sq = 0, log = -Infinite,
3353                    // thus triggering an infinite loop in flyTo
3354                    var log = sq < 0.000000001 ? -18 : Math.log(sq);
3355  
3356                return log;
3357            }
3358  
3359            function sinh(n) { return (Math.exp(n) - Math.exp(-n)) / 2; }
3360            function cosh(n) { return (Math.exp(n) + Math.exp(-n)) / 2; }
3361            function tanh(n) { return sinh(n) / cosh(n); }
3362  
3363            var r0 = r(0);
3364  
3365            function w(s) { return w0 * (cosh(r0) / cosh(r0 + rho * s)); }
3366            function u(s) { return w0 * (cosh(r0) * tanh(r0 + rho * s) - sinh(r0)) / rho2; }
3367  
3368            function easeOut(t) { return 1 - Math.pow(1 - t, 1.5); }
3369  
3370            var start = Date.now(),
3371                S = (r(1) - r0) / rho,
3372                duration = options.duration ? 1000 * options.duration : 1000 * S * 0.8;
3373  
3374            function frame() {
3375                var t = (Date.now() - start) / duration,
3376                    s = easeOut(t) * S;
3377  
3378                if (t <= 1) {
3379                    this._flyToFrame = requestAnimFrame(frame, this);
3380  
3381                    this._move(
3382                        this.unproject(from.add(to.subtract(from).multiplyBy(u(s) / u1)), startZoom),
3383                        this.getScaleZoom(w0 / w(s), startZoom),
3384                        {flyTo: true});
3385  
3386                } else {
3387                    this
3388                        ._move(targetCenter, targetZoom)
3389                        ._moveEnd(true);
3390                }
3391            }
3392  
3393            this._moveStart(true, options.noMoveStart);
3394  
3395            frame.call(this);
3396            return this;
3397        },
3398  
3399        // @method flyToBounds(bounds: LatLngBounds, options?: fitBounds options): this
3400        // Sets the view of the map with a smooth animation like [`flyTo`](#map-flyto),
3401        // but takes a bounds parameter like [`fitBounds`](#map-fitbounds).
3402        flyToBounds: function (bounds, options) {
3403            var target = this._getBoundsCenterZoom(bounds, options);
3404            return this.flyTo(target.center, target.zoom, options);
3405        },
3406  
3407        // @method setMaxBounds(bounds: LatLngBounds): this
3408        // Restricts the map view to the given bounds (see the [maxBounds](#map-maxbounds) option).
3409        setMaxBounds: function (bounds) {
3410            bounds = toLatLngBounds(bounds);
3411  
3412            if (!bounds.isValid()) {
3413                this.options.maxBounds = null;
3414                return this.off('moveend', this._panInsideMaxBounds);
3415            } else if (this.options.maxBounds) {
3416                this.off('moveend', this._panInsideMaxBounds);
3417            }
3418  
3419            this.options.maxBounds = bounds;
3420  
3421            if (this._loaded) {
3422                this._panInsideMaxBounds();
3423            }
3424  
3425            return this.on('moveend', this._panInsideMaxBounds);
3426        },
3427  
3428        // @method setMinZoom(zoom: Number): this
3429        // Sets the lower limit for the available zoom levels (see the [minZoom](#map-minzoom) option).
3430        setMinZoom: function (zoom) {
3431            var oldZoom = this.options.minZoom;
3432            this.options.minZoom = zoom;
3433  
3434            if (this._loaded && oldZoom !== zoom) {
3435                this.fire('zoomlevelschange');
3436  
3437                if (this.getZoom() < this.options.minZoom) {
3438                    return this.setZoom(zoom);
3439                }
3440            }
3441  
3442            return this;
3443        },
3444  
3445        // @method setMaxZoom(zoom: Number): this
3446        // Sets the upper limit for the available zoom levels (see the [maxZoom](#map-maxzoom) option).
3447        setMaxZoom: function (zoom) {
3448            var oldZoom = this.options.maxZoom;
3449            this.options.maxZoom = zoom;
3450  
3451            if (this._loaded && oldZoom !== zoom) {
3452                this.fire('zoomlevelschange');
3453  
3454                if (this.getZoom() > this.options.maxZoom) {
3455                    return this.setZoom(zoom);
3456                }
3457            }
3458  
3459            return this;
3460        },
3461  
3462        // @method panInsideBounds(bounds: LatLngBounds, options?: Pan options): this
3463        // 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.
3464        panInsideBounds: function (bounds, options) {
3465            this._enforcingBounds = true;
3466            var center = this.getCenter(),
3467                newCenter = this._limitCenter(center, this._zoom, toLatLngBounds(bounds));
3468  
3469            if (!center.equals(newCenter)) {
3470                this.panTo(newCenter, options);
3471            }
3472  
3473            this._enforcingBounds = false;
3474            return this;
3475        },
3476  
3477        // @method panInside(latlng: LatLng, options?: padding options): this
3478        // Pans the map the minimum amount to make the `latlng` visible. Use
3479        // padding options to fit the display to more restricted bounds.
3480        // If `latlng` is already within the (optionally padded) display bounds,
3481        // the map will not be panned.
3482        panInside: function (latlng, options) {
3483            options = options || {};
3484  
3485            var paddingTL = toPoint(options.paddingTopLeft || options.padding || [0, 0]),
3486                paddingBR = toPoint(options.paddingBottomRight || options.padding || [0, 0]),
3487                pixelCenter = this.project(this.getCenter()),
3488                pixelPoint = this.project(latlng),
3489                pixelBounds = this.getPixelBounds(),
3490                paddedBounds = toBounds([pixelBounds.min.add(paddingTL), pixelBounds.max.subtract(paddingBR)]),
3491                paddedSize = paddedBounds.getSize();
3492  
3493            if (!paddedBounds.contains(pixelPoint)) {
3494                this._enforcingBounds = true;
3495                var centerOffset = pixelPoint.subtract(paddedBounds.getCenter());
3496                var offset = paddedBounds.extend(pixelPoint).getSize().subtract(paddedSize);
3497                pixelCenter.x += centerOffset.x < 0 ? -offset.x : offset.x;
3498                pixelCenter.y += centerOffset.y < 0 ? -offset.y : offset.y;
3499                this.panTo(this.unproject(pixelCenter), options);
3500                this._enforcingBounds = false;
3501            }
3502            return this;
3503        },
3504  
3505        // @method invalidateSize(options: Zoom/pan options): this
3506        // Checks if the map container size changed and updates the map if so —
3507        // call it after you've changed the map size dynamically, also animating
3508        // pan by default. If `options.pan` is `false`, panning will not occur.
3509        // If `options.debounceMoveend` is `true`, it will delay `moveend` event so
3510        // that it doesn't happen often even if the method is called many
3511        // times in a row.
3512  
3513        // @alternative
3514        // @method invalidateSize(animate: Boolean): this
3515        // Checks if the map container size changed and updates the map if so —
3516        // call it after you've changed the map size dynamically, also animating
3517        // pan by default.
3518        invalidateSize: function (options) {
3519            if (!this._loaded) { return this; }
3520  
3521            options = extend({
3522                animate: false,
3523                pan: true
3524            }, options === true ? {animate: true} : options);
3525  
3526            var oldSize = this.getSize();
3527            this._sizeChanged = true;
3528            this._lastCenter = null;
3529  
3530            var newSize = this.getSize(),
3531                oldCenter = oldSize.divideBy(2).round(),
3532                newCenter = newSize.divideBy(2).round(),
3533                offset = oldCenter.subtract(newCenter);
3534  
3535            if (!offset.x && !offset.y) { return this; }
3536  
3537            if (options.animate && options.pan) {
3538                this.panBy(offset);
3539  
3540            } else {
3541                if (options.pan) {
3542                    this._rawPanBy(offset);
3543                }
3544  
3545                this.fire('move');
3546  
3547                if (options.debounceMoveend) {
3548                    clearTimeout(this._sizeTimer);
3549                    this._sizeTimer = setTimeout(bind(this.fire, this, 'moveend'), 200);
3550                } else {
3551                    this.fire('moveend');
3552                }
3553            }
3554  
3555            // @section Map state change events
3556            // @event resize: ResizeEvent
3557            // Fired when the map is resized.
3558            return this.fire('resize', {
3559                oldSize: oldSize,
3560                newSize: newSize
3561            });
3562        },
3563  
3564        // @section Methods for modifying map state
3565        // @method stop(): this
3566        // Stops the currently running `panTo` or `flyTo` animation, if any.
3567        stop: function () {
3568            this.setZoom(this._limitZoom(this._zoom));
3569            if (!this.options.zoomSnap) {
3570                this.fire('viewreset');
3571            }
3572            return this._stop();
3573        },
3574  
3575        // @section Geolocation methods
3576        // @method locate(options?: Locate options): this
3577        // Tries to locate the user using the Geolocation API, firing a [`locationfound`](#map-locationfound)
3578        // event with location data on success or a [`locationerror`](#map-locationerror) event on failure,
3579        // and optionally sets the map view to the user's location with respect to
3580        // detection accuracy (or to the world view if geolocation failed).
3581        // Note that, if your page doesn't use HTTPS, this method will fail in
3582        // modern browsers ([Chrome 50 and newer](https://sites.google.com/a/chromium.org/dev/Home/chromium-security/deprecating-powerful-features-on-insecure-origins))
3583        // See `Locate options` for more details.
3584        locate: function (options) {
3585  
3586            options = this._locateOptions = extend({
3587                timeout: 10000,
3588                watch: false
3589                // setView: false
3590                // maxZoom: <Number>
3591                // maximumAge: 0
3592                // enableHighAccuracy: false
3593            }, options);
3594  
3595            if (!('geolocation' in navigator)) {
3596                this._handleGeolocationError({
3597                    code: 0,
3598                    message: 'Geolocation not supported.'
3599                });
3600                return this;
3601            }
3602  
3603            var onResponse = bind(this._handleGeolocationResponse, this),
3604                onError = bind(this._handleGeolocationError, this);
3605  
3606            if (options.watch) {
3607                this._locationWatchId =
3608                        navigator.geolocation.watchPosition(onResponse, onError, options);
3609            } else {
3610                navigator.geolocation.getCurrentPosition(onResponse, onError, options);
3611            }
3612            return this;
3613        },
3614  
3615        // @method stopLocate(): this
3616        // Stops watching location previously initiated by `map.locate({watch: true})`
3617        // and aborts resetting the map view if map.locate was called with
3618        // `{setView: true}`.
3619        stopLocate: function () {
3620            if (navigator.geolocation && navigator.geolocation.clearWatch) {
3621                navigator.geolocation.clearWatch(this._locationWatchId);
3622            }
3623            if (this._locateOptions) {
3624                this._locateOptions.setView = false;
3625            }
3626            return this;
3627        },
3628  
3629        _handleGeolocationError: function (error) {
3630            if (!this._container._leaflet_id) { return; }
3631  
3632            var c = error.code,
3633                message = error.message ||
3634                        (c === 1 ? 'permission denied' :
3635                        (c === 2 ? 'position unavailable' : 'timeout'));
3636  
3637            if (this._locateOptions.setView && !this._loaded) {
3638                this.fitWorld();
3639            }
3640  
3641            // @section Location events
3642            // @event locationerror: ErrorEvent
3643            // Fired when geolocation (using the [`locate`](#map-locate) method) failed.
3644            this.fire('locationerror', {
3645                code: c,
3646                message: 'Geolocation error: ' + message + '.'
3647            });
3648        },
3649  
3650        _handleGeolocationResponse: function (pos) {
3651            if (!this._container._leaflet_id) { return; }
3652  
3653            var lat = pos.coords.latitude,
3654                lng = pos.coords.longitude,
3655                latlng = new LatLng(lat, lng),
3656                bounds = latlng.toBounds(pos.coords.accuracy * 2),
3657                options = this._locateOptions;
3658  
3659            if (options.setView) {
3660                var zoom = this.getBoundsZoom(bounds);
3661                this.setView(latlng, options.maxZoom ? Math.min(zoom, options.maxZoom) : zoom);
3662            }
3663  
3664            var data = {
3665                latlng: latlng,
3666                bounds: bounds,
3667                timestamp: pos.timestamp
3668            };
3669  
3670            for (var i in pos.coords) {
3671                if (typeof pos.coords[i] === 'number') {
3672                    data[i] = pos.coords[i];
3673                }
3674            }
3675  
3676            // @event locationfound: LocationEvent
3677            // Fired when geolocation (using the [`locate`](#map-locate) method)
3678            // went successfully.
3679            this.fire('locationfound', data);
3680        },
3681  
3682        // TODO Appropriate docs section?
3683        // @section Other Methods
3684        // @method addHandler(name: String, HandlerClass: Function): this
3685        // Adds a new `Handler` to the map, given its name and constructor function.
3686        addHandler: function (name, HandlerClass) {
3687            if (!HandlerClass) { return this; }
3688  
3689            var handler = this[name] = new HandlerClass(this);
3690  
3691            this._handlers.push(handler);
3692  
3693            if (this.options[name]) {
3694                handler.enable();
3695            }
3696  
3697            return this;
3698        },
3699  
3700        // @method remove(): this
3701        // Destroys the map and clears all related event listeners.
3702        remove: function () {
3703  
3704            this._initEvents(true);
3705            if (this.options.maxBounds) { this.off('moveend', this._panInsideMaxBounds); }
3706  
3707            if (this._containerId !== this._container._leaflet_id) {
3708                throw new Error('Map container is being reused by another instance');
3709            }
3710  
3711            try {
3712                // throws error in IE6-8
3713                delete this._container._leaflet_id;
3714                delete this._containerId;
3715            } catch (e) {
3716                /*eslint-disable */
3717                this._container._leaflet_id = undefined;
3718                /* eslint-enable */
3719                this._containerId = undefined;
3720            }
3721  
3722            if (this._locationWatchId !== undefined) {
3723                this.stopLocate();
3724            }
3725  
3726            this._stop();
3727  
3728            remove(this._mapPane);
3729  
3730            if (this._clearControlPos) {
3731                this._clearControlPos();
3732            }
3733            if (this._resizeRequest) {
3734                cancelAnimFrame(this._resizeRequest);
3735                this._resizeRequest = null;
3736            }
3737  
3738            this._clearHandlers();
3739  
3740            if (this._loaded) {
3741                // @section Map state change events
3742                // @event unload: Event
3743                // Fired when the map is destroyed with [remove](#map-remove) method.
3744                this.fire('unload');
3745            }
3746  
3747            var i;
3748            for (i in this._layers) {
3749                this._layers[i].remove();
3750            }
3751            for (i in this._panes) {
3752                remove(this._panes[i]);
3753            }
3754  
3755            this._layers = [];
3756            this._panes = [];
3757            delete this._mapPane;
3758            delete this._renderer;
3759  
3760            return this;
3761        },
3762  
3763        // @section Other Methods
3764        // @method createPane(name: String, container?: HTMLElement): HTMLElement
3765        // Creates a new [map pane](#map-pane) with the given name if it doesn't exist already,
3766        // then returns it. The pane is created as a child of `container`, or
3767        // as a child of the main map pane if not set.
3768        createPane: function (name, container) {
3769            var className = 'leaflet-pane' + (name ? ' leaflet-' + name.replace('Pane', '') + '-pane' : ''),
3770                pane = create$1('div', className, container || this._mapPane);
3771  
3772            if (name) {
3773                this._panes[name] = pane;
3774            }
3775            return pane;
3776        },
3777  
3778        // @section Methods for Getting Map State
3779  
3780        // @method getCenter(): LatLng
3781        // Returns the geographical center of the map view
3782        getCenter: function () {
3783            this._checkIfLoaded();
3784  
3785            if (this._lastCenter && !this._moved()) {
3786                return this._lastCenter;
3787            }
3788            return this.layerPointToLatLng(this._getCenterLayerPoint());
3789        },
3790  
3791        // @method getZoom(): Number
3792        // Returns the current zoom level of the map view
3793        getZoom: function () {
3794            return this._zoom;
3795        },
3796  
3797        // @method getBounds(): LatLngBounds
3798        // Returns the geographical bounds visible in the current map view
3799        getBounds: function () {
3800            var bounds = this.getPixelBounds(),
3801                sw = this.unproject(bounds.getBottomLeft()),
3802                ne = this.unproject(bounds.getTopRight());
3803  
3804            return new LatLngBounds(sw, ne);
3805        },
3806  
3807        // @method getMinZoom(): Number
3808        // 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.
3809        getMinZoom: function () {
3810            return this.options.minZoom === undefined ? this._layersMinZoom || 0 : this.options.minZoom;
3811        },
3812  
3813        // @method getMaxZoom(): Number
3814        // Returns the maximum zoom level of the map (if set in the `maxZoom` option of the map or of any layers).
3815        getMaxZoom: function () {
3816            return this.options.maxZoom === undefined ?
3817                (this._layersMaxZoom === undefined ? Infinity : this._layersMaxZoom) :
3818                this.options.maxZoom;
3819        },
3820  
3821        // @method getBoundsZoom(bounds: LatLngBounds, inside?: Boolean, padding?: Point): Number
3822        // Returns the maximum zoom level on which the given bounds fit to the map
3823        // view in its entirety. If `inside` (optional) is set to `true`, the method
3824        // instead returns the minimum zoom level on which the map view fits into
3825        // the given bounds in its entirety.
3826        getBoundsZoom: function (bounds, inside, padding) { // (LatLngBounds[, Boolean, Point]) -> Number
3827            bounds = toLatLngBounds(bounds);
3828            padding = toPoint(padding || [0, 0]);
3829  
3830            var zoom = this.getZoom() || 0,
3831                min = this.getMinZoom(),
3832                max = this.getMaxZoom(),
3833                nw = bounds.getNorthWest(),
3834                se = bounds.getSouthEast(),
3835                size = this.getSize().subtract(padding),
3836                boundsSize = toBounds(this.project(se, zoom), this.project(nw, zoom)).getSize(),
3837                snap = Browser.any3d ? this.options.zoomSnap : 1,
3838                scalex = size.x / boundsSize.x,
3839                scaley = size.y / boundsSize.y,
3840                scale = inside ? Math.max(scalex, scaley) : Math.min(scalex, scaley);
3841  
3842            zoom = this.getScaleZoom(scale, zoom);
3843  
3844            if (snap) {
3845                zoom = Math.round(zoom / (snap / 100)) * (snap / 100); // don't jump if within 1% of a snap level
3846                zoom = inside ? Math.ceil(zoom / snap) * snap : Math.floor(zoom / snap) * snap;
3847            }
3848  
3849            return Math.max(min, Math.min(max, zoom));
3850        },
3851  
3852        // @method getSize(): Point
3853        // Returns the current size of the map container (in pixels).
3854        getSize: function () {
3855            if (!this._size || this._sizeChanged) {
3856                this._size = new Point(
3857                    this._container.clientWidth || 0,
3858                    this._container.clientHeight || 0);
3859  
3860                this._sizeChanged = false;
3861            }
3862            return this._size.clone();
3863        },
3864  
3865        // @method getPixelBounds(): Bounds
3866        // Returns the bounds of the current map view in projected pixel
3867        // coordinates (sometimes useful in layer and overlay implementations).
3868        getPixelBounds: function (center, zoom) {
3869            var topLeftPoint = this._getTopLeftPoint(center, zoom);
3870            return new Bounds(topLeftPoint, topLeftPoint.add(this.getSize()));
3871        },
3872  
3873        // TODO: Check semantics - isn't the pixel origin the 0,0 coord relative to
3874        // the map pane? "left point of the map layer" can be confusing, specially
3875        // since there can be negative offsets.
3876        // @method getPixelOrigin(): Point
3877        // Returns the projected pixel coordinates of the top left point of
3878        // the map layer (useful in custom layer and overlay implementations).
3879        getPixelOrigin: function () {
3880            this._checkIfLoaded();
3881            return this._pixelOrigin;
3882        },
3883  
3884        // @method getPixelWorldBounds(zoom?: Number): Bounds
3885        // Returns the world's bounds in pixel coordinates for zoom level `zoom`.
3886        // If `zoom` is omitted, the map's current zoom level is used.
3887        getPixelWorldBounds: function (zoom) {
3888            return this.options.crs.getProjectedBounds(zoom === undefined ? this.getZoom() : zoom);
3889        },
3890  
3891        // @section Other Methods
3892  
3893        // @method getPane(pane: String|HTMLElement): HTMLElement
3894        // Returns a [map pane](#map-pane), given its name or its HTML element (its identity).
3895        getPane: function (pane) {
3896            return typeof pane === 'string' ? this._panes[pane] : pane;
3897        },
3898  
3899        // @method getPanes(): Object
3900        // Returns a plain object containing the names of all [panes](#map-pane) as keys and
3901        // the panes as values.
3902        getPanes: function () {
3903            return this._panes;
3904        },
3905  
3906        // @method getContainer: HTMLElement
3907        // Returns the HTML element that contains the map.
3908        getContainer: function () {
3909            return this._container;
3910        },
3911  
3912  
3913        // @section Conversion Methods
3914  
3915        // @method getZoomScale(toZoom: Number, fromZoom: Number): Number
3916        // Returns the scale factor to be applied to a map transition from zoom level
3917        // `fromZoom` to `toZoom`. Used internally to help with zoom animations.
3918        getZoomScale: function (toZoom, fromZoom) {
3919            // TODO replace with universal implementation after refactoring projections
3920            var crs = this.options.crs;
3921            fromZoom = fromZoom === undefined ? this._zoom : fromZoom;
3922            return crs.scale(toZoom) / crs.scale(fromZoom);
3923        },
3924  
3925        // @method getScaleZoom(scale: Number, fromZoom: Number): Number
3926        // Returns the zoom level that the map would end up at, if it is at `fromZoom`
3927        // level and everything is scaled by a factor of `scale`. Inverse of
3928        // [`getZoomScale`](#map-getZoomScale).
3929        getScaleZoom: function (scale, fromZoom) {
3930            var crs = this.options.crs;
3931            fromZoom = fromZoom === undefined ? this._zoom : fromZoom;
3932            var zoom = crs.zoom(scale * crs.scale(fromZoom));
3933            return isNaN(zoom) ? Infinity : zoom;
3934        },
3935  
3936        // @method project(latlng: LatLng, zoom: Number): Point
3937        // Projects a geographical coordinate `LatLng` according to the projection
3938        // of the map's CRS, then scales it according to `zoom` and the CRS's
3939        // `Transformation`. The result is pixel coordinate relative to
3940        // the CRS origin.
3941        project: function (latlng, zoom) {
3942            zoom = zoom === undefined ? this._zoom : zoom;
3943            return this.options.crs.latLngToPoint(toLatLng(latlng), zoom);
3944        },
3945  
3946        // @method unproject(point: Point, zoom: Number): LatLng
3947        // Inverse of [`project`](#map-project).
3948        unproject: function (point, zoom) {
3949            zoom = zoom === undefined ? this._zoom : zoom;
3950            return this.options.crs.pointToLatLng(toPoint(point), zoom);
3951        },
3952  
3953        // @method layerPointToLatLng(point: Point): LatLng
3954        // Given a pixel coordinate relative to the [origin pixel](#map-getpixelorigin),
3955        // returns the corresponding geographical coordinate (for the current zoom level).
3956        layerPointToLatLng: function (point) {
3957            var projectedPoint = toPoint(point).add(this.getPixelOrigin());
3958            return this.unproject(projectedPoint);
3959        },
3960  
3961        // @method latLngToLayerPoint(latlng: LatLng): Point
3962        // Given a geographical coordinate, returns the corresponding pixel coordinate
3963        // relative to the [origin pixel](#map-getpixelorigin).
3964        latLngToLayerPoint: function (latlng) {
3965            var projectedPoint = this.project(toLatLng(latlng))._round();
3966            return projectedPoint._subtract(this.getPixelOrigin());
3967        },
3968  
3969        // @method wrapLatLng(latlng: LatLng): LatLng
3970        // Returns a `LatLng` where `lat` and `lng` has been wrapped according to the
3971        // map's CRS's `wrapLat` and `wrapLng` properties, if they are outside the
3972        // CRS's bounds.
3973        // By default this means longitude is wrapped around the dateline so its
3974        // value is between -180 and +180 degrees.
3975        wrapLatLng: function (latlng) {
3976            return this.options.crs.wrapLatLng(toLatLng(latlng));
3977        },
3978  
3979        // @method wrapLatLngBounds(bounds: LatLngBounds): LatLngBounds
3980        // Returns a `LatLngBounds` with the same size as the given one, ensuring that
3981        // its center is within the CRS's bounds.
3982        // By default this means the center longitude is wrapped around the dateline so its
3983        // value is between -180 and +180 degrees, and the majority of the bounds
3984        // overlaps the CRS's bounds.
3985        wrapLatLngBounds: function (latlng) {
3986            return this.options.crs.wrapLatLngBounds(toLatLngBounds(latlng));
3987        },
3988  
3989        // @method distance(latlng1: LatLng, latlng2: LatLng): Number
3990        // Returns the distance between two geographical coordinates according to
3991        // the map's CRS. By default this measures distance in meters.
3992        distance: function (latlng1, latlng2) {
3993            return this.options.crs.distance(toLatLng(latlng1), toLatLng(latlng2));
3994        },
3995  
3996        // @method containerPointToLayerPoint(point: Point): Point
3997        // Given a pixel coordinate relative to the map container, returns the corresponding
3998        // pixel coordinate relative to the [origin pixel](#map-getpixelorigin).
3999        containerPointToLayerPoint: function (point) { // (Point)
4000            return toPoint(point).subtract(this._getMapPanePos());
4001        },
4002  
4003        // @method layerPointToContainerPoint(point: Point): Point
4004        // Given a pixel coordinate relative to the [origin pixel](#map-getpixelorigin),
4005        // returns the corresponding pixel coordinate relative to the map container.
4006        layerPointToContainerPoint: function (point) { // (Point)
4007            return toPoint(point).add(this._getMapPanePos());
4008        },
4009  
4010        // @method containerPointToLatLng(point: Point): LatLng
4011        // Given a pixel coordinate relative to the map container, returns
4012        // the corresponding geographical coordinate (for the current zoom level).
4013        containerPointToLatLng: function (point) {
4014            var layerPoint = this.containerPointToLayerPoint(toPoint(point));
4015            return this.layerPointToLatLng(layerPoint);
4016        },
4017  
4018        // @method latLngToContainerPoint(latlng: LatLng): Point
4019        // Given a geographical coordinate, returns the corresponding pixel coordinate
4020        // relative to the map container.
4021        latLngToContainerPoint: function (latlng) {
4022            return this.layerPointToContainerPoint(this.latLngToLayerPoint(toLatLng(latlng)));
4023        },
4024  
4025        // @method mouseEventToContainerPoint(ev: MouseEvent): Point
4026        // Given a MouseEvent object, returns the pixel coordinate relative to the
4027        // map container where the event took place.
4028        mouseEventToContainerPoint: function (e) {
4029            return getMousePosition(e, this._container);
4030        },
4031  
4032        // @method mouseEventToLayerPoint(ev: MouseEvent): Point
4033        // Given a MouseEvent object, returns the pixel coordinate relative to
4034        // the [origin pixel](#map-getpixelorigin) where the event took place.
4035        mouseEventToLayerPoint: function (e) {
4036            return this.containerPointToLayerPoint(this.mouseEventToContainerPoint(e));
4037        },
4038  
4039        // @method mouseEventToLatLng(ev: MouseEvent): LatLng
4040        // Given a MouseEvent object, returns geographical coordinate where the
4041        // event took place.
4042        mouseEventToLatLng: function (e) { // (MouseEvent)
4043            return this.layerPointToLatLng(this.mouseEventToLayerPoint(e));
4044        },
4045  
4046  
4047        // map initialization methods
4048  
4049        _initContainer: function (id) {
4050            var container = this._container = get(id);
4051  
4052            if (!container) {
4053                throw new Error('Map container not found.');
4054            } else if (container._leaflet_id) {
4055                throw new Error('Map container is already initialized.');
4056            }
4057  
4058            on(container, 'scroll', this._onScroll, this);
4059            this._containerId = stamp(container);
4060        },
4061  
4062        _initLayout: function () {
4063            var container = this._container;
4064  
4065            this._fadeAnimated = this.options.fadeAnimation && Browser.any3d;
4066  
4067            addClass(container, 'leaflet-container' +
4068                (Browser.touch ? ' leaflet-touch' : '') +
4069                (Browser.retina ? ' leaflet-retina' : '') +
4070                (Browser.ielt9 ? ' leaflet-oldie' : '') +
4071                (Browser.safari ? ' leaflet-safari' : '') +
4072                (this._fadeAnimated ? ' leaflet-fade-anim' : ''));
4073  
4074            var position = getStyle(container, 'position');
4075  
4076            if (position !== 'absolute' && position !== 'relative' && position !== 'fixed') {
4077                container.style.position = 'relative';
4078            }
4079  
4080            this._initPanes();
4081  
4082            if (this._initControlPos) {
4083                this._initControlPos();
4084            }
4085        },
4086  
4087        _initPanes: function () {
4088            var panes = this._panes = {};
4089            this._paneRenderers = {};
4090  
4091            // @section
4092            //
4093            // Panes are DOM elements used to control the ordering of layers on the map. You
4094            // can access panes with [`map.getPane`](#map-getpane) or
4095            // [`map.getPanes`](#map-getpanes) methods. New panes can be created with the
4096            // [`map.createPane`](#map-createpane) method.
4097            //
4098            // Every map has the following default panes that differ only in zIndex.
4099            //
4100            // @pane mapPane: HTMLElement = 'auto'
4101            // Pane that contains all other map panes
4102  
4103            this._mapPane = this.createPane('mapPane', this._container);
4104            setPosition(this._mapPane, new Point(0, 0));
4105  
4106            // @pane tilePane: HTMLElement = 200
4107            // Pane for `GridLayer`s and `TileLayer`s
4108            this.createPane('tilePane');
4109            // @pane overlayPane: HTMLElement = 400
4110            // Pane for vectors (`Path`s, like `Polyline`s and `Polygon`s), `ImageOverlay`s and `VideoOverlay`s
4111            this.createPane('overlayPane');
4112            // @pane shadowPane: HTMLElement = 500
4113            // Pane for overlay shadows (e.g. `Marker` shadows)
4114            this.createPane('shadowPane');
4115            // @pane markerPane: HTMLElement = 600
4116            // Pane for `Icon`s of `Marker`s
4117            this.createPane('markerPane');
4118            // @pane tooltipPane: HTMLElement = 650
4119            // Pane for `Tooltip`s.
4120            this.createPane('tooltipPane');
4121            // @pane popupPane: HTMLElement = 700
4122            // Pane for `Popup`s.
4123            this.createPane('popupPane');
4124  
4125            if (!this.options.markerZoomAnimation) {
4126                addClass(panes.markerPane, 'leaflet-zoom-hide');
4127                addClass(panes.shadowPane, 'leaflet-zoom-hide');
4128            }
4129        },
4130  
4131  
4132        // private methods that modify map state
4133  
4134        // @section Map state change events
4135        _resetView: function (center, zoom) {
4136            setPosition(this._mapPane, new Point(0, 0));
4137  
4138            var loading = !this._loaded;
4139            this._loaded = true;
4140            zoom = this._limitZoom(zoom);
4141  
4142            this.fire('viewprereset');
4143  
4144            var zoomChanged = this._zoom !== zoom;
4145            this
4146                ._moveStart(zoomChanged, false)
4147                ._move(center, zoom)
4148                ._moveEnd(zoomChanged);
4149  
4150            // @event viewreset: Event
4151            // Fired when the map needs to redraw its content (this usually happens
4152            // on map zoom or load). Very useful for creating custom overlays.
4153            this.fire('viewreset');
4154  
4155            // @event load: Event
4156            // Fired when the map is initialized (when its center and zoom are set
4157            // for the first time).
4158            if (loading) {
4159                this.fire('load');
4160            }
4161        },
4162  
4163        _moveStart: function (zoomChanged, noMoveStart) {
4164            // @event zoomstart: Event
4165            // Fired when the map zoom is about to change (e.g. before zoom animation).
4166            // @event movestart: Event
4167            // Fired when the view of the map starts changing (e.g. user starts dragging the map).
4168            if (zoomChanged) {
4169                this.fire('zoomstart');
4170            }
4171            if (!noMoveStart) {
4172                this.fire('movestart');
4173            }
4174            return this;
4175        },
4176  
4177        _move: function (center, zoom, data, supressEvent) {
4178            if (zoom === undefined) {
4179                zoom = this._zoom;
4180            }
4181            var zoomChanged = this._zoom !== zoom;
4182  
4183            this._zoom = zoom;
4184            this._lastCenter = center;
4185            this._pixelOrigin = this._getNewPixelOrigin(center);
4186  
4187            if (!supressEvent) {
4188                // @event zoom: Event
4189                // Fired repeatedly during any change in zoom level,
4190                // including zoom and fly animations.
4191                if (zoomChanged || (data && data.pinch)) {	// Always fire 'zoom' if pinching because #3530
4192                    this.fire('zoom', data);
4193                }
4194  
4195                // @event move: Event
4196                // Fired repeatedly during any movement of the map,
4197                // including pan and fly animations.
4198                this.fire('move', data);
4199            } else if (data && data.pinch) {	// Always fire 'zoom' if pinching because #3530
4200                this.fire('zoom', data);
4201            }
4202            return this;
4203        },
4204  
4205        _moveEnd: function (zoomChanged) {
4206            // @event zoomend: Event
4207            // Fired when the map zoom changed, after any animations.
4208            if (zoomChanged) {
4209                this.fire('zoomend');
4210            }
4211  
4212            // @event moveend: Event
4213            // Fired when the center of the map stops changing
4214            // (e.g. user stopped dragging the map or after non-centered zoom).
4215            return this.fire('moveend');
4216        },
4217  
4218        _stop: function () {
4219            cancelAnimFrame(this._flyToFrame);
4220            if (this._panAnim) {
4221                this._panAnim.stop();
4222            }
4223            return this;
4224        },
4225  
4226        _rawPanBy: function (offset) {
4227            setPosition(this._mapPane, this._getMapPanePos().subtract(offset));
4228        },
4229  
4230        _getZoomSpan: function () {
4231            return this.getMaxZoom() - this.getMinZoom();
4232        },
4233  
4234        _panInsideMaxBounds: function () {
4235            if (!this._enforcingBounds) {
4236                this.panInsideBounds(this.options.maxBounds);
4237            }
4238        },
4239  
4240        _checkIfLoaded: function () {
4241            if (!this._loaded) {
4242                throw new Error('Set map center and zoom first.');
4243            }
4244        },
4245  
4246        // DOM event handling
4247  
4248        // @section Interaction events
4249        _initEvents: function (remove) {
4250            this._targets = {};
4251            this._targets[stamp(this._container)] = this;
4252  
4253            var onOff = remove ? off : on;
4254  
4255            // @event click: MouseEvent
4256            // Fired when the user clicks (or taps) the map.
4257            // @event dblclick: MouseEvent
4258            // Fired when the user double-clicks (or double-taps) the map.
4259            // @event mousedown: MouseEvent
4260            // Fired when the user pushes the mouse button on the map.
4261            // @event mouseup: MouseEvent
4262            // Fired when the user releases the mouse button on the map.
4263            // @event mouseover: MouseEvent
4264            // Fired when the mouse enters the map.
4265            // @event mouseout: MouseEvent
4266            // Fired when the mouse leaves the map.
4267            // @event mousemove: MouseEvent
4268            // Fired while the mouse moves over the map.
4269            // @event contextmenu: MouseEvent
4270            // Fired when the user pushes the right mouse button on the map, prevents
4271            // default browser context menu from showing if there are listeners on
4272            // this event. Also fired on mobile when the user holds a single touch
4273            // for a second (also called long press).
4274            // @event keypress: KeyboardEvent
4275            // Fired when the user presses a key from the keyboard that produces a character value while the map is focused.
4276            // @event keydown: KeyboardEvent
4277            // Fired when the user presses a key from the keyboard while the map is focused. Unlike the `keypress` event,
4278            // the `keydown` event is fired for keys that produce a character value and for keys
4279            // that do not produce a character value.
4280            // @event keyup: KeyboardEvent
4281            // Fired when the user releases a key from the keyboard while the map is focused.
4282            onOff(this._container, 'click dblclick mousedown mouseup ' +
4283                'mouseover mouseout mousemove contextmenu keypress keydown keyup', this._handleDOMEvent, this);
4284  
4285            if (this.options.trackResize) {
4286                onOff(window, 'resize', this._onResize, this);
4287            }
4288  
4289            if (Browser.any3d && this.options.transform3DLimit) {
4290                (remove ? this.off : this.on).call(this, 'moveend', this._onMoveEnd);
4291            }
4292        },
4293  
4294        _onResize: function () {
4295            cancelAnimFrame(this._resizeRequest);
4296            this._resizeRequest = requestAnimFrame(
4297                    function () { this.invalidateSize({debounceMoveend: true}); }, this);
4298        },
4299  
4300        _onScroll: function () {
4301            this._container.scrollTop  = 0;
4302            this._container.scrollLeft = 0;
4303        },
4304  
4305        _onMoveEnd: function () {
4306            var pos = this._getMapPanePos();
4307            if (Math.max(Math.abs(pos.x), Math.abs(pos.y)) >= this.options.transform3DLimit) {
4308                // https://bugzilla.mozilla.org/show_bug.cgi?id=1203873 but Webkit also have
4309                // a pixel offset on very high values, see: https://jsfiddle.net/dg6r5hhb/
4310                this._resetView(this.getCenter(), this.getZoom());
4311            }
4312        },
4313  
4314        _findEventTargets: function (e, type) {
4315            var targets = [],
4316                target,
4317                isHover = type === 'mouseout' || type === 'mouseover',
4318                src = e.target || e.srcElement,
4319                dragging = false;
4320  
4321            while (src) {
4322                target = this._targets[stamp(src)];
4323                if (target && (type === 'click' || type === 'preclick') && this._draggableMoved(target)) {
4324                    // Prevent firing click after you just dragged an object.
4325                    dragging = true;
4326                    break;
4327                }
4328                if (target && target.listens(type, true)) {
4329                    if (isHover && !isExternalTarget(src, e)) { break; }
4330                    targets.push(target);
4331                    if (isHover) { break; }
4332                }
4333                if (src === this._container) { break; }
4334                src = src.parentNode;
4335            }
4336            if (!targets.length && !dragging && !isHover && this.listens(type, true)) {
4337                targets = [this];
4338            }
4339            return targets;
4340        },
4341  
4342        _isClickDisabled: function (el) {
4343            while (el !== this._container) {
4344                if (el['_leaflet_disable_click']) { return true; }
4345                el = el.parentNode;
4346            }
4347        },
4348  
4349        _handleDOMEvent: function (e) {
4350            var el = (e.target || e.srcElement);
4351            if (!this._loaded || el['_leaflet_disable_events'] || e.type === 'click' && this._isClickDisabled(el)) {
4352                return;
4353            }
4354  
4355            var type = e.type;
4356  
4357            if (type === 'mousedown') {
4358                // prevents outline when clicking on keyboard-focusable element
4359                preventOutline(el);
4360            }
4361  
4362            this._fireDOMEvent(e, type);
4363        },
4364  
4365        _mouseEvents: ['click', 'dblclick', 'mouseover', 'mouseout', 'contextmenu'],
4366  
4367        _fireDOMEvent: function (e, type, canvasTargets) {
4368  
4369            if (e.type === 'click') {
4370                // Fire a synthetic 'preclick' event which propagates up (mainly for closing popups).
4371                // @event preclick: MouseEvent
4372                // Fired before mouse click on the map (sometimes useful when you
4373                // want something to happen on click before any existing click
4374                // handlers start running).
4375                var synth = extend({}, e);
4376                synth.type = 'preclick';
4377                this._fireDOMEvent(synth, synth.type, canvasTargets);
4378            }
4379  
4380            // Find the layer the event is propagating from and its parents.
4381            var targets = this._findEventTargets(e, type);
4382  
4383            if (canvasTargets) {
4384                var filtered = []; // pick only targets with listeners
4385                for (var i = 0; i < canvasTargets.length; i++) {
4386                    if (canvasTargets[i].listens(type, true)) {
4387                        filtered.push(canvasTargets[i]);
4388                    }
4389                }
4390                targets = filtered.concat(targets);
4391            }
4392  
4393            if (!targets.length) { return; }
4394  
4395            if (type === 'contextmenu') {
4396                preventDefault(e);
4397            }
4398  
4399            var target = targets[0];
4400            var data = {
4401                originalEvent: e
4402            };
4403  
4404            if (e.type !== 'keypress' && e.type !== 'keydown' && e.type !== 'keyup') {
4405                var isMarker = target.getLatLng && (!target._radius || target._radius <= 10);
4406                data.containerPoint = isMarker ?
4407                    this.latLngToContainerPoint(target.getLatLng()) : this.mouseEventToContainerPoint(e);
4408                data.layerPoint = this.containerPointToLayerPoint(data.containerPoint);
4409                data.latlng = isMarker ? target.getLatLng() : this.layerPointToLatLng(data.layerPoint);
4410            }
4411  
4412            for (i = 0; i < targets.length; i++) {
4413                targets[i].fire(type, data, true);
4414                if (data.originalEvent._stopped ||
4415                    (targets[i].options.bubblingMouseEvents === false && indexOf(this._mouseEvents, type) !== -1)) { return; }
4416            }
4417        },
4418  
4419        _draggableMoved: function (obj) {
4420            obj = obj.dragging && obj.dragging.enabled() ? obj : this;
4421            return (obj.dragging && obj.dragging.moved()) || (this.boxZoom && this.boxZoom.moved());
4422        },
4423  
4424        _clearHandlers: function () {
4425            for (var i = 0, len = this._handlers.length; i < len; i++) {
4426                this._handlers[i].disable();
4427            }
4428        },
4429  
4430        // @section Other Methods
4431  
4432        // @method whenReady(fn: Function, context?: Object): this
4433        // Runs the given function `fn` when the map gets initialized with
4434        // a view (center and zoom) and at least one layer, or immediately
4435        // if it's already initialized, optionally passing a function context.
4436        whenReady: function (callback, context) {
4437            if (this._loaded) {
4438                callback.call(context || this, {target: this});
4439            } else {
4440                this.on('load', callback, context);
4441            }
4442            return this;
4443        },
4444  
4445  
4446        // private methods for getting map state
4447  
4448        _getMapPanePos: function () {
4449            return getPosition(this._mapPane) || new Point(0, 0);
4450        },
4451  
4452        _moved: function () {
4453            var pos = this._getMapPanePos();
4454            return pos && !pos.equals([0, 0]);
4455        },
4456  
4457        _getTopLeftPoint: function (center, zoom) {
4458            var pixelOrigin = center && zoom !== undefined ?
4459                this._getNewPixelOrigin(center, zoom) :
4460                this.getPixelOrigin();
4461            return pixelOrigin.subtract(this._getMapPanePos());
4462        },
4463  
4464        _getNewPixelOrigin: function (center, zoom) {
4465            var viewHalf = this.getSize()._divideBy(2);
4466            return this.project(center, zoom)._subtract(viewHalf)._add(this._getMapPanePos())._round();
4467        },
4468  
4469        _latLngToNewLayerPoint: function (latlng, zoom, center) {
4470            var topLeft = this._getNewPixelOrigin(center, zoom);
4471            return this.project(latlng, zoom)._subtract(topLeft);
4472        },
4473  
4474        _latLngBoundsToNewLayerBounds: function (latLngBounds, zoom, center) {
4475            var topLeft = this._getNewPixelOrigin(center, zoom);
4476            return toBounds([
4477                this.project(latLngBounds.getSouthWest(), zoom)._subtract(topLeft),
4478                this.project(latLngBounds.getNorthWest(), zoom)._subtract(topLeft),
4479                this.project(latLngBounds.getSouthEast(), zoom)._subtract(topLeft),
4480                this.project(latLngBounds.getNorthEast(), zoom)._subtract(topLeft)
4481            ]);
4482        },
4483  
4484        // layer point of the current center
4485        _getCenterLayerPoint: function () {
4486            return this.containerPointToLayerPoint(this.getSize()._divideBy(2));
4487        },
4488  
4489        // offset of the specified place to the current center in pixels
4490        _getCenterOffset: function (latlng) {
4491            return this.latLngToLayerPoint(latlng).subtract(this._getCenterLayerPoint());
4492        },
4493  
4494        // adjust center for view to get inside bounds
4495        _limitCenter: function (center, zoom, bounds) {
4496  
4497            if (!bounds) { return center; }
4498  
4499            var centerPoint = this.project(center, zoom),
4500                viewHalf = this.getSize().divideBy(2),