@hybridcore/ui 1.6.13 → 1.6.16

package/dist/Vector-DfTqQEln.js

@@ -0,0 +1,1735 @@
+import { B as Q, A as S, f as b, O as Z, b as X, E as P, g, i as Y, V as H, a as T, l as U, h as j, u as G, e as ee, T as te } from "./math-Bvt2Ubuz.js";
+import { b as E, S as O, F as ie, a as ne, T as se, I as re, R as ae, C as he, t as oe, c as ue } from "./Text-ChJRuaD8.js";
+import { L as ce, R as J, T as le, S as de, U as fe, V as me } from "./Source-BSZST_GH.js";
+const R = {
+  /**
+   * Triggered when an item is added to the collection.
+   * @event module:ol/Collection.CollectionEvent#add
+   * @api
+   */
+  ADD: "add",
+  /**
+   * Triggered when an item is removed from the collection.
+   * @event module:ol/Collection.CollectionEvent#remove
+   * @api
+   */
+  REMOVE: "remove"
+}, k = {
+  LENGTH: "length"
+};
+class C extends b {
+  /**
+   * @param {import("./CollectionEventType.js").default} type Type.
+   * @param {T} element Element.
+   * @param {number} index The index of the added or removed element.
+   */
+  constructor(e, t, i) {
+    super(e), this.element = t, this.index = i;
+  }
+}
+class ge extends Q {
+  /**
+   * @param {Array<T>} [array] Array.
+   * @param {Options} [options] Collection options.
+   */
+  constructor(e, t) {
+    if (super(), this.on, this.once, this.un, t = t || {}, this.unique_ = !!t.unique, this.array_ = e || [], this.unique_)
+      for (let i = 0, s = this.array_.length; i < s; ++i)
+        this.assertUnique_(this.array_[i], i);
+    this.updateLength_();
+  }
+  /**
+   * Remove all elements from the collection.
+   * @api
+   */
+  clear() {
+    for (; this.getLength() > 0; )
+      this.pop();
+  }
+  /**
+   * Add elements to the collection.  This pushes each item in the provided array
+   * to the end of the collection.
+   * @param {!Array<T>} arr Array.
+   * @return {Collection<T>} This collection.
+   * @api
+   */
+  extend(e) {
+    for (let t = 0, i = e.length; t < i; ++t)
+      this.push(e[t]);
+    return this;
+  }
+  /**
+   * Iterate over each element, calling the provided callback.
+   * @param {function(T, number, Array<T>): *} f The function to call
+   *     for every element. This function takes 3 arguments (the element, the
+   *     index and the array). The return value is ignored.
+   * @api
+   */
+  forEach(e) {
+    const t = this.array_;
+    for (let i = 0, s = t.length; i < s; ++i)
+      e(t[i], i, t);
+  }
+  /**
+   * Get a reference to the underlying Array object. Warning: if the array
+   * is mutated, no events will be dispatched by the collection, and the
+   * collection's "length" property won't be in sync with the actual length
+   * of the array.
+   * @return {!Array<T>} Array.
+   * @api
+   */
+  getArray() {
+    return this.array_;
+  }
+  /**
+   * Get the element at the provided index.
+   * @param {number} index Index.
+   * @return {T} Element.
+   * @api
+   */
+  item(e) {
+    return this.array_[e];
+  }
+  /**
+   * Get the length of this collection.
+   * @return {number} The length of the array.
+   * @observable
+   * @api
+   */
+  getLength() {
+    return this.get(k.LENGTH);
+  }
+  /**
+   * Insert an element at the provided index.
+   * @param {number} index Index.
+   * @param {T} elem Element.
+   * @api
+   */
+  insertAt(e, t) {
+    if (e < 0 || e > this.getLength())
+      throw new Error("Index out of bounds: " + e);
+    this.unique_ && this.assertUnique_(t), this.array_.splice(e, 0, t), this.updateLength_(), this.dispatchEvent(
+      new C(R.ADD, t, e)
+    );
+  }
+  /**
+   * Remove the last element of the collection and return it.
+   * Return `undefined` if the collection is empty.
+   * @return {T|undefined} Element.
+   * @api
+   */
+  pop() {
+    return this.removeAt(this.getLength() - 1);
+  }
+  /**
+   * Insert the provided element at the end of the collection.
+   * @param {T} elem Element.
+   * @return {number} New length of the collection.
+   * @api
+   */
+  push(e) {
+    this.unique_ && this.assertUnique_(e);
+    const t = this.getLength();
+    return this.insertAt(t, e), this.getLength();
+  }
+  /**
+   * Remove the first occurrence of an element from the collection.
+   * @param {T} elem Element.
+   * @return {T|undefined} The removed element or undefined if none found.
+   * @api
+   */
+  remove(e) {
+    const t = this.array_;
+    for (let i = 0, s = t.length; i < s; ++i)
+      if (t[i] === e)
+        return this.removeAt(i);
+  }
+  /**
+   * Remove the element at the provided index and return it.
+   * Return `undefined` if the collection does not contain this index.
+   * @param {number} index Index.
+   * @return {T|undefined} Value.
+   * @api
+   */
+  removeAt(e) {
+    if (e < 0 || e >= this.getLength())
+      return;
+    const t = this.array_[e];
+    return this.array_.splice(e, 1), this.updateLength_(), this.dispatchEvent(
+      /** @type {CollectionEvent<T>} */
+      new C(R.REMOVE, t, e)
+    ), t;
+  }
+  /**
+   * Set the element at the provided index.
+   * @param {number} index Index.
+   * @param {T} elem Element.
+   * @api
+   */
+  setAt(e, t) {
+    const i = this.getLength();
+    if (e >= i) {
+      this.insertAt(e, t);
+      return;
+    }
+    if (e < 0)
+      throw new Error("Index out of bounds: " + e);
+    this.unique_ && this.assertUnique_(t, e);
+    const s = this.array_[e];
+    this.array_[e] = t, this.dispatchEvent(
+      /** @type {CollectionEvent<T>} */
+      new C(R.REMOVE, s, e)
+    ), this.dispatchEvent(
+      /** @type {CollectionEvent<T>} */
+      new C(R.ADD, t, e)
+    );
+  }
+  /**
+   * @private
+   */
+  updateLength_() {
+    this.set(k.LENGTH, this.array_.length);
+  }
+  /**
+   * @private
+   * @param {T} elem Element.
+   * @param {number} [except] Optional index to ignore.
+   */
+  assertUnique_(e, t) {
+    for (let i = 0, s = this.array_.length; i < s; ++i)
+      if (this.array_[i] === e && i !== t)
+        throw new S(58);
+  }
+}
+function Te(n, e, t, i) {
+  let s = n[e], r = n[e + 1], a = 0;
+  for (let h = e + i; h < t; h += i) {
+    const o = n[h], u = n[h + 1];
+    a += Math.sqrt((o - s) * (o - s) + (u - r) * (u - r)), s = o, r = u;
+  }
+  return a;
+}
+class De extends Z {
+  /**
+   * @param {LayerType} layer Layer.
+   */
+  constructor(e) {
+    super(), this.ready = !0, this.boundHandleImageChange_ = this.handleImageChange_.bind(this), this.layer_ = e, this.declutterExecutorGroup = null;
+  }
+  /**
+   * Asynchronous layer level hit detection.
+   * @param {import("../pixel.js").Pixel} pixel Pixel.
+   * @return {Promise<Array<import("../Feature").FeatureLike>>} Promise that resolves with
+   * an array of features.
+   */
+  getFeatures(e) {
+    return X();
+  }
+  /**
+   * @param {import("../pixel.js").Pixel} pixel Pixel.
+   * @return {Uint8ClampedArray|Uint8Array|Float32Array|DataView|null} Pixel data.
+   */
+  getData(e) {
+    return null;
+  }
+  /**
+   * Determine whether render should be called.
+   * @abstract
+   * @param {import("../Map.js").FrameState} frameState Frame state.
+   * @return {boolean} Layer is ready to be rendered.
+   */
+  prepareFrame(e) {
+    return X();
+  }
+  /**
+   * Render the layer.
+   * @abstract
+   * @param {import("../Map.js").FrameState} frameState Frame state.
+   * @param {HTMLElement|null} target Target that may be used to render content to.
+   * @return {HTMLElement|null} The rendered element.
+   */
+  renderFrame(e, t) {
+    return X();
+  }
+  /**
+   * @param {Object<number, Object<string, import("../Tile.js").default>>} tiles Lookup of loaded tiles by zoom level.
+   * @param {number} zoom Zoom level.
+   * @param {import("../Tile.js").default} tile Tile.
+   * @return {boolean|void} If `false`, the tile will not be considered loaded.
+   */
+  loadedTileCallback(e, t, i) {
+    e[t] || (e[t] = {}), e[t][i.tileCoord.toString()] = i;
+  }
+  /**
+   * Create a function that adds loaded tiles to the tile lookup.
+   * @param {import("../source/Tile.js").default} source Tile source.
+   * @param {import("../proj/Projection.js").default} projection Projection of the tiles.
+   * @param {Object<number, Object<string, import("../Tile.js").default>>} tiles Lookup of loaded tiles by zoom level.
+   * @return {function(number, import("../TileRange.js").default):boolean} A function that can be
+   *     called with a zoom level and a tile range to add loaded tiles to the lookup.
+   * @protected
+   */
+  createLoadedTileFinder(e, t, i) {
+    return (
+      /**
+       * @param {number} zoom Zoom level.
+       * @param {import("../TileRange.js").default} tileRange Tile range.
+       * @return {boolean} The tile range is fully loaded.
+       */
+      (s, r) => {
+        const a = this.loadedTileCallback.bind(this, i, s);
+        return e.forEachLoadedTile(t, s, r, a);
+      }
+    );
+  }
+  /**
+   * @abstract
+   * @param {import("../coordinate.js").Coordinate} coordinate Coordinate.
+   * @param {import("../Map.js").FrameState} frameState Frame state.
+   * @param {number} hitTolerance Hit tolerance in pixels.
+   * @param {import("./vector.js").FeatureCallback<T>} callback Feature callback.
+   * @param {Array<import("./Map.js").HitMatch<T>>} matches The hit detected matches with tolerance.
+   * @return {T|undefined} Callback result.
+   * @template T
+   */
+  forEachFeatureAtCoordinate(e, t, i, s, r) {
+  }
+  /**
+   * @return {LayerType} Layer.
+   */
+  getLayer() {
+    return this.layer_;
+  }
+  /**
+   * Perform action necessary to get the layer rendered after new fonts have loaded
+   * @abstract
+   */
+  handleFontsChanged() {
+  }
+  /**
+   * Handle changes in image state.
+   * @param {import("../events/Event.js").default} event Image change event.
+   * @private
+   */
+  handleImageChange_(e) {
+    const t = (
+      /** @type {import("../Image.js").default} */
+      e.target
+    );
+    (t.getState() === E.LOADED || t.getState() === E.ERROR) && this.renderIfReadyAndVisible();
+  }
+  /**
+   * Load the image if not already loaded, and register the image change
+   * listener if needed.
+   * @param {import("../ImageBase.js").default} image Image.
+   * @return {boolean} `true` if the image is already loaded, `false` otherwise.
+   * @protected
+   */
+  loadImage(e) {
+    let t = e.getState();
+    return t != E.LOADED && t != E.ERROR && e.addEventListener(P.CHANGE, this.boundHandleImageChange_), t == E.IDLE && (e.load(), t = e.getState()), t == E.LOADED;
+  }
+  /**
+   * @protected
+   */
+  renderIfReadyAndVisible() {
+    const e = this.getLayer();
+    e && e.getVisible() && e.getSourceState() === "ready" && e.changed();
+  }
+  /**
+   * Clean up.
+   */
+  disposeInternal() {
+    delete this.layer_, super.disposeInternal();
+  }
+}
+class Le extends b {
+  /**
+   * @param {import("./EventType.js").default} type Type.
+   * @param {import("../transform.js").Transform} [inversePixelTransform] Transform for
+   *     CSS pixels to rendered pixels.
+   * @param {import("../Map.js").FrameState} [frameState] Frame state.
+   * @param {?(CanvasRenderingContext2D|WebGLRenderingContext)} [context] Context.
+   */
+  constructor(e, t, i, s) {
+    super(e), this.inversePixelTransform = t, this.frameState = i, this.context = s;
+  }
+}
+function _e(n, e, t, i, s) {
+  $(n, e, t || 0, i || n.length - 1, s || xe);
+}
+function $(n, e, t, i, s) {
+  for (; i > t; ) {
+    if (i - t > 600) {
+      var r = i - t + 1, a = e - t + 1, h = Math.log(r), o = 0.5 * Math.exp(2 * h / 3), u = 0.5 * Math.sqrt(h * o * (r - o) / r) * (a - r / 2 < 0 ? -1 : 1), c = Math.max(t, Math.floor(e - a * o / r + u)), l = Math.min(i, Math.floor(e + (r - a) * o / r + u));
+      $(n, e, c, l, s);
+    }
+    var d = n[e], x = t, f = i;
+    for (F(n, t, e), s(n[i], d) > 0 && F(n, t, i); x < f; ) {
+      for (F(n, x, f), x++, f--; s(n[x], d) < 0; ) x++;
+      for (; s(n[f], d) > 0; ) f--;
+    }
+    s(n[t], d) === 0 ? F(n, t, f) : (f++, F(n, f, i)), f <= e && (t = f + 1), e <= f && (i = f - 1);
+  }
+}
+function F(n, e, t) {
+  var i = n[e];
+  n[e] = n[t], n[t] = i;
+}
+function xe(n, e) {
+  return n < e ? -1 : n > e ? 1 : 0;
+}
+let z = class {
+  constructor(e = 9) {
+    this._maxEntries = Math.max(4, e), this._minEntries = Math.max(2, Math.ceil(this._maxEntries * 0.4)), this.clear();
+  }
+  all() {
+    return this._all(this.data, []);
+  }
+  search(e) {
+    let t = this.data;
+    const i = [];
+    if (!M(e, t)) return i;
+    const s = this.toBBox, r = [];
+    for (; t; ) {
+      for (let a = 0; a < t.children.length; a++) {
+        const h = t.children[a], o = t.leaf ? s(h) : h;
+        M(e, o) && (t.leaf ? i.push(h) : L(e, o) ? this._all(h, i) : r.push(h));
+      }
+      t = r.pop();
+    }
+    return i;
+  }
+  collides(e) {
+    let t = this.data;
+    if (!M(e, t)) return !1;
+    const i = [];
+    for (; t; ) {
+      for (let s = 0; s < t.children.length; s++) {
+        const r = t.children[s], a = t.leaf ? this.toBBox(r) : r;
+        if (M(e, a)) {
+          if (t.leaf || L(e, a)) return !0;
+          i.push(r);
+        }
+      }
+      t = i.pop();
+    }
+    return !1;
+  }
+  load(e) {
+    if (!(e && e.length)) return this;
+    if (e.length < this._minEntries) {
+      for (let i = 0; i < e.length; i++)
+        this.insert(e[i]);
+      return this;
+    }
+    let t = this._build(e.slice(), 0, e.length - 1, 0);
+    if (!this.data.children.length)
+      this.data = t;
+    else if (this.data.height === t.height)
+      this._splitRoot(this.data, t);
+    else {
+      if (this.data.height < t.height) {
+        const i = this.data;
+        this.data = t, t = i;
+      }
+      this._insert(t, this.data.height - t.height - 1, !0);
+    }
+    return this;
+  }
+  insert(e) {
+    return e && this._insert(e, this.data.height - 1), this;
+  }
+  clear() {
+    return this.data = I([]), this;
+  }
+  remove(e, t) {
+    if (!e) return this;
+    let i = this.data;
+    const s = this.toBBox(e), r = [], a = [];
+    let h, o, u;
+    for (; i || r.length; ) {
+      if (i || (i = r.pop(), o = r[r.length - 1], h = a.pop(), u = !0), i.leaf) {
+        const c = Ee(e, i.children, t);
+        if (c !== -1)
+          return i.children.splice(c, 1), r.push(i), this._condense(r), this;
+      }
+      !u && !i.leaf && L(i, s) ? (r.push(i), a.push(h), h = 0, o = i, i = i.children[0]) : o ? (h++, i = o.children[h], u = !1) : i = null;
+    }
+    return this;
+  }
+  toBBox(e) {
+    return e;
+  }
+  compareMinX(e, t) {
+    return e.minX - t.minX;
+  }
+  compareMinY(e, t) {
+    return e.minY - t.minY;
+  }
+  toJSON() {
+    return this.data;
+  }
+  fromJSON(e) {
+    return this.data = e, this;
+  }
+  _all(e, t) {
+    const i = [];
+    for (; e; )
+      e.leaf ? t.push(...e.children) : i.push(...e.children), e = i.pop();
+    return t;
+  }
+  _build(e, t, i, s) {
+    const r = i - t + 1;
+    let a = this._maxEntries, h;
+    if (r <= a)
+      return h = I(e.slice(t, i + 1)), p(h, this.toBBox), h;
+    s || (s = Math.ceil(Math.log(r) / Math.log(a)), a = Math.ceil(r / Math.pow(a, s - 1))), h = I([]), h.leaf = !1, h.height = s;
+    const o = Math.ceil(r / a), u = o * Math.ceil(Math.sqrt(a));
+    N(e, t, i, u, this.compareMinX);
+    for (let c = t; c <= i; c += u) {
+      const l = Math.min(c + u - 1, i);
+      N(e, c, l, o, this.compareMinY);
+      for (let d = c; d <= l; d += o) {
+        const x = Math.min(d + o - 1, l);
+        h.children.push(this._build(e, d, x, s - 1));
+      }
+    }
+    return p(h, this.toBBox), h;
+  }
+  _chooseSubtree(e, t, i, s) {
+    for (; s.push(t), !(t.leaf || s.length - 1 === i); ) {
+      let r = 1 / 0, a = 1 / 0, h;
+      for (let o = 0; o < t.children.length; o++) {
+        const u = t.children[o], c = D(u), l = Re(e, u) - c;
+        l < a ? (a = l, r = c < r ? c : r, h = u) : l === a && c < r && (r = c, h = u);
+      }
+      t = h || t.children[0];
+    }
+    return t;
+  }
+  _insert(e, t, i) {
+    const s = i ? e : this.toBBox(e), r = [], a = this._chooseSubtree(s, this.data, t, r);
+    for (a.children.push(e), A(a, s); t >= 0 && r[t].children.length > this._maxEntries; )
+      this._split(r, t), t--;
+    this._adjustParentBBoxes(s, r, t);
+  }
+  // split overflowed node into two
+  _split(e, t) {
+    const i = e[t], s = i.children.length, r = this._minEntries;
+    this._chooseSplitAxis(i, r, s);
+    const a = this._chooseSplitIndex(i, r, s), h = I(i.children.splice(a, i.children.length - a));
+    h.height = i.height, h.leaf = i.leaf, p(i, this.toBBox), p(h, this.toBBox), t ? e[t - 1].children.push(h) : this._splitRoot(i, h);
+  }
+  _splitRoot(e, t) {
+    this.data = I([e, t]), this.data.height = e.height + 1, this.data.leaf = !1, p(this.data, this.toBBox);
+  }
+  _chooseSplitIndex(e, t, i) {
+    let s, r = 1 / 0, a = 1 / 0;
+    for (let h = t; h <= i - t; h++) {
+      const o = y(e, 0, h, this.toBBox), u = y(e, h, i, this.toBBox), c = Fe(o, u), l = D(o) + D(u);
+      c < r ? (r = c, s = h, a = l < a ? l : a) : c === r && l < a && (a = l, s = h);
+    }
+    return s || i - t;
+  }
+  // sorts node children by the best axis for split
+  _chooseSplitAxis(e, t, i) {
+    const s = e.leaf ? this.compareMinX : pe, r = e.leaf ? this.compareMinY : Ie, a = this._allDistMargin(e, t, i, s), h = this._allDistMargin(e, t, i, r);
+    a < h && e.children.sort(s);
+  }
+  // total margin of all possible split distributions where each node is at least m full
+  _allDistMargin(e, t, i, s) {
+    e.children.sort(s);
+    const r = this.toBBox, a = y(e, 0, t, r), h = y(e, i - t, i, r);
+    let o = B(a) + B(h);
+    for (let u = t; u < i - t; u++) {
+      const c = e.children[u];
+      A(a, e.leaf ? r(c) : c), o += B(a);
+    }
+    for (let u = i - t - 1; u >= t; u--) {
+      const c = e.children[u];
+      A(h, e.leaf ? r(c) : c), o += B(h);
+    }
+    return o;
+  }
+  _adjustParentBBoxes(e, t, i) {
+    for (let s = i; s >= 0; s--)
+      A(t[s], e);
+  }
+  _condense(e) {
+    for (let t = e.length - 1, i; t >= 0; t--)
+      e[t].children.length === 0 ? t > 0 ? (i = e[t - 1].children, i.splice(i.indexOf(e[t]), 1)) : this.clear() : p(e[t], this.toBBox);
+  }
+};
+function Ee(n, e, t) {
+  if (!t) return e.indexOf(n);
+  for (let i = 0; i < e.length; i++)
+    if (t(n, e[i])) return i;
+  return -1;
+}
+function p(n, e) {
+  y(n, 0, n.children.length, e, n);
+}
+function y(n, e, t, i, s) {
+  s || (s = I(null)), s.minX = 1 / 0, s.minY = 1 / 0, s.maxX = -1 / 0, s.maxY = -1 / 0;
+  for (let r = e; r < t; r++) {
+    const a = n.children[r];
+    A(s, n.leaf ? i(a) : a);
+  }
+  return s;
+}
+function A(n, e) {
+  return n.minX = Math.min(n.minX, e.minX), n.minY = Math.min(n.minY, e.minY), n.maxX = Math.max(n.maxX, e.maxX), n.maxY = Math.max(n.maxY, e.maxY), n;
+}
+function pe(n, e) {
+  return n.minX - e.minX;
+}
+function Ie(n, e) {
+  return n.minY - e.minY;
+}
+function D(n) {
+  return (n.maxX - n.minX) * (n.maxY - n.minY);
+}
+function B(n) {
+  return n.maxX - n.minX + (n.maxY - n.minY);
+}
+function Re(n, e) {
+  return (Math.max(e.maxX, n.maxX) - Math.min(e.minX, n.minX)) * (Math.max(e.maxY, n.maxY) - Math.min(e.minY, n.minY));
+}
+function Fe(n, e) {
+  const t = Math.max(n.minX, e.minX), i = Math.max(n.minY, e.minY), s = Math.min(n.maxX, e.maxX), r = Math.min(n.maxY, e.maxY);
+  return Math.max(0, s - t) * Math.max(0, r - i);
+}
+function L(n, e) {
+  return n.minX <= e.minX && n.minY <= e.minY && e.maxX <= n.maxX && e.maxY <= n.maxY;
+}
+function M(n, e) {
+  return e.minX <= n.maxX && e.minY <= n.maxY && e.maxX >= n.minX && e.maxY >= n.minY;
+}
+function I(n) {
+  return {
+    children: n,
+    height: 1,
+    leaf: !0,
+    minX: 1 / 0,
+    minY: 1 / 0,
+    maxX: -1 / 0,
+    maxY: -1 / 0
+  };
+}
+function N(n, e, t, i, s) {
+  const r = [e, t];
+  for (; r.length; ) {
+    if (t = r.pop(), e = r.pop(), t - e <= i) continue;
+    const a = e + Math.ceil((t - e) / i / 2) * i;
+    _e(n, a, e, t, s), r.push(e, a, a, t);
+  }
+}
+function V(n) {
+  return new O({
+    fill: v(n, ""),
+    stroke: w(n, ""),
+    text: ye(n),
+    image: Ae(n)
+  });
+}
+function v(n, e) {
+  const t = n[e + "fill-color"];
+  if (t)
+    return t === "none" ? null : new ie({ color: t });
+}
+function w(n, e) {
+  const t = n[e + "stroke-width"], i = n[e + "stroke-color"];
+  if (!(!t && !i))
+    return new ne({
+      width: t,
+      color: i,
+      lineCap: n[e + "stroke-line-cap"],
+      lineJoin: n[e + "stroke-line-join"],
+      lineDash: n[e + "stroke-line-dash"],
+      lineDashOffset: n[e + "stroke-line-dash-offset"],
+      miterLimit: n[e + "stroke-miter-limit"]
+    });
+}
+function ye(n) {
+  const e = n["text-value"];
+  return e ? new se({
+    text: e,
+    font: n["text-font"],
+    maxAngle: n["text-max-angle"],
+    offsetX: n["text-offset-x"],
+    offsetY: n["text-offset-y"],
+    overflow: n["text-overflow"],
+    placement: n["text-placement"],
+    repeat: n["text-repeat"],
+    scale: n["text-scale"],
+    rotateWithView: n["text-rotate-with-view"],
+    rotation: n["text-rotation"],
+    textAlign: n["text-align"],
+    justify: n["text-justify"],
+    textBaseline: n["text-baseline"],
+    padding: n["text-padding"],
+    fill: v(n, "text-"),
+    backgroundFill: v(n, "text-background-"),
+    stroke: w(n, "text-"),
+    backgroundStroke: w(n, "text-background-")
+  }) : void 0;
+}
+function Ae(n) {
+  const e = n["icon-src"], t = n["icon-img"];
+  if (e || t)
+    return new re({
+      src: e,
+      img: t,
+      imgSize: n["icon-img-size"],
+      anchor: n["icon-anchor"],
+      anchorOrigin: n["icon-anchor-origin"],
+      anchorXUnits: n["icon-anchor-x-units"],
+      anchorYUnits: n["icon-anchor-y-units"],
+      color: n["icon-color"],
+      crossOrigin: n["icon-cross-origin"],
+      offset: n["icon-offset"],
+      displacement: n["icon-displacement"],
+      opacity: n["icon-opacity"],
+      scale: n["icon-scale"],
+      width: n["icon-width"],
+      height: n["icon-height"],
+      rotation: n["icon-rotation"],
+      rotateWithView: n["icon-rotate-with-view"],
+      size: n["icon-size"],
+      declutterMode: n["icon-declutter-mode"]
+    });
+  const i = n["shape-points"];
+  if (i) {
+    const r = "shape-";
+    return new ae({
+      points: i,
+      fill: v(n, r),
+      stroke: w(n, r),
+      radius: n["shape-radius"],
+      radius1: n["shape-radius1"],
+      radius2: n["shape-radius2"],
+      angle: n["shape-angle"],
+      displacement: n["shape-displacement"],
+      rotation: n["shape-rotation"],
+      rotateWithView: n["shape-rotate-with-view"],
+      scale: n["shape-scale"],
+      declutterMode: n["shape-declutter-mode"]
+    });
+  }
+  const s = n["circle-radius"];
+  if (s) {
+    const r = "circle-";
+    return new he({
+      radius: s,
+      fill: v(n, r),
+      stroke: w(n, r),
+      displacement: n["circle-displacement"],
+      scale: n["circle-scale"],
+      rotation: n["circle-rotation"],
+      rotateWithView: n["circle-rotate-with-view"],
+      declutterMode: n["circle-declutter-mode"]
+    });
+  }
+}
+const q = {
+  RENDER_ORDER: "renderOrder"
+};
+class Oe extends ce {
+  /**
+   * @param {Options<VectorSourceType>} [options] Options.
+   */
+  constructor(e) {
+    e = e || {};
+    const t = Object.assign({}, e);
+    delete t.style, delete t.renderBuffer, delete t.updateWhileAnimating, delete t.updateWhileInteracting, super(t), this.declutter_ = e.declutter !== void 0 ? e.declutter : !1, this.renderBuffer_ = e.renderBuffer !== void 0 ? e.renderBuffer : 100, this.style_ = null, this.styleFunction_ = void 0, this.setStyle(e.style), this.updateWhileAnimating_ = e.updateWhileAnimating !== void 0 ? e.updateWhileAnimating : !1, this.updateWhileInteracting_ = e.updateWhileInteracting !== void 0 ? e.updateWhileInteracting : !1;
+  }
+  /**
+   * @return {boolean} Declutter.
+   */
+  getDeclutter() {
+    return this.declutter_;
+  }
+  /**
+   * Get the topmost feature that intersects the given pixel on the viewport. Returns a promise
+   * that resolves with an array of features. The array will either contain the topmost feature
+   * when a hit was detected, or it will be empty.
+   *
+   * The hit detection algorithm used for this method is optimized for performance, but is less
+   * accurate than the one used in [map.getFeaturesAtPixel()]{@link import("../Map.js").default#getFeaturesAtPixel}.
+   * Text is not considered, and icons are only represented by their bounding box instead of the exact
+   * image.
+   *
+   * @param {import("../pixel.js").Pixel} pixel Pixel.
+   * @return {Promise<Array<import("../Feature").FeatureLike>>} Promise that resolves with an array of features.
+   * @api
+   */
+  getFeatures(e) {
+    return super.getFeatures(e);
+  }
+  /**
+   * @return {number|undefined} Render buffer.
+   */
+  getRenderBuffer() {
+    return this.renderBuffer_;
+  }
+  /**
+   * @return {function(import("../Feature.js").default, import("../Feature.js").default): number|null|undefined} Render
+   *     order.
+   */
+  getRenderOrder() {
+    return (
+      /** @type {import("../render.js").OrderFunction|null|undefined} */
+      this.get(q.RENDER_ORDER)
+    );
+  }
+  /**
+   * Get the style for features.  This returns whatever was passed to the `style`
+   * option at construction or to the `setStyle` method.
+   * @return {import("../style/Style.js").StyleLike|null|undefined} Layer style.
+   * @api
+   */
+  getStyle() {
+    return this.style_;
+  }
+  /**
+   * Get the style function.
+   * @return {import("../style/Style.js").StyleFunction|undefined} Layer style function.
+   * @api
+   */
+  getStyleFunction() {
+    return this.styleFunction_;
+  }
+  /**
+   * @return {boolean} Whether the rendered layer should be updated while
+   *     animating.
+   */
+  getUpdateWhileAnimating() {
+    return this.updateWhileAnimating_;
+  }
+  /**
+   * @return {boolean} Whether the rendered layer should be updated while
+   *     interacting.
+   */
+  getUpdateWhileInteracting() {
+    return this.updateWhileInteracting_;
+  }
+  /**
+   * Render declutter items for this layer
+   * @param {import("../Map.js").FrameState} frameState Frame state.
+   */
+  renderDeclutter(e) {
+    e.declutterTree || (e.declutterTree = new z(9)), this.getRenderer().renderDeclutter(e);
+  }
+  /**
+   * @param {import("../render.js").OrderFunction|null|undefined} renderOrder
+   *     Render order.
+   */
+  setRenderOrder(e) {
+    this.set(q.RENDER_ORDER, e);
+  }
+  /**
+   * Set the style for features.  This can be a single style object, an array
+   * of styles, or a function that takes a feature and resolution and returns
+   * an array of styles. If set to `null`, the layer has no style (a `null` style),
+   * so only features that have their own styles will be rendered in the layer. Call
+   * `setStyle()` without arguments to reset to the default style. See
+   * [the ol/style/Style module]{@link module:ol/style/Style~Style} for information on the default style.
+   *
+   * If your layer has a static style, you can use [flat style]{@link module:ol/style/flat~FlatStyle} object
+   * literals instead of using the `Style` and symbolizer constructors (`Fill`, `Stroke`, etc.):
+   * ```js
+   * vectorLayer.setStyle({
+   *   "fill-color": "yellow",
+   *   "stroke-color": "black",
+   *   "stroke-width": 4
+   * })
+   * ```
+   *
+   * @param {import("../style/Style.js").StyleLike|import("../style/flat.js").FlatStyleLike|null} [style] Layer style.
+   * @api
+   */
+  setStyle(e) {
+    let t;
+    if (e === void 0)
+      t = ue;
+    else if (e === null)
+      t = null;
+    else if (typeof e == "function")
+      t = e;
+    else if (e instanceof O)
+      t = e;
+    else if (Array.isArray(e)) {
+      const i = e.length, s = new Array(i);
+      for (let r = 0; r < i; ++r) {
+        const a = e[r];
+        a instanceof O ? s[r] = a : s[r] = V(a);
+      }
+      t = s;
+    } else
+      t = V(e);
+    this.style_ = t, this.styleFunction_ = e === null ? void 0 : oe(this.style_), this.changed();
+  }
+}
+class W {
+  /**
+   * @param {number} [maxEntries] Max entries.
+   */
+  constructor(e) {
+    this.rbush_ = new z(e), this.items_ = {};
+  }
+  /**
+   * Insert a value into the RBush.
+   * @param {import("../extent.js").Extent} extent Extent.
+   * @param {T} value Value.
+   */
+  insert(e, t) {
+    const i = {
+      minX: e[0],
+      minY: e[1],
+      maxX: e[2],
+      maxY: e[3],
+      value: t
+    };
+    this.rbush_.insert(i), this.items_[g(t)] = i;
+  }
+  /**
+   * Bulk-insert values into the RBush.
+   * @param {Array<import("../extent.js").Extent>} extents Extents.
+   * @param {Array<T>} values Values.
+   */
+  load(e, t) {
+    const i = new Array(t.length);
+    for (let s = 0, r = t.length; s < r; s++) {
+      const a = e[s], h = t[s], o = {
+        minX: a[0],
+        minY: a[1],
+        maxX: a[2],
+        maxY: a[3],
+        value: h
+      };
+      i[s] = o, this.items_[g(h)] = o;
+    }
+    this.rbush_.load(i);
+  }
+  /**
+   * Remove a value from the RBush.
+   * @param {T} value Value.
+   * @return {boolean} Removed.
+   */
+  remove(e) {
+    const t = g(e), i = this.items_[t];
+    return delete this.items_[t], this.rbush_.remove(i) !== null;
+  }
+  /**
+   * Update the extent of a value in the RBush.
+   * @param {import("../extent.js").Extent} extent Extent.
+   * @param {T} value Value.
+   */
+  update(e, t) {
+    const i = this.items_[g(t)], s = [i.minX, i.minY, i.maxX, i.maxY];
+    J(s, e) || (this.remove(t), this.insert(e, t));
+  }
+  /**
+   * Return all values in the RBush.
+   * @return {Array<T>} All.
+   */
+  getAll() {
+    return this.rbush_.all().map(function(t) {
+      return t.value;
+    });
+  }
+  /**
+   * Return all values in the given extent.
+   * @param {import("../extent.js").Extent} extent Extent.
+   * @return {Array<T>} All in extent.
+   */
+  getInExtent(e) {
+    const t = {
+      minX: e[0],
+      minY: e[1],
+      maxX: e[2],
+      maxY: e[3]
+    };
+    return this.rbush_.search(t).map(function(s) {
+      return s.value;
+    });
+  }
+  /**
+   * Calls a callback function with each value in the tree.
+   * If the callback returns a truthy value, this value is returned without
+   * checking the rest of the tree.
+   * @param {function(T): *} callback Callback.
+   * @return {*} Callback return value.
+   */
+  forEach(e) {
+    return this.forEach_(this.getAll(), e);
+  }
+  /**
+   * Calls a callback function with each value in the provided extent.
+   * @param {import("../extent.js").Extent} extent Extent.
+   * @param {function(T): *} callback Callback.
+   * @return {*} Callback return value.
+   */
+  forEachInExtent(e, t) {
+    return this.forEach_(this.getInExtent(e), t);
+  }
+  /**
+   * @param {Array<T>} values Values.
+   * @param {function(T): *} callback Callback.
+   * @private
+   * @return {*} Callback return value.
+   */
+  forEach_(e, t) {
+    let i;
+    for (let s = 0, r = e.length; s < r; s++)
+      if (i = t(e[s]), i)
+        return i;
+    return i;
+  }
+  /**
+   * @return {boolean} Is empty.
+   */
+  isEmpty() {
+    return Y(this.items_);
+  }
+  /**
+   * Remove all values from the RBush.
+   */
+  clear() {
+    this.rbush_.clear(), this.items_ = {};
+  }
+  /**
+   * @param {import("../extent.js").Extent} [extent] Extent.
+   * @return {import("../extent.js").Extent} Extent.
+   */
+  getExtent(e) {
+    const t = this.rbush_.toJSON();
+    return le(t.minX, t.minY, t.maxX, t.maxY, e);
+  }
+  /**
+   * @param {RBush} rbush R-Tree.
+   */
+  concat(e) {
+    this.rbush_.load(e.rbush_.all());
+    for (const t in e.items_)
+      this.items_[t] = e.items_[t];
+  }
+}
+const m = {
+  /**
+   * Triggered when a feature is added to the source.
+   * @event module:ol/source/Vector.VectorSourceEvent#addfeature
+   * @api
+   */
+  ADDFEATURE: "addfeature",
+  /**
+   * Triggered when a feature is updated.
+   * @event module:ol/source/Vector.VectorSourceEvent#changefeature
+   * @api
+   */
+  CHANGEFEATURE: "changefeature",
+  /**
+   * Triggered when the clear method is called on the source.
+   * @event module:ol/source/Vector.VectorSourceEvent#clear
+   * @api
+   */
+  CLEAR: "clear",
+  /**
+   * Triggered when a feature is removed from the source.
+   * See {@link module:ol/source/Vector~VectorSource#clear source.clear()} for exceptions.
+   * @event module:ol/source/Vector.VectorSourceEvent#removefeature
+   * @api
+   */
+  REMOVEFEATURE: "removefeature",
+  /**
+   * Triggered when features starts loading.
+   * @event module:ol/source/Vector.VectorSourceEvent#featuresloadstart
+   * @api
+   */
+  FEATURESLOADSTART: "featuresloadstart",
+  /**
+   * Triggered when features finishes loading.
+   * @event module:ol/source/Vector.VectorSourceEvent#featuresloadend
+   * @api
+   */
+  FEATURESLOADEND: "featuresloadend",
+  /**
+   * Triggered if feature loading results in an error.
+   * @event module:ol/source/Vector.VectorSourceEvent#featuresloaderror
+   * @api
+   */
+  FEATURESLOADERROR: "featuresloaderror"
+};
+function ve(n, e) {
+  return [[-1 / 0, -1 / 0, 1 / 0, 1 / 0]];
+}
+let we = !1;
+function Ce(n, e, t, i, s, r, a) {
+  const h = new XMLHttpRequest();
+  h.open(
+    "GET",
+    typeof n == "function" ? n(t, i, s) : n,
+    !0
+  ), e.getType() == "arraybuffer" && (h.responseType = "arraybuffer"), h.withCredentials = we, h.onload = function(o) {
+    if (!h.status || h.status >= 200 && h.status < 300) {
+      const u = e.getType();
+      let c;
+      u == "json" || u == "text" ? c = h.responseText : u == "xml" ? (c = h.responseXML, c || (c = new DOMParser().parseFromString(
+        h.responseText,
+        "application/xml"
+      ))) : u == "arraybuffer" && (c = /** @type {ArrayBuffer} */
+      h.response), c ? r(
+        /** @type {Array<import("./Feature.js").default>} */
+        e.readFeatures(c, {
+          extent: t,
+          featureProjection: s
+        }),
+        e.readProjection(c)
+      ) : a();
+    } else
+      a();
+  }, h.onerror = a, h.send();
+}
+function K(n, e) {
+  return function(t, i, s, r, a) {
+    const h = (
+      /** @type {import("./source/Vector").default} */
+      this
+    );
+    Ce(
+      n,
+      e,
+      t,
+      i,
+      s,
+      /**
+       * @param {Array<import("./Feature.js").default>} features The loaded features.
+       * @param {import("./proj/Projection.js").default} dataProjection Data
+       * projection.
+       */
+      function(o, u) {
+        h.addFeatures(o), r !== void 0 && r(o);
+      },
+      /* FIXME handle error */
+      a || H
+    );
+  };
+}
+class _ extends b {
+  /**
+   * @param {string} type Type.
+   * @param {import("../Feature.js").default<Geometry>} [feature] Feature.
+   * @param {Array<import("../Feature.js").default<Geometry>>} [features] Features.
+   */
+  constructor(e, t, i) {
+    super(e), this.feature = t, this.features = i;
+  }
+}
+class be extends de {
+  /**
+   * @param {Options<Geometry>} [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_ = H, this.format_ = e.format, 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 && (T(this.format_, 7), this.loader_ = K(
+      this.url_,
+      /** @type {import("../format/Feature.js").default} */
+      this.format_
+    )), this.strategy_ = e.strategy !== void 0 ? e.strategy : ve;
+    const t = e.useSpatialIndex !== void 0 ? e.useSpatialIndex : !0;
+    this.featuresRtree_ = t ? new W() : null, this.loadedExtentsRtree_ = new W(), this.loadingExtentsCount_ = 0, this.nullGeometryFeatures_ = {}, this.idIndex_ = {}, this.uidIndex_ = {}, this.featureChangeKeys_ = {}, this.featuresCollection_ = null;
+    let i, s;
+    Array.isArray(e.features) ? s = e.features : e.features && (i = e.features, s = i.getArray()), !t && i === void 0 && (i = new ge(s)), s !== void 0 && this.addFeaturesInternal(s), i !== void 0 && this.bindFeaturesCollection_(i);
+  }
+  /**
+   * 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 an {@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 {import("../Feature.js").default<Geometry>} feature Feature to add.
+   * @api
+   */
+  addFeature(e) {
+    this.addFeatureInternal(e), this.changed();
+  }
+  /**
+   * Add a feature without firing a `change` event.
+   * @param {import("../Feature.js").default<Geometry>} feature Feature.
+   * @protected
+   */
+  addFeatureInternal(e) {
+    const t = g(e);
+    if (!this.addToIndex_(t, e)) {
+      this.featuresCollection_ && this.featuresCollection_.remove(e);
+      return;
+    }
+    this.setupChangeEvents_(t, e);
+    const i = e.getGeometry();
+    if (i) {
+      const s = i.getExtent();
+      this.featuresRtree_ && this.featuresRtree_.insert(s, e);
+    } else
+      this.nullGeometryFeatures_[t] = e;
+    this.dispatchEvent(
+      new _(m.ADDFEATURE, e)
+    );
+  }
+  /**
+   * @param {string} featureKey Unique identifier for the feature.
+   * @param {import("../Feature.js").default<Geometry>} feature The feature.
+   * @private
+   */
+  setupChangeEvents_(e, t) {
+    this.featureChangeKeys_[e] = [
+      U(t, P.CHANGE, this.handleFeatureChange_, this),
+      U(
+        t,
+        j.PROPERTYCHANGE,
+        this.handleFeatureChange_,
+        this
+      )
+    ];
+  }
+  /**
+   * @param {string} featureKey Unique identifier for the feature.
+   * @param {import("../Feature.js").default<Geometry>} 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 i = !0;
+    const s = t.getId();
+    return s !== void 0 && (s.toString() in this.idIndex_ ? i = !1 : this.idIndex_[s.toString()] = t), i && (T(!(e in this.uidIndex_), 30), this.uidIndex_[e] = t), i;
+  }
+  /**
+   * Add a batch of features to the source.
+   * @param {Array<import("../Feature.js").default<Geometry>>} features Features to add.
+   * @api
+   */
+  addFeatures(e) {
+    this.addFeaturesInternal(e), this.changed();
+  }
+  /**
+   * Add features without firing a `change` event.
+   * @param {Array<import("../Feature.js").default<Geometry>>} features Features.
+   * @protected
+   */
+  addFeaturesInternal(e) {
+    const t = [], i = [], s = [];
+    for (let r = 0, a = e.length; r < a; r++) {
+      const h = e[r], o = g(h);
+      this.addToIndex_(o, h) && i.push(h);
+    }
+    for (let r = 0, a = i.length; r < a; r++) {
+      const h = i[r], o = g(h);
+      this.setupChangeEvents_(o, h);
+      const u = h.getGeometry();
+      if (u) {
+        const c = u.getExtent();
+        t.push(c), s.push(h);
+      } else
+        this.nullGeometryFeatures_[o] = h;
+    }
+    if (this.featuresRtree_ && this.featuresRtree_.load(t, s), this.hasListener(m.ADDFEATURE))
+      for (let r = 0, a = i.length; r < a; r++)
+        this.dispatchEvent(
+          new _(m.ADDFEATURE, i[r])
+        );
+  }
+  /**
+   * @param {!Collection<import("../Feature.js").default<Geometry>>} collection Collection.
+   * @private
+   */
+  bindFeaturesCollection_(e) {
+    let t = !1;
+    this.addEventListener(
+      m.ADDFEATURE,
+      /**
+       * @param {VectorSourceEvent<Geometry>} evt The vector source event
+       */
+      function(i) {
+        t || (t = !0, e.push(i.feature), t = !1);
+      }
+    ), this.addEventListener(
+      m.REMOVEFEATURE,
+      /**
+       * @param {VectorSourceEvent<Geometry>} evt The vector source event
+       */
+      function(i) {
+        t || (t = !0, e.remove(i.feature), t = !1);
+      }
+    ), e.addEventListener(
+      R.ADD,
+      /**
+       * @param {import("../Collection.js").CollectionEvent<import("../Feature.js").default<Geometry>>} evt The collection event
+       */
+      (i) => {
+        t || (t = !0, this.addFeature(i.element), t = !1);
+      }
+    ), e.addEventListener(
+      R.REMOVE,
+      /**
+       * @param {import("../Collection.js").CollectionEvent<import("../Feature.js").default<Geometry>>} evt The collection event
+       */
+      (i) => {
+        t || (t = !0, this.removeFeature(i.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 i in this.featureChangeKeys_)
+        this.featureChangeKeys_[i].forEach(G);
+      this.featuresCollection_ || (this.featureChangeKeys_ = {}, this.idIndex_ = {}, this.uidIndex_ = {});
+    } else if (this.featuresRtree_) {
+      const i = (s) => {
+        this.removeFeatureInternal(s);
+      };
+      this.featuresRtree_.forEach(i);
+      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 _(m.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(import("../Feature.js").default<Geometry>): 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.
+   *
+   * @param {import("../coordinate.js").Coordinate} coordinate Coordinate.
+   * @param {function(import("../Feature.js").default<Geometry>): 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 i = [e[0], e[1], e[0], e[1]];
+    return this.forEachFeatureInExtent(i, function(s) {
+      if (s.getGeometry().intersectsCoordinate(e))
+        return t(s);
+    });
+  }
+  /**
+   * 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(import("../Feature.js").default<Geometry>): 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(import("../Feature.js").default<Geometry>): 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 {import("../Feature.js").default<Geometry>} feature Feature.
+       * @return {T|undefined} The return value from the last call to the callback.
+       */
+      function(i) {
+        if (i.getGeometry().intersectsExtent(e)) {
+          const r = t(i);
+          if (r)
+            return r;
+        }
+      }
+    );
+  }
+  /**
+   * Get the features collection associated with this source. Will be `null`
+   * unless the source was configured with `useSpatialIndex` set to `false`, or
+   * with an {@link module:ol/Collection~Collection} as `features`.
+   * @return {Collection<import("../Feature.js").default<Geometry>>|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<import("../Feature.js").default<Geometry>>} Features.
+   * @api
+   */
+  getFeatures() {
+    let e;
+    return this.featuresCollection_ ? e = this.featuresCollection_.getArray().slice(0) : this.featuresRtree_ && (e = this.featuresRtree_.getAll(), Y(this.nullGeometryFeatures_) || ee(e, Object.values(this.nullGeometryFeatures_))), /** @type {Array<import("../Feature.js").default<Geometry>>} */
+    e;
+  }
+  /**
+   * Get all features whose geometry intersects the provided coordinate.
+   * @param {import("../coordinate.js").Coordinate} coordinate Coordinate.
+   * @return {Array<import("../Feature.js").default<Geometry>>} Features.
+   * @api
+   */
+  getFeaturesAtCoordinate(e) {
+    const t = [];
+    return this.forEachFeatureAtCoordinateDirect(e, function(i) {
+      t.push(i);
+    }), 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<import("../Feature.js").default<Geometry>>} Features.
+   * @api
+   */
+  getFeaturesInExtent(e, t) {
+    if (this.featuresRtree_) {
+      if (!(t && t.canWrapX() && this.getWrapX()))
+        return this.featuresRtree_.getInExtent(e);
+      const s = fe(e, t);
+      return [].concat(
+        ...s.map((r) => this.featuresRtree_.getInExtent(r))
+      );
+    }
+    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`.
+   * @param {import("../coordinate.js").Coordinate} coordinate Coordinate.
+   * @param {function(import("../Feature.js").default<Geometry>):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 {import("../Feature.js").default<Geometry>} Closest feature.
+   * @api
+   */
+  getClosestFeatureToCoordinate(e, t) {
+    const i = e[0], s = e[1];
+    let r = null;
+    const a = [NaN, NaN];
+    let h = 1 / 0;
+    const o = [-1 / 0, -1 / 0, 1 / 0, 1 / 0];
+    return t = t || te, this.featuresRtree_.forEachInExtent(
+      o,
+      /**
+       * @param {import("../Feature.js").default<Geometry>} feature Feature.
+       */
+      function(u) {
+        if (t(u)) {
+          const c = u.getGeometry(), l = h;
+          if (h = c.closestPointXY(
+            i,
+            s,
+            a,
+            h
+          ), h < l) {
+            r = u;
+            const d = Math.sqrt(h);
+            o[0] = i - d, o[1] = s - d, o[2] = i + d, o[3] = s + d;
+          }
+        }
+      }
+    ), r;
+  }
+  /**
+   * 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()).
+   * 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 {import("../Feature.js").default<Geometry>|null} The feature (or `null` if not found).
+   * @api
+   */
+  getFeatureById(e) {
+    const t = this.idIndex_[e.toString()];
+    return t !== void 0 ? t : null;
+  }
+  /**
+   * Get a feature by its internal unique identifier (using `getUid`).
+   *
+   * @param {string} uid Feature identifier.
+   * @return {import("../Feature.js").default<Geometry>|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|undefined} 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 {import("../Feature.js").default<Geometry>} */
+      e.target
+    ), i = g(t), s = t.getGeometry();
+    if (!s)
+      i in this.nullGeometryFeatures_ || (this.featuresRtree_ && this.featuresRtree_.remove(t), this.nullGeometryFeatures_[i] = t);
+    else {
+      const a = s.getExtent();
+      i in this.nullGeometryFeatures_ ? (delete this.nullGeometryFeatures_[i], this.featuresRtree_ && this.featuresRtree_.insert(a, t)) : this.featuresRtree_ && this.featuresRtree_.update(a, t);
+    }
+    const r = t.getId();
+    if (r !== void 0) {
+      const a = r.toString();
+      this.idIndex_[a] !== t && (this.removeFromIdIndex_(t), this.idIndex_[a] = t);
+    } else
+      this.removeFromIdIndex_(t), this.uidIndex_[i] = t;
+    this.changed(), this.dispatchEvent(
+      new _(m.CHANGEFEATURE, t)
+    );
+  }
+  /**
+   * Returns true if the feature is contained within the source.
+   * @param {import("../Feature.js").default<Geometry>} feature Feature.
+   * @return {boolean} Has feature.
+   * @api
+   */
+  hasFeature(e) {
+    const t = e.getId();
+    return t !== void 0 ? t in this.idIndex_ : g(e) in this.uidIndex_;
+  }
+  /**
+   * @return {boolean} Is empty.
+   */
+  isEmpty() {
+    return this.featuresRtree_ ? this.featuresRtree_.isEmpty() && Y(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, i) {
+    const s = this.loadedExtentsRtree_, r = this.strategy_(e, t, i);
+    for (let a = 0, h = r.length; a < h; ++a) {
+      const o = r[a];
+      s.forEachInExtent(
+        o,
+        /**
+         * @param {{extent: import("../extent.js").Extent}} object Object.
+         * @return {boolean} Contains.
+         */
+        function(c) {
+          return me(c.extent, o);
+        }
+      ) || (++this.loadingExtentsCount_, this.dispatchEvent(
+        new _(m.FEATURESLOADSTART)
+      ), this.loader_.call(
+        this,
+        o,
+        t,
+        i,
+        (c) => {
+          --this.loadingExtentsCount_, this.dispatchEvent(
+            new _(
+              m.FEATURESLOADEND,
+              void 0,
+              c
+            )
+          );
+        },
+        () => {
+          --this.loadingExtentsCount_, this.dispatchEvent(
+            new _(m.FEATURESLOADERROR)
+          );
+        }
+      ), s.insert(o, { extent: o.slice() }));
+    }
+    this.loading = this.loader_.length < 4 ? !1 : this.loadingExtentsCount_ > 0;
+  }
+  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_;
+    let i;
+    t.forEachInExtent(e, function(s) {
+      if (J(s.extent, e))
+        return i = s, !0;
+    }), i && t.remove(i);
+  }
+  /**
+   * Remove a single feature 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 {import("../Feature.js").default<Geometry>} feature Feature to remove.
+   * @api
+   */
+  removeFeature(e) {
+    if (!e)
+      return;
+    const t = g(e);
+    t in this.nullGeometryFeatures_ ? delete this.nullGeometryFeatures_[t] : this.featuresRtree_ && this.featuresRtree_.remove(e), this.removeFeatureInternal(e) && this.changed();
+  }
+  /**
+   * Remove feature without firing a `change` event.
+   * @param {import("../Feature.js").default<Geometry>} feature Feature.
+   * @return {import("../Feature.js").default<Geometry>|undefined} The removed feature
+   *     (or undefined if the feature was not found).
+   * @protected
+   */
+  removeFeatureInternal(e) {
+    const t = g(e), i = this.featureChangeKeys_[t];
+    if (!i)
+      return;
+    i.forEach(G), delete this.featureChangeKeys_[t];
+    const s = e.getId();
+    return s !== void 0 && delete this.idIndex_[s.toString()], delete this.uidIndex_[t], this.dispatchEvent(
+      new _(m.REMOVEFEATURE, e)
+    ), e;
+  }
+  /**
+   * Remove a feature from the id index.  Called internally when the feature id
+   * may have changed.
+   * @param {import("../Feature.js").default<Geometry>} feature The feature.
+   * @return {boolean} Removed the feature from the index.
+   * @private
+   */
+  removeFromIdIndex_(e) {
+    let t = !1;
+    for (const i in this.idIndex_)
+      if (this.idIndex_[i] === e) {
+        delete this.idIndex_[i], t = !0;
+        break;
+      }
+    return t;
+  }
+  /**
+   * 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) {
+    T(this.format_, 7), this.url_ = e, this.setLoader(K(e, this.format_));
+  }
+}
+export {
+  Oe as B,
+  ge as C,
+  De as L,
+  Le as R,
+  be as V,
+  m as a,
+  R as b,
+  W as c,
+  Te as l
+};