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

 https://github.com/Leaflet/Leaflet.draw
 http://leafletjs.com
 */
!(function (t, e, i) {
    function o(t, e) {
        for (; (t = t.parentElement) && !t.classList.contains(e); );
        return t;
    }
    (L.drawVersion = "1.0.4"),
        (L.Draw = {}),
        (L.drawLocal = {
            draw: {
                toolbar: {
                    actions: { title: "Cancel disegno", text: "Cancella" },
                    finish: { title: "Finisci disegno", text: "Finisci" },
                    undo: { title: "Cancella ultimo punto disegnato", text: "Cancella ultimo punto" },
                    buttons: { polyline: "Disegna una polilinea", polygon: "Disegna un poligono", rectangle: "Disegna un rettangolo", circle: "Disegna un un cerchio", marker: "Disegna un marker", circlemarker: "Disegna un circlemarker" },
                },
                handlers: {
                    circle: { tooltip: { start: "Click and drag to draw circle." }, radius: "Radius" },
                    circlemarker: { tooltip: { start: "Click sulla mappa e posizione il marker." } },
                    marker: { tooltip: { start: "Click sulla mappa e posizione il marker." } },
                    polygon: { tooltip: { start: "Click per iniziare a disegnare.", cont: "Click per continuare a disegnare.", end: "Click sul primo punto per chiudere il disegno." } },
                    polyline: { error: "<strong>Error:</strong> shape edges cannot cross!", tooltip: { start: "Click per iniziare a disegnare una linea.", cont: "Click per continuare a disegnare una linea.", end: "Click ultimo punto per finire linea." } },
                    rectangle: { tooltip: { start: "Click and muovi per disegnare un rettangolo." } },
                    simpleshape: { tooltip: { end: "Rilascia il mouse per finire il disegno." } },
                },
            },
            edit: {
                toolbar: {
                    actions: { save: { title: "Salva modifiche", text: "Salva" }, cancel: { title: "Cancella modifiche, discards all changes", text: "Cancel" }, clearAll: { title: "Cancella tutti i  layers", text: "Cancella tutto" } },
                    buttons: { edit: "Modifica layers", editDisabled: "Nessun layer da modificare", remove: "Cancella layer", removeDisabled: "Nessun layer da cancellare" },
                },
                handlers: { edit: { tooltip: { text: "Drag handles or markers to edit features.", subtext: "Click cancel to undo changes." } }, remove: { tooltip: { text: "Click on a feature to remove." } } },
            },
        }),
        (L.Draw.Event = {}),
        (L.Draw.Event.CREATED = "draw:created"),
        (L.Draw.Event.EDITED = "draw:edited"),
        (L.Draw.Event.DELETED = "draw:deleted"),
        (L.Draw.Event.DRAWSTART = "draw:drawstart"),
        (L.Draw.Event.DRAWSTOP = "draw:drawstop"),
        (L.Draw.Event.DRAWVERTEX = "draw:drawvertex"),
        (L.Draw.Event.EDITSTART = "draw:editstart"),
        (L.Draw.Event.EDITMOVE = "draw:editmove"),
        (L.Draw.Event.EDITRESIZE = "draw:editresize"),
        (L.Draw.Event.EDITVERTEX = "draw:editvertex"),
        (L.Draw.Event.EDITSTOP = "draw:editstop"),
        (L.Draw.Event.DELETESTART = "draw:deletestart"),
        (L.Draw.Event.DELETESTOP = "draw:deletestop"),
        (L.Draw.Event.TOOLBAROPENED = "draw:toolbaropened"),
        (L.Draw.Event.TOOLBARCLOSED = "draw:toolbarclosed"),
        (L.Draw.Event.MARKERCONTEXT = "draw:markercontext"),
        (L.Draw = L.Draw || {}),
        (L.Draw.Feature = L.Handler.extend({
            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);
                var i = L.version.split(".");
                1 === parseInt(i[0], 10) && parseInt(i[1], 10) >= 2 ? L.Draw.Feature.include(L.Evented.prototype) : L.Draw.Feature.include(L.Mixin.Events);
            },
            enable: function () {
                this._enabled || (L.Handler.prototype.enable.call(this), this.fire("enabled", { handler: this.type }), this._map.fire(L.Draw.Event.DRAWSTART, { layerType: this.type }));
            },
            disable: function () {
                this._enabled && (L.Handler.prototype.disable.call(this), this._map.fire(L.Draw.Event.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.Draw.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(L.Draw.Event.CREATED, { layer: t, layerType: this.type });
            },
            _cancelDrawing: function (t) {
                27 === t.keyCode && (this._map.fire("draw:canceled", { layerType: this.type }), 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" }),
                touchIcon: new L.DivIcon({ iconSize: new L.Point(20, 20), className: "leaflet-div-icon leaflet-editing-icon leaflet-touch-icon" }),
                guidelineDistance: 20,
                maxGuideLineLength: 4e3,
                shapeOptions: { stroke: !0, color: "#3388ff", weight: 4, opacity: 0.5, fill: !1, clickable: !0 },
                metric: !0,
                feet: !0,
                nautic: !1,
                showLength: !0,
                zIndexOffset: 2e3,
                factor: 1,
                maxPoints: 0,
            },
            initialize: function (t, e) {
                L.Browser.touch && (this.options.icon = this.options.touchIcon),
                    (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("mouseout", this._onMouseOut, this).on("mousemove", this._onMouseMove, this).on("mousedown", this._onMouseDown, this).on("mouseup", this._onMouseUp, this).addTo(this._map),
                        this._map.on("mouseup", this._onMouseUp, this).on("mousemove", this._onMouseMove, this).on("zoomlevelschange", this._onZoomEnd, this).on("touchstart", this._onTouch, 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("mouseout", this._onMouseOut, this).off("mouseup", this._onMouseUp, this).off("mousemove", this._onMouseMove, this),
                    this._map.removeLayer(this._mouseMarker),
                    delete this._mouseMarker,
                    this._clearGuides(),
                    this._map
                        .off("mouseup", this._onMouseUp, this)
                        .off("mousemove", this._onMouseMove, this)
                        .off("zoomlevelschange", this._onZoomEnd, this)
                        .off("zoomend", this._onZoomEnd, this)
                        .off("touchstart", this._onTouch, this)
                        .off("click", this._onTouch, this);
            },
            deleteLastVertex: function () {
                if (!(this._markers.length <= 1)) {
                    var t = this._markers.pop(),
                        e = this._poly,
                        i = e.getLatLngs(),
                        o = i.splice(-1, 1)[0];
                    this._poly.setLatLngs(i), this._markerGroup.removeLayer(t), e.getLatLngs().length < 2 && this._map.removeLayer(e), this._vertexChanged(o, !1);
                }
            },
            addVertex: function (t) {
                if (this._markers.length >= 2 && !this.options.allowIntersection && this._poly.newLatLngIntersects(t)) return 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), this._vertexChanged(t, !0);
            },
            completeShape: function () {
                this._markers.length <= 1 || !this._shapeIsValid() || (this._fireCreatedEvent(), this.disable(), this.options.repeatMode && this.enable());
            },
            _finishShape: function () {
                var t = this._poly._defaultShape ? this._poly._defaultShape() : this._poly.getLatLngs(),
                    e = this._poly.newLatLngIntersects(t[t.length - 1]);
                if ((!this.options.allowIntersection && e) || !this._shapeIsValid()) return void this._showErrorTooltip();
                this._fireCreatedEvent(), this.disable(), this.options.repeatMode && this.enable();
            },
            _shapeIsValid: function () {
                return !0;
            },
            _onZoomEnd: function () {
                null !== this._markers && this._updateGuide();
            },
            _onMouseMove: function (t) {
                var e = this._map.mouseEventToLayerPoint(t.originalEvent),
                    i = this._map.layerPointToLatLng(e);
                (this._currentLatLng = i), this._updateTooltip(i), this._updateGuide(e), this._mouseMarker.setLatLng(i), L.DomEvent.preventDefault(t.originalEvent);
            },
            _vertexChanged: function (t, e) {
                this._map.fire(L.Draw.Event.DRAWVERTEX, { layers: this._markerGroup }), this._updateFinishHandler(), this._updateRunningMeasure(t, e), this._clearGuides(), this._updateTooltip();
            },
            _onMouseDown: function (t) {
                if (!this._clickHandled && !this._touchHandled && !this._disableMarkers) {
                    this._onMouseMove(t), (this._clickHandled = !0), this._disableNewMarkers();
                    var e = t.originalEvent,
                        i = e.clientX,
                        o = e.clientY;
                    this._startPoint.call(this, i, o);
                }
            },
            _startPoint: function (t, e) {
                this._mouseDownOrigin = L.point(t, e);
            },
            _onMouseUp: function (t) {
                var e = t.originalEvent,
                    i = e.clientX,
                    o = e.clientY;
                this._endPoint.call(this, i, o, t), (this._clickHandled = null);
            },
            _endPoint: function (e, i, o) {
                if (this._mouseDownOrigin) {
                    var a = L.point(e, i).distanceTo(this._mouseDownOrigin),
                        n = this._calculateFinishDistance(o.latlng);
                    this.options.maxPoints > 1 && this.options.maxPoints == this._markers.length + 1
                        ? (this.addVertex(o.latlng), this._finishShape())
                        : n < 10 && L.Browser.touch
                        ? this._finishShape()
                        : Math.abs(a) < 9 * (t.devicePixelRatio || 1) && this.addVertex(o.latlng),
                        this._enableNewMarkers();
                }
                this._mouseDownOrigin = null;
            },
            _onTouch: function (t) {
                var e,
                    i,
                    o = t.originalEvent;
                !o.touches ||
                    !o.touches[0] ||
                    this._clickHandled ||
                    this._touchHandled ||
                    this._disableMarkers ||
                    ((e = o.touches[0].clientX), (i = o.touches[0].clientY), this._disableNewMarkers(), (this._touchHandled = !0), this._startPoint.call(this, e, i), this._endPoint.call(this, e, i, t), (this._touchHandled = null)),
                    (this._clickHandled = null);
            },
            _onMouseOut: function () {
                this._tooltip && this._tooltip._onMouseOut.call(this._tooltip);
            },
            _calculateFinishDistance: function (t) {
                var e;
                if (this._markers.length > 0) {
                    var i;
                    if (this.type === L.Draw.Polyline.TYPE) i = this._markers[this._markers.length - 1];
                    else {
                        if (this.type !== L.Draw.Polygon.TYPE) return 1 / 0;
                        i = this._markers[0];
                    }
                    var o = this._map.latLngToContainerPoint(i.getLatLng()),
                        a = new L.Marker(t, { icon: this.options.icon, zIndexOffset: 2 * this.options.zIndexOffset }),
                        n = this._map.latLngToContainerPoint(a.getLatLng());
                    e = o.distanceTo(n);
                } else e = 1 / 0;
                return e;
            },
            _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 ? this._markers.length : 0;
                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,
                    n = Math.floor(Math.sqrt(Math.pow(e.x - t.x, 2) + Math.pow(e.y - t.y, 2))),
                    s = this.options.guidelineDistance,
                    r = this.options.maxGuideLineLength,
                    l = n > r ? n - r : s;
                for (this._guidesContainer || (this._guidesContainer = L.DomUtil.create("div", "leaflet-draw-guides", this._overlayPane)); l < n; l += this.options.guidelineDistance)
                    (i = l / n),
                        (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; e < i; 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 = L.GeometryUtil.isVersion07x() ? t.distanceTo(this._markers[i].getLatLng()) * (this.options.factor || 1) : this._map.distance(t, this._markers[i].getLatLng()) * (this.options.factor || 1)),
                      (this._measurementRunningTotal += o * (e ? 1 : -1)));
            },
            _getMeasurementString: function () {
                var t,
                    e = this._currentLatLng,
                    i = this._markers[this._markers.length - 1].getLatLng();
                return (
                    (t = L.GeometryUtil.isVersion07x()
                        ? i && e && e.distanceTo
                            ? this._measurementRunningTotal + e.distanceTo(i) * (this.options.factor || 1)
                            : this._measurementRunningTotal || 0
                        : i && e
                        ? this._measurementRunningTotal + this._map.distance(e, i) * (this.options.factor || 1)
                        : this._measurementRunningTotal || 0),
                    L.GeometryUtil.readableDistance(t, this.options.metric, this.options.feet, this.options.nautic, this.options.precision)
                );
            },
            _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));
            },
            _disableNewMarkers: function () {
                this._disableMarkers = !0;
            },
            _enableNewMarkers: function () {
                setTimeout(
                    function () {
                        this._disableMarkers = !1;
                    }.bind(this),
                    50
                );
            },
            _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, showLength: !1, shapeOptions: { stroke: !0, color: "#3388ff", weight: 4, opacity: 0.5, fill: !0, fillColor: null, fillOpacity: 0.2, clickable: !0 }, metric: !0, feet: !0, nautic: !1, precision: {} },
            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), (e = this._getMeasurementString()))
                        : ((t = L.drawLocal.draw.handlers.polygon.tooltip.end), (e = this._getMeasurementString())),
                    { text: t, subtext: e }
                );
            },
            _getMeasurementString: function () {
                var t = this._area,
                    e = "";
                return t || this.options.showLength
                    ? (this.options.showLength && (e = L.Draw.Polyline.prototype._getMeasurementString.call(this)), t && (e += "<br>" + L.GeometryUtil.readableArea(t, this.options.metric, this.options.precision)), e)
                    : null;
            },
            _shapeIsValid: function () {
                return this._markers.length >= 3;
            },
            _vertexChanged: function (t, e) {
                var i;
                !this.options.allowIntersection && this.options.showArea && ((i = this._poly.getLatLngs()), (this._area = L.GeometryUtil.geodesicArea(i))), L.Draw.Polyline.prototype._vertexChanged.call(this, t, e);
            },
            _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).on("touchstart", this._onMouseDown, this).on("touchmove", this._onMouseMove, this),
                        e.addEventListener("touchstart", L.DomEvent.preventDefault, { passive: !1 }));
            },
            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).off("touchstart", this._onMouseDown, this).off("touchmove", this._onMouseMove, this),
                        L.DomEvent.off(e, "mouseup", this._onMouseUp, this),
                        L.DomEvent.off(e, "touchend", this._onMouseUp, this),
                        e.removeEventListener("touchstart", L.DomEvent.preventDefault),
                        this._shape && (this._map.removeLayer(this._shape), delete this._shape)),
                    (this._isDrawing = !1);
            },
            _getTooltipText: function () {
                return { text: this._endLabelText };
            },
            _onMouseDown: function (t) {
                (this._isDrawing = !0), (this._startLatLng = t.latlng), L.DomEvent.on(e, "mouseup", this._onMouseUp, this).on(e, "touchend", this._onMouseUp, this).preventDefault(t.originalEvent);
            },
            _onMouseMove: function (t) {
                var e = t.latlng;
                this._tooltip.updatePosition(e), this._isDrawing && (this._tooltip.updateContent(this._getTooltipText()), 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: "#3388ff", weight: 4, opacity: 0.5, fill: !0, fillColor: null, fillOpacity: 0.2, clickable: !0 }, showArea: !0, metric: !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);
            },
            disable: function () {
                this._enabled && ((this._isCurrentlyTwoClickDrawing = !1), L.Draw.SimpleShape.prototype.disable.call(this));
            },
            _onMouseUp: function (t) {
                if (!this._shape && !this._isCurrentlyTwoClickDrawing) return void (this._isCurrentlyTwoClickDrawing = !0);
                (this._isCurrentlyTwoClickDrawing && !o(t.target, "leaflet-pane")) || L.Draw.SimpleShape.prototype._onMouseUp.call(this);
            },
            _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);
            },
            _getTooltipText: function () {
                var t,
                    e,
                    i,
                    o = L.Draw.SimpleShape.prototype._getTooltipText.call(this),
                    a = this._shape,
                    n = this.options.showArea;
                return (
                    a && ((t = this._shape._defaultShape ? this._shape._defaultShape() : this._shape.getLatLngs()), (e = L.GeometryUtil.geodesicArea(t)), (i = n ? L.GeometryUtil.readableArea(e, this.options.metric) : "")),
                    { text: o.text, subtext: i }
                );
            },
        })),
        (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), (this._initialLabelText = L.drawLocal.draw.handlers.marker.tooltip.start), L.Draw.Feature.prototype.initialize.call(this, t, e);
            },
            addHooks: function () {
                L.Draw.Feature.prototype.addHooks.call(this),
                    this._map &&
                        (this._tooltip.updateContent({ text: this._initialLabelText }),
                        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),
                        this._map.on("click", this._onTouch, this));
            },
            removeHooks: function () {
                L.Draw.Feature.prototype.removeHooks.call(this),
                    this._map &&
                        (this._map.off("click", this._onClick, this).off("click", this._onTouch, this),
                        this._marker && (this._marker.off("click", this._onClick, this), this._map.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 = this._createMarker(e)), this._marker.on("click", this._onClick, this), this._map.on("click", this._onClick, this).addLayer(this._marker));
            },
            _createMarker: function (t) {
                return new L.Marker(t, { icon: this.options.icon, zIndexOffset: this.options.zIndexOffset });
            },
            _onClick: function () {
                this._fireCreatedEvent(), this.disable(), this.options.repeatMode && this.enable();
            },
            _onTouch: function (t) {
                this._onMouseMove(t), this._onClick();
            },
            _fireCreatedEvent: function () {
                var t = new L.Marker.Touch(this._marker.getLatLng(), { icon: this.options.icon });
                L.Draw.Feature.prototype._fireCreatedEvent.call(this, t);
            },
        })),
        (L.Draw.CircleMarker = L.Draw.Marker.extend({
            statics: { TYPE: "circlemarker" },
            options: { stroke: !0, color: "#3388ff", weight: 4, opacity: 0.5, fill: !0, fillColor: null, fillOpacity: 0.2, clickable: !0, zIndexOffset: 2e3 },
            initialize: function (t, e) {
                (this.type = L.Draw.CircleMarker.TYPE), (this._initialLabelText = L.drawLocal.draw.handlers.circlemarker.tooltip.start), L.Draw.Feature.prototype.initialize.call(this, t, e);
            },
            _fireCreatedEvent: function () {
                var t = new L.CircleMarker(this._marker.getLatLng(), this.options);
                L.Draw.Feature.prototype._fireCreatedEvent.call(this, t);
            },
            _createMarker: function (t) {
                return new L.CircleMarker(t, this.options);
            },
        })),
        (L.Draw.Circle = L.Draw.SimpleShape.extend({
            statics: { TYPE: "circle" },
            options: { shapeOptions: { stroke: !0, color: "#3388ff", weight: 4, opacity: 0.5, fill: !0, fillColor: null, fillOpacity: 0.2, clickable: !0 }, showRadius: !0, metric: !0, feet: !0, nautic: !1 },
            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) {
                if (L.GeometryUtil.isVersion07x()) var e = this._startLatLng.distanceTo(t);
                else var e = this._map.distance(this._startLatLng, t);
                this._shape ? this._shape.setRadius(e) : ((this._shape = new L.Circle(this._startLatLng, e, 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;
                if ((this._tooltip.updatePosition(i), this._isDrawing)) {
                    this._drawShape(i), (e = this._shape.getRadius().toFixed(1));
                    var n = "";
                    o && (n = L.drawLocal.draw.handlers.circle.radius + ": " + L.GeometryUtil.readableDistance(e, a, this.options.feet, this.options.nautic)), this._tooltip.updateContent({ text: this._endLabelText, subtext: n });
                }
            },
        })),
        (L.Edit = L.Edit || {}),
        (L.Edit.Marker = L.Handler.extend({
            initialize: function (t, e) {
                (this._marker = t), L.setOptions(this, e);
            },
            addHooks: function () {
                var t = this._marker;
                t.dragging.enable(), t.on("dragend", this._onDragEnd, t), this._toggleMarkerHighlight();
            },
            removeHooks: function () {
                var t = this._marker;
                t.dragging.disable(), t.off("dragend", this._onDragEnd, t), this._toggleMarkerHighlight();
            },
            _onDragEnd: function (t) {
                var e = t.target;
                (e.edited = !0), this._map.fire(L.Draw.Event.EDITMOVE, { layer: e });
            },
            _toggleMarkerHighlight: function () {
                var t = this._marker._icon;
                t &&
                    ((t.style.display = "none"),
                    L.DomUtil.hasClass(t, "leaflet-edit-marker-selected")
                        ? (L.DomUtil.removeClass(t, "leaflet-edit-marker-selected"), this._offsetMarker(t, -4))
                        : (L.DomUtil.addClass(t, "leaflet-edit-marker-selected"), this._offsetMarker(t, 4)),
                    (t.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");
            },
        })),
        L.Marker.addInitHook(function () {
            L.Edit.Marker && ((this.editing = new L.Edit.Marker(this)), this.options.editable && this.editing.enable());
        }),
        (L.Edit = L.Edit || {}),
        (L.Edit.Poly = L.Handler.extend({
            initialize: function (t) {
                (this.latlngs = [t._latlngs]), t._holes && (this.latlngs = this.latlngs.concat(t._holes)), (this._poly = t), this._poly.on("revert-edited", this._updateLatLngs, this);
            },
            _defaultShape: function () {
                return L.Polyline._flat ? (L.Polyline._flat(this._poly._latlngs) ? this._poly._latlngs : this._poly._latlngs[0]) : this._poly._latlngs;
            },
            _eachVertexHandler: function (t) {
                for (var e = 0; e < this._verticesHandlers.length; e++) t(this._verticesHandlers[e]);
            },
            addHooks: function () {
                this._initHandlers(),
                    this._eachVertexHandler(function (t) {
                        t.addHooks();
                    });
            },
            removeHooks: function () {
                this._eachVertexHandler(function (t) {
                    t.removeHooks();
                });
            },
            updateMarkers: function () {
                this._eachVertexHandler(function (t) {
                    t.updateMarkers();
                });
            },
            _initHandlers: function () {
                this._verticesHandlers = [];
                for (var t = 0; t < this.latlngs.length; t++) this._verticesHandlers.push(new L.Edit.PolyVerticesEdit(this._poly, this.latlngs[t], this._poly.options.poly));
            },
            _updateLatLngs: function (t) {
                (this.latlngs = [t.layer._latlngs]), t.layer._holes && (this.latlngs = this.latlngs.concat(t.layer._holes));
            },
        })),
        (L.Edit.PolyVerticesEdit = L.Handler.extend({
            options: {
                icon: new L.DivIcon({ iconSize: new L.Point(8, 8), className: "leaflet-div-icon leaflet-editing-icon" }),
                touchIcon: new L.DivIcon({ iconSize: new L.Point(20, 20), className: "leaflet-div-icon leaflet-editing-icon leaflet-touch-icon" }),
                drawError: { color: "#b00b00", timeout: 1e3 },
            },
            initialize: function (t, e, i) {
                L.Browser.touch && (this.options.icon = this.options.touchIcon), (this._poly = t), i && i.drawError && (i.drawError = L.Util.extend({}, this.options.drawError, i.drawError)), (this._latlngs = e), L.setOptions(this, i);
            },
            _defaultShape: function () {
                return L.Polyline._flat ? (L.Polyline._flat(this._latlngs) ? this._latlngs : this._latlngs[0]) : this._latlngs;
            },
            addHooks: function () {
                var t = this._poly,
                    e = t._path;
                t instanceof L.Polygon || ((t.options.fill = !1), t.options.editing && (t.options.editing.fill = !1)),
                    e &&
                        t.options.editing &&
                        t.options.editing.className &&
                        (t.options.original.className &&
                            t.options.original.className.split(" ").forEach(function (t) {
                                L.DomUtil.removeClass(e, t);
                            }),
                        t.options.editing.className.split(" ").forEach(function (t) {
                            L.DomUtil.addClass(e, t);
                        })),
                    t.setStyle(t.options.editing),
                    this._poly._map && ((this._map = this._poly._map), this._markerGroup || this._initMarkers(), this._poly._map.addLayer(this._markerGroup));
            },
            removeHooks: function () {
                var t = this._poly,
                    e = t._path;
                e &&
                    t.options.editing &&
                    t.options.editing.className &&
                    (t.options.editing.className.split(" ").forEach(function (t) {
                        L.DomUtil.removeClass(e, t);
                    }),
                    t.options.original.className &&
                        t.options.original.className.split(" ").forEach(function (t) {
                            L.DomUtil.addClass(e, t);
                        })),
                    t.setStyle(t.options.original),
                    t._map && (t._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._defaultShape();
                for (t = 0, i = a.length; t < i; t++) (o = this._createMarker(a[t], t)), o.on("click", this._onMarkerClick, this), o.on("contextmenu", this._onContextMenu, this), this._markers.push(o);
                var n, s;
                for (t = 0, e = i - 1; t < i; e = t++) (0 !== t || (L.Polygon && this._poly instanceof L.Polygon)) && ((n = this._markers[e]), (s = this._markers[t]), this._createMiddleMarker(n, s), this._updatePrevNext(n, s));
            },
            _createMarker: function (t, e) {
                var i = new L.Marker.Touch(t, { draggable: !0, icon: this.options.icon });
                return (
                    (i._origLatLng = t),
                    (i._index = e),
                    i
                        .on("dragstart", this._onMarkerDragStart, this)
                        .on("drag", this._onMarkerDrag, this)
                        .on("dragend", this._fireEdit, this)
                        .on("touchmove", this._onTouchMove, this)
                        .on("touchend", this._fireEdit, this)
                        .on("MSPointerMove", this._onTouchMove, this)
                        .on("MSPointerUp", this._fireEdit, this),
                    this._markerGroup.addLayer(i),
                    i
                );
            },
            _onMarkerDragStart: function () {
                this._poly.fire("editstart");
            },
            _spliceLatLngs: function () {
                var t = this._defaultShape(),
                    e = [].splice.apply(t, arguments);
                return this._poly._convertLatLngs(t, !0), this._poly.redraw(), e;
            },
            _removeMarker: function (t) {
                var e = t._index;
                this._markerGroup.removeLayer(t),
                    this._markers.splice(e, 1),
                    this._spliceLatLngs(e, 1),
                    this._updateIndexes(e, -1),
                    t
                        .off("dragstart", this._onMarkerDragStart, this)
                        .off("drag", this._onMarkerDrag, this)
                        .off("dragend", this._fireEdit, this)
                        .off("touchmove", this._onMarkerDrag, this)
                        .off("touchend", this._fireEdit, this)
                        .off("click", this._onMarkerClick, this)
                        .off("MSPointerMove", this._onTouchMove, this)
                        .off("MSPointerUp", this._fireEdit, this);
            },
            _fireEdit: function () {
                (this._poly.edited = !0), this._poly.fire("edit"), this._poly._map.fire(L.Draw.Event.EDITVERTEX, { layers: this._markerGroup, poly: this._poly });
            },
            _onMarkerDrag: function (t) {
                var e = t.target,
                    i = this._poly,
                    o = L.LatLngUtil.cloneLatLng(e._origLatLng);
                if ((L.extend(e._origLatLng, e._latlng), i.options.poly)) {
                    var a = i._map._editTooltip;
                    if (!i.options.poly.allowIntersection && i.intersects()) {
                        L.extend(e._origLatLng, o), e.setLatLng(o);
                        var n = i.options.color;
                        i.setStyle({ color: this.options.drawError.color }),
                            a && a.updateContent({ text: L.drawLocal.draw.handlers.polyline.error }),
                            setTimeout(function () {
                                i.setStyle({ color: n }), a && a.updateContent({ text: L.drawLocal.edit.handlers.edit.tooltip.text, subtext: L.drawLocal.edit.handlers.edit.tooltip.subtext });
                            }, 1e3);
                    }
                }
                e._middleLeft && e._middleLeft.setLatLng(this._getMiddleLatLng(e._prev, e)),
                    e._middleRight && e._middleRight.setLatLng(this._getMiddleLatLng(e, e._next)),
                    (this._poly._bounds._southWest = L.latLng(1 / 0, 1 / 0)),
                    (this._poly._bounds._northEast = L.latLng(-1 / 0, -1 / 0));
                var s = this._poly.getLatLngs();
                this._poly._convertLatLngs(s, !0), this._poly.redraw(), this._poly.fire("editdrag");
            },
            _onMarkerClick: function (t) {
                var e = L.Polygon && this._poly instanceof L.Polygon ? 4 : 3,
                    i = t.target;
                this._defaultShape().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());
            },
            _onContextMenu: function (t) {
                var e = t.target;
                this._poly;
                this._poly._map.fire(L.Draw.Event.MARKERCONTEXT, { marker: e, layers: this._markerGroup, poly: this._poly }), L.DomEvent.stopPropagation;
            },
            _onTouchMove: function (t) {
                var e = this._map.mouseEventToLayerPoint(t.originalEvent.touches[0]),
                    i = this._map.layerPointToLatLng(e),
                    o = t.target;
                L.extend(o._origLatLng, i),
                    o._middleLeft && o._middleLeft.setLatLng(this._getMiddleLatLng(o._prev, o)),
                    o._middleRight && o._middleRight.setLatLng(this._getMiddleLatLng(o, o._next)),
                    this._poly.redraw(),
                    this.updateMarkers();
            },
            _updateIndexes: function (t, e) {
                this._markerGroup.eachLayer(function (i) {
                    i._index > t && (i._index += e);
                });
            },
            _createMiddleMarker: function (t, e) {
                var i,
                    o,
                    a,
                    n = this._getMiddleLatLng(t, e),
                    s = this._createMarker(n);
                s.setOpacity(0.6),
                    (t._middleRight = e._middleLeft = s),
                    (o = function () {
                        s.off("touchmove", o, this);
                        var a = e._index;
                        (s._index = a),
                            s.off("click", i, this).on("click", this._onMarkerClick, this),
                            (n.lat = s.getLatLng().lat),
                            (n.lng = s.getLatLng().lng),
                            this._spliceLatLngs(a, 0, n),
                            this._markers.splice(a, 0, s),
                            s.setOpacity(1),
                            this._updateIndexes(a, 1),
                            e._index++,
                            this._updatePrevNext(t, s),
                            this._updatePrevNext(s, e),
                            this._poly.fire("editstart");
                    }),
                    (a = function () {
                        s.off("dragstart", o, this), s.off("dragend", a, this), s.off("touchmove", o, this), this._createMiddleMarker(t, s), this._createMiddleMarker(s, e);
                    }),
                    (i = function () {
                        o.call(this), a.call(this), this._fireEdit();
                    }),
                    s.on("click", i, this).on("dragstart", o, this).on("dragend", a, this).on("touchmove", o, this),
                    this._markerGroup.addLayer(s);
            },
            _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" }),
                touchMoveIcon: new L.DivIcon({ iconSize: new L.Point(20, 20), className: "leaflet-div-icon leaflet-editing-icon leaflet-edit-move leaflet-touch-icon" }),
                touchResizeIcon: new L.DivIcon({ iconSize: new L.Point(20, 20), className: "leaflet-div-icon leaflet-editing-icon leaflet-edit-resize leaflet-touch-icon" }),
            },
            initialize: function (t, e) {
                L.Browser.touch && ((this.options.moveIcon = this.options.touchMoveIcon), (this.options.resizeIcon = this.options.touchResizeIcon)), (this._shape = t), L.Util.setOptions(this, e);
            },
            addHooks: function () {
                var t = this._shape;
                this._shape._map && ((this._map = this._shape._map), t.setStyle(t.options.editing), t._map && ((this._map = t._map), this._markerGroup || this._initMarkers(), this._map.addLayer(this._markerGroup)));
            },
            removeHooks: function () {
                var t = this._shape;
                if ((t.setStyle(t.options.original), t._map)) {
                    this._unbindMarker(this._moveMarker);
                    for (var e = 0, i = this._resizeMarkers.length; e < i; e++) this._unbindMarker(this._resizeMarkers[e]);
                    (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.Touch(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)
                    .on("touchstart", this._onTouchStart, this)
                    .on("touchmove", this._onTouchMove, this)
                    .on("MSPointerMove", this._onTouchMove, this)
                    .on("touchend", this._onTouchEnd, this)
                    .on("MSPointerUp", this._onTouchEnd, this);
            },
            _unbindMarker: function (t) {
                t.off("dragstart", this._onMarkerDragStart, this)
                    .off("drag", this._onMarkerDrag, this)
                    .off("dragend", this._onMarkerDragEnd, this)
                    .off("touchstart", this._onTouchStart, this)
                    .off("touchmove", this._onTouchMove, this)
                    .off("MSPointerMove", this._onTouchMove, this)
                    .off("touchend", this._onTouchEnd, this)
                    .off("MSPointerUp", this._onTouchEnd, this);
            },
            _onMarkerDragStart: function (t) {
                t.target.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(), this._shape.fire("editdrag");
            },
            _onMarkerDragEnd: function (t) {
                t.target.setOpacity(1), this._fireEdit();
            },
            _onTouchStart: function (t) {
                if ((L.Edit.SimpleShape.prototype._onMarkerDragStart.call(this, t), "function" == typeof this._getCorners)) {
                    var e = this._getCorners(),
                        i = t.target,
                        o = i._cornerIndex;
                    i.setOpacity(0), (this._oppositeCorner = e[(o + 2) % 4]), this._toggleCornerMarkers(0, o);
                }
                this._shape.fire("editstart");
            },
            _onTouchMove: function (t) {
                var e = this._map.mouseEventToLayerPoint(t.originalEvent.touches[0]),
                    i = this._map.layerPointToLatLng(e);
                return t.target === this._moveMarker ? this._move(i) : this._resize(i), this._shape.redraw(), !1;
            },
            _onTouchEnd: function (t) {
                t.target.setOpacity(1), this.updateMarkers(), 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; e < i; 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._defaultShape ? this._shape._defaultShape() : this._shape.getLatLngs(), o = this._shape.getBounds(), a = o.getCenter(), n = [], s = 0, r = i.length; s < r; s++)
                    (e = [i[s].lat - a.lat, i[s].lng - a.lng]), n.push([t.lat + e[0], t.lng + e[1]]);
                this._shape.setLatLngs(n), this._repositionCornerMarkers(), this._map.fire(L.Draw.Event.EDITMOVE, { layer: this._shape });
            },
            _resize: function (t) {
                var e;
                this._shape.setBounds(L.latLngBounds(t, this._oppositeCorner)), (e = this._shape.getBounds()), this._moveMarker.setLatLng(e.getCenter()), this._map.fire(L.Draw.Event.EDITRESIZE, { layer: this._shape });
            },
            _getCorners: function () {
                var t = this._shape.getBounds();
                return [t.getNorthWest(), t.getNorthEast(), t.getSouthEast(), t.getSouthWest()];
            },
            _toggleCornerMarkers: function (t) {
                for (var e = 0, i = this._resizeMarkers.length; e < i; e++) this._resizeMarkers[e].setOpacity(t);
            },
            _repositionCornerMarkers: function () {
                for (var t = this._getCorners(), e = 0, i = this._resizeMarkers.length; e < i; 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.CircleMarker = L.Edit.SimpleShape.extend({
            _createMoveMarker: function () {
                var t = this._shape.getLatLng();
                this._moveMarker = this._createMarker(t, this.options.moveIcon);
            },
            _createResizeMarker: function () {
                this._resizeMarkers = [];
            },
            _move: function (t) {
                if (this._resizeMarkers.length) {
                    var e = this._getResizeMarkerPoint(t);
                    this._resizeMarkers[0].setLatLng(e);
                }
                this._shape.setLatLng(t), this._map.fire(L.Draw.Event.EDITMOVE, { layer: this._shape });
            },
        })),
        L.CircleMarker.addInitHook(function () {
            L.Edit.CircleMarker && ((this.editing = new L.Edit.CircleMarker(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.Circle = L.Edit.CircleMarker.extend({
            _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]);
            },
            _resize: function (t) {
                var e = this._moveMarker.getLatLng();
                L.GeometryUtil.isVersion07x() ? (radius = e.distanceTo(t)) : (radius = this._map.distance(e, t)),
                    this._shape.setRadius(radius),
                    this._map.editTooltip &&
                        this._map._editTooltip.updateContent({
                            text: L.drawLocal.edit.handlers.edit.tooltip.subtext + "<br />" + L.drawLocal.edit.handlers.edit.tooltip.text,
                            subtext: L.drawLocal.draw.handlers.circle.radius + ": " + L.GeometryUtil.readableDistance(radius, !0, this.options.feet, this.options.nautic),
                        }),
                    this._shape.setRadius(radius),
                    this._map.fire(L.Draw.Event.EDITRESIZE, { layer: this._shape });
            },
        })),
        L.Circle.addInitHook(function () {
            L.Edit.Circle && ((this.editing = new L.Edit.Circle(this)), this.options.editable && this.editing.enable());
        }),
        L.Map.mergeOptions({ touchExtend: !0 }),
        (L.Map.TouchExtend = L.Handler.extend({
            initialize: function (t) {
                (this._map = t), (this._container = t._container), (this._pane = t._panes.overlayPane);
            },
            addHooks: function () {
                L.DomEvent.on(this._container, "touchstart", this._onTouchStart, this),
                    L.DomEvent.on(this._container, "touchend", this._onTouchEnd, this),
                    L.DomEvent.on(this._container, "touchmove", this._onTouchMove, this),
                    this._detectIE()
                        ? (L.DomEvent.on(this._container, "MSPointerDown", this._onTouchStart, this),
                          L.DomEvent.on(this._container, "MSPointerUp", this._onTouchEnd, this),
                          L.DomEvent.on(this._container, "MSPointerMove", this._onTouchMove, this),
                          L.DomEvent.on(this._container, "MSPointerCancel", this._onTouchCancel, this))
                        : (L.DomEvent.on(this._container, "touchcancel", this._onTouchCancel, this), L.DomEvent.on(this._container, "touchleave", this._onTouchLeave, this));
            },
            removeHooks: function () {
                L.DomEvent.off(this._container, "touchstart", this._onTouchStart, this),
                    L.DomEvent.off(this._container, "touchend", this._onTouchEnd, this),
                    L.DomEvent.off(this._container, "touchmove", this._onTouchMove, this),
                    this._detectIE()
                        ? (L.DomEvent.off(this._container, "MSPointerDown", this._onTouchStart, this),
                          L.DomEvent.off(this._container, "MSPointerUp", this._onTouchEnd, this),
                          L.DomEvent.off(this._container, "MSPointerMove", this._onTouchMove, this),
                          L.DomEvent.off(this._container, "MSPointerCancel", this._onTouchCancel, this))
                        : (L.DomEvent.off(this._container, "touchcancel", this._onTouchCancel, this), L.DomEvent.off(this._container, "touchleave", this._onTouchLeave, this));
            },
            _touchEvent: function (t, e) {
                var i = {};
                if (void 0 !== t.touches) {
                    if (!t.touches.length) return;
                    i = t.touches[0];
                } else {
                    if ("touch" !== t.pointerType) return;
                    if (((i = t), !this._filterClick(t))) return;
                }
                var o = this._map.mouseEventToContainerPoint(i),
                    a = this._map.mouseEventToLayerPoint(i),
                    n = this._map.layerPointToLatLng(a);
                this._map.fire(e, { latlng: n, layerPoint: a, containerPoint: o, pageX: i.pageX, pageY: i.pageY, originalEvent: t });
            },
            _filterClick: function (t) {
                var e = t.timeStamp || t.originalEvent.timeStamp,
                    i = L.DomEvent._lastClick && e - L.DomEvent._lastClick;
                return (i && i > 100 && i < 500) || (t.target._simulatedClick && !t._simulated) ? (L.DomEvent.stop(t), !1) : ((L.DomEvent._lastClick = e), !0);
            },
            _onTouchStart: function (t) {
                if (this._map._loaded) {
                    this._touchEvent(t, "touchstart");
                }
            },
            _onTouchEnd: function (t) {
                if (this._map._loaded) {
                    this._touchEvent(t, "touchend");
                }
            },
            _onTouchCancel: function (t) {
                if (this._map._loaded) {
                    var e = "touchcancel";
                    this._detectIE() && (e = "pointercancel"), this._touchEvent(t, e);
                }
            },
            _onTouchLeave: function (t) {
                if (this._map._loaded) {
                    this._touchEvent(t, "touchleave");
                }
            },
            _onTouchMove: function (t) {
                if (this._map._loaded) {
                    this._touchEvent(t, "touchmove");
                }
            },
            _detectIE: function () {
                var e = t.navigator.userAgent,
                    i = e.indexOf("MSIE ");
                if (i > 0) return parseInt(e.substring(i + 5, e.indexOf(".", i)), 10);
                if (e.indexOf("Trident/") > 0) {
                    var o = e.indexOf("rv:");
                    return parseInt(e.substring(o + 3, e.indexOf(".", o)), 10);
                }
                var a = e.indexOf("Edge/");
                return a > 0 && parseInt(e.substring(a + 5, e.indexOf(".", a)), 10);
            },
        })),
        L.Map.addInitHook("addHandler", "touchExtend", L.Map.TouchExtend),
        (L.Marker.Touch = L.Marker.extend({
            _initInteraction: function () {
                return this.addInteractiveTarget ? L.Marker.prototype._initInteraction.apply(this) : this._initInteractionLegacy();
            },
            _initInteractionLegacy: function () {
                if (this.options.clickable) {
                    var t = this._icon,
                        e = ["dblclick", "mousedown", "mouseover", "mouseout", "contextmenu", "touchstart", "touchend", "touchmove"];
                    this._detectIE ? e.concat(["MSPointerDown", "MSPointerUp", "MSPointerMove", "MSPointerCancel"]) : e.concat(["touchcancel"]),
                        L.DomUtil.addClass(t, "leaflet-clickable"),
                        L.DomEvent.on(t, "click", this._onMouseClick, this),
                        L.DomEvent.on(t, "keypress", this._onKeyPress, this);
                    for (var i = 0; i < e.length; i++) L.DomEvent.on(t, e[i], this._fireMouseEvent, this);
                    L.Handler.MarkerDrag && ((this.dragging = new L.Handler.MarkerDrag(this)), this.options.draggable && this.dragging.enable());
                }
            },
            _detectIE: function () {
                var e = t.navigator.userAgent,
                    i = e.indexOf("MSIE ");
                if (i > 0) return parseInt(e.substring(i + 5, e.indexOf(".", i)), 10);
                if (e.indexOf("Trident/") > 0) {
                    var o = e.indexOf("rv:");
                    return parseInt(e.substring(o + 3, e.indexOf(".", o)), 10);
                }
                var a = e.indexOf("Edge/");
                return a > 0 && parseInt(e.substring(a + 5, e.indexOf(".", a)), 10);
            },
        })),
        (L.LatLngUtil = {
            cloneLatLngs: function (t) {
                for (var e = [], i = 0, o = t.length; i < o; i++) Array.isArray(t[i]) ? e.push(L.LatLngUtil.cloneLatLngs(t[i])) : e.push(this.cloneLatLng(t[i]));
                return e;
            },
            cloneLatLng: function (t) {
                return L.latLng(t.lat, t.lng);
            },
        }),
        (function () {
            var t = { km: 2, ha: 2, m: 0, mi: 2, ac: 2, yd: 0, ft: 0, nm: 2 };
            L.GeometryUtil = L.extend(L.GeometryUtil || {}, {
                geodesicArea: function (t) {
                    var e,
                        i,
                        o = t.length,
                        a = 0,
                        n = Math.PI / 180;
                    if (o > 2) {
                        for (var s = 0; s < o; s++) (e = t[s]), (i = t[(s + 1) % o]), (a += (i.lng - e.lng) * n * (2 + Math.sin(e.lat * n) + Math.sin(i.lat * n)));
                        a = (6378137 * a * 6378137) / 2;
                    }
                    return Math.abs(a);
                },
                formattedNumber: function (t, e) {
                    var i = parseFloat(t).toFixed(e),
                        o = L.drawLocal.format && L.drawLocal.format.numeric,
                        a = o && o.delimiters,
                        n = a && a.thousands,
                        s = a && a.decimal;
                    if (n || s) {
                        var r = i.split(".");
                        (i = n ? r[0].replace(/(\d)(?=(\d{3})+(?!\d))/g, "$1" + n) : r[0]), (s = s || "."), r.length > 1 && (i = i + s + r[1]);
                    }
                    return i;
                },
                readableArea: function (e, i, o) {
                    var a,
                        n,
                        o = L.Util.extend({}, t, o);
                    return (
                        i
                            ? ((n = ["ha", "m"]),
                              (type = typeof i),
                              "string" === type ? (n = [i]) : "boolean" !== type && (n = i),
                              (a =
                                  e >= 1e6 && -1 !== n.indexOf("km")
                                      ? L.GeometryUtil.formattedNumber(1e-6 * e, o.km) + " km²"
                                      : e >= 1e4 && -1 !== n.indexOf("ha")
                                      ? L.GeometryUtil.formattedNumber(1e-4 * e, o.ha) + " ha"
                                      : L.GeometryUtil.formattedNumber(e, o.m) + " m²"))
                            : ((e /= 0.836127),
                              (a = e >= 3097600 ? L.GeometryUtil.formattedNumber(e / 3097600, o.mi) + " mi²" : e >= 4840 ? L.GeometryUtil.formattedNumber(e / 4840, o.ac) + " acres" : L.GeometryUtil.formattedNumber(e, o.yd) + " yd²")),
                        a
                    );
                },
                readableDistance: function (e, i, o, a, n) {
                    var s,
                        n = L.Util.extend({}, t, n);
                    switch (i ? ("string" == typeof i ? i : "metric") : o ? "feet" : a ? "nauticalMile" : "yards") {
                        case "metric":
                            s = e > 1e3 ? L.GeometryUtil.formattedNumber(e / 1e3, n.km) + " km" : L.GeometryUtil.formattedNumber(e, n.m) + " m";
                            break;
                        case "feet":
                            (e *= 3.28083), (s = L.GeometryUtil.formattedNumber(e, n.ft) + " ft");
                            break;
                        case "nauticalMile":
                            (e *= 0.53996), (s = L.GeometryUtil.formattedNumber(e / 1e3, n.nm) + " nm");
                            break;
                        case "yards":
                        default:
                            (e *= 1.09361), (s = e > 1760 ? L.GeometryUtil.formattedNumber(e / 1760, n.mi) + " miles" : L.GeometryUtil.formattedNumber(e, n.yd) + " yd");
                    }
                    return s;
                },
                isVersion07x: function () {
                    var t = L.version.split(".");
                    return 0 === parseInt(t[0], 10) && 7 === parseInt(t[1], 10);
                },
            });
        })(),
        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._getProjectedPoints(),
                    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);
            },
            newPointIntersects: function (t, e) {
                var i = this._getProjectedPoints(),
                    o = i ? i.length : 0,
                    a = i ? i[o - 1] : null,
                    n = o - 2;
                return !this._tooFewPointsForIntersection(1) && this._lineSegmentsIntersectsRange(a, t, n, e ? 1 : 0);
            },
            _tooFewPointsForIntersection: function (t) {
                var e = this._getProjectedPoints(),
                    i = e ? e.length : 0;
                return (i += t || 0), !e || i <= 3;
            },
            _lineSegmentsIntersectsRange: function (t, e, i, o) {
                var a,
                    n,
                    s = this._getProjectedPoints();
                o = o || 0;
                for (var r = i; r > o; r--) if (((a = s[r - 1]), (n = s[r]), L.LineUtil.segmentsIntersect(t, e, a, n))) return !0;
                return !1;
            },
            _getProjectedPoints: function () {
                if (!this._defaultShape) return this._originalPoints;
                for (var t = [], e = this._defaultShape(), i = 0; i < e.length; i++) t.push(this._map.latLngToLayerPoint(e[i]));
                return t;
            },
        }),
        L.Polygon.include({
            intersects: function () {
                var t,
                    e,
                    i,
                    o,
                    a = this._getProjectedPoints();
                return !this._tooFewPointsForIntersection() && (!!L.Polyline.prototype.intersects.call(this) || ((t = a.length), (e = a[0]), (i = a[t - 1]), (o = t - 2), this._lineSegmentsIntersectsRange(i, e, o, 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;
                (this._toolbars = {}),
                    L.DrawToolbar && this.options.draw && ((e = new L.DrawToolbar(this.options.draw)), (this._toolbars[L.DrawToolbar.TYPE] = e), this._toolbars[L.DrawToolbar.TYPE].on("enable", this._toolbarEnabled, this)),
                    L.EditToolbar && this.options.edit && ((e = new L.EditToolbar(this.options.edit)), (this._toolbars[L.EditToolbar.TYPE] = e), this._toolbars[L.EditToolbar.TYPE].on("enable", this._toolbarEnabled, this)),
                    (L.toolbar = this);
            },
            onAdd: function (t) {
                var e,
                    i = L.DomUtil.create("div", "leaflet-draw"),
                    o = !1;
                for (var a in this._toolbars)
                    this._toolbars.hasOwnProperty(a) &&
                        (e = this._toolbars[a].addToolbar(t)) &&
                        (o || (L.DomUtil.hasClass(e, "leaflet-draw-toolbar-top") || L.DomUtil.addClass(e.childNodes[0], "leaflet-draw-toolbar-top"), (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 = t.target;
                for (var i in this._toolbars) this._toolbars[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({
            initialize: function (t) {
                L.setOptions(this, t), (this._modes = {}), (this._actionButtons = []), (this._activeMode = null);
                var e = L.version.split(".");
                1 === parseInt(e[0], 10) && parseInt(e[1], 10) >= 2 ? L.Toolbar.include(L.Evented.prototype) : L.Toolbar.include(L.Mixin.Events);
            },
            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 || "",
                    n = this.getModeHandlers(t);
                for (this._toolbarContainer = L.DomUtil.create("div", "leaflet-draw-toolbar leaflet-bar"), this._map = t, e = 0; e < n.length; e++)
                    n[e].enabled && this._initModeHandler(n[e].handler, this._toolbarContainer, o++, a, n[e].title);
                if (o) return (this._lastButtonIndex = --o), (this._actionsContainer = L.DomUtil.create("ul", "leaflet-draw-actions")), i.appendChild(this._toolbarContainer), i.appendChild(this._actionsContainer), i;
            },
            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; e < i; 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 n = t.type;
                (this._modes[n] = {}),
                    (this._modes[n].handler = t),
                    (this._modes[n].button = this._createButton({ type: n, title: a, className: o + "-" + n, container: e, callback: this._modes[n].handler.enable, context: this._modes[n].handler })),
                    (this._modes[n].buttonIndex = i),
                    this._modes[n].handler.on("enabled", this._handlerActivated, this).on("disabled", this._handlerDeactivated, this);
            },
            _detectIOS: function () {
                return /iPad|iPhone|iPod/.test(navigator.userAgent) && !t.MSStream;
            },
            _createButton: function (t) {
                var e = L.DomUtil.create("a", t.className || "", t.container),
                    i = L.DomUtil.create("span", "sr-only", t.container);
                (e.href = "#"), e.appendChild(i), t.title && ((e.title = t.title), (i.innerHTML = t.title)), t.text && ((e.innerHTML = t.text), (i.innerHTML = t.text));
                var o = this._detectIOS() ? "touchstart" : "click";
                return (
                    L.DomEvent.on(e, "click", L.DomEvent.stopPropagation)
                        .on(e, "mousedown", L.DomEvent.stopPropagation)
                        .on(e, "dblclick", L.DomEvent.stopPropagation)
                        .on(e, "touchstart", L.DomEvent.stopPropagation)
                        .on(e, "click", L.DomEvent.preventDefault)
                        .on(e, o, t.callback, t.context),
                    e
                );
            },
            _disposeButton: function (t, e) {
                var i = this._detectIOS() ? "touchstart" : "click";
                L.DomEvent.off(t, "click", L.DomEvent.stopPropagation)
                    .off(t, "mousedown", L.DomEvent.stopPropagation)
                    .off(t, "dblclick", L.DomEvent.stopPropagation)
                    .off(t, "touchstart", L.DomEvent.stopPropagation)
                    .off(t, "click", L.DomEvent.preventDefault)
                    .off(t, i, 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,
                    n = this._actionsContainer,
                    s = this.getActions(t),
                    r = s.length;
                for (i = 0, o = this._actionButtons.length; i < o; i++) this._disposeButton(this._actionButtons[i].button, this._actionButtons[i].callback);
                for (this._actionButtons = []; n.firstChild; ) n.removeChild(n.firstChild);
                for (var l = 0; l < r; l++)
                    ("enabled" in s[l] && !s[l].enabled) ||
                        ((e = L.DomUtil.create("li", "", n)),
                        (a = this._createButton({ title: s[l].title, text: s[l].text, container: e, callback: s[l].callback, context: s[l].context })),
                        this._actionButtons.push({ button: a, callback: s[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"),
                    this._map.fire(L.Draw.Event.TOOLBAROPENED);
            },
            _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"),
                    this._map.fire(L.Draw.Event.TOOLBARCLOSED);
            },
        })),
        (L.Draw = L.Draw || {}),
        (L.Draw.Tooltip = L.Class.extend({
            initialize: function (t) {
                (this._map = t),
                    (this._popupPane = t._panes.popupPane),
                    (this._visible = !1),
                    (this._container = t.options.drawControlTooltips ? L.DomUtil.create("div", "leaflet-draw-tooltip", this._popupPane) : null),
                    (this._singleLineLabel = !1),
                    this._map.on("mouseout", this._onMouseOut, this);
            },
            dispose: function () {
                this._map.off("mouseout", this._onMouseOut, this), 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>"),
                      t.text || t.subtext ? ((this._visible = !0), (this._container.style.visibility = "inherit")) : ((this._visible = !1), (this._container.style.visibility = "hidden")),
                      this)
                    : this;
            },
            updatePosition: function (t) {
                var e = this._map.latLngToLayerPoint(t),
                    i = this._container;
                return this._container && (this._visible && (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;
            },
            _onMouseOut: function () {
                this._container && (this._container.style.visibility = "hidden");
            },
        })),
        (L.DrawToolbar = L.Toolbar.extend({
            statics: { TYPE: "draw" },
            options: { polyline: {}, polygon: {}, rectangle: {}, circle: {}, marker: {}, circlemarker: {} },
            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 },
                    { enabled: this.options.circlemarker, handler: new L.Draw.CircleMarker(t, this.options.circlemarker), title: L.drawLocal.draw.toolbar.buttons.circlemarker },
                ];
            },
            getActions: function (t) {
                return [
                    { enabled: t.completeShape, title: L.drawLocal.draw.toolbar.finish.title, text: L.drawLocal.draw.toolbar.finish.text, callback: t.completeShape, context: t },
                    { 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({
            statics: { TYPE: "edit" },
            options: { edit: { selectedPathOptions: { dashArray: "10, 10", fill: !0, fillColor: "#fe57a1", fillOpacity: 0.1, maintainColor: !1 } }, remove: {}, poly: null, featureGroup: null },
            initialize: function (t) {
                t.edit &&
                    (void 0 === t.edit.selectedPathOptions && (t.edit.selectedPathOptions = this.options.edit.selectedPathOptions),
                    (t.edit.selectedPathOptions = L.extend({}, this.options.edit.selectedPathOptions, t.edit.selectedPathOptions))),
                    t.remove && (t.remove = L.extend({}, this.options.remove, t.remove)),
                    t.poly && (t.poly = L.extend({}, this.options.poly, t.poly)),
                    (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, poly: this.options.poly }), 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 (t) {
                var e = [
                    { 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 },
                ];
                return t.removeAllLayers && e.push({ title: L.drawLocal.edit.toolbar.actions.clearAll.title, text: L.drawLocal.edit.toolbar.actions.clearAll.text, callback: this._clearAllLayers, context: this }), e;
            },
            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 && this._activeMode.handler.disable();
            },
            _clearAllLayers: function () {
                this._activeMode.handler.removeAllLayers(), this._activeMode && 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" },
            initialize: function (t, e) {
                if ((L.Handler.prototype.initialize.call(this, t), L.setOptions(this, e), (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);
                var i = L.version.split(".");
                1 === parseInt(i[0], 10) && parseInt(i[1], 10) >= 2 ? L.EditToolbar.Edit.include(L.Evented.prototype) : L.EditToolbar.Edit.include(L.Mixin.Events);
            },
            enable: function () {
                !this._enabled &&
                    this._hasAvailableLayers() &&
                    (this.fire("enabled", { handler: this.type }),
                    this._map.fire(L.Draw.Event.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(L.Draw.Event.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.Draw.Tooltip(this._map)),
                    this._tooltip.updateContent({ text: L.drawLocal.edit.handlers.edit.tooltip.text, subtext: L.drawLocal.edit.handlers.edit.tooltip.subtext }),
                    (t._editTooltip = this._tooltip),
                    this._updateTooltip(),
                    this._map.on("mousemove", this._onMouseMove, this).on("touchmove", this._onMouseMove, this).on("MSPointerMove", this._onMouseMove, this).on(L.Draw.Event.EDITVERTEX, this._updateTooltip, 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).off("touchmove", this._onMouseMove, this).off("MSPointerMove", this._onMouseMove, this).off(L.Draw.Event.EDITVERTEX, this._updateTooltip, 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(L.Draw.Event.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 || t instanceof L.CircleMarker) && (this._uneditedLayerProps[e] = { latlng: L.LatLngUtil.cloneLatLng(t.getLatLng()) }));
            },
            _getTooltipText: function () {
                return { text: L.drawLocal.edit.handlers.edit.tooltip.text, subtext: L.drawLocal.edit.handlers.edit.tooltip.subtext };
            },
            _updateTooltip: function () {
                this._tooltip.updateContent(this._getTooltipText());
            },
            _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 instanceof L.CircleMarker) && t.setLatLng(this._uneditedLayerProps[e].latlng),
                        t.fire("revert-edited", { layer: t }));
            },
            _enableLayerEdit: function (t) {
                var e,
                    i,
                    o = t.layer || t.target || t;
                this._backupLayer(o),
                    this.options.poly && ((i = L.Util.extend({}, this.options.poly)), (o.options.poly = i)),
                    this.options.selectedPathOptions &&
                        ((e = L.Util.extend({}, this.options.selectedPathOptions)),
                        e.maintainColor && ((e.color = o.options.color), (e.fillColor = o.options.fillColor)),
                        (o.options.original = L.extend({}, o.options)),
                        (o.options.editing = e)),
                    o instanceof L.Marker
                        ? (o.editing && o.editing.enable(),
                          o.dragging.enable(),
                          o
                              .on("dragend", this._onMarkerDragEnd)
                              .on("touchmove", this._onTouchMove, this)
                              .on("MSPointerMove", this._onTouchMove, this)
                              .on("touchend", this._onMarkerDragEnd, this)
                              .on("MSPointerUp", this._onMarkerDragEnd, this))
                        : o.editing.enable();
            },
            _disableLayerEdit: function (t) {
                var e = t.layer || t.target || t;
                (e.edited = !1),
                    e.editing && e.editing.disable(),
                    delete e.options.editing,
                    delete e.options.original,
                    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)
                              .off("touchmove", this._onTouchMove, this)
                              .off("MSPointerMove", this._onTouchMove, this)
                              .off("touchend", this._onMarkerDragEnd, this)
                              .off("MSPointerUp", this._onMarkerDragEnd, this))
                        : e.editing.disable();
            },
            _onMouseMove: function (t) {
                this._tooltip.updatePosition(t.latlng);
            },
            _onMarkerDragEnd: function (t) {
                var e = t.target;
                (e.edited = !0), this._map.fire(L.Draw.Event.EDITMOVE, { layer: e });
            },
            _onTouchMove: function (t) {
                var e = t.originalEvent.changedTouches[0],
                    i = this._map.mouseEventToLayerPoint(e),
                    o = this._map.layerPointToLatLng(i);
                t.target.setLatLng(o);
            },
            _hasAvailableLayers: function () {
                return 0 !== this._featureGroup.getLayers().length;
            },
        })),
        (L.EditToolbar.Delete = L.Handler.extend({
            statics: { TYPE: "remove" },
            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;
                var i = L.version.split(".");
                1 === parseInt(i[0], 10) && parseInt(i[1], 10) >= 2 ? L.EditToolbar.Delete.include(L.Evented.prototype) : L.EditToolbar.Delete.include(L.Mixin.Events);
            },
            enable: function () {
                !this._enabled &&
                    this._hasAvailableLayers() &&
                    (this.fire("enabled", { handler: this.type }),
                    this._map.fire(L.Draw.Event.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(L.Draw.Event.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.Draw.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), t.fire("revert-deleted", { layer: t });
                }, this);
            },
            save: function () {
                this._map.fire(L.Draw.Event.DELETED, { layers: this._deletedLayers });
            },
            removeAllLayers: function () {
                this._deletableLayers.eachLayer(function (t) {
                    this._removeLayer({ layer: t });
                }, this),
                    this.save();
            },
            _enableLayerDelete: function (t) {
                (t.layer || t.target || t).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), e.fire("deleted");
            },
            _onMouseMove: function (t) {
                this._tooltip.updatePosition(t.latlng);
            },
            _hasAvailableLayers: function () {
                return 0 !== this._deletableLayers.getLayers().length;
            },
        }));
})(window, document);