@performant-software/geospatial 3.1.3-beta.3 → 3.1.4-beta.0

package/dist/index.es73.js

@@ -1,29 +1,1996 @@
-import { __exports as t } from "./index.es82.js";
-import R from "react";
-var p;
-function v() {
-  if (p) return t;
-  p = 1;
-  /**
-   * @license React
-   * react-jsx-runtime.production.min.js
-   *
-   * Copyright (c) Facebook, Inc. and its affiliates.
-   *
-   * This source code is licensed under the MIT license found in the
-   * LICENSE file in the root directory of this source tree.
-   */
-  var s = R, m = Symbol.for("react.element"), l = Symbol.for("react.fragment"), c = Object.prototype.hasOwnProperty, a = s.__SECRET_INTERNALS_DO_NOT_USE_OR_YOU_WILL_BE_FIRED.ReactCurrentOwner, d = { key: !0, ref: !0, __self: !0, __source: !0 };
-  function u(o, r, i) {
-    var e, n = {}, _ = null, f = null;
-    i !== void 0 && (_ = "" + i), r.key !== void 0 && (_ = "" + r.key), r.ref !== void 0 && (f = r.ref);
-    for (e in r) c.call(r, e) && !d.hasOwnProperty(e) && (n[e] = r[e]);
-    if (o && o.defaultProps) for (e in r = o.defaultProps, r) n[e] === void 0 && (n[e] = r[e]);
-    return { $$typeof: m, type: o, key: _, ref: f, props: n, _owner: a.current };
-  }
-  return t.Fragment = l, t.jsx = u, t.jsxs = u, t;
+import { commonjsGlobal as bt } from "./index.es74.js";
+import { __module as Et } from "./index.es75.js";
+var io = Et.exports, Wn;
+function co() {
+  return Wn ? Et.exports : (Wn = 1, function(Kn, ao) {
+    (function(Je, de) {
+      Kn.exports = de();
+    })(io, function() {
+      var Je = function(e, t) {
+        var n = { drag: [], click: [], mousemove: [], mousedown: [], mouseup: [], mouseout: [], keydown: [], keyup: [], touchstart: [], touchmove: [], touchend: [], tap: [] }, r = { on: function(i, a, l) {
+          if (n[i] === void 0) throw new Error("Invalid event type: " + i);
+          n[i].push({ selector: a, fn: l });
+        }, render: function(i) {
+          t.store.featureChanged(i);
+        } }, o = function(i, a) {
+          for (var l = n[i], d = l.length; d--; ) {
+            var h = l[d];
+            if (h.selector(a)) {
+              h.fn.call(r, a) || t.store.render(), t.ui.updateMapClasses();
+              break;
+            }
+          }
+        };
+        return e.start.call(r), { render: e.render, stop: function() {
+          e.stop && e.stop();
+        }, trash: function() {
+          e.trash && (e.trash(), t.store.render());
+        }, combineFeatures: function() {
+          e.combineFeatures && e.combineFeatures();
+        }, uncombineFeatures: function() {
+          e.uncombineFeatures && e.uncombineFeatures();
+        }, drag: function(i) {
+          o("drag", i);
+        }, click: function(i) {
+          o("click", i);
+        }, mousemove: function(i) {
+          o("mousemove", i);
+        }, mousedown: function(i) {
+          o("mousedown", i);
+        }, mouseup: function(i) {
+          o("mouseup", i);
+        }, mouseout: function(i) {
+          o("mouseout", i);
+        }, keydown: function(i) {
+          o("keydown", i);
+        }, keyup: function(i) {
+          o("keyup", i);
+        }, touchstart: function(i) {
+          o("touchstart", i);
+        }, touchmove: function(i) {
+          o("touchmove", i);
+        }, touchend: function(i) {
+          o("touchend", i);
+        }, tap: function(i) {
+          o("tap", i);
+        } };
+      };
+      function de(e) {
+        return e && e.__esModule && Object.prototype.hasOwnProperty.call(e, "default") ? e.default : e;
+      }
+      function Qn(e) {
+        if (e.__esModule) return e;
+        var t = e.default;
+        if (typeof t == "function") {
+          var n = function r() {
+            if (this instanceof r) {
+              var o = [null];
+              o.push.apply(o, arguments);
+              var i = Function.bind.apply(t, o);
+              return new i();
+            }
+            return t.apply(this, arguments);
+          };
+          n.prototype = t.prototype;
+        } else n = {};
+        return Object.defineProperty(n, "__esModule", { value: !0 }), Object.keys(e).forEach(function(r) {
+          var o = Object.getOwnPropertyDescriptor(e, r);
+          Object.defineProperty(n, r, o.get ? o : { enumerable: !0, get: function() {
+            return e[r];
+          } });
+        }), n;
+      }
+      var Tt = {}, er = { RADIUS: 6378137 }, Zt = er;
+      function Wt(e) {
+        var t = 0;
+        if (e && e.length > 0) {
+          t += Math.abs(Ct(e[0]));
+          for (var n = 1; n < e.length; n++) t -= Math.abs(Ct(e[n]));
+        }
+        return t;
+      }
+      function Ct(e) {
+        var t, n, r, o, i, a, l = 0, d = e.length;
+        if (d > 2) {
+          for (a = 0; a < d; a++) a === d - 2 ? (r = d - 2, o = d - 1, i = 0) : a === d - 1 ? (r = d - 1, o = 0, i = 1) : (r = a, o = a + 1, i = a + 2), t = e[r], n = e[o], l += (Ot(e[i][0]) - Ot(t[0])) * Math.sin(Ot(n[1]));
+          l = l * Zt.RADIUS * Zt.RADIUS / 2;
+        }
+        return l;
+      }
+      function Ot(e) {
+        return e * Math.PI / 180;
+      }
+      Tt.geometry = function e(t) {
+        var n, r = 0;
+        switch (t.type) {
+          case "Polygon":
+            return Wt(t.coordinates);
+          case "MultiPolygon":
+            for (n = 0; n < t.coordinates.length; n++) r += Wt(t.coordinates[n]);
+            return r;
+          case "Point":
+          case "MultiPoint":
+          case "LineString":
+          case "MultiLineString":
+            return 0;
+          case "GeometryCollection":
+            for (n = 0; n < t.geometries.length; n++) r += e(t.geometries[n]);
+            return r;
+        }
+      }, Tt.ring = Ct;
+      var q = { CONTROL_BASE: "mapboxgl-ctrl", CONTROL_PREFIX: "mapboxgl-ctrl-", CONTROL_BUTTON: "mapbox-gl-draw_ctrl-draw-btn", CONTROL_BUTTON_LINE: "mapbox-gl-draw_line", CONTROL_BUTTON_POLYGON: "mapbox-gl-draw_polygon", CONTROL_BUTTON_POINT: "mapbox-gl-draw_point", CONTROL_BUTTON_TRASH: "mapbox-gl-draw_trash", CONTROL_BUTTON_COMBINE_FEATURES: "mapbox-gl-draw_combine", CONTROL_BUTTON_UNCOMBINE_FEATURES: "mapbox-gl-draw_uncombine", CONTROL_GROUP: "mapboxgl-ctrl-group", ATTRIBUTION: "mapboxgl-ctrl-attrib", ACTIVE_BUTTON: "active", BOX_SELECT: "mapbox-gl-draw_boxselect" }, X = { HOT: "mapbox-gl-draw-hot", COLD: "mapbox-gl-draw-cold" }, N = { ADD: "add", MOVE: "move", DRAG: "drag", POINTER: "pointer", NONE: "none" }, Y = { POLYGON: "polygon", LINE: "line_string", POINT: "point" }, m = { FEATURE: "Feature", POLYGON: "Polygon", LINE_STRING: "LineString", POINT: "Point", FEATURE_COLLECTION: "FeatureCollection", MULTI_PREFIX: "Multi", MULTI_POINT: "MultiPoint", MULTI_LINE_STRING: "MultiLineString", MULTI_POLYGON: "MultiPolygon" }, T = { DRAW_LINE_STRING: "draw_line_string", DRAW_POLYGON: "draw_polygon", DRAW_POINT: "draw_point", SIMPLE_SELECT: "simple_select", DIRECT_SELECT: "direct_select", STATIC: "static" }, H = { CREATE: "draw.create", DELETE: "draw.delete", UPDATE: "draw.update", SELECTION_CHANGE: "draw.selectionchange", MODE_CHANGE: "draw.modechange", ACTIONABLE: "draw.actionable", RENDER: "draw.render", COMBINE_FEATURES: "draw.combine", UNCOMBINE_FEATURES: "draw.uncombine" }, St = { MOVE: "move", CHANGE_COORDINATES: "change_coordinates" }, B = { FEATURE: "feature", MIDPOINT: "midpoint", VERTEX: "vertex" }, j = { ACTIVE: "true", INACTIVE: "false" }, Kt = ["scrollZoom", "boxZoom", "dragRotate", "dragPan", "keyboard", "doubleClickZoom", "touchZoomRotate"], It = -85, tr = Object.freeze({ __proto__: null, classes: q, sources: X, cursors: N, types: Y, geojsonTypes: m, modes: T, events: H, updateActions: St, meta: B, activeStates: j, interactions: Kt, LAT_MIN: -90, LAT_RENDERED_MIN: It, LAT_MAX: 90, LAT_RENDERED_MAX: 85, LNG_MIN: -270, LNG_MAX: 270 }), Qt = { Point: 0, LineString: 1, MultiLineString: 1, Polygon: 2 };
+      function nr(e, t) {
+        var n = Qt[e.geometry.type] - Qt[t.geometry.type];
+        return n === 0 && e.geometry.type === m.POLYGON ? e.area - t.area : n;
+      }
+      function en(e) {
+        return e.map(function(t) {
+          return t.geometry.type === m.POLYGON && (t.area = Tt.geometry({ type: m.FEATURE, property: {}, geometry: t.geometry })), t;
+        }).sort(nr).map(function(t) {
+          return delete t.area, t;
+        });
+      }
+      function tn(e, t) {
+        return t === void 0 && (t = 0), [[e.point.x - t, e.point.y - t], [e.point.x + t, e.point.y + t]];
+      }
+      function Z(e) {
+        if (this._items = {}, this._nums = {}, this._length = e ? e.length : 0, e) for (var t = 0, n = e.length; t < n; t++) this.add(e[t]), e[t] !== void 0 && (typeof e[t] == "string" ? this._items[e[t]] = t : this._nums[e[t]] = t);
+      }
+      Z.prototype.add = function(e) {
+        return this.has(e) || (this._length++, typeof e == "string" ? this._items[e] = this._length : this._nums[e] = this._length), this;
+      }, Z.prototype.delete = function(e) {
+        return this.has(e) === !1 || (this._length--, delete this._items[e], delete this._nums[e]), this;
+      }, Z.prototype.has = function(e) {
+        return (typeof e == "string" || typeof e == "number") && (this._items[e] !== void 0 || this._nums[e] !== void 0);
+      }, Z.prototype.values = function() {
+        var e = this, t = [];
+        return Object.keys(this._items).forEach(function(n) {
+          t.push({ k: n, v: e._items[n] });
+        }), Object.keys(this._nums).forEach(function(n) {
+          t.push({ k: JSON.parse(n), v: e._nums[n] });
+        }), t.sort(function(n, r) {
+          return n.v - r.v;
+        }).map(function(n) {
+          return n.k;
+        });
+      }, Z.prototype.clear = function() {
+        return this._length = 0, this._items = {}, this._nums = {}, this;
+      };
+      var rr = [B.FEATURE, B.MIDPOINT, B.VERTEX], xe = { click: function(e, t, n) {
+        return nn(e, t, n, n.options.clickBuffer);
+      }, touch: function(e, t, n) {
+        return nn(e, t, n, n.options.touchBuffer);
+      } };
+      function nn(e, t, n, r) {
+        if (n.map === null) return [];
+        var o = e ? tn(e, r) : t, i = {};
+        n.options.styles && (i.layers = n.options.styles.map(function(h) {
+          return h.id;
+        }).filter(function(h) {
+          return n.map.getLayer(h) != null;
+        }));
+        var a = n.map.queryRenderedFeatures(o, i).filter(function(h) {
+          return rr.indexOf(h.properties.meta) !== -1;
+        }), l = new Z(), d = [];
+        return a.forEach(function(h) {
+          var g = h.properties.id;
+          l.has(g) || (l.add(g), d.push(h));
+        }), en(d);
+      }
+      function ze(e, t) {
+        var n = xe.click(e, null, t), r = { mouse: N.NONE };
+        return n[0] && (r.mouse = n[0].properties.active === j.ACTIVE ? N.MOVE : N.POINTER, r.feature = n[0].properties.meta), t.events.currentModeName().indexOf("draw") !== -1 && (r.mouse = N.ADD), t.ui.queueMapClasses(r), t.ui.updateMapClasses(), n[0];
+      }
+      function xt(e, t) {
+        var n = e.x - t.x, r = e.y - t.y;
+        return Math.sqrt(n * n + r * r);
+      }
+      function Mt(e, t, n) {
+        n === void 0 && (n = {});
+        var r = n.fineTolerance != null ? n.fineTolerance : 4, o = n.grossTolerance != null ? n.grossTolerance : 12, i = n.interval != null ? n.interval : 500;
+        e.point = e.point || t.point, e.time = e.time || t.time;
+        var a = xt(e.point, t.point);
+        return a < r || a < o && t.time - e.time < i;
+      }
+      function Lt(e, t, n) {
+        n === void 0 && (n = {});
+        var r = n.tolerance != null ? n.tolerance : 25, o = n.interval != null ? n.interval : 250;
+        return e.point = e.point || t.point, e.time = e.time || t.time, xt(e.point, t.point) < r && t.time - e.time < o;
+      }
+      var rn = { exports: {} }, Nt = rn.exports = function(e, t) {
+        if (t || (t = 16), e === void 0 && (e = 128), e <= 0) return "0";
+        for (var n = Math.log(Math.pow(2, e)) / Math.log(t), r = 2; n === 1 / 0; r *= 2) n = Math.log(Math.pow(2, e / r)) / Math.log(t) * r;
+        var o = n - Math.floor(n), i = "";
+        for (r = 0; r < Math.floor(n); r++)
+          i = Math.floor(Math.random() * t).toString(t) + i;
+        if (o) {
+          var a = Math.pow(t, o);
+          i = Math.floor(Math.random() * a).toString(t) + i;
+        }
+        var l = parseInt(i, t);
+        return l !== 1 / 0 && l >= Math.pow(2, e) ? Nt(e, t) : i;
+      };
+      Nt.rack = function(e, t, n) {
+        var r = function(i) {
+          var a = 0;
+          do {
+            if (a++ > 10) {
+              if (!n) throw new Error("too many ID collisions, use more bits");
+              e += n;
+            }
+            var l = Nt(e, t);
+          } while (Object.hasOwnProperty.call(o, l));
+          return o[l] = i, l;
+        }, o = r.hats = {};
+        return r.get = function(i) {
+          return r.hats[i];
+        }, r.set = function(i, a) {
+          return r.hats[i] = a, r;
+        }, r.bits = e || 128, r.base = t || 16, r;
+      };
+      var Pt = de(rn.exports), G = function(e, t) {
+        this.ctx = e, this.properties = t.properties || {}, this.coordinates = t.geometry.coordinates, this.id = t.id || Pt(), this.type = t.geometry.type;
+      };
+      G.prototype.changed = function() {
+        this.ctx.store.featureChanged(this.id);
+      }, G.prototype.incomingCoords = function(e) {
+        this.setCoordinates(e);
+      }, G.prototype.setCoordinates = function(e) {
+        this.coordinates = e, this.changed();
+      }, G.prototype.getCoordinates = function() {
+        return JSON.parse(JSON.stringify(this.coordinates));
+      }, G.prototype.setProperty = function(e, t) {
+        this.properties[e] = t;
+      }, G.prototype.toGeoJSON = function() {
+        return JSON.parse(JSON.stringify({ id: this.id, type: m.FEATURE, properties: this.properties, geometry: { coordinates: this.getCoordinates(), type: this.type } }));
+      }, G.prototype.internal = function(e) {
+        var t = { id: this.id, meta: B.FEATURE, "meta:type": this.type, active: j.INACTIVE, mode: e };
+        if (this.ctx.options.userProperties) for (var n in this.properties) t["user_" + n] = this.properties[n];
+        return { type: m.FEATURE, properties: t, geometry: { coordinates: this.getCoordinates(), type: this.type } };
+      };
+      var me = function(e, t) {
+        G.call(this, e, t);
+      };
+      (me.prototype = Object.create(G.prototype)).isValid = function() {
+        return typeof this.coordinates[0] == "number" && typeof this.coordinates[1] == "number";
+      }, me.prototype.updateCoordinate = function(e, t, n) {
+        this.coordinates = arguments.length === 3 ? [t, n] : [e, t], this.changed();
+      }, me.prototype.getCoordinate = function() {
+        return this.getCoordinates();
+      };
+      var ie = function(e, t) {
+        G.call(this, e, t);
+      };
+      (ie.prototype = Object.create(G.prototype)).isValid = function() {
+        return this.coordinates.length > 1;
+      }, ie.prototype.addCoordinate = function(e, t, n) {
+        this.changed();
+        var r = parseInt(e, 10);
+        this.coordinates.splice(r, 0, [t, n]);
+      }, ie.prototype.getCoordinate = function(e) {
+        var t = parseInt(e, 10);
+        return JSON.parse(JSON.stringify(this.coordinates[t]));
+      }, ie.prototype.removeCoordinate = function(e) {
+        this.changed(), this.coordinates.splice(parseInt(e, 10), 1);
+      }, ie.prototype.updateCoordinate = function(e, t, n) {
+        var r = parseInt(e, 10);
+        this.coordinates[r] = [t, n], this.changed();
+      };
+      var W = function(e, t) {
+        G.call(this, e, t), this.coordinates = this.coordinates.map(function(n) {
+          return n.slice(0, -1);
+        });
+      };
+      (W.prototype = Object.create(G.prototype)).isValid = function() {
+        return this.coordinates.length !== 0 && this.coordinates.every(function(e) {
+          return e.length > 2;
+        });
+      }, W.prototype.incomingCoords = function(e) {
+        this.coordinates = e.map(function(t) {
+          return t.slice(0, -1);
+        }), this.changed();
+      }, W.prototype.setCoordinates = function(e) {
+        this.coordinates = e, this.changed();
+      }, W.prototype.addCoordinate = function(e, t, n) {
+        this.changed();
+        var r = e.split(".").map(function(o) {
+          return parseInt(o, 10);
+        });
+        this.coordinates[r[0]].splice(r[1], 0, [t, n]);
+      }, W.prototype.removeCoordinate = function(e) {
+        this.changed();
+        var t = e.split(".").map(function(r) {
+          return parseInt(r, 10);
+        }), n = this.coordinates[t[0]];
+        n && (n.splice(t[1], 1), n.length < 3 && this.coordinates.splice(t[0], 1));
+      }, W.prototype.getCoordinate = function(e) {
+        var t = e.split(".").map(function(r) {
+          return parseInt(r, 10);
+        }), n = this.coordinates[t[0]];
+        return JSON.parse(JSON.stringify(n[t[1]]));
+      }, W.prototype.getCoordinates = function() {
+        return this.coordinates.map(function(e) {
+          return e.concat([e[0]]);
+        });
+      }, W.prototype.updateCoordinate = function(e, t, n) {
+        this.changed();
+        var r = e.split("."), o = parseInt(r[0], 10), i = parseInt(r[1], 10);
+        this.coordinates[o] === void 0 && (this.coordinates[o] = []), this.coordinates[o][i] = [t, n];
+      };
+      var or = { MultiPoint: me, MultiLineString: ie, MultiPolygon: W }, Ye = function(e, t, n, r, o) {
+        var i = n.split("."), a = parseInt(i[0], 10), l = i[1] ? i.slice(1).join(".") : null;
+        return e[a][t](l, r, o);
+      }, $ = function(e, t) {
+        if (G.call(this, e, t), delete this.coordinates, this.model = or[t.geometry.type], this.model === void 0) throw new TypeError(t.geometry.type + " is not a valid type");
+        this.features = this._coordinatesToFeatures(t.geometry.coordinates);
+      };
+      function E(e) {
+        this.map = e.map, this.drawConfig = JSON.parse(JSON.stringify(e.options || {})), this._ctx = e;
+      }
+      ($.prototype = Object.create(G.prototype))._coordinatesToFeatures = function(e) {
+        var t = this, n = this.model.bind(this);
+        return e.map(function(r) {
+          return new n(t.ctx, { id: Pt(), type: m.FEATURE, properties: {}, geometry: { coordinates: r, type: t.type.replace("Multi", "") } });
+        });
+      }, $.prototype.isValid = function() {
+        return this.features.every(function(e) {
+          return e.isValid();
+        });
+      }, $.prototype.setCoordinates = function(e) {
+        this.features = this._coordinatesToFeatures(e), this.changed();
+      }, $.prototype.getCoordinate = function(e) {
+        return Ye(this.features, "getCoordinate", e);
+      }, $.prototype.getCoordinates = function() {
+        return JSON.parse(JSON.stringify(this.features.map(function(e) {
+          return e.type === m.POLYGON ? e.getCoordinates() : e.coordinates;
+        })));
+      }, $.prototype.updateCoordinate = function(e, t, n) {
+        Ye(this.features, "updateCoordinate", e, t, n), this.changed();
+      }, $.prototype.addCoordinate = function(e, t, n) {
+        Ye(this.features, "addCoordinate", e, t, n), this.changed();
+      }, $.prototype.removeCoordinate = function(e) {
+        Ye(this.features, "removeCoordinate", e), this.changed();
+      }, $.prototype.getFeatures = function() {
+        return this.features;
+      }, E.prototype.setSelected = function(e) {
+        return this._ctx.store.setSelected(e);
+      }, E.prototype.setSelectedCoordinates = function(e) {
+        var t = this;
+        this._ctx.store.setSelectedCoordinates(e), e.reduce(function(n, r) {
+          return n[r.feature_id] === void 0 && (n[r.feature_id] = !0, t._ctx.store.get(r.feature_id).changed()), n;
+        }, {});
+      }, E.prototype.getSelected = function() {
+        return this._ctx.store.getSelected();
+      }, E.prototype.getSelectedIds = function() {
+        return this._ctx.store.getSelectedIds();
+      }, E.prototype.isSelected = function(e) {
+        return this._ctx.store.isSelected(e);
+      }, E.prototype.getFeature = function(e) {
+        return this._ctx.store.get(e);
+      }, E.prototype.select = function(e) {
+        return this._ctx.store.select(e);
+      }, E.prototype.deselect = function(e) {
+        return this._ctx.store.deselect(e);
+      }, E.prototype.deleteFeature = function(e, t) {
+        return t === void 0 && (t = {}), this._ctx.store.delete(e, t);
+      }, E.prototype.addFeature = function(e) {
+        return this._ctx.store.add(e);
+      }, E.prototype.clearSelectedFeatures = function() {
+        return this._ctx.store.clearSelected();
+      }, E.prototype.clearSelectedCoordinates = function() {
+        return this._ctx.store.clearSelectedCoordinates();
+      }, E.prototype.setActionableState = function(e) {
+        e === void 0 && (e = {});
+        var t = { trash: e.trash || !1, combineFeatures: e.combineFeatures || !1, uncombineFeatures: e.uncombineFeatures || !1 };
+        return this._ctx.events.actionable(t);
+      }, E.prototype.changeMode = function(e, t, n) {
+        return t === void 0 && (t = {}), n === void 0 && (n = {}), this._ctx.events.changeMode(e, t, n);
+      }, E.prototype.updateUIClasses = function(e) {
+        return this._ctx.ui.queueMapClasses(e);
+      }, E.prototype.activateUIButton = function(e) {
+        return this._ctx.ui.setActiveButton(e);
+      }, E.prototype.featuresAt = function(e, t, n) {
+        if (n === void 0 && (n = "click"), n !== "click" && n !== "touch") throw new Error("invalid buffer type");
+        return xe[n](e, t, this._ctx);
+      }, E.prototype.newFeature = function(e) {
+        var t = e.geometry.type;
+        return t === m.POINT ? new me(this._ctx, e) : t === m.LINE_STRING ? new ie(this._ctx, e) : t === m.POLYGON ? new W(this._ctx, e) : new $(this._ctx, e);
+      }, E.prototype.isInstanceOf = function(e, t) {
+        if (e === m.POINT) return t instanceof me;
+        if (e === m.LINE_STRING) return t instanceof ie;
+        if (e === m.POLYGON) return t instanceof W;
+        if (e === "MultiFeature") return t instanceof $;
+        throw new Error("Unknown feature class: " + e);
+      }, E.prototype.doRender = function(e) {
+        return this._ctx.store.featureChanged(e);
+      }, E.prototype.onSetup = function() {
+      }, E.prototype.onDrag = function() {
+      }, E.prototype.onClick = function() {
+      }, E.prototype.onMouseMove = function() {
+      }, E.prototype.onMouseDown = function() {
+      }, E.prototype.onMouseUp = function() {
+      }, E.prototype.onMouseOut = function() {
+      }, E.prototype.onKeyUp = function() {
+      }, E.prototype.onKeyDown = function() {
+      }, E.prototype.onTouchStart = function() {
+      }, E.prototype.onTouchMove = function() {
+      }, E.prototype.onTouchEnd = function() {
+      }, E.prototype.onTap = function() {
+      }, E.prototype.onStop = function() {
+      }, E.prototype.onTrash = function() {
+      }, E.prototype.onCombineFeature = function() {
+      }, E.prototype.onUncombineFeature = function() {
+      }, E.prototype.toDisplayFeatures = function() {
+        throw new Error("You must overwrite toDisplayFeatures");
+      };
+      var on = { drag: "onDrag", click: "onClick", mousemove: "onMouseMove", mousedown: "onMouseDown", mouseup: "onMouseUp", mouseout: "onMouseOut", keyup: "onKeyUp", keydown: "onKeyDown", touchstart: "onTouchStart", touchmove: "onTouchMove", touchend: "onTouchEnd", tap: "onTap" }, ir = Object.keys(on);
+      function ar(e) {
+        var t = Object.keys(e);
+        return function(n, r) {
+          r === void 0 && (r = {});
+          var o = {}, i = t.reduce(function(a, l) {
+            return a[l] = e[l], a;
+          }, new E(n));
+          return { start: function() {
+            var a = this;
+            o = i.onSetup(r), ir.forEach(function(l) {
+              var d, h = on[l], g = function() {
+                return !1;
+              };
+              e[h] && (g = function() {
+                return !0;
+              }), a.on(l, g, (d = h, function(p) {
+                return i[d](o, p);
+              }));
+            });
+          }, stop: function() {
+            i.onStop(o);
+          }, trash: function() {
+            i.onTrash(o);
+          }, combineFeatures: function() {
+            i.onCombineFeatures(o);
+          }, uncombineFeatures: function() {
+            i.onUncombineFeatures(o);
+          }, render: function(a, l) {
+            i.toDisplayFeatures(o, a, l);
+          } };
+        };
+      }
+      function Re(e) {
+        return [].concat(e).filter(function(t) {
+          return t !== void 0;
+        });
+      }
+      function sr() {
+        var e = this;
+        if (!(e.ctx.map && e.ctx.map.getSource(X.HOT) !== void 0)) return d();
+        var t = e.ctx.events.currentModeName();
+        e.ctx.ui.queueMapClasses({ mode: t });
+        var n = [], r = [];
+        e.isDirty ? r = e.getAllIds() : (n = e.getChangedIds().filter(function(h) {
+          return e.get(h) !== void 0;
+        }), r = e.sources.hot.filter(function(h) {
+          return h.properties.id && n.indexOf(h.properties.id) === -1 && e.get(h.properties.id) !== void 0;
+        }).map(function(h) {
+          return h.properties.id;
+        })), e.sources.hot = [];
+        var o = e.sources.cold.length;
+        e.sources.cold = e.isDirty ? [] : e.sources.cold.filter(function(h) {
+          var g = h.properties.id || h.properties.parent;
+          return n.indexOf(g) === -1;
+        });
+        var i = o !== e.sources.cold.length || r.length > 0;
+        function a(h, g) {
+          var p = e.get(h).internal(t);
+          e.ctx.events.currentModeRender(p, function(_) {
+            e.sources[g].push(_);
+          });
+        }
+        if (n.forEach(function(h) {
+          return a(h, "hot");
+        }), r.forEach(function(h) {
+          return a(h, "cold");
+        }), i && e.ctx.map.getSource(X.COLD).setData({ type: m.FEATURE_COLLECTION, features: e.sources.cold }), e.ctx.map.getSource(X.HOT).setData({ type: m.FEATURE_COLLECTION, features: e.sources.hot }), e._emitSelectionChange && (e.ctx.map.fire(H.SELECTION_CHANGE, { features: e.getSelected().map(function(h) {
+          return h.toGeoJSON();
+        }), points: e.getSelectedCoordinates().map(function(h) {
+          return { type: m.FEATURE, properties: {}, geometry: { type: m.POINT, coordinates: h.coordinates } };
+        }) }), e._emitSelectionChange = !1), e._deletedFeaturesToEmit.length) {
+          var l = e._deletedFeaturesToEmit.map(function(h) {
+            return h.toGeoJSON();
+          });
+          e._deletedFeaturesToEmit = [], e.ctx.map.fire(H.DELETE, { features: l });
+        }
+        function d() {
+          e.isDirty = !1, e.clearChangedIds();
+        }
+        d(), e.ctx.map.fire(H.RENDER, {});
+      }
+      function x(e) {
+        var t, n = this;
+        this._features = {}, this._featureIds = new Z(), this._selectedFeatureIds = new Z(), this._selectedCoordinates = [], this._changedFeatureIds = new Z(), this._deletedFeaturesToEmit = [], this._emitSelectionChange = !1, this._mapInitialConfig = {}, this.ctx = e, this.sources = { hot: [], cold: [] }, this.render = function() {
+          t || (t = requestAnimationFrame(function() {
+            t = null, sr.call(n);
+          }));
+        }, this.isDirty = !1;
+      }
+      function an(e, t) {
+        var n = e._selectedCoordinates.filter(function(r) {
+          return e._selectedFeatureIds.has(r.feature_id);
+        });
+        e._selectedCoordinates.length === n.length || t.silent || (e._emitSelectionChange = !0), e._selectedCoordinates = n;
+      }
+      x.prototype.createRenderBatch = function() {
+        var e = this, t = this.render, n = 0;
+        return this.render = function() {
+          n++;
+        }, function() {
+          e.render = t, n > 0 && e.render();
+        };
+      }, x.prototype.setDirty = function() {
+        return this.isDirty = !0, this;
+      }, x.prototype.featureChanged = function(e) {
+        return this._changedFeatureIds.add(e), this;
+      }, x.prototype.getChangedIds = function() {
+        return this._changedFeatureIds.values();
+      }, x.prototype.clearChangedIds = function() {
+        return this._changedFeatureIds.clear(), this;
+      }, x.prototype.getAllIds = function() {
+        return this._featureIds.values();
+      }, x.prototype.add = function(e) {
+        return this.featureChanged(e.id), this._features[e.id] = e, this._featureIds.add(e.id), this;
+      }, x.prototype.delete = function(e, t) {
+        var n = this;
+        return t === void 0 && (t = {}), Re(e).forEach(function(r) {
+          n._featureIds.has(r) && (n._featureIds.delete(r), n._selectedFeatureIds.delete(r), t.silent || n._deletedFeaturesToEmit.indexOf(n._features[r]) === -1 && n._deletedFeaturesToEmit.push(n._features[r]), delete n._features[r], n.isDirty = !0);
+        }), an(this, t), this;
+      }, x.prototype.get = function(e) {
+        return this._features[e];
+      }, x.prototype.getAll = function() {
+        var e = this;
+        return Object.keys(this._features).map(function(t) {
+          return e._features[t];
+        });
+      }, x.prototype.select = function(e, t) {
+        var n = this;
+        return t === void 0 && (t = {}), Re(e).forEach(function(r) {
+          n._selectedFeatureIds.has(r) || (n._selectedFeatureIds.add(r), n._changedFeatureIds.add(r), t.silent || (n._emitSelectionChange = !0));
+        }), this;
+      }, x.prototype.deselect = function(e, t) {
+        var n = this;
+        return t === void 0 && (t = {}), Re(e).forEach(function(r) {
+          n._selectedFeatureIds.has(r) && (n._selectedFeatureIds.delete(r), n._changedFeatureIds.add(r), t.silent || (n._emitSelectionChange = !0));
+        }), an(this, t), this;
+      }, x.prototype.clearSelected = function(e) {
+        return e === void 0 && (e = {}), this.deselect(this._selectedFeatureIds.values(), { silent: e.silent }), this;
+      }, x.prototype.setSelected = function(e, t) {
+        var n = this;
+        return t === void 0 && (t = {}), e = Re(e), this.deselect(this._selectedFeatureIds.values().filter(function(r) {
+          return e.indexOf(r) === -1;
+        }), { silent: t.silent }), this.select(e.filter(function(r) {
+          return !n._selectedFeatureIds.has(r);
+        }), { silent: t.silent }), this;
+      }, x.prototype.setSelectedCoordinates = function(e) {
+        return this._selectedCoordinates = e, this._emitSelectionChange = !0, this;
+      }, x.prototype.clearSelectedCoordinates = function() {
+        return this._selectedCoordinates = [], this._emitSelectionChange = !0, this;
+      }, x.prototype.getSelectedIds = function() {
+        return this._selectedFeatureIds.values();
+      }, x.prototype.getSelected = function() {
+        var e = this;
+        return this._selectedFeatureIds.values().map(function(t) {
+          return e.get(t);
+        });
+      }, x.prototype.getSelectedCoordinates = function() {
+        var e = this;
+        return this._selectedCoordinates.map(function(t) {
+          return { coordinates: e.get(t.feature_id).getCoordinate(t.coord_path) };
+        });
+      }, x.prototype.isSelected = function(e) {
+        return this._selectedFeatureIds.has(e);
+      }, x.prototype.setFeatureProperty = function(e, t, n) {
+        this.get(e).setProperty(t, n), this.featureChanged(e);
+      }, x.prototype.storeMapConfig = function() {
+        var e = this;
+        Kt.forEach(function(t) {
+          e.ctx.map[t] && (e._mapInitialConfig[t] = e.ctx.map[t].isEnabled());
+        });
+      }, x.prototype.restoreMapConfig = function() {
+        var e = this;
+        Object.keys(this._mapInitialConfig).forEach(function(t) {
+          e._mapInitialConfig[t] ? e.ctx.map[t].enable() : e.ctx.map[t].disable();
+        });
+      }, x.prototype.getInitialConfigValue = function(e) {
+        return this._mapInitialConfig[e] === void 0 || this._mapInitialConfig[e];
+      };
+      var ur = function() {
+        for (var e = arguments, t = {}, n = 0; n < arguments.length; n++) {
+          var r = e[n];
+          for (var o in r) cr.call(r, o) && (t[o] = r[o]);
+        }
+        return t;
+      }, cr = Object.prototype.hasOwnProperty, pe = de(ur), lr = ["mode", "feature", "mouse"];
+      function dr(e) {
+        var t = null, n = null, r = { onRemove: function() {
+          return e.map.off("load", r.connect), clearInterval(n), r.removeLayers(), e.store.restoreMapConfig(), e.ui.removeButtons(), e.events.removeEventListeners(), e.ui.clearMapClasses(), e.boxZoomInitial && e.map.boxZoom.enable(), e.map = null, e.container = null, e.store = null, t && t.parentNode && t.parentNode.removeChild(t), t = null, this;
+        }, connect: function() {
+          e.map.off("load", r.connect), clearInterval(n), r.addLayers(), e.store.storeMapConfig(), e.events.addEventListeners();
+        }, onAdd: function(o) {
+          var i = o.fire;
+          return o.fire = function(a, l) {
+            var d = arguments;
+            return i.length === 1 && arguments.length !== 1 && (d = [pe({}, { type: a }, l)]), i.apply(o, d);
+          }, e.map = o, e.events = function(a) {
+            var l = Object.keys(a.options.modes).reduce(function(c, y) {
+              return c[y] = ar(a.options.modes[y]), c;
+            }, {}), d = {}, h = {}, g = {}, p = null, _ = null;
+            g.drag = function(c, y) {
+              y({ point: c.point, time: (/* @__PURE__ */ new Date()).getTime() }) ? (a.ui.queueMapClasses({ mouse: N.DRAG }), _.drag(c)) : c.originalEvent.stopPropagation();
+            }, g.mousedrag = function(c) {
+              g.drag(c, function(y) {
+                return !Mt(d, y);
+              });
+            }, g.touchdrag = function(c) {
+              g.drag(c, function(y) {
+                return !Lt(h, y);
+              });
+            }, g.mousemove = function(c) {
+              if ((c.originalEvent.buttons !== void 0 ? c.originalEvent.buttons : c.originalEvent.which) === 1) return g.mousedrag(c);
+              var y = ze(c, a);
+              c.featureTarget = y, _.mousemove(c);
+            }, g.mousedown = function(c) {
+              d = { time: (/* @__PURE__ */ new Date()).getTime(), point: c.point };
+              var y = ze(c, a);
+              c.featureTarget = y, _.mousedown(c);
+            }, g.mouseup = function(c) {
+              var y = ze(c, a);
+              c.featureTarget = y, Mt(d, { point: c.point, time: (/* @__PURE__ */ new Date()).getTime() }) ? _.click(c) : _.mouseup(c);
+            }, g.mouseout = function(c) {
+              _.mouseout(c);
+            }, g.touchstart = function(c) {
+              if (a.options.touchEnabled) {
+                h = { time: (/* @__PURE__ */ new Date()).getTime(), point: c.point };
+                var y = xe.touch(c, null, a)[0];
+                c.featureTarget = y, _.touchstart(c);
+              }
+            }, g.touchmove = function(c) {
+              if (a.options.touchEnabled) return _.touchmove(c), g.touchdrag(c);
+            }, g.touchend = function(c) {
+              if (c.originalEvent.preventDefault(), a.options.touchEnabled) {
+                var y = xe.touch(c, null, a)[0];
+                c.featureTarget = y, Lt(h, { time: (/* @__PURE__ */ new Date()).getTime(), point: c.point }) ? _.tap(c) : _.touchend(c);
+              }
+            };
+            var P = function(c) {
+              return !(c === 8 || c === 46 || c >= 48 && c <= 57);
+            };
+            function b(c, y, O) {
+              O === void 0 && (O = {}), _.stop();
+              var V = l[c];
+              if (V === void 0) throw new Error(c + " is not valid");
+              p = c;
+              var F = V(a, y);
+              _ = Je(F, a), O.silent || a.map.fire(H.MODE_CHANGE, { mode: c }), a.store.setDirty(), a.store.render();
+            }
+            g.keydown = function(c) {
+              (c.srcElement || c.target).classList.contains("mapboxgl-canvas") && (c.keyCode !== 8 && c.keyCode !== 46 || !a.options.controls.trash ? P(c.keyCode) ? _.keydown(c) : c.keyCode === 49 && a.options.controls.point ? b(T.DRAW_POINT) : c.keyCode === 50 && a.options.controls.line_string ? b(T.DRAW_LINE_STRING) : c.keyCode === 51 && a.options.controls.polygon && b(T.DRAW_POLYGON) : (c.preventDefault(), _.trash()));
+            }, g.keyup = function(c) {
+              P(c.keyCode) && _.keyup(c);
+            }, g.zoomend = function() {
+              a.store.changeZoom();
+            }, g.data = function(c) {
+              if (c.dataType === "style") {
+                var y = a.setup, O = a.map, V = a.options, F = a.store;
+                V.styles.some(function(jt) {
+                  return O.getLayer(jt.id);
+                }) || (y.addLayers(), F.setDirty(), F.render());
+              }
+            };
+            var w = { trash: !1, combineFeatures: !1, uncombineFeatures: !1 };
+            return { start: function() {
+              p = a.options.defaultMode, _ = Je(l[p](a), a);
+            }, changeMode: b, actionable: function(c) {
+              var y = !1;
+              Object.keys(c).forEach(function(O) {
+                if (w[O] === void 0) throw new Error("Invalid action type");
+                w[O] !== c[O] && (y = !0), w[O] = c[O];
+              }), y && a.map.fire(H.ACTIONABLE, { actions: w });
+            }, currentModeName: function() {
+              return p;
+            }, currentModeRender: function(c, y) {
+              return _.render(c, y);
+            }, fire: function(c, y) {
+              g[c] && g[c](y);
+            }, addEventListeners: function() {
+              a.map.on("mousemove", g.mousemove), a.map.on("mousedown", g.mousedown), a.map.on("mouseup", g.mouseup), a.map.on("data", g.data), a.map.on("touchmove", g.touchmove), a.map.on("touchstart", g.touchstart), a.map.on("touchend", g.touchend), a.container.addEventListener("mouseout", g.mouseout), a.options.keybindings && (a.container.addEventListener("keydown", g.keydown), a.container.addEventListener("keyup", g.keyup));
+            }, removeEventListeners: function() {
+              a.map.off("mousemove", g.mousemove), a.map.off("mousedown", g.mousedown), a.map.off("mouseup", g.mouseup), a.map.off("data", g.data), a.map.off("touchmove", g.touchmove), a.map.off("touchstart", g.touchstart), a.map.off("touchend", g.touchend), a.container.removeEventListener("mouseout", g.mouseout), a.options.keybindings && (a.container.removeEventListener("keydown", g.keydown), a.container.removeEventListener("keyup", g.keyup));
+            }, trash: function(c) {
+              _.trash(c);
+            }, combineFeatures: function() {
+              _.combineFeatures();
+            }, uncombineFeatures: function() {
+              _.uncombineFeatures();
+            }, getMode: function() {
+              return p;
+            } };
+          }(e), e.ui = /* @__PURE__ */ function(a) {
+            var l = {}, d = null, h = { mode: null, feature: null, mouse: null }, g = { mode: null, feature: null, mouse: null };
+            function p(c) {
+              g = pe(g, c);
+            }
+            function _() {
+              var c, y;
+              if (a.container) {
+                var O = [], V = [];
+                lr.forEach(function(F) {
+                  g[F] !== h[F] && (O.push(F + "-" + h[F]), g[F] !== null && V.push(F + "-" + g[F]));
+                }), O.length > 0 && (c = a.container.classList).remove.apply(c, O), V.length > 0 && (y = a.container.classList).add.apply(y, V), h = pe(h, g);
+              }
+            }
+            function P(c, y) {
+              y === void 0 && (y = {});
+              var O = document.createElement("button");
+              return O.className = q.CONTROL_BUTTON + " " + y.className, O.setAttribute("title", y.title), y.container.appendChild(O), O.addEventListener("click", function(V) {
+                if (V.preventDefault(), V.stopPropagation(), V.target === d) return b(), void y.onDeactivate();
+                w(c), y.onActivate();
+              }, !0), O;
+            }
+            function b() {
+              d && (d.classList.remove(q.ACTIVE_BUTTON), d = null);
+            }
+            function w(c) {
+              b();
+              var y = l[c];
+              y && y && c !== "trash" && (y.classList.add(q.ACTIVE_BUTTON), d = y);
+            }
+            return { setActiveButton: w, queueMapClasses: p, updateMapClasses: _, clearMapClasses: function() {
+              p({ mode: null, feature: null, mouse: null }), _();
+            }, addButtons: function() {
+              var c = a.options.controls, y = document.createElement("div");
+              return y.className = q.CONTROL_GROUP + " " + q.CONTROL_BASE, c && (c[Y.LINE] && (l[Y.LINE] = P(Y.LINE, { container: y, className: q.CONTROL_BUTTON_LINE, title: "LineString tool " + (a.options.keybindings ? "(l)" : ""), onActivate: function() {
+                return a.events.changeMode(T.DRAW_LINE_STRING);
+              }, onDeactivate: function() {
+                return a.events.trash();
+              } })), c[Y.POLYGON] && (l[Y.POLYGON] = P(Y.POLYGON, { container: y, className: q.CONTROL_BUTTON_POLYGON, title: "Polygon tool " + (a.options.keybindings ? "(p)" : ""), onActivate: function() {
+                return a.events.changeMode(T.DRAW_POLYGON);
+              }, onDeactivate: function() {
+                return a.events.trash();
+              } })), c[Y.POINT] && (l[Y.POINT] = P(Y.POINT, { container: y, className: q.CONTROL_BUTTON_POINT, title: "Marker tool " + (a.options.keybindings ? "(m)" : ""), onActivate: function() {
+                return a.events.changeMode(T.DRAW_POINT);
+              }, onDeactivate: function() {
+                return a.events.trash();
+              } })), c.trash && (l.trash = P("trash", { container: y, className: q.CONTROL_BUTTON_TRASH, title: "Delete", onActivate: function() {
+                a.events.trash();
+              } })), c.combine_features && (l.combine_features = P("combineFeatures", { container: y, className: q.CONTROL_BUTTON_COMBINE_FEATURES, title: "Combine", onActivate: function() {
+                a.events.combineFeatures();
+              } })), c.uncombine_features && (l.uncombine_features = P("uncombineFeatures", { container: y, className: q.CONTROL_BUTTON_UNCOMBINE_FEATURES, title: "Uncombine", onActivate: function() {
+                a.events.uncombineFeatures();
+              } }))), y;
+            }, removeButtons: function() {
+              Object.keys(l).forEach(function(c) {
+                var y = l[c];
+                y.parentNode && y.parentNode.removeChild(y), delete l[c];
+              });
+            } };
+          }(e), e.container = o.getContainer(), e.store = new x(e), t = e.ui.addButtons(), e.options.boxSelect && (e.boxZoomInitial = o.boxZoom.isEnabled(), o.boxZoom.disable(), o.dragPan.disable(), o.dragPan.enable()), o.loaded() ? r.connect() : (o.on("load", r.connect), n = setInterval(function() {
+            o.loaded() && r.connect();
+          }, 16)), e.events.start(), t;
+        }, addLayers: function() {
+          e.map.addSource(X.COLD, { data: { type: m.FEATURE_COLLECTION, features: [] }, type: "geojson" }), e.map.addSource(X.HOT, { data: { type: m.FEATURE_COLLECTION, features: [] }, type: "geojson" }), e.options.styles.forEach(function(o) {
+            e.map.addLayer(o);
+          }), e.store.setDirty(!0), e.store.render();
+        }, removeLayers: function() {
+          e.options.styles.forEach(function(o) {
+            e.map.getLayer(o.id) && e.map.removeLayer(o.id);
+          }), e.map.getSource(X.COLD) && e.map.removeSource(X.COLD), e.map.getSource(X.HOT) && e.map.removeSource(X.HOT);
+        } };
+        return e.setup = r, r;
+      }
+      var sn = [{ id: "gl-draw-polygon-fill-inactive", type: "fill", filter: ["all", ["==", "active", "false"], ["==", "$type", "Polygon"], ["!=", "mode", "static"]], paint: { "fill-color": "#3bb2d0", "fill-outline-color": "#3bb2d0", "fill-opacity": 0.1 } }, { id: "gl-draw-polygon-fill-active", type: "fill", filter: ["all", ["==", "active", "true"], ["==", "$type", "Polygon"]], paint: { "fill-color": "#fbb03b", "fill-outline-color": "#fbb03b", "fill-opacity": 0.1 } }, { id: "gl-draw-polygon-midpoint", type: "circle", filter: ["all", ["==", "$type", "Point"], ["==", "meta", "midpoint"]], paint: { "circle-radius": 3, "circle-color": "#fbb03b" } }, { id: "gl-draw-polygon-stroke-inactive", type: "line", filter: ["all", ["==", "active", "false"], ["==", "$type", "Polygon"], ["!=", "mode", "static"]], layout: { "line-cap": "round", "line-join": "round" }, paint: { "line-color": "#3bb2d0", "line-width": 2 } }, { id: "gl-draw-polygon-stroke-active", type: "line", filter: ["all", ["==", "active", "true"], ["==", "$type", "Polygon"]], layout: { "line-cap": "round", "line-join": "round" }, paint: { "line-color": "#fbb03b", "line-dasharray": [0.2, 2], "line-width": 2 } }, { id: "gl-draw-line-inactive", type: "line", filter: ["all", ["==", "active", "false"], ["==", "$type", "LineString"], ["!=", "mode", "static"]], layout: { "line-cap": "round", "line-join": "round" }, paint: { "line-color": "#3bb2d0", "line-width": 2 } }, { id: "gl-draw-line-active", type: "line", filter: ["all", ["==", "$type", "LineString"], ["==", "active", "true"]], layout: { "line-cap": "round", "line-join": "round" }, paint: { "line-color": "#fbb03b", "line-dasharray": [0.2, 2], "line-width": 2 } }, { id: "gl-draw-polygon-and-line-vertex-stroke-inactive", type: "circle", filter: ["all", ["==", "meta", "vertex"], ["==", "$type", "Point"], ["!=", "mode", "static"]], paint: { "circle-radius": 5, "circle-color": "#fff" } }, { id: "gl-draw-polygon-and-line-vertex-inactive", type: "circle", filter: ["all", ["==", "meta", "vertex"], ["==", "$type", "Point"], ["!=", "mode", "static"]], paint: { "circle-radius": 3, "circle-color": "#fbb03b" } }, { id: "gl-draw-point-point-stroke-inactive", type: "circle", filter: ["all", ["==", "active", "false"], ["==", "$type", "Point"], ["==", "meta", "feature"], ["!=", "mode", "static"]], paint: { "circle-radius": 5, "circle-opacity": 1, "circle-color": "#fff" } }, { id: "gl-draw-point-inactive", type: "circle", filter: ["all", ["==", "active", "false"], ["==", "$type", "Point"], ["==", "meta", "feature"], ["!=", "mode", "static"]], paint: { "circle-radius": 3, "circle-color": "#3bb2d0" } }, { id: "gl-draw-point-stroke-active", type: "circle", filter: ["all", ["==", "$type", "Point"], ["==", "active", "true"], ["!=", "meta", "midpoint"]], paint: { "circle-radius": 7, "circle-color": "#fff" } }, { id: "gl-draw-point-active", type: "circle", filter: ["all", ["==", "$type", "Point"], ["!=", "meta", "midpoint"], ["==", "active", "true"]], paint: { "circle-radius": 5, "circle-color": "#fbb03b" } }, { id: "gl-draw-polygon-fill-static", type: "fill", filter: ["all", ["==", "mode", "static"], ["==", "$type", "Polygon"]], paint: { "fill-color": "#404040", "fill-outline-color": "#404040", "fill-opacity": 0.1 } }, { id: "gl-draw-polygon-stroke-static", type: "line", filter: ["all", ["==", "mode", "static"], ["==", "$type", "Polygon"]], layout: { "line-cap": "round", "line-join": "round" }, paint: { "line-color": "#404040", "line-width": 2 } }, { id: "gl-draw-line-static", type: "line", filter: ["all", ["==", "mode", "static"], ["==", "$type", "LineString"]], layout: { "line-cap": "round", "line-join": "round" }, paint: { "line-color": "#404040", "line-width": 2 } }, { id: "gl-draw-point-static", type: "circle", filter: ["all", ["==", "mode", "static"], ["==", "$type", "Point"]], paint: { "circle-radius": 5, "circle-color": "#404040" } }];
+      function $e(e) {
+        return function(t) {
+          var n = t.featureTarget;
+          return !!n && !!n.properties && n.properties.meta === e;
+        };
+      }
+      function un(e) {
+        return !!e.originalEvent && !!e.originalEvent.shiftKey && e.originalEvent.button === 0;
+      }
+      function _e(e) {
+        return !!e.featureTarget && !!e.featureTarget.properties && e.featureTarget.properties.active === j.ACTIVE && e.featureTarget.properties.meta === B.FEATURE;
+      }
+      function At(e) {
+        return !!e.featureTarget && !!e.featureTarget.properties && e.featureTarget.properties.active === j.INACTIVE && e.featureTarget.properties.meta === B.FEATURE;
+      }
+      function qe(e) {
+        return e.featureTarget === void 0;
+      }
+      function wt(e) {
+        return !!e.featureTarget && !!e.featureTarget.properties && e.featureTarget.properties.meta === B.FEATURE;
+      }
+      function De(e) {
+        var t = e.featureTarget;
+        return !!t && !!t.properties && t.properties.meta === B.VERTEX;
+      }
+      function He(e) {
+        return !!e.originalEvent && e.originalEvent.shiftKey === !0;
+      }
+      function Xe(e) {
+        return e.keyCode === 27;
+      }
+      function Ze(e) {
+        return e.keyCode === 13;
+      }
+      var pr = Object.freeze({ __proto__: null, isOfMetaType: $e, isShiftMousedown: un, isActiveFeature: _e, isInactiveFeature: At, noTarget: qe, isFeature: wt, isVertex: De, isShiftDown: He, isEscapeKey: Xe, isEnterKey: Ze, isTrue: function() {
+        return !0;
+      } }), fr = Me;
+      function Me(e, t) {
+        this.x = e, this.y = t;
+      }
+      Me.prototype = { clone: function() {
+        return new Me(this.x, this.y);
+      }, add: function(e) {
+        return this.clone()._add(e);
+      }, sub: function(e) {
+        return this.clone()._sub(e);
+      }, multByPoint: function(e) {
+        return this.clone()._multByPoint(e);
+      }, divByPoint: function(e) {
+        return this.clone()._divByPoint(e);
+      }, mult: function(e) {
+        return this.clone()._mult(e);
+      }, div: function(e) {
+        return this.clone()._div(e);
+      }, rotate: function(e) {
+        return this.clone()._rotate(e);
+      }, rotateAround: function(e, t) {
+        return this.clone()._rotateAround(e, t);
+      }, matMult: function(e) {
+        return this.clone()._matMult(e);
+      }, unit: function() {
+        return this.clone()._unit();
+      }, perp: function() {
+        return this.clone()._perp();
+      }, round: function() {
+        return this.clone()._round();
+      }, mag: function() {
+        return Math.sqrt(this.x * this.x + this.y * this.y);
+      }, equals: function(e) {
+        return this.x === e.x && this.y === e.y;
+      }, dist: function(e) {
+        return Math.sqrt(this.distSqr(e));
+      }, distSqr: function(e) {
+        var t = e.x - this.x, n = e.y - this.y;
+        return t * t + n * n;
+      }, angle: function() {
+        return Math.atan2(this.y, this.x);
+      }, angleTo: function(e) {
+        return Math.atan2(this.y - e.y, this.x - e.x);
+      }, angleWith: function(e) {
+        return this.angleWithSep(e.x, e.y);
+      }, angleWithSep: function(e, t) {
+        return Math.atan2(this.x * t - this.y * e, this.x * e + this.y * t);
+      }, _matMult: function(e) {
+        var t = e[0] * this.x + e[1] * this.y, n = e[2] * this.x + e[3] * this.y;
+        return this.x = t, this.y = n, this;
+      }, _add: function(e) {
+        return this.x += e.x, this.y += e.y, this;
+      }, _sub: function(e) {
+        return this.x -= e.x, this.y -= e.y, this;
+      }, _mult: function(e) {
+        return this.x *= e, this.y *= e, this;
+      }, _div: function(e) {
+        return this.x /= e, this.y /= e, this;
+      }, _multByPoint: function(e) {
+        return this.x *= e.x, this.y *= e.y, this;
+      }, _divByPoint: function(e) {
+        return this.x /= e.x, this.y /= e.y, this;
+      }, _unit: function() {
+        return this._div(this.mag()), this;
+      }, _perp: function() {
+        var e = this.y;
+        return this.y = this.x, this.x = -e, this;
+      }, _rotate: function(e) {
+        var t = Math.cos(e), n = Math.sin(e), r = t * this.x - n * this.y, o = n * this.x + t * this.y;
+        return this.x = r, this.y = o, this;
+      }, _rotateAround: function(e, t) {
+        var n = Math.cos(e), r = Math.sin(e), o = t.x + n * (this.x - t.x) - r * (this.y - t.y), i = t.y + r * (this.x - t.x) + n * (this.y - t.y);
+        return this.x = o, this.y = i, this;
+      }, _round: function() {
+        return this.x = Math.round(this.x), this.y = Math.round(this.y), this;
+      } }, Me.convert = function(e) {
+        return e instanceof Me ? e : Array.isArray(e) ? new Me(e[0], e[1]) : e;
+      };
+      var hr = de(fr);
+      function Ft(e, t) {
+        var n = t.getBoundingClientRect();
+        return new hr(e.clientX - n.left - (t.clientLeft || 0), e.clientY - n.top - (t.clientTop || 0));
+      }
+      function Le(e, t, n, r) {
+        return { type: m.FEATURE, properties: { meta: B.VERTEX, parent: e, coord_path: n, active: r ? j.ACTIVE : j.INACTIVE }, geometry: { type: m.POINT, coordinates: t } };
+      }
+      function cn(e, t, n) {
+        var r = t.geometry.coordinates, o = n.geometry.coordinates;
+        if (r[1] > 85 || r[1] < It || o[1] > 85 || o[1] < It) return null;
+        var i = { lng: (r[0] + o[0]) / 2, lat: (r[1] + o[1]) / 2 };
+        return { type: m.FEATURE, properties: { meta: B.MIDPOINT, parent: e, lng: i.lng, lat: i.lat, coord_path: n.properties.coord_path }, geometry: { type: m.POINT, coordinates: [i.lng, i.lat] } };
+      }
+      function We(e, t, n) {
+        t === void 0 && (t = {}), n === void 0 && (n = null);
+        var r, o = e.geometry, i = o.type, a = o.coordinates, l = e.properties && e.properties.id, d = [];
+        function h(p, _) {
+          var P = "", b = null;
+          p.forEach(function(w, c) {
+            var y = _ != null ? _ + "." + c : String(c), O = Le(l, w, y, g(y));
+            if (t.midpoints && b) {
+              var V = cn(l, b, O);
+              V && d.push(V);
+            }
+            b = O;
+            var F = JSON.stringify(w);
+            P !== F && d.push(O), c === 0 && (P = F);
+          });
+        }
+        function g(p) {
+          return !!t.selectedPaths && t.selectedPaths.indexOf(p) !== -1;
+        }
+        return i === m.POINT ? d.push(Le(l, a, n, g(n))) : i === m.POLYGON ? a.forEach(function(p, _) {
+          h(p, n !== null ? n + "." + _ : String(_));
+        }) : i === m.LINE_STRING ? h(a, n) : i.indexOf(m.MULTI_PREFIX) === 0 && (r = i.replace(m.MULTI_PREFIX, ""), a.forEach(function(p, _) {
+          var P = { type: m.FEATURE, properties: e.properties, geometry: { type: r, coordinates: p } };
+          d = d.concat(We(P, t, _));
+        })), d;
+      }
+      var ee = { enable: function(e) {
+        setTimeout(function() {
+          e.map && e.map.doubleClickZoom && e._ctx && e._ctx.store && e._ctx.store.getInitialConfigValue && e._ctx.store.getInitialConfigValue("doubleClickZoom") && e.map.doubleClickZoom.enable();
+        }, 0);
+      }, disable: function(e) {
+        setTimeout(function() {
+          e.map && e.map.doubleClickZoom && e.map.doubleClickZoom.disable();
+        }, 0);
+      } }, Ke = { exports: {} }, ln = function(e) {
+        if (!e || !e.type) return null;
+        var t = gr[e.type];
+        if (!t) return null;
+        if (t === "geometry") return { type: "FeatureCollection", features: [{ type: "Feature", properties: {}, geometry: e }] };
+        if (t === "feature") return { type: "FeatureCollection", features: [e] };
+        if (t === "featurecollection") return e;
+      }, gr = { Point: "geometry", MultiPoint: "geometry", LineString: "geometry", MultiLineString: "geometry", Polygon: "geometry", MultiPolygon: "geometry", GeometryCollection: "geometry", Feature: "feature", FeatureCollection: "featurecollection" }, yr = de(ln), vr = Object.freeze({ __proto__: null, default: function e(t) {
+        switch (t && t.type || null) {
+          case "FeatureCollection":
+            return t.features = t.features.reduce(function(n, r) {
+              return n.concat(e(r));
+            }, []), t;
+          case "Feature":
+            return t.geometry ? e(t.geometry).map(function(n) {
+              var r = { type: "Feature", properties: JSON.parse(JSON.stringify(t.properties)), geometry: n };
+              return t.id !== void 0 && (r.id = t.id), r;
+            }) : [t];
+          case "MultiPoint":
+            return t.coordinates.map(function(n) {
+              return { type: "Point", coordinates: n };
+            });
+          case "MultiPolygon":
+            return t.coordinates.map(function(n) {
+              return { type: "Polygon", coordinates: n };
+            });
+          case "MultiLineString":
+            return t.coordinates.map(function(n) {
+              return { type: "LineString", coordinates: n };
+            });
+          case "GeometryCollection":
+            return t.geometries.map(e).reduce(function(n, r) {
+              return n.concat(r);
+            }, []);
+          case "Point":
+          case "Polygon":
+          case "LineString":
+            return [t];
+        }
+      } }), mr = ln, Qe = Qn(vr), _r = function(e) {
+        return function t(n) {
+          return Array.isArray(n) && n.length && typeof n[0] == "number" ? [n] : n.reduce(function(r, o) {
+            return Array.isArray(o) && Array.isArray(o[0]) ? r.concat(t(o)) : (r.push(o), r);
+          }, []);
+        }(e);
+      };
+      Qe instanceof Function || (Qe = Qe.default);
+      var dn = { exports: {} }, br = dn.exports = function(e) {
+        return new K(e);
+      };
+      function K(e) {
+        this.value = e;
+      }
+      function pn(e, t, n) {
+        var r = [], o = [], i = !0;
+        return function a(l) {
+          var d = n ? fn(l) : l, h = {}, g = !0, p = { node: d, node_: l, path: [].concat(r), parent: o[o.length - 1], parents: o, key: r.slice(-1)[0], isRoot: r.length === 0, level: r.length, circular: null, update: function(b, w) {
+            p.isRoot || (p.parent.node[p.key] = b), p.node = b, w && (g = !1);
+          }, delete: function(b) {
+            delete p.parent.node[p.key], b && (g = !1);
+          }, remove: function(b) {
+            hn(p.parent.node) ? p.parent.node.splice(p.key, 1) : delete p.parent.node[p.key], b && (g = !1);
+          }, keys: null, before: function(b) {
+            h.before = b;
+          }, after: function(b) {
+            h.after = b;
+          }, pre: function(b) {
+            h.pre = b;
+          }, post: function(b) {
+            h.post = b;
+          }, stop: function() {
+            i = !1;
+          }, block: function() {
+            g = !1;
+          } };
+          if (!i) return p;
+          function _() {
+            if (typeof p.node == "object" && p.node !== null) {
+              p.keys && p.node_ === p.node || (p.keys = et(p.node)), p.isLeaf = p.keys.length == 0;
+              for (var b = 0; b < o.length; b++) if (o[b].node_ === l) {
+                p.circular = o[b];
+                break;
+              }
+            } else p.isLeaf = !0, p.keys = null;
+            p.notLeaf = !p.isLeaf, p.notRoot = !p.isRoot;
+          }
+          _();
+          var P = t.call(p, p.node);
+          return P !== void 0 && p.update && p.update(P), h.before && h.before.call(p, p.node), g && (typeof p.node != "object" || p.node === null || p.circular || (o.push(p), _(), tt(p.keys, function(b, w) {
+            r.push(b), h.pre && h.pre.call(p, p.node[b], b);
+            var c = a(p.node[b]);
+            n && nt.call(p.node, b) && (p.node[b] = c.node), c.isLast = w == p.keys.length - 1, c.isFirst = w == 0, h.post && h.post.call(p, c), r.pop();
+          }), o.pop()), h.after && h.after.call(p, p.node)), p;
+        }(e).node;
+      }
+      function fn(e) {
+        if (typeof e == "object" && e !== null) {
+          var t;
+          if (hn(e)) t = [];
+          else if (Ne(e) === "[object Date]") t = new Date(e.getTime ? e.getTime() : e);
+          else if (function(o) {
+            return Ne(o) === "[object RegExp]";
+          }(e)) t = new RegExp(e);
+          else if (function(o) {
+            return Ne(o) === "[object Error]";
+          }(e)) t = { message: e.message };
+          else if (function(o) {
+            return Ne(o) === "[object Boolean]";
+          }(e)) t = new Boolean(e);
+          else if (function(o) {
+            return Ne(o) === "[object Number]";
+          }(e)) t = new Number(e);
+          else if (function(o) {
+            return Ne(o) === "[object String]";
+          }(e)) t = new String(e);
+          else if (Object.create && Object.getPrototypeOf) t = Object.create(Object.getPrototypeOf(e));
+          else if (e.constructor === Object) t = {};
+          else {
+            var n = e.constructor && e.constructor.prototype || e.__proto__ || {}, r = function() {
+            };
+            r.prototype = n, t = new r();
+          }
+          return tt(et(e), function(o) {
+            t[o] = e[o];
+          }), t;
+        }
+        return e;
+      }
+      K.prototype.get = function(e) {
+        for (var t = this.value, n = 0; n < e.length; n++) {
+          var r = e[n];
+          if (!t || !nt.call(t, r)) {
+            t = void 0;
+            break;
+          }
+          t = t[r];
+        }
+        return t;
+      }, K.prototype.has = function(e) {
+        for (var t = this.value, n = 0; n < e.length; n++) {
+          var r = e[n];
+          if (!t || !nt.call(t, r)) return !1;
+          t = t[r];
+        }
+        return !0;
+      }, K.prototype.set = function(e, t) {
+        for (var n = this.value, r = 0; r < e.length - 1; r++) {
+          var o = e[r];
+          nt.call(n, o) || (n[o] = {}), n = n[o];
+        }
+        return n[e[r]] = t, t;
+      }, K.prototype.map = function(e) {
+        return pn(this.value, e, !0);
+      }, K.prototype.forEach = function(e) {
+        return this.value = pn(this.value, e, !1), this.value;
+      }, K.prototype.reduce = function(e, t) {
+        var n = arguments.length === 1, r = n ? this.value : t;
+        return this.forEach(function(o) {
+          this.isRoot && n || (r = e.call(this, r, o));
+        }), r;
+      }, K.prototype.paths = function() {
+        var e = [];
+        return this.forEach(function(t) {
+          e.push(this.path);
+        }), e;
+      }, K.prototype.nodes = function() {
+        var e = [];
+        return this.forEach(function(t) {
+          e.push(this.node);
+        }), e;
+      }, K.prototype.clone = function() {
+        var e = [], t = [];
+        return function n(r) {
+          for (var o = 0; o < e.length; o++) if (e[o] === r) return t[o];
+          if (typeof r == "object" && r !== null) {
+            var i = fn(r);
+            return e.push(r), t.push(i), tt(et(r), function(a) {
+              i[a] = n(r[a]);
+            }), e.pop(), t.pop(), i;
+          }
+          return r;
+        }(this.value);
+      };
+      var et = Object.keys || function(e) {
+        var t = [];
+        for (var n in e) t.push(n);
+        return t;
+      };
+      function Ne(e) {
+        return Object.prototype.toString.call(e);
+      }
+      var hn = Array.isArray || function(e) {
+        return Object.prototype.toString.call(e) === "[object Array]";
+      }, tt = function(e, t) {
+        if (e.forEach) return e.forEach(t);
+        for (var n = 0; n < e.length; n++) t(e[n], n, e);
+      };
+      tt(et(K.prototype), function(e) {
+        br[e] = function(t) {
+          var n = [].slice.call(arguments, 1), r = new K(t);
+          return r[e].apply(r, n);
+        };
+      });
+      var nt = Object.hasOwnProperty || function(e, t) {
+        return t in e;
+      }, Er = dn.exports, Tr = J;
+      function J(e) {
+        if (!(this instanceof J)) return new J(e);
+        this._bbox = e || [1 / 0, 1 / 0, -1 / 0, -1 / 0], this._valid = !!e;
+      }
+      J.prototype.include = function(e) {
+        return this._valid = !0, this._bbox[0] = Math.min(this._bbox[0], e[0]), this._bbox[1] = Math.min(this._bbox[1], e[1]), this._bbox[2] = Math.max(this._bbox[2], e[0]), this._bbox[3] = Math.max(this._bbox[3], e[1]), this;
+      }, J.prototype.equals = function(e) {
+        var t;
+        return t = e instanceof J ? e.bbox() : e, this._bbox[0] == t[0] && this._bbox[1] == t[1] && this._bbox[2] == t[2] && this._bbox[3] == t[3];
+      }, J.prototype.center = function(e) {
+        return this._valid ? [(this._bbox[0] + this._bbox[2]) / 2, (this._bbox[1] + this._bbox[3]) / 2] : null;
+      }, J.prototype.union = function(e) {
+        var t;
+        return this._valid = !0, t = e instanceof J ? e.bbox() : e, this._bbox[0] = Math.min(this._bbox[0], t[0]), this._bbox[1] = Math.min(this._bbox[1], t[1]), this._bbox[2] = Math.max(this._bbox[2], t[2]), this._bbox[3] = Math.max(this._bbox[3], t[3]), this;
+      }, J.prototype.bbox = function() {
+        return this._valid ? this._bbox : null;
+      }, J.prototype.contains = function(e) {
+        if (!e) return this._fastContains();
+        if (!this._valid) return null;
+        var t = e[0], n = e[1];
+        return this._bbox[0] <= t && this._bbox[1] <= n && this._bbox[2] >= t && this._bbox[3] >= n;
+      }, J.prototype.intersect = function(e) {
+        return this._valid ? (t = e instanceof J ? e.bbox() : e, !(this._bbox[0] > t[2] || this._bbox[2] < t[0] || this._bbox[3] < t[1] || this._bbox[1] > t[3])) : null;
+        var t;
+      }, J.prototype._fastContains = function() {
+        if (!this._valid) return new Function("return null;");
+        var e = "return " + this._bbox[0] + "<= ll[0] &&" + this._bbox[1] + "<= ll[1] &&" + this._bbox[2] + ">= ll[0] &&" + this._bbox[3] + ">= ll[1]";
+        return new Function("ll", e);
+      }, J.prototype.polygon = function() {
+        return this._valid ? { type: "Polygon", coordinates: [[[this._bbox[0], this._bbox[1]], [this._bbox[2], this._bbox[1]], [this._bbox[2], this._bbox[3]], [this._bbox[0], this._bbox[3]], [this._bbox[0], this._bbox[1]]]] } : null;
+      };
+      var Cr = function(e) {
+        if (!e) return [];
+        var t = Qe(mr(e)), n = [];
+        return t.features.forEach(function(r) {
+          r.geometry && (n = n.concat(_r(r.geometry.coordinates)));
+        }), n;
+      }, Or = Er, Sr = Tr, gn = { features: ["FeatureCollection"], coordinates: ["Point", "MultiPoint", "LineString", "MultiLineString", "Polygon", "MultiPolygon"], geometry: ["Feature"], geometries: ["GeometryCollection"] }, Ir = Object.keys(gn);
+      function Rt(e) {
+        for (var t = Sr(), n = Cr(e), r = 0; r < n.length; r++) t.include(n[r]);
+        return t;
+      }
+      Ke.exports = function(e) {
+        return Rt(e).bbox();
+      }, Ke.exports.polygon = function(e) {
+        return Rt(e).polygon();
+      }, Ke.exports.bboxify = function(e) {
+        return Or(e).map(function(t) {
+          t && Ir.some(function(n) {
+            return !!t[n] && gn[n].indexOf(t.type) !== -1;
+          }) && (t.bbox = Rt(t).bbox(), this.update(t));
+        });
+      };
+      var xr = de(Ke.exports), rt = -90;
+      function Dt(e, t) {
+        var n = rt, r = 90, o = rt, i = 90, a = 270, l = -270;
+        e.forEach(function(h) {
+          var g = xr(h), p = g[1], _ = g[3], P = g[0], b = g[2];
+          p > n && (n = p), _ < r && (r = _), _ > o && (o = _), p < i && (i = p), P < a && (a = P), b > l && (l = b);
+        });
+        var d = t;
+        return n + d.lat > 85 && (d.lat = 85 - n), o + d.lat > 90 && (d.lat = 90 - o), r + d.lat < -85 && (d.lat = -85 - r), i + d.lat < rt && (d.lat = rt - i), a + d.lng <= -270 && (d.lng += 360 * Math.ceil(Math.abs(d.lng) / 360)), l + d.lng >= 270 && (d.lng -= 360 * Math.ceil(Math.abs(d.lng) / 360)), d;
+      }
+      function kt(e, t) {
+        var n = Dt(e.map(function(r) {
+          return r.toGeoJSON();
+        }), t);
+        e.forEach(function(r) {
+          var o, i = r.getCoordinates(), a = function(d) {
+            var h = { lng: d[0] + n.lng, lat: d[1] + n.lat };
+            return [h.lng, h.lat];
+          }, l = function(d) {
+            return d.map(function(h) {
+              return a(h);
+            });
+          };
+          r.type === m.POINT ? o = a(i) : r.type === m.LINE_STRING || r.type === m.MULTI_POINT ? o = i.map(a) : r.type === m.POLYGON || r.type === m.MULTI_LINE_STRING ? o = i.map(l) : r.type === m.MULTI_POLYGON && (o = i.map(function(d) {
+            return d.map(function(h) {
+              return l(h);
+            });
+          })), r.incomingCoords(o);
+        });
+      }
+      var D = { onSetup: function(e) {
+        var t = this, n = { dragMoveLocation: null, boxSelectStartLocation: null, boxSelectElement: void 0, boxSelecting: !1, canBoxSelect: !1, dragMoving: !1, canDragMove: !1, initiallySelectedFeatureIds: e.featureIds || [] };
+        return this.setSelected(n.initiallySelectedFeatureIds.filter(function(r) {
+          return t.getFeature(r) !== void 0;
+        })), this.fireActionable(), this.setActionableState({ combineFeatures: !0, uncombineFeatures: !0, trash: !0 }), n;
+      }, fireUpdate: function() {
+        this.map.fire(H.UPDATE, { action: St.MOVE, features: this.getSelected().map(function(e) {
+          return e.toGeoJSON();
+        }) });
+      }, fireActionable: function() {
+        var e = this, t = this.getSelected(), n = t.filter(function(l) {
+          return e.isInstanceOf("MultiFeature", l);
+        }), r = !1;
+        if (t.length > 1) {
+          r = !0;
+          var o = t[0].type.replace("Multi", "");
+          t.forEach(function(l) {
+            l.type.replace("Multi", "") !== o && (r = !1);
+          });
+        }
+        var i = n.length > 0, a = t.length > 0;
+        this.setActionableState({ combineFeatures: r, uncombineFeatures: i, trash: a });
+      }, getUniqueIds: function(e) {
+        return e.length ? e.map(function(t) {
+          return t.properties.id;
+        }).filter(function(t) {
+          return t !== void 0;
+        }).reduce(function(t, n) {
+          return t.add(n), t;
+        }, new Z()).values() : [];
+      }, stopExtendedInteractions: function(e) {
+        e.boxSelectElement && (e.boxSelectElement.parentNode && e.boxSelectElement.parentNode.removeChild(e.boxSelectElement), e.boxSelectElement = null), this.map.dragPan.enable(), e.boxSelecting = !1, e.canBoxSelect = !1, e.dragMoving = !1, e.canDragMove = !1;
+      }, onStop: function() {
+        ee.enable(this);
+      }, onMouseMove: function(e, t) {
+        return wt(t) && e.dragMoving && this.fireUpdate(), this.stopExtendedInteractions(e), !0;
+      }, onMouseOut: function(e) {
+        return !e.dragMoving || this.fireUpdate();
+      } };
+      D.onTap = D.onClick = function(e, t) {
+        return qe(t) ? this.clickAnywhere(e, t) : $e(B.VERTEX)(t) ? this.clickOnVertex(e, t) : wt(t) ? this.clickOnFeature(e, t) : void 0;
+      }, D.clickAnywhere = function(e) {
+        var t = this, n = this.getSelectedIds();
+        n.length && (this.clearSelectedFeatures(), n.forEach(function(r) {
+          return t.doRender(r);
+        })), ee.enable(this), this.stopExtendedInteractions(e);
+      }, D.clickOnVertex = function(e, t) {
+        this.changeMode(T.DIRECT_SELECT, { featureId: t.featureTarget.properties.parent, coordPath: t.featureTarget.properties.coord_path, startPos: t.lngLat }), this.updateUIClasses({ mouse: N.MOVE });
+      }, D.startOnActiveFeature = function(e, t) {
+        this.stopExtendedInteractions(e), this.map.dragPan.disable(), this.doRender(t.featureTarget.properties.id), e.canDragMove = !0, e.dragMoveLocation = t.lngLat;
+      }, D.clickOnFeature = function(e, t) {
+        var n = this;
+        ee.disable(this), this.stopExtendedInteractions(e);
+        var r = He(t), o = this.getSelectedIds(), i = t.featureTarget.properties.id, a = this.isSelected(i);
+        if (!r && a && this.getFeature(i).type !== m.POINT) return this.changeMode(T.DIRECT_SELECT, { featureId: i });
+        a && r ? (this.deselect(i), this.updateUIClasses({ mouse: N.POINTER }), o.length === 1 && ee.enable(this)) : !a && r ? (this.select(i), this.updateUIClasses({ mouse: N.MOVE })) : a || r || (o.forEach(function(l) {
+          return n.doRender(l);
+        }), this.setSelected(i), this.updateUIClasses({ mouse: N.MOVE })), this.doRender(i);
+      }, D.onMouseDown = function(e, t) {
+        return _e(t) ? this.startOnActiveFeature(e, t) : this.drawConfig.boxSelect && un(t) ? this.startBoxSelect(e, t) : void 0;
+      }, D.startBoxSelect = function(e, t) {
+        this.stopExtendedInteractions(e), this.map.dragPan.disable(), e.boxSelectStartLocation = Ft(t.originalEvent, this.map.getContainer()), e.canBoxSelect = !0;
+      }, D.onTouchStart = function(e, t) {
+        if (_e(t)) return this.startOnActiveFeature(e, t);
+      }, D.onDrag = function(e, t) {
+        return e.canDragMove ? this.dragMove(e, t) : this.drawConfig.boxSelect && e.canBoxSelect ? this.whileBoxSelect(e, t) : void 0;
+      }, D.whileBoxSelect = function(e, t) {
+        e.boxSelecting = !0, this.updateUIClasses({ mouse: N.ADD }), e.boxSelectElement || (e.boxSelectElement = document.createElement("div"), e.boxSelectElement.classList.add(q.BOX_SELECT), this.map.getContainer().appendChild(e.boxSelectElement));
+        var n = Ft(t.originalEvent, this.map.getContainer()), r = Math.min(e.boxSelectStartLocation.x, n.x), o = Math.max(e.boxSelectStartLocation.x, n.x), i = Math.min(e.boxSelectStartLocation.y, n.y), a = Math.max(e.boxSelectStartLocation.y, n.y), l = "translate(" + r + "px, " + i + "px)";
+        e.boxSelectElement.style.transform = l, e.boxSelectElement.style.WebkitTransform = l, e.boxSelectElement.style.width = o - r + "px", e.boxSelectElement.style.height = a - i + "px";
+      }, D.dragMove = function(e, t) {
+        e.dragMoving = !0, t.originalEvent.stopPropagation();
+        var n = { lng: t.lngLat.lng - e.dragMoveLocation.lng, lat: t.lngLat.lat - e.dragMoveLocation.lat };
+        kt(this.getSelected(), n), e.dragMoveLocation = t.lngLat;
+      }, D.onTouchEnd = D.onMouseUp = function(e, t) {
+        var n = this;
+        if (e.dragMoving) this.fireUpdate();
+        else if (e.boxSelecting) {
+          var r = [e.boxSelectStartLocation, Ft(t.originalEvent, this.map.getContainer())], o = this.featuresAt(null, r, "click"), i = this.getUniqueIds(o).filter(function(a) {
+            return !n.isSelected(a);
+          });
+          i.length && (this.select(i), i.forEach(function(a) {
+            return n.doRender(a);
+          }), this.updateUIClasses({ mouse: N.MOVE }));
+        }
+        this.stopExtendedInteractions(e);
+      }, D.toDisplayFeatures = function(e, t, n) {
+        t.properties.active = this.isSelected(t.properties.id) ? j.ACTIVE : j.INACTIVE, n(t), this.fireActionable(), t.properties.active === j.ACTIVE && t.geometry.type !== m.POINT && We(t).forEach(n);
+      }, D.onTrash = function() {
+        this.deleteFeature(this.getSelectedIds()), this.fireActionable();
+      }, D.onCombineFeatures = function() {
+        var e = this.getSelected();
+        if (!(e.length === 0 || e.length < 2)) {
+          for (var t = [], n = [], r = e[0].type.replace("Multi", ""), o = 0; o < e.length; o++) {
+            var i = e[o];
+            if (i.type.replace("Multi", "") !== r) return;
+            i.type.includes("Multi") ? i.getCoordinates().forEach(function(l) {
+              t.push(l);
+            }) : t.push(i.getCoordinates()), n.push(i.toGeoJSON());
+          }
+          if (n.length > 1) {
+            var a = this.newFeature({ type: m.FEATURE, properties: n[0].properties, geometry: { type: "Multi" + r, coordinates: t } });
+            this.addFeature(a), this.deleteFeature(this.getSelectedIds(), { silent: !0 }), this.setSelected([a.id]), this.map.fire(H.COMBINE_FEATURES, { createdFeatures: [a.toGeoJSON()], deletedFeatures: n });
+          }
+          this.fireActionable();
+        }
+      }, D.onUncombineFeatures = function() {
+        var e = this, t = this.getSelected();
+        if (t.length !== 0) {
+          for (var n = [], r = [], o = function(a) {
+            var l = t[a];
+            e.isInstanceOf("MultiFeature", l) && (l.getFeatures().forEach(function(d) {
+              e.addFeature(d), d.properties = l.properties, n.push(d.toGeoJSON()), e.select([d.id]);
+            }), e.deleteFeature(l.id, { silent: !0 }), r.push(l.toGeoJSON()));
+          }, i = 0; i < t.length; i++) o(i);
+          n.length > 1 && this.map.fire(H.UNCOMBINE_FEATURES, { createdFeatures: n, deletedFeatures: r }), this.fireActionable();
+        }
+      };
+      var yn = $e(B.VERTEX), vn = $e(B.MIDPOINT), fe = { fireUpdate: function() {
+        this.map.fire(H.UPDATE, { action: St.CHANGE_COORDINATES, features: this.getSelected().map(function(e) {
+          return e.toGeoJSON();
+        }) });
+      }, fireActionable: function(e) {
+        this.setActionableState({ combineFeatures: !1, uncombineFeatures: !1, trash: e.selectedCoordPaths.length > 0 });
+      }, startDragging: function(e, t) {
+        this.map.dragPan.disable(), e.canDragMove = !0, e.dragMoveLocation = t.lngLat;
+      }, stopDragging: function(e) {
+        this.map.dragPan.enable(), e.dragMoving = !1, e.canDragMove = !1, e.dragMoveLocation = null;
+      }, onVertex: function(e, t) {
+        this.startDragging(e, t);
+        var n = t.featureTarget.properties, r = e.selectedCoordPaths.indexOf(n.coord_path);
+        He(t) || r !== -1 ? He(t) && r === -1 && e.selectedCoordPaths.push(n.coord_path) : e.selectedCoordPaths = [n.coord_path];
+        var o = this.pathsToCoordinates(e.featureId, e.selectedCoordPaths);
+        this.setSelectedCoordinates(o);
+      }, onMidpoint: function(e, t) {
+        this.startDragging(e, t);
+        var n = t.featureTarget.properties;
+        e.feature.addCoordinate(n.coord_path, n.lng, n.lat), this.fireUpdate(), e.selectedCoordPaths = [n.coord_path];
+      }, pathsToCoordinates: function(e, t) {
+        return t.map(function(n) {
+          return { feature_id: e, coord_path: n };
+        });
+      }, onFeature: function(e, t) {
+        e.selectedCoordPaths.length === 0 ? this.startDragging(e, t) : this.stopDragging(e);
+      }, dragFeature: function(e, t, n) {
+        kt(this.getSelected(), n), e.dragMoveLocation = t.lngLat;
+      }, dragVertex: function(e, t, n) {
+        for (var r = e.selectedCoordPaths.map(function(l) {
+          return e.feature.getCoordinate(l);
+        }), o = Dt(r.map(function(l) {
+          return { type: m.FEATURE, properties: {}, geometry: { type: m.POINT, coordinates: l } };
+        }), n), i = 0; i < r.length; i++) {
+          var a = r[i];
+          e.feature.updateCoordinate(e.selectedCoordPaths[i], a[0] + o.lng, a[1] + o.lat);
+        }
+      }, clickNoTarget: function() {
+        this.changeMode(T.SIMPLE_SELECT);
+      }, clickInactive: function() {
+        this.changeMode(T.SIMPLE_SELECT);
+      }, clickActiveFeature: function(e) {
+        e.selectedCoordPaths = [], this.clearSelectedCoordinates(), e.feature.changed();
+      }, onSetup: function(e) {
+        var t = e.featureId, n = this.getFeature(t);
+        if (!n) throw new Error("You must provide a featureId to enter direct_select mode");
+        if (n.type === m.POINT) throw new TypeError("direct_select mode doesn't handle point features");
+        var r = { featureId: t, feature: n, dragMoveLocation: e.startPos || null, dragMoving: !1, canDragMove: !1, selectedCoordPaths: e.coordPath ? [e.coordPath] : [] };
+        return this.setSelectedCoordinates(this.pathsToCoordinates(t, r.selectedCoordPaths)), this.setSelected(t), ee.disable(this), this.setActionableState({ trash: !0 }), r;
+      }, onStop: function() {
+        ee.enable(this), this.clearSelectedCoordinates();
+      }, toDisplayFeatures: function(e, t, n) {
+        e.featureId === t.properties.id ? (t.properties.active = j.ACTIVE, n(t), We(t, { map: this.map, midpoints: !0, selectedPaths: e.selectedCoordPaths }).forEach(n)) : (t.properties.active = j.INACTIVE, n(t)), this.fireActionable(e);
+      }, onTrash: function(e) {
+        e.selectedCoordPaths.sort(function(t, n) {
+          return n.localeCompare(t, "en", { numeric: !0 });
+        }).forEach(function(t) {
+          return e.feature.removeCoordinate(t);
+        }), this.fireUpdate(), e.selectedCoordPaths = [], this.clearSelectedCoordinates(), this.fireActionable(e), e.feature.isValid() === !1 && (this.deleteFeature([e.featureId]), this.changeMode(T.SIMPLE_SELECT, {}));
+      }, onMouseMove: function(e, t) {
+        var n = _e(t), r = yn(t), o = vn(t), i = e.selectedCoordPaths.length === 0;
+        return n && i || r && !i ? this.updateUIClasses({ mouse: N.MOVE }) : this.updateUIClasses({ mouse: N.NONE }), (r || n || o) && e.dragMoving && this.fireUpdate(), this.stopDragging(e), !0;
+      }, onMouseOut: function(e) {
+        return e.dragMoving && this.fireUpdate(), !0;
+      } };
+      fe.onTouchStart = fe.onMouseDown = function(e, t) {
+        return yn(t) ? this.onVertex(e, t) : _e(t) ? this.onFeature(e, t) : vn(t) ? this.onMidpoint(e, t) : void 0;
+      }, fe.onDrag = function(e, t) {
+        if (e.canDragMove === !0) {
+          e.dragMoving = !0, t.originalEvent.stopPropagation();
+          var n = { lng: t.lngLat.lng - e.dragMoveLocation.lng, lat: t.lngLat.lat - e.dragMoveLocation.lat };
+          e.selectedCoordPaths.length > 0 ? this.dragVertex(e, t, n) : this.dragFeature(e, t, n), e.dragMoveLocation = t.lngLat;
+        }
+      }, fe.onClick = function(e, t) {
+        return qe(t) ? this.clickNoTarget(e, t) : _e(t) ? this.clickActiveFeature(e, t) : At(t) ? this.clickInactive(e, t) : void this.stopDragging(e);
+      }, fe.onTap = function(e, t) {
+        return qe(t) ? this.clickNoTarget(e, t) : _e(t) ? this.clickActiveFeature(e, t) : At(t) ? this.clickInactive(e, t) : void 0;
+      }, fe.onTouchEnd = fe.onMouseUp = function(e) {
+        e.dragMoving && this.fireUpdate(), this.stopDragging(e);
+      };
+      var ne = {};
+      function ot(e, t) {
+        return !!e.lngLat && e.lngLat.lng === t[0] && e.lngLat.lat === t[1];
+      }
+      ne.onSetup = function() {
+        var e = this.newFeature({ type: m.FEATURE, properties: {}, geometry: { type: m.POINT, coordinates: [] } });
+        return this.addFeature(e), this.clearSelectedFeatures(), this.updateUIClasses({ mouse: N.ADD }), this.activateUIButton(Y.POINT), this.setActionableState({ trash: !0 }), { point: e };
+      }, ne.stopDrawingAndRemove = function(e) {
+        this.deleteFeature([e.point.id], { silent: !0 }), this.changeMode(T.SIMPLE_SELECT);
+      }, ne.onTap = ne.onClick = function(e, t) {
+        this.updateUIClasses({ mouse: N.MOVE }), e.point.updateCoordinate("", t.lngLat.lng, t.lngLat.lat), this.map.fire(H.CREATE, { features: [e.point.toGeoJSON()] }), this.changeMode(T.SIMPLE_SELECT, { featureIds: [e.point.id] });
+      }, ne.onStop = function(e) {
+        this.activateUIButton(), e.point.getCoordinate().length || this.deleteFeature([e.point.id], { silent: !0 });
+      }, ne.toDisplayFeatures = function(e, t, n) {
+        var r = t.properties.id === e.point.id;
+        if (t.properties.active = r ? j.ACTIVE : j.INACTIVE, !r) return n(t);
+      }, ne.onTrash = ne.stopDrawingAndRemove, ne.onKeyUp = function(e, t) {
+        if (Xe(t) || Ze(t)) return this.stopDrawingAndRemove(e, t);
+      };
+      var be = { onSetup: function() {
+        var e = this.newFeature({ type: m.FEATURE, properties: {}, geometry: { type: m.POLYGON, coordinates: [[]] } });
+        return this.addFeature(e), this.clearSelectedFeatures(), ee.disable(this), this.updateUIClasses({ mouse: N.ADD }), this.activateUIButton(Y.POLYGON), this.setActionableState({ trash: !0 }), { polygon: e, currentVertexPosition: 0 };
+      }, clickAnywhere: function(e, t) {
+        if (e.currentVertexPosition > 0 && ot(t, e.polygon.coordinates[0][e.currentVertexPosition - 1])) return this.changeMode(T.SIMPLE_SELECT, { featureIds: [e.polygon.id] });
+        this.updateUIClasses({ mouse: N.ADD }), e.polygon.updateCoordinate("0." + e.currentVertexPosition, t.lngLat.lng, t.lngLat.lat), e.currentVertexPosition++, e.polygon.updateCoordinate("0." + e.currentVertexPosition, t.lngLat.lng, t.lngLat.lat);
+      }, clickOnVertex: function(e) {
+        return this.changeMode(T.SIMPLE_SELECT, { featureIds: [e.polygon.id] });
+      }, onMouseMove: function(e, t) {
+        e.polygon.updateCoordinate("0." + e.currentVertexPosition, t.lngLat.lng, t.lngLat.lat), De(t) && this.updateUIClasses({ mouse: N.POINTER });
+      } };
+      be.onTap = be.onClick = function(e, t) {
+        return De(t) ? this.clickOnVertex(e, t) : this.clickAnywhere(e, t);
+      }, be.onKeyUp = function(e, t) {
+        Xe(t) ? (this.deleteFeature([e.polygon.id], { silent: !0 }), this.changeMode(T.SIMPLE_SELECT)) : Ze(t) && this.changeMode(T.SIMPLE_SELECT, { featureIds: [e.polygon.id] });
+      }, be.onStop = function(e) {
+        this.updateUIClasses({ mouse: N.NONE }), ee.enable(this), this.activateUIButton(), this.getFeature(e.polygon.id) !== void 0 && (e.polygon.removeCoordinate("0." + e.currentVertexPosition), e.polygon.isValid() ? this.map.fire(H.CREATE, { features: [e.polygon.toGeoJSON()] }) : (this.deleteFeature([e.polygon.id], { silent: !0 }), this.changeMode(T.SIMPLE_SELECT, {}, { silent: !0 })));
+      }, be.toDisplayFeatures = function(e, t, n) {
+        var r = t.properties.id === e.polygon.id;
+        if (t.properties.active = r ? j.ACTIVE : j.INACTIVE, !r) return n(t);
+        if (t.geometry.coordinates.length !== 0) {
+          var o = t.geometry.coordinates[0].length;
+          if (!(o < 3)) {
+            if (t.properties.meta = B.FEATURE, n(Le(e.polygon.id, t.geometry.coordinates[0][0], "0.0", !1)), o > 3) {
+              var i = t.geometry.coordinates[0].length - 3;
+              n(Le(e.polygon.id, t.geometry.coordinates[0][i], "0." + i, !1));
+            }
+            if (o <= 4) {
+              var a = [[t.geometry.coordinates[0][0][0], t.geometry.coordinates[0][0][1]], [t.geometry.coordinates[0][1][0], t.geometry.coordinates[0][1][1]]];
+              if (n({ type: m.FEATURE, properties: t.properties, geometry: { coordinates: a, type: m.LINE_STRING } }), o === 3) return;
+            }
+            return n(t);
+          }
+        }
+      }, be.onTrash = function(e) {
+        this.deleteFeature([e.polygon.id], { silent: !0 }), this.changeMode(T.SIMPLE_SELECT);
+      };
+      var Ee = { onSetup: function(e) {
+        var t, n, r = (e = e || {}).featureId, o = "forward";
+        if (r) {
+          if (!(t = this.getFeature(r))) throw new Error("Could not find a feature with the provided featureId");
+          var i = e.from;
+          if (i && i.type === "Feature" && i.geometry && i.geometry.type === "Point" && (i = i.geometry), i && i.type === "Point" && i.coordinates && i.coordinates.length === 2 && (i = i.coordinates), !i || !Array.isArray(i)) throw new Error("Please use the `from` property to indicate which point to continue the line from");
+          var a = t.coordinates.length - 1;
+          if (t.coordinates[a][0] === i[0] && t.coordinates[a][1] === i[1]) n = a + 1, t.addCoordinate.apply(t, [n].concat(t.coordinates[a]));
+          else {
+            if (t.coordinates[0][0] !== i[0] || t.coordinates[0][1] !== i[1]) throw new Error("`from` should match the point at either the start or the end of the provided LineString");
+            o = "backwards", n = 0, t.addCoordinate.apply(t, [n].concat(t.coordinates[0]));
+          }
+        } else t = this.newFeature({ type: m.FEATURE, properties: {}, geometry: { type: m.LINE_STRING, coordinates: [] } }), n = 0, this.addFeature(t);
+        return this.clearSelectedFeatures(), ee.disable(this), this.updateUIClasses({ mouse: N.ADD }), this.activateUIButton(Y.LINE), this.setActionableState({ trash: !0 }), { line: t, currentVertexPosition: n, direction: o };
+      }, clickAnywhere: function(e, t) {
+        if (e.currentVertexPosition > 0 && ot(t, e.line.coordinates[e.currentVertexPosition - 1]) || e.direction === "backwards" && ot(t, e.line.coordinates[e.currentVertexPosition + 1])) return this.changeMode(T.SIMPLE_SELECT, { featureIds: [e.line.id] });
+        this.updateUIClasses({ mouse: N.ADD }), e.line.updateCoordinate(e.currentVertexPosition, t.lngLat.lng, t.lngLat.lat), e.direction === "forward" ? (e.currentVertexPosition++, e.line.updateCoordinate(e.currentVertexPosition, t.lngLat.lng, t.lngLat.lat)) : e.line.addCoordinate(0, t.lngLat.lng, t.lngLat.lat);
+      }, clickOnVertex: function(e) {
+        return this.changeMode(T.SIMPLE_SELECT, { featureIds: [e.line.id] });
+      }, onMouseMove: function(e, t) {
+        e.line.updateCoordinate(e.currentVertexPosition, t.lngLat.lng, t.lngLat.lat), De(t) && this.updateUIClasses({ mouse: N.POINTER });
+      } };
+      Ee.onTap = Ee.onClick = function(e, t) {
+        if (De(t)) return this.clickOnVertex(e, t);
+        this.clickAnywhere(e, t);
+      }, Ee.onKeyUp = function(e, t) {
+        Ze(t) ? this.changeMode(T.SIMPLE_SELECT, { featureIds: [e.line.id] }) : Xe(t) && (this.deleteFeature([e.line.id], { silent: !0 }), this.changeMode(T.SIMPLE_SELECT));
+      }, Ee.onStop = function(e) {
+        ee.enable(this), this.activateUIButton(), this.getFeature(e.line.id) !== void 0 && (e.line.removeCoordinate("" + e.currentVertexPosition), e.line.isValid() ? this.map.fire(H.CREATE, { features: [e.line.toGeoJSON()] }) : (this.deleteFeature([e.line.id], { silent: !0 }), this.changeMode(T.SIMPLE_SELECT, {}, { silent: !0 })));
+      }, Ee.onTrash = function(e) {
+        this.deleteFeature([e.line.id], { silent: !0 }), this.changeMode(T.SIMPLE_SELECT);
+      }, Ee.toDisplayFeatures = function(e, t, n) {
+        var r = t.properties.id === e.line.id;
+        if (t.properties.active = r ? j.ACTIVE : j.INACTIVE, !r) return n(t);
+        t.geometry.coordinates.length < 2 || (t.properties.meta = B.FEATURE, n(Le(e.line.id, t.geometry.coordinates[e.direction === "forward" ? t.geometry.coordinates.length - 2 : 1], "" + (e.direction === "forward" ? t.geometry.coordinates.length - 2 : 1), !1)), n(t));
+      };
+      var mn = { simple_select: D, direct_select: fe, draw_point: ne, draw_polygon: be, draw_line_string: Ee }, Mr = { defaultMode: T.SIMPLE_SELECT, keybindings: !0, touchEnabled: !0, clickBuffer: 2, touchBuffer: 25, boxSelect: !0, displayControlsDefault: !0, styles: sn, modes: mn, controls: {}, userProperties: !1 }, Lr = { point: !0, line_string: !0, polygon: !0, trash: !0, combine_features: !0, uncombine_features: !0 }, Nr = { point: !1, line_string: !1, polygon: !1, trash: !1, combine_features: !1, uncombine_features: !1 };
+      function _n(e, t) {
+        return e.map(function(n) {
+          return n.source ? n : pe(n, { id: n.id + "." + t, source: t === "hot" ? X.HOT : X.COLD });
+        });
+      }
+      var Ut = { exports: {} };
+      (function(e, t) {
+        var n = "__lodash_hash_undefined__", r = 9007199254740991, o = "[object Arguments]", i = "[object Array]", a = "[object Boolean]", l = "[object Date]", d = "[object Error]", h = "[object Function]", g = "[object Map]", p = "[object Number]", _ = "[object Object]", P = "[object Promise]", b = "[object RegExp]", w = "[object Set]", c = "[object String]", y = "[object Symbol]", O = "[object WeakMap]", V = "[object ArrayBuffer]", F = "[object DataView]", jt = /^\[object .+?Constructor\]$/, Fr = /^(?:0|[1-9]\d*)$/, M = {};
+        M["[object Float32Array]"] = M["[object Float64Array]"] = M["[object Int8Array]"] = M["[object Int16Array]"] = M["[object Int32Array]"] = M["[object Uint8Array]"] = M["[object Uint8ClampedArray]"] = M["[object Uint16Array]"] = M["[object Uint32Array]"] = !0, M[o] = M[i] = M[V] = M[a] = M[F] = M[l] = M[d] = M[h] = M[g] = M[p] = M[_] = M[b] = M[w] = M[c] = M[O] = !1;
+        var Tn = typeof bt == "object" && bt && bt.Object === Object && bt, Rr = typeof self == "object" && self && self.Object === Object && self, ae = Tn || Rr || Function("return this")(), Cn = t && !t.nodeType && t, On = Cn && e && !e.nodeType && e, Sn = On && On.exports === Cn, Vt = Sn && Tn.process, In = function() {
+          try {
+            return Vt && Vt.binding && Vt.binding("util");
+          } catch {
+          }
+        }(), xn = In && In.isTypedArray;
+        function Dr(s, u) {
+          for (var f = -1, v = s == null ? 0 : s.length; ++f < v; ) if (u(s[f], f, s)) return !0;
+          return !1;
+        }
+        function kr(s) {
+          var u = -1, f = Array(s.size);
+          return s.forEach(function(v, L) {
+            f[++u] = [L, v];
+          }), f;
+        }
+        function Ur(s) {
+          var u = -1, f = Array(s.size);
+          return s.forEach(function(v) {
+            f[++u] = v;
+          }), f;
+        }
+        var Mn, Ln, Nn, jr = Array.prototype, Vr = Function.prototype, at = Object.prototype, Bt = ae["__core-js_shared__"], Pn = Vr.toString, re = at.hasOwnProperty, An = (Mn = /[^.]+$/.exec(Bt && Bt.keys && Bt.keys.IE_PROTO || "")) ? "Symbol(src)_1." + Mn : "", wn = at.toString, Br = RegExp("^" + Pn.call(re).replace(/[\\^$.*+?()[\]{}|]/g, "\\$&").replace(/hasOwnProperty|(function).*?(?=\\\()| for .+?(?=\\\])/g, "$1.*?") + "$"), Fn = Sn ? ae.Buffer : void 0, st = ae.Symbol, Rn = ae.Uint8Array, Dn = at.propertyIsEnumerable, Gr = jr.splice, Te = st ? st.toStringTag : void 0, kn = Object.getOwnPropertySymbols, Jr = Fn ? Fn.isBuffer : void 0, zr = (Ln = Object.keys, Nn = Object, function(s) {
+          return Ln(Nn(s));
+        }), Gt = Pe(ae, "DataView"), ke = Pe(ae, "Map"), Jt = Pe(ae, "Promise"), zt = Pe(ae, "Set"), Yt = Pe(ae, "WeakMap"), Ue = Pe(Object, "create"), Yr = Se(Gt), $r = Se(ke), qr = Se(Jt), Hr = Se(zt), Xr = Se(Yt), Un = st ? st.prototype : void 0, $t = Un ? Un.valueOf : void 0;
+        function Ce(s) {
+          var u = -1, f = s == null ? 0 : s.length;
+          for (this.clear(); ++u < f; ) {
+            var v = s[u];
+            this.set(v[0], v[1]);
+          }
+        }
+        function se(s) {
+          var u = -1, f = s == null ? 0 : s.length;
+          for (this.clear(); ++u < f; ) {
+            var v = s[u];
+            this.set(v[0], v[1]);
+          }
+        }
+        function Oe(s) {
+          var u = -1, f = s == null ? 0 : s.length;
+          for (this.clear(); ++u < f; ) {
+            var v = s[u];
+            this.set(v[0], v[1]);
+          }
+        }
+        function ut(s) {
+          var u = -1, f = s == null ? 0 : s.length;
+          for (this.__data__ = new Oe(); ++u < f; ) this.add(s[u]);
+        }
+        function he(s) {
+          var u = this.__data__ = new se(s);
+          this.size = u.size;
+        }
+        function Zr(s, u) {
+          var f = dt(s), v = !f && to(s), L = !f && !v && qt(s), C = !f && !v && !L && qn(s), A = f || v || L || C, R = A ? function(U, oe) {
+            for (var ue = -1, z = Array(U); ++ue < U; ) z[ue] = oe(ue);
+            return z;
+          }(s.length, String) : [], te = R.length;
+          for (var k in s) !re.call(s, k) || A && (k == "length" || L && (k == "offset" || k == "parent") || C && (k == "buffer" || k == "byteLength" || k == "byteOffset") || eo(k, te)) || R.push(k);
+          return R;
+        }
+        function ct(s, u) {
+          for (var f = s.length; f--; ) if (Jn(s[f][0], u)) return f;
+          return -1;
+        }
+        function je(s) {
+          return s == null ? s === void 0 ? "[object Undefined]" : "[object Null]" : Te && Te in Object(s) ? function(u) {
+            var f = re.call(u, Te), v = u[Te];
+            try {
+              u[Te] = void 0;
+              var L = !0;
+            } catch {
+            }
+            var C = wn.call(u);
+            return L && (f ? u[Te] = v : delete u[Te]), C;
+          }(s) : function(u) {
+            return wn.call(u);
+          }(s);
+        }
+        function jn(s) {
+          return Ve(s) && je(s) == o;
+        }
+        function Vn(s, u, f, v, L) {
+          return s === u || (s == null || u == null || !Ve(s) && !Ve(u) ? s != s && u != u : function(C, A, R, te, k, U) {
+            var oe = dt(C), ue = dt(A), z = oe ? i : ge(C), ce = ue ? i : ge(A), Ae = (z = z == o ? _ : z) == _, pt = (ce = ce == o ? _ : ce) == _, we = z == ce;
+            if (we && qt(C)) {
+              if (!qt(A)) return !1;
+              oe = !0, Ae = !1;
+            }
+            if (we && !Ae) return U || (U = new he()), oe || qn(C) ? Bn(C, A, R, te, k, U) : function(I, S, ft, ye, Ht, Q, le) {
+              switch (ft) {
+                case F:
+                  if (I.byteLength != S.byteLength || I.byteOffset != S.byteOffset) return !1;
+                  I = I.buffer, S = S.buffer;
+                case V:
+                  return !(I.byteLength != S.byteLength || !Q(new Rn(I), new Rn(S)));
+                case a:
+                case l:
+                case p:
+                  return Jn(+I, +S);
+                case d:
+                  return I.name == S.name && I.message == S.message;
+                case b:
+                case c:
+                  return I == S + "";
+                case g:
+                  var ve = kr;
+                case w:
+                  var Ge = 1 & ye;
+                  if (ve || (ve = Ur), I.size != S.size && !Ge) return !1;
+                  var ht = le.get(I);
+                  if (ht) return ht == S;
+                  ye |= 2, le.set(I, S);
+                  var Fe = Bn(ve(I), ve(S), ye, Ht, Q, le);
+                  return le.delete(I), Fe;
+                case y:
+                  if ($t) return $t.call(I) == $t.call(S);
+              }
+              return !1;
+            }(C, A, z, R, te, k, U);
+            if (!(1 & R)) {
+              var Be = Ae && re.call(C, "__wrapped__"), Hn = pt && re.call(A, "__wrapped__");
+              if (Be || Hn) {
+                var ro = Be ? C.value() : C, oo = Hn ? A.value() : A;
+                return U || (U = new he()), k(ro, oo, R, te, U);
+              }
+            }
+            return we ? (U || (U = new he()), function(I, S, ft, ye, Ht, Q) {
+              var le = 1 & ft, ve = Gn(I), Ge = ve.length, ht = Gn(S).length;
+              if (Ge != ht && !le) return !1;
+              for (var Fe = Ge; Fe--; ) {
+                var Ie = ve[Fe];
+                if (!(le ? Ie in S : re.call(S, Ie))) return !1;
+              }
+              var Xn = Q.get(I);
+              if (Xn && Q.get(S)) return Xn == S;
+              var gt = !0;
+              Q.set(I, S), Q.set(S, I);
+              for (var Xt = le; ++Fe < Ge; ) {
+                var yt = I[Ie = ve[Fe]], vt = S[Ie];
+                if (ye) var Zn = le ? ye(vt, yt, Ie, S, I, Q) : ye(yt, vt, Ie, I, S, Q);
+                if (!(Zn === void 0 ? yt === vt || Ht(yt, vt, ft, ye, Q) : Zn)) {
+                  gt = !1;
+                  break;
+                }
+                Xt || (Xt = Ie == "constructor");
+              }
+              if (gt && !Xt) {
+                var mt = I.constructor, _t = S.constructor;
+                mt == _t || !("constructor" in I) || !("constructor" in S) || typeof mt == "function" && mt instanceof mt && typeof _t == "function" && _t instanceof _t || (gt = !1);
+              }
+              return Q.delete(I), Q.delete(S), gt;
+            }(C, A, R, te, k, U)) : !1;
+          }(s, u, f, v, Vn, L));
+        }
+        function Wr(s) {
+          return !(!$n(s) || function(u) {
+            return !!An && An in u;
+          }(s)) && (zn(s) ? Br : jt).test(Se(s));
+        }
+        function Kr(s) {
+          if (f = (u = s) && u.constructor, v = typeof f == "function" && f.prototype || at, u !== v) return zr(s);
+          var u, f, v, L = [];
+          for (var C in Object(s)) re.call(s, C) && C != "constructor" && L.push(C);
+          return L;
+        }
+        function Bn(s, u, f, v, L, C) {
+          var A = 1 & f, R = s.length, te = u.length;
+          if (R != te && !(A && te > R)) return !1;
+          var k = C.get(s);
+          if (k && C.get(u)) return k == u;
+          var U = -1, oe = !0, ue = 2 & f ? new ut() : void 0;
+          for (C.set(s, u), C.set(u, s); ++U < R; ) {
+            var z = s[U], ce = u[U];
+            if (v) var Ae = A ? v(ce, z, U, u, s, C) : v(z, ce, U, s, u, C);
+            if (Ae !== void 0) {
+              if (Ae) continue;
+              oe = !1;
+              break;
+            }
+            if (ue) {
+              if (!Dr(u, function(pt, we) {
+                if (Be = we, !ue.has(Be) && (z === pt || L(z, pt, f, v, C))) return ue.push(we);
+                var Be;
+              })) {
+                oe = !1;
+                break;
+              }
+            } else if (z !== ce && !L(z, ce, f, v, C)) {
+              oe = !1;
+              break;
+            }
+          }
+          return C.delete(s), C.delete(u), oe;
+        }
+        function Gn(s) {
+          return function(u, f, v) {
+            var L = f(u);
+            return dt(u) ? L : function(C, A) {
+              for (var R = -1, te = A.length, k = C.length; ++R < te; ) C[k + R] = A[R];
+              return C;
+            }(L, v(u));
+          }(s, no, Qr);
+        }
+        function lt(s, u) {
+          var f, v, L = s.__data__;
+          return ((v = typeof (f = u)) == "string" || v == "number" || v == "symbol" || v == "boolean" ? f !== "__proto__" : f === null) ? L[typeof u == "string" ? "string" : "hash"] : L.map;
+        }
+        function Pe(s, u) {
+          var f = function(v, L) {
+            return v?.[L];
+          }(s, u);
+          return Wr(f) ? f : void 0;
+        }
+        Ce.prototype.clear = function() {
+          this.__data__ = Ue ? Ue(null) : {}, this.size = 0;
+        }, Ce.prototype.delete = function(s) {
+          var u = this.has(s) && delete this.__data__[s];
+          return this.size -= u ? 1 : 0, u;
+        }, Ce.prototype.get = function(s) {
+          var u = this.__data__;
+          if (Ue) {
+            var f = u[s];
+            return f === n ? void 0 : f;
+          }
+          return re.call(u, s) ? u[s] : void 0;
+        }, Ce.prototype.has = function(s) {
+          var u = this.__data__;
+          return Ue ? u[s] !== void 0 : re.call(u, s);
+        }, Ce.prototype.set = function(s, u) {
+          var f = this.__data__;
+          return this.size += this.has(s) ? 0 : 1, f[s] = Ue && u === void 0 ? n : u, this;
+        }, se.prototype.clear = function() {
+          this.__data__ = [], this.size = 0;
+        }, se.prototype.delete = function(s) {
+          var u = this.__data__, f = ct(u, s);
+          return !(f < 0) && (f == u.length - 1 ? u.pop() : Gr.call(u, f, 1), --this.size, !0);
+        }, se.prototype.get = function(s) {
+          var u = this.__data__, f = ct(u, s);
+          return f < 0 ? void 0 : u[f][1];
+        }, se.prototype.has = function(s) {
+          return ct(this.__data__, s) > -1;
+        }, se.prototype.set = function(s, u) {
+          var f = this.__data__, v = ct(f, s);
+          return v < 0 ? (++this.size, f.push([s, u])) : f[v][1] = u, this;
+        }, Oe.prototype.clear = function() {
+          this.size = 0, this.__data__ = { hash: new Ce(), map: new (ke || se)(), string: new Ce() };
+        }, Oe.prototype.delete = function(s) {
+          var u = lt(this, s).delete(s);
+          return this.size -= u ? 1 : 0, u;
+        }, Oe.prototype.get = function(s) {
+          return lt(this, s).get(s);
+        }, Oe.prototype.has = function(s) {
+          return lt(this, s).has(s);
+        }, Oe.prototype.set = function(s, u) {
+          var f = lt(this, s), v = f.size;
+          return f.set(s, u), this.size += f.size == v ? 0 : 1, this;
+        }, ut.prototype.add = ut.prototype.push = function(s) {
+          return this.__data__.set(s, n), this;
+        }, ut.prototype.has = function(s) {
+          return this.__data__.has(s);
+        }, he.prototype.clear = function() {
+          this.__data__ = new se(), this.size = 0;
+        }, he.prototype.delete = function(s) {
+          var u = this.__data__, f = u.delete(s);
+          return this.size = u.size, f;
+        }, he.prototype.get = function(s) {
+          return this.__data__.get(s);
+        }, he.prototype.has = function(s) {
+          return this.__data__.has(s);
+        }, he.prototype.set = function(s, u) {
+          var f = this.__data__;
+          if (f instanceof se) {
+            var v = f.__data__;
+            if (!ke || v.length < 199) return v.push([s, u]), this.size = ++f.size, this;
+            f = this.__data__ = new Oe(v);
+          }
+          return f.set(s, u), this.size = f.size, this;
+        };
+        var Qr = kn ? function(s) {
+          return s == null ? [] : (s = Object(s), function(u, f) {
+            for (var v = -1, L = u == null ? 0 : u.length, C = 0, A = []; ++v < L; ) {
+              var R = u[v];
+              f(R, v, u) && (A[C++] = R);
+            }
+            return A;
+          }(kn(s), function(u) {
+            return Dn.call(s, u);
+          }));
+        } : function() {
+          return [];
+        }, ge = je;
+        function eo(s, u) {
+          return !!(u = u ?? r) && (typeof s == "number" || Fr.test(s)) && s > -1 && s % 1 == 0 && s < u;
+        }
+        function Se(s) {
+          if (s != null) {
+            try {
+              return Pn.call(s);
+            } catch {
+            }
+            try {
+              return s + "";
+            } catch {
+            }
+          }
+          return "";
+        }
+        function Jn(s, u) {
+          return s === u || s != s && u != u;
+        }
+        (Gt && ge(new Gt(new ArrayBuffer(1))) != F || ke && ge(new ke()) != g || Jt && ge(Jt.resolve()) != P || zt && ge(new zt()) != w || Yt && ge(new Yt()) != O) && (ge = function(s) {
+          var u = je(s), f = u == _ ? s.constructor : void 0, v = f ? Se(f) : "";
+          if (v) switch (v) {
+            case Yr:
+              return F;
+            case $r:
+              return g;
+            case qr:
+              return P;
+            case Hr:
+              return w;
+            case Xr:
+              return O;
+          }
+          return u;
+        });
+        var to = jn(/* @__PURE__ */ function() {
+          return arguments;
+        }()) ? jn : function(s) {
+          return Ve(s) && re.call(s, "callee") && !Dn.call(s, "callee");
+        }, dt = Array.isArray, qt = Jr || function() {
+          return !1;
+        };
+        function zn(s) {
+          if (!$n(s)) return !1;
+          var u = je(s);
+          return u == h || u == "[object GeneratorFunction]" || u == "[object AsyncFunction]" || u == "[object Proxy]";
+        }
+        function Yn(s) {
+          return typeof s == "number" && s > -1 && s % 1 == 0 && s <= r;
+        }
+        function $n(s) {
+          var u = typeof s;
+          return s != null && (u == "object" || u == "function");
+        }
+        function Ve(s) {
+          return s != null && typeof s == "object";
+        }
+        var qn = xn ? /* @__PURE__ */ function(s) {
+          return function(u) {
+            return s(u);
+          };
+        }(xn) : function(s) {
+          return Ve(s) && Yn(s.length) && !!M[je(s)];
+        };
+        function no(s) {
+          return (u = s) != null && Yn(u.length) && !zn(u) ? Zr(s) : Kr(s);
+          var u;
+        }
+        e.exports = function(s, u) {
+          return Vn(s, u);
+        };
+      })(Ut, Ut.exports);
+      var bn = de(Ut.exports);
+      function En(e, t) {
+        return e.length === t.length && JSON.stringify(e.map(function(n) {
+          return n;
+        }).sort()) === JSON.stringify(t.map(function(n) {
+          return n;
+        }).sort());
+      }
+      var Pr = { Polygon: W, LineString: ie, Point: me, MultiPolygon: $, MultiLineString: $, MultiPoint: $ }, Ar = Object.freeze({ __proto__: null, CommonSelectors: pr, constrainFeatureMovement: Dt, createMidPoint: cn, createSupplementaryPoints: We, createVertex: Le, doubleClickZoom: ee, euclideanDistance: xt, featuresAt: xe, getFeatureAtAndSetCursors: ze, isClick: Mt, isEventAtCoordinates: ot, isTap: Lt, mapEventToBoundingBox: tn, ModeHandler: Je, moveFeatures: kt, sortFeatures: en, stringSetsAreEqual: En, StringSet: Z, theme: sn, toDenseArray: Re }), wr = function(e, t) {
+        var n = { options: e = function(o) {
+          o === void 0 && (o = {});
+          var i = pe(o);
+          return o.controls || (i.controls = {}), o.displayControlsDefault === !1 ? i.controls = pe(Nr, o.controls) : i.controls = pe(Lr, o.controls), (i = pe(Mr, i)).styles = _n(i.styles, "cold").concat(_n(i.styles, "hot")), i;
+        }(e) };
+        t = function(o, i) {
+          return i.modes = T, i.getFeatureIdsAt = function(a) {
+            return xe.click({ point: a }, null, o).map(function(l) {
+              return l.properties.id;
+            });
+          }, i.getSelectedIds = function() {
+            return o.store.getSelectedIds();
+          }, i.getSelected = function() {
+            return { type: m.FEATURE_COLLECTION, features: o.store.getSelectedIds().map(function(a) {
+              return o.store.get(a);
+            }).map(function(a) {
+              return a.toGeoJSON();
+            }) };
+          }, i.getSelectedPoints = function() {
+            return { type: m.FEATURE_COLLECTION, features: o.store.getSelectedCoordinates().map(function(a) {
+              return { type: m.FEATURE, properties: {}, geometry: { type: m.POINT, coordinates: a.coordinates } };
+            }) };
+          }, i.set = function(a) {
+            if (a.type === void 0 || a.type !== m.FEATURE_COLLECTION || !Array.isArray(a.features)) throw new Error("Invalid FeatureCollection");
+            var l = o.store.createRenderBatch(), d = o.store.getAllIds().slice(), h = i.add(a), g = new Z(h);
+            return (d = d.filter(function(p) {
+              return !g.has(p);
+            })).length && i.delete(d), l(), h;
+          }, i.add = function(a) {
+            var l = JSON.parse(JSON.stringify(yr(a))).features.map(function(d) {
+              if (d.id = d.id || Pt(), d.geometry === null) throw new Error("Invalid geometry: null");
+              if (o.store.get(d.id) === void 0 || o.store.get(d.id).type !== d.geometry.type) {
+                var h = Pr[d.geometry.type];
+                if (h === void 0) throw new Error("Invalid geometry type: " + d.geometry.type + ".");
+                var g = new h(o, d);
+                o.store.add(g);
+              } else {
+                var p = o.store.get(d.id);
+                p.properties = d.properties, bn(p.properties, d.properties) || o.store.featureChanged(p.id), bn(p.getCoordinates(), d.geometry.coordinates) || p.incomingCoords(d.geometry.coordinates);
+              }
+              return d.id;
+            });
+            return o.store.render(), l;
+          }, i.get = function(a) {
+            var l = o.store.get(a);
+            if (l) return l.toGeoJSON();
+          }, i.getAll = function() {
+            return { type: m.FEATURE_COLLECTION, features: o.store.getAll().map(function(a) {
+              return a.toGeoJSON();
+            }) };
+          }, i.delete = function(a) {
+            return o.store.delete(a, { silent: !0 }), i.getMode() !== T.DIRECT_SELECT || o.store.getSelectedIds().length ? o.store.render() : o.events.changeMode(T.SIMPLE_SELECT, void 0, { silent: !0 }), i;
+          }, i.deleteAll = function() {
+            return o.store.delete(o.store.getAllIds(), { silent: !0 }), i.getMode() === T.DIRECT_SELECT ? o.events.changeMode(T.SIMPLE_SELECT, void 0, { silent: !0 }) : o.store.render(), i;
+          }, i.changeMode = function(a, l) {
+            return l === void 0 && (l = {}), a === T.SIMPLE_SELECT && i.getMode() === T.SIMPLE_SELECT ? (En(l.featureIds || [], o.store.getSelectedIds()) || (o.store.setSelected(l.featureIds, { silent: !0 }), o.store.render()), i) : (a === T.DIRECT_SELECT && i.getMode() === T.DIRECT_SELECT && l.featureId === o.store.getSelectedIds()[0] || o.events.changeMode(a, l, { silent: !0 }), i);
+          }, i.getMode = function() {
+            return o.events.getMode();
+          }, i.trash = function() {
+            return o.events.trash({ silent: !0 }), i;
+          }, i.combineFeatures = function() {
+            return o.events.combineFeatures({ silent: !0 }), i;
+          }, i.uncombineFeatures = function() {
+            return o.events.uncombineFeatures({ silent: !0 }), i;
+          }, i.setFeatureProperty = function(a, l, d) {
+            return o.store.setFeatureProperty(a, l, d), i;
+          }, i;
+        }(n, t), n.api = t;
+        var r = dr(n);
+        return t.onAdd = r.onAdd, t.onRemove = r.onRemove, t.types = Y, t.options = e, t;
+      };
+      function it(e) {
+        wr(e, this);
+      }
+      return it.modes = mn, it.constants = tr, it.lib = Ar, it;
+    });
+  }(Et), Et.exports);
 }
 export {
-  v as __require
+  co as __require
 };
 //# sourceMappingURL=index.es73.js.map