[rails.git] / vendor / assets / leaflet / leaflet.js

/*
 * Leaflet 1.1.0, a JS library for interactive maps. http://leafletjs.com
 * (c) 2010-2017 Vladimir Agafonkin, (c) 2010-2011 CloudMade
 */
(function (global, factory) {
        typeof exports === 'object' && typeof module !== 'undefined' ? factory(exports) :
        typeof define === 'function' && define.amd ? define(['exports'], factory) :
        (factory((global.L = global.L || {})));
}(this, (function (exports) { 'use strict';

var version = "1.1.0";

/*
 * @namespace Util
 *
 * Various utility functions, used by Leaflet internally.
 */

// @function extend(dest: Object, src?: Object): Object
// Merges the properties of the `src` object (or multiple objects) into `dest` object and returns the latter. Has an `L.extend` shortcut.
function extend(dest) {
        var i, j, len, src;

        for (j = 1, len = arguments.length; j < len; j++) {
                src = arguments[j];
                for (i in src) {
                        dest[i] = src[i];
                }
        }
        return dest;
}

// @function create(proto: Object, properties?: Object): Object
// Compatibility polyfill for [Object.create](https://developer.mozilla.org/docs/Web/JavaScript/Reference/Global_Objects/Object/create)
var create = Object.create || (function () {
        function F() {}
        return function (proto) {
                F.prototype = proto;
                return new F();
        };
})();

// @function bind(fn: Function, …): Function
// 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).
// Has a `L.bind()` shortcut.
function bind(fn, obj) {
        var slice = Array.prototype.slice;

        if (fn.bind) {
                return fn.bind.apply(fn, slice.call(arguments, 1));
        }

        var args = slice.call(arguments, 2);

        return function () {
                return fn.apply(obj, args.length ? args.concat(slice.call(arguments)) : arguments);
        };
}

// @property lastId: Number
// Last unique ID used by [`stamp()`](#util-stamp)
var lastId = 0;

// @function stamp(obj: Object): Number
// Returns the unique ID of an object, assiging it one if it doesn't have it.
function stamp(obj) {
        /*eslint-disable */
        obj._leaflet_id = obj._leaflet_id || ++lastId;
        return obj._leaflet_id;
        /*eslint-enable */
}

// @function throttle(fn: Function, time: Number, context: Object): Function
// Returns a function which executes function `fn` with the given scope `context`
// (so that the `this` keyword refers to `context` inside `fn`'s code). The function
// `fn` will be called no more than one time per given amount of `time`. The arguments
// received by the bound function will be any arguments passed when binding the
// function, followed by any arguments passed when invoking the bound function.
// Has an `L.throttle` shortcut.
function throttle(fn, time, context) {
        var lock, args, wrapperFn, later;

        later = function () {
                // reset lock and call if queued
                lock = false;
                if (args) {
                        wrapperFn.apply(context, args);
                        args = false;
                }
        };

        wrapperFn = function () {
                if (lock) {
                        // called too soon, queue to call later
                        args = arguments;

                } else {
                        // call and lock until later
                        fn.apply(context, arguments);
                        setTimeout(later, time);
                        lock = true;
                }
        };

        return wrapperFn;
}

// @function wrapNum(num: Number, range: Number[], includeMax?: Boolean): Number
// Returns the number `num` modulo `range` in such a way so it lies within
// `range[0]` and `range[1]`. The returned value will be always smaller than
// `range[1]` unless `includeMax` is set to `true`.
function wrapNum(x, range, includeMax) {
        var max = range[1],
            min = range[0],
            d = max - min;
        return x === max && includeMax ? x : ((x - min) % d + d) % d + min;
}

// @function falseFn(): Function
// Returns a function which always returns `false`.
function falseFn() { return false; }

// @function formatNum(num: Number, digits?: Number): Number
// Returns the number `num` rounded to `digits` decimals, or to 5 decimals by default.
function formatNum(num, digits) {
        var pow = Math.pow(10, digits || 5);
        return Math.round(num * pow) / pow;
}

// @function trim(str: String): String
// Compatibility polyfill for [String.prototype.trim](https://developer.mozilla.org/docs/Web/JavaScript/Reference/Global_Objects/String/Trim)
function trim(str) {
        return str.trim ? str.trim() : str.replace(/^\s+|\s+$/g, '');
}

// @function splitWords(str: String): String[]
// Trims and splits the string on whitespace and returns the array of parts.
function splitWords(str) {
        return trim(str).split(/\s+/);
}

// @function setOptions(obj: Object, options: Object): Object
// Merges the given properties to the `options` of the `obj` object, returning the resulting options. See `Class options`. Has an `L.setOptions` shortcut.
function setOptions(obj, options) {
        if (!obj.hasOwnProperty('options')) {
                obj.options = obj.options ? create(obj.options) : {};
        }
        for (var i in options) {
                obj.options[i] = options[i];
        }
        return obj.options;
}

// @function getParamString(obj: Object, existingUrl?: String, uppercase?: Boolean): String
// Converts an object into a parameter URL string, e.g. `{a: "foo", b: "bar"}`
// translates to `'?a=foo&b=bar'`. If `existingUrl` is set, the parameters will
// be appended at the end. If `uppercase` is `true`, the parameter names will
// be uppercased (e.g. `'?A=foo&B=bar'`)
function getParamString(obj, existingUrl, uppercase) {
        var params = [];
        for (var i in obj) {
                params.push(encodeURIComponent(uppercase ? i.toUpperCase() : i) + '=' + encodeURIComponent(obj[i]));
        }
        return ((!existingUrl || existingUrl.indexOf('?') === -1) ? '?' : '&') + params.join('&');
}

var templateRe = /\{ *([\w_\-]+) *\}/g;

// @function template(str: String, data: Object): String
// Simple templating facility, accepts a template string of the form `'Hello {a}, {b}'`
// and a data object like `{a: 'foo', b: 'bar'}`, returns evaluated string
// `('Hello foo, bar')`. You can also specify functions instead of strings for
// data values — they will be evaluated passing `data` as an argument.
function template(str, data) {
        return str.replace(templateRe, function (str, key) {
                var value = data[key];

                if (value === undefined) {
                        throw new Error('No value provided for variable ' + str);

                } else if (typeof value === 'function') {
                        value = value(data);
                }
                return value;
        });
}

// @function isArray(obj): Boolean
// Compatibility polyfill for [Array.isArray](https://developer.mozilla.org/docs/Web/JavaScript/Reference/Global_Objects/Array/isArray)
var isArray = Array.isArray || function (obj) {
        return (Object.prototype.toString.call(obj) === '[object Array]');
};

// @function indexOf(array: Array, el: Object): Number
// Compatibility polyfill for [Array.prototype.indexOf](https://developer.mozilla.org/docs/Web/JavaScript/Reference/Global_Objects/Array/indexOf)
function indexOf(array, el) {
        for (var i = 0; i < array.length; i++) {
                if (array[i] === el) { return i; }
        }
        return -1;
}

// @property emptyImageUrl: String
// Data URI string containing a base64-encoded empty GIF image.
// Used as a hack to free memory from unused images on WebKit-powered
// mobile devices (by setting image `src` to this string).
var emptyImageUrl = 'data:image/gif;base64,R0lGODlhAQABAAD/ACwAAAAAAQABAAACADs=';

// inspired by http://paulirish.com/2011/requestanimationframe-for-smart-animating/

function getPrefixed(name) {
        return window['webkit' + name] || window['moz' + name] || window['ms' + name];
}

var lastTime = 0;

// fallback for IE 7-8
function timeoutDefer(fn) {
        var time = +new Date(),
            timeToCall = Math.max(0, 16 - (time - lastTime));

        lastTime = time + timeToCall;
        return window.setTimeout(fn, timeToCall);
}

var requestFn = window.requestAnimationFrame || getPrefixed('RequestAnimationFrame') || timeoutDefer;
var cancelFn = window.cancelAnimationFrame || getPrefixed('CancelAnimationFrame') ||
                getPrefixed('CancelRequestAnimationFrame') || function (id) { window.clearTimeout(id); };

// @function requestAnimFrame(fn: Function, context?: Object, immediate?: Boolean): Number
// Schedules `fn` to be executed when the browser repaints. `fn` is bound to
// `context` if given. When `immediate` is set, `fn` is called immediately if
// the browser doesn't have native support for
// [`window.requestAnimationFrame`](https://developer.mozilla.org/docs/Web/API/window/requestAnimationFrame),
// otherwise it's delayed. Returns a request ID that can be used to cancel the request.
function requestAnimFrame(fn, context, immediate) {
        if (immediate && requestFn === timeoutDefer) {
                fn.call(context);
        } else {
                return requestFn.call(window, bind(fn, context));
        }
}

// @function cancelAnimFrame(id: Number): undefined
// Cancels a previous `requestAnimFrame`. See also [window.cancelAnimationFrame](https://developer.mozilla.org/docs/Web/API/window/cancelAnimationFrame).
function cancelAnimFrame(id) {
        if (id) {
                cancelFn.call(window, id);
        }
}


var Util = (Object.freeze || Object)({
        extend: extend,
        create: create,
        bind: bind,
        lastId: lastId,
        stamp: stamp,
        throttle: throttle,
        wrapNum: wrapNum,
        falseFn: falseFn,
        formatNum: formatNum,
        trim: trim,
        splitWords: splitWords,
        setOptions: setOptions,
        getParamString: getParamString,
        template: template,
        isArray: isArray,
        indexOf: indexOf,
        emptyImageUrl: emptyImageUrl,
        requestFn: requestFn,
        cancelFn: cancelFn,
        requestAnimFrame: requestAnimFrame,
        cancelAnimFrame: cancelAnimFrame
});

// @class Class
// @aka L.Class

// @section
// @uninheritable

// Thanks to John Resig and Dean Edwards for inspiration!

function Class() {}

Class.extend = function (props) {

        // @function extend(props: Object): Function
        // [Extends the current class](#class-inheritance) given the properties to be included.
        // Returns a Javascript function that is a class constructor (to be called with `new`).
        var NewClass = function () {

                // call the constructor
                if (this.initialize) {
                        this.initialize.apply(this, arguments);
                }

                // call all constructor hooks
                this.callInitHooks();
        };

        var parentProto = NewClass.__super__ = this.prototype;

        var proto = create(parentProto);
        proto.constructor = NewClass;

        NewClass.prototype = proto;

        // inherit parent's statics
        for (var i in this) {
                if (this.hasOwnProperty(i) && i !== 'prototype' && i !== '__super__') {
                        NewClass[i] = this[i];
                }
        }

        // mix static properties into the class
        if (props.statics) {
                extend(NewClass, props.statics);
                delete props.statics;
        }

        // mix includes into the prototype
        if (props.includes) {
                checkDeprecatedMixinEvents(props.includes);
                extend.apply(null, [proto].concat(props.includes));
                delete props.includes;
        }

        // merge options
        if (proto.options) {
                props.options = extend(create(proto.options), props.options);
        }

        // mix given properties into the prototype
        extend(proto, props);

        proto._initHooks = [];

        // add method for calling all hooks
        proto.callInitHooks = function () {

                if (this._initHooksCalled) { return; }

                if (parentProto.callInitHooks) {
                        parentProto.callInitHooks.call(this);
                }

                this._initHooksCalled = true;

                for (var i = 0, len = proto._initHooks.length; i < len; i++) {
                        proto._initHooks[i].call(this);
                }
        };

        return NewClass;
};


// @function include(properties: Object): this
// [Includes a mixin](#class-includes) into the current class.
Class.include = function (props) {
        extend(this.prototype, props);
        return this;
};

// @function mergeOptions(options: Object): this
// [Merges `options`](#class-options) into the defaults of the class.
Class.mergeOptions = function (options) {
        extend(this.prototype.options, options);
        return this;
};

// @function addInitHook(fn: Function): this
// Adds a [constructor hook](#class-constructor-hooks) to the class.
Class.addInitHook = function (fn) { // (Function) || (String, args...)
        var args = Array.prototype.slice.call(arguments, 1);

        var init = typeof fn === 'function' ? fn : function () {
                this[fn].apply(this, args);
        };

        this.prototype._initHooks = this.prototype._initHooks || [];
        this.prototype._initHooks.push(init);
        return this;
};

function checkDeprecatedMixinEvents(includes) {
        if (!L || !L.Mixin) { return; }

        includes = isArray(includes) ? includes : [includes];

        for (var i = 0; i < includes.length; i++) {
                if (includes[i] === L.Mixin.Events) {
                        console.warn('Deprecated include of L.Mixin.Events: ' +
                                'this property will be removed in future releases, ' +
                                'please inherit from L.Evented instead.', new Error().stack);
                }
        }
}

/*
 * @class Evented
 * @aka L.Evented
 * @inherits Class
 *
 * A set of methods shared between event-powered classes (like `Map` and `Marker`). Generally, events allow you to execute some function when something happens with an object (e.g. the user clicks on the map, causing the map to fire `'click'` event).
 *
 * @example
 *
 * ```js
 * map.on('click', function(e) {
 *      alert(e.latlng);
 * } );
 * ```
 *
 * Leaflet deals with event listeners by reference, so if you want to add a listener and then remove it, define it as a function:
 *
 * ```js
 * function onClick(e) { ... }
 *
 * map.on('click', onClick);
 * map.off('click', onClick);
 * ```
 */

var Events = {
        /* @method on(type: String, fn: Function, context?: Object): this
         * Adds a listener function (`fn`) to a particular event type of the object. You can optionally specify the context of the listener (object the this keyword will point to). You can also pass several space-separated types (e.g. `'click dblclick'`).
         *
         * @alternative
         * @method on(eventMap: Object): this
         * Adds a set of type/listener pairs, e.g. `{click: onClick, mousemove: onMouseMove}`
         */
        on: function (types, fn, context) {

                // types can be a map of types/handlers
                if (typeof types === 'object') {
                        for (var type in types) {
                                // we don't process space-separated events here for performance;
                                // it's a hot path since Layer uses the on(obj) syntax
                                this._on(type, types[type], fn);
                        }

                } else {
                        // types can be a string of space-separated words
                        types = splitWords(types);

                        for (var i = 0, len = types.length; i < len; i++) {
                                this._on(types[i], fn, context);
                        }
                }

                return this;
        },

        /* @method off(type: String, fn?: Function, context?: Object): this
         * Removes a previously added listener function. If no function is specified, it will remove all the listeners of that particular event from the object. Note that if you passed a custom context to `on`, you must pass the same context to `off` in order to remove the listener.
         *
         * @alternative
         * @method off(eventMap: Object): this
         * Removes a set of type/listener pairs.
         *
         * @alternative
         * @method off: this
         * Removes all listeners to all events on the object.
         */
        off: function (types, fn, context) {

                if (!types) {
                        // clear all listeners if called without arguments
                        delete this._events;

                } else if (typeof types === 'object') {
                        for (var type in types) {
                                this._off(type, types[type], fn);
                        }

                } else {
                        types = splitWords(types);

                        for (var i = 0, len = types.length; i < len; i++) {
                                this._off(types[i], fn, context);
                        }
                }

                return this;
        },

        // attach listener (without syntactic sugar now)
        _on: function (type, fn, context) {
                this._events = this._events || {};

                /* get/init listeners for type */
                var typeListeners = this._events[type];
                if (!typeListeners) {
                        typeListeners = [];
                        this._events[type] = typeListeners;
                }

                if (context === this) {
                        // Less memory footprint.
                        context = undefined;
                }
                var newListener = {fn: fn, ctx: context},
                    listeners = typeListeners;

                // check if fn already there
                for (var i = 0, len = listeners.length; i < len; i++) {
                        if (listeners[i].fn === fn && listeners[i].ctx === context) {
                                return;
                        }
                }

                listeners.push(newListener);
        },

        _off: function (type, fn, context) {
                var listeners,
                    i,
                    len;

                if (!this._events) { return; }

                listeners = this._events[type];

                if (!listeners) {
                        return;
                }

                if (!fn) {
                        // Set all removed listeners to noop so they are not called if remove happens in fire
                        for (i = 0, len = listeners.length; i < len; i++) {
                                listeners[i].fn = falseFn;
                        }
                        // clear all listeners for a type if function isn't specified
                        delete this._events[type];
                        return;
                }

                if (context === this) {
                        context = undefined;
                }

                if (listeners) {

                        // find fn and remove it
                        for (i = 0, len = listeners.length; i < len; i++) {
                                var l = listeners[i];
                                if (l.ctx !== context) { continue; }
                                if (l.fn === fn) {

                                        // set the removed listener to noop so that's not called if remove happens in fire
                                        l.fn = falseFn;

                                        if (this._firingCount) {
                                                /* copy array in case events are being fired */
                                                this._events[type] = listeners = listeners.slice();
                                        }
                                        listeners.splice(i, 1);

                                        return;
                                }
                        }
                }
        },

        // @method fire(type: String, data?: Object, propagate?: Boolean): this
        // Fires an event of the specified type. You can optionally provide an data
        // object — the first argument of the listener function will contain its
        // properties. The event can optionally be propagated to event parents.
        fire: function (type, data, propagate) {
                if (!this.listens(type, propagate)) { return this; }

                var event = extend({}, data, {type: type, target: this});

                if (this._events) {
                        var listeners = this._events[type];

                        if (listeners) {
                                this._firingCount = (this._firingCount + 1) || 1;
                                for (var i = 0, len = listeners.length; i < len; i++) {
                                        var l = listeners[i];
                                        l.fn.call(l.ctx || this, event);
                                }

                                this._firingCount--;
                        }
                }

                if (propagate) {
                        // propagate the event to parents (set with addEventParent)
                        this._propagateEvent(event);
                }

                return this;
        },

        // @method listens(type: String): Boolean
        // Returns `true` if a particular event type has any listeners attached to it.
        listens: function (type, propagate) {
                var listeners = this._events && this._events[type];
                if (listeners && listeners.length) { return true; }

                if (propagate) {
                        // also check parents for listeners if event propagates
                        for (var id in this._eventParents) {
                                if (this._eventParents[id].listens(type, propagate)) { return true; }
                        }
                }
                return false;
        },

        // @method once(…): this
        // Behaves as [`on(…)`](#evented-on), except the listener will only get fired once and then removed.
        once: function (types, fn, context) {

                if (typeof types === 'object') {
                        for (var type in types) {
                                this.once(type, types[type], fn);
                        }
                        return this;
                }

                var handler = bind(function () {
                        this
                            .off(types, fn, context)
                            .off(types, handler, context);
                }, this);

                // add a listener that's executed once and removed after that
                return this
                    .on(types, fn, context)
                    .on(types, handler, context);
        },

        // @method addEventParent(obj: Evented): this
        // Adds an event parent - an `Evented` that will receive propagated events
        addEventParent: function (obj) {
                this._eventParents = this._eventParents || {};
                this._eventParents[stamp(obj)] = obj;
                return this;
        },

        // @method removeEventParent(obj: Evented): this
        // Removes an event parent, so it will stop receiving propagated events
        removeEventParent: function (obj) {
                if (this._eventParents) {
                        delete this._eventParents[stamp(obj)];
                }
                return this;
        },

        _propagateEvent: function (e) {
                for (var id in this._eventParents) {
                        this._eventParents[id].fire(e.type, extend({layer: e.target}, e), true);
                }
        }
};

// aliases; we should ditch those eventually

// @method addEventListener(…): this
// Alias to [`on(…)`](#evented-on)
Events.addEventListener = Events.on;

// @method removeEventListener(…): this
// Alias to [`off(…)`](#evented-off)

// @method clearAllEventListeners(…): this
// Alias to [`off()`](#evented-off)
Events.removeEventListener = Events.clearAllEventListeners = Events.off;

// @method addOneTimeEventListener(…): this
// Alias to [`once(…)`](#evented-once)
Events.addOneTimeEventListener = Events.once;

// @method fireEvent(…): this
// Alias to [`fire(…)`](#evented-fire)
Events.fireEvent = Events.fire;

// @method hasEventListeners(…): Boolean
// Alias to [`listens(…)`](#evented-listens)
Events.hasEventListeners = Events.listens;

var Evented = Class.extend(Events);

/*
 * @class Point
 * @aka L.Point
 *
 * Represents a point with `x` and `y` coordinates in pixels.
 *
 * @example
 *
 * ```js
 * var point = L.point(200, 300);
 * ```
 *
 * All Leaflet methods and options that accept `Point` objects also accept them in a simple Array form (unless noted otherwise), so these lines are equivalent:
 *
 * ```js
 * map.panBy([200, 300]);
 * map.panBy(L.point(200, 300));
 * ```
 */

function Point(x, y, round) {
        // @property x: Number; The `x` coordinate of the point
        this.x = (round ? Math.round(x) : x);
        // @property y: Number; The `y` coordinate of the point
        this.y = (round ? Math.round(y) : y);
}

Point.prototype = {

        // @method clone(): Point
        // Returns a copy of the current point.
        clone: function () {
                return new Point(this.x, this.y);
        },

        // @method add(otherPoint: Point): Point
        // Returns the result of addition of the current and the given points.
        add: function (point) {
                // non-destructive, returns a new point
                return this.clone()._add(toPoint(point));
        },

        _add: function (point) {
                // destructive, used directly for performance in situations where it's safe to modify existing point
                this.x += point.x;
                this.y += point.y;
                return this;
        },

        // @method subtract(otherPoint: Point): Point
        // Returns the result of subtraction of the given point from the current.
        subtract: function (point) {
                return this.clone()._subtract(toPoint(point));
        },

        _subtract: function (point) {
                this.x -= point.x;
                this.y -= point.y;
                return this;
        },

        // @method divideBy(num: Number): Point
        // Returns the result of division of the current point by the given number.
        divideBy: function (num) {
                return this.clone()._divideBy(num);
        },

        _divideBy: function (num) {
                this.x /= num;
                this.y /= num;
                return this;
        },

        // @method multiplyBy(num: Number): Point
        // Returns the result of multiplication of the current point by the given number.
        multiplyBy: function (num) {
                return this.clone()._multiplyBy(num);
        },

        _multiplyBy: function (num) {
                this.x *= num;
                this.y *= num;
                return this;
        },

        // @method scaleBy(scale: Point): Point
        // Multiply each coordinate of the current point by each coordinate of
        // `scale`. In linear algebra terms, multiply the point by the
        // [scaling matrix](https://en.wikipedia.org/wiki/Scaling_%28geometry%29#Matrix_representation)
        // defined by `scale`.
        scaleBy: function (point) {
                return new Point(this.x * point.x, this.y * point.y);
        },

        // @method unscaleBy(scale: Point): Point
        // Inverse of `scaleBy`. Divide each coordinate of the current point by
        // each coordinate of `scale`.
        unscaleBy: function (point) {
                return new Point(this.x / point.x, this.y / point.y);
        },

        // @method round(): Point
        // Returns a copy of the current point with rounded coordinates.
        round: function () {
                return this.clone()._round();
        },

        _round: function () {
                this.x = Math.round(this.x);
                this.y = Math.round(this.y);
                return this;
        },

        // @method floor(): Point
        // Returns a copy of the current point with floored coordinates (rounded down).
        floor: function () {
                return this.clone()._floor();
        },

        _floor: function () {
                this.x = Math.floor(this.x);
                this.y = Math.floor(this.y);
                return this;
        },

        // @method ceil(): Point
        // Returns a copy of the current point with ceiled coordinates (rounded up).
        ceil: function () {
                return this.clone()._ceil();
        },

        _ceil: function () {
                this.x = Math.ceil(this.x);
                this.y = Math.ceil(this.y);
                return this;
        },

        // @method distanceTo(otherPoint: Point): Number
        // Returns the cartesian distance between the current and the given points.
        distanceTo: function (point) {
                point = toPoint(point);

                var x = point.x - this.x,
                    y = point.y - this.y;

                return Math.sqrt(x * x + y * y);
        },

        // @method equals(otherPoint: Point): Boolean
        // Returns `true` if the given point has the same coordinates.
        equals: function (point) {
                point = toPoint(point);

                return point.x === this.x &&
                       point.y === this.y;
        },

        // @method contains(otherPoint: Point): Boolean
        // Returns `true` if both coordinates of the given point are less than the corresponding current point coordinates (in absolute values).
        contains: function (point) {
                point = toPoint(point);

                return Math.abs(point.x) <= Math.abs(this.x) &&
                       Math.abs(point.y) <= Math.abs(this.y);
        },

        // @method toString(): String
        // Returns a string representation of the point for debugging purposes.
        toString: function () {
                return 'Point(' +
                        formatNum(this.x) + ', ' +
                        formatNum(this.y) + ')';
        }
};

// @factory L.point(x: Number, y: Number, round?: Boolean)
// Creates a Point object with the given `x` and `y` coordinates. If optional `round` is set to true, rounds the `x` and `y` values.

// @alternative
// @factory L.point(coords: Number[])
// Expects an array of the form `[x, y]` instead.

// @alternative
// @factory L.point(coords: Object)
// Expects a plain object of the form `{x: Number, y: Number}` instead.
function toPoint(x, y, round) {
        if (x instanceof Point) {
                return x;
        }
        if (isArray(x)) {
                return new Point(x[0], x[1]);
        }
        if (x === undefined || x === null) {
                return x;
        }
        if (typeof x === 'object' && 'x' in x && 'y' in x) {
                return new Point(x.x, x.y);
        }
        return new Point(x, y, round);
}

/*
 * @class Bounds
 * @aka L.Bounds
 *
 * Represents a rectangular area in pixel coordinates.
 *
 * @example
 *
 * ```js
 * var p1 = L.point(10, 10),
 * p2 = L.point(40, 60),
 * bounds = L.bounds(p1, p2);
 * ```
 *
 * 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:
 *
 * ```js
 * otherBounds.intersects([[10, 10], [40, 60]]);
 * ```
 */

function Bounds(a, b) {
        if (!a) { return; }

        var points = b ? [a, b] : a;

        for (var i = 0, len = points.length; i < len; i++) {
                this.extend(points[i]);
        }
}

Bounds.prototype = {
        // @method extend(point: Point): this
        // Extends the bounds to contain the given point.
        extend: function (point) { // (Point)
                point = toPoint(point);

                // @property min: Point
                // The top left corner of the rectangle.
                // @property max: Point
                // The bottom right corner of the rectangle.
                if (!this.min && !this.max) {
                        this.min = point.clone();
                        this.max = point.clone();
                } else {
                        this.min.x = Math.min(point.x, this.min.x);
                        this.max.x = Math.max(point.x, this.max.x);
                        this.min.y = Math.min(point.y, this.min.y);
                        this.max.y = Math.max(point.y, this.max.y);
                }
                return this;
        },

        // @method getCenter(round?: Boolean): Point
        // Returns the center point of the bounds.
        getCenter: function (round) {
                return new Point(
                        (this.min.x + this.max.x) / 2,
                        (this.min.y + this.max.y) / 2, round);
        },

        // @method getBottomLeft(): Point
        // Returns the bottom-left point of the bounds.
        getBottomLeft: function () {
                return new Point(this.min.x, this.max.y);
        },

        // @method getTopRight(): Point
        // Returns the top-right point of the bounds.
        getTopRight: function () { // -> Point
                return new Point(this.max.x, this.min.y);
        },

        // @method getTopLeft(): Point
        // Returns the top-left point of the bounds (i.e. [`this.min`](#bounds-min)).
        getTopLeft: function () {
                return this.min; // left, top
        },

        // @method getBottomRight(): Point
        // Returns the bottom-right point of the bounds (i.e. [`this.max`](#bounds-max)).
        getBottomRight: function () {
                return this.max; // right, bottom
        },

        // @method getSize(): Point
        // Returns the size of the given bounds
        getSize: function () {
                return this.max.subtract(this.min);
        },

        // @method contains(otherBounds: Bounds): Boolean
        // Returns `true` if the rectangle contains the given one.
        // @alternative
        // @method contains(point: Point): Boolean
        // Returns `true` if the rectangle contains the given point.
        contains: function (obj) {
                var min, max;

                if (typeof obj[0] === 'number' || obj instanceof Point) {
                        obj = toPoint(obj);
                } else {
                        obj = toBounds(obj);
                }

                if (obj instanceof Bounds) {
                        min = obj.min;
                        max = obj.max;
                } else {
                        min = max = obj;
                }

                return (min.x >= this.min.x) &&
                       (max.x <= this.max.x) &&
                       (min.y >= this.min.y) &&
                       (max.y <= this.max.y);
        },

        // @method intersects(otherBounds: Bounds): Boolean
        // Returns `true` if the rectangle intersects the given bounds. Two bounds
        // intersect if they have at least one point in common.
        intersects: function (bounds) { // (Bounds) -> Boolean
                bounds = toBounds(bounds);

                var min = this.min,
                    max = this.max,
                    min2 = bounds.min,
                    max2 = bounds.max,
                    xIntersects = (max2.x >= min.x) && (min2.x <= max.x),
                    yIntersects = (max2.y >= min.y) && (min2.y <= max.y);

                return xIntersects && yIntersects;
        },

        // @method overlaps(otherBounds: Bounds): Boolean
        // Returns `true` if the rectangle overlaps the given bounds. Two bounds
        // overlap if their intersection is an area.
        overlaps: function (bounds) { // (Bounds) -> Boolean
                bounds = toBounds(bounds);

                var min = this.min,
                    max = this.max,
                    min2 = bounds.min,
                    max2 = bounds.max,
                    xOverlaps = (max2.x > min.x) && (min2.x < max.x),
                    yOverlaps = (max2.y > min.y) && (min2.y < max.y);

                return xOverlaps && yOverlaps;
        },

        isValid: function () {
                return !!(this.min && this.max);
        }
};


// @factory L.bounds(corner1: Point, corner2: Point)
// Creates a Bounds object from two corners coordinate pairs.
// @alternative
// @factory L.bounds(points: Point[])
// Creates a Bounds object from the given array of points.
function toBounds(a, b) {
        if (!a || a instanceof Bounds) {
                return a;
        }
        return new Bounds(a, b);
}

/*
 * @class LatLngBounds
 * @aka L.LatLngBounds
 *
 * Represents a rectangular geographical area on a map.
 *
 * @example
 *
 * ```js
 * var corner1 = L.latLng(40.712, -74.227),
 * corner2 = L.latLng(40.774, -74.125),
 * bounds = L.latLngBounds(corner1, corner2);
 * ```
 *
 * 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:
 *
 * ```js
 * map.fitBounds([
 *      [40.712, -74.227],
 *      [40.774, -74.125]
 * ]);
 * ```
 *
 * 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.
 */

function LatLngBounds(corner1, corner2) { // (LatLng, LatLng) or (LatLng[])
        if (!corner1) { return; }

        var latlngs = corner2 ? [corner1, corner2] : corner1;

        for (var i = 0, len = latlngs.length; i < len; i++) {
                this.extend(latlngs[i]);
        }
}

LatLngBounds.prototype = {

        // @method extend(latlng: LatLng): this
        // Extend the bounds to contain the given point

        // @alternative
        // @method extend(otherBounds: LatLngBounds): this
        // Extend the bounds to contain the given bounds
        extend: function (obj) {
                var sw = this._southWest,
                    ne = this._northEast,
                    sw2, ne2;

                if (obj instanceof LatLng) {
                        sw2 = obj;
                        ne2 = obj;

                } else if (obj instanceof LatLngBounds) {
                        sw2 = obj._southWest;
                        ne2 = obj._northEast;

                        if (!sw2 || !ne2) { return this; }

                } else {
                        return obj ? this.extend(toLatLng(obj) || toLatLngBounds(obj)) : this;
                }

                if (!sw && !ne) {
                        this._southWest = new LatLng(sw2.lat, sw2.lng);
                        this._northEast = new LatLng(ne2.lat, ne2.lng);
                } else {
                        sw.lat = Math.min(sw2.lat, sw.lat);
                        sw.lng = Math.min(sw2.lng, sw.lng);
                        ne.lat = Math.max(ne2.lat, ne.lat);
                        ne.lng = Math.max(ne2.lng, ne.lng);
                }

                return this;
        },

        // @method pad(bufferRatio: Number): LatLngBounds
        // Returns bigger bounds created by extending the current bounds by a given percentage in each direction.
        pad: function (bufferRatio) {
                var sw = this._southWest,
                    ne = this._northEast,
                    heightBuffer = Math.abs(sw.lat - ne.lat) * bufferRatio,
                    widthBuffer = Math.abs(sw.lng - ne.lng) * bufferRatio;

                return new LatLngBounds(
                        new LatLng(sw.lat - heightBuffer, sw.lng - widthBuffer),
                        new LatLng(ne.lat + heightBuffer, ne.lng + widthBuffer));
        },

        // @method getCenter(): LatLng
        // Returns the center point of the bounds.
        getCenter: function () {
                return new LatLng(
                        (this._southWest.lat + this._northEast.lat) / 2,
                        (this._southWest.lng + this._northEast.lng) / 2);
        },

        // @method getSouthWest(): LatLng
        // Returns the south-west point of the bounds.
        getSouthWest: function () {
                return this._southWest;
        },

        // @method getNorthEast(): LatLng
        // Returns the north-east point of the bounds.
        getNorthEast: function () {
                return this._northEast;
        },

        // @method getNorthWest(): LatLng
        // Returns the north-west point of the bounds.
        getNorthWest: function () {
                return new LatLng(this.getNorth(), this.getWest());
        },

        // @method getSouthEast(): LatLng
        // Returns the south-east point of the bounds.
        getSouthEast: function () {
                return new LatLng(this.getSouth(), this.getEast());
        },

        // @method getWest(): Number
        // Returns the west longitude of the bounds
        getWest: function () {
                return this._southWest.lng;
        },

        // @method getSouth(): Number
        // Returns the south latitude of the bounds
        getSouth: function () {
                return this._southWest.lat;
        },

        // @method getEast(): Number
        // Returns the east longitude of the bounds
        getEast: function () {
                return this._northEast.lng;
        },

        // @method getNorth(): Number
        // Returns the north latitude of the bounds
        getNorth: function () {
                return this._northEast.lat;
        },

        // @method contains(otherBounds: LatLngBounds): Boolean
        // Returns `true` if the rectangle contains the given one.

        // @alternative
        // @method contains (latlng: LatLng): Boolean
        // Returns `true` if the rectangle contains the given point.
        contains: function (obj) { // (LatLngBounds) or (LatLng) -> Boolean
                if (typeof obj[0] === 'number' || obj instanceof LatLng || 'lat' in obj) {
                        obj = toLatLng(obj);
                } else {
                        obj = toLatLngBounds(obj);
                }

                var sw = this._southWest,
                    ne = this._northEast,
                    sw2, ne2;

                if (obj instanceof LatLngBounds) {
                        sw2 = obj.getSouthWest();
                        ne2 = obj.getNorthEast();
                } else {
                        sw2 = ne2 = obj;
                }

                return (sw2.lat >= sw.lat) && (ne2.lat <= ne.lat) &&
                       (sw2.lng >= sw.lng) && (ne2.lng <= ne.lng);
        },

        // @method intersects(otherBounds: LatLngBounds): Boolean
        // Returns `true` if the rectangle intersects the given bounds. Two bounds intersect if they have at least one point in common.
        intersects: function (bounds) {
                bounds = toLatLngBounds(bounds);

                var sw = this._southWest,
                    ne = this._northEast,
                    sw2 = bounds.getSouthWest(),
                    ne2 = bounds.getNorthEast(),

                    latIntersects = (ne2.lat >= sw.lat) && (sw2.lat <= ne.lat),
                    lngIntersects = (ne2.lng >= sw.lng) && (sw2.lng <= ne.lng);

                return latIntersects && lngIntersects;
        },

        // @method overlaps(otherBounds: Bounds): Boolean
        // Returns `true` if the rectangle overlaps the given bounds. Two bounds overlap if their intersection is an area.
        overlaps: function (bounds) {
                bounds = toLatLngBounds(bounds);

                var sw = this._southWest,
                    ne = this._northEast,
                    sw2 = bounds.getSouthWest(),
                    ne2 = bounds.getNorthEast(),

                    latOverlaps = (ne2.lat > sw.lat) && (sw2.lat < ne.lat),
                    lngOverlaps = (ne2.lng > sw.lng) && (sw2.lng < ne.lng);

                return latOverlaps && lngOverlaps;
        },

        // @method toBBoxString(): String
        // 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.
        toBBoxString: function () {
                return [this.getWest(), this.getSouth(), this.getEast(), this.getNorth()].join(',');
        },

        // @method equals(otherBounds: LatLngBounds, maxMargin?: Number): Boolean
        // Returns `true` if the rectangle is equivalent (within a small margin of error) to the given bounds. The margin of error can be overriden by setting `maxMargin` to a small number.
        equals: function (bounds, maxMargin) {
                if (!bounds) { return false; }

                bounds = toLatLngBounds(bounds);

                return this._southWest.equals(bounds.getSouthWest(), maxMargin) &&
                       this._northEast.equals(bounds.getNorthEast(), maxMargin);
        },

        // @method isValid(): Boolean
        // Returns `true` if the bounds are properly initialized.
        isValid: function () {
                return !!(this._southWest && this._northEast);
        }
};

// TODO International date line?

// @factory L.latLngBounds(corner1: LatLng, corner2: LatLng)
// Creates a `LatLngBounds` object by defining two diagonally opposite corners of the rectangle.

// @alternative
// @factory L.latLngBounds(latlngs: LatLng[])
// 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).
function toLatLngBounds(a, b) {
        if (a instanceof LatLngBounds) {
                return a;
        }
        return new LatLngBounds(a, b);
}

/* @class LatLng
 * @aka L.LatLng
 *
 * Represents a geographical point with a certain latitude and longitude.
 *
 * @example
 *
 * ```
 * var latlng = L.latLng(50.5, 30.5);
 * ```
 *
 * 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:
 *
 * ```
 * map.panTo([50, 30]);
 * map.panTo({lon: 30, lat: 50});
 * map.panTo({lat: 50, lng: 30});
 * map.panTo(L.latLng(50, 30));
 * ```
 */

function LatLng(lat, lng, alt) {
        if (isNaN(lat) || isNaN(lng)) {
                throw new Error('Invalid LatLng object: (' + lat + ', ' + lng + ')');
        }

        // @property lat: Number
        // Latitude in degrees
        this.lat = +lat;

        // @property lng: Number
        // Longitude in degrees
        this.lng = +lng;

        // @property alt: Number
        // Altitude in meters (optional)
        if (alt !== undefined) {
                this.alt = +alt;
        }
}

LatLng.prototype = {
        // @method equals(otherLatLng: LatLng, maxMargin?: Number): Boolean
        // Returns `true` if the given `LatLng` point is at the same position (within a small margin of error). The margin of error can be overriden by setting `maxMargin` to a small number.
        equals: function (obj, maxMargin) {
                if (!obj) { return false; }

                obj = toLatLng(obj);

                var margin = Math.max(
                        Math.abs(this.lat - obj.lat),
                        Math.abs(this.lng - obj.lng));

                return margin <= (maxMargin === undefined ? 1.0E-9 : maxMargin);
        },

        // @method toString(): String
        // Returns a string representation of the point (for debugging purposes).
        toString: function (precision) {
                return 'LatLng(' +
                        formatNum(this.lat, precision) + ', ' +
                        formatNum(this.lng, precision) + ')';
        },

        // @method distanceTo(otherLatLng: LatLng): Number
        // Returns the distance (in meters) to the given `LatLng` calculated using the [Haversine formula](http://en.wikipedia.org/wiki/Haversine_formula).
        distanceTo: function (other) {
                return Earth.distance(this, toLatLng(other));
        },

        // @method wrap(): LatLng
        // Returns a new `LatLng` object with the longitude wrapped so it's always between -180 and +180 degrees.
        wrap: function () {
                return Earth.wrapLatLng(this);
        },

        // @method toBounds(sizeInMeters: Number): LatLngBounds
        // Returns a new `LatLngBounds` object in which each boundary is `sizeInMeters/2` meters apart from the `LatLng`.
        toBounds: function (sizeInMeters) {
                var latAccuracy = 180 * sizeInMeters / 40075017,
                    lngAccuracy = latAccuracy / Math.cos((Math.PI / 180) * this.lat);

                return toLatLngBounds(
                        [this.lat - latAccuracy, this.lng - lngAccuracy],
                        [this.lat + latAccuracy, this.lng + lngAccuracy]);
        },

        clone: function () {
                return new LatLng(this.lat, this.lng, this.alt);
        }
};



// @factory L.latLng(latitude: Number, longitude: Number, altitude?: Number): LatLng
// Creates an object representing a geographical point with the given latitude and longitude (and optionally altitude).

// @alternative
// @factory L.latLng(coords: Array): LatLng
// Expects an array of the form `[Number, Number]` or `[Number, Number, Number]` instead.

// @alternative
// @factory L.latLng(coords: Object): LatLng
// Expects an plain object of the form `{lat: Number, lng: Number}` or `{lat: Number, lng: Number, alt: Number}` instead.

function toLatLng(a, b, c) {
        if (a instanceof LatLng) {
                return a;
        }
        if (isArray(a) && typeof a[0] !== 'object') {
                if (a.length === 3) {
                        return new LatLng(a[0], a[1], a[2]);
                }
                if (a.length === 2) {
                        return new LatLng(a[0], a[1]);
                }
                return null;
        }
        if (a === undefined || a === null) {
                return a;
        }
        if (typeof a === 'object' && 'lat' in a) {
                return new LatLng(a.lat, 'lng' in a ? a.lng : a.lon, a.alt);
        }
        if (b === undefined) {
                return null;
        }
        return new LatLng(a, b, c);
}

/*
 * @namespace CRS
 * @crs L.CRS.Base
 * Object that defines coordinate reference systems for projecting
 * geographical points into pixel (screen) coordinates and back (and to
 * coordinates in other units for [WMS](https://en.wikipedia.org/wiki/Web_Map_Service) services). See
 * [spatial reference system](http://en.wikipedia.org/wiki/Coordinate_reference_system).
 *
 * Leaflet defines the most usual CRSs by default. If you want to use a
 * CRS not defined by default, take a look at the
 * [Proj4Leaflet](https://github.com/kartena/Proj4Leaflet) plugin.
 */

var CRS = {
        // @method latLngToPoint(latlng: LatLng, zoom: Number): Point
        // Projects geographical coordinates into pixel coordinates for a given zoom.
        latLngToPoint: function (latlng, zoom) {
                var projectedPoint = this.projection.project(latlng),
                    scale = this.scale(zoom);

                return this.transformation._transform(projectedPoint, scale);
        },

        // @method pointToLatLng(point: Point, zoom: Number): LatLng
        // The inverse of `latLngToPoint`. Projects pixel coordinates on a given
        // zoom into geographical coordinates.
        pointToLatLng: function (point, zoom) {
                var scale = this.scale(zoom),
                    untransformedPoint = this.transformation.untransform(point, scale);

                return this.projection.unproject(untransformedPoint);
        },

        // @method project(latlng: LatLng): Point
        // Projects geographical coordinates into coordinates in units accepted for
        // this CRS (e.g. meters for EPSG:3857, for passing it to WMS services).
        project: function (latlng) {
                return this.projection.project(latlng);
        },

        // @method unproject(point: Point): LatLng
        // Given a projected coordinate returns the corresponding LatLng.
        // The inverse of `project`.
        unproject: function (point) {
                return this.projection.unproject(point);
        },

        // @method scale(zoom: Number): Number
        // Returns the scale used when transforming projected coordinates into
        // pixel coordinates for a particular zoom. For example, it returns
        // `256 * 2^zoom` for Mercator-based CRS.
        scale: function (zoom) {
                return 256 * Math.pow(2, zoom);
        },

        // @method zoom(scale: Number): Number
        // Inverse of `scale()`, returns the zoom level corresponding to a scale
        // factor of `scale`.
        zoom: function (scale) {
                return Math.log(scale / 256) / Math.LN2;
        },

        // @method getProjectedBounds(zoom: Number): Bounds
        // Returns the projection's bounds scaled and transformed for the provided `zoom`.
        getProjectedBounds: function (zoom) {
                if (this.infinite) { return null; }

                var b = this.projection.bounds,
                    s = this.scale(zoom),
                    min = this.transformation.transform(b.min, s),
                    max = this.transformation.transform(b.max, s);

                return new Bounds(min, max);
        },

        // @method distance(latlng1: LatLng, latlng2: LatLng): Number
        // Returns the distance between two geographical coordinates.

        // @property code: String
        // Standard code name of the CRS passed into WMS services (e.g. `'EPSG:3857'`)
        //
        // @property wrapLng: Number[]
        // An array of two numbers defining whether the longitude (horizontal) coordinate
        // axis wraps around a given range and how. Defaults to `[-180, 180]` in most
        // geographical CRSs. If `undefined`, the longitude axis does not wrap around.
        //
        // @property wrapLat: Number[]
        // Like `wrapLng`, but for the latitude (vertical) axis.

        // wrapLng: [min, max],
        // wrapLat: [min, max],

        // @property infinite: Boolean
        // If true, the coordinate space will be unbounded (infinite in both axes)
        infinite: false,

        // @method wrapLatLng(latlng: LatLng): LatLng
        // Returns a `LatLng` where lat and lng has been wrapped according to the
        // CRS's `wrapLat` and `wrapLng` properties, if they are outside the CRS's bounds.
        wrapLatLng: function (latlng) {
                var lng = this.wrapLng ? wrapNum(latlng.lng, this.wrapLng, true) : latlng.lng,
                    lat = this.wrapLat ? wrapNum(latlng.lat, this.wrapLat, true) : latlng.lat,
                    alt = latlng.alt;

                return new LatLng(lat, lng, alt);
        },

        // @method wrapLatLngBounds(bounds: LatLngBounds): LatLngBounds
        // Returns a `LatLngBounds` with the same size as the given one, ensuring
        // that its center is within the CRS's bounds.
        // Only accepts actual `L.LatLngBounds` instances, not arrays.
        wrapLatLngBounds: function (bounds) {
                var center = bounds.getCenter(),
                    newCenter = this.wrapLatLng(center),
                    latShift = center.lat - newCenter.lat,
                    lngShift = center.lng - newCenter.lng;

                if (latShift === 0 && lngShift === 0) {
                        return bounds;
                }

                var sw = bounds.getSouthWest(),
                    ne = bounds.getNorthEast(),
                    newSw = new LatLng(sw.lat - latShift, sw.lng - lngShift),
                    newNe = new LatLng(ne.lat - latShift, ne.lng - lngShift);

                return new LatLngBounds(newSw, newNe);
        }
};

/*
 * @namespace CRS
 * @crs L.CRS.Earth
 *
 * Serves as the base for CRS that are global such that they cover the earth.
 * Can only be used as the base for other CRS and cannot be used directly,
 * since it does not have a `code`, `projection` or `transformation`. `distance()` returns
 * meters.
 */

var Earth = extend({}, CRS, {
        wrapLng: [-180, 180],

        // Mean Earth Radius, as recommended for use by
        // the International Union of Geodesy and Geophysics,
        // see http://rosettacode.org/wiki/Haversine_formula
        R: 6371000,

        // distance between two geographical points using spherical law of cosines approximation
        distance: function (latlng1, latlng2) {
                var rad = Math.PI / 180,
                    lat1 = latlng1.lat * rad,
                    lat2 = latlng2.lat * rad,
                    a = Math.sin(lat1) * Math.sin(lat2) +
                        Math.cos(lat1) * Math.cos(lat2) * Math.cos((latlng2.lng - latlng1.lng) * rad);

                return this.R * Math.acos(Math.min(a, 1));
        }
});

/*
 * @namespace Projection
 * @projection L.Projection.SphericalMercator
 *
 * Spherical Mercator projection — the most common projection for online maps,
 * used by almost all free and commercial tile providers. Assumes that Earth is
 * a sphere. Used by the `EPSG:3857` CRS.
 */

var SphericalMercator = {

        R: 6378137,
        MAX_LATITUDE: 85.0511287798,

        project: function (latlng) {
                var d = Math.PI / 180,
                    max = this.MAX_LATITUDE,
                    lat = Math.max(Math.min(max, latlng.lat), -max),
                    sin = Math.sin(lat * d);

                return new Point(
                                this.R * latlng.lng * d,
                                this.R * Math.log((1 + sin) / (1 - sin)) / 2);
        },

        unproject: function (point) {
                var d = 180 / Math.PI;

                return new LatLng(
                        (2 * Math.atan(Math.exp(point.y / this.R)) - (Math.PI / 2)) * d,
                        point.x * d / this.R);
        },

        bounds: (function () {
                var d = 6378137 * Math.PI;
                return new Bounds([-d, -d], [d, d]);
        })()
};

/*
 * @class Transformation
 * @aka L.Transformation
 *
 * Represents an affine transformation: a set of coefficients `a`, `b`, `c`, `d`
 * for transforming a point of a form `(x, y)` into `(a*x + b, c*y + d)` and doing
 * the reverse. Used by Leaflet in its projections code.
 *
 * @example
 *
 * ```js
 * var transformation = L.transformation(2, 5, -1, 10),
 *      p = L.point(1, 2),
 *      p2 = transformation.transform(p), //  L.point(7, 8)
 *      p3 = transformation.untransform(p2); //  L.point(1, 2)
 * ```
 */


// factory new L.Transformation(a: Number, b: Number, c: Number, d: Number)
// Creates a `Transformation` object with the given coefficients.
function Transformation(a, b, c, d) {
        if (isArray(a)) {
                // use array properties
                this._a = a[0];
                this._b = a[1];
                this._c = a[2];
                this._d = a[3];
                return;
        }
        this._a = a;
        this._b = b;
        this._c = c;
        this._d = d;
}

Transformation.prototype = {
        // @method transform(point: Point, scale?: Number): Point
        // Returns a transformed point, optionally multiplied by the given scale.
        // Only accepts actual `L.Point` instances, not arrays.
        transform: function (point, scale) { // (Point, Number) -> Point
                return this._transform(point.clone(), scale);
        },

        // destructive transform (faster)
        _transform: function (point, scale) {
                scale = scale || 1;
                point.x = scale * (this._a * point.x + this._b);
                point.y = scale * (this._c * point.y + this._d);
                return point;
        },

        // @method untransform(point: Point, scale?: Number): Point
        // Returns the reverse transformation of the given point, optionally divided
        // by the given scale. Only accepts actual `L.Point` instances, not arrays.
        untransform: function (point, scale) {
                scale = scale || 1;
                return new Point(
                        (point.x / scale - this._b) / this._a,
                        (point.y / scale - this._d) / this._c);
        }
};

// factory L.transformation(a: Number, b: Number, c: Number, d: Number)

// @factory L.transformation(a: Number, b: Number, c: Number, d: Number)
// Instantiates a Transformation object with the given coefficients.

// @alternative
// @factory L.transformation(coefficients: Array): Transformation
// Expects an coeficients array of the form
// `[a: Number, b: Number, c: Number, d: Number]`.

function toTransformation(a, b, c, d) {
        return new Transformation(a, b, c, d);
}

/*
 * @namespace CRS
 * @crs L.CRS.EPSG3857
 *
 * The most common CRS for online maps, used by almost all free and commercial
 * tile providers. Uses Spherical Mercator projection. Set in by default in
 * Map's `crs` option.
 */

var EPSG3857 = extend({}, Earth, {
        code: 'EPSG:3857',
        projection: SphericalMercator,

        transformation: (function () {
                var scale = 0.5 / (Math.PI * SphericalMercator.R);
                return toTransformation(scale, 0.5, -scale, 0.5);
        }())
});

var EPSG900913 = extend({}, EPSG3857, {
        code: 'EPSG:900913'
});

// @namespace SVG; @section
// There are several static functions which can be called without instantiating L.SVG:

// @function create(name: String): SVGElement
// Returns a instance of [SVGElement](https://developer.mozilla.org/docs/Web/API/SVGElement),
// corresponding to the class name passed. For example, using 'line' will return
// an instance of [SVGLineElement](https://developer.mozilla.org/docs/Web/API/SVGLineElement).
function svgCreate(name) {
        return document.createElementNS('http://www.w3.org/2000/svg', name);
}

// @function pointsToPath(rings: Point[], closed: Boolean): String
// Generates a SVG path string for multiple rings, with each ring turning
// into "M..L..L.." instructions
function pointsToPath(rings, closed) {
        var str = '',
        i, j, len, len2, points, p;

        for (i = 0, len = rings.length; i < len; i++) {
                points = rings[i];

                for (j = 0, len2 = points.length; j < len2; j++) {
                        p = points[j];
                        str += (j ? 'L' : 'M') + p.x + ' ' + p.y;
                }

                // closes the ring for polygons; "x" is VML syntax
                str += closed ? (svg ? 'z' : 'x') : '';
        }

        // SVG complains about empty path strings
        return str || 'M0 0';
}

/*
 * @namespace Browser
 * @aka L.Browser
 *
 * A namespace with static properties for browser/feature detection used by Leaflet internally.
 *
 * @example
 *
 * ```js
 * if (L.Browser.ielt9) {
 *   alert('Upgrade your browser, dude!');
 * }
 * ```
 */

var style$1 = document.documentElement.style;

// @property ie: Boolean; `true` for all Internet Explorer versions (not Edge).
var ie = 'ActiveXObject' in window;

// @property ielt9: Boolean; `true` for Internet Explorer versions less than 9.
var ielt9 = ie && !document.addEventListener;

// @property edge: Boolean; `true` for the Edge web browser.
var edge = 'msLaunchUri' in navigator && !('documentMode' in document);

// @property webkit: Boolean;
// `true` for webkit-based browsers like Chrome and Safari (including mobile versions).
var webkit = userAgentContains('webkit');

// @property android: Boolean
// `true` for any browser running on an Android platform.
var android = userAgentContains('android');

// @property android23: Boolean; `true` for browsers running on Android 2 or Android 3.
var android23 = userAgentContains('android 2') || userAgentContains('android 3');

// @property opera: Boolean; `true` for the Opera browser
var opera = !!window.opera;

// @property chrome: Boolean; `true` for the Chrome browser.
var chrome = userAgentContains('chrome');

// @property gecko: Boolean; `true` for gecko-based browsers like Firefox.
var gecko = userAgentContains('gecko') && !webkit && !opera && !ie;

// @property safari: Boolean; `true` for the Safari browser.
var safari = !chrome && userAgentContains('safari');

var phantom = userAgentContains('phantom');

// @property opera12: Boolean
// `true` for the Opera browser supporting CSS transforms (version 12 or later).
var opera12 = 'OTransition' in style$1;

// @property win: Boolean; `true` when the browser is running in a Windows platform
var win = navigator.platform.indexOf('Win') === 0;

// @property ie3d: Boolean; `true` for all Internet Explorer versions supporting CSS transforms.
var ie3d = ie && ('transition' in style$1);

// @property webkit3d: Boolean; `true` for webkit-based browsers supporting CSS transforms.
var webkit3d = ('WebKitCSSMatrix' in window) && ('m11' in new window.WebKitCSSMatrix()) && !android23;

// @property gecko3d: Boolean; `true` for gecko-based browsers supporting CSS transforms.
var gecko3d = 'MozPerspective' in style$1;

// @property any3d: Boolean
// `true` for all browsers supporting CSS transforms.
var any3d = !window.L_DISABLE_3D && (ie3d || webkit3d || gecko3d) && !opera12 && !phantom;

// @property mobile: Boolean; `true` for all browsers running in a mobile device.
var mobile = typeof orientation !== 'undefined' || userAgentContains('mobile');

// @property mobileWebkit: Boolean; `true` for all webkit-based browsers in a mobile device.
var mobileWebkit = mobile && webkit;

// @property mobileWebkit3d: Boolean
// `true` for all webkit-based browsers in a mobile device supporting CSS transforms.
var mobileWebkit3d = mobile && webkit3d;

// @property msPointer: Boolean
// `true` for browsers implementing the Microsoft touch events model (notably IE10).
var msPointer = !window.PointerEvent && window.MSPointerEvent;

// @property pointer: Boolean
// `true` for all browsers supporting [pointer events](https://msdn.microsoft.com/en-us/library/dn433244%28v=vs.85%29.aspx).
var pointer = !!(window.PointerEvent || msPointer);

// @property touch: Boolean
// `true` for all browsers supporting [touch events](https://developer.mozilla.org/docs/Web/API/Touch_events).
// This does not necessarily mean that the browser is running in a computer with
// a touchscreen, it only means that the browser is capable of understanding
// touch events.
var touch = !window.L_NO_TOUCH && (pointer || 'ontouchstart' in window ||
                (window.DocumentTouch && document instanceof window.DocumentTouch));

// @property mobileOpera: Boolean; `true` for the Opera browser in a mobile device.
var mobileOpera = mobile && opera;

// @property mobileGecko: Boolean
// `true` for gecko-based browsers running in a mobile device.
var mobileGecko = mobile && gecko;

// @property retina: Boolean
// `true` for browsers on a high-resolution "retina" screen.
var retina = (window.devicePixelRatio || (window.screen.deviceXDPI / window.screen.logicalXDPI)) > 1;


// @property canvas: Boolean
// `true` when the browser supports [`<canvas>`](https://developer.mozilla.org/docs/Web/API/Canvas_API).
var canvas = (function () {
        return !!document.createElement('canvas').getContext;
}());

// @property svg: Boolean
// `true` when the browser supports [SVG](https://developer.mozilla.org/docs/Web/SVG).
var svg = !!(document.createElementNS && svgCreate('svg').createSVGRect);

// @property vml: Boolean
// `true` if the browser supports [VML](https://en.wikipedia.org/wiki/Vector_Markup_Language).
var vml = !svg && (function () {
        try {
                var div = document.createElement('div');
                div.innerHTML = '<v:shape adj="1"/>';

                var shape = div.firstChild;
                shape.style.behavior = 'url(#default#VML)';

                return shape && (typeof shape.adj === 'object');

        } catch (e) {
                return false;
        }
}());


function userAgentContains(str) {
        return navigator.userAgent.toLowerCase().indexOf(str) >= 0;
}


var Browser = (Object.freeze || Object)({
        ie: ie,
        ielt9: ielt9,
        edge: edge,
        webkit: webkit,
        android: android,
        android23: android23,
        opera: opera,
        chrome: chrome,
        gecko: gecko,
        safari: safari,
        phantom: phantom,
        opera12: opera12,
        win: win,
        ie3d: ie3d,
        webkit3d: webkit3d,
        gecko3d: gecko3d,
        any3d: any3d,
        mobile: mobile,
        mobileWebkit: mobileWebkit,
        mobileWebkit3d: mobileWebkit3d,
        msPointer: msPointer,
        pointer: pointer,
        touch: touch,
        mobileOpera: mobileOpera,
        mobileGecko: mobileGecko,
        retina: retina,
        canvas: canvas,
        svg: svg,
        vml: vml
});

/*
 * Extends L.DomEvent to provide touch support for Internet Explorer and Windows-based devices.
 */


var POINTER_DOWN =   msPointer ? 'MSPointerDown'   : 'pointerdown';
var POINTER_MOVE =   msPointer ? 'MSPointerMove'   : 'pointermove';
var POINTER_UP =     msPointer ? 'MSPointerUp'     : 'pointerup';
var POINTER_CANCEL = msPointer ? 'MSPointerCancel' : 'pointercancel';
var TAG_WHITE_LIST = ['INPUT', 'SELECT', 'OPTION'];
var _pointers = {};
var _pointerDocListener = false;

// DomEvent.DoubleTap needs to know about this
var _pointersCount = 0;

// Provides a touch events wrapper for (ms)pointer events.
// ref http://www.w3.org/TR/pointerevents/ https://www.w3.org/Bugs/Public/show_bug.cgi?id=22890

function addPointerListener(obj, type, handler, id) {
        if (type === 'touchstart') {
                _addPointerStart(obj, handler, id);

        } else if (type === 'touchmove') {
                _addPointerMove(obj, handler, id);

        } else if (type === 'touchend') {
                _addPointerEnd(obj, handler, id);
        }

        return this;
}

function removePointerListener(obj, type, id) {
        var handler = obj['_leaflet_' + type + id];

        if (type === 'touchstart') {
                obj.removeEventListener(POINTER_DOWN, handler, false);

        } else if (type === 'touchmove') {
                obj.removeEventListener(POINTER_MOVE, handler, false);

        } else if (type === 'touchend') {
                obj.removeEventListener(POINTER_UP, handler, false);
                obj.removeEventListener(POINTER_CANCEL, handler, false);
        }

        return this;
}

function _addPointerStart(obj, handler, id) {
        var onDown = bind(function (e) {
                if (e.pointerType !== 'mouse' && e.pointerType !== e.MSPOINTER_TYPE_MOUSE && e.pointerType !== e.MSPOINTER_TYPE_MOUSE) {
                        // In IE11, some touch events needs to fire for form controls, or
                        // the controls will stop working. We keep a whitelist of tag names that
                        // need these events. For other target tags, we prevent default on the event.
                        if (TAG_WHITE_LIST.indexOf(e.target.tagName) < 0) {
                                preventDefault(e);
                        } else {
                                return;
                        }
                }

                _handlePointer(e, handler);
        });

        obj['_leaflet_touchstart' + id] = onDown;
        obj.addEventListener(POINTER_DOWN, onDown, false);

        // need to keep track of what pointers and how many are active to provide e.touches emulation
        if (!_pointerDocListener) {
                // we listen documentElement as any drags that end by moving the touch off the screen get fired there
                document.documentElement.addEventListener(POINTER_DOWN, _globalPointerDown, true);
                document.documentElement.addEventListener(POINTER_MOVE, _globalPointerMove, true);
                document.documentElement.addEventListener(POINTER_UP, _globalPointerUp, true);
                document.documentElement.addEventListener(POINTER_CANCEL, _globalPointerUp, true);

                _pointerDocListener = true;
        }
}

function _globalPointerDown(e) {
        _pointers[e.pointerId] = e;
        _pointersCount++;
}

function _globalPointerMove(e) {
        if (_pointers[e.pointerId]) {
                _pointers[e.pointerId] = e;
        }
}

function _globalPointerUp(e) {
        delete _pointers[e.pointerId];
        _pointersCount--;
}

function _handlePointer(e, handler) {
        e.touches = [];
        for (var i in _pointers) {
                e.touches.push(_pointers[i]);
        }
        e.changedTouches = [e];

        handler(e);
}

function _addPointerMove(obj, handler, id) {
        var onMove = function (e) {
                // don't fire touch moves when mouse isn't down
                if ((e.pointerType === e.MSPOINTER_TYPE_MOUSE || e.pointerType === 'mouse') && e.buttons === 0) { return; }

                _handlePointer(e, handler);
        };

        obj['_leaflet_touchmove' + id] = onMove;
        obj.addEventListener(POINTER_MOVE, onMove, false);
}

function _addPointerEnd(obj, handler, id) {
        var onUp = function (e) {
                _handlePointer(e, handler);
        };

        obj['_leaflet_touchend' + id] = onUp;
        obj.addEventListener(POINTER_UP, onUp, false);
        obj.addEventListener(POINTER_CANCEL, onUp, false);
}

/*
 * Extends the event handling code with double tap support for mobile browsers.
 */

var _touchstart = msPointer ? 'MSPointerDown' : pointer ? 'pointerdown' : 'touchstart';
var _touchend = msPointer ? 'MSPointerUp' : pointer ? 'pointerup' : 'touchend';
var _pre = '_leaflet_';

// inspired by Zepto touch code by Thomas Fuchs
function addDoubleTapListener(obj, handler, id) {
        var last, touch$$1,
            doubleTap = false,
            delay = 250;

        function onTouchStart(e) {
                var count;

                if (pointer) {
                        if ((!edge) || e.pointerType === 'mouse') { return; }
                        count = _pointersCount;
                } else {
                        count = e.touches.length;
                }

                if (count > 1) { return; }

                var now = Date.now(),
                    delta = now - (last || now);

                touch$$1 = e.touches ? e.touches[0] : e;
                doubleTap = (delta > 0 && delta <= delay);
                last = now;
        }

        function onTouchEnd(e) {
                if (doubleTap && !touch$$1.cancelBubble) {
                        if (pointer) {
                                if ((!edge) || e.pointerType === 'mouse') { return; }
                                // work around .type being readonly with MSPointer* events
                                var newTouch = {},
                                    prop, i;

                                for (i in touch$$1) {
                                        prop = touch$$1[i];
                                        newTouch[i] = prop && prop.bind ? prop.bind(touch$$1) : prop;
                                }
                                touch$$1 = newTouch;
                        }
                        touch$$1.type = 'dblclick';
                        handler(touch$$1);
                        last = null;
                }
        }

        obj[_pre + _touchstart + id] = onTouchStart;
        obj[_pre + _touchend + id] = onTouchEnd;
        obj[_pre + 'dblclick' + id] = handler;

        obj.addEventListener(_touchstart, onTouchStart, false);
        obj.addEventListener(_touchend, onTouchEnd, false);

        // On some platforms (notably, chrome<55 on win10 + touchscreen + mouse),
        // the browser doesn't fire touchend/pointerup events but does fire
        // native dblclicks. See #4127.
        // Edge 14 also fires native dblclicks, but only for pointerType mouse, see #5180.
        obj.addEventListener('dblclick', handler, false);

        return this;
}

function removeDoubleTapListener(obj, id) {
        var touchstart = obj[_pre + _touchstart + id],
            touchend = obj[_pre + _touchend + id],
            dblclick = obj[_pre + 'dblclick' + id];

        obj.removeEventListener(_touchstart, touchstart, false);
        obj.removeEventListener(_touchend, touchend, false);
        if (!edge) {
                obj.removeEventListener('dblclick', dblclick, false);
        }

        return this;
}

/*
 * @namespace DomEvent
 * Utility functions to work with the [DOM events](https://developer.mozilla.org/docs/Web/API/Event), used by Leaflet internally.
 */

// Inspired by John Resig, Dean Edwards and YUI addEvent implementations.

// @function on(el: HTMLElement, types: String, fn: Function, context?: Object): this
// Adds a listener function (`fn`) to a particular DOM event type of the
// element `el`. You can optionally specify the context of the listener
// (object the `this` keyword will point to). You can also pass several
// space-separated types (e.g. `'click dblclick'`).

// @alternative
// @function on(el: HTMLElement, eventMap: Object, context?: Object): this
// Adds a set of type/listener pairs, e.g. `{click: onClick, mousemove: onMouseMove}`
function on(obj, types, fn, context) {

        if (typeof types === 'object') {
                for (var type in types) {
                        addOne(obj, type, types[type], fn);
                }
        } else {
                types = splitWords(types);

                for (var i = 0, len = types.length; i < len; i++) {
                        addOne(obj, types[i], fn, context);
                }
        }

        return this;
}

var eventsKey = '_leaflet_events';

// @function off(el: HTMLElement, types: String, fn: Function, context?: Object): this
// Removes a previously added listener function. If no function is specified,
// it will remove all the listeners of that particular DOM event from the element.
// Note that if you passed a custom context to on, you must pass the same
// context to `off` in order to remove the listener.

// @alternative
// @function off(el: HTMLElement, eventMap: Object, context?: Object): this
// Removes a set of type/listener pairs, e.g. `{click: onClick, mousemove: onMouseMove}`

// @alternative
// @function off(el: HTMLElement): this
// Removes all known event listeners
function off(obj, types, fn, context) {

        if (typeof types === 'object') {
                for (var type in types) {
                        removeOne(obj, type, types[type], fn);
                }
        } else if (types) {
                types = splitWords(types);

                for (var i = 0, len = types.length; i < len; i++) {
                        removeOne(obj, types[i], fn, context);
                }
        } else {
                for (var j in obj[eventsKey]) {
                        removeOne(obj, j, obj[eventsKey][j]);
                }
                delete obj[eventsKey];
        }
}

function addOne(obj, type, fn, context) {
        var id = type + stamp(fn) + (context ? '_' + stamp(context) : '');

        if (obj[eventsKey] && obj[eventsKey][id]) { return this; }

        var handler = function (e) {
                return fn.call(context || obj, e || window.event);
        };

        var originalHandler = handler;

        if (pointer && type.indexOf('touch') === 0) {
                // Needs DomEvent.Pointer.js
                addPointerListener(obj, type, handler, id);

        } else if (touch && (type === 'dblclick') && addDoubleTapListener &&
                   !(pointer && chrome)) {
                // Chrome >55 does not need the synthetic dblclicks from addDoubleTapListener
                // See #5180
                addDoubleTapListener(obj, handler, id);

        } else if ('addEventListener' in obj) {

                if (type === 'mousewheel') {
                        obj.addEventListener('onwheel' in obj ? 'wheel' : 'mousewheel', handler, false);

                } else if ((type === 'mouseenter') || (type === 'mouseleave')) {
                        handler = function (e) {
                                e = e || window.event;
                                if (isExternalTarget(obj, e)) {
                                        originalHandler(e);
                                }
                        };
                        obj.addEventListener(type === 'mouseenter' ? 'mouseover' : 'mouseout', handler, false);

                } else {
                        if (type === 'click' && android) {
                                handler = function (e) {
                                        filterClick(e, originalHandler);
                                };
                        }
                        obj.addEventListener(type, handler, false);
                }

        } else if ('attachEvent' in obj) {
                obj.attachEvent('on' + type, handler);
        }

        obj[eventsKey] = obj[eventsKey] || {};
        obj[eventsKey][id] = handler;
}

function removeOne(obj, type, fn, context) {

        var id = type + stamp(fn) + (context ? '_' + stamp(context) : ''),
            handler = obj[eventsKey] && obj[eventsKey][id];

        if (!handler) { return this; }

        if (pointer && type.indexOf('touch') === 0) {
                removePointerListener(obj, type, id);

        } else if (touch && (type === 'dblclick') && removeDoubleTapListener) {
                removeDoubleTapListener(obj, id);

        } else if ('removeEventListener' in obj) {

                if (type === 'mousewheel') {
                        obj.removeEventListener('onwheel' in obj ? 'wheel' : 'mousewheel', handler, false);

                } else {
                        obj.removeEventListener(
                                type === 'mouseenter' ? 'mouseover' :
                                type === 'mouseleave' ? 'mouseout' : type, handler, false);
                }

        } else if ('detachEvent' in obj) {
                obj.detachEvent('on' + type, handler);
        }

        obj[eventsKey][id] = null;
}

// @function stopPropagation(ev: DOMEvent): this
// Stop the given event from propagation to parent elements. Used inside the listener functions:
// ```js
// L.DomEvent.on(div, 'click', function (ev) {
//      L.DomEvent.stopPropagation(ev);
// });
// ```
function stopPropagation(e) {

        if (e.stopPropagation) {
                e.stopPropagation();
        } else if (e.originalEvent) {  // In case of Leaflet event.
                e.originalEvent._stopped = true;
        } else {
                e.cancelBubble = true;
        }
        skipped(e);

        return this;
}

// @function disableScrollPropagation(el: HTMLElement): this
// Adds `stopPropagation` to the element's `'mousewheel'` events (plus browser variants).
function disableScrollPropagation(el) {
        return addOne(el, 'mousewheel', stopPropagation);
}

// @function disableClickPropagation(el: HTMLElement): this
// Adds `stopPropagation` to the element's `'click'`, `'doubleclick'`,
// `'mousedown'` and `'touchstart'` events (plus browser variants).
function disableClickPropagation(el) {
        on(el, 'mousedown touchstart dblclick', stopPropagation);
        addOne(el, 'click', fakeStop);
        return this;
}

// @function preventDefault(ev: DOMEvent): this
// Prevents the default action of the DOM Event `ev` from happening (such as
// following a link in the href of the a element, or doing a POST request
// with page reload when a `<form>` is submitted).
// Use it inside listener functions.
function preventDefault(e) {
        if (e.preventDefault) {
                e.preventDefault();
        } else {
                e.returnValue = false;
        }
        return this;
}

// @function stop(ev): this
// Does `stopPropagation` and `preventDefault` at the same time.
function stop(e) {
        preventDefault(e);
        stopPropagation(e);
        return this;
}

// @function getMousePosition(ev: DOMEvent, container?: HTMLElement): Point
// Gets normalized mouse position from a DOM event relative to the
// `container` or to the whole page if not specified.
function getMousePosition(e, container) {
        if (!container) {
                return new Point(e.clientX, e.clientY);
        }

        var rect = container.getBoundingClientRect();

        return new Point(
                e.clientX - rect.left - container.clientLeft,
                e.clientY - rect.top - container.clientTop);
}

// Chrome on Win scrolls double the pixels as in other platforms (see #4538),
// and Firefox scrolls device pixels, not CSS pixels
var wheelPxFactor =
        (win && chrome) ? 2 * window.devicePixelRatio :
        gecko ? window.devicePixelRatio : 1;

// @function getWheelDelta(ev: DOMEvent): Number
// Gets normalized wheel delta from a mousewheel DOM event, in vertical
// pixels scrolled (negative if scrolling down).
// Events from pointing devices without precise scrolling are mapped to
// a best guess of 60 pixels.
function getWheelDelta(e) {
        return (edge) ? e.wheelDeltaY / 2 : // Don't trust window-geometry-based delta
               (e.deltaY && e.deltaMode === 0) ? -e.deltaY / wheelPxFactor : // Pixels
               (e.deltaY && e.deltaMode === 1) ? -e.deltaY * 20 : // Lines
               (e.deltaY && e.deltaMode === 2) ? -e.deltaY * 60 : // Pages
               (e.deltaX || e.deltaZ) ? 0 :     // Skip horizontal/depth wheel events
               e.wheelDelta ? (e.wheelDeltaY || e.wheelDelta) / 2 : // Legacy IE pixels
               (e.detail && Math.abs(e.detail) < 32765) ? -e.detail * 20 : // Legacy Moz lines
               e.detail ? e.detail / -32765 * 60 : // Legacy Moz pages
               0;
}

var skipEvents = {};

function fakeStop(e) {
        // fakes stopPropagation by setting a special event flag, checked/reset with skipped(e)
        skipEvents[e.type] = true;
}

function skipped(e) {
        var events = skipEvents[e.type];
        // reset when checking, as it's only used in map container and propagates outside of the map
        skipEvents[e.type] = false;
        return events;
}

// check if element really left/entered the event target (for mouseenter/mouseleave)
function isExternalTarget(el, e) {

        var related = e.relatedTarget;

        if (!related) { return true; }

        try {
                while (related && (related !== el)) {
                        related = related.parentNode;
                }
        } catch (err) {
                return false;
        }
        return (related !== el);
}

var lastClick;

// this is a horrible workaround for a bug in Android where a single touch triggers two click events
function filterClick(e, handler) {
        var timeStamp = (e.timeStamp || (e.originalEvent && e.originalEvent.timeStamp)),
            elapsed = lastClick && (timeStamp - lastClick);

        // are they closer together than 500ms yet more than 100ms?
        // Android typically triggers them ~300ms apart while multiple listeners
        // on the same event should be triggered far faster;
        // or check if click is simulated on the element, and if it is, reject any non-simulated events

        if ((elapsed && elapsed > 100 && elapsed < 500) || (e.target._simulatedClick && !e._simulated)) {
                stop(e);
                return;
        }
        lastClick = timeStamp;

        handler(e);
}




var DomEvent = (Object.freeze || Object)({
        on: on,
        off: off,
        stopPropagation: stopPropagation,
        disableScrollPropagation: disableScrollPropagation,
        disableClickPropagation: disableClickPropagation,
        preventDefault: preventDefault,
        stop: stop,
        getMousePosition: getMousePosition,
        getWheelDelta: getWheelDelta,
        fakeStop: fakeStop,
        skipped: skipped,
        isExternalTarget: isExternalTarget,
        addListener: on,
        removeListener: off
});

/*
 * @namespace DomUtil
 *
 * Utility functions to work with the [DOM](https://developer.mozilla.org/docs/Web/API/Document_Object_Model)
 * tree, used by Leaflet internally.
 *
 * Most functions expecting or returning a `HTMLElement` also work for
 * SVG elements. The only difference is that classes refer to CSS classes
 * in HTML and SVG classes in SVG.
 */


// @property TRANSFORM: String
// Vendor-prefixed transform style name (e.g. `'webkitTransform'` for WebKit).
var TRANSFORM = testProp(
        ['transform', 'WebkitTransform', 'OTransform', 'MozTransform', 'msTransform']);

// webkitTransition comes first because some browser versions that drop vendor prefix don't do
// the same for the transitionend event, in particular the Android 4.1 stock browser

// @property TRANSITION: String
// Vendor-prefixed transition style name.
var TRANSITION = testProp(
        ['webkitTransition', 'transition', 'OTransition', 'MozTransition', 'msTransition']);

// @property TRANSITION_END: String
// Vendor-prefixed transitionend event name.
var TRANSITION_END =
        TRANSITION === 'webkitTransition' || TRANSITION === 'OTransition' ? TRANSITION + 'End' : 'transitionend';


// @function get(id: String|HTMLElement): HTMLElement
// Returns an element given its DOM id, or returns the element itself
// if it was passed directly.
function get(id) {
        return typeof id === 'string' ? document.getElementById(id) : id;
}

// @function getStyle(el: HTMLElement, styleAttrib: String): String
// Returns the value for a certain style attribute on an element,
// including computed values or values set through CSS.
function getStyle(el, style) {
        var value = el.style[style] || (el.currentStyle && el.currentStyle[style]);

        if ((!value || value === 'auto') && document.defaultView) {
                var css = document.defaultView.getComputedStyle(el, null);
                value = css ? css[style] : null;
        }
        return value === 'auto' ? null : value;
}

// @function create(tagName: String, className?: String, container?: HTMLElement): HTMLElement
// Creates an HTML element with `tagName`, sets its class to `className`, and optionally appends it to `container` element.
function create$1(tagName, className, container) {
        var el = document.createElement(tagName);
        el.className = className || '';

        if (container) {
                container.appendChild(el);
        }
        return el;
}

// @function remove(el: HTMLElement)
// Removes `el` from its parent element
function remove(el) {
        var parent = el.parentNode;
        if (parent) {
                parent.removeChild(el);
        }
}

// @function empty(el: HTMLElement)
// Removes all of `el`'s children elements from `el`
function empty(el) {
        while (el.firstChild) {
                el.removeChild(el.firstChild);
        }
}

// @function toFront(el: HTMLElement)
// Makes `el` the last child of its parent, so it renders in front of the other children.
function toFront(el) {
        var parent = el.parentNode;
        if (parent.lastChild !== el) {
                parent.appendChild(el);
        }
}

// @function toBack(el: HTMLElement)
// Makes `el` the first child of its parent, so it renders behind the other children.
function toBack(el) {
        var parent = el.parentNode;
        if (parent.firstChild !== el) {
                parent.insertBefore(el, parent.firstChild);
        }
}

// @function hasClass(el: HTMLElement, name: String): Boolean
// Returns `true` if the element's class attribute contains `name`.
function hasClass(el, name) {
        if (el.classList !== undefined) {
                return el.classList.contains(name);
        }
        var className = getClass(el);
        return className.length > 0 && new RegExp('(^|\\s)' + name + '(\\s|$)').test(className);
}

// @function addClass(el: HTMLElement, name: String)
// Adds `name` to the element's class attribute.
function addClass(el, name) {
        if (el.classList !== undefined) {
                var classes = splitWords(name);
                for (var i = 0, len = classes.length; i < len; i++) {
                        el.classList.add(classes[i]);
                }
        } else if (!hasClass(el, name)) {
                var className = getClass(el);
                setClass(el, (className ? className + ' ' : '') + name);
        }
}

// @function removeClass(el: HTMLElement, name: String)
// Removes `name` from the element's class attribute.
function removeClass(el, name) {
        if (el.classList !== undefined) {
                el.classList.remove(name);
        } else {
                setClass(el, trim((' ' + getClass(el) + ' ').replace(' ' + name + ' ', ' ')));
        }
}

// @function setClass(el: HTMLElement, name: String)
// Sets the element's class.
function setClass(el, name) {
        if (el.className.baseVal === undefined) {
                el.className = name;
        } else {
                // in case of SVG element
                el.className.baseVal = name;
        }
}

// @function getClass(el: HTMLElement): String
// Returns the element's class.
function getClass(el) {
        return el.className.baseVal === undefined ? el.className : el.className.baseVal;
}

// @function setOpacity(el: HTMLElement, opacity: Number)
// Set the opacity of an element (including old IE support).
// `opacity` must be a number from `0` to `1`.
function setOpacity(el, value) {
        if ('opacity' in el.style) {
                el.style.opacity = value;
        } else if ('filter' in el.style) {
                _setOpacityIE(el, value);
        }
}

function _setOpacityIE(el, value) {
        var filter = false,
            filterName = 'DXImageTransform.Microsoft.Alpha';

        // filters collection throws an error if we try to retrieve a filter that doesn't exist
        try {
                filter = el.filters.item(filterName);
        } catch (e) {
                // don't set opacity to 1 if we haven't already set an opacity,
                // it isn't needed and breaks transparent pngs.
                if (value === 1) { return; }
        }

        value = Math.round(value * 100);

        if (filter) {
                filter.Enabled = (value !== 100);
                filter.Opacity = value;
        } else {
                el.style.filter += ' progid:' + filterName + '(opacity=' + value + ')';
        }
}

// @function testProp(props: String[]): String|false
// Goes through the array of style names and returns the first name
// that is a valid style name for an element. If no such name is found,
// it returns false. Useful for vendor-prefixed styles like `transform`.
function testProp(props) {
        var style = document.documentElement.style;

        for (var i = 0; i < props.length; i++) {
                if (props[i] in style) {
                        return props[i];
                }
        }
        return false;
}

// @function setTransform(el: HTMLElement, offset: Point, scale?: Number)
// Resets the 3D CSS transform of `el` so it is translated by `offset` pixels
// and optionally scaled by `scale`. Does not have an effect if the
// browser doesn't support 3D CSS transforms.
function setTransform(el, offset, scale) {
        var pos = offset || new Point(0, 0);

        el.style[TRANSFORM] =
                (ie3d ?
                        'translate(' + pos.x + 'px,' + pos.y + 'px)' :
                        'translate3d(' + pos.x + 'px,' + pos.y + 'px,0)') +
                (scale ? ' scale(' + scale + ')' : '');
}

// @function setPosition(el: HTMLElement, position: Point)
// Sets the position of `el` to coordinates specified by `position`,
// using CSS translate or top/left positioning depending on the browser
// (used by Leaflet internally to position its layers).
function setPosition(el, point) {

        /*eslint-disable */
        el._leaflet_pos = point;
        /*eslint-enable */

        if (any3d) {
                setTransform(el, point);
        } else {
                el.style.left = point.x + 'px';
                el.style.top = point.y + 'px';
        }
}

// @function getPosition(el: HTMLElement): Point
// Returns the coordinates of an element previously positioned with setPosition.
function getPosition(el) {
        // this method is only used for elements previously positioned using setPosition,
        // so it's safe to cache the position for performance

        return el._leaflet_pos || new Point(0, 0);
}

// @function disableTextSelection()
// Prevents the user from generating `selectstart` DOM events, usually generated
// when the user drags the mouse through a page with text. Used internally
// by Leaflet to override the behaviour of any click-and-drag interaction on
// the map. Affects drag interactions on the whole document.

// @function enableTextSelection()
// Cancels the effects of a previous [`L.DomUtil.disableTextSelection`](#domutil-disabletextselection).
var disableTextSelection;
var enableTextSelection;
var _userSelect;
if ('onselectstart' in document) {
        disableTextSelection = function () {
                on(window, 'selectstart', preventDefault);
        };
        enableTextSelection = function () {
                off(window, 'selectstart', preventDefault);
        };
} else {
        var userSelectProperty = testProp(
                ['userSelect', 'WebkitUserSelect', 'OUserSelect', 'MozUserSelect', 'msUserSelect']);

        disableTextSelection = function () {
                if (userSelectProperty) {
                        var style = document.documentElement.style;
                        _userSelect = style[userSelectProperty];
                        style[userSelectProperty] = 'none';
                }
        };
        enableTextSelection = function () {
                if (userSelectProperty) {
                        document.documentElement.style[userSelectProperty] = _userSelect;
                        _userSelect = undefined;
                }
        };
}

// @function disableImageDrag()
// As [`L.DomUtil.disableTextSelection`](#domutil-disabletextselection), but
// for `dragstart` DOM events, usually generated when the user drags an image.
function disableImageDrag() {
        on(window, 'dragstart', preventDefault);
}

// @function enableImageDrag()
// Cancels the effects of a previous [`L.DomUtil.disableImageDrag`](#domutil-disabletextselection).
function enableImageDrag() {
        off(window, 'dragstart', preventDefault);
}

var _outlineElement;
var _outlineStyle;
// @function preventOutline(el: HTMLElement)
// Makes the [outline](https://developer.mozilla.org/docs/Web/CSS/outline)
// of the element `el` invisible. Used internally by Leaflet to prevent
// focusable elements from displaying an outline when the user performs a
// drag interaction on them.
function preventOutline(element) {
        while (element.tabIndex === -1) {
                element = element.parentNode;
        }
        if (!element.style) { return; }
        restoreOutline();
        _outlineElement = element;
        _outlineStyle = element.style.outline;
        element.style.outline = 'none';
        on(window, 'keydown', restoreOutline);
}

// @function restoreOutline()
// Cancels the effects of a previous [`L.DomUtil.preventOutline`]().
function restoreOutline() {
        if (!_outlineElement) { return; }
        _outlineElement.style.outline = _outlineStyle;
        _outlineElement = undefined;
        _outlineStyle = undefined;
        off(window, 'keydown', restoreOutline);
}


var DomUtil = (Object.freeze || Object)({
        TRANSFORM: TRANSFORM,
        TRANSITION: TRANSITION,
        TRANSITION_END: TRANSITION_END,
        get: get,
        getStyle: getStyle,
        create: create$1,
        remove: remove,
        empty: empty,
        toFront: toFront,
        toBack: toBack,
        hasClass: hasClass,
        addClass: addClass,
        removeClass: removeClass,
        setClass: setClass,
        getClass: getClass,
        setOpacity: setOpacity,
        testProp: testProp,
        setTransform: setTransform,
        setPosition: setPosition,
        getPosition: getPosition,
        disableTextSelection: disableTextSelection,
        enableTextSelection: enableTextSelection,
        disableImageDrag: disableImageDrag,
        enableImageDrag: enableImageDrag,
        preventOutline: preventOutline,
        restoreOutline: restoreOutline
});

/*
 * @class PosAnimation
 * @aka L.PosAnimation
 * @inherits Evented
 * Used internally for panning animations, utilizing CSS3 Transitions for modern browsers and a timer fallback for IE6-9.
 *
 * @example
 * ```js
 * var fx = new L.PosAnimation();
 * fx.run(el, [300, 500], 0.5);
 * ```
 *
 * @constructor L.PosAnimation()
 * Creates a `PosAnimation` object.
 *
 */

var PosAnimation = Evented.extend({

        // @method run(el: HTMLElement, newPos: Point, duration?: Number, easeLinearity?: Number)
        // Run an animation of a given element to a new position, optionally setting
        // duration in seconds (`0.25` by default) and easing linearity factor (3rd
        // argument of the [cubic bezier curve](http://cubic-bezier.com/#0,0,.5,1),
        // `0.5` by default).
        run: function (el, newPos, duration, easeLinearity) {
                this.stop();

                this._el = el;
                this._inProgress = true;
                this._duration = duration || 0.25;
                this._easeOutPower = 1 / Math.max(easeLinearity || 0.5, 0.2);

                this._startPos = getPosition(el);
                this._offset = newPos.subtract(this._startPos);
                this._startTime = +new Date();

                // @event start: Event
                // Fired when the animation starts
                this.fire('start');

                this._animate();
        },

        // @method stop()
        // Stops the animation (if currently running).
        stop: function () {
                if (!this._inProgress) { return; }

                this._step(true);
                this._complete();
        },

        _animate: function () {
                // animation loop
                this._animId = requestAnimFrame(this._animate, this);
                this._step();
        },

        _step: function (round) {
                var elapsed = (+new Date()) - this._startTime,
                    duration = this._duration * 1000;

                if (elapsed < duration) {
                        this._runFrame(this._easeOut(elapsed / duration), round);
                } else {
                        this._runFrame(1);
                        this._complete();
                }
        },

        _runFrame: function (progress, round) {
                var pos = this._startPos.add(this._offset.multiplyBy(progress));
                if (round) {
                        pos._round();
                }
                setPosition(this._el, pos);

                // @event step: Event
                // Fired continuously during the animation.
                this.fire('step');
        },

        _complete: function () {
                cancelAnimFrame(this._animId);

                this._inProgress = false;
                // @event end: Event
                // Fired when the animation ends.
                this.fire('end');
        },

        _easeOut: function (t) {
                return 1 - Math.pow(1 - t, this._easeOutPower);
        }
});

/*
 * @class Map
 * @aka L.Map
 * @inherits Evented
 *
 * The central class of the API — it is used to create a map on a page and manipulate it.
 *
 * @example
 *
 * ```js
 * // initialize the map on the "map" div with a given center and zoom
 * var map = L.map('map', {
 *      center: [51.505, -0.09],
 *      zoom: 13
 * });
 * ```
 *
 */

var Map = Evented.extend({

        options: {
                // @section Map State Options
                // @option crs: CRS = L.CRS.EPSG3857
                // The [Coordinate Reference System](#crs) to use. Don't change this if you're not
                // sure what it means.
                crs: EPSG3857,

                // @option center: LatLng = undefined
                // Initial geographic center of the map
                center: undefined,

                // @option zoom: Number = undefined
                // Initial map zoom level
                zoom: undefined,

                // @option minZoom: Number = *
                // Minimum zoom level of the map.
                // If not specified and at least one `GridLayer` or `TileLayer` is in the map,
                // the lowest of their `minZoom` options will be used instead.
                minZoom: undefined,

                // @option maxZoom: Number = *
                // Maximum zoom level of the map.
                // If not specified and at least one `GridLayer` or `TileLayer` is in the map,
                // the highest of their `maxZoom` options will be used instead.
                maxZoom: undefined,

                // @option layers: Layer[] = []
                // Array of layers that will be added to the map initially
                layers: [],

                // @option maxBounds: LatLngBounds = null
                // When this option is set, the map restricts the view to the given
                // geographical bounds, bouncing the user back if the user tries to pan
                // outside the view. To set the restriction dynamically, use
                // [`setMaxBounds`](#map-setmaxbounds) method.
                maxBounds: undefined,

                // @option renderer: Renderer = *
                // The default method for drawing vector layers on the map. `L.SVG`
                // or `L.Canvas` by default depending on browser support.
                renderer: undefined,


                // @section Animation Options
                // @option zoomAnimation: Boolean = true
                // Whether the map zoom animation is enabled. By default it's enabled
                // in all browsers that support CSS3 Transitions except Android.
                zoomAnimation: true,

                // @option zoomAnimationThreshold: Number = 4
                // Won't animate zoom if the zoom difference exceeds this value.
                zoomAnimationThreshold: 4,

                // @option fadeAnimation: Boolean = true
                // Whether the tile fade animation is enabled. By default it's enabled
                // in all browsers that support CSS3 Transitions except Android.
                fadeAnimation: true,

                // @option markerZoomAnimation: Boolean = true
                // Whether markers animate their zoom with the zoom animation, if disabled
                // they will disappear for the length of the animation. By default it's
                // enabled in all browsers that support CSS3 Transitions except Android.
                markerZoomAnimation: true,

                // @option transform3DLimit: Number = 2^23
                // Defines the maximum size of a CSS translation transform. The default
                // value should not be changed unless a web browser positions layers in
                // the wrong place after doing a large `panBy`.
                transform3DLimit: 8388608, // Precision limit of a 32-bit float

                // @section Interaction Options
                // @option zoomSnap: Number = 1
                // Forces the map's zoom level to always be a multiple of this, particularly
                // right after a [`fitBounds()`](#map-fitbounds) or a pinch-zoom.
                // By default, the zoom level snaps to the nearest integer; lower values
                // (e.g. `0.5` or `0.1`) allow for greater granularity. A value of `0`
                // means the zoom level will not be snapped after `fitBounds` or a pinch-zoom.
                zoomSnap: 1,

                // @option zoomDelta: Number = 1
                // Controls how much the map's zoom level will change after a
                // [`zoomIn()`](#map-zoomin), [`zoomOut()`](#map-zoomout), pressing `+`
                // or `-` on the keyboard, or using the [zoom controls](#control-zoom).
                // Values smaller than `1` (e.g. `0.5`) allow for greater granularity.
                zoomDelta: 1,

                // @option trackResize: Boolean = true
                // Whether the map automatically handles browser window resize to update itself.
                trackResize: true
        },

        initialize: function (id, options) { // (HTMLElement or String, Object)
                options = setOptions(this, options);

                this._initContainer(id);
                this._initLayout();

                // hack for https://github.com/Leaflet/Leaflet/issues/1980
                this._onResize = bind(this._onResize, this);

                this._initEvents();

                if (options.maxBounds) {
                        this.setMaxBounds(options.maxBounds);
                }

                if (options.zoom !== undefined) {
                        this._zoom = this._limitZoom(options.zoom);
                }

                if (options.center && options.zoom !== undefined) {
                        this.setView(toLatLng(options.center), options.zoom, {reset: true});
                }

                this._handlers = [];
                this._layers = {};
                this._zoomBoundLayers = {};
                this._sizeChanged = true;

                this.callInitHooks();

                // don't animate on browsers without hardware-accelerated transitions or old Android/Opera
                this._zoomAnimated = TRANSITION && any3d && !mobileOpera &&
                                this.options.zoomAnimation;

                // zoom transitions run with the same duration for all layers, so if one of transitionend events
                // happens after starting zoom animation (propagating to the map pane), we know that it ended globally
                if (this._zoomAnimated) {
                        this._createAnimProxy();
                        on(this._proxy, TRANSITION_END, this._catchTransitionEnd, this);
                }

                this._addLayers(this.options.layers);
        },


        // @section Methods for modifying map state

        // @method setView(center: LatLng, zoom: Number, options?: Zoom/pan options): this
        // Sets the view of the map (geographical center and zoom) with the given
        // animation options.
        setView: function (center, zoom, options) {

                zoom = zoom === undefined ? this._zoom : this._limitZoom(zoom);
                center = this._limitCenter(toLatLng(center), zoom, this.options.maxBounds);
                options = options || {};

                this._stop();

                if (this._loaded && !options.reset && options !== true) {

                        if (options.animate !== undefined) {
                                options.zoom = extend({animate: options.animate}, options.zoom);
                                options.pan = extend({animate: options.animate, duration: options.duration}, options.pan);
                        }

                        // try animating pan or zoom
                        var moved = (this._zoom !== zoom) ?
                                this._tryAnimatedZoom && this._tryAnimatedZoom(center, zoom, options.zoom) :
                                this._tryAnimatedPan(center, options.pan);

                        if (moved) {
                                // prevent resize handler call, the view will refresh after animation anyway
                                clearTimeout(this._sizeTimer);
                                return this;
                        }
                }

                // animation didn't start, just reset the map view
                this._resetView(center, zoom);

                return this;
        },

        // @method setZoom(zoom: Number, options?: Zoom/pan options): this
        // Sets the zoom of the map.
        setZoom: function (zoom, options) {
                if (!this._loaded) {
                        this._zoom = zoom;
                        return this;
                }
                return this.setView(this.getCenter(), zoom, {zoom: options});
        },

        // @method zoomIn(delta?: Number, options?: Zoom options): this
        // Increases the zoom of the map by `delta` ([`zoomDelta`](#map-zoomdelta) by default).
        zoomIn: function (delta, options) {
                delta = delta || (any3d ? this.options.zoomDelta : 1);
                return this.setZoom(this._zoom + delta, options);
        },

        // @method zoomOut(delta?: Number, options?: Zoom options): this
        // Decreases the zoom of the map by `delta` ([`zoomDelta`](#map-zoomdelta) by default).
        zoomOut: function (delta, options) {
                delta = delta || (any3d ? this.options.zoomDelta : 1);
                return this.setZoom(this._zoom - delta, options);
        },

        // @method setZoomAround(latlng: LatLng, zoom: Number, options: Zoom options): this
        // Zooms the map while keeping a specified geographical point on the map
        // stationary (e.g. used internally for scroll zoom and double-click zoom).
        // @alternative
        // @method setZoomAround(offset: Point, zoom: Number, options: Zoom options): this
        // Zooms the map while keeping a specified pixel on the map (relative to the top-left corner) stationary.
        setZoomAround: function (latlng, zoom, options) {
                var scale = this.getZoomScale(zoom),
                    viewHalf = this.getSize().divideBy(2),
                    containerPoint = latlng instanceof Point ? latlng : this.latLngToContainerPoint(latlng),

                    centerOffset = containerPoint.subtract(viewHalf).multiplyBy(1 - 1 / scale),
                    newCenter = this.containerPointToLatLng(viewHalf.add(centerOffset));

                return this.setView(newCenter, zoom, {zoom: options});
        },

        _getBoundsCenterZoom: function (bounds, options) {

                options = options || {};
                bounds = bounds.getBounds ? bounds.getBounds() : toLatLngBounds(bounds);

                var paddingTL = toPoint(options.paddingTopLeft || options.padding || [0, 0]),
                    paddingBR = toPoint(options.paddingBottomRight || options.padding || [0, 0]),

                    zoom = this.getBoundsZoom(bounds, false, paddingTL.add(paddingBR));

                zoom = (typeof options.maxZoom === 'number') ? Math.min(options.maxZoom, zoom) : zoom;

                if (zoom === Infinity) {
                        return {
                                center: bounds.getCenter(),
                                zoom: zoom
                        };
                }

                var paddingOffset = paddingBR.subtract(paddingTL).divideBy(2),

                    swPoint = this.project(bounds.getSouthWest(), zoom),
                    nePoint = this.project(bounds.getNorthEast(), zoom),
                    center = this.unproject(swPoint.add(nePoint).divideBy(2).add(paddingOffset), zoom);

                return {
                        center: center,
                        zoom: zoom
                };
        },

        // @method fitBounds(bounds: LatLngBounds, options?: fitBounds options): this
        // Sets a map view that contains the given geographical bounds with the
        // maximum zoom level possible.
        fitBounds: function (bounds, options) {

                bounds = toLatLngBounds(bounds);

                if (!bounds.isValid()) {
                        throw new Error('Bounds are not valid.');
                }

                var target = this._getBoundsCenterZoom(bounds, options);
                return this.setView(target.center, target.zoom, options);
        },

        // @method fitWorld(options?: fitBounds options): this
        // Sets a map view that mostly contains the whole world with the maximum
        // zoom level possible.
        fitWorld: function (options) {
                return this.fitBounds([[-90, -180], [90, 180]], options);
        },

        // @method panTo(latlng: LatLng, options?: Pan options): this
        // Pans the map to a given center.
        panTo: function (center, options) { // (LatLng)
                return this.setView(center, this._zoom, {pan: options});
        },

        // @method panBy(offset: Point, options?: Pan options): this
        // Pans the map by a given number of pixels (animated).
        panBy: function (offset, options) {
                offset = toPoint(offset).round();
                options = options || {};

                if (!offset.x && !offset.y) {
                        return this.fire('moveend');
                }
                // If we pan too far, Chrome gets issues with tiles
                // and makes them disappear or appear in the wrong place (slightly offset) #2602
                if (options.animate !== true && !this.getSize().contains(offset)) {
                        this._resetView(this.unproject(this.project(this.getCenter()).add(offset)), this.getZoom());
                        return this;
                }

                if (!this._panAnim) {
                        this._panAnim = new PosAnimation();

                        this._panAnim.on({
                                'step': this._onPanTransitionStep,
                                'end': this._onPanTransitionEnd
                        }, this);
                }

                // don't fire movestart if animating inertia
                if (!options.noMoveStart) {
                        this.fire('movestart');
                }

                // animate pan unless animate: false specified
                if (options.animate !== false) {
                        addClass(this._mapPane, 'leaflet-pan-anim');

                        var newPos = this._getMapPanePos().subtract(offset).round();
                        this._panAnim.run(this._mapPane, newPos, options.duration || 0.25, options.easeLinearity);
                } else {
                        this._rawPanBy(offset);
                        this.fire('move').fire('moveend');
                }

                return this;
        },

        // @method flyTo(latlng: LatLng, zoom?: Number, options?: Zoom/pan options): this
        // Sets the view of the map (geographical center and zoom) performing a smooth
        // pan-zoom animation.
        flyTo: function (targetCenter, targetZoom, options) {

                options = options || {};
                if (options.animate === false || !any3d) {
                        return this.setView(targetCenter, targetZoom, options);
                }

                this._stop();

                var from = this.project(this.getCenter()),
                    to = this.project(targetCenter),
                    size = this.getSize(),
                    startZoom = this._zoom;

                targetCenter = toLatLng(targetCenter);
                targetZoom = targetZoom === undefined ? startZoom : targetZoom;

                var w0 = Math.max(size.x, size.y),
                    w1 = w0 * this.getZoomScale(startZoom, targetZoom),
                    u1 = (to.distanceTo(from)) || 1,
                    rho = 1.42,
                    rho2 = rho * rho;

                function r(i) {
                        var s1 = i ? -1 : 1,
                            s2 = i ? w1 : w0,
                            t1 = w1 * w1 - w0 * w0 + s1 * rho2 * rho2 * u1 * u1,
                            b1 = 2 * s2 * rho2 * u1,
                            b = t1 / b1,
                            sq = Math.sqrt(b * b + 1) - b;

                            // workaround for floating point precision bug when sq = 0, log = -Infinite,
                            // thus triggering an infinite loop in flyTo
                            var log = sq < 0.000000001 ? -18 : Math.log(sq);

                        return log;
                }

                function sinh(n) { return (Math.exp(n) - Math.exp(-n)) / 2; }
                function cosh(n) { return (Math.exp(n) + Math.exp(-n)) / 2; }
                function tanh(n) { return sinh(n) / cosh(n); }

                var r0 = r(0);

                function w(s) { return w0 * (cosh(r0) / cosh(r0 + rho * s)); }
                function u(s) { return w0 * (cosh(r0) * tanh(r0 + rho * s) - sinh(r0)) / rho2; }

                function easeOut(t) { return 1 - Math.pow(1 - t, 1.5); }

                var start = Date.now(),
                    S = (r(1) - r0) / rho,
                    duration = options.duration ? 1000 * options.duration : 1000 * S * 0.8;

                function frame() {
                        var t = (Date.now() - start) / duration,
                            s = easeOut(t) * S;

                        if (t <= 1) {
                                this._flyToFrame = requestAnimFrame(frame, this);

                                this._move(
                                        this.unproject(from.add(to.subtract(from).multiplyBy(u(s) / u1)), startZoom),
                                        this.getScaleZoom(w0 / w(s), startZoom),
                                        {flyTo: true});

                        } else {
                                this
                                        ._move(targetCenter, targetZoom)
                                        ._moveEnd(true);
                        }
                }

                this._moveStart(true);

                frame.call(this);
                return this;
        },

        // @method flyToBounds(bounds: LatLngBounds, options?: fitBounds options): this
        // Sets the view of the map with a smooth animation like [`flyTo`](#map-flyto),
        // but takes a bounds parameter like [`fitBounds`](#map-fitbounds).
        flyToBounds: function (bounds, options) {
                var target = this._getBoundsCenterZoom(bounds, options);
                return this.flyTo(target.center, target.zoom, options);
        },

        // @method setMaxBounds(bounds: Bounds): this
        // Restricts the map view to the given bounds (see the [maxBounds](#map-maxbounds) option).
        setMaxBounds: function (bounds) {
                bounds = toLatLngBounds(bounds);

                if (!bounds.isValid()) {
                        this.options.maxBounds = null;
                        return this.off('moveend', this._panInsideMaxBounds);
                } else if (this.options.maxBounds) {
                        this.off('moveend', this._panInsideMaxBounds);
                }

                this.options.maxBounds = bounds;

                if (this._loaded) {
                        this._panInsideMaxBounds();
                }

                return this.on('moveend', this._panInsideMaxBounds);
        },

        // @method setMinZoom(zoom: Number): this
        // Sets the lower limit for the available zoom levels (see the [minZoom](#map-minzoom) option).
        setMinZoom: function (zoom) {
                this.options.minZoom = zoom;

                if (this._loaded && this.getZoom() < this.options.minZoom) {
                        return this.setZoom(zoom);
                }

                return this;
        },

        // @method setMaxZoom(zoom: Number): this
        // Sets the upper limit for the available zoom levels (see the [maxZoom](#map-maxzoom) option).
        setMaxZoom: function (zoom) {
                this.options.maxZoom = zoom;

                if (this._loaded && (this.getZoom() > this.options.maxZoom)) {
                        return this.setZoom(zoom);
                }

                return this;
        },

        // @method panInsideBounds(bounds: LatLngBounds, options?: Pan options): this
        // 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.
        panInsideBounds: function (bounds, options) {
                this._enforcingBounds = true;
                var center = this.getCenter(),
                    newCenter = this._limitCenter(center, this._zoom, toLatLngBounds(bounds));

                if (!center.equals(newCenter)) {
                        this.panTo(newCenter, options);
                }

                this._enforcingBounds = false;
                return this;
        },

        // @method invalidateSize(options: Zoom/Pan options): this
        // Checks if the map container size changed and updates the map if so —
        // call it after you've changed the map size dynamically, also animating
        // pan by default. If `options.pan` is `false`, panning will not occur.
        // If `options.debounceMoveend` is `true`, it will delay `moveend` event so
        // that it doesn't happen often even if the method is called many
        // times in a row.

        // @alternative
        // @method invalidateSize(animate: Boolean): this
        // Checks if the map container size changed and updates the map if so —
        // call it after you've changed the map size dynamically, also animating
        // pan by default.
        invalidateSize: function (options) {
                if (!this._loaded) { return this; }

                options = extend({
                        animate: false,
                        pan: true
                }, options === true ? {animate: true} : options);

                var oldSize = this.getSize();
                this._sizeChanged = true;
                this._lastCenter = null;

                var newSize = this.getSize(),
                    oldCenter = oldSize.divideBy(2).round(),
                    newCenter = newSize.divideBy(2).round(),
                    offset = oldCenter.subtract(newCenter);

                if (!offset.x && !offset.y) { return this; }

                if (options.animate && options.pan) {
                        this.panBy(offset);

                } else {
                        if (options.pan) {
                                this._rawPanBy(offset);
                        }

                        this.fire('move');

                        if (options.debounceMoveend) {
                                clearTimeout(this._sizeTimer);
                                this._sizeTimer = setTimeout(bind(this.fire, this, 'moveend'), 200);
                        } else {
                                this.fire('moveend');
                        }
                }

                // @section Map state change events
                // @event resize: ResizeEvent
                // Fired when the map is resized.
                return this.fire('resize', {
                        oldSize: oldSize,
                        newSize: newSize
                });
        },

        // @section Methods for modifying map state
        // @method stop(): this
        // Stops the currently running `panTo` or `flyTo` animation, if any.
        stop: function () {
                this.setZoom(this._limitZoom(this._zoom));
                if (!this.options.zoomSnap) {
                        this.fire('viewreset');
                }
                return this._stop();
        },

        // @section Geolocation methods
        // @method locate(options?: Locate options): this
        // Tries to locate the user using the Geolocation API, firing a [`locationfound`](#map-locationfound)
        // event with location data on success or a [`locationerror`](#map-locationerror) event on failure,
        // and optionally sets the map view to the user's location with respect to
        // detection accuracy (or to the world view if geolocation failed).
        // Note that, if your page doesn't use HTTPS, this method will fail in
        // modern browsers ([Chrome 50 and newer](https://sites.google.com/a/chromium.org/dev/Home/chromium-security/deprecating-powerful-features-on-insecure-origins))
        // See `Locate options` for more details.
        locate: function (options) {

                options = this._locateOptions = extend({
                        timeout: 10000,
                        watch: false
                        // setView: false
                        // maxZoom: <Number>
                        // maximumAge: 0
                        // enableHighAccuracy: false
                }, options);

                if (!('geolocation' in navigator)) {
                        this._handleGeolocationError({
                                code: 0,
                                message: 'Geolocation not supported.'
                        });
                        return this;
                }

                var onResponse = bind(this._handleGeolocationResponse, this),
                    onError = bind(this._handleGeolocationError, this);

                if (options.watch) {
                        this._locationWatchId =
                                navigator.geolocation.watchPosition(onResponse, onError, options);
                } else {
                        navigator.geolocation.getCurrentPosition(onResponse, onError, options);
                }
                return this;
        },

        // @method stopLocate(): this
        // Stops watching location previously initiated by `map.locate({watch: true})`
        // and aborts resetting the map view if map.locate was called with
        // `{setView: true}`.
        stopLocate: function () {
                if (navigator.geolocation && navigator.geolocation.clearWatch) {
                        navigator.geolocation.clearWatch(this._locationWatchId);
                }
                if (this._locateOptions) {
                        this._locateOptions.setView = false;
                }
                return this;
        },

        _handleGeolocationError: function (error) {
                var c = error.code,
                    message = error.message ||
                            (c === 1 ? 'permission denied' :
                            (c === 2 ? 'position unavailable' : 'timeout'));

                if (this._locateOptions.setView && !this._loaded) {
                        this.fitWorld();
                }

                // @section Location events
                // @event locationerror: ErrorEvent
                // Fired when geolocation (using the [`locate`](#map-locate) method) failed.
                this.fire('locationerror', {
                        code: c,
                        message: 'Geolocation error: ' + message + '.'
                });
        },

        _handleGeolocationResponse: function (pos) {
                var lat = pos.coords.latitude,
                    lng = pos.coords.longitude,
                    latlng = new LatLng(lat, lng),
                    bounds = latlng.toBounds(pos.coords.accuracy),
                    options = this._locateOptions;

                if (options.setView) {
                        var zoom = this.getBoundsZoom(bounds);
                        this.setView(latlng, options.maxZoom ? Math.min(zoom, options.maxZoom) : zoom);
                }

                var data = {
                        latlng: latlng,
                        bounds: bounds,
                        timestamp: pos.timestamp
                };

                for (var i in pos.coords) {
                        if (typeof pos.coords[i] === 'number') {
                                data[i] = pos.coords[i];
                        }
                }

                // @event locationfound: LocationEvent
                // Fired when geolocation (using the [`locate`](#map-locate) method)
                // went successfully.
                this.fire('locationfound', data);
        },

        // TODO handler.addTo
        // TODO Appropiate docs section?
        // @section Other Methods
        // @method addHandler(name: String, HandlerClass: Function): this
        // Adds a new `Handler` to the map, given its name and constructor function.
        addHandler: function (name, HandlerClass) {
                if (!HandlerClass) { return this; }

                var handler = this[name] = new HandlerClass(this);

                this._handlers.push(handler);

                if (this.options[name]) {
                        handler.enable();
                }

                return this;
        },

        // @method remove(): this
        // Destroys the map and clears all related event listeners.
        remove: function () {

                this._initEvents(true);

                if (this._containerId !== this._container._leaflet_id) {
                        throw new Error('Map container is being reused by another instance');
                }

                try {
                        // throws error in IE6-8
                        delete this._container._leaflet_id;
                        delete this._containerId;
                } catch (e) {
                        /*eslint-disable */
                        this._container._leaflet_id = undefined;
                        /*eslint-enable */
                        this._containerId = undefined;
                }

                remove(this._mapPane);

                if (this._clearControlPos) {
                        this._clearControlPos();
                }

                this._clearHandlers();

                if (this._loaded) {
                        // @section Map state change events
                        // @event unload: Event
                        // Fired when the map is destroyed with [remove](#map-remove) method.
                        this.fire('unload');
                }

                var i;
                for (i in this._layers) {
                        this._layers[i].remove();
                }
                for (i in this._panes) {
                        remove(this._panes[i]);
                }

                this._layers = [];
                this._panes = [];
                delete this._mapPane;
                delete this._renderer;

                return this;
        },

        // @section Other Methods
        // @method createPane(name: String, container?: HTMLElement): HTMLElement
        // Creates a new [map pane](#map-pane) with the given name if it doesn't exist already,
        // then returns it. The pane is created as a child of `container`, or
        // as a child of the main map pane if not set.
        createPane: function (name, container) {
                var className = 'leaflet-pane' + (name ? ' leaflet-' + name.replace('Pane', '') + '-pane' : ''),
                    pane = create$1('div', className, container || this._mapPane);

                if (name) {
                        this._panes[name] = pane;
                }
                return pane;
        },

        // @section Methods for Getting Map State

        // @method getCenter(): LatLng
        // Returns the geographical center of the map view
        getCenter: function () {
                this._checkIfLoaded();

                if (this._lastCenter && !this._moved()) {
                        return this._lastCenter;
                }
                return this.layerPointToLatLng(this._getCenterLayerPoint());
        },

        // @method getZoom(): Number
        // Returns the current zoom level of the map view
        getZoom: function () {
                return this._zoom;
        },

        // @method getBounds(): LatLngBounds
        // Returns the geographical bounds visible in the current map view
        getBounds: function () {
                var bounds = this.getPixelBounds(),
                    sw = this.unproject(bounds.getBottomLeft()),
                    ne = this.unproject(bounds.getTopRight());

                return new LatLngBounds(sw, ne);
        },

        // @method getMinZoom(): Number
        // 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.
        getMinZoom: function () {
                return this.options.minZoom === undefined ? this._layersMinZoom || 0 : this.options.minZoom;
        },

        // @method getMaxZoom(): Number
        // Returns the maximum zoom level of the map (if set in the `maxZoom` option of the map or of any layers).
        getMaxZoom: function () {
                return this.options.maxZoom === undefined ?
                        (this._layersMaxZoom === undefined ? Infinity : this._layersMaxZoom) :
                        this.options.maxZoom;
        },

        // @method getBoundsZoom(bounds: LatLngBounds, inside?: Boolean): Number
        // Returns the maximum zoom level on which the given bounds fit to the map
        // view in its entirety. If `inside` (optional) is set to `true`, the method
        // instead returns the minimum zoom level on which the map view fits into
        // the given bounds in its entirety.
        getBoundsZoom: function (bounds, inside, padding) { // (LatLngBounds[, Boolean, Point]) -> Number
                bounds = toLatLngBounds(bounds);
                padding = toPoint(padding || [0, 0]);

                var zoom = this.getZoom() || 0,
                    min = this.getMinZoom(),
                    max = this.getMaxZoom(),
                    nw = bounds.getNorthWest(),
                    se = bounds.getSouthEast(),
                    size = this.getSize().subtract(padding),
                    boundsSize = toBounds(this.project(se, zoom), this.project(nw, zoom)).getSize(),
                    snap = any3d ? this.options.zoomSnap : 1,
                    scalex = size.x / boundsSize.x,
                    scaley = size.y / boundsSize.y,
                    scale = inside ? Math.max(scalex, scaley) : Math.min(scalex, scaley);

                zoom = this.getScaleZoom(scale, zoom);

                if (snap) {
                        zoom = Math.round(zoom / (snap / 100)) * (snap / 100); // don't jump if within 1% of a snap level
                        zoom = inside ? Math.ceil(zoom / snap) * snap : Math.floor(zoom / snap) * snap;
                }

                return Math.max(min, Math.min(max, zoom));
        },

        // @method getSize(): Point
        // Returns the current size of the map container (in pixels).
        getSize: function () {
                if (!this._size || this._sizeChanged) {
                        this._size = new Point(
                                this._container.clientWidth || 0,
                                this._container.clientHeight || 0);

                        this._sizeChanged = false;
                }
                return this._size.clone();
        },

        // @method getPixelBounds(): Bounds
        // Returns the bounds of the current map view in projected pixel
        // coordinates (sometimes useful in layer and overlay implementations).
        getPixelBounds: function (center, zoom) {
                var topLeftPoint = this._getTopLeftPoint(center, zoom);
                return new Bounds(topLeftPoint, topLeftPoint.add(this.getSize()));
        },

        // TODO: Check semantics - isn't the pixel origin the 0,0 coord relative to
        // the map pane? "left point of the map layer" can be confusing, specially
        // since there can be negative offsets.
        // @method getPixelOrigin(): Point
        // Returns the projected pixel coordinates of the top left point of
        // the map layer (useful in custom layer and overlay implementations).
        getPixelOrigin: function () {
                this._checkIfLoaded();
                return this._pixelOrigin;
        },

        // @method getPixelWorldBounds(zoom?: Number): Bounds
        // Returns the world's bounds in pixel coordinates for zoom level `zoom`.
        // If `zoom` is omitted, the map's current zoom level is used.
        getPixelWorldBounds: function (zoom) {
                return this.options.crs.getProjectedBounds(zoom === undefined ? this.getZoom() : zoom);
        },

        // @section Other Methods

        // @method getPane(pane: String|HTMLElement): HTMLElement
        // Returns a [map pane](#map-pane), given its name or its HTML element (its identity).
        getPane: function (pane) {
                return typeof pane === 'string' ? this._panes[pane] : pane;
        },

        // @method getPanes(): Object
        // Returns a plain object containing the names of all [panes](#map-pane) as keys and
        // the panes as values.
        getPanes: function () {
                return this._panes;
        },

        // @method getContainer: HTMLElement
        // Returns the HTML element that contains the map.
        getContainer: function () {
                return this._container;
        },


        // @section Conversion Methods

        // @method getZoomScale(toZoom: Number, fromZoom: Number): Number
        // Returns the scale factor to be applied to a map transition from zoom level
        // `fromZoom` to `toZoom`. Used internally to help with zoom animations.
        getZoomScale: function (toZoom, fromZoom) {
                // TODO replace with universal implementation after refactoring projections
                var crs = this.options.crs;
                fromZoom = fromZoom === undefined ? this._zoom : fromZoom;
                return crs.scale(toZoom) / crs.scale(fromZoom);
        },

        // @method getScaleZoom(scale: Number, fromZoom: Number): Number
        // Returns the zoom level that the map would end up at, if it is at `fromZoom`
        // level and everything is scaled by a factor of `scale`. Inverse of
        // [`getZoomScale`](#map-getZoomScale).
        getScaleZoom: function (scale, fromZoom) {
                var crs = this.options.crs;
                fromZoom = fromZoom === undefined ? this._zoom : fromZoom;
                var zoom = crs.zoom(scale * crs.scale(fromZoom));
                return isNaN(zoom) ? Infinity : zoom;
        },

        // @method project(latlng: LatLng, zoom: Number): Point
        // Projects a geographical coordinate `LatLng` according to the projection
        // of the map's CRS, then scales it according to `zoom` and the CRS's
        // `Transformation`. The result is pixel coordinate relative to
        // the CRS origin.
        project: function (latlng, zoom) {
                zoom = zoom === undefined ? this._zoom : zoom;
                return this.options.crs.latLngToPoint(toLatLng(latlng), zoom);
        },

        // @method unproject(point: Point, zoom: Number): LatLng
        // Inverse of [`project`](#map-project).
        unproject: function (point, zoom) {
                zoom = zoom === undefined ? this._zoom : zoom;
                return this.options.crs.pointToLatLng(toPoint(point), zoom);
        },

        // @method layerPointToLatLng(point: Point): LatLng
        // Given a pixel coordinate relative to the [origin pixel](#map-getpixelorigin),
        // returns the corresponding geographical coordinate (for the current zoom level).
        layerPointToLatLng: function (point) {
                var projectedPoint = toPoint(point).add(this.getPixelOrigin());
                return this.unproject(projectedPoint);
        },

        // @method latLngToLayerPoint(latlng: LatLng): Point
        // Given a geographical coordinate, returns the corresponding pixel coordinate
        // relative to the [origin pixel](#map-getpixelorigin).
        latLngToLayerPoint: function (latlng) {
                var projectedPoint = this.project(toLatLng(latlng))._round();
                return projectedPoint._subtract(this.getPixelOrigin());
        },

        // @method wrapLatLng(latlng: LatLng): LatLng
        // Returns a `LatLng` where `lat` and `lng` has been wrapped according to the
        // map's CRS's `wrapLat` and `wrapLng` properties, if they are outside the
        // CRS's bounds.
        // By default this means longitude is wrapped around the dateline so its
        // value is between -180 and +180 degrees.
        wrapLatLng: function (latlng) {
                return this.options.crs.wrapLatLng(toLatLng(latlng));
        },

        // @method wrapLatLngBounds(bounds: LatLngBounds): LatLngBounds
        // Returns a `LatLngBounds` with the same size as the given one, ensuring that
        // its center is within the CRS's bounds.
        // By default this means the center longitude is wrapped around the dateline so its
        // value is between -180 and +180 degrees, and the majority of the bounds
        // overlaps the CRS's bounds.
        wrapLatLngBounds: function (latlng) {
                return this.options.crs.wrapLatLngBounds(toLatLngBounds(latlng));
        },

        // @method distance(latlng1: LatLng, latlng2: LatLng): Number
        // Returns the distance between two geographical coordinates according to
        // the map's CRS. By default this measures distance in meters.
        distance: function (latlng1, latlng2) {
                return this.options.crs.distance(toLatLng(latlng1), toLatLng(latlng2));
        },

        // @method containerPointToLayerPoint(point: Point): Point
        // Given a pixel coordinate relative to the map container, returns the corresponding
        // pixel coordinate relative to the [origin pixel](#map-getpixelorigin).
        containerPointToLayerPoint: function (point) { // (Point)
                return toPoint(point).subtract(this._getMapPanePos());
        },

        // @method layerPointToContainerPoint(point: Point): Point
        // Given a pixel coordinate relative to the [origin pixel](#map-getpixelorigin),
        // returns the corresponding pixel coordinate relative to the map container.
        layerPointToContainerPoint: function (point) { // (Point)
                return toPoint(point).add(this._getMapPanePos());
        },

        // @method containerPointToLatLng(point: Point): LatLng
        // Given a pixel coordinate relative to the map container, returns
        // the corresponding geographical coordinate (for the current zoom level).
        containerPointToLatLng: function (point) {
                var layerPoint = this.containerPointToLayerPoint(toPoint(point));
                return this.layerPointToLatLng(layerPoint);
        },

        // @method latLngToContainerPoint(latlng: LatLng): Point
        // Given a geographical coordinate, returns the corresponding pixel coordinate
        // relative to the map container.
        latLngToContainerPoint: function (latlng) {
                return this.layerPointToContainerPoint(this.latLngToLayerPoint(toLatLng(latlng)));
        },

        // @method mouseEventToContainerPoint(ev: MouseEvent): Point
        // Given a MouseEvent object, returns the pixel coordinate relative to the
        // map container where the event took place.
        mouseEventToContainerPoint: function (e) {
                return getMousePosition(e, this._container);
        },

        // @method mouseEventToLayerPoint(ev: MouseEvent): Point
        // Given a MouseEvent object, returns the pixel coordinate relative to
        // the [origin pixel](#map-getpixelorigin) where the event took place.
        mouseEventToLayerPoint: function (e) {
                return this.containerPointToLayerPoint(this.mouseEventToContainerPoint(e));
        },

        // @method mouseEventToLatLng(ev: MouseEvent): LatLng
        // Given a MouseEvent object, returns geographical coordinate where the
        // event took place.
        mouseEventToLatLng: function (e) { // (MouseEvent)
                return this.layerPointToLatLng(this.mouseEventToLayerPoint(e));
        },


        // map initialization methods

        _initContainer: function (id) {
                var container = this._container = get(id);

                if (!container) {
                        throw new Error('Map container not found.');
                } else if (container._leaflet_id) {
                        throw new Error('Map container is already initialized.');
                }

                on(container, 'scroll', this._onScroll, this);
                this._containerId = stamp(container);
        },

        _initLayout: function () {
                var container = this._container;

                this._fadeAnimated = this.options.fadeAnimation && any3d;

                addClass(container, 'leaflet-container' +
                        (touch ? ' leaflet-touch' : '') +
                        (retina ? ' leaflet-retina' : '') +
                        (ielt9 ? ' leaflet-oldie' : '') +
                        (safari ? ' leaflet-safari' : '') +
                        (this._fadeAnimated ? ' leaflet-fade-anim' : ''));

                var position = getStyle(container, 'position');

                if (position !== 'absolute' && position !== 'relative' && position !== 'fixed') {
                        container.style.position = 'relative';
                }

                this._initPanes();