gisviewer-vue3-arcgis 1.0.281 → 1.0.282

package/es/node_modules/.pnpm/ol@10.7.0/node_modules/ol/render/canvas/Executor.mjs

@@ -0,0 +1,700 @@
+import { equals as Kt } from "../../array.mjs";
+import { createOrUpdate as Dt, intersects as te, createEmpty as ee } from "../../extent.mjs";
+import { lineStringLength as ie } from "../../geom/flat/length.mjs";
+import { drawTextOnPath as se } from "../../geom/flat/textpath.mjs";
+import { transform2D as ae } from "../../geom/flat/transform.mjs";
+import { create as vt, compose as le, apply as ot, setFromArray as oe } from "../../transform.mjs";
+import ne from "./ZIndexContext.mjs";
+import { defaultTextAlign as Yt, getTextDimensions as re, drawImageOrLabel as he, defaultTextBaseline as ce, measureAndCacheTextWidth as Bt, defaultPadding as St } from "../canvas.mjs";
+import k from "./Instruction.mjs";
+import { TEXT_ALIGN as yt } from "./TextBuilder.mjs";
+const tt = ee(), j = [], J = [], U = [], q = [];
+function Pt(A) {
+  return A[3].declutterBox;
+}
+const Xt = new RegExp(
+  /* eslint-disable prettier/prettier */
+  "[" + String.fromCharCode(1425) + "-" + String.fromCharCode(2303) + String.fromCharCode(64285) + "-" + String.fromCharCode(65023) + String.fromCharCode(65136) + "-" + String.fromCharCode(65276) + String.fromCharCode(67584) + "-" + String.fromCharCode(69631) + String.fromCharCode(124928) + "-" + String.fromCharCode(126975) + "]"
+  /* eslint-enable prettier/prettier */
+);
+function bt(A, t) {
+  return t === "start" ? t = Xt.test(A) ? "right" : "left" : t === "end" && (t = Xt.test(A) ? "left" : "right"), yt[t];
+}
+function fe(A, t, s) {
+  return s > 0 && A.push(`
+`, ""), A.push(t, ""), A;
+}
+function de(A, t, s) {
+  return s % 2 === 0 && (A += t), A;
+}
+class pe {
+  /**
+   * @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.
+   * @param {boolean} [deferredRendering] Enable deferred rendering.
+   */
+  constructor(t, s, n, i, c) {
+    this.overlaps = n, this.pixelRatio = s, this.resolution = t, this.alignAndScaleFill_, this.instructions = i.instructions, this.coordinates = i.coordinates, this.coordinateCache_ = {}, this.renderedTransform_ = vt(), this.hitDetectionInstructions = i.hitDetectionInstructions, this.pixelCoordinates_ = null, this.viewRotation_ = 0, this.fillStates = i.fillStates || {}, this.strokeStates = i.strokeStates || {}, this.textStates = i.textStates || {}, this.widths_ = {}, this.labels_ = {}, this.zIndexContext_ = c ? new ne() : null;
+  }
+  /**
+   * @return {ZIndexContext} ZIndex context.
+   */
+  getZIndexContext() {
+    return this.zIndexContext_;
+  }
+  /**
+   * @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, s, n, i) {
+    const c = t + s + n + i;
+    if (this.labels_[c])
+      return this.labels_[c];
+    const r = i ? this.strokeStates[i] : null, u = n ? this.fillStates[n] : null, h = this.textStates[s], g = this.pixelRatio, a = [
+      h.scale[0] * g,
+      h.scale[1] * g
+    ], l = h.justify ? yt[h.justify] : bt(
+      Array.isArray(t) ? t[0] : t,
+      h.textAlign || Yt
+    ), b = i && r.lineWidth ? r.lineWidth : 0, o = Array.isArray(t) ? t : String(t).split(`
+`).reduce(fe, []), { width: m, height: T, widths: C, heights: x, lineWidths: O } = re(
+      h,
+      o
+    ), E = m + b, d = [], W = (E + 2) * a[0], S = (T + b) * a[1], p = {
+      width: W < 0 ? Math.floor(W) : Math.ceil(W),
+      height: S < 0 ? Math.floor(S) : Math.ceil(S),
+      contextInstructions: d
+    };
+    (a[0] != 1 || a[1] != 1) && d.push("scale", a), i && (d.push("strokeStyle", r.strokeStyle), d.push("lineWidth", b), d.push("lineCap", r.lineCap), d.push("lineJoin", r.lineJoin), d.push("miterLimit", r.miterLimit), d.push("setLineDash", [r.lineDash]), d.push("lineDashOffset", r.lineDashOffset)), n && d.push("fillStyle", u.fillStyle), d.push("textBaseline", "middle"), d.push("textAlign", "center");
+    const _ = 0.5 - l;
+    let y = l * E + _ * b;
+    const P = [], D = [];
+    let w = 0, Z = 0, X = 0, $ = 0, Q;
+    for (let F = 0, Y = o.length; F < Y; F += 2) {
+      const N = o[F];
+      if (N === `
+`) {
+        Z += w, w = 0, y = l * E + _ * b, ++$;
+        continue;
+      }
+      const v = o[F + 1] || h.font;
+      v !== Q && (i && P.push("font", v), n && D.push("font", v), Q = v), w = Math.max(w, x[X]);
+      const K = [
+        N,
+        y + _ * C[X] + l * (C[X] - O[$]),
+        0.5 * (b + w) + Z
+      ];
+      y += C[X], i && P.push("strokeText", K), n && D.push("fillText", K), ++X;
+    }
+    return Array.prototype.push.apply(d, P), Array.prototype.push.apply(d, D), this.labels_[c] = p, p;
+  }
+  /**
+   * @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, s, n, i, c, r, u) {
+    t.beginPath(), t.moveTo.apply(t, s), t.lineTo.apply(t, n), t.lineTo.apply(t, i), t.lineTo.apply(t, c), t.lineTo.apply(t, s), r && (this.alignAndScaleFill_ = /** @type {number} */
+    r[2], t.fillStyle = /** @type {string} */
+    r[1], this.fill_(t)), u && (this.setStrokeStyle_(
+      t,
+      /** @type {Array<*>} */
+      u
+    ), 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, s, n, i, c, r, u, h, g, a, l, b, o, m, T, C) {
+    u *= b[0], h *= b[1];
+    let x = n - u, O = i - h;
+    const E = c + g > t ? t - g : c, d = r + a > s ? s - a : r, W = m[3] + E * b[0] + m[1], S = m[0] + d * b[1] + m[2], p = x - m[3], _ = O - m[0];
+    (T || l !== 0) && (j[0] = p, q[0] = p, j[1] = _, J[1] = _, J[0] = p + W, U[0] = J[0], U[1] = _ + S, q[1] = U[1]);
+    let y;
+    return l !== 0 ? (y = le(
+      vt(),
+      n,
+      i,
+      1,
+      1,
+      l,
+      -n,
+      -i
+    ), ot(y, j), ot(y, J), ot(y, U), ot(y, q), Dt(
+      Math.min(j[0], J[0], U[0], q[0]),
+      Math.min(j[1], J[1], U[1], q[1]),
+      Math.max(j[0], J[0], U[0], q[0]),
+      Math.max(j[1], J[1], U[1], q[1]),
+      tt
+    )) : Dt(
+      Math.min(p, p + W),
+      Math.min(_, _ + S),
+      Math.max(p, p + W),
+      Math.max(_, _ + S),
+      tt
+    ), o && (x = Math.round(x), O = Math.round(O)), {
+      drawImageX: x,
+      drawImageY: O,
+      drawImageW: E,
+      drawImageH: d,
+      originX: g,
+      originY: a,
+      declutterBox: {
+        minX: tt[0],
+        minY: tt[1],
+        maxX: tt[2],
+        maxY: tt[3],
+        value: C
+      },
+      canvasTransform: y,
+      scale: b
+    };
+  }
+  /**
+   * @private
+   * @param {CanvasRenderingContext2D} context Context.
+   * @param {import('../../size.js').Size} scaledCanvasSize Scaled canvas size.
+   * @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, s, n, i, c, r, u) {
+    const h = !!(r || u), g = i.declutterBox, a = u ? u[2] * i.scale[0] / 2 : 0;
+    return g.minX - a <= s[0] && g.maxX + a >= 0 && g.minY - a <= s[1] && g.maxY + a >= 0 && (h && this.replayTextBackground_(
+      t,
+      j,
+      J,
+      U,
+      q,
+      /** @type {Array<*>} */
+      r,
+      /** @type {Array<*>} */
+      u
+    ), he(
+      t,
+      i.canvasTransform,
+      c,
+      n,
+      i.originX,
+      i.originY,
+      i.drawImageW,
+      i.drawImageH,
+      i.drawImageX,
+      i.drawImageY,
+      i.scale
+    )), !0;
+  }
+  /**
+   * @private
+   * @param {CanvasRenderingContext2D|OffscreenCanvasRenderingContext2D} context Context.
+   */
+  fill_(t) {
+    const s = this.alignAndScaleFill_;
+    if (s) {
+      const n = ot(this.renderedTransform_, [0, 0]), i = 512 * this.pixelRatio;
+      t.save(), t.translate(n[0] % i, n[1] % i), s !== 1 && t.scale(s, s), t.rotate(this.viewRotation_);
+    }
+    t.fill(), s && t.restore();
+  }
+  /**
+   * @private
+   * @param {CanvasRenderingContext2D|OffscreenCanvasRenderingContext2D} context Context.
+   * @param {Array<*>} instruction Instruction.
+   */
+  setStrokeStyle_(t, s) {
+    t.strokeStyle = /** @type {import("../../colorlike.js").ColorLike} */
+    s[1], s[1] && (t.lineWidth = /** @type {number} */
+    s[2], t.lineCap = /** @type {CanvasLineCap} */
+    s[3], t.lineJoin = /** @type {CanvasLineJoin} */
+    s[4], t.miterLimit = /** @type {number} */
+    s[5], t.lineDashOffset = /** @type {number} */
+    s[7], t.setLineDash(
+      /** @type {Array<number>} */
+      s[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, s, n, i) {
+    const c = this.textStates[s], r = this.createLabel(t, s, i, n), u = this.strokeStates[n], h = this.pixelRatio, g = bt(
+      Array.isArray(t) ? t[0] : t,
+      c.textAlign || Yt
+    ), a = yt[c.textBaseline || ce], l = u && u.lineWidth ? u.lineWidth : 0, b = r.width / h - 2 * c.scale[0], o = g * b + 2 * (0.5 - g) * l, m = a * r.height / h + 2 * (0.5 - a) * l;
+    return {
+      label: r,
+      anchorX: o,
+      anchorY: m
+    };
+  }
+  /**
+   * @private
+   * @param {CanvasRenderingContext2D|OffscreenCanvasRenderingContext2D} context Context.
+   * @param {import('../../size.js').Size} scaledCanvasSize Scaled canvas size
+   * @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<DeclutterEntry>} [declutterTree] Declutter tree.
+   * @return {T|undefined} Callback result.
+   * @template T
+   */
+  execute_(t, s, n, i, c, r, u, h) {
+    const g = this.zIndexContext_;
+    let a;
+    this.pixelCoordinates_ && Kt(n, this.renderedTransform_) ? a = this.pixelCoordinates_ : (this.pixelCoordinates_ || (this.pixelCoordinates_ = []), a = ae(
+      this.coordinates,
+      0,
+      this.coordinates.length,
+      2,
+      n,
+      this.pixelCoordinates_
+    ), oe(this.renderedTransform_, n));
+    let l = 0;
+    const b = i.length;
+    let o = 0, m, T, C, x, O, E, d, W, S, p, _, y, P, D = 0, w = 0;
+    const Z = this.coordinateCache_, X = this.viewRotation_, $ = Math.round(Math.atan2(-n[1], n[0]) * 1e12) / 1e12, Q = (
+      /** @type {import("../../render.js").State} */
+      {
+        context: t,
+        pixelRatio: this.pixelRatio,
+        resolution: this.resolution,
+        rotation: X
+      }
+    ), F = this.instructions != i || this.overlaps ? 0 : 200;
+    let Y, N, v, K;
+    for (; l < b; ) {
+      const e = i[l];
+      switch (
+        /** @type {import("./Instruction.js").default} */
+        e[0]
+      ) {
+        case k.BEGIN_GEOMETRY:
+          Y = /** @type {import("../../Feature.js").FeatureLike} */
+          e[1], K = e[3], Y.getGeometry() ? u !== void 0 && !te(u, K.getExtent()) ? l = /** @type {number} */
+          e[2] + 1 : ++l : l = /** @type {number} */
+          e[2], g && (g.zIndex = e[4]);
+          break;
+        case k.BEGIN_PATH:
+          D > F && (this.fill_(t), D = 0), w > F && (t.stroke(), w = 0), !D && !w && (t.beginPath(), O = NaN, E = NaN), ++l;
+          break;
+        case k.CIRCLE:
+          o = /** @type {number} */
+          e[1];
+          const ct = a[o], ft = a[o + 1], Ft = a[o + 2], Nt = a[o + 3], wt = Ft - ct, It = Nt - ft, Ct = Math.sqrt(wt * wt + It * It);
+          t.moveTo(ct + Ct, ft), t.arc(ct, ft, Ct, 0, 2 * Math.PI, !0), ++l;
+          break;
+        case k.CLOSE_PATH:
+          t.closePath(), ++l;
+          break;
+        case k.CUSTOM:
+          o = /** @type {number} */
+          e[1], m = e[2];
+          const Gt = (
+            /** @type {import("../../geom/SimpleGeometry.js").default} */
+            e[3]
+          ), Ht = e[4], kt = e[5];
+          Q.geometry = Gt, Q.feature = Y, l in Z || (Z[l] = []);
+          const et = Z[l];
+          kt ? kt(a, o, m, 2, et) : (et[0] = a[o], et[1] = a[o + 1], et.length = 2), g && (g.zIndex = e[6]), Ht(et, Q), ++l;
+          break;
+        case k.DRAW_IMAGE:
+          o = /** @type {number} */
+          e[1], m = /** @type {number} */
+          e[2], S = /** @type {HTMLCanvasElement|HTMLVideoElement|HTMLImageElement} */
+          e[3], T = /** @type {number} */
+          e[4], C = /** @type {number} */
+          e[5];
+          let dt = (
+            /** @type {number} */
+            e[6]
+          );
+          const zt = (
+            /** @type {number} */
+            e[7]
+          ), Jt = (
+            /** @type {number} */
+            e[8]
+          ), Ut = (
+            /** @type {number} */
+            e[9]
+          ), At = (
+            /** @type {boolean} */
+            e[10]
+          );
+          let pt = (
+            /** @type {number} */
+            e[11]
+          );
+          const jt = (
+            /** @type {import("../../size.js").Size} */
+            e[12]
+          );
+          let nt = (
+            /** @type {number} */
+            e[13]
+          );
+          x = e[14] || "declutter";
+          const it = (
+            /** @type {{args: import("../canvas.js").DeclutterImageWithText, declutterMode: import('../../style/Style.js').DeclutterMode}} */
+            e[15]
+          );
+          if (!S && e.length >= 20) {
+            p = /** @type {string} */
+            e[19], _ = /** @type {string} */
+            e[20], y = /** @type {string} */
+            e[21], P = /** @type {string} */
+            e[22];
+            const L = this.drawLabelWithPointPlacement_(
+              p,
+              _,
+              y,
+              P
+            );
+            S = L.label, e[3] = S;
+            const V = (
+              /** @type {number} */
+              e[23]
+            );
+            T = (L.anchorX - V) * this.pixelRatio, e[4] = T;
+            const R = (
+              /** @type {number} */
+              e[24]
+            );
+            C = (L.anchorY - R) * this.pixelRatio, e[5] = C, dt = S.height, e[6] = dt, nt = S.width, e[13] = nt;
+          }
+          let ut;
+          e.length > 25 && (ut = /** @type {number} */
+          e[25]);
+          let gt, rt, ht;
+          e.length > 17 ? (gt = /** @type {Array<number>} */
+          e[16], rt = /** @type {Array<*>} */
+          e[17], ht = /** @type {Array<*>} */
+          e[18]) : (gt = St, rt = null, ht = null), At && $ ? pt += X : !At && !$ && (pt -= X);
+          let qt = 0;
+          for (; o < m; o += 2) {
+            if (ut && ut[qt++] < nt / this.pixelRatio)
+              continue;
+            const L = this.calculateImageOrLabelDimensions_(
+              S.width,
+              S.height,
+              a[o],
+              a[o + 1],
+              nt,
+              dt,
+              T,
+              C,
+              Jt,
+              Ut,
+              pt,
+              jt,
+              c,
+              gt,
+              !!rt || !!ht,
+              Y
+            ), V = [
+              t,
+              s,
+              S,
+              L,
+              zt,
+              rt,
+              ht
+            ];
+            if (h) {
+              let R, B, M;
+              if (it) {
+                const f = m - o;
+                if (!it[f]) {
+                  it[f] = { args: V, declutterMode: x };
+                  continue;
+                }
+                const I = it[f];
+                R = I.args, B = I.declutterMode, delete it[f], M = Pt(R);
+              }
+              let G, H;
+              if (R && (B !== "declutter" || !h.collides(M)) && (G = !0), (x !== "declutter" || !h.collides(L.declutterBox)) && (H = !0), B === "declutter" && x === "declutter") {
+                const f = G && H;
+                G = f, H = f;
+              }
+              G && (B !== "none" && h.insert(M), this.replayImageOrLabel_.apply(this, R)), H && (x !== "none" && h.insert(L.declutterBox), this.replayImageOrLabel_.apply(this, V));
+            } else
+              this.replayImageOrLabel_.apply(this, V);
+          }
+          ++l;
+          break;
+        case k.DRAW_CHARS:
+          const Tt = (
+            /** @type {number} */
+            e[1]
+          ), Lt = (
+            /** @type {number} */
+            e[2]
+          ), mt = (
+            /** @type {number} */
+            e[3]
+          ), Vt = (
+            /** @type {number} */
+            e[4]
+          );
+          P = /** @type {string} */
+          e[5];
+          const Zt = (
+            /** @type {number} */
+            e[6]
+          ), Rt = (
+            /** @type {number} */
+            e[7]
+          ), Mt = (
+            /** @type {number} */
+            e[8]
+          );
+          y = /** @type {string} */
+          e[9];
+          const _t = (
+            /** @type {number} */
+            e[10]
+          );
+          p = /** @type {string|Array<string>} */
+          e[11], Array.isArray(p) && (p = p.reduce(de, "")), _ = /** @type {string} */
+          e[12];
+          const Ot = [
+            /** @type {number} */
+            e[13],
+            /** @type {number} */
+            e[13]
+          ];
+          x = e[14] || "declutter";
+          const $t = (
+            /** @type {boolean} */
+            e[15]
+          ), xt = this.textStates[_], st = xt.font, at = [
+            xt.scale[0] * Rt,
+            xt.scale[1] * Rt
+          ];
+          let lt;
+          st in this.widths_ ? lt = this.widths_[st] : (lt = {}, this.widths_[st] = lt);
+          const Et = ie(a, Tt, Lt, 2), Wt = Math.abs(at[0]) * Bt(st, p, lt);
+          if (Vt || Wt <= Et) {
+            const L = this.textStates[_].textAlign, V = (Et - Wt) * bt(p, L), R = se(
+              a,
+              Tt,
+              Lt,
+              2,
+              p,
+              V,
+              Zt,
+              Math.abs(at[0]),
+              Bt,
+              st,
+              lt,
+              $ ? 0 : this.viewRotation_,
+              $t
+            );
+            t:
+              if (R) {
+                const B = [];
+                let M, G, H, f, I;
+                if (y)
+                  for (M = 0, G = R.length; M < G; ++M) {
+                    I = R[M], H = /** @type {string} */
+                    I[4], f = this.createLabel(H, _, "", y), T = /** @type {number} */
+                    I[2] + (at[0] < 0 ? -_t : _t), C = mt * f.height + (0.5 - mt) * 2 * _t * at[1] / at[0] - Mt;
+                    const z = this.calculateImageOrLabelDimensions_(
+                      f.width,
+                      f.height,
+                      I[0],
+                      I[1],
+                      f.width,
+                      f.height,
+                      T,
+                      C,
+                      0,
+                      0,
+                      I[3],
+                      Ot,
+                      !1,
+                      St,
+                      !1,
+                      Y
+                    );
+                    if (h && x === "declutter" && h.collides(z.declutterBox))
+                      break t;
+                    B.push([
+                      t,
+                      s,
+                      f,
+                      z,
+                      1,
+                      null,
+                      null
+                    ]);
+                  }
+                if (P)
+                  for (M = 0, G = R.length; M < G; ++M) {
+                    I = R[M], H = /** @type {string} */
+                    I[4], f = this.createLabel(H, _, P, ""), T = /** @type {number} */
+                    I[2], C = mt * f.height - Mt;
+                    const z = this.calculateImageOrLabelDimensions_(
+                      f.width,
+                      f.height,
+                      I[0],
+                      I[1],
+                      f.width,
+                      f.height,
+                      T,
+                      C,
+                      0,
+                      0,
+                      I[3],
+                      Ot,
+                      !1,
+                      St,
+                      !1,
+                      Y
+                    );
+                    if (h && x === "declutter" && h.collides(z.declutterBox))
+                      break t;
+                    B.push([
+                      t,
+                      s,
+                      f,
+                      z,
+                      1,
+                      null,
+                      null
+                    ]);
+                  }
+                h && x !== "none" && h.load(B.map(Pt));
+                for (let z = 0, Qt = B.length; z < Qt; ++z)
+                  this.replayImageOrLabel_.apply(this, B[z]);
+              }
+          }
+          ++l;
+          break;
+        case k.END_GEOMETRY:
+          if (r !== void 0) {
+            Y = /** @type {import("../../Feature.js").FeatureLike} */
+            e[1];
+            const L = r(
+              Y,
+              K,
+              x
+            );
+            if (L)
+              return L;
+          }
+          ++l;
+          break;
+        case k.FILL:
+          F ? D++ : this.fill_(t), ++l;
+          break;
+        case k.MOVE_TO_LINE_TO:
+          for (o = /** @type {number} */
+          e[1], m = /** @type {number} */
+          e[2], N = a[o], v = a[o + 1], t.moveTo(N, v), O = N + 0.5 | 0, E = v + 0.5 | 0, o += 2; o < m; o += 2)
+            N = a[o], v = a[o + 1], d = N + 0.5 | 0, W = v + 0.5 | 0, (o == m - 2 || d !== O || W !== E) && (t.lineTo(N, v), O = d, E = W);
+          ++l;
+          break;
+        case k.SET_FILL_STYLE:
+          this.alignAndScaleFill_ = e[2], D && (this.fill_(t), D = 0, w && (t.stroke(), w = 0)), t.fillStyle = e[1], ++l;
+          break;
+        case k.SET_STROKE_STYLE:
+          w && (t.stroke(), w = 0), this.setStrokeStyle_(
+            t,
+            /** @type {Array<*>} */
+            e
+          ), ++l;
+          break;
+        case k.STROKE:
+          F ? w++ : t.stroke(), ++l;
+          break;
+        default:
+          ++l;
+          break;
+      }
+    }
+    D && this.fill_(t), w && t.stroke();
+  }
+  /**
+   * @param {CanvasRenderingContext2D|OffscreenCanvasRenderingContext2D} context Context.
+   * @param {import('../../size.js').Size} scaledCanvasSize Scaled canvas size.
+   * @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<DeclutterEntry>} [declutterTree] Declutter tree.
+   */
+  execute(t, s, n, i, c, r) {
+    this.viewRotation_ = i, this.execute_(
+      t,
+      s,
+      n,
+      this.instructions,
+      c,
+      void 0,
+      void 0,
+      r
+    );
+  }
+  /**
+   * @param {CanvasRenderingContext2D|OffscreenCanvasRenderingContext2D} 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, s, n, i, c) {
+    return this.viewRotation_ = n, this.execute_(
+      t,
+      [t.canvas.width, t.canvas.height],
+      s,
+      this.hitDetectionInstructions,
+      !0,
+      i,
+      c
+    );
+  }
+}
+const ke = pe;
+export {
+  ke as default
+};