gisviewer-vue3-arcgis 1.0.280 → 1.0.282

package/es/node_modules/.pnpm/ol@10.7.0/node_modules/ol/source/Vector.mjs

@@ -0,0 +1,667 @@
+import C from "../Collection.mjs";
+import E from "../CollectionEventType.mjs";
+import p from "../ObjectEventType.mjs";
+import { extend as A } from "../array.mjs";
+import { assert as m } from "../asserts.mjs";
+import T from "../events/Event.mjs";
+import G from "../events/EventType.mjs";
+import { listen as g, unlistenByKey as x } from "../events.mjs";
+import { wrapAndSliceX as D, containsExtent as w, equals as S } from "../extent.mjs";
+import { xhr as y } from "../featureloader.mjs";
+import { VOID as L, TRUE as U } from "../functions.mjs";
+import { all as O } from "../loadingstrategy.mjs";
+import { isEmpty as F } from "../obj.mjs";
+import f from "../render/Feature.mjs";
+import I from "../structs/RBush.mjs";
+import { getUid as c } from "../util.mjs";
+import K from "./Source.mjs";
+import u from "./VectorEventType.mjs";
+class d extends T {
+  /**
+   * @param {string} type Type.
+   * @param {FeatureType} [feature] Feature.
+   * @param {Array<FeatureType>} [features] Features.
+   */
+  constructor(e, t, s) {
+    super(e), this.feature = t, this.features = s;
+  }
+}
+class V extends K {
+  /**
+   * @param {Options<FeatureType>} [options] Vector source options.
+   */
+  constructor(e) {
+    e = e || {}, super({
+      attributions: e.attributions,
+      interpolate: !0,
+      projection: void 0,
+      state: "ready",
+      wrapX: e.wrapX !== void 0 ? e.wrapX : !0
+    }), this.on, this.once, this.un, this.loader_ = L, this.format_ = e.format || null, this.overlaps_ = e.overlaps === void 0 ? !0 : e.overlaps, this.url_ = e.url, e.loader !== void 0 ? this.loader_ = e.loader : this.url_ !== void 0 && (m(this.format_, "`format` must be set when `url` is set"), this.loader_ = y(this.url_, this.format_)), this.strategy_ = e.strategy !== void 0 ? e.strategy : O;
+    const t = e.useSpatialIndex !== void 0 ? e.useSpatialIndex : !0;
+    this.featuresRtree_ = t ? new I() : null, this.loadedExtentsRtree_ = new I(), this.loadingExtentsCount_ = 0, this.nullGeometryFeatures_ = {}, this.idIndex_ = {}, this.uidIndex_ = {}, this.featureChangeKeys_ = {}, this.featuresCollection_ = null;
+    let s, r;
+    Array.isArray(e.features) ? r = e.features : e.features && (s = e.features, r = s.getArray()), !t && s === void 0 && (s = new C(r)), r !== void 0 && this.addFeaturesInternal(r), s !== void 0 && this.bindFeaturesCollection_(s);
+  }
+  /**
+   * Add a single feature to the source.  If you want to add a batch of features
+   * at once, call {@link module:ol/source/Vector~VectorSource#addFeatures #addFeatures()}
+   * instead. A feature will not be added to the source if feature with
+   * the same id is already there. The reason for this behavior is to avoid
+   * feature duplication when using bbox or tile loading strategies.
+   * Note: this also applies if a {@link module:ol/Collection~Collection} is used for features,
+   * meaning that if a feature with a duplicate id is added in the collection, it will
+   * be removed from it right away.
+   * @param {FeatureType} feature Feature to add.
+   * @api
+   */
+  addFeature(e) {
+    this.addFeatureInternal(e), this.changed();
+  }
+  /**
+   * Add a feature without firing a `change` event.
+   * @param {FeatureType} feature Feature.
+   * @protected
+   */
+  addFeatureInternal(e) {
+    const t = c(e);
+    if (!this.addToIndex_(t, e)) {
+      this.featuresCollection_ && this.featuresCollection_.remove(e);
+      return;
+    }
+    this.setupChangeEvents_(t, e);
+    const s = e.getGeometry();
+    if (s) {
+      const r = s.getExtent();
+      this.featuresRtree_ && this.featuresRtree_.insert(r, e);
+    } else
+      this.nullGeometryFeatures_[t] = e;
+    this.dispatchEvent(
+      new d(u.ADDFEATURE, e)
+    );
+  }
+  /**
+   * @param {string} featureKey Unique identifier for the feature.
+   * @param {FeatureType} feature The feature.
+   * @private
+   */
+  setupChangeEvents_(e, t) {
+    t instanceof f || (this.featureChangeKeys_[e] = [
+      g(t, G.CHANGE, this.handleFeatureChange_, this),
+      g(
+        t,
+        p.PROPERTYCHANGE,
+        this.handleFeatureChange_,
+        this
+      )
+    ]);
+  }
+  /**
+   * @param {string} featureKey Unique identifier for the feature.
+   * @param {FeatureType} feature The feature.
+   * @return {boolean} The feature is "valid", in the sense that it is also a
+   *     candidate for insertion into the Rtree.
+   * @private
+   */
+  addToIndex_(e, t) {
+    let s = !0;
+    if (t.getId() !== void 0) {
+      const r = String(t.getId());
+      if (!(r in this.idIndex_))
+        this.idIndex_[r] = t;
+      else if (t instanceof f) {
+        const i = this.idIndex_[r];
+        i instanceof f ? Array.isArray(i) ? i.push(t) : this.idIndex_[r] = [i, t] : s = !1;
+      } else
+        s = !1;
+    }
+    return s && (m(
+      !(e in this.uidIndex_),
+      "The passed `feature` was already added to the source"
+    ), this.uidIndex_[e] = t), s;
+  }
+  /**
+   * Add a batch of features to the source.
+   * @param {Array<FeatureType>} features Features to add.
+   * @api
+   */
+  addFeatures(e) {
+    this.addFeaturesInternal(e), this.changed();
+  }
+  /**
+   * Add features without firing a `change` event.
+   * @param {Array<FeatureType>} features Features.
+   * @protected
+   */
+  addFeaturesInternal(e) {
+    const t = [], s = [], r = [];
+    for (let i = 0, n = e.length; i < n; i++) {
+      const a = e[i], o = c(a);
+      this.addToIndex_(o, a) && s.push(a);
+    }
+    for (let i = 0, n = s.length; i < n; i++) {
+      const a = s[i], o = c(a);
+      this.setupChangeEvents_(o, a);
+      const l = a.getGeometry();
+      if (l) {
+        const h = l.getExtent();
+        t.push(h), r.push(a);
+      } else
+        this.nullGeometryFeatures_[o] = a;
+    }
+    if (this.featuresRtree_ && this.featuresRtree_.load(t, r), this.hasListener(u.ADDFEATURE))
+      for (let i = 0, n = s.length; i < n; i++)
+        this.dispatchEvent(
+          new d(u.ADDFEATURE, s[i])
+        );
+  }
+  /**
+   * @param {!Collection<FeatureType>} collection Collection.
+   * @private
+   */
+  bindFeaturesCollection_(e) {
+    let t = !1;
+    this.addEventListener(
+      u.ADDFEATURE,
+      /**
+       * @param {VectorSourceEvent<FeatureType>} evt The vector source event
+       */
+      function(s) {
+        t || (t = !0, e.push(s.feature), t = !1);
+      }
+    ), this.addEventListener(
+      u.REMOVEFEATURE,
+      /**
+       * @param {VectorSourceEvent<FeatureType>} evt The vector source event
+       */
+      function(s) {
+        t || (t = !0, e.remove(s.feature), t = !1);
+      }
+    ), e.addEventListener(
+      E.ADD,
+      /**
+       * @param {import("../Collection.js").CollectionEvent<FeatureType>} evt The collection event
+       */
+      (s) => {
+        t || (t = !0, this.addFeature(s.element), t = !1);
+      }
+    ), e.addEventListener(
+      E.REMOVE,
+      /**
+       * @param {import("../Collection.js").CollectionEvent<FeatureType>} evt The collection event
+       */
+      (s) => {
+        t || (t = !0, this.removeFeature(s.element), t = !1);
+      }
+    ), this.featuresCollection_ = e;
+  }
+  /**
+   * Remove all features from the source.
+   * @param {boolean} [fast] Skip dispatching of {@link module:ol/source/Vector.VectorSourceEvent#event:removefeature} events.
+   * @api
+   */
+  clear(e) {
+    if (e) {
+      for (const s in this.featureChangeKeys_)
+        this.featureChangeKeys_[s].forEach(x);
+      this.featuresCollection_ || (this.featureChangeKeys_ = {}, this.idIndex_ = {}, this.uidIndex_ = {});
+    } else if (this.featuresRtree_) {
+      this.featuresRtree_.forEach((s) => {
+        this.removeFeatureInternal(s);
+      });
+      for (const s in this.nullGeometryFeatures_)
+        this.removeFeatureInternal(this.nullGeometryFeatures_[s]);
+    }
+    this.featuresCollection_ && this.featuresCollection_.clear(), this.featuresRtree_ && this.featuresRtree_.clear(), this.nullGeometryFeatures_ = {};
+    const t = new d(u.CLEAR);
+    this.dispatchEvent(t), this.changed();
+  }
+  /**
+   * Iterate through all features on the source, calling the provided callback
+   * with each one.  If the callback returns any "truthy" value, iteration will
+   * stop and the function will return the same value.
+   * Note: this function only iterate through the feature that have a defined geometry.
+   *
+   * @param {function(FeatureType): T} callback Called with each feature
+   *     on the source.  Return a truthy value to stop iteration.
+   * @return {T|undefined} The return value from the last call to the callback.
+   * @template T
+   * @api
+   */
+  forEachFeature(e) {
+    if (this.featuresRtree_)
+      return this.featuresRtree_.forEach(e);
+    this.featuresCollection_ && this.featuresCollection_.forEach(e);
+  }
+  /**
+   * Iterate through all features whose geometries contain the provided
+   * coordinate, calling the callback with each feature.  If the callback returns
+   * a "truthy" value, iteration will stop and the function will return the same
+   * value.
+   *
+   * For {@link module:ol/render/Feature~RenderFeature} features, the callback will be
+   * called for all features.
+   *
+   * @param {import("../coordinate.js").Coordinate} coordinate Coordinate.
+   * @param {function(FeatureType): T} callback Called with each feature
+   *     whose goemetry contains the provided coordinate.
+   * @return {T|undefined} The return value from the last call to the callback.
+   * @template T
+   */
+  forEachFeatureAtCoordinateDirect(e, t) {
+    const s = [e[0], e[1], e[0], e[1]];
+    return this.forEachFeatureInExtent(s, function(r) {
+      const i = r.getGeometry();
+      if (i instanceof f || i.intersectsCoordinate(e))
+        return t(r);
+    });
+  }
+  /**
+   * Iterate through all features whose bounding box intersects the provided
+   * extent (note that the feature's geometry may not intersect the extent),
+   * calling the callback with each feature.  If the callback returns a "truthy"
+   * value, iteration will stop and the function will return the same value.
+   *
+   * If you are interested in features whose geometry intersects an extent, call
+   * the {@link module:ol/source/Vector~VectorSource#forEachFeatureIntersectingExtent #forEachFeatureIntersectingExtent()} method instead.
+   *
+   * When `useSpatialIndex` is set to false, this method will loop through all
+   * features, equivalent to {@link module:ol/source/Vector~VectorSource#forEachFeature #forEachFeature()}.
+   *
+   * @param {import("../extent.js").Extent} extent Extent.
+   * @param {function(FeatureType): T} callback Called with each feature
+   *     whose bounding box intersects the provided extent.
+   * @return {T|undefined} The return value from the last call to the callback.
+   * @template T
+   * @api
+   */
+  forEachFeatureInExtent(e, t) {
+    if (this.featuresRtree_)
+      return this.featuresRtree_.forEachInExtent(e, t);
+    this.featuresCollection_ && this.featuresCollection_.forEach(t);
+  }
+  /**
+   * Iterate through all features whose geometry intersects the provided extent,
+   * calling the callback with each feature.  If the callback returns a "truthy"
+   * value, iteration will stop and the function will return the same value.
+   *
+   * If you only want to test for bounding box intersection, call the
+   * {@link module:ol/source/Vector~VectorSource#forEachFeatureInExtent #forEachFeatureInExtent()} method instead.
+   *
+   * @param {import("../extent.js").Extent} extent Extent.
+   * @param {function(FeatureType): T} callback Called with each feature
+   *     whose geometry intersects the provided extent.
+   * @return {T|undefined} The return value from the last call to the callback.
+   * @template T
+   * @api
+   */
+  forEachFeatureIntersectingExtent(e, t) {
+    return this.forEachFeatureInExtent(
+      e,
+      /**
+       * @param {FeatureType} feature Feature.
+       * @return {T|undefined} The return value from the last call to the callback.
+       */
+      function(s) {
+        const r = s.getGeometry();
+        if (r instanceof f || r.intersectsExtent(e)) {
+          const i = t(s);
+          if (i)
+            return i;
+        }
+      }
+    );
+  }
+  /**
+   * Get the features collection associated with this source. Will be `null`
+   * unless the source was configured with `useSpatialIndex` set to `false`, or
+   * with a {@link module:ol/Collection~Collection} as `features`.
+   * @return {Collection<FeatureType>|null} The collection of features.
+   * @api
+   */
+  getFeaturesCollection() {
+    return this.featuresCollection_;
+  }
+  /**
+   * Get a snapshot of the features currently on the source in random order. The returned array
+   * is a copy, the features are references to the features in the source.
+   * @return {Array<FeatureType>} Features.
+   * @api
+   */
+  getFeatures() {
+    let e;
+    return this.featuresCollection_ ? e = this.featuresCollection_.getArray().slice(0) : this.featuresRtree_ && (e = this.featuresRtree_.getAll(), F(this.nullGeometryFeatures_) || A(e, Object.values(this.nullGeometryFeatures_))), e;
+  }
+  /**
+   * Get all features whose geometry intersects the provided coordinate.
+   * @param {import("../coordinate.js").Coordinate} coordinate Coordinate.
+   * @return {Array<FeatureType>} Features.
+   * @api
+   */
+  getFeaturesAtCoordinate(e) {
+    const t = [];
+    return this.forEachFeatureAtCoordinateDirect(e, function(s) {
+      t.push(s);
+    }), t;
+  }
+  /**
+   * Get all features whose bounding box intersects the provided extent.  Note that this returns an array of
+   * all features intersecting the given extent in random order (so it may include
+   * features whose geometries do not intersect the extent).
+   *
+   * When `useSpatialIndex` is set to false, this method will return all
+   * features.
+   *
+   * @param {import("../extent.js").Extent} extent Extent.
+   * @param {import("../proj/Projection.js").default} [projection] Include features
+   * where `extent` exceeds the x-axis bounds of `projection` and wraps around the world.
+   * @return {Array<FeatureType>} Features.
+   * @api
+   */
+  getFeaturesInExtent(e, t) {
+    if (this.featuresRtree_) {
+      if (!(t && t.canWrapX() && this.getWrapX()))
+        return this.featuresRtree_.getInExtent(e);
+      const r = D(e, t);
+      return [].concat(
+        ...r.map((i) => this.featuresRtree_.getInExtent(i))
+      );
+    }
+    return this.featuresCollection_ ? this.featuresCollection_.getArray().slice(0) : [];
+  }
+  /**
+   * Get the closest feature to the provided coordinate.
+   *
+   * This method is not available when the source is configured with
+   * `useSpatialIndex` set to `false` and the features in this source are of type
+   * {@link module:ol/Feature~Feature}.
+   * @param {import("../coordinate.js").Coordinate} coordinate Coordinate.
+   * @param {function(FeatureType):boolean} [filter] Feature filter function.
+   *     The filter function will receive one argument, the {@link module:ol/Feature~Feature feature}
+   *     and it should return a boolean value. By default, no filtering is made.
+   * @return {FeatureType|null} Closest feature (or `null` if none found).
+   * @api
+   */
+  getClosestFeatureToCoordinate(e, t) {
+    const s = e[0], r = e[1];
+    let i = null;
+    const n = [NaN, NaN];
+    let a = 1 / 0;
+    const o = [-1 / 0, -1 / 0, 1 / 0, 1 / 0];
+    return t = t || U, this.featuresRtree_.forEachInExtent(
+      o,
+      /**
+       * @param {FeatureType} feature Feature.
+       */
+      function(l) {
+        if (t(l)) {
+          const h = l.getGeometry(), v = a;
+          if (a = h instanceof f ? 0 : h.closestPointXY(s, r, n, a), a < v) {
+            i = l;
+            const _ = Math.sqrt(a);
+            o[0] = s - _, o[1] = r - _, o[2] = s + _, o[3] = r + _;
+          }
+        }
+      }
+    ), i;
+  }
+  /**
+   * Get the extent of the features currently in the source.
+   *
+   * This method is not available when the source is configured with
+   * `useSpatialIndex` set to `false`.
+   * @param {import("../extent.js").Extent} [extent] Destination extent. If provided, no new extent
+   *     will be created. Instead, that extent's coordinates will be overwritten.
+   * @return {import("../extent.js").Extent} Extent.
+   * @api
+   */
+  getExtent(e) {
+    return this.featuresRtree_.getExtent(e);
+  }
+  /**
+   * Get a feature by its identifier (the value returned by feature.getId()). When `RenderFeature`s
+   * are used, `getFeatureById()` can return an array of `RenderFeature`s. This allows for handling
+   * of `GeometryCollection` geometries, where format readers create one `RenderFeature` per
+   * `GeometryCollection` member.
+   * Note that the index treats string and numeric identifiers as the same.  So
+   * `source.getFeatureById(2)` will return a feature with id `'2'` or `2`.
+   *
+   * @param {string|number} id Feature identifier.
+   * @return {FeatureClassOrArrayOfRenderFeatures<FeatureType>|null} The feature (or `null` if not found).
+   * @api
+   */
+  getFeatureById(e) {
+    const t = this.idIndex_[e.toString()];
+    return t !== void 0 ? (
+      /** @type {FeatureClassOrArrayOfRenderFeatures<FeatureType>} */
+      t
+    ) : null;
+  }
+  /**
+   * Get a feature by its internal unique identifier (using `getUid`).
+   *
+   * @param {string} uid Feature identifier.
+   * @return {FeatureType|null} The feature (or `null` if not found).
+   */
+  getFeatureByUid(e) {
+    const t = this.uidIndex_[e];
+    return t !== void 0 ? t : null;
+  }
+  /**
+   * Get the format associated with this source.
+   *
+   * @return {import("../format/Feature.js").default<FeatureType>|null}} The feature format.
+   * @api
+   */
+  getFormat() {
+    return this.format_;
+  }
+  /**
+   * @return {boolean} The source can have overlapping geometries.
+   */
+  getOverlaps() {
+    return this.overlaps_;
+  }
+  /**
+   * Get the url associated with this source.
+   *
+   * @return {string|import("../featureloader.js").FeatureUrlFunction|undefined} The url.
+   * @api
+   */
+  getUrl() {
+    return this.url_;
+  }
+  /**
+   * @param {Event} event Event.
+   * @private
+   */
+  handleFeatureChange_(e) {
+    const t = (
+      /** @type {FeatureType} */
+      e.target
+    ), s = c(t), r = t.getGeometry();
+    if (!r)
+      s in this.nullGeometryFeatures_ || (this.featuresRtree_ && this.featuresRtree_.remove(t), this.nullGeometryFeatures_[s] = t);
+    else {
+      const n = r.getExtent();
+      s in this.nullGeometryFeatures_ ? (delete this.nullGeometryFeatures_[s], this.featuresRtree_ && this.featuresRtree_.insert(n, t)) : this.featuresRtree_ && this.featuresRtree_.update(n, t);
+    }
+    const i = t.getId();
+    if (i !== void 0) {
+      const n = i.toString();
+      this.idIndex_[n] !== t && (this.removeFromIdIndex_(t), this.idIndex_[n] = t);
+    } else
+      this.removeFromIdIndex_(t), this.uidIndex_[s] = t;
+    this.changed(), this.dispatchEvent(
+      new d(u.CHANGEFEATURE, t)
+    );
+  }
+  /**
+   * Returns true if the feature is contained within the source.
+   * @param {FeatureType} feature Feature.
+   * @return {boolean} Has feature.
+   * @api
+   */
+  hasFeature(e) {
+    const t = e.getId();
+    return t !== void 0 ? t in this.idIndex_ : c(e) in this.uidIndex_;
+  }
+  /**
+   * @return {boolean} Is empty.
+   */
+  isEmpty() {
+    return this.featuresRtree_ ? this.featuresRtree_.isEmpty() && F(this.nullGeometryFeatures_) : this.featuresCollection_ ? this.featuresCollection_.getLength() === 0 : !0;
+  }
+  /**
+   * @param {import("../extent.js").Extent} extent Extent.
+   * @param {number} resolution Resolution.
+   * @param {import("../proj/Projection.js").default} projection Projection.
+   */
+  loadFeatures(e, t, s) {
+    const r = this.loadedExtentsRtree_, i = this.strategy_(e, t, s);
+    for (let n = 0, a = i.length; n < a; ++n) {
+      const o = i[n];
+      r.forEachInExtent(
+        o,
+        /**
+         * @param {{extent: import("../extent.js").Extent}} object Object.
+         * @return {boolean} Contains.
+         */
+        function(h) {
+          return w(h.extent, o);
+        }
+      ) || (++this.loadingExtentsCount_, this.dispatchEvent(
+        new d(u.FEATURESLOADSTART)
+      ), this.loader_.call(
+        this,
+        o,
+        t,
+        s,
+        /**
+         * @param {Array<FeatureType>} features Loaded features
+         */
+        (h) => {
+          --this.loadingExtentsCount_, this.dispatchEvent(
+            new d(
+              u.FEATURESLOADEND,
+              void 0,
+              h
+            )
+          );
+        },
+        () => {
+          --this.loadingExtentsCount_, this.dispatchEvent(
+            new d(u.FEATURESLOADERROR)
+          );
+        }
+      ), r.insert(o, { extent: o.slice() }));
+    }
+    this.loading = this.loader_.length < 4 ? !1 : this.loadingExtentsCount_ > 0;
+  }
+  /**
+   * @override
+   */
+  refresh() {
+    this.clear(!0), this.loadedExtentsRtree_.clear(), super.refresh();
+  }
+  /**
+   * Remove an extent from the list of loaded extents.
+   * @param {import("../extent.js").Extent} extent Extent.
+   * @api
+   */
+  removeLoadedExtent(e) {
+    const t = this.loadedExtentsRtree_, s = t.forEachInExtent(e, function(r) {
+      if (S(r.extent, e))
+        return r;
+    });
+    s && t.remove(s);
+  }
+  /**
+   * Batch remove features from the source.  If you want to remove all features
+   * at once, use the {@link module:ol/source/Vector~VectorSource#clear #clear()} method
+   * instead.
+   * @param {Array<FeatureType>} features Features to remove.
+   * @api
+   */
+  removeFeatures(e) {
+    let t = !1;
+    for (let s = 0, r = e.length; s < r; ++s)
+      t = this.removeFeatureInternal(e[s]) || t;
+    t && this.changed();
+  }
+  /**
+   * Remove a single feature from the source. If you want to batch remove
+   * features, use the {@link module:ol/source/Vector~VectorSource#removeFeatures #removeFeatures()} method
+   * instead.
+   * @param {FeatureType} feature Feature to remove.
+   * @api
+   */
+  removeFeature(e) {
+    if (!e)
+      return;
+    this.removeFeatureInternal(e) && this.changed();
+  }
+  /**
+   * Remove feature without firing a `change` event.
+   * @param {FeatureType} feature Feature.
+   * @return {boolean} True if the feature was removed, false if it was not found.
+   * @protected
+   */
+  removeFeatureInternal(e) {
+    const t = c(e);
+    if (!(t in this.uidIndex_))
+      return !1;
+    t in this.nullGeometryFeatures_ ? delete this.nullGeometryFeatures_[t] : this.featuresRtree_ && this.featuresRtree_.remove(e);
+    const s = this.featureChangeKeys_[t];
+    s == null || s.forEach(x), delete this.featureChangeKeys_[t];
+    const r = e.getId();
+    if (r !== void 0) {
+      const i = r.toString(), n = this.idIndex_[i];
+      n === e ? delete this.idIndex_[i] : Array.isArray(n) && (n.splice(n.indexOf(e), 1), n.length === 1 && (this.idIndex_[i] = n[0]));
+    }
+    return delete this.uidIndex_[t], this.hasListener(u.REMOVEFEATURE) && this.dispatchEvent(
+      new d(u.REMOVEFEATURE, e)
+    ), !0;
+  }
+  /**
+   * Remove a feature from the id index.  Called internally when the feature id
+   * may have changed.
+   * @param {FeatureType} feature The feature.
+   * @private
+   */
+  removeFromIdIndex_(e) {
+    for (const t in this.idIndex_)
+      if (this.idIndex_[t] === e) {
+        delete this.idIndex_[t];
+        break;
+      }
+  }
+  /**
+   * Set the new loader of the source. The next render cycle will use the
+   * new loader.
+   * @param {import("../featureloader.js").FeatureLoader} loader The loader to set.
+   * @api
+   */
+  setLoader(e) {
+    this.loader_ = e;
+  }
+  /**
+   * Points the source to a new url. The next render cycle will use the new url.
+   * @param {string|import("../featureloader.js").FeatureUrlFunction} url Url.
+   * @api
+   */
+  setUrl(e) {
+    m(this.format_, "`format` must be set when `url` is set"), this.url_ = e, this.setLoader(y(e, this.format_));
+  }
+  /**
+   * @param {boolean} overlaps The source can have overlapping geometries.
+   */
+  setOverlaps(e) {
+    this.overlaps_ = e, this.changed();
+  }
+}
+const te = V;
+export {
+  d as VectorSourceEvent,
+  te as default
+};