/*
	Leaflet.draw, a plugin that adds drawing and editing tools to Leaflet powered maps.
	(c) 2012-2013, Jacob Toye, Smartrak

	https://github.com/Leaflet/Leaflet.draw
	http://leafletjs.com
	https://github.com/jacobtoye
*/
!(function (t, e) {
	(L.drawVersion = "0.2.3"),
		(L.drawLocal = {
			draw: {
				toolbar: {
					actions: { title: "Cancel drawing", text: "Cancel" },
					undo: { title: "Delete last point drawn", text: "Delete last point" },
					buttons: {
						polyline: "Draw a polyline",
						polygon: "Draw a polygon",
						rectangle: "Draw a rectangle",
						circle: "Draw a circle",
						marker: "Draw a marker",
					},
				},
				handlers: {
					circle: { tooltip: { start: "Click and drag to draw circle." } },
					marker: { tooltip: { start: "Click map to place marker." } },
					polygon: {
						tooltip: {
							start: "Click to start drawing shape.",
							cont: "Click to continue drawing shape.",
							end: "Click first point to close this shape.",
						},
					},
					polyline: {
						error: "<strong>Error:</strong> shape edges cannot cross!",
						tooltip: {
							start: "Click to start drawing line.",
							cont: "Click to continue drawing line.",
							end: "Click last point to finish line.",
						},
					},
					rectangle: { tooltip: { start: "Click and drag to draw rectangle." } },
					simpleshape: { tooltip: { end: "Release mouse to finish drawing." } },
				},
			},
			edit: {
				toolbar: {
					actions: {
						save: { title: "Save changes.", text: "Save" },
						cancel: { title: "Cancel editing, discards all changes.", text: "Cancel" },
					},
					buttons: {
						edit: "Edit layers.",
						editDisabled: "No layers to edit.",
						remove: "Delete layers.",
						removeDisabled: "No layers to delete.",
					},
				},
				handlers: {
					edit: {
						tooltip: {
							text: "Drag handles, or marker to edit feature.",
							subtext: "Click cancel to undo changes.",
						},
					},
					remove: { tooltip: { text: "Click on a feature to remove" } },
				},
			},
		}),
		(L.Draw = {}),
		(L.Draw.Feature = L.Handler.extend({
			includes: L.Mixin.Events,
			initialize: function (t, e) {
				(this._map = t),
					(this._container = t._container),
					(this._overlayPane = t._panes.overlayPane),
					(this._popupPane = t._panes.popupPane),
					e &&
						e.shapeOptions &&
						(e.shapeOptions = L.Util.extend({}, this.options.shapeOptions, e.shapeOptions)),
					L.setOptions(this, e);
			},
			enable: function () {
				this._enabled ||
					(this.fire("enabled", { handler: this.type }),
					this._map.fire("draw:drawstart", { layerType: this.type }),
					L.Handler.prototype.enable.call(this));
			},
			disable: function () {
				this._enabled &&
					(L.Handler.prototype.disable.call(this),
					this._map.fire("draw:drawstop", { layerType: this.type }),
					this.fire("disabled", { handler: this.type }));
			},
			addHooks: function () {
				var t = this._map;
				t &&
					(L.DomUtil.disableTextSelection(),
					t.getContainer().focus(),
					(this._tooltip = new L.Tooltip(this._map)),
					L.DomEvent.on(this._container, "keyup", this._cancelDrawing, this));
			},
			removeHooks: function () {
				this._map &&
					(L.DomUtil.enableTextSelection(),
					this._tooltip.dispose(),
					(this._tooltip = null),
					L.DomEvent.off(this._container, "keyup", this._cancelDrawing, this));
			},
			setOptions: function (t) {
				L.setOptions(this, t);
			},
			_fireCreatedEvent: function (t) {
				this._map.fire("draw:created", { layer: t, layerType: this.type });
			},
			_cancelDrawing: function (t) {
				27 === t.keyCode && this.disable();
			},
		})),
		(L.Draw.Polyline = L.Draw.Feature.extend({
			statics: { TYPE: "polyline" },
			Poly: L.Polyline,
			options: {
				allowIntersection: !0,
				repeatMode: !1,
				drawError: { color: "#b00b00", timeout: 2500 },
				icon: new L.DivIcon({
					iconSize: new L.Point(8, 8),
					className: "leaflet-div-icon leaflet-editing-icon",
				}),
				guidelineDistance: 20,
				maxGuideLineLength: 4e3,
				shapeOptions: {
					stroke: !0,
					color: "#f06eaa",
					weight: 4,
					opacity: 0.5,
					fill: !1,
					clickable: !0,
				},
				metric: !0,
				showLength: !0,
				zIndexOffset: 2e3,
			},
			initialize: function (t, e) {
				(this.options.drawError.message = L.drawLocal.draw.handlers.polyline.error),
					e &&
						e.drawError &&
						(e.drawError = L.Util.extend({}, this.options.drawError, e.drawError)),
					(this.type = L.Draw.Polyline.TYPE),
					L.Draw.Feature.prototype.initialize.call(this, t, e);
			},
			addHooks: function () {
				L.Draw.Feature.prototype.addHooks.call(this),
					this._map &&
						((this._markers = []),
						(this._markerGroup = new L.LayerGroup()),
						this._map.addLayer(this._markerGroup),
						(this._poly = new L.Polyline([], this.options.shapeOptions)),
						this._tooltip.updateContent(this._getTooltipText()),
						this._mouseMarker ||
							(this._mouseMarker = L.marker(this._map.getCenter(), {
								icon: L.divIcon({
									className: "leaflet-mouse-marker",
									iconAnchor: [20, 20],
									iconSize: [40, 40],
								}),
								opacity: 0,
								zIndexOffset: this.options.zIndexOffset,
							})),
						this._mouseMarker.on("mousedown", this._onMouseDown, this).addTo(this._map),
						this._map
							.on("mousemove", this._onMouseMove, this)
							.on("mouseup", this._onMouseUp, this)
							.on("zoomend", this._onZoomEnd, this));
			},
			removeHooks: function () {
				L.Draw.Feature.prototype.removeHooks.call(this),
					this._clearHideErrorTimeout(),
					this._cleanUpShape(),
					this._map.removeLayer(this._markerGroup),
					delete this._markerGroup,
					delete this._markers,
					this._map.removeLayer(this._poly),
					delete this._poly,
					this._mouseMarker
						.off("mousedown", this._onMouseDown, this)
						.off("mouseup", this._onMouseUp, this),
					this._map.removeLayer(this._mouseMarker),
					delete this._mouseMarker,
					this._clearGuides(),
					this._map.off("mousemove", this._onMouseMove, this).off("zoomend", this._onZoomEnd, this);
			},
			deleteLastVertex: function () {
				if (!(this._markers.length <= 1)) {
					var t = this._markers.pop(),
						e = this._poly,
						i = this._poly.spliceLatLngs(e.getLatLngs().length - 1, 1)[0];
					this._markerGroup.removeLayer(t),
						e.getLatLngs().length < 2 && this._map.removeLayer(e),
						this._vertexChanged(i, !1);
				}
			},
			addVertex: function (t) {
				var e = this._markers.length;
				return e > 0 && !this.options.allowIntersection && this._poly.newLatLngIntersects(t)
					? void this._showErrorTooltip()
					: (this._errorShown && this._hideErrorTooltip(),
					  this._markers.push(this._createMarker(t)),
					  this._poly.addLatLng(t),
					  2 === this._poly.getLatLngs().length && this._map.addLayer(this._poly),
					  void this._vertexChanged(t, !0));
			},
			_finishShape: function () {
				var t = this._poly.newLatLngIntersects(this._poly.getLatLngs()[0], !0);
				return (!this.options.allowIntersection && t) || !this._shapeIsValid()
					? void this._showErrorTooltip()
					: (this._fireCreatedEvent(),
					  this.disable(),
					  void (this.options.repeatMode && this.enable()));
			},
			_shapeIsValid: function () {
				return !0;
			},
			_onZoomEnd: function () {
				this._updateGuide();
			},
			_onMouseMove: function (t) {
				var e = t.layerPoint,
					i = t.latlng;
				(this._currentLatLng = i),
					this._updateTooltip(i),
					this._updateGuide(e),
					this._mouseMarker.setLatLng(i),
					L.DomEvent.preventDefault(t.originalEvent);
			},
			_vertexChanged: function (t, e) {
				this._updateFinishHandler(),
					this._updateRunningMeasure(t, e),
					this._clearGuides(),
					this._updateTooltip();
			},
			_onMouseDown: function (t) {
				var e = t.originalEvent;
				this._mouseDownOrigin = L.point(e.clientX, e.clientY);
			},
			_onMouseUp: function (e) {
				if (this._mouseDownOrigin) {
					var i = L.point(e.originalEvent.clientX, e.originalEvent.clientY).distanceTo(
						this._mouseDownOrigin
					);
					Math.abs(i) < 9 * (t.devicePixelRatio || 1) && this.addVertex(e.latlng);
				}
				this._mouseDownOrigin = null;
			},
			_updateFinishHandler: function () {
				var t = this._markers.length;
				t > 1 && this._markers[t - 1].on("click", this._finishShape, this),
					t > 2 && this._markers[t - 2].off("click", this._finishShape, this);
			},
			_createMarker: function (t) {
				var e = new L.Marker(t, {
					icon: this.options.icon,
					zIndexOffset: 2 * this.options.zIndexOffset,
				});
				return this._markerGroup.addLayer(e), e;
			},
			_updateGuide: function (t) {
				var e = this._markers.length;
				e > 0 &&
					((t = t || this._map.latLngToLayerPoint(this._currentLatLng)),
					this._clearGuides(),
					this._drawGuide(this._map.latLngToLayerPoint(this._markers[e - 1].getLatLng()), t));
			},
			_updateTooltip: function (t) {
				var e = this._getTooltipText();
				t && this._tooltip.updatePosition(t), this._errorShown || this._tooltip.updateContent(e);
			},
			_drawGuide: function (t, e) {
				var i,
					o,
					a,
					s = Math.floor(Math.sqrt(Math.pow(e.x - t.x, 2) + Math.pow(e.y - t.y, 2))),
					r = this.options.guidelineDistance,
					n = this.options.maxGuideLineLength,
					l = s > n ? s - n : r;
				for (
					this._guidesContainer ||
					(this._guidesContainer = L.DomUtil.create(
						"div",
						"leaflet-draw-guides",
						this._overlayPane
					));
					s > l;
					l += this.options.guidelineDistance
				)
					(i = l / s),
						(o = {
							x: Math.floor(t.x * (1 - i) + i * e.x),
							y: Math.floor(t.y * (1 - i) + i * e.y),
						}),
						(a = L.DomUtil.create("div", "leaflet-draw-guide-dash", this._guidesContainer)),
						(a.style.backgroundColor = this._errorShown
							? this.options.drawError.color
							: this.options.shapeOptions.color),
						L.DomUtil.setPosition(a, o);
			},
			_updateGuideColor: function (t) {
				if (this._guidesContainer)
					for (var e = 0, i = this._guidesContainer.childNodes.length; i > e; e++)
						this._guidesContainer.childNodes[e].style.backgroundColor = t;
			},
			_clearGuides: function () {
				if (this._guidesContainer)
					for (; this._guidesContainer.firstChild; )
						this._guidesContainer.removeChild(this._guidesContainer.firstChild);
			},
			_getTooltipText: function () {
				var t,
					e,
					i = this.options.showLength;
				return (
					0 === this._markers.length
						? (t = { text: L.drawLocal.draw.handlers.polyline.tooltip.start })
						: ((e = i ? this._getMeasurementString() : ""),
						  (t =
								1 === this._markers.length
									? { text: L.drawLocal.draw.handlers.polyline.tooltip.cont, subtext: e }
									: { text: L.drawLocal.draw.handlers.polyline.tooltip.end, subtext: e })),
					t
				);
			},
			_updateRunningMeasure: function (t, e) {
				var i,
					o,
					a = this._markers.length;
				1 === this._markers.length
					? (this._measurementRunningTotal = 0)
					: ((i = a - (e ? 2 : 1)),
					  (o = t.distanceTo(this._markers[i].getLatLng())),
					  (this._measurementRunningTotal += o * (e ? 1 : -1)));
			},
			_getMeasurementString: function () {
				var t,
					e = this._currentLatLng,
					i = this._markers[this._markers.length - 1].getLatLng();
				return (
					(t = this._measurementRunningTotal + e.distanceTo(i)),
					L.GeometryUtil.readableDistance(t, this.options.metric)
				);
			},
			_showErrorTooltip: function () {
				(this._errorShown = !0),
					this._tooltip.showAsError().updateContent({ text: this.options.drawError.message }),
					this._updateGuideColor(this.options.drawError.color),
					this._poly.setStyle({ color: this.options.drawError.color }),
					this._clearHideErrorTimeout(),
					(this._hideErrorTimeout = setTimeout(
						L.Util.bind(this._hideErrorTooltip, this),
						this.options.drawError.timeout
					));
			},
			_hideErrorTooltip: function () {
				(this._errorShown = !1),
					this._clearHideErrorTimeout(),
					this._tooltip.removeError().updateContent(this._getTooltipText()),
					this._updateGuideColor(this.options.shapeOptions.color),
					this._poly.setStyle({ color: this.options.shapeOptions.color });
			},
			_clearHideErrorTimeout: function () {
				this._hideErrorTimeout &&
					(clearTimeout(this._hideErrorTimeout), (this._hideErrorTimeout = null));
			},
			_cleanUpShape: function () {
				this._markers.length > 1 &&
					this._markers[this._markers.length - 1].off("click", this._finishShape, this);
			},
			_fireCreatedEvent: function () {
				var t = new this.Poly(this._poly.getLatLngs(), this.options.shapeOptions);
				L.Draw.Feature.prototype._fireCreatedEvent.call(this, t);
			},
		})),
		(L.Draw.Polygon = L.Draw.Polyline.extend({
			statics: { TYPE: "polygon" },
			Poly: L.Polygon,
			options: {
				showArea: !1,
				shapeOptions: {
					stroke: !0,
					color: "#f06eaa",
					weight: 4,
					opacity: 0.5,
					fill: !0,
					fillColor: null,
					fillOpacity: 0.2,
					clickable: !0,
				},
			},
			initialize: function (t, e) {
				L.Draw.Polyline.prototype.initialize.call(this, t, e), (this.type = L.Draw.Polygon.TYPE);
			},
			_updateFinishHandler: function () {
				var t = this._markers.length;
				1 === t && this._markers[0].on("click", this._finishShape, this),
					t > 2 &&
						(this._markers[t - 1].on("dblclick", this._finishShape, this),
						t > 3 && this._markers[t - 2].off("dblclick", this._finishShape, this));
			},
			_getTooltipText: function () {
				var t, e;
				return (
					0 === this._markers.length
						? (t = L.drawLocal.draw.handlers.polygon.tooltip.start)
						: this._markers.length < 3
						? (t = L.drawLocal.draw.handlers.polygon.tooltip.cont)
						: ((t = L.drawLocal.draw.handlers.polygon.tooltip.end),
						  (e = this._getMeasurementString())),
					{ text: t, subtext: e }
				);
			},
			_getMeasurementString: function () {
				var t = this._area;
				return t ? L.GeometryUtil.readableArea(t, this.options.metric) : null;
			},
			_shapeIsValid: function () {
				return this._markers.length >= 3;
			},
			_vertexAdded: function () {
				if (!this.options.allowIntersection && this.options.showArea) {
					var t = this._poly.getLatLngs();
					this._area = L.GeometryUtil.geodesicArea(t);
				}
			},
			_cleanUpShape: function () {
				var t = this._markers.length;
				t > 0 &&
					(this._markers[0].off("click", this._finishShape, this),
					t > 2 && this._markers[t - 1].off("dblclick", this._finishShape, this));
			},
		})),
		(L.SimpleShape = {}),
		(L.Draw.SimpleShape = L.Draw.Feature.extend({
			options: { repeatMode: !1 },
			initialize: function (t, e) {
				(this._endLabelText = L.drawLocal.draw.handlers.simpleshape.tooltip.end),
					L.Draw.Feature.prototype.initialize.call(this, t, e);
			},
			addHooks: function () {
				L.Draw.Feature.prototype.addHooks.call(this),
					this._map &&
						((this._mapDraggable = this._map.dragging.enabled()),
						this._mapDraggable && this._map.dragging.disable(),
						(this._container.style.cursor = "crosshair"),
						this._tooltip.updateContent({ text: this._initialLabelText }),
						this._map
							.on("mousedown", this._onMouseDown, this)
							.on("mousemove", this._onMouseMove, this));
			},
			removeHooks: function () {
				L.Draw.Feature.prototype.removeHooks.call(this),
					this._map &&
						(this._mapDraggable && this._map.dragging.enable(),
						(this._container.style.cursor = ""),
						this._map
							.off("mousedown", this._onMouseDown, this)
							.off("mousemove", this._onMouseMove, this),
						L.DomEvent.off(e, "mouseup", this._onMouseUp, this),
						this._shape && (this._map.removeLayer(this._shape), delete this._shape)),
					(this._isDrawing = !1);
			},
			_onMouseDown: function (t) {
				(this._isDrawing = !0),
					(this._startLatLng = t.latlng),
					L.DomEvent.on(e, "mouseup", this._onMouseUp, this).preventDefault(t.originalEvent);
			},
			_onMouseMove: function (t) {
				var e = t.latlng;
				this._tooltip.updatePosition(e),
					this._isDrawing &&
						(this._tooltip.updateContent({ text: this._endLabelText }), this._drawShape(e));
			},
			_onMouseUp: function () {
				this._shape && this._fireCreatedEvent(),
					this.disable(),
					this.options.repeatMode && this.enable();
			},
		})),
		(L.Draw.Rectangle = L.Draw.SimpleShape.extend({
			statics: { TYPE: "rectangle" },
			options: {
				shapeOptions: {
					stroke: !0,
					color: "#f06eaa",
					weight: 4,
					opacity: 0.5,
					fill: !0,
					fillColor: null,
					fillOpacity: 0.2,
					clickable: !0,
				},
			},
			initialize: function (t, e) {
				(this.type = L.Draw.Rectangle.TYPE),
					(this._initialLabelText = L.drawLocal.draw.handlers.rectangle.tooltip.start),
					L.Draw.SimpleShape.prototype.initialize.call(this, t, e);
			},
			_drawShape: function (t) {
				this._shape
					? this._shape.setBounds(new L.LatLngBounds(this._startLatLng, t))
					: ((this._shape = new L.Rectangle(
							new L.LatLngBounds(this._startLatLng, t),
							this.options.shapeOptions
					  )),
					  this._map.addLayer(this._shape));
			},
			_fireCreatedEvent: function () {
				var t = new L.Rectangle(this._shape.getBounds(), this.options.shapeOptions);
				L.Draw.SimpleShape.prototype._fireCreatedEvent.call(this, t);
			},
		})),
		(L.Draw.Circle = L.Draw.SimpleShape.extend({
			statics: { TYPE: "circle" },
			options: {
				shapeOptions: {
					stroke: !0,
					color: "#f06eaa",
					weight: 4,
					opacity: 0.5,
					fill: !0,
					fillColor: null,
					fillOpacity: 0.2,
					clickable: !0,
				},
				showRadius: !0,
				metric: !0,
			},
			initialize: function (t, e) {
				(this.type = L.Draw.Circle.TYPE),
					(this._initialLabelText = L.drawLocal.draw.handlers.circle.tooltip.start),
					L.Draw.SimpleShape.prototype.initialize.call(this, t, e);
			},
			_drawShape: function (t) {
				this._shape
					? this._shape.setRadius(this._startLatLng.distanceTo(t))
					: ((this._shape = new L.Circle(
							this._startLatLng,
							this._startLatLng.distanceTo(t),
							this.options.shapeOptions
					  )),
					  this._map.addLayer(this._shape));
			},
			_fireCreatedEvent: function () {
				var t = new L.Circle(this._startLatLng, this._shape.getRadius(), this.options.shapeOptions);
				L.Draw.SimpleShape.prototype._fireCreatedEvent.call(this, t);
			},
			_onMouseMove: function (t) {
				var e,
					i = t.latlng,
					o = this.options.showRadius,
					a = this.options.metric;
				this._tooltip.updatePosition(i),
					this._isDrawing &&
						(this._drawShape(i),
						(e = this._shape.getRadius().toFixed(1)),
						this._tooltip.updateContent({
							text: this._endLabelText,
							subtext: o ? "Radius: " + L.GeometryUtil.readableDistance(e, a) : "",
						}));
			},
		})),
		(L.Draw.Marker = L.Draw.Feature.extend({
			statics: { TYPE: "marker" },
			options: { icon: new L.Icon.Default(), repeatMode: !1, zIndexOffset: 2e3 },
			initialize: function (t, e) {
				(this.type = L.Draw.Marker.TYPE), L.Draw.Feature.prototype.initialize.call(this, t, e);
			},
			addHooks: function () {
				L.Draw.Feature.prototype.addHooks.call(this),
					this._map &&
						(this._tooltip.updateContent({
							text: L.drawLocal.draw.handlers.marker.tooltip.start,
						}),
						this._mouseMarker ||
							(this._mouseMarker = L.marker(this._map.getCenter(), {
								icon: L.divIcon({
									className: "leaflet-mouse-marker",
									iconAnchor: [20, 20],
									iconSize: [40, 40],
								}),
								opacity: 0,
								zIndexOffset: this.options.zIndexOffset,
							})),
						this._mouseMarker.on("click", this._onClick, this).addTo(this._map),
						this._map.on("mousemove", this._onMouseMove, this));
			},
			removeHooks: function () {
				L.Draw.Feature.prototype.removeHooks.call(this),
					this._map &&
						(this._marker &&
							(this._marker.off("click", this._onClick, this),
							this._map.off("click", this._onClick, this).removeLayer(this._marker),
							delete this._marker),
						this._mouseMarker.off("click", this._onClick, this),
						this._map.removeLayer(this._mouseMarker),
						delete this._mouseMarker,
						this._map.off("mousemove", this._onMouseMove, this));
			},
			_onMouseMove: function (t) {
				var e = t.latlng;
				this._tooltip.updatePosition(e),
					this._mouseMarker.setLatLng(e),
					this._marker
						? ((e = this._mouseMarker.getLatLng()), this._marker.setLatLng(e))
						: ((this._marker = new L.Marker(e, {
								icon: this.options.icon,
								zIndexOffset: this.options.zIndexOffset,
						  })),
						  this._marker.on("click", this._onClick, this),
						  this._map.on("click", this._onClick, this).addLayer(this._marker));
			},
			_onClick: function () {
				this._fireCreatedEvent(), this.disable(), this.options.repeatMode && this.enable();
			},
			_fireCreatedEvent: function () {
				var t = new L.Marker(this._marker.getLatLng(), { icon: this.options.icon });
				L.Draw.Feature.prototype._fireCreatedEvent.call(this, t);
			},
		})),
		(L.Edit = L.Edit || {}),
		(L.Edit.Poly = L.Handler.extend({
			options: {
				icon: new L.DivIcon({
					iconSize: new L.Point(8, 8),
					className: "leaflet-div-icon leaflet-editing-icon",
				}),
			},
			initialize: function (t, e) {
				(this._poly = t), L.setOptions(this, e);
			},
			addHooks: function () {
				this._poly._map &&
					(this._markerGroup || this._initMarkers(), this._poly._map.addLayer(this._markerGroup));
			},
			removeHooks: function () {
				this._poly._map &&
					(this._poly._map.removeLayer(this._markerGroup),
					delete this._markerGroup,
					delete this._markers);
			},
			updateMarkers: function () {
				this._markerGroup.clearLayers(), this._initMarkers();
			},
			_initMarkers: function () {
				this._markerGroup || (this._markerGroup = new L.LayerGroup()), (this._markers = []);
				var t,
					e,
					i,
					o,
					a = this._poly._latlngs;
				for (t = 0, i = a.length; i > t; t++)
					(o = this._createMarker(a[t], t)),
						o.on("click", this._onMarkerClick, this),
						this._markers.push(o);
				var s, r;
				for (t = 0, e = i - 1; i > t; e = t++)
					(0 !== t || (L.Polygon && this._poly instanceof L.Polygon)) &&
						((s = this._markers[e]),
						(r = this._markers[t]),
						this._createMiddleMarker(s, r),
						this._updatePrevNext(s, r));
			},
			_createMarker: function (t, e) {
				var i = new L.Marker(t, { draggable: !0, icon: this.options.icon });
				return (
					(i._origLatLng = t),
					(i._index = e),
					i.on("drag", this._onMarkerDrag, this),
					i.on("dragend", this._fireEdit, this),
					this._markerGroup.addLayer(i),
					i
				);
			},
			_removeMarker: function (t) {
				var e = t._index;
				this._markerGroup.removeLayer(t),
					this._markers.splice(e, 1),
					this._poly.spliceLatLngs(e, 1),
					this._updateIndexes(e, -1),
					t
						.off("drag", this._onMarkerDrag, this)
						.off("dragend", this._fireEdit, this)
						.off("click", this._onMarkerClick, this);
			},
			_fireEdit: function () {
				(this._poly.edited = !0), this._poly.fire("edit");
			},
			_onMarkerDrag: function (t) {
				var e = t.target;
				L.extend(e._origLatLng, e._latlng),
					e._middleLeft && e._middleLeft.setLatLng(this._getMiddleLatLng(e._prev, e)),
					e._middleRight && e._middleRight.setLatLng(this._getMiddleLatLng(e, e._next)),
					this._poly.redraw();
			},
			_onMarkerClick: function (t) {
				var e = L.Polygon && this._poly instanceof L.Polygon ? 4 : 3,
					i = t.target;
				this._poly._latlngs.length < e ||
					(this._removeMarker(i),
					this._updatePrevNext(i._prev, i._next),
					i._middleLeft && this._markerGroup.removeLayer(i._middleLeft),
					i._middleRight && this._markerGroup.removeLayer(i._middleRight),
					i._prev && i._next
						? this._createMiddleMarker(i._prev, i._next)
						: i._prev
						? i._next || (i._prev._middleRight = null)
						: (i._next._middleLeft = null),
					this._fireEdit());
			},
			_updateIndexes: function (t, e) {
				this._markerGroup.eachLayer(function (i) {
					i._index > t && (i._index += e);
				});
			},
			_createMiddleMarker: function (t, e) {
				var i,
					o,
					a,
					s = this._getMiddleLatLng(t, e),
					r = this._createMarker(s);
				r.setOpacity(0.6),
					(t._middleRight = e._middleLeft = r),
					(o = function () {
						var o = e._index;
						(r._index = o),
							r.off("click", i, this).on("click", this._onMarkerClick, this),
							(s.lat = r.getLatLng().lat),
							(s.lng = r.getLatLng().lng),
							this._poly.spliceLatLngs(o, 0, s),
							this._markers.splice(o, 0, r),
							r.setOpacity(1),
							this._updateIndexes(o, 1),
							e._index++,
							this._updatePrevNext(t, r),
							this._updatePrevNext(r, e),
							this._poly.fire("editstart");
					}),
					(a = function () {
						r.off("dragstart", o, this),
							r.off("dragend", a, this),
							this._createMiddleMarker(t, r),
							this._createMiddleMarker(r, e);
					}),
					(i = function () {
						o.call(this), a.call(this), this._fireEdit();
					}),
					r.on("click", i, this).on("dragstart", o, this).on("dragend", a, this),
					this._markerGroup.addLayer(r);
			},
			_updatePrevNext: function (t, e) {
				t && (t._next = e), e && (e._prev = t);
			},
			_getMiddleLatLng: function (t, e) {
				var i = this._poly._map,
					o = i.project(t.getLatLng()),
					a = i.project(e.getLatLng());
				return i.unproject(o._add(a)._divideBy(2));
			},
		})),
		L.Polyline.addInitHook(function () {
			this.editing ||
				(L.Edit.Poly &&
					((this.editing = new L.Edit.Poly(this)), this.options.editable && this.editing.enable()),
				this.on("add", function () {
					this.editing && this.editing.enabled() && this.editing.addHooks();
				}),
				this.on("remove", function () {
					this.editing && this.editing.enabled() && this.editing.removeHooks();
				}));
		}),
		(L.Edit = L.Edit || {}),
		(L.Edit.SimpleShape = L.Handler.extend({
			options: {
				moveIcon: new L.DivIcon({
					iconSize: new L.Point(8, 8),
					className: "leaflet-div-icon leaflet-editing-icon leaflet-edit-move",
				}),
				resizeIcon: new L.DivIcon({
					iconSize: new L.Point(8, 8),
					className: "leaflet-div-icon leaflet-editing-icon leaflet-edit-resize",
				}),
			},
			initialize: function (t, e) {
				(this._shape = t), L.Util.setOptions(this, e);
			},
			addHooks: function () {
				this._shape._map &&
					((this._map = this._shape._map),
					this._markerGroup || this._initMarkers(),
					this._map.addLayer(this._markerGroup));
			},
			removeHooks: function () {
				if (this._shape._map) {
					this._unbindMarker(this._moveMarker);
					for (var t = 0, e = this._resizeMarkers.length; e > t; t++)
						this._unbindMarker(this._resizeMarkers[t]);
					(this._resizeMarkers = null),
						this._map.removeLayer(this._markerGroup),
						delete this._markerGroup;
				}
				this._map = null;
			},
			updateMarkers: function () {
				this._markerGroup.clearLayers(), this._initMarkers();
			},
			_initMarkers: function () {
				this._markerGroup || (this._markerGroup = new L.LayerGroup()),
					this._createMoveMarker(),
					this._createResizeMarker();
			},
			_createMoveMarker: function () {},
			_createResizeMarker: function () {},
			_createMarker: function (t, e) {
				var i = new L.Marker(t, { draggable: !0, icon: e, zIndexOffset: 10 });
				return this._bindMarker(i), this._markerGroup.addLayer(i), i;
			},
			_bindMarker: function (t) {
				t.on("dragstart", this._onMarkerDragStart, this)
					.on("drag", this._onMarkerDrag, this)
					.on("dragend", this._onMarkerDragEnd, this);
			},
			_unbindMarker: function (t) {
				t.off("dragstart", this._onMarkerDragStart, this)
					.off("drag", this._onMarkerDrag, this)
					.off("dragend", this._onMarkerDragEnd, this);
			},
			_onMarkerDragStart: function (t) {
				var e = t.target;
				e.setOpacity(0), this._shape.fire("editstart");
			},
			_fireEdit: function () {
				(this._shape.edited = !0), this._shape.fire("edit");
			},
			_onMarkerDrag: function (t) {
				var e = t.target,
					i = e.getLatLng();
				e === this._moveMarker ? this._move(i) : this._resize(i), this._shape.redraw();
			},
			_onMarkerDragEnd: function (t) {
				var e = t.target;
				e.setOpacity(1), this._fireEdit();
			},
			_move: function () {},
			_resize: function () {},
		})),
		(L.Edit = L.Edit || {}),
		(L.Edit.Rectangle = L.Edit.SimpleShape.extend({
			_createMoveMarker: function () {
				var t = this._shape.getBounds(),
					e = t.getCenter();
				this._moveMarker = this._createMarker(e, this.options.moveIcon);
			},
			_createResizeMarker: function () {
				var t = this._getCorners();
				this._resizeMarkers = [];
				for (var e = 0, i = t.length; i > e; e++)
					this._resizeMarkers.push(this._createMarker(t[e], this.options.resizeIcon)),
						(this._resizeMarkers[e]._cornerIndex = e);
			},
			_onMarkerDragStart: function (t) {
				L.Edit.SimpleShape.prototype._onMarkerDragStart.call(this, t);
				var e = this._getCorners(),
					i = t.target,
					o = i._cornerIndex;
				(this._oppositeCorner = e[(o + 2) % 4]), this._toggleCornerMarkers(0, o);
			},
			_onMarkerDragEnd: function (t) {
				var e,
					i,
					o = t.target;
				o === this._moveMarker &&
					((e = this._shape.getBounds()), (i = e.getCenter()), o.setLatLng(i)),
					this._toggleCornerMarkers(1),
					this._repositionCornerMarkers(),
					L.Edit.SimpleShape.prototype._onMarkerDragEnd.call(this, t);
			},
			_move: function (t) {
				for (
					var e,
						i = this._shape.getLatLngs(),
						o = this._shape.getBounds(),
						a = o.getCenter(),
						s = [],
						r = 0,
						n = i.length;
					n > r;
					r++
				)
					(e = [i[r].lat - a.lat, i[r].lng - a.lng]), s.push([t.lat + e[0], t.lng + e[1]]);
				this._shape.setLatLngs(s), this._repositionCornerMarkers();
			},
			_resize: function (t) {
				var e;
				this._shape.setBounds(L.latLngBounds(t, this._oppositeCorner)),
					(e = this._shape.getBounds()),
					this._moveMarker.setLatLng(e.getCenter());
			},
			_getCorners: function () {
				var t = this._shape.getBounds(),
					e = t.getNorthWest(),
					i = t.getNorthEast(),
					o = t.getSouthEast(),
					a = t.getSouthWest();
				return [e, i, o, a];
			},
			_toggleCornerMarkers: function (t) {
				for (var e = 0, i = this._resizeMarkers.length; i > e; e++)
					this._resizeMarkers[e].setOpacity(t);
			},
			_repositionCornerMarkers: function () {
				for (var t = this._getCorners(), e = 0, i = this._resizeMarkers.length; i > e; e++)
					this._resizeMarkers[e].setLatLng(t[e]);
			},
		})),
		L.Rectangle.addInitHook(function () {
			L.Edit.Rectangle &&
				((this.editing = new L.Edit.Rectangle(this)), this.options.editable && this.editing.enable());
		}),
		(L.Edit = L.Edit || {}),
		(L.Edit.Circle = L.Edit.SimpleShape.extend({
			_createMoveMarker: function () {
				var t = this._shape.getLatLng();
				this._moveMarker = this._createMarker(t, this.options.moveIcon);
			},
			_createResizeMarker: function () {
				var t = this._shape.getLatLng(),
					e = this._getResizeMarkerPoint(t);
				(this._resizeMarkers = []),
					this._resizeMarkers.push(this._createMarker(e, this.options.resizeIcon));
			},
			_getResizeMarkerPoint: function (t) {
				var e = this._shape._radius * Math.cos(Math.PI / 4),
					i = this._map.project(t);
				return this._map.unproject([i.x + e, i.y - e]);
			},
			_move: function (t) {
				var e = this._getResizeMarkerPoint(t);
				this._resizeMarkers[0].setLatLng(e), this._shape.setLatLng(t);
			},
			_resize: function (t) {
				var e = this._moveMarker.getLatLng(),
					i = e.distanceTo(t);
				this._shape.setRadius(i);
			},
		})),
		L.Circle.addInitHook(function () {
			L.Edit.Circle &&
				((this.editing = new L.Edit.Circle(this)), this.options.editable && this.editing.enable()),
				this.on("add", function () {
					this.editing && this.editing.enabled() && this.editing.addHooks();
				}),
				this.on("remove", function () {
					this.editing && this.editing.enabled() && this.editing.removeHooks();
				});
		}),
		(L.LatLngUtil = {
			cloneLatLngs: function (t) {
				for (var e = [], i = 0, o = t.length; o > i; i++) e.push(this.cloneLatLng(t[i]));
				return e;
			},
			cloneLatLng: function (t) {
				return L.latLng(t.lat, t.lng);
			},
		}),
		(L.GeometryUtil = L.extend(L.GeometryUtil || {}, {
			geodesicArea: function (t) {
				var e,
					i,
					o = t.length,
					a = 0,
					s = L.LatLng.DEG_TO_RAD;
				if (o > 2) {
					for (var r = 0; o > r; r++)
						(e = t[r]),
							(i = t[(r + 1) % o]),
							(a += (i.lng - e.lng) * s * (2 + Math.sin(e.lat * s) + Math.sin(i.lat * s)));
					a = (6378137 * a * 6378137) / 2;
				}
				return Math.abs(a);
			},
			readableArea: function (t, e) {
				var i;
				return (
					e
						? (i = t >= 1e4 ? (1e-4 * t).toFixed(2) + " ha" : t.toFixed(2) + " m&sup2;")
						: ((t *= 0.836127),
						  (i =
								t >= 3097600
									? (t / 3097600).toFixed(2) + " mi&sup2;"
									: t >= 4840
									? (t / 4840).toFixed(2) + " acres"
									: Math.ceil(t) + " yd&sup2;")),
					i
				);
			},
			readableDistance: function (t, e) {
				var i;
				return (
					e
						? (i = t > 1e3 ? (t / 1e3).toFixed(2) + " km" : Math.ceil(t) + " m")
						: ((t *= 1.09361),
						  (i = t > 1760 ? (t / 1760).toFixed(2) + " miles" : Math.ceil(t) + " yd")),
					i
				);
			},
		})),
		L.Util.extend(L.LineUtil, {
			segmentsIntersect: function (t, e, i, o) {
				return (
					this._checkCounterclockwise(t, i, o) !== this._checkCounterclockwise(e, i, o) &&
					this._checkCounterclockwise(t, e, i) !== this._checkCounterclockwise(t, e, o)
				);
			},
			_checkCounterclockwise: function (t, e, i) {
				return (i.y - t.y) * (e.x - t.x) > (e.y - t.y) * (i.x - t.x);
			},
		}),
		L.Polyline.include({
			intersects: function () {
				var t,
					e,
					i,
					o = this._originalPoints,
					a = o ? o.length : 0;
				if (this._tooFewPointsForIntersection()) return !1;
				for (t = a - 1; t >= 3; t--)
					if (((e = o[t - 1]), (i = o[t]), this._lineSegmentsIntersectsRange(e, i, t - 2)))
						return !0;
				return !1;
			},
			newLatLngIntersects: function (t, e) {
				return this._map ? this.newPointIntersects(this._map.latLngToLayerPoint(t), e) : !1;
			},
			newPointIntersects: function (t, e) {
				var i = this._originalPoints,
					o = i ? i.length : 0,
					a = i ? i[o - 1] : null,
					s = o - 2;
				return this._tooFewPointsForIntersection(1)
					? !1
					: this._lineSegmentsIntersectsRange(a, t, s, e ? 1 : 0);
			},
			_tooFewPointsForIntersection: function (t) {
				var e = this._originalPoints,
					i = e ? e.length : 0;
				return (i += t || 0), !this._originalPoints || 3 >= i;
			},
			_lineSegmentsIntersectsRange: function (t, e, i, o) {
				var a,
					s,
					r = this._originalPoints;
				o = o || 0;
				for (var n = i; n > o; n--)
					if (((a = r[n - 1]), (s = r[n]), L.LineUtil.segmentsIntersect(t, e, a, s))) return !0;
				return !1;
			},
		}),
		L.Polygon.include({
			intersects: function () {
				var t,
					e,
					i,
					o,
					a,
					s = this._originalPoints;
				return this._tooFewPointsForIntersection()
					? !1
					: (t = L.Polyline.prototype.intersects.call(this))
					? !0
					: ((e = s.length),
					  (i = s[0]),
					  (o = s[e - 1]),
					  (a = e - 2),
					  this._lineSegmentsIntersectsRange(o, i, a, 1));
			},
		}),
		(L.Control.Draw = L.Control.extend({
			options: { position: "topleft", draw: {}, edit: !1 },
			initialize: function (t) {
				if (L.version < "0.7")
					throw new Error(
						"Leaflet.draw 0.2.3+ requires Leaflet 0.7.0+. Download latest from https://github.com/Leaflet/Leaflet/"
					);
				L.Control.prototype.initialize.call(this, t);
				var e, i;
				(this._toolbars = {}),
					L.DrawToolbar &&
						this.options.draw &&
						((i = new L.DrawToolbar(this.options.draw)),
						(e = L.stamp(i)),
						(this._toolbars[e] = i),
						this._toolbars[e].on("enable", this._toolbarEnabled, this)),
					L.EditToolbar &&
						this.options.edit &&
						((i = new L.EditToolbar(this.options.edit)),
						(e = L.stamp(i)),
						(this._toolbars[e] = i),
						this._toolbars[e].on("enable", this._toolbarEnabled, this));
			},
			onAdd: function (t) {
				var e,
					i = L.DomUtil.create("div", "leaflet-draw"),
					o = !1,
					a = "leaflet-draw-toolbar-top";
				for (var s in this._toolbars)
					this._toolbars.hasOwnProperty(s) &&
						((e = this._toolbars[s].addToolbar(t)),
						e &&
							(o ||
								(L.DomUtil.hasClass(e, a) || L.DomUtil.addClass(e.childNodes[0], a),
								(o = !0)),
							i.appendChild(e)));
				return i;
			},
			onRemove: function () {
				for (var t in this._toolbars)
					this._toolbars.hasOwnProperty(t) && this._toolbars[t].removeToolbar();
			},
			setDrawingOptions: function (t) {
				for (var e in this._toolbars)
					this._toolbars[e] instanceof L.DrawToolbar && this._toolbars[e].setOptions(t);
			},
			_toolbarEnabled: function (t) {
				var e = "" + L.stamp(t.target);
				for (var i in this._toolbars)
					this._toolbars.hasOwnProperty(i) && i !== e && this._toolbars[i].disable();
			},
		})),
		L.Map.mergeOptions({ drawControlTooltips: !0, drawControl: !1 }),
		L.Map.addInitHook(function () {
			this.options.drawControl &&
				((this.drawControl = new L.Control.Draw()), this.addControl(this.drawControl));
		}),
		(L.Toolbar = L.Class.extend({
			includes: [L.Mixin.Events],
			initialize: function (t) {
				L.setOptions(this, t),
					(this._modes = {}),
					(this._actionButtons = []),
					(this._activeMode = null);
			},
			enabled: function () {
				return null !== this._activeMode;
			},
			disable: function () {
				this.enabled() && this._activeMode.handler.disable();
			},
			addToolbar: function (t) {
				var e,
					i = L.DomUtil.create("div", "leaflet-draw-section"),
					o = 0,
					a = this._toolbarClass || "",
					s = this.getModeHandlers(t);
				for (
					this._toolbarContainer = L.DomUtil.create("div", "leaflet-draw-toolbar leaflet-bar"),
						this._map = t,
						e = 0;
					e < s.length;
					e++
				)
					s[e].enabled &&
						this._initModeHandler(s[e].handler, this._toolbarContainer, o++, a, s[e].title);
				return o
					? ((this._lastButtonIndex = --o),
					  (this._actionsContainer = L.DomUtil.create("ul", "leaflet-draw-actions")),
					  i.appendChild(this._toolbarContainer),
					  i.appendChild(this._actionsContainer),
					  i)
					: void 0;
			},
			removeToolbar: function () {
				for (var t in this._modes)
					this._modes.hasOwnProperty(t) &&
						(this._disposeButton(
							this._modes[t].button,
							this._modes[t].handler.enable,
							this._modes[t].handler
						),
						this._modes[t].handler.disable(),
						this._modes[t].handler
							.off("enabled", this._handlerActivated, this)
							.off("disabled", this._handlerDeactivated, this));
				this._modes = {};
				for (var e = 0, i = this._actionButtons.length; i > e; e++)
					this._disposeButton(this._actionButtons[e].button, this._actionButtons[e].callback, this);
				(this._actionButtons = []), (this._actionsContainer = null);
			},
			_initModeHandler: function (t, e, i, o, a) {
				var s = t.type;
				(this._modes[s] = {}),
					(this._modes[s].handler = t),
					(this._modes[s].button = this._createButton({
						title: a,
						className: o + "-" + s,
						container: e,
						callback: this._modes[s].handler.enable,
						context: this._modes[s].handler,
					})),
					(this._modes[s].buttonIndex = i),
					this._modes[s].handler
						.on("enabled", this._handlerActivated, this)
						.on("disabled", this._handlerDeactivated, this);
			},
			_createButton: function (t) {
				var e = L.DomUtil.create("a", t.className || "", t.container);
				return (
					(e.href = "#"),
					t.text && (e.innerHTML = t.text),
					t.title && (e.title = t.title),
					L.DomEvent.on(e, "click", L.DomEvent.stopPropagation)
						.on(e, "mousedown", L.DomEvent.stopPropagation)
						.on(e, "dblclick", L.DomEvent.stopPropagation)
						.on(e, "click", L.DomEvent.preventDefault)
						.on(e, "click", t.callback, t.context),
					e
				);
			},
			_disposeButton: function (t, e) {
				L.DomEvent.off(t, "click", L.DomEvent.stopPropagation)
					.off(t, "mousedown", L.DomEvent.stopPropagation)
					.off(t, "dblclick", L.DomEvent.stopPropagation)
					.off(t, "click", L.DomEvent.preventDefault)
					.off(t, "click", e);
			},
			_handlerActivated: function (t) {
				this.disable(),
					(this._activeMode = this._modes[t.handler]),
					L.DomUtil.addClass(this._activeMode.button, "leaflet-draw-toolbar-button-enabled"),
					this._showActionsToolbar(),
					this.fire("enable");
			},
			_handlerDeactivated: function () {
				this._hideActionsToolbar(),
					L.DomUtil.removeClass(this._activeMode.button, "leaflet-draw-toolbar-button-enabled"),
					(this._activeMode = null),
					this.fire("disable");
			},
			_createActions: function (t) {
				var e,
					i,
					o,
					a,
					s = this._actionsContainer,
					r = this.getActions(t),
					n = r.length;
				for (i = 0, o = this._actionButtons.length; o > i; i++)
					this._disposeButton(this._actionButtons[i].button, this._actionButtons[i].callback);
				for (this._actionButtons = []; s.firstChild; ) s.removeChild(s.firstChild);
				for (var l = 0; n > l; l++)
					("enabled" in r[l] && !r[l].enabled) ||
						((e = L.DomUtil.create("li", "", s)),
						(a = this._createButton({
							title: r[l].title,
							text: r[l].text,
							container: e,
							callback: r[l].callback,
							context: r[l].context,
						})),
						this._actionButtons.push({ button: a, callback: r[l].callback }));
			},
			_showActionsToolbar: function () {
				var t = this._activeMode.buttonIndex,
					e = this._lastButtonIndex,
					i = this._activeMode.button.offsetTop - 1;
				this._createActions(this._activeMode.handler),
					(this._actionsContainer.style.top = i + "px"),
					0 === t &&
						(L.DomUtil.addClass(this._toolbarContainer, "leaflet-draw-toolbar-notop"),
						L.DomUtil.addClass(this._actionsContainer, "leaflet-draw-actions-top")),
					t === e &&
						(L.DomUtil.addClass(this._toolbarContainer, "leaflet-draw-toolbar-nobottom"),
						L.DomUtil.addClass(this._actionsContainer, "leaflet-draw-actions-bottom")),
					(this._actionsContainer.style.display = "block");
			},
			_hideActionsToolbar: function () {
				(this._actionsContainer.style.display = "none"),
					L.DomUtil.removeClass(this._toolbarContainer, "leaflet-draw-toolbar-notop"),
					L.DomUtil.removeClass(this._toolbarContainer, "leaflet-draw-toolbar-nobottom"),
					L.DomUtil.removeClass(this._actionsContainer, "leaflet-draw-actions-top"),
					L.DomUtil.removeClass(this._actionsContainer, "leaflet-draw-actions-bottom");
			},
		})),
		(L.Tooltip = L.Class.extend({
			initialize: function (t) {
				(this._map = t),
					(this._popupPane = t._panes.popupPane),
					(this._container = t.options.drawControlTooltips
						? L.DomUtil.create("div", "leaflet-draw-tooltip", this._popupPane)
						: null),
					(this._singleLineLabel = !1);
			},
			dispose: function () {
				this._container && (this._popupPane.removeChild(this._container), (this._container = null));
			},
			updateContent: function (t) {
				return this._container
					? ((t.subtext = t.subtext || ""),
					  0 !== t.subtext.length || this._singleLineLabel
							? t.subtext.length > 0 &&
							  this._singleLineLabel &&
							  (L.DomUtil.removeClass(this._container, "leaflet-draw-tooltip-single"),
							  (this._singleLineLabel = !1))
							: (L.DomUtil.addClass(this._container, "leaflet-draw-tooltip-single"),
							  (this._singleLineLabel = !0)),
					  (this._container.innerHTML =
							(t.subtext.length > 0
								? '<span class="leaflet-draw-tooltip-subtext">' + t.subtext + "</span><br />"
								: "") +
							"<span>" +
							t.text +
							"</span>"),
					  this)
					: this;
			},
			updatePosition: function (t) {
				var e = this._map.latLngToLayerPoint(t),
					i = this._container;
				return (
					this._container && ((i.style.visibility = "inherit"), L.DomUtil.setPosition(i, e)), this
				);
			},
			showAsError: function () {
				return (
					this._container && L.DomUtil.addClass(this._container, "leaflet-error-draw-tooltip"), this
				);
			},
			removeError: function () {
				return (
					this._container && L.DomUtil.removeClass(this._container, "leaflet-error-draw-tooltip"),
					this
				);
			},
		})),
		(L.DrawToolbar = L.Toolbar.extend({
			options: { polyline: {}, polygon: {}, rectangle: {}, circle: {}, marker: {} },
			initialize: function (t) {
				for (var e in this.options)
					this.options.hasOwnProperty(e) && t[e] && (t[e] = L.extend({}, this.options[e], t[e]));
				(this._toolbarClass = "leaflet-draw-draw"), L.Toolbar.prototype.initialize.call(this, t);
			},
			getModeHandlers: function (t) {
				return [
					{
						enabled: this.options.polyline,
						handler: new L.Draw.Polyline(t, this.options.polyline),
						title: L.drawLocal.draw.toolbar.buttons.polyline,
					},
					{
						enabled: this.options.polygon,
						handler: new L.Draw.Polygon(t, this.options.polygon),
						title: L.drawLocal.draw.toolbar.buttons.polygon,
					},
					{
						enabled: this.options.rectangle,
						handler: new L.Draw.Rectangle(t, this.options.rectangle),
						title: L.drawLocal.draw.toolbar.buttons.rectangle,
					},
					{
						enabled: this.options.circle,
						handler: new L.Draw.Circle(t, this.options.circle),
						title: L.drawLocal.draw.toolbar.buttons.circle,
					},
					{
						enabled: this.options.marker,
						handler: new L.Draw.Marker(t, this.options.marker),
						title: L.drawLocal.draw.toolbar.buttons.marker,
					},
				];
			},
			getActions: function (t) {
				return [
					{
						enabled: t.deleteLastVertex,
						title: L.drawLocal.draw.toolbar.undo.title,
						text: L.drawLocal.draw.toolbar.undo.text,
						callback: t.deleteLastVertex,
						context: t,
					},
					{
						title: L.drawLocal.draw.toolbar.actions.title,
						text: L.drawLocal.draw.toolbar.actions.text,
						callback: this.disable,
						context: this,
					},
				];
			},
			setOptions: function (t) {
				L.setOptions(this, t);
				for (var e in this._modes)
					this._modes.hasOwnProperty(e) &&
						t.hasOwnProperty(e) &&
						this._modes[e].handler.setOptions(t[e]);
			},
		})),
		(L.EditToolbar = L.Toolbar.extend({
			options: {
				edit: {
					selectedPathOptions: {
						color: "#fe57a1",
						opacity: 0.6,
						dashArray: "10, 10",
						fill: !0,
						fillColor: "#fe57a1",
						fillOpacity: 0.1,
					},
				},
				remove: {},
				featureGroup: null,
			},
			initialize: function (t) {
				t.edit &&
					("undefined" == typeof t.edit.selectedPathOptions &&
						(t.edit.selectedPathOptions = this.options.edit.selectedPathOptions),
					(t.edit = L.extend({}, this.options.edit, t.edit))),
					t.remove && (t.remove = L.extend({}, this.options.remove, t.remove)),
					(this._toolbarClass = "leaflet-draw-edit"),
					L.Toolbar.prototype.initialize.call(this, t),
					(this._selectedFeatureCount = 0);
			},
			getModeHandlers: function (t) {
				var e = this.options.featureGroup;
				return [
					{
						enabled: this.options.edit,
						handler: new L.EditToolbar.Edit(t, {
							featureGroup: e,
							selectedPathOptions: this.options.edit.selectedPathOptions,
						}),
						title: L.drawLocal.edit.toolbar.buttons.edit,
					},
					{
						enabled: this.options.remove,
						handler: new L.EditToolbar.Delete(t, { featureGroup: e }),
						title: L.drawLocal.edit.toolbar.buttons.remove,
					},
				];
			},
			getActions: function () {
				return [
					{
						title: L.drawLocal.edit.toolbar.actions.save.title,
						text: L.drawLocal.edit.toolbar.actions.save.text,
						callback: this._save,
						context: this,
					},
					{
						title: L.drawLocal.edit.toolbar.actions.cancel.title,
						text: L.drawLocal.edit.toolbar.actions.cancel.text,
						callback: this.disable,
						context: this,
					},
				];
			},
			addToolbar: function (t) {
				var e = L.Toolbar.prototype.addToolbar.call(this, t);
				return (
					this._checkDisabled(),
					this.options.featureGroup.on("layeradd layerremove", this._checkDisabled, this),
					e
				);
			},
			removeToolbar: function () {
				this.options.featureGroup.off("layeradd layerremove", this._checkDisabled, this),
					L.Toolbar.prototype.removeToolbar.call(this);
			},
			disable: function () {
				this.enabled() &&
					(this._activeMode.handler.revertLayers(), L.Toolbar.prototype.disable.call(this));
			},
			_save: function () {
				this._activeMode.handler.save(), this._activeMode.handler.disable();
			},
			_checkDisabled: function () {
				var t,
					e = this.options.featureGroup,
					i = 0 !== e.getLayers().length;
				this.options.edit &&
					((t = this._modes[L.EditToolbar.Edit.TYPE].button),
					i
						? L.DomUtil.removeClass(t, "leaflet-disabled")
						: L.DomUtil.addClass(t, "leaflet-disabled"),
					t.setAttribute(
						"title",
						i
							? L.drawLocal.edit.toolbar.buttons.edit
							: L.drawLocal.edit.toolbar.buttons.editDisabled
					)),
					this.options.remove &&
						((t = this._modes[L.EditToolbar.Delete.TYPE].button),
						i
							? L.DomUtil.removeClass(t, "leaflet-disabled")
							: L.DomUtil.addClass(t, "leaflet-disabled"),
						t.setAttribute(
							"title",
							i
								? L.drawLocal.edit.toolbar.buttons.remove
								: L.drawLocal.edit.toolbar.buttons.removeDisabled
						));
			},
		})),
		(L.EditToolbar.Edit = L.Handler.extend({
			statics: { TYPE: "edit" },
			includes: L.Mixin.Events,
			initialize: function (t, e) {
				if (
					(L.Handler.prototype.initialize.call(this, t),
					(this._selectedPathOptions = e.selectedPathOptions),
					(this._featureGroup = e.featureGroup),
					!(this._featureGroup instanceof L.FeatureGroup))
				)
					throw new Error("options.featureGroup must be a L.FeatureGroup");
				(this._uneditedLayerProps = {}), (this.type = L.EditToolbar.Edit.TYPE);
			},
			enable: function () {
				!this._enabled &&
					this._hasAvailableLayers() &&
					(this.fire("enabled", { handler: this.type }),
					this._map.fire("draw:editstart", { handler: this.type }),
					L.Handler.prototype.enable.call(this),
					this._featureGroup
						.on("layeradd", this._enableLayerEdit, this)
						.on("layerremove", this._disableLayerEdit, this));
			},
			disable: function () {
				this._enabled &&
					(this._featureGroup
						.off("layeradd", this._enableLayerEdit, this)
						.off("layerremove", this._disableLayerEdit, this),
					L.Handler.prototype.disable.call(this),
					this._map.fire("draw:editstop", { handler: this.type }),
					this.fire("disabled", { handler: this.type }));
			},
			addHooks: function () {
				var t = this._map;
				t &&
					(t.getContainer().focus(),
					this._featureGroup.eachLayer(this._enableLayerEdit, this),
					(this._tooltip = new L.Tooltip(this._map)),
					this._tooltip.updateContent({
						text: L.drawLocal.edit.handlers.edit.tooltip.text,
						subtext: L.drawLocal.edit.handlers.edit.tooltip.subtext,
					}),
					this._map.on("mousemove", this._onMouseMove, this));
			},
			removeHooks: function () {
				this._map &&
					(this._featureGroup.eachLayer(this._disableLayerEdit, this),
					(this._uneditedLayerProps = {}),
					this._tooltip.dispose(),
					(this._tooltip = null),
					this._map.off("mousemove", this._onMouseMove, this));
			},
			revertLayers: function () {
				this._featureGroup.eachLayer(function (t) {
					this._revertLayer(t);
				}, this);
			},
			save: function () {
				var t = new L.LayerGroup();
				this._featureGroup.eachLayer(function (e) {
					e.edited && (t.addLayer(e), (e.edited = !1));
				}),
					this._map.fire("draw:edited", { layers: t });
			},
			_backupLayer: function (t) {
				var e = L.Util.stamp(t);
				this._uneditedLayerProps[e] ||
					(t instanceof L.Polyline || t instanceof L.Polygon || t instanceof L.Rectangle
						? (this._uneditedLayerProps[e] = {
								latlngs: L.LatLngUtil.cloneLatLngs(t.getLatLngs()),
						  })
						: t instanceof L.Circle
						? (this._uneditedLayerProps[e] = {
								latlng: L.LatLngUtil.cloneLatLng(t.getLatLng()),
								radius: t.getRadius(),
						  })
						: t instanceof L.Marker &&
						  (this._uneditedLayerProps[e] = {
								latlng: L.LatLngUtil.cloneLatLng(t.getLatLng()),
						  }));
			},
			_revertLayer: function (t) {
				var e = L.Util.stamp(t);
				(t.edited = !1),
					this._uneditedLayerProps.hasOwnProperty(e) &&
						(t instanceof L.Polyline || t instanceof L.Polygon || t instanceof L.Rectangle
							? t.setLatLngs(this._uneditedLayerProps[e].latlngs)
							: t instanceof L.Circle
							? (t.setLatLng(this._uneditedLayerProps[e].latlng),
							  t.setRadius(this._uneditedLayerProps[e].radius))
							: t instanceof L.Marker && t.setLatLng(this._uneditedLayerProps[e].latlng));
			},
			_toggleMarkerHighlight: function (t) {
				if (t._icon) {
					var e = t._icon;
					(e.style.display = "none"),
						L.DomUtil.hasClass(e, "leaflet-edit-marker-selected")
							? (L.DomUtil.removeClass(e, "leaflet-edit-marker-selected"),
							  this._offsetMarker(e, -4))
							: (L.DomUtil.addClass(e, "leaflet-edit-marker-selected"),
							  this._offsetMarker(e, 4)),
						(e.style.display = "");
				}
			},
			_offsetMarker: function (t, e) {
				var i = parseInt(t.style.marginTop, 10) - e,
					o = parseInt(t.style.marginLeft, 10) - e;
				(t.style.marginTop = i + "px"), (t.style.marginLeft = o + "px");
			},
			_enableLayerEdit: function (t) {
				var e,
					i = t.layer || t.target || t,
					o = i instanceof L.Marker;
				(!o || i._icon) &&
					(this._backupLayer(i),
					this._selectedPathOptions &&
						((e = L.Util.extend({}, this._selectedPathOptions)),
						o
							? this._toggleMarkerHighlight(i)
							: ((i.options.previousOptions = L.Util.extend({ dashArray: null }, i.options)),
							  i instanceof L.Circle ||
									i instanceof L.Polygon ||
									i instanceof L.Rectangle ||
									(e.fill = !1),
							  i.setStyle(e))),
					o ? (i.dragging.enable(), i.on("dragend", this._onMarkerDragEnd)) : i.editing.enable());
			},
			_disableLayerEdit: function (t) {
				var e = t.layer || t.target || t;
				(e.edited = !1),
					this._selectedPathOptions &&
						(e instanceof L.Marker
							? this._toggleMarkerHighlight(e)
							: (e.setStyle(e.options.previousOptions), delete e.options.previousOptions)),
					e instanceof L.Marker
						? (e.dragging.disable(), e.off("dragend", this._onMarkerDragEnd, this))
						: e.editing.disable();
			},
			_onMarkerDragEnd: function (t) {
				var e = t.target;
				e.edited = !0;
			},
			_onMouseMove: function (t) {
				this._tooltip.updatePosition(t.latlng);
			},
			_hasAvailableLayers: function () {
				return 0 !== this._featureGroup.getLayers().length;
			},
		})),
		(L.EditToolbar.Delete = L.Handler.extend({
			statics: { TYPE: "remove" },
			includes: L.Mixin.Events,
			initialize: function (t, e) {
				if (
					(L.Handler.prototype.initialize.call(this, t),
					L.Util.setOptions(this, e),
					(this._deletableLayers = this.options.featureGroup),
					!(this._deletableLayers instanceof L.FeatureGroup))
				)
					throw new Error("options.featureGroup must be a L.FeatureGroup");
				this.type = L.EditToolbar.Delete.TYPE;
			},
			enable: function () {
				!this._enabled &&
					this._hasAvailableLayers() &&
					(this.fire("enabled", { handler: this.type }),
					this._map.fire("draw:deletestart", { handler: this.type }),
					L.Handler.prototype.enable.call(this),
					this._deletableLayers
						.on("layeradd", this._enableLayerDelete, this)
						.on("layerremove", this._disableLayerDelete, this));
			},
			disable: function () {
				this._enabled &&
					(this._deletableLayers
						.off("layeradd", this._enableLayerDelete, this)
						.off("layerremove", this._disableLayerDelete, this),
					L.Handler.prototype.disable.call(this),
					this._map.fire("draw:deletestop", { handler: this.type }),
					this.fire("disabled", { handler: this.type }));
			},
			addHooks: function () {
				var t = this._map;
				t &&
					(t.getContainer().focus(),
					this._deletableLayers.eachLayer(this._enableLayerDelete, this),
					(this._deletedLayers = new L.layerGroup()),
					(this._tooltip = new L.Tooltip(this._map)),
					this._tooltip.updateContent({ text: L.drawLocal.edit.handlers.remove.tooltip.text }),
					this._map.on("mousemove", this._onMouseMove, this));
			},
			removeHooks: function () {
				this._map &&
					(this._deletableLayers.eachLayer(this._disableLayerDelete, this),
					(this._deletedLayers = null),
					this._tooltip.dispose(),
					(this._tooltip = null),
					this._map.off("mousemove", this._onMouseMove, this));
			},
			revertLayers: function () {
				this._deletedLayers.eachLayer(function (t) {
					this._deletableLayers.addLayer(t);
				}, this);
			},
			save: function () {
				this._map.fire("draw:deleted", { layers: this._deletedLayers });
			},
			_enableLayerDelete: function (t) {
				var e = t.layer || t.target || t;
				e.on("click", this._removeLayer, this);
			},
			_disableLayerDelete: function (t) {
				var e = t.layer || t.target || t;
				e.off("click", this._removeLayer, this), this._deletedLayers.removeLayer(e);
			},
			_removeLayer: function (t) {
				var e = t.layer || t.target || t;
				this._deletableLayers.removeLayer(e), this._deletedLayers.addLayer(e);
			},
			_onMouseMove: function (t) {
				this._tooltip.updatePosition(t.latlng);
			},
			_hasAvailableLayers: function () {
				return 0 !== this._deletableLayers.getLayers().length;
			},
		}));
})(window, document);