@nika-js/onlymap 0.5.9 → 0.5.11

package/dist/raster-pipeline-Dzo5h6YY.js

@@ -0,0 +1,1585 @@
+import { w as ae } from "./mgrs-BY9bIvp4.js";
+import { am as ce, an as le, ao as ee, ap as te, aq as ue, b as he, ar as de, l as Z, as as fe, d as pe, at as me, au as ge, av as ve, aw as ne } from "./index-DTRXxe7D.js";
+function Pe(o, e, t) {
+  const { projectedCorners: n } = e, { topLeft: s, topRight: r, bottomRight: a, bottomLeft: i } = n, c = t(s[0], s[1]), u = t(r[0], r[1]), l = t(a[0], a[1]), d = t(i[0], i[1]), f = [
+    c,
+    u,
+    l,
+    d,
+    c
+  ], h = [
+    (c[0] + l[0]) / 2,
+    (c[1] + l[1]) / 2
+  ], p = new ce({
+    id: `${o}-label`,
+    data: [
+      {
+        position: h,
+        text: `x=${e.index.x} y=${e.index.y} z=${e.index.z}`
+      }
+    ],
+    getColor: [255, 255, 255, 255],
+    getSize: 24,
+    sizeUnits: "pixels",
+    outlineWidth: 3,
+    outlineColor: [0, 0, 0, 255],
+    fontSettings: { sdf: !0 }
+  });
+  return [new le({
+    id: o,
+    data: [f],
+    getPath: (g) => g,
+    getColor: [255, 0, 0, 255],
+    // Red
+    getWidth: 2,
+    widthUnits: "pixels",
+    pickable: !1
+  }), p];
+}
+const xe = [
+  [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
+], be = 0.125;
+class Te {
+  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(e, t, n = t) {
+    this.reprojectors = e, this.width = t, this.height = n, this.uvs = [], this.exactOutputPositions = [], this.triangles = [], this._halfedges = [], this._candidatesUV = [], this._queueIndices = [], this._queue = [], this._errors = [], this._pending = [], this._pendingLen = 0;
+    const s = 1, r = 1, a = this._addPoint(0, 0), i = this._addPoint(s, 0), c = this._addPoint(0, r), u = this._addPoint(s, r), l = this._addTriangle(u, a, c, -1, -1, -1);
+    this._addTriangle(a, u, i, l, -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(e = be, { maxIterations: t = 1e4 } = {}) {
+    if (e <= 0)
+      throw new Error("maxError must be positive");
+    let n = 0;
+    for (; this.getMaxError() > e; )
+      if (this.refine(), ++n > t) {
+        console.warn(`RasterReprojector: mesh refinement did not converge after ${n} iterations (maxError=${e}, 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 e = 0; e < this._pendingLen; e++) {
+      const t = this._pending[e];
+      this._findReprojectionCandidate(t);
+    }
+    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(e) {
+    const t = 2 * this.triangles[e * 3 + 0], n = 2 * this.triangles[e * 3 + 1], s = 2 * this.triangles[e * 3 + 2], r = this.uvs[t], a = this.uvs[t + 1], i = this.uvs[n], c = this.uvs[n + 1], u = this.uvs[s], l = this.uvs[s + 1], d = this.exactOutputPositions[t], f = this.exactOutputPositions[t + 1], h = this.exactOutputPositions[n], p = this.exactOutputPositions[n + 1], m = this.exactOutputPositions[s], g = this.exactOutputPositions[s + 1];
+    let b = 0, P = 0, x = 0;
+    for (const v of xe) {
+      const T = A(r, i, u, v[0], v[1], v[2]), L = A(a, c, l, v[0], v[1], v[2]), j = A(d, h, m, v[0], v[1], v[2]), w = A(f, p, g, v[0], v[1], v[2]), O = T * (this.width - 1), z = L * (this.height - 1), H = this.reprojectors.inverseReproject(j, w), F = this.reprojectors.inverseTransform(H[0], H[1]), oe = O - F[0], ie = z - F[1], W = Math.hypot(oe, ie);
+      W > b && (b = W, P = T, x = L);
+    }
+    (P === r && x === a || P === i && x === c || P === u && x === l) && (b = 0), this._candidatesUV[2 * e] = P, this._candidatesUV[2 * e + 1] = x, this._queuePush(e, b);
+  }
+  // process the next triangle in the queue, splitting it with a new point
+  _step() {
+    const e = this._queuePop(), t = e * 3 + 0, n = e * 3 + 1, s = e * 3 + 2, r = this.triangles[t], a = this.triangles[n], i = this.triangles[s], c = this.uvs[2 * r], u = this.uvs[2 * r + 1], l = this.uvs[2 * a], d = this.uvs[2 * a + 1], f = this.uvs[2 * i], h = this.uvs[2 * i + 1], p = this._candidatesUV[2 * e], m = this._candidatesUV[2 * e + 1], g = this._addPoint(p, m);
+    if (D(c, u, l, d, p, m) === 0)
+      this._handleCollinear(g, t);
+    else if (D(l, d, f, h, p, m) === 0)
+      this._handleCollinear(g, n);
+    else if (D(f, h, c, u, p, m) === 0)
+      this._handleCollinear(g, s);
+    else {
+      const b = this._halfedges[t], P = this._halfedges[n], x = this._halfedges[s], v = this._addTriangle(r, a, g, b, -1, -1, t), T = this._addTriangle(a, i, g, P, -1, v + 1), L = this._addTriangle(i, r, g, x, v + 2, T + 1);
+      this._legalize(v), this._legalize(T), this._legalize(L);
+    }
+  }
+  // add coordinates for a new vertex
+  _addPoint(e, t) {
+    const n = this.uvs.length >> 1;
+    this.uvs.push(e, t);
+    const s = e * (this.width - 1), r = t * (this.height - 1), a = this.reprojectors.forwardTransform(s, r), i = this.reprojectors.forwardReproject(a[0], a[1]);
+    return this.exactOutputPositions.push(i[0], i[1]), n;
+  }
+  // add or update a triangle in the mesh
+  _addTriangle(e, t, n, s, r, a, i = this.triangles.length) {
+    const c = i / 3;
+    return this.triangles[i + 0] = e, this.triangles[i + 1] = t, this.triangles[i + 2] = n, this._halfedges[i + 0] = s, this._halfedges[i + 1] = r, this._halfedges[i + 2] = a, s >= 0 && (this._halfedges[s] = i + 0), r >= 0 && (this._halfedges[r] = i + 1), a >= 0 && (this._halfedges[a] = i + 2), this._candidatesUV[2 * c + 0] = 0, this._candidatesUV[2 * c + 1] = 0, this._queueIndices[c] = -1, this._pending[this._pendingLen++] = c, i;
+  }
+  _legalize(e) {
+    const t = this._halfedges[e];
+    if (t < 0)
+      return;
+    const n = e - e % 3, s = t - t % 3, r = n + (e + 1) % 3, a = n + (e + 2) % 3, i = s + (t + 2) % 3, c = s + (t + 1) % 3, u = this.triangles[a], l = this.triangles[e], d = this.triangles[r], f = this.triangles[i], h = this.uvs;
+    if (!ye(h[2 * u], h[2 * u + 1], h[2 * l], h[2 * l + 1], h[2 * d], h[2 * d + 1], h[2 * f], h[2 * f + 1]))
+      return;
+    const p = this._halfedges[r], m = this._halfedges[a], g = this._halfedges[i], b = this._halfedges[c];
+    this._queueRemove(n / 3), this._queueRemove(s / 3);
+    const P = this._addTriangle(u, f, d, -1, g, p, n), x = this._addTriangle(f, u, l, P, m, b, s);
+    this._legalize(P + 1), this._legalize(x + 2);
+  }
+  // handle a case where new vertex is on the edge of a triangle
+  _handleCollinear(e, t) {
+    const n = t - t % 3, s = n + (t + 1) % 3, r = n + (t + 2) % 3, a = this.triangles[r], i = this.triangles[t], c = this.triangles[s], u = this._halfedges[s], l = this._halfedges[r], d = this._halfedges[t];
+    if (d < 0) {
+      const L = this._addTriangle(e, a, i, -1, l, -1, n), j = this._addTriangle(a, e, c, L, -1, u);
+      this._legalize(L + 1), this._legalize(j + 2);
+      return;
+    }
+    const f = d - d % 3, h = f + (d + 2) % 3, p = f + (d + 1) % 3, m = this.triangles[h], g = this._halfedges[h], b = this._halfedges[p];
+    this._queueRemove(f / 3);
+    const P = this._addTriangle(a, i, e, l, -1, -1, n), x = this._addTriangle(i, m, e, b, -1, P + 1, f), v = this._addTriangle(m, c, e, g, -1, x + 1), T = this._addTriangle(c, a, e, u, P + 2, v + 1);
+    this._legalize(P), this._legalize(x), this._legalize(v), this._legalize(T);
+  }
+  // priority queue methods
+  _queuePush(e, t) {
+    const n = this._queue.length;
+    this._queueIndices[e] = n, this._queue.push(e), this._errors.push(t), this._queueUp(n);
+  }
+  _queuePop() {
+    const e = this._queue.length - 1;
+    return this._queueSwap(0, e), this._queueDown(0, e), this._queuePopBack();
+  }
+  _queuePopBack() {
+    const e = this._queue.pop();
+    return this._errors.pop(), this._queueIndices[e] = -1, e;
+  }
+  _queueRemove(e) {
+    const t = this._queueIndices[e];
+    if (t < 0) {
+      const s = this._pending.indexOf(e);
+      if (s !== -1)
+        this._pending[s] = this._pending[--this._pendingLen];
+      else
+        throw new Error("Broken triangulation (something went wrong).");
+      return;
+    }
+    const n = this._queue.length - 1;
+    n !== t && (this._queueSwap(t, n), this._queueDown(t, n) || this._queueUp(t)), this._queuePopBack();
+  }
+  _queueLess(e, t) {
+    return this._errors[e] > this._errors[t];
+  }
+  _queueSwap(e, t) {
+    const n = this._queue[e], s = this._queue[t];
+    this._queue[e] = s, this._queue[t] = n, this._queueIndices[n] = t, this._queueIndices[s] = e;
+    const r = this._errors[e];
+    this._errors[e] = this._errors[t], this._errors[t] = r;
+  }
+  _queueUp(e) {
+    let t = e;
+    for (; ; ) {
+      const n = t - 1 >> 1;
+      if (n === t || !this._queueLess(t, n))
+        break;
+      this._queueSwap(n, t), t = n;
+    }
+  }
+  _queueDown(e, t) {
+    let n = e;
+    for (; ; ) {
+      const s = 2 * n + 1;
+      if (s >= t || s < 0)
+        break;
+      const r = s + 1;
+      let a = s;
+      if (r < t && this._queueLess(r, s) && (a = r), !this._queueLess(a, n))
+        break;
+      this._queueSwap(n, a), n = a;
+    }
+    return n > e;
+  }
+}
+function D(o, e, t, n, s, r) {
+  return (t - s) * (e - r) - (n - r) * (o - s);
+}
+function ye(o, e, t, n, s, r, a, i) {
+  const c = o - a, u = e - i, l = t - a, d = n - i, f = s - a, h = r - i, p = c * c + u * u, m = l * l + d * d, g = f * f + h * h;
+  return c * (d * g - m * h) - u * (l * g - m * f) + p * (l * h - d * f) < 0;
+}
+function A(o, e, t, n, s, r) {
+  return n * o + s * e + r * t;
+}
+const se = {
+  name: "create-texture-unorm",
+  inject: {
+    "fs:#decl": "uniform sampler2D textureName;",
+    "fs:DECKGL_FILTER_COLOR": (
+      /* glsl */
+      `
+      color = texture(textureName, geometry.uv);
+    `
+    )
+  },
+  getUniforms: (o) => ({
+    textureName: o.textureName
+  })
+}, Le = (
+  /* 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);
+}
+`
+), Oe = {
+  ...ee.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 je extends ee {
+  static layerName = "mesh-texture-layer";
+  static defaultProps = Oe;
+  _resolveRenderPipeline() {
+    const { image: e, renderPipeline: t } = this.props;
+    return [...e ? [{ module: se, props: { textureName: e } }] : [], ...t ?? []];
+  }
+  updateState(e) {
+    this.hasRenderPipelineChanged(e) && (e.changeFlags.extensionsChanged = !0), super.updateState(e);
+  }
+  /** Returns true if the render pipeline has changed between the old and new props. */
+  hasRenderPipelineChanged(e) {
+    const { oldProps: t, props: n } = e;
+    if (!!t.image != !!n.image)
+      return !0;
+    const s = t.renderPipeline ?? [], r = n.renderPipeline ?? [];
+    if (s.length !== r.length)
+      return !0;
+    for (let a = 0; a < s.length; a++)
+      if (s[a]?.module.name !== r[a]?.module.name)
+        return !0;
+    return !1;
+  }
+  getShaders() {
+    const e = super.getShaders(), t = e.modules;
+    for (const n of this._resolveRenderPipeline())
+      t.push(n.module);
+    return {
+      ...e,
+      // Override upstream's fragment shader with our copy with modified
+      // injection points
+      fs: Le,
+      modules: t
+    };
+  }
+  draw(e) {
+    const t = {};
+    for (const n of this._resolveRenderPipeline())
+      t[n.module.name] = n.props || {};
+    for (const n of super.getModels())
+      n.shaderInputs.setProps(t);
+    super.draw(e);
+  }
+}
+const we = 0.125, U = [
+  [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
+], Me = {
+  // 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 Ce extends te {
+  static layerName = "RasterLayer";
+  static defaultProps = Me;
+  initializeState() {
+    this.setState({});
+  }
+  updateState(e) {
+    super.updateState(e);
+    const { props: t, oldProps: n, changeFlags: s } = e, r = t.reprojectionFns.forwardTransform !== n.reprojectionFns?.forwardTransform || t.reprojectionFns.inverseTransform !== n.reprojectionFns?.inverseTransform || t.reprojectionFns.forwardReproject !== n.reprojectionFns?.forwardReproject || t.reprojectionFns.inverseReproject !== n.reprojectionFns?.inverseReproject;
+    (!!s.dataChanged || t.width !== n.width || t.height !== n.height || r || t.maxError !== n.maxError) && this._generateMesh();
+  }
+  _generateMesh() {
+    const { width: e, height: t, reprojectionFns: n, maxError: s = we } = this.props, r = new Te(n, e + 1, t + 1);
+    r.run(s);
+    const { indices: a, positions: i, texCoords: c } = Ae(r);
+    this.setState({
+      reprojector: r,
+      mesh: {
+        indices: { value: a, size: 1 },
+        attributes: {
+          POSITION: { value: i, size: 3 },
+          TEXCOORD_0: { value: c, size: 2 }
+        }
+      }
+    });
+  }
+  renderDebugLayer() {
+    const { reprojector: e } = this.state, { debugOpacity: t } = this.props;
+    return e ? new ue(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: e, length: e.triangles.length / 3 },
+      getPolygon: (n, { index: s, data: r }) => {
+        const a = r.reprojector.triangles, i = e.exactOutputPositions, c = a[s * 3], u = a[s * 3 + 1], l = a[s * 3 + 2];
+        return [
+          [i[c * 2], i[c * 2 + 1]],
+          [i[u * 2], i[u * 2 + 1]],
+          [i[l * 2], i[l * 2 + 1]],
+          [i[c * 2], i[c * 2 + 1]]
+        ];
+      },
+      getFillColor: (n, { index: s, target: r }) => {
+        const a = U[s % U.length];
+        return r[0] = a[0], r[1] = a[1], r[2] = a[2], r[3] = 255, r;
+      },
+      getLineColor: [0, 0, 0],
+      getLineWidth: 1,
+      lineWidthUnits: "pixels",
+      opacity: t !== void 0 && Number.isFinite(t) ? Math.max(0, Math.min(1, t)) : 1,
+      pickable: !1
+    })) : null;
+  }
+  renderLayers() {
+    const { mesh: e } = this.state, { debug: t, image: n, renderPipeline: s } = this.props;
+    if (!e || !n && (s?.length ?? 0) === 0)
+      return null;
+    const a = [new je(this.getSubLayerProps({
+      id: "raster",
+      image: n,
+      renderPipeline: s,
+      // 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: e,
+      // 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 (t) {
+      const i = this.renderDebugLayer();
+      i && a.push(i);
+    }
+    return a;
+  }
+}
+function Ae(o) {
+  const e = o.uvs.length / 2, t = new Float32Array(e * 3), n = new Float32Array(o.uvs);
+  for (let r = 0; r < e; r++)
+    t[r * 3] = o.exactOutputPositions[r * 2], t[r * 3 + 1] = o.exactOutputPositions[r * 2 + 1], t[r * 3 + 2] = 0;
+  return {
+    indices: new Uint32Array(o.triangles),
+    positions: t,
+    texCoords: n
+  };
+}
+class ft {
+  levels;
+  projectTo3857;
+  projectFrom3857;
+  projectTo4326;
+  projectFrom4326;
+  projectedBounds;
+  constructor(e) {
+    if (e.levels.length === 0)
+      throw new Error("AffineTileset requires at least one level");
+    this.levels = e.levels, this.projectTo3857 = e.projectTo3857, this.projectFrom3857 = e.projectFrom3857, this.projectTo4326 = e.projectTo4326, this.projectFrom4326 = e.projectFrom4326, this.projectedBounds = e.levels[0].projectedBounds;
+  }
+}
+function Re(o, e) {
+  return [1, 0, o, 0, 1, e];
+}
+function pt(o, e = o) {
+  return [o, 0, 0, 0, e, 0];
+}
+function y([o, e, t, n, s, r], a, i) {
+  return [
+    o * a + e * i + t,
+    n * a + s * i + r
+  ];
+}
+function ze([o, e, t, n, s, r], [a, i, c, u, l, d]) {
+  return [
+    o * a + e * u,
+    o * i + e * l,
+    o * c + e * d + t,
+    n * a + s * u,
+    n * i + s * l,
+    n * c + s * d + r
+  ];
+}
+function q([o, e, t, n, s, r]) {
+  const a = o * s - e * n;
+  if (a === 0)
+    throw new Error("Cannot invert degenerate transform");
+  const i = 1 / a, c = s * i, u = -e * i, l = -n * i, d = o * i;
+  return [
+    c,
+    u,
+    -t * c - r * u,
+    l,
+    d,
+    -t * l - r * d
+  ];
+}
+function De(o) {
+  return o[0];
+}
+function Xe(o) {
+  return o[4];
+}
+class mt {
+  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(e) {
+    this._affine = e.affine, this._invAffine = q(e.affine), this.tileWidth = e.tileWidth, this.tileHeight = e.tileHeight, this.matrixWidth = Math.ceil(e.arrayWidth / e.tileWidth), this.matrixHeight = Math.ceil(e.arrayHeight / e.tileHeight);
+    const t = De(e.affine), n = Xe(e.affine);
+    this.metersPerPixel = Math.sqrt(Math.abs(t * n)) * e.mpu;
+    const s = [
+      y(e.affine, 0, 0),
+      y(e.affine, e.arrayWidth, 0),
+      y(e.affine, 0, e.arrayHeight),
+      y(e.affine, e.arrayWidth, e.arrayHeight)
+    ], r = s.map(([i]) => i), a = s.map(([, i]) => i);
+    this.projectedBounds = [
+      Math.min(...r),
+      Math.min(...a),
+      Math.max(...r),
+      Math.max(...a)
+    ];
+  }
+  projectedTileCorners(e, t) {
+    const n = this.tileWidth, s = this.tileHeight, r = this._affine;
+    return {
+      topLeft: y(r, e * n, t * s),
+      topRight: y(r, (e + 1) * n, t * s),
+      bottomLeft: y(r, e * n, (t + 1) * s),
+      bottomRight: y(r, (e + 1) * n, (t + 1) * s)
+    };
+  }
+  tileTransform(e, t) {
+    const n = Re(e * this.tileWidth, t * this.tileHeight), s = ze(this._affine, n), r = q(s);
+    return {
+      forwardTransform: (a, i) => y(s, a, i),
+      inverseTransform: (a, i) => y(r, a, i)
+    };
+  }
+  crsBoundsToTileRange(e, t, n, s) {
+    const r = this._invAffine, a = [
+      y(r, e, t),
+      y(r, n, t),
+      y(r, e, s),
+      y(r, n, s)
+    ], i = a.map(([T]) => T), c = a.map(([, T]) => T), u = Math.min(...i), l = Math.max(...i), d = Math.min(...c), f = Math.max(...c), h = this.tileWidth, p = this.tileHeight, m = this.matrixWidth - 1, g = this.matrixHeight - 1, b = Math.max(0, Math.floor(u / h)), P = Math.min(m, Math.floor(l / h)), x = Math.max(0, Math.floor(d / p)), v = Math.min(g, Math.floor(f / p));
+    return { minCol: b, maxCol: P, minRow: x, maxRow: v };
+  }
+}
+function gt(o, { semiMajorAxis: e } = {}) {
+  switch (o = o.toLowerCase(), o) {
+    case "m":
+    case "metre":
+    case "meter":
+    case "meters":
+      return 1;
+    case "foot":
+      return 0.3048;
+    case "us survey foot":
+      return 1200 / 3937;
+  }
+  if (o === "degree") {
+    if (e === void 0)
+      throw new Error("CRS with degrees unit requires ellipsoid semi-major-axis");
+    return 2 * Math.PI * e / 360;
+  }
+  throw new Error(`Unsupported CRS units: ${o} when computing metersPerUnit.`);
+}
+function Ie(o) {
+  const e = ae(o);
+  return e.projName === "longlat" && (!e.units || e.units === "unknown") && (e.units = "degree", e.to_meter = void 0), e;
+}
+const k = /* @__PURE__ */ new Map();
+async function vt(o) {
+  const e = `EPSG:${o}`, t = k.get(e);
+  if (t !== void 0)
+    return t;
+  const n = await Be(o), s = Ie(n);
+  return k.set(e, s), s;
+}
+async function Be(o) {
+  const e = `https://epsg.io/${o}.json`, t = await fetch(e);
+  if (!t.ok)
+    throw new Error(`Failed to fetch PROJJSON from ${e}`);
+  return await t.json();
+}
+function I(o, e, t, n, s, r = {}) {
+  const { densifyPts: a = 21 } = r, i = [e, n, n, e], c = [t, t, s, s];
+  let u = 1 / 0, l = 1 / 0, d = -1 / 0, f = -1 / 0;
+  for (let h = 0; h < 4; h++) {
+    const p = i[h], m = c[h], g = i[(h + 1) % 4], b = c[(h + 1) % 4];
+    for (let P = 0; P <= a; P++) {
+      const x = P / (a + 1), [v, T] = o(p + (g - p) * x, m + (b - m) * x);
+      v < u && (u = v), T < l && (l = T), v > d && (d = v), T > f && (f = T);
+    }
+  }
+  return [u, l, d, f];
+}
+const V = 6378137, Y = 85.05112877980659;
+function Ee(o, e) {
+  const t = o * Math.PI * V / 180, n = e * Math.PI / 180, s = Math.log(Math.tan(Math.PI / 4 + n / 2)) * V;
+  return [t, s];
+}
+function Pt(o, e) {
+  return (t, n) => {
+    const [s, r] = o(t, n);
+    if (Number.isFinite(s) && Number.isFinite(r))
+      return [s, r];
+    const [a, i] = e(t, n), c = Math.max(-Y, Math.min(Y, i));
+    return Ee(a, c);
+  };
+}
+const Se = 65536;
+class re {
+  entries = /* @__PURE__ */ new Map();
+  maxEntries;
+  constructor({ maxEntries: e = Se } = {}) {
+    this.maxEntries = Math.max(0, e);
+  }
+  /** 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(e, t, n) {
+    const s = `${e}/${t}/${n}`, r = this.entries.get(s);
+    if (r !== void 0)
+      return this.entries.delete(s), this.entries.set(s, r), r;
+  }
+  /** Store the bounding volume for tile `(z, x, y)` as most-recently-used. */
+  set(e, t, n, s) {
+    const r = `${e}/${t}/${n}`;
+    this.entries.delete(r), this.entries.set(r, s);
+  }
+  /**
+   * 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 e = Math.floor(this.maxEntries / 2), t = this.entries.size - e, n = [];
+    for (const s of this.entries.keys())
+      if (n.push(s), n.length >= t)
+        break;
+    for (const s of n)
+      this.entries.delete(s);
+  }
+}
+const G = 512, Ne = [
+  [0.5, 0.5],
+  // center
+  [0, 0],
+  // top-left
+  [0, 1],
+  // bottom-left
+  [1, 0],
+  // top-right
+  [1, 1]
+  // bottom-right
+], He = Ne.concat([
+  [0, 0.5],
+  // left edge
+  [0.5, 0],
+  // top edge
+  [1, 0.5],
+  // right edge
+  [0.5, 1]
+  // bottom edge
+]), B = 6378137, E = 2 * Math.PI * B, J = E / 2, K = 85.05112877980659;
+class R {
+  /** 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(e, t, n, { descriptor: s }) {
+    this.x = e, this.y = t, this.z = n, this.descriptor = s;
+  }
+  /** 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 e = this.descriptor.levels.length - 1;
+      if (this.z >= e)
+        return this._children = null, null;
+      const t = this.z + 1, n = this.descriptor.levels[t], s = this.level.projectedTileCorners(this.x, this.y), r = Ge(s), { minCol: a, maxCol: i, minRow: c, maxRow: u } = n.crsBoundsToTileRange(...r), l = [], { descriptor: d } = this;
+      for (let f = c; f <= u; f++)
+        for (let h = a; h <= i; h++)
+          l.push(new R(h, f, t, { descriptor: d }));
+      this._children = l.length > 0 ? l : 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(e) {
+    this.childVisible = !1, this.selected = !1;
+    const { viewport: t, cullingVolume: n, elevationBounds: s, minZ: r, maxZ: a = this.descriptor.levels.length - 1, project: i, bounds: c, pixelRatio: u, boundingVolumeCache: l } = e, { boundingVolume: d, commonSpaceBounds: f } = this.getBoundingVolume(s, i, l);
+    if (c && !this.insideBounds(c, f) || n.computeVisibility(d) < 0)
+      return !1;
+    const p = this.children;
+    if (!this.childVisible && this.z >= r) {
+      const m = Ye(d, t.zoom);
+      if (this.level.metersPerPixel * u / m <= 1 || this.z >= a || p === null && this.z >= r)
+        return this.selected = !0, !0;
+    }
+    if (p && p.length > 0) {
+      this.selected = !1;
+      let m = !1;
+      for (const g of p)
+        g.update(e) && (m = !0);
+      return this.childVisible = m, m;
+    }
+    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(e = []) {
+    if (this.selected && e.push(this), this._children)
+      for (const t of this._children)
+        t.getSelected(e);
+    return e;
+  }
+  /**
+   * 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(e, t) {
+    const [n, s, r, a] = e, [i, c, u, l] = t;
+    return i < r && u > n && c < a && l > s;
+  }
+  /**
+   * 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(e, t, n) {
+    const s = n.get(this.z, this.x, this.y);
+    if (s && s.zRange[0] === e[0] && s.zRange[1] === e[1])
+      return s;
+    const r = this.computeBoundingVolume(e, t);
+    return n.set(this.z, this.x, this.y, { zRange: e, ...r }), r;
+  }
+  /**
+   * 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(e, t) {
+    return t && pe(!1, "TODO: implement getBoundingVolume in Globe view"), this._getGenericBoundingVolume(e);
+  }
+  /**
+   * Generic case - sample reference points and reproject to Web Mercator, then
+   * convert to deck.gl common space
+   *
+   */
+  _getGenericBoundingVolume(e) {
+    const [t, n] = e, s = this.level.projectedTileCorners(this.x, this.y), a = We(He, s, this.descriptor.projectTo3857, this.descriptor.projectTo4326).map((h) => Ze(h)), i = [];
+    for (const h of a)
+      i.push([h[0], h[1], t]), t !== n && i.push([h[0], h[1], n]);
+    let c = Number.POSITIVE_INFINITY, u = Number.POSITIVE_INFINITY, l = Number.NEGATIVE_INFINITY, d = Number.NEGATIVE_INFINITY;
+    for (const [h, p] of a)
+      h < c && (c = h), p < u && (u = p), h > l && (l = h), p > d && (d = p);
+    const f = [c, u, l, d];
+    return {
+      boundingVolume: me(i),
+      commonSpaceBounds: f
+    };
+  }
+}
+function Fe(o, e) {
+  return (t, n) => {
+    const [s, r] = o(t, n);
+    if (Number.isFinite(s) && Number.isFinite(r))
+      return [s, r];
+    const [a, i] = e(t, n), u = Math.max(-K, Math.min(K, i)) * Math.PI / 180, l = a * Math.PI * B / 180, d = Math.log(Math.tan(Math.PI / 4 + u / 2)) * B;
+    return [l, d];
+  };
+}
+function We(o, e, t, n) {
+  const { topLeft: s, topRight: r, bottomLeft: a, bottomRight: i } = e, c = Fe(t, n), u = [];
+  for (const [l, d] of o) {
+    const [f, h] = Je(s, r, a, i, l, d);
+    u.push(c(f, h));
+  }
+  return u;
+}
+function Ze([o, e]) {
+  const t = Math.max(-J, Math.min(J, e));
+  return [
+    (o / E + 0.5) * G,
+    (t / E + 0.5) * G
+  ];
+}
+const Ue = 100;
+function qe(o) {
+  const { descriptor: e, viewport: t, datasetWgs84Bounds: n } = o, s = e.levels[0], r = [];
+  if (s.matrixWidth * s.matrixHeight <= Ue) {
+    for (let p = 0; p < s.matrixHeight; p++)
+      for (let m = 0; m < s.matrixWidth; m++)
+        r.push(new R(m, p, 0, { descriptor: e }));
+    return r;
+  }
+  const i = t.getBounds(), c = [
+    Math.max(n[0], i[0]),
+    Math.max(n[1], i[1]),
+    Math.min(n[2], i[2]),
+    Math.min(n[3], i[3])
+  ];
+  if (c[0] > c[2] || c[1] > c[3])
+    return r;
+  const [u, l, d, f] = I(e.projectFrom4326, c[0], c[1], c[2], c[3]), h = s.crsBoundsToTileRange(u, l, d, f);
+  for (let p = h.minRow; p <= h.maxRow; p++)
+    for (let m = h.minCol; m <= h.maxCol; m++)
+      r.push(new R(m, p, 0, { descriptor: e }));
+  return r;
+}
+function ke(o, e) {
+  const { viewport: t, maxZ: n, zRange: s, wgs84Bounds: r, pixelRatio: a = 1 } = e, i = e.boundingVolumeCache ?? new re();
+  i.sweep();
+  const c = t instanceof he && t.resolution ? t.projectPosition : null, u = Object.values(t.getFrustumPlanes()).map(({ normal: O, distance: z }) => new de(O.clone().negate(), z)), l = new fe(u), d = t.distanceScales.unitsPerMeter[2], f = s && s[0] * d || 0, h = s && s[1] * d || 0, p = 0, [m, g, b, P] = r, x = Z([m, g]), v = Z([b, P]), T = [
+    x[0],
+    x[1],
+    v[0],
+    v[1]
+  ], L = qe({
+    descriptor: o,
+    viewport: t,
+    datasetWgs84Bounds: r
+  }), j = {
+    viewport: t,
+    project: c,
+    cullingVolume: l,
+    elevationBounds: [f, h],
+    minZ: p,
+    maxZ: n,
+    bounds: T,
+    pixelRatio: a,
+    boundingVolumeCache: i
+  };
+  for (const O of L)
+    O.update(j);
+  const w = [];
+  for (const O of L)
+    O.getSelected(w);
+  return w;
+}
+function Ve(o, e) {
+  return 40075016686e-3 * Math.cos(o * Math.PI / 180) / 2 ** (e + 8);
+}
+function Ye(o, e) {
+  const [t, n] = ge(o.center);
+  return Ve(n, e);
+}
+function Ge({ topLeft: o, topRight: e, bottomLeft: t, bottomRight: n }) {
+  const s = [o[0], e[0], t[0], n[0]], r = [o[1], e[1], t[1], n[1]];
+  return [Math.min(...s), Math.min(...r), Math.max(...s), Math.max(...r)];
+}
+function Je(o, e, t, n, s, r) {
+  const a = (1 - s) * (1 - r), i = s * (1 - r), c = (1 - s) * r, u = s * r;
+  return [
+    o[0] * a + e[0] * i + t[0] * c + n[0] * u,
+    o[1] * a + e[1] * i + t[1] * c + n[1] * u
+  ];
+}
+function Ke(o, e) {
+  const t = o.length;
+  if (t < 2)
+    return o;
+  const { getCenter: n, reference: s } = e, r = s[0], a = s[1], i = new Float64Array(t);
+  for (let l = 0; l < t; l++) {
+    const d = n(o[l]), f = d[0] - r, h = d[1] - a;
+    i[l] = f * f + h * h;
+  }
+  const c = new Uint32Array(t);
+  for (let l = 0; l < t; l++)
+    c[l] = l;
+  c.sort((l, d) => i[l] - i[d]);
+  const u = o.slice();
+  for (let l = 0; l < t; l++)
+    o[l] = u[c[l]];
+  return o;
+}
+function Qe(o, e, t) {
+  const [n, s, r, a] = e.getBounds(), i = [
+    (n + r) / 2,
+    (s + a) / 2
+  ];
+  return Ke(o, {
+    reference: i,
+    getCenter: t
+  });
+}
+class _e extends ve {
+  descriptor;
+  wgs84Bounds;
+  getPixelRatio;
+  boundingVolumeCache;
+  constructor(e, t, { getPixelRatio: n, maxBoundingVolumeCacheSize: s } = {}) {
+    super(e), this.descriptor = t, this.getPixelRatio = n ?? (() => 1), this.boundingVolumeCache = new re({
+      maxEntries: s
+    });
+    const r = I(this.descriptor.projectTo4326, ...this.descriptor.projectedBounds), a = 85.0511287798066;
+    this.wgs84Bounds = [
+      r[0],
+      Math.max(r[1], -a),
+      r[2],
+      Math.min(r[3], a)
+    ];
+  }
+  /**
+   * 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(e) {
+    const { viewport: t, minZoom: n } = e;
+    if (typeof n == "number" && t.zoom < n)
+      return [];
+    const s = this.descriptor.levels.length - 1, r = typeof e.maxZoom == "number" ? Math.min(e.maxZoom, s) : s, a = ke(this.descriptor, {
+      viewport: t,
+      maxZ: r,
+      zRange: e.zRange ?? null,
+      wgs84Bounds: this.wgs84Bounds,
+      pixelRatio: this.getPixelRatio(),
+      boundingVolumeCache: this.boundingVolumeCache
+    });
+    return this.sortTileIndicesByDistance(a, t);
+  }
+  /**
+   * 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(e, t) {
+    const { maxRequests: n } = this.opts;
+    if (e.length <= n)
+      return e;
+    const s = this.descriptor;
+    return Qe(e, t, (r) => {
+      const { x: a, y: i, z: c } = r, { topLeft: u, bottomRight: l } = s.levels[c].projectedTileCorners(a, i), d = [
+        (u[0] + l[0]) / 2,
+        (u[1] + l[1]) / 2
+      ];
+      return s.projectTo4326(d[0], d[1]);
+    });
+  }
+  getTileId(e) {
+    return `${e.x}-${e.y}-${e.z}`;
+  }
+  getParentIndex(e) {
+    if (e.z === 0)
+      return e;
+    const t = this.descriptor.levels[e.z], n = this.descriptor.levels[e.z - 1], s = n.metersPerPixel * n.tileWidth, r = n.metersPerPixel * n.tileHeight, a = t.metersPerPixel * t.tileWidth, i = t.metersPerPixel * t.tileHeight, c = s / a, u = r / i;
+    return {
+      x: Math.floor(e.x / c),
+      y: Math.floor(e.y / u),
+      z: e.z - 1
+    };
+  }
+  getTileZoom(e) {
+    return e.z;
+  }
+  getTileMetadata(e) {
+    const { x: t, y: n, z: s } = e, r = this.descriptor.levels[s], { tileHeight: a, tileWidth: i } = r, { topLeft: c, topRight: u, bottomLeft: l, bottomRight: d } = r.projectedTileCorners(t, n), f = {
+      topLeft: c,
+      topRight: u,
+      bottomLeft: l,
+      bottomRight: d
+    }, h = [
+      Math.min(c[0], u[0], l[0], d[0]),
+      Math.min(c[1], u[1], l[1], d[1]),
+      Math.max(c[0], u[0], l[0], d[0]),
+      Math.max(c[1], u[1], l[1], d[1])
+    ], [p, m, g, b] = I(this.descriptor.projectTo4326, ...h), { forwardTransform: P, inverseTransform: x } = r.tileTransform(t, n);
+    return {
+      bbox: {
+        west: p,
+        south: m,
+        east: g,
+        north: b
+      },
+      projectedBbox: {
+        left: h[0],
+        bottom: h[1],
+        right: h[2],
+        top: h[3]
+      },
+      projectedCorners: f,
+      tileWidth: i,
+      tileHeight: a,
+      forwardTransform: P,
+      inverseTransform: x
+    };
+  }
+}
+const S = 512, $e = 40075016686e-3, Q = S / $e, et = {
+  ...ne.defaultProps,
+  maxError: 0.125,
+  debug: !1,
+  debugOpacity: 0.5
+};
+class xt extends te {
+  static layerName = "RasterTileLayer";
+  static defaultProps = et;
+  /**
+   * 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(e, t) {
+    const n = this._tilesetDescriptor();
+    return n ? Pe(`${this.id}-${e.id}-bounds`, e, n.projectTo4326) : [];
+  }
+  renderLayers() {
+    const e = this._tilesetDescriptor(), t = this._getTileDataCallback(), n = this._renderTileCallback();
+    return !e || !t || !n ? null : this._renderTileLayer(e, t, n);
+  }
+  _renderTileLayer(e, t, n) {
+    const s = this.context.device;
+    class r extends _e {
+      constructor(L) {
+        super(L, e, {
+          getPixelRatio: () => {
+            const j = s.getDefaultCanvasContext(), [w] = j.getDrawingBufferSize(), [O] = j.getCSSSize();
+            return O ? w / O : 1;
+          }
+        });
+      }
+    }
+    const { tileSize: a, zoomOffset: i, maxZoom: c, minZoom: u, extent: l, debounceTime: d, maxCacheSize: f, maxCacheByteSize: h, maxRequests: p, refinementStrategy: m, updateTriggers: g, onTileError: b, onTileLoad: P, onTileUnload: x, onViewportLoad: v } = this.props;
+    return new ne({
+      id: `raster-tile-layer-${this.id}`,
+      TilesetClass: r,
+      getTileData: (T) => this._wrapGetTileData(T, t),
+      renderSubLayers: (T) => this._renderSubLayers(T, e, n),
+      updateTriggers: {
+        renderSubLayers: g?.renderTile
+      },
+      tileSize: a,
+      zoomOffset: i,
+      maxZoom: c,
+      minZoom: u,
+      extent: l,
+      debounceTime: d,
+      maxCacheSize: f,
+      maxCacheByteSize: h,
+      maxRequests: p,
+      refinementStrategy: m,
+      onTileError: b,
+      onTileLoad: P,
+      onTileUnload: x,
+      onViewportLoad: v
+    });
+  }
+  async _wrapGetTileData(e, t) {
+    const { signal: n } = e, s = this.props.signal, r = s && n ? AbortSignal.any([s, n]) : s ?? n, a = {
+      device: this.context.device,
+      signal: r
+    };
+    return t(e, a);
+  }
+  _renderSubLayers(e, t, n) {
+    const { maxError: s, debug: r, debugOpacity: a } = this.props, i = e.tile, c = r ? this._renderDebug(i, e.data ?? null) : [];
+    if (!e.data)
+      return c;
+    const { forwardTransform: u, inverseTransform: l } = i, d = n(e.data);
+    if (!d)
+      return c;
+    const { image: f, renderPipeline: h } = d, { width: p, height: m } = e.data, g = this.context.viewport.resolution !== void 0, b = g ? {
+      forwardTransform: u,
+      inverseTransform: l,
+      forwardReproject: t.projectTo4326,
+      inverseReproject: t.projectFrom4326
+    } : {
+      forwardTransform: u,
+      inverseTransform: l,
+      forwardReproject: t.projectTo3857,
+      inverseReproject: t.projectFrom3857
+    }, P = g ? {} : {
+      coordinateSystem: "cartesian",
+      coordinateOrigin: [S / 2, S / 2, 0],
+      // biome-ignore format: array
+      modelMatrix: [
+        Q,
+        0,
+        0,
+        0,
+        0,
+        Q,
+        0,
+        0,
+        0,
+        0,
+        1,
+        0,
+        0,
+        0,
+        0,
+        1
+      ]
+    };
+    return [new Ce(this.getSubLayerProps({
+      id: `${e.id}-raster`,
+      width: p,
+      height: m,
+      // Passing `image: undefined` explicitly would trip isAsyncPropLoading
+      // and cause a transient black flash (see issue #376).
+      ...f !== void 0 && { image: f },
+      renderPipeline: h,
+      maxError: s,
+      reprojectionFns: b,
+      debug: r,
+      debugOpacity: a,
+      ...P
+    })), ...c];
+  }
+}
+const C = "colormap", tt = {
+  name: C,
+  fs: `uniform ${C}Uniforms {
+  int colormapIndex;
+  float reversed;
+} ${C};
+`,
+  inject: {
+    "fs:#decl": `precision highp sampler2DArray;
+uniform sampler2DArray colormapTexture;
+`,
+    "fs:DECKGL_FILTER_COLOR": (
+      /* glsl */
+      `
+      float idx = mix(color.r, 1.0 - color.r, ${C}.reversed);
+      color = texture(
+        colormapTexture,
+        vec3(idx, 0.5, float(${C}.colormapIndex))
+      );
+    `
+    )
+  },
+  uniformTypes: {
+    colormapIndex: "i32",
+    reversed: "f32"
+  },
+  getUniforms: (o) => ({
+    colormapTexture: o.colormapTexture,
+    colormapIndex: o.colormapIndex ?? 0,
+    reversed: o.reversed ?? !1
+  })
+}, X = {
+  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 nt(o, e) {
+  if (e.width !== 256)
+    throw new Error(`Expected a 256-pixel-wide colormap sprite, got width ${e.width}.`);
+  const t = new Uint8Array(e.data.buffer, e.data.byteOffset, e.data.byteLength);
+  return o.createTexture({
+    dimension: "2d-array",
+    format: "rgba8unorm",
+    width: 256,
+    height: 1,
+    depth: e.height,
+    data: t,
+    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 st(o) {
+  const e = await rt(o);
+  try {
+    return ot(e);
+  } finally {
+    e.close();
+  }
+}
+async function rt(o) {
+  if (o instanceof ImageBitmap)
+    return o;
+  const e = new Blob([o]);
+  return createImageBitmap(e);
+}
+function ot(o) {
+  const t = new OffscreenCanvas(o.width, o.height).getContext("2d");
+  if (!t)
+    throw new Error("Failed to obtain 2D context for decoding the colormap sprite.");
+  return t.drawImage(o, 0, 0), t.getImageData(0, 0, o.width, o.height);
+}
+const N = "nodata", it = `uniform ${N}Uniforms {
+  float value;
+} ${N};
+`, at = {
+  name: N,
+  fs: it,
+  inject: {
+    "fs:DECKGL_FILTER_COLOR": (
+      /* glsl */
+      `
+    if (color.r == nodata.value) {
+      discard;
+    }
+    `
+    )
+  },
+  uniformTypes: {
+    value: "f32"
+  },
+  getUniforms: (o) => ({
+    value: o.value
+  })
+}, M = "linearRescale", ct = {
+  name: M,
+  fs: `uniform ${M}Uniforms {
+  float rescaleMin;
+  float rescaleMax;
+} ${M};
+`,
+  inject: {
+    "fs:DECKGL_FILTER_COLOR": (
+      /* glsl */
+      `
+  color.rgb = clamp((color.rgb - ${M}.rescaleMin) / (${M}.rescaleMax - ${M}.rescaleMin), 0.0, 1.0);
+`
+    )
+  },
+  uniformTypes: {
+    rescaleMin: "f32",
+    rescaleMax: "f32"
+  },
+  getUniforms: (o) => ({
+    rescaleMin: o.rescaleMin ?? 0,
+    rescaleMax: o.rescaleMax ?? 1
+  })
+}, lt = "data:image/png;base64,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", _ = /* @__PURE__ */ new WeakMap();
+function bt(o) {
+  const e = _.get(o);
+  if (e) return e;
+  const t = (async () => {
+    const n = await (await fetch(lt)).arrayBuffer();
+    return nt(o, await st(n));
+  })();
+  return _.set(o, t), t;
+}
+const $ = /* @__PURE__ */ new Set();
+function ut(o) {
+  return o in X ? X[o] : ($.has(o) || ($.add(o), console.warn(`[onlymapjs] raster: unknown colormap "${o}" — falling back to gray.`)), X.gray);
+}
+function Tt(o, e) {
+  const t = [
+    // Per-tile textureName (not the layer-level `image:` shorthand — that
+    // binds only the first tile's sampler in this setup).
+    { module: se, props: { textureName: o.texture } }
+  ], n = e.nodataOverride ?? o.nodata;
+  return n != null && Number.isFinite(n) && t.push({ module: at, props: { value: n } }), t.push({
+    module: ct,
+    props: { rescaleMin: e.rescaleMin ?? 0, rescaleMax: e.rescaleMax ?? 255 }
+  }), o.bandCount === 1 && t.push({
+    module: tt,
+    props: { colormapTexture: o.colormapTexture, colormapIndex: ut(e.colormap ?? "gray") }
+  }), { renderPipeline: t };
+}
+export {
+  mt as A,
+  tt as C,
+  at as F,
+  xt as R,
+  y as a,
+  se as b,
+  ze as c,
+  ft as d,
+  vt as e,
+  Pt as f,
+  Tt as g,
+  bt as h,
+  q as i,
+  gt as m,
+  Ie as p,
+  pt as s,
+  Re as t
+};