@hybridcore/ui 1.6.13 → 1.6.14

package/dist/components/geometry-picker/map/logic.js

@@ -1,198 +1,3709 @@
-import i from "react";
-import { createMapboxLayer as _ } from "../../map/helpers/mapbox.js";
-import B from "ol/interaction/Select";
-import j from "ol/source/Vector";
-import { createFeaturesFromKML as K, createFeaturesFromWKT as F } from "../../map/helpers/ol.js";
-import { click as q } from "ol/events/condition";
-import { defaultStyle as z, selectStyleFunction as H, markerStyle as J } from "./style.js";
-import Q from "ol/layer/Vector";
-import U from "ol/interaction/Modify";
-import X from "ol/interaction/Draw";
-import $ from "ol/interaction/Snap";
-import { alert as p } from "../../confirm/index.js";
-import ee from "ol/layer/Tile";
-import te from "ol/source/OSM";
-let T = null;
-const c = new j(), o = {
-  layer: new Q({
-    source: c,
-    style: z
+import v from "react";
+import { createMapboxLayer as Tt } from "../../map/helpers/mapbox.js";
+import { C as we, b as A, c as Be, V as De, a as he } from "../../../Vector-DfTqQEln.js";
+import { T as ce, g as C, j as Ft, e as Oe, f as J, E as $, k as pt, F as We, t as Et, s as He, m as $e, l as B, u as me, a as M, p as St, q as wt, r as ee, v as te, b as Pt, w as Lt } from "../../../math-Bvt2Ubuz.js";
+import { F as G, L as le, M as Dt, a as Je, b as Qe, G as Mt } from "../../../WKT-2wsDT-nq.js";
+import { I as kt, s as et, n as Pe, e as tt, P as Me, p as Gt, f as vt, h as Le, M as D, C as Rt, i as At, j as bt, l as It, T as jt, m as z, o as j, q as Ot, R as Ut, r as zt, a as Ue, t as ze, u as Kt } from "../../../ol-yOE-NV0X.js";
+import { V as ge } from "../../../Vector-BmuhQO4p.js";
+import { e as ke, f as I, s as Nt } from "../../../Text-ChJRuaD8.js";
+import { defaultStyle as Vt, selectStyleFunction as Xt, markerStyle as Zt } from "./style.js";
+import { a8 as P, a9 as ye, P as W, aa as ue, ab as p, ac as b, ad as de, ae as qt, af as it, a4 as nt, ag as O, ah as st, ai as Yt, aj as Ke, I as rt, y as Bt, ak as Wt, al as Ht, am as $t, an as ot, T as at, ao as Jt, c as Ge, ap as Qt, a2 as lt, aq as ei, ar as ti, as as ii, at as ni, S as si, e as N } from "../../../Source-BSZST_GH.js";
+import { alert as ri } from "../../confirm/index.js";
+const oi = {
+  /**
+   * Triggered when feature(s) has been (de)selected.
+   * @event SelectEvent#select
+   * @api
+   */
+  SELECT: "select"
+};
+class ai extends J {
+  /**
+   * @param {SelectEventType} type The event type.
+   * @param {Array<import("../Feature.js").default>} selected Selected features.
+   * @param {Array<import("../Feature.js").default>} deselected Deselected features.
+   * @param {import("../MapBrowserEvent.js").default} mapBrowserEvent Associated
+   *     {@link module:ol/MapBrowserEvent~MapBrowserEvent}.
+   */
+  constructor(e, t, i, n) {
+    super(e), this.selected = t, this.deselected = i, this.mapBrowserEvent = n;
+  }
+}
+const ie = {};
+class ve extends kt {
+  /**
+   * @param {Options} [options] Options.
+   */
+  constructor(e) {
+    super(), this.on, this.once, this.un, e = e || {}, this.boundAddFeature_ = this.addFeature_.bind(this), this.boundRemoveFeature_ = this.removeFeature_.bind(this), this.condition_ = e.condition ? e.condition : et, this.addCondition_ = e.addCondition ? e.addCondition : Pe, this.removeCondition_ = e.removeCondition ? e.removeCondition : Pe, this.toggleCondition_ = e.toggleCondition ? e.toggleCondition : tt, this.multi_ = e.multi ? e.multi : !1, this.filter_ = e.filter ? e.filter : ce, this.hitTolerance_ = e.hitTolerance ? e.hitTolerance : 0, this.style_ = e.style !== void 0 ? e.style : li(), this.features_ = e.features || new we();
+    let t;
+    if (e.layers)
+      if (typeof e.layers == "function")
+        t = e.layers;
+      else {
+        const i = e.layers;
+        t = function(n) {
+          return i.includes(n);
+        };
+      }
+    else
+      t = ce;
+    this.layerFilter_ = t, this.featureLayerAssociation_ = {};
+  }
+  /**
+   * @param {import("../Feature.js").default} feature Feature.
+   * @param {import("../layer/Layer.js").default} layer Layer.
+   * @private
+   */
+  addFeatureLayerAssociation_(e, t) {
+    this.featureLayerAssociation_[C(e)] = t;
+  }
+  /**
+   * Get the selected features.
+   * @return {Collection<Feature>} Features collection.
+   * @api
+   */
+  getFeatures() {
+    return this.features_;
+  }
+  /**
+   * Returns the Hit-detection tolerance.
+   * @return {number} Hit tolerance in pixels.
+   * @api
+   */
+  getHitTolerance() {
+    return this.hitTolerance_;
+  }
+  /**
+   * Returns the associated {@link module:ol/layer/Vector~VectorLayer vector layer} of
+   * a selected feature.
+   * @param {import("../Feature.js").default} feature Feature
+   * @return {import('../layer/Vector.js').default} Layer.
+   * @api
+   */
+  getLayer(e) {
+    return (
+      /** @type {import('../layer/Vector.js').default} */
+      this.featureLayerAssociation_[C(e)]
+    );
+  }
+  /**
+   * Hit-detection tolerance. Pixels inside the radius around the given position
+   * will be checked for features.
+   * @param {number} hitTolerance Hit tolerance in pixels.
+   * @api
+   */
+  setHitTolerance(e) {
+    this.hitTolerance_ = e;
+  }
+  /**
+   * Remove the interaction from its current map, if any,  and attach it to a new
+   * map, if any. Pass `null` to just remove the interaction from the current map.
+   * @param {import("../Map.js").default|null} map Map.
+   * @api
+   */
+  setMap(e) {
+    this.getMap() && this.style_ && this.features_.forEach(this.restorePreviousStyle_.bind(this)), super.setMap(e), e ? (this.features_.addEventListener(
+      A.ADD,
+      this.boundAddFeature_
+    ), this.features_.addEventListener(
+      A.REMOVE,
+      this.boundRemoveFeature_
+    ), this.style_ && this.features_.forEach(this.applySelectedStyle_.bind(this))) : (this.features_.removeEventListener(
+      A.ADD,
+      this.boundAddFeature_
+    ), this.features_.removeEventListener(
+      A.REMOVE,
+      this.boundRemoveFeature_
+    ));
+  }
+  /**
+   * @param {import("../Collection.js").CollectionEvent<Feature>} evt Event.
+   * @private
+   */
+  addFeature_(e) {
+    const t = e.element;
+    if (this.style_ && this.applySelectedStyle_(t), !this.getLayer(t)) {
+      const i = (
+        /** @type {VectorLayer} */
+        this.getMap().getAllLayers().find(function(n) {
+          if (n instanceof ge && n.getSource() && n.getSource().hasFeature(t))
+            return n;
+        })
+      );
+      i && this.addFeatureLayerAssociation_(t, i);
+    }
+  }
+  /**
+   * @param {import("../Collection.js").CollectionEvent<Feature>} evt Event.
+   * @private
+   */
+  removeFeature_(e) {
+    this.style_ && this.restorePreviousStyle_(e.element);
+  }
+  /**
+   * @return {import("../style/Style.js").StyleLike|null} Select style.
+   */
+  getStyle() {
+    return this.style_;
+  }
+  /**
+   * @param {Feature} feature Feature
+   * @private
+   */
+  applySelectedStyle_(e) {
+    const t = C(e);
+    t in ie || (ie[t] = e.getStyle()), e.setStyle(this.style_);
+  }
+  /**
+   * @param {Feature} feature Feature
+   * @private
+   */
+  restorePreviousStyle_(e) {
+    const t = this.getMap().getInteractions().getArray();
+    for (let n = t.length - 1; n >= 0; --n) {
+      const s = t[n];
+      if (s !== this && s instanceof ve && s.getStyle() && s.getFeatures().getArray().lastIndexOf(e) !== -1) {
+        e.setStyle(s.getStyle());
+        return;
+      }
+    }
+    const i = C(e);
+    e.setStyle(ie[i]), delete ie[i];
+  }
+  /**
+   * @param {Feature} feature Feature.
+   * @private
+   */
+  removeFeatureLayerAssociation_(e) {
+    delete this.featureLayerAssociation_[C(e)];
+  }
+  /**
+   * Handles the {@link module:ol/MapBrowserEvent~MapBrowserEvent map browser event} and may change the
+   * selected state of features.
+   * @param {import("../MapBrowserEvent.js").default} mapBrowserEvent Map browser event.
+   * @return {boolean} `false` to stop event propagation.
+   */
+  handleEvent(e) {
+    if (!this.condition_(e))
+      return !0;
+    const t = this.addCondition_(e), i = this.removeCondition_(e), n = this.toggleCondition_(e), s = !t && !i && !n, r = e.map, o = this.getFeatures(), a = [], h = [];
+    if (s) {
+      Ft(this.featureLayerAssociation_), r.forEachFeatureAtPixel(
+        e.pixel,
+        /**
+         * @param {import("../Feature.js").FeatureLike} feature Feature.
+         * @param {import("../layer/Layer.js").default} layer Layer.
+         * @return {boolean|undefined} Continue to iterate over the features.
+         */
+        (c, u) => {
+          if (!(!(c instanceof G) || !this.filter_(c, u)))
+            return this.addFeatureLayerAssociation_(c, u), h.push(c), !this.multi_;
+        },
+        {
+          layerFilter: this.layerFilter_,
+          hitTolerance: this.hitTolerance_
+        }
+      );
+      for (let c = o.getLength() - 1; c >= 0; --c) {
+        const u = o.item(c), g = h.indexOf(u);
+        g > -1 ? h.splice(g, 1) : (o.remove(u), a.push(u));
+      }
+      h.length !== 0 && o.extend(h);
+    } else {
+      r.forEachFeatureAtPixel(
+        e.pixel,
+        /**
+         * @param {import("../Feature.js").FeatureLike} feature Feature.
+         * @param {import("../layer/Layer.js").default} layer Layer.
+         * @return {boolean|undefined} Continue to iterate over the features.
+         */
+        (c, u) => {
+          if (!(!(c instanceof G) || !this.filter_(c, u)))
+            return (t || n) && !o.getArray().includes(c) ? (this.addFeatureLayerAssociation_(c, u), h.push(c)) : (i || n) && o.getArray().includes(c) && (a.push(c), this.removeFeatureLayerAssociation_(c)), !this.multi_;
+        },
+        {
+          layerFilter: this.layerFilter_,
+          hitTolerance: this.hitTolerance_
+        }
+      );
+      for (let c = a.length - 1; c >= 0; --c)
+        o.remove(a[c]);
+      o.extend(h);
+    }
+    return (h.length > 0 || a.length > 0) && this.dispatchEvent(
+      new ai(
+        oi.SELECT,
+        h,
+        a,
+        e
+      )
+    ), !0;
+  }
+}
+function li() {
+  const l = ke();
+  return Oe(l.Polygon, l.LineString), Oe(l.GeometryCollection, l.LineString), function(e) {
+    return e.getGeometry() ? l[e.getGeometry().getType()] : null;
+  };
+}
+const Ne = 0, H = 1, Ve = [0, 0, 0, 0], Z = [], xe = {
+  /**
+   * Triggered upon feature modification start
+   * @event ModifyEvent#modifystart
+   * @api
+   */
+  MODIFYSTART: "modifystart",
+  /**
+   * Triggered upon feature modification end
+   * @event ModifyEvent#modifyend
+   * @api
+   */
+  MODIFYEND: "modifyend"
+};
+class Ce extends J {
+  /**
+   * @param {ModifyEventType} type Type.
+   * @param {Collection<Feature>} features
+   * The features modified.
+   * @param {import("../MapBrowserEvent.js").default} mapBrowserEvent
+   * Associated {@link module:ol/MapBrowserEvent~MapBrowserEvent}.
+   */
+  constructor(e, t, i) {
+    super(e), this.features = t, this.mapBrowserEvent = i;
+  }
+}
+class hi extends Me {
+  /**
+   * @param {Options} options Options.
+   */
+  constructor(e) {
+    super(
+      /** @type {import("./Pointer.js").Options} */
+      e
+    ), this.on, this.once, this.un, this.boundHandleFeatureChange_ = this.handleFeatureChange_.bind(this), this.condition_ = e.condition ? e.condition : Gt, this.defaultDeleteCondition_ = function(i) {
+      return vt(i) && et(i);
+    }, this.deleteCondition_ = e.deleteCondition ? e.deleteCondition : this.defaultDeleteCondition_, this.insertVertexCondition_ = e.insertVertexCondition ? e.insertVertexCondition : Le, this.vertexFeature_ = null, this.vertexSegments_ = null, this.lastPixel_ = [0, 0], this.ignoreNextSingleClick_ = !1, this.featuresBeingModified_ = null, this.rBush_ = new Be(), this.pixelTolerance_ = e.pixelTolerance !== void 0 ? e.pixelTolerance : 10, this.snappedToVertex_ = !1, this.changingFeature_ = !1, this.dragSegments_ = [], this.overlay_ = new ge({
+      source: new De({
+        useSpatialIndex: !1,
+        wrapX: !!e.wrapX
+      }),
+      style: e.style ? e.style : ui(),
+      updateWhileAnimating: !0,
+      updateWhileInteracting: !0
+    }), this.SEGMENT_WRITERS_ = {
+      Point: this.writePointGeometry_.bind(this),
+      LineString: this.writeLineStringGeometry_.bind(this),
+      LinearRing: this.writeLineStringGeometry_.bind(this),
+      Polygon: this.writePolygonGeometry_.bind(this),
+      MultiPoint: this.writeMultiPointGeometry_.bind(this),
+      MultiLineString: this.writeMultiLineStringGeometry_.bind(this),
+      MultiPolygon: this.writeMultiPolygonGeometry_.bind(this),
+      Circle: this.writeCircleGeometry_.bind(this),
+      GeometryCollection: this.writeGeometryCollectionGeometry_.bind(this)
+    }, this.source_ = null, this.hitDetection_ = null;
+    let t;
+    if (e.features ? t = e.features : e.source && (this.source_ = e.source, t = new we(this.source_.getFeatures()), this.source_.addEventListener(
+      he.ADDFEATURE,
+      this.handleSourceAdd_.bind(this)
+    ), this.source_.addEventListener(
+      he.REMOVEFEATURE,
+      this.handleSourceRemove_.bind(this)
+    )), !t)
+      throw new Error(
+        "The modify interaction requires features, a source or a layer"
+      );
+    e.hitDetection && (this.hitDetection_ = e.hitDetection), this.features_ = t, this.features_.forEach(this.addFeature_.bind(this)), this.features_.addEventListener(
+      A.ADD,
+      this.handleFeatureAdd_.bind(this)
+    ), this.features_.addEventListener(
+      A.REMOVE,
+      this.handleFeatureRemove_.bind(this)
+    ), this.lastPointerEvent_ = null, this.delta_ = [0, 0], this.snapToPointer_ = e.snapToPointer === void 0 ? !this.hitDetection_ : e.snapToPointer;
+  }
+  /**
+   * @param {Feature} feature Feature.
+   * @private
+   */
+  addFeature_(e) {
+    const t = e.getGeometry();
+    if (t) {
+      const n = this.SEGMENT_WRITERS_[t.getType()];
+      n && n(e, t);
+    }
+    const i = this.getMap();
+    i && i.isRendered() && this.getActive() && this.handlePointerAtPixel_(this.lastPixel_, i), e.addEventListener($.CHANGE, this.boundHandleFeatureChange_);
+  }
+  /**
+   * @param {import("../MapBrowserEvent.js").default} evt Map browser event.
+   * @param {Array<Array<SegmentData>>} segments The segments subject to modification.
+   * @private
+   */
+  willModifyFeatures_(e, t) {
+    if (!this.featuresBeingModified_) {
+      this.featuresBeingModified_ = new we();
+      const i = this.featuresBeingModified_.getArray();
+      for (let n = 0, s = t.length; n < s; ++n) {
+        const r = t[n];
+        for (let o = 0, a = r.length; o < a; ++o) {
+          const h = r[o].feature;
+          h && !i.includes(h) && this.featuresBeingModified_.push(h);
+        }
+      }
+      this.featuresBeingModified_.getLength() === 0 ? this.featuresBeingModified_ = null : this.dispatchEvent(
+        new Ce(
+          xe.MODIFYSTART,
+          this.featuresBeingModified_,
+          e
+        )
+      );
+    }
+  }
+  /**
+   * @param {Feature} feature Feature.
+   * @private
+   */
+  removeFeature_(e) {
+    this.removeFeatureSegmentData_(e), this.vertexFeature_ && this.features_.getLength() === 0 && (this.overlay_.getSource().removeFeature(this.vertexFeature_), this.vertexFeature_ = null), e.removeEventListener(
+      $.CHANGE,
+      this.boundHandleFeatureChange_
+    );
+  }
+  /**
+   * @param {Feature} feature Feature.
+   * @private
+   */
+  removeFeatureSegmentData_(e) {
+    const t = this.rBush_, i = [];
+    t.forEach(
+      /**
+       * @param {SegmentData} node RTree node.
+       */
+      function(n) {
+        e === n.feature && i.push(n);
+      }
+    );
+    for (let n = i.length - 1; n >= 0; --n) {
+      const s = i[n];
+      for (let r = this.dragSegments_.length - 1; r >= 0; --r)
+        this.dragSegments_[r][0] === s && this.dragSegments_.splice(r, 1);
+      t.remove(s);
+    }
+  }
+  /**
+   * Activate or deactivate the interaction.
+   * @param {boolean} active Active.
+   * @observable
+   * @api
+   */
+  setActive(e) {
+    this.vertexFeature_ && !e && (this.overlay_.getSource().removeFeature(this.vertexFeature_), this.vertexFeature_ = null), super.setActive(e);
+  }
+  /**
+   * Remove the interaction from its current map and attach it to the new map.
+   * Subclasses may set up event handlers to get notified about changes to
+   * the map here.
+   * @param {import("../Map.js").default} map Map.
+   */
+  setMap(e) {
+    this.overlay_.setMap(e), super.setMap(e);
+  }
+  /**
+   * Get the overlay layer that this interaction renders the modification point or vertex to.
+   * @return {VectorLayer} Overlay layer.
+   * @api
+   */
+  getOverlay() {
+    return this.overlay_;
+  }
+  /**
+   * @param {import("../source/Vector.js").VectorSourceEvent} event Event.
+   * @private
+   */
+  handleSourceAdd_(e) {
+    e.feature && this.features_.push(e.feature);
+  }
+  /**
+   * @param {import("../source/Vector.js").VectorSourceEvent} event Event.
+   * @private
+   */
+  handleSourceRemove_(e) {
+    e.feature && this.features_.remove(e.feature);
+  }
+  /**
+   * @param {import("../Collection.js").CollectionEvent<Feature>} evt Event.
+   * @private
+   */
+  handleFeatureAdd_(e) {
+    this.addFeature_(e.element);
+  }
+  /**
+   * @param {import("../events/Event.js").default} evt Event.
+   * @private
+   */
+  handleFeatureChange_(e) {
+    if (!this.changingFeature_) {
+      const t = (
+        /** @type {Feature} */
+        e.target
+      );
+      this.removeFeature_(t), this.addFeature_(t);
+    }
+  }
+  /**
+   * @param {import("../Collection.js").CollectionEvent<Feature>} evt Event.
+   * @private
+   */
+  handleFeatureRemove_(e) {
+    this.removeFeature_(e.element);
+  }
+  /**
+   * @param {Feature} feature Feature
+   * @param {Point} geometry Geometry.
+   * @private
+   */
+  writePointGeometry_(e, t) {
+    const i = t.getCoordinates(), n = {
+      feature: e,
+      geometry: t,
+      segment: [i, i]
+    };
+    this.rBush_.insert(t.getExtent(), n);
+  }
+  /**
+   * @param {Feature} feature Feature
+   * @param {import("../geom/MultiPoint.js").default} geometry Geometry.
+   * @private
+   */
+  writeMultiPointGeometry_(e, t) {
+    const i = t.getCoordinates();
+    for (let n = 0, s = i.length; n < s; ++n) {
+      const r = i[n], o = {
+        feature: e,
+        geometry: t,
+        depth: [n],
+        index: n,
+        segment: [r, r]
+      };
+      this.rBush_.insert(t.getExtent(), o);
+    }
+  }
+  /**
+   * @param {Feature} feature Feature
+   * @param {import("../geom/LineString.js").default} geometry Geometry.
+   * @private
+   */
+  writeLineStringGeometry_(e, t) {
+    const i = t.getCoordinates();
+    for (let n = 0, s = i.length - 1; n < s; ++n) {
+      const r = i.slice(n, n + 2), o = {
+        feature: e,
+        geometry: t,
+        index: n,
+        segment: r
+      };
+      this.rBush_.insert(P(r), o);
+    }
+  }
+  /**
+   * @param {Feature} feature Feature
+   * @param {import("../geom/MultiLineString.js").default} geometry Geometry.
+   * @private
+   */
+  writeMultiLineStringGeometry_(e, t) {
+    const i = t.getCoordinates();
+    for (let n = 0, s = i.length; n < s; ++n) {
+      const r = i[n];
+      for (let o = 0, a = r.length - 1; o < a; ++o) {
+        const h = r.slice(o, o + 2), c = {
+          feature: e,
+          geometry: t,
+          depth: [n],
+          index: o,
+          segment: h
+        };
+        this.rBush_.insert(P(h), c);
+      }
+    }
+  }
+  /**
+   * @param {Feature} feature Feature
+   * @param {import("../geom/Polygon.js").default} geometry Geometry.
+   * @private
+   */
+  writePolygonGeometry_(e, t) {
+    const i = t.getCoordinates();
+    for (let n = 0, s = i.length; n < s; ++n) {
+      const r = i[n];
+      for (let o = 0, a = r.length - 1; o < a; ++o) {
+        const h = r.slice(o, o + 2), c = {
+          feature: e,
+          geometry: t,
+          depth: [n],
+          index: o,
+          segment: h
+        };
+        this.rBush_.insert(P(h), c);
+      }
+    }
+  }
+  /**
+   * @param {Feature} feature Feature
+   * @param {import("../geom/MultiPolygon.js").default} geometry Geometry.
+   * @private
+   */
+  writeMultiPolygonGeometry_(e, t) {
+    const i = t.getCoordinates();
+    for (let n = 0, s = i.length; n < s; ++n) {
+      const r = i[n];
+      for (let o = 0, a = r.length; o < a; ++o) {
+        const h = r[o];
+        for (let c = 0, u = h.length - 1; c < u; ++c) {
+          const g = h.slice(c, c + 2), d = {
+            feature: e,
+            geometry: t,
+            depth: [o, n],
+            index: c,
+            segment: g
+          };
+          this.rBush_.insert(P(g), d);
+        }
+      }
+    }
+  }
+  /**
+   * We convert a circle into two segments.  The segment at index
+   * {@link CIRCLE_CENTER_INDEX} is the
+   * circle's center (a point).  The segment at index
+   * {@link CIRCLE_CIRCUMFERENCE_INDEX} is
+   * the circumference, and is not a line segment.
+   *
+   * @param {Feature} feature Feature.
+   * @param {import("../geom/Circle.js").default} geometry Geometry.
+   * @private
+   */
+  writeCircleGeometry_(e, t) {
+    const i = t.getCenter(), n = {
+      feature: e,
+      geometry: t,
+      index: Ne,
+      segment: [i, i]
+    }, s = {
+      feature: e,
+      geometry: t,
+      index: H,
+      segment: [i, i]
+    }, r = [n, s];
+    n.featureSegments = r, s.featureSegments = r, this.rBush_.insert(ye(i), n);
+    let o = (
+      /** @type {import("../geom/Geometry.js").default} */
+      t
+    );
+    this.rBush_.insert(o.getExtent(), s);
+  }
+  /**
+   * @param {Feature} feature Feature
+   * @param {import("../geom/GeometryCollection.js").default} geometry Geometry.
+   * @private
+   */
+  writeGeometryCollectionGeometry_(e, t) {
+    const i = t.getGeometriesArray();
+    for (let n = 0; n < i.length; ++n) {
+      const s = i[n], r = this.SEGMENT_WRITERS_[s.getType()];
+      r(e, s);
+    }
+  }
+  /**
+   * @param {import("../coordinate.js").Coordinate} coordinates Coordinates.
+   * @param {Array<Feature>} features The features being modified.
+   * @param {Array<import("../geom/SimpleGeometry.js").default>} geometries The geometries being modified.
+   * @return {Feature} Vertex feature.
+   * @private
+   */
+  createOrUpdateVertexFeature_(e, t, i) {
+    let n = this.vertexFeature_;
+    return n ? n.getGeometry().setCoordinates(e) : (n = new G(new W(e)), this.vertexFeature_ = n, this.overlay_.getSource().addFeature(n)), n.set("features", t), n.set("geometries", i), n;
+  }
+  /**
+   * Handles the {@link module:ol/MapBrowserEvent~MapBrowserEvent map browser event} and may modify the geometry.
+   * @param {import("../MapBrowserEvent.js").default} mapBrowserEvent Map browser event.
+   * @return {boolean} `false` to stop event propagation.
+   */
+  handleEvent(e) {
+    if (!e.originalEvent)
+      return !0;
+    this.lastPointerEvent_ = e;
+    let t;
+    return !e.map.getView().getInteracting() && e.type == D.POINTERMOVE && !this.handlingDownUpSequence && this.handlePointerMove_(e), this.vertexFeature_ && this.deleteCondition_(e) && (e.type != D.SINGLECLICK || !this.ignoreNextSingleClick_ ? t = this.removePoint() : t = !0), e.type == D.SINGLECLICK && (this.ignoreNextSingleClick_ = !1), super.handleEvent(e) && !t;
+  }
+  /**
+   * Handle pointer drag events.
+   * @param {import("../MapBrowserEvent.js").default} evt Event.
+   */
+  handleDragEvent(e) {
+    this.ignoreNextSingleClick_ = !1, this.willModifyFeatures_(e, this.dragSegments_);
+    const t = [
+      e.coordinate[0] + this.delta_[0],
+      e.coordinate[1] + this.delta_[1]
+    ], i = [], n = [];
+    for (let s = 0, r = this.dragSegments_.length; s < r; ++s) {
+      const o = this.dragSegments_[s], a = o[0], h = a.feature;
+      i.includes(h) || i.push(h);
+      const c = a.geometry;
+      n.includes(c) || n.push(c);
+      const u = a.depth;
+      let g;
+      const d = a.segment, f = o[1];
+      for (; t.length < c.getStride(); )
+        t.push(d[f][t.length]);
+      switch (c.getType()) {
+        case "Point":
+          g = t, d[0] = t, d[1] = t;
+          break;
+        case "MultiPoint":
+          g = c.getCoordinates(), g[a.index] = t, d[0] = t, d[1] = t;
+          break;
+        case "LineString":
+          g = c.getCoordinates(), g[a.index + f] = t, d[f] = t;
+          break;
+        case "MultiLineString":
+          g = c.getCoordinates(), g[u[0]][a.index + f] = t, d[f] = t;
+          break;
+        case "Polygon":
+          g = c.getCoordinates(), g[u[0]][a.index + f] = t, d[f] = t;
+          break;
+        case "MultiPolygon":
+          g = c.getCoordinates(), g[u[1]][u[0]][a.index + f] = t, d[f] = t;
+          break;
+        case "Circle":
+          if (d[0] = t, d[1] = t, a.index === Ne)
+            this.changingFeature_ = !0, c.setCenter(t), this.changingFeature_ = !1;
+          else {
+            this.changingFeature_ = !0, e.map.getView().getProjection();
+            let _ = ue(
+              p(c.getCenter()),
+              p(t)
+            );
+            c.setRadius(_), this.changingFeature_ = !1;
+          }
+          break;
+      }
+      g && this.setGeometryCoordinates_(c, g);
+    }
+    this.createOrUpdateVertexFeature_(t, i, n);
+  }
+  /**
+   * Handle pointer down events.
+   * @param {import("../MapBrowserEvent.js").default} evt Event.
+   * @return {boolean} If the event was consumed.
+   */
+  handleDownEvent(e) {
+    if (!this.condition_(e))
+      return !1;
+    const t = e.coordinate;
+    this.handlePointerAtPixel_(e.pixel, e.map, t), this.dragSegments_.length = 0, this.featuresBeingModified_ = null;
+    const i = this.vertexFeature_;
+    if (i) {
+      e.map.getView().getProjection();
+      const n = [], s = i.getGeometry().getCoordinates(), r = P([s]), o = this.rBush_.getInExtent(r), a = {};
+      o.sort(ci);
+      for (let h = 0, c = o.length; h < c; ++h) {
+        const u = o[h], g = u.segment;
+        let d = C(u.geometry);
+        const f = u.depth;
+        if (f && (d += "-" + f.join("-")), a[d] || (a[d] = new Array(2)), u.geometry.getType() === "Circle" && u.index === H) {
+          const _ = Ze(
+            t,
+            u
+          );
+          b(_, s) && !a[d][0] && (this.dragSegments_.push([u, 0]), a[d][0] = u);
+          continue;
+        }
+        if (b(g[0], s) && !a[d][0]) {
+          this.dragSegments_.push([u, 0]), a[d][0] = u;
+          continue;
+        }
+        if (b(g[1], s) && !a[d][1]) {
+          if (a[d][0] && a[d][0].index === 0) {
+            let _ = u.geometry.getCoordinates();
+            switch (u.geometry.getType()) {
+              case "LineString":
+              case "MultiLineString":
+                continue;
+              case "MultiPolygon":
+                _ = _[f[1]];
+              case "Polygon":
+                if (u.index !== _[f[0]].length - 2)
+                  continue;
+                break;
+            }
+          }
+          this.dragSegments_.push([u, 1]), a[d][1] = u;
+          continue;
+        }
+        C(g) in this.vertexSegments_ && !a[d][0] && !a[d][1] && this.insertVertexCondition_(e) && n.push(u);
+      }
+      n.length && this.willModifyFeatures_(e, [n]);
+      for (let h = n.length - 1; h >= 0; --h)
+        this.insertVertex_(n[h], s);
+    }
+    return !!this.vertexFeature_;
+  }
+  /**
+   * Handle pointer up events.
+   * @param {import("../MapBrowserEvent.js").default} evt Event.
+   * @return {boolean} If the event was consumed.
+   */
+  handleUpEvent(e) {
+    for (let t = this.dragSegments_.length - 1; t >= 0; --t) {
+      const i = this.dragSegments_[t][0], n = i.geometry;
+      if (n.getType() === "Circle") {
+        const s = n.getCenter(), r = i.featureSegments[0], o = i.featureSegments[1];
+        r.segment[0] = s, r.segment[1] = s, o.segment[0] = s, o.segment[1] = s, this.rBush_.update(ye(s), r);
+        let a = n;
+        this.rBush_.update(
+          a.getExtent(),
+          o
+        );
+      } else
+        this.rBush_.update(P(i.segment), i);
+    }
+    return this.featuresBeingModified_ && (this.dispatchEvent(
+      new Ce(
+        xe.MODIFYEND,
+        this.featuresBeingModified_,
+        e
+      )
+    ), this.featuresBeingModified_ = null), !1;
+  }
+  /**
+   * @param {import("../MapBrowserEvent.js").default} evt Event.
+   * @private
+   */
+  handlePointerMove_(e) {
+    this.lastPixel_ = e.pixel, this.handlePointerAtPixel_(e.pixel, e.map, e.coordinate);
+  }
+  /**
+   * @param {import("../pixel.js").Pixel} pixel Pixel
+   * @param {import("../Map.js").default} map Map.
+   * @param {import("../coordinate.js").Coordinate} [coordinate] The pixel Coordinate.
+   * @private
+   */
+  handlePointerAtPixel_(e, t, i) {
+    const n = i || t.getCoordinateFromPixel(e);
+    t.getView().getProjection();
+    const s = function(a, h) {
+      return Xe(n, a) - Xe(n, h);
+    };
+    let r, o;
+    if (this.hitDetection_) {
+      const a = typeof this.hitDetection_ == "object" ? (h) => h === this.hitDetection_ : void 0;
+      t.forEachFeatureAtPixel(
+        e,
+        (h, c, u) => {
+          u && (u = new W(
+            de(u.getCoordinates())
+          ));
+          const g = u || h.getGeometry();
+          if (g.getType() === "Point" && h instanceof G && this.features_.getArray().includes(h)) {
+            o = /** @type {Point} */
+            g;
+            const d = (
+              /** @type {Point} */
+              h.getGeometry().getFlatCoordinates().slice(0, 2)
+            );
+            r = [
+              {
+                feature: h,
+                geometry: o,
+                segment: [d, d]
+              }
+            ];
+          }
+          return !0;
+        },
+        { layerFilter: a }
+      );
+    }
+    if (!r) {
+      const a = qt(
+        ye(n, Ve)
+      ), h = t.getView().getResolution() * this.pixelTolerance_, c = it(
+        nt(a, h, Ve)
+      );
+      r = this.rBush_.getInExtent(c);
+    }
+    if (r && r.length > 0) {
+      const a = r.sort(s)[0], h = a.segment;
+      let c = Ze(n, a);
+      const u = t.getPixelFromCoordinate(c);
+      let g = ue(e, u);
+      if (o || g <= this.pixelTolerance_) {
+        const d = {};
+        if (d[C(h)] = !0, this.snapToPointer_ || (this.delta_[0] = c[0] - n[0], this.delta_[1] = c[1] - n[1]), a.geometry.getType() === "Circle" && a.index === H)
+          this.snappedToVertex_ = !0, this.createOrUpdateVertexFeature_(
+            c,
+            [a.feature],
+            [a.geometry]
+          );
+        else {
+          const f = t.getPixelFromCoordinate(h[0]), _ = t.getPixelFromCoordinate(h[1]), x = O(u, f), T = O(u, _);
+          g = Math.sqrt(Math.min(x, T)), this.snappedToVertex_ = g <= this.pixelTolerance_, this.snappedToVertex_ && (c = x > T ? h[1] : h[0]), this.createOrUpdateVertexFeature_(
+            c,
+            [a.feature],
+            [a.geometry]
+          );
+          const F = {};
+          F[C(a.geometry)] = !0;
+          for (let E = 1, q = r.length; E < q; ++E) {
+            const k = r[E].segment;
+            if (b(h[0], k[0]) && b(h[1], k[1]) || b(h[0], k[1]) && b(h[1], k[0])) {
+              const Q = C(r[E].geometry);
+              Q in F || (F[Q] = !0, d[C(k)] = !0);
+            } else
+              break;
+          }
+        }
+        this.vertexSegments_ = d;
+        return;
+      }
+    }
+    this.vertexFeature_ && (this.overlay_.getSource().removeFeature(this.vertexFeature_), this.vertexFeature_ = null);
+  }
+  /**
+   * @param {SegmentData} segmentData Segment data.
+   * @param {import("../coordinate.js").Coordinate} vertex Vertex.
+   * @private
+   */
+  insertVertex_(e, t) {
+    const i = e.segment, n = e.feature, s = e.geometry, r = e.depth, o = e.index;
+    let a;
+    for (; t.length < s.getStride(); )
+      t.push(0);
+    switch (s.getType()) {
+      case "MultiLineString":
+        a = s.getCoordinates(), a[r[0]].splice(o + 1, 0, t);
+        break;
+      case "Polygon":
+        a = s.getCoordinates(), a[r[0]].splice(o + 1, 0, t);
+        break;
+      case "MultiPolygon":
+        a = s.getCoordinates(), a[r[1]][r[0]].splice(o + 1, 0, t);
+        break;
+      case "LineString":
+        a = s.getCoordinates(), a.splice(o + 1, 0, t);
+        break;
+      default:
+        return;
+    }
+    this.setGeometryCoordinates_(s, a);
+    const h = this.rBush_;
+    h.remove(e), this.updateSegmentIndices_(s, o, r, 1);
+    const c = {
+      segment: [i[0], t],
+      feature: n,
+      geometry: s,
+      depth: r,
+      index: o
+    };
+    h.insert(P(c.segment), c), this.dragSegments_.push([c, 1]);
+    const u = {
+      segment: [t, i[1]],
+      feature: n,
+      geometry: s,
+      depth: r,
+      index: o + 1
+    };
+    h.insert(P(u.segment), u), this.dragSegments_.push([u, 0]), this.ignoreNextSingleClick_ = !0;
+  }
+  /**
+   * Removes the vertex currently being pointed.
+   * @return {boolean} True when a vertex was removed.
+   * @api
+   */
+  removePoint() {
+    if (this.lastPointerEvent_ && this.lastPointerEvent_.type != D.POINTERDRAG) {
+      const e = this.lastPointerEvent_;
+      this.willModifyFeatures_(e, this.dragSegments_);
+      const t = this.removeVertex_();
+      return this.featuresBeingModified_ && this.dispatchEvent(
+        new Ce(
+          xe.MODIFYEND,
+          this.featuresBeingModified_,
+          e
+        )
+      ), this.featuresBeingModified_ = null, t;
+    }
+    return !1;
+  }
+  /**
+   * Removes a vertex from all matching features.
+   * @return {boolean} True when a vertex was removed.
+   * @private
+   */
+  removeVertex_() {
+    const e = this.dragSegments_, t = {};
+    let i = !1, n, s, r, o, a, h, c, u, g, d, f;
+    for (a = e.length - 1; a >= 0; --a)
+      r = e[a], d = r[0], f = C(d.feature), d.depth && (f += "-" + d.depth.join("-")), f in t || (t[f] = {}), r[1] === 0 ? (t[f].right = d, t[f].index = d.index) : r[1] == 1 && (t[f].left = d, t[f].index = d.index + 1);
+    for (f in t) {
+      switch (g = t[f].right, c = t[f].left, h = t[f].index, u = h - 1, c !== void 0 ? d = c : d = g, u < 0 && (u = 0), o = d.geometry, s = o.getCoordinates(), n = s, i = !1, o.getType()) {
+        case "MultiLineString":
+          s[d.depth[0]].length > 2 && (s[d.depth[0]].splice(h, 1), i = !0);
+          break;
+        case "LineString":
+          s.length > 2 && (s.splice(h, 1), i = !0);
+          break;
+        case "MultiPolygon":
+          n = n[d.depth[1]];
+        case "Polygon":
+          n = n[d.depth[0]], n.length > 4 && (h == n.length - 1 && (h = 0), n.splice(h, 1), i = !0, h === 0 && (n.pop(), n.push(n[0]), u = n.length - 1));
+          break;
+      }
+      if (i) {
+        this.setGeometryCoordinates_(o, s);
+        const _ = [];
+        if (c !== void 0 && (this.rBush_.remove(c), _.push(c.segment[0])), g !== void 0 && (this.rBush_.remove(g), _.push(g.segment[1])), c !== void 0 && g !== void 0) {
+          const x = {
+            depth: d.depth,
+            feature: d.feature,
+            geometry: d.geometry,
+            index: u,
+            segment: _
+          };
+          this.rBush_.insert(
+            P(x.segment),
+            x
+          );
+        }
+        this.updateSegmentIndices_(o, h, d.depth, -1), this.vertexFeature_ && (this.overlay_.getSource().removeFeature(this.vertexFeature_), this.vertexFeature_ = null), e.length = 0;
+      }
+    }
+    return i;
+  }
+  /**
+   * @param {import("../geom/SimpleGeometry.js").default} geometry Geometry.
+   * @param {Array} coordinates Coordinates.
+   * @private
+   */
+  setGeometryCoordinates_(e, t) {
+    this.changingFeature_ = !0, e.setCoordinates(t), this.changingFeature_ = !1;
+  }
+  /**
+   * @param {import("../geom/SimpleGeometry.js").default} geometry Geometry.
+   * @param {number} index Index.
+   * @param {Array<number>|undefined} depth Depth.
+   * @param {number} delta Delta (1 or -1).
+   * @private
+   */
+  updateSegmentIndices_(e, t, i, n) {
+    this.rBush_.forEachInExtent(
+      e.getExtent(),
+      function(s) {
+        s.geometry === e && (i === void 0 || s.depth === void 0 || pt(s.depth, i)) && s.index > t && (s.index += n);
+      }
+    );
+  }
+}
+function ci(l, e) {
+  return l.index - e.index;
+}
+function Xe(l, e, t) {
+  const i = e.geometry;
+  if (i.getType() === "Circle") {
+    let s = (
+      /** @type {import("../geom/Circle.js").default} */
+      i
+    );
+    if (e.index === H) {
+      const r = O(
+        s.getCenter(),
+        p(l)
+      ), o = Math.sqrt(r) - s.getRadius();
+      return o * o;
+    }
+  }
+  const n = p(l);
+  return Z[0] = p(e.segment[0]), Z[1] = p(e.segment[1]), Yt(n, Z);
+}
+function Ze(l, e, t) {
+  const i = e.geometry;
+  if (i.getType() === "Circle" && e.index === H)
+    return de(
+      /** @type {import("../geom/Circle.js").default} */
+      i.getClosestPoint(
+        p(l)
+      )
+    );
+  const n = p(l);
+  return Z[0] = p(e.segment[0]), Z[1] = p(e.segment[1]), de(
+    st(n, Z)
+  );
+}
+function ui() {
+  const l = ke();
+  return function(e, t) {
+    return l.Point;
+  };
+}
+const ne = {
+  /**
+   * Triggered upon feature draw start
+   * @event DrawEvent#drawstart
+   * @api
+   */
+  DRAWSTART: "drawstart",
+  /**
+   * Triggered upon feature draw end
+   * @event DrawEvent#drawend
+   * @api
+   */
+  DRAWEND: "drawend",
+  /**
+   * Triggered upon feature draw abortion
+   * @event DrawEvent#drawabort
+   * @api
+   */
+  DRAWABORT: "drawabort"
+};
+class se extends J {
+  /**
+   * @param {DrawEventType} type Type.
+   * @param {Feature} feature The feature drawn.
+   */
+  constructor(e, t) {
+    super(e), this.feature = t;
+  }
+}
+function di(l, e) {
+  const t = [];
+  for (let i = 0; i < e.length; ++i) {
+    const s = e[i].getGeometry();
+    ht(l, s, t);
+  }
+  return t;
+}
+function re(l, e) {
+  return He(l[0], l[1], e[0], e[1]);
+}
+function V(l, e) {
+  const t = l.length;
+  return e < 0 ? l[e + t] : e >= t ? l[e - t] : l[e];
+}
+function oe(l, e, t) {
+  let i, n;
+  e < t ? (i = e, n = t) : (i = t, n = e);
+  const s = Math.ceil(i), r = Math.floor(n);
+  if (s > r) {
+    const a = X(l, i), h = X(l, n);
+    return re(a, h);
+  }
+  let o = 0;
+  if (i < s) {
+    const a = X(l, i), h = V(l, s);
+    o += re(a, h);
+  }
+  if (r < n) {
+    const a = V(l, r), h = X(l, n);
+    o += re(a, h);
+  }
+  for (let a = s; a < r - 1; ++a) {
+    const h = V(l, a), c = V(l, a + 1);
+    o += re(h, c);
+  }
+  return o;
+}
+function ht(l, e, t) {
+  if (e instanceof le) {
+    ae(l, e.getCoordinates(), !1, t);
+    return;
+  }
+  if (e instanceof Je) {
+    const i = e.getCoordinates();
+    for (let n = 0, s = i.length; n < s; ++n)
+      ae(l, i[n], !1, t);
+    return;
+  }
+  if (e instanceof rt) {
+    const i = e.getCoordinates();
+    for (let n = 0, s = i.length; n < s; ++n)
+      ae(l, i[n], !0, t);
+    return;
+  }
+  if (e instanceof Qe) {
+    const i = e.getCoordinates();
+    for (let n = 0, s = i.length; n < s; ++n) {
+      const r = i[n];
+      for (let o = 0, a = r.length; o < a; ++o)
+        ae(l, r[o], !0, t);
+    }
+    return;
+  }
+  if (e instanceof Mt) {
+    const i = e.getGeometries();
+    for (let n = 0; n < i.length; ++n)
+      ht(l, i[n], t);
+    return;
+  }
+}
+const Te = { index: -1, endIndex: NaN };
+function gi(l, e, t, i) {
+  const n = l[0], s = l[1];
+  let r = 1 / 0, o = -1, a = NaN;
+  for (let u = 0; u < e.targets.length; ++u) {
+    const g = e.targets[u], d = g.coordinates;
+    let f = 1 / 0, _;
+    for (let x = 0; x < d.length - 1; ++x) {
+      const T = d[x], F = d[x + 1], E = ct(n, s, T, F);
+      E.squaredDistance < f && (f = E.squaredDistance, _ = x + E.along);
+    }
+    f < r && (r = f, g.ring && e.targetIndex === u && (g.endIndex > g.startIndex ? _ < g.startIndex && (_ += d.length) : g.endIndex < g.startIndex && _ > g.startIndex && (_ -= d.length)), a = _, o = u);
+  }
+  const h = e.targets[o];
+  let c = h.ring;
+  if (e.targetIndex === o && c) {
+    const u = X(
+      h.coordinates,
+      a
+    ), g = t.getPixelFromCoordinate(u);
+    ue(g, e.startPx) > i && (c = !1);
+  }
+  if (c) {
+    const u = h.coordinates, g = u.length, d = h.startIndex, f = a;
+    if (d < f) {
+      const _ = oe(
+        u,
+        d,
+        f
+      );
+      oe(
+        u,
+        d,
+        f - g
+      ) < _ && (a -= g);
+    } else {
+      const _ = oe(
+        u,
+        d,
+        f
+      );
+      oe(
+        u,
+        d,
+        f + g
+      ) < _ && (a += g);
+    }
+  }
+  return Te.index = o, Te.endIndex = a, Te;
+}
+function ae(l, e, t, i) {
+  const n = l[0], s = l[1];
+  for (let r = 0, o = e.length - 1; r < o; ++r) {
+    const a = e[r], h = e[r + 1], c = ct(n, s, a, h);
+    if (c.squaredDistance === 0) {
+      const u = r + c.along;
+      i.push({
+        coordinates: e,
+        ring: t,
+        startIndex: u,
+        endIndex: u
+      });
+      return;
+    }
+  }
+}
+const Fe = { along: 0, squaredDistance: 0 };
+function ct(l, e, t, i) {
+  const n = t[0], s = t[1], r = i[0], o = i[1], a = r - n, h = o - s;
+  let c = 0, u = n, g = s;
+  return (a !== 0 || h !== 0) && (c = $e(((l - n) * a + (e - s) * h) / (a * a + h * h), 0, 1), u += a * c, g += h * c), Fe.along = c, Fe.squaredDistance = Et(He(l, e, u, g), 10), Fe;
+}
+function X(l, e) {
+  const t = l.length;
+  let i = Math.floor(e);
+  const n = e - i;
+  i >= t ? i -= t : i < 0 && (i += t);
+  let s = i + 1;
+  s >= t && (s -= t);
+  const r = l[i], o = r[0], a = r[1], h = l[s], c = h[0] - o, u = h[1] - a;
+  return [o + c * n, a + u * n];
+}
+class fi extends Me {
+  /**
+   * @param {Options} options Options.
+   */
+  constructor(e) {
+    const t = (
+      /** @type {import("./Pointer.js").Options} */
+      e
+    );
+    t.stopDown || (t.stopDown = We), super(t), this.on, this.once, this.un, this.shouldHandle_ = !1, this.downPx_ = null, this.downTimeout_, this.lastDragTime_, this.pointerType_, this.freehand_ = !1, this.source_ = e.source ? e.source : null, this.features_ = e.features ? e.features : null, this.snapTolerance_ = e.snapTolerance ? e.snapTolerance : 12, this.type_ = /** @type {import("../geom/Geometry.js").Type} */
+    e.type, this.mode_ = mi(this.type_), this.stopClick_ = !!e.stopClick, this.minPoints_ = e.minPoints ? e.minPoints : this.mode_ === "Polygon" ? 3 : 2, this.maxPoints_ = this.mode_ === "Circle" ? 2 : e.maxPoints ? e.maxPoints : 1 / 0, this.finishCondition_ = e.finishCondition ? e.finishCondition : ce, this.geometryLayout_ = e.geometryLayout ? e.geometryLayout : "XY";
+    let i = e.geometryFunction;
+    if (!i) {
+      const n = this.mode_;
+      if (n === "Circle")
+        i = function(s, r, o) {
+          const a = r || new Rt([NaN, NaN]), h = p(s[0]), c = O(
+            h,
+            p(s[s.length - 1])
+          );
+          return a.setCenterAndRadius(
+            h,
+            Math.sqrt(c),
+            this.geometryLayout_
+          ), a;
+        };
+      else {
+        let s;
+        n === "Point" ? s = W : n === "LineString" ? s = le : n === "Polygon" && (s = rt), i = function(r, o, a) {
+          return o ? n === "Polygon" ? r[0].length ? o.setCoordinates(
+            [r[0].concat([r[0][0]])],
+            this.geometryLayout_
+          ) : o.setCoordinates([], this.geometryLayout_) : o.setCoordinates(r, this.geometryLayout_) : o = new s(r, this.geometryLayout_), o;
+        };
+      }
+    }
+    this.geometryFunction_ = i, this.dragVertexDelay_ = e.dragVertexDelay !== void 0 ? e.dragVertexDelay : 500, this.finishCoordinate_ = null, this.sketchFeature_ = null, this.sketchPoint_ = null, this.sketchCoords_ = null, this.sketchLine_ = null, this.sketchLineCoords_ = null, this.squaredClickTolerance_ = e.clickTolerance ? e.clickTolerance * e.clickTolerance : 36, this.overlay_ = new ge({
+      source: new De({
+        useSpatialIndex: !1,
+        wrapX: e.wrapX ? e.wrapX : !1
+      }),
+      style: e.style ? e.style : _i(),
+      updateWhileInteracting: !0
+    }), this.geometryName_ = e.geometryName, this.condition_ = e.condition ? e.condition : At, this.freehandCondition_, e.freehand ? this.freehandCondition_ = Le : this.freehandCondition_ = e.freehandCondition ? e.freehandCondition : tt, this.traceCondition_, this.setTrace(e.trace || !1), this.traceState_ = { active: !1 }, this.traceSource_ = e.traceSource || e.source || null, this.addChangeListener(bt.ACTIVE, this.updateState_);
+  }
+  /**
+   * Toggle tracing mode or set a tracing condition.
+   *
+   * @param {boolean|import("../events/condition.js").Condition} trace A boolean to toggle tracing mode or an event
+   *     condition that will be checked when a feature is clicked to determine if tracing should be active.
+   */
+  setTrace(e) {
+    let t;
+    e ? e === !0 ? t = Le : t = e : t = Pe, this.traceCondition_ = t;
+  }
+  /**
+   * Remove the interaction from its current map and attach it to the new map.
+   * Subclasses may set up event handlers to get notified about changes to
+   * the map here.
+   * @param {import("../Map.js").default} map Map.
+   */
+  setMap(e) {
+    super.setMap(e), this.updateState_();
+  }
+  /**
+   * Get the overlay layer that this interaction renders sketch features to.
+   * @return {VectorLayer} Overlay layer.
+   * @api
+   */
+  getOverlay() {
+    return this.overlay_;
+  }
+  /**
+   * Handles the {@link module:ol/MapBrowserEvent~MapBrowserEvent map browser event} and may actually draw or finish the drawing.
+   * @param {import("../MapBrowserEvent.js").default} event Map browser event.
+   * @return {boolean} `false` to stop event propagation.
+   * @api
+   */
+  handleEvent(e) {
+    e.originalEvent.type === $.CONTEXTMENU && e.originalEvent.preventDefault(), this.freehand_ = this.mode_ !== "Point" && this.freehandCondition_(e);
+    let t = e.type === D.POINTERMOVE, i = !0;
+    return !this.freehand_ && this.lastDragTime_ && e.type === D.POINTERDRAG && (Date.now() - this.lastDragTime_ >= this.dragVertexDelay_ ? (this.downPx_ = e.pixel, this.shouldHandle_ = !this.freehand_, t = !0) : this.lastDragTime_ = void 0, this.shouldHandle_ && this.downTimeout_ !== void 0 && (clearTimeout(this.downTimeout_), this.downTimeout_ = void 0)), this.freehand_ && e.type === D.POINTERDRAG && this.sketchFeature_ !== null ? (this.addToDrawing_(e.coordinate), i = !1) : this.freehand_ && e.type === D.POINTERDOWN ? i = !1 : t && this.getPointerCount() < 2 ? (i = e.type === D.POINTERMOVE, i && this.freehand_ ? (this.handlePointerMove_(e), this.shouldHandle_ && e.originalEvent.preventDefault()) : (e.originalEvent.pointerType === "mouse" || e.type === D.POINTERDRAG && this.downTimeout_ === void 0) && this.handlePointerMove_(e)) : e.type === D.DBLCLICK && (i = !1), super.handleEvent(e) && i;
+  }
+  /**
+   * Handle pointer down events.
+   * @param {import("../MapBrowserEvent.js").default} event Event.
+   * @return {boolean} If the event was consumed.
+   */
+  handleDownEvent(e) {
+    return this.shouldHandle_ = !this.freehand_, this.freehand_ ? (this.downPx_ = e.pixel, this.finishCoordinate_ || this.startDrawing_(e.coordinate), !0) : this.condition_(e) ? (this.lastDragTime_ = Date.now(), this.downTimeout_ = setTimeout(() => {
+      this.handlePointerMove_(
+        new It(
+          D.POINTERMOVE,
+          e.map,
+          e.originalEvent,
+          !1,
+          e.frameState
+        )
+      );
+    }, this.dragVertexDelay_), this.downPx_ = e.pixel, !0) : (this.lastDragTime_ = void 0, !1);
+  }
+  /**
+   * @private
+   */
+  deactivateTrace_() {
+    this.traceState_ = { active: !1 };
+  }
+  /**
+   * Activate or deactivate trace state based on a browser event.
+   * @param {import("../MapBrowserEvent.js").default} event Event.
+   * @private
+   */
+  toggleTraceState_(e) {
+    if (!this.traceSource_ || !this.traceCondition_(e))
+      return;
+    if (this.traceState_.active) {
+      this.deactivateTrace_();
+      return;
+    }
+    const t = this.getMap(), i = t.getCoordinateFromPixel([
+      e.pixel[0] - this.snapTolerance_,
+      e.pixel[1] + this.snapTolerance_
+    ]), n = t.getCoordinateFromPixel([
+      e.pixel[0] + this.snapTolerance_,
+      e.pixel[1] - this.snapTolerance_
+    ]), s = P([i, n]), r = this.traceSource_.getFeaturesInExtent(s);
+    if (r.length === 0)
+      return;
+    const o = di(e.coordinate, r);
+    o.length && (this.traceState_ = {
+      active: !0,
+      startPx: e.pixel.slice(),
+      targets: o,
+      targetIndex: -1
+    });
+  }
+  /**
+   * @param {TraceTarget} target The trace target.
+   * @param {number} endIndex The new end index of the trace.
+   * @private
+   */
+  addOrRemoveTracedCoordinates_(e, t) {
+    const i = e.startIndex <= e.endIndex, n = e.startIndex <= t;
+    i === n ? i && t > e.endIndex || !i && t < e.endIndex ? this.addTracedCoordinates_(e, e.endIndex, t) : (i && t < e.endIndex || !i && t > e.endIndex) && this.removeTracedCoordinates_(t, e.endIndex) : (this.removeTracedCoordinates_(e.startIndex, e.endIndex), this.addTracedCoordinates_(e, e.startIndex, t));
+  }
+  /**
+   * @param {number} fromIndex The start index.
+   * @param {number} toIndex The end index.
+   * @private
+   */
+  removeTracedCoordinates_(e, t) {
+    if (e === t)
+      return;
+    let i = 0;
+    if (e < t) {
+      const n = Math.ceil(e);
+      let s = Math.floor(t);
+      s === t && (s -= 1), i = s - n + 1;
+    } else {
+      const n = Math.floor(e);
+      let s = Math.ceil(t);
+      s === t && (s += 1), i = n - s + 1;
+    }
+    i > 0 && this.removeLastPoints_(i);
+  }
+  /**
+   * @param {TraceTarget} target The trace target.
+   * @param {number} fromIndex The start index.
+   * @param {number} toIndex The end index.
+   * @private
+   */
+  addTracedCoordinates_(e, t, i) {
+    if (t === i)
+      return;
+    const n = [];
+    if (t < i) {
+      const s = Math.ceil(t);
+      let r = Math.floor(i);
+      r === i && (r -= 1);
+      for (let o = s; o <= r; ++o)
+        n.push(V(e.coordinates, o));
+    } else {
+      const s = Math.floor(t);
+      let r = Math.ceil(i);
+      r === i && (r += 1);
+      for (let o = s; o >= r; --o)
+        n.push(V(e.coordinates, o));
+    }
+    n.length && this.appendCoordinates(n);
+  }
+  /**
+   * Update the trace.
+   * @param {import("../MapBrowserEvent.js").default} event Event.
+   * @private
+   */
+  updateTrace_(e) {
+    const t = this.traceState_;
+    if (!t.active || t.targetIndex === -1 && ue(t.startPx, e.pixel) < this.snapTolerance_)
+      return;
+    const i = gi(
+      e.coordinate,
+      t,
+      this.getMap(),
+      this.snapTolerance_
+    );
+    if (t.targetIndex !== i.index) {
+      if (t.targetIndex !== -1) {
+        const a = t.targets[t.targetIndex];
+        this.removeTracedCoordinates_(a.startIndex, a.endIndex);
+      }
+      const o = t.targets[i.index];
+      this.addTracedCoordinates_(
+        o,
+        o.startIndex,
+        i.endIndex
+      );
+    } else {
+      const o = t.targets[t.targetIndex];
+      this.addOrRemoveTracedCoordinates_(o, i.endIndex);
+    }
+    t.targetIndex = i.index;
+    const n = t.targets[t.targetIndex];
+    n.endIndex = i.endIndex;
+    const s = X(
+      n.coordinates,
+      n.endIndex
+    ), r = this.getMap().getPixelFromCoordinate(s);
+    e.coordinate = s, e.pixel = [Math.round(r[0]), Math.round(r[1])];
+  }
+  /**
+   * Handle pointer up events.
+   * @param {import("../MapBrowserEvent.js").default} event Event.
+   * @return {boolean} If the event was consumed.
+   */
+  handleUpEvent(e) {
+    let t = !0;
+    if (this.getPointerCount() === 0) {
+      this.downTimeout_ && (clearTimeout(this.downTimeout_), this.downTimeout_ = void 0), this.handlePointerMove_(e);
+      const i = this.traceState_.active;
+      if (this.toggleTraceState_(e), this.shouldHandle_) {
+        const n = !this.finishCoordinate_;
+        n && this.startDrawing_(e.coordinate), !n && this.freehand_ ? this.finishDrawing() : !this.freehand_ && (!n || this.mode_ === "Point") && (this.atFinish_(e.pixel, i) ? this.finishCondition_(e) && this.finishDrawing() : this.addToDrawing_(e.coordinate)), t = !1;
+      } else this.freehand_ && this.abortDrawing();
+    }
+    return !t && this.stopClick_ && e.preventDefault(), t;
+  }
+  /**
+   * Handle move events.
+   * @param {import("../MapBrowserEvent.js").default} event A move event.
+   * @private
+   */
+  handlePointerMove_(e) {
+    if (this.pointerType_ = e.originalEvent.pointerType, this.downPx_ && (!this.freehand_ && this.shouldHandle_ || this.freehand_ && !this.shouldHandle_)) {
+      const t = this.downPx_, i = e.pixel, n = t[0] - i[0], s = t[1] - i[1], r = n * n + s * s;
+      if (this.shouldHandle_ = this.freehand_ ? r > this.squaredClickTolerance_ : r <= this.squaredClickTolerance_, !this.shouldHandle_)
+        return;
+    }
+    if (!this.finishCoordinate_) {
+      this.createOrUpdateSketchPoint_(e.coordinate.slice());
+      return;
+    }
+    this.updateTrace_(e), this.modifyDrawing_(e.coordinate);
+  }
+  /**
+   * Determine if an event is within the snapping tolerance of the start coord.
+   * @param {import("../pixel.js").Pixel} pixel Pixel.
+   * @param {boolean} [tracing] Drawing in trace mode (only stop if at the starting point).
+   * @return {boolean} The event is within the snapping tolerance of the start.
+   * @private
+   */
+  atFinish_(e, t) {
+    let i = !1;
+    if (this.sketchFeature_) {
+      let n = !1, s = [this.finishCoordinate_];
+      const r = this.mode_;
+      if (r === "Point")
+        i = !0;
+      else if (r === "Circle")
+        i = this.sketchCoords_.length === 2;
+      else if (r === "LineString")
+        n = !t && this.sketchCoords_.length > this.minPoints_;
+      else if (r === "Polygon") {
+        const o = (
+          /** @type {PolyCoordType} */
+          this.sketchCoords_
+        );
+        n = o[0].length > this.minPoints_, s = [
+          o[0][0],
+          o[0][o[0].length - 2]
+        ], t ? s = [o[0][0]] : s = [
+          o[0][0],
+          o[0][o[0].length - 2]
+        ];
+      }
+      if (n) {
+        const o = this.getMap();
+        for (let a = 0, h = s.length; a < h; a++) {
+          const c = s[a], u = o.getPixelFromCoordinate(c), g = e[0] - u[0], d = e[1] - u[1], f = this.freehand_ ? 1 : this.snapTolerance_;
+          if (i = Math.sqrt(g * g + d * d) <= f, i) {
+            this.finishCoordinate_ = c;
+            break;
+          }
+        }
+      }
+    }
+    return i;
+  }
+  /**
+   * @param {import("../coordinate").Coordinate} coordinates Coordinate.
+   * @private
+   */
+  createOrUpdateSketchPoint_(e) {
+    this.sketchPoint_ ? this.sketchPoint_.getGeometry().setCoordinates(e) : (this.sketchPoint_ = new G(new W(e)), this.updateSketchFeatures_());
+  }
+  /**
+   * @param {import("../geom/Polygon.js").default} geometry Polygon geometry.
+   * @private
+   */
+  createOrUpdateCustomSketchLine_(e) {
+    this.sketchLine_ || (this.sketchLine_ = new G());
+    const t = e.getLinearRing(0);
+    let i = this.sketchLine_.getGeometry();
+    i ? (i.setFlatCoordinates(
+      t.getLayout(),
+      t.getFlatCoordinates()
+    ), i.changed()) : (i = new le(
+      t.getFlatCoordinates(),
+      t.getLayout()
+    ), this.sketchLine_.setGeometry(i));
+  }
+  /**
+   * Start the drawing.
+   * @param {import("../coordinate.js").Coordinate} start Start coordinate.
+   * @private
+   */
+  startDrawing_(e) {
+    const t = this.getMap().getView().getProjection(), i = Ke(this.geometryLayout_);
+    for (; e.length < i; )
+      e.push(0);
+    this.finishCoordinate_ = e, this.mode_ === "Point" ? this.sketchCoords_ = e.slice() : this.mode_ === "Polygon" ? (this.sketchCoords_ = [[e.slice(), e.slice()]], this.sketchLineCoords_ = this.sketchCoords_[0]) : this.sketchCoords_ = [e.slice(), e.slice()], this.sketchLineCoords_ && (this.sketchLine_ = new G(new le(this.sketchLineCoords_)));
+    const n = this.geometryFunction_(
+      this.sketchCoords_,
+      void 0,
+      t
+    );
+    this.sketchFeature_ = new G(), this.geometryName_ && this.sketchFeature_.setGeometryName(this.geometryName_), this.sketchFeature_.setGeometry(n), this.updateSketchFeatures_(), this.dispatchEvent(
+      new se(ne.DRAWSTART, this.sketchFeature_)
+    );
+  }
+  /**
+   * Modify the drawing.
+   * @param {import("../coordinate.js").Coordinate} coordinate Coordinate.
+   * @private
+   */
+  modifyDrawing_(e) {
+    const t = this.getMap(), i = this.sketchFeature_.getGeometry(), n = t.getView().getProjection(), s = Ke(this.geometryLayout_);
+    let r, o;
+    for (; e.length < s; )
+      e.push(0);
+    this.mode_ === "Point" ? o = this.sketchCoords_ : this.mode_ === "Polygon" ? (r = /** @type {PolyCoordType} */
+    this.sketchCoords_[0], o = r[r.length - 1], this.atFinish_(t.getPixelFromCoordinate(e)) && (e = this.finishCoordinate_.slice())) : (r = this.sketchCoords_, o = r[r.length - 1]), o[0] = e[0], o[1] = e[1], this.geometryFunction_(
+      /** @type {!LineCoordType} */
+      this.sketchCoords_,
+      i,
+      n
+    ), this.sketchPoint_ && this.sketchPoint_.getGeometry().setCoordinates(e), i.getType() === "Polygon" && this.mode_ !== "Polygon" ? this.createOrUpdateCustomSketchLine_(
+      /** @type {Polygon} */
+      i
+    ) : this.sketchLineCoords_ && this.sketchLine_.getGeometry().setCoordinates(this.sketchLineCoords_), this.updateSketchFeatures_();
+  }
+  /**
+   * Add a new coordinate to the drawing.
+   * @param {!PointCoordType} coordinate Coordinate
+   * @private
+   */
+  addToDrawing_(e) {
+    const t = this.sketchFeature_.getGeometry(), i = this.getMap().getView().getProjection();
+    let n, s;
+    const r = this.mode_;
+    r === "LineString" || r === "Circle" ? (this.finishCoordinate_ = e.slice(), s = /** @type {LineCoordType} */
+    this.sketchCoords_, s.length >= this.maxPoints_ && (this.freehand_ ? s.pop() : n = !0), s.push(e.slice()), this.geometryFunction_(s, t, i)) : r === "Polygon" && (s = /** @type {PolyCoordType} */
+    this.sketchCoords_[0], s.length >= this.maxPoints_ && (this.freehand_ ? s.pop() : n = !0), s.push(e.slice()), n && (this.finishCoordinate_ = s[0]), this.geometryFunction_(this.sketchCoords_, t, i)), this.createOrUpdateSketchPoint_(e.slice()), this.updateSketchFeatures_(), n && this.finishDrawing();
+  }
+  /**
+   * @param {number} n The number of points to remove.
+   */
+  removeLastPoints_(e) {
+    if (!this.sketchFeature_)
+      return;
+    const t = this.sketchFeature_.getGeometry(), i = this.getMap().getView().getProjection(), n = this.mode_;
+    for (let s = 0; s < e; ++s) {
+      let r;
+      if (n === "LineString" || n === "Circle") {
+        if (r = /** @type {LineCoordType} */
+        this.sketchCoords_, r.splice(-2, 1), r.length >= 2) {
+          this.finishCoordinate_ = r[r.length - 2].slice();
+          const o = this.finishCoordinate_.slice();
+          r[r.length - 1] = o, this.createOrUpdateSketchPoint_(o);
+        }
+        this.geometryFunction_(r, t, i), t.getType() === "Polygon" && this.sketchLine_ && this.createOrUpdateCustomSketchLine_(
+          /** @type {Polygon} */
+          t
+        );
+      } else if (n === "Polygon") {
+        r = /** @type {PolyCoordType} */
+        this.sketchCoords_[0], r.splice(-2, 1);
+        const o = this.sketchLine_.getGeometry();
+        if (r.length >= 2) {
+          const a = r[r.length - 2].slice();
+          r[r.length - 1] = a, this.createOrUpdateSketchPoint_(a);
+        }
+        o.setCoordinates(r), this.geometryFunction_(this.sketchCoords_, t, i);
+      }
+      if (r.length === 1) {
+        this.abortDrawing();
+        break;
+      }
+    }
+    this.updateSketchFeatures_();
+  }
+  /**
+   * Remove last point of the feature currently being drawn. Does not do anything when
+   * drawing POINT or MULTI_POINT geometries.
+   * @api
+   */
+  removeLastPoint() {
+    this.removeLastPoints_(1);
+  }
+  /**
+   * Stop drawing and add the sketch feature to the target layer.
+   * The {@link module:ol/interaction/Draw~DrawEventType.DRAWEND} event is
+   * dispatched before inserting the feature.
+   * @api
+   */
+  finishDrawing() {
+    const e = this.abortDrawing_();
+    if (!e)
+      return;
+    let t = this.sketchCoords_;
+    const i = e.getGeometry(), n = this.getMap().getView().getProjection();
+    this.mode_ === "LineString" ? (t.pop(), this.geometryFunction_(t, i, n)) : this.mode_ === "Polygon" && (t[0].pop(), this.geometryFunction_(t, i, n), t = i.getCoordinates()), this.type_ === "MultiPoint" ? e.setGeometry(
+      new Dt([
+        /** @type {PointCoordType} */
+        t
+      ])
+    ) : this.type_ === "MultiLineString" ? e.setGeometry(
+      new Je([
+        /** @type {LineCoordType} */
+        t
+      ])
+    ) : this.type_ === "MultiPolygon" && e.setGeometry(
+      new Qe([
+        /** @type {PolyCoordType} */
+        t
+      ])
+    ), this.dispatchEvent(new se(ne.DRAWEND, e)), this.features_ && this.features_.push(e), this.source_ && this.source_.addFeature(e);
+  }
+  /**
+   * Stop drawing without adding the sketch feature to the target layer.
+   * @return {Feature<import("../geom/SimpleGeometry.js").default>|null} The sketch feature (or null if none).
+   * @private
+   */
+  abortDrawing_() {
+    this.finishCoordinate_ = null;
+    const e = this.sketchFeature_;
+    return this.sketchFeature_ = null, this.sketchPoint_ = null, this.sketchLine_ = null, this.overlay_.getSource().clear(!0), this.deactivateTrace_(), e;
+  }
+  /**
+   * Stop drawing without adding the sketch feature to the target layer.
+   * @api
+   */
+  abortDrawing() {
+    const e = this.abortDrawing_();
+    e && this.dispatchEvent(new se(ne.DRAWABORT, e));
+  }
+  /**
+   * Append coordinates to the end of the geometry that is currently being drawn.
+   * This can be used when drawing LineStrings or Polygons. Coordinates will
+   * either be appended to the current LineString or the outer ring of the current
+   * Polygon. If no geometry is being drawn, a new one will be created.
+   * @param {!LineCoordType} coordinates Linear coordinates to be appended to
+   * the coordinate array.
+   * @api
+   */
+  appendCoordinates(e) {
+    const t = this.mode_, i = !this.sketchFeature_;
+    i && this.startDrawing_(e[0]);
+    let n;
+    if (t === "LineString" || t === "Circle")
+      n = /** @type {LineCoordType} */
+      this.sketchCoords_;
+    else if (t === "Polygon")
+      n = this.sketchCoords_ && this.sketchCoords_.length ? (
+        /** @type {PolyCoordType} */
+        this.sketchCoords_[0]
+      ) : [];
+    else
+      return;
+    i && n.shift(), n.pop();
+    for (let r = 0; r < e.length; r++)
+      this.addToDrawing_(e[r]);
+    const s = e[e.length - 1];
+    this.addToDrawing_(s), this.modifyDrawing_(s);
+  }
+  /**
+   * Initiate draw mode by starting from an existing geometry which will
+   * receive new additional points. This only works on features with
+   * `LineString` geometries, where the interaction will extend lines by adding
+   * points to the end of the coordinates array.
+   * This will change the original feature, instead of drawing a copy.
+   *
+   * The function will dispatch a `drawstart` event.
+   *
+   * @param {!Feature<LineString>} feature Feature to be extended.
+   * @api
+   */
+  extend(e) {
+    const i = e.getGeometry();
+    this.sketchFeature_ = e, this.sketchCoords_ = i.getCoordinates();
+    const n = this.sketchCoords_[this.sketchCoords_.length - 1];
+    this.finishCoordinate_ = n.slice(), this.sketchCoords_.push(n.slice()), this.sketchPoint_ = new G(new W(n)), this.updateSketchFeatures_(), this.dispatchEvent(
+      new se(ne.DRAWSTART, this.sketchFeature_)
+    );
+  }
+  /**
+   * Redraw the sketch features.
+   * @private
+   */
+  updateSketchFeatures_() {
+    const e = [];
+    this.sketchFeature_ && e.push(this.sketchFeature_), this.sketchLine_ && e.push(this.sketchLine_), this.sketchPoint_ && e.push(this.sketchPoint_);
+    const t = this.overlay_.getSource();
+    t.clear(!0), t.addFeatures(e);
+  }
+  /**
+   * @private
+   */
+  updateState_() {
+    const e = this.getMap(), t = this.getActive();
+    (!e || !t) && this.abortDrawing(), this.overlay_.setMap(t ? e : null);
+  }
+}
+function _i() {
+  const l = ke();
+  return function(e, t) {
+    return l[e.getGeometry().getType()];
+  };
+}
+function mi(l) {
+  switch (l) {
+    case "Point":
+    case "MultiPoint":
+      return "Point";
+    case "LineString":
+    case "MultiLineString":
+      return "LineString";
+    case "Polygon":
+    case "MultiPolygon":
+      return "Polygon";
+    case "Circle":
+      return "Circle";
+    default:
+      throw new Error("Invalid type: " + l);
+  }
+}
+const yi = {
+  /**
+   * Triggered upon snapping to vertex or edge
+   * @event SnapEvent#snap
+   * @api
+   */
+  SNAP: "snap"
+};
+class xi extends J {
+  /**
+   * @param {SnapEventType} type Type.
+   * @param {Object} options Options.
+   * @param {import("../coordinate.js").Coordinate} options.vertex The snapped vertex.
+   * @param {import("../coordinate.js").Coordinate} options.vertexPixel The pixel of the snapped vertex.
+   * @param {import("../Feature.js").default} options.feature The feature being snapped.
+   */
+  constructor(e, t) {
+    super(e), this.vertex = t.vertex, this.vertexPixel = t.vertexPixel, this.feature = t.feature;
+  }
+}
+function qe(l) {
+  return (
+    /** @type {import("../source/Vector.js").VectorSourceEvent} */
+    l.feature ? (
+      /** @type {import("../source/Vector.js").VectorSourceEvent} */
+      l.feature
+    ) : (
+      /** @type {import("../Collection.js").CollectionEvent<import("../Feature.js").default>} */
+      l.element ? (
+        /** @type {import("../Collection.js").CollectionEvent<import("../Feature.js").default>} */
+        l.element
+      ) : null
+    )
+  );
+}
+const pe = [];
+class Ci extends Me {
+  /**
+   * @param {Options} [options] Options.
+   */
+  constructor(e) {
+    e = e || {};
+    const t = (
+      /** @type {import("./Pointer.js").Options} */
+      e
+    );
+    t.handleDownEvent || (t.handleDownEvent = ce), t.stopDown || (t.stopDown = We), super(t), this.on, this.once, this.un, this.source_ = e.source ? e.source : null, this.vertex_ = e.vertex !== void 0 ? e.vertex : !0, this.edge_ = e.edge !== void 0 ? e.edge : !0, this.features_ = e.features ? e.features : null, this.featuresListenerKeys_ = [], this.featureChangeListenerKeys_ = {}, this.indexedFeaturesExtents_ = {}, this.pendingFeatures_ = {}, this.pixelTolerance_ = e.pixelTolerance !== void 0 ? e.pixelTolerance : 10, this.rBush_ = new Be(), this.GEOMETRY_SEGMENTERS_ = {
+      Point: this.segmentPointGeometry_.bind(this),
+      LineString: this.segmentLineStringGeometry_.bind(this),
+      LinearRing: this.segmentLineStringGeometry_.bind(this),
+      Polygon: this.segmentPolygonGeometry_.bind(this),
+      MultiPoint: this.segmentMultiPointGeometry_.bind(this),
+      MultiLineString: this.segmentMultiLineStringGeometry_.bind(this),
+      MultiPolygon: this.segmentMultiPolygonGeometry_.bind(this),
+      GeometryCollection: this.segmentGeometryCollectionGeometry_.bind(this),
+      Circle: this.segmentCircleGeometry_.bind(this)
+    };
+  }
+  /**
+   * Add a feature to the collection of features that we may snap to.
+   * @param {import("../Feature.js").default} feature Feature.
+   * @param {boolean} [register] Whether to listen to the feature change or not
+   *     Defaults to `true`.
+   * @api
+   */
+  addFeature(e, t) {
+    t = t !== void 0 ? t : !0;
+    const i = C(e), n = e.getGeometry();
+    if (n) {
+      const s = this.GEOMETRY_SEGMENTERS_[n.getType()];
+      if (s) {
+        this.indexedFeaturesExtents_[i] = n.getExtent(
+          Bt()
+        );
+        const r = (
+          /** @type {Array<Array<import('../coordinate.js').Coordinate>>} */
+          []
+        );
+        if (s(r, n), r.length === 1)
+          this.rBush_.insert(P(r[0]), {
+            feature: e,
+            segment: r[0]
+          });
+        else if (r.length > 1) {
+          const o = r.map((h) => P(h)), a = r.map((h) => ({
+            feature: e,
+            segment: h
+          }));
+          this.rBush_.load(o, a);
+        }
+      }
+    }
+    t && (this.featureChangeListenerKeys_[i] = B(
+      e,
+      $.CHANGE,
+      this.handleFeatureChange_,
+      this
+    ));
+  }
+  /**
+   * @return {import("../Collection.js").default<import("../Feature.js").default>|Array<import("../Feature.js").default>} Features.
+   * @private
+   */
+  getFeatures_() {
+    let e;
+    return this.features_ ? e = this.features_ : this.source_ && (e = this.source_.getFeatures()), e;
+  }
+  /**
+   * @param {import("../MapBrowserEvent.js").default} evt Map browser event.
+   * @return {boolean} `false` to stop event propagation.
+   * @api
+   */
+  handleEvent(e) {
+    const t = this.snapTo(e.pixel, e.coordinate, e.map);
+    return t && (e.coordinate = t.vertex.slice(0, 2), e.pixel = t.vertexPixel, this.dispatchEvent(
+      new xi(yi.SNAP, {
+        vertex: e.coordinate,
+        vertexPixel: e.pixel,
+        feature: t.feature
+      })
+    )), super.handleEvent(e);
+  }
+  /**
+   * @param {import("../source/Vector.js").VectorSourceEvent|import("../Collection.js").CollectionEvent<import("../Feature.js").default>} evt Event.
+   * @private
+   */
+  handleFeatureAdd_(e) {
+    const t = qe(e);
+    t && this.addFeature(t);
+  }
+  /**
+   * @param {import("../source/Vector.js").VectorSourceEvent|import("../Collection.js").CollectionEvent<import("../Feature.js").default>} evt Event.
+   * @private
+   */
+  handleFeatureRemove_(e) {
+    const t = qe(e);
+    t && this.removeFeature(t);
+  }
+  /**
+   * @param {import("../events/Event.js").default} evt Event.
+   * @private
+   */
+  handleFeatureChange_(e) {
+    const t = (
+      /** @type {import("../Feature.js").default} */
+      e.target
+    );
+    if (this.handlingDownUpSequence) {
+      const i = C(t);
+      i in this.pendingFeatures_ || (this.pendingFeatures_[i] = t);
+    } else
+      this.updateFeature_(t);
+  }
+  /**
+   * Handle pointer up events.
+   * @param {import("../MapBrowserEvent.js").default} evt Event.
+   * @return {boolean} If the event was consumed.
+   */
+  handleUpEvent(e) {
+    const t = Object.values(this.pendingFeatures_);
+    return t.length && (t.forEach(this.updateFeature_.bind(this)), this.pendingFeatures_ = {}), !1;
+  }
+  /**
+   * Remove a feature from the collection of features that we may snap to.
+   * @param {import("../Feature.js").default} feature Feature
+   * @param {boolean} [unlisten] Whether to unlisten to the feature change
+   *     or not. Defaults to `true`.
+   * @api
+   */
+  removeFeature(e, t) {
+    const i = t !== void 0 ? t : !0, n = C(e), s = this.indexedFeaturesExtents_[n];
+    if (s) {
+      const r = this.rBush_, o = [];
+      r.forEachInExtent(s, function(a) {
+        e === a.feature && o.push(a);
+      });
+      for (let a = o.length - 1; a >= 0; --a)
+        r.remove(o[a]);
+    }
+    i && (me(this.featureChangeListenerKeys_[n]), delete this.featureChangeListenerKeys_[n]);
+  }
+  /**
+   * Remove the interaction from its current map and attach it to the new map.
+   * Subclasses may set up event handlers to get notified about changes to
+   * the map here.
+   * @param {import("../Map.js").default} map Map.
+   */
+  setMap(e) {
+    const t = this.getMap(), i = this.featuresListenerKeys_, n = (
+      /** @type {Array<import("../Feature.js").default>} */
+      this.getFeatures_()
+    );
+    t && (i.forEach(me), i.length = 0, this.rBush_.clear(), Object.values(this.featureChangeListenerKeys_).forEach(me), this.featureChangeListenerKeys_ = {}), super.setMap(e), e && (this.features_ ? i.push(
+      B(
+        this.features_,
+        A.ADD,
+        this.handleFeatureAdd_,
+        this
+      ),
+      B(
+        this.features_,
+        A.REMOVE,
+        this.handleFeatureRemove_,
+        this
+      )
+    ) : this.source_ && i.push(
+      B(
+        this.source_,
+        he.ADDFEATURE,
+        this.handleFeatureAdd_,
+        this
+      ),
+      B(
+        this.source_,
+        he.REMOVEFEATURE,
+        this.handleFeatureRemove_,
+        this
+      )
+    ), n.forEach((s) => this.addFeature(s)));
+  }
+  /**
+   * @param {import("../pixel.js").Pixel} pixel Pixel
+   * @param {import("../coordinate.js").Coordinate} pixelCoordinate Coordinate
+   * @param {import("../Map.js").default} map Map.
+   * @return {Result|null} Snap result
+   */
+  snapTo(e, t, i) {
+    i.getView().getProjection();
+    const n = p(t), s = it(
+      nt(
+        P([n]),
+        i.getView().getResolution() * this.pixelTolerance_
+      )
+    ), r = this.rBush_.getInExtent(s), o = r.length;
+    if (o === 0)
+      return null;
+    let a, h = 1 / 0, c;
+    const u = this.pixelTolerance_ * this.pixelTolerance_, g = () => {
+      if (a) {
+        const d = i.getPixelFromCoordinate(a);
+        if (O(e, d) <= u)
+          return {
+            vertex: a,
+            vertexPixel: [
+              Math.round(d[0]),
+              Math.round(d[1])
+            ],
+            feature: c
+          };
+      }
+      return null;
+    };
+    if (this.vertex_) {
+      for (let f = 0; f < o; ++f) {
+        const _ = r[f];
+        _.feature.getGeometry().getType() !== "Circle" && _.segment.forEach((x) => {
+          const T = p(x), F = O(n, T);
+          F < h && (a = x, h = F, c = _.feature);
+        });
+      }
+      const d = g();
+      if (d)
+        return d;
+    }
+    if (this.edge_) {
+      for (let f = 0; f < o; ++f) {
+        let _ = null;
+        const x = r[f];
+        if (x.feature.getGeometry().getType() === "Circle") {
+          let T = x.feature.getGeometry();
+          _ = Wt(
+            n,
+            /** @type {import("../geom/Circle.js").default} */
+            T
+          );
+        } else {
+          const [T, F] = x.segment;
+          F && (pe[0] = p(T), pe[1] = p(F), _ = st(n, pe));
+        }
+        if (_) {
+          const T = O(n, _);
+          T < h && (a = de(_), h = T);
+        }
+      }
+      const d = g();
+      if (d)
+        return d;
+    }
+    return null;
+  }
+  /**
+   * @param {import("../Feature.js").default} feature Feature
+   * @private
+   */
+  updateFeature_(e) {
+    this.removeFeature(e, !1), this.addFeature(e, !1);
+  }
+  /**
+   * @param {Array<Array<import('../coordinate.js').Coordinate>>} segments Segments
+   * @param {import("../geom/Circle.js").default} geometry Geometry.
+   * @private
+   */
+  segmentCircleGeometry_(e, t) {
+    this.getMap().getView().getProjection();
+    const s = Ht(t).getCoordinates()[0];
+    for (let r = 0, o = s.length - 1; r < o; ++r)
+      e.push(s.slice(r, r + 2));
+  }
+  /**
+   * @param {Array<Array<import('../coordinate.js').Coordinate>>} segments Segments
+   * @param {import("../geom/GeometryCollection.js").default} geometry Geometry.
+   * @private
+   */
+  segmentGeometryCollectionGeometry_(e, t) {
+    const i = t.getGeometriesArray();
+    for (let n = 0; n < i.length; ++n) {
+      const s = this.GEOMETRY_SEGMENTERS_[i[n].getType()];
+      s && s(e, i[n]);
+    }
+  }
+  /**
+   * @param {Array<Array<import('../coordinate.js').Coordinate>>} segments Segments
+   * @param {import("../geom/LineString.js").default} geometry Geometry.
+   * @private
+   */
+  segmentLineStringGeometry_(e, t) {
+    const i = t.getCoordinates();
+    for (let n = 0, s = i.length - 1; n < s; ++n)
+      e.push(i.slice(n, n + 2));
+  }
+  /**
+   * @param {Array<Array<import('../coordinate.js').Coordinate>>} segments Segments
+   * @param {import("../geom/MultiLineString.js").default} geometry Geometry.
+   * @private
+   */
+  segmentMultiLineStringGeometry_(e, t) {
+    const i = t.getCoordinates();
+    for (let n = 0, s = i.length; n < s; ++n) {
+      const r = i[n];
+      for (let o = 0, a = r.length - 1; o < a; ++o)
+        e.push(r.slice(o, o + 2));
+    }
+  }
+  /**
+   * @param {Array<Array<import('../coordinate.js').Coordinate>>} segments Segments
+   * @param {import("../geom/MultiPoint.js").default} geometry Geometry.
+   * @private
+   */
+  segmentMultiPointGeometry_(e, t) {
+    t.getCoordinates().forEach((i) => {
+      e.push([i]);
+    });
+  }
+  /**
+   * @param {Array<Array<import('../coordinate.js').Coordinate>>} segments Segments
+   * @param {import("../geom/MultiPolygon.js").default} geometry Geometry.
+   * @private
+   */
+  segmentMultiPolygonGeometry_(e, t) {
+    const i = t.getCoordinates();
+    for (let n = 0, s = i.length; n < s; ++n) {
+      const r = i[n];
+      for (let o = 0, a = r.length; o < a; ++o) {
+        const h = r[o];
+        for (let c = 0, u = h.length - 1; c < u; ++c)
+          e.push(h.slice(c, c + 2));
+      }
+    }
+  }
+  /**
+   * @param {Array<Array<import('../coordinate.js').Coordinate>>} segments Segments
+   * @param {import("../geom/Point.js").default} geometry Geometry.
+   * @private
+   */
+  segmentPointGeometry_(e, t) {
+    e.push([t.getCoordinates()]);
+  }
+  /**
+   * @param {Array<Array<import('../coordinate.js').Coordinate>>} segments Segments
+   * @param {import("../geom/Polygon.js").default} geometry Geometry.
+   * @private
+   */
+  segmentPolygonGeometry_(e, t) {
+    const i = t.getCoordinates();
+    for (let n = 0, s = i.length; n < s; ++n) {
+      const r = i[n];
+      for (let o = 0, a = r.length - 1; o < a; ++o)
+        e.push(r.slice(o, o + 2));
+    }
+  }
+}
+class Ti {
+  /**
+   * @param {number} [highWaterMark] High water mark.
+   */
+  constructor(e) {
+    this.highWaterMark = e !== void 0 ? e : 2048, this.count_ = 0, this.entries_ = {}, this.oldest_ = null, this.newest_ = null;
+  }
+  /**
+   * @return {boolean} Can expire cache.
+   */
+  canExpireCache() {
+    return this.highWaterMark > 0 && this.getCount() > this.highWaterMark;
+  }
+  /**
+   * Expire the cache.
+   * @param {!Object<string, boolean>} [keep] Keys to keep. To be implemented by subclasses.
+   */
+  expireCache(e) {
+    for (; this.canExpireCache(); )
+      this.pop();
+  }
+  /**
+   * FIXME empty description for jsdoc
+   */
+  clear() {
+    this.count_ = 0, this.entries_ = {}, this.oldest_ = null, this.newest_ = null;
+  }
+  /**
+   * @param {string} key Key.
+   * @return {boolean} Contains key.
+   */
+  containsKey(e) {
+    return this.entries_.hasOwnProperty(e);
+  }
+  /**
+   * @param {function(T, string, LRUCache<T>): ?} f The function
+   *     to call for every entry from the oldest to the newer. This function takes
+   *     3 arguments (the entry value, the entry key and the LRUCache object).
+   *     The return value is ignored.
+   */
+  forEach(e) {
+    let t = this.oldest_;
+    for (; t; )
+      e(t.value_, t.key_, this), t = t.newer;
+  }
+  /**
+   * @param {string} key Key.
+   * @param {*} [options] Options (reserved for subclasses).
+   * @return {T} Value.
+   */
+  get(e, t) {
+    const i = this.entries_[e];
+    return M(i !== void 0, 15), i === this.newest_ || (i === this.oldest_ ? (this.oldest_ = /** @type {Entry} */
+    this.oldest_.newer, this.oldest_.older = null) : (i.newer.older = i.older, i.older.newer = i.newer), i.newer = null, i.older = this.newest_, this.newest_.newer = i, this.newest_ = i), i.value_;
+  }
+  /**
+   * Remove an entry from the cache.
+   * @param {string} key The entry key.
+   * @return {T} The removed entry.
+   */
+  remove(e) {
+    const t = this.entries_[e];
+    return M(t !== void 0, 15), t === this.newest_ ? (this.newest_ = /** @type {Entry} */
+    t.older, this.newest_ && (this.newest_.newer = null)) : t === this.oldest_ ? (this.oldest_ = /** @type {Entry} */
+    t.newer, this.oldest_ && (this.oldest_.older = null)) : (t.newer.older = t.older, t.older.newer = t.newer), delete this.entries_[e], --this.count_, t.value_;
+  }
+  /**
+   * @return {number} Count.
+   */
+  getCount() {
+    return this.count_;
+  }
+  /**
+   * @return {Array<string>} Keys.
+   */
+  getKeys() {
+    const e = new Array(this.count_);
+    let t = 0, i;
+    for (i = this.newest_; i; i = i.older)
+      e[t++] = i.key_;
+    return e;
+  }
+  /**
+   * @return {Array<T>} Values.
+   */
+  getValues() {
+    const e = new Array(this.count_);
+    let t = 0, i;
+    for (i = this.newest_; i; i = i.older)
+      e[t++] = i.value_;
+    return e;
+  }
+  /**
+   * @return {T} Last value.
+   */
+  peekLast() {
+    return this.oldest_.value_;
+  }
+  /**
+   * @return {string} Last key.
+   */
+  peekLastKey() {
+    return this.oldest_.key_;
+  }
+  /**
+   * Get the key of the newest item in the cache.  Throws if the cache is empty.
+   * @return {string} The newest key.
+   */
+  peekFirstKey() {
+    return this.newest_.key_;
+  }
+  /**
+   * Return an entry without updating least recently used time.
+   * @param {string} key Key.
+   * @return {T} Value.
+   */
+  peek(e) {
+    if (this.containsKey(e))
+      return this.entries_[e].value_;
+  }
+  /**
+   * @return {T} value Value.
+   */
+  pop() {
+    const e = this.oldest_;
+    return delete this.entries_[e.key_], e.newer && (e.newer.older = null), this.oldest_ = /** @type {Entry} */
+    e.newer, this.oldest_ || (this.newest_ = null), --this.count_, e.value_;
+  }
+  /**
+   * @param {string} key Key.
+   * @param {T} value Value.
+   */
+  replace(e, t) {
+    this.get(e), this.entries_[e].value_ = t;
+  }
+  /**
+   * @param {string} key Key.
+   * @param {T} value Value.
+   */
+  set(e, t) {
+    M(!(e in this.entries_), 16);
+    const i = {
+      key_: e,
+      newer: null,
+      older: this.newest_,
+      value_: t
+    };
+    this.newest_ ? this.newest_.newer = i : this.oldest_ = i, this.newest_ = i, this.entries_[e] = i, ++this.count_;
+  }
+  /**
+   * Set a maximum number of entries for the cache.
+   * @param {number} size Cache size.
+   * @api
+   */
+  setSize(e) {
+    this.highWaterMark = e;
+  }
+}
+function Ye(l, e, t, i) {
+  return i !== void 0 ? (i[0] = l, i[1] = e, i[2] = t, i) : [l, e, t];
+}
+function fe(l, e, t) {
+  return l + "/" + e + "/" + t;
+}
+function ut(l) {
+  return fe(l[0], l[1], l[2]);
+}
+function Fi(l) {
+  return l.split("/").map(Number);
+}
+function pi(l) {
+  return (l[1] << l[0]) + l[2];
+}
+function Ei(l, e) {
+  const t = l[0], i = l[1], n = l[2];
+  if (e.getMinZoom() > t || t > e.getMaxZoom())
+    return !1;
+  const s = e.getFullTileRange(t);
+  return s ? s.containsXY(i, n) : !0;
+}
+class dt extends Ti {
+  clear() {
+    for (; this.getCount() > 0; )
+      this.pop().release();
+    super.clear();
+  }
+  /**
+   * @param {!Object<string, boolean>} usedTiles Used tiles.
+   */
+  expireCache(e) {
+    for (; this.canExpireCache() && !(this.peekLast().getKey() in e); )
+      this.pop().release();
+  }
+  /**
+   * Prune all tiles from the cache that don't have the same z as the newest tile.
+   */
+  pruneExceptNewestZ() {
+    if (this.getCount() === 0)
+      return;
+    const e = this.peekFirstKey(), i = Fi(e)[0];
+    this.forEach((n) => {
+      n.tileCoord[0] !== i && (this.remove(ut(n.tileCoord)), n.release());
+    });
+  }
+}
+const Ee = {
+  /**
+   * Triggered when a tile starts loading.
+   * @event module:ol/source/Tile.TileSourceEvent#tileloadstart
+   * @api
+   */
+  TILELOADSTART: "tileloadstart",
+  /**
+   * Triggered when a tile finishes loading, either when its data is loaded,
+   * or when loading was aborted because the tile is no longer needed.
+   * @event module:ol/source/Tile.TileSourceEvent#tileloadend
+   * @api
+   */
+  TILELOADEND: "tileloadend",
+  /**
+   * Triggered if tile loading results in an error. Note that this is not the
+   * right place to re-fetch tiles. See {@link module:ol/ImageTile~ImageTile#load}
+   * for details.
+   * @event module:ol/source/Tile.TileSourceEvent#tileloaderror
+   * @api
+   */
+  TILELOADERROR: "tileloaderror"
+}, K = [0, 0, 0], R = 5;
+class gt {
+  /**
+   * @param {Options} options Tile grid options.
+   */
+  constructor(e) {
+    this.minZoom = e.minZoom !== void 0 ? e.minZoom : 0, this.resolutions_ = e.resolutions, M(
+      St(
+        this.resolutions_,
+        function(n, s) {
+          return s - n;
+        }
+      ),
+      17
+    );
+    let t;
+    if (!e.origins) {
+      for (let n = 0, s = this.resolutions_.length - 1; n < s; ++n)
+        if (!t)
+          t = this.resolutions_[n] / this.resolutions_[n + 1];
+        else if (this.resolutions_[n] / this.resolutions_[n + 1] !== t) {
+          t = void 0;
+          break;
+        }
+    }
+    this.zoomFactor_ = t, this.maxZoom = this.resolutions_.length - 1, this.origin_ = e.origin !== void 0 ? e.origin : null, this.origins_ = null, e.origins !== void 0 && (this.origins_ = e.origins, M(this.origins_.length == this.resolutions_.length, 20));
+    const i = e.extent;
+    i !== void 0 && !this.origin_ && !this.origins_ && (this.origin_ = $t(i)), M(
+      !this.origin_ && this.origins_ || this.origin_ && !this.origins_,
+      18
+    ), this.tileSizes_ = null, e.tileSizes !== void 0 && (this.tileSizes_ = e.tileSizes, M(this.tileSizes_.length == this.resolutions_.length, 19)), this.tileSize_ = e.tileSize !== void 0 ? e.tileSize : this.tileSizes_ ? null : ot, M(
+      !this.tileSize_ && this.tileSizes_ || this.tileSize_ && !this.tileSizes_,
+      22
+    ), this.extent_ = i !== void 0 ? i : null, this.fullTileRanges_ = null, this.tmpSize_ = [0, 0], this.tmpExtent_ = [0, 0, 0, 0], e.sizes !== void 0 ? this.fullTileRanges_ = e.sizes.map(function(n, s) {
+      const r = new jt(
+        Math.min(0, n[0]),
+        Math.max(n[0] - 1, -1),
+        Math.min(0, n[1]),
+        Math.max(n[1] - 1, -1)
+      );
+      if (i) {
+        const o = this.getTileRangeForExtentAndZ(i, s);
+        r.minX = Math.max(o.minX, r.minX), r.maxX = Math.min(o.maxX, r.maxX), r.minY = Math.max(o.minY, r.minY), r.maxY = Math.min(o.maxY, r.maxY);
+      }
+      return r;
+    }, this) : i && this.calculateTileRanges_(i);
+  }
+  /**
+   * Call a function with each tile coordinate for a given extent and zoom level.
+   *
+   * @param {import("../extent.js").Extent} extent Extent.
+   * @param {number} zoom Integer zoom level.
+   * @param {function(import("../tilecoord.js").TileCoord): void} callback Function called with each tile coordinate.
+   * @api
+   */
+  forEachTileCoord(e, t, i) {
+    const n = this.getTileRangeForExtentAndZ(e, t);
+    for (let s = n.minX, r = n.maxX; s <= r; ++s)
+      for (let o = n.minY, a = n.maxY; o <= a; ++o)
+        i([t, s, o]);
+  }
+  /**
+   * @param {import("../tilecoord.js").TileCoord} tileCoord Tile coordinate.
+   * @param {function(number, import("../TileRange.js").default): boolean} callback Callback.
+   * @param {import("../TileRange.js").default} [tempTileRange] Temporary import("../TileRange.js").default object.
+   * @param {import("../extent.js").Extent} [tempExtent] Temporary import("../extent.js").Extent object.
+   * @return {boolean} Callback succeeded.
+   */
+  forEachTileCoordParentTileRange(e, t, i, n) {
+    let s, r, o, a = null, h = e[0] - 1;
+    for (this.zoomFactor_ === 2 ? (r = e[1], o = e[2]) : a = this.getTileCoordExtent(e, n); h >= this.minZoom; ) {
+      if (this.zoomFactor_ === 2 ? (r = Math.floor(r / 2), o = Math.floor(o / 2), s = z(r, r, o, o, i)) : s = this.getTileRangeForExtentAndZ(
+        a,
+        h,
+        i
+      ), t(h, s))
+        return !0;
+      --h;
+    }
+    return !1;
+  }
+  /**
+   * Get the extent for this tile grid, if it was configured.
+   * @return {import("../extent.js").Extent} Extent.
+   * @api
+   */
+  getExtent() {
+    return this.extent_;
+  }
+  /**
+   * Get the maximum zoom level for the grid.
+   * @return {number} Max zoom.
+   * @api
+   */
+  getMaxZoom() {
+    return this.maxZoom;
+  }
+  /**
+   * Get the minimum zoom level for the grid.
+   * @return {number} Min zoom.
+   * @api
+   */
+  getMinZoom() {
+    return this.minZoom;
+  }
+  /**
+   * Get the origin for the grid at the given zoom level.
+   * @param {number} z Integer zoom level.
+   * @return {import("../coordinate.js").Coordinate} Origin.
+   * @api
+   */
+  getOrigin(e) {
+    return this.origin_ ? this.origin_ : this.origins_[e];
+  }
+  /**
+   * Get the resolution for the given zoom level.
+   * @param {number} z Integer zoom level.
+   * @return {number} Resolution.
+   * @api
+   */
+  getResolution(e) {
+    return this.resolutions_[e];
+  }
+  /**
+   * Get the list of resolutions for the tile grid.
+   * @return {Array<number>} Resolutions.
+   * @api
+   */
+  getResolutions() {
+    return this.resolutions_;
+  }
+  /**
+   * @param {import("../tilecoord.js").TileCoord} tileCoord Tile coordinate.
+   * @param {import("../TileRange.js").default} [tempTileRange] Temporary import("../TileRange.js").default object.
+   * @param {import("../extent.js").Extent} [tempExtent] Temporary import("../extent.js").Extent object.
+   * @return {import("../TileRange.js").default|null} Tile range.
+   */
+  getTileCoordChildTileRange(e, t, i) {
+    if (e[0] < this.maxZoom) {
+      if (this.zoomFactor_ === 2) {
+        const s = e[1] * 2, r = e[2] * 2;
+        return z(
+          s,
+          s + 1,
+          r,
+          r + 1,
+          t
+        );
+      }
+      const n = this.getTileCoordExtent(
+        e,
+        i || this.tmpExtent_
+      );
+      return this.getTileRangeForExtentAndZ(
+        n,
+        e[0] + 1,
+        t
+      );
+    }
+    return null;
+  }
+  /**
+   * @param {import("../tilecoord.js").TileCoord} tileCoord Tile coordinate.
+   * @param {number} z Integer zoom level.
+   * @param {import("../TileRange.js").default} [tempTileRange] Temporary import("../TileRange.js").default object.
+   * @return {import("../TileRange.js").default|null} Tile range.
+   */
+  getTileRangeForTileCoordAndZ(e, t, i) {
+    if (t > this.maxZoom || t < this.minZoom)
+      return null;
+    const n = e[0], s = e[1], r = e[2];
+    if (t === n)
+      return z(
+        s,
+        r,
+        s,
+        r,
+        i
+      );
+    if (this.zoomFactor_) {
+      const a = Math.pow(this.zoomFactor_, t - n), h = Math.floor(s * a), c = Math.floor(r * a);
+      if (t < n)
+        return z(h, h, c, c, i);
+      const u = Math.floor(a * (s + 1)) - 1, g = Math.floor(a * (r + 1)) - 1;
+      return z(h, u, c, g, i);
+    }
+    const o = this.getTileCoordExtent(e, this.tmpExtent_);
+    return this.getTileRangeForExtentAndZ(o, t, i);
+  }
+  /**
+   * Get a tile range for the given extent and integer zoom level.
+   * @param {import("../extent.js").Extent} extent Extent.
+   * @param {number} z Integer zoom level.
+   * @param {import("../TileRange.js").default} [tempTileRange] Temporary tile range object.
+   * @return {import("../TileRange.js").default} Tile range.
+   */
+  getTileRangeForExtentAndZ(e, t, i) {
+    this.getTileCoordForXYAndZ_(e[0], e[3], t, !1, K);
+    const n = K[1], s = K[2];
+    this.getTileCoordForXYAndZ_(e[2], e[1], t, !0, K);
+    const r = K[1], o = K[2];
+    return z(n, r, s, o, i);
+  }
+  /**
+   * @param {import("../tilecoord.js").TileCoord} tileCoord Tile coordinate.
+   * @return {import("../coordinate.js").Coordinate} Tile center.
+   */
+  getTileCoordCenter(e) {
+    const t = this.getOrigin(e[0]), i = this.getResolution(e[0]), n = I(this.getTileSize(e[0]), this.tmpSize_);
+    return [
+      t[0] + (e[1] + 0.5) * n[0] * i,
+      t[1] - (e[2] + 0.5) * n[1] * i
+    ];
+  }
+  /**
+   * Get the extent of a tile coordinate.
+   *
+   * @param {import("../tilecoord.js").TileCoord} tileCoord Tile coordinate.
+   * @param {import("../extent.js").Extent} [tempExtent] Temporary extent object.
+   * @return {import("../extent.js").Extent} Extent.
+   * @api
+   */
+  getTileCoordExtent(e, t) {
+    const i = this.getOrigin(e[0]), n = this.getResolution(e[0]), s = I(this.getTileSize(e[0]), this.tmpSize_), r = i[0] + e[1] * s[0] * n, o = i[1] - (e[2] + 1) * s[1] * n, a = r + s[0] * n, h = o + s[1] * n;
+    return at(r, o, a, h, t);
+  }
+  /**
+   * Get the tile coordinate for the given map coordinate and resolution.  This
+   * method considers that coordinates that intersect tile boundaries should be
+   * assigned the higher tile coordinate.
+   *
+   * @param {import("../coordinate.js").Coordinate} coordinate Coordinate.
+   * @param {number} resolution Resolution.
+   * @param {import("../tilecoord.js").TileCoord} [opt_tileCoord] Destination import("../tilecoord.js").TileCoord object.
+   * @return {import("../tilecoord.js").TileCoord} Tile coordinate.
+   * @api
+   */
+  getTileCoordForCoordAndResolution(e, t, i) {
+    return this.getTileCoordForXYAndResolution_(
+      e[0],
+      e[1],
+      t,
+      !1,
+      i
+    );
+  }
+  /**
+   * Note that this method should not be called for resolutions that correspond
+   * to an integer zoom level.  Instead call the `getTileCoordForXYAndZ_` method.
+   * @param {number} x X.
+   * @param {number} y Y.
+   * @param {number} resolution Resolution (for a non-integer zoom level).
+   * @param {boolean} reverseIntersectionPolicy Instead of letting edge
+   *     intersections go to the higher tile coordinate, let edge intersections
+   *     go to the lower tile coordinate.
+   * @param {import("../tilecoord.js").TileCoord} [opt_tileCoord] Temporary import("../tilecoord.js").TileCoord object.
+   * @return {import("../tilecoord.js").TileCoord} Tile coordinate.
+   * @private
+   */
+  getTileCoordForXYAndResolution_(e, t, i, n, s) {
+    const r = this.getZForResolution(i), o = i / this.getResolution(r), a = this.getOrigin(r), h = I(this.getTileSize(r), this.tmpSize_);
+    let c = o * (e - a[0]) / i / h[0], u = o * (a[1] - t) / i / h[1];
+    return n ? (c = ee(c, R) - 1, u = ee(u, R) - 1) : (c = te(c, R), u = te(u, R)), Ye(r, c, u, s);
+  }
+  /**
+   * Although there is repetition between this method and `getTileCoordForXYAndResolution_`,
+   * they should have separate implementations.  This method is for integer zoom
+   * levels.  The other method should only be called for resolutions corresponding
+   * to non-integer zoom levels.
+   * @param {number} x Map x coordinate.
+   * @param {number} y Map y coordinate.
+   * @param {number} z Integer zoom level.
+   * @param {boolean} reverseIntersectionPolicy Instead of letting edge
+   *     intersections go to the higher tile coordinate, let edge intersections
+   *     go to the lower tile coordinate.
+   * @param {import("../tilecoord.js").TileCoord} [opt_tileCoord] Temporary import("../tilecoord.js").TileCoord object.
+   * @return {import("../tilecoord.js").TileCoord} Tile coordinate.
+   * @private
+   */
+  getTileCoordForXYAndZ_(e, t, i, n, s) {
+    const r = this.getOrigin(i), o = this.getResolution(i), a = I(this.getTileSize(i), this.tmpSize_);
+    let h = (e - r[0]) / o / a[0], c = (r[1] - t) / o / a[1];
+    return n ? (h = ee(h, R) - 1, c = ee(c, R) - 1) : (h = te(h, R), c = te(c, R)), Ye(i, h, c, s);
+  }
+  /**
+   * Get a tile coordinate given a map coordinate and zoom level.
+   * @param {import("../coordinate.js").Coordinate} coordinate Coordinate.
+   * @param {number} z Zoom level.
+   * @param {import("../tilecoord.js").TileCoord} [opt_tileCoord] Destination import("../tilecoord.js").TileCoord object.
+   * @return {import("../tilecoord.js").TileCoord} Tile coordinate.
+   * @api
+   */
+  getTileCoordForCoordAndZ(e, t, i) {
+    return this.getTileCoordForXYAndZ_(
+      e[0],
+      e[1],
+      t,
+      !1,
+      i
+    );
+  }
+  /**
+   * @param {import("../tilecoord.js").TileCoord} tileCoord Tile coordinate.
+   * @return {number} Tile resolution.
+   */
+  getTileCoordResolution(e) {
+    return this.resolutions_[e[0]];
+  }
+  /**
+   * Get the tile size for a zoom level. The type of the return value matches the
+   * `tileSize` or `tileSizes` that the tile grid was configured with. To always
+   * get an {@link import("../size.js").Size}, run the result through {@link module:ol/size.toSize}.
+   * @param {number} z Z.
+   * @return {number|import("../size.js").Size} Tile size.
+   * @api
+   */
+  getTileSize(e) {
+    return this.tileSize_ ? this.tileSize_ : this.tileSizes_[e];
+  }
+  /**
+   * @param {number} z Zoom level.
+   * @return {import("../TileRange.js").default} Extent tile range for the specified zoom level.
+   */
+  getFullTileRange(e) {
+    return this.fullTileRanges_ ? this.fullTileRanges_[e] : this.extent_ ? this.getTileRangeForExtentAndZ(this.extent_, e) : null;
+  }
+  /**
+   * @param {number} resolution Resolution.
+   * @param {number|import("../array.js").NearestDirectionFunction} [opt_direction]
+   *     If 0, the nearest resolution will be used.
+   *     If 1, the nearest higher resolution (lower Z) will be used. If -1, the
+   *     nearest lower resolution (higher Z) will be used. Default is 0.
+   *     Use a {@link module:ol/array~NearestDirectionFunction} for more precise control.
+   *
+   * For example to change tile Z at the midpoint of zoom levels
+   * ```js
+   * function(value, high, low) {
+   *   return value - low * Math.sqrt(high / low);
+   * }
+   * ```
+   * @return {number} Z.
+   * @api
+   */
+  getZForResolution(e, t) {
+    const i = wt(
+      this.resolutions_,
+      e,
+      t || 0
+    );
+    return $e(i, this.minZoom, this.maxZoom);
+  }
+  /**
+   * The tile with the provided tile coordinate intersects the given viewport.
+   * @param {import('../tilecoord.js').TileCoord} tileCoord Tile coordinate.
+   * @param {Array<number>} viewport Viewport as returned from {@link module:ol/extent.getRotatedViewport}.
+   * @return {boolean} The tile with the provided tile coordinate intersects the given viewport.
+   */
+  tileCoordIntersectsViewport(e, t) {
+    return Jt(
+      t,
+      0,
+      t.length,
+      2,
+      this.getTileCoordExtent(e)
+    );
+  }
+  /**
+   * @param {!import("../extent.js").Extent} extent Extent for this tile grid.
+   * @private
+   */
+  calculateTileRanges_(e) {
+    const t = this.resolutions_.length, i = new Array(t);
+    for (let n = this.minZoom; n < t; ++n)
+      i[n] = this.getTileRangeForExtentAndZ(e, n);
+    this.fullTileRanges_ = i;
+  }
+}
+function ft(l) {
+  let e = l.getDefaultTileGrid();
+  return e || (e = Li(l), l.setDefaultTileGrid(e)), e;
+}
+function Si(l, e, t) {
+  const i = e[0], n = l.getTileCoordCenter(e), s = Re(t);
+  if (!ni(s, n)) {
+    const r = lt(s), o = Math.ceil(
+      (s[0] - n[0]) / r
+    );
+    return n[0] += r * o, l.getTileCoordForCoordAndZ(n, i);
+  }
+  return e;
+}
+function wi(l, e, t, i) {
+  i = i !== void 0 ? i : "top-left";
+  const n = _t(l, e, t);
+  return new gt({
+    extent: l,
+    origin: ti(l, i),
+    resolutions: n,
+    tileSize: t
+  });
+}
+function Pi(l) {
+  const e = l || {}, t = e.extent || Ge("EPSG:3857").getExtent(), i = {
+    extent: t,
+    minZoom: e.minZoom,
+    tileSize: e.tileSize,
+    resolutions: _t(
+      t,
+      e.maxZoom,
+      e.tileSize,
+      e.maxResolution
+    )
+  };
+  return new gt(i);
+}
+function _t(l, e, t, i) {
+  e = e !== void 0 ? e : ii, t = I(t !== void 0 ? t : ot);
+  const n = Qt(l), s = lt(l);
+  i = i > 0 ? i : Math.max(s / t[0], n / t[1]);
+  const r = e + 1, o = new Array(r);
+  for (let a = 0; a < r; ++a)
+    o[a] = i / Math.pow(2, a);
+  return o;
+}
+function Li(l, e, t, i) {
+  const n = Re(l);
+  return wi(n, e, t, i);
+}
+function Re(l) {
+  l = Ge(l);
+  let e = l.getExtent();
+  if (!e) {
+    const t = 180 * ei.degrees / l.getMetersPerUnit();
+    e = at(-t, -t, t, t);
+  }
+  return e;
+}
+class Di extends si {
+  /**
+   * @param {Options} options SourceTile source options.
+   */
+  constructor(e) {
+    super({
+      attributions: e.attributions,
+      attributionsCollapsible: e.attributionsCollapsible,
+      projection: e.projection,
+      state: e.state,
+      wrapX: e.wrapX,
+      interpolate: e.interpolate
+    }), this.on, this.once, this.un, this.opaque_ = e.opaque !== void 0 ? e.opaque : !1, this.tilePixelRatio_ = e.tilePixelRatio !== void 0 ? e.tilePixelRatio : 1, this.tileGrid = e.tileGrid !== void 0 ? e.tileGrid : null;
+    const t = [256, 256];
+    this.tileGrid && I(this.tileGrid.getTileSize(this.tileGrid.getMinZoom()), t), this.tileCache = new dt(e.cacheSize || 0), this.tmpSize = [0, 0], this.key_ = e.key || "", this.tileOptions = {
+      transition: e.transition,
+      interpolate: e.interpolate
+    }, this.zDirection = e.zDirection ? e.zDirection : 0;
+  }
+  /**
+   * @return {boolean} Can expire cache.
+   */
+  canExpireCache() {
+    return this.tileCache.canExpireCache();
+  }
+  /**
+   * @param {import("../proj/Projection.js").default} projection Projection.
+   * @param {!Object<string, boolean>} usedTiles Used tiles.
+   */
+  expireCache(e, t) {
+    const i = this.getTileCacheForProjection(e);
+    i && i.expireCache(t);
+  }
+  /**
+   * @param {import("../proj/Projection.js").default} projection Projection.
+   * @param {number} z Zoom level.
+   * @param {import("../TileRange.js").default} tileRange Tile range.
+   * @param {function(import("../Tile.js").default):(boolean|void)} callback Called with each
+   *     loaded tile.  If the callback returns `false`, the tile will not be
+   *     considered loaded.
+   * @return {boolean} The tile range is fully covered with loaded tiles.
+   */
+  forEachLoadedTile(e, t, i, n) {
+    const s = this.getTileCacheForProjection(e);
+    if (!s)
+      return !1;
+    let r = !0, o, a, h;
+    for (let c = i.minX; c <= i.maxX; ++c)
+      for (let u = i.minY; u <= i.maxY; ++u)
+        a = fe(t, c, u), h = !1, s.containsKey(a) && (o = /** @type {!import("../Tile.js").default} */
+        s.get(a), h = o.getState() === j.LOADED, h && (h = n(o) !== !1)), h || (r = !1);
+    return r;
+  }
+  /**
+   * @param {import("../proj/Projection.js").default} projection Projection.
+   * @return {number} Gutter.
+   */
+  getGutterForProjection(e) {
+    return 0;
+  }
+  /**
+   * Return the key to be used for all tiles in the source.
+   * @return {string} The key for all tiles.
+   */
+  getKey() {
+    return this.key_;
+  }
+  /**
+   * Set the value to be used as the key for all tiles in the source.
+   * @param {string} key The key for tiles.
+   * @protected
+   */
+  setKey(e) {
+    this.key_ !== e && (this.key_ = e, this.changed());
+  }
+  /**
+   * @param {import("../proj/Projection.js").default} projection Projection.
+   * @return {boolean} Opaque.
+   */
+  getOpaque(e) {
+    return this.opaque_;
+  }
+  /**
+   * @param {import("../proj/Projection").default} [projection] Projection.
+   * @return {Array<number>|null} Resolutions.
+   */
+  getResolutions(e) {
+    const t = e ? this.getTileGridForProjection(e) : this.tileGrid;
+    return t ? t.getResolutions() : null;
+  }
+  /**
+   * @abstract
+   * @param {number} z Tile coordinate z.
+   * @param {number} x Tile coordinate x.
+   * @param {number} y Tile coordinate y.
+   * @param {number} pixelRatio Pixel ratio.
+   * @param {import("../proj/Projection.js").default} projection Projection.
+   * @return {!import("../Tile.js").default} Tile.
+   */
+  getTile(e, t, i, n, s) {
+    return Pt();
+  }
+  /**
+   * Return the tile grid of the tile source.
+   * @return {import("../tilegrid/TileGrid.js").default|null} Tile grid.
+   * @api
+   */
+  getTileGrid() {
+    return this.tileGrid;
+  }
+  /**
+   * @param {import("../proj/Projection.js").default} projection Projection.
+   * @return {!import("../tilegrid/TileGrid.js").default} Tile grid.
+   */
+  getTileGridForProjection(e) {
+    return this.tileGrid ? this.tileGrid : ft(e);
+  }
+  /**
+   * @param {import("../proj/Projection.js").default} projection Projection.
+   * @return {import("../TileCache.js").default} Tile cache.
+   * @protected
+   */
+  getTileCacheForProjection(e) {
+    const t = this.getProjection();
+    return M(
+      t === null || N(t, e),
+      68
+      // A VectorTile source can only be rendered if it has a projection compatible with the view projection.
+    ), this.tileCache;
+  }
+  /**
+   * Get the tile pixel ratio for this source. Subclasses may override this
+   * method, which is meant to return a supported pixel ratio that matches the
+   * provided `pixelRatio` as close as possible.
+   * @param {number} pixelRatio Pixel ratio.
+   * @return {number} Tile pixel ratio.
+   */
+  getTilePixelRatio(e) {
+    return this.tilePixelRatio_;
+  }
+  /**
+   * @param {number} z Z.
+   * @param {number} pixelRatio Pixel ratio.
+   * @param {import("../proj/Projection.js").default} projection Projection.
+   * @return {import("../size.js").Size} Tile size.
+   */
+  getTilePixelSize(e, t, i) {
+    const n = this.getTileGridForProjection(i), s = this.getTilePixelRatio(t), r = I(n.getTileSize(e), this.tmpSize);
+    return s == 1 ? r : Nt(r, s, this.tmpSize);
+  }
+  /**
+   * Returns a tile coordinate wrapped around the x-axis. When the tile coordinate
+   * is outside the resolution and extent range of the tile grid, `null` will be
+   * returned.
+   * @param {import("../tilecoord.js").TileCoord} tileCoord Tile coordinate.
+   * @param {import("../proj/Projection.js").default} [projection] Projection.
+   * @return {import("../tilecoord.js").TileCoord} Tile coordinate to be passed to the tileUrlFunction or
+   *     null if no tile URL should be created for the passed `tileCoord`.
+   */
+  getTileCoordForTileUrlFunction(e, t) {
+    t = t !== void 0 ? t : this.getProjection();
+    const i = this.getTileGridForProjection(t);
+    return this.getWrapX() && t.isGlobal() && (e = Si(i, e, t)), Ei(e, i) ? e : null;
+  }
+  /**
+   * Remove all cached tiles from the source. The next render cycle will fetch new tiles.
+   * @api
+   */
+  clear() {
+    this.tileCache.clear();
+  }
+  refresh() {
+    this.clear(), super.refresh();
+  }
+  /**
+   * Increases the cache size if needed
+   * @param {number} tileCount Minimum number of tiles needed.
+   * @param {import("../proj/Projection.js").default} projection Projection.
+   */
+  updateCacheSize(e, t) {
+    const i = this.getTileCacheForProjection(t);
+    e > i.highWaterMark && (i.highWaterMark = e);
+  }
+  /**
+   * Marks a tile coord as being used, without triggering a load.
+   * @abstract
+   * @param {number} z Tile coordinate z.
+   * @param {number} x Tile coordinate x.
+   * @param {number} y Tile coordinate y.
+   * @param {import("../proj/Projection.js").default} projection Projection.
+   */
+  useTile(e, t, i, n) {
+  }
+}
+class Mi extends J {
+  /**
+   * @param {string} type Type.
+   * @param {import("../Tile.js").default} tile The tile.
+   */
+  constructor(e, t) {
+    super(e), this.tile = t;
+  }
+}
+function ki(l, e) {
+  const t = /\{z\}/g, i = /\{x\}/g, n = /\{y\}/g, s = /\{-y\}/g;
+  return (
+    /**
+     * @param {import("./tilecoord.js").TileCoord} tileCoord Tile Coordinate.
+     * @param {number} pixelRatio Pixel ratio.
+     * @param {import("./proj/Projection.js").default} projection Projection.
+     * @return {string|undefined} Tile URL.
+     */
+    function(r, o, a) {
+      if (r)
+        return l.replace(t, r[0].toString()).replace(i, r[1].toString()).replace(n, r[2].toString()).replace(s, function() {
+          const h = r[0], c = e.getFullTileRange(h);
+          return M(c, 55), (c.getHeight() - r[2] - 1).toString();
+        });
+    }
+  );
+}
+function Gi(l, e) {
+  const t = l.length, i = new Array(t);
+  for (let n = 0; n < t; ++n)
+    i[n] = ki(l[n], e);
+  return vi(i);
+}
+function vi(l) {
+  return l.length === 1 ? l[0] : (
+    /**
+     * @param {import("./tilecoord.js").TileCoord} tileCoord Tile Coordinate.
+     * @param {number} pixelRatio Pixel ratio.
+     * @param {import("./proj/Projection.js").default} projection Projection.
+     * @return {string|undefined} Tile URL.
+     */
+    function(e, t, i) {
+      if (!e)
+        return;
+      const n = pi(e), s = Lt(n, l.length);
+      return l[s](e, t, i);
+    }
+  );
+}
+function Ri(l) {
+  const e = [];
+  let t = /\{([a-z])-([a-z])\}/.exec(l);
+  if (t) {
+    const i = t[1].charCodeAt(0), n = t[2].charCodeAt(0);
+    let s;
+    for (s = i; s <= n; ++s)
+      e.push(l.replace(t[0], String.fromCharCode(s)));
+    return e;
+  }
+  if (t = /\{(\d+)-(\d+)\}/.exec(l), t) {
+    const i = parseInt(t[2], 10);
+    for (let n = parseInt(t[1], 10); n <= i; n++)
+      e.push(l.replace(t[0], n.toString()));
+    return e;
+  }
+  return e.push(l), e;
+}
+class Ae extends Di {
+  /**
+   * @param {Options} options Image tile options.
+   */
+  constructor(e) {
+    super({
+      attributions: e.attributions,
+      cacheSize: e.cacheSize,
+      opaque: e.opaque,
+      projection: e.projection,
+      state: e.state,
+      tileGrid: e.tileGrid,
+      tilePixelRatio: e.tilePixelRatio,
+      wrapX: e.wrapX,
+      transition: e.transition,
+      interpolate: e.interpolate,
+      key: e.key,
+      attributionsCollapsible: e.attributionsCollapsible,
+      zDirection: e.zDirection
+    }), this.generateTileUrlFunction_ = this.tileUrlFunction === Ae.prototype.tileUrlFunction, this.tileLoadFunction = e.tileLoadFunction, e.tileUrlFunction && (this.tileUrlFunction = e.tileUrlFunction), this.urls = null, e.urls ? this.setUrls(e.urls) : e.url && this.setUrl(e.url), this.tileLoadingKeys_ = {};
+  }
+  /**
+   * Return the tile load function of the source.
+   * @return {import("../Tile.js").LoadFunction} TileLoadFunction
+   * @api
+   */
+  getTileLoadFunction() {
+    return this.tileLoadFunction;
+  }
+  /**
+   * Return the tile URL function of the source.
+   * @return {import("../Tile.js").UrlFunction} TileUrlFunction
+   * @api
+   */
+  getTileUrlFunction() {
+    return Object.getPrototypeOf(this).tileUrlFunction === this.tileUrlFunction ? this.tileUrlFunction.bind(this) : this.tileUrlFunction;
+  }
+  /**
+   * Return the URLs used for this source.
+   * When a tileUrlFunction is used instead of url or urls,
+   * null will be returned.
+   * @return {!Array<string>|null} URLs.
+   * @api
+   */
+  getUrls() {
+    return this.urls;
+  }
+  /**
+   * Handle tile change events.
+   * @param {import("../events/Event.js").default} event Event.
+   * @protected
+   */
+  handleTileChange(e) {
+    const t = (
+      /** @type {import("../Tile.js").default} */
+      e.target
+    ), i = C(t), n = t.getState();
+    let s;
+    n == j.LOADING ? (this.tileLoadingKeys_[i] = !0, s = Ee.TILELOADSTART) : i in this.tileLoadingKeys_ && (delete this.tileLoadingKeys_[i], s = n == j.ERROR ? Ee.TILELOADERROR : n == j.LOADED ? Ee.TILELOADEND : void 0), s != null && this.dispatchEvent(new Mi(s, t));
+  }
+  /**
+   * Set the tile load function of the source.
+   * @param {import("../Tile.js").LoadFunction} tileLoadFunction Tile load function.
+   * @api
+   */
+  setTileLoadFunction(e) {
+    this.tileCache.clear(), this.tileLoadFunction = e, this.changed();
+  }
+  /**
+   * Set the tile URL function of the source.
+   * @param {import("../Tile.js").UrlFunction} tileUrlFunction Tile URL function.
+   * @param {string} [key] Optional new tile key for the source.
+   * @api
+   */
+  setTileUrlFunction(e, t) {
+    this.tileUrlFunction = e, this.tileCache.pruneExceptNewestZ(), typeof t < "u" ? this.setKey(t) : this.changed();
+  }
+  /**
+   * Set the URL to use for requests.
+   * @param {string} url URL.
+   * @api
+   */
+  setUrl(e) {
+    const t = Ri(e);
+    this.urls = t, this.setUrls(t);
+  }
+  /**
+   * Set the URLs to use for requests.
+   * @param {Array<string>} urls URLs.
+   * @api
+   */
+  setUrls(e) {
+    this.urls = e;
+    const t = e.join(`
+`);
+    this.generateTileUrlFunction_ ? this.setTileUrlFunction(Gi(e, this.tileGrid), t) : this.setKey(t);
+  }
+  /**
+   * @param {import("../tilecoord.js").TileCoord} tileCoord Tile coordinate.
+   * @param {number} pixelRatio Pixel ratio.
+   * @param {import("../proj/Projection.js").default} projection Projection.
+   * @return {string|undefined} Tile URL.
+   */
+  tileUrlFunction(e, t, i) {
+  }
+  /**
+   * Marks a tile coord as being used, without triggering a load.
+   * @param {number} z Tile coordinate z.
+   * @param {number} x Tile coordinate x.
+   * @param {number} y Tile coordinate y.
+   */
+  useTile(e, t, i) {
+    const n = fe(e, t, i);
+    this.tileCache.containsKey(n) && this.tileCache.get(n);
+  }
+}
+class Ai extends Ae {
+  /**
+   * @param {!Options} options Image tile options.
+   */
+  constructor(e) {
+    super({
+      attributions: e.attributions,
+      cacheSize: e.cacheSize,
+      opaque: e.opaque,
+      projection: e.projection,
+      state: e.state,
+      tileGrid: e.tileGrid,
+      tileLoadFunction: e.tileLoadFunction ? e.tileLoadFunction : bi,
+      tilePixelRatio: e.tilePixelRatio,
+      tileUrlFunction: e.tileUrlFunction,
+      url: e.url,
+      urls: e.urls,
+      wrapX: e.wrapX,
+      transition: e.transition,
+      interpolate: e.interpolate !== void 0 ? e.interpolate : !0,
+      key: e.key,
+      attributionsCollapsible: e.attributionsCollapsible,
+      zDirection: e.zDirection
+    }), this.crossOrigin = e.crossOrigin !== void 0 ? e.crossOrigin : null, this.tileClass = e.tileClass !== void 0 ? e.tileClass : Ot, this.tileCacheForProjection = {}, this.tileGridForProjection = {}, this.reprojectionErrorThreshold_ = e.reprojectionErrorThreshold, this.renderReprojectionEdges_ = !1;
+  }
+  /**
+   * @return {boolean} Can expire cache.
+   */
+  canExpireCache() {
+    if (this.tileCache.canExpireCache())
+      return !0;
+    for (const e in this.tileCacheForProjection)
+      if (this.tileCacheForProjection[e].canExpireCache())
+        return !0;
+    return !1;
+  }
+  /**
+   * @param {import("../proj/Projection.js").default} projection Projection.
+   * @param {!Object<string, boolean>} usedTiles Used tiles.
+   */
+  expireCache(e, t) {
+    const i = this.getTileCacheForProjection(e);
+    this.tileCache.expireCache(
+      this.tileCache == i ? t : {}
+    );
+    for (const n in this.tileCacheForProjection) {
+      const s = this.tileCacheForProjection[n];
+      s.expireCache(s == i ? t : {});
+    }
+  }
+  /**
+   * @param {import("../proj/Projection.js").default} projection Projection.
+   * @return {number} Gutter.
+   */
+  getGutterForProjection(e) {
+    return this.getProjection() && e && !N(this.getProjection(), e) ? 0 : this.getGutter();
+  }
+  /**
+   * @return {number} Gutter.
+   */
+  getGutter() {
+    return 0;
+  }
+  /**
+   * Return the key to be used for all tiles in the source.
+   * @return {string} The key for all tiles.
+   */
+  getKey() {
+    let e = super.getKey();
+    return this.getInterpolate() || (e += ":disable-interpolation"), e;
+  }
+  /**
+   * @param {import("../proj/Projection.js").default} projection Projection.
+   * @return {boolean} Opaque.
+   */
+  getOpaque(e) {
+    return this.getProjection() && e && !N(this.getProjection(), e) ? !1 : super.getOpaque(e);
+  }
+  /**
+   * @param {import("../proj/Projection.js").default} projection Projection.
+   * @return {!import("../tilegrid/TileGrid.js").default} Tile grid.
+   */
+  getTileGridForProjection(e) {
+    const t = this.getProjection();
+    if (this.tileGrid && (!t || N(t, e)))
+      return this.tileGrid;
+    const i = C(e);
+    return i in this.tileGridForProjection || (this.tileGridForProjection[i] = ft(e)), this.tileGridForProjection[i];
+  }
+  /**
+   * @param {import("../proj/Projection.js").default} projection Projection.
+   * @return {import("../TileCache.js").default} Tile cache.
+   */
+  getTileCacheForProjection(e) {
+    const t = this.getProjection();
+    if (!t || N(t, e))
+      return this.tileCache;
+    const i = C(e);
+    return i in this.tileCacheForProjection || (this.tileCacheForProjection[i] = new dt(
+      this.tileCache.highWaterMark
+    )), this.tileCacheForProjection[i];
+  }
+  /**
+   * @param {number} z Tile coordinate z.
+   * @param {number} x Tile coordinate x.
+   * @param {number} y Tile coordinate y.
+   * @param {number} pixelRatio Pixel ratio.
+   * @param {import("../proj/Projection.js").default} projection Projection.
+   * @param {string} key The key set on the tile.
+   * @return {!ImageTile} Tile.
+   * @private
+   */
+  createTile_(e, t, i, n, s, r) {
+    const o = [e, t, i], a = this.getTileCoordForTileUrlFunction(
+      o,
+      s
+    ), h = a ? this.tileUrlFunction(a, n, s) : void 0, c = new this.tileClass(
+      o,
+      h !== void 0 ? j.IDLE : j.EMPTY,
+      h !== void 0 ? h : "",
+      this.crossOrigin,
+      this.tileLoadFunction,
+      this.tileOptions
+    );
+    return c.key = r, c.addEventListener($.CHANGE, this.handleTileChange.bind(this)), c;
+  }
+  /**
+   * @param {number} z Tile coordinate z.
+   * @param {number} x Tile coordinate x.
+   * @param {number} y Tile coordinate y.
+   * @param {number} pixelRatio Pixel ratio.
+   * @param {import("../proj/Projection.js").default} projection Projection.
+   * @return {!(ImageTile|ReprojTile)} Tile.
+   */
+  getTile(e, t, i, n, s) {
+    const r = this.getProjection();
+    if (!r || !s || N(r, s))
+      return this.getTileInternal(
+        e,
+        t,
+        i,
+        n,
+        r || s
+      );
+    const o = this.getTileCacheForProjection(s), a = [e, t, i];
+    let h;
+    const c = ut(a);
+    o.containsKey(c) && (h = o.get(c));
+    const u = this.getKey();
+    if (h && h.key == u)
+      return h;
+    const g = this.getTileGridForProjection(r), d = this.getTileGridForProjection(s), f = this.getTileCoordForTileUrlFunction(
+      a,
+      s
+    ), _ = new Ut(
+      r,
+      g,
+      s,
+      d,
+      a,
+      f,
+      this.getTilePixelRatio(n),
+      this.getGutter(),
+      (x, T, F, E) => this.getTileInternal(x, T, F, E, r),
+      this.reprojectionErrorThreshold_,
+      this.renderReprojectionEdges_,
+      this.getInterpolate()
+    );
+    return _.key = u, h ? (_.interimTile = h, _.refreshInterimChain(), o.replace(c, _)) : o.set(c, _), _;
+  }
+  /**
+   * @param {number} z Tile coordinate z.
+   * @param {number} x Tile coordinate x.
+   * @param {number} y Tile coordinate y.
+   * @param {number} pixelRatio Pixel ratio.
+   * @param {!import("../proj/Projection.js").default} projection Projection.
+   * @return {!ImageTile} Tile.
+   * @protected
+   */
+  getTileInternal(e, t, i, n, s) {
+    let r = null;
+    const o = fe(e, t, i), a = this.getKey();
+    if (!this.tileCache.containsKey(o))
+      r = this.createTile_(e, t, i, n, s, a), this.tileCache.set(o, r);
+    else if (r = this.tileCache.get(o), r.key != a) {
+      const h = r;
+      r = this.createTile_(e, t, i, n, s, a), h.getState() == j.IDLE ? r.interimTile = h.interimTile : r.interimTile = h, r.refreshInterimChain(), this.tileCache.replace(o, r);
+    }
+    return r;
+  }
+  /**
+   * Sets whether to render reprojection edges or not (usually for debugging).
+   * @param {boolean} render Render the edges.
+   * @api
+   */
+  setRenderReprojectionEdges(e) {
+    if (this.renderReprojectionEdges_ != e) {
+      this.renderReprojectionEdges_ = e;
+      for (const t in this.tileCacheForProjection)
+        this.tileCacheForProjection[t].clear();
+      this.changed();
+    }
+  }
+  /**
+   * Sets the tile grid to use when reprojecting the tiles to the given
+   * projection instead of the default tile grid for the projection.
+   *
+   * This can be useful when the default tile grid cannot be created
+   * (e.g. projection has no extent defined) or
+   * for optimization reasons (custom tile size, resolutions, ...).
+   *
+   * @param {import("../proj.js").ProjectionLike} projection Projection.
+   * @param {import("../tilegrid/TileGrid.js").default} tilegrid Tile grid to use for the projection.
+   * @api
+   */
+  setTileGridForProjection(e, t) {
+    const i = Ge(e);
+    if (i) {
+      const n = C(i);
+      n in this.tileGridForProjection || (this.tileGridForProjection[n] = t);
+    }
+  }
+  clear() {
+    super.clear();
+    for (const e in this.tileCacheForProjection)
+      this.tileCacheForProjection[e].clear();
+  }
+}
+function bi(l, e) {
+  l.getImage().src = e;
+}
+class Ii extends Ai {
+  /**
+   * @param {Options} [options] XYZ options.
+   */
+  constructor(e) {
+    e = e || {};
+    const t = e.projection !== void 0 ? e.projection : "EPSG:3857", i = e.tileGrid !== void 0 ? e.tileGrid : Pi({
+      extent: Re(t),
+      maxResolution: e.maxResolution,
+      maxZoom: e.maxZoom,
+      minZoom: e.minZoom,
+      tileSize: e.tileSize
+    });
+    super({
+      attributions: e.attributions,
+      cacheSize: e.cacheSize,
+      crossOrigin: e.crossOrigin,
+      interpolate: e.interpolate,
+      opaque: e.opaque,
+      projection: t,
+      reprojectionErrorThreshold: e.reprojectionErrorThreshold,
+      tileGrid: i,
+      tileLoadFunction: e.tileLoadFunction,
+      tilePixelRatio: e.tilePixelRatio,
+      tileUrlFunction: e.tileUrlFunction,
+      url: e.url,
+      urls: e.urls,
+      wrapX: e.wrapX !== void 0 ? e.wrapX : !0,
+      transition: e.transition,
+      attributionsCollapsible: e.attributionsCollapsible,
+      zDirection: e.zDirection
+    }), this.gutter_ = e.gutter !== void 0 ? e.gutter : 0;
+  }
+  /**
+   * @return {number} Gutter.
+   */
+  getGutter() {
+    return this.gutter_;
+  }
+}
+const ji = '&#169; <a href="https://www.openstreetmap.org/copyright" target="_blank">OpenStreetMap</a> contributors.';
+class Oi extends Ii {
+  /**
+   * @param {Options} [options] Open Street Map options.
+   */
+  constructor(e) {
+    e = e || {};
+    let t;
+    e.attributions !== void 0 ? t = e.attributions : t = [ji];
+    const i = e.crossOrigin !== void 0 ? e.crossOrigin : "anonymous", n = e.url !== void 0 ? e.url : "https://tile.openstreetmap.org/{z}/{x}/{y}.png";
+    super({
+      attributions: t,
+      attributionsCollapsible: !1,
+      cacheSize: e.cacheSize,
+      crossOrigin: i,
+      interpolate: e.interpolate,
+      maxZoom: e.maxZoom !== void 0 ? e.maxZoom : 19,
+      opaque: e.opaque !== void 0 ? e.opaque : !0,
+      reprojectionErrorThreshold: e.reprojectionErrorThreshold,
+      tileLoadFunction: e.tileLoadFunction,
+      transition: e.transition,
+      url: n,
+      wrapX: e.wrapX,
+      zDirection: e.zDirection
+    });
+  }
+}
+let Se = null;
+const L = new De(), w = {
+  layer: new ge({
+    source: L,
+    style: Vt
   }),
-  modify: new U({ source: c }),
+  modify: new hi({ source: L }),
   draw: null,
   snap: null,
-  select: new B({
-    condition: q,
-    style: H
+  select: new ve({
+    condition: zt,
+    style: Xt
   })
 };
-function Te(n) {
-  const r = i.useRef(null), [u, D] = i.useState("Pointer"), [S, I] = i.useState(!1), [v, f] = i.useState({
+function Hi(l) {
+  const e = v.useRef(null), [t, i] = v.useState("Pointer"), [n, s] = v.useState(!1), [r, o] = v.useState({
     open: !1,
     buttons: [],
     position: void 0
-  }), b = () => {
-    if (n.defaultExtent && M(n.defaultExtent), C(), W(), O(), w(), n.drawingWKTData && n.drawingWKTData !== "GEOMETRYCOLLECTION()") {
-      m(n.drawingWKTData);
-      const e = F(n.drawingWKTData);
-      e && x(e[0], [100, 100, 100, 100]);
+  }), a = () => {
+    if (l.defaultExtent && je(l.defaultExtent), h(), c(), u(), k(), l.drawingWKTData && l.drawingWKTData !== "GEOMETRYCOLLECTION()") {
+      q(l.drawingWKTData);
+      const m = ze(l.drawingWKTData);
+      m && Ie(m[0], [100, 100, 100, 100]);
     }
   };
-  i.useEffect(() => () => {
-  }, []), i.useEffect(() => {
-    if (u !== "Pointer") {
-      if (u === "KML") {
-        y();
+  v.useEffect(() => () => {
+  }, []), v.useEffect(() => {
+    if (t !== "Pointer") {
+      if (t === "KML") {
+        _e();
         return;
       }
-      return g(u), () => {
+      return T(t), () => {
       };
     }
-  }, [u]), i.useEffect(() => (n.drawingKMLData && L(n.drawingKMLData), () => {
-  }), [n.drawingKMLData]), i.useEffect(() => (n.drawingWKTData && (w(), n.drawingWKTData !== "GEOMETRYCOLLECTION()" && m(n.drawingWKTData)), () => {
-  }), [n.drawingWKTData]);
-  const C = () => {
-    k(), A();
-  }, W = () => {
-    R(), h();
-  }, O = () => {
-    P();
-  }, k = () => {
-    var e;
-    n.mapboxAccessToken ? T = _({
-      id: n.id,
+  }, [t]), v.useEffect(() => (l.drawingKMLData && E(l.drawingKMLData), () => {
+  }), [l.drawingKMLData]), v.useEffect(() => (l.drawingWKTData && (k(), l.drawingWKTData !== "GEOMETRYCOLLECTION()" && q(l.drawingWKTData)), () => {
+  }), [l.drawingWKTData]);
+  const h = () => {
+    g(), d();
+  }, c = () => {
+    f(), _();
+  }, u = () => {
+    x();
+  }, g = () => {
+    var m;
+    l.mapboxAccessToken ? Se = Tt({
+      id: l.id,
       center: [0, 0],
       style: "mapbox://styles/mapbox/streets-v11",
-      accessToken: n.mapboxAccessToken
-    }).layer : T = new ee({
-      source: new te()
-    }), (e = r.current) == null || e.addLayer(T);
-  }, A = () => {
-    var e;
-    (e = r.current) == null || e.addLayer(o.layer);
-  }, R = () => {
-    var e;
-    (e = r.current) == null || e.addInteraction(o.select), o.select.on("select", function() {
-      n.onSelect && n.onSelect(o.select.getFeatures().getArray());
+      accessToken: l.mapboxAccessToken
+    }).layer : Se = new Kt({
+      source: new Oi()
+    }), (m = e.current) == null || m.addLayer(Se);
+  }, d = () => {
+    var m;
+    (m = e.current) == null || m.addLayer(w.layer);
+  }, f = () => {
+    var m;
+    (m = e.current) == null || m.addInteraction(w.select), w.select.on("select", function() {
+      l.onSelect && l.onSelect(w.select.getFeatures().getArray());
     });
-  }, h = () => {
-    var e;
-    (e = r.current) == null || e.addInteraction(o.modify), o.modify.on("modifyend", () => {
+  }, _ = () => {
+    var m;
+    (m = e.current) == null || m.addInteraction(w.modify), w.modify.on("modifyend", () => {
       setTimeout(() => {
-        n.onDrawEnd && n.onDrawEnd(c.getFeatures());
-      }, 250), l();
+        l.onDrawEnd && l.onDrawEnd(L.getFeatures());
+      }, 250), F();
     });
-  }, P = async () => {
-    var e;
-    (e = r.current) == null || e.on(
+  }, x = async () => {
+    var m;
+    (m = e.current) == null || m.on(
       "contextmenu",
-      async (t) => {
-        var d;
-        t.preventDefault();
-        const a = (d = r.current) == null ? void 0 : d.getEventPixel(t.originalEvent);
-        if (a) {
-          const s = await o.layer.getFeatures(a);
-          if (s && s.length > 0) {
-            f({
+      async (y) => {
+        var Y;
+        y.preventDefault();
+        const S = (Y = e.current) == null ? void 0 : Y.getEventPixel(y.originalEvent);
+        if (S) {
+          const U = await w.layer.getFeatures(S);
+          if (U && U.length > 0) {
+            o({
               open: !0,
               buttons: [
                 {
                   label: "Delete",
                   onClick: () => {
-                    s.forEach(
-                      (Z) => G(Z)
-                    ), E(), setTimeout(() => {
-                      n.onDrawEnd && n.onDrawEnd(c.getFeatures());
+                    U.forEach(
+                      (Ct) => Q(Ct)
+                    ), be(), setTimeout(() => {
+                      l.onDrawEnd && l.onDrawEnd(L.getFeatures());
                     }, 250);
                   }
                 }
               ],
               position: {
-                top: a[1],
-                left: a[0]
+                top: S[1],
+                left: S[0]
               }
             });
             return;
           }
         }
-        E();
+        be();
       }
     );
-  }, g = (e) => {
-    var d, s;
-    l();
-    const t = new X({
-      source: c,
-      type: e
-    }), a = new $({ source: c });
-    t.on("drawend", () => {
+  }, T = (m) => {
+    var Y, U;
+    F();
+    const y = new fi({
+      source: L,
+      type: m
+    }), S = new Ci({ source: L });
+    y.on("drawend", () => {
       setTimeout(() => {
-        n.onDrawEnd && n.onDrawEnd(c.getFeatures());
-      }, 250), l(), D("Pointer");
-    }), o.draw = t, o.snap = a, (d = r.current) == null || d.addInteraction(t), (s = r.current) == null || s.addInteraction(a);
-  }, l = () => {
-    var e, t;
-    o.draw && ((e = r.current) == null || e.removeInteraction(o.draw)), o.snap && ((t = r.current) == null || t.removeInteraction(o.snap));
-  }, L = (e) => {
-    const t = K(e);
-    t && c.addFeatures(t);
-  }, m = (e) => {
-    const t = F(e, J);
-    t && c.addFeatures(t);
-  }, w = () => {
-    c.clear();
-  }, G = (e) => {
-    c.removeFeature(e);
-  }, E = () => {
-    f({
+        l.onDrawEnd && l.onDrawEnd(L.getFeatures());
+      }, 250), F(), i("Pointer");
+    }), w.draw = y, w.snap = S, (Y = e.current) == null || Y.addInteraction(y), (U = e.current) == null || U.addInteraction(S);
+  }, F = () => {
+    var m, y;
+    w.draw && ((m = e.current) == null || m.removeInteraction(w.draw)), w.snap && ((y = e.current) == null || y.removeInteraction(w.snap));
+  }, E = (m) => {
+    const y = Ue(m);
+    y && L.addFeatures(y);
+  }, q = (m) => {
+    const y = ze(m, Zt);
+    y && L.addFeatures(y);
+  }, k = () => {
+    L.clear();
+  }, Q = (m) => {
+    L.removeFeature(m);
+  }, be = () => {
+    o({
       open: !1,
       buttons: []
     });
-  }, y = () => {
-    I((e) => !e);
-  }, N = (e) => {
-    var a;
-    const t = K(e);
-    t ? (y(), c.addFeatures(t), (a = r.current) == null || a.centerToFeature(t[0]), n.onDrawEnd && n.onDrawEnd(t)) : p("Error!", "Feature(s) could not be loaded! Check your KML data!");
-  }, V = (e) => {
-    var t;
-    (t = r.current) == null || t.setCenter(e);
-  }, Y = (e) => {
-    var t;
-    (t = r.current) == null || t.setZoomLevel(e);
-  }, x = (e, t = [0, 0, 0, 0]) => {
-    var a;
-    (a = r.current) == null || a.centerToFeature(e, t);
-  }, M = (e) => {
-    var t;
-    (t = r.current) == null || t.centerToExtent(e);
+  }, _e = () => {
+    s((m) => !m);
+  }, mt = (m) => {
+    var S;
+    const y = Ue(m);
+    y ? (_e(), L.addFeatures(y), (S = e.current) == null || S.centerToFeature(y[0]), l.onDrawEnd && l.onDrawEnd(y)) : ri("Error!", "Feature(s) could not be loaded! Check your KML data!");
+  }, yt = (m) => {
+    var y;
+    (y = e.current) == null || y.setCenter(m);
+  }, xt = (m) => {
+    var y;
+    (y = e.current) == null || y.setZoomLevel(m);
+  }, Ie = (m, y = [0, 0, 0, 0]) => {
+    var S;
+    (S = e.current) == null || S.centerToFeature(m, y);
+  }, je = (m) => {
+    var y;
+    (y = e.current) == null || y.centerToExtent(m);
   };
   return {
     refs: {
-      mapRef: r
+      mapRef: e
     },
     state: {
-      activeDrawingTool: u,
-      openAddKMLText: S,
-      contextMenu: v
+      activeDrawingTool: t,
+      openAddKMLText: n,
+      contextMenu: r
     },
     action: {
-      setActiveDrawingTool: D,
-      addInteractions: g,
-      addDrawingSourceKMLData: L,
-      addDrawingSourceWKTData: m,
-      clearDrawingSource: w,
-      toggleAddKMLText: y,
-      addKMLText: N,
-      setContextMenu: f,
-      setCenter: V,
-      setZoomLevel: Y,
-      centerToFeature: x,
-      centerToExtent: M,
-      onMapInit: b
+      setActiveDrawingTool: i,
+      addInteractions: T,
+      addDrawingSourceKMLData: E,
+      addDrawingSourceWKTData: q,
+      clearDrawingSource: k,
+      toggleAddKMLText: _e,
+      addKMLText: mt,
+      setContextMenu: o,
+      setCenter: yt,
+      setZoomLevel: xt,
+      centerToFeature: Ie,
+      centerToExtent: je,
+      onMapInit: a
     }
   };
 }
 export {
-  Te as default
+  Hi as default
 };