@nika-js/onlymap 0.4.6 → 0.5.1

package/dist/raster-D43jYSib.js

@@ -0,0 +1,4842 @@
+import Ae from "./index-CW1n5LdO.js";
+import { ak as Mt, al as Rt, am as tt, an as nt, ao as zt, b as Ft, ap as Dt, l as Ee, aq as Nt, d as Ut, ar as Bt, as as Gt, at as Kt, au as rt } from "./index-ppCRU8Eb.js";
+import { w as _t } from "./mgrs-BY9bIvp4.js";
+function Xt(e, t, n) {
+  const { projectedCorners: r } = t, { topLeft: o, topRight: i, bottomRight: s, bottomLeft: a } = r, l = n(o[0], o[1]), c = n(i[0], i[1]), u = n(s[0], s[1]), h = n(a[0], a[1]), p = [
+    l,
+    c,
+    u,
+    h,
+    l
+  ], d = [
+    (l[0] + u[0]) / 2,
+    (l[1] + u[1]) / 2
+  ], g = new Mt({
+    id: `${e}-label`,
+    data: [
+      {
+        position: d,
+        text: `x=${t.index.x} y=${t.index.y} z=${t.index.z}`
+      }
+    ],
+    getColor: [255, 255, 255, 255],
+    getSize: 24,
+    sizeUnits: "pixels",
+    outlineWidth: 3,
+    outlineColor: [0, 0, 0, 255],
+    fontSettings: { sdf: !0 }
+  });
+  return [new Rt({
+    id: e,
+    data: [p],
+    getPath: (y) => y,
+    getColor: [255, 0, 0, 255],
+    // Red
+    getWidth: 2,
+    widthUnits: "pixels",
+    pickable: !1
+  }), g];
+}
+const Wt = [
+  [1 / 3, 1 / 3, 1 / 3],
+  // centroid
+  [0.5, 0.5, 0],
+  // edge 0–1
+  [0.5, 0, 0.5],
+  // edge 0–2
+  [0, 0.5, 0.5]
+  // edge 1–2
+], Ht = 0.125;
+class kt {
+  reprojectors;
+  /** Width of the image in pixels */
+  width;
+  /** Height of the image in pixels */
+  height;
+  /**
+   * UV vertex coordinates (x, y), i.e.
+   * [x0, y0, x1, y1, ...]
+   *
+   * These coordinates are floats that range from [0, 1] in both X and Y.
+   */
+  uvs;
+  /**
+   * XY Positions in output CRS, computed via exact forward reprojection.
+   */
+  exactOutputPositions;
+  /**
+   * triangle vertex indices
+   */
+  triangles;
+  _halfedges;
+  /**
+   * The UV texture coordinates of candidates found from
+   * `findReprojectionCandidate`.
+   *
+   * Maybe in the future we'll want to store the barycentric coordinates instead
+   * of just the uv coordinates?
+   */
+  _candidatesUV;
+  _queueIndices;
+  _queue;
+  _errors;
+  _pending;
+  _pendingLen;
+  constructor(t, n, r = n) {
+    this.reprojectors = t, this.width = n, this.height = r, this.uvs = [], this.exactOutputPositions = [], this.triangles = [], this._halfedges = [], this._candidatesUV = [], this._queueIndices = [], this._queue = [], this._errors = [], this._pending = [], this._pendingLen = 0;
+    const o = 1, i = 1, s = this._addPoint(0, 0), a = this._addPoint(o, 0), l = this._addPoint(0, i), c = this._addPoint(o, i), u = this._addTriangle(c, s, l, -1, -1, -1);
+    this._addTriangle(s, c, a, u, -1, -1), this._flush();
+  }
+  /**
+   * Refine the mesh until its maximum error gets below the given one
+   *
+   * @param maxError The maximum reprojection error in input pixels that the mesh should achieve.
+   * @param maxIterations Optional safeguard to prevent infinite loops in case of non-convergence. If the mesh fails to converge within this number of iterations, a warning will be logged and the function will return early.
+   *
+   * @return  {[type]}  [return description]
+   */
+  run(t = Ht, { maxIterations: n = 1e4 } = {}) {
+    if (t <= 0)
+      throw new Error("maxError must be positive");
+    let r = 0;
+    for (; this.getMaxError() > t; )
+      if (this.refine(), ++r > n) {
+        console.warn(`RasterReprojector: mesh refinement did not converge after ${r} iterations (maxError=${t}, currentError=${this.getMaxError()})`);
+        break;
+      }
+  }
+  // refine the mesh with a single point
+  refine() {
+    this._step(), this._flush();
+  }
+  // max error of the current mesh
+  getMaxError() {
+    return this._errors[0];
+  }
+  // rasterize and queue all triangles that got added or updated in _step
+  _flush() {
+    for (let t = 0; t < this._pendingLen; t++) {
+      const n = this._pending[t];
+      this._findReprojectionCandidate(n);
+    }
+    this._pendingLen = 0;
+  }
+  /**
+   * Conversion of upstream's `_findCandidate` for reprojection error handling.
+   *
+   * @param t The index (into `this.triangles`) of the pending triangle to process.
+   *
+   * @return Doesn't return; instead modifies internal state.
+   */
+  _findReprojectionCandidate(t) {
+    const n = 2 * this.triangles[t * 3 + 0], r = 2 * this.triangles[t * 3 + 1], o = 2 * this.triangles[t * 3 + 2], i = this.uvs[n], s = this.uvs[n + 1], a = this.uvs[r], l = this.uvs[r + 1], c = this.uvs[o], u = this.uvs[o + 1], h = this.exactOutputPositions[n], p = this.exactOutputPositions[n + 1], d = this.exactOutputPositions[r], g = this.exactOutputPositions[r + 1], f = this.exactOutputPositions[o], y = this.exactOutputPositions[o + 1];
+    let j = 0, b = 0, S = 0;
+    for (const v of Wt) {
+      const L = re(i, a, c, v[0], v[1], v[2]), E = re(s, l, u, v[0], v[1], v[2]), M = re(h, d, f, v[0], v[1], v[2]), z = re(p, g, y, v[0], v[1], v[2]), I = L * (this.width - 1), J = E * (this.height - 1), q = this.reprojectors.inverseReproject(M, z), te = this.reprojectors.inverseTransform(q[0], q[1]), ne = I - te[0], It = J - te[1], Oe = Math.hypot(ne, It);
+      Oe > j && (j = Oe, b = L, S = E);
+    }
+    (b === i && S === s || b === a && S === l || b === c && S === u) && (j = 0), this._candidatesUV[2 * t] = b, this._candidatesUV[2 * t + 1] = S, this._queuePush(t, j);
+  }
+  // process the next triangle in the queue, splitting it with a new point
+  _step() {
+    const t = this._queuePop(), n = t * 3 + 0, r = t * 3 + 1, o = t * 3 + 2, i = this.triangles[n], s = this.triangles[r], a = this.triangles[o], l = this.uvs[2 * i], c = this.uvs[2 * i + 1], u = this.uvs[2 * s], h = this.uvs[2 * s + 1], p = this.uvs[2 * a], d = this.uvs[2 * a + 1], g = this._candidatesUV[2 * t], f = this._candidatesUV[2 * t + 1], y = this._addPoint(g, f);
+    if (ce(l, c, u, h, g, f) === 0)
+      this._handleCollinear(y, n);
+    else if (ce(u, h, p, d, g, f) === 0)
+      this._handleCollinear(y, r);
+    else if (ce(p, d, l, c, g, f) === 0)
+      this._handleCollinear(y, o);
+    else {
+      const j = this._halfedges[n], b = this._halfedges[r], S = this._halfedges[o], v = this._addTriangle(i, s, y, j, -1, -1, n), L = this._addTriangle(s, a, y, b, -1, v + 1), E = this._addTriangle(a, i, y, S, v + 2, L + 1);
+      this._legalize(v), this._legalize(L), this._legalize(E);
+    }
+  }
+  // add coordinates for a new vertex
+  _addPoint(t, n) {
+    const r = this.uvs.length >> 1;
+    this.uvs.push(t, n);
+    const o = t * (this.width - 1), i = n * (this.height - 1), s = this.reprojectors.forwardTransform(o, i), a = this.reprojectors.forwardReproject(s[0], s[1]);
+    return this.exactOutputPositions.push(a[0], a[1]), r;
+  }
+  // add or update a triangle in the mesh
+  _addTriangle(t, n, r, o, i, s, a = this.triangles.length) {
+    const l = a / 3;
+    return this.triangles[a + 0] = t, this.triangles[a + 1] = n, this.triangles[a + 2] = r, this._halfedges[a + 0] = o, this._halfedges[a + 1] = i, this._halfedges[a + 2] = s, o >= 0 && (this._halfedges[o] = a + 0), i >= 0 && (this._halfedges[i] = a + 1), s >= 0 && (this._halfedges[s] = a + 2), this._candidatesUV[2 * l + 0] = 0, this._candidatesUV[2 * l + 1] = 0, this._queueIndices[l] = -1, this._pending[this._pendingLen++] = l, a;
+  }
+  _legalize(t) {
+    const n = this._halfedges[t];
+    if (n < 0)
+      return;
+    const r = t - t % 3, o = n - n % 3, i = r + (t + 1) % 3, s = r + (t + 2) % 3, a = o + (n + 2) % 3, l = o + (n + 1) % 3, c = this.triangles[s], u = this.triangles[t], h = this.triangles[i], p = this.triangles[a], d = this.uvs;
+    if (!Zt(d[2 * c], d[2 * c + 1], d[2 * u], d[2 * u + 1], d[2 * h], d[2 * h + 1], d[2 * p], d[2 * p + 1]))
+      return;
+    const g = this._halfedges[i], f = this._halfedges[s], y = this._halfedges[a], j = this._halfedges[l];
+    this._queueRemove(r / 3), this._queueRemove(o / 3);
+    const b = this._addTriangle(c, p, h, -1, y, g, r), S = this._addTriangle(p, c, u, b, f, j, o);
+    this._legalize(b + 1), this._legalize(S + 2);
+  }
+  // handle a case where new vertex is on the edge of a triangle
+  _handleCollinear(t, n) {
+    const r = n - n % 3, o = r + (n + 1) % 3, i = r + (n + 2) % 3, s = this.triangles[i], a = this.triangles[n], l = this.triangles[o], c = this._halfedges[o], u = this._halfedges[i], h = this._halfedges[n];
+    if (h < 0) {
+      const E = this._addTriangle(t, s, a, -1, u, -1, r), M = this._addTriangle(s, t, l, E, -1, c);
+      this._legalize(E + 1), this._legalize(M + 2);
+      return;
+    }
+    const p = h - h % 3, d = p + (h + 2) % 3, g = p + (h + 1) % 3, f = this.triangles[d], y = this._halfedges[d], j = this._halfedges[g];
+    this._queueRemove(p / 3);
+    const b = this._addTriangle(s, a, t, u, -1, -1, r), S = this._addTriangle(a, f, t, j, -1, b + 1, p), v = this._addTriangle(f, l, t, y, -1, S + 1), L = this._addTriangle(l, s, t, c, b + 2, v + 1);
+    this._legalize(b), this._legalize(S), this._legalize(v), this._legalize(L);
+  }
+  // priority queue methods
+  _queuePush(t, n) {
+    const r = this._queue.length;
+    this._queueIndices[t] = r, this._queue.push(t), this._errors.push(n), this._queueUp(r);
+  }
+  _queuePop() {
+    const t = this._queue.length - 1;
+    return this._queueSwap(0, t), this._queueDown(0, t), this._queuePopBack();
+  }
+  _queuePopBack() {
+    const t = this._queue.pop();
+    return this._errors.pop(), this._queueIndices[t] = -1, t;
+  }
+  _queueRemove(t) {
+    const n = this._queueIndices[t];
+    if (n < 0) {
+      const o = this._pending.indexOf(t);
+      if (o !== -1)
+        this._pending[o] = this._pending[--this._pendingLen];
+      else
+        throw new Error("Broken triangulation (something went wrong).");
+      return;
+    }
+    const r = this._queue.length - 1;
+    r !== n && (this._queueSwap(n, r), this._queueDown(n, r) || this._queueUp(n)), this._queuePopBack();
+  }
+  _queueLess(t, n) {
+    return this._errors[t] > this._errors[n];
+  }
+  _queueSwap(t, n) {
+    const r = this._queue[t], o = this._queue[n];
+    this._queue[t] = o, this._queue[n] = r, this._queueIndices[r] = n, this._queueIndices[o] = t;
+    const i = this._errors[t];
+    this._errors[t] = this._errors[n], this._errors[n] = i;
+  }
+  _queueUp(t) {
+    let n = t;
+    for (; ; ) {
+      const r = n - 1 >> 1;
+      if (r === n || !this._queueLess(n, r))
+        break;
+      this._queueSwap(r, n), n = r;
+    }
+  }
+  _queueDown(t, n) {
+    let r = t;
+    for (; ; ) {
+      const o = 2 * r + 1;
+      if (o >= n || o < 0)
+        break;
+      const i = o + 1;
+      let s = o;
+      if (i < n && this._queueLess(i, o) && (s = i), !this._queueLess(s, r))
+        break;
+      this._queueSwap(r, s), r = s;
+    }
+    return r > t;
+  }
+}
+function ce(e, t, n, r, o, i) {
+  return (n - o) * (t - i) - (r - i) * (e - o);
+}
+function Zt(e, t, n, r, o, i, s, a) {
+  const l = e - s, c = t - a, u = n - s, h = r - a, p = o - s, d = i - a, g = l * l + c * c, f = u * u + h * h, y = p * p + d * d;
+  return l * (h * y - f * d) - c * (u * y - f * p) + g * (u * d - h * p) < 0;
+}
+function re(e, t, n, r, o, i) {
+  return r * e + o * t + i * n;
+}
+const Se = {
+  name: "create-texture-unorm",
+  inject: {
+    "fs:#decl": "uniform sampler2D textureName;",
+    "fs:DECKGL_FILTER_COLOR": (
+      /* glsl */
+      `
+      color = texture(textureName, geometry.uv);
+    `
+    )
+  },
+  getUniforms: (e) => ({
+    textureName: e.textureName
+  })
+}, Vt = (
+  /* glsl */
+  `#version 300 es
+#define SHADER_NAME simple-mesh-layer-fs
+
+precision highp float;
+
+in vec2 vTexCoord;
+in vec3 cameraPosition;
+in vec3 normals_commonspace;
+in vec4 position_commonspace;
+in vec4 vColor;
+
+out vec4 fragColor;
+
+void main(void) {
+  geometry.uv = vTexCoord;
+
+  vec3 normal;
+  if (simpleMesh.flatShading) {
+
+  normal = normalize(cross(dFdx(position_commonspace.xyz), dFdy(position_commonspace.xyz)));
+  } else {
+    normal = normals_commonspace;
+  }
+
+  // We initialize color here before passing into DECKGL_FILTER_COLOR
+  vec4 color;
+  DECKGL_FILTER_COLOR(color, geometry);
+
+  vec3 lightColor = lighting_getLightColor(color.rgb, cameraPosition, position_commonspace.xyz, normal);
+  fragColor = vec4(lightColor, color.a * layer.opacity);
+}
+`
+), Yt = {
+  ...tt.defaultProps,
+  // Note: putting `image` in defaultProps causes Maplibre to fail to render
+  // labels in interleaved mode 🤷‍♂️
+  // image: { type: "image", value: null, async: true },
+  renderPipeline: { type: "array", value: [], compare: !0 },
+  // Disable lighting by default (avoids darkening raster)
+  material: {
+    ambient: 1,
+    diffuse: 0,
+    shininess: 0,
+    specularColor: [0, 0, 0]
+  }
+};
+class Jt extends tt {
+  static layerName = "mesh-texture-layer";
+  static defaultProps = Yt;
+  _resolveRenderPipeline() {
+    const { image: t, renderPipeline: n } = this.props;
+    return [...t ? [{ module: Se, props: { textureName: t } }] : [], ...n ?? []];
+  }
+  updateState(t) {
+    this.hasRenderPipelineChanged(t) && (t.changeFlags.extensionsChanged = !0), super.updateState(t);
+  }
+  /** Returns true if the render pipeline has changed between the old and new props. */
+  hasRenderPipelineChanged(t) {
+    const { oldProps: n, props: r } = t;
+    if (!!n.image != !!r.image)
+      return !0;
+    const o = n.renderPipeline ?? [], i = r.renderPipeline ?? [];
+    if (o.length !== i.length)
+      return !0;
+    for (let s = 0; s < o.length; s++)
+      if (o[s]?.module.name !== i[s]?.module.name)
+        return !0;
+    return !1;
+  }
+  getShaders() {
+    const t = super.getShaders(), n = t.modules;
+    for (const r of this._resolveRenderPipeline())
+      n.push(r.module);
+    return {
+      ...t,
+      // Override upstream's fragment shader with our copy with modified
+      // injection points
+      fs: Vt,
+      modules: n
+    };
+  }
+  draw(t) {
+    const n = {};
+    for (const r of this._resolveRenderPipeline())
+      n[r.module.name] = r.props || {};
+    for (const r of super.getModels())
+      r.shaderInputs.setProps(n);
+    super.draw(t);
+  }
+}
+const qt = 0.125, Ie = [
+  [252, 73, 163],
+  // pink
+  [255, 51, 204],
+  // magenta-pink
+  [204, 102, 255],
+  // purple-ish
+  [153, 51, 255],
+  // deep purple
+  [102, 204, 255],
+  // sky blue
+  [51, 153, 255],
+  // clear blue
+  [102, 255, 204],
+  // teal
+  [51, 255, 170],
+  // aqua-teal
+  [0, 255, 0],
+  // lime green
+  [51, 204, 51],
+  // stronger green
+  [255, 204, 102],
+  // light orange
+  [255, 179, 71],
+  // golden-orange
+  [255, 102, 102],
+  // salmon
+  [255, 80, 80],
+  // red-salmon
+  [255, 0, 0],
+  // red
+  [204, 0, 0],
+  // crimson
+  [255, 128, 0],
+  // orange
+  [255, 153, 51],
+  // bright orange
+  [255, 255, 102],
+  // yellow
+  [255, 255, 51],
+  // lemon
+  [0, 255, 255],
+  // turquoise
+  [0, 204, 255]
+  // cyan
+], Qt = {
+  // A prop with `type: "image"` gets converted to a texture automatically by
+  // deck.gl (as long as async: true)
+  image: { type: "image", value: null, async: !0 },
+  renderPipeline: { type: "array", value: [], compare: !0 },
+  debug: !1,
+  debugOpacity: 0.5
+};
+class Tt extends nt {
+  static layerName = "RasterLayer";
+  static defaultProps = Qt;
+  initializeState() {
+    this.setState({});
+  }
+  updateState(t) {
+    super.updateState(t);
+    const { props: n, oldProps: r, changeFlags: o } = t, i = n.reprojectionFns.forwardTransform !== r.reprojectionFns?.forwardTransform || n.reprojectionFns.inverseTransform !== r.reprojectionFns?.inverseTransform || n.reprojectionFns.forwardReproject !== r.reprojectionFns?.forwardReproject || n.reprojectionFns.inverseReproject !== r.reprojectionFns?.inverseReproject;
+    (!!o.dataChanged || n.width !== r.width || n.height !== r.height || i || n.maxError !== r.maxError) && this._generateMesh();
+  }
+  _generateMesh() {
+    const { width: t, height: n, reprojectionFns: r, maxError: o = qt } = this.props, i = new kt(r, t + 1, n + 1);
+    i.run(o);
+    const { indices: s, positions: a, texCoords: l } = $t(i);
+    this.setState({
+      reprojector: i,
+      mesh: {
+        indices: { value: s, size: 1 },
+        attributes: {
+          POSITION: { value: a, size: 3 },
+          TEXCOORD_0: { value: l, size: 2 }
+        }
+      }
+    });
+  }
+  renderDebugLayer() {
+    const { reprojector: t } = this.state, { debugOpacity: n } = this.props;
+    return t ? new zt(this.getSubLayerProps({
+      id: "polygon",
+      // https://deck.gl/docs/developer-guide/performance#supply-binary-blobs-to-the-data-prop
+      // This `data` gets passed into `getPolygon` with the row index.
+      data: { reprojector: t, length: t.triangles.length / 3 },
+      getPolygon: (r, { index: o, data: i }) => {
+        const s = i.reprojector.triangles, a = t.exactOutputPositions, l = s[o * 3], c = s[o * 3 + 1], u = s[o * 3 + 2];
+        return [
+          [a[l * 2], a[l * 2 + 1]],
+          [a[c * 2], a[c * 2 + 1]],
+          [a[u * 2], a[u * 2 + 1]],
+          [a[l * 2], a[l * 2 + 1]]
+        ];
+      },
+      getFillColor: (r, { index: o, target: i }) => {
+        const s = Ie[o % Ie.length];
+        return i[0] = s[0], i[1] = s[1], i[2] = s[2], i[3] = 255, i;
+      },
+      getLineColor: [0, 0, 0],
+      getLineWidth: 1,
+      lineWidthUnits: "pixels",
+      opacity: n !== void 0 && Number.isFinite(n) ? Math.max(0, Math.min(1, n)) : 1,
+      pickable: !1
+    })) : null;
+  }
+  renderLayers() {
+    const { mesh: t } = this.state, { debug: n, image: r, renderPipeline: o } = this.props;
+    if (!t || !r && (o?.length ?? 0) === 0)
+      return null;
+    const s = [new Jt(this.getSubLayerProps({
+      id: "raster",
+      image: r,
+      renderPipeline: o,
+      // Dummy data because we're only rendering _one_ instance of this mesh
+      // https://github.com/visgl/deck.gl/blob/93111b667b919148da06ff1918410cf66381904f/modules/geo-layers/src/terrain-layer/terrain-layer.ts#L241
+      data: [1],
+      mesh: t,
+      // We're only rendering a single mesh, without instancing
+      // https://github.com/visgl/deck.gl/blob/93111b667b919148da06ff1918410cf66381904f/modules/geo-layers/src/terrain-layer/terrain-layer.ts#L244
+      _instanced: !1,
+      // Dummy accessors for the dummy data
+      // We place our mesh at the coordinate origin
+      getPosition: [0, 0, 0],
+      // We give a white color to turn off color mixing with the texture
+      getColor: [255, 255, 255]
+    }))];
+    if (n) {
+      const a = this.renderDebugLayer();
+      a && s.push(a);
+    }
+    return s;
+  }
+}
+function $t(e) {
+  const t = e.uvs.length / 2, n = new Float32Array(t * 3), r = new Float32Array(e.uvs);
+  for (let i = 0; i < t; i++)
+    n[i * 3] = e.exactOutputPositions[i * 2], n[i * 3 + 1] = e.exactOutputPositions[i * 2 + 1], n[i * 3 + 2] = 0;
+  return {
+    indices: new Uint32Array(e.triangles),
+    positions: n,
+    texCoords: r
+  };
+}
+class en {
+  levels;
+  projectTo3857;
+  projectFrom3857;
+  projectTo4326;
+  projectFrom4326;
+  projectedBounds;
+  constructor(t) {
+    if (t.levels.length === 0)
+      throw new Error("AffineTileset requires at least one level");
+    this.levels = t.levels, this.projectTo3857 = t.projectTo3857, this.projectFrom3857 = t.projectFrom3857, this.projectTo4326 = t.projectTo4326, this.projectFrom4326 = t.projectFrom4326, this.projectedBounds = t.levels[0].projectedBounds;
+  }
+}
+function Le(e, t) {
+  return [1, 0, e, 0, 1, t];
+}
+function tn(e, t = e) {
+  return [e, 0, 0, 0, t, 0];
+}
+function A([e, t, n, r, o, i], s, a) {
+  return [
+    e * s + t * a + n,
+    r * s + o * a + i
+  ];
+}
+function ae([e, t, n, r, o, i], [s, a, l, c, u, h]) {
+  return [
+    e * s + t * c,
+    e * a + t * u,
+    e * l + t * h + n,
+    r * s + o * c,
+    r * a + o * u,
+    r * l + o * h + i
+  ];
+}
+function de([e, t, n, r, o, i]) {
+  const s = e * o - t * r;
+  if (s === 0)
+    throw new Error("Cannot invert degenerate transform");
+  const a = 1 / s, l = o * a, c = -t * a, u = -r * a, h = e * a;
+  return [
+    l,
+    c,
+    -n * l - i * c,
+    u,
+    h,
+    -n * u - i * h
+  ];
+}
+function nn(e) {
+  return e[0];
+}
+function rn(e) {
+  return e[4];
+}
+class on {
+  tileWidth;
+  tileHeight;
+  matrixWidth;
+  matrixHeight;
+  metersPerPixel;
+  /**
+   * Source-CRS bounding box of the level's array `[minX, minY, maxX, maxY]`.
+   * Computed from the affine applied to the four array corners.
+   */
+  projectedBounds;
+  _affine;
+  _invAffine;
+  constructor(t) {
+    this._affine = t.affine, this._invAffine = de(t.affine), this.tileWidth = t.tileWidth, this.tileHeight = t.tileHeight, this.matrixWidth = Math.ceil(t.arrayWidth / t.tileWidth), this.matrixHeight = Math.ceil(t.arrayHeight / t.tileHeight);
+    const n = nn(t.affine), r = rn(t.affine);
+    this.metersPerPixel = Math.sqrt(Math.abs(n * r)) * t.mpu;
+    const o = [
+      A(t.affine, 0, 0),
+      A(t.affine, t.arrayWidth, 0),
+      A(t.affine, 0, t.arrayHeight),
+      A(t.affine, t.arrayWidth, t.arrayHeight)
+    ], i = o.map(([a]) => a), s = o.map(([, a]) => a);
+    this.projectedBounds = [
+      Math.min(...i),
+      Math.min(...s),
+      Math.max(...i),
+      Math.max(...s)
+    ];
+  }
+  projectedTileCorners(t, n) {
+    const r = this.tileWidth, o = this.tileHeight, i = this._affine;
+    return {
+      topLeft: A(i, t * r, n * o),
+      topRight: A(i, (t + 1) * r, n * o),
+      bottomLeft: A(i, t * r, (n + 1) * o),
+      bottomRight: A(i, (t + 1) * r, (n + 1) * o)
+    };
+  }
+  tileTransform(t, n) {
+    const r = Le(t * this.tileWidth, n * this.tileHeight), o = ae(this._affine, r), i = de(o);
+    return {
+      forwardTransform: (s, a) => A(o, s, a),
+      inverseTransform: (s, a) => A(i, s, a)
+    };
+  }
+  crsBoundsToTileRange(t, n, r, o) {
+    const i = this._invAffine, s = [
+      A(i, t, n),
+      A(i, r, n),
+      A(i, t, o),
+      A(i, r, o)
+    ], a = s.map(([L]) => L), l = s.map(([, L]) => L), c = Math.min(...a), u = Math.max(...a), h = Math.min(...l), p = Math.max(...l), d = this.tileWidth, g = this.tileHeight, f = this.matrixWidth - 1, y = this.matrixHeight - 1, j = Math.max(0, Math.floor(c / d)), b = Math.min(f, Math.floor(u / d)), S = Math.max(0, Math.floor(h / g)), v = Math.min(y, Math.floor(p / g));
+    return { minCol: j, maxCol: b, minRow: S, maxRow: v };
+  }
+}
+function sn(e, { semiMajorAxis: t } = {}) {
+  switch (e = e.toLowerCase(), e) {
+    case "m":
+    case "metre":
+    case "meter":
+    case "meters":
+      return 1;
+    case "foot":
+      return 0.3048;
+    case "us survey foot":
+      return 1200 / 3937;
+  }
+  if (e === "degree") {
+    if (t === void 0)
+      throw new Error("CRS with degrees unit requires ellipsoid semi-major-axis");
+    return 2 * Math.PI * t / 360;
+  }
+  throw new Error(`Unsupported CRS units: ${e} when computing metersPerUnit.`);
+}
+function ot(e) {
+  const t = _t(e);
+  return t.projName === "longlat" && (!t.units || t.units === "unknown") && (t.units = "degree", t.to_meter = void 0), t;
+}
+const Me = /* @__PURE__ */ new Map();
+async function an(e) {
+  const t = `EPSG:${e}`, n = Me.get(t);
+  if (n !== void 0)
+    return n;
+  const r = await ln(e), o = ot(r);
+  return Me.set(t, o), o;
+}
+async function ln(e) {
+  const t = `https://epsg.io/${e}.json`, n = await fetch(t);
+  if (!n.ok)
+    throw new Error(`Failed to fetch PROJJSON from ${t}`);
+  return await n.json();
+}
+function pe(e, t, n, r, o, i = {}) {
+  const { densifyPts: s = 21 } = i, a = [t, r, r, t], l = [n, n, o, o];
+  let c = 1 / 0, u = 1 / 0, h = -1 / 0, p = -1 / 0;
+  for (let d = 0; d < 4; d++) {
+    const g = a[d], f = l[d], y = a[(d + 1) % 4], j = l[(d + 1) % 4];
+    for (let b = 0; b <= s; b++) {
+      const S = b / (s + 1), [v, L] = e(g + (y - g) * S, f + (j - f) * S);
+      v < c && (c = v), L < u && (u = L), v > h && (h = v), L > p && (p = L);
+    }
+  }
+  return [c, u, h, p];
+}
+const Re = 6378137, ze = 85.05112877980659;
+function cn(e, t) {
+  const n = e * Math.PI * Re / 180, r = t * Math.PI / 180, o = Math.log(Math.tan(Math.PI / 4 + r / 2)) * Re;
+  return [n, o];
+}
+function un(e, t) {
+  return (n, r) => {
+    const [o, i] = e(n, r);
+    if (Number.isFinite(o) && Number.isFinite(i))
+      return [o, i];
+    const [s, a] = t(n, r), l = Math.max(-ze, Math.min(ze, a));
+    return cn(s, l);
+  };
+}
+const hn = 65536;
+class it {
+  entries = /* @__PURE__ */ new Map();
+  maxEntries;
+  constructor({ maxEntries: t = hn } = {}) {
+    this.maxEntries = Math.max(0, t);
+  }
+  /** Number of cached entries. */
+  get size() {
+    return this.entries.size;
+  }
+  /**
+   * Look up the cached bounding volume for tile `(z, x, y)`. On a hit the entry
+   * is marked most-recently-used. Returns `undefined` on a miss.
+   */
+  get(t, n, r) {
+    const o = `${t}/${n}/${r}`, i = this.entries.get(o);
+    if (i !== void 0)
+      return this.entries.delete(o), this.entries.set(o, i), i;
+  }
+  /** Store the bounding volume for tile `(z, x, y)` as most-recently-used. */
+  set(t, n, r, o) {
+    const i = `${t}/${n}/${r}`;
+    this.entries.delete(i), this.entries.set(i, o);
+  }
+  /**
+   * If the cache is over its soft cap, drop least-recently-used entries down to
+   * roughly half of `maxEntries`. No-op when at or under the cap. Call once at
+   * the start of a traversal, never mid-traversal.
+   */
+  sweep() {
+    if (this.entries.size <= this.maxEntries)
+      return;
+    const t = Math.floor(this.maxEntries / 2), n = this.entries.size - t, r = [];
+    for (const o of this.entries.keys())
+      if (r.push(o), r.length >= n)
+        break;
+    for (const o of r)
+      this.entries.delete(o);
+  }
+}
+const Fe = 512, dn = [
+  [0.5, 0.5],
+  // center
+  [0, 0],
+  // top-left
+  [0, 1],
+  // bottom-left
+  [1, 0],
+  // top-right
+  [1, 1]
+  // bottom-right
+], pn = dn.concat([
+  [0, 0.5],
+  // left edge
+  [0.5, 0],
+  // top edge
+  [1, 0.5],
+  // right edge
+  [0.5, 1]
+  // bottom edge
+]), me = 6378137, ge = 2 * Math.PI * me, De = ge / 2, Ne = 85.05112877980659;
+class ie {
+  /** Index across a row */
+  x;
+  /** Index down a column */
+  y;
+  /** Zoom index assumed to be (higher = finer detail) */
+  z;
+  descriptor;
+  /**
+   * Flag indicating whether any descendant of this tile is visible.
+   *
+   * Used to prevent loading parent tiles when children are visible (avoids
+   * overdraw).
+   */
+  childVisible;
+  /**
+   * Flag indicating this tile should be rendered
+   *
+   * Set to `true` when this is the appropriate LOD for its distance from camera.
+   */
+  selected;
+  /** A cache of the children of this node. */
+  _children;
+  constructor(t, n, r, { descriptor: o }) {
+    this.x = t, this.y = n, this.z = r, this.descriptor = o;
+  }
+  /** Get the level info for this tile's z index. */
+  get level() {
+    return this.descriptor.levels[this.z];
+  }
+  /** Get the children of this node.
+   *
+   * Find all tiles at level this.z + 1 whose spatial extent overlaps this tile.
+   *
+   * A tileset pyramid is not guaranteed to be a quadtree — it is a stack of
+   * independent grids. We find children by mapping the parent tile's CRS bounds
+   * into the child grid using {@link RasterTilesetLevel.crsBoundsToTileRange}.
+   */
+  get children() {
+    if (!this._children) {
+      const t = this.descriptor.levels.length - 1;
+      if (this.z >= t)
+        return this._children = null, null;
+      const n = this.z + 1, r = this.descriptor.levels[n], o = this.level.projectedTileCorners(this.x, this.y), i = Sn(o), { minCol: s, maxCol: a, minRow: l, maxRow: c } = r.crsBoundsToTileRange(...i), u = [], { descriptor: h } = this;
+      for (let p = l; p <= c; p++)
+        for (let d = s; d <= a; d++)
+          u.push(new ie(d, p, n, { descriptor: h }));
+      this._children = u.length > 0 ? u : null;
+    }
+    return this._children;
+  }
+  /**
+   * Recursively traverse the tile pyramid to determine if this tile (or its
+   * descendants) should be rendered.
+   *
+   * I.e. "Given this tile node, should I render this tile, or should I recurse
+   * into its children?"
+   *
+   * The algorithm performs:
+   * 1. Visibility culling - reject tiles outside the view frustum
+   * 2. Bounds checking - reject tiles outside the specified geographic bounds
+   * 3. LOD selection - choose appropriate zoom level based on distance from camera
+   * 4. Recursive subdivision - if LOD is insufficient, test child tiles
+   *
+   * Additionally, there should never be overdraw, i.e. a tile should never be
+   * rendered if any of its descendants are rendered.
+   *
+   * @returns true if this tile or any descendant is visible, false otherwise
+   */
+  update(t) {
+    this.childVisible = !1, this.selected = !1;
+    const { viewport: n, cullingVolume: r, elevationBounds: o, minZ: i, maxZ: s = this.descriptor.levels.length - 1, project: a, bounds: l, pixelRatio: c, boundingVolumeCache: u } = t, { boundingVolume: h, commonSpaceBounds: p } = this.getBoundingVolume(o, a, u);
+    if (l && !this.insideBounds(l, p) || r.computeVisibility(h) < 0)
+      return !1;
+    const g = this.children;
+    if (!this.childVisible && this.z >= i) {
+      const f = vn(h, n.zoom);
+      if (this.level.metersPerPixel * c / f <= 1 || this.z >= s || g === null && this.z >= i)
+        return this.selected = !0, !0;
+    }
+    if (g && g.length > 0) {
+      this.selected = !1;
+      let f = !1;
+      for (const y of g)
+        y.update(t) && (f = !0);
+      return this.childVisible = f, f;
+    }
+    return !0;
+  }
+  /**
+   * Collect all tiles marked as selected in the tree.
+   * Recursively traverses the entire tree and gathers tiles where selected=true.
+   *
+   * @param result - Accumulator array for selected tiles
+   * @returns Array of selected RasterTileNode tiles
+   */
+  getSelected(t = []) {
+    if (this.selected && t.push(this), this._children)
+      for (const n of this._children)
+        n.getSelected(t);
+    return t;
+  }
+  /**
+   * Test if this tile intersects the specified bounds in Web Mercator space.
+   * Used to filter tiles when only a specific geographic region is needed.
+   *
+   * @param bounds - [minX, minY, maxX, maxY] in Web Mercator units (0-512)
+   * @returns true if tile overlaps the bounds
+   */
+  insideBounds(t, n) {
+    const [r, o, i, s] = t, [a, l, c, u] = n;
+    return a < i && c > r && l < s && u > o;
+  }
+  /**
+   * The 3D bounding volume for this tile in deck.gl's common coordinate space,
+   * used for frustum culling.
+   *
+   * Memoized in `boundingVolumeCache` (keyed by `z/x/y`): a tile's bounding
+   * volume depends only on `(z, x, y, zRange)` for a given descriptor, so on a
+   * cache hit it is returned without rerunning {@link computeBoundingVolume}'s
+   * proj4 reprojections + oriented-bounding-box fit.
+   */
+  getBoundingVolume(t, n, r) {
+    const o = r.get(this.z, this.x, this.y);
+    if (o && o.zRange[0] === t[0] && o.zRange[1] === t[1])
+      return o;
+    const i = this.computeBoundingVolume(t, n);
+    return r.set(this.z, this.x, this.y, { zRange: t, ...i }), i;
+  }
+  /**
+   * Compute (without caching) the 3D bounding volume for this tile in deck.gl's
+   * common coordinate space.
+   *
+   * TODO: In the future, we can add a fast path in the case that the source
+   * tiling is already in EPSG:3857.
+   */
+  computeBoundingVolume(t, n) {
+    return n && Ut(!1, "TODO: implement getBoundingVolume in Globe view"), this._getGenericBoundingVolume(t);
+  }
+  /**
+   * Generic case - sample reference points and reproject to Web Mercator, then
+   * convert to deck.gl common space
+   *
+   */
+  _getGenericBoundingVolume(t) {
+    const [n, r] = t, o = this.level.projectedTileCorners(this.x, this.y), s = gn(pn, o, this.descriptor.projectTo3857, this.descriptor.projectTo4326).map((d) => fn(d)), a = [];
+    for (const d of s)
+      a.push([d[0], d[1], n]), n !== r && a.push([d[0], d[1], r]);
+    let l = Number.POSITIVE_INFINITY, c = Number.POSITIVE_INFINITY, u = Number.NEGATIVE_INFINITY, h = Number.NEGATIVE_INFINITY;
+    for (const [d, g] of s)
+      d < l && (l = d), g < c && (c = g), d > u && (u = d), g > h && (h = g);
+    const p = [l, c, u, h];
+    return {
+      boundingVolume: Bt(a),
+      commonSpaceBounds: p
+    };
+  }
+}
+function mn(e, t) {
+  return (n, r) => {
+    const [o, i] = e(n, r);
+    if (Number.isFinite(o) && Number.isFinite(i))
+      return [o, i];
+    const [s, a] = t(n, r), c = Math.max(-Ne, Math.min(Ne, a)) * Math.PI / 180, u = s * Math.PI * me / 180, h = Math.log(Math.tan(Math.PI / 4 + c / 2)) * me;
+    return [u, h];
+  };
+}
+function gn(e, t, n, r) {
+  const { topLeft: o, topRight: i, bottomLeft: s, bottomRight: a } = t, l = mn(n, r), c = [];
+  for (const [u, h] of e) {
+    const [p, d] = Ln(o, i, s, a, u, h);
+    c.push(l(p, d));
+  }
+  return c;
+}
+function fn([e, t]) {
+  const n = Math.max(-De, Math.min(De, t));
+  return [
+    (e / ge + 0.5) * Fe,
+    (n / ge + 0.5) * Fe
+  ];
+}
+const yn = 100;
+function wn(e) {
+  const { descriptor: t, viewport: n, datasetWgs84Bounds: r } = e, o = t.levels[0], i = [];
+  if (o.matrixWidth * o.matrixHeight <= yn) {
+    for (let g = 0; g < o.matrixHeight; g++)
+      for (let f = 0; f < o.matrixWidth; f++)
+        i.push(new ie(f, g, 0, { descriptor: t }));
+    return i;
+  }
+  const a = n.getBounds(), l = [
+    Math.max(r[0], a[0]),
+    Math.max(r[1], a[1]),
+    Math.min(r[2], a[2]),
+    Math.min(r[3], a[3])
+  ];
+  if (l[0] > l[2] || l[1] > l[3])
+    return i;
+  const [c, u, h, p] = pe(t.projectFrom4326, l[0], l[1], l[2], l[3]), d = o.crsBoundsToTileRange(c, u, h, p);
+  for (let g = d.minRow; g <= d.maxRow; g++)
+    for (let f = d.minCol; f <= d.maxCol; f++)
+      i.push(new ie(f, g, 0, { descriptor: t }));
+  return i;
+}
+function Pn(e, t) {
+  const { viewport: n, maxZ: r, zRange: o, wgs84Bounds: i, pixelRatio: s = 1 } = t, a = t.boundingVolumeCache ?? new it();
+  a.sweep();
+  const l = n instanceof Ft && n.resolution ? n.projectPosition : null, c = Object.values(n.getFrustumPlanes()).map(({ normal: I, distance: J }) => new Dt(I.clone().negate(), J)), u = new Nt(c), h = n.distanceScales.unitsPerMeter[2], p = o && o[0] * h || 0, d = o && o[1] * h || 0, g = 0, [f, y, j, b] = i, S = Ee([f, y]), v = Ee([j, b]), L = [
+    S[0],
+    S[1],
+    v[0],
+    v[1]
+  ], E = wn({
+    descriptor: e,
+    viewport: n,
+    datasetWgs84Bounds: i
+  }), M = {
+    viewport: n,
+    project: l,
+    cullingVolume: u,
+    elevationBounds: [p, d],
+    minZ: g,
+    maxZ: r,
+    bounds: L,
+    pixelRatio: s,
+    boundingVolumeCache: a
+  };
+  for (const I of E)
+    I.update(M);
+  const z = [];
+  for (const I of E)
+    I.getSelected(z);
+  return z;
+}
+function bn(e, t) {
+  return 40075016686e-3 * Math.cos(e * Math.PI / 180) / 2 ** (t + 8);
+}
+function vn(e, t) {
+  const [n, r] = Gt(e.center);
+  return bn(r, t);
+}
+function Sn({ topLeft: e, topRight: t, bottomLeft: n, bottomRight: r }) {
+  const o = [e[0], t[0], n[0], r[0]], i = [e[1], t[1], n[1], r[1]];
+  return [Math.min(...o), Math.min(...i), Math.max(...o), Math.max(...i)];
+}
+function Ln(e, t, n, r, o, i) {
+  const s = (1 - o) * (1 - i), a = o * (1 - i), l = (1 - o) * i, c = o * i;
+  return [
+    e[0] * s + t[0] * a + n[0] * l + r[0] * c,
+    e[1] * s + t[1] * a + n[1] * l + r[1] * c
+  ];
+}
+function Cn(e, t) {
+  const n = e.length;
+  if (n < 2)
+    return e;
+  const { getCenter: r, reference: o } = t, i = o[0], s = o[1], a = new Float64Array(n);
+  for (let u = 0; u < n; u++) {
+    const h = r(e[u]), p = h[0] - i, d = h[1] - s;
+    a[u] = p * p + d * d;
+  }
+  const l = new Uint32Array(n);
+  for (let u = 0; u < n; u++)
+    l[u] = u;
+  l.sort((u, h) => a[u] - a[h]);
+  const c = e.slice();
+  for (let u = 0; u < n; u++)
+    e[u] = c[l[u]];
+  return e;
+}
+function jn(e, t, n) {
+  const [r, o, i, s] = t.getBounds(), a = [
+    (r + i) / 2,
+    (o + s) / 2
+  ];
+  return Cn(e, {
+    reference: a,
+    getCenter: n
+  });
+}
+class xn extends Kt {
+  descriptor;
+  wgs84Bounds;
+  getPixelRatio;
+  boundingVolumeCache;
+  constructor(t, n, { getPixelRatio: r, maxBoundingVolumeCacheSize: o } = {}) {
+    super(t), this.descriptor = n, this.getPixelRatio = r ?? (() => 1), this.boundingVolumeCache = new it({
+      maxEntries: o
+    });
+    const i = pe(this.descriptor.projectTo4326, ...this.descriptor.projectedBounds), s = 85.0511287798066;
+    this.wgs84Bounds = [
+      i[0],
+      Math.max(i[1], -s),
+      i[2],
+      Math.min(i[3], s)
+    ];
+  }
+  /**
+   * Get tile indices visible in viewport
+   * Uses frustum culling similar to OSM implementation
+   *
+   * Overviews follow TileMatrixSet ordering: index 0 = coarsest, higher = finer
+   *
+   * `minZoom` and `maxZoom` gate against `viewport.zoom` (not the tileset
+   * z-index, which is an overview level in our descriptor). When the
+   * viewport zoom is outside these bounds this method returns an empty
+   * list — no new tile fetches, and because deck.gl's `updateTileStates`
+   * marks unselected cached tiles invisible, no rendering either.
+   * `visibleMinZoom` / `visibleMaxZoom` (deck.gl 9.3+) are deliberately
+   * not honored: their documented "fetch but don't render" semantic
+   * requires a notion of clamping to a coarser z, which doesn't
+   * generalize to descriptors with sparse or single overviews. See
+   * `dev-docs/zoom-terminology.md` for the rationale.
+   */
+  getTileIndices(t) {
+    const { viewport: n, minZoom: r } = t;
+    if (typeof r == "number" && n.zoom < r)
+      return [];
+    const o = this.descriptor.levels.length - 1, i = typeof t.maxZoom == "number" ? Math.min(t.maxZoom, o) : o, s = Pn(this.descriptor, {
+      viewport: n,
+      maxZ: i,
+      zRange: t.zRange ?? null,
+      wgs84Bounds: this.wgs84Bounds,
+      pixelRatio: this.getPixelRatio(),
+      boundingVolumeCache: this.boundingVolumeCache
+    });
+    return this.sortTileIndicesByDistance(s, n);
+  }
+  /**
+   * Sort tile indices by ascending distance from the viewport center in
+   * projected (common/world) space so loads initiate center-out.
+   *
+   * Short-circuits when `tileIndices.length <= maxRequests` — all fetches
+   * would start concurrently regardless of order in that case. Mutates and
+   * returns `tileIndices`.
+   */
+  sortTileIndicesByDistance(t, n) {
+    const { maxRequests: r } = this.opts;
+    if (t.length <= r)
+      return t;
+    const o = this.descriptor;
+    return jn(t, n, (i) => {
+      const { x: s, y: a, z: l } = i, { topLeft: c, bottomRight: u } = o.levels[l].projectedTileCorners(s, a), h = [
+        (c[0] + u[0]) / 2,
+        (c[1] + u[1]) / 2
+      ];
+      return o.projectTo4326(h[0], h[1]);
+    });
+  }
+  getTileId(t) {
+    return `${t.x}-${t.y}-${t.z}`;
+  }
+  getParentIndex(t) {
+    if (t.z === 0)
+      return t;
+    const n = this.descriptor.levels[t.z], r = this.descriptor.levels[t.z - 1], o = r.metersPerPixel * r.tileWidth, i = r.metersPerPixel * r.tileHeight, s = n.metersPerPixel * n.tileWidth, a = n.metersPerPixel * n.tileHeight, l = o / s, c = i / a;
+    return {
+      x: Math.floor(t.x / l),
+      y: Math.floor(t.y / c),
+      z: t.z - 1
+    };
+  }
+  getTileZoom(t) {
+    return t.z;
+  }
+  getTileMetadata(t) {
+    const { x: n, y: r, z: o } = t, i = this.descriptor.levels[o], { tileHeight: s, tileWidth: a } = i, { topLeft: l, topRight: c, bottomLeft: u, bottomRight: h } = i.projectedTileCorners(n, r), p = {
+      topLeft: l,
+      topRight: c,
+      bottomLeft: u,
+      bottomRight: h
+    }, d = [
+      Math.min(l[0], c[0], u[0], h[0]),
+      Math.min(l[1], c[1], u[1], h[1]),
+      Math.max(l[0], c[0], u[0], h[0]),
+      Math.max(l[1], c[1], u[1], h[1])
+    ], [g, f, y, j] = pe(this.descriptor.projectTo4326, ...d), { forwardTransform: b, inverseTransform: S } = i.tileTransform(n, r);
+    return {
+      bbox: {
+        west: g,
+        south: f,
+        east: y,
+        north: j
+      },
+      projectedBbox: {
+        left: d[0],
+        bottom: d[1],
+        right: d[2],
+        top: d[3]
+      },
+      projectedCorners: p,
+      tileWidth: a,
+      tileHeight: s,
+      forwardTransform: b,
+      inverseTransform: S
+    };
+  }
+}
+const fe = 512, On = 40075016686e-3, Ue = fe / On, An = {
+  ...rt.defaultProps,
+  maxError: 0.125,
+  debug: !1,
+  debugOpacity: 0.5
+};
+class Be extends nt {
+  static layerName = "RasterTileLayer";
+  static defaultProps = An;
+  /**
+   * The currently effective {@link RasterTilesetDescriptor}.
+   *
+   * Subclasses override this to return a descriptor built from their own
+   * async-parsed state. Returns `undefined` while the source is still
+   * loading; `renderLayers()` returns `null` in that case.
+   *
+   * The inline cast to `RasterTileLayerProps<DataT>` is required because
+   * `tilesetDescriptor` is declared on `ExtraProps`, not on the base's
+   * `RasterTileLayerBaseProps`. For direct use the default `ExtraProps`
+   * brings it in; for subclass use this method is overridden and the cast
+   * is never reached.
+   */
+  _tilesetDescriptor() {
+    return this.props.tilesetDescriptor;
+  }
+  /**
+   * The currently effective tile-fetch callback.
+   *
+   * Subclasses override this to adapt their user-facing `getTileData`
+   * signature into the base's `(tile, options) => Promise<DataT>` shape.
+   * Returns `undefined` when the callback is not yet available.
+   */
+  _getTileDataCallback() {
+    return this.props.getTileData;
+  }
+  /**
+   * The currently effective per-tile render callback.
+   *
+   * Subclasses override this to thread their user-facing `renderTile` and
+   * any inferred default. Returns `undefined` when no callback is available.
+   */
+  _renderTileCallback() {
+    return this.props.renderTile;
+  }
+  /**
+   * Hook for rendering per-tile debug overlay sub-layers.
+   *
+   * Called once per tile from `_renderSubLayers` only when `props.debug` is
+   * `true`. The hook fires both before data has arrived (`data` is `null`) and
+   * after (`data` is the fetched `DataT`), so the default outline can render
+   * during loading.
+   *
+   * Default behavior renders the primary tile boundary via
+   * {@link renderDebugTileOutline} using the active descriptor. Subclasses can
+   * override to replace, extend (via `super._renderDebug(...)`), or suppress
+   * the default — for example, a multi-source layer can replace the default
+   * with per-band tile outlines and tiered metadata labels once `data` is
+   * available.
+   */
+  _renderDebug(t, n) {
+    const r = this._tilesetDescriptor();
+    return r ? Xt(`${this.id}-${t.id}-bounds`, t, r.projectTo4326) : [];
+  }
+  renderLayers() {
+    const t = this._tilesetDescriptor(), n = this._getTileDataCallback(), r = this._renderTileCallback();
+    return !t || !n || !r ? null : this._renderTileLayer(t, n, r);
+  }
+  _renderTileLayer(t, n, r) {
+    const o = this.context.device;
+    class i extends xn {
+      constructor(E) {
+        super(E, t, {
+          getPixelRatio: () => {
+            const M = o.getDefaultCanvasContext(), [z] = M.getDrawingBufferSize(), [I] = M.getCSSSize();
+            return I ? z / I : 1;
+          }
+        });
+      }
+    }
+    const { tileSize: s, zoomOffset: a, maxZoom: l, minZoom: c, extent: u, debounceTime: h, maxCacheSize: p, maxCacheByteSize: d, maxRequests: g, refinementStrategy: f, updateTriggers: y, onTileError: j, onTileLoad: b, onTileUnload: S, onViewportLoad: v } = this.props;
+    return new rt({
+      id: `raster-tile-layer-${this.id}`,
+      TilesetClass: i,
+      getTileData: (L) => this._wrapGetTileData(L, n),
+      renderSubLayers: (L) => this._renderSubLayers(L, t, r),
+      updateTriggers: {
+        renderSubLayers: y?.renderTile
+      },
+      tileSize: s,
+      zoomOffset: a,
+      maxZoom: l,
+      minZoom: c,
+      extent: u,
+      debounceTime: h,
+      maxCacheSize: p,
+      maxCacheByteSize: d,
+      maxRequests: g,
+      refinementStrategy: f,
+      onTileError: j,
+      onTileLoad: b,
+      onTileUnload: S,
+      onViewportLoad: v
+    });
+  }
+  async _wrapGetTileData(t, n) {
+    const { signal: r } = t, o = this.props.signal, i = o && r ? AbortSignal.any([o, r]) : o ?? r, s = {
+      device: this.context.device,
+      signal: i
+    };
+    return n(t, s);
+  }
+  _renderSubLayers(t, n, r) {
+    const { maxError: o, debug: i, debugOpacity: s } = this.props, a = t.tile, l = i ? this._renderDebug(a, t.data ?? null) : [];
+    if (!t.data)
+      return l;
+    const { forwardTransform: c, inverseTransform: u } = a, h = r(t.data);
+    if (!h)
+      return l;
+    const { image: p, renderPipeline: d } = h, { width: g, height: f } = t.data, y = this.context.viewport.resolution !== void 0, j = y ? {
+      forwardTransform: c,
+      inverseTransform: u,
+      forwardReproject: n.projectTo4326,
+      inverseReproject: n.projectFrom4326
+    } : {
+      forwardTransform: c,
+      inverseTransform: u,
+      forwardReproject: n.projectTo3857,
+      inverseReproject: n.projectFrom3857
+    }, b = y ? {} : {
+      coordinateSystem: "cartesian",
+      coordinateOrigin: [fe / 2, fe / 2, 0],
+      // biome-ignore format: array
+      modelMatrix: [
+        Ue,
+        0,
+        0,
+        0,
+        0,
+        Ue,
+        0,
+        0,
+        0,
+        0,
+        1,
+        0,
+        0,
+        0,
+        0,
+        1
+      ]
+    };
+    return [new Tt(this.getSubLayerProps({
+      id: `${t.id}-raster`,
+      width: g,
+      height: f,
+      // Passing `image: undefined` explicitly would trip isAsyncPropLoading
+      // and cause a transient black flash (see issue #376).
+      ...p !== void 0 && { image: p },
+      renderPipeline: d,
+      maxError: o,
+      reprojectionFns: j,
+      debug: i,
+      debugOpacity: s,
+      ...b
+    })), ...l];
+  }
+}
+function En(e, t) {
+  const n = e.length / 3, r = new Uint8ClampedArray(n * 4), o = 0, i = n, s = n * 2;
+  for (let a = 0; a < n; a++)
+    r[4 * a + 0] = e[o + a] >> 8, r[4 * a + 1] = e[i + a] >> 8, r[4 * a + 2] = e[s + a] >> 8, r[4 * a + 3] = 255;
+  return new ImageData(r, n, 1);
+}
+var ye;
+(function(e) {
+  e[e.Big = 19789] = "Big", e[e.Little = 18761] = "Little";
+})(ye || (ye = {}));
+var $;
+(function(e) {
+  e[e.ReducedImage = 1] = "ReducedImage", e[e.Page = 2] = "Page", e[e.Mask = 4] = "Mask";
+})($ || ($ = {}));
+var Ge;
+(function(e) {
+  e[e.TopLeft = 1] = "TopLeft", e[e.TopRight = 2] = "TopRight", e[e.BottomRight = 3] = "BottomRight", e[e.BottomLeft = 4] = "BottomLeft", e[e.LeftTop = 5] = "LeftTop", e[e.RightTOP = 6] = "RightTOP", e[e.RightBottom = 7] = "RightBottom", e[e.LeftBottom = 8] = "LeftBottom";
+})(Ge || (Ge = {}));
+var we;
+(function(e) {
+  e[e.PixelIsArea = 1] = "PixelIsArea", e[e.PixelIsPoint = 2] = "PixelIsPoint";
+})(we || (we = {}));
+var G;
+(function(e) {
+  e[e.Unknown = 0] = "Unknown", e[e.Projected = 1] = "Projected", e[e.Geographic = 2] = "Geographic", e[e.Geocentric = 3] = "Geocentric", e[e.UserDefined = 32767] = "UserDefined";
+})(G || (G = {}));
+var Ke;
+(function(e) {
+  e[e.Image = 1] = "Image", e[e.ReducedImage = 2] = "ReducedImage", e[e.Page = 3] = "Page";
+})(Ke || (Ke = {}));
+var P;
+(function(e) {
+  e[e.None = 1] = "None", e[e.Ccittrle = 2] = "Ccittrle", e[e.CcittT4 = 3] = "CcittT4", e[e.CcittT6 = 4] = "CcittT6", e[e.Lzw = 5] = "Lzw", e[e.Jpeg6 = 6] = "Jpeg6", e[e.Jpeg = 7] = "Jpeg", e[e.DeflateOther = 8] = "DeflateOther", e[e.T85 = 9] = "T85", e[e.T43 = 10] = "T43", e[e.Next = 32766] = "Next", e[e.Ccittrlew = 32771] = "Ccittrlew", e[e.PackBits = 32773] = "PackBits", e[e.ThunderScan = 32809] = "ThunderScan", e[e.It8ctpad = 32895] = "It8ctpad", e[e.It8lw = 32896] = "It8lw", e[e.It8mp = 32897] = "It8mp", e[e.It8bl = 32898] = "It8bl", e[e.PixarFilm = 32908] = "PixarFilm", e[e.PixarLog = 32909] = "PixarLog", e[e.Deflate = 32946] = "Deflate", e[e.Dcs = 32947] = "Dcs", e[e.Jbig = 34661] = "Jbig", e[e.SgiLog = 34676] = "SgiLog", e[e.SgiLog24 = 34677] = "SgiLog24", e[e.Jp2000 = 34712] = "Jp2000", e[e.Lerc = 34887] = "Lerc", e[e.Lzma = 34925] = "Lzma", e[e.Zstd = 5e4] = "Zstd", e[e.Webp = 50001] = "Webp", e[e.JpegXl = 50002] = "JpegXl", e[e.JpegXlDng17 = 52546] = "JpegXlDng17";
+})(P || (P = {}));
+var U;
+(function(e) {
+  e[e.Contig = 1] = "Contig", e[e.Separate = 2] = "Separate";
+})(U || (U = {}));
+var V;
+(function(e) {
+  e[e.None = 1] = "None", e[e.Horizontal = 2] = "Horizontal", e[e.FloatingPoint = 3] = "FloatingPoint";
+})(V || (V = {}));
+var F;
+(function(e) {
+  e[e.Uint = 1] = "Uint", e[e.Int = 2] = "Int", e[e.Float = 3] = "Float", e[e.Void = 4] = "Void", e[e.ComplexInt = 5] = "ComplexInt", e[e.ComplexFloat = 6] = "ComplexFloat";
+})(F || (F = {}));
+var R;
+(function(e) {
+  e[e.MinIsWhite = 0] = "MinIsWhite", e[e.MinIsBlack = 1] = "MinIsBlack", e[e.Rgb = 2] = "Rgb", e[e.Palette = 3] = "Palette", e[e.Mask = 4] = "Mask", e[e.Separated = 5] = "Separated", e[e.Ycbcr = 6] = "Ycbcr", e[e.Cielab = 8] = "Cielab", e[e.Icclab = 9] = "Icclab", e[e.Itulab = 10] = "Itulab", e[e.Cfa = 32803] = "Cfa", e[e.Logl = 32844] = "Logl", e[e.Logluv = 32845] = "Logluv";
+})(R || (R = {}));
+var m;
+(function(e) {
+  e[e.SubFileType = 254] = "SubFileType", e[e.OldSubFileType = 255] = "OldSubFileType", e[e.ImageWidth = 256] = "ImageWidth", e[e.ImageHeight = 257] = "ImageHeight", e[e.BitsPerSample = 258] = "BitsPerSample", e[e.SampleFormat = 339] = "SampleFormat", e[e.Compression = 259] = "Compression", e[e.Photometric = 262] = "Photometric", e[e.TileWidth = 322] = "TileWidth", e[e.TileHeight = 323] = "TileHeight", e[e.TileOffsets = 324] = "TileOffsets", e[e.TileByteCounts = 325] = "TileByteCounts", e[e.JpegTables = 347] = "JpegTables", e[e.StripOffsets = 273] = "StripOffsets", e[e.StripByteCounts = 279] = "StripByteCounts", e[e.GdalMetadata = 42112] = "GdalMetadata", e[e.GdalNoData = 42113] = "GdalNoData", e[e.ModelPixelScale = 33550] = "ModelPixelScale", e[e.ModelTiePoint = 33922] = "ModelTiePoint", e[e.ModelTransformation = 34264] = "ModelTransformation", e[e.GeoKeyDirectory = 34735] = "GeoKeyDirectory", e[e.GeoDoubleParams = 34736] = "GeoDoubleParams", e[e.GeoAsciiParams = 34737] = "GeoAsciiParams", e[e.LercParameters = 50674] = "LercParameters", e[e.PlanarConfiguration = 284] = "PlanarConfiguration", e[e.CellLength = 265] = "CellLength", e[e.CellWidth = 264] = "CellWidth", e[e.ColorMap = 320] = "ColorMap", e[e.Copyright = 33432] = "Copyright", e[e.DateTime = 306] = "DateTime", e[e.ExtraSamples = 338] = "ExtraSamples", e[e.FillOrder = 266] = "FillOrder", e[e.FreeByteCounts = 289] = "FreeByteCounts", e[e.FreeOffsets = 288] = "FreeOffsets", e[e.GrayResponseCurve = 291] = "GrayResponseCurve", e[e.GrayResponseUnit = 290] = "GrayResponseUnit", e[e.HostComputer = 316] = "HostComputer", e[e.ImageDescription = 270] = "ImageDescription", e[e.Make = 271] = "Make", e[e.MaxSampleValue = 281] = "MaxSampleValue", e[e.MinSampleValue = 280] = "MinSampleValue", e[e.Model = 272] = "Model", e[e.Orientation = 274] = "Orientation", e[e.ResolutionUnit = 296] = "ResolutionUnit", e[e.RowsPerStrip = 278] = "RowsPerStrip", e[e.SamplesPerPixel = 277] = "SamplesPerPixel", e[e.Software = 305] = "Software", e[e.Threshholding = 263] = "Threshholding", e[e.XResolution = 282] = "XResolution", e[e.YResolution = 283] = "YResolution", e[e.BadFaxLines = 326] = "BadFaxLines", e[e.CleanFaxData = 327] = "CleanFaxData", e[e.ClipPath = 343] = "ClipPath", e[e.ConsecutiveBadFaxLines = 328] = "ConsecutiveBadFaxLines", e[e.Decode = 433] = "Decode", e[e.DefaultImageColor = 434] = "DefaultImageColor", e[e.DocumentName = 269] = "DocumentName", e[e.DotRange = 336] = "DotRange", e[e.HalftoneHints = 321] = "HalftoneHints", e[e.Indexed = 346] = "Indexed", e[e.PageName = 285] = "PageName", e[e.PageNumber = 297] = "PageNumber", e[e.Predictor = 317] = "Predictor", e[e.PrimaryChromaticities = 319] = "PrimaryChromaticities", e[e.ReferenceBlackWhite = 532] = "ReferenceBlackWhite", e[e.SMinSampleValue = 340] = "SMinSampleValue", e[e.SMaxSampleValue = 341] = "SMaxSampleValue", e[e.StripRowCounts = 559] = "StripRowCounts", e[e.SubIFDs = 330] = "SubIFDs", e[e.T4Options = 292] = "T4Options", e[e.T6Options = 293] = "T6Options", e[e.TransferFunction = 301] = "TransferFunction", e[e.WhitePoint = 318] = "WhitePoint", e[e.XClipPathUnits = 344] = "XClipPathUnits", e[e.XPosition = 286] = "XPosition", e[e.YCbCrCoefficients = 529] = "YCbCrCoefficients", e[e.YCbCrPositioning = 531] = "YCbCrPositioning", e[e.YCbCrSubSampling = 530] = "YCbCrSubSampling", e[e.YClipPathUnits = 345] = "YClipPathUnits", e[e.YPosition = 287] = "YPosition", e[e.ApertureValue = 37378] = "ApertureValue", e[e.ColorSpace = 40961] = "ColorSpace", e[e.DateTimeDigitized = 36868] = "DateTimeDigitized", e[e.DateTimeOriginal = 36867] = "DateTimeOriginal", e[e.ExifIFD = 34665] = "ExifIFD", e[e.ExifVersion = 36864] = "ExifVersion", e[e.ExposureTime = 33434] = "ExposureTime", e[e.FileSource = 41728] = "FileSource", e[e.Flash = 37385] = "Flash", e[e.FlashpixVersion = 40960] = "FlashpixVersion", e[e.FNumber = 33437] = "FNumber", e[e.ImageUniqueID = 42016] = "ImageUniqueID", e[e.LightSource = 37384] = "LightSource", e[e.MakerNote = 37500] = "MakerNote", e[e.ShutterSpeedValue = 37377] = "ShutterSpeedValue", e[e.UserComment = 37510] = "UserComment", e[e.IPTC = 33723] = "IPTC", e[e.ICCProfile = 34675] = "ICCProfile", e[e.XMP = 700] = "XMP";
+})(m || (m = {}));
+var w;
+(function(e) {
+  e[e.GTModelTypeGeoKey = 1024] = "GTModelTypeGeoKey", e[e.GTRasterTypeGeoKey = 1025] = "GTRasterTypeGeoKey", e[e.GTCitationGeoKey = 1026] = "GTCitationGeoKey", e[e.GeodeticCRSGeoKey = 2048] = "GeodeticCRSGeoKey", e[e.GeodeticCitationGeoKey = 2049] = "GeodeticCitationGeoKey", e[e.GeodeticDatumGeoKey = 2050] = "GeodeticDatumGeoKey", e[e.PrimeMeridianGeoKey = 2051] = "PrimeMeridianGeoKey", e[e.GeogLinearUnitsGeoKey = 2052] = "GeogLinearUnitsGeoKey", e[e.GeogLinearUnitSizeGeoKey = 2053] = "GeogLinearUnitSizeGeoKey", e[e.GeogAngularUnitsGeoKey = 2054] = "GeogAngularUnitsGeoKey", e[e.GeogAngularUnitSizeGeoKey = 2055] = "GeogAngularUnitSizeGeoKey", e[e.EllipsoidGeoKey = 2056] = "EllipsoidGeoKey", e[e.EllipsoidSemiMajorAxisGeoKey = 2057] = "EllipsoidSemiMajorAxisGeoKey", e[e.EllipsoidSemiMinorAxisGeoKey = 2058] = "EllipsoidSemiMinorAxisGeoKey", e[e.EllipsoidInvFlatteningGeoKey = 2059] = "EllipsoidInvFlatteningGeoKey", e[e.PrimeMeridianLongitudeGeoKey = 2061] = "PrimeMeridianLongitudeGeoKey", e[e.GeogTOWGS84GeoKey = 2062] = "GeogTOWGS84GeoKey", e[e.GeogAzimuthUnitsGeoKey = 2060] = "GeogAzimuthUnitsGeoKey", e[e.ProjectedCRSGeoKey = 3072] = "ProjectedCRSGeoKey", e[e.ProjectedCitationGeoKey = 3073] = "ProjectedCitationGeoKey", e[e.ProjectionGeoKey = 3074] = "ProjectionGeoKey", e[e.ProjMethodGeoKey = 3075] = "ProjMethodGeoKey", e[e.ProjLinearUnitsGeoKey = 3076] = "ProjLinearUnitsGeoKey", e[e.ProjLinearUnitSizeGeoKey = 3077] = "ProjLinearUnitSizeGeoKey", e[e.ProjStdParallel1GeoKey = 3078] = "ProjStdParallel1GeoKey", e[e.ProjStdParallel2GeoKey = 3079] = "ProjStdParallel2GeoKey", e[e.ProjNatOriginLongGeoKey = 3080] = "ProjNatOriginLongGeoKey", e[e.ProjNatOriginLatGeoKey = 3081] = "ProjNatOriginLatGeoKey", e[e.ProjFalseEastingGeoKey = 3082] = "ProjFalseEastingGeoKey", e[e.ProjFalseNorthingGeoKey = 3083] = "ProjFalseNorthingGeoKey", e[e.ProjFalseOriginLongGeoKey = 3084] = "ProjFalseOriginLongGeoKey", e[e.ProjFalseOriginLatGeoKey = 3085] = "ProjFalseOriginLatGeoKey", e[e.ProjFalseOriginEastingGeoKey = 3086] = "ProjFalseOriginEastingGeoKey", e[e.ProjFalseOriginNorthingGeoKey = 3087] = "ProjFalseOriginNorthingGeoKey", e[e.ProjCenterLongGeoKey = 3088] = "ProjCenterLongGeoKey", e[e.ProjCenterLatGeoKey = 3089] = "ProjCenterLatGeoKey", e[e.ProjCenterEastingGeoKey = 3090] = "ProjCenterEastingGeoKey", e[e.ProjCenterNorthingGeoKey = 3091] = "ProjCenterNorthingGeoKey", e[e.ProjScaleAtNatOriginGeoKey = 3092] = "ProjScaleAtNatOriginGeoKey", e[e.ProjScaleAtCenterGeoKey = 3093] = "ProjScaleAtCenterGeoKey", e[e.ProjAzimuthAngleGeoKey = 3094] = "ProjAzimuthAngleGeoKey", e[e.ProjStraightVertPoleLongGeoKey = 3095] = "ProjStraightVertPoleLongGeoKey", e[e.ProjRectifiedGridAngleGeoKey = 3096] = "ProjRectifiedGridAngleGeoKey", e[e.VerticalGeoKey = 4096] = "VerticalGeoKey", e[e.VerticalCitationGeoKey = 4097] = "VerticalCitationGeoKey", e[e.VerticalDatumGeoKey = 4098] = "VerticalDatumGeoKey", e[e.VerticalUnitsGeoKey = 4099] = "VerticalUnitsGeoKey";
+})(w || (w = {}));
+var _e;
+(function(e) {
+  e[e.Radian = 9101] = "Radian", e[e.Degree = 9102] = "Degree", e[e.ArcMinute = 9103] = "ArcMinute", e[e.ArcDegree = 9104] = "ArcDegree", e[e.Grad = 9105] = "Grad", e[e.Gon = 9106] = "Gon", e[e.Dms = 9107] = "Dms";
+})(_e || (_e = {}));
+var Xe;
+(function(e) {
+  e[e.Metre = 9001] = "Metre", e[e.Foot = 9002] = "Foot", e[e.FootUsSurvey = 9003] = "FootUsSurvey", e[e.FootModifiedAmerican = 9004] = "FootModifiedAmerican", e[e.FootClarke = 9005] = "FootClarke", e[e.FootIndian = 9006] = "FootIndian", e[e.Link = 9007] = "Link", e[e.LinkBenoit = 9008] = "LinkBenoit", e[e.LinkSears = 9009] = "LinkSears", e[e.ChainBenoit = 9010] = "ChainBenoit", e[e.ChainSears = 9011] = "ChainSears", e[e.YardSears = 9012] = "YardSears", e[e.YardIndian = 9013] = "YardIndian", e[e.Fathom = 9014] = "Fathom", e[e.MileInternationalNautical = 9015] = "MileInternationalNautical";
+})(Xe || (Xe = {}));
+const In = {
+  [m.TileByteCounts]: !0,
+  [m.TileOffsets]: !0,
+  [m.StripOffsets]: !0,
+  [m.StripByteCounts]: !0,
+  [m.BitsPerSample]: !0,
+  [m.SampleFormat]: !0,
+  [m.GeoKeyDirectory]: !0,
+  [m.GeoDoubleParams]: !0
+};
+var x;
+(function(e) {
+  e.None = "application/octet-stream", e.Jbig = "image/jbig", e.Dcs = "image/x-kodak-dcs", e.PackBits = "application/packbits", e.Jpeg = "image/jpeg", e.Jp2000 = "image/jp2", e.JpegXl = "image/jpegxl", e.Webp = "image/webp", e.Zstd = "application/zstd", e.Lzw = "application/lzw", e.Deflate = "application/deflate", e.Lerc = "application/lerc", e.Lzma = "application/x-lzma";
+})(x || (x = {}));
+const st = {
+  [P.None]: x.None,
+  [P.Lzw]: x.Lzw,
+  [P.Jpeg6]: x.Jpeg,
+  [P.Jpeg]: x.Jpeg,
+  [P.DeflateOther]: x.Deflate,
+  [P.Deflate]: x.Deflate,
+  [P.Lerc]: x.Lerc,
+  [P.Lzma]: x.Lzma,
+  [P.Jp2000]: x.Jp2000,
+  [P.Zstd]: x.Zstd,
+  [P.Webp]: x.Webp,
+  [P.JpegXl]: x.JpegXl,
+  [P.Ccittrle]: x.None,
+  [P.CcittT4]: x.None,
+  [P.CcittT6]: x.None,
+  [P.T85]: x.Jbig,
+  [P.T43]: x.Jbig,
+  [P.Next]: x.None,
+  [P.Ccittrlew]: x.None,
+  [P.PackBits]: x.PackBits,
+  [P.ThunderScan]: x.None,
+  [P.It8ctpad]: x.None,
+  [P.It8lw]: x.None,
+  [P.It8mp]: x.None,
+  [P.It8bl]: x.None,
+  [P.PixarFilm]: x.None,
+  [P.PixarLog]: x.None,
+  [P.Dcs]: x.Dcs,
+  [P.Jbig]: x.Jbig,
+  [P.SgiLog]: x.None,
+  [P.SgiLog24]: x.None,
+  [P.JpegXlDng17]: x.JpegXl
+};
+function Mn(e) {
+  return e == null ? null : st[e];
+}
+var C;
+(function(e) {
+  e[e.Uint8 = 1] = "Uint8", e[e.Ascii = 2] = "Ascii", e[e.Uint16 = 3] = "Uint16", e[e.Uint32 = 4] = "Uint32", e[e.Rational = 5] = "Rational", e[e.Int8 = 6] = "Int8", e[e.Undefined = 7] = "Undefined", e[e.Int16 = 8] = "Int16", e[e.Int32 = 9] = "Int32", e[e.SignedRational = 10] = "SignedRational", e[e.Float32 = 11] = "Float32", e[e.Float64 = 12] = "Float64", e[e.Ifd = 13] = "Ifd", e[e.Uint64 = 16] = "Uint64", e[e.Int64 = 17] = "Int64", e[e.Ifd8 = 18] = "Ifd8";
+})(C || (C = {}));
+var N;
+(function(e) {
+  e[e.BigTiff = 43] = "BigTiff", e[e.Tiff = 42] = "Tiff";
+})(N || (N = {}));
+function W(e) {
+  switch (e) {
+    case C.Uint8:
+    case C.Ascii:
+    case C.Int8:
+    case C.Undefined:
+      return 1;
+    case C.Uint16:
+    case C.Int16:
+      return 2;
+    case C.Uint32:
+    case C.Int32:
+    case C.Float32:
+    case C.Ifd:
+      return 4;
+    case C.Rational:
+    case C.SignedRational:
+    case C.Float64:
+    case C.Uint64:
+    case C.Int64:
+    case C.Ifd8:
+      return 8;
+    default:
+      throw new Error(`Invalid fieldType ${String(e)}`);
+  }
+}
+var We;
+(function(e) {
+  e[e.Double = 8] = "Double", e[e.Float32 = 4] = "Float32";
+})(We || (We = {}));
+var O;
+(function(e) {
+  e[e.UInt64 = 8] = "UInt64", e[e.UInt32 = 4] = "UInt32", e[e.UInt16 = 2] = "UInt16", e[e.UInt8 = 1] = "UInt8";
+})(O || (O = {}));
+const He = 2 ** 32;
+function at(e, t, n) {
+  const r = e.getUint32(t, n), o = e.getUint32(t + 4, n), i = n ? r + He * o : He * r + o;
+  if (!Number.isSafeInteger(i))
+    throw new Error(i + " exceeds MAX_SAFE_INTEGER. Precision may is lost");
+  return i;
+}
+function K(e, t, n, r) {
+  switch (n) {
+    case O.UInt8:
+      return e.getUint8(t);
+    case O.UInt16:
+      return e.getUint16(t, r);
+    case O.UInt32:
+      return e.getUint32(t, r);
+    case O.UInt64:
+      return at(e, t, r);
+  }
+}
+function se(e, t, n) {
+  return !(t < e.sourceOffset || e.sourceOffset + e.byteLength < t + n);
+}
+const lt = new ArrayBuffer(4), Rn = new Uint32Array(lt), zn = new Uint8Array(lt);
+Rn[0] = 1;
+const ke = zn[0] === 1;
+function Ze(e, t, n, r) {
+  switch (e) {
+    case C.Ascii:
+      return String.fromCharCode(t.getUint8(n));
+    case C.Undefined:
+    case C.Uint8:
+      return t.getUint8(n);
+    case C.Int8:
+      return t.getInt8(n);
+    case C.Uint16:
+      return t.getUint16(n, r);
+    case C.Int16:
+      return t.getInt16(n, r);
+    case C.Uint32:
+    case C.Ifd:
+      return t.getUint32(n, r);
+    case C.Int32:
+      return t.getInt32(n, r);
+    case C.Rational:
+      return [t.getUint32(n, r), t.getUint32(n + 4, r)];
+    case C.SignedRational:
+      return [t.getInt32(n, r), t.getInt32(n + 4, r)];
+    case C.Float64:
+      return t.getFloat64(n, r);
+    case C.Float32:
+      return t.getFloat32(n, r);
+    case C.Uint64:
+      return at(t, n, r);
+    default:
+      throw new Error(`Unknown read type "${e}" "${C[e]}"`);
+  }
+}
+function ct(e, t, n, r, o) {
+  switch (o) {
+    case C.Uint8:
+      return new Uint8Array(t.buffer.slice(t.byteOffset + n, t.byteOffset + n + r));
+    case C.Uint16:
+      return e.isLittleEndian !== ke ? null : new Uint16Array(t.buffer.slice(t.byteOffset + n, t.byteOffset + n + r));
+    case C.Uint32:
+      return e.isLittleEndian !== ke ? null : new Uint32Array(t.buffer.slice(t.byteOffset + n, t.byteOffset + n + r));
+  }
+  return null;
+}
+function X(e, t, n, r, o, i) {
+  const s = W(o), a = i * s;
+  if (i === 1) {
+    const c = Ze(o, n, r, e.isLittleEndian);
+    return t && In[t] ? [c] : c;
+  }
+  switch (o) {
+    case C.Ascii:
+      return String.fromCharCode.apply(null, new Uint8Array(n.buffer, r, a - 1));
+  }
+  if (t === m.TileOffsets || t === m.TileByteCounts || t === m.StripOffsets || t === m.StripByteCounts) {
+    const c = ct(e, n, r, a, o);
+    if (c)
+      return c;
+  }
+  const l = [];
+  for (let c = 0; c < a; c += s)
+    l.push(Ze(o, n, r + c, e.isLittleEndian));
+  return l;
+}
+function Fn(e, t, n) {
+  const r = t.getUint16(n + 0, e.isLittleEndian), o = t.getUint16(n + 2, e.isLittleEndian), i = K(t, n + 4, e.ifdConfig.pointer, e.isLittleEndian), a = W(o) * i;
+  if (a <= e.ifdConfig.pointer) {
+    const c = X(e, r, t, n + 4 + e.ifdConfig.pointer, o, i);
+    return { type: "inline", id: r, name: m[r], count: i, value: c, dataType: o, tagOffset: n };
+  }
+  const l = K(t, n + 4 + e.ifdConfig.pointer, e.ifdConfig.pointer, e.isLittleEndian);
+  switch (r) {
+    case m.TileOffsets:
+    case m.TileByteCounts:
+    case m.StripByteCounts:
+    case m.StripOffsets:
+      const c = {
+        type: "offset",
+        id: r,
+        name: m[r],
+        count: i,
+        dataType: o,
+        dataOffset: l,
+        isLoaded: !1,
+        value: [],
+        tagOffset: n
+      };
+      if (se(t, l, a)) {
+        const u = ct(e, t, l - t.sourceOffset, a, o);
+        u ? (c.value = u, c.isLoaded = !0) : Un(c, t);
+      }
+      return c;
+  }
+  if (se(t, l, a)) {
+    const c = X(e, r, t, l - t.sourceOffset, o, i);
+    return { type: "inline", id: r, name: m[r], count: i, value: c, dataType: o, tagOffset: n };
+  }
+  return { type: "lazy", id: r, name: m[r], count: i, dataOffset: l, dataType: o, tagOffset: n };
+}
+async function Dn(e, t, n) {
+  if (e.value != null)
+    return e.value;
+  const o = W(e.dataType) * e.count, i = await t.source.fetch(e.dataOffset, o, n), s = new DataView(i);
+  return e.value = X(t, e.id, s, 0, e.dataType, e.count), e.value;
+}
+async function Nn(e, t, n) {
+  const r = W(t.dataType);
+  if (t.view == null) {
+    const o = await e.source.fetch(t.dataOffset, r * t.count, n);
+    t.view = new DataView(o), t.view.sourceOffset = t.dataOffset;
+  }
+  return t.value = X(e, t.id, t.view, 0, t.dataType, t.count), t.view = void 0, t.isLoaded = !0, t.value;
+}
+function Un(e, t) {
+  const n = W(e.dataType), r = t.byteOffset + e.dataOffset - t.sourceOffset;
+  e.view = new DataView(t.buffer.slice(r, r + n * e.count)), e.view.sourceOffset = e.dataOffset;
+}
+async function Bn(e, t, n, r) {
+  if (n > t.count || n < 0)
+    throw new Error("TagOffset: out of bounds :" + n);
+  if (t.value[n] != null)
+    return t.value[n];
+  const o = W(t.dataType);
+  if (t.view == null) {
+    const s = await e.source.fetch(t.dataOffset + n * o, o, r), a = new DataView(s), l = X(e, void 0, a, 0, t.dataType, 1);
+    if (typeof l != "number")
+      throw new Error("Value is not a number");
+    return t.value[n] = l, l;
+  }
+  const i = X(e, void 0, t.view, n * o, t.dataType, 1);
+  if (typeof i != "number")
+    throw new Error("Value is not a number");
+  return t.value[n] = i, i;
+}
+function Gn(e, t, n) {
+  if (n > t.count || n < 0)
+    throw new Error("TagOffset: out of bounds :" + n);
+  if (t.value[n] != null)
+    return t.value[n];
+  if (t.view == null)
+    return null;
+  const r = W(t.dataType), o = X(e, void 0, t.view, n * r, t.dataType, 1);
+  if (typeof o != "number")
+    throw new Error("Value is not a number");
+  return t.value[n] = o, o;
+}
+const Ve = 32767, Kn = /* @__PURE__ */ new Set([
+  m.Compression,
+  m.ImageHeight,
+  m.ImageWidth,
+  m.ModelPixelScale,
+  m.ModelTiePoint,
+  m.ModelTransformation,
+  m.TileHeight,
+  m.TileWidth
+]), _n = /* @__PURE__ */ new Set([m.GeoKeyDirectory, m.GeoAsciiParams, m.GeoDoubleParams]);
+class Xn {
+  /**
+   * Id of the tif image, generally the image index inside the tif
+   * where 0 is the root image, and every sub image is +1
+   *
+   * @example 0, 1, 2
+   */
+  id;
+  /** Reference to the TIFF that owns this image */
+  tiff;
+  /** Has loadGeoTiffTags been called */
+  isGeoTagsLoaded = !1;
+  /** Sub tags stored in TiffTag.GeoKeyDirectory */
+  tagsGeo = /* @__PURE__ */ new Map();
+  /** All IFD tags that have been read for the image */
+  tags;
+  constructor(t, n, r) {
+    this.tiff = t, this.id = n, this.tags = r;
+  }
+  /**
+   * Force loading of important tags if they have not already been loaded
+   *
+   * @param loadGeoTags Whether to load the GeoKeyDirectory and unpack it
+   */
+  async init(t = !0, n) {
+    const r = [];
+    Kn.forEach((o) => {
+      r.push(this.fetch(o, n));
+    }), t && _n.forEach((o) => {
+      r.push(this.fetch(o, n));
+    }), await Promise.all(r), t && await this.loadGeoTiffTags();
+  }
+  /**
+   * Get the value of a TiffTag if it has been loaded, null otherwise.
+   *
+   * If the value is not loaded use {@link TiffImage.fetch} to load the value
+   * Or use {@link TiffImage.has} to check if the tag exists
+   *
+   *
+   * @returns value if loaded, null otherwise
+   */
+  value(t) {
+    const n = this.tags.get(t);
+    return n == null || n.type === "offset" && n.isLoaded === !1 ? null : n.value;
+  }
+  /**
+   * Does the tag exist
+   *
+   * @example
+   * ```typescript
+   * img.has(TiffTag.ImageWidth) // true
+   * ```
+   *
+   * @param tag Tag to check
+   * @returns true if the tag exists, false otherwise
+   */
+  has(t) {
+    return this.tags.has(t);
+  }
+  /**
+   * Load a tag.
+   *
+   * If it is not currently loaded, fetch the required data for the tag.
+   *
+   * @example
+   * ```typescript
+   * await img.fetch(TiffTag.ImageWidth) // 512 (px)
+   * ```
+   *
+   * @param tag tag to fetch
+   */
+  async fetch(t, n) {
+    const r = this.tags.get(t);
+    if (r == null)
+      return null;
+    if (r.type === "inline")
+      return r.value;
+    if (r.type === "lazy")
+      return Dn(r, this.tiff, n);
+    if (r.isLoaded)
+      return r.value;
+    if (r.type === "offset")
+      return Nn(this.tiff, r, n);
+    throw new Error("Cannot fetch:" + t);
+  }
+  /**
+   * Get the associated TiffTagGeo
+   *
+   * @example
+   * ```typescript
+   * image.valueGeo(TiffTagGeo.GTRasterTypeGeoKey)
+   * ```
+   * @throws if {@link loadGeoTiffTags} has not been called
+   */
+  valueGeo(t) {
+    if (this.isGeoTagsLoaded === !1)
+      throw new Error("loadGeoTiffTags() has not been called");
+    return this.tagsGeo.get(t);
+  }
+  /**
+   * Load and parse the GDAL_NODATA Tifftag
+   *
+   * @throws if the tag is not loaded
+   * @returns null if the tag does not exist
+   */
+  get noData() {
+    const t = this.tags.get(m.GdalNoData);
+    if (t == null)
+      return null;
+    if (t.value != null)
+      return Number(t.value);
+    throw new Error("GdalNoData tag is not loaded");
+  }
+  /**
+   * Load and unpack the GeoKeyDirectory
+   *
+   * @see {TiffTag.GeoKeyDirectory}
+   */
+  async loadGeoTiffTags() {
+    if (this.isGeoTagsLoaded)
+      return;
+    const t = this.tags.get(m.GeoKeyDirectory);
+    if (t == null) {
+      this.isGeoTagsLoaded = !0;
+      return;
+    }
+    if (t.type === "lazy" && t.value == null && await Promise.all([
+      this.fetch(m.GeoKeyDirectory),
+      this.fetch(m.GeoAsciiParams),
+      this.fetch(m.GeoDoubleParams)
+    ]), this.isGeoTagsLoaded = !0, t.value == null)
+      return;
+    const n = t.value;
+    if (typeof n == "number")
+      throw new Error("Invalid geo tags found");
+    for (let r = 4; r <= n[3] * 4; r += 4) {
+      const o = n[r], i = n[r + 1], s = n[r + 3];
+      if (i === 0) {
+        this.tagsGeo.set(o, s);
+        continue;
+      }
+      const a = this.tags.get(i);
+      if (a == null || a.value == null)
+        continue;
+      const l = n[r + 2];
+      if (typeof a.value == "string")
+        this.tagsGeo.set(o, a.value.slice(s, s + l - 1).trim());
+      else if (Array.isArray(a.value))
+        l === 1 ? this.tagsGeo.set(o, a.value[s]) : this.tagsGeo.set(o, a.value.slice(s, s + l));
+      else
+        throw new Error("Failed to extract GeoTiffTags");
+    }
+  }
+  /**
+   * Get the origin point for the image
+   *
+   * @returns origin point of the image
+   */
+  get origin() {
+    const t = this.value(m.ModelTiePoint);
+    if (t != null && t.length === 6)
+      return [t[3], t[4], t[5]];
+    const n = this.value(m.ModelTransformation);
+    if (n != null)
+      return [n[3], n[7], n[11]];
+    if (this.value(m.SubFileType) === $.ReducedImage && this.id !== 0)
+      return this.tiff.images[0].origin;
+    throw new Error("Image does not have a geo transformation.");
+  }
+  /** Is there enough geo information on this image to figure out where its actually located */
+  get isGeoLocated() {
+    return this.value(m.ModelPixelScale) != null || this.value(m.ModelTransformation) != null ? !0 : this.isSubImage && this.id !== 0 ? this.tiff.images[0].isGeoLocated : !1;
+  }
+  /**
+   * Get the resolution of the image
+   *
+   * @returns [x,y,z] pixel scale
+   */
+  get resolution() {
+    const t = this.value(m.ModelPixelScale);
+    if (t != null)
+      return [t[0], -t[1], t[2]];
+    const n = this.value(m.ModelTransformation);
+    if (n != null)
+      return [n[0], n[5], n[10]];
+    if (this.isSubImage && this.id !== 0) {
+      const r = this.tiff.images[0], [o, i, s] = r.resolution, a = r.size, l = this.size;
+      return [o * a.width / l.width, i * a.height / l.height, s];
+    }
+    throw new Error("Image does not have a geo transformation.");
+  }
+  /**
+   * Is this image a reduced size image
+   * @see {@link TiffTag.SubFileType}
+   * @returns true if SubFileType is Reduces image, false otherwise
+   */
+  get isSubImage() {
+    return this.value(m.SubFileType) === $.ReducedImage;
+  }
+  /**
+   * Bounding box of the image
+   *
+   * @returns [minX, minY, maxX, maxY] bounding box
+   */
+  get bbox() {
+    const t = this.size, n = this.origin, r = this.resolution;
+    if (n == null || t == null || r == null)
+      throw new Error("Unable to calculate bounding box");
+    const o = n[0], i = n[1], s = o + r[0] * t.width, a = i + r[1] * t.height;
+    return [Math.min(o, s), Math.min(i, a), Math.max(o, s), Math.max(i, a)];
+  }
+  /**
+   * Get the compression used by the tile
+   *
+   * @see {@link TiffCompressionMimeType}
+   *
+   * @returns Compression type eg webp
+   */
+  get compression() {
+    const t = this.value(m.Compression);
+    return t == null ? null : st[t];
+  }
+  /**
+   * Attempt to read the EPSG Code from TiffGeoTags
+   *
+   * looks at TiffTagGeo.ProjectionGeoKey, TiffTagGeo.ProjectedCRSGeoKey and TiffTagGeo.GeodeticCRSGeoKey
+   *
+   * @returns EPSG Code if it exists and is not user defined.
+   */
+  get epsg() {
+    const t = this.valueGeo(w.ProjectionGeoKey);
+    if (t != null && t !== Ve)
+      return t;
+    let n = null;
+    switch (this.valueGeo(w.GTModelTypeGeoKey)) {
+      case G.Unknown:
+        return null;
+      case G.Projected:
+        n = this.valueGeo(w.ProjectedCRSGeoKey);
+        break;
+      case G.Geographic:
+        n = this.valueGeo(w.GeodeticCRSGeoKey);
+        break;
+      case G.Geocentric:
+        n = this.valueGeo(w.GeodeticCRSGeoKey);
+        break;
+      case G.UserDefined:
+        return null;
+    }
+    return n === Ve ? null : n;
+  }
+  /**
+   * Get the size of the image
+   *
+   * @returns Size in pixels
+   */
+  get size() {
+    const t = this.value(m.ImageWidth), n = this.value(m.ImageHeight);
+    if (t == null || n == null)
+      throw new Error("Tiff has no height or width");
+    return { width: t, height: n };
+  }
+  /**
+   * Determine if this image is tiled
+   */
+  isTiled() {
+    return this.value(m.TileWidth) !== null;
+  }
+  /**
+   * Get size of individual tiles
+   */
+  get tileSize() {
+    const t = this.value(m.TileWidth), n = this.value(m.TileHeight);
+    if (t == null || n == null)
+      throw new Error("Tiff is not tiled");
+    return { width: t, height: n };
+  }
+  /**
+   * Number of tiles used to create this image
+   */
+  get tileCount() {
+    const t = this.size, n = this.tileSize, r = Math.ceil(t.width / n.width), o = Math.ceil(t.height / n.height);
+    return { x: r, y: o };
+  }
+  /**
+   * Get the pointer to where the tiles start in the Tiff file
+   *
+   * @remarks Used to read tiled tiffs
+   *
+   * @returns file offset to where the tiffs are stored
+   */
+  get tileOffset() {
+    const t = this.tags.get(m.TileOffsets);
+    if (t == null)
+      throw new Error("No tile offsets found");
+    return t;
+  }
+  /**
+   * Get the number of strip's inside this tiff
+   *
+   * @remarks Used to read striped tiffs
+   *
+   * @returns number of strips present
+   */
+  get stripCount() {
+    return this.tags.get(m.StripByteCounts)?.count ?? 0;
+  }
+  // Clamp the bounds of the output image to the size of the image, as sometimes the edge tiles are not full tiles
+  getTileBounds(t, n) {
+    const { size: r, tileSize: o } = this, i = n * o.height, s = t * o.width, a = s + o.width >= r.width ? r.width - s : o.width, l = i + o.height >= r.height ? r.height - i : o.height;
+    return { x: s, y: i, width: a, height: l };
+  }
+  /**
+   * Read a strip into a ArrayBuffer
+   *
+   * Image has to be striped see {@link stripCount}
+   *
+   * @param index Strip index to read
+   */
+  async getStrip(t, n) {
+    if (this.isTiled())
+      throw new Error("Cannot read stripes, tiff is tiled: " + t);
+    const r = this.tags.get(m.StripByteCounts), o = this.tags.get(m.StripOffsets);
+    if (t >= r.count)
+      throw new Error("Cannot read strip, index out of bounds");
+    const [i, s] = await Promise.all([
+      Q(this.tiff, o, t, n),
+      Q(this.tiff, r, t, n)
+    ]);
+    return this.getBytes(i, s, n);
+  }
+  /** The jpeg header is stored in the IFD, read the JPEG header and adjust the byte array to include it */
+  getJpegHeader(t) {
+    const n = this.value(m.JpegTables);
+    if (n == null)
+      throw new Error("Unable to find Jpeg header");
+    const r = n.slice(0, n.length - 2), o = new Uint8Array(t.byteLength + r.length - 2);
+    return o.set(r, 0), o.set(new Uint8Array(t).slice(2), r.length), o.buffer.slice(o.byteOffset, o.byteOffset + o.byteLength);
+  }
+  /** Read image bytes at the given offset */
+  async getBytes(t, n, r) {
+    if (n === 0)
+      return null;
+    const o = await this.tiff.source.fetch(t, n, r);
+    if (o.byteLength < n)
+      throw new Error(`Failed to fetch bytes from offset:${t} wanted:${n} got:${o.byteLength}`);
+    let i = this.value(m.Compression);
+    i == null && (i = P.None);
+    const s = Mn(i) ?? x.None;
+    return i === P.Jpeg ? { mimeType: s, bytes: this.getJpegHeader(o), compression: i } : { mimeType: s, bytes: o, compression: i };
+  }
+  /**
+   * Load a tile into a ArrayBuffer
+   *
+   * if the tile compression is JPEG, This will also apply the JPEG compression tables to the resulting ArrayBuffer see {@link getJpegHeader}
+   *
+   * @param x Tile x offset
+   * @param y Tile y offset
+   */
+  async getTile(t, n, r) {
+    const o = this.size, i = this.tileSize;
+    if (i == null)
+      throw new Error("Tiff is not tiled");
+    const s = Math.ceil(o.height / i.height), a = Math.ceil(o.width / i.width);
+    if (t >= a || n >= s)
+      throw new Error(`Tile index is outside of range x:${t} >= ${a} or y:${n} >= ${s}`);
+    const l = n * a + t, c = a * s;
+    if (l >= c)
+      throw new Error(`Tile index is outside of tile range: ${l} >= ${c}`);
+    const { offset: u, imageSize: h } = await this.getTileSize(l, r);
+    return this.getBytes(u, h, r);
+  }
+  /**
+   * Does this tile exist in the tiff and does it actually have a value
+   *
+   * Sparse tiffs can have a lot of empty tiles, they set the tile size to `0 bytes` when the tile is empty
+   * this checks the tile byte size to validate if it actually has any data.
+   *
+   * @param x Tile x offset
+   * @param y Tile y offset
+   *
+   * @returns if the tile exists and has data
+   */
+  async hasTile(t, n, r) {
+    const o = this.tileSize, i = this.size;
+    if (o == null)
+      throw new Error("Tiff is not tiled");
+    const s = Math.ceil(i.height / o.height), a = Math.ceil(i.width / o.width);
+    if (t >= a || n >= s)
+      return !1;
+    const l = n * a + t;
+    return (await this.getTileSize(l, r)).offset > 0;
+  }
+  /**
+   * Load the offset and byteCount of a tile
+   *
+   * if the tiff is sparse, offset and byteCount will be zero if the tile is empty
+   *
+   * @param index index in the tile array
+   * @returns Offset and byteCount for the tile
+   */
+  async getTileSize(t, n) {
+    const r = this.tags.get(m.TileByteCounts), o = Pe(this.tiff, this.tileOffset, t), i = Pe(this.tiff, r, t);
+    if (o != null && i != null)
+      return { offset: o, imageSize: i };
+    const s = this.tiff.options?.tileLeaderByteSize;
+    if (s) {
+      const c = o ?? await Q(this.tiff, this.tileOffset, t, n);
+      if (c === 0)
+        return { offset: 0, imageSize: 0 };
+      const u = await this.tiff.source.fetch(c - s, s, n);
+      return { offset: c, imageSize: K(new DataView(u), 0, s, this.tiff.isLittleEndian) };
+    }
+    if (r == null)
+      throw new Error("No tile byte counts found");
+    const [a, l] = await Promise.all([
+      o ?? Q(this.tiff, this.tileOffset, t, n),
+      i ?? Q(this.tiff, r, t, n)
+    ]);
+    return { offset: a, imageSize: l };
+  }
+}
+function Q(e, t, n, r) {
+  const o = Pe(e, t, n);
+  return o != null ? Promise.resolve(o) : Bn(e, t, n, r);
+}
+function Pe(e, t, n) {
+  if (n < 0)
+    throw new Error(`Tiff: ${e.source.url.href} out of bounds ${m[t.id]} index:${n} total:${t.count}`);
+  return n >= t.count ? 0 : t.type === "inline" || t.isLoaded ? t.value[n] : Gn(e, t, n);
+}
+var k;
+(function(e) {
+  e.GdalStructuralMetadataSize = "GDAL_STRUCTURAL_METADATA_SIZE", e.Layout = "LAYOUT", e.BlockOrder = "BLOCK_ORDER", e.BlockLeader = "BLOCK_LEADER", e.BlockTrailer = "BLOCK_TRAILER", e.KnownIncompatibleEdition = "KNOWN_INCOMPATIBLE_EDITION", e.MaskInterleavedWithImagery = "MASK_INTERLEAVED_WITH_IMAGERY";
+})(k || (k = {}));
+var Ye;
+(function(e) {
+  e.RowMajor = "ROW_MAJOR";
+})(Ye || (Ye = {}));
+var be;
+(function(e) {
+  e.uint32 = "SIZE_AS_UINT4";
+})(be || (be = {}));
+class Wn {
+  options = /* @__PURE__ */ new Map();
+  /**
+   * Has GDAL optimized this tiff
+   */
+  get isCogOptimized() {
+    return this.isBroken ? !1 : this.options.get(k.Layout) === "IFDS_BEFORE_DATA";
+  }
+  /**
+   * Has GDAL determined this tiff is now broken
+   */
+  get isBroken() {
+    return this.options.get(k.KnownIncompatibleEdition) === "YES";
+  }
+  /**
+   * Load the ghost options from a source
+   * @param bytes the ghost header bytes
+   */
+  process(t, n, r) {
+    let o = "", i = "", s = !1;
+    for (let a = 0; a < r; a++) {
+      const l = t.getUint8(n + a);
+      if (l === 0)
+        break;
+      const c = String.fromCharCode(l);
+      c === `
+` ? (this.options.set(o.trim(), i.trim()), o = "", i = "", s = !1) : c === "=" ? s = !0 : s ? i += c : o += c;
+    }
+  }
+  /**
+   * If the tile leader is set, how many bytes are allocated to the tile size
+   */
+  get tileLeaderByteSize() {
+    switch (this.options.get(k.BlockLeader)) {
+      case be.uint32:
+        return O.UInt32;
+      default:
+        return null;
+    }
+  }
+  get isMaskInterleaved() {
+    return this.options.get(k.MaskInterleavedWithImagery) === "YES";
+  }
+}
+const ut = {
+  version: N.Tiff,
+  pointer: O.UInt32,
+  offset: O.UInt16,
+  /**
+   * Each tag entry is specified as
+   * UInt16:TagCode
+   * UInt16:TagType
+   * UInt32:TagCount
+   * UInt32:Pointer To Value or value
+   */
+  ifd: O.UInt16 + O.UInt16 + 2 * O.UInt32
+}, ht = {
+  version: N.BigTiff,
+  /** Size of most pointers */
+  pointer: O.UInt64,
+  /** Size of offsets */
+  offset: O.UInt64,
+  /**
+   * Each tag entry is specified as
+   * UInt16:TagCode
+   * UInt16:TagType
+   * UInt64:TagCount
+   * UInt64:Pointer To Value or value
+   */
+  ifd: O.UInt16 + O.UInt16 + 2 * O.UInt64
+};
+N.BigTiff + "", N.Tiff + "";
+function Hn(e, t = 4, n = !0) {
+  const r = e.toString(16).padStart(t, "0");
+  return n ? "0x" + r : r;
+}
+class Z {
+  /** Read 16KB blocks at a time */
+  static DefaultReadSize = 16 * 1024;
+  /** Read 16KB blocks at a time */
+  defaultReadSize = Z.DefaultReadSize;
+  /** Where this cog is fetching its data from */
+  source;
+  /** Big or small Tiff */
+  version = N.Tiff;
+  /** List of images, o is the base image */
+  images = [];
+  /** Ghost header options */
+  options;
+  /** Configuration for the size of the IFD */
+  ifdConfig = ut;
+  /** Is the tiff being read is little Endian */
+  isLittleEndian = !1;
+  /** Has init() been called */
+  isInitialized = !1;
+  _initPromise;
+  /** A Tiff constructed from a source will not be pre-initialized with {@link init}. */
+  constructor(t, n = { defaultReadSize: Z.DefaultReadSize }) {
+    this.source = t, this.defaultReadSize = n.defaultReadSize;
+  }
+  /** Create a tiff and initialize it by reading the tiff headers */
+  static create(t, n = { defaultReadSize: Z.DefaultReadSize }) {
+    return new Z(t, n).init(n);
+  }
+  /**
+   * Initialize the tiff loading in the header and all image headers.
+   *
+   * This is only required if the Tiff was created with the constructor, if you
+   * used {@link create} this will have already been called.
+   */
+  init(t) {
+    return this.isInitialized ? Promise.resolve(this) : this._initPromise ? this._initPromise : (this._initPromise = this.readHeader(t), this._initPromise);
+  }
+  /**
+   * Find a image which has a resolution similar to the provided resolution
+   *
+   * @param resolution resolution to find
+   */
+  getImageByResolution(t) {
+    const n = this.images[0], r = n.size, [o] = n.resolution, i = o * r.width;
+    for (let s = this.images.length - 1; s > 0; s--) {
+      const a = this.images[s], l = a.size;
+      if (i / l.width - t <= 0.01)
+        return a;
+    }
+    return n;
+  }
+  /** Read the Starting header and all Image headers from the source */
+  async readHeader(t) {
+    if (this.isInitialized)
+      return this;
+    const n = new DataView(await this.source.fetch(0, Je(this.source, 0, this.defaultReadSize), t));
+    if (n.byteLength === 0)
+      throw new Error("Unable to read empty tiff");
+    n.sourceOffset = 0;
+    let r = 0;
+    const o = n.getUint16(r, this.isLittleEndian);
+    r += 2, this.isLittleEndian = o === ye.Little, this.version = n.getUint16(r, this.isLittleEndian), r += 2;
+    let i;
+    if (this.version === N.BigTiff) {
+      this.ifdConfig = ht;
+      const a = n.getUint16(r, this.isLittleEndian);
+      if (r += 2, a !== 8)
+        throw new Error("Only 8byte pointers are supported");
+      const l = n.getUint16(r, this.isLittleEndian);
+      if (r += 2, l !== 0)
+        throw new Error("Invalid big tiff header");
+      i = K(n, r, this.ifdConfig.pointer, this.isLittleEndian), r += this.ifdConfig.pointer;
+    } else if (this.version === N.Tiff)
+      i = K(n, r, this.ifdConfig.pointer, this.isLittleEndian), r += this.ifdConfig.pointer;
+    else
+      throw new Error(`Only tiff supported version:${String(this.version)}`);
+    const s = i - r;
+    for (s > 0 && s < 16 * 1024 && (this.options = new Wn(), this.options.process(n, r, s)); i !== 0; ) {
+      let a = n;
+      if (!se(a, i, 1024)) {
+        const l = await this.source.fetch(i, Je(this.source, i, this.defaultReadSize), t);
+        a = new DataView(l), a.sourceOffset = i;
+      }
+      i = this.readIfd(i, a);
+    }
+    return await Promise.all(this.images.map((a) => a.init(!0, t))), this.isInitialized = !0, this;
+  }
+  /**
+   * Read a IFD at a the provided offset
+   *
+   * @param offset file offset to read the header from
+   * @param view offset that contains the bytes for the header
+   */
+  readIfd(t, n) {
+    const r = t - n.sourceOffset, o = K(n, r, this.ifdConfig.offset, this.isLittleEndian), i = /* @__PURE__ */ new Map(), s = o * this.ifdConfig.ifd;
+    if (!se(n, t, s))
+      throw new Error("IFD out of range @ " + Hn(t) + " IFD" + this.images.length);
+    const a = this.ifdConfig.ifd, l = r + this.ifdConfig.offset;
+    for (let c = 0; c < o; c++) {
+      const u = Fn(this, n, l + c * a);
+      i.set(u.id, u);
+    }
+    return this.images.push(new Xn(this, this.images.length, i)), K(n, l + o * a, this.ifdConfig.pointer, this.isLittleEndian);
+  }
+}
+function Je(e, t, n) {
+  const r = e.metadata?.size;
+  return r == null || r < 0 ? n : t + n > r ? r - t : n;
+}
+async function Ce(e, t) {
+  const n = new Blob([e]), r = await createImageBitmap(n), o = new OffscreenCanvas(r.width, r.height), i = o.getContext("2d");
+  i.drawImage(r, 0, 0), r.close();
+  const { width: s, height: a } = o, c = i.getImageData(0, 0, s, a).data, u = t.samplesPerPixel;
+  if (u === 4)
+    return { layout: "pixel-interleaved", data: c };
+  if (u === 3) {
+    const h = s * a, p = new Uint8ClampedArray(h * 3);
+    for (let d = 0, g = 0; d < p.length; d += 3, g += 4)
+      p[d] = c[g], p[d + 1] = c[g + 1], p[d + 2] = c[g + 2];
+    return { layout: "pixel-interleaved", data: p };
+  }
+  if (u === 1) {
+    const h = s * a, p = new Uint8ClampedArray(h);
+    for (let d = 0, g = 0; d < h; d++, g += 4)
+      p[d] = c[g];
+    return { layout: "pixel-interleaved", data: p };
+  }
+  throw new Error(`Unsupported SamplesPerPixel for JPEG: ${u}`);
+}
+function kn(e, t = "") {
+  if (!e)
+    throw new Error(t);
+}
+async function Zn(e, { format: t, signal: n }) {
+  const r = e instanceof Response ? e : new Response(e);
+  kn(r.body, "Response does not contain body.");
+  try {
+    return await new Response(r.body.pipeThrough(new DecompressionStream(t), { signal: n })).arrayBuffer();
+  } catch {
+    throw n?.throwIfAborted(), new Error(`Failed to decode ${t}`);
+  }
+}
+async function dt(e) {
+  return Zn(e, { format: "deflate" });
+}
+function Vn(e, t) {
+  const n = e;
+  let r = 0, o = e.length - t;
+  do {
+    for (let i = t; i > 0; i--)
+      n[r + t] = (n[r + t] ?? 0) + (n[r] ?? 0), r++;
+    o -= t;
+  } while (o > 0);
+}
+function Yn(e, t, n) {
+  let r = 0, o = e.length;
+  const i = o / n;
+  for (; o > t; ) {
+    for (let a = t; a > 0; a--)
+      e[r + t] += e[r], r++;
+    o -= t;
+  }
+  const s = e.slice();
+  for (let a = 0; a < i; a++)
+    for (let l = 0; l < n; l++)
+      e[n * a + l] = s[(n - l - 1) * i + a];
+}
+function Jn(e, t, n, r, o, i, s) {
+  if (t === V.None)
+    return e;
+  const a = o / 8, l = s === U.Separate ? 1 : i;
+  for (let c = 0; c < r; c++) {
+    const u = c * l * n * a;
+    if (u >= e.byteLength)
+      break;
+    if (t === V.Horizontal) {
+      let h;
+      const p = l * n;
+      switch (o) {
+        case 8:
+          h = new Uint8Array(e, u, p);
+          break;
+        case 16:
+          h = new Uint16Array(e, u, p);
+          break;
+        case 32:
+          h = new Uint32Array(e, u, p);
+          break;
+        default:
+          throw new Error(`Predictor 2 not supported for ${o} bits per sample.`);
+      }
+      Vn(h, l);
+    } else if (t === V.FloatingPoint) {
+      const h = new Uint8Array(e, u, l * n * a);
+      Yn(h, l, a);
+    }
+  }
+  return e;
+}
+async function qn(e) {
+  return e;
+}
+const D = /* @__PURE__ */ new Map();
+D.set(P.None, () => Promise.resolve(qn));
+D.set(P.Deflate, () => Promise.resolve(dt));
+D.set(P.DeflateOther, () => Promise.resolve(dt));
+D.set(P.Lzw, () => import("./lzw-BY5a_5nb.js").then((e) => e.decode));
+D.set(P.Zstd, () => import("./zstd-jXobGRcq.js").then((e) => e.decode));
+D.set(P.Jpeg, () => Promise.resolve(Ce));
+D.set(P.Jpeg6, () => Promise.resolve(Ce));
+D.set(P.Webp, () => Promise.resolve(Ce));
+D.set(P.Lerc, () => import("./lerc-C-D0ZLmp.js").then((e) => e.l).then((e) => e.decode));
+async function je(e, t, n) {
+  const r = D.get(t);
+  if (!r)
+    throw new Error(`Unsupported compression: ${t}`);
+  const i = await (await r())(e, n);
+  if (i instanceof ArrayBuffer) {
+    const { predictor: s, width: a, height: l, bitsPerSample: c, samplesPerPixel: u, planarConfiguration: h } = n, p = Jn(i, s, a, l, c, u, h);
+    return {
+      layout: "pixel-interleaved",
+      data: Tn(p, n)
+    };
+  }
+  return i;
+}
+function Qn(e, t) {
+  const n = new Uint8Array(e), r = new Uint8Array(t);
+  for (let o = 0; o < t; o++)
+    r[o] = n[o >> 3] >> 7 - (o & 7) & 1 ? 255 : 0;
+  return r;
+}
+function Tn(e, t) {
+  const { sampleFormat: n, bitsPerSample: r } = t;
+  switch (n) {
+    case F.Uint:
+      switch (r) {
+        case 1:
+          return Qn(e, t.width * t.height * t.samplesPerPixel);
+        case 8:
+          return new Uint8Array(e);
+        case 16:
+          return new Uint16Array(e);
+        case 32:
+          return new Uint32Array(e);
+      }
+      break;
+    case F.Int:
+      switch (r) {
+        case 8:
+          return new Int8Array(e);
+        case 16:
+          return new Int16Array(e);
+        case 32:
+          return new Int32Array(e);
+      }
+      break;
+    case F.Float:
+      switch (r) {
+        case 32:
+          return new Float32Array(e);
+        case 64:
+          return new Float64Array(e);
+      }
+      break;
+  }
+  throw new Error(`Unsupported sample format/depth: SampleFormat=${n}, BitsPerSample=${r}`);
+}
+class $n {
+  name = "source:cache";
+  maxSize;
+  /** Number of bytes cached in cacheA, when this overflows maxSize cacheA is moved to cacheB and cacheB is dropped */
+  size = 0;
+  /** Number of times `this.cacheB` has been cleared */
+  resets = 0;
+  /** Primary cache of objects */
+  cacheA = /* @__PURE__ */ new Map();
+  cacheB = /* @__PURE__ */ new Map();
+  /** List of protocols to cache */
+  protocols;
+  constructor(t) {
+    this.maxSize = t.size, this.protocols = new Set(t.protocols ?? []);
+  }
+  fetch(t, n) {
+    if (this.protocols.size > 0 && !this.protocols.has(t.source.url.protocol) || t.length == null)
+      return n(t);
+    const r = `${t.source.url.toString()}@${t.offset}+${t.length}`;
+    let o = this.cacheA.get(r);
+    return o ? (o.hits++, o.promise) : (o = this.cacheB.get(r), o ? (o.hits++, o.saves++, this.size += o.size, this.cacheA.set(r, o), o.promise) : (o = { promise: n(t), hits: 0, saves: 0, size: t.length }, this.size += o.size, this.size > this.maxSize && (this.size = o.size, this.cacheB = this.cacheA, this.cacheA = /* @__PURE__ */ new Map(), this.resets++), this.cacheA.set(r, o), o.promise));
+  }
+}
+class B extends Error {
+  /** Status code for the error eg 403 - Forbidden vs 404 Not found */
+  code;
+  /** URL that the status code came from */
+  url;
+  /** File system that triggered the error */
+  source;
+  constructor(t, n, r, o) {
+    super(t, { cause: o }), this.code = n, this.url = r.url, this.source = r, Object.defineProperty(this, "_sourceError", {
+      enumerable: !1,
+      // hide it from for..in
+      value: "SourceError"
+    });
+  }
+  /** Check that a unknown is a FsError */
+  static is(t) {
+    return t instanceof B ? !0 : typeof t != "object" || t == null ? !1 : "_sourceError" in t && t._sourceError === "SourceError";
+  }
+}
+const le = {
+  /** Convert a offset/length to a range request
+   *
+   * @example
+   * ```typescript
+   * ContentRange.toRange(10) // "bytes=10"
+   * ContentRange.toRange(0, 1024) // "bytes=0-1023"
+   * ```
+   */
+  toRange(e, t) {
+    if (t == null)
+      return `bytes=${e}`;
+    if (e < 0)
+      throw new Error("Cannot read from remote source with negative offset and length");
+    return `bytes=${e}-${e + t - 1}`;
+  },
+  /**
+   * Parse a Content-Range header to extract the size of the source
+   *
+   * @example
+   * ```typescript
+   * ContentRange.parseRange("bytes 200-1000/67589"); // 67589
+   * ```
+   * @throws if range is not a Content-Range with size
+   */
+  parseSize(e) {
+    const [t, n] = e.split(" ");
+    if (t !== "bytes")
+      throw new Error("Failed to parse content-range: " + e);
+    if (n == null)
+      throw new Error("Failed to parse content-range: " + e);
+    const [, r] = n.split("/"), o = Number(r);
+    if (isNaN(o))
+      throw new Error("Failed to parse content-range: " + e);
+    return o;
+  }
+};
+class er {
+  source;
+  middleware;
+  static is(t) {
+    return "middleware" in t;
+  }
+  constructor(t, n = []) {
+    this.source = t, this.middleware = n;
+  }
+  get type() {
+    return this.source.type;
+  }
+  get url() {
+    return this.source.url;
+  }
+  get metadata() {
+    return this.source.metadata;
+  }
+  head(t) {
+    return this.source.head(t);
+  }
+  async fetch(t, n, r) {
+    const o = this.middleware;
+    if (o == null || o.length === 0)
+      return this.source.fetch(t, n, r);
+    const i = (s) => this.source.fetch(s.offset, s.length, r);
+    return this.run(i, t, n, r);
+  }
+  /** Run a request using all the middleware */
+  async run(t, n, r, o) {
+    const i = this.middleware;
+    if (i == null)
+      return t({ source: this, offset: n, length: r, signal: o?.signal });
+    function s(a, l) {
+      return (c) => a.fetch(c, l);
+    }
+    for (let a = i.length - 1; a >= 0; a--)
+      t = s(i[a], t);
+    return t({ source: this, offset: n, length: r, signal: o?.signal });
+  }
+}
+function tr(e) {
+  try {
+    return new URL(e);
+  } catch {
+    return null;
+  }
+}
+class nr {
+  name = "source:chunk";
+  /** Number of bytes to chunk requests into */
+  chunkSize;
+  constructor(t) {
+    this.chunkSize = t.size ?? 32 * 1024;
+  }
+  async fetch(t, n) {
+    if (t.offset < 0 || t.length == null)
+      return n(t);
+    const r = Math.floor(t.offset / this.chunkSize), o = Math.ceil((t.offset + t.length) / this.chunkSize), i = t.source.metadata?.size;
+    if (i != null && t.offset + t.length > i)
+      throw new B(`Request outside of bounds ${le.toRange(t.offset, t.length)}`, 416, t.source);
+    const s = r * this.chunkSize, l = (i != null ? Math.min(o * this.chunkSize, i) : o * this.chunkSize) - s, c = t.offset - s;
+    return o - r > 1 ? (await this.fetchChunks(t, r, o)).slice(c, c + t.length) : t.offset === s && t.length === l ? n(t) : (await n({ ...t, offset: s, length: l })).slice(c, c + t.length);
+  }
+  async fetchChunks(t, n, r) {
+    const o = [], i = t.source.metadata?.size ?? r * this.chunkSize;
+    for (let l = n; l < r; l++) {
+      const c = l * this.chunkSize, h = Math.min(c + this.chunkSize, i) - c;
+      o.push(t.source.fetch(l * this.chunkSize, h, t.signal ? { signal: t.signal } : void 0));
+    }
+    const s = await Promise.all(o), a = new Uint8Array(o.length * this.chunkSize);
+    for (let l = 0; l < s.length; l++)
+      a.set(new Uint8Array(s[l]), l * this.chunkSize);
+    return a.buffer;
+  }
+}
+function qe(e) {
+  const t = {}, n = e.headers.get("content-length");
+  n && (t.size = parseInt(n));
+  const r = e.headers.get("content-range");
+  return r != null && (t.size = le.parseSize(r)), t.eTag = e.headers.get("etag") ?? void 0, t.contentType = e.headers.get("content-type") ?? void 0, t.contentDisposition = e.headers.get("content-disposition") ?? void 0, t.cacheControl = e.headers.get("cache-control") ?? void 0, t.contentEncoding = e.headers.get("content-encoding") ?? void 0, t;
+}
+class Y {
+  constructor(t, n) {
+    this.type = "http", this.url = typeof t == "string" ? Y.tryUrl(t) : t, this.headers = n;
+  }
+  /** Attempt to parse a relative string into a URL */
+  static tryUrl(t) {
+    try {
+      return new URL(t);
+    } catch {
+      return typeof document < "u" ? new URL(t, document.baseURI) : new URL(t, import.meta.url);
+    }
+  }
+  head() {
+    return this._head ? this._head : (this._head = Y.fetch(this.url, { method: "HEAD", headers: this.headers }).then((t) => {
+      if (!t.ok)
+        throw delete this._head, new Error(`Failed to HEAD ${this.url.href}`, { cause: { statusCode: t.status, msg: t.statusText } });
+      return this.metadata = qe(t), this.metadata;
+    }), this._head);
+  }
+  async fetch(t, n, r) {
+    try {
+      const o = { range: le.toRange(t, n), ...this.headers }, i = await Y.fetch(this.url, { headers: o, signal: r?.signal });
+      if (!i.ok)
+        throw new B(`Failed to fetch ${this.url.href} ${o.range}`, i.status, this, new Error(i.statusText));
+      const s = qe(i);
+      if (this.metadata == null)
+        this.metadata = s;
+      else if (this.metadata.eTag && this.metadata.eTag !== s.eTag)
+        throw new B(`ETag conflict ${this.url.href} ${o.range} expected: ${this.metadata.eTag} got: ${s.eTag}`, 409, this);
+      return i.arrayBuffer();
+    } catch (o) {
+      throw B.is(o) && o.source === this ? o : new B(`Failed to fetch: ${this.url.href}`, 500, this, o);
+    }
+  }
+}
+Y.fetch = (e, t) => fetch(e, t);
+function rr(e) {
+  if (typeof e != "string")
+    return e;
+  const t = tr(e);
+  return t || new URL("memory://" + e);
+}
+class xe {
+  url;
+  type = "memory";
+  data;
+  metadata;
+  static toArrayBuffer(t) {
+    return t instanceof ArrayBuffer ? t : t.byteLength === t.buffer.byteLength ? t.buffer : t.buffer.slice(t.byteOffset, t.byteOffset + t.byteLength);
+  }
+  constructor(t, n) {
+    const r = xe.toArrayBuffer(n ?? new Uint8Array());
+    this.url = rr(t), this.data = r, this.metadata = { size: r.byteLength };
+  }
+  head() {
+    return Promise.resolve({ size: this.data.byteLength });
+  }
+  fetch(t, n) {
+    if (t < 0 && (t = this.data.byteLength + t), t > this.data.byteLength)
+      throw new B(`Read offset outside of file bounds range:${le.toRange(t, n)} fileSize:${this.data.byteLength}`, 416, this);
+    return Promise.resolve(this.data.slice(t, n == null ? void 0 : t + n));
+  }
+}
+const pt = "https://proj.org/schemas/v0.7/projjson.schema.json", or = 1, ir = 2, ee = 32767, Qe = 1, sr = 2, ar = 3, lr = 4, cr = 5, ur = 6, hr = 7, dr = 8, pr = 9, mr = 10, gr = 11, fr = 12, yr = 14, wr = 15, Pr = 16, br = 17, vr = 18, Sr = 21, Lr = 22, Cr = 24, jr = 26, xr = 27, mt = 9102, Or = 9101, Ar = 9105, Er = {
+  [mt]: "degree",
+  [Or]: "radian",
+  [Ar]: "grad"
+}, gt = 9001, Ir = 9002, Mr = 9003, Rr = {
+  type: "LinearUnit",
+  name: "US survey foot",
+  conversion_factor: 0.30480060960121924
+}, zr = {
+  [gt]: "metre",
+  [Ir]: "foot",
+  [Mr]: Rr
+};
+function Fr(e) {
+  const t = e.modelType;
+  if (t === or)
+    return Nr(e);
+  if (t === ir)
+    return Dr(e);
+  throw new Error(`Unsupported GeoTIFF model type: ${t}`);
+}
+function Dr(e) {
+  const t = e.geodeticCRS;
+  return t !== null && t !== ee ? t : ft(e, pt);
+}
+function Nr(e) {
+  const t = e.projectedCRS;
+  return t !== null && t !== ee ? t : Ur(e);
+}
+function ft(e, t) {
+  const n = Br(e);
+  let r = "Greenwich", o = 0;
+  e.primeMeridian !== null && e.primeMeridian !== ee ? r = `EPSG:${e.primeMeridian}` : e.primeMeridianLongitude !== null && (o = e.primeMeridianLongitude, r = "User-defined");
+  let i;
+  e.geodeticDatum !== null && e.geodeticDatum !== ee ? i = {
+    type: "GeodeticReferenceFrame",
+    name: `Unknown datum based upon EPSG ${e.geodeticDatum} ellipsoid`
+  } : i = {
+    type: "GeodeticReferenceFrame",
+    name: e.geodeticCitation ?? "User-defined",
+    ellipsoid: n,
+    prime_meridian: { name: r, longitude: o }
+  };
+  const s = {
+    type: "GeographicCRS",
+    name: e.geodeticCitation ?? "User-defined",
+    datum: i,
+    coordinate_system: Kr(e)
+  };
+  return t !== void 0 && (s.$schema = t), s;
+}
+function Ur(e) {
+  const t = ft(e), n = Gr(e), r = _r(e);
+  return {
+    type: "ProjectedCRS",
+    $schema: pt,
+    name: e.projectedCitation ?? e.citation ?? "User-defined",
+    base_crs: t,
+    conversion: n,
+    coordinate_system: r
+  };
+}
+function Br(e) {
+  if (e.ellipsoid !== null && e.ellipsoid !== ee) {
+    const n = {
+      name: `EPSG ellipsoid ${e.ellipsoid}`
+    };
+    return e.ellipsoidSemiMajorAxis !== null && (n.semi_major_axis = e.ellipsoidSemiMajorAxis), e.ellipsoidInvFlattening !== null ? n.inverse_flattening = e.ellipsoidInvFlattening : e.ellipsoidSemiMinorAxis !== null && (n.semi_minor_axis = e.ellipsoidSemiMinorAxis), n;
+  }
+  if (e.ellipsoidSemiMajorAxis === null)
+    throw new Error("User-defined ellipsoid requires ellipsoidSemiMajorAxis");
+  const t = {
+    name: e.geodeticCitation ?? "User-defined",
+    semi_major_axis: e.ellipsoidSemiMajorAxis
+  };
+  if (e.ellipsoidInvFlattening !== null)
+    t.inverse_flattening = e.ellipsoidInvFlattening;
+  else if (e.ellipsoidSemiMinorAxis !== null)
+    t.semi_minor_axis = e.ellipsoidSemiMinorAxis;
+  else
+    throw new Error("User-defined ellipsoid requires ellipsoidInvFlattening or ellipsoidSemiMinorAxis");
+  return t;
+}
+function Gr(e) {
+  const t = e.projMethod;
+  if (t === null)
+    throw new Error("User-defined projected CRS requires projMethod");
+  const n = (i, s, a = 0) => ({
+    name: i,
+    value: s ?? a,
+    unit: "degree"
+  }), r = (i, s, a = 0) => ({
+    name: i,
+    value: s ?? a,
+    unit: "metre"
+  }), o = (i, s, a = 1) => ({
+    name: i,
+    value: s ?? a,
+    unit: "unity"
+  });
+  switch (t) {
+    case Qe:
+    case sr:
+    case xr: {
+      const i = t === Qe ? "Transverse Mercator" : "Transverse Mercator (South Orientated)";
+      return {
+        name: i,
+        method: { name: i },
+        parameters: [
+          n("Latitude of natural origin", e.projNatOriginLat),
+          n("Longitude of natural origin", e.projNatOriginLong),
+          o("Scale factor at natural origin", e.projScaleAtNatOrigin),
+          r("False easting", e.projFalseEasting),
+          r("False northing", e.projFalseNorthing)
+        ]
+      };
+    }
+    case ar:
+    case lr:
+    case cr:
+    case ur: {
+      const i = "Hotine Oblique Mercator (variant B)";
+      return {
+        name: i,
+        method: { name: i },
+        parameters: [
+          n("Latitude of projection centre", e.projCenterLat),
+          n("Longitude of projection centre", e.projCenterLong),
+          n("Azimuth of initial line", e.projAzimuthAngle),
+          n("Angle from Rectified to Skew Grid", e.projAzimuthAngle),
+          o("Scale factor on initial line", e.projScaleAtCenter),
+          r("Easting at projection centre", e.projCenterEasting),
+          r("Northing at projection centre", e.projCenterNorthing)
+        ]
+      };
+    }
+    case hr: {
+      const i = "Mercator (variant A)";
+      return {
+        name: i,
+        method: { name: i },
+        parameters: [
+          n("Latitude of natural origin", e.projNatOriginLat),
+          n("Longitude of natural origin", e.projNatOriginLong),
+          o("Scale factor at natural origin", e.projScaleAtNatOrigin),
+          r("False easting", e.projFalseEasting),
+          r("False northing", e.projFalseNorthing)
+        ]
+      };
+    }
+    case dr: {
+      const i = "Lambert Conic Conformal (2SP)";
+      return {
+        name: i,
+        method: { name: i },
+        parameters: [
+          n("Latitude of false origin", e.projFalseOriginLat ?? e.projNatOriginLat),
+          n("Longitude of false origin", e.projFalseOriginLong ?? e.projNatOriginLong),
+          n("Latitude of 1st standard parallel", e.projStdParallel1),
+          n("Latitude of 2nd standard parallel", e.projStdParallel2),
+          r("Easting at false origin", e.projFalseOriginEasting ?? e.projFalseEasting),
+          r("Northing at false origin", e.projFalseOriginNorthing ?? e.projFalseNorthing)
+        ]
+      };
+    }
+    case pr: {
+      const i = "Lambert Conic Conformal (1SP)";
+      return {
+        name: i,
+        method: { name: i },
+        parameters: [
+          n("Latitude of natural origin", e.projNatOriginLat),
+          n("Longitude of natural origin", e.projNatOriginLong),
+          o("Scale factor at natural origin", e.projScaleAtNatOrigin),
+          r("False easting", e.projFalseEasting),
+          r("False northing", e.projFalseNorthing)
+        ]
+      };
+    }
+    case mr: {
+      const i = "Lambert Azimuthal Equal Area";
+      return {
+        name: i,
+        method: { name: i },
+        parameters: [
+          n("Latitude of natural origin", e.projCenterLat),
+          n("Longitude of natural origin", e.projCenterLong),
+          r("False easting", e.projFalseEasting),
+          r("False northing", e.projFalseNorthing)
+        ]
+      };
+    }
+    case gr: {
+      const i = "Albers Equal Area";
+      return {
+        name: i,
+        method: { name: i },
+        parameters: [
+          n("Latitude of false origin", e.projFalseOriginLat ?? e.projNatOriginLat),
+          n("Longitude of false origin", e.projFalseOriginLong ?? e.projNatOriginLong),
+          n("Latitude of 1st standard parallel", e.projStdParallel1),
+          n("Latitude of 2nd standard parallel", e.projStdParallel2),
+          r("Easting at false origin", e.projFalseOriginEasting ?? e.projFalseEasting),
+          r("Northing at false origin", e.projFalseOriginNorthing ?? e.projFalseNorthing)
+        ]
+      };
+    }
+    case fr: {
+      const i = "Modified Azimuthal Equidistant";
+      return {
+        name: i,
+        method: { name: i },
+        parameters: [
+          n("Latitude of natural origin", e.projCenterLat),
+          n("Longitude of natural origin", e.projCenterLong),
+          r("False easting", e.projFalseEasting),
+          r("False northing", e.projFalseNorthing)
+        ]
+      };
+    }
+    case yr: {
+      const i = "Stereographic";
+      return {
+        name: i,
+        method: { name: i },
+        parameters: [
+          n("Latitude of natural origin", e.projCenterLat),
+          n("Longitude of natural origin", e.projCenterLong),
+          o("Scale factor at natural origin", e.projScaleAtCenter),
+          r("False easting", e.projFalseEasting),
+          r("False northing", e.projFalseNorthing)
+        ]
+      };
+    }
+    case wr: {
+      const i = "Polar Stereographic (variant B)";
+      return {
+        name: i,
+        method: { name: i },
+        parameters: [
+          n("Latitude of standard parallel", e.projNatOriginLat ?? e.projStdParallel1),
+          n("Longitude of origin", e.projStraightVertPoleLong ?? e.projNatOriginLong),
+          r("False easting", e.projFalseEasting),
+          r("False northing", e.projFalseNorthing)
+        ]
+      };
+    }
+    case Pr: {
+      const i = "Oblique Stereographic";
+      return {
+        name: i,
+        method: { name: i },
+        parameters: [
+          n("Latitude of natural origin", e.projCenterLat),
+          n("Longitude of natural origin", e.projCenterLong),
+          o("Scale factor at natural origin", e.projScaleAtCenter),
+          r("False easting", e.projFalseEasting),
+          r("False northing", e.projFalseNorthing)
+        ]
+      };
+    }
+    case br: {
+      const i = "Equidistant Cylindrical";
+      return {
+        name: i,
+        method: { name: i },
+        parameters: [
+          n("Latitude of 1st standard parallel", e.projStdParallel1 ?? e.projCenterLat),
+          n("Longitude of natural origin", e.projCenterLong),
+          r("False easting", e.projFalseEasting),
+          r("False northing", e.projFalseNorthing)
+        ]
+      };
+    }
+    case vr: {
+      const i = "Cassini-Soldner";
+      return {
+        name: i,
+        method: { name: i },
+        parameters: [
+          n("Latitude of natural origin", e.projNatOriginLat),
+          n("Longitude of natural origin", e.projNatOriginLong),
+          r("False easting", e.projFalseEasting),
+          r("False northing", e.projFalseNorthing)
+        ]
+      };
+    }
+    case Lr: {
+      const i = "American Polyconic";
+      return {
+        name: i,
+        method: { name: i },
+        parameters: [
+          n("Latitude of natural origin", e.projNatOriginLat),
+          n("Longitude of natural origin", e.projNatOriginLong),
+          r("False easting", e.projFalseEasting),
+          r("False northing", e.projFalseNorthing)
+        ]
+      };
+    }
+    case Cr: {
+      const i = "Sinusoidal";
+      return {
+        name: i,
+        method: { name: i },
+        parameters: [
+          n("Longitude of natural origin", e.projCenterLong),
+          r("False easting", e.projFalseEasting),
+          r("False northing", e.projFalseNorthing)
+        ]
+      };
+    }
+    case Sr: {
+      const i = "Orthographic";
+      return {
+        name: i,
+        method: { name: i },
+        parameters: [
+          n("Latitude of natural origin", e.projCenterLat),
+          n("Longitude of natural origin", e.projCenterLong),
+          r("False easting", e.projFalseEasting),
+          r("False northing", e.projFalseNorthing)
+        ]
+      };
+    }
+    case jr: {
+      const i = "New Zealand Map Grid";
+      return {
+        name: i,
+        method: { name: i },
+        parameters: [
+          n("Latitude of natural origin", e.projNatOriginLat),
+          n("Longitude of natural origin", e.projNatOriginLong),
+          r("False easting", e.projFalseEasting),
+          r("False northing", e.projFalseNorthing)
+        ]
+      };
+    }
+    default:
+      throw new Error(`Unsupported coordinate transformation type: ${t}`);
+  }
+}
+function Kr(e) {
+  const t = Er[e.angularUnits ?? mt] ?? "degree";
+  return {
+    subtype: "ellipsoidal",
+    axis: [
+      {
+        name: "Geodetic latitude",
+        abbreviation: "Lat",
+        direction: "north",
+        unit: t
+      },
+      {
+        name: "Geodetic longitude",
+        abbreviation: "Lon",
+        direction: "east",
+        unit: t
+      }
+    ]
+  };
+}
+function _r(e) {
+  const t = zr[e.projLinearUnits ?? gt] ?? "metre";
+  return {
+    subtype: "Cartesian",
+    axis: [
+      { name: "Easting", abbreviation: "E", direction: "east", unit: t },
+      { name: "Northing", abbreviation: "N", direction: "north", unit: t }
+    ]
+  };
+}
+const Xr = 1024 * 1024, Wr = 16 * 1024 * 1024, Te = 6;
+async function Hr(e, t, n) {
+  if (t.length === 0)
+    return [];
+  const r = n?.coalesce ?? Xr, o = n?.maxRangeSize ?? Wr, i = n?.signal, s = kr(t, r, o), a = await Vr(e, s, i), l = new Array(t.length);
+  for (let c = 0; c < t.length; c++) {
+    const u = t[c], h = Zr(s, u.offset), p = s[h], d = a[h], g = u.offset - p.offset, f = g + u.length;
+    if (f > d.byteLength)
+      throw new Error(`Failed to fetch bytes from offset:${u.offset} wanted:${u.length} got:${d.byteLength - g}`);
+    l[c] = d.slice(g, f);
+  }
+  return l;
+}
+function kr(e, t, n) {
+  const r = [...e].sort((s, a) => s.offset - a.offset), o = [];
+  let i = null;
+  for (const s of r) {
+    if (i == null) {
+      i = { offset: s.offset, length: s.length };
+      continue;
+    }
+    const a = i.offset + i.length, l = s.offset + s.length, c = s.offset - a, u = Math.max(a, l), h = u - i.offset;
+    c <= t && h <= n ? i.length = u - i.offset : (o.push(i), i = { offset: s.offset, length: s.length });
+  }
+  return i != null && o.push(i), o;
+}
+function Zr(e, t) {
+  let n = 0, r = e.length - 1;
+  for (; n < r; ) {
+    const o = n + r + 1 >>> 1;
+    e[o].offset <= t ? n = o : r = o - 1;
+  }
+  return n;
+}
+async function Vr(e, t, n) {
+  const r = new Array(t.length);
+  for (let o = 0; o < t.length; o += Te) {
+    const i = t.slice(o, o + Te), s = await Promise.all(i.map((a) => e.fetch(a.offset, a.length, { signal: n })));
+    for (let a = 0; a < s.length; a++)
+      r[o + a] = s[a];
+  }
+  return r;
+}
+async function yt(e, t, n, { boundless: r = !0, pool: o, signal: i } = {}) {
+  const s = qr(e, t, n, { signal: i }), a = e.maskImage != null ? vt(e.maskImage, t, n, e.dataSource, {
+    signal: i,
+    debug: e._debug ? { label: "mask" } : void 0
+  }) : Promise.resolve(null), [l, c] = await Promise.all([s, a]);
+  return wt(e, t, n, l, c, { boundless: r, pool: o });
+}
+async function wt(e, t, n, r, o, { boundless: i, pool: s }) {
+  const { bitsPerSample: a, predictor: l, planarConfiguration: c, sampleFormat: u, lercParameters: h } = e.cachedTags, { sampleFormat: p, bitsPerSample: d } = jt(u, a), g = ae(e.transform, Le(t * e.tileWidth, n * e.tileHeight)), f = e.image.value(m.SamplesPerPixel) ?? 1, y = {
+    sampleFormat: p,
+    bitsPerSample: d,
+    samplesPerPixel: f,
+    width: e.tileWidth,
+    height: e.tileHeight,
+    predictor: l,
+    planarConfiguration: c,
+    lercParameters: h
+  }, [j, b] = await Promise.all([
+    Jr(r, y, s),
+    o != null && e.maskImage != null ? Yr(o, e.maskImage, s) : Promise.resolve(null)
+  ]), S = {
+    ...j,
+    count: f,
+    height: e.tileHeight,
+    width: e.tileWidth,
+    mask: b,
+    transform: g,
+    crs: e.crs,
+    nodata: e.nodata
+  };
+  return {
+    x: t,
+    y: n,
+    array: i === !0 ? S : eo(e, t, n, S)
+  };
+}
+async function Pt(e, t, { boundless: n = !0, pool: r, signal: o } = {}) {
+  if (t.length === 0)
+    return [];
+  const i = Tr(e, t, { signal: o }), s = e.maskImage != null ? Ct(e.maskImage, t, e.dataSource, {
+    signal: o,
+    debug: e._debug ? { label: "mask" } : void 0
+  }) : Promise.resolve(t.map(() => null)), [a, l] = await Promise.all([
+    i,
+    s
+  ]);
+  return Promise.all(t.map(([c, u], h) => wt(e, c, u, a[h], l[h] ?? null, {
+    boundless: n,
+    pool: r
+  })));
+}
+async function Yr(e, t, n) {
+  const r = t.value(m.SampleFormat) ?? [1], o = t.value(m.BitsPerSample) ?? [8], { sampleFormat: i, bitsPerSample: s } = jt(r, new Uint16Array(o)), { width: a, height: l } = t.tileSize, c = {
+    sampleFormat: i,
+    bitsPerSample: s,
+    samplesPerPixel: t.value(m.SamplesPerPixel) ?? 1,
+    width: a,
+    height: l,
+    predictor: t.value(m.Predictor) ?? 1,
+    planarConfiguration: t.value(m.PlanarConfiguration) ?? U.Contig
+  }, u = (f, y, j) => n ? n.decode(f, y, j) : je(f, y, j), { bytes: h, compression: p } = e, d = await u(h, p, c), g = d.layout === "pixel-interleaved" ? d.data : d.bands[0];
+  if (g instanceof Uint8Array)
+    return g;
+  throw new Error("Expected mask data to decode to Uint8Array");
+}
+async function Jr(e, t, n) {
+  const r = (o, i, s) => n ? n.decode(o, i, s) : je(o, i, s);
+  if (Array.isArray(e)) {
+    const o = { ...t, samplesPerPixel: 1 };
+    return { layout: "band-separate", bands: (await Promise.all(e.map(({ bytes: a, compression: l }) => r(a, l, o)))).map((a) => a.layout === "band-separate" ? a.bands[0] : a.data) };
+  } else {
+    const { bytes: o, compression: i } = e;
+    return r(o, i, t);
+  }
+}
+async function qr(e, t, n, { signal: r } = {}) {
+  const o = e._debug ? { label: "data" } : void 0;
+  switch (e.cachedTags.planarConfiguration) {
+    case U.Contig: {
+      const i = await vt(e.image, t, n, e.dataSource, {
+        signal: r,
+        debug: o
+      });
+      if (i === null)
+        throw new Error(`Tile at (${t}, ${n}) not found`);
+      return i;
+    }
+    case U.Separate:
+      return await Qr(e, t, n, { signal: r });
+    default:
+      throw new Error(`Unsupported PlanarConfiguration: ${e.cachedTags.planarConfiguration}`);
+  }
+}
+async function bt(e, t, n) {
+  const { x: r, y: o } = e.image.tileCount, i = r * o, s = e.cachedTags.samplesPerPixel, a = [...Array(s).keys()].map((l) => {
+    const c = l * i + n * r + t;
+    return e.image.getTileSize(c);
+  });
+  return Promise.all(a);
+}
+async function Qr(e, t, n, { signal: r } = {}) {
+  const o = e._debug ? { label: "data" } : void 0, s = (await bt(e, t, n)).map(async ({ offset: a, imageSize: l }) => {
+    const c = await St(e.image, a, l, e.dataSource, { signal: r, debug: o });
+    if (c === null)
+      throw new Error(`Tile at (${t}, ${n}) not found`);
+    return c;
+  });
+  return Promise.all(s);
+}
+async function Tr(e, t, { signal: n } = {}) {
+  const r = e._debug ? { label: "data" } : void 0;
+  switch (e.cachedTags.planarConfiguration) {
+    case U.Contig:
+      return (await Ct(e.image, t, e.dataSource, {
+        signal: n,
+        debug: r
+      })).map((i, s) => {
+        if (i === null) {
+          const [a, l] = t[s];
+          throw new Error(`Tile at (${a}, ${l}) not found`);
+        }
+        return i;
+      });
+    case U.Separate:
+      return $r(e, t, { signal: n });
+    default:
+      throw new Error(`Unsupported PlanarConfiguration: ${e.cachedTags.planarConfiguration}`);
+  }
+}
+async function $r(e, t, { signal: n } = {}) {
+  const r = e._debug ? { label: "data" } : void 0, o = e.cachedTags.samplesPerPixel, s = (await Promise.all(t.map(([l, c]) => bt(e, l, c)))).flatMap((l) => l.map(({ offset: c, imageSize: u }) => ({
+    offset: c,
+    byteCount: u
+  }))), a = await Lt(e.image, s, e.dataSource, { signal: n, debug: r });
+  return t.map(([l, c], u) => a.slice(u * o, u * o + o).map((h) => {
+    if (h === null)
+      throw new Error(`Tile at (${l}, ${c}) not found`);
+    return h;
+  }));
+}
+async function vt(e, t, n, r, o) {
+  const { size: i, tileSize: s } = e;
+  if (s == null)
+    throw new Error("Tiff is not tiled");
+  const a = Math.ceil(i.height / s.height), l = Math.ceil(i.width / s.width);
+  if (t >= l || n >= a)
+    throw new Error(`Tile index is outside of range x:${t} >= ${l} or y:${n} >= ${a}`);
+  const c = n * l + t, u = l * a;
+  if (c >= u)
+    throw new Error(`Tile index is outside of tile range: ${c} >= ${u}`);
+  const { offset: h, imageSize: p } = await e.getTileSize(c);
+  return St(e, h, p, r, o);
+}
+async function St(e, t, n, r, o) {
+  if (n === 0)
+    return null;
+  o?.debug !== void 0 && console.log(`[geotiff dataSource] ${o.debug.label}: offset=${t} length=${n}`);
+  const i = await r.fetch(t, n, o);
+  if (i.byteLength < n)
+    throw new Error(`Failed to fetch bytes from offset:${t} wanted:${n} got:${i.byteLength}`);
+  const s = e.value(m.Compression) ?? P.None;
+  return s === P.Jpeg ? {
+    bytes: e.getJpegHeader(i),
+    compression: s
+  } : { bytes: i, compression: s };
+}
+async function Lt(e, t, n, r) {
+  if (t.length === 0)
+    return [];
+  const o = new Array(t.length), i = [], s = [];
+  for (let c = 0; c < t.length; c++) {
+    const u = t[c];
+    u.offset === 0 || u.byteCount === 0 ? o[c] = null : (s.push(c), i.push({ offset: u.offset, length: u.byteCount }));
+  }
+  if (i.length === 0)
+    return o;
+  if (r?.debug !== void 0)
+    for (const c of i)
+      console.log(`[geotiff dataSource] ${r.debug.label}: offset=${c.offset} length=${c.length}`);
+  const a = await Hr(n, i, {
+    coalesce: r?.coalesce,
+    maxRangeSize: r?.maxRangeSize,
+    signal: r?.signal
+  }), l = e.value(m.Compression) ?? P.None;
+  for (let c = 0; c < a.length; c++) {
+    const u = s[c], h = a[c], p = l === P.Jpeg ? e.getJpegHeader(h) : h;
+    o[u] = { bytes: p, compression: l };
+  }
+  return o;
+}
+async function Ct(e, t, n, r) {
+  if (t.length === 0)
+    return [];
+  const { size: o, tileSize: i } = e;
+  if (i == null)
+    throw new Error("Tiff is not tiled");
+  const s = Math.ceil(o.height / i.height), a = Math.ceil(o.width / i.width), l = a * s, c = t.map(([h, p]) => {
+    if (h >= a || p >= s)
+      throw new Error(`Tile index is outside of range x:${h} >= ${a} or y:${p} >= ${s}`);
+    const d = p * a + h;
+    if (d >= l)
+      throw new Error(`Tile index is outside of tile range: ${d} >= ${l}`);
+    return d;
+  }), u = await Promise.all(c.map((h) => e.getTileSize(h)));
+  return Lt(e, u.map((h) => ({ offset: h.offset, byteCount: h.imageSize })), n, r);
+}
+function eo(e, t, n, r) {
+  const { width: o, height: i } = e.image.getTileBounds(t, n);
+  if (o === e.tileWidth && i === e.tileHeight)
+    return r;
+  const s = r.mask ? ue(r.mask, e.tileWidth, o, i, 1) : r.mask;
+  if (r.layout === "pixel-interleaved") {
+    const { count: c, data: u } = r, h = ue(u, e.tileWidth, o, i, c);
+    return {
+      ...r,
+      width: o,
+      height: i,
+      data: h,
+      mask: s
+    };
+  }
+  const { bands: a } = r, l = a.map((c) => ue(c, e.tileWidth, o, i, 1));
+  return {
+    ...r,
+    width: o,
+    height: i,
+    bands: l,
+    mask: s
+  };
+}
+function ue(e, t, n, r, o) {
+  const i = t * o, s = n * o, a = new e.constructor(s * r);
+  for (let l = 0; l < r; l++)
+    a.set(e.subarray(l * i, l * i + s), l * s);
+  return a;
+}
+function jt(e, t) {
+  const n = new Set(e), r = new Set(t);
+  if (n.size > 1)
+    throw new Error("Multiple sample formats are not supported.");
+  if (r.size > 1)
+    throw new Error("Multiple bits per sample values are not supported.");
+  const o = e[0], i = t[0];
+  if (o === void 0 || i === void 0)
+    throw new Error("SampleFormat and BitsPerSample arrays cannot be empty.");
+  return {
+    sampleFormat: o,
+    bitsPerSample: i
+  };
+}
+function to(e, { count: t }) {
+  if (e == null)
+    return null;
+  const o = new DOMParser().parseFromString(e, "text/xml").documentElement;
+  if (o.tagName !== "GDALMetadata")
+    throw new Error("Not a GDALMetadata XML block");
+  const i = /* @__PURE__ */ new Map(), s = Array(t).fill(0), a = Array(t).fill(1), l = (c) => {
+    const u = parseInt(c, 10) + 1;
+    return i.has(u) || i.set(u, {
+      max: null,
+      min: null,
+      mean: null,
+      std: null,
+      validPercent: null
+    }), i.get(u);
+  };
+  for (const c of Array.from(o.querySelectorAll("Item"))) {
+    const u = c.getAttribute("name"), h = c.getAttribute("sample"), p = c.textContent ?? "";
+    if (h !== null)
+      switch (u) {
+        case "STATISTICS_MAXIMUM":
+          l(h).max = parseFloat(p);
+          break;
+        case "STATISTICS_MEAN":
+          l(h).mean = parseFloat(p);
+          break;
+        case "STATISTICS_MINIMUM":
+          l(h).min = parseFloat(p);
+          break;
+        case "STATISTICS_STDDEV":
+          l(h).std = parseFloat(p);
+          break;
+        case "STATISTICS_VALID_PERCENT":
+          l(h).validPercent = parseFloat(p);
+          break;
+        case "OFFSET":
+          s[parseInt(h, 10)] = parseFloat(p);
+          break;
+        case "SCALE":
+          a[parseInt(h, 10)] = parseFloat(p);
+          break;
+      }
+  }
+  return { bandStatistics: i, offsets: s, scales: a };
+}
+async function no(e, t = {}) {
+  const { signal: n } = t, r = e.value(m.Compression);
+  if (r === null)
+    throw new Error("Compression tag should always exist.");
+  const [o, i, s, a, l, c, u, h, p, d, g, f, y] = await Promise.all([
+    e.fetch(m.BitsPerSample, { signal: n }),
+    e.fetch(m.ColorMap, { signal: n }),
+    e.fetch(m.GdalNoData, { signal: n }),
+    e.fetch(m.GdalMetadata, { signal: n }),
+    e.fetch(m.LercParameters, { signal: n }),
+    e.fetch(m.ModelPixelScale, { signal: n }),
+    e.fetch(m.ModelTiePoint, { signal: n }),
+    e.fetch(m.ModelTransformation, { signal: n }),
+    e.fetch(m.Photometric, { signal: n }),
+    e.fetch(m.PlanarConfiguration, { signal: n }),
+    e.fetch(m.Predictor, { signal: n }),
+    e.fetch(m.SampleFormat, { signal: n }),
+    e.fetch(m.SamplesPerPixel, { signal: n })
+  ]), j = (b) => {
+    throw new Error(`${b} tag should always exist.`);
+  };
+  return o === null && j("BitsPerSample"), y === null && j("SamplesPerPixel"), p === null && j("Photometric"), {
+    bitsPerSample: new Uint16Array(o),
+    colorMap: i ? new Uint16Array(i) : void 0,
+    compression: r,
+    gdalMetadata: a,
+    lercParameters: l,
+    modelTiepoint: u,
+    modelPixelScale: c,
+    modelTransformation: h,
+    nodata: s !== null ? Number(s) : null,
+    photometric: p,
+    // PlanarConfiguration defaults to interleaved/chunky/contig
+    // https://web.archive.org/web/20240329145253/https://www.awaresystems.be/imaging/tiff/tifftags/planarconfiguration.html
+    planarConfiguration: d ?? U.Contig,
+    predictor: g ?? V.None,
+    // Uint is the default sample format according to the spec
+    // https://web.archive.org/web/20240329145340/https://www.awaresystems.be/imaging/tiff/tifftags/sampleformat.html
+    sampleFormat: f ?? [F.Uint],
+    samplesPerPixel: y
+  };
+}
+function ro(e) {
+  const t = (n) => e.valueGeo(n) ?? null;
+  return {
+    // Configuration keys
+    modelType: t(w.GTModelTypeGeoKey),
+    rasterType: t(w.GTRasterTypeGeoKey),
+    citation: t(w.GTCitationGeoKey),
+    // Geographic CRS keys
+    geodeticCRS: t(w.GeodeticCRSGeoKey),
+    geodeticCitation: t(w.GeodeticCitationGeoKey),
+    geodeticDatum: t(w.GeodeticDatumGeoKey),
+    primeMeridian: t(w.PrimeMeridianGeoKey),
+    linearUnits: t(w.GeogLinearUnitsGeoKey),
+    linearUnitSize: t(w.GeogLinearUnitSizeGeoKey),
+    angularUnits: t(w.GeogAngularUnitsGeoKey),
+    angularUnitSize: t(w.GeogAngularUnitSizeGeoKey),
+    ellipsoid: t(w.EllipsoidGeoKey),
+    ellipsoidSemiMajorAxis: t(w.EllipsoidSemiMajorAxisGeoKey),
+    ellipsoidSemiMinorAxis: t(w.EllipsoidSemiMinorAxisGeoKey),
+    ellipsoidInvFlattening: t(w.EllipsoidInvFlatteningGeoKey),
+    azimuthUnits: t(w.GeogAzimuthUnitsGeoKey),
+    primeMeridianLongitude: t(w.PrimeMeridianLongitudeGeoKey),
+    toWGS84: t(w.GeogTOWGS84GeoKey),
+    // Projected CRS keys
+    projectedCRS: t(w.ProjectedCRSGeoKey),
+    projectedCitation: t(w.ProjectedCitationGeoKey),
+    projection: t(w.ProjectionGeoKey),
+    projMethod: t(w.ProjMethodGeoKey),
+    projLinearUnits: t(w.ProjLinearUnitsGeoKey),
+    projLinearUnitSize: t(w.ProjLinearUnitSizeGeoKey),
+    projStdParallel1: t(w.ProjStdParallel1GeoKey),
+    projStdParallel2: t(w.ProjStdParallel2GeoKey),
+    projNatOriginLong: t(w.ProjNatOriginLongGeoKey),
+    projNatOriginLat: t(w.ProjNatOriginLatGeoKey),
+    projFalseEasting: t(w.ProjFalseEastingGeoKey),
+    projFalseNorthing: t(w.ProjFalseNorthingGeoKey),
+    projFalseOriginLong: t(w.ProjFalseOriginLongGeoKey),
+    projFalseOriginLat: t(w.ProjFalseOriginLatGeoKey),
+    projFalseOriginEasting: t(w.ProjFalseOriginEastingGeoKey),
+    projFalseOriginNorthing: t(w.ProjFalseOriginNorthingGeoKey),
+    projCenterLong: t(w.ProjCenterLongGeoKey),
+    projCenterLat: t(w.ProjCenterLatGeoKey),
+    projCenterEasting: t(w.ProjCenterEastingGeoKey),
+    projCenterNorthing: t(w.ProjCenterNorthingGeoKey),
+    projScaleAtNatOrigin: t(w.ProjScaleAtNatOriginGeoKey),
+    projScaleAtCenter: t(w.ProjScaleAtCenterGeoKey),
+    projAzimuthAngle: t(w.ProjAzimuthAngleGeoKey),
+    projStraightVertPoleLong: t(w.ProjStraightVertPoleLongGeoKey),
+    projRectifiedGridAngle: t(w.ProjRectifiedGridAngleGeoKey),
+    // Vertical CRS keys
+    verticalCRS: t(w.VerticalGeoKey),
+    verticalCitation: t(w.VerticalCitationGeoKey),
+    verticalDatum: t(w.VerticalDatumGeoKey),
+    verticalUnits: t(w.VerticalUnitsGeoKey)
+  };
+}
+function oo({ modelTiepoint: e, modelPixelScale: t, modelTransformation: n, rasterType: r }) {
+  let o;
+  if (e && t)
+    o = io(e, t);
+  else if (n)
+    o = so(n);
+  else
+    throw new Error("The image does not have an affine transformation.");
+  return r === we.PixelIsPoint && (o = ae(o, Le(-0.5, -0.5))), o;
+}
+function io(e, t) {
+  const n = e[3], r = e[4], o = t[0], i = -t[1];
+  return [o, 0, n, 0, i, r];
+}
+function so(e) {
+  const t = e[3], n = e[7], r = e[1], o = e[4], i = e[0], s = e[5];
+  return [i, r, t, o, s, n];
+}
+function xt(e, t, n, r = Math.floor) {
+  const o = de(e.transform), [i, s] = A(o, t, n);
+  return [r(s), r(i)];
+}
+function Ot(e, t, n, r = "center") {
+  let o, i;
+  switch (r) {
+    case "center":
+      o = n + 0.5, i = t + 0.5;
+      break;
+    case "ul":
+      o = n, i = t;
+      break;
+    case "ur":
+      o = n + 1, i = t;
+      break;
+    case "ll":
+      o = n, i = t + 1;
+      break;
+    case "lr":
+      o = n + 1, i = t + 1;
+      break;
+  }
+  return A(e.transform, o, i);
+}
+class ao {
+  cachedTags;
+  /** The data source used for fetching tile data. */
+  dataSource;
+  /** A reference to the parent GeoTIFF object. */
+  geotiff;
+  /** The GeoKeyDirectory of the primary IFD. */
+  gkd;
+  /** The data IFD for this resolution level. */
+  image;
+  /** The IFD for the mask associated with this overview level, if any. */
+  maskImage = null;
+  constructor(t, n, r, o, i, s) {
+    this.geotiff = t, this.gkd = n, this.image = r, this.maskImage = o, this.cachedTags = i, this.dataSource = s;
+  }
+  /**
+   * The CRS parsed from the GeoKeyDirectory.
+   *
+   * Returns an EPSG code (number) for EPSG-coded CRSes, or a PROJJSON object
+   * for user-defined CRSes. The result is cached after the first access.
+   *
+   * See also {@link GeoTIFF.epsg} for the EPSG code directly from the TIFF tags.
+   */
+  get crs() {
+    return this.geotiff.crs;
+  }
+  /** Image height in pixels. */
+  get height() {
+    return this.image.size.height;
+  }
+  /** The no data value, or null if not set. */
+  get nodata() {
+    return this.geotiff.nodata;
+  }
+  /** Inherits the {@link GeoTIFF._debug} flag from the parent. */
+  get _debug() {
+    return this.geotiff._debug;
+  }
+  /** The number of tiles in the x and y directions */
+  get tileCount() {
+    return this.image.tileCount;
+  }
+  /** Tile height in pixels. */
+  get tileHeight() {
+    return this.image.tileSize.height;
+  }
+  /** Tile width in pixels. */
+  get tileWidth() {
+    return this.image.tileSize.width;
+  }
+  /**
+   * Return the dataset's georeferencing transformation matrix.
+   */
+  get transform() {
+    const t = this.geotiff.transform, n = this.geotiff.width / this.width, r = this.geotiff.height / this.height;
+    return ae(t, tn(n, r));
+  }
+  /** Image width in pixels. */
+  get width() {
+    return this.image.size.width;
+  }
+  /** Fetch a single tile from the full-resolution image.
+   *
+   * @param x The tile column index (0-based).
+   * @param y The tile row index (0-based).
+   * @param options Optional parameters for fetching the tile.
+   * @param options.boundless Whether to clip tiles that are partially outside the image bounds. When `true`, no clipping is applied and edge tiles are returned at the full nominal tile size. Defaults to `true`.
+   * @param options.pool An optional {@link DecoderPool} for decoding the tile data. If not provided, a new decoder will be created for each tile.
+   * @param options.signal An optional {@link AbortSignal} to cancel the fetch request.
+   */
+  async fetchTile(t, n, r = {}) {
+    return await yt(this, t, n, r);
+  }
+  /**
+   * Fetch multiple tiles in parallel.
+   *
+   * A future implementation may coalesce contiguous byte ranges to reduce
+   * the number of HTTP requests.
+   *
+   * @param xy - Array of `[x, y]` tile coordinates.
+   * @param options - Optional parameters (same as {@link fetchTile}).
+   * @returns Array of {@link Tile} objects in the same order as `xy`.
+   *
+   * @see {@link fetchTile} for single-tile fetching.
+   */
+  async fetchTiles(t, n = {}) {
+    return await Pt(this, t, n);
+  }
+  // TiledMixin
+  // Transform mixin
+  /**
+   * Get the (row, col) pixel index containing the geographic coordinate (x, y).
+   *
+   * @param x          x coordinate in the CRS.
+   * @param y          y coordinate in the CRS.
+   * @param op         Rounding function applied to fractional pixel indices.
+   *                   Defaults to Math.floor.
+   * @returns          [row, col] pixel indices.
+   */
+  index(t, n, r = Math.floor) {
+    return xt(this, t, n, r);
+  }
+  /**
+   * Get the geographic (x, y) coordinate of the pixel at (row, col).
+   *
+   * @param row        Pixel row.
+   * @param col        Pixel column.
+   * @param offset     Which part of the pixel to return.  Defaults to "center".
+   * @returns          [x, y] in the CRS.
+   */
+  xy(t, n, r = "center") {
+    return Ot(this, t, n, r);
+  }
+}
+class _ {
+  /**
+   * Reduced-resolution overview levels, sorted finest-to-coarsest.
+   *
+   * Does not include the full-resolution image — use {@link fetchTile} on the
+   * GeoTIFF instance itself for that.
+   */
+  overviews;
+  /** A cached CRS value. */
+  _crs;
+  /** Cached TIFF tags that are pre-fetched when opening the GeoTIFF. */
+  cachedTags;
+  /** The data source used for fetching tile data.
+   *
+   * This is typically the raw source (e.g. HTTP or memory) rather than a
+   * layered source with caching and chunking, to avoid unnecessary copying of
+   * tile data through cache layers.
+   */
+  dataSource;
+  /** The underlying Tiff instance. */
+  tiff;
+  /** The primary (full-resolution) TiffImage. */
+  image;
+  /** The mask IFD of the full-resolution GeoTIFF, if any. */
+  maskImage;
+  /** The GeoKeyDirectory of the primary IFD. */
+  gkd;
+  /** Parsed GDALMetadata tag, if present. */
+  gdalMetadata;
+  /**
+   * Internal: when true, log each `dataSource` fetch (image tile data and
+   * mask tile data) to the console with offset/length and a `data`/`mask`
+   * label. Enable via the `debug` option on {@link GeoTIFF.open} or
+   * {@link GeoTIFF.fromUrl}. Read by the tile-fetch path; not part of the
+   * public API surface.
+   *
+   * @internal
+   */
+  _debug;
+  constructor(t, n, r, o, i, s, a, l, c) {
+    this.tiff = t, this.image = n, this.maskImage = r, this.gkd = o, this.overviews = i, this.cachedTags = s, this.dataSource = a, this.gdalMetadata = l, this._debug = c;
+  }
+  /**
+   * Open a GeoTIFF from a @cogeotiff/core Source.
+   *
+   * This creates and initialises the underlying Tiff, then classifies IFDs.
+   *
+   * @param options.dataSource A source for fetching tile data. This is separate from the source used to construct the TIFF to allow for separate caching implementations.
+   * @param options.headerSource The source used to construct the TIFF. This is typically a layered source with caching and chunking, to optimise access to TIFF tags and IFDs. Callers who want to control the initial read size should compose a `SourceChunk` of the desired block size; cogeotiff's default `defaultReadSize` (16 KiB) gets padded up by the chunking layer anyway.
+   * @param options.signal An optional {@link AbortSignal} to cancel the header reads.
+   * @param options.debug When true, the returned GeoTIFF logs each tile/mask data fetch to the console. Off by default.
+   */
+  static async open(t) {
+    const { dataSource: n, headerSource: r, signal: o, debug: i } = t, s = await new Z(r).init({ signal: o });
+    return s.options = void 0, _.fromTiff(s, n, { signal: o, debug: i });
+  }
+  /**
+   * Create a GeoTIFF from an already-initialised Tiff instance.
+   *
+   * All IFDs are walked; mask IFDs are matched to data IFDs by matching
+   * (width, height).  Overviews are sorted from finest to coarsest resolution.
+   *
+   * @param dataSource A source for fetching tile data. This is separate from the source used to construct the TIFF to allow for separate caching implementations.
+   * @param options.signal An optional {@link AbortSignal} to cancel header tag reads.
+   * @param options.debug When true, the returned GeoTIFF logs each tile/mask data fetch to the console.
+   */
+  static async fromTiff(t, n, r = {}) {
+    const { signal: o, debug: i = !1 } = r, s = t.images;
+    if (s.length === 0)
+      throw new Error("TIFF does not contain any IFDs");
+    await Promise.all(s.map((b) => b.init(!0, { signal: o })));
+    const a = s[0], l = ro(a), c = /* @__PURE__ */ new Map(), u = /* @__PURE__ */ new Map();
+    for (let b = 1; b < s.length; b++) {
+      const S = s[b], v = S.size, L = `${v.width},${v.height}`;
+      lo(S) ? u.set(L, S) : c.set(L, S);
+    }
+    const h = `${a.size.width},${a.size.height}`, p = u.get(h) ?? null, d = Array.from(c.entries());
+    d.sort((b, S) => {
+      const v = b[1].size, L = S[1].size;
+      return L.width * L.height - v.width * v.height;
+    });
+    const g = await no(a, { signal: o }), f = to(g.gdalMetadata, {
+      count: g.samplesPerPixel
+    }), y = new _(t, a, p, l, [], g, n, f, i), j = d.map(([b, S]) => {
+      const v = u.get(b) ?? null;
+      return new ao(y, l, S, v, g, n);
+    });
+    return y.overviews = j, y;
+  }
+  /**
+   * Create a GeoTIFF from an ArrayBuffer containing the entire file.
+   *
+   * This is a convenience method that wraps the ArrayBuffer in a memory source
+   * and calls {@link GeoTIFF.open}. For large files, consider using
+   * {@link GeoTIFF.fromUrl} or {@link GeoTIFF.open} with a chunked HTTP source
+   * to avoid loading the entire file into memory at once.
+   *
+   * @param input The ArrayBuffer containing the GeoTIFF file data.
+   * @returns A Promise that resolves to a GeoTIFF instance.
+   */
+  static async fromArrayBuffer(t) {
+    const n = new xe("memory://input.tif", t);
+    return await _.open({
+      dataSource: n,
+      headerSource: n
+    });
+  }
+  /**
+   * Create a new GeoTIFF from a URL.
+   *
+   * Wraps the HTTP source with a fixed-size block-aligned LRU cache tuned for
+   * TIFF metadata. cogeotiff's lazy per-entry reads (for tile offsets, byte
+   * counts, and other tag values) are served by the block cache; adjacent
+   * entries within a single block hit one underlying request. Tile data reads
+   * bypass the cache and go straight to the raw HTTP source.
+   *
+   * @param url The URL of the GeoTIFF to open.
+   * @param options Optional parameters.
+   * @param options.chunkSize Bytes per chunk for the header cache. Defaults to 64 KiB (matches geotiff.js's BlockedSource).
+   * @param options.cacheSize Total cache size in bytes. Defaults to 8 MiB (~128 blocks at the default chunk size).
+   * @param options.signal An optional {@link AbortSignal} to cancel the header reads.
+   * @param options.debug When true, the returned GeoTIFF logs each tile/mask data fetch to the console with offset/length and a `data`/`mask` label. Off by default.
+   * @returns A Promise that resolves to a GeoTIFF instance.
+   */
+  static async fromUrl(t, { chunkSize: n = 64 * 1024, cacheSize: r = 8 * 1024 * 1024, signal: o, debug: i } = {}) {
+    const s = new Y(t, {});
+    s.metadata = { size: Number.POSITIVE_INFINITY };
+    const a = new er(s, [
+      new nr({ size: n }),
+      new $n({ size: r })
+    ]);
+    return await _.open({
+      // Tile data reads bypass the header cache (raw source).
+      dataSource: s,
+      headerSource: a,
+      signal: o,
+      debug: i
+    });
+  }
+  // ── Properties from the primary image ─────────────────────────────────
+  /**
+   * The CRS parsed from the GeoKeyDirectory.
+   *
+   * Returns an EPSG code (number) for EPSG-coded CRSes, or a PROJJSON object
+   * for user-defined CRSes. The result is cached after the first access.
+   *
+   * See also {@link GeoTIFF.epsg} for the EPSG code directly from the TIFF tags.
+   */
+  get crs() {
+    return this._crs === void 0 && (this._crs = Fr(this.gkd)), this._crs;
+  }
+  /** Image width in pixels. */
+  get width() {
+    return this.image.size.width;
+  }
+  /** Image height in pixels. */
+  get height() {
+    return this.image.size.height;
+  }
+  /** The number of tiles in the x and y directions */
+  get tileCount() {
+    return this.image.tileCount;
+  }
+  /** Tile width in pixels. */
+  get tileWidth() {
+    return this.image.tileSize.width;
+  }
+  /** Tile height in pixels. */
+  get tileHeight() {
+    return this.image.tileSize.height;
+  }
+  /** The no data value, or null if not set. */
+  get nodata() {
+    return this.image.noData;
+  }
+  /** Whether the primary image is tiled. */
+  get isTiled() {
+    return this.image.isTiled();
+  }
+  /**
+   * The pre-existing statistics for each band, if available.
+   *
+   * Extracted from the GDALMetadata TIFF tag; never computed on demand.
+   * Keys are **1-based** band indices to match GDAL's convention.
+   *
+   * Returns `null` if no statistics are stored in the file.
+   */
+  get storedStats() {
+    const t = this.gdalMetadata?.bandStatistics;
+    return t && t.size > 0 ? t : null;
+  }
+  /**
+   * The offset for each band (0-indexed), defaulting to 0.
+   *
+   * Extracted from the GDALMetadata TIFF tag.
+   */
+  get offsets() {
+    return this.gdalMetadata?.offsets ?? Array(this.count).fill(0);
+  }
+  /**
+   * The scale for each band (0-indexed), defaulting to 1.
+   *
+   * Extracted from the GDALMetadata TIFF tag.
+   */
+  get scales() {
+    return this.gdalMetadata?.scales ?? Array(this.count).fill(1);
+  }
+  /** Number of bands (samples per pixel). */
+  get count() {
+    return this.image.value(m.SamplesPerPixel) ?? 1;
+  }
+  /** Bounding box [minX, minY, maxX, maxY] in the CRS. */
+  get bbox() {
+    return this.image.bbox;
+  }
+  /**
+   * Return the dataset's georeferencing transformation matrix.
+   */
+  get transform() {
+    const { modelPixelScale: t, modelTiepoint: n, modelTransformation: r } = this.cachedTags;
+    return oo({
+      modelTiepoint: n,
+      modelPixelScale: t,
+      modelTransformation: r,
+      rasterType: this.gkd.rasterType
+    });
+  }
+  // Mixins
+  /** Fetch a single tile from the full-resolution image.
+   *
+   * @param x The tile column index (0-based).
+   * @param y The tile row index (0-based).
+   * @param options Optional parameters for fetching the tile.
+   * @param options.boundless Whether to clip tiles that are partially outside the image bounds. When `true`, no clipping is applied and edge tiles are returned at the full nominal tile size. Defaults to `true`.
+   * @param options.pool An optional {@link DecoderPool} for decoding the tile data. If not provided, a new decoder will be created for each tile.
+   * @param options.signal An optional {@link AbortSignal} to cancel the fetch request.
+   */
+  async fetchTile(t, n, r = {}) {
+    return await yt(this, t, n, r);
+  }
+  /**
+   * Fetch multiple tiles in parallel.
+   *
+   * A future implementation may coalesce contiguous byte ranges to reduce
+   * the number of HTTP requests.
+   *
+   * @param xy - Array of `[x, y]` tile coordinates.
+   * @param options - Optional parameters (same as {@link fetchTile}).
+   * @returns Array of {@link Tile} objects in the same order as `xy`.
+   *
+   * @see {@link fetchTile} for single-tile fetching.
+   */
+  async fetchTiles(t, n = {}) {
+    return await Pt(this, t, n);
+  }
+  // Transform mixin
+  /**
+   * Get the (row, col) pixel index containing the geographic coordinate (x, y).
+   *
+   * @param x          x coordinate in the CRS.
+   * @param y          y coordinate in the CRS.
+   * @param op         Rounding function applied to fractional pixel indices.
+   *                   Defaults to Math.floor.
+   * @returns          [row, col] pixel indices.
+   */
+  index(t, n, r = Math.floor) {
+    return xt(this, t, n, r);
+  }
+  /**
+   * Get the geographic (x, y) coordinate of the pixel at (row, col).
+   *
+   * @param row        Pixel row.
+   * @param col        Pixel column.
+   * @param offset     Which part of the pixel to return.  Defaults to "center".
+   * @returns          [x, y] in the CRS.
+   */
+  xy(t, n, r = "center") {
+    return Ot(this, t, n, r);
+  }
+}
+function lo(e) {
+  const t = e.value(m.SubFileType), n = e.value(m.Photometric);
+  return t !== null && (t & $.Mask) !== 0 && n === R.Mask;
+}
+class co {
+  worker;
+  jobIdCounter = 0;
+  jobs = /* @__PURE__ */ new Map();
+  constructor(t) {
+    this.worker = t, this.worker.addEventListener("message", (n) => this.onMessage(n));
+  }
+  get jobCount() {
+    return this.jobs.size;
+  }
+  onMessage(t) {
+    const { jobId: n, error: r, pixels: o } = t.data, i = this.jobs.get(n);
+    this.jobs.delete(n), i && (r ? i.reject(new Error(r)) : i.resolve(o));
+  }
+  submitJob(t, n) {
+    const r = this.jobIdCounter++;
+    return new Promise((o, i) => {
+      this.jobs.set(r, { resolve: o, reject: i }), this.worker.postMessage({ ...t, jobId: r }, { transfer: n });
+    });
+  }
+  terminate() {
+    this.worker.terminate();
+  }
+}
+const uo = typeof navigator < "u" ? navigator.hardwareConcurrency ?? 2 : 2;
+class ho {
+  workerWrappers;
+  constructor(t = {}) {
+    const { size: n = uo, createWorker: r } = t;
+    if (this.workerWrappers = [], r && n > 0)
+      for (let o = 0; o < n; o++)
+        this.workerWrappers.push(new co(r()));
+  }
+  /** True when workers are available for off-main-thread decoding. */
+  get hasWorkers() {
+    return this.workerWrappers.length > 0;
+  }
+  /**
+   * Decode a compressed tile buffer.
+   *
+   * When workers are available, the compressed `bytes` buffer is transferred
+   * zero-copy to the least-loaded worker. The returned `DecodedPixels` typed
+   * array buffers are transferred back to the main thread.
+   *
+   * When no workers are available, decoding runs on the main thread via the
+   * normal `decode()` path.
+   */
+  async decode(t, n, r) {
+    if (!this.hasWorkers)
+      return je(t, n, r);
+    const o = this.leastLoaded(), i = {
+      compression: n,
+      metadata: r,
+      buffer: t
+    };
+    return await o.submitJob(i, [t]);
+  }
+  /** Terminate all workers and release resources. */
+  destroy() {
+    for (const t of this.workerWrappers)
+      t.terminate();
+    this.workerWrappers.length = 0;
+  }
+  leastLoaded() {
+    let t = this.workerWrappers[0];
+    for (let n = 1; n < this.workerWrappers.length; n++)
+      this.workerWrappers[n].jobCount < t.jobCount && (t = this.workerWrappers[n]);
+    return t;
+  }
+}
+let oe = null;
+function po() {
+  return oe !== null || (oe = new ho({
+    createWorker: () => new Worker(new URL(
+      /* @vite-ignore */
+      "/assets/worker-DtIrTJB7.js",
+      import.meta.url
+    ), { type: "module" })
+  })), oe;
+}
+function mo(e) {
+  const { height: t, width: n } = e;
+  if (e.layout === "band-separate")
+    throw new Error("Band-separate images not yet implemented.");
+  if (e.data.length === t * n * 4)
+    return e;
+  if (e.data.length === t * n * 3) {
+    const r = e.data.length / 3 * 4, o = e.data instanceof Uint16Array, i = o ? new Uint16Array(r) : new Uint8ClampedArray(r), s = o ? 65535 : 255;
+    for (let a = 0; a < e.data.length / 3; ++a)
+      i[a * 4] = e.data[a * 3], i[a * 4 + 1] = e.data[a * 3 + 1], i[a * 4 + 2] = e.data[a * 3 + 2], i[a * 4 + 3] = s;
+    return {
+      ...e,
+      count: 4,
+      data: i
+    };
+  } else
+    throw new Error(`Unexpected number of channels in raster data: ${e.data.length / (t * n)}`);
+}
+async function go(e) {
+  return typeof e == "string" || e instanceof URL ? await _.fromUrl(e) : e instanceof ArrayBuffer ? await _.fromArrayBuffer(e) : e;
+}
+function fo(e, t) {
+  const [n, r, o, i] = e.bbox, s = [
+    t.forward([n, r]),
+    // bottom-left
+    t.forward([o, r]),
+    // bottom-right
+    t.forward([o, i]),
+    // top-right
+    t.forward([n, i])
+    // top-left
+  ], a = s.map((d) => d[0]), l = s.map((d) => d[1]), c = Math.min(...a), u = Math.min(...l), h = Math.max(...a), p = Math.max(...l);
+  return { west: c, south: u, east: h, north: p };
+}
+const yo = (
+  /* glsl */
+  `
+  vec3 black_zero_to_rgb(float value) {
+    return vec3(value, value, value);
+  }
+`
+), wo = {
+  name: "black-is-zero",
+  inject: {
+    "fs:#decl": yo,
+    "fs:DECKGL_FILTER_COLOR": (
+      /* glsl */
+      `
+      color.rgb = black_zero_to_rgb(color.r);
+    `
+    )
+  }
+}, Po = (
+  /* glsl */
+  `
+  const vec3 D65 = vec3(
+      0.95047, // Xn
+      1.00000, // Yn
+      1.08883 // Zn
+  );
+
+  vec3 cielabToRgb(vec3 labTex) {
+    // labTex in [0,1] from RGB8 texture
+    float L = labTex.r * 255.0;
+    float a = (labTex.g - 0.5) * 255.0;
+    float b = (labTex.b - 0.5) * 255.0;
+
+    float y = (L + 16.0) / 116.0;
+    float x = (a / 500.0) + y;
+    float z = y - (b / 200.0);
+
+    vec3 xyz;
+    vec3 v = vec3(x, y, z);
+    vec3 v3 = v * v * v;
+
+    xyz = D65 * mix(
+      (v - 16.0 / 116.0) / 7.787,
+      v3,
+      step(0.008856, v3)
+    );
+
+    vec3 rgb = mat3(
+      3.2406, -1.5372, -0.4986,
+      -0.9689, 1.8758, 0.0415,
+      0.0557, -0.2040, 1.0570
+    ) * xyz;
+
+    // sRGB gamma
+    rgb = mix(
+      12.92 * rgb,
+      1.055 * pow(rgb, vec3(1.0 / 2.4)) - 0.055,
+      step(0.0031308, rgb)
+    );
+
+    return clamp(rgb, 0.0, 1.0);
+  }
+`
+), bo = {
+  name: "cielab-to-rgb",
+  inject: {
+    "fs:#decl": Po,
+    "fs:DECKGL_FILTER_COLOR": (
+      /* glsl */
+      `
+      color.rgb = cielabToRgb(color);
+    `
+    )
+  }
+}, vo = (
+  /* glsl */
+  `
+  vec3 cmykToRgb(vec4 cmyk) {
+    // cmyk in [0.0, 1.0]
+    float invK = 1.0 - cmyk.a;
+
+    return vec3(
+        (1.0 - cmyk.r) * invK,
+        (1.0 - cmyk.g) * invK,
+        (1.0 - cmyk.b) * invK
+    );
+  }
+`
+), So = {
+  name: "cmyk-to-rgb",
+  inject: {
+    "fs:#decl": vo,
+    "fs:DECKGL_FILTER_COLOR": (
+      /* glsl */
+      `
+      color.rgb = cmykToRgb(color);
+    `
+    )
+  }
+}, Lo = (
+  /* glsl */
+  `
+  vec3 white_zero_to_rgb(float value) {
+    return vec3(1.0 - value, 1.0 - value, 1.0 - value);
+  }
+`
+), Co = {
+  name: "white-is-zero",
+  inject: {
+    "fs:#decl": Lo,
+    "fs:DECKGL_FILTER_COLOR": (
+      /* glsl */
+      `
+      color.rgb = white_zero_to_rgb(color.r);
+    `
+    )
+  }
+}, T = "colormap", At = {
+  name: T,
+  fs: `uniform ${T}Uniforms {
+  int colormapIndex;
+  float reversed;
+} ${T};
+`,
+  inject: {
+    "fs:#decl": `precision highp sampler2DArray;
+uniform sampler2DArray colormapTexture;
+`,
+    "fs:DECKGL_FILTER_COLOR": (
+      /* glsl */
+      `
+      float idx = mix(color.r, 1.0 - color.r, ${T}.reversed);
+      color = texture(
+        colormapTexture,
+        vec3(idx, 0.5, float(${T}.colormapIndex))
+      );
+    `
+    )
+  },
+  uniformTypes: {
+    colormapIndex: "i32",
+    reversed: "f32"
+  },
+  getUniforms: (e) => ({
+    colormapTexture: e.colormapTexture,
+    colormapIndex: e.colormapIndex ?? 0,
+    reversed: e.reversed ?? !1
+  })
+}, he = {
+  accent: 0,
+  afmhot: 1,
+  algae: 2,
+  amp: 3,
+  autumn: 4,
+  balance: 5,
+  binary: 6,
+  blues: 7,
+  bone: 8,
+  brbg: 9,
+  brg: 10,
+  bugn: 11,
+  bupu: 12,
+  bwr: 13,
+  cfastie: 14,
+  cividis: 15,
+  cmrmap: 16,
+  cool: 17,
+  coolwarm: 18,
+  copper: 19,
+  cubehelix: 20,
+  curl: 21,
+  dark2: 22,
+  deep: 23,
+  delta: 24,
+  dense: 25,
+  diff: 26,
+  flag: 27,
+  gist_earth: 28,
+  gist_gray: 29,
+  gist_heat: 30,
+  gist_ncar: 31,
+  gist_rainbow: 32,
+  gist_stern: 33,
+  gist_yarg: 34,
+  gnbu: 35,
+  gnuplot: 36,
+  gnuplot2: 37,
+  gray: 38,
+  greens: 39,
+  greys: 40,
+  haline: 41,
+  hot: 42,
+  hsv: 43,
+  ice: 44,
+  inferno: 45,
+  jet: 46,
+  magma: 47,
+  matter: 48,
+  nipy_spectral: 49,
+  ocean: 50,
+  oranges: 51,
+  orrd: 52,
+  oxy: 53,
+  paired: 54,
+  pastel1: 55,
+  pastel2: 56,
+  phase: 57,
+  pink: 58,
+  piyg: 59,
+  plasma: 60,
+  prgn: 61,
+  prism: 62,
+  pubu: 63,
+  pubugn: 64,
+  puor: 65,
+  purd: 66,
+  purples: 67,
+  rain: 68,
+  rainbow: 69,
+  rdbu: 70,
+  rdgy: 71,
+  rdpu: 72,
+  rdylbu: 73,
+  rdylgn: 74,
+  reds: 75,
+  rplumbo: 76,
+  schwarzwald: 77,
+  seismic: 78,
+  set1: 79,
+  set2: 80,
+  set3: 81,
+  solar: 82,
+  spectral: 83,
+  speed: 84,
+  spring: 85,
+  summer: 86,
+  tab10: 87,
+  tab20: 88,
+  tab20b: 89,
+  tab20c: 90,
+  tarn: 91,
+  tempo: 92,
+  terrain: 93,
+  thermal: 94,
+  topo: 95,
+  turbid: 96,
+  turbo: 97,
+  twilight: 98,
+  twilight_shifted: 99,
+  viridis: 100,
+  winter: 101,
+  wistia: 102,
+  ylgn: 103,
+  ylgnbu: 104,
+  ylorbr: 105,
+  ylorrd: 106
+};
+function jo(e, t) {
+  if (t.width !== 256)
+    throw new Error(`Expected a 256-pixel-wide colormap sprite, got width ${t.width}.`);
+  const n = new Uint8Array(t.data.buffer, t.data.byteOffset, t.data.byteLength);
+  return e.createTexture({
+    dimension: "2d-array",
+    format: "rgba8unorm",
+    width: 256,
+    height: 1,
+    depth: t.height,
+    data: n,
+    mipLevels: 1,
+    sampler: {
+      minFilter: "linear",
+      magFilter: "linear",
+      // Clamp in every axis so an out-of-range colormapIndex yields an
+      // edge color rather than wrapping to an unrelated colormap.
+      addressModeU: "clamp-to-edge",
+      addressModeV: "clamp-to-edge",
+      addressModeW: "clamp-to-edge"
+    }
+  });
+}
+async function xo(e) {
+  const t = await Oo(e);
+  try {
+    return Ao(t);
+  } finally {
+    t.close();
+  }
+}
+async function Oo(e) {
+  if (e instanceof ImageBitmap)
+    return e;
+  const t = new Blob([e]);
+  return createImageBitmap(t);
+}
+function Ao(e) {
+  const n = new OffscreenCanvas(e.width, e.height).getContext("2d");
+  if (!n)
+    throw new Error("Failed to obtain 2D context for decoding the colormap sprite.");
+  return n.drawImage(e, 0, 0), n.getImageData(0, 0, e.width, e.height);
+}
+const ve = "nodata", Eo = `uniform ${ve}Uniforms {
+  float value;
+} ${ve};
+`, Et = {
+  name: ve,
+  fs: Eo,
+  inject: {
+    "fs:DECKGL_FILTER_COLOR": (
+      /* glsl */
+      `
+    if (color.r == nodata.value) {
+      discard;
+    }
+    `
+    )
+  },
+  uniformTypes: {
+    value: "f32"
+  },
+  getUniforms: (e) => ({
+    value: e.value
+  })
+}, H = "linearRescale", Io = {
+  name: H,
+  fs: `uniform ${H}Uniforms {
+  float rescaleMin;
+  float rescaleMax;
+} ${H};
+`,
+  inject: {
+    "fs:DECKGL_FILTER_COLOR": (
+      /* glsl */
+      `
+  color.rgb = clamp((color.rgb - ${H}.rescaleMin) / (${H}.rescaleMax - ${H}.rescaleMin), 0.0, 1.0);
+`
+    )
+  },
+  uniformTypes: {
+    rescaleMin: "f32",
+    rescaleMax: "f32"
+  },
+  getUniforms: (e) => ({
+    rescaleMin: e.rescaleMin ?? 0,
+    rescaleMax: e.rescaleMax ?? 1
+  })
+}, Mo = {
+  name: "mask-texture",
+  inject: {
+    "fs:#decl": "uniform sampler2D maskTexture;",
+    "fs:DECKGL_FILTER_COLOR": (
+      /* glsl */
+      `
+      float maskValue = texture(maskTexture, geometry.uv).r;
+      if (maskValue == 0.0) {
+        discard;
+      }
+    `
+    )
+  },
+  getUniforms: (e) => ({
+    maskTexture: e.maskTexture
+  })
+};
+function Ro(e, t, n) {
+  const r = zo(e), o = Fo(t), i = Do(n), s = `${r}:${i}:${o}`, a = No[s];
+  if (!a)
+    throw new Error(`Unsupported texture format for SamplesPerPixel=${e}, BitsPerSample=${t}, SampleFormat=${n}`);
+  return a;
+}
+function zo(e) {
+  if (e === 1 || e === 2 || e === 3 || e === 4)
+    return e;
+  throw new Error(`Unsupported SamplesPerPixel ${e}. Only 1, 2, 3, or 4 are supported.`);
+}
+function Fo(e) {
+  const t = e[0];
+  for (let n = 1; n < e.length; n++)
+    if (e[n] !== t)
+      throw new Error(`Unsupported varying BitsPerSample ${e}. All samples must have the same bit width.`);
+  if (t !== 8 && t !== 16 && t !== 32)
+    throw new Error(`Unsupported BitsPerSample ${t}. Only 8, 16, or 32 are supported.`);
+  return t;
+}
+function Do(e) {
+  const t = e[0];
+  for (let n = 1; n < e.length; n++)
+    if (e[n] !== t)
+      throw new Error(`Unsupported varying SampleFormat ${e}. All samples must have the same format.`);
+  switch (t) {
+    case F.Uint:
+      return "unorm";
+    case F.Int:
+      return "sint";
+    case F.Float:
+      return "float";
+    default:
+      throw new Error(`Unsupported SampleFormat ${e}`);
+  }
+}
+const No = {
+  // 1 byte per pixel
+  "1:sint:8": "r8sint",
+  "1:uint:8": "r8uint",
+  "1:unorm:8": "r8unorm",
+  // 2 bytes per pixel (one channel)
+  "1:float:16": "r16float",
+  "1:sint:16": "r16sint",
+  "1:uint:16": "r16uint",
+  "1:unorm:16": "r16unorm",
+  // 2 bytes per pixel (two channels)
+  "2:sint:8": "rg8sint",
+  "2:uint:8": "rg8uint",
+  "2:unorm:8": "rg8unorm",
+  // 4 bytes per pixel (one channel)
+  "1:float:32": "r32float",
+  "1:sint:32": "r32sint",
+  "1:uint:32": "r32uint",
+  // 4 bytes per pixel (two channels)
+  "2:float:16": "rg16float",
+  "2:sint:16": "rg16sint",
+  "2:uint:16": "rg16uint",
+  "2:unorm:16": "rg16unorm",
+  // 4 bytes per pixel (four channels)
+  "4:sint:8": "rgba8sint",
+  "4:uint:8": "rgba8uint",
+  "4:unorm:8": "rgba8unorm",
+  // 6 bytes per pixel (three channels)
+  // Note: this is supported on WebGL2 but not supported on WebGPU
+  // I expect actual switch to WebGPU to be quite a ways off still
+  "3:uint:16": "rgb16unorm-webgl",
+  // 8 bytes per pixel (two channels)
+  "2:float:32": "rg32float",
+  "2:sint:32": "rg32sint",
+  "2:uint:32": "rg32uint",
+  // 8 bytes per pixel (four channels)
+  "4:float:16": "rgba16float",
+  "4:sint:16": "rgba16sint",
+  "4:uint:16": "rgba16uint",
+  "4:unorm:16": "rgba16unorm",
+  // 12 bytes per pixel (three channels)
+  "3:float:32": "rgb32float-webgl",
+  // 16 bytes per pixel (four channels)
+  "4:float:32": "rgba32float",
+  "4:sint:32": "rgba32sint",
+  "4:uint:32": "rgba32uint"
+};
+function Uo(e, t) {
+  const { sampleFormat: n } = e.cachedTags;
+  if (n === null)
+    throw new Error("SampleFormat tag is required to infer render pipeline");
+  switch (n[0]) {
+    // Unsigned integers
+    case F.Uint:
+      return Bo(e, t);
+  }
+  throw new Error(`Inferring render pipeline for non-unsigned integers not yet supported. Found SampleFormat: ${n}`);
+}
+function Bo(e, t) {
+  const { bitsPerSample: n, colorMap: r, photometric: o, sampleFormat: i, samplesPerPixel: s, nodata: a } = e.cachedTags, l = [
+    {
+      module: Se,
+      props: {
+        textureName: (d) => d.texture
+      }
+    }
+  ];
+  if (a !== null) {
+    const d = 2 ** n[0] - 1, g = a / d;
+    l.push({
+      module: Et,
+      props: { value: g }
+    });
+  }
+  e.maskImage !== null && l.push({
+    module: Mo,
+    props: {
+      // TODO: how to handle if mask failed to load and is undefined here
+      maskTexture: (d) => d.mask
+    }
+  });
+  const c = Go({
+    count: s,
+    photometric: o,
+    device: t,
+    colorMap: r
+  });
+  c && l.push(c);
+  const u = o === R.Palette ? {
+    magFilter: "nearest",
+    minFilter: "nearest"
+  } : {
+    magFilter: "linear",
+    minFilter: "linear"
+  };
+  return { getTileData: async (d, g) => {
+    const { device: f, x: y, y: j, signal: b, pool: S } = g, v = await d.fetchTile(y, j, {
+      boundless: !1,
+      pool: S,
+      signal: b
+    });
+    let { array: L } = v;
+    const { width: E, height: M, mask: z } = L;
+    let I = s;
+    if (s === 3 && (L = mo(L), I = 4), L.layout === "band-separate")
+      throw new Error("Band-separate images not yet implemented.");
+    const J = Ro(
+      // Add one sample for added alpha channel
+      I,
+      n,
+      i
+    );
+    let q = L.data.byteLength;
+    const te = f.createTexture({
+      data: L.data,
+      format: J,
+      width: E,
+      height: M,
+      sampler: u
+    });
+    let ne;
+    return z !== null && (ne = f.createTexture({
+      data: z,
+      // Single-channel 8-bit texture for the mask
+      format: "r8unorm",
+      width: E,
+      height: M,
+      // Use nearest filtering for the mask to avoid interpolated edges/halos
+      sampler: {
+        minFilter: "nearest",
+        magFilter: "nearest"
+      }
+    }), q += z.byteLength), {
+      texture: te,
+      mask: ne,
+      byteLength: q,
+      height: L.height,
+      width: L.width
+    };
+  }, renderTile: (d) => ({
+    renderPipeline: l.map((g, f) => Ko(g, d))
+  }) };
+}
+function Go({ count: e, colorMap: t, device: n, photometric: r }) {
+  if (e === 3 || e === 4)
+    return null;
+  switch (r) {
+    case R.MinIsWhite:
+      return {
+        module: Co
+      };
+    case R.MinIsBlack:
+      return {
+        module: wo
+      };
+    case R.Rgb:
+      return null;
+    case R.Palette: {
+      if (!t)
+        throw new Error("ColorMap is required for PhotometricInterpretation Palette");
+      const { data: o, width: i, height: s } = En(t), a = n.createTexture({
+        dimension: "2d-array",
+        data: o,
+        format: "rgba8unorm",
+        width: i,
+        height: s,
+        depth: 1,
+        mipLevels: 1,
+        sampler: {
+          minFilter: "nearest",
+          magFilter: "nearest",
+          addressModeU: "clamp-to-edge",
+          addressModeV: "clamp-to-edge",
+          addressModeW: "clamp-to-edge"
+        }
+      });
+      return {
+        module: At,
+        props: {
+          colormapTexture: a
+        }
+      };
+    }
+    // Not sure why cogeotiff calls this "Separated", but it means CMYK
+    case R.Separated:
+      return {
+        module: So
+      };
+    case R.Ycbcr:
+      return null;
+    case R.Cielab:
+      return {
+        module: bo
+      };
+    default:
+      throw new Error(`Unsupported PhotometricInterpretation ${r}`);
+  }
+}
+function Ko(e, t) {
+  const { module: n, props: r } = e;
+  if (!r)
+    return { module: n };
+  const o = {};
+  for (const [i, s] of Object.entries(r)) {
+    const a = typeof s == "function" ? s(t) : s;
+    a !== void 0 && (o[i] = a);
+  }
+  return { module: n, props: o };
+}
+function _o(e, t) {
+  const r = [
+    ...[...e.overviews].reverse(),
+    e
+  ].map((o) => new on({
+    affine: o.transform,
+    arrayWidth: o.width,
+    arrayHeight: o.height,
+    tileWidth: o.tileWidth,
+    tileHeight: o.tileHeight,
+    mpu: t.mpu
+  }));
+  return new en({
+    levels: r,
+    projectTo3857: t.projectTo3857,
+    projectFrom3857: t.projectFrom3857,
+    projectTo4326: t.projectTo4326,
+    projectFrom4326: t.projectFrom4326
+  });
+}
+class Xo extends Be {
+  static layerName = "COGLayer";
+  // COGLayer's getTileData signature differs from the base class's, so
+  // `DefaultProps<COGLayerProps>` is not assignable to
+  // `DefaultProps<RasterTileLayerProps>`. Cast to the base static-side type
+  // to keep inheritance happy. The only COG-specific default is
+  // `epsgResolver`; all behavior still flows from the base class.
+  static defaultProps = {
+    ...Be.defaultProps,
+    epsgResolver: an
+  };
+  initializeState() {
+    this.setState({});
+  }
+  updateState(t) {
+    super.updateState(t);
+    const { props: n, oldProps: r, changeFlags: o } = t;
+    (!!o.dataChanged || n.geotiff !== r.geotiff) && (this.clearState(), this._parseGeoTIFF());
+  }
+  clearState() {
+    this.setState({
+      geotiff: void 0,
+      tilesetDescriptor: void 0,
+      defaultGetTileData: void 0,
+      defaultRenderTile: void 0
+    });
+  }
+  async _parseGeoTIFF() {
+    const t = await go(this.props.geotiff), n = t.crs, r = typeof n == "number" ? await this.props.epsgResolver(n) : ot(n), o = Ae(r, "EPSG:4326"), i = (f, y) => o.forward([f, y], !1), s = (f, y) => o.inverse([f, y], !1), a = Ae(r, "EPSG:3857"), l = un((f, y) => a.forward([f, y], !1), i), c = (f, y) => a.inverse([f, y], !1), u = r.units;
+    if (!u)
+      throw new Error("Source projection is missing 'units' property, cannot compute meters per unit");
+    const h = sn(u, {
+      semiMajorAxis: r.datum?.a ?? r.a
+    }), p = _o(t, {
+      projectTo4326: i,
+      projectFrom4326: s,
+      projectTo3857: l,
+      projectFrom3857: c,
+      mpu: h
+    });
+    if (this.props.onGeoTIFFLoad) {
+      const f = fo(t, o);
+      this.props.onGeoTIFFLoad(t, {
+        projection: r,
+        geographicBounds: f
+      });
+    }
+    let d, g;
+    (!this.props.getTileData || !this.props.renderTile) && ({ getTileData: d, renderTile: g } = Uo(t, this.context.device)), this.setState({
+      geotiff: t,
+      tilesetDescriptor: p,
+      defaultGetTileData: d,
+      defaultRenderTile: g
+    });
+  }
+  _tilesetDescriptor() {
+    return this.state.tilesetDescriptor;
+  }
+  /**
+   * Adapts the user-facing `(image, { x, y, ... }) => Promise<DataT>` signature
+   * into RasterTileLayer's `(tile, { signal, device }) => Promise<DataT>`.
+   */
+  _getTileDataCallback() {
+    const t = this.state.geotiff;
+    if (!t)
+      return;
+    const n = this.props.getTileData ?? this.state.defaultGetTileData;
+    return n ? async (o, i) => {
+      const { x: s, y: a, z: l } = o.index, c = l === t.overviews.length ? t : t.overviews[t.overviews.length - 1 - l];
+      return n(c, {
+        device: i.device,
+        x: s,
+        y: a,
+        signal: i.signal,
+        pool: this.props.pool ?? po()
+      });
+    } : void 0;
+  }
+  _renderTileCallback() {
+    const t = this.props.renderTile ?? this.state.defaultRenderTile;
+    if (t)
+      return t;
+  }
+}
+const Wo = "data:image/png;base64,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", $e = /* @__PURE__ */ new WeakMap();
+function Ho(e) {
+  const t = $e.get(e);
+  if (t) return t;
+  const n = (async () => {
+    const r = await (await fetch(Wo)).arrayBuffer();
+    return jo(e, await xo(r));
+  })();
+  return $e.set(e, n), n;
+}
+const et = /* @__PURE__ */ new Set();
+function ko(e) {
+  return e in he ? he[e] : (et.has(e) || (et.add(e), console.warn(`[onlymapjs] COGLayer: unknown colormap "${e}" — falling back to gray.`)), he.gray);
+}
+function Zo(e) {
+  const t = e.layout === "band-separate" ? e.bands[0] : e.data;
+  return t instanceof Float32Array ? t : new Float32Array(t);
+}
+function Vo(e) {
+  const t = e.width * e.height, n = new Float32Array(t * 4);
+  if (e.layout === "band-separate") {
+    const [r, o, i] = [e.bands[0], e.bands[1], e.bands[2]];
+    for (let s = 0; s < t; s++)
+      n[s * 4] = r[s], n[s * 4 + 1] = o[s], n[s * 4 + 2] = i[s], n[s * 4 + 3] = 1;
+  } else {
+    const { data: r, count: o } = e;
+    for (let i = 0; i < t; i++)
+      n[i * 4] = r[i * o], n[i * 4 + 1] = r[i * o + 1], n[i * 4 + 2] = r[i * o + 2], n[i * 4 + 3] = 1;
+  }
+  return n;
+}
+const Yo = async (e, { device: t, x: n, y: r, signal: o, pool: i }) => {
+  const s = () => {
+    throw o?.reason ?? new DOMException("aborted", "AbortError");
+  };
+  o?.aborted && s();
+  const a = await e.fetchTile(n, r, { boundless: !1, pool: i, signal: o });
+  o?.aborted && s();
+  const l = a.array, c = e.cachedTags.samplesPerPixel, u = { minFilter: "nearest", magFilter: "nearest" }, h = c === 1, p = h ? Zo(l) : Vo(l), d = t.createTexture({
+    data: p,
+    format: h ? "r32float" : "rgba32float",
+    width: l.width,
+    height: l.height,
+    sampler: u
+  });
+  return {
+    width: l.width,
+    height: l.height,
+    byteLength: p.byteLength,
+    texture: d,
+    colormapTexture: await Ho(t),
+    bandCount: c,
+    nodata: l.nodata
+  };
+};
+function Jo(e, t) {
+  const n = [
+    // Per-tile textureName (not the layer-level `image:` shorthand — that
+    // binds only the first tile's sampler in this setup).
+    { module: Se, props: { textureName: e.texture } }
+  ], r = t.nodataOverride ?? e.nodata;
+  return r != null && Number.isFinite(r) && n.push({ module: Et, props: { value: r } }), n.push({
+    module: Io,
+    props: { rescaleMin: t.rescaleMin ?? 0, rescaleMax: t.rescaleMax ?? 255 }
+  }), e.bandCount === 1 && n.push({
+    module: At,
+    props: { colormapTexture: e.colormapTexture, colormapIndex: ko(t.colormap ?? "gray") }
+  }), { renderPipeline: n };
+}
+class qo extends Xo {
+  static layerName = "OmCOGLayer";
+  // Plain nulls (not `{type:"number", value:null}` specs): deck's typed
+  // number props reject null defaults with a console warning per instance.
+  static defaultProps = {
+    rescaleMin: null,
+    rescaleMax: null,
+    colormap: null,
+    nodataOverride: null
+  };
+  constructor(t) {
+    const n = t;
+    if (!(n.rescaleMin != null || n.rescaleMax != null || n.colormap != null && n.colormap !== "" || n.nodataOverride != null)) {
+      super(t);
+      return;
+    }
+    super(t, {
+      getTileData: Yo,
+      renderTile: (o) => o ? Jo(o, n) : null,
+      // Free the per-tile texture on cache eviction; the sprite texture is
+      // device-scoped (WeakMap above) and must NOT be destroyed here.
+      onTileUnload: (o) => {
+        const i = o.data;
+        i && typeof i == "object" && "texture" in i && i.texture.destroy();
+      }
+    });
+  }
+}
+const ei = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
+  __proto__: null,
+  OmCOGLayer: qo
+}, Symbol.toStringTag, { value: "Module" }));
+export {
+  P as C,
+  D,
+  ei as r
+};