Adding debian version 1.1.0-4.debian/1.1.0-4debian

Signed-off-by: Daniel Baumann <daniel.baumann@progress-linux.org>

10 files changed, 2770 insertions, 0 deletions

diff --git a/debian/missing-sources/leaflet.js/map/Map.js b/debian/missing-sources/leaflet.js/map/Map.js
new file mode 100644
index 0000000..b276d86
--- /dev/null
+++ b/debian/missing-sources/leaflet.js/map/Map.js
@@ -0,0 +1,1667 @@
+import * as Util from '../core/Util';

+import {Evented} from '../core/Events';

+import {EPSG3857} from '../geo/crs/CRS.EPSG3857';

+import {Point, toPoint} from '../geometry/Point';

+import {Bounds, toBounds} from '../geometry/Bounds';

+import {LatLng, toLatLng} from '../geo/LatLng';

+import {LatLngBounds, toLatLngBounds} from '../geo/LatLngBounds';

+import * as Browser from '../core/Browser';

+import * as DomEvent from '../dom/DomEvent';

+import * as DomUtil from '../dom/DomUtil';

+import {PosAnimation} from '../dom/PosAnimation';

+

+/*

+ * @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

+ * });

+ * ```

+ *

+ */

+

+export 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 = Util.setOptions(this, options);

+

+		this._initContainer(id);

+		this._initLayout();

+

+		// hack for https://github.com/Leaflet/Leaflet/issues/1980

+		this._onResize = Util.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 = DomUtil.TRANSITION && Browser.any3d && !Browser.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();

+			DomEvent.on(this._proxy, DomUtil.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 = Util.extend({animate: options.animate}, options.zoom);

+				options.pan = Util.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 || (Browser.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 || (Browser.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) {

+			DomUtil.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 || !Browser.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 = Util.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, options.noMoveStart);

+

+		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) {

+		var oldZoom = this.options.minZoom;

+		this.options.minZoom = zoom;

+

+		if (this._loaded && oldZoom !== zoom) {

+			this.fire('zoomlevelschange');

+

+			if (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) {

+		var oldZoom = this.options.maxZoom;

+		this.options.maxZoom = zoom;

+

+		if (this._loaded && oldZoom !== zoom) {

+			this.fire('zoomlevelschange');

+

+			if (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 = Util.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(Util.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 = Util.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 = Util.bind(this._handleGeolocationResponse, this),

+		    onError = Util.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 Appropriate 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;

+		}

+

+		if (this._locationWatchId !== undefined) {

+			this.stopLocate();

+		}

+

+		this._stop();

+

+		DomUtil.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) {

+			DomUtil.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 = DomUtil.create('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 = Browser.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 DomEvent.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 = DomUtil.get(id);

+

+		if (!container) {

+			throw new Error('Map container not found.');

+		} else if (container._leaflet_id) {

+			throw new Error('Map container is already initialized.');

+		}

+

+		DomEvent.on(container, 'scroll', this._onScroll, this);

+		this._containerId = Util.stamp(container);

+	},

+

+	_initLayout: function () {

+		var container = this._container;

+

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

+

+		DomUtil.addClass(container, 'leaflet-container' +

+			(Browser.touch ? ' leaflet-touch' : '') +

+			(Browser.retina ? ' leaflet-retina' : '') +

+			(Browser.ielt9 ? ' leaflet-oldie' : '') +

+			(Browser.safari ? ' leaflet-safari' : '') +

+			(this._fadeAnimated ? ' leaflet-fade-anim' : ''));

+

+		var position = DomUtil.getStyle(container, 'position');

+

+		if (position !== 'absolute' && position !== 'relative' && position !== 'fixed') {

+			container.style.position = 'relative';

+		}

+

+		this._initPanes();

+

+		if (this._initControlPos) {

+			this._initControlPos();

+		}

+	},

+

+	_initPanes: function () {

+		var panes = this._panes = {};

+		this._paneRenderers = {};

+

+		// @section

+		//

+		// Panes are DOM elements used to control the ordering of layers on the map. You

+		// can access panes with [`map.getPane`](#map-getpane) or

+		// [`map.getPanes`](#map-getpanes) methods. New panes can be created with the

+		// [`map.createPane`](#map-createpane) method.

+		//

+		// Every map has the following default panes that differ only in zIndex.

+		//

+		// @pane mapPane: HTMLElement = 'auto'

+		// Pane that contains all other map panes

+

+		this._mapPane = this.createPane('mapPane', this._container);

+		DomUtil.setPosition(this._mapPane, new Point(0, 0));

+

+		// @pane tilePane: HTMLElement = 200

+		// Pane for `GridLayer`s and `TileLayer`s

+		this.createPane('tilePane');

+		// @pane overlayPane: HTMLElement = 400

+		// Pane for vectors (`Path`s, like `Polyline`s and `Polygon`s), `ImageOverlay`s and `VideoOverlay`s

+		this.createPane('shadowPane');

+		// @pane shadowPane: HTMLElement = 500

+		// Pane for overlay shadows (e.g. `Marker` shadows)

+		this.createPane('overlayPane');

+		// @pane markerPane: HTMLElement = 600

+		// Pane for `Icon`s of `Marker`s

+		this.createPane('markerPane');

+		// @pane tooltipPane: HTMLElement = 650

+		// Pane for `Tooltip`s.

+		this.createPane('tooltipPane');

+		// @pane popupPane: HTMLElement = 700

+		// Pane for `Popup`s.

+		this.createPane('popupPane');

+

+		if (!this.options.markerZoomAnimation) {

+			DomUtil.addClass(panes.markerPane, 'leaflet-zoom-hide');

+			DomUtil.addClass(panes.shadowPane, 'leaflet-zoom-hide');

+		}

+	},

+

+

+	// private methods that modify map state

+

+	// @section Map state change events

+	_resetView: function (center, zoom) {

+		DomUtil.setPosition(this._mapPane, new Point(0, 0));

+

+		var loading = !this._loaded;

+		this._loaded = true;

+		zoom = this._limitZoom(zoom);

+

+		this.fire('viewprereset');

+

+		var zoomChanged = this._zoom !== zoom;

+		this

+			._moveStart(zoomChanged, false)

+			._move(center, zoom)

+			._moveEnd(zoomChanged);

+

+		// @event viewreset: Event

+		// Fired when the map needs to redraw its content (this usually happens

+		// on map zoom or load). Very useful for creating custom overlays.

+		this.fire('viewreset');

+

+		// @event load: Event

+		// Fired when the map is initialized (when its center and zoom are set

+		// for the first time).

+		if (loading) {

+			this.fire('load');

+		}

+	},

+

+	_moveStart: function (zoomChanged, noMoveStart) {

+		// @event zoomstart: Event

+		// Fired when the map zoom is about to change (e.g. before zoom animation).

+		// @event movestart: Event

+		// Fired when the view of the map starts changing (e.g. user starts dragging the map).

+		if (zoomChanged) {

+			this.fire('zoomstart');

+		}

+		if (!noMoveStart) {

+			this.fire('movestart');

+		}

+		return this;

+	},

+

+	_move: function (center, zoom, data) {

+		if (zoom === undefined) {

+			zoom = this._zoom;

+		}

+		var zoomChanged = this._zoom !== zoom;

+

+		this._zoom = zoom;

+		this._lastCenter = center;

+		this._pixelOrigin = this._getNewPixelOrigin(center);

+

+		// @event zoom: Event

+		// Fired repeatedly during any change in zoom level, including zoom

+		// and fly animations.

+		if (zoomChanged || (data && data.pinch)) {	// Always fire 'zoom' if pinching because #3530

+			this.fire('zoom', data);

+		}

+

+		// @event move: Event

+		// Fired repeatedly during any movement of the map, including pan and

+		// fly animations.

+		return this.fire('move', data);

+	},

+

+	_moveEnd: function (zoomChanged) {

+		// @event zoomend: Event

+		// Fired when the map has changed, after any animations.

+		if (zoomChanged) {

+			this.fire('zoomend');

+		}

+

+		// @event moveend: Event

+		// Fired when the center of the map stops changing (e.g. user stopped

+		// dragging the map).

+		return this.fire('moveend');

+	},

+

+	_stop: function () {

+		Util.cancelAnimFrame(this._flyToFrame);

+		if (this._panAnim) {

+			this._panAnim.stop();

+		}

+		return this;

+	},

+

+	_rawPanBy: function (offset) {

+		DomUtil.setPosition(this._mapPane, this._getMapPanePos().subtract(offset));

+	},

+

+	_getZoomSpan: function () {

+		return this.getMaxZoom() - this.getMinZoom();

+	},

+

+	_panInsideMaxBounds: function () {

+		if (!this._enforcingBounds) {

+			this.panInsideBounds(this.options.maxBounds);

+		}

+	},

+

+	_checkIfLoaded: function () {

+		if (!this._loaded) {

+			throw new Error('Set map center and zoom first.');

+		}

+	},

+

+	// DOM event handling

+

+	// @section Interaction events

+	_initEvents: function (remove) {

+		this._targets = {};

+		this._targets[Util.stamp(this._container)] = this;

+

+		var onOff = remove ? DomEvent.off : DomEvent.on;

+

+		// @event click: MouseEvent

+		// Fired when the user clicks (or taps) the map.

+		// @event dblclick: MouseEvent

+		// Fired when the user double-clicks (or double-taps) the map.

+		// @event mousedown: MouseEvent

+		// Fired when the user pushes the mouse button on the map.

+		// @event mouseup: MouseEvent

+		// Fired when the user releases the mouse button on the map.

+		// @event mouseover: MouseEvent

+		// Fired when the mouse enters the map.

+		// @event mouseout: MouseEvent

+		// Fired when the mouse leaves the map.

+		// @event mousemove: MouseEvent

+		// Fired while the mouse moves over the map.

+		// @event contextmenu: MouseEvent

+		// Fired when the user pushes the right mouse button on the map, prevents

+		// default browser context menu from showing if there are listeners on

+		// this event. Also fired on mobile when the user holds a single touch

+		// for a second (also called long press).

+		// @event keypress: KeyboardEvent

+		// Fired when the user presses a key from the keyboard while the map is focused.

+		onOff(this._container, 'click dblclick mousedown mouseup ' +

+			'mouseover mouseout mousemove contextmenu keypress', this._handleDOMEvent, this);

+

+		if (this.options.trackResize) {

+			onOff(window, 'resize', this._onResize, this);

+		}

+

+		if (Browser.any3d && this.options.transform3DLimit) {

+			(remove ? this.off : this.on).call(this, 'moveend', this._onMoveEnd);

+		}

+	},

+

+	_onResize: function () {

+		Util.cancelAnimFrame(this._resizeRequest);

+		this._resizeRequest = Util.requestAnimFrame(

+		        function () { this.invalidateSize({debounceMoveend: true}); }, this);

+	},

+

+	_onScroll: function () {

+		this._container.scrollTop  = 0;

+		this._container.scrollLeft = 0;

+	},

+

+	_onMoveEnd: function () {

+		var pos = this._getMapPanePos();

+		if (Math.max(Math.abs(pos.x), Math.abs(pos.y)) >= this.options.transform3DLimit) {

+			// https://bugzilla.mozilla.org/show_bug.cgi?id=1203873 but Webkit also have

+			// a pixel offset on very high values, see: http://jsfiddle.net/dg6r5hhb/

+			this._resetView(this.getCenter(), this.getZoom());

+		}

+	},

+

+	_findEventTargets: function (e, type) {

+		var targets = [],

+		    target,

+		    isHover = type === 'mouseout' || type === 'mouseover',

+		    src = e.target || e.srcElement,

+		    dragging = false;

+

+		while (src) {

+			target = this._targets[Util.stamp(src)];

+			if (target && (type === 'click' || type === 'preclick') && !e._simulated && this._draggableMoved(target)) {

+				// Prevent firing click after you just dragged an object.

+				dragging = true;

+				break;

+			}

+			if (target && target.listens(type, true)) {

+				if (isHover && !DomEvent.isExternalTarget(src, e)) { break; }

+				targets.push(target);

+				if (isHover) { break; }

+			}

+			if (src === this._container) { break; }

+			src = src.parentNode;

+		}

+		if (!targets.length && !dragging && !isHover && DomEvent.isExternalTarget(src, e)) {

+			targets = [this];

+		}

+		return targets;

+	},

+

+	_handleDOMEvent: function (e) {

+		if (!this._loaded || DomEvent.skipped(e)) { return; }

+

+		var type = e.type;

+

+		if (type === 'mousedown' || type === 'keypress') {

+			// prevents outline when clicking on keyboard-focusable element

+			DomUtil.preventOutline(e.target || e.srcElement);

+		}

+

+		this._fireDOMEvent(e, type);

+	},

+

+	_mouseEvents: ['click', 'dblclick', 'mouseover', 'mouseout', 'contextmenu'],

+

+	_fireDOMEvent: function (e, type, targets) {

+

+		if (e.type === 'click') {

+			// Fire a synthetic 'preclick' event which propagates up (mainly for closing popups).

+			// @event preclick: MouseEvent

+			// Fired before mouse click on the map (sometimes useful when you

+			// want something to happen on click before any existing click

+			// handlers start running).

+			var synth = Util.extend({}, e);

+			synth.type = 'preclick';

+			this._fireDOMEvent(synth, synth.type, targets);

+		}

+

+		if (e._stopped) { return; }

+

+		// Find the layer the event is propagating from and its parents.

+		targets = (targets || []).concat(this._findEventTargets(e, type));

+

+		if (!targets.length) { return; }

+

+		var target = targets[0];

+		if (type === 'contextmenu' && target.listens(type, true)) {

+			DomEvent.preventDefault(e);

+		}

+

+		var data = {

+			originalEvent: e

+		};

+

+		if (e.type !== 'keypress') {

+			var isMarker = target.getLatLng && (!target._radius || target._radius <= 10);

+			data.containerPoint = isMarker ?

+				this.latLngToContainerPoint(target.getLatLng()) : this.mouseEventToContainerPoint(e);

+			data.layerPoint = this.containerPointToLayerPoint(data.containerPoint);

+			data.latlng = isMarker ? target.getLatLng() : this.layerPointToLatLng(data.layerPoint);

+		}

+

+		for (var i = 0; i < targets.length; i++) {

+			targets[i].fire(type, data, true);

+			if (data.originalEvent._stopped ||

+				(targets[i].options.bubblingMouseEvents === false && Util.indexOf(this._mouseEvents, type) !== -1)) { return; }

+		}

+	},

+

+	_draggableMoved: function (obj) {

+		obj = obj.dragging && obj.dragging.enabled() ? obj : this;

+		return (obj.dragging && obj.dragging.moved()) || (this.boxZoom && this.boxZoom.moved());

+	},

+

+	_clearHandlers: function () {

+		for (var i = 0, len = this._handlers.length; i < len; i++) {

+			this._handlers[i].disable();

+		}

+	},

+

+	// @section Other Methods

+

+	// @method whenReady(fn: Function, context?: Object): this

+	// Runs the given function `fn` when the map gets initialized with

+	// a view (center and zoom) and at least one layer, or immediately

+	// if it's already initialized, optionally passing a function context.

+	whenReady: function (callback, context) {

+		if (this._loaded) {

+			callback.call(context || this, {target: this});

+		} else {

+			this.on('load', callback, context);

+		}

+		return this;

+	},

+

+

+	// private methods for getting map state

+

+	_getMapPanePos: function () {

+		return DomUtil.getPosition(this._mapPane) || new Point(0, 0);

+	},

+

+	_moved: function () {

+		var pos = this._getMapPanePos();

+		return pos && !pos.equals([0, 0]);

+	},

+

+	_getTopLeftPoint: function (center, zoom) {

+		var pixelOrigin = center && zoom !== undefined ?

+			this._getNewPixelOrigin(center, zoom) :

+			this.getPixelOrigin();

+		return pixelOrigin.subtract(this._getMapPanePos());

+	},

+

+	_getNewPixelOrigin: function (center, zoom) {

+		var viewHalf = this.getSize()._divideBy(2);

+		return this.project(center, zoom)._subtract(viewHalf)._add(this._getMapPanePos())._round();

+	},

+

+	_latLngToNewLayerPoint: function (latlng, zoom, center) {

+		var topLeft = this._getNewPixelOrigin(center, zoom);

+		return this.project(latlng, zoom)._subtract(topLeft);

+	},

+

+	_latLngBoundsToNewLayerBounds: function (latLngBounds, zoom, center) {

+		var topLeft = this._getNewPixelOrigin(center, zoom);

+		return toBounds([

+			this.project(latLngBounds.getSouthWest(), zoom)._subtract(topLeft),

+			this.project(latLngBounds.getNorthWest(), zoom)._subtract(topLeft),

+			this.project(latLngBounds.getSouthEast(), zoom)._subtract(topLeft),

+			this.project(latLngBounds.getNorthEast(), zoom)._subtract(topLeft)

+		]);

+	},

+

+	// layer point of the current center

+	_getCenterLayerPoint: function () {

+		return this.containerPointToLayerPoint(this.getSize()._divideBy(2));

+	},

+

+	// offset of the specified place to the current center in pixels

+	_getCenterOffset: function (latlng) {

+		return this.latLngToLayerPoint(latlng).subtract(this._getCenterLayerPoint());

+	},

+

+	// adjust center for view to get inside bounds

+	_limitCenter: function (center, zoom, bounds) {

+

+		if (!bounds) { return center; }

+

+		var centerPoint = this.project(center, zoom),

+		    viewHalf = this.getSize().divideBy(2),

+		    viewBounds = new Bounds(centerPoint.subtract(viewHalf), centerPoint.add(viewHalf)),

+		    offset = this._getBoundsOffset(viewBounds, bounds, zoom);

+

+		// If offset is less than a pixel, ignore.

+		// This prevents unstable projections from getting into

+		// an infinite loop of tiny offsets.

+		if (offset.round().equals([0, 0])) {

+			return center;

+		}

+

+		return this.unproject(centerPoint.add(offset), zoom);

+	},

+

+	// adjust offset for view to get inside bounds

+	_limitOffset: function (offset, bounds) {

+		if (!bounds) { return offset; }

+

+		var viewBounds = this.getPixelBounds(),

+		    newBounds = new Bounds(viewBounds.min.add(offset), viewBounds.max.add(offset));

+

+		return offset.add(this._getBoundsOffset(newBounds, bounds));

+	},

+

+	// returns offset needed for pxBounds to get inside maxBounds at a specified zoom

+	_getBoundsOffset: function (pxBounds, maxBounds, zoom) {

+		var projectedMaxBounds = toBounds(

+		        this.project(maxBounds.getNorthEast(), zoom),

+		        this.project(maxBounds.getSouthWest(), zoom)

+		    ),

+		    minOffset = projectedMaxBounds.min.subtract(pxBounds.min),

+		    maxOffset = projectedMaxBounds.max.subtract(pxBounds.max),

+

+		    dx = this._rebound(minOffset.x, -maxOffset.x),

+		    dy = this._rebound(minOffset.y, -maxOffset.y);

+

+		return new Point(dx, dy);

+	},

+

+	_rebound: function (left, right) {

+		return left + right > 0 ?

+			Math.round(left - right) / 2 :

+			Math.max(0, Math.ceil(left)) - Math.max(0, Math.floor(right));

+	},

+

+	_limitZoom: function (zoom) {

+		var min = this.getMinZoom(),

+		    max = this.getMaxZoom(),

+		    snap = Browser.any3d ? this.options.zoomSnap : 1;

+		if (snap) {

+			zoom = Math.round(zoom / snap) * snap;

+		}

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

+	},

+

+	_onPanTransitionStep: function () {

+		this.fire('move');

+	},

+

+	_onPanTransitionEnd: function () {

+		DomUtil.removeClass(this._mapPane, 'leaflet-pan-anim');

+		this.fire('moveend');

+	},

+

+	_tryAnimatedPan: function (center, options) {

+		// difference between the new and current centers in pixels

+		var offset = this._getCenterOffset(center)._trunc();

+

+		// don't animate too far unless animate: true specified in options

+		if ((options && options.animate) !== true && !this.getSize().contains(offset)) { return false; }

+

+		this.panBy(offset, options);

+

+		return true;

+	},

+

+	_createAnimProxy: function () {

+

+		var proxy = this._proxy = DomUtil.create('div', 'leaflet-proxy leaflet-zoom-animated');

+		this._panes.mapPane.appendChild(proxy);

+

+		this.on('zoomanim', function (e) {

+			var prop = DomUtil.TRANSFORM,

+			    transform = this._proxy.style[prop];

+

+			DomUtil.setTransform(this._proxy, this.project(e.center, e.zoom), this.getZoomScale(e.zoom, 1));

+

+			// workaround for case when transform is the same and so transitionend event is not fired

+			if (transform === this._proxy.style[prop] && this._animatingZoom) {

+				this._onZoomTransitionEnd();

+			}

+		}, this);

+

+		this.on('load moveend', function () {

+			var c = this.getCenter(),

+			    z = this.getZoom();

+			DomUtil.setTransform(this._proxy, this.project(c, z), this.getZoomScale(z, 1));

+		}, this);

+

+		this._on('unload', this._destroyAnimProxy, this);

+	},

+

+	_destroyAnimProxy: function () {

+		DomUtil.remove(this._proxy);

+		delete this._proxy;

+	},

+

+	_catchTransitionEnd: function (e) {

+		if (this._animatingZoom && e.propertyName.indexOf('transform') >= 0) {

+			this._onZoomTransitionEnd();

+		}

+	},

+

+	_nothingToAnimate: function () {

+		return !this._container.getElementsByClassName('leaflet-zoom-animated').length;

+	},

+

+	_tryAnimatedZoom: function (center, zoom, options) {

+

+		if (this._animatingZoom) { return true; }

+

+		options = options || {};

+

+		// don't animate if disabled, not supported or zoom difference is too large

+		if (!this._zoomAnimated || options.animate === false || this._nothingToAnimate() ||

+		        Math.abs(zoom - this._zoom) > this.options.zoomAnimationThreshold) { return false; }

+

+		// offset is the pixel coords of the zoom origin relative to the current center

+		var scale = this.getZoomScale(zoom),

+		    offset = this._getCenterOffset(center)._divideBy(1 - 1 / scale);

+

+		// don't animate if the zoom origin isn't within one screen from the current center, unless forced

+		if (options.animate !== true && !this.getSize().contains(offset)) { return false; }

+

+		Util.requestAnimFrame(function () {

+			this

+			    ._moveStart(true, false)

+			    ._animateZoom(center, zoom, true);

+		}, this);

+

+		return true;

+	},

+

+	_animateZoom: function (center, zoom, startAnim, noUpdate) {

+		if (!this._mapPane) { return; }

+

+		if (startAnim) {

+			this._animatingZoom = true;

+

+			// remember what center/zoom to set after animation

+			this._animateToCenter = center;

+			this._animateToZoom = zoom;

+

+			DomUtil.addClass(this._mapPane, 'leaflet-zoom-anim');

+		}

+

+		// @event zoomanim: ZoomAnimEvent

+		// Fired on every frame of a zoom animation

+		this.fire('zoomanim', {

+			center: center,

+			zoom: zoom,

+			noUpdate: noUpdate

+		});

+

+		// Work around webkit not firing 'transitionend', see https://github.com/Leaflet/Leaflet/issues/3689, 2693

+		setTimeout(Util.bind(this._onZoomTransitionEnd, this), 250);

+	},

+

+	_onZoomTransitionEnd: function () {

+		if (!this._animatingZoom) { return; }

+

+		if (this._mapPane) {

+			DomUtil.removeClass(this._mapPane, 'leaflet-zoom-anim');

+		}

+

+		this._animatingZoom = false;

+

+		this._move(this._animateToCenter, this._animateToZoom);

+

+		// This anim frame should prevent an obscure iOS webkit tile loading race condition.

+		Util.requestAnimFrame(function () {

+			this._moveEnd(true);

+		}, this);

+	}

+});

+

+// @section

+

+// @factory L.map(id: String, options?: Map options)

+// Instantiates a map object given the DOM ID of a `<div>` element

+// and optionally an object literal with `Map options`.

+//

+// @alternative

+// @factory L.map(el: HTMLElement, options?: Map options)

+// Instantiates a map object given an instance of a `<div>` HTML element

+// and optionally an object literal with `Map options`.

+export function createMap(id, options) {

+	return new Map(id, options);

+}

diff --git a/debian/missing-sources/leaflet.js/map/Map.methodOptions.leafdoc b/debian/missing-sources/leaflet.js/map/Map.methodOptions.leafdoc
new file mode 100644
index 0000000..8ce8aad
--- /dev/null
+++ b/debian/missing-sources/leaflet.js/map/Map.methodOptions.leafdoc
@@ -0,0 +1,108 @@
+
+This file documents the common options passed to several map methods.
+
+
+@miniclass Locate options (Map)
+@aka locate options
+@section
+
+Some of the geolocation methods for `Map` take in an `options` parameter. This
+is a plain javascript object with the following optional components:
+
+@option watch: Boolean = false
+If `true`, starts continuous watching of location changes (instead of detecting it
+once) using W3C `watchPosition` method. You can later stop watching using
+`map.stopLocate()` method.
+
+
+@option setView: Boolean = false
+If `true`, automatically sets the map view to the user location with respect to
+detection accuracy, or to world view if geolocation failed.
+
+@option maxZoom: Number = Infinity
+The maximum zoom for automatic view setting when using `setView` option.
+
+@option timeout: Number = 10000
+Number of milliseconds to wait for a response from geolocation before firing a
+`locationerror` event.
+
+@option maximumAge: Number = 0
+Maximum age of detected location. If less than this amount of milliseconds
+passed since last geolocation response, `locate` will return a cached location.
+
+@option enableHighAccuracy: Boolean = false
+Enables high accuracy, see [description in the W3C spec](http://dev.w3.org/geo/api/spec-source.html#high-accuracy).
+
+
+
+@miniclass Zoom options (Map)
+@aka zoom options
+@section
+
+Some of the `Map` methods which modify the zoom level take in an `options`
+parameter. This is a plain javascript object with the following optional
+components:
+
+
+@option animate: Boolean
+If not specified, zoom animation will happen if the zoom origin is inside the
+current view. If `true`, the map will attempt animating zoom disregarding where
+zoom origin is. Setting `false` will make it always reset the view completely
+without animation.
+
+
+
+
+@miniclass Pan options (Map)
+@aka pan options
+@section
+
+Some of the `Map` methods which modify the center of the map take in an `options`
+parameter. This is a plain javascript object with the following optional
+components:
+
+@option animate: Boolean
+If `true`, panning will always be animated if possible. If `false`, it will
+not animate panning, either resetting the map view if panning more than a
+screen away, or just setting a new offset for the map pane (except for `panBy`
+which always does the latter).
+
+@option duration: Number = 0.25
+Duration of animated panning, in seconds.
+
+@option easeLinearity: Number = 0.25
+The curvature factor of panning animation easing (third parameter of the
+[Cubic Bezier curve](http://cubic-bezier.com/)). 1.0 means linear animation,
+and the smaller this number, the more bowed the curve.
+
+@option noMoveStart: Boolean = false
+If `true`, panning won't fire `movestart` event on start (used internally for
+panning inertia).
+
+
+@miniclass Zoom/pan options (Map)
+@aka zoom/pan options
+@inherits Zoom options
+@inherits Pan options
+
+
+@miniclass FitBounds options (Map)
+@aka fitBounds options
+@inherits Zoom/pan options
+
+@option paddingTopLeft: Point = [0, 0]
+Sets the amount of padding in the top left corner of a map container that
+shouldn't be accounted for when setting the view to fit bounds. Useful if you
+have some control overlays on the map like a sidebar and you don't want them
+to obscure objects you're zooming to.
+
+@option paddingBottomRight: Point = [0, 0]
+The same for the bottom right corner of the map.
+
+@option padding: Point = [0, 0]
+Equivalent of setting both top left and bottom right padding to the same value.
+
+@option maxZoom: Number = null
+The maximum possible zoom to use.
+
+
diff --git a/debian/missing-sources/leaflet.js/map/handler/Map.BoxZoom.js b/debian/missing-sources/leaflet.js/map/handler/Map.BoxZoom.js
new file mode 100644
index 0000000..297a20a
--- /dev/null
+++ b/debian/missing-sources/leaflet.js/map/handler/Map.BoxZoom.js
@@ -0,0 +1,150 @@
+import {Map} from '../Map';
+import {Handler} from '../../core/Handler';
+import * as Util from '../../core/Util';
+import * as DomUtil from '../../dom/DomUtil';
+import * as DomEvent from '../../dom/DomEvent';
+import {LatLngBounds} from '../../geo/LatLngBounds';
+import {Bounds} from '../../geometry/Bounds';
+
+/*
+ * L.Handler.BoxZoom is used to add shift-drag zoom interaction to the map
+ * (zoom to a selected bounding box), enabled by default.
+ */
+
+// @namespace Map
+// @section Interaction Options
+Map.mergeOptions({
+	// @option boxZoom: Boolean = true
+	// Whether the map can be zoomed to a rectangular area specified by
+	// dragging the mouse while pressing the shift key.
+	boxZoom: true
+});
+
+export var BoxZoom = Handler.extend({
+	initialize: function (map) {
+		this._map = map;
+		this._container = map._container;
+		this._pane = map._panes.overlayPane;
+		this._resetStateTimeout = 0;
+		map.on('unload', this._destroy, this);
+	},
+
+	addHooks: function () {
+		DomEvent.on(this._container, 'mousedown', this._onMouseDown, this);
+	},
+
+	removeHooks: function () {
+		DomEvent.off(this._container, 'mousedown', this._onMouseDown, this);
+	},
+
+	moved: function () {
+		return this._moved;
+	},
+
+	_destroy: function () {
+		DomUtil.remove(this._pane);
+		delete this._pane;
+	},
+
+	_resetState: function () {
+		this._resetStateTimeout = 0;
+		this._moved = false;
+	},
+
+	_clearDeferredResetState: function () {
+		if (this._resetStateTimeout !== 0) {
+			clearTimeout(this._resetStateTimeout);
+			this._resetStateTimeout = 0;
+		}
+	},
+
+	_onMouseDown: function (e) {
+		if (!e.shiftKey || ((e.which !== 1) && (e.button !== 1))) { return false; }
+
+		// Clear the deferred resetState if it hasn't executed yet, otherwise it
+		// will interrupt the interaction and orphan a box element in the container.
+		this._clearDeferredResetState();
+		this._resetState();
+
+		DomUtil.disableTextSelection();
+		DomUtil.disableImageDrag();
+
+		this._startPoint = this._map.mouseEventToContainerPoint(e);
+
+		DomEvent.on(document, {
+			contextmenu: DomEvent.stop,
+			mousemove: this._onMouseMove,
+			mouseup: this._onMouseUp,
+			keydown: this._onKeyDown
+		}, this);
+	},
+
+	_onMouseMove: function (e) {
+		if (!this._moved) {
+			this._moved = true;
+
+			this._box = DomUtil.create('div', 'leaflet-zoom-box', this._container);
+			DomUtil.addClass(this._container, 'leaflet-crosshair');
+
+			this._map.fire('boxzoomstart');
+		}
+
+		this._point = this._map.mouseEventToContainerPoint(e);
+
+		var bounds = new Bounds(this._point, this._startPoint),
+		    size = bounds.getSize();
+
+		DomUtil.setPosition(this._box, bounds.min);
+
+		this._box.style.width  = size.x + 'px';
+		this._box.style.height = size.y + 'px';
+	},
+
+	_finish: function () {
+		if (this._moved) {
+			DomUtil.remove(this._box);
+			DomUtil.removeClass(this._container, 'leaflet-crosshair');
+		}
+
+		DomUtil.enableTextSelection();
+		DomUtil.enableImageDrag();
+
+		DomEvent.off(document, {
+			contextmenu: DomEvent.stop,
+			mousemove: this._onMouseMove,
+			mouseup: this._onMouseUp,
+			keydown: this._onKeyDown
+		}, this);
+	},
+
+	_onMouseUp: function (e) {
+		if ((e.which !== 1) && (e.button !== 1)) { return; }
+
+		this._finish();
+
+		if (!this._moved) { return; }
+		// Postpone to next JS tick so internal click event handling
+		// still see it as "moved".
+		this._clearDeferredResetState();
+		this._resetStateTimeout = setTimeout(Util.bind(this._resetState, this), 0);
+
+		var bounds = new LatLngBounds(
+		        this._map.containerPointToLatLng(this._startPoint),
+		        this._map.containerPointToLatLng(this._point));
+
+		this._map
+			.fitBounds(bounds)
+			.fire('boxzoomend', {boxZoomBounds: bounds});
+	},
+
+	_onKeyDown: function (e) {
+		if (e.keyCode === 27) {
+			this._finish();
+		}
+	}
+});
+
+// @section Handlers
+// @property boxZoom: Handler
+// Box (shift-drag with mouse) zoom handler.
+Map.addInitHook('addHandler', 'boxZoom', BoxZoom);
diff --git a/debian/missing-sources/leaflet.js/map/handler/Map.DoubleClickZoom.js b/debian/missing-sources/leaflet.js/map/handler/Map.DoubleClickZoom.js
new file mode 100644
index 0000000..c105e8e
--- /dev/null
+++ b/debian/missing-sources/leaflet.js/map/handler/Map.DoubleClickZoom.js
@@ -0,0 +1,55 @@
+import {Map} from '../Map';
+import {Handler} from '../../core/Handler';
+
+/*
+ * L.Handler.DoubleClickZoom is used to handle double-click zoom on the map, enabled by default.
+ */
+
+// @namespace Map
+// @section Interaction Options
+
+Map.mergeOptions({
+	// @option doubleClickZoom: Boolean|String = true
+	// Whether the map can be zoomed in by double clicking on it and
+	// zoomed out by double clicking while holding shift. If passed
+	// `'center'`, double-click zoom will zoom to the center of the
+	//  view regardless of where the mouse was.
+	doubleClickZoom: true
+});
+
+export var DoubleClickZoom = Handler.extend({
+	addHooks: function () {
+		this._map.on('dblclick', this._onDoubleClick, this);
+	},
+
+	removeHooks: function () {
+		this._map.off('dblclick', this._onDoubleClick, this);
+	},
+
+	_onDoubleClick: function (e) {
+		var map = this._map,
+		    oldZoom = map.getZoom(),
+		    delta = map.options.zoomDelta,
+		    zoom = e.originalEvent.shiftKey ? oldZoom - delta : oldZoom + delta;
+
+		if (map.options.doubleClickZoom === 'center') {
+			map.setZoom(zoom);
+		} else {
+			map.setZoomAround(e.containerPoint, zoom);
+		}
+	}
+});
+
+// @section Handlers
+//
+// Map properties include interaction handlers that allow you to control
+// interaction behavior in runtime, enabling or disabling certain features such
+// as dragging or touch zoom (see `Handler` methods). For example:
+//
+// ```js
+// map.doubleClickZoom.disable();
+// ```
+//
+// @property doubleClickZoom: Handler
+// Double click zoom handler.
+Map.addInitHook('addHandler', 'doubleClickZoom', DoubleClickZoom);
diff --git a/debian/missing-sources/leaflet.js/map/handler/Map.Drag.js b/debian/missing-sources/leaflet.js/map/handler/Map.Drag.js
new file mode 100644
index 0000000..69597bd
--- /dev/null
+++ b/debian/missing-sources/leaflet.js/map/handler/Map.Drag.js
@@ -0,0 +1,236 @@
+import {Map} from '../Map';
+import * as Browser from '../../core/Browser';
+import {Handler} from '../../core/Handler';
+import {Draggable} from '../../dom/Draggable';
+import * as Util from '../../core/Util';
+import * as DomUtil from '../../dom/DomUtil';
+import {toLatLngBounds as latLngBounds} from '../../geo/LatLngBounds';
+import {toBounds} from '../../geometry/Bounds';
+
+/*
+ * L.Handler.MapDrag is used to make the map draggable (with panning inertia), enabled by default.
+ */
+
+// @namespace Map
+// @section Interaction Options
+Map.mergeOptions({
+	// @option dragging: Boolean = true
+	// Whether the map be draggable with mouse/touch or not.
+	dragging: true,
+
+	// @section Panning Inertia Options
+	// @option inertia: Boolean = *
+	// If enabled, panning of the map will have an inertia effect where
+	// the map builds momentum while dragging and continues moving in
+	// the same direction for some time. Feels especially nice on touch
+	// devices. Enabled by default unless running on old Android devices.
+	inertia: !Browser.android23,
+
+	// @option inertiaDeceleration: Number = 3000
+	// The rate with which the inertial movement slows down, in pixels/second².
+	inertiaDeceleration: 3400, // px/s^2
+
+	// @option inertiaMaxSpeed: Number = Infinity
+	// Max speed of the inertial movement, in pixels/second.
+	inertiaMaxSpeed: Infinity, // px/s
+
+	// @option easeLinearity: Number = 0.2
+	easeLinearity: 0.2,
+
+	// TODO refactor, move to CRS
+	// @option worldCopyJump: Boolean = false
+	// With this option enabled, the map tracks when you pan to another "copy"
+	// of the world and seamlessly jumps to the original one so that all overlays
+	// like markers and vector layers are still visible.
+	worldCopyJump: false,
+
+	// @option maxBoundsViscosity: Number = 0.0
+	// If `maxBounds` is set, this option will control how solid the bounds
+	// are when dragging the map around. The default value of `0.0` allows the
+	// user to drag outside the bounds at normal speed, higher values will
+	// slow down map dragging outside bounds, and `1.0` makes the bounds fully
+	// solid, preventing the user from dragging outside the bounds.
+	maxBoundsViscosity: 0.0
+});
+
+export var Drag = Handler.extend({
+	addHooks: function () {
+		if (!this._draggable) {
+			var map = this._map;
+
+			this._draggable = new Draggable(map._mapPane, map._container);
+
+			this._draggable.on({
+				dragstart: this._onDragStart,
+				drag: this._onDrag,
+				dragend: this._onDragEnd
+			}, this);
+
+			this._draggable.on('predrag', this._onPreDragLimit, this);
+			if (map.options.worldCopyJump) {
+				this._draggable.on('predrag', this._onPreDragWrap, this);
+				map.on('zoomend', this._onZoomEnd, this);
+
+				map.whenReady(this._onZoomEnd, this);
+			}
+		}
+		DomUtil.addClass(this._map._container, 'leaflet-grab leaflet-touch-drag');
+		this._draggable.enable();
+		this._positions = [];
+		this._times = [];
+	},
+
+	removeHooks: function () {
+		DomUtil.removeClass(this._map._container, 'leaflet-grab');
+		DomUtil.removeClass(this._map._container, 'leaflet-touch-drag');
+		this._draggable.disable();
+	},
+
+	moved: function () {
+		return this._draggable && this._draggable._moved;
+	},
+
+	moving: function () {
+		return this._draggable && this._draggable._moving;
+	},
+
+	_onDragStart: function () {
+		var map = this._map;
+
+		map._stop();
+		if (this._map.options.maxBounds && this._map.options.maxBoundsViscosity) {
+			var bounds = latLngBounds(this._map.options.maxBounds);
+
+			this._offsetLimit = toBounds(
+				this._map.latLngToContainerPoint(bounds.getNorthWest()).multiplyBy(-1),
+				this._map.latLngToContainerPoint(bounds.getSouthEast()).multiplyBy(-1)
+					.add(this._map.getSize()));
+
+			this._viscosity = Math.min(1.0, Math.max(0.0, this._map.options.maxBoundsViscosity));
+		} else {
+			this._offsetLimit = null;
+		}
+
+		map
+		    .fire('movestart')
+		    .fire('dragstart');
+
+		if (map.options.inertia) {
+			this._positions = [];
+			this._times = [];
+		}
+	},
+
+	_onDrag: function (e) {
+		if (this._map.options.inertia) {
+			var time = this._lastTime = +new Date(),
+			    pos = this._lastPos = this._draggable._absPos || this._draggable._newPos;
+
+			this._positions.push(pos);
+			this._times.push(time);
+
+			this._prunePositions(time);
+		}
+
+		this._map
+		    .fire('move', e)
+		    .fire('drag', e);
+	},
+
+	_prunePositions: function (time) {
+		while (this._positions.length > 1 && time - this._times[0] > 50) {
+			this._positions.shift();
+			this._times.shift();
+		}
+	},
+
+	_onZoomEnd: function () {
+		var pxCenter = this._map.getSize().divideBy(2),
+		    pxWorldCenter = this._map.latLngToLayerPoint([0, 0]);
+
+		this._initialWorldOffset = pxWorldCenter.subtract(pxCenter).x;
+		this._worldWidth = this._map.getPixelWorldBounds().getSize().x;
+	},
+
+	_viscousLimit: function (value, threshold) {
+		return value - (value - threshold) * this._viscosity;
+	},
+
+	_onPreDragLimit: function () {
+		if (!this._viscosity || !this._offsetLimit) { return; }
+
+		var offset = this._draggable._newPos.subtract(this._draggable._startPos);
+
+		var limit = this._offsetLimit;
+		if (offset.x < limit.min.x) { offset.x = this._viscousLimit(offset.x, limit.min.x); }
+		if (offset.y < limit.min.y) { offset.y = this._viscousLimit(offset.y, limit.min.y); }
+		if (offset.x > limit.max.x) { offset.x = this._viscousLimit(offset.x, limit.max.x); }
+		if (offset.y > limit.max.y) { offset.y = this._viscousLimit(offset.y, limit.max.y); }
+
+		this._draggable._newPos = this._draggable._startPos.add(offset);
+	},
+
+	_onPreDragWrap: function () {
+		// TODO refactor to be able to adjust map pane position after zoom
+		var worldWidth = this._worldWidth,
+		    halfWidth = Math.round(worldWidth / 2),
+		    dx = this._initialWorldOffset,
+		    x = this._draggable._newPos.x,
+		    newX1 = (x - halfWidth + dx) % worldWidth + halfWidth - dx,
+		    newX2 = (x + halfWidth + dx) % worldWidth - halfWidth - dx,
+		    newX = Math.abs(newX1 + dx) < Math.abs(newX2 + dx) ? newX1 : newX2;
+
+		this._draggable._absPos = this._draggable._newPos.clone();
+		this._draggable._newPos.x = newX;
+	},
+
+	_onDragEnd: function (e) {
+		var map = this._map,
+		    options = map.options,
+
+		    noInertia = !options.inertia || this._times.length < 2;
+
+		map.fire('dragend', e);
+
+		if (noInertia) {
+			map.fire('moveend');
+
+		} else {
+			this._prunePositions(+new Date());
+
+			var direction = this._lastPos.subtract(this._positions[0]),
+			    duration = (this._lastTime - this._times[0]) / 1000,
+			    ease = options.easeLinearity,
+
+			    speedVector = direction.multiplyBy(ease / duration),
+			    speed = speedVector.distanceTo([0, 0]),
+
+			    limitedSpeed = Math.min(options.inertiaMaxSpeed, speed),
+			    limitedSpeedVector = speedVector.multiplyBy(limitedSpeed / speed),
+
+			    decelerationDuration = limitedSpeed / (options.inertiaDeceleration * ease),
+			    offset = limitedSpeedVector.multiplyBy(-decelerationDuration / 2).round();
+
+			if (!offset.x && !offset.y) {
+				map.fire('moveend');
+
+			} else {
+				offset = map._limitOffset(offset, map.options.maxBounds);
+
+				Util.requestAnimFrame(function () {
+					map.panBy(offset, {
+						duration: decelerationDuration,
+						easeLinearity: ease,
+						noMoveStart: true,
+						animate: true
+					});
+				});
+			}
+		}
+	}
+});
+
+// @section Handlers
+// @property dragging: Handler
+// Map dragging handler (by both mouse and touch).
+Map.addInitHook('addHandler', 'dragging', Drag);
diff --git a/debian/missing-sources/leaflet.js/map/handler/Map.Keyboard.js b/debian/missing-sources/leaflet.js/map/handler/Map.Keyboard.js
new file mode 100644
index 0000000..66d34e6
--- /dev/null
+++ b/debian/missing-sources/leaflet.js/map/handler/Map.Keyboard.js
@@ -0,0 +1,180 @@
+import {Map} from '../Map';
+import {Handler} from '../../core/Handler';
+import {on, off, stop} from '../../dom/DomEvent';
+import {toPoint} from '../../geometry/Point';
+
+
+/*
+ * L.Map.Keyboard is handling keyboard interaction with the map, enabled by default.
+ */
+
+// @namespace Map
+// @section Keyboard Navigation Options
+Map.mergeOptions({
+	// @option keyboard: Boolean = true
+	// Makes the map focusable and allows users to navigate the map with keyboard
+	// arrows and `+`/`-` keys.
+	keyboard: true,
+
+	// @option keyboardPanDelta: Number = 80
+	// Amount of pixels to pan when pressing an arrow key.
+	keyboardPanDelta: 80
+});
+
+export var Keyboard = Handler.extend({
+
+	keyCodes: {
+		left:    [37],
+		right:   [39],
+		down:    [40],
+		up:      [38],
+		zoomIn:  [187, 107, 61, 171],
+		zoomOut: [189, 109, 54, 173]
+	},
+
+	initialize: function (map) {
+		this._map = map;
+
+		this._setPanDelta(map.options.keyboardPanDelta);
+		this._setZoomDelta(map.options.zoomDelta);
+	},
+
+	addHooks: function () {
+		var container = this._map._container;
+
+		// make the container focusable by tabbing
+		if (container.tabIndex <= 0) {
+			container.tabIndex = '0';
+		}
+
+		on(container, {
+			focus: this._onFocus,
+			blur: this._onBlur,
+			mousedown: this._onMouseDown
+		}, this);
+
+		this._map.on({
+			focus: this._addHooks,
+			blur: this._removeHooks
+		}, this);
+	},
+
+	removeHooks: function () {
+		this._removeHooks();
+
+		off(this._map._container, {
+			focus: this._onFocus,
+			blur: this._onBlur,
+			mousedown: this._onMouseDown
+		}, this);
+
+		this._map.off({
+			focus: this._addHooks,
+			blur: this._removeHooks
+		}, this);
+	},
+
+	_onMouseDown: function () {
+		if (this._focused) { return; }
+
+		var body = document.body,
+		    docEl = document.documentElement,
+		    top = body.scrollTop || docEl.scrollTop,
+		    left = body.scrollLeft || docEl.scrollLeft;
+
+		this._map._container.focus();
+
+		window.scrollTo(left, top);
+	},
+
+	_onFocus: function () {
+		this._focused = true;
+		this._map.fire('focus');
+	},
+
+	_onBlur: function () {
+		this._focused = false;
+		this._map.fire('blur');
+	},
+
+	_setPanDelta: function (panDelta) {
+		var keys = this._panKeys = {},
+		    codes = this.keyCodes,
+		    i, len;
+
+		for (i = 0, len = codes.left.length; i < len; i++) {
+			keys[codes.left[i]] = [-1 * panDelta, 0];
+		}
+		for (i = 0, len = codes.right.length; i < len; i++) {
+			keys[codes.right[i]] = [panDelta, 0];
+		}
+		for (i = 0, len = codes.down.length; i < len; i++) {
+			keys[codes.down[i]] = [0, panDelta];
+		}
+		for (i = 0, len = codes.up.length; i < len; i++) {
+			keys[codes.up[i]] = [0, -1 * panDelta];
+		}
+	},
+
+	_setZoomDelta: function (zoomDelta) {
+		var keys = this._zoomKeys = {},
+		    codes = this.keyCodes,
+		    i, len;
+
+		for (i = 0, len = codes.zoomIn.length; i < len; i++) {
+			keys[codes.zoomIn[i]] = zoomDelta;
+		}
+		for (i = 0, len = codes.zoomOut.length; i < len; i++) {
+			keys[codes.zoomOut[i]] = -zoomDelta;
+		}
+	},
+
+	_addHooks: function () {
+		on(document, 'keydown', this._onKeyDown, this);
+	},
+
+	_removeHooks: function () {
+		off(document, 'keydown', this._onKeyDown, this);
+	},
+
+	_onKeyDown: function (e) {
+		if (e.altKey || e.ctrlKey || e.metaKey) { return; }
+
+		var key = e.keyCode,
+		    map = this._map,
+		    offset;
+
+		if (key in this._panKeys) {
+
+			if (map._panAnim && map._panAnim._inProgress) { return; }
+
+			offset = this._panKeys[key];
+			if (e.shiftKey) {
+				offset = toPoint(offset).multiplyBy(3);
+			}
+
+			map.panBy(offset);
+
+			if (map.options.maxBounds) {
+				map.panInsideBounds(map.options.maxBounds);
+			}
+
+		} else if (key in this._zoomKeys) {
+			map.setZoom(map.getZoom() + (e.shiftKey ? 3 : 1) * this._zoomKeys[key]);
+
+		} else if (key === 27 && map._popup && map._popup.options.closeOnEscapeKey) {
+			map.closePopup();
+
+		} else {
+			return;
+		}
+
+		stop(e);
+	}
+});
+
+// @section Handlers
+// @section Handlers
+// @property keyboard: Handler
+// Keyboard navigation handler.
+Map.addInitHook('addHandler', 'keyboard', Keyboard);
diff --git a/debian/missing-sources/leaflet.js/map/handler/Map.ScrollWheelZoom.js b/debian/missing-sources/leaflet.js/map/handler/Map.ScrollWheelZoom.js
new file mode 100644
index 0000000..d61d33d
--- /dev/null
+++ b/debian/missing-sources/leaflet.js/map/handler/Map.ScrollWheelZoom.js
@@ -0,0 +1,91 @@
+import {Map} from '../Map';
+import {Handler} from '../../core/Handler';
+import * as DomEvent from '../../dom/DomEvent';
+import * as Util from '../../core/Util';
+
+/*
+ * L.Handler.ScrollWheelZoom is used by L.Map to enable mouse scroll wheel zoom on the map.
+ */
+
+// @namespace Map
+// @section Interaction Options
+Map.mergeOptions({
+	// @section Mousewheel options
+	// @option scrollWheelZoom: Boolean|String = true
+	// Whether the map can be zoomed by using the mouse wheel. If passed `'center'`,
+	// it will zoom to the center of the view regardless of where the mouse was.
+	scrollWheelZoom: true,
+
+	// @option wheelDebounceTime: Number = 40
+	// Limits the rate at which a wheel can fire (in milliseconds). By default
+	// user can't zoom via wheel more often than once per 40 ms.
+	wheelDebounceTime: 40,
+
+	// @option wheelPxPerZoomLevel: Number = 60
+	// How many scroll pixels (as reported by [L.DomEvent.getWheelDelta](#domevent-getwheeldelta))
+	// mean a change of one full zoom level. Smaller values will make wheel-zooming
+	// faster (and vice versa).
+	wheelPxPerZoomLevel: 60
+});
+
+export var ScrollWheelZoom = Handler.extend({
+	addHooks: function () {
+		DomEvent.on(this._map._container, 'mousewheel', this._onWheelScroll, this);
+
+		this._delta = 0;
+	},
+
+	removeHooks: function () {
+		DomEvent.off(this._map._container, 'mousewheel', this._onWheelScroll, this);
+	},
+
+	_onWheelScroll: function (e) {
+		var delta = DomEvent.getWheelDelta(e);
+
+		var debounce = this._map.options.wheelDebounceTime;
+
+		this._delta += delta;
+		this._lastMousePos = this._map.mouseEventToContainerPoint(e);
+
+		if (!this._startTime) {
+			this._startTime = +new Date();
+		}
+
+		var left = Math.max(debounce - (+new Date() - this._startTime), 0);
+
+		clearTimeout(this._timer);
+		this._timer = setTimeout(Util.bind(this._performZoom, this), left);
+
+		DomEvent.stop(e);
+	},
+
+	_performZoom: function () {
+		var map = this._map,
+		    zoom = map.getZoom(),
+		    snap = this._map.options.zoomSnap || 0;
+
+		map._stop(); // stop panning and fly animations if any
+
+		// map the delta with a sigmoid function to -4..4 range leaning on -1..1
+		var d2 = this._delta / (this._map.options.wheelPxPerZoomLevel * 4),
+		    d3 = 4 * Math.log(2 / (1 + Math.exp(-Math.abs(d2)))) / Math.LN2,
+		    d4 = snap ? Math.ceil(d3 / snap) * snap : d3,
+		    delta = map._limitZoom(zoom + (this._delta > 0 ? d4 : -d4)) - zoom;
+
+		this._delta = 0;
+		this._startTime = null;
+
+		if (!delta) { return; }
+
+		if (map.options.scrollWheelZoom === 'center') {
+			map.setZoom(zoom + delta);
+		} else {
+			map.setZoomAround(this._lastMousePos, zoom + delta);
+		}
+	}
+});
+
+// @section Handlers
+// @property scrollWheelZoom: Handler
+// Scroll wheel zoom handler.
+Map.addInitHook('addHandler', 'scrollWheelZoom', ScrollWheelZoom);
diff --git a/debian/missing-sources/leaflet.js/map/handler/Map.Tap.js b/debian/missing-sources/leaflet.js/map/handler/Map.Tap.js
new file mode 100644
index 0000000..9162637
--- /dev/null
+++ b/debian/missing-sources/leaflet.js/map/handler/Map.Tap.js
@@ -0,0 +1,136 @@
+import {Map} from '../Map';
+import {Handler} from '../../core/Handler';
+import * as DomEvent from '../../dom/DomEvent';
+import {Point} from '../../geometry/Point';
+import * as Util from '../../core/Util';
+import * as DomUtil from '../../dom/DomUtil';
+import * as Browser from '../../core/Browser';
+
+
+/*
+ * L.Map.Tap is used to enable mobile hacks like quick taps and long hold.
+ */
+
+// @namespace Map
+// @section Interaction Options
+Map.mergeOptions({
+	// @section Touch interaction options
+	// @option tap: Boolean = true
+	// Enables mobile hacks for supporting instant taps (fixing 200ms click
+	// delay on iOS/Android) and touch holds (fired as `contextmenu` events).
+	tap: true,
+
+	// @option tapTolerance: Number = 15
+	// The max number of pixels a user can shift his finger during touch
+	// for it to be considered a valid tap.
+	tapTolerance: 15
+});
+
+export var Tap = Handler.extend({
+	addHooks: function () {
+		DomEvent.on(this._map._container, 'touchstart', this._onDown, this);
+	},
+
+	removeHooks: function () {
+		DomEvent.off(this._map._container, 'touchstart', this._onDown, this);
+	},
+
+	_onDown: function (e) {
+		if (!e.touches) { return; }
+
+		DomEvent.preventDefault(e);
+
+		this._fireClick = true;
+
+		// don't simulate click or track longpress if more than 1 touch
+		if (e.touches.length > 1) {
+			this._fireClick = false;
+			clearTimeout(this._holdTimeout);
+			return;
+		}
+
+		var first = e.touches[0],
+		    el = first.target;
+
+		this._startPos = this._newPos = new Point(first.clientX, first.clientY);
+
+		// if touching a link, highlight it
+		if (el.tagName && el.tagName.toLowerCase() === 'a') {
+			DomUtil.addClass(el, 'leaflet-active');
+		}
+
+		// simulate long hold but setting a timeout
+		this._holdTimeout = setTimeout(Util.bind(function () {
+			if (this._isTapValid()) {
+				this._fireClick = false;
+				this._onUp();
+				this._simulateEvent('contextmenu', first);
+			}
+		}, this), 1000);
+
+		this._simulateEvent('mousedown', first);
+
+		DomEvent.on(document, {
+			touchmove: this._onMove,
+			touchend: this._onUp
+		}, this);
+	},
+
+	_onUp: function (e) {
+		clearTimeout(this._holdTimeout);
+
+		DomEvent.off(document, {
+			touchmove: this._onMove,
+			touchend: this._onUp
+		}, this);
+
+		if (this._fireClick && e && e.changedTouches) {
+
+			var first = e.changedTouches[0],
+			    el = first.target;
+
+			if (el && el.tagName && el.tagName.toLowerCase() === 'a') {
+				DomUtil.removeClass(el, 'leaflet-active');
+			}
+
+			this._simulateEvent('mouseup', first);
+
+			// simulate click if the touch didn't move too much
+			if (this._isTapValid()) {
+				this._simulateEvent('click', first);
+			}
+		}
+	},
+
+	_isTapValid: function () {
+		return this._newPos.distanceTo(this._startPos) <= this._map.options.tapTolerance;
+	},
+
+	_onMove: function (e) {
+		var first = e.touches[0];
+		this._newPos = new Point(first.clientX, first.clientY);
+		this._simulateEvent('mousemove', first);
+	},
+
+	_simulateEvent: function (type, e) {
+		var simulatedEvent = document.createEvent('MouseEvents');
+
+		simulatedEvent._simulated = true;
+		e.target._simulatedClick = true;
+
+		simulatedEvent.initMouseEvent(
+		        type, true, true, window, 1,
+		        e.screenX, e.screenY,
+		        e.clientX, e.clientY,
+		        false, false, false, false, 0, null);
+
+		e.target.dispatchEvent(simulatedEvent);
+	}
+});
+
+// @section Handlers
+// @property tap: Handler
+// Mobile touch hacks (quick tap and touch hold) handler.
+if (Browser.touch && !Browser.pointer) {
+	Map.addInitHook('addHandler', 'tap', Tap);
+}
diff --git a/debian/missing-sources/leaflet.js/map/handler/Map.TouchZoom.js b/debian/missing-sources/leaflet.js/map/handler/Map.TouchZoom.js
new file mode 100644
index 0000000..5daa0ba
--- /dev/null
+++ b/debian/missing-sources/leaflet.js/map/handler/Map.TouchZoom.js
@@ -0,0 +1,130 @@
+import {Map} from '../Map';
+import {Handler} from '../../core/Handler';
+import * as DomEvent from '../../dom/DomEvent';
+import * as Util from '../../core/Util';
+import * as DomUtil from '../../dom/DomUtil';
+import * as Browser from '../../core/Browser';
+
+/*
+ * L.Handler.TouchZoom is used by L.Map to add pinch zoom on supported mobile browsers.
+ */
+
+// @namespace Map
+// @section Interaction Options
+Map.mergeOptions({
+	// @section Touch interaction options
+	// @option touchZoom: Boolean|String = *
+	// Whether the map can be zoomed by touch-dragging with two fingers. If
+	// passed `'center'`, it will zoom to the center of the view regardless of
+	// where the touch events (fingers) were. Enabled for touch-capable web
+	// browsers except for old Androids.
+	touchZoom: Browser.touch && !Browser.android23,
+
+	// @option bounceAtZoomLimits: Boolean = true
+	// Set it to false if you don't want the map to zoom beyond min/max zoom
+	// and then bounce back when pinch-zooming.
+	bounceAtZoomLimits: true
+});
+
+export var TouchZoom = Handler.extend({
+	addHooks: function () {
+		DomUtil.addClass(this._map._container, 'leaflet-touch-zoom');
+		DomEvent.on(this._map._container, 'touchstart', this._onTouchStart, this);
+	},
+
+	removeHooks: function () {
+		DomUtil.removeClass(this._map._container, 'leaflet-touch-zoom');
+		DomEvent.off(this._map._container, 'touchstart', this._onTouchStart, this);
+	},
+
+	_onTouchStart: function (e) {
+		var map = this._map;
+		if (!e.touches || e.touches.length !== 2 || map._animatingZoom || this._zooming) { return; }
+
+		var p1 = map.mouseEventToContainerPoint(e.touches[0]),
+		    p2 = map.mouseEventToContainerPoint(e.touches[1]);
+
+		this._centerPoint = map.getSize()._divideBy(2);
+		this._startLatLng = map.containerPointToLatLng(this._centerPoint);
+		if (map.options.touchZoom !== 'center') {
+			this._pinchStartLatLng = map.containerPointToLatLng(p1.add(p2)._divideBy(2));
+		}
+
+		this._startDist = p1.distanceTo(p2);
+		this._startZoom = map.getZoom();
+
+		this._moved = false;
+		this._zooming = true;
+
+		map._stop();
+
+		DomEvent.on(document, 'touchmove', this._onTouchMove, this);
+		DomEvent.on(document, 'touchend', this._onTouchEnd, this);
+
+		DomEvent.preventDefault(e);
+	},
+
+	_onTouchMove: function (e) {
+		if (!e.touches || e.touches.length !== 2 || !this._zooming) { return; }
+
+		var map = this._map,
+		    p1 = map.mouseEventToContainerPoint(e.touches[0]),
+		    p2 = map.mouseEventToContainerPoint(e.touches[1]),
+		    scale = p1.distanceTo(p2) / this._startDist;
+
+		this._zoom = map.getScaleZoom(scale, this._startZoom);
+
+		if (!map.options.bounceAtZoomLimits && (
+			(this._zoom < map.getMinZoom() && scale < 1) ||
+			(this._zoom > map.getMaxZoom() && scale > 1))) {
+			this._zoom = map._limitZoom(this._zoom);
+		}
+
+		if (map.options.touchZoom === 'center') {
+			this._center = this._startLatLng;
+			if (scale === 1) { return; }
+		} else {
+			// Get delta from pinch to center, so centerLatLng is delta applied to initial pinchLatLng
+			var delta = p1._add(p2)._divideBy(2)._subtract(this._centerPoint);
+			if (scale === 1 && delta.x === 0 && delta.y === 0) { return; }
+			this._center = map.unproject(map.project(this._pinchStartLatLng, this._zoom).subtract(delta), this._zoom);
+		}
+
+		if (!this._moved) {
+			map._moveStart(true, false);
+			this._moved = true;
+		}
+
+		Util.cancelAnimFrame(this._animRequest);
+
+		var moveFn = Util.bind(map._move, map, this._center, this._zoom, {pinch: true, round: false});
+		this._animRequest = Util.requestAnimFrame(moveFn, this, true);
+
+		DomEvent.preventDefault(e);
+	},
+
+	_onTouchEnd: function () {
+		if (!this._moved || !this._zooming) {
+			this._zooming = false;
+			return;
+		}
+
+		this._zooming = false;
+		Util.cancelAnimFrame(this._animRequest);
+
+		DomEvent.off(document, 'touchmove', this._onTouchMove);
+		DomEvent.off(document, 'touchend', this._onTouchEnd);
+
+		// Pinch updates GridLayers' levels only when zoomSnap is off, so zoomSnap becomes noUpdate.
+		if (this._map.options.zoomAnimation) {
+			this._map._animateZoom(this._center, this._map._limitZoom(this._zoom), true, this._map.options.zoomSnap);
+		} else {
+			this._map._resetView(this._center, this._map._limitZoom(this._zoom));
+		}
+	}
+});
+
+// @section Handlers
+// @property touchZoom: Handler
+// Touch zoom handler.
+Map.addInitHook('addHandler', 'touchZoom', TouchZoom);
diff --git a/debian/missing-sources/leaflet.js/map/index.js b/debian/missing-sources/leaflet.js/map/index.js
new file mode 100644
index 0000000..bc73790
--- /dev/null
+++ b/debian/missing-sources/leaflet.js/map/index.js
@@ -0,0 +1,17 @@
+import {Map} from './Map';
+import {BoxZoom} from './handler/Map.BoxZoom';
+Map.BoxZoom = BoxZoom;
+import {DoubleClickZoom} from './handler/Map.DoubleClickZoom';
+Map.DoubleClickZoom = DoubleClickZoom;
+import {Drag} from './handler/Map.Drag';
+Map.Drag = Drag;
+import {Keyboard} from './handler/Map.Keyboard';
+Map.Keyboard = Keyboard;
+import {ScrollWheelZoom} from './handler/Map.ScrollWheelZoom';
+Map.ScrollWheelZoom = ScrollWheelZoom;
+import {Tap} from './handler/Map.Tap';
+Map.Tap = Tap;
+import {TouchZoom} from './handler/Map.TouchZoom';
+Map.TouchZoom = TouchZoom;
+
+export {Map, createMap as map} from './Map';