@hybridcore/ui 1.0.2 → 1.1.2

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

@@ -0,0 +1,2360 @@
+import k from "react";
+import { createMapboxLayer as Xe } from "../../map/helpers/mapbox.js";
+import { I as $e, s as ke, n as ge, e as ve, C as fe, f as v, V as se, F as L, P as me, p as Ze, h as ze, i as _e, R as Ge, j as ye, k as J, M as D, l as Je, m as Qe, o as et, q as tt, L as z, r as it, t as Ie, u as Re, G as st, v as nt, b as Fe, a as rt } from "../../../ol-DXmSLlWv.js";
+import { T as Q, g as F, c as ot, e as Te, B as ne, E as ee, a as at, F as Ae, t as ht, s as be, b as ct, l as q, u as oe } from "../../../has-9_asnBxn.js";
+import { c as xe } from "../../../Text-BT5kPHOo.js";
+import { defaultStyle as lt, selectStyleFunction as dt, markerStyle as ut } from "./style.js";
+import { c as E, d as ae, P as U, e as te, f as C, g as I, h as ie, i as gt, j as Oe, k as Ne, s as R, l as Ve, m as ft, n as Se, o as je, p as _t, q as mt, r as yt } from "../../../Source-CnCcu5UP.js";
+import { alert as xt } from "../../confirm/index.js";
+const pt = {
+  /**
+   * Triggered when feature(s) has been (de)selected.
+   * @event SelectEvent#select
+   * @api
+   */
+  SELECT: "select"
+};
+class Ct extends ne {
+  /**
+   * @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, s, i) {
+    super(e), this.selected = t, this.deselected = s, this.mapBrowserEvent = i;
+  }
+}
+const W = {};
+class pe extends $e {
+  /**
+   * @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 : ke, this.addCondition_ = e.addCondition ? e.addCondition : ge, this.removeCondition_ = e.removeCondition ? e.removeCondition : ge, this.toggleCondition_ = e.toggleCondition ? e.toggleCondition : ve, this.multi_ = e.multi ? e.multi : !1, this.filter_ = e.filter ? e.filter : Q, this.hitTolerance_ = e.hitTolerance ? e.hitTolerance : 0, this.style_ = e.style !== void 0 ? e.style : Ft(), this.features_ = e.features || new fe();
+    let t;
+    if (e.layers)
+      if (typeof e.layers == "function")
+        t = e.layers;
+      else {
+        const s = e.layers;
+        t = function(i) {
+          return s.includes(i);
+        };
+      }
+    else
+      t = Q;
+    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_[F(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_[F(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(
+      v.ADD,
+      this.boundAddFeature_
+    ), this.features_.addEventListener(
+      v.REMOVE,
+      this.boundRemoveFeature_
+    ), this.style_ && this.features_.forEach(this.applySelectedStyle_.bind(this))) : (this.features_.removeEventListener(
+      v.ADD,
+      this.boundAddFeature_
+    ), this.features_.removeEventListener(
+      v.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 s = (
+        /** @type {VectorLayer} */
+        this.getMap().getAllLayers().find(function(i) {
+          if (i instanceof se && i.getSource() && i.getSource().hasFeature(t))
+            return i;
+        })
+      );
+      s && this.addFeatureLayerAssociation_(t, s);
+    }
+  }
+  /**
+   * @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 = F(e);
+    t in W || (W[t] = e.getStyle()), e.setStyle(this.style_);
+  }
+  /**
+   * @param {Feature} feature Feature
+   * @private
+   */
+  restorePreviousStyle_(e) {
+    const t = this.getMap().getInteractions().getArray();
+    for (let i = t.length - 1; i >= 0; --i) {
+      const n = t[i];
+      if (n !== this && n instanceof pe && n.getStyle() && n.getFeatures().getArray().lastIndexOf(e) !== -1) {
+        e.setStyle(n.getStyle());
+        return;
+      }
+    }
+    const s = F(e);
+    e.setStyle(W[s]), delete W[s];
+  }
+  /**
+   * @param {Feature} feature Feature.
+   * @private
+   */
+  removeFeatureLayerAssociation_(e) {
+    delete this.featureLayerAssociation_[F(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), s = this.removeCondition_(e), i = this.toggleCondition_(e), n = !t && !s && !i, r = e.map, o = this.getFeatures(), a = [], h = [];
+    if (n) {
+      ot(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, d) => {
+          if (!(!(c instanceof L) || !this.filter_(c, d)))
+            return this.addFeatureLayerAssociation_(c, d), h.push(c), !this.multi_;
+        },
+        {
+          layerFilter: this.layerFilter_,
+          hitTolerance: this.hitTolerance_
+        }
+      );
+      for (let c = o.getLength() - 1; c >= 0; --c) {
+        const d = o.item(c), g = h.indexOf(d);
+        g > -1 ? h.splice(g, 1) : (o.remove(d), a.push(d));
+      }
+      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, d) => {
+          if (!(!(c instanceof L) || !this.filter_(c, d)))
+            return (t || i) && !o.getArray().includes(c) ? (this.addFeatureLayerAssociation_(c, d), h.push(c)) : (s || i) && 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 Ct(
+        pt.SELECT,
+        h,
+        a,
+        e
+      )
+    ), !0;
+  }
+}
+function Ft() {
+  const l = xe();
+  return Te(l.Polygon, l.LineString), Te(l.GeometryCollection, l.LineString), function(e) {
+    return e.getGeometry() ? l[e.getGeometry().getType()] : null;
+  };
+}
+const Pe = 0, K = 1, Ee = [0, 0, 0, 0], N = [], he = {
+  /**
+   * 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 ne {
+  /**
+   * @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, s) {
+    super(e), this.features = t, this.mapBrowserEvent = s;
+  }
+}
+class Tt 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 : Ze, this.defaultDeleteCondition_ = function(s) {
+      return ze(s) && ke(s);
+    }, this.deleteCondition_ = e.deleteCondition ? e.deleteCondition : this.defaultDeleteCondition_, this.insertVertexCondition_ = e.insertVertexCondition ? e.insertVertexCondition : _e, this.vertexFeature_ = null, this.vertexSegments_ = null, this.lastPixel_ = [0, 0], this.ignoreNextSingleClick_ = !1, this.featuresBeingModified_ = null, this.rBush_ = new Ge(), this.pixelTolerance_ = e.pixelTolerance !== void 0 ? e.pixelTolerance : 10, this.snappedToVertex_ = !1, this.changingFeature_ = !1, this.dragSegments_ = [], this.overlay_ = new se({
+      source: new ye({
+        useSpatialIndex: !1,
+        wrapX: !!e.wrapX
+      }),
+      style: e.style ? e.style : Pt(),
+      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 fe(this.source_.getFeatures()), this.source_.addEventListener(
+      J.ADDFEATURE,
+      this.handleSourceAdd_.bind(this)
+    ), this.source_.addEventListener(
+      J.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(
+      v.ADD,
+      this.handleFeatureAdd_.bind(this)
+    ), this.features_.addEventListener(
+      v.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 i = this.SEGMENT_WRITERS_[t.getType()];
+      i && i(e, t);
+    }
+    const s = this.getMap();
+    s && s.isRendered() && this.getActive() && this.handlePointerAtPixel_(this.lastPixel_, s), e.addEventListener(ee.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 fe();
+      const s = this.featuresBeingModified_.getArray();
+      for (let i = 0, n = t.length; i < n; ++i) {
+        const r = t[i];
+        for (let o = 0, a = r.length; o < a; ++o) {
+          const h = r[o].feature;
+          h && !s.includes(h) && this.featuresBeingModified_.push(h);
+        }
+      }
+      this.featuresBeingModified_.getLength() === 0 ? this.featuresBeingModified_ = null : this.dispatchEvent(
+        new ce(
+          he.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(
+      ee.CHANGE,
+      this.boundHandleFeatureChange_
+    );
+  }
+  /**
+   * @param {Feature} feature Feature.
+   * @private
+   */
+  removeFeatureSegmentData_(e) {
+    const t = this.rBush_, s = [];
+    t.forEach(
+      /**
+       * @param {SegmentData} node RTree node.
+       */
+      function(i) {
+        e === i.feature && s.push(i);
+      }
+    );
+    for (let i = s.length - 1; i >= 0; --i) {
+      const n = s[i];
+      for (let r = this.dragSegments_.length - 1; r >= 0; --r)
+        this.dragSegments_[r][0] === n && this.dragSegments_.splice(r, 1);
+      t.remove(n);
+    }
+  }
+  /**
+   * 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 s = t.getCoordinates(), i = {
+      feature: e,
+      geometry: t,
+      segment: [s, s]
+    };
+    this.rBush_.insert(t.getExtent(), i);
+  }
+  /**
+   * @param {Feature} feature Feature
+   * @param {import("../geom/MultiPoint.js").default} geometry Geometry.
+   * @private
+   */
+  writeMultiPointGeometry_(e, t) {
+    const s = t.getCoordinates();
+    for (let i = 0, n = s.length; i < n; ++i) {
+      const r = s[i], o = {
+        feature: e,
+        geometry: t,
+        depth: [i],
+        index: i,
+        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 s = t.getCoordinates();
+    for (let i = 0, n = s.length - 1; i < n; ++i) {
+      const r = s.slice(i, i + 2), o = {
+        feature: e,
+        geometry: t,
+        index: i,
+        segment: r
+      };
+      this.rBush_.insert(E(r), o);
+    }
+  }
+  /**
+   * @param {Feature} feature Feature
+   * @param {import("../geom/MultiLineString.js").default} geometry Geometry.
+   * @private
+   */
+  writeMultiLineStringGeometry_(e, t) {
+    const s = t.getCoordinates();
+    for (let i = 0, n = s.length; i < n; ++i) {
+      const r = s[i];
+      for (let o = 0, a = r.length - 1; o < a; ++o) {
+        const h = r.slice(o, o + 2), c = {
+          feature: e,
+          geometry: t,
+          depth: [i],
+          index: o,
+          segment: h
+        };
+        this.rBush_.insert(E(h), c);
+      }
+    }
+  }
+  /**
+   * @param {Feature} feature Feature
+   * @param {import("../geom/Polygon.js").default} geometry Geometry.
+   * @private
+   */
+  writePolygonGeometry_(e, t) {
+    const s = t.getCoordinates();
+    for (let i = 0, n = s.length; i < n; ++i) {
+      const r = s[i];
+      for (let o = 0, a = r.length - 1; o < a; ++o) {
+        const h = r.slice(o, o + 2), c = {
+          feature: e,
+          geometry: t,
+          depth: [i],
+          index: o,
+          segment: h
+        };
+        this.rBush_.insert(E(h), c);
+      }
+    }
+  }
+  /**
+   * @param {Feature} feature Feature
+   * @param {import("../geom/MultiPolygon.js").default} geometry Geometry.
+   * @private
+   */
+  writeMultiPolygonGeometry_(e, t) {
+    const s = t.getCoordinates();
+    for (let i = 0, n = s.length; i < n; ++i) {
+      const r = s[i];
+      for (let o = 0, a = r.length; o < a; ++o) {
+        const h = r[o];
+        for (let c = 0, d = h.length - 1; c < d; ++c) {
+          const g = h.slice(c, c + 2), u = {
+            feature: e,
+            geometry: t,
+            depth: [o, i],
+            index: c,
+            segment: g
+          };
+          this.rBush_.insert(E(g), u);
+        }
+      }
+    }
+  }
+  /**
+   * 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 s = t.getCenter(), i = {
+      feature: e,
+      geometry: t,
+      index: Pe,
+      segment: [s, s]
+    }, n = {
+      feature: e,
+      geometry: t,
+      index: K,
+      segment: [s, s]
+    }, r = [i, n];
+    i.featureSegments = r, n.featureSegments = r, this.rBush_.insert(ae(s), i);
+    let o = (
+      /** @type {import("../geom/Geometry.js").default} */
+      t
+    );
+    this.rBush_.insert(o.getExtent(), n);
+  }
+  /**
+   * @param {Feature} feature Feature
+   * @param {import("../geom/GeometryCollection.js").default} geometry Geometry.
+   * @private
+   */
+  writeGeometryCollectionGeometry_(e, t) {
+    const s = t.getGeometriesArray();
+    for (let i = 0; i < s.length; ++i) {
+      const n = s[i], r = this.SEGMENT_WRITERS_[n.getType()];
+      r(e, n);
+    }
+  }
+  /**
+   * @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, s) {
+    let i = this.vertexFeature_;
+    return i ? i.getGeometry().setCoordinates(e) : (i = new L(new U(e)), this.vertexFeature_ = i, this.overlay_.getSource().addFeature(i)), i.set("features", t), i.set("geometries", s), i;
+  }
+  /**
+   * 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]
+    ], s = [], i = [];
+    for (let n = 0, r = this.dragSegments_.length; n < r; ++n) {
+      const o = this.dragSegments_[n], a = o[0], h = a.feature;
+      s.includes(h) || s.push(h);
+      const c = a.geometry;
+      i.includes(c) || i.push(c);
+      const d = a.depth;
+      let g;
+      const u = a.segment, f = o[1];
+      for (; t.length < c.getStride(); )
+        t.push(u[f][t.length]);
+      switch (c.getType()) {
+        case "Point":
+          g = t, u[0] = t, u[1] = t;
+          break;
+        case "MultiPoint":
+          g = c.getCoordinates(), g[a.index] = t, u[0] = t, u[1] = t;
+          break;
+        case "LineString":
+          g = c.getCoordinates(), g[a.index + f] = t, u[f] = t;
+          break;
+        case "MultiLineString":
+          g = c.getCoordinates(), g[d[0]][a.index + f] = t, u[f] = t;
+          break;
+        case "Polygon":
+          g = c.getCoordinates(), g[d[0]][a.index + f] = t, u[f] = t;
+          break;
+        case "MultiPolygon":
+          g = c.getCoordinates(), g[d[1]][d[0]][a.index + f] = t, u[f] = t;
+          break;
+        case "Circle":
+          if (u[0] = t, u[1] = t, a.index === Pe)
+            this.changingFeature_ = !0, c.setCenter(t), this.changingFeature_ = !1;
+          else {
+            this.changingFeature_ = !0, e.map.getView().getProjection();
+            let _ = te(
+              C(c.getCenter()),
+              C(t)
+            );
+            c.setRadius(_), this.changingFeature_ = !1;
+          }
+          break;
+      }
+      g && this.setGeometryCoordinates_(c, g);
+    }
+    this.createOrUpdateVertexFeature_(t, s, i);
+  }
+  /**
+   * 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 s = this.vertexFeature_;
+    if (s) {
+      e.map.getView().getProjection();
+      const i = [], n = s.getGeometry().getCoordinates(), r = E([n]), o = this.rBush_.getInExtent(r), a = {};
+      o.sort(St);
+      for (let h = 0, c = o.length; h < c; ++h) {
+        const d = o[h], g = d.segment;
+        let u = F(d.geometry);
+        const f = d.depth;
+        if (f && (u += "-" + f.join("-")), a[u] || (a[u] = new Array(2)), d.geometry.getType() === "Circle" && d.index === K) {
+          const _ = De(
+            t,
+            d
+          );
+          I(_, n) && !a[u][0] && (this.dragSegments_.push([d, 0]), a[u][0] = d);
+          continue;
+        }
+        if (I(g[0], n) && !a[u][0]) {
+          this.dragSegments_.push([d, 0]), a[u][0] = d;
+          continue;
+        }
+        if (I(g[1], n) && !a[u][1]) {
+          if (a[u][0] && a[u][0].index === 0) {
+            let _ = d.geometry.getCoordinates();
+            switch (d.geometry.getType()) {
+              case "LineString":
+              case "MultiLineString":
+                continue;
+              case "MultiPolygon":
+                _ = _[f[1]];
+              case "Polygon":
+                if (d.index !== _[f[0]].length - 2)
+                  continue;
+                break;
+            }
+          }
+          this.dragSegments_.push([d, 1]), a[u][1] = d;
+          continue;
+        }
+        F(g) in this.vertexSegments_ && !a[u][0] && !a[u][1] && this.insertVertexCondition_(e) && i.push(d);
+      }
+      i.length && this.willModifyFeatures_(e, [i]);
+      for (let h = i.length - 1; h >= 0; --h)
+        this.insertVertex_(i[h], n);
+    }
+    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 s = this.dragSegments_[t][0], i = s.geometry;
+      if (i.getType() === "Circle") {
+        const n = i.getCenter(), r = s.featureSegments[0], o = s.featureSegments[1];
+        r.segment[0] = n, r.segment[1] = n, o.segment[0] = n, o.segment[1] = n, this.rBush_.update(ae(n), r);
+        let a = i;
+        this.rBush_.update(
+          a.getExtent(),
+          o
+        );
+      } else
+        this.rBush_.update(E(s.segment), s);
+    }
+    return this.featuresBeingModified_ && (this.dispatchEvent(
+      new ce(
+        he.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, s) {
+    const i = s || t.getCoordinateFromPixel(e);
+    t.getView().getProjection();
+    const n = function(a, h) {
+      return we(i, a) - we(i, h);
+    };
+    let r, o;
+    if (this.hitDetection_) {
+      const a = typeof this.hitDetection_ == "object" ? (h) => h === this.hitDetection_ : void 0;
+      t.forEachFeatureAtPixel(
+        e,
+        (h, c, d) => {
+          d && (d = new U(
+            ie(d.getCoordinates())
+          ));
+          const g = d || h.getGeometry();
+          if (g.getType() === "Point" && h instanceof L && this.features_.getArray().includes(h)) {
+            o = /** @type {Point} */
+            g;
+            const u = (
+              /** @type {Point} */
+              h.getGeometry().getFlatCoordinates().slice(0, 2)
+            );
+            r = [
+              {
+                feature: h,
+                geometry: o,
+                segment: [u, u]
+              }
+            ];
+          }
+          return !0;
+        },
+        { layerFilter: a }
+      );
+    }
+    if (!r) {
+      const a = gt(
+        ae(i, Ee)
+      ), h = t.getView().getResolution() * this.pixelTolerance_, c = Oe(
+        Ne(a, h, Ee)
+      );
+      r = this.rBush_.getInExtent(c);
+    }
+    if (r && r.length > 0) {
+      const a = r.sort(n)[0], h = a.segment;
+      let c = De(i, a);
+      const d = t.getPixelFromCoordinate(c);
+      let g = te(e, d);
+      if (o || g <= this.pixelTolerance_) {
+        const u = {};
+        if (u[F(h)] = !0, this.snapToPointer_ || (this.delta_[0] = c[0] - i[0], this.delta_[1] = c[1] - i[1]), a.geometry.getType() === "Circle" && a.index === K)
+          this.snappedToVertex_ = !0, this.createOrUpdateVertexFeature_(
+            c,
+            [a.feature],
+            [a.geometry]
+          );
+        else {
+          const f = t.getPixelFromCoordinate(h[0]), _ = t.getPixelFromCoordinate(h[1]), x = R(d, f), p = R(d, _);
+          g = Math.sqrt(Math.min(x, p)), this.snappedToVertex_ = g <= this.pixelTolerance_, this.snappedToVertex_ && (c = x > p ? h[1] : h[0]), this.createOrUpdateVertexFeature_(
+            c,
+            [a.feature],
+            [a.geometry]
+          );
+          const T = {};
+          T[F(a.geometry)] = !0;
+          for (let M = 1, V = r.length; M < V; ++M) {
+            const G = r[M].segment;
+            if (I(h[0], G[0]) && I(h[1], G[1]) || I(h[0], G[1]) && I(h[1], G[0])) {
+              const j = F(r[M].geometry);
+              j in T || (T[j] = !0, u[F(G)] = !0);
+            } else
+              break;
+          }
+        }
+        this.vertexSegments_ = u;
+        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 s = e.segment, i = e.feature, n = e.geometry, r = e.depth, o = e.index;
+    let a;
+    for (; t.length < n.getStride(); )
+      t.push(0);
+    switch (n.getType()) {
+      case "MultiLineString":
+        a = n.getCoordinates(), a[r[0]].splice(o + 1, 0, t);
+        break;
+      case "Polygon":
+        a = n.getCoordinates(), a[r[0]].splice(o + 1, 0, t);
+        break;
+      case "MultiPolygon":
+        a = n.getCoordinates(), a[r[1]][r[0]].splice(o + 1, 0, t);
+        break;
+      case "LineString":
+        a = n.getCoordinates(), a.splice(o + 1, 0, t);
+        break;
+      default:
+        return;
+    }
+    this.setGeometryCoordinates_(n, a);
+    const h = this.rBush_;
+    h.remove(e), this.updateSegmentIndices_(n, o, r, 1);
+    const c = {
+      segment: [s[0], t],
+      feature: i,
+      geometry: n,
+      depth: r,
+      index: o
+    };
+    h.insert(E(c.segment), c), this.dragSegments_.push([c, 1]);
+    const d = {
+      segment: [t, s[1]],
+      feature: i,
+      geometry: n,
+      depth: r,
+      index: o + 1
+    };
+    h.insert(E(d.segment), d), this.dragSegments_.push([d, 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(
+          he.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 s = !1, i, n, r, o, a, h, c, d, g, u, f;
+    for (a = e.length - 1; a >= 0; --a)
+      r = e[a], u = r[0], f = F(u.feature), u.depth && (f += "-" + u.depth.join("-")), f in t || (t[f] = {}), r[1] === 0 ? (t[f].right = u, t[f].index = u.index) : r[1] == 1 && (t[f].left = u, t[f].index = u.index + 1);
+    for (f in t) {
+      switch (g = t[f].right, c = t[f].left, h = t[f].index, d = h - 1, c !== void 0 ? u = c : u = g, d < 0 && (d = 0), o = u.geometry, n = o.getCoordinates(), i = n, s = !1, o.getType()) {
+        case "MultiLineString":
+          n[u.depth[0]].length > 2 && (n[u.depth[0]].splice(h, 1), s = !0);
+          break;
+        case "LineString":
+          n.length > 2 && (n.splice(h, 1), s = !0);
+          break;
+        case "MultiPolygon":
+          i = i[u.depth[1]];
+        case "Polygon":
+          i = i[u.depth[0]], i.length > 4 && (h == i.length - 1 && (h = 0), i.splice(h, 1), s = !0, h === 0 && (i.pop(), i.push(i[0]), d = i.length - 1));
+          break;
+      }
+      if (s) {
+        this.setGeometryCoordinates_(o, n);
+        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: u.depth,
+            feature: u.feature,
+            geometry: u.geometry,
+            index: d,
+            segment: _
+          };
+          this.rBush_.insert(
+            E(x.segment),
+            x
+          );
+        }
+        this.updateSegmentIndices_(o, h, u.depth, -1), this.vertexFeature_ && (this.overlay_.getSource().removeFeature(this.vertexFeature_), this.vertexFeature_ = null), e.length = 0;
+      }
+    }
+    return s;
+  }
+  /**
+   * @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, s, i) {
+    this.rBush_.forEachInExtent(
+      e.getExtent(),
+      function(n) {
+        n.geometry === e && (s === void 0 || n.depth === void 0 || at(n.depth, s)) && n.index > t && (n.index += i);
+      }
+    );
+  }
+}
+function St(l, e) {
+  return l.index - e.index;
+}
+function we(l, e, t) {
+  const s = e.geometry;
+  if (s.getType() === "Circle") {
+    let n = (
+      /** @type {import("../geom/Circle.js").default} */
+      s
+    );
+    if (e.index === K) {
+      const r = R(
+        n.getCenter(),
+        C(l)
+      ), o = Math.sqrt(r) - n.getRadius();
+      return o * o;
+    }
+  }
+  const i = C(l);
+  return N[0] = C(e.segment[0]), N[1] = C(e.segment[1]), ft(i, N);
+}
+function De(l, e, t) {
+  const s = e.geometry;
+  if (s.getType() === "Circle" && e.index === K)
+    return ie(
+      /** @type {import("../geom/Circle.js").default} */
+      s.getClosestPoint(
+        C(l)
+      )
+    );
+  const i = C(l);
+  return N[0] = C(e.segment[0]), N[1] = C(e.segment[1]), ie(
+    Ve(i, N)
+  );
+}
+function Pt() {
+  const l = xe();
+  return function(e, t) {
+    return l.Point;
+  };
+}
+const H = {
+  /**
+   * 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 Y extends ne {
+  /**
+   * @param {DrawEventType} type Type.
+   * @param {Feature} feature The feature drawn.
+   */
+  constructor(e, t) {
+    super(e), this.feature = t;
+  }
+}
+function Et(l, e) {
+  const t = [];
+  for (let s = 0; s < e.length; ++s) {
+    const n = e[s].getGeometry();
+    Be(l, n, t);
+  }
+  return t;
+}
+function X(l, e) {
+  return be(l[0], l[1], e[0], e[1]);
+}
+function b(l, e) {
+  const t = l.length;
+  return e < 0 ? l[e + t] : e >= t ? l[e - t] : l[e];
+}
+function $(l, e, t) {
+  let s, i;
+  e < t ? (s = e, i = t) : (s = t, i = e);
+  const n = Math.ceil(s), r = Math.floor(i);
+  if (n > r) {
+    const a = O(l, s), h = O(l, i);
+    return X(a, h);
+  }
+  let o = 0;
+  if (s < n) {
+    const a = O(l, s), h = b(l, n);
+    o += X(a, h);
+  }
+  if (r < i) {
+    const a = b(l, r), h = O(l, i);
+    o += X(a, h);
+  }
+  for (let a = n; a < r - 1; ++a) {
+    const h = b(l, a), c = b(l, a + 1);
+    o += X(h, c);
+  }
+  return o;
+}
+function Be(l, e, t) {
+  if (e instanceof z) {
+    Z(l, e.getCoordinates(), !1, t);
+    return;
+  }
+  if (e instanceof Ie) {
+    const s = e.getCoordinates();
+    for (let i = 0, n = s.length; i < n; ++i)
+      Z(l, s[i], !1, t);
+    return;
+  }
+  if (e instanceof je) {
+    const s = e.getCoordinates();
+    for (let i = 0, n = s.length; i < n; ++i)
+      Z(l, s[i], !0, t);
+    return;
+  }
+  if (e instanceof Re) {
+    const s = e.getCoordinates();
+    for (let i = 0, n = s.length; i < n; ++i) {
+      const r = s[i];
+      for (let o = 0, a = r.length; o < a; ++o)
+        Z(l, r[o], !0, t);
+    }
+    return;
+  }
+  if (e instanceof st) {
+    const s = e.getGeometries();
+    for (let i = 0; i < s.length; ++i)
+      Be(l, s[i], t);
+    return;
+  }
+}
+const le = { index: -1, endIndex: NaN };
+function wt(l, e, t, s) {
+  const i = l[0], n = l[1];
+  let r = 1 / 0, o = -1, a = NaN;
+  for (let d = 0; d < e.targets.length; ++d) {
+    const g = e.targets[d], u = g.coordinates;
+    let f = 1 / 0, _;
+    for (let x = 0; x < u.length - 1; ++x) {
+      const p = u[x], T = u[x + 1], M = qe(i, n, p, T);
+      M.squaredDistance < f && (f = M.squaredDistance, _ = x + M.along);
+    }
+    f < r && (r = f, g.ring && e.targetIndex === d && (g.endIndex > g.startIndex ? _ < g.startIndex && (_ += u.length) : g.endIndex < g.startIndex && _ > g.startIndex && (_ -= u.length)), a = _, o = d);
+  }
+  const h = e.targets[o];
+  let c = h.ring;
+  if (e.targetIndex === o && c) {
+    const d = O(
+      h.coordinates,
+      a
+    ), g = t.getPixelFromCoordinate(d);
+    te(g, e.startPx) > s && (c = !1);
+  }
+  if (c) {
+    const d = h.coordinates, g = d.length, u = h.startIndex, f = a;
+    if (u < f) {
+      const _ = $(
+        d,
+        u,
+        f
+      );
+      $(
+        d,
+        u,
+        f - g
+      ) < _ && (a -= g);
+    } else {
+      const _ = $(
+        d,
+        u,
+        f
+      );
+      $(
+        d,
+        u,
+        f + g
+      ) < _ && (a += g);
+    }
+  }
+  return le.index = o, le.endIndex = a, le;
+}
+function Z(l, e, t, s) {
+  const i = l[0], n = l[1];
+  for (let r = 0, o = e.length - 1; r < o; ++r) {
+    const a = e[r], h = e[r + 1], c = qe(i, n, a, h);
+    if (c.squaredDistance === 0) {
+      const d = r + c.along;
+      s.push({
+        coordinates: e,
+        ring: t,
+        startIndex: d,
+        endIndex: d
+      });
+      return;
+    }
+  }
+}
+const de = { along: 0, squaredDistance: 0 };
+function qe(l, e, t, s) {
+  const i = t[0], n = t[1], r = s[0], o = s[1], a = r - i, h = o - n;
+  let c = 0, d = i, g = n;
+  return (a !== 0 || h !== 0) && (c = ct(((l - i) * a + (e - n) * h) / (a * a + h * h), 0, 1), d += a * c, g += h * c), de.along = c, de.squaredDistance = ht(be(l, e, d, g), 10), de;
+}
+function O(l, e) {
+  const t = l.length;
+  let s = Math.floor(e);
+  const i = e - s;
+  s >= t ? s -= t : s < 0 && (s += t);
+  let n = s + 1;
+  n >= t && (n -= t);
+  const r = l[s], o = r[0], a = r[1], h = l[n], c = h[0] - o, d = h[1] - a;
+  return [o + c * i, a + d * i];
+}
+class Dt extends me {
+  /**
+   * @param {Options} options Options.
+   */
+  constructor(e) {
+    const t = (
+      /** @type {import("./Pointer.js").Options} */
+      e
+    );
+    t.stopDown || (t.stopDown = Ae), 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_ = Lt(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 : Q, this.geometryLayout_ = e.geometryLayout ? e.geometryLayout : "XY";
+    let s = e.geometryFunction;
+    if (!s) {
+      const i = this.mode_;
+      if (i === "Circle")
+        s = function(n, r, o) {
+          const a = r || new Je([NaN, NaN]), h = C(n[0]), c = R(
+            h,
+            C(n[n.length - 1])
+          );
+          return a.setCenterAndRadius(
+            h,
+            Math.sqrt(c),
+            this.geometryLayout_
+          ), a;
+        };
+      else {
+        let n;
+        i === "Point" ? n = U : i === "LineString" ? n = z : i === "Polygon" && (n = je), s = function(r, o, a) {
+          return o ? i === "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 n(r, this.geometryLayout_), o;
+        };
+      }
+    }
+    this.geometryFunction_ = s, 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 se({
+      source: new ye({
+        useSpatialIndex: !1,
+        wrapX: e.wrapX ? e.wrapX : !1
+      }),
+      style: e.style ? e.style : Mt(),
+      updateWhileInteracting: !0
+    }), this.geometryName_ = e.geometryName, this.condition_ = e.condition ? e.condition : Qe, this.freehandCondition_, e.freehand ? this.freehandCondition_ = _e : this.freehandCondition_ = e.freehandCondition ? e.freehandCondition : ve, this.traceCondition_, this.setTrace(e.trace || !1), this.traceState_ = { active: !1 }, this.traceSource_ = e.traceSource || e.source || null, this.addChangeListener(et.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 = _e : t = e : t = ge, 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 === ee.CONTEXTMENU && e.originalEvent.preventDefault(), this.freehand_ = this.mode_ !== "Point" && this.freehandCondition_(e);
+    let t = e.type === D.POINTERMOVE, s = !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), s = !1) : this.freehand_ && e.type === D.POINTERDOWN ? s = !1 : t && this.getPointerCount() < 2 ? (s = e.type === D.POINTERMOVE, s && 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 && (s = !1), super.handleEvent(e) && s;
+  }
+  /**
+   * 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 tt(
+          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(), s = t.getCoordinateFromPixel([
+      e.pixel[0] - this.snapTolerance_,
+      e.pixel[1] + this.snapTolerance_
+    ]), i = t.getCoordinateFromPixel([
+      e.pixel[0] + this.snapTolerance_,
+      e.pixel[1] - this.snapTolerance_
+    ]), n = E([s, i]), r = this.traceSource_.getFeaturesInExtent(n);
+    if (r.length === 0)
+      return;
+    const o = Et(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 s = e.startIndex <= e.endIndex, i = e.startIndex <= t;
+    s === i ? s && t > e.endIndex || !s && t < e.endIndex ? this.addTracedCoordinates_(e, e.endIndex, t) : (s && t < e.endIndex || !s && 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 s = 0;
+    if (e < t) {
+      const i = Math.ceil(e);
+      let n = Math.floor(t);
+      n === t && (n -= 1), s = n - i + 1;
+    } else {
+      const i = Math.floor(e);
+      let n = Math.ceil(t);
+      n === t && (n += 1), s = i - n + 1;
+    }
+    s > 0 && this.removeLastPoints_(s);
+  }
+  /**
+   * @param {TraceTarget} target The trace target.
+   * @param {number} fromIndex The start index.
+   * @param {number} toIndex The end index.
+   * @private
+   */
+  addTracedCoordinates_(e, t, s) {
+    if (t === s)
+      return;
+    const i = [];
+    if (t < s) {
+      const n = Math.ceil(t);
+      let r = Math.floor(s);
+      r === s && (r -= 1);
+      for (let o = n; o <= r; ++o)
+        i.push(b(e.coordinates, o));
+    } else {
+      const n = Math.floor(t);
+      let r = Math.ceil(s);
+      r === s && (r += 1);
+      for (let o = n; o >= r; --o)
+        i.push(b(e.coordinates, o));
+    }
+    i.length && this.appendCoordinates(i);
+  }
+  /**
+   * Update the trace.
+   * @param {import("../MapBrowserEvent.js").default} event Event.
+   * @private
+   */
+  updateTrace_(e) {
+    const t = this.traceState_;
+    if (!t.active || t.targetIndex === -1 && te(t.startPx, e.pixel) < this.snapTolerance_)
+      return;
+    const s = wt(
+      e.coordinate,
+      t,
+      this.getMap(),
+      this.snapTolerance_
+    );
+    if (t.targetIndex !== s.index) {
+      if (t.targetIndex !== -1) {
+        const a = t.targets[t.targetIndex];
+        this.removeTracedCoordinates_(a.startIndex, a.endIndex);
+      }
+      const o = t.targets[s.index];
+      this.addTracedCoordinates_(
+        o,
+        o.startIndex,
+        s.endIndex
+      );
+    } else {
+      const o = t.targets[t.targetIndex];
+      this.addOrRemoveTracedCoordinates_(o, s.endIndex);
+    }
+    t.targetIndex = s.index;
+    const i = t.targets[t.targetIndex];
+    i.endIndex = s.endIndex;
+    const n = O(
+      i.coordinates,
+      i.endIndex
+    ), r = this.getMap().getPixelFromCoordinate(n);
+    e.coordinate = n, 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 s = this.traceState_.active;
+      if (this.toggleTraceState_(e), this.shouldHandle_) {
+        const i = !this.finishCoordinate_;
+        i && this.startDrawing_(e.coordinate), !i && this.freehand_ ? this.finishDrawing() : !this.freehand_ && (!i || this.mode_ === "Point") && (this.atFinish_(e.pixel, s) ? 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_, s = e.pixel, i = t[0] - s[0], n = t[1] - s[1], r = i * i + n * n;
+      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 s = !1;
+    if (this.sketchFeature_) {
+      let i = !1, n = [this.finishCoordinate_];
+      const r = this.mode_;
+      if (r === "Point")
+        s = !0;
+      else if (r === "Circle")
+        s = this.sketchCoords_.length === 2;
+      else if (r === "LineString")
+        i = !t && this.sketchCoords_.length > this.minPoints_;
+      else if (r === "Polygon") {
+        const o = (
+          /** @type {PolyCoordType} */
+          this.sketchCoords_
+        );
+        i = o[0].length > this.minPoints_, n = [
+          o[0][0],
+          o[0][o[0].length - 2]
+        ], t ? n = [o[0][0]] : n = [
+          o[0][0],
+          o[0][o[0].length - 2]
+        ];
+      }
+      if (i) {
+        const o = this.getMap();
+        for (let a = 0, h = n.length; a < h; a++) {
+          const c = n[a], d = o.getPixelFromCoordinate(c), g = e[0] - d[0], u = e[1] - d[1], f = this.freehand_ ? 1 : this.snapTolerance_;
+          if (s = Math.sqrt(g * g + u * u) <= f, s) {
+            this.finishCoordinate_ = c;
+            break;
+          }
+        }
+      }
+    }
+    return s;
+  }
+  /**
+   * @param {import("../coordinate").Coordinate} coordinates Coordinate.
+   * @private
+   */
+  createOrUpdateSketchPoint_(e) {
+    this.sketchPoint_ ? this.sketchPoint_.getGeometry().setCoordinates(e) : (this.sketchPoint_ = new L(new U(e)), this.updateSketchFeatures_());
+  }
+  /**
+   * @param {import("../geom/Polygon.js").default} geometry Polygon geometry.
+   * @private
+   */
+  createOrUpdateCustomSketchLine_(e) {
+    this.sketchLine_ || (this.sketchLine_ = new L());
+    const t = e.getLinearRing(0);
+    let s = this.sketchLine_.getGeometry();
+    s ? (s.setFlatCoordinates(
+      t.getLayout(),
+      t.getFlatCoordinates()
+    ), s.changed()) : (s = new z(
+      t.getFlatCoordinates(),
+      t.getLayout()
+    ), this.sketchLine_.setGeometry(s));
+  }
+  /**
+   * Start the drawing.
+   * @param {import("../coordinate.js").Coordinate} start Start coordinate.
+   * @private
+   */
+  startDrawing_(e) {
+    const t = this.getMap().getView().getProjection(), s = Se(this.geometryLayout_);
+    for (; e.length < s; )
+      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 L(new z(this.sketchLineCoords_)));
+    const i = this.geometryFunction_(
+      this.sketchCoords_,
+      void 0,
+      t
+    );
+    this.sketchFeature_ = new L(), this.geometryName_ && this.sketchFeature_.setGeometryName(this.geometryName_), this.sketchFeature_.setGeometry(i), this.updateSketchFeatures_(), this.dispatchEvent(
+      new Y(H.DRAWSTART, this.sketchFeature_)
+    );
+  }
+  /**
+   * Modify the drawing.
+   * @param {import("../coordinate.js").Coordinate} coordinate Coordinate.
+   * @private
+   */
+  modifyDrawing_(e) {
+    const t = this.getMap(), s = this.sketchFeature_.getGeometry(), i = t.getView().getProjection(), n = Se(this.geometryLayout_);
+    let r, o;
+    for (; e.length < n; )
+      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_,
+      s,
+      i
+    ), this.sketchPoint_ && this.sketchPoint_.getGeometry().setCoordinates(e), s.getType() === "Polygon" && this.mode_ !== "Polygon" ? this.createOrUpdateCustomSketchLine_(
+      /** @type {Polygon} */
+      s
+    ) : 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(), s = this.getMap().getView().getProjection();
+    let i, n;
+    const r = this.mode_;
+    r === "LineString" || r === "Circle" ? (this.finishCoordinate_ = e.slice(), n = /** @type {LineCoordType} */
+    this.sketchCoords_, n.length >= this.maxPoints_ && (this.freehand_ ? n.pop() : i = !0), n.push(e.slice()), this.geometryFunction_(n, t, s)) : r === "Polygon" && (n = /** @type {PolyCoordType} */
+    this.sketchCoords_[0], n.length >= this.maxPoints_ && (this.freehand_ ? n.pop() : i = !0), n.push(e.slice()), i && (this.finishCoordinate_ = n[0]), this.geometryFunction_(this.sketchCoords_, t, s)), this.createOrUpdateSketchPoint_(e.slice()), this.updateSketchFeatures_(), i && this.finishDrawing();
+  }
+  /**
+   * @param {number} n The number of points to remove.
+   */
+  removeLastPoints_(e) {
+    if (!this.sketchFeature_)
+      return;
+    const t = this.sketchFeature_.getGeometry(), s = this.getMap().getView().getProjection(), i = this.mode_;
+    for (let n = 0; n < e; ++n) {
+      let r;
+      if (i === "LineString" || i === "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, s), t.getType() === "Polygon" && this.sketchLine_ && this.createOrUpdateCustomSketchLine_(
+          /** @type {Polygon} */
+          t
+        );
+      } else if (i === "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, s);
+      }
+      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 s = e.getGeometry(), i = this.getMap().getView().getProjection();
+    this.mode_ === "LineString" ? (t.pop(), this.geometryFunction_(t, s, i)) : this.mode_ === "Polygon" && (t[0].pop(), this.geometryFunction_(t, s, i), t = s.getCoordinates()), this.type_ === "MultiPoint" ? e.setGeometry(
+      new it([
+        /** @type {PointCoordType} */
+        t
+      ])
+    ) : this.type_ === "MultiLineString" ? e.setGeometry(
+      new Ie([
+        /** @type {LineCoordType} */
+        t
+      ])
+    ) : this.type_ === "MultiPolygon" && e.setGeometry(
+      new Re([
+        /** @type {PolyCoordType} */
+        t
+      ])
+    ), this.dispatchEvent(new Y(H.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 Y(H.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_, s = !this.sketchFeature_;
+    s && this.startDrawing_(e[0]);
+    let i;
+    if (t === "LineString" || t === "Circle")
+      i = /** @type {LineCoordType} */
+      this.sketchCoords_;
+    else if (t === "Polygon")
+      i = this.sketchCoords_ && this.sketchCoords_.length ? (
+        /** @type {PolyCoordType} */
+        this.sketchCoords_[0]
+      ) : [];
+    else
+      return;
+    s && i.shift(), i.pop();
+    for (let r = 0; r < e.length; r++)
+      this.addToDrawing_(e[r]);
+    const n = e[e.length - 1];
+    this.addToDrawing_(n), this.modifyDrawing_(n);
+  }
+  /**
+   * 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 s = e.getGeometry();
+    this.sketchFeature_ = e, this.sketchCoords_ = s.getCoordinates();
+    const i = this.sketchCoords_[this.sketchCoords_.length - 1];
+    this.finishCoordinate_ = i.slice(), this.sketchCoords_.push(i.slice()), this.sketchPoint_ = new L(new U(i)), this.updateSketchFeatures_(), this.dispatchEvent(
+      new Y(H.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 Mt() {
+  const l = xe();
+  return function(e, t) {
+    return l[e.getGeometry().getType()];
+  };
+}
+function Lt(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 kt = {
+  /**
+   * Triggered upon snapping to vertex or edge
+   * @event SnapEvent#snap
+   * @api
+   */
+  SNAP: "snap"
+};
+class vt extends ne {
+  /**
+   * @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 Me(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 ue = [];
+class Gt extends me {
+  /**
+   * @param {Options} [options] Options.
+   */
+  constructor(e) {
+    e = e || {};
+    const t = (
+      /** @type {import("./Pointer.js").Options} */
+      e
+    );
+    t.handleDownEvent || (t.handleDownEvent = Q), t.stopDown || (t.stopDown = Ae), 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 Ge(), 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 s = F(e), i = e.getGeometry();
+    if (i) {
+      const n = this.GEOMETRY_SEGMENTERS_[i.getType()];
+      if (n) {
+        this.indexedFeaturesExtents_[s] = i.getExtent(
+          _t()
+        );
+        const r = (
+          /** @type {Array<Array<import('../coordinate.js').Coordinate>>} */
+          []
+        );
+        if (n(r, i), r.length === 1)
+          this.rBush_.insert(E(r[0]), {
+            feature: e,
+            segment: r[0]
+          });
+        else if (r.length > 1) {
+          const o = r.map((h) => E(h)), a = r.map((h) => ({
+            feature: e,
+            segment: h
+          }));
+          this.rBush_.load(o, a);
+        }
+      }
+    }
+    t && (this.featureChangeListenerKeys_[s] = q(
+      e,
+      ee.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 vt(kt.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 = Me(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 = Me(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 s = F(t);
+      s in this.pendingFeatures_ || (this.pendingFeatures_[s] = 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 s = t !== void 0 ? t : !0, i = F(e), n = this.indexedFeaturesExtents_[i];
+    if (n) {
+      const r = this.rBush_, o = [];
+      r.forEachInExtent(n, function(a) {
+        e === a.feature && o.push(a);
+      });
+      for (let a = o.length - 1; a >= 0; --a)
+        r.remove(o[a]);
+    }
+    s && (oe(this.featureChangeListenerKeys_[i]), delete this.featureChangeListenerKeys_[i]);
+  }
+  /**
+   * 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(), s = this.featuresListenerKeys_, i = (
+      /** @type {Array<import("../Feature.js").default>} */
+      this.getFeatures_()
+    );
+    t && (s.forEach(oe), s.length = 0, this.rBush_.clear(), Object.values(this.featureChangeListenerKeys_).forEach(oe), this.featureChangeListenerKeys_ = {}), super.setMap(e), e && (this.features_ ? s.push(
+      q(
+        this.features_,
+        v.ADD,
+        this.handleFeatureAdd_,
+        this
+      ),
+      q(
+        this.features_,
+        v.REMOVE,
+        this.handleFeatureRemove_,
+        this
+      )
+    ) : this.source_ && s.push(
+      q(
+        this.source_,
+        J.ADDFEATURE,
+        this.handleFeatureAdd_,
+        this
+      ),
+      q(
+        this.source_,
+        J.REMOVEFEATURE,
+        this.handleFeatureRemove_,
+        this
+      )
+    ), i.forEach((n) => this.addFeature(n)));
+  }
+  /**
+   * @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, s) {
+    s.getView().getProjection();
+    const i = C(t), n = Oe(
+      Ne(
+        E([i]),
+        s.getView().getResolution() * this.pixelTolerance_
+      )
+    ), r = this.rBush_.getInExtent(n), o = r.length;
+    if (o === 0)
+      return null;
+    let a, h = 1 / 0, c;
+    const d = this.pixelTolerance_ * this.pixelTolerance_, g = () => {
+      if (a) {
+        const u = s.getPixelFromCoordinate(a);
+        if (R(e, u) <= d)
+          return {
+            vertex: a,
+            vertexPixel: [
+              Math.round(u[0]),
+              Math.round(u[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 p = C(x), T = R(i, p);
+          T < h && (a = x, h = T, c = _.feature);
+        });
+      }
+      const u = g();
+      if (u)
+        return u;
+    }
+    if (this.edge_) {
+      for (let f = 0; f < o; ++f) {
+        let _ = null;
+        const x = r[f];
+        if (x.feature.getGeometry().getType() === "Circle") {
+          let p = x.feature.getGeometry();
+          _ = mt(
+            i,
+            /** @type {import("../geom/Circle.js").default} */
+            p
+          );
+        } else {
+          const [p, T] = x.segment;
+          T && (ue[0] = C(p), ue[1] = C(T), _ = Ve(i, ue));
+        }
+        if (_) {
+          const p = R(i, _);
+          p < h && (a = ie(_), h = p);
+        }
+      }
+      const u = g();
+      if (u)
+        return u;
+    }
+    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 n = yt(t).getCoordinates()[0];
+    for (let r = 0, o = n.length - 1; r < o; ++r)
+      e.push(n.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 s = t.getGeometriesArray();
+    for (let i = 0; i < s.length; ++i) {
+      const n = this.GEOMETRY_SEGMENTERS_[s[i].getType()];
+      n && n(e, s[i]);
+    }
+  }
+  /**
+   * @param {Array<Array<import('../coordinate.js').Coordinate>>} segments Segments
+   * @param {import("../geom/LineString.js").default} geometry Geometry.
+   * @private
+   */
+  segmentLineStringGeometry_(e, t) {
+    const s = t.getCoordinates();
+    for (let i = 0, n = s.length - 1; i < n; ++i)
+      e.push(s.slice(i, i + 2));
+  }
+  /**
+   * @param {Array<Array<import('../coordinate.js').Coordinate>>} segments Segments
+   * @param {import("../geom/MultiLineString.js").default} geometry Geometry.
+   * @private
+   */
+  segmentMultiLineStringGeometry_(e, t) {
+    const s = t.getCoordinates();
+    for (let i = 0, n = s.length; i < n; ++i) {
+      const r = s[i];
+      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((s) => {
+      e.push([s]);
+    });
+  }
+  /**
+   * @param {Array<Array<import('../coordinate.js').Coordinate>>} segments Segments
+   * @param {import("../geom/MultiPolygon.js").default} geometry Geometry.
+   * @private
+   */
+  segmentMultiPolygonGeometry_(e, t) {
+    const s = t.getCoordinates();
+    for (let i = 0, n = s.length; i < n; ++i) {
+      const r = s[i];
+      for (let o = 0, a = r.length; o < a; ++o) {
+        const h = r[o];
+        for (let c = 0, d = h.length - 1; c < d; ++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 s = t.getCoordinates();
+    for (let i = 0, n = s.length; i < n; ++i) {
+      const r = s[i];
+      for (let o = 0, a = r.length - 1; o < a; ++o)
+        e.push(r.slice(o, o + 2));
+    }
+  }
+}
+let Le = null, w = new ye(), P = {
+  layer: new se({
+    source: w,
+    style: lt
+  }),
+  modify: new Tt({ source: w }),
+  draw: null,
+  snap: null,
+  select: new pe({
+    condition: nt,
+    style: dt
+  })
+};
+function qt(l) {
+  const e = k.useRef(null), [t, s] = k.useState("Pointer"), [i, n] = k.useState(!1), [r, o] = k.useState({
+    open: !1,
+    buttons: [],
+    position: void 0
+  });
+  k.useEffect(() => (a(), h(), c(), V(), () => {
+  }), []), k.useEffect(() => {
+    if (t !== "Pointer") {
+      if (t === "KML") {
+        re();
+        return;
+      }
+      return x(t), () => {
+      };
+    }
+  }, [t]), k.useEffect(() => (l.drawingKMLData && T(l.drawingKMLData), () => {
+  }), [l.drawingKMLData]), k.useEffect(() => (l.drawingWKTData && (V(), l.drawingWKTData !== "GEOMETRYCOLLECTION()" && M(l.drawingWKTData)), () => {
+  }), [l.drawingWKTData]);
+  const a = () => {
+    d(), g();
+  }, h = () => {
+    u(), f();
+  }, c = () => {
+    _();
+  }, d = () => {
+    var y;
+    Le = Xe({
+      id: l.id,
+      center: [0, 0],
+      style: "mapbox://styles/mapbox/streets-v11",
+      accessToken: l.mapboxAccessToken
+    }).layer, (y = e.current) == null || y.addLayer(Le);
+  }, g = () => {
+    var m;
+    (m = e.current) == null || m.addLayer(P.layer);
+  }, u = () => {
+    var m;
+    (m = e.current) == null || m.addInteraction(P.select), P.select.on("select", function() {
+      l.onSelect && l.onSelect(P.select.getFeatures().getArray());
+    });
+  }, f = () => {
+    var m;
+    (m = e.current) == null || m.addInteraction(P.modify), P.modify.on("modifyend", () => {
+      setTimeout(() => {
+        l.onDrawEnd && l.onDrawEnd(w.getFeatures());
+      }, 250), p();
+    });
+  }, _ = async () => {
+    var m;
+    (m = e.current) == null || m.on(
+      "contextmenu",
+      async (y) => {
+        var B;
+        y.preventDefault();
+        const S = (B = e.current) == null ? void 0 : B.getEventPixel(y.originalEvent);
+        if (S) {
+          const A = await P.layer.getFeatures(S);
+          if (A && A.length > 0) {
+            o({
+              open: !0,
+              buttons: [
+                {
+                  label: "Delete",
+                  onClick: () => {
+                    A.forEach(
+                      (Ye) => G(Ye)
+                    ), j(), setTimeout(() => {
+                      l.onDrawEnd && l.onDrawEnd(w.getFeatures());
+                    }, 250);
+                  }
+                }
+              ],
+              position: {
+                top: S[1],
+                left: S[0]
+              }
+            });
+            return;
+          }
+        }
+        j();
+      }
+    );
+  }, x = (m) => {
+    var B, A;
+    p();
+    const y = new Dt({
+      source: w,
+      type: m
+    }), S = new Gt({ source: w });
+    y.on("drawend", () => {
+      setTimeout(() => {
+        l.onDrawEnd && l.onDrawEnd(w.getFeatures());
+      }, 250), p(), s("Pointer");
+    }), P.draw = y, P.snap = S, (B = e.current) == null || B.addInteraction(y), (A = e.current) == null || A.addInteraction(S);
+  }, p = () => {
+    var m, y;
+    P.draw && ((m = e.current) == null || m.removeInteraction(P.draw)), P.snap && ((y = e.current) == null || y.removeInteraction(P.snap));
+  }, T = (m) => {
+    const y = Fe(m);
+    y && w.addFeatures(y);
+  }, M = (m) => {
+    const y = rt(m, ut);
+    y && w.addFeatures(y);
+  }, V = () => {
+    w.clear();
+  }, G = (m) => {
+    w.removeFeature(m);
+  }, j = () => {
+    o({
+      open: !1,
+      buttons: []
+    });
+  }, re = () => {
+    n((m) => !m);
+  }, Ue = (m) => {
+    var S;
+    const y = Fe(m);
+    y ? (re(), w.addFeatures(y), (S = e.current) == null || S.centerToFeature(y[0]), l.onDrawEnd && l.onDrawEnd(y)) : xt("Error!", "Feature(s) could not be loaded! Check your KML data!");
+  }, Ke = (m) => {
+    var y;
+    (y = e.current) == null || y.setCenter(m);
+  }, We = (m) => {
+    var y;
+    (y = e.current) == null || y.setZoomLevel(m);
+  }, He = (m, y = [0, 0, 0, 0]) => {
+    var S;
+    (S = e.current) == null || S.centerToFeature(m, y);
+  }, Ce = (m) => {
+    var y;
+    (y = e.current) == null || y.centerToExtent(m);
+  };
+  return {
+    refs: {
+      mapRef: e
+    },
+    state: {
+      activeDrawingTool: t,
+      openAddKMLText: i,
+      contextMenu: r
+    },
+    action: {
+      setActiveDrawingTool: s,
+      addInteractions: x,
+      addDrawingSourceKMLData: T,
+      addDrawingSourceWKTData: M,
+      clearDrawingSource: V,
+      toggleAddKMLText: re,
+      addKMLText: Ue,
+      setContextMenu: o,
+      setCenter: Ke,
+      setZoomLevel: We,
+      centerToFeature: He,
+      centerToExtent: Ce,
+      onMapInit: () => {
+        l.defaultExtent && Ce(l.defaultExtent);
+      }
+    }
+  };
+}
+export {
+  qt as default
+};