@hybridcore/ui 1.5.89 → 1.6.0

package/dist/Vector-BmuhQO4p.js

@@ -0,0 +1,3606 @@
+import { L as ze, R as qe, l as Ue, B as $e } from "./Vector-DfTqQEln.js";
+import { W as ht, am as Qe, au as ti, av as ei, aw as ii, a5 as G, a0 as vt, _ as Vt, at as ni, ax as si, ay as oi, k as bt, r as me, E as ye, az as ri, a4 as se, aA as li, aB as tt, aC as ai, T as Ce, aD as yt, aE as hi, y as At, aF as ci, aG as di, a3 as Mt, a2 as Ft, aH as fi, a1 as ui, aI as gi, ae as _i, V as Wt, aJ as xi, aK as pi, af as Si } from "./Source-BSZST_GH.js";
+import { g as Te, d as gt, h as ot, i as V, j as Bt, k as Gt, l as et, m as it, n as Yt, o as Xt, p as Nt, q as lt, r as Tt, u as Ht, v as Fe, w as mi, x as yi, y as Ci, z as Ie, I as Ti, b as Ct, A as Ii } from "./Text-ChJRuaD8.js";
+import { k as Rt, x as Ri, d as K, g as It, y as ie, i as ki, t as wi, m as Re } from "./math-Bvt2Ubuz.js";
+const ke = [];
+let ut = null;
+function Ei() {
+  ut = gt(1, 1, void 0, {
+    willReadFrequently: !0
+  });
+}
+class Li extends ze {
+  /**
+   * @param {LayerType} layer Layer.
+   */
+  constructor(t) {
+    super(t), this.container = null, this.renderedResolution, this.tempTransform = ht(), this.pixelTransform = ht(), this.inversePixelTransform = ht(), this.context = null, this.containerReused = !1, this.pixelContext_ = null, this.frameState = null;
+  }
+  /**
+   * @param {HTMLCanvasElement|HTMLImageElement|HTMLVideoElement} image Image.
+   * @param {number} col The column index.
+   * @param {number} row The row index.
+   * @return {Uint8ClampedArray|null} The image data.
+   */
+  getImageData(t, e, i) {
+    ut || Ei(), ut.clearRect(0, 0, 1, 1);
+    let n;
+    try {
+      ut.drawImage(t, e, i, 1, 1, 0, 0, 1, 1), n = ut.getImageData(0, 0, 1, 1).data;
+    } catch {
+      return ut = null, null;
+    }
+    return n;
+  }
+  /**
+   * @param {import('../../Map.js').FrameState} frameState Frame state.
+   * @return {string} Background color.
+   */
+  getBackground(t) {
+    let i = this.getLayer().getBackground();
+    return typeof i == "function" && (i = i(t.viewState.resolution)), i || void 0;
+  }
+  /**
+   * Get a rendering container from an existing target, if compatible.
+   * @param {HTMLElement} target Potential render target.
+   * @param {string} transform CSS Transform.
+   * @param {string} [backgroundColor] Background color.
+   */
+  useContainer(t, e, i) {
+    const n = this.getLayer().getClassName();
+    let s, o;
+    if (t && t.className === n && (!i || t && t.style.backgroundColor && Rt(
+      Te(t.style.backgroundColor),
+      Te(i)
+    ))) {
+      const r = t.firstElementChild;
+      r instanceof HTMLCanvasElement && (o = r.getContext("2d"));
+    }
+    if (o && o.canvas.style.transform === e ? (this.container = t, this.context = o, this.containerReused = !0) : this.containerReused ? (this.container = null, this.context = null, this.containerReused = !1) : this.container && (this.container.style.backgroundColor = null), !this.container) {
+      s = document.createElement("div"), s.className = n;
+      let r = s.style;
+      r.position = "absolute", r.width = "100%", r.height = "100%", o = gt();
+      const l = o.canvas;
+      s.appendChild(l), r = l.style, r.position = "absolute", r.left = "0", r.transformOrigin = "top left", this.container = s, this.context = o;
+    }
+    !this.containerReused && i && !this.container.style.backgroundColor && (this.container.style.backgroundColor = i);
+  }
+  /**
+   * @param {CanvasRenderingContext2D} context Context.
+   * @param {import("../../Map.js").FrameState} frameState Frame state.
+   * @param {import("../../extent.js").Extent} extent Clip extent.
+   * @protected
+   */
+  clipUnrotated(t, e, i) {
+    const n = Qe(i), s = ti(i), o = ei(i), r = ii(i);
+    G(e.coordinateToPixelTransform, n), G(e.coordinateToPixelTransform, s), G(e.coordinateToPixelTransform, o), G(e.coordinateToPixelTransform, r);
+    const l = this.inversePixelTransform;
+    G(l, n), G(l, s), G(l, o), G(l, r), t.save(), t.beginPath(), t.moveTo(Math.round(n[0]), Math.round(n[1])), t.lineTo(Math.round(s[0]), Math.round(s[1])), t.lineTo(Math.round(o[0]), Math.round(o[1])), t.lineTo(Math.round(r[0]), Math.round(r[1])), t.clip();
+  }
+  /**
+   * @param {import("../../render/EventType.js").default} type Event type.
+   * @param {CanvasRenderingContext2D} context Context.
+   * @param {import("../../Map.js").FrameState} frameState Frame state.
+   * @private
+   */
+  dispatchRenderEvent_(t, e, i) {
+    const n = this.getLayer();
+    if (n.hasListener(t)) {
+      const s = new qe(
+        t,
+        this.inversePixelTransform,
+        i,
+        e
+      );
+      n.dispatchEvent(s);
+    }
+  }
+  /**
+   * @param {CanvasRenderingContext2D} context Context.
+   * @param {import("../../Map.js").FrameState} frameState Frame state.
+   * @protected
+   */
+  preRender(t, e) {
+    this.frameState = e, this.dispatchRenderEvent_(vt.PRERENDER, t, e);
+  }
+  /**
+   * @param {CanvasRenderingContext2D} context Context.
+   * @param {import("../../Map.js").FrameState} frameState Frame state.
+   * @protected
+   */
+  postRender(t, e) {
+    this.dispatchRenderEvent_(vt.POSTRENDER, t, e);
+  }
+  /**
+   * Creates a transform for rendering to an element that will be rotated after rendering.
+   * @param {import("../../coordinate.js").Coordinate} center Center.
+   * @param {number} resolution Resolution.
+   * @param {number} rotation Rotation.
+   * @param {number} pixelRatio Pixel ratio.
+   * @param {number} width Width of the rendered element (in pixels).
+   * @param {number} height Height of the rendered element (in pixels).
+   * @param {number} offsetX Offset on the x-axis in view coordinates.
+   * @protected
+   * @return {!import("../../transform.js").Transform} Transform.
+   */
+  getRenderTransform(t, e, i, n, s, o, r) {
+    const l = s / 2, a = o / 2, h = n / e, d = -h, c = -t[0] + r, f = -t[1];
+    return Vt(
+      this.tempTransform,
+      l,
+      a,
+      h,
+      d,
+      -i,
+      c,
+      f
+    );
+  }
+  /**
+   * Clean up.
+   */
+  disposeInternal() {
+    delete this.frameState, super.disposeInternal();
+  }
+}
+const I = {
+  BEGIN_GEOMETRY: 0,
+  BEGIN_PATH: 1,
+  CIRCLE: 2,
+  CLOSE_PATH: 3,
+  CUSTOM: 4,
+  DRAW_CHARS: 5,
+  DRAW_IMAGE: 6,
+  END_GEOMETRY: 7,
+  FILL: 8,
+  MOVE_TO_LINE_TO: 9,
+  SET_FILL_STYLE: 10,
+  SET_STROKE_STYLE: 11,
+  STROKE: 12
+}, Pt = [I.FILL], rt = [I.STROKE], at = [I.BEGIN_PATH], we = [I.CLOSE_PATH];
+class We {
+  /**
+   * Render a geometry with a custom renderer.
+   *
+   * @param {import("../geom/SimpleGeometry.js").default} geometry Geometry.
+   * @param {import("../Feature.js").FeatureLike} feature Feature.
+   * @param {Function} renderer Renderer.
+   * @param {Function} hitDetectionRenderer Renderer.
+   */
+  drawCustom(t, e, i, n) {
+  }
+  /**
+   * Render a geometry.
+   *
+   * @param {import("../geom/Geometry.js").default} geometry The geometry to render.
+   */
+  drawGeometry(t) {
+  }
+  /**
+   * Set the rendering style.
+   *
+   * @param {import("../style/Style.js").default} style The rendering style.
+   */
+  setStyle(t) {
+  }
+  /**
+   * @param {import("../geom/Circle.js").default} circleGeometry Circle geometry.
+   * @param {import("../Feature.js").default} feature Feature.
+   */
+  drawCircle(t, e) {
+  }
+  /**
+   * @param {import("../Feature.js").default} feature Feature.
+   * @param {import("../style/Style.js").default} style Style.
+   */
+  drawFeature(t, e) {
+  }
+  /**
+   * @param {import("../geom/GeometryCollection.js").default} geometryCollectionGeometry Geometry collection.
+   * @param {import("../Feature.js").default} feature Feature.
+   */
+  drawGeometryCollection(t, e) {
+  }
+  /**
+   * @param {import("../geom/LineString.js").default|import("./Feature.js").default} lineStringGeometry Line string geometry.
+   * @param {import("../Feature.js").FeatureLike} feature Feature.
+   */
+  drawLineString(t, e) {
+  }
+  /**
+   * @param {import("../geom/MultiLineString.js").default|import("./Feature.js").default} multiLineStringGeometry MultiLineString geometry.
+   * @param {import("../Feature.js").FeatureLike} feature Feature.
+   */
+  drawMultiLineString(t, e) {
+  }
+  /**
+   * @param {import("../geom/MultiPoint.js").default|import("./Feature.js").default} multiPointGeometry MultiPoint geometry.
+   * @param {import("../Feature.js").FeatureLike} feature Feature.
+   */
+  drawMultiPoint(t, e) {
+  }
+  /**
+   * @param {import("../geom/MultiPolygon.js").default} multiPolygonGeometry MultiPolygon geometry.
+   * @param {import("../Feature.js").FeatureLike} feature Feature.
+   */
+  drawMultiPolygon(t, e) {
+  }
+  /**
+   * @param {import("../geom/Point.js").default|import("./Feature.js").default} pointGeometry Point geometry.
+   * @param {import("../Feature.js").FeatureLike} feature Feature.
+   */
+  drawPoint(t, e) {
+  }
+  /**
+   * @param {import("../geom/Polygon.js").default|import("./Feature.js").default} polygonGeometry Polygon geometry.
+   * @param {import("../Feature.js").FeatureLike} feature Feature.
+   */
+  drawPolygon(t, e) {
+  }
+  /**
+   * @param {import("../geom/SimpleGeometry.js").default|import("./Feature.js").default} geometry Geometry.
+   * @param {import("../Feature.js").FeatureLike} feature Feature.
+   */
+  drawText(t, e) {
+  }
+  /**
+   * @param {import("../style/Fill.js").default} fillStyle Fill style.
+   * @param {import("../style/Stroke.js").default} strokeStyle Stroke style.
+   */
+  setFillStrokeStyle(t, e) {
+  }
+  /**
+   * @param {import("../style/Image.js").default} imageStyle Image style.
+   * @param {import("../render/canvas.js").DeclutterImageWithText} [declutterImageWithText] Shared data for combined decluttering with a text style.
+   */
+  setImageStyle(t, e) {
+  }
+  /**
+   * @param {import("../style/Text.js").default} textStyle Text style.
+   * @param {import("../render/canvas.js").DeclutterImageWithText} [declutterImageWithText] Shared data for combined decluttering with an image style.
+   */
+  setTextStyle(t, e) {
+  }
+}
+class kt extends We {
+  /**
+   * @param {number} tolerance Tolerance.
+   * @param {import("../../extent.js").Extent} maxExtent Maximum extent.
+   * @param {number} resolution Resolution.
+   * @param {number} pixelRatio Pixel ratio.
+   */
+  constructor(t, e, i, n) {
+    super(), this.tolerance = t, this.maxExtent = e, this.pixelRatio = n, this.maxLineWidth = 0, this.resolution = i, this.beginGeometryInstruction1_ = null, this.beginGeometryInstruction2_ = null, this.bufferedMaxExtent_ = null, this.instructions = [], this.coordinates = [], this.tmpCoordinate_ = [], this.hitDetectionInstructions = [], this.state = /** @type {import("../canvas.js").FillStrokeState} */
+    {};
+  }
+  /**
+   * @protected
+   * @param {Array<number>} dashArray Dash array.
+   * @return {Array<number>} Dash array with pixel ratio applied
+   */
+  applyPixelRatio(t) {
+    const e = this.pixelRatio;
+    return e == 1 ? t : t.map(function(i) {
+      return i * e;
+    });
+  }
+  /**
+   * @param {Array<number>} flatCoordinates Flat coordinates.
+   * @param {number} stride Stride.
+   * @protected
+   * @return {number} My end
+   */
+  appendFlatPointCoordinates(t, e) {
+    const i = this.getBufferedMaxExtent(), n = this.tmpCoordinate_, s = this.coordinates;
+    let o = s.length;
+    for (let r = 0, l = t.length; r < l; r += e)
+      n[0] = t[r], n[1] = t[r + 1], ni(i, n) && (s[o++] = n[0], s[o++] = n[1]);
+    return o;
+  }
+  /**
+   * @param {Array<number>} flatCoordinates Flat coordinates.
+   * @param {number} offset Offset.
+   * @param {number} end End.
+   * @param {number} stride Stride.
+   * @param {boolean} closed Last input coordinate equals first.
+   * @param {boolean} skipFirst Skip first coordinate.
+   * @protected
+   * @return {number} My end.
+   */
+  appendFlatLineCoordinates(t, e, i, n, s, o) {
+    const r = this.coordinates;
+    let l = r.length;
+    const a = this.getBufferedMaxExtent();
+    o && (e += n);
+    let h = t[e], d = t[e + 1];
+    const c = this.tmpCoordinate_;
+    let f = !0, u, _, p;
+    for (u = e + n; u < i; u += n)
+      c[0] = t[u], c[1] = t[u + 1], p = si(a, c), p !== _ ? (f && (r[l++] = h, r[l++] = d, f = !1), r[l++] = c[0], r[l++] = c[1]) : p === oi.INTERSECTING ? (r[l++] = c[0], r[l++] = c[1], f = !1) : f = !0, h = c[0], d = c[1], _ = p;
+    return (s && f || u === e + n) && (r[l++] = h, r[l++] = d), l;
+  }
+  /**
+   * @param {Array<number>} flatCoordinates Flat coordinates.
+   * @param {number} offset Offset.
+   * @param {Array<number>} ends Ends.
+   * @param {number} stride Stride.
+   * @param {Array<number>} builderEnds Builder ends.
+   * @return {number} Offset.
+   */
+  drawCustomCoordinates_(t, e, i, n, s) {
+    for (let o = 0, r = i.length; o < r; ++o) {
+      const l = i[o], a = this.appendFlatLineCoordinates(
+        t,
+        e,
+        l,
+        n,
+        !1,
+        !1
+      );
+      s.push(a), e = l;
+    }
+    return e;
+  }
+  /**
+   * @param {import("../../geom/SimpleGeometry.js").default} geometry Geometry.
+   * @param {import("../../Feature.js").FeatureLike} feature Feature.
+   * @param {Function} renderer Renderer.
+   * @param {Function} hitDetectionRenderer Renderer.
+   */
+  drawCustom(t, e, i, n) {
+    this.beginGeometry(t, e);
+    const s = t.getType(), o = t.getStride(), r = this.coordinates.length;
+    let l, a, h, d, c;
+    switch (s) {
+      case "MultiPolygon":
+        l = /** @type {import("../../geom/MultiPolygon.js").default} */
+        t.getOrientedFlatCoordinates(), d = [];
+        const f = (
+          /** @type {import("../../geom/MultiPolygon.js").default} */
+          t.getEndss()
+        );
+        c = 0;
+        for (let u = 0, _ = f.length; u < _; ++u) {
+          const p = [];
+          c = this.drawCustomCoordinates_(
+            l,
+            c,
+            f[u],
+            o,
+            p
+          ), d.push(p);
+        }
+        this.instructions.push([
+          I.CUSTOM,
+          r,
+          d,
+          t,
+          i,
+          ye
+        ]), this.hitDetectionInstructions.push([
+          I.CUSTOM,
+          r,
+          d,
+          t,
+          n || i,
+          ye
+        ]);
+        break;
+      case "Polygon":
+      case "MultiLineString":
+        h = [], l = s == "Polygon" ? (
+          /** @type {import("../../geom/Polygon.js").default} */
+          t.getOrientedFlatCoordinates()
+        ) : t.getFlatCoordinates(), c = this.drawCustomCoordinates_(
+          l,
+          0,
+          /** @type {import("../../geom/Polygon.js").default|import("../../geom/MultiLineString.js").default} */
+          t.getEnds(),
+          o,
+          h
+        ), this.instructions.push([
+          I.CUSTOM,
+          r,
+          h,
+          t,
+          i,
+          me
+        ]), this.hitDetectionInstructions.push([
+          I.CUSTOM,
+          r,
+          h,
+          t,
+          n || i,
+          me
+        ]);
+        break;
+      case "LineString":
+      case "Circle":
+        l = t.getFlatCoordinates(), a = this.appendFlatLineCoordinates(
+          l,
+          0,
+          l.length,
+          o,
+          !1,
+          !1
+        ), this.instructions.push([
+          I.CUSTOM,
+          r,
+          a,
+          t,
+          i,
+          bt
+        ]), this.hitDetectionInstructions.push([
+          I.CUSTOM,
+          r,
+          a,
+          t,
+          n || i,
+          bt
+        ]);
+        break;
+      case "MultiPoint":
+        l = t.getFlatCoordinates(), a = this.appendFlatPointCoordinates(l, o), a > r && (this.instructions.push([
+          I.CUSTOM,
+          r,
+          a,
+          t,
+          i,
+          bt
+        ]), this.hitDetectionInstructions.push([
+          I.CUSTOM,
+          r,
+          a,
+          t,
+          n || i,
+          bt
+        ]));
+        break;
+      case "Point":
+        l = t.getFlatCoordinates(), this.coordinates.push(l[0], l[1]), a = this.coordinates.length, this.instructions.push([
+          I.CUSTOM,
+          r,
+          a,
+          t,
+          i
+        ]), this.hitDetectionInstructions.push([
+          I.CUSTOM,
+          r,
+          a,
+          t,
+          n || i
+        ]);
+        break;
+    }
+    this.endGeometry(e);
+  }
+  /**
+   * @protected
+   * @param {import("../../geom/Geometry").default|import("../Feature.js").default} geometry The geometry.
+   * @param {import("../../Feature.js").FeatureLike} feature Feature.
+   */
+  beginGeometry(t, e) {
+    this.beginGeometryInstruction1_ = [
+      I.BEGIN_GEOMETRY,
+      e,
+      0,
+      t
+    ], this.instructions.push(this.beginGeometryInstruction1_), this.beginGeometryInstruction2_ = [
+      I.BEGIN_GEOMETRY,
+      e,
+      0,
+      t
+    ], this.hitDetectionInstructions.push(this.beginGeometryInstruction2_);
+  }
+  /**
+   * @return {import("../canvas.js").SerializableInstructions} the serializable instructions.
+   */
+  finish() {
+    return {
+      instructions: this.instructions,
+      hitDetectionInstructions: this.hitDetectionInstructions,
+      coordinates: this.coordinates
+    };
+  }
+  /**
+   * Reverse the hit detection instructions.
+   */
+  reverseHitDetectionInstructions() {
+    const t = this.hitDetectionInstructions;
+    t.reverse();
+    let e;
+    const i = t.length;
+    let n, s, o = -1;
+    for (e = 0; e < i; ++e)
+      n = t[e], s = /** @type {import("./Instruction.js").default} */
+      n[0], s == I.END_GEOMETRY ? o = e : s == I.BEGIN_GEOMETRY && (n[2] = e, Ri(this.hitDetectionInstructions, o, e), o = -1);
+  }
+  /**
+   * @param {import("../../style/Fill.js").default} fillStyle Fill style.
+   * @param {import("../../style/Stroke.js").default} strokeStyle Stroke style.
+   */
+  setFillStrokeStyle(t, e) {
+    const i = this.state;
+    if (t) {
+      const n = t.getColor();
+      i.fillStyle = ot(
+        n || V
+      );
+    } else
+      i.fillStyle = void 0;
+    if (e) {
+      const n = e.getColor();
+      i.strokeStyle = ot(
+        n || Bt
+      );
+      const s = e.getLineCap();
+      i.lineCap = s !== void 0 ? s : Gt;
+      const o = e.getLineDash();
+      i.lineDash = o ? o.slice() : et;
+      const r = e.getLineDashOffset();
+      i.lineDashOffset = r || it;
+      const l = e.getLineJoin();
+      i.lineJoin = l !== void 0 ? l : Yt;
+      const a = e.getWidth();
+      i.lineWidth = a !== void 0 ? a : Xt;
+      const h = e.getMiterLimit();
+      i.miterLimit = h !== void 0 ? h : Nt, i.lineWidth > this.maxLineWidth && (this.maxLineWidth = i.lineWidth, this.bufferedMaxExtent_ = null);
+    } else
+      i.strokeStyle = void 0, i.lineCap = void 0, i.lineDash = null, i.lineDashOffset = void 0, i.lineJoin = void 0, i.lineWidth = void 0, i.miterLimit = void 0;
+  }
+  /**
+   * @param {import("../canvas.js").FillStrokeState} state State.
+   * @return {Array<*>} Fill instruction.
+   */
+  createFill(t) {
+    const e = t.fillStyle, i = [I.SET_FILL_STYLE, e];
+    return typeof e != "string" && i.push(!0), i;
+  }
+  /**
+   * @param {import("../canvas.js").FillStrokeState} state State.
+   */
+  applyStroke(t) {
+    this.instructions.push(this.createStroke(t));
+  }
+  /**
+   * @param {import("../canvas.js").FillStrokeState} state State.
+   * @return {Array<*>} Stroke instruction.
+   */
+  createStroke(t) {
+    return [
+      I.SET_STROKE_STYLE,
+      t.strokeStyle,
+      t.lineWidth * this.pixelRatio,
+      t.lineCap,
+      t.lineJoin,
+      t.miterLimit,
+      this.applyPixelRatio(t.lineDash),
+      t.lineDashOffset * this.pixelRatio
+    ];
+  }
+  /**
+   * @param {import("../canvas.js").FillStrokeState} state State.
+   * @param {function(this:CanvasBuilder, import("../canvas.js").FillStrokeState):Array<*>} createFill Create fill.
+   */
+  updateFillStyle(t, e) {
+    const i = t.fillStyle;
+    (typeof i != "string" || t.currentFillStyle != i) && (i !== void 0 && this.instructions.push(e.call(this, t)), t.currentFillStyle = i);
+  }
+  /**
+   * @param {import("../canvas.js").FillStrokeState} state State.
+   * @param {function(this:CanvasBuilder, import("../canvas.js").FillStrokeState): void} applyStroke Apply stroke.
+   */
+  updateStrokeStyle(t, e) {
+    const i = t.strokeStyle, n = t.lineCap, s = t.lineDash, o = t.lineDashOffset, r = t.lineJoin, l = t.lineWidth, a = t.miterLimit;
+    (t.currentStrokeStyle != i || t.currentLineCap != n || s != t.currentLineDash && !Rt(t.currentLineDash, s) || t.currentLineDashOffset != o || t.currentLineJoin != r || t.currentLineWidth != l || t.currentMiterLimit != a) && (i !== void 0 && e.call(this, t), t.currentStrokeStyle = i, t.currentLineCap = n, t.currentLineDash = s, t.currentLineDashOffset = o, t.currentLineJoin = r, t.currentLineWidth = l, t.currentMiterLimit = a);
+  }
+  /**
+   * @param {import("../../Feature.js").FeatureLike} feature Feature.
+   */
+  endGeometry(t) {
+    this.beginGeometryInstruction1_[2] = this.instructions.length, this.beginGeometryInstruction1_ = null, this.beginGeometryInstruction2_[2] = this.hitDetectionInstructions.length, this.beginGeometryInstruction2_ = null;
+    const e = [I.END_GEOMETRY, t];
+    this.instructions.push(e), this.hitDetectionInstructions.push(e);
+  }
+  /**
+   * Get the buffered rendering extent.  Rendering will be clipped to the extent
+   * provided to the constructor.  To account for symbolizers that may intersect
+   * this extent, we calculate a buffered extent (e.g. based on stroke width).
+   * @return {import("../../extent.js").Extent} The buffered rendering extent.
+   * @protected
+   */
+  getBufferedMaxExtent() {
+    if (!this.bufferedMaxExtent_ && (this.bufferedMaxExtent_ = ri(this.maxExtent), this.maxLineWidth > 0)) {
+      const t = this.resolution * (this.maxLineWidth + 1) / 2;
+      se(this.bufferedMaxExtent_, t, this.bufferedMaxExtent_);
+    }
+    return this.bufferedMaxExtent_;
+  }
+}
+class Di extends kt {
+  /**
+   * @param {number} tolerance Tolerance.
+   * @param {import("../../extent.js").Extent} maxExtent Maximum extent.
+   * @param {number} resolution Resolution.
+   * @param {number} pixelRatio Pixel ratio.
+   */
+  constructor(t, e, i, n) {
+    super(t, e, i, n), this.hitDetectionImage_ = null, this.image_ = null, this.imagePixelRatio_ = void 0, this.anchorX_ = void 0, this.anchorY_ = void 0, this.height_ = void 0, this.opacity_ = void 0, this.originX_ = void 0, this.originY_ = void 0, this.rotateWithView_ = void 0, this.rotation_ = void 0, this.scale_ = void 0, this.width_ = void 0, this.declutterMode_ = void 0, this.declutterImageWithText_ = void 0;
+  }
+  /**
+   * @param {import("../../geom/Point.js").default|import("../Feature.js").default} pointGeometry Point geometry.
+   * @param {import("../../Feature.js").FeatureLike} feature Feature.
+   */
+  drawPoint(t, e) {
+    if (!this.image_)
+      return;
+    this.beginGeometry(t, e);
+    const i = t.getFlatCoordinates(), n = t.getStride(), s = this.coordinates.length, o = this.appendFlatPointCoordinates(i, n);
+    this.instructions.push([
+      I.DRAW_IMAGE,
+      s,
+      o,
+      this.image_,
+      // Remaining arguments to DRAW_IMAGE are in alphabetical order
+      this.anchorX_ * this.imagePixelRatio_,
+      this.anchorY_ * this.imagePixelRatio_,
+      Math.ceil(this.height_ * this.imagePixelRatio_),
+      this.opacity_,
+      this.originX_ * this.imagePixelRatio_,
+      this.originY_ * this.imagePixelRatio_,
+      this.rotateWithView_,
+      this.rotation_,
+      [
+        this.scale_[0] * this.pixelRatio / this.imagePixelRatio_,
+        this.scale_[1] * this.pixelRatio / this.imagePixelRatio_
+      ],
+      Math.ceil(this.width_ * this.imagePixelRatio_),
+      this.declutterMode_,
+      this.declutterImageWithText_
+    ]), this.hitDetectionInstructions.push([
+      I.DRAW_IMAGE,
+      s,
+      o,
+      this.hitDetectionImage_,
+      // Remaining arguments to DRAW_IMAGE are in alphabetical order
+      this.anchorX_,
+      this.anchorY_,
+      this.height_,
+      1,
+      this.originX_,
+      this.originY_,
+      this.rotateWithView_,
+      this.rotation_,
+      this.scale_,
+      this.width_,
+      this.declutterMode_,
+      this.declutterImageWithText_
+    ]), this.endGeometry(e);
+  }
+  /**
+   * @param {import("../../geom/MultiPoint.js").default|import("../Feature.js").default} multiPointGeometry MultiPoint geometry.
+   * @param {import("../../Feature.js").FeatureLike} feature Feature.
+   */
+  drawMultiPoint(t, e) {
+    if (!this.image_)
+      return;
+    this.beginGeometry(t, e);
+    const i = t.getFlatCoordinates(), n = t.getStride(), s = this.coordinates.length, o = this.appendFlatPointCoordinates(i, n);
+    this.instructions.push([
+      I.DRAW_IMAGE,
+      s,
+      o,
+      this.image_,
+      // Remaining arguments to DRAW_IMAGE are in alphabetical order
+      this.anchorX_ * this.imagePixelRatio_,
+      this.anchorY_ * this.imagePixelRatio_,
+      Math.ceil(this.height_ * this.imagePixelRatio_),
+      this.opacity_,
+      this.originX_ * this.imagePixelRatio_,
+      this.originY_ * this.imagePixelRatio_,
+      this.rotateWithView_,
+      this.rotation_,
+      [
+        this.scale_[0] * this.pixelRatio / this.imagePixelRatio_,
+        this.scale_[1] * this.pixelRatio / this.imagePixelRatio_
+      ],
+      Math.ceil(this.width_ * this.imagePixelRatio_),
+      this.declutterMode_,
+      this.declutterImageWithText_
+    ]), this.hitDetectionInstructions.push([
+      I.DRAW_IMAGE,
+      s,
+      o,
+      this.hitDetectionImage_,
+      // Remaining arguments to DRAW_IMAGE are in alphabetical order
+      this.anchorX_,
+      this.anchorY_,
+      this.height_,
+      1,
+      this.originX_,
+      this.originY_,
+      this.rotateWithView_,
+      this.rotation_,
+      this.scale_,
+      this.width_,
+      this.declutterMode_,
+      this.declutterImageWithText_
+    ]), this.endGeometry(e);
+  }
+  /**
+   * @return {import("../canvas.js").SerializableInstructions} the serializable instructions.
+   */
+  finish() {
+    return this.reverseHitDetectionInstructions(), this.anchorX_ = void 0, this.anchorY_ = void 0, this.hitDetectionImage_ = null, this.image_ = null, this.imagePixelRatio_ = void 0, this.height_ = void 0, this.scale_ = void 0, this.opacity_ = void 0, this.originX_ = void 0, this.originY_ = void 0, this.rotateWithView_ = void 0, this.rotation_ = void 0, this.width_ = void 0, super.finish();
+  }
+  /**
+   * @param {import("../../style/Image.js").default} imageStyle Image style.
+   * @param {Object} [sharedData] Shared data.
+   */
+  setImageStyle(t, e) {
+    const i = t.getAnchor(), n = t.getSize(), s = t.getOrigin();
+    this.imagePixelRatio_ = t.getPixelRatio(this.pixelRatio), this.anchorX_ = i[0], this.anchorY_ = i[1], this.hitDetectionImage_ = t.getHitDetectionImage(), this.image_ = t.getImage(this.pixelRatio), this.height_ = n[1], this.opacity_ = t.getOpacity(), this.originX_ = s[0], this.originY_ = s[1], this.rotateWithView_ = t.getRotateWithView(), this.rotation_ = t.getRotation(), this.scale_ = t.getScaleArray(), this.width_ = n[0], this.declutterMode_ = t.getDeclutterMode(), this.declutterImageWithText_ = e;
+  }
+}
+class Oi extends kt {
+  /**
+   * @param {number} tolerance Tolerance.
+   * @param {import("../../extent.js").Extent} maxExtent Maximum extent.
+   * @param {number} resolution Resolution.
+   * @param {number} pixelRatio Pixel ratio.
+   */
+  constructor(t, e, i, n) {
+    super(t, e, i, n);
+  }
+  /**
+   * @param {Array<number>} flatCoordinates Flat coordinates.
+   * @param {number} offset Offset.
+   * @param {number} end End.
+   * @param {number} stride Stride.
+   * @private
+   * @return {number} end.
+   */
+  drawFlatCoordinates_(t, e, i, n) {
+    const s = this.coordinates.length, o = this.appendFlatLineCoordinates(
+      t,
+      e,
+      i,
+      n,
+      !1,
+      !1
+    ), r = [
+      I.MOVE_TO_LINE_TO,
+      s,
+      o
+    ];
+    return this.instructions.push(r), this.hitDetectionInstructions.push(r), i;
+  }
+  /**
+   * @param {import("../../geom/LineString.js").default|import("../Feature.js").default} lineStringGeometry Line string geometry.
+   * @param {import("../../Feature.js").FeatureLike} feature Feature.
+   */
+  drawLineString(t, e) {
+    const i = this.state, n = i.strokeStyle, s = i.lineWidth;
+    if (n === void 0 || s === void 0)
+      return;
+    this.updateStrokeStyle(i, this.applyStroke), this.beginGeometry(t, e), this.hitDetectionInstructions.push(
+      [
+        I.SET_STROKE_STYLE,
+        i.strokeStyle,
+        i.lineWidth,
+        i.lineCap,
+        i.lineJoin,
+        i.miterLimit,
+        et,
+        it
+      ],
+      at
+    );
+    const o = t.getFlatCoordinates(), r = t.getStride();
+    this.drawFlatCoordinates_(
+      o,
+      0,
+      o.length,
+      r
+    ), this.hitDetectionInstructions.push(rt), this.endGeometry(e);
+  }
+  /**
+   * @param {import("../../geom/MultiLineString.js").default|import("../Feature.js").default} multiLineStringGeometry MultiLineString geometry.
+   * @param {import("../../Feature.js").FeatureLike} feature Feature.
+   */
+  drawMultiLineString(t, e) {
+    const i = this.state, n = i.strokeStyle, s = i.lineWidth;
+    if (n === void 0 || s === void 0)
+      return;
+    this.updateStrokeStyle(i, this.applyStroke), this.beginGeometry(t, e), this.hitDetectionInstructions.push(
+      [
+        I.SET_STROKE_STYLE,
+        i.strokeStyle,
+        i.lineWidth,
+        i.lineCap,
+        i.lineJoin,
+        i.miterLimit,
+        et,
+        it
+      ],
+      at
+    );
+    const o = t.getEnds(), r = t.getFlatCoordinates(), l = t.getStride();
+    let a = 0;
+    for (let h = 0, d = o.length; h < d; ++h)
+      a = this.drawFlatCoordinates_(
+        r,
+        a,
+        /** @type {number} */
+        o[h],
+        l
+      );
+    this.hitDetectionInstructions.push(rt), this.endGeometry(e);
+  }
+  /**
+   * @return {import("../canvas.js").SerializableInstructions} the serializable instructions.
+   */
+  finish() {
+    const t = this.state;
+    return t.lastStroke != null && t.lastStroke != this.coordinates.length && this.instructions.push(rt), this.reverseHitDetectionInstructions(), this.state = null, super.finish();
+  }
+  /**
+   * @param {import("../canvas.js").FillStrokeState} state State.
+   */
+  applyStroke(t) {
+    t.lastStroke != null && t.lastStroke != this.coordinates.length && (this.instructions.push(rt), t.lastStroke = this.coordinates.length), t.lastStroke = 0, super.applyStroke(t), this.instructions.push(at);
+  }
+}
+class Ee extends kt {
+  /**
+   * @param {number} tolerance Tolerance.
+   * @param {import("../../extent.js").Extent} maxExtent Maximum extent.
+   * @param {number} resolution Resolution.
+   * @param {number} pixelRatio Pixel ratio.
+   */
+  constructor(t, e, i, n) {
+    super(t, e, i, n);
+  }
+  /**
+   * @param {Array<number>} flatCoordinates Flat coordinates.
+   * @param {number} offset Offset.
+   * @param {Array<number>} ends Ends.
+   * @param {number} stride Stride.
+   * @private
+   * @return {number} End.
+   */
+  drawFlatCoordinatess_(t, e, i, n) {
+    const s = this.state, o = s.fillStyle !== void 0, r = s.strokeStyle !== void 0, l = i.length;
+    this.instructions.push(at), this.hitDetectionInstructions.push(at);
+    for (let a = 0; a < l; ++a) {
+      const h = i[a], d = this.coordinates.length, c = this.appendFlatLineCoordinates(
+        t,
+        e,
+        h,
+        n,
+        !0,
+        !r
+      ), f = [
+        I.MOVE_TO_LINE_TO,
+        d,
+        c
+      ];
+      this.instructions.push(f), this.hitDetectionInstructions.push(f), r && (this.instructions.push(we), this.hitDetectionInstructions.push(we)), e = h;
+    }
+    return o && (this.instructions.push(Pt), this.hitDetectionInstructions.push(Pt)), r && (this.instructions.push(rt), this.hitDetectionInstructions.push(rt)), e;
+  }
+  /**
+   * @param {import("../../geom/Circle.js").default} circleGeometry Circle geometry.
+   * @param {import("../../Feature.js").default} feature Feature.
+   */
+  drawCircle(t, e) {
+    const i = this.state, n = i.fillStyle, s = i.strokeStyle;
+    if (n === void 0 && s === void 0)
+      return;
+    this.setFillStrokeStyles_(), this.beginGeometry(t, e), i.fillStyle !== void 0 && this.hitDetectionInstructions.push([
+      I.SET_FILL_STYLE,
+      V
+    ]), i.strokeStyle !== void 0 && this.hitDetectionInstructions.push([
+      I.SET_STROKE_STYLE,
+      i.strokeStyle,
+      i.lineWidth,
+      i.lineCap,
+      i.lineJoin,
+      i.miterLimit,
+      et,
+      it
+    ]);
+    const o = t.getFlatCoordinates(), r = t.getStride(), l = this.coordinates.length;
+    this.appendFlatLineCoordinates(
+      o,
+      0,
+      o.length,
+      r,
+      !1,
+      !1
+    );
+    const a = [I.CIRCLE, l];
+    this.instructions.push(at, a), this.hitDetectionInstructions.push(at, a), i.fillStyle !== void 0 && (this.instructions.push(Pt), this.hitDetectionInstructions.push(Pt)), i.strokeStyle !== void 0 && (this.instructions.push(rt), this.hitDetectionInstructions.push(rt)), this.endGeometry(e);
+  }
+  /**
+   * @param {import("../../geom/Polygon.js").default|import("../Feature.js").default} polygonGeometry Polygon geometry.
+   * @param {import("../../Feature.js").FeatureLike} feature Feature.
+   */
+  drawPolygon(t, e) {
+    const i = this.state, n = i.fillStyle, s = i.strokeStyle;
+    if (n === void 0 && s === void 0)
+      return;
+    this.setFillStrokeStyles_(), this.beginGeometry(t, e), i.fillStyle !== void 0 && this.hitDetectionInstructions.push([
+      I.SET_FILL_STYLE,
+      V
+    ]), i.strokeStyle !== void 0 && this.hitDetectionInstructions.push([
+      I.SET_STROKE_STYLE,
+      i.strokeStyle,
+      i.lineWidth,
+      i.lineCap,
+      i.lineJoin,
+      i.miterLimit,
+      et,
+      it
+    ]);
+    const o = t.getEnds(), r = t.getOrientedFlatCoordinates(), l = t.getStride();
+    this.drawFlatCoordinatess_(
+      r,
+      0,
+      /** @type {Array<number>} */
+      o,
+      l
+    ), this.endGeometry(e);
+  }
+  /**
+   * @param {import("../../geom/MultiPolygon.js").default} multiPolygonGeometry MultiPolygon geometry.
+   * @param {import("../../Feature.js").FeatureLike} feature Feature.
+   */
+  drawMultiPolygon(t, e) {
+    const i = this.state, n = i.fillStyle, s = i.strokeStyle;
+    if (n === void 0 && s === void 0)
+      return;
+    this.setFillStrokeStyles_(), this.beginGeometry(t, e), i.fillStyle !== void 0 && this.hitDetectionInstructions.push([
+      I.SET_FILL_STYLE,
+      V
+    ]), i.strokeStyle !== void 0 && this.hitDetectionInstructions.push([
+      I.SET_STROKE_STYLE,
+      i.strokeStyle,
+      i.lineWidth,
+      i.lineCap,
+      i.lineJoin,
+      i.miterLimit,
+      et,
+      it
+    ]);
+    const o = t.getEndss(), r = t.getOrientedFlatCoordinates(), l = t.getStride();
+    let a = 0;
+    for (let h = 0, d = o.length; h < d; ++h)
+      a = this.drawFlatCoordinatess_(
+        r,
+        a,
+        o[h],
+        l
+      );
+    this.endGeometry(e);
+  }
+  /**
+   * @return {import("../canvas.js").SerializableInstructions} the serializable instructions.
+   */
+  finish() {
+    this.reverseHitDetectionInstructions(), this.state = null;
+    const t = this.tolerance;
+    if (t !== 0) {
+      const e = this.coordinates;
+      for (let i = 0, n = e.length; i < n; ++i)
+        e[i] = li(e[i], t);
+    }
+    return super.finish();
+  }
+  /**
+   * @private
+   */
+  setFillStrokeStyles_() {
+    const t = this.state;
+    t.fillStyle !== void 0 && this.updateFillStyle(t, this.createFill), t.strokeStyle !== void 0 && this.updateStrokeStyle(t, this.applyStroke);
+  }
+}
+function bi(g, t, e, i, n) {
+  const s = [];
+  let o = e, r = 0, l = t.slice(e, 2);
+  for (; r < g && o + n < i; ) {
+    const [a, h] = l.slice(-2), d = t[o + n], c = t[o + n + 1], f = Math.sqrt(
+      (d - a) * (d - a) + (c - h) * (c - h)
+    );
+    if (r += f, r >= g) {
+      const u = (g - r + f) / f, _ = K(a, d, u), p = K(h, c, u);
+      l.push(_, p), s.push(l), l = [_, p], r == g && (o += n), r = 0;
+    } else if (r < g)
+      l.push(
+        t[o + n],
+        t[o + n + 1]
+      ), o += n;
+    else {
+      const u = f - r, _ = K(a, d, u / f), p = K(h, c, u / f);
+      l.push(_, p), s.push(l), l = [_, p], r = 0, o += n;
+    }
+  }
+  return r > 0 && s.push(l), s;
+}
+function Mi(g, t, e, i, n) {
+  let s = e, o = e, r = 0, l = 0, a = e, h, d, c, f, u, _, p, x, y, m;
+  for (d = e; d < i; d += n) {
+    const C = t[d], T = t[d + 1];
+    u !== void 0 && (y = C - u, m = T - _, f = Math.sqrt(y * y + m * m), p !== void 0 && (l += c, h = Math.acos((p * y + x * m) / (c * f)), h > g && (l > r && (r = l, s = a, o = d), l = 0, a = d - n)), c = f, p = y, x = m), u = C, _ = T;
+  }
+  return l += f, l > r ? [a, d] : [s, o];
+}
+const Jt = {
+  left: 0,
+  center: 0.5,
+  right: 1,
+  top: 0,
+  middle: 0.5,
+  hanging: 0.2,
+  alphabetic: 0.8,
+  ideographic: 0.8,
+  bottom: 1
+};
+class Fi extends kt {
+  /**
+   * @param {number} tolerance Tolerance.
+   * @param {import("../../extent.js").Extent} maxExtent Maximum extent.
+   * @param {number} resolution Resolution.
+   * @param {number} pixelRatio Pixel ratio.
+   */
+  constructor(t, e, i, n) {
+    super(t, e, i, n), this.labels_ = null, this.text_ = "", this.textOffsetX_ = 0, this.textOffsetY_ = 0, this.textRotateWithView_ = void 0, this.textRotation_ = 0, this.textFillState_ = null, this.fillStates = {}, this.fillStates[V] = { fillStyle: V }, this.textStrokeState_ = null, this.strokeStates = {}, this.textState_ = /** @type {import("../canvas.js").TextState} */
+    {}, this.textStates = {}, this.textKey_ = "", this.fillKey_ = "", this.strokeKey_ = "", this.declutterImageWithText_ = void 0;
+  }
+  /**
+   * @return {import("../canvas.js").SerializableInstructions} the serializable instructions.
+   */
+  finish() {
+    const t = super.finish();
+    return t.textStates = this.textStates, t.fillStates = this.fillStates, t.strokeStates = this.strokeStates, t;
+  }
+  /**
+   * @param {import("../../geom/SimpleGeometry.js").default|import("../Feature.js").default} geometry Geometry.
+   * @param {import("../../Feature.js").FeatureLike} feature Feature.
+   */
+  drawText(t, e) {
+    const i = this.textFillState_, n = this.textStrokeState_, s = this.textState_;
+    if (this.text_ === "" || !s || !i && !n)
+      return;
+    const o = this.coordinates;
+    let r = o.length;
+    const l = t.getType();
+    let a = null, h = t.getStride();
+    if (s.placement === "line" && (l == "LineString" || l == "MultiLineString" || l == "Polygon" || l == "MultiPolygon")) {
+      if (!tt(this.getBufferedMaxExtent(), t.getExtent()))
+        return;
+      let d;
+      if (a = t.getFlatCoordinates(), l == "LineString")
+        d = [a.length];
+      else if (l == "MultiLineString")
+        d = /** @type {import("../../geom/MultiLineString.js").default} */
+        t.getEnds();
+      else if (l == "Polygon")
+        d = /** @type {import("../../geom/Polygon.js").default} */
+        t.getEnds().slice(0, 1);
+      else if (l == "MultiPolygon") {
+        const _ = (
+          /** @type {import("../../geom/MultiPolygon.js").default} */
+          t.getEndss()
+        );
+        d = [];
+        for (let p = 0, x = _.length; p < x; ++p)
+          d.push(_[p][0]);
+      }
+      this.beginGeometry(t, e);
+      const c = s.repeat, f = c ? void 0 : s.textAlign;
+      let u = 0;
+      for (let _ = 0, p = d.length; _ < p; ++_) {
+        let x;
+        c ? x = bi(
+          c * this.resolution,
+          a,
+          u,
+          d[_],
+          h
+        ) : x = [a.slice(u, d[_])];
+        for (let y = 0, m = x.length; y < m; ++y) {
+          const C = x[y];
+          let T = 0, L = C.length;
+          if (f == null) {
+            const k = Mi(
+              s.maxAngle,
+              C,
+              0,
+              C.length,
+              2
+            );
+            T = k[0], L = k[1];
+          }
+          for (let k = T; k < L; k += h)
+            o.push(C[k], C[k + 1]);
+          const O = o.length;
+          u = d[_], this.drawChars_(r, O), r = O;
+        }
+      }
+      this.endGeometry(e);
+    } else {
+      let d = s.overflow ? null : [];
+      switch (l) {
+        case "Point":
+        case "MultiPoint":
+          a = /** @type {import("../../geom/MultiPoint.js").default} */
+          t.getFlatCoordinates();
+          break;
+        case "LineString":
+          a = /** @type {import("../../geom/LineString.js").default} */
+          t.getFlatMidpoint();
+          break;
+        case "Circle":
+          a = /** @type {import("../../geom/Circle.js").default} */
+          t.getCenter();
+          break;
+        case "MultiLineString":
+          a = /** @type {import("../../geom/MultiLineString.js").default} */
+          t.getFlatMidpoints(), h = 2;
+          break;
+        case "Polygon":
+          a = /** @type {import("../../geom/Polygon.js").default} */
+          t.getFlatInteriorPoint(), s.overflow || d.push(a[2] / this.resolution), h = 3;
+          break;
+        case "MultiPolygon":
+          const x = (
+            /** @type {import("../../geom/MultiPolygon.js").default} */
+            t.getFlatInteriorPoints()
+          );
+          a = [];
+          for (let y = 0, m = x.length; y < m; y += 3)
+            s.overflow || d.push(x[y + 2] / this.resolution), a.push(x[y], x[y + 1]);
+          if (a.length === 0)
+            return;
+          h = 2;
+          break;
+      }
+      const c = this.appendFlatPointCoordinates(a, h);
+      if (c === r)
+        return;
+      if (d && (c - r) / 2 !== a.length / h) {
+        let x = r / 2;
+        d = d.filter((y, m) => {
+          const C = o[(x + m) * 2] === a[m * h] && o[(x + m) * 2 + 1] === a[m * h + 1];
+          return C || --x, C;
+        });
+      }
+      this.saveTextStates_(), (s.backgroundFill || s.backgroundStroke) && (this.setFillStrokeStyle(
+        s.backgroundFill,
+        s.backgroundStroke
+      ), s.backgroundFill && this.updateFillStyle(this.state, this.createFill), s.backgroundStroke && (this.updateStrokeStyle(this.state, this.applyStroke), this.hitDetectionInstructions.push(this.createStroke(this.state)))), this.beginGeometry(t, e);
+      let f = s.padding;
+      if (f != lt && (s.scale[0] < 0 || s.scale[1] < 0)) {
+        let x = s.padding[0], y = s.padding[1], m = s.padding[2], C = s.padding[3];
+        s.scale[0] < 0 && (y = -y, C = -C), s.scale[1] < 0 && (x = -x, m = -m), f = [x, y, m, C];
+      }
+      const u = this.pixelRatio;
+      this.instructions.push([
+        I.DRAW_IMAGE,
+        r,
+        c,
+        null,
+        NaN,
+        NaN,
+        NaN,
+        1,
+        0,
+        0,
+        this.textRotateWithView_,
+        this.textRotation_,
+        [1, 1],
+        NaN,
+        void 0,
+        this.declutterImageWithText_,
+        f == lt ? lt : f.map(function(x) {
+          return x * u;
+        }),
+        !!s.backgroundFill,
+        !!s.backgroundStroke,
+        this.text_,
+        this.textKey_,
+        this.strokeKey_,
+        this.fillKey_,
+        this.textOffsetX_,
+        this.textOffsetY_,
+        d
+      ]);
+      const _ = 1 / u, p = this.state.fillStyle;
+      s.backgroundFill && (this.state.fillStyle = V, this.hitDetectionInstructions.push(this.createFill(this.state))), this.hitDetectionInstructions.push([
+        I.DRAW_IMAGE,
+        r,
+        c,
+        null,
+        NaN,
+        NaN,
+        NaN,
+        1,
+        0,
+        0,
+        this.textRotateWithView_,
+        this.textRotation_,
+        [_, _],
+        NaN,
+        void 0,
+        this.declutterImageWithText_,
+        f,
+        !!s.backgroundFill,
+        !!s.backgroundStroke,
+        this.text_,
+        this.textKey_,
+        this.strokeKey_,
+        this.fillKey_ ? V : this.fillKey_,
+        this.textOffsetX_,
+        this.textOffsetY_,
+        d
+      ]), s.backgroundFill && (this.state.fillStyle = p, this.hitDetectionInstructions.push(this.createFill(this.state))), this.endGeometry(e);
+    }
+  }
+  /**
+   * @private
+   */
+  saveTextStates_() {
+    const t = this.textStrokeState_, e = this.textState_, i = this.textFillState_, n = this.strokeKey_;
+    t && (n in this.strokeStates || (this.strokeStates[n] = {
+      strokeStyle: t.strokeStyle,
+      lineCap: t.lineCap,
+      lineDashOffset: t.lineDashOffset,
+      lineWidth: t.lineWidth,
+      lineJoin: t.lineJoin,
+      miterLimit: t.miterLimit,
+      lineDash: t.lineDash
+    }));
+    const s = this.textKey_;
+    s in this.textStates || (this.textStates[s] = {
+      font: e.font,
+      textAlign: e.textAlign || Tt,
+      justify: e.justify,
+      textBaseline: e.textBaseline || Ht,
+      scale: e.scale
+    });
+    const o = this.fillKey_;
+    i && (o in this.fillStates || (this.fillStates[o] = {
+      fillStyle: i.fillStyle
+    }));
+  }
+  /**
+   * @private
+   * @param {number} begin Begin.
+   * @param {number} end End.
+   */
+  drawChars_(t, e) {
+    const i = this.textStrokeState_, n = this.textState_, s = this.strokeKey_, o = this.textKey_, r = this.fillKey_;
+    this.saveTextStates_();
+    const l = this.pixelRatio, a = Jt[n.textBaseline], h = this.textOffsetY_ * l, d = this.text_, c = i ? i.lineWidth * Math.abs(n.scale[0]) / 2 : 0;
+    this.instructions.push([
+      I.DRAW_CHARS,
+      t,
+      e,
+      a,
+      n.overflow,
+      r,
+      n.maxAngle,
+      l,
+      h,
+      s,
+      c * l,
+      d,
+      o,
+      1
+    ]), this.hitDetectionInstructions.push([
+      I.DRAW_CHARS,
+      t,
+      e,
+      a,
+      n.overflow,
+      r && V,
+      n.maxAngle,
+      1,
+      h,
+      s,
+      c,
+      d,
+      o,
+      1 / l
+    ]);
+  }
+  /**
+   * @param {import("../../style/Text.js").default} textStyle Text style.
+   * @param {Object} [sharedData] Shared data.
+   */
+  setTextStyle(t, e) {
+    let i, n, s;
+    if (!t)
+      this.text_ = "";
+    else {
+      const o = t.getFill();
+      o ? (n = this.textFillState_, n || (n = /** @type {import("../canvas.js").FillState} */
+      {}, this.textFillState_ = n), n.fillStyle = ot(
+        o.getColor() || V
+      )) : (n = null, this.textFillState_ = n);
+      const r = t.getStroke();
+      if (!r)
+        s = null, this.textStrokeState_ = s;
+      else {
+        s = this.textStrokeState_, s || (s = /** @type {import("../canvas.js").StrokeState} */
+        {}, this.textStrokeState_ = s);
+        const u = r.getLineDash(), _ = r.getLineDashOffset(), p = r.getWidth(), x = r.getMiterLimit();
+        s.lineCap = r.getLineCap() || Gt, s.lineDash = u ? u.slice() : et, s.lineDashOffset = _ === void 0 ? it : _, s.lineJoin = r.getLineJoin() || Yt, s.lineWidth = p === void 0 ? Xt : p, s.miterLimit = x === void 0 ? Nt : x, s.strokeStyle = ot(
+          r.getColor() || Bt
+        );
+      }
+      i = this.textState_;
+      const l = t.getFont() || Fe;
+      mi(l);
+      const a = t.getScaleArray();
+      i.overflow = t.getOverflow(), i.font = l, i.maxAngle = t.getMaxAngle(), i.placement = t.getPlacement(), i.textAlign = t.getTextAlign(), i.repeat = t.getRepeat(), i.justify = t.getJustify(), i.textBaseline = t.getTextBaseline() || Ht, i.backgroundFill = t.getBackgroundFill(), i.backgroundStroke = t.getBackgroundStroke(), i.padding = t.getPadding() || lt, i.scale = a === void 0 ? [1, 1] : a;
+      const h = t.getOffsetX(), d = t.getOffsetY(), c = t.getRotateWithView(), f = t.getRotation();
+      this.text_ = t.getText() || "", this.textOffsetX_ = h === void 0 ? 0 : h, this.textOffsetY_ = d === void 0 ? 0 : d, this.textRotateWithView_ = c === void 0 ? !1 : c, this.textRotation_ = f === void 0 ? 0 : f, this.strokeKey_ = s ? (typeof s.strokeStyle == "string" ? s.strokeStyle : It(s.strokeStyle)) + s.lineCap + s.lineDashOffset + "|" + s.lineWidth + s.lineJoin + s.miterLimit + "[" + s.lineDash.join() + "]" : "", this.textKey_ = i.font + i.scale + (i.textAlign || "?") + (i.repeat || "?") + (i.justify || "?") + (i.textBaseline || "?"), this.fillKey_ = n ? typeof n.fillStyle == "string" ? n.fillStyle : "|" + It(n.fillStyle) : "";
+    }
+    this.declutterImageWithText_ = e;
+  }
+}
+const Wi = {
+  Circle: Ee,
+  Default: kt,
+  Image: Di,
+  LineString: Oi,
+  Polygon: Ee,
+  Text: Fi
+};
+class Le {
+  /**
+   * @param {number} tolerance Tolerance.
+   * @param {import("../../extent.js").Extent} maxExtent Max extent.
+   * @param {number} resolution Resolution.
+   * @param {number} pixelRatio Pixel ratio.
+   */
+  constructor(t, e, i, n) {
+    this.tolerance_ = t, this.maxExtent_ = e, this.pixelRatio_ = n, this.resolution_ = i, this.buildersByZIndex_ = {};
+  }
+  /**
+   * @return {!Object<string, !Object<import("../canvas.js").BuilderType, import("./Builder.js").SerializableInstructions>>} The serializable instructions
+   */
+  finish() {
+    const t = {};
+    for (const e in this.buildersByZIndex_) {
+      t[e] = t[e] || {};
+      const i = this.buildersByZIndex_[e];
+      for (const n in i) {
+        const s = i[n].finish();
+        t[e][n] = s;
+      }
+    }
+    return t;
+  }
+  /**
+   * @param {number|undefined} zIndex Z index.
+   * @param {import("../canvas.js").BuilderType} builderType Replay type.
+   * @return {import("../VectorContext.js").default} Replay.
+   */
+  getBuilder(t, e) {
+    const i = t !== void 0 ? t.toString() : "0";
+    let n = this.buildersByZIndex_[i];
+    n === void 0 && (n = {}, this.buildersByZIndex_[i] = n);
+    let s = n[e];
+    if (s === void 0) {
+      const o = Wi[e];
+      s = new o(
+        this.tolerance_,
+        this.maxExtent_,
+        this.resolution_,
+        this.pixelRatio_
+      ), n[e] = s;
+    }
+    return s;
+  }
+}
+function Pi(g, t, e, i, n, s, o, r, l, a, h, d) {
+  let c = g[t], f = g[t + 1], u = 0, _ = 0, p = 0, x = 0;
+  function y() {
+    u = c, _ = f, t += i, c = g[t], f = g[t + 1], x += p, p = Math.sqrt((c - u) * (c - u) + (f - _) * (f - _));
+  }
+  do
+    y();
+  while (t < e - i && x + p < s);
+  let m = p === 0 ? 0 : (s - x) / p;
+  const C = K(u, c, m), T = K(_, f, m), L = t - i, O = x, k = s + r * l(a, n, h);
+  for (; t < e - i && x + p < k; )
+    y();
+  m = p === 0 ? 0 : (k - x) / p;
+  const D = K(u, c, m), b = K(_, f, m);
+  let P;
+  if (d) {
+    const E = [C, T, D, b];
+    ai(E, 0, 4, 2, d, E, E), P = E[0] > E[2];
+  } else
+    P = C > D;
+  const W = Math.PI, F = [], Y = L + i === t;
+  t = L, p = 0, x = O, c = g[t], f = g[t + 1];
+  let R;
+  if (Y) {
+    y(), R = Math.atan2(f - _, c - u), P && (R += R > 0 ? -W : W);
+    const E = (D + C) / 2, w = (b + T) / 2;
+    return F[0] = [E, w, (k - s) / 2, R, n], F;
+  }
+  n = n.replace(/\n/g, " ");
+  for (let E = 0, w = n.length; E < w; ) {
+    y();
+    let M = Math.atan2(f - _, c - u);
+    if (P && (M += M > 0 ? -W : W), R !== void 0) {
+      let j = M - R;
+      if (j += j > W ? -2 * W : j < -W ? 2 * W : 0, Math.abs(j) > o)
+        return null;
+    }
+    R = M;
+    const v = E;
+    let A = 0;
+    for (; E < w; ++E) {
+      const j = P ? w - E - 1 : E, ct = r * l(a, n[j], h);
+      if (t + i < e && x + p < s + A + ct / 2)
+        break;
+      A += ct;
+    }
+    if (E === v)
+      continue;
+    const Z = P ? n.substring(w - v, w - E) : n.substring(v, E);
+    m = p === 0 ? 0 : (s + A / 2 - x) / p;
+    const S = K(u, c, m), oe = K(_, f, m);
+    F.push([S, oe, A / 2, M, Z]), s += A;
+  }
+  return F;
+}
+const ft = At(), nt = [], $ = [], Q = [], st = [];
+function De(g) {
+  return g[3].declutterBox;
+}
+const Oe = new RegExp(
+  /* eslint-disable prettier/prettier */
+  "[֑-ࣿיִ-﷿ﹰ-ﻼࠀ-࿿-]"
+  /* eslint-enable prettier/prettier */
+);
+function Qt(g, t) {
+  return t === "start" ? t = Oe.test(g) ? "right" : "left" : t === "end" && (t = Oe.test(g) ? "left" : "right"), Jt[t];
+}
+function vi(g, t, e) {
+  return e > 0 && g.push(`
+`, ""), g.push(t, ""), g;
+}
+class Ai {
+  /**
+   * @param {number} resolution Resolution.
+   * @param {number} pixelRatio Pixel ratio.
+   * @param {boolean} overlaps The replay can have overlapping geometries.
+   * @param {import("../canvas.js").SerializableInstructions} instructions The serializable instructions
+   */
+  constructor(t, e, i, n) {
+    this.overlaps = i, this.pixelRatio = e, this.resolution = t, this.alignFill_, this.instructions = n.instructions, this.coordinates = n.coordinates, this.coordinateCache_ = {}, this.renderedTransform_ = ht(), this.hitDetectionInstructions = n.hitDetectionInstructions, this.pixelCoordinates_ = null, this.viewRotation_ = 0, this.fillStates = n.fillStates || {}, this.strokeStates = n.strokeStates || {}, this.textStates = n.textStates || {}, this.widths_ = {}, this.labels_ = {};
+  }
+  /**
+   * @param {string|Array<string>} text Text.
+   * @param {string} textKey Text style key.
+   * @param {string} fillKey Fill style key.
+   * @param {string} strokeKey Stroke style key.
+   * @return {import("../canvas.js").Label} Label.
+   */
+  createLabel(t, e, i, n) {
+    const s = t + e + i + n;
+    if (this.labels_[s])
+      return this.labels_[s];
+    const o = n ? this.strokeStates[n] : null, r = i ? this.fillStates[i] : null, l = this.textStates[e], a = this.pixelRatio, h = [
+      l.scale[0] * a,
+      l.scale[1] * a
+    ], d = Array.isArray(t), c = l.justify ? Jt[l.justify] : Qt(
+      Array.isArray(t) ? t[0] : t,
+      l.textAlign || Tt
+    ), f = n && o.lineWidth ? o.lineWidth : 0, u = d ? t : t.split(`
+`).reduce(vi, []), { width: _, height: p, widths: x, heights: y, lineWidths: m } = yi(
+      l,
+      u
+    ), C = _ + f, T = [], L = (C + 2) * h[0], O = (p + f) * h[1], k = {
+      width: L < 0 ? Math.floor(L) : Math.ceil(L),
+      height: O < 0 ? Math.floor(O) : Math.ceil(O),
+      contextInstructions: T
+    };
+    (h[0] != 1 || h[1] != 1) && T.push("scale", h), n && (T.push("strokeStyle", o.strokeStyle), T.push("lineWidth", f), T.push("lineCap", o.lineCap), T.push("lineJoin", o.lineJoin), T.push("miterLimit", o.miterLimit), T.push("setLineDash", [o.lineDash]), T.push("lineDashOffset", o.lineDashOffset)), i && T.push("fillStyle", r.fillStyle), T.push("textBaseline", "middle"), T.push("textAlign", "center");
+    const D = 0.5 - c;
+    let b = c * C + D * f;
+    const P = [], W = [];
+    let F = 0, Y = 0, R = 0, E = 0, w;
+    for (let M = 0, v = u.length; M < v; M += 2) {
+      const A = u[M];
+      if (A === `
+`) {
+        Y += F, F = 0, b = c * C + D * f, ++E;
+        continue;
+      }
+      const Z = u[M + 1] || l.font;
+      Z !== w && (n && P.push("font", Z), i && W.push("font", Z), w = Z), F = Math.max(F, y[R]);
+      const S = [
+        A,
+        b + D * x[R] + c * (x[R] - m[E]),
+        0.5 * (f + F) + Y
+      ];
+      b += x[R], n && P.push("strokeText", S), i && W.push("fillText", S), ++R;
+    }
+    return Array.prototype.push.apply(T, P), Array.prototype.push.apply(T, W), this.labels_[s] = k, k;
+  }
+  /**
+   * @param {CanvasRenderingContext2D} context Context.
+   * @param {import("../../coordinate.js").Coordinate} p1 1st point of the background box.
+   * @param {import("../../coordinate.js").Coordinate} p2 2nd point of the background box.
+   * @param {import("../../coordinate.js").Coordinate} p3 3rd point of the background box.
+   * @param {import("../../coordinate.js").Coordinate} p4 4th point of the background box.
+   * @param {Array<*>} fillInstruction Fill instruction.
+   * @param {Array<*>} strokeInstruction Stroke instruction.
+   */
+  replayTextBackground_(t, e, i, n, s, o, r) {
+    t.beginPath(), t.moveTo.apply(t, e), t.lineTo.apply(t, i), t.lineTo.apply(t, n), t.lineTo.apply(t, s), t.lineTo.apply(t, e), o && (this.alignFill_ = /** @type {boolean} */
+    o[2], this.fill_(t)), r && (this.setStrokeStyle_(
+      t,
+      /** @type {Array<*>} */
+      r
+    ), t.stroke());
+  }
+  /**
+   * @private
+   * @param {number} sheetWidth Width of the sprite sheet.
+   * @param {number} sheetHeight Height of the sprite sheet.
+   * @param {number} centerX X.
+   * @param {number} centerY Y.
+   * @param {number} width Width.
+   * @param {number} height Height.
+   * @param {number} anchorX Anchor X.
+   * @param {number} anchorY Anchor Y.
+   * @param {number} originX Origin X.
+   * @param {number} originY Origin Y.
+   * @param {number} rotation Rotation.
+   * @param {import("../../size.js").Size} scale Scale.
+   * @param {boolean} snapToPixel Snap to pixel.
+   * @param {Array<number>} padding Padding.
+   * @param {boolean} fillStroke Background fill or stroke.
+   * @param {import("../../Feature.js").FeatureLike} feature Feature.
+   * @return {ImageOrLabelDimensions} Dimensions for positioning and decluttering the image or label.
+   */
+  calculateImageOrLabelDimensions_(t, e, i, n, s, o, r, l, a, h, d, c, f, u, _, p) {
+    r *= c[0], l *= c[1];
+    let x = i - r, y = n - l;
+    const m = s + a > t ? t - a : s, C = o + h > e ? e - h : o, T = u[3] + m * c[0] + u[1], L = u[0] + C * c[1] + u[2], O = x - u[3], k = y - u[0];
+    (_ || d !== 0) && (nt[0] = O, st[0] = O, nt[1] = k, $[1] = k, $[0] = O + T, Q[0] = $[0], Q[1] = k + L, st[1] = Q[1]);
+    let D;
+    return d !== 0 ? (D = Vt(
+      ht(),
+      i,
+      n,
+      1,
+      1,
+      d,
+      -i,
+      -n
+    ), G(D, nt), G(D, $), G(D, Q), G(D, st), Ce(
+      Math.min(nt[0], $[0], Q[0], st[0]),
+      Math.min(nt[1], $[1], Q[1], st[1]),
+      Math.max(nt[0], $[0], Q[0], st[0]),
+      Math.max(nt[1], $[1], Q[1], st[1]),
+      ft
+    )) : Ce(
+      Math.min(O, O + T),
+      Math.min(k, k + L),
+      Math.max(O, O + T),
+      Math.max(k, k + L),
+      ft
+    ), f && (x = Math.round(x), y = Math.round(y)), {
+      drawImageX: x,
+      drawImageY: y,
+      drawImageW: m,
+      drawImageH: C,
+      originX: a,
+      originY: h,
+      declutterBox: {
+        minX: ft[0],
+        minY: ft[1],
+        maxX: ft[2],
+        maxY: ft[3],
+        value: p
+      },
+      canvasTransform: D,
+      scale: c
+    };
+  }
+  /**
+   * @private
+   * @param {CanvasRenderingContext2D} context Context.
+   * @param {number} contextScale Scale of the context.
+   * @param {import("../canvas.js").Label|HTMLImageElement|HTMLCanvasElement|HTMLVideoElement} imageOrLabel Image.
+   * @param {ImageOrLabelDimensions} dimensions Dimensions.
+   * @param {number} opacity Opacity.
+   * @param {Array<*>} fillInstruction Fill instruction.
+   * @param {Array<*>} strokeInstruction Stroke instruction.
+   * @return {boolean} The image or label was rendered.
+   */
+  replayImageOrLabel_(t, e, i, n, s, o, r) {
+    const l = !!(o || r), a = n.declutterBox, h = t.canvas, d = r ? r[2] * n.scale[0] / 2 : 0;
+    return a.minX - d <= h.width / e && a.maxX + d >= 0 && a.minY - d <= h.height / e && a.maxY + d >= 0 && (l && this.replayTextBackground_(
+      t,
+      nt,
+      $,
+      Q,
+      st,
+      /** @type {Array<*>} */
+      o,
+      /** @type {Array<*>} */
+      r
+    ), Ci(
+      t,
+      n.canvasTransform,
+      s,
+      i,
+      n.originX,
+      n.originY,
+      n.drawImageW,
+      n.drawImageH,
+      n.drawImageX,
+      n.drawImageY,
+      n.scale
+    )), !0;
+  }
+  /**
+   * @private
+   * @param {CanvasRenderingContext2D} context Context.
+   */
+  fill_(t) {
+    if (this.alignFill_) {
+      const e = G(this.renderedTransform_, [0, 0]), i = 512 * this.pixelRatio;
+      t.save(), t.translate(e[0] % i, e[1] % i), t.rotate(this.viewRotation_);
+    }
+    t.fill(), this.alignFill_ && t.restore();
+  }
+  /**
+   * @private
+   * @param {CanvasRenderingContext2D} context Context.
+   * @param {Array<*>} instruction Instruction.
+   */
+  setStrokeStyle_(t, e) {
+    t.strokeStyle = /** @type {import("../../colorlike.js").ColorLike} */
+    e[1], t.lineWidth = /** @type {number} */
+    e[2], t.lineCap = /** @type {CanvasLineCap} */
+    e[3], t.lineJoin = /** @type {CanvasLineJoin} */
+    e[4], t.miterLimit = /** @type {number} */
+    e[5], t.lineDashOffset = /** @type {number} */
+    e[7], t.setLineDash(
+      /** @type {Array<number>} */
+      e[6]
+    );
+  }
+  /**
+   * @private
+   * @param {string|Array<string>} text The text to draw.
+   * @param {string} textKey The key of the text state.
+   * @param {string} strokeKey The key for the stroke state.
+   * @param {string} fillKey The key for the fill state.
+   * @return {{label: import("../canvas.js").Label, anchorX: number, anchorY: number}} The text image and its anchor.
+   */
+  drawLabelWithPointPlacement_(t, e, i, n) {
+    const s = this.textStates[e], o = this.createLabel(t, e, n, i), r = this.strokeStates[i], l = this.pixelRatio, a = Qt(
+      Array.isArray(t) ? t[0] : t,
+      s.textAlign || Tt
+    ), h = Jt[s.textBaseline || Ht], d = r && r.lineWidth ? r.lineWidth : 0, c = o.width / l - 2 * s.scale[0], f = a * c + 2 * (0.5 - a) * d, u = h * o.height / l + 2 * (0.5 - h) * d;
+    return {
+      label: o,
+      anchorX: f,
+      anchorY: u
+    };
+  }
+  /**
+   * @private
+   * @param {CanvasRenderingContext2D} context Context.
+   * @param {number} contextScale Scale of the context.
+   * @param {import("../../transform.js").Transform} transform Transform.
+   * @param {Array<*>} instructions Instructions array.
+   * @param {boolean} snapToPixel Snap point symbols and text to integer pixels.
+   * @param {FeatureCallback<T>} [featureCallback] Feature callback.
+   * @param {import("../../extent.js").Extent} [hitExtent] Only check
+   *     features that intersect this extent.
+   * @param {import("rbush").default} [declutterTree] Declutter tree.
+   * @return {T|undefined} Callback result.
+   * @template T
+   */
+  execute_(t, e, i, n, s, o, r, l) {
+    let a;
+    this.pixelCoordinates_ && Rt(i, this.renderedTransform_) ? a = this.pixelCoordinates_ : (this.pixelCoordinates_ || (this.pixelCoordinates_ = []), a = yt(
+      this.coordinates,
+      0,
+      this.coordinates.length,
+      2,
+      i,
+      this.pixelCoordinates_
+    ), hi(this.renderedTransform_, i));
+    let h = 0;
+    const d = n.length;
+    let c = 0, f, u, _, p, x, y, m, C, T, L, O, k, D = 0, b = 0, P = null, W = null;
+    const F = this.coordinateCache_, Y = this.viewRotation_, R = Math.round(Math.atan2(-i[1], i[0]) * 1e12) / 1e12, E = (
+      /** @type {import("../../render.js").State} */
+      {
+        context: t,
+        pixelRatio: this.pixelRatio,
+        resolution: this.resolution,
+        rotation: Y
+      }
+    ), w = this.instructions != n || this.overlaps ? 0 : 200;
+    let M, v, A, Z;
+    for (; h < d; ) {
+      const S = n[h];
+      switch (
+        /** @type {import("./Instruction.js").default} */
+        S[0]
+      ) {
+        case I.BEGIN_GEOMETRY:
+          M = /** @type {import("../../Feature.js").FeatureLike} */
+          S[1], Z = S[3], M.getGeometry() ? r !== void 0 && !tt(r, Z.getExtent()) ? h = /** @type {number} */
+          S[2] + 1 : ++h : h = /** @type {number} */
+          S[2];
+          break;
+        case I.BEGIN_PATH:
+          D > w && (this.fill_(t), D = 0), b > w && (t.stroke(), b = 0), !D && !b && (t.beginPath(), p = NaN, x = NaN), ++h;
+          break;
+        case I.CIRCLE:
+          c = /** @type {number} */
+          S[1];
+          const j = a[c], ct = a[c + 1], Ae = a[c + 2], Be = a[c + 3], re = Ae - j, le = Be - ct, ae = Math.sqrt(re * re + le * le);
+          t.moveTo(j + ae, ct), t.arc(j, ct, ae, 0, 2 * Math.PI, !0), ++h;
+          break;
+        case I.CLOSE_PATH:
+          t.closePath(), ++h;
+          break;
+        case I.CUSTOM:
+          c = /** @type {number} */
+          S[1], f = S[2];
+          const Ge = (
+            /** @type {import("../../geom/SimpleGeometry.js").default} */
+            S[3]
+          ), Ye = S[4], he = S.length == 6 ? S[5] : void 0;
+          E.geometry = Ge, E.feature = M, h in F || (F[h] = []);
+          const _t = F[h];
+          he ? he(a, c, f, 2, _t) : (_t[0] = a[c], _t[1] = a[c + 1], _t.length = 2), Ye(_t, E), ++h;
+          break;
+        case I.DRAW_IMAGE:
+          c = /** @type {number} */
+          S[1], f = /** @type {number} */
+          S[2], C = /** @type {HTMLCanvasElement|HTMLVideoElement|HTMLImageElement} */
+          S[3], u = /** @type {number} */
+          S[4], _ = /** @type {number} */
+          S[5];
+          let Zt = (
+            /** @type {number} */
+            S[6]
+          );
+          const Xe = (
+            /** @type {number} */
+            S[7]
+          ), Ne = (
+            /** @type {number} */
+            S[8]
+          ), He = (
+            /** @type {number} */
+            S[9]
+          ), ce = (
+            /** @type {boolean} */
+            S[10]
+          );
+          let jt = (
+            /** @type {number} */
+            S[11]
+          );
+          const Je = (
+            /** @type {import("../../size.js").Size} */
+            S[12]
+          );
+          let wt = (
+            /** @type {number} */
+            S[13]
+          );
+          const de = (
+            /** @type {"declutter"|"obstacle"|"none"|undefined} */
+            S[14]
+          ), xt = (
+            /** @type {import("../canvas.js").DeclutterImageWithText} */
+            S[15]
+          );
+          if (!C && S.length >= 20) {
+            T = /** @type {string} */
+            S[19], L = /** @type {string} */
+            S[20], O = /** @type {string} */
+            S[21], k = /** @type {string} */
+            S[22];
+            const X = this.drawLabelWithPointPlacement_(
+              T,
+              L,
+              O,
+              k
+            );
+            C = X.label, S[3] = C;
+            const dt = (
+              /** @type {number} */
+              S[23]
+            );
+            u = (X.anchorX - dt) * this.pixelRatio, S[4] = u;
+            const H = (
+              /** @type {number} */
+              S[24]
+            );
+            _ = (X.anchorY - H) * this.pixelRatio, S[5] = _, Zt = C.height, S[6] = Zt, wt = C.width, S[13] = wt;
+          }
+          let Kt;
+          S.length > 25 && (Kt = /** @type {number} */
+          S[25]);
+          let zt, Et, Lt;
+          S.length > 17 ? (zt = /** @type {Array<number>} */
+          S[16], Et = /** @type {boolean} */
+          S[17], Lt = /** @type {boolean} */
+          S[18]) : (zt = lt, Et = !1, Lt = !1), ce && R ? jt += Y : !ce && !R && (jt -= Y);
+          let Ve = 0;
+          for (; c < f; c += 2) {
+            if (Kt && Kt[Ve++] < wt / this.pixelRatio)
+              continue;
+            const X = this.calculateImageOrLabelDimensions_(
+              C.width,
+              C.height,
+              a[c],
+              a[c + 1],
+              wt,
+              Zt,
+              u,
+              _,
+              Ne,
+              He,
+              jt,
+              Je,
+              s,
+              zt,
+              Et || Lt,
+              M
+            ), dt = [
+              t,
+              e,
+              C,
+              X,
+              Xe,
+              Et ? (
+                /** @type {Array<*>} */
+                P
+              ) : null,
+              Lt ? (
+                /** @type {Array<*>} */
+                W
+              ) : null
+            ];
+            if (l) {
+              if (de === "none")
+                continue;
+              if (de === "obstacle") {
+                l.insert(X.declutterBox);
+                continue;
+              } else {
+                let H, q;
+                if (xt) {
+                  const N = f - c;
+                  if (!xt[N]) {
+                    xt[N] = dt;
+                    continue;
+                  }
+                  if (H = xt[N], delete xt[N], q = De(H), l.collides(q))
+                    continue;
+                }
+                if (l.collides(X.declutterBox))
+                  continue;
+                H && (l.insert(q), this.replayImageOrLabel_.apply(this, H)), l.insert(X.declutterBox);
+              }
+            }
+            this.replayImageOrLabel_.apply(this, dt);
+          }
+          ++h;
+          break;
+        case I.DRAW_CHARS:
+          const fe = (
+            /** @type {number} */
+            S[1]
+          ), ue = (
+            /** @type {number} */
+            S[2]
+          ), qt = (
+            /** @type {number} */
+            S[3]
+          ), Ze = (
+            /** @type {number} */
+            S[4]
+          );
+          k = /** @type {string} */
+          S[5];
+          const je = (
+            /** @type {number} */
+            S[6]
+          ), ge = (
+            /** @type {number} */
+            S[7]
+          ), _e = (
+            /** @type {number} */
+            S[8]
+          );
+          O = /** @type {string} */
+          S[9];
+          const Ut = (
+            /** @type {number} */
+            S[10]
+          );
+          T = /** @type {string} */
+          S[11], L = /** @type {string} */
+          S[12];
+          const xe = [
+            /** @type {number} */
+            S[13],
+            /** @type {number} */
+            S[13]
+          ], $t = this.textStates[L], pt = $t.font, St = [
+            $t.scale[0] * ge,
+            $t.scale[1] * ge
+          ];
+          let mt;
+          pt in this.widths_ ? mt = this.widths_[pt] : (mt = {}, this.widths_[pt] = mt);
+          const pe = Ue(a, fe, ue, 2), Se = Math.abs(St[0]) * Ie(pt, T, mt);
+          if (Ze || Se <= pe) {
+            const X = this.textStates[L].textAlign, dt = (pe - Se) * Qt(T, X), H = Pi(
+              a,
+              fe,
+              ue,
+              2,
+              T,
+              dt,
+              je,
+              Math.abs(St[0]),
+              Ie,
+              pt,
+              mt,
+              R ? 0 : this.viewRotation_
+            );
+            t: if (H) {
+              const q = [];
+              let N, Dt, Ot, B, J;
+              if (O)
+                for (N = 0, Dt = H.length; N < Dt; ++N) {
+                  J = H[N], Ot = /** @type {string} */
+                  J[4], B = this.createLabel(Ot, L, "", O), u = /** @type {number} */
+                  J[2] + (St[0] < 0 ? -Ut : Ut), _ = qt * B.height + (0.5 - qt) * 2 * Ut * St[1] / St[0] - _e;
+                  const U = this.calculateImageOrLabelDimensions_(
+                    B.width,
+                    B.height,
+                    J[0],
+                    J[1],
+                    B.width,
+                    B.height,
+                    u,
+                    _,
+                    0,
+                    0,
+                    J[3],
+                    xe,
+                    !1,
+                    lt,
+                    !1,
+                    M
+                  );
+                  if (l && l.collides(U.declutterBox))
+                    break t;
+                  q.push([
+                    t,
+                    e,
+                    B,
+                    U,
+                    1,
+                    null,
+                    null
+                  ]);
+                }
+              if (k)
+                for (N = 0, Dt = H.length; N < Dt; ++N) {
+                  J = H[N], Ot = /** @type {string} */
+                  J[4], B = this.createLabel(Ot, L, k, ""), u = /** @type {number} */
+                  J[2], _ = qt * B.height - _e;
+                  const U = this.calculateImageOrLabelDimensions_(
+                    B.width,
+                    B.height,
+                    J[0],
+                    J[1],
+                    B.width,
+                    B.height,
+                    u,
+                    _,
+                    0,
+                    0,
+                    J[3],
+                    xe,
+                    !1,
+                    lt,
+                    !1,
+                    M
+                  );
+                  if (l && l.collides(U.declutterBox))
+                    break t;
+                  q.push([
+                    t,
+                    e,
+                    B,
+                    U,
+                    1,
+                    null,
+                    null
+                  ]);
+                }
+              l && l.load(q.map(De));
+              for (let U = 0, Ke = q.length; U < Ke; ++U)
+                this.replayImageOrLabel_.apply(this, q[U]);
+            }
+          }
+          ++h;
+          break;
+        case I.END_GEOMETRY:
+          if (o !== void 0) {
+            M = /** @type {import("../../Feature.js").FeatureLike} */
+            S[1];
+            const X = o(M, Z);
+            if (X)
+              return X;
+          }
+          ++h;
+          break;
+        case I.FILL:
+          w ? D++ : this.fill_(t), ++h;
+          break;
+        case I.MOVE_TO_LINE_TO:
+          for (c = /** @type {number} */
+          S[1], f = /** @type {number} */
+          S[2], v = a[c], A = a[c + 1], y = v + 0.5 | 0, m = A + 0.5 | 0, (y !== p || m !== x) && (t.moveTo(v, A), p = y, x = m), c += 2; c < f; c += 2)
+            v = a[c], A = a[c + 1], y = v + 0.5 | 0, m = A + 0.5 | 0, (c == f - 2 || y !== p || m !== x) && (t.lineTo(v, A), p = y, x = m);
+          ++h;
+          break;
+        case I.SET_FILL_STYLE:
+          P = S, this.alignFill_ = S[2], D && (this.fill_(t), D = 0, b && (t.stroke(), b = 0)), t.fillStyle = /** @type {import("../../colorlike.js").ColorLike} */
+          S[1], ++h;
+          break;
+        case I.SET_STROKE_STYLE:
+          W = S, b && (t.stroke(), b = 0), this.setStrokeStyle_(
+            t,
+            /** @type {Array<*>} */
+            S
+          ), ++h;
+          break;
+        case I.STROKE:
+          w ? b++ : t.stroke(), ++h;
+          break;
+        default:
+          ++h;
+          break;
+      }
+    }
+    D && this.fill_(t), b && t.stroke();
+  }
+  /**
+   * @param {CanvasRenderingContext2D} context Context.
+   * @param {number} contextScale Scale of the context.
+   * @param {import("../../transform.js").Transform} transform Transform.
+   * @param {number} viewRotation View rotation.
+   * @param {boolean} snapToPixel Snap point symbols and text to integer pixels.
+   * @param {import("rbush").default} [declutterTree] Declutter tree.
+   */
+  execute(t, e, i, n, s, o) {
+    this.viewRotation_ = n, this.execute_(
+      t,
+      e,
+      i,
+      this.instructions,
+      s,
+      void 0,
+      void 0,
+      o
+    );
+  }
+  /**
+   * @param {CanvasRenderingContext2D} context Context.
+   * @param {import("../../transform.js").Transform} transform Transform.
+   * @param {number} viewRotation View rotation.
+   * @param {FeatureCallback<T>} [featureCallback] Feature callback.
+   * @param {import("../../extent.js").Extent} [hitExtent] Only check
+   *     features that intersect this extent.
+   * @return {T|undefined} Callback result.
+   * @template T
+   */
+  executeHitDetection(t, e, i, n, s) {
+    return this.viewRotation_ = i, this.execute_(
+      t,
+      1,
+      e,
+      this.hitDetectionInstructions,
+      !0,
+      n,
+      s
+    );
+  }
+}
+const te = ["Polygon", "Circle", "LineString", "Image", "Text", "Default"];
+class be {
+  /**
+   * @param {import("../../extent.js").Extent} maxExtent Max extent for clipping. When a
+   * `maxExtent` was set on the Builder for this executor group, the same `maxExtent`
+   * should be set here, unless the target context does not exceed that extent (which
+   * can be the case when rendering to tiles).
+   * @param {number} resolution Resolution.
+   * @param {number} pixelRatio Pixel ratio.
+   * @param {boolean} overlaps The executor group can have overlapping geometries.
+   * @param {!Object<string, !Object<import("../canvas.js").BuilderType, import("../canvas.js").SerializableInstructions>>} allInstructions
+   * The serializable instructions.
+   * @param {number} [renderBuffer] Optional rendering buffer.
+   */
+  constructor(t, e, i, n, s, o) {
+    this.maxExtent_ = t, this.overlaps_ = n, this.pixelRatio_ = i, this.resolution_ = e, this.renderBuffer_ = o, this.executorsByZIndex_ = {}, this.hitDetectionContext_ = null, this.hitDetectionTransform_ = ht(), this.createExecutors_(s);
+  }
+  /**
+   * @param {CanvasRenderingContext2D} context Context.
+   * @param {import("../../transform.js").Transform} transform Transform.
+   */
+  clip(t, e) {
+    const i = this.getClipCoords(e);
+    t.beginPath(), t.moveTo(i[0], i[1]), t.lineTo(i[2], i[3]), t.lineTo(i[4], i[5]), t.lineTo(i[6], i[7]), t.clip();
+  }
+  /**
+   * Create executors and populate them using the provided instructions.
+   * @private
+   * @param {!Object<string, !Object<import("../canvas.js").BuilderType, import("../canvas.js").SerializableInstructions>>} allInstructions The serializable instructions
+   */
+  createExecutors_(t) {
+    for (const e in t) {
+      let i = this.executorsByZIndex_[e];
+      i === void 0 && (i = {}, this.executorsByZIndex_[e] = i);
+      const n = t[e];
+      for (const s in n) {
+        const o = n[s];
+        i[s] = new Ai(
+          this.resolution_,
+          this.pixelRatio_,
+          this.overlaps_,
+          o
+        );
+      }
+    }
+  }
+  /**
+   * @param {Array<import("../canvas.js").BuilderType>} executors Executors.
+   * @return {boolean} Has executors of the provided types.
+   */
+  hasExecutors(t) {
+    for (const e in this.executorsByZIndex_) {
+      const i = this.executorsByZIndex_[e];
+      for (let n = 0, s = t.length; n < s; ++n)
+        if (t[n] in i)
+          return !0;
+    }
+    return !1;
+  }
+  /**
+   * @param {import("../../coordinate.js").Coordinate} coordinate Coordinate.
+   * @param {number} resolution Resolution.
+   * @param {number} rotation Rotation.
+   * @param {number} hitTolerance Hit tolerance in pixels.
+   * @param {function(import("../../Feature.js").FeatureLike, import("../../geom/SimpleGeometry.js").default, number): T} callback Feature callback.
+   * @param {Array<import("../../Feature.js").FeatureLike>} declutteredFeatures Decluttered features.
+   * @return {T|undefined} Callback result.
+   * @template T
+   */
+  forEachFeatureAtCoordinate(t, e, i, n, s, o) {
+    n = Math.round(n);
+    const r = n * 2 + 1, l = Vt(
+      this.hitDetectionTransform_,
+      n + 0.5,
+      n + 0.5,
+      1 / e,
+      -1 / e,
+      -i,
+      -t[0],
+      -t[1]
+    ), a = !this.hitDetectionContext_;
+    a && (this.hitDetectionContext_ = gt(
+      r,
+      r,
+      void 0,
+      { willReadFrequently: !0 }
+    ));
+    const h = this.hitDetectionContext_;
+    h.canvas.width !== r || h.canvas.height !== r ? (h.canvas.width = r, h.canvas.height = r) : a || h.clearRect(0, 0, r, r);
+    let d;
+    this.renderBuffer_ !== void 0 && (d = At(), ci(d, t), se(
+      d,
+      e * (this.renderBuffer_ + n),
+      d
+    ));
+    const c = Bi(n);
+    let f;
+    function u(T, L) {
+      const O = h.getImageData(
+        0,
+        0,
+        r,
+        r
+      ).data;
+      for (let k = 0, D = c.length; k < D; k++)
+        if (O[c[k]] > 0) {
+          if (!o || f !== "Image" && f !== "Text" || o.includes(T)) {
+            const b = (c[k] - 3) / 4, P = n - b % r, W = n - (b / r | 0), F = s(T, L, P * P + W * W);
+            if (F)
+              return F;
+          }
+          h.clearRect(0, 0, r, r);
+          break;
+        }
+    }
+    const _ = Object.keys(this.executorsByZIndex_).map(Number);
+    _.sort(ie);
+    let p, x, y, m, C;
+    for (p = _.length - 1; p >= 0; --p) {
+      const T = _[p].toString();
+      for (y = this.executorsByZIndex_[T], x = te.length - 1; x >= 0; --x)
+        if (f = te[x], m = y[f], m !== void 0 && (C = m.executeHitDetection(
+          h,
+          l,
+          i,
+          u,
+          d
+        ), C))
+          return C;
+    }
+  }
+  /**
+   * @param {import("../../transform.js").Transform} transform Transform.
+   * @return {Array<number>|null} Clip coordinates.
+   */
+  getClipCoords(t) {
+    const e = this.maxExtent_;
+    if (!e)
+      return null;
+    const i = e[0], n = e[1], s = e[2], o = e[3], r = [i, n, i, o, s, o, s, n];
+    return yt(r, 0, 8, 2, t, r), r;
+  }
+  /**
+   * @return {boolean} Is empty.
+   */
+  isEmpty() {
+    return ki(this.executorsByZIndex_);
+  }
+  /**
+   * @param {CanvasRenderingContext2D} context Context.
+   * @param {number} contextScale Scale of the context.
+   * @param {import("../../transform.js").Transform} transform Transform.
+   * @param {number} viewRotation View rotation.
+   * @param {boolean} snapToPixel Snap point symbols and test to integer pixel.
+   * @param {Array<import("../canvas.js").BuilderType>} [builderTypes] Ordered replay types to replay.
+   *     Default is {@link module:ol/render/replay~ORDER}
+   * @param {import("rbush").default} [declutterTree] Declutter tree.
+   */
+  execute(t, e, i, n, s, o, r) {
+    const l = Object.keys(this.executorsByZIndex_).map(Number);
+    l.sort(ie), this.maxExtent_ && (t.save(), this.clip(t, i)), o = o || te;
+    let a, h, d, c, f, u;
+    for (r && l.reverse(), a = 0, h = l.length; a < h; ++a) {
+      const _ = l[a].toString();
+      for (f = this.executorsByZIndex_[_], d = 0, c = o.length; d < c; ++d) {
+        const p = o[d];
+        u = f[p], u !== void 0 && u.execute(
+          t,
+          e,
+          i,
+          n,
+          s,
+          r
+        );
+      }
+    }
+    this.maxExtent_ && t.restore();
+  }
+}
+const ee = {};
+function Bi(g) {
+  if (ee[g] !== void 0)
+    return ee[g];
+  const t = g * 2 + 1, e = g * g, i = new Array(e + 1);
+  for (let s = 0; s <= g; ++s)
+    for (let o = 0; o <= g; ++o) {
+      const r = s * s + o * o;
+      if (r > e)
+        break;
+      let l = i[r];
+      l || (l = [], i[r] = l), l.push(((g + s) * t + (g + o)) * 4 + 3), s > 0 && l.push(((g - s) * t + (g + o)) * 4 + 3), o > 0 && (l.push(((g + s) * t + (g - o)) * 4 + 3), s > 0 && l.push(((g - s) * t + (g - o)) * 4 + 3));
+    }
+  const n = [];
+  for (let s = 0, o = i.length; s < o; ++s)
+    i[s] && n.push(...i[s]);
+  return ee[g] = n, n;
+}
+class Gi extends We {
+  /**
+   * @param {CanvasRenderingContext2D} context Context.
+   * @param {number} pixelRatio Pixel ratio.
+   * @param {import("../../extent.js").Extent} extent Extent.
+   * @param {import("../../transform.js").Transform} transform Transform.
+   * @param {number} viewRotation View rotation.
+   * @param {number} [squaredTolerance] Optional squared tolerance for simplification.
+   * @param {import("../../proj.js").TransformFunction} [userTransform] Transform from user to view projection.
+   */
+  constructor(t, e, i, n, s, o, r) {
+    super(), this.context_ = t, this.pixelRatio_ = e, this.extent_ = i, this.transform_ = n, this.transformRotation_ = n ? wi(Math.atan2(n[1], n[0]), 10) : 0, this.viewRotation_ = s, this.squaredTolerance_ = o, this.userTransform_ = r, this.contextFillState_ = null, this.contextStrokeState_ = null, this.contextTextState_ = null, this.fillState_ = null, this.strokeState_ = null, this.image_ = null, this.imageAnchorX_ = 0, this.imageAnchorY_ = 0, this.imageHeight_ = 0, this.imageOpacity_ = 0, this.imageOriginX_ = 0, this.imageOriginY_ = 0, this.imageRotateWithView_ = !1, this.imageRotation_ = 0, this.imageScale_ = [0, 0], this.imageWidth_ = 0, this.text_ = "", this.textOffsetX_ = 0, this.textOffsetY_ = 0, this.textRotateWithView_ = !1, this.textRotation_ = 0, this.textScale_ = [0, 0], this.textFillState_ = null, this.textStrokeState_ = null, this.textState_ = null, this.pixelCoordinates_ = [], this.tmpLocalTransform_ = ht();
+  }
+  /**
+   * @param {Array<number>} flatCoordinates Flat coordinates.
+   * @param {number} offset Offset.
+   * @param {number} end End.
+   * @param {number} stride Stride.
+   * @private
+   */
+  drawImages_(t, e, i, n) {
+    if (!this.image_)
+      return;
+    const s = yt(
+      t,
+      e,
+      i,
+      n,
+      this.transform_,
+      this.pixelCoordinates_
+    ), o = this.context_, r = this.tmpLocalTransform_, l = o.globalAlpha;
+    this.imageOpacity_ != 1 && (o.globalAlpha = l * this.imageOpacity_);
+    let a = this.imageRotation_;
+    this.transformRotation_ === 0 && (a -= this.viewRotation_), this.imageRotateWithView_ && (a += this.viewRotation_);
+    for (let h = 0, d = s.length; h < d; h += 2) {
+      const c = s[h] - this.imageAnchorX_, f = s[h + 1] - this.imageAnchorY_;
+      if (a !== 0 || this.imageScale_[0] != 1 || this.imageScale_[1] != 1) {
+        const u = c + this.imageAnchorX_, _ = f + this.imageAnchorY_;
+        Vt(
+          r,
+          u,
+          _,
+          1,
+          1,
+          a,
+          -u,
+          -_
+        ), o.setTransform.apply(o, r), o.translate(u, _), o.scale(this.imageScale_[0], this.imageScale_[1]), o.drawImage(
+          this.image_,
+          this.imageOriginX_,
+          this.imageOriginY_,
+          this.imageWidth_,
+          this.imageHeight_,
+          -this.imageAnchorX_,
+          -this.imageAnchorY_,
+          this.imageWidth_,
+          this.imageHeight_
+        ), o.setTransform(1, 0, 0, 1, 0, 0);
+      } else
+        o.drawImage(
+          this.image_,
+          this.imageOriginX_,
+          this.imageOriginY_,
+          this.imageWidth_,
+          this.imageHeight_,
+          c,
+          f,
+          this.imageWidth_,
+          this.imageHeight_
+        );
+    }
+    this.imageOpacity_ != 1 && (o.globalAlpha = l);
+  }
+  /**
+   * @param {Array<number>} flatCoordinates Flat coordinates.
+   * @param {number} offset Offset.
+   * @param {number} end End.
+   * @param {number} stride Stride.
+   * @private
+   */
+  drawText_(t, e, i, n) {
+    if (!this.textState_ || this.text_ === "")
+      return;
+    this.textFillState_ && this.setContextFillState_(this.textFillState_), this.textStrokeState_ && this.setContextStrokeState_(this.textStrokeState_), this.setContextTextState_(this.textState_);
+    const s = yt(
+      t,
+      e,
+      i,
+      n,
+      this.transform_,
+      this.pixelCoordinates_
+    ), o = this.context_;
+    let r = this.textRotation_;
+    for (this.transformRotation_ === 0 && (r -= this.viewRotation_), this.textRotateWithView_ && (r += this.viewRotation_); e < i; e += n) {
+      const l = s[e] + this.textOffsetX_, a = s[e + 1] + this.textOffsetY_;
+      r !== 0 || this.textScale_[0] != 1 || this.textScale_[1] != 1 ? (o.translate(l - this.textOffsetX_, a - this.textOffsetY_), o.rotate(r), o.translate(this.textOffsetX_, this.textOffsetY_), o.scale(this.textScale_[0], this.textScale_[1]), this.textStrokeState_ && o.strokeText(this.text_, 0, 0), this.textFillState_ && o.fillText(this.text_, 0, 0), o.setTransform(1, 0, 0, 1, 0, 0)) : (this.textStrokeState_ && o.strokeText(this.text_, l, a), this.textFillState_ && o.fillText(this.text_, l, a));
+    }
+  }
+  /**
+   * @param {Array<number>} flatCoordinates Flat coordinates.
+   * @param {number} offset Offset.
+   * @param {number} end End.
+   * @param {number} stride Stride.
+   * @param {boolean} close Close.
+   * @private
+   * @return {number} end End.
+   */
+  moveToLineTo_(t, e, i, n, s) {
+    const o = this.context_, r = yt(
+      t,
+      e,
+      i,
+      n,
+      this.transform_,
+      this.pixelCoordinates_
+    );
+    o.moveTo(r[0], r[1]);
+    let l = r.length;
+    s && (l -= 2);
+    for (let a = 2; a < l; a += 2)
+      o.lineTo(r[a], r[a + 1]);
+    return s && o.closePath(), i;
+  }
+  /**
+   * @param {Array<number>} flatCoordinates Flat coordinates.
+   * @param {number} offset Offset.
+   * @param {Array<number>} ends Ends.
+   * @param {number} stride Stride.
+   * @private
+   * @return {number} End.
+   */
+  drawRings_(t, e, i, n) {
+    for (let s = 0, o = i.length; s < o; ++s)
+      e = this.moveToLineTo_(
+        t,
+        e,
+        i[s],
+        n,
+        !0
+      );
+    return e;
+  }
+  /**
+   * Render a circle geometry into the canvas.  Rendering is immediate and uses
+   * the current fill and stroke styles.
+   *
+   * @param {import("../../geom/Circle.js").default} geometry Circle geometry.
+   * @api
+   */
+  drawCircle(t) {
+    if (this.squaredTolerance_ && (t = /** @type {import("../../geom/Circle.js").default} */
+    t.simplifyTransformed(
+      this.squaredTolerance_,
+      this.userTransform_
+    )), !!tt(this.extent_, t.getExtent())) {
+      if (this.fillState_ || this.strokeState_) {
+        this.fillState_ && this.setContextFillState_(this.fillState_), this.strokeState_ && this.setContextStrokeState_(this.strokeState_);
+        const e = di(
+          t,
+          this.transform_,
+          this.pixelCoordinates_
+        ), i = e[2] - e[0], n = e[3] - e[1], s = Math.sqrt(i * i + n * n), o = this.context_;
+        o.beginPath(), o.arc(
+          e[0],
+          e[1],
+          s,
+          0,
+          2 * Math.PI
+        ), this.fillState_ && o.fill(), this.strokeState_ && o.stroke();
+      }
+      this.text_ !== "" && this.drawText_(t.getCenter(), 0, 2, 2);
+    }
+  }
+  /**
+   * Set the rendering style.  Note that since this is an immediate rendering API,
+   * any `zIndex` on the provided style will be ignored.
+   *
+   * @param {import("../../style/Style.js").default} style The rendering style.
+   * @api
+   */
+  setStyle(t) {
+    this.setFillStrokeStyle(t.getFill(), t.getStroke()), this.setImageStyle(t.getImage()), this.setTextStyle(t.getText());
+  }
+  /**
+   * @param {import("../../transform.js").Transform} transform Transform.
+   */
+  setTransform(t) {
+    this.transform_ = t;
+  }
+  /**
+   * Render a geometry into the canvas.  Call
+   * {@link module:ol/render/canvas/Immediate~CanvasImmediateRenderer#setStyle renderer.setStyle()} first to set the rendering style.
+   *
+   * @param {import("../../geom/Geometry.js").default|import("../Feature.js").default} geometry The geometry to render.
+   * @api
+   */
+  drawGeometry(t) {
+    switch (t.getType()) {
+      case "Point":
+        this.drawPoint(
+          /** @type {import("../../geom/Point.js").default} */
+          t
+        );
+        break;
+      case "LineString":
+        this.drawLineString(
+          /** @type {import("../../geom/LineString.js").default} */
+          t
+        );
+        break;
+      case "Polygon":
+        this.drawPolygon(
+          /** @type {import("../../geom/Polygon.js").default} */
+          t
+        );
+        break;
+      case "MultiPoint":
+        this.drawMultiPoint(
+          /** @type {import("../../geom/MultiPoint.js").default} */
+          t
+        );
+        break;
+      case "MultiLineString":
+        this.drawMultiLineString(
+          /** @type {import("../../geom/MultiLineString.js").default} */
+          t
+        );
+        break;
+      case "MultiPolygon":
+        this.drawMultiPolygon(
+          /** @type {import("../../geom/MultiPolygon.js").default} */
+          t
+        );
+        break;
+      case "GeometryCollection":
+        this.drawGeometryCollection(
+          /** @type {import("../../geom/GeometryCollection.js").default} */
+          t
+        );
+        break;
+      case "Circle":
+        this.drawCircle(
+          /** @type {import("../../geom/Circle.js").default} */
+          t
+        );
+        break;
+    }
+  }
+  /**
+   * Render a feature into the canvas.  Note that any `zIndex` on the provided
+   * style will be ignored - features are rendered immediately in the order that
+   * this method is called.  If you need `zIndex` support, you should be using an
+   * {@link module:ol/layer/Vector~VectorLayer} instead.
+   *
+   * @param {import("../../Feature.js").default} feature Feature.
+   * @param {import("../../style/Style.js").default} style Style.
+   * @api
+   */
+  drawFeature(t, e) {
+    const i = e.getGeometryFunction()(t);
+    i && (this.setStyle(e), this.drawGeometry(i));
+  }
+  /**
+   * Render a GeometryCollection to the canvas.  Rendering is immediate and
+   * uses the current styles appropriate for each geometry in the collection.
+   *
+   * @param {import("../../geom/GeometryCollection.js").default} geometry Geometry collection.
+   */
+  drawGeometryCollection(t) {
+    const e = t.getGeometriesArray();
+    for (let i = 0, n = e.length; i < n; ++i)
+      this.drawGeometry(e[i]);
+  }
+  /**
+   * Render a Point geometry into the canvas.  Rendering is immediate and uses
+   * the current style.
+   *
+   * @param {import("../../geom/Point.js").default|import("../Feature.js").default} geometry Point geometry.
+   */
+  drawPoint(t) {
+    this.squaredTolerance_ && (t = /** @type {import("../../geom/Point.js").default} */
+    t.simplifyTransformed(
+      this.squaredTolerance_,
+      this.userTransform_
+    ));
+    const e = t.getFlatCoordinates(), i = t.getStride();
+    this.image_ && this.drawImages_(e, 0, e.length, i), this.text_ !== "" && this.drawText_(e, 0, e.length, i);
+  }
+  /**
+   * Render a MultiPoint geometry  into the canvas.  Rendering is immediate and
+   * uses the current style.
+   *
+   * @param {import("../../geom/MultiPoint.js").default|import("../Feature.js").default} geometry MultiPoint geometry.
+   */
+  drawMultiPoint(t) {
+    this.squaredTolerance_ && (t = /** @type {import("../../geom/MultiPoint.js").default} */
+    t.simplifyTransformed(
+      this.squaredTolerance_,
+      this.userTransform_
+    ));
+    const e = t.getFlatCoordinates(), i = t.getStride();
+    this.image_ && this.drawImages_(e, 0, e.length, i), this.text_ !== "" && this.drawText_(e, 0, e.length, i);
+  }
+  /**
+   * Render a LineString into the canvas.  Rendering is immediate and uses
+   * the current style.
+   *
+   * @param {import("../../geom/LineString.js").default|import("../Feature.js").default} geometry LineString geometry.
+   */
+  drawLineString(t) {
+    if (this.squaredTolerance_ && (t = /** @type {import("../../geom/LineString.js").default} */
+    t.simplifyTransformed(
+      this.squaredTolerance_,
+      this.userTransform_
+    )), !!tt(this.extent_, t.getExtent())) {
+      if (this.strokeState_) {
+        this.setContextStrokeState_(this.strokeState_);
+        const e = this.context_, i = t.getFlatCoordinates();
+        e.beginPath(), this.moveToLineTo_(
+          i,
+          0,
+          i.length,
+          t.getStride(),
+          !1
+        ), e.stroke();
+      }
+      if (this.text_ !== "") {
+        const e = t.getFlatMidpoint();
+        this.drawText_(e, 0, 2, 2);
+      }
+    }
+  }
+  /**
+   * Render a MultiLineString geometry into the canvas.  Rendering is immediate
+   * and uses the current style.
+   *
+   * @param {import("../../geom/MultiLineString.js").default|import("../Feature.js").default} geometry MultiLineString geometry.
+   */
+  drawMultiLineString(t) {
+    this.squaredTolerance_ && (t = /** @type {import("../../geom/MultiLineString.js").default} */
+    t.simplifyTransformed(
+      this.squaredTolerance_,
+      this.userTransform_
+    ));
+    const e = t.getExtent();
+    if (tt(this.extent_, e)) {
+      if (this.strokeState_) {
+        this.setContextStrokeState_(this.strokeState_);
+        const i = this.context_, n = t.getFlatCoordinates();
+        let s = 0;
+        const o = (
+          /** @type {Array<number>} */
+          t.getEnds()
+        ), r = t.getStride();
+        i.beginPath();
+        for (let l = 0, a = o.length; l < a; ++l)
+          s = this.moveToLineTo_(
+            n,
+            s,
+            o[l],
+            r,
+            !1
+          );
+        i.stroke();
+      }
+      if (this.text_ !== "") {
+        const i = t.getFlatMidpoints();
+        this.drawText_(i, 0, i.length, 2);
+      }
+    }
+  }
+  /**
+   * Render a Polygon geometry into the canvas.  Rendering is immediate and uses
+   * the current style.
+   *
+   * @param {import("../../geom/Polygon.js").default|import("../Feature.js").default} geometry Polygon geometry.
+   */
+  drawPolygon(t) {
+    if (this.squaredTolerance_ && (t = /** @type {import("../../geom/Polygon.js").default} */
+    t.simplifyTransformed(
+      this.squaredTolerance_,
+      this.userTransform_
+    )), !!tt(this.extent_, t.getExtent())) {
+      if (this.strokeState_ || this.fillState_) {
+        this.fillState_ && this.setContextFillState_(this.fillState_), this.strokeState_ && this.setContextStrokeState_(this.strokeState_);
+        const e = this.context_;
+        e.beginPath(), this.drawRings_(
+          t.getOrientedFlatCoordinates(),
+          0,
+          /** @type {Array<number>} */
+          t.getEnds(),
+          t.getStride()
+        ), this.fillState_ && e.fill(), this.strokeState_ && e.stroke();
+      }
+      if (this.text_ !== "") {
+        const e = t.getFlatInteriorPoint();
+        this.drawText_(e, 0, 2, 2);
+      }
+    }
+  }
+  /**
+   * Render MultiPolygon geometry into the canvas.  Rendering is immediate and
+   * uses the current style.
+   * @param {import("../../geom/MultiPolygon.js").default} geometry MultiPolygon geometry.
+   */
+  drawMultiPolygon(t) {
+    if (this.squaredTolerance_ && (t = /** @type {import("../../geom/MultiPolygon.js").default} */
+    t.simplifyTransformed(
+      this.squaredTolerance_,
+      this.userTransform_
+    )), !!tt(this.extent_, t.getExtent())) {
+      if (this.strokeState_ || this.fillState_) {
+        this.fillState_ && this.setContextFillState_(this.fillState_), this.strokeState_ && this.setContextStrokeState_(this.strokeState_);
+        const e = this.context_, i = t.getOrientedFlatCoordinates();
+        let n = 0;
+        const s = t.getEndss(), o = t.getStride();
+        e.beginPath();
+        for (let r = 0, l = s.length; r < l; ++r) {
+          const a = s[r];
+          n = this.drawRings_(i, n, a, o);
+        }
+        this.fillState_ && e.fill(), this.strokeState_ && e.stroke();
+      }
+      if (this.text_ !== "") {
+        const e = t.getFlatInteriorPoints();
+        this.drawText_(e, 0, e.length, 2);
+      }
+    }
+  }
+  /**
+   * @param {import("../canvas.js").FillState} fillState Fill state.
+   * @private
+   */
+  setContextFillState_(t) {
+    const e = this.context_, i = this.contextFillState_;
+    i ? i.fillStyle != t.fillStyle && (i.fillStyle = t.fillStyle, e.fillStyle = t.fillStyle) : (e.fillStyle = t.fillStyle, this.contextFillState_ = {
+      fillStyle: t.fillStyle
+    });
+  }
+  /**
+   * @param {import("../canvas.js").StrokeState} strokeState Stroke state.
+   * @private
+   */
+  setContextStrokeState_(t) {
+    const e = this.context_, i = this.contextStrokeState_;
+    i ? (i.lineCap != t.lineCap && (i.lineCap = t.lineCap, e.lineCap = t.lineCap), Rt(i.lineDash, t.lineDash) || e.setLineDash(
+      i.lineDash = t.lineDash
+    ), i.lineDashOffset != t.lineDashOffset && (i.lineDashOffset = t.lineDashOffset, e.lineDashOffset = t.lineDashOffset), i.lineJoin != t.lineJoin && (i.lineJoin = t.lineJoin, e.lineJoin = t.lineJoin), i.lineWidth != t.lineWidth && (i.lineWidth = t.lineWidth, e.lineWidth = t.lineWidth), i.miterLimit != t.miterLimit && (i.miterLimit = t.miterLimit, e.miterLimit = t.miterLimit), i.strokeStyle != t.strokeStyle && (i.strokeStyle = t.strokeStyle, e.strokeStyle = t.strokeStyle)) : (e.lineCap = t.lineCap, e.setLineDash(t.lineDash), e.lineDashOffset = t.lineDashOffset, e.lineJoin = t.lineJoin, e.lineWidth = t.lineWidth, e.miterLimit = t.miterLimit, e.strokeStyle = t.strokeStyle, this.contextStrokeState_ = {
+      lineCap: t.lineCap,
+      lineDash: t.lineDash,
+      lineDashOffset: t.lineDashOffset,
+      lineJoin: t.lineJoin,
+      lineWidth: t.lineWidth,
+      miterLimit: t.miterLimit,
+      strokeStyle: t.strokeStyle
+    });
+  }
+  /**
+   * @param {import("../canvas.js").TextState} textState Text state.
+   * @private
+   */
+  setContextTextState_(t) {
+    const e = this.context_, i = this.contextTextState_, n = t.textAlign ? t.textAlign : Tt;
+    i ? (i.font != t.font && (i.font = t.font, e.font = t.font), i.textAlign != n && (i.textAlign = n, e.textAlign = n), i.textBaseline != t.textBaseline && (i.textBaseline = t.textBaseline, e.textBaseline = t.textBaseline)) : (e.font = t.font, e.textAlign = n, e.textBaseline = t.textBaseline, this.contextTextState_ = {
+      font: t.font,
+      textAlign: n,
+      textBaseline: t.textBaseline
+    });
+  }
+  /**
+   * Set the fill and stroke style for subsequent draw operations.  To clear
+   * either fill or stroke styles, pass null for the appropriate parameter.
+   *
+   * @param {import("../../style/Fill.js").default} fillStyle Fill style.
+   * @param {import("../../style/Stroke.js").default} strokeStyle Stroke style.
+   */
+  setFillStrokeStyle(t, e) {
+    if (!t)
+      this.fillState_ = null;
+    else {
+      const i = t.getColor();
+      this.fillState_ = {
+        fillStyle: ot(
+          i || V
+        )
+      };
+    }
+    if (!e)
+      this.strokeState_ = null;
+    else {
+      const i = e.getColor(), n = e.getLineCap(), s = e.getLineDash(), o = e.getLineDashOffset(), r = e.getLineJoin(), l = e.getWidth(), a = e.getMiterLimit(), h = s || et;
+      this.strokeState_ = {
+        lineCap: n !== void 0 ? n : Gt,
+        lineDash: this.pixelRatio_ === 1 ? h : h.map((d) => d * this.pixelRatio_),
+        lineDashOffset: (o || it) * this.pixelRatio_,
+        lineJoin: r !== void 0 ? r : Yt,
+        lineWidth: (l !== void 0 ? l : Xt) * this.pixelRatio_,
+        miterLimit: a !== void 0 ? a : Nt,
+        strokeStyle: ot(
+          i || Bt
+        )
+      };
+    }
+  }
+  /**
+   * Set the image style for subsequent draw operations.  Pass null to remove
+   * the image style.
+   *
+   * @param {import("../../style/Image.js").default} imageStyle Image style.
+   */
+  setImageStyle(t) {
+    let e;
+    if (!t || !(e = t.getSize())) {
+      this.image_ = null;
+      return;
+    }
+    const i = t.getPixelRatio(this.pixelRatio_), n = t.getAnchor(), s = t.getOrigin();
+    this.image_ = t.getImage(this.pixelRatio_), this.imageAnchorX_ = n[0] * i, this.imageAnchorY_ = n[1] * i, this.imageHeight_ = e[1] * i, this.imageOpacity_ = t.getOpacity(), this.imageOriginX_ = s[0], this.imageOriginY_ = s[1], this.imageRotateWithView_ = t.getRotateWithView(), this.imageRotation_ = t.getRotation();
+    const o = t.getScaleArray();
+    this.imageScale_ = [
+      o[0] * this.pixelRatio_ / i,
+      o[1] * this.pixelRatio_ / i
+    ], this.imageWidth_ = e[0] * i;
+  }
+  /**
+   * Set the text style for subsequent draw operations.  Pass null to
+   * remove the text style.
+   *
+   * @param {import("../../style/Text.js").default} textStyle Text style.
+   */
+  setTextStyle(t) {
+    if (!t)
+      this.text_ = "";
+    else {
+      const e = t.getFill();
+      if (!e)
+        this.textFillState_ = null;
+      else {
+        const f = e.getColor();
+        this.textFillState_ = {
+          fillStyle: ot(
+            f || V
+          )
+        };
+      }
+      const i = t.getStroke();
+      if (!i)
+        this.textStrokeState_ = null;
+      else {
+        const f = i.getColor(), u = i.getLineCap(), _ = i.getLineDash(), p = i.getLineDashOffset(), x = i.getLineJoin(), y = i.getWidth(), m = i.getMiterLimit();
+        this.textStrokeState_ = {
+          lineCap: u !== void 0 ? u : Gt,
+          lineDash: _ || et,
+          lineDashOffset: p || it,
+          lineJoin: x !== void 0 ? x : Yt,
+          lineWidth: y !== void 0 ? y : Xt,
+          miterLimit: m !== void 0 ? m : Nt,
+          strokeStyle: ot(
+            f || Bt
+          )
+        };
+      }
+      const n = t.getFont(), s = t.getOffsetX(), o = t.getOffsetY(), r = t.getRotateWithView(), l = t.getRotation(), a = t.getScaleArray(), h = t.getText(), d = t.getTextAlign(), c = t.getTextBaseline();
+      this.textState_ = {
+        font: n !== void 0 ? n : Fe,
+        textAlign: d !== void 0 ? d : Tt,
+        textBaseline: c !== void 0 ? c : Ht
+      }, this.text_ = h !== void 0 ? Array.isArray(h) ? h.reduce((f, u, _) => f += _ % 2 ? " " : u, "") : h : "", this.textOffsetX_ = s !== void 0 ? this.pixelRatio_ * s : 0, this.textOffsetY_ = o !== void 0 ? this.pixelRatio_ * o : 0, this.textRotateWithView_ = r !== void 0 ? r : !1, this.textRotation_ = l !== void 0 ? l : 0, this.textScale_ = [
+        this.pixelRatio_ * a[0],
+        this.pixelRatio_ * a[1]
+      ];
+    }
+  }
+}
+const z = 0.5;
+function Yi(g, t, e, i, n, s, o) {
+  const r = g[0] * z, l = g[1] * z, a = gt(r, l);
+  a.imageSmoothingEnabled = !1;
+  const h = a.canvas, d = new Gi(
+    a,
+    z,
+    n,
+    null,
+    o
+  ), c = e.length, f = Math.floor((256 * 256 * 256 - 1) / c), u = {};
+  for (let p = 1; p <= c; ++p) {
+    const x = e[p - 1], y = x.getStyleFunction() || i;
+    if (!y)
+      continue;
+    let m = y(x, s);
+    if (!m)
+      continue;
+    Array.isArray(m) || (m = [m]);
+    const T = (p * f).toString(16).padStart(7, "#00000");
+    for (let L = 0, O = m.length; L < O; ++L) {
+      const k = m[L], D = k.getGeometryFunction()(x);
+      if (!D || !tt(n, D.getExtent()))
+        continue;
+      const b = k.clone(), P = b.getFill();
+      P && P.setColor(T);
+      const W = b.getStroke();
+      W && (W.setColor(T), W.setLineDash(null)), b.setText(void 0);
+      const F = k.getImage();
+      if (F) {
+        const w = F.getImageSize();
+        if (!w)
+          continue;
+        const M = gt(
+          w[0],
+          w[1],
+          void 0,
+          { alpha: !1 }
+        ), v = M.canvas;
+        M.fillStyle = T, M.fillRect(0, 0, v.width, v.height), b.setImage(
+          new Ti({
+            img: v,
+            imgSize: w,
+            anchor: F.getAnchor(),
+            anchorXUnits: "pixels",
+            anchorYUnits: "pixels",
+            offset: F.getOrigin(),
+            opacity: 1,
+            size: F.getSize(),
+            scale: F.getScale(),
+            rotation: F.getRotation(),
+            rotateWithView: F.getRotateWithView()
+          })
+        );
+      }
+      const Y = b.getZIndex() || 0;
+      let R = u[Y];
+      R || (R = {}, u[Y] = R, R.Polygon = [], R.Circle = [], R.LineString = [], R.Point = []);
+      const E = D.getType();
+      if (E === "GeometryCollection") {
+        const w = (
+          /** @type {import("../../geom/GeometryCollection.js").default} */
+          D.getGeometriesArrayRecursive()
+        );
+        for (let M = 0, v = w.length; M < v; ++M) {
+          const A = w[M];
+          R[A.getType().replace("Multi", "")].push(
+            A,
+            b
+          );
+        }
+      } else
+        R[E.replace("Multi", "")].push(D, b);
+    }
+  }
+  const _ = Object.keys(u).map(Number).sort(ie);
+  for (let p = 0, x = _.length; p < x; ++p) {
+    const y = u[_[p]];
+    for (const m in y) {
+      const C = y[m];
+      for (let T = 0, L = C.length; T < L; T += 2) {
+        d.setStyle(C[T + 1]);
+        for (let O = 0, k = t.length; O < k; ++O)
+          d.setTransform(t[O]), d.drawGeometry(C[T]);
+      }
+    }
+  }
+  return a.getImageData(0, 0, h.width, h.height);
+}
+function Xi(g, t, e) {
+  const i = [];
+  if (e) {
+    const n = Math.floor(Math.round(g[0]) * z), s = Math.floor(Math.round(g[1]) * z), o = (Re(n, 0, e.width - 1) + Re(s, 0, e.height - 1) * e.width) * 4, r = e.data[o], l = e.data[o + 1], h = e.data[o + 2] + 256 * (l + 256 * r), d = Math.floor((256 * 256 * 256 - 1) / t.length);
+    h && h % d === 0 && i.push(t[h / d - 1]);
+  }
+  return i;
+}
+const Ni = 0.5, Pe = {
+  Point: Ui,
+  LineString: Ki,
+  Polygon: Qi,
+  MultiPoint: $i,
+  MultiLineString: zi,
+  MultiPolygon: qi,
+  GeometryCollection: ji,
+  Circle: Vi
+};
+function Hi(g, t) {
+  return parseInt(It(g), 10) - parseInt(It(t), 10);
+}
+function Ji(g, t) {
+  const e = ne(g, t);
+  return e * e;
+}
+function ne(g, t) {
+  return Ni * g / t;
+}
+function Vi(g, t, e, i, n) {
+  const s = e.getFill(), o = e.getStroke();
+  if (s || o) {
+    const l = g.getBuilder(e.getZIndex(), "Circle");
+    l.setFillStrokeStyle(s, o), l.drawCircle(t, i);
+  }
+  const r = e.getText();
+  if (r && r.getText()) {
+    const l = (n || g).getBuilder(
+      e.getZIndex(),
+      "Text"
+    );
+    l.setTextStyle(r), l.drawText(t, i);
+  }
+}
+function Me(g, t, e, i, n, s, o) {
+  let r = !1;
+  const l = e.getImage();
+  if (l) {
+    const a = l.getImageState();
+    a == Ct.LOADED || a == Ct.ERROR ? l.unlistenImageChange(n) : (a == Ct.IDLE && l.load(), l.listenImageChange(n), r = !0);
+  }
+  return Zi(
+    g,
+    t,
+    e,
+    i,
+    s,
+    o
+  ), r;
+}
+function Zi(g, t, e, i, n, s) {
+  const o = e.getGeometryFunction()(t);
+  if (!o)
+    return;
+  const r = o.simplifyTransformed(
+    i,
+    n
+  );
+  if (e.getRenderer())
+    ve(g, r, e, t);
+  else {
+    const a = Pe[r.getType()];
+    a(
+      g,
+      r,
+      e,
+      t,
+      s
+    );
+  }
+}
+function ve(g, t, e, i) {
+  if (t.getType() == "GeometryCollection") {
+    const s = (
+      /** @type {import("../geom/GeometryCollection.js").default} */
+      t.getGeometries()
+    );
+    for (let o = 0, r = s.length; o < r; ++o)
+      ve(g, s[o], e, i);
+    return;
+  }
+  g.getBuilder(e.getZIndex(), "Default").drawCustom(
+    /** @type {import("../geom/SimpleGeometry.js").default} */
+    t,
+    i,
+    e.getRenderer(),
+    e.getHitDetectionRenderer()
+  );
+}
+function ji(g, t, e, i, n) {
+  const s = t.getGeometriesArray();
+  let o, r;
+  for (o = 0, r = s.length; o < r; ++o) {
+    const l = Pe[s[o].getType()];
+    l(
+      g,
+      s[o],
+      e,
+      i,
+      n
+    );
+  }
+}
+function Ki(g, t, e, i, n) {
+  const s = e.getStroke();
+  if (s) {
+    const r = g.getBuilder(
+      e.getZIndex(),
+      "LineString"
+    );
+    r.setFillStrokeStyle(null, s), r.drawLineString(t, i);
+  }
+  const o = e.getText();
+  if (o && o.getText()) {
+    const r = (n || g).getBuilder(
+      e.getZIndex(),
+      "Text"
+    );
+    r.setTextStyle(o), r.drawText(t, i);
+  }
+}
+function zi(g, t, e, i, n) {
+  const s = e.getStroke();
+  if (s) {
+    const r = g.getBuilder(
+      e.getZIndex(),
+      "LineString"
+    );
+    r.setFillStrokeStyle(null, s), r.drawMultiLineString(t, i);
+  }
+  const o = e.getText();
+  if (o && o.getText()) {
+    const r = (n || g).getBuilder(
+      e.getZIndex(),
+      "Text"
+    );
+    r.setTextStyle(o), r.drawText(t, i);
+  }
+}
+function qi(g, t, e, i, n) {
+  const s = e.getFill(), o = e.getStroke();
+  if (o || s) {
+    const l = g.getBuilder(e.getZIndex(), "Polygon");
+    l.setFillStrokeStyle(s, o), l.drawMultiPolygon(t, i);
+  }
+  const r = e.getText();
+  if (r && r.getText()) {
+    const l = (n || g).getBuilder(
+      e.getZIndex(),
+      "Text"
+    );
+    l.setTextStyle(r), l.drawText(t, i);
+  }
+}
+function Ui(g, t, e, i, n) {
+  const s = e.getImage(), o = e.getText();
+  let r;
+  if (s) {
+    if (s.getImageState() != Ct.LOADED)
+      return;
+    let l = g;
+    if (n) {
+      const h = s.getDeclutterMode();
+      if (h !== "none")
+        if (l = n, h === "obstacle") {
+          const d = g.getBuilder(
+            e.getZIndex(),
+            "Image"
+          );
+          d.setImageStyle(s, r), d.drawPoint(t, i);
+        } else o && o.getText() && (r = {});
+    }
+    const a = l.getBuilder(
+      e.getZIndex(),
+      "Image"
+    );
+    a.setImageStyle(s, r), a.drawPoint(t, i);
+  }
+  if (o && o.getText()) {
+    let l = g;
+    n && (l = n);
+    const a = l.getBuilder(e.getZIndex(), "Text");
+    a.setTextStyle(o, r), a.drawText(t, i);
+  }
+}
+function $i(g, t, e, i, n) {
+  const s = e.getImage(), o = e.getText();
+  let r;
+  if (s) {
+    if (s.getImageState() != Ct.LOADED)
+      return;
+    let l = g;
+    if (n) {
+      const h = s.getDeclutterMode();
+      if (h !== "none")
+        if (l = n, h === "obstacle") {
+          const d = g.getBuilder(
+            e.getZIndex(),
+            "Image"
+          );
+          d.setImageStyle(s, r), d.drawMultiPoint(t, i);
+        } else o && o.getText() && (r = {});
+    }
+    const a = l.getBuilder(
+      e.getZIndex(),
+      "Image"
+    );
+    a.setImageStyle(s, r), a.drawMultiPoint(t, i);
+  }
+  if (o && o.getText()) {
+    let l = g;
+    n && (l = n);
+    const a = l.getBuilder(e.getZIndex(), "Text");
+    a.setTextStyle(o, r), a.drawText(t, i);
+  }
+}
+function Qi(g, t, e, i, n) {
+  const s = e.getFill(), o = e.getStroke();
+  if (s || o) {
+    const l = g.getBuilder(e.getZIndex(), "Polygon");
+    l.setFillStrokeStyle(s, o), l.drawPolygon(t, i);
+  }
+  const r = e.getText();
+  if (r && r.getText()) {
+    const l = (n || g).getBuilder(
+      e.getZIndex(),
+      "Text"
+    );
+    l.setTextStyle(r), l.drawText(t, i);
+  }
+}
+class tn extends Li {
+  /**
+   * @param {import("../../layer/BaseVector.js").default} vectorLayer Vector layer.
+   */
+  constructor(t) {
+    super(t), this.boundHandleStyleImageChange_ = this.handleStyleImageChange_.bind(this), this.animatingOrInteracting_, this.hitDetectionImageData_ = null, this.renderedFeatures_ = null, this.renderedRevision_ = -1, this.renderedResolution_ = NaN, this.renderedExtent_ = At(), this.wrappedRenderedExtent_ = At(), this.renderedRotation_, this.renderedCenter_ = null, this.renderedProjection_ = null, this.renderedRenderOrder_ = null, this.replayGroup_ = null, this.replayGroupChanged = !0, this.declutterExecutorGroup = null, this.clipping = !0, this.compositionContext_ = null, this.opacity_ = 1;
+  }
+  /**
+   * @param {ExecutorGroup} executorGroup Executor group.
+   * @param {import("../../Map.js").FrameState} frameState Frame state.
+   * @param {import("rbush").default} [declutterTree] Declutter tree.
+   */
+  renderWorlds(t, e, i) {
+    const n = e.extent, s = e.viewState, o = s.center, r = s.resolution, l = s.projection, a = s.rotation, h = l.getExtent(), d = this.getLayer().getSource(), c = e.pixelRatio, f = e.viewHints, u = !(f[Mt.ANIMATING] || f[Mt.INTERACTING]), _ = this.compositionContext_, p = Math.round(e.size[0] * c), x = Math.round(e.size[1] * c), y = d.getWrapX() && l.canWrapX(), m = y ? Ft(h) : null, C = y ? Math.ceil((n[2] - h[2]) / m) + 1 : 1;
+    let T = y ? Math.floor((n[0] - h[0]) / m) : 0;
+    do {
+      const L = this.getRenderTransform(
+        o,
+        r,
+        a,
+        c,
+        p,
+        x,
+        T * m
+      );
+      t.execute(
+        _,
+        1,
+        L,
+        a,
+        u,
+        void 0,
+        i
+      );
+    } while (++T < C);
+  }
+  setupCompositionContext_() {
+    if (this.opacity_ !== 1) {
+      const t = gt(
+        this.context.canvas.width,
+        this.context.canvas.height,
+        ke
+      );
+      this.compositionContext_ = t;
+    } else
+      this.compositionContext_ = this.context;
+  }
+  releaseCompositionContext_() {
+    if (this.opacity_ !== 1) {
+      const t = this.context.globalAlpha;
+      this.context.globalAlpha = this.opacity_, this.context.drawImage(this.compositionContext_.canvas, 0, 0), this.context.globalAlpha = t, Ii(this.compositionContext_), ke.push(this.compositionContext_.canvas), this.compositionContext_ = null;
+    }
+  }
+  /**
+   * Render declutter items for this layer
+   * @param {import("../../Map.js").FrameState} frameState Frame state.
+   */
+  renderDeclutter(t) {
+    this.declutterExecutorGroup && (this.setupCompositionContext_(), this.renderWorlds(
+      this.declutterExecutorGroup,
+      t,
+      t.declutterTree
+    ), this.releaseCompositionContext_());
+  }
+  /**
+   * Render the layer.
+   * @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(t, e) {
+    const i = t.pixelRatio, n = t.layerStatesArray[t.layerIndex];
+    fi(this.pixelTransform, 1 / i, 1 / i), ui(this.inversePixelTransform, this.pixelTransform);
+    const s = gi(this.pixelTransform);
+    this.useContainer(e, s, this.getBackground(t));
+    const o = this.context, r = o.canvas, l = this.replayGroup_, a = this.declutterExecutorGroup;
+    let h = l && !l.isEmpty() || a && !a.isEmpty();
+    if (!h && !(this.getLayer().hasListener(vt.PRERENDER) || this.getLayer().hasListener(vt.POSTRENDER)))
+      return null;
+    const d = Math.round(t.size[0] * i), c = Math.round(t.size[1] * i);
+    r.width != d || r.height != c ? (r.width = d, r.height = c, r.style.transform !== s && (r.style.transform = s)) : this.containerReused || o.clearRect(0, 0, d, c), this.preRender(o, t);
+    const f = t.viewState;
+    f.projection, this.opacity_ = n.opacity, this.setupCompositionContext_();
+    let u = !1;
+    if (h && n.extent && this.clipping) {
+      const _ = _i(n.extent);
+      h = tt(_, t.extent), u = h && !Wt(_, t.extent), u && this.clipUnrotated(this.compositionContext_, t, _);
+    }
+    return h && this.renderWorlds(l, t), u && this.compositionContext_.restore(), this.releaseCompositionContext_(), this.postRender(o, t), this.renderedRotation_ !== f.rotation && (this.renderedRotation_ = f.rotation, this.hitDetectionImageData_ = null), this.container;
+  }
+  /**
+   * Asynchronous layer level hit detection.
+   * @param {import("../../pixel.js").Pixel} pixel Pixel.
+   * @return {Promise<Array<import("../../Feature").default>>} Promise
+   * that resolves with an array of features.
+   */
+  getFeatures(t) {
+    return new Promise((e) => {
+      if (!this.hitDetectionImageData_ && !this.animatingOrInteracting_) {
+        const i = [this.context.canvas.width, this.context.canvas.height];
+        G(this.pixelTransform, i);
+        const n = this.renderedCenter_, s = this.renderedResolution_, o = this.renderedRotation_, r = this.renderedProjection_, l = this.wrappedRenderedExtent_, a = this.getLayer(), h = [], d = i[0] * z, c = i[1] * z;
+        h.push(
+          this.getRenderTransform(
+            n,
+            s,
+            o,
+            z,
+            d,
+            c,
+            0
+          ).slice()
+        );
+        const f = a.getSource(), u = r.getExtent();
+        if (f.getWrapX() && r.canWrapX() && !Wt(u, l)) {
+          let _ = l[0];
+          const p = Ft(u);
+          let x = 0, y;
+          for (; _ < u[0]; )
+            --x, y = p * x, h.push(
+              this.getRenderTransform(
+                n,
+                s,
+                o,
+                z,
+                d,
+                c,
+                y
+              ).slice()
+            ), _ += p;
+          for (x = 0, _ = l[2]; _ > u[2]; )
+            ++x, y = p * x, h.push(
+              this.getRenderTransform(
+                n,
+                s,
+                o,
+                z,
+                d,
+                c,
+                y
+              ).slice()
+            ), _ -= p;
+        }
+        this.hitDetectionImageData_ = Yi(
+          i,
+          h,
+          this.renderedFeatures_,
+          a.getStyleFunction(),
+          l,
+          s,
+          o
+        );
+      }
+      e(
+        Xi(t, this.renderedFeatures_, this.hitDetectionImageData_)
+      );
+    });
+  }
+  /**
+   * @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(t, e, i, n, s) {
+    if (!this.replayGroup_)
+      return;
+    const o = e.viewState.resolution, r = e.viewState.rotation, l = this.getLayer(), a = {}, h = function(f, u, _) {
+      const p = It(f), x = a[p];
+      if (x) {
+        if (x !== !0 && _ < x.distanceSq) {
+          if (_ === 0)
+            return a[p] = !0, s.splice(s.lastIndexOf(x), 1), n(f, l, u);
+          x.geometry = u, x.distanceSq = _;
+        }
+      } else {
+        if (_ === 0)
+          return a[p] = !0, n(f, l, u);
+        s.push(
+          a[p] = {
+            feature: f,
+            layer: l,
+            geometry: u,
+            distanceSq: _,
+            callback: n
+          }
+        );
+      }
+    };
+    let d;
+    const c = [this.replayGroup_];
+    return this.declutterExecutorGroup && c.push(this.declutterExecutorGroup), c.some((f) => d = f.forEachFeatureAtCoordinate(
+      t,
+      o,
+      r,
+      i,
+      h,
+      f === this.declutterExecutorGroup && e.declutterTree ? e.declutterTree.all().map((u) => u.value) : null
+    )), d;
+  }
+  /**
+   * Perform action necessary to get the layer rendered after new fonts have loaded
+   */
+  handleFontsChanged() {
+    const t = this.getLayer();
+    t.getVisible() && this.replayGroup_ && t.changed();
+  }
+  /**
+   * Handle changes in image style state.
+   * @param {import("../../events/Event.js").default} event Image style change event.
+   * @private
+   */
+  handleStyleImageChange_(t) {
+    this.renderIfReadyAndVisible();
+  }
+  /**
+   * Determine whether render should be called.
+   * @param {import("../../Map.js").FrameState} frameState Frame state.
+   * @return {boolean} Layer is ready to be rendered.
+   */
+  prepareFrame(t) {
+    const e = this.getLayer(), i = e.getSource();
+    if (!i)
+      return !1;
+    const n = t.viewHints[Mt.ANIMATING], s = t.viewHints[Mt.INTERACTING], o = e.getUpdateWhileAnimating(), r = e.getUpdateWhileInteracting();
+    if (this.ready && !o && n || !r && s)
+      return this.animatingOrInteracting_ = !0, !0;
+    this.animatingOrInteracting_ = !1;
+    const l = t.extent, a = t.viewState, h = a.projection, d = a.resolution, c = t.pixelRatio, f = e.getRevision(), u = e.getRenderBuffer();
+    let _ = e.getRenderOrder();
+    _ === void 0 && (_ = Hi);
+    const p = a.center.slice(), x = se(
+      l,
+      u * d
+    ), y = x.slice(), m = [x.slice()], C = h.getExtent();
+    if (i.getWrapX() && h.canWrapX() && !Wt(C, t.extent)) {
+      const R = Ft(C), E = Math.max(Ft(x) / 2, R);
+      x[0] = C[0] - E, x[2] = C[2] + E, xi(p, h);
+      const w = pi(m[0], h);
+      w[0] < C[0] && w[2] < C[2] ? m.push([
+        w[0] + R,
+        w[1],
+        w[2] + R,
+        w[3]
+      ]) : w[0] > C[0] && w[2] > C[2] && m.push([
+        w[0] - R,
+        w[1],
+        w[2] - R,
+        w[3]
+      ]);
+    }
+    if (this.ready && this.renderedResolution_ == d && this.renderedRevision_ == f && this.renderedRenderOrder_ == _ && Wt(this.wrappedRenderedExtent_, x))
+      return Rt(this.renderedExtent_, y) || (this.hitDetectionImageData_ = null, this.renderedExtent_ = y), this.renderedCenter_ = p, this.replayGroupChanged = !1, !0;
+    this.replayGroup_ = null;
+    const T = new Le(
+      ne(d, c),
+      x,
+      d,
+      c
+    );
+    let L;
+    this.getLayer().getDeclutter() && (L = new Le(
+      ne(d, c),
+      x,
+      d,
+      c
+    ));
+    let O;
+    for (let R = 0, E = m.length; R < E; ++R)
+      i.loadFeatures(m[R], d, h);
+    const k = Ji(d, c);
+    let D = !0;
+    const b = (
+      /**
+       * @param {import("../../Feature.js").default} feature Feature.
+       */
+      (R) => {
+        let E;
+        const w = R.getStyleFunction() || e.getStyleFunction();
+        if (w && (E = w(R, d)), E) {
+          const M = this.renderFeature(
+            R,
+            k,
+            E,
+            T,
+            O,
+            L
+          );
+          D = D && !M;
+        }
+      }
+    ), P = Si(x), W = i.getFeaturesInExtent(P);
+    _ && W.sort(_);
+    for (let R = 0, E = W.length; R < E; ++R)
+      b(W[R]);
+    this.renderedFeatures_ = W, this.ready = D;
+    const F = T.finish(), Y = new be(
+      x,
+      d,
+      c,
+      i.getOverlaps(),
+      F,
+      e.getRenderBuffer()
+    );
+    return L && (this.declutterExecutorGroup = new be(
+      x,
+      d,
+      c,
+      i.getOverlaps(),
+      L.finish(),
+      e.getRenderBuffer()
+    )), this.renderedResolution_ = d, this.renderedRevision_ = f, this.renderedRenderOrder_ = _, this.renderedExtent_ = y, this.wrappedRenderedExtent_ = x, this.renderedCenter_ = p, this.renderedProjection_ = h, this.replayGroup_ = Y, this.hitDetectionImageData_ = null, this.replayGroupChanged = !0, !0;
+  }
+  /**
+   * @param {import("../../Feature.js").default} feature Feature.
+   * @param {number} squaredTolerance Squared render tolerance.
+   * @param {import("../../style/Style.js").default|Array<import("../../style/Style.js").default>} styles The style or array of styles.
+   * @param {import("../../render/canvas/BuilderGroup.js").default} builderGroup Builder group.
+   * @param {import("../../proj.js").TransformFunction} [transform] Transform from user to view projection.
+   * @param {import("../../render/canvas/BuilderGroup.js").default} [declutterBuilderGroup] Builder for decluttering.
+   * @return {boolean} `true` if an image is loading.
+   */
+  renderFeature(t, e, i, n, s, o) {
+    if (!i)
+      return !1;
+    let r = !1;
+    if (Array.isArray(i))
+      for (let l = 0, a = i.length; l < a; ++l)
+        r = Me(
+          n,
+          t,
+          i[l],
+          e,
+          this.boundHandleStyleImageChange_,
+          s,
+          o
+        ) || r;
+    else
+      r = Me(
+        n,
+        t,
+        i,
+        e,
+        this.boundHandleStyleImageChange_,
+        s,
+        o
+      );
+    return r;
+  }
+}
+class rn extends $e {
+  /**
+   * @param {import("./BaseVector.js").Options<VectorSourceType>} [options] Options.
+   */
+  constructor(t) {
+    super(t);
+  }
+  createRenderer() {
+    return new tn(this);
+  }
+}
+export {
+  Li as C,
+  rn as V
+};