@performant-software/core-data 1.2.0-beta.27 → 1.2.0-beta.29

package/dist/index.es290.js

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