gisviewer-vue3-arcgis 1.0.280 → 1.0.282

package/es/node_modules/.pnpm/ol@10.7.0/node_modules/ol/reproj/Tile.mjs

@@ -0,0 +1,194 @@
+import K from "../Tile.mjs";
+import i from "../TileState.mjs";
+import { releaseCanvas as M } from "../dom.mjs";
+import X from "../events/EventType.mjs";
+import { listen as Z, unlistenByKey as v } from "../events.mjs";
+import { getIntersection as x, getArea as w, getWidth as W, wrapAndSliceX as b } from "../extent.mjs";
+import { clamp as A } from "../math.mjs";
+import { render as z, canvasPool as F, calculateSourceExtentResolution as H } from "../reproj.mjs";
+import N from "./Triangulation.mjs";
+import { ERROR_THRESHOLD as B } from "./common.mjs";
+class P extends K {
+  /**
+   * @param {import("../proj/Projection.js").default} sourceProj Source projection.
+   * @param {import("../tilegrid/TileGrid.js").default} sourceTileGrid Source tile grid.
+   * @param {import("../proj/Projection.js").default} targetProj Target projection.
+   * @param {import("../tilegrid/TileGrid.js").default} targetTileGrid Target tile grid.
+   * @param {import("../tilecoord.js").TileCoord} tileCoord Coordinate of the tile.
+   * @param {import("../tilecoord.js").TileCoord} wrappedTileCoord Coordinate of the tile wrapped in X.
+   * @param {number} pixelRatio Pixel ratio.
+   * @param {number} gutter Gutter of the source tiles.
+   * @param {FunctionType} getTileFunction
+   *     Function returning source tiles (z, x, y, pixelRatio).
+   * @param {number} [errorThreshold] Acceptable reprojection error (in px).
+   * @param {boolean} [renderEdges] Render reprojection edges.
+   * @param {import("../Tile.js").Options} [options] Tile options.
+   */
+  constructor(s, t, e, o, a, n, h, _, C, m, R, I) {
+    super(a, i.IDLE, I), this.renderEdges_ = R !== void 0 ? R : !1, this.pixelRatio_ = h, this.gutter_ = _, this.canvas_ = null, this.sourceTileGrid_ = t, this.targetTileGrid_ = o, this.wrappedTileCoord_ = n || a, this.sourceTiles_ = [], this.sourcesListenerKeys_ = null, this.sourceZ_ = 0, this.clipExtent_ = s.canWrapX() ? s.getExtent() : void 0;
+    const L = o.getTileCoordExtent(
+      this.wrappedTileCoord_
+    ), D = this.targetTileGrid_.getExtent();
+    let r = this.sourceTileGrid_.getExtent();
+    const g = D ? x(L, D) : L;
+    if (w(g) === 0) {
+      this.state = i.EMPTY;
+      return;
+    }
+    const c = s.getExtent();
+    c && (r ? r = x(r, c) : r = c);
+    const S = o.getResolution(
+      this.wrappedTileCoord_[0]
+    ), u = H(
+      s,
+      e,
+      g,
+      S
+    );
+    if (!isFinite(u) || u <= 0) {
+      this.state = i.EMPTY;
+      return;
+    }
+    const G = m !== void 0 ? m : B;
+    if (this.triangulation_ = new N(
+      s,
+      e,
+      g,
+      r,
+      u * G,
+      S
+    ), this.triangulation_.getTriangles().length === 0) {
+      this.state = i.EMPTY;
+      return;
+    }
+    this.sourceZ_ = t.getZForResolution(u);
+    let l = this.triangulation_.calculateSourceExtent();
+    if (r && (s.canWrapX() ? (l[1] = A(
+      l[1],
+      r[1],
+      r[3]
+    ), l[3] = A(
+      l[3],
+      r[1],
+      r[3]
+    )) : l = x(l, r)), !w(l))
+      this.state = i.EMPTY;
+    else {
+      let E = 0, p = 0;
+      s.canWrapX() && (E = W(c), p = Math.floor(
+        (l[0] - c[0]) / E
+      )), b(
+        l.slice(),
+        s,
+        !0
+      ).forEach((O) => {
+        const f = t.getTileRangeForExtentAndZ(
+          O,
+          this.sourceZ_
+        );
+        for (let d = f.minX; d <= f.maxX; d++)
+          for (let T = f.minY; T <= f.maxY; T++) {
+            const y = C(this.sourceZ_, d, T, h);
+            if (y) {
+              const Y = p * E;
+              this.sourceTiles_.push({ tile: y, offset: Y });
+            }
+          }
+        ++p;
+      }), this.sourceTiles_.length === 0 && (this.state = i.EMPTY);
+    }
+  }
+  /**
+   * Get the HTML Canvas element for this tile.
+   * @return {HTMLCanvasElement|OffscreenCanvas} Canvas.
+   */
+  getImage() {
+    return this.canvas_;
+  }
+  /**
+   * @private
+   */
+  reproject_() {
+    const s = [];
+    if (this.sourceTiles_.forEach((t) => {
+      var o;
+      const e = t.tile;
+      if (e && e.getState() == i.LOADED) {
+        const a = this.sourceTileGrid_.getTileCoordExtent(e.tileCoord);
+        a[0] += t.offset, a[2] += t.offset;
+        const n = (o = this.clipExtent_) == null ? void 0 : o.slice();
+        n && (n[0] += t.offset, n[2] += t.offset), s.push({
+          extent: a,
+          clipExtent: n,
+          image: e.getImage()
+        });
+      }
+    }), this.sourceTiles_.length = 0, s.length === 0)
+      this.state = i.ERROR;
+    else {
+      const t = this.wrappedTileCoord_[0], e = this.targetTileGrid_.getTileSize(t), o = typeof e == "number" ? e : e[0], a = typeof e == "number" ? e : e[1], n = this.targetTileGrid_.getResolution(t), h = this.sourceTileGrid_.getResolution(
+        this.sourceZ_
+      ), _ = this.targetTileGrid_.getTileCoordExtent(
+        this.wrappedTileCoord_
+      );
+      this.canvas_ = z(
+        o,
+        a,
+        this.pixelRatio_,
+        h,
+        this.sourceTileGrid_.getExtent(),
+        n,
+        _,
+        this.triangulation_,
+        s,
+        this.gutter_,
+        this.renderEdges_,
+        this.interpolate
+      ), this.state = i.LOADED;
+    }
+    this.changed();
+  }
+  /**
+   * Load not yet loaded URI.
+   * @override
+   */
+  load() {
+    if (this.state == i.IDLE) {
+      this.state = i.LOADING, this.changed();
+      let s = 0;
+      this.sourcesListenerKeys_ = [], this.sourceTiles_.forEach(({ tile: t }) => {
+        const e = t.getState();
+        if (e == i.IDLE || e == i.LOADING) {
+          s++;
+          const o = Z(t, X.CHANGE, (a) => {
+            const n = t.getState();
+            (n == i.LOADED || n == i.ERROR || n == i.EMPTY) && (v(o), s--, s === 0 && (this.unlistenSources_(), this.reproject_()));
+          });
+          this.sourcesListenerKeys_.push(o);
+        }
+      }), s === 0 ? setTimeout(this.reproject_.bind(this), 0) : this.sourceTiles_.forEach(function({ tile: t }, e, o) {
+        t.getState() == i.IDLE && t.load();
+      });
+    }
+  }
+  /**
+   * @private
+   */
+  unlistenSources_() {
+    this.sourcesListenerKeys_.forEach(v), this.sourcesListenerKeys_ = null;
+  }
+  /**
+   * Remove from the cache due to expiry
+   * @override
+   */
+  release() {
+    this.canvas_ && (M(
+      /** @type {CanvasRenderingContext2D|OffscreenCanvasRenderingContext2D} */
+      this.canvas_.getContext("2d")
+    ), F.push(this.canvas_), this.canvas_ = null), super.release();
+  }
+}
+const nt = P;
+export {
+  nt as default
+};

package/es/node_modules/.pnpm/ol@10.7.0/node_modules/ol/reproj/Triangulation.mjs

@@ -0,0 +1,225 @@
+import { getWidth as T, getTopLeft as v, getTopRight as M, getBottomRight as B, getBottomLeft as Q, getArea as L, boundingExtent as P, intersects as C, extendCoordinate as X, createEmpty as w } from "../extent.mjs";
+import { modulo as j } from "../math.mjs";
+import { createTransformFromCoordinateTransform as y, getTransform as R, transform as q } from "../proj.mjs";
+import { apply as A } from "../transform.mjs";
+const G = 10, x = 0.25;
+class N {
+  /**
+   * @param {import("../proj/Projection.js").default} sourceProj Source projection.
+   * @param {import("../proj/Projection.js").default} targetProj Target projection.
+   * @param {import("../extent.js").Extent} targetExtent Target extent to triangulate.
+   * @param {import("../extent.js").Extent} maxSourceExtent Maximal source extent that can be used.
+   * @param {number} errorThreshold Acceptable error (in source units).
+   * @param {?number} destinationResolution The (optional) resolution of the destination.
+   * @param {import("../transform.js").Transform} [sourceMatrix] Source transform matrix.
+   */
+  constructor(t, n, s, r, i, h, a) {
+    this.sourceProj_ = t, this.targetProj_ = n;
+    let u = {};
+    const g = a ? y(
+      (o) => A(
+        a,
+        q(o, this.targetProj_, this.sourceProj_)
+      )
+    ) : R(this.targetProj_, this.sourceProj_);
+    this.transformInv_ = function(o) {
+      const e = o[0] + "/" + o[1];
+      return u[e] || (u[e] = g(o)), u[e];
+    }, this.maxSourceExtent_ = r, this.errorThresholdSquared_ = i * i, this.triangles_ = [], this.wrapsXInSource_ = !1, this.canWrapXInSource_ = this.sourceProj_.canWrapX() && !!r && !!this.sourceProj_.getExtent() && T(r) >= T(this.sourceProj_.getExtent()), this.sourceWorldWidth_ = this.sourceProj_.getExtent() ? T(this.sourceProj_.getExtent()) : null, this.targetWorldWidth_ = this.targetProj_.getExtent() ? T(this.targetProj_.getExtent()) : null;
+    const W = v(s), p = M(s), I = B(s), F = Q(s), c = this.transformInv_(W), l = this.transformInv_(p), d = this.transformInv_(I), m = this.transformInv_(F), f = G + (h ? Math.max(
+      0,
+      Math.ceil(
+        Math.log2(
+          L(s) / (h * h * 256 * 256)
+        )
+      )
+    ) : 0);
+    if (this.addQuad_(
+      W,
+      p,
+      I,
+      F,
+      c,
+      l,
+      d,
+      m,
+      f
+    ), this.wrapsXInSource_) {
+      let o = 1 / 0;
+      this.triangles_.forEach(function(e, _, E) {
+        o = Math.min(
+          o,
+          e.source[0][0],
+          e.source[1][0],
+          e.source[2][0]
+        );
+      }), this.triangles_.forEach((e) => {
+        if (Math.max(
+          e.source[0][0],
+          e.source[1][0],
+          e.source[2][0]
+        ) - o > this.sourceWorldWidth_ / 2) {
+          const _ = [
+            [e.source[0][0], e.source[0][1]],
+            [e.source[1][0], e.source[1][1]],
+            [e.source[2][0], e.source[2][1]]
+          ];
+          _[0][0] - o > this.sourceWorldWidth_ / 2 && (_[0][0] -= this.sourceWorldWidth_), _[1][0] - o > this.sourceWorldWidth_ / 2 && (_[1][0] -= this.sourceWorldWidth_), _[2][0] - o > this.sourceWorldWidth_ / 2 && (_[2][0] -= this.sourceWorldWidth_);
+          const E = Math.min(
+            _[0][0],
+            _[1][0],
+            _[2][0]
+          );
+          Math.max(
+            _[0][0],
+            _[1][0],
+            _[2][0]
+          ) - E < this.sourceWorldWidth_ / 2 && (e.source = _);
+        }
+      });
+    }
+    u = {};
+  }
+  /**
+   * Adds triangle to the triangulation.
+   * @param {import("../coordinate.js").Coordinate} a The target a coordinate.
+   * @param {import("../coordinate.js").Coordinate} b The target b coordinate.
+   * @param {import("../coordinate.js").Coordinate} c The target c coordinate.
+   * @param {import("../coordinate.js").Coordinate} aSrc The source a coordinate.
+   * @param {import("../coordinate.js").Coordinate} bSrc The source b coordinate.
+   * @param {import("../coordinate.js").Coordinate} cSrc The source c coordinate.
+   * @private
+   */
+  addTriangle_(t, n, s, r, i, h) {
+    this.triangles_.push({
+      source: [r, i, h],
+      target: [t, n, s]
+    });
+  }
+  /**
+   * Adds quad (points in clock-wise order) to the triangulation
+   * (and reprojects the vertices) if valid.
+   * Performs quad subdivision if needed to increase precision.
+   *
+   * @param {import("../coordinate.js").Coordinate} a The target a coordinate.
+   * @param {import("../coordinate.js").Coordinate} b The target b coordinate.
+   * @param {import("../coordinate.js").Coordinate} c The target c coordinate.
+   * @param {import("../coordinate.js").Coordinate} d The target d coordinate.
+   * @param {import("../coordinate.js").Coordinate} aSrc The source a coordinate.
+   * @param {import("../coordinate.js").Coordinate} bSrc The source b coordinate.
+   * @param {import("../coordinate.js").Coordinate} cSrc The source c coordinate.
+   * @param {import("../coordinate.js").Coordinate} dSrc The source d coordinate.
+   * @param {number} maxSubdivision Maximal allowed subdivision of the quad.
+   * @private
+   */
+  addQuad_(t, n, s, r, i, h, a, u, g) {
+    const W = P([i, h, a, u]), p = this.sourceWorldWidth_ ? T(W) / this.sourceWorldWidth_ : null, I = (
+      /** @type {number} */
+      this.sourceWorldWidth_
+    ), F = this.sourceProj_.canWrapX() && p > 0.5 && p < 1;
+    let c = !1;
+    if (g > 0) {
+      if (this.targetProj_.isGlobal() && this.targetWorldWidth_) {
+        const d = P([t, n, s, r]);
+        c = T(d) / this.targetWorldWidth_ > x || c;
+      }
+      !F && this.sourceProj_.isGlobal() && p && (c = p > x || c);
+    }
+    if (!c && this.maxSourceExtent_ && isFinite(W[0]) && isFinite(W[1]) && isFinite(W[2]) && isFinite(W[3]) && !C(W, this.maxSourceExtent_))
+      return;
+    let l = 0;
+    if (!c && (!isFinite(i[0]) || !isFinite(i[1]) || !isFinite(h[0]) || !isFinite(h[1]) || !isFinite(a[0]) || !isFinite(a[1]) || !isFinite(u[0]) || !isFinite(u[1]))) {
+      if (g > 0)
+        c = !0;
+      else if (l = (!isFinite(i[0]) || !isFinite(i[1]) ? 8 : 0) + (!isFinite(h[0]) || !isFinite(h[1]) ? 4 : 0) + (!isFinite(a[0]) || !isFinite(a[1]) ? 2 : 0) + (!isFinite(u[0]) || !isFinite(u[1]) ? 1 : 0), l != 1 && l != 2 && l != 4 && l != 8)
+        return;
+    }
+    if (g > 0) {
+      if (!c) {
+        const d = [(t[0] + s[0]) / 2, (t[1] + s[1]) / 2], m = this.transformInv_(d);
+        let f;
+        F ? f = (j(i[0], I) + j(a[0], I)) / 2 - j(m[0], I) : f = (i[0] + a[0]) / 2 - m[0];
+        const o = (i[1] + a[1]) / 2 - m[1];
+        c = f * f + o * o > this.errorThresholdSquared_;
+      }
+      if (c) {
+        if (Math.abs(t[0] - s[0]) <= Math.abs(t[1] - s[1])) {
+          const d = [(n[0] + s[0]) / 2, (n[1] + s[1]) / 2], m = this.transformInv_(d), f = [(r[0] + t[0]) / 2, (r[1] + t[1]) / 2], o = this.transformInv_(f);
+          this.addQuad_(
+            t,
+            n,
+            d,
+            f,
+            i,
+            h,
+            m,
+            o,
+            g - 1
+          ), this.addQuad_(
+            f,
+            d,
+            s,
+            r,
+            o,
+            m,
+            a,
+            u,
+            g - 1
+          );
+        } else {
+          const d = [(t[0] + n[0]) / 2, (t[1] + n[1]) / 2], m = this.transformInv_(d), f = [(s[0] + r[0]) / 2, (s[1] + r[1]) / 2], o = this.transformInv_(f);
+          this.addQuad_(
+            t,
+            d,
+            f,
+            r,
+            i,
+            m,
+            o,
+            u,
+            g - 1
+          ), this.addQuad_(
+            d,
+            n,
+            s,
+            f,
+            m,
+            h,
+            a,
+            o,
+            g - 1
+          );
+        }
+        return;
+      }
+    }
+    if (F) {
+      if (!this.canWrapXInSource_)
+        return;
+      this.wrapsXInSource_ = !0;
+    }
+    l & 11 || this.addTriangle_(t, s, r, i, a, u), l & 14 || this.addTriangle_(t, s, n, i, a, h), l && (l & 13 || this.addTriangle_(n, r, t, h, u, i), l & 7 || this.addTriangle_(n, r, s, h, u, a));
+  }
+  /**
+   * Calculates extent of the `source` coordinates from all the triangles.
+   *
+   * @return {import("../extent.js").Extent} Calculated extent.
+   */
+  calculateSourceExtent() {
+    const t = w();
+    return this.triangles_.forEach(function(n, s, r) {
+      const i = n.source;
+      X(t, i[0]), X(t, i[1]), X(t, i[2]);
+    }), t;
+  }
+  /**
+   * @return {Array<Triangle>} Array of the calculated triangles.
+   */
+  getTriangles() {
+    return this.triangles_;
+  }
+}
+const $ = N;
+export {
+  $ as default
+};

package/es/node_modules/.pnpm/ol@10.7.0/node_modules/ol/reproj/common.mjs

@@ -0,0 +1,4 @@
+const R = 0.5;
+export {
+  R as ERROR_THRESHOLD
+};

package/es/node_modules/.pnpm/ol@10.7.0/node_modules/ol/reproj.mjs

@@ -0,0 +1,178 @@
+import { createCanvasContext2D as J, releaseCanvas as j } from "./dom.mjs";
+import { containsCoordinate as on, extend as an, getHeight as H, getWidth as N, getTopLeft as sn, getCenter as cn, forEachCorner as rn, createEmpty as hn } from "./extent.mjs";
+import { solveLinearSystem as fn } from "./math.mjs";
+import { transform as ln, getPointResolution as V } from "./proj.mjs";
+let A;
+const X = [];
+function Z(t, a, s, v, h) {
+  t.beginPath(), t.moveTo(0, 0), t.lineTo(a, s), t.lineTo(v, h), t.closePath(), t.save(), t.clip(), t.fillRect(0, 0, Math.max(a, v) + 1, Math.max(s, h)), t.restore();
+}
+function G(t, a) {
+  return Math.abs(t[a * 4] - 210) > 2 || Math.abs(t[a * 4 + 3] - 0.75 * 255) > 2;
+}
+function dn() {
+  if (A === void 0) {
+    const t = J(6, 6, X);
+    t.globalCompositeOperation = "lighter", t.fillStyle = "rgba(210, 0, 0, 0.75)", Z(t, 4, 5, 4, 0), Z(t, 4, 5, 0, 5);
+    const a = t.getImageData(0, 0, 3, 3).data;
+    A = G(a, 0) || G(a, 4) || G(a, 8), j(t), X.push(t.canvas);
+  }
+  return A;
+}
+function $(t, a, s, v) {
+  const h = ln(s, a, t);
+  let e = V(
+    a,
+    v,
+    s
+  );
+  const S = a.getMetersPerUnit();
+  S !== void 0 && (e *= S);
+  const D = t.getMetersPerUnit();
+  D !== void 0 && (e /= D);
+  const x = t.getExtent();
+  if (!x || on(x, h)) {
+    const T = V(t, e, h) / e;
+    isFinite(T) && T > 0 && (e /= T);
+  }
+  return e;
+}
+function vn(t, a, s, v) {
+  const h = cn(s);
+  let e = $(
+    t,
+    a,
+    h,
+    v
+  );
+  return (!isFinite(e) || e <= 0) && rn(s, function(S) {
+    return e = $(
+      t,
+      a,
+      S,
+      v
+    ), isFinite(e) && e > 0;
+  }), e;
+}
+function Tn(t, a, s, v, h, e, S, D, x, T, R, l, nn, tn) {
+  const n = J(
+    Math.round(s * t),
+    Math.round(s * a),
+    X
+  );
+  if (l || (n.imageSmoothingEnabled = !1), x.length === 0)
+    return n.canvas;
+  n.scale(s, s);
+  function m(o) {
+    return Math.round(o * s) / s;
+  }
+  n.globalCompositeOperation = "lighter";
+  const u = hn();
+  x.forEach(function(o, F, U) {
+    an(u, o.extent);
+  });
+  let r;
+  const c = s / v, K = (l ? 1 : 1 + Math.pow(2, -24)) / c;
+  if (!nn || x.length !== 1 || T !== 0) {
+    if (r = J(
+      Math.round(N(u) * c),
+      Math.round(H(u) * c),
+      X
+    ), l || (r.imageSmoothingEnabled = !1), h && tn) {
+      const o = (h[0] - u[0]) * c, F = -(h[3] - u[3]) * c, U = N(h) * c, i = H(h) * c;
+      r.rect(o, F, U, i), r.clip();
+    }
+    x.forEach(function(o, F, U) {
+      if (o.image.width > 0 && o.image.height > 0) {
+        if (o.clipExtent) {
+          r.save();
+          const g = (o.clipExtent[0] - u[0]) * c, M = -(o.clipExtent[3] - u[3]) * c, b = N(o.clipExtent) * c, P = H(o.clipExtent) * c;
+          r.rect(
+            l ? g : Math.round(g),
+            l ? M : Math.round(M),
+            l ? b : Math.round(g + b) - Math.round(g),
+            l ? P : Math.round(M + P) - Math.round(M)
+          ), r.clip();
+        }
+        const i = (o.extent[0] - u[0]) * c, f = -(o.extent[3] - u[3]) * c, E = N(o.extent) * c, C = H(o.extent) * c;
+        r.drawImage(
+          o.image,
+          T,
+          T,
+          o.image.width - 2 * T,
+          o.image.height - 2 * T,
+          l ? i : Math.round(i),
+          l ? f : Math.round(f),
+          l ? E : Math.round(i + E) - Math.round(i),
+          l ? C : Math.round(f + C) - Math.round(f)
+        ), o.clipExtent && r.restore();
+      }
+    });
+  }
+  const d = sn(S);
+  return D.getTriangles().forEach(function(o, F, U) {
+    const i = o.source, f = o.target;
+    let E = i[0][0], C = i[0][1], g = i[1][0], M = i[1][1], b = i[2][0], P = i[2][1];
+    const I = m((f[0][0] - d[0]) / e), L = m(
+      -(f[0][1] - d[1]) / e
+    ), w = m((f[1][0] - d[0]) / e), k = m(
+      -(f[1][1] - d[1]) / e
+    ), Y = m((f[2][0] - d[0]) / e), _ = m(
+      -(f[2][1] - d[1]) / e
+    ), q = E, z = C;
+    E = 0, C = 0, g -= q, M -= z, b -= q, P -= z;
+    const en = [
+      [g, M, 0, 0, w - I],
+      [b, P, 0, 0, Y - I],
+      [0, 0, g, M, k - L],
+      [0, 0, b, P, _ - L]
+    ], O = fn(en);
+    if (!O)
+      return;
+    if (n.save(), n.beginPath(), dn() || !l) {
+      n.moveTo(w, k);
+      const p = 4, B = I - w, Q = L - k;
+      for (let y = 0; y < p; y++)
+        n.lineTo(
+          w + m((y + 1) * B / p),
+          k + m(y * Q / (p - 1))
+        ), y != p - 1 && n.lineTo(
+          w + m((y + 1) * B / p),
+          k + m((y + 1) * Q / (p - 1))
+        );
+      n.lineTo(Y, _);
+    } else
+      n.moveTo(w, k), n.lineTo(I, L), n.lineTo(Y, _);
+    n.clip(), n.transform(
+      O[0],
+      O[2],
+      O[1],
+      O[3],
+      I,
+      L
+    ), n.translate(
+      u[0] - q,
+      u[3] - z
+    );
+    let W;
+    if (r)
+      W = r.canvas, n.scale(K, -K);
+    else {
+      const p = x[0], B = p.extent;
+      W = p.image, n.scale(
+        N(B) / W.width,
+        -H(B) / W.height
+      );
+    }
+    n.drawImage(W, 0, 0), n.restore();
+  }), r && (j(r), X.push(r.canvas)), R && (n.save(), n.globalCompositeOperation = "source-over", n.strokeStyle = "black", n.lineWidth = 1, D.getTriangles().forEach(function(o, F, U) {
+    const i = o.target, f = (i[0][0] - d[0]) / e, E = -(i[0][1] - d[1]) / e, C = (i[1][0] - d[0]) / e, g = -(i[1][1] - d[1]) / e, M = (i[2][0] - d[0]) / e, b = -(i[2][1] - d[1]) / e;
+    n.beginPath(), n.moveTo(C, g), n.lineTo(f, E), n.lineTo(M, b), n.closePath(), n.stroke();
+  }), n.restore()), n.canvas;
+}
+export {
+  vn as calculateSourceExtentResolution,
+  $ as calculateSourceResolution,
+  X as canvasPool,
+  Tn as render
+};

package/es/node_modules/.pnpm/ol@10.7.0/node_modules/ol/resolutionconstraint.mjs

@@ -0,0 +1,99 @@
+import { linearFindNearest as y } from "./array.mjs";
+import { getWidth as z, getHeight as F } from "./extent.mjs";
+import { clamp as i } from "./math.mjs";
+function L(e, t, n, a) {
+  const c = z(t) / n[0], r = F(t) / n[1];
+  return a ? Math.min(e, Math.max(c, r)) : Math.min(e, Math.min(c, r));
+}
+function v(e, t, n) {
+  let a = Math.min(e, t);
+  const c = 50;
+  return a *= Math.log(1 + c * Math.max(0, e / t - 1)) / c + 1, n && (a = Math.max(a, n), a /= Math.log(1 + c * Math.max(0, n / e - 1)) / c + 1), i(a, n / 2, t * 2);
+}
+function V(e, t, n, a) {
+  return t = t !== void 0 ? t : !0, /**
+   * @param {number|undefined} resolution Resolution.
+   * @param {number} direction Direction.
+   * @param {import("./size.js").Size} size Viewport size.
+   * @param {boolean} [isMoving] True if an interaction or animation is in progress.
+   * @return {number|undefined} Resolution.
+   */
+  function(c, r, d, u) {
+    if (c !== void 0) {
+      const p = e[0], M = e[e.length - 1], f = n ? L(
+        p,
+        n,
+        d,
+        a
+      ) : p;
+      if (u)
+        return t ? v(
+          c,
+          f,
+          M
+        ) : i(c, M, f);
+      const g = Math.min(f, c), h = Math.floor(y(e, g, r));
+      return e[h] > f && h < e.length - 1 ? e[h + 1] : e[h];
+    }
+  };
+}
+function W(e, t, n, a, c, r) {
+  return a = a !== void 0 ? a : !0, n = n !== void 0 ? n : 0, /**
+   * @param {number|undefined} resolution Resolution.
+   * @param {number} direction Direction.
+   * @param {import("./size.js").Size} size Viewport size.
+   * @param {boolean} [isMoving] True if an interaction or animation is in progress.
+   * @return {number|undefined} Resolution.
+   */
+  function(d, u, p, M) {
+    if (d !== void 0) {
+      const f = c ? L(
+        t,
+        c,
+        p,
+        r
+      ) : t;
+      if (M)
+        return a ? v(
+          d,
+          f,
+          n
+        ) : i(d, n, f);
+      const g = 1e-9, h = Math.ceil(
+        Math.log(t / f) / Math.log(e) - g
+      ), C = -u * (0.5 - g) + 0.5, S = Math.min(f, d), T = Math.floor(
+        Math.log(t / S) / Math.log(e) + C
+      ), Z = Math.max(h, T), w = t / Math.pow(e, Z);
+      return i(w, n, f);
+    }
+  };
+}
+function b(e, t, n, a, c) {
+  return n = n !== void 0 ? n : !0, /**
+   * @param {number|undefined} resolution Resolution.
+   * @param {number} direction Direction.
+   * @param {import("./size.js").Size} size Viewport size.
+   * @param {boolean} [isMoving] True if an interaction or animation is in progress.
+   * @return {number|undefined} Resolution.
+   */
+  function(r, d, u, p) {
+    if (r !== void 0) {
+      const M = a ? L(
+        e,
+        a,
+        u,
+        c
+      ) : e;
+      return !n || !p ? i(r, t, M) : v(
+        r,
+        M,
+        t
+      );
+    }
+  };
+}
+export {
+  b as createMinMaxResolution,
+  W as createSnapToPower,
+  V as createSnapToResolutions
+};