gisviewer-vue3-arcgis 1.0.281 → 1.0.283

package/es/node_modules/.pnpm/ol@10.7.0/node_modules/ol/tilegrid/TileGrid.mjs

@@ -0,0 +1,400 @@
+import R, { createOrUpdate as m } from "../TileRange.mjs";
+import { isSorted as Z, linearFindNearest as z } from "../array.mjs";
+import { assert as _ } from "../asserts.mjs";
+import { getTopLeft as E, createOrUpdate as F } from "../extent.mjs";
+import { intersectsLinearRing as X } from "../geom/flat/intersectsextent.mjs";
+import { clamp as Y, ceil as d, floor as c } from "../math.mjs";
+import { toSize as x } from "../size.mjs";
+import { createOrUpdate as T } from "../tilecoord.mjs";
+import { DEFAULT_TILE_SIZE as A } from "./common.mjs";
+const f = [0, 0, 0], u = 5;
+class C {
+  /**
+   * @param {Options} options Tile grid options.
+   */
+  constructor(t) {
+    this.minZoom = t.minZoom !== void 0 ? t.minZoom : 0, this.resolutions_ = t.resolutions, _(
+      Z(
+        this.resolutions_,
+        /**
+         * @param {number} a First resolution
+         * @param {number} b Second resolution
+         * @return {number} Comparison result
+         */
+        (e, s) => s - e,
+        !0
+      ),
+      "`resolutions` must be sorted in descending order"
+    );
+    let n;
+    if (!t.origins) {
+      for (let e = 0, s = this.resolutions_.length - 1; e < s; ++e)
+        if (!n)
+          n = this.resolutions_[e] / this.resolutions_[e + 1];
+        else if (this.resolutions_[e] / this.resolutions_[e + 1] !== n) {
+          n = void 0;
+          break;
+        }
+    }
+    this.zoomFactor_ = n, this.maxZoom = this.resolutions_.length - 1, this.origin_ = t.origin !== void 0 ? t.origin : null, this.origins_ = null, t.origins !== void 0 && (this.origins_ = t.origins, _(
+      this.origins_.length == this.resolutions_.length,
+      "Number of `origins` and `resolutions` must be equal"
+    ));
+    const i = t.extent;
+    i !== void 0 && !this.origin_ && !this.origins_ && (this.origin_ = E(i)), _(
+      !this.origin_ && this.origins_ || this.origin_ && !this.origins_,
+      "Either `origin` or `origins` must be configured, never both"
+    ), this.tileSizes_ = null, t.tileSizes !== void 0 && (this.tileSizes_ = t.tileSizes, _(
+      this.tileSizes_.length == this.resolutions_.length,
+      "Number of `tileSizes` and `resolutions` must be equal"
+    )), this.tileSize_ = t.tileSize !== void 0 ? t.tileSize : this.tileSizes_ ? null : A, _(
+      !this.tileSize_ && this.tileSizes_ || this.tileSize_ && !this.tileSizes_,
+      "Either `tileSize` or `tileSizes` must be configured, never both"
+    ), this.extent_ = i !== void 0 ? i : null, this.fullTileRanges_ = null, this.tmpSize_ = [0, 0], this.tmpExtent_ = [0, 0, 0, 0], t.sizes !== void 0 ? this.fullTileRanges_ = t.sizes.map((e, s) => {
+      const o = new R(
+        Math.min(0, e[0]),
+        Math.max(e[0] - 1, -1),
+        Math.min(0, e[1]),
+        Math.max(e[1] - 1, -1)
+      );
+      if (i) {
+        const r = this.getTileRangeForExtentAndZ(i, s);
+        o.minX = Math.max(r.minX, o.minX), o.maxX = Math.min(r.maxX, o.maxX), o.minY = Math.max(r.minY, o.minY), o.maxY = Math.min(r.maxY, o.maxY);
+      }
+      return o;
+    }) : i && this.calculateTileRanges_(i);
+  }
+  /**
+   * Call a function with each tile coordinate for a given extent and zoom level.
+   *
+   * @param {import("../extent.js").Extent} extent Extent.
+   * @param {number} zoom Integer zoom level.
+   * @param {function(import("../tilecoord.js").TileCoord): void} callback Function called with each tile coordinate.
+   * @api
+   */
+  forEachTileCoord(t, n, i) {
+    const e = this.getTileRangeForExtentAndZ(t, n);
+    for (let s = e.minX, o = e.maxX; s <= o; ++s)
+      for (let r = e.minY, h = e.maxY; r <= h; ++r)
+        i([n, s, r]);
+  }
+  /**
+   * @param {import("../tilecoord.js").TileCoord} tileCoord Tile coordinate.
+   * @param {function(number, import("../TileRange.js").default): boolean} callback Callback.
+   * @param {import("../TileRange.js").default} [tempTileRange] Temporary import("../TileRange.js").default object.
+   * @param {import("../extent.js").Extent} [tempExtent] Temporary import("../extent.js").Extent object.
+   * @return {boolean} Callback succeeded.
+   */
+  forEachTileCoordParentTileRange(t, n, i, e) {
+    let s, o, r, h = null, l = t[0] - 1;
+    for (this.zoomFactor_ === 2 ? (o = t[1], r = t[2]) : h = this.getTileCoordExtent(t, e); l >= this.minZoom; ) {
+      if (o !== void 0 && r !== void 0 ? (o = Math.floor(o / 2), r = Math.floor(r / 2), s = m(o, o, r, r, i)) : s = this.getTileRangeForExtentAndZ(
+        h,
+        l,
+        i
+      ), n(l, s))
+        return !0;
+      --l;
+    }
+    return !1;
+  }
+  /**
+   * Get the extent for this tile grid, if it was configured.
+   * @return {import("../extent.js").Extent} Extent.
+   * @api
+   */
+  getExtent() {
+    return this.extent_;
+  }
+  /**
+   * Get the maximum zoom level for the grid.
+   * @return {number} Max zoom.
+   * @api
+   */
+  getMaxZoom() {
+    return this.maxZoom;
+  }
+  /**
+   * Get the minimum zoom level for the grid.
+   * @return {number} Min zoom.
+   * @api
+   */
+  getMinZoom() {
+    return this.minZoom;
+  }
+  /**
+   * Get the origin for the grid at the given zoom level.
+   * @param {number} z Integer zoom level.
+   * @return {import("../coordinate.js").Coordinate} Origin.
+   * @api
+   */
+  getOrigin(t) {
+    return this.origin_ ? this.origin_ : this.origins_[t];
+  }
+  /**
+   * Get the resolution for the given zoom level.
+   * @param {number} z Integer zoom level.
+   * @return {number} Resolution.
+   * @api
+   */
+  getResolution(t) {
+    return this.resolutions_[t];
+  }
+  /**
+   * Get the list of resolutions for the tile grid.
+   * @return {Array<number>} Resolutions.
+   * @api
+   */
+  getResolutions() {
+    return this.resolutions_;
+  }
+  /**
+   * @param {import("../tilecoord.js").TileCoord} tileCoord Tile coordinate.
+   * @param {import("../TileRange.js").default} [tempTileRange] Temporary import("../TileRange.js").default object.
+   * @param {import("../extent.js").Extent} [tempExtent] Temporary import("../extent.js").Extent object.
+   * @return {import("../TileRange.js").default|null} Tile range.
+   */
+  getTileCoordChildTileRange(t, n, i) {
+    if (t[0] < this.maxZoom) {
+      if (this.zoomFactor_ === 2) {
+        const s = t[1] * 2, o = t[2] * 2;
+        return m(
+          s,
+          s + 1,
+          o,
+          o + 1,
+          n
+        );
+      }
+      const e = this.getTileCoordExtent(
+        t,
+        i || this.tmpExtent_
+      );
+      return this.getTileRangeForExtentAndZ(
+        e,
+        t[0] + 1,
+        n
+      );
+    }
+    return null;
+  }
+  /**
+   * @param {import("../tilecoord.js").TileCoord} tileCoord Tile coordinate.
+   * @param {number} z Integer zoom level.
+   * @param {import("../TileRange.js").default} [tempTileRange] Temporary import("../TileRange.js").default object.
+   * @return {import("../TileRange.js").default|null} Tile range.
+   */
+  getTileRangeForTileCoordAndZ(t, n, i) {
+    if (n > this.maxZoom || n < this.minZoom)
+      return null;
+    const e = t[0], s = t[1], o = t[2];
+    if (n === e)
+      return m(
+        s,
+        o,
+        s,
+        o,
+        i
+      );
+    if (this.zoomFactor_) {
+      const h = Math.pow(this.zoomFactor_, n - e), l = Math.floor(s * h), g = Math.floor(o * h);
+      if (n < e)
+        return m(l, l, g, g, i);
+      const a = Math.floor(h * (s + 1)) - 1, S = Math.floor(h * (o + 1)) - 1;
+      return m(l, a, g, S, i);
+    }
+    const r = this.getTileCoordExtent(t, this.tmpExtent_);
+    return this.getTileRangeForExtentAndZ(r, n, i);
+  }
+  /**
+   * Get a tile range for the given extent and integer zoom level.
+   * @param {import("../extent.js").Extent} extent Extent.
+   * @param {number} z Integer zoom level.
+   * @param {import("../TileRange.js").default} [tempTileRange] Temporary tile range object.
+   * @return {import("../TileRange.js").default} Tile range.
+   */
+  getTileRangeForExtentAndZ(t, n, i) {
+    this.getTileCoordForXYAndZ_(t[0], t[3], n, !1, f);
+    const e = f[1], s = f[2];
+    this.getTileCoordForXYAndZ_(t[2], t[1], n, !0, f);
+    const o = f[1], r = f[2];
+    return m(e, o, s, r, i);
+  }
+  /**
+   * @param {import("../tilecoord.js").TileCoord} tileCoord Tile coordinate.
+   * @return {import("../coordinate.js").Coordinate} Tile center.
+   */
+  getTileCoordCenter(t) {
+    const n = this.getOrigin(t[0]), i = this.getResolution(t[0]), e = x(this.getTileSize(t[0]), this.tmpSize_);
+    return [
+      n[0] + (t[1] + 0.5) * e[0] * i,
+      n[1] - (t[2] + 0.5) * e[1] * i
+    ];
+  }
+  /**
+   * Get the extent of a tile coordinate.
+   *
+   * @param {import("../tilecoord.js").TileCoord} tileCoord Tile coordinate.
+   * @param {import("../extent.js").Extent} [tempExtent] Temporary extent object.
+   * @return {import("../extent.js").Extent} Extent.
+   * @api
+   */
+  getTileCoordExtent(t, n) {
+    const i = this.getOrigin(t[0]), e = this.getResolution(t[0]), s = x(this.getTileSize(t[0]), this.tmpSize_), o = i[0] + t[1] * s[0] * e, r = i[1] - (t[2] + 1) * s[1] * e, h = o + s[0] * e, l = r + s[1] * e;
+    return F(o, r, h, l, n);
+  }
+  /**
+   * Get the tile coordinate for the given map coordinate and resolution.  This
+   * method considers that coordinates that intersect tile boundaries should be
+   * assigned the higher tile coordinate.
+   *
+   * @param {import("../coordinate.js").Coordinate} coordinate Coordinate.
+   * @param {number} resolution Resolution.
+   * @param {import("../tilecoord.js").TileCoord} [opt_tileCoord] Destination import("../tilecoord.js").TileCoord object.
+   * @return {import("../tilecoord.js").TileCoord} Tile coordinate.
+   * @api
+   */
+  getTileCoordForCoordAndResolution(t, n, i) {
+    return this.getTileCoordForXYAndResolution_(
+      t[0],
+      t[1],
+      n,
+      !1,
+      i
+    );
+  }
+  /**
+   * Note that this method should not be called for resolutions that correspond
+   * to an integer zoom level.  Instead call the `getTileCoordForXYAndZ_` method.
+   * @param {number} x X.
+   * @param {number} y Y.
+   * @param {number} resolution Resolution (for a non-integer zoom level).
+   * @param {boolean} reverseIntersectionPolicy Instead of letting edge
+   *     intersections go to the higher tile coordinate, let edge intersections
+   *     go to the lower tile coordinate.
+   * @param {import("../tilecoord.js").TileCoord} [opt_tileCoord] Temporary import("../tilecoord.js").TileCoord object.
+   * @return {import("../tilecoord.js").TileCoord} Tile coordinate.
+   * @private
+   */
+  getTileCoordForXYAndResolution_(t, n, i, e, s) {
+    const o = this.getZForResolution(i), r = i / this.getResolution(o), h = this.getOrigin(o), l = x(this.getTileSize(o), this.tmpSize_);
+    let g = r * (t - h[0]) / i / l[0], a = r * (h[1] - n) / i / l[1];
+    return e ? (g = d(g, u) - 1, a = d(a, u) - 1) : (g = c(g, u), a = c(a, u)), T(o, g, a, s);
+  }
+  /**
+   * Although there is repetition between this method and `getTileCoordForXYAndResolution_`,
+   * they should have separate implementations.  This method is for integer zoom
+   * levels.  The other method should only be called for resolutions corresponding
+   * to non-integer zoom levels.
+   * @param {number} x Map x coordinate.
+   * @param {number} y Map y coordinate.
+   * @param {number} z Integer zoom level.
+   * @param {boolean} reverseIntersectionPolicy Instead of letting edge
+   *     intersections go to the higher tile coordinate, let edge intersections
+   *     go to the lower tile coordinate.
+   * @param {import("../tilecoord.js").TileCoord} [opt_tileCoord] Temporary import("../tilecoord.js").TileCoord object.
+   * @return {import("../tilecoord.js").TileCoord} Tile coordinate.
+   * @private
+   */
+  getTileCoordForXYAndZ_(t, n, i, e, s) {
+    const o = this.getOrigin(i), r = this.getResolution(i), h = x(this.getTileSize(i), this.tmpSize_);
+    let l = (t - o[0]) / r / h[0], g = (o[1] - n) / r / h[1];
+    return e ? (l = d(l, u) - 1, g = d(g, u) - 1) : (l = c(l, u), g = c(g, u)), T(i, l, g, s);
+  }
+  /**
+   * Get a tile coordinate given a map coordinate and zoom level.
+   * @param {import("../coordinate.js").Coordinate} coordinate Coordinate.
+   * @param {number} z Integer zoom level, e.g. the result of a `getZForResolution()` method call
+   * @param {import("../tilecoord.js").TileCoord} [opt_tileCoord] Destination import("../tilecoord.js").TileCoord object.
+   * @return {import("../tilecoord.js").TileCoord} Tile coordinate.
+   * @api
+   */
+  getTileCoordForCoordAndZ(t, n, i) {
+    return this.getTileCoordForXYAndZ_(
+      t[0],
+      t[1],
+      n,
+      !1,
+      i
+    );
+  }
+  /**
+   * @param {import("../tilecoord.js").TileCoord} tileCoord Tile coordinate.
+   * @return {number} Tile resolution.
+   */
+  getTileCoordResolution(t) {
+    return this.resolutions_[t[0]];
+  }
+  /**
+   * Get the tile size for a zoom level. The type of the return value matches the
+   * `tileSize` or `tileSizes` that the tile grid was configured with. To always
+   * get an {@link import("../size.js").Size}, run the result through {@link module:ol/size.toSize}.
+   * @param {number} z Z.
+   * @return {number|import("../size.js").Size} Tile size.
+   * @api
+   */
+  getTileSize(t) {
+    return this.tileSize_ ? this.tileSize_ : this.tileSizes_[t];
+  }
+  /**
+   * @param {number} z Zoom level.
+   * @return {import("../TileRange.js").default|null} Extent tile range for the specified zoom level.
+   */
+  getFullTileRange(t) {
+    return this.fullTileRanges_ ? this.fullTileRanges_[t] : this.extent_ ? this.getTileRangeForExtentAndZ(this.extent_, t) : null;
+  }
+  /**
+   * @param {number} resolution Resolution.
+   * @param {number|import("../array.js").NearestDirectionFunction} [opt_direction]
+   *     If 0, the nearest resolution will be used.
+   *     If 1, the nearest higher resolution (lower Z) will be used. If -1, the
+   *     nearest lower resolution (higher Z) will be used. Default is 0.
+   *     Use a {@link module:ol/array~NearestDirectionFunction} for more precise control.
+   *
+   * For example to change tile Z at the midpoint of zoom levels
+   * ```js
+   * function(value, high, low) {
+   *   return value - low * Math.sqrt(high / low);
+   * }
+   * ```
+   * @return {number} Z.
+   * @api
+   */
+  getZForResolution(t, n) {
+    const i = z(
+      this.resolutions_,
+      t,
+      n || 0
+    );
+    return Y(i, this.minZoom, this.maxZoom);
+  }
+  /**
+   * The tile with the provided tile coordinate intersects the given viewport.
+   * @param {import('../tilecoord.js').TileCoord} tileCoord Tile coordinate.
+   * @param {Array<number>} viewport Viewport as returned from {@link module:ol/extent.getRotatedViewport}.
+   * @return {boolean} The tile with the provided tile coordinate intersects the given viewport.
+   */
+  tileCoordIntersectsViewport(t, n) {
+    return X(
+      n,
+      0,
+      n.length,
+      2,
+      this.getTileCoordExtent(t)
+    );
+  }
+  /**
+   * @param {!import("../extent.js").Extent} extent Extent for this tile grid.
+   * @private
+   */
+  calculateTileRanges_(t) {
+    const n = this.resolutions_.length, i = new Array(n);
+    for (let e = this.minZoom; e < n; ++e)
+      i[e] = this.getTileRangeForExtentAndZ(t, e);
+    this.fullTileRanges_ = i;
+  }
+}
+const $ = C;
+export {
+  $ as default
+};

package/es/node_modules/.pnpm/ol@10.7.0/node_modules/ol/tilegrid/WMTS.mjs

@@ -0,0 +1,37 @@
+import "../proj.mjs";
+import e from "./TileGrid.mjs";
+class r extends e {
+  /**
+   * @param {Options} options WMTS options.
+   */
+  constructor(i) {
+    super({
+      extent: i.extent,
+      origin: i.origin,
+      origins: i.origins,
+      resolutions: i.resolutions,
+      tileSize: i.tileSize,
+      tileSizes: i.tileSizes,
+      sizes: i.sizes
+    }), this.matrixIds_ = i.matrixIds;
+  }
+  /**
+   * @param {number} z Z.
+   * @return {string} MatrixId..
+   */
+  getMatrixId(i) {
+    return this.matrixIds_[i];
+  }
+  /**
+   * Get the list of matrix identifiers.
+   * @return {Array<string>} MatrixIds.
+   * @api
+   */
+  getMatrixIds() {
+    return this.matrixIds_;
+  }
+}
+const l = r;
+export {
+  l as default
+};

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

@@ -0,0 +1,5 @@
+const E = 42, _ = 256;
+export {
+  E as DEFAULT_MAX_ZOOM,
+  _ as DEFAULT_TILE_SIZE
+};

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

@@ -0,0 +1,60 @@
+import { createOrUpdate as g, getCorner as h, getHeight as l, getWidth as d, containsCoordinate as E } from "./extent.mjs";
+import { get as a } from "./proj.mjs";
+import { toSize as T } from "./size.mjs";
+import w from "./tilegrid/TileGrid.mjs";
+import { DEFAULT_TILE_SIZE as F, DEFAULT_MAX_ZOOM as p } from "./tilegrid/common.mjs";
+import { METERS_PER_UNIT as M } from "./proj/Units.mjs";
+function L(e) {
+  let t = e.getDefaultTileGrid();
+  return t || (t = _(e), e.setDefaultTileGrid(t)), t;
+}
+function O(e, t, r) {
+  const n = t[0], o = e.getTileCoordCenter(t), i = u(r);
+  if (!E(i, o)) {
+    const f = d(i), s = Math.ceil(
+      (i[0] - o[0]) / f
+    );
+    return o[0] += f * s, e.getTileCoordForCoordAndZ(o, n);
+  }
+  return t;
+}
+function m(e, t, r, n) {
+  n = n !== void 0 ? n : "top-left";
+  const o = A(e, t, r);
+  return new w({
+    extent: e,
+    origin: h(e, n),
+    resolutions: o,
+    tileSize: r
+  });
+}
+function A(e, t, r, n) {
+  t = t !== void 0 ? t : p, r = T(r !== void 0 ? r : F);
+  const o = l(e), i = d(e);
+  n = n > 0 ? n : Math.max(i / r[0], o / r[1]);
+  const f = t + 1, s = new Array(f);
+  for (let c = 0; c < f; ++c)
+    s[c] = n / Math.pow(2, c);
+  return s;
+}
+function _(e, t, r, n) {
+  const o = u(e);
+  return m(o, t, r, n);
+}
+function u(e) {
+  e = a(e);
+  let t = e.getExtent();
+  if (!t) {
+    const r = 180 * M.degrees / e.getMetersPerUnit();
+    t = g(-r, -r, r, r);
+  }
+  return t;
+}
+export {
+  w as TileGrid,
+  m as createForExtent,
+  _ as createForProjection,
+  u as extentFromProjection,
+  L as getForProjection,
+  O as wrapX
+};

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

@@ -0,0 +1,51 @@
+import { modulo as i } from "./math.mjs";
+import { hash as m } from "./tilecoord.mjs";
+import { renderXYZTemplate as a } from "./uri.mjs";
+function g(n, r) {
+  return (
+    /**
+     * @param {import("./tilecoord.js").TileCoord} tileCoord Tile Coordinate.
+     * @param {number} pixelRatio Pixel ratio.
+     * @param {import("./proj/Projection.js").default} projection Projection.
+     * @return {string|undefined} Tile URL.
+     */
+    function(e, f, t) {
+      if (!e)
+        return;
+      let o;
+      const u = e[0];
+      if (r) {
+        const c = r.getFullTileRange(u);
+        c && (o = c.getHeight() - 1);
+      }
+      return a(n, u, e[1], e[2], o);
+    }
+  );
+}
+function T(n, r) {
+  const e = n.length, f = new Array(e);
+  for (let t = 0; t < e; ++t)
+    f[t] = g(n[t], r);
+  return p(f);
+}
+function p(n) {
+  return n.length === 1 ? n[0] : (
+    /**
+     * @param {import("./tilecoord.js").TileCoord} tileCoord Tile Coordinate.
+     * @param {number} pixelRatio Pixel ratio.
+     * @param {import("./proj/Projection.js").default} projection Projection.
+     * @return {string|undefined} Tile URL.
+     */
+    function(r, e, f) {
+      if (!r)
+        return;
+      const t = m(r), o = i(t, n.length);
+      return n[o](r, e, f);
+    }
+  );
+}
+export {
+  g as createFromTemplate,
+  T as createFromTemplates,
+  p as createFromTileUrlFunctions
+};

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

@@ -0,0 +1,50 @@
+import { assert as S } from "./asserts.mjs";
+new Array(6);
+function F() {
+  return [1, 0, 0, 1, 0, 0];
+}
+function j(n, t) {
+  return n[0] = t[0], n[1] = t[1], n[2] = t[2], n[3] = t[3], n[4] = t[4], n[5] = t[5], n;
+}
+function k(n, t) {
+  const i = t[0], c = t[1];
+  return t[0] = n[0] * i + n[2] * c + n[4], t[1] = n[1] * i + n[3] * c + n[5], t;
+}
+function q(n, t, i, c, e, l, o, p) {
+  const u = Math.sin(l), v = Math.cos(l);
+  return n[0] = c * v, n[1] = e * u, n[2] = -c * u, n[3] = e * v, n[4] = o * c * v - p * c * u + t, n[5] = o * e * u + p * e * v + i, n;
+}
+function w(n, t) {
+  const i = b(t);
+  S(i !== 0, "Transformation matrix cannot be inverted");
+  const c = t[0], e = t[1], l = t[2], o = t[3], p = t[4], u = t[5];
+  return n[0] = o / i, n[1] = -e / i, n[2] = -l / i, n[3] = c / i, n[4] = (l * u - o * p) / i, n[5] = -(c * u - e * p) / i, n;
+}
+function b(n) {
+  return n[0] * n[3] - n[1] * n[2];
+}
+const M = [1e5, 1e5, 1e5, 1e5, 2, 2];
+function x(n) {
+  return "matrix(" + n.join(", ") + ")";
+}
+function h(n) {
+  return n.substring(7, n.length - 1).split(",").map(parseFloat);
+}
+function I(n, t) {
+  const i = h(n), c = h(t);
+  for (let e = 0; e < 6; ++e)
+    if (Math.round((i[e] - c[e]) * M[e]) !== 0)
+      return !1;
+  return !0;
+}
+export {
+  k as apply,
+  q as compose,
+  F as create,
+  b as determinant,
+  I as equivalent,
+  h as fromString,
+  w as makeInverse,
+  j as setFromArray,
+  x as toString
+};

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

@@ -0,0 +1,41 @@
+function h(t, n) {
+  const e = [];
+  Object.keys(n).forEach(function(o) {
+    n[o] !== null && n[o] !== void 0 && e.push(o + "=" + encodeURIComponent(n[o]));
+  });
+  const r = e.join("&");
+  return t = t.replace(/[?&]$/, ""), t += t.includes("?") ? "&" : "?", t + r;
+}
+const a = /\{z\}/g, s = /\{x\}/g, d = /\{y\}/g, p = /\{-y\}/g;
+function i(t, n, e, r, o) {
+  return t.replace(a, n.toString()).replace(s, e.toString()).replace(d, r.toString()).replace(p, function() {
+    if (o === void 0)
+      throw new Error(
+        "If the URL template has a {-y} placeholder, the grid extent must be known"
+      );
+    return (o - r).toString();
+  });
+}
+function f(t) {
+  const n = [];
+  let e = /\{([a-z])-([a-z])\}/.exec(t);
+  if (e) {
+    const r = e[1].charCodeAt(0), o = e[2].charCodeAt(0);
+    let c;
+    for (c = r; c <= o; ++c)
+      n.push(t.replace(e[0], String.fromCharCode(c)));
+    return n;
+  }
+  if (e = /\{(\d+)-(\d+)\}/.exec(t), e) {
+    const r = parseInt(e[2], 10);
+    for (let o = parseInt(e[1], 10); o <= r; o++)
+      n.push(t.replace(e[0], o.toString()));
+    return n;
+  }
+  return n.push(t), n;
+}
+export {
+  h as appendParams,
+  f as expandUrl,
+  i as renderXYZTemplate
+};

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

@@ -0,0 +1,11 @@
+function e() {
+  throw new Error("Unimplemented abstract method.");
+}
+let r = 0;
+function n(t) {
+  return t.ol_uid || (t.ol_uid = String(++r));
+}
+export {
+  e as abstract,
+  n as getUid
+};

package/es/node_modules/.pnpm/quickselect@3.0.0/node_modules/quickselect/index.mjs

@@ -0,0 +1,27 @@
+function m(n, s, o = 0, c = n.length - 1, u = p) {
+  for (; c > o; ) {
+    if (c - o > 600) {
+      const i = c - o + 1, l = s - o + 1, d = Math.log(i), h = 0.5 * Math.exp(2 * d / 3), f = 0.5 * Math.sqrt(d * h * (i - h) / i) * (l - i / 2 < 0 ? -1 : 1), x = Math.max(o, Math.floor(s - l * h / i + f)), q = Math.min(c, Math.floor(s + (i - l) * h / i + f));
+      m(n, s, x, q, u);
+    }
+    const e = n[s];
+    let w = o, t = c;
+    for (M(n, o, s), u(n[c], e) > 0 && M(n, o, c); w < t; ) {
+      for (M(n, w, t), w++, t--; u(n[w], e) < 0; )
+        w++;
+      for (; u(n[t], e) > 0; )
+        t--;
+    }
+    u(n[o], e) === 0 ? M(n, o, t) : (t++, M(n, t, c)), t <= s && (o = t + 1), s <= t && (c = t - 1);
+  }
+}
+function M(n, s, o) {
+  const c = n[s];
+  n[s] = n[o], n[o] = c;
+}
+function p(n, s) {
+  return n < s ? -1 : n > s ? 1 : 0;
+}
+export {
+  m as default
+};