@gisfun/maplibre-gl-components 0.15.0-alpha.0

package/dist/index-Bi1MMPUx.js

@@ -0,0 +1,4163 @@
+import q from "./index-DQXdX5y1.js";
+import { f as $e, b as Xe, c as Ze, d as He, e as Ke, P as Qe } from "./geotiff-o_Fq1Na4.js";
+import { CreateTexture as xe, cieLabToRGB as Je, YCbCrToRGB as ts, CMYKToRGB as es, Colormap as ss, FilterNoDataVal as ns } from "./index-C9fk_HKR.js";
+import { aX as is, aY as os, aZ as rs, a_ as Wt, a$ as R, b0 as as, b1 as Me, b2 as cs, b3 as ls, b4 as it, b5 as hs, b6 as us, b7 as ds, b8 as we, b9 as fs, ba as ms, bb as ps, bc as gs, bd as Vt, be as ys, bf as ut, bg as _s, bh as xs, bi as Ms, bj as ws, bk as Ts, bl as bs, bm as Ss, bn as Cs, bo as Ls, bp as Es, bq as Ps, br as Rs, bs as Is, bt as V, bu as Te, bv as As, bw as be, bx as vs, by as Os, bz as Se, bA as M, bB as zs, bC as xt, bD as st, bE as Ce, bF as kt, bG as ot, bH as G, bI as Ns, bJ as Fs, bK as dt, bL as qs, bM as Bs, bN as Gs, bO as Ds, bP as Us, bQ as ft, bR as Ws, bS as Vs } from "./ControlGrid-rVNG7B9O.js";
+const ks = "Queued Requests", js = "Active Requests", Ys = "Cancelled Requests", $s = "Queued Requests Ever", Xs = "Active Requests Ever", Zs = {
+  id: "request-scheduler",
+  /** Specifies if the request scheduler should throttle incoming requests, mainly for comparative testing. */
+  throttleRequests: !0,
+  /** The maximum number of simultaneous active requests. Un-throttled requests do not observe this limit. */
+  maxRequests: 6,
+  /**
+   * Specifies a debounce time, in milliseconds. All requests are queued, until no new requests have
+   * been added to the queue for this amount of time.
+   */
+  debounceTime: 0
+};
+class Hs {
+  props;
+  stats;
+  activeRequestCount = 0;
+  /** Tracks the number of active requests and prioritizes/cancels queued requests. */
+  requestQueue = [];
+  requestMap = /* @__PURE__ */ new Map();
+  updateTimer = null;
+  constructor(t = {}) {
+    this.props = { ...Zs, ...t }, this.stats = new is({ id: this.props.id }), this.stats.get(ks), this.stats.get(js), this.stats.get(Ys), this.stats.get($s), this.stats.get(Xs);
+  }
+  /**
+   * Called by an application that wants to issue a request, without having it deeply queued by the browser
+   *
+   * When the returned promise resolved, it is OK for the application to issue a request.
+   * The promise resolves to an object that contains a `done` method.
+   * When the application's request has completed (or failed), the application must call the `done` function
+   *
+   * @param handle
+   * @param getPriority will be called when request "slots" open up,
+   *    allowing the caller to update priority or cancel the request
+   *    Highest priority executes first, priority < 0 cancels the request
+   * @returns a promise
+   *   - resolves to a object (with a `done` field) when the request can be issued without queueing,
+   *   - resolves to `null` if the request has been cancelled (by the callback return < 0).
+   *     In this case the application should not issue the request
+   */
+  scheduleRequest(t, e = () => 0) {
+    if (!this.props.throttleRequests)
+      return Promise.resolve({ done: () => {
+      } });
+    if (this.requestMap.has(t))
+      return this.requestMap.get(t);
+    const s = { handle: t, priority: 0, getPriority: e }, i = new Promise((o) => (s.resolve = o, s));
+    return this.requestQueue.push(s), this.requestMap.set(t, i), this._issueNewRequests(), i;
+  }
+  // PRIVATE
+  _issueRequest(t) {
+    const { handle: e, resolve: s } = t;
+    let i = !1;
+    const o = () => {
+      i || (i = !0, this.requestMap.delete(e), this.activeRequestCount--, this._issueNewRequests());
+    };
+    return this.activeRequestCount++, s ? s({ done: o }) : Promise.resolve({ done: o });
+  }
+  /** We check requests asynchronously, to prevent multiple updates */
+  _issueNewRequests() {
+    this.updateTimer !== null && clearTimeout(this.updateTimer), this.updateTimer = setTimeout(() => this._issueNewRequestsAsync(), this.props.debounceTime);
+  }
+  /** Refresh all requests  */
+  _issueNewRequestsAsync() {
+    this.updateTimer !== null && clearTimeout(this.updateTimer), this.updateTimer = null;
+    const t = Math.max(this.props.maxRequests - this.activeRequestCount, 0);
+    if (t !== 0) {
+      this._updateAllRequests();
+      for (let e = 0; e < t; ++e) {
+        const s = this.requestQueue.shift();
+        s && this._issueRequest(s);
+      }
+    }
+  }
+  /** Ensure all requests have updated priorities, and that no longer valid requests are cancelled */
+  _updateAllRequests() {
+    const t = this.requestQueue;
+    for (let e = 0; e < t.length; ++e) {
+      const s = t[e];
+      this._updateRequest(s) || (t.splice(e, 1), this.requestMap.delete(s.handle), e--);
+    }
+    t.sort((e, s) => e.priority - s.priority);
+  }
+  /** Update a single request by calling the callback */
+  _updateRequest(t) {
+    return t.priority = t.getPriority(t.handle), t.priority < 0 ? (t.resolve(null), !1) : !0;
+  }
+}
+function Ks(n) {
+  let t = 1 / 0, e = 1 / 0, s = 1 / 0, i = -1 / 0, o = -1 / 0, r = -1 / 0;
+  const a = n.POSITION ? n.POSITION.value : [], c = a && a.length;
+  for (let h = 0; h < c; h += 3) {
+    const u = a[h], l = a[h + 1], d = a[h + 2];
+    t = u < t ? u : t, e = l < e ? l : e, s = d < s ? d : s, i = u > i ? u : i, o = l > o ? l : o, r = d > r ? d : r;
+  }
+  return [
+    [t, e, s],
+    [i, o, r]
+  ];
+}
+let $;
+class Et extends os {
+  static get ZERO() {
+    return $ || ($ = new Et(0, 0, 0, 0), Object.freeze($)), $;
+  }
+  constructor(t = 0, e = 0, s = 0, i = 0) {
+    super(-0, -0, -0, -0), rs(t) && arguments.length === 1 ? this.copy(t) : (Wt.debug && (R(t), R(e), R(s), R(i)), this[0] = t, this[1] = e, this[2] = s, this[3] = i);
+  }
+  set(t, e, s, i) {
+    return this[0] = t, this[1] = e, this[2] = s, this[3] = i, this.check();
+  }
+  copy(t) {
+    return this[0] = t[0], this[1] = t[1], this[2] = t[2], this[3] = t[3], this.check();
+  }
+  fromObject(t) {
+    return Wt.debug && (R(t.x), R(t.y), R(t.z), R(t.w)), this[0] = t.x, this[1] = t.y, this[2] = t.z, this[3] = t.w, this;
+  }
+  toObject(t) {
+    return t.x = this[0], t.y = this[1], t.z = this[2], t.w = this[3], t;
+  }
+  // Getters/setters
+  /* eslint-disable no-multi-spaces, brace-style, no-return-assign */
+  get ELEMENTS() {
+    return 4;
+  }
+  get z() {
+    return this[2];
+  }
+  set z(t) {
+    this[2] = R(t);
+  }
+  get w() {
+    return this[3];
+  }
+  set w(t) {
+    this[3] = R(t);
+  }
+  transform(t) {
+    return as(this, this, t), this.check();
+  }
+  transformByMatrix3(t) {
+    return Me(this, this, t), this.check();
+  }
+  transformByMatrix2(t) {
+    return cs(this, this, t), this.check();
+  }
+  transformByQuaternion(t) {
+    return ls(this, this, t), this.check();
+  }
+  // three.js compatibility
+  applyMatrix4(t) {
+    return t.transform(this, this), this;
+  }
+}
+function Qs() {
+  const n = new it(9);
+  return it != Float32Array && (n[1] = 0, n[2] = 0, n[3] = 0, n[5] = 0, n[6] = 0, n[7] = 0), n[0] = 1, n[4] = 1, n[8] = 1, n;
+}
+function Js(n, t) {
+  if (n === t) {
+    const e = t[1], s = t[2], i = t[5];
+    n[1] = t[3], n[2] = t[6], n[3] = e, n[5] = t[7], n[6] = s, n[7] = i;
+  } else
+    n[0] = t[0], n[1] = t[3], n[2] = t[6], n[3] = t[1], n[4] = t[4], n[5] = t[7], n[6] = t[2], n[7] = t[5], n[8] = t[8];
+  return n;
+}
+function tn(n, t) {
+  const e = t[0], s = t[1], i = t[2], o = t[3], r = t[4], a = t[5], c = t[6], h = t[7], u = t[8], l = u * r - a * h, d = -u * o + a * c, f = h * o - r * c;
+  let m = e * l + s * d + i * f;
+  return m ? (m = 1 / m, n[0] = l * m, n[1] = (-u * s + i * h) * m, n[2] = (a * s - i * r) * m, n[3] = d * m, n[4] = (u * e - i * c) * m, n[5] = (-a * e + i * o) * m, n[6] = f * m, n[7] = (-h * e + s * c) * m, n[8] = (r * e - s * o) * m, n) : null;
+}
+function en(n) {
+  const t = n[0], e = n[1], s = n[2], i = n[3], o = n[4], r = n[5], a = n[6], c = n[7], h = n[8];
+  return t * (h * o - r * c) + e * (-h * i + r * a) + s * (c * i - o * a);
+}
+function jt(n, t, e) {
+  const s = t[0], i = t[1], o = t[2], r = t[3], a = t[4], c = t[5], h = t[6], u = t[7], l = t[8], d = e[0], f = e[1], m = e[2], p = e[3], g = e[4], y = e[5], _ = e[6], x = e[7], w = e[8];
+  return n[0] = d * s + f * r + m * h, n[1] = d * i + f * a + m * u, n[2] = d * o + f * c + m * l, n[3] = p * s + g * r + y * h, n[4] = p * i + g * a + y * u, n[5] = p * o + g * c + y * l, n[6] = _ * s + x * r + w * h, n[7] = _ * i + x * a + w * u, n[8] = _ * o + x * c + w * l, n;
+}
+function sn(n, t, e) {
+  const s = t[0], i = t[1], o = t[2], r = t[3], a = t[4], c = t[5], h = t[6], u = t[7], l = t[8], d = e[0], f = e[1];
+  return n[0] = s, n[1] = i, n[2] = o, n[3] = r, n[4] = a, n[5] = c, n[6] = d * s + f * r + h, n[7] = d * i + f * a + u, n[8] = d * o + f * c + l, n;
+}
+function nn(n, t, e) {
+  const s = t[0], i = t[1], o = t[2], r = t[3], a = t[4], c = t[5], h = t[6], u = t[7], l = t[8], d = Math.sin(e), f = Math.cos(e);
+  return n[0] = f * s + d * r, n[1] = f * i + d * a, n[2] = f * o + d * c, n[3] = f * r - d * s, n[4] = f * a - d * i, n[5] = f * c - d * o, n[6] = h, n[7] = u, n[8] = l, n;
+}
+function Yt(n, t, e) {
+  const s = e[0], i = e[1];
+  return n[0] = s * t[0], n[1] = s * t[1], n[2] = s * t[2], n[3] = i * t[3], n[4] = i * t[4], n[5] = i * t[5], n[6] = t[6], n[7] = t[7], n[8] = t[8], n;
+}
+function on(n, t) {
+  const e = t[0], s = t[1], i = t[2], o = t[3], r = e + e, a = s + s, c = i + i, h = e * r, u = s * r, l = s * a, d = i * r, f = i * a, m = i * c, p = o * r, g = o * a, y = o * c;
+  return n[0] = 1 - l - m, n[3] = u - y, n[6] = d + g, n[1] = u + y, n[4] = 1 - h - m, n[7] = f - p, n[2] = d - g, n[5] = f + p, n[8] = 1 - h - l, n;
+}
+var Mt;
+(function(n) {
+  n[n.COL0ROW0 = 0] = "COL0ROW0", n[n.COL0ROW1 = 1] = "COL0ROW1", n[n.COL0ROW2 = 2] = "COL0ROW2", n[n.COL1ROW0 = 3] = "COL1ROW0", n[n.COL1ROW1 = 4] = "COL1ROW1", n[n.COL1ROW2 = 5] = "COL1ROW2", n[n.COL2ROW0 = 6] = "COL2ROW0", n[n.COL2ROW1 = 7] = "COL2ROW1", n[n.COL2ROW2 = 8] = "COL2ROW2";
+})(Mt || (Mt = {}));
+const rn = Object.freeze([1, 0, 0, 0, 1, 0, 0, 0, 1]);
+class E extends hs {
+  static get IDENTITY() {
+    return cn();
+  }
+  static get ZERO() {
+    return an();
+  }
+  get ELEMENTS() {
+    return 9;
+  }
+  get RANK() {
+    return 3;
+  }
+  get INDICES() {
+    return Mt;
+  }
+  constructor(t, ...e) {
+    super(-0, -0, -0, -0, -0, -0, -0, -0, -0), arguments.length === 1 && Array.isArray(t) ? this.copy(t) : e.length > 0 ? this.copy([t, ...e]) : this.identity();
+  }
+  copy(t) {
+    return this[0] = t[0], this[1] = t[1], this[2] = t[2], this[3] = t[3], this[4] = t[4], this[5] = t[5], this[6] = t[6], this[7] = t[7], this[8] = t[8], this.check();
+  }
+  // Constructors
+  identity() {
+    return this.copy(rn);
+  }
+  /**
+   *
+   * @param object
+   * @returns self
+   */
+  // eslint-disable-next-line @typescript-eslint/no-unused-vars
+  fromObject(t) {
+    return this.check();
+  }
+  /** Calculates a 3x3 matrix from the given quaternion
+   * q quat  Quaternion to create matrix from
+   */
+  fromQuaternion(t) {
+    return on(this, t), this.check();
+  }
+  /**
+   * accepts column major order, stores in column major order
+   */
+  // eslint-disable-next-line max-params
+  set(t, e, s, i, o, r, a, c, h) {
+    return this[0] = t, this[1] = e, this[2] = s, this[3] = i, this[4] = o, this[5] = r, this[6] = a, this[7] = c, this[8] = h, this.check();
+  }
+  /**
+   * accepts row major order, stores as column major
+   */
+  // eslint-disable-next-line max-params
+  setRowMajor(t, e, s, i, o, r, a, c, h) {
+    return this[0] = t, this[1] = i, this[2] = a, this[3] = e, this[4] = o, this[5] = c, this[6] = s, this[7] = r, this[8] = h, this.check();
+  }
+  // Accessors
+  determinant() {
+    return en(this);
+  }
+  // Modifiers
+  transpose() {
+    return Js(this, this), this.check();
+  }
+  /** Invert a matrix. Note that this can fail if the matrix is not invertible */
+  invert() {
+    return tn(this, this), this.check();
+  }
+  // Operations
+  multiplyLeft(t) {
+    return jt(this, t, this), this.check();
+  }
+  multiplyRight(t) {
+    return jt(this, this, t), this.check();
+  }
+  rotate(t) {
+    return nn(this, this, t), this.check();
+  }
+  scale(t) {
+    return Array.isArray(t) ? Yt(this, this, t) : Yt(this, this, [t, t]), this.check();
+  }
+  translate(t) {
+    return sn(this, this, t), this.check();
+  }
+  // Transforms
+  transform(t, e) {
+    let s;
+    switch (t.length) {
+      case 2:
+        s = ds(e || [-0, -0], t, this);
+        break;
+      case 3:
+        s = us(e || [-0, -0, -0], t, this);
+        break;
+      case 4:
+        s = Me(e || [-0, -0, -0, -0], t, this);
+        break;
+      default:
+        throw new Error("Illegal vector");
+    }
+    return we(s, t.length), s;
+  }
+  /** @deprecated */
+  transformVector(t, e) {
+    return this.transform(t, e);
+  }
+  /** @deprecated */
+  transformVector2(t, e) {
+    return this.transform(t, e);
+  }
+  /** @deprecated */
+  transformVector3(t, e) {
+    return this.transform(t, e);
+  }
+}
+let X, Z = null;
+function an() {
+  return X || (X = new E([0, 0, 0, 0, 0, 0, 0, 0, 0]), Object.freeze(X)), X;
+}
+function cn() {
+  return Z || (Z = new E(), Object.freeze(Z)), Z;
+}
+function $t() {
+  const n = new it(4);
+  return it != Float32Array && (n[0] = 0, n[1] = 0, n[2] = 0), n[3] = 1, n;
+}
+function ln(n) {
+  return n[0] = 0, n[1] = 0, n[2] = 0, n[3] = 1, n;
+}
+function Le(n, t, e) {
+  e = e * 0.5;
+  const s = Math.sin(e);
+  return n[0] = s * t[0], n[1] = s * t[1], n[2] = s * t[2], n[3] = Math.cos(e), n;
+}
+function Xt(n, t, e) {
+  const s = t[0], i = t[1], o = t[2], r = t[3], a = e[0], c = e[1], h = e[2], u = e[3];
+  return n[0] = s * u + r * a + i * h - o * c, n[1] = i * u + r * c + o * a - s * h, n[2] = o * u + r * h + s * c - i * a, n[3] = r * u - s * a - i * c - o * h, n;
+}
+function hn(n, t, e) {
+  e *= 0.5;
+  const s = t[0], i = t[1], o = t[2], r = t[3], a = Math.sin(e), c = Math.cos(e);
+  return n[0] = s * c + r * a, n[1] = i * c + o * a, n[2] = o * c - i * a, n[3] = r * c - s * a, n;
+}
+function un(n, t, e) {
+  e *= 0.5;
+  const s = t[0], i = t[1], o = t[2], r = t[3], a = Math.sin(e), c = Math.cos(e);
+  return n[0] = s * c - o * a, n[1] = i * c + r * a, n[2] = o * c + s * a, n[3] = r * c - i * a, n;
+}
+function dn(n, t, e) {
+  e *= 0.5;
+  const s = t[0], i = t[1], o = t[2], r = t[3], a = Math.sin(e), c = Math.cos(e);
+  return n[0] = s * c + i * a, n[1] = i * c - s * a, n[2] = o * c + r * a, n[3] = r * c - o * a, n;
+}
+function fn(n, t) {
+  const e = t[0], s = t[1], i = t[2];
+  return n[0] = e, n[1] = s, n[2] = i, n[3] = Math.sqrt(Math.abs(1 - e * e - s * s - i * i)), n;
+}
+function nt(n, t, e, s) {
+  const i = t[0], o = t[1], r = t[2], a = t[3];
+  let c = e[0], h = e[1], u = e[2], l = e[3], d, f, m, p, g;
+  return d = i * c + o * h + r * u + a * l, d < 0 && (d = -d, c = -c, h = -h, u = -u, l = -l), 1 - d > Ss ? (f = Math.acos(d), g = Math.sin(f), m = Math.sin((1 - s) * f) / g, p = Math.sin(s * f) / g) : (m = 1 - s, p = s), n[0] = m * i + p * c, n[1] = m * o + p * h, n[2] = m * r + p * u, n[3] = m * a + p * l, n;
+}
+function mn(n, t) {
+  const e = t[0], s = t[1], i = t[2], o = t[3], r = e * e + s * s + i * i + o * o, a = r ? 1 / r : 0;
+  return n[0] = -e * a, n[1] = -s * a, n[2] = -i * a, n[3] = o * a, n;
+}
+function pn(n, t) {
+  return n[0] = -t[0], n[1] = -t[1], n[2] = -t[2], n[3] = t[3], n;
+}
+function Ee(n, t) {
+  const e = t[0] + t[4] + t[8];
+  let s;
+  if (e > 0)
+    s = Math.sqrt(e + 1), n[3] = 0.5 * s, s = 0.5 / s, n[0] = (t[5] - t[7]) * s, n[1] = (t[6] - t[2]) * s, n[2] = (t[1] - t[3]) * s;
+  else {
+    let i = 0;
+    t[4] > t[0] && (i = 1), t[8] > t[i * 3 + i] && (i = 2);
+    const o = (i + 1) % 3, r = (i + 2) % 3;
+    s = Math.sqrt(t[i * 3 + i] - t[o * 3 + o] - t[r * 3 + r] + 1), n[i] = 0.5 * s, s = 0.5 / s, n[3] = (t[o * 3 + r] - t[r * 3 + o]) * s, n[o] = (t[o * 3 + i] + t[i * 3 + o]) * s, n[r] = (t[r * 3 + i] + t[i * 3 + r]) * s;
+  }
+  return n;
+}
+const gn = Ms, yn = Ts, _n = ps, xn = ws, Mn = fs, wn = ms, Pe = bs, Tn = (function() {
+  const n = gs(), t = Vt(1, 0, 0), e = Vt(0, 1, 0);
+  return function(s, i, o) {
+    const r = ys(i, o);
+    return r < -0.999999 ? (ut(n, t, i), _s(n) < 1e-6 && ut(n, e, i), xs(n, n), Le(s, n, Math.PI), s) : r > 0.999999 ? (s[0] = 0, s[1] = 0, s[2] = 0, s[3] = 1, s) : (ut(n, i, o), s[0] = n[0], s[1] = n[1], s[2] = n[2], s[3] = 1 + r, Pe(s, s));
+  };
+})();
+(function() {
+  const n = $t(), t = $t();
+  return function(e, s, i, o, r, a) {
+    return nt(n, s, r, a), nt(t, i, o, a), nt(e, n, t, 2 * a * (1 - a)), e;
+  };
+})();
+(function() {
+  const n = Qs();
+  return function(t, e, s, i) {
+    return n[0] = s[0], n[3] = s[1], n[6] = s[2], n[1] = i[0], n[4] = i[1], n[7] = i[2], n[2] = -e[0], n[5] = -e[1], n[8] = -e[2], Pe(t, Ee(t, n));
+  };
+})();
+const bn = [0, 0, 0, 1];
+class Zt extends Cs {
+  constructor(t = 0, e = 0, s = 0, i = 1) {
+    super(-0, -0, -0, -0), Array.isArray(t) && arguments.length === 1 ? this.copy(t) : this.set(t, e, s, i);
+  }
+  copy(t) {
+    return this[0] = t[0], this[1] = t[1], this[2] = t[2], this[3] = t[3], this.check();
+  }
+  set(t, e, s, i) {
+    return this[0] = t, this[1] = e, this[2] = s, this[3] = i, this.check();
+  }
+  fromObject(t) {
+    return this[0] = t.x, this[1] = t.y, this[2] = t.z, this[3] = t.w, this.check();
+  }
+  /**
+   * Creates a quaternion from the given 3x3 rotation matrix.
+   * NOTE: The resultant quaternion is not normalized, so you should
+   * be sure to renormalize the quaternion yourself where necessary.
+   * @param m
+   * @returns
+   */
+  fromMatrix3(t) {
+    return Ee(this, t), this.check();
+  }
+  fromAxisRotation(t, e) {
+    return Le(this, t, e), this.check();
+  }
+  /** Set a quat to the identity quaternion */
+  identity() {
+    return ln(this), this.check();
+  }
+  // Set the components of a quat to the given values
+  // set(i, j, k, l) {
+  //   quat_set(this, i, j, k, l);
+  //   return this.check();
+  // }
+  // Sets a quat from the given angle and rotation axis, then returns it.
+  setAxisAngle(t, e) {
+    return this.fromAxisRotation(t, e);
+  }
+  // Getters/setters
+  get ELEMENTS() {
+    return 4;
+  }
+  get x() {
+    return this[0];
+  }
+  set x(t) {
+    this[0] = R(t);
+  }
+  get y() {
+    return this[1];
+  }
+  set y(t) {
+    this[1] = R(t);
+  }
+  get z() {
+    return this[2];
+  }
+  set z(t) {
+    this[2] = R(t);
+  }
+  get w() {
+    return this[3];
+  }
+  set w(t) {
+    this[3] = R(t);
+  }
+  // Calculates the length of a quat
+  len() {
+    return Mn(this);
+  }
+  // Calculates the squared length of a quat
+  lengthSquared() {
+    return wn(this);
+  }
+  // Calculates the dot product of two quat's
+  // @return {Number}
+  dot(t) {
+    return _n(this, t);
+  }
+  // Gets the rotation axis and angle for a given quaternion.
+  // If a quaternion is created with setAxisAngle, this method will
+  // return the same values as providied in the original parameter
+  // list OR functionally equivalent values.
+  // Example: The quaternion formed by axis [0, 0, 1] and angle -90
+  // is the same as the quaternion formed by [0, 0, 1] and 270.
+  // This method favors the latter.
+  // @return {{[x,y,z], Number}}
+  // getAxisAngle() {
+  //   const axis = [];
+  // //   const angle = quat_getAxisAngle(axis, this);
+  //   return {axis, angle};
+  // }
+  // MODIFIERS
+  // Sets a quaternion to represent the shortest rotation from one vector
+  // to another. Both vectors are assumed to be unit length.
+  rotationTo(t, e) {
+    return Tn(this, t, e), this.check();
+  }
+  // Sets the specified quaternion with values corresponding to the given axes.
+  // Each axis is a vec3 and is expected to be unit length and perpendicular
+  // to all other specified axes.
+  // setAxes() {
+  //   Number
+  // }
+  // Performs a spherical linear interpolation with two control points
+  // sqlerp() {
+  //   Number;
+  // }
+  // Adds two quat's
+  add(t) {
+    return gn(this, this, t), this.check();
+  }
+  // Calculates the W component of a quat from the X, Y, and Z components.
+  // Any existing W component will be ignored.
+  calculateW() {
+    return fn(this, this), this.check();
+  }
+  // Calculates the conjugate of a quat If the quaternion is normalized,
+  // this function is faster than quat_invert and produces the same result.
+  conjugate() {
+    return pn(this, this), this.check();
+  }
+  // Calculates the inverse of a quat
+  invert() {
+    return mn(this, this), this.check();
+  }
+  // Performs a linear interpolation between two quat's
+  lerp(t, e, s) {
+    return s === void 0 ? this.lerp(this, t, e) : (xn(this, t, e, s), this.check());
+  }
+  // Multiplies two quat's
+  multiplyRight(t) {
+    return Xt(this, this, t), this.check();
+  }
+  multiplyLeft(t) {
+    return Xt(this, t, this), this.check();
+  }
+  // Normalize a quat
+  normalize() {
+    const t = this.len(), e = t > 0 ? 1 / t : 0;
+    return this[0] = this[0] * e, this[1] = this[1] * e, this[2] = this[2] * e, this[3] = this[3] * e, t === 0 && (this[3] = 1), this.check();
+  }
+  // Rotates a quaternion by the given angle about the X axis
+  rotateX(t) {
+    return hn(this, this, t), this.check();
+  }
+  // Rotates a quaternion by the given angle about the Y axis
+  rotateY(t) {
+    return un(this, this, t), this.check();
+  }
+  // Rotates a quaternion by the given angle about the Z axis
+  rotateZ(t) {
+    return dn(this, this, t), this.check();
+  }
+  // Scales a quat by a scalar number
+  scale(t) {
+    return yn(this, this, t), this.check();
+  }
+  // Performs a spherical linear interpolation between two quat
+  slerp(t, e, s) {
+    let i, o, r;
+    switch (arguments.length) {
+      case 1:
+        ({
+          start: i = bn,
+          target: o,
+          ratio: r
+        } = t);
+        break;
+      case 2:
+        i = this, o = t, r = e;
+        break;
+      default:
+        i = t, o = e, r = s;
+    }
+    return nt(this, i, o, r), this.check();
+  }
+  transformVector4(t, e = new Et()) {
+    return Ls(e, t, this), we(e, 4);
+  }
+  // THREE.js Math API compatibility
+  lengthSq() {
+    return this.lengthSquared();
+  }
+  setFromAxisAngle(t, e) {
+    return this.setAxisAngle(t, e);
+  }
+  premultiply(t) {
+    return this.multiplyLeft(t);
+  }
+  multiply(t) {
+    return this.multiplyRight(t);
+  }
+}
+const Sn = 1e-15, Cn = 1e-20, Re = {
+  name: "phongMaterial",
+  dependencies: [Is],
+  // Note these are switched between phong and gouraud
+  source: Rs,
+  vs: Ps,
+  fs: Es,
+  defines: {
+    LIGHTING_FRAGMENT: !0
+  },
+  uniformTypes: {
+    ambient: "f32",
+    diffuse: "f32",
+    shininess: "f32",
+    specularColor: "vec3<f32>"
+  },
+  defaultUniforms: {
+    ambient: 0.35,
+    diffuse: 0.6,
+    shininess: 32,
+    specularColor: [0.15, 0.15, 0.15]
+  },
+  getUniforms(n) {
+    const t = { ...n };
+    return t.specularColor && (t.specularColor = t.specularColor.map((e) => e / 255)), { ...Re.defaultUniforms, ...t };
+  }
+}, Ie = [0, 0, 0, 255], Ln = [0, 0, 0, 255], En = {
+  stroked: !0,
+  filled: !0,
+  extruded: !1,
+  elevationScale: 1,
+  wireframe: !1,
+  _normalize: !0,
+  _windingOrder: "CW",
+  lineWidthUnits: "meters",
+  lineWidthScale: 1,
+  lineWidthMinPixels: 0,
+  lineWidthMaxPixels: Number.MAX_SAFE_INTEGER,
+  lineJointRounded: !1,
+  lineMiterLimit: 4,
+  getPolygon: { type: "accessor", value: (n) => n.polygon },
+  // Polygon fill color
+  getFillColor: { type: "accessor", value: Ln },
+  // Point, line and polygon outline color
+  getLineColor: { type: "accessor", value: Ie },
+  // Line and polygon outline accessors
+  getLineWidth: { type: "accessor", value: 1 },
+  // Polygon extrusion accessor
+  getElevation: { type: "accessor", value: 1e3 },
+  // Optional material for 'lighting' shader module
+  material: !0
+};
+class Pt extends V {
+  initializeState() {
+    this.state = {
+      paths: [],
+      pathsDiff: null
+    }, this.props.getLineDashArray && Te.removed("getLineDashArray", "PathStyleExtension")();
+  }
+  updateState({ changeFlags: t }) {
+    const e = t.dataChanged || t.updateTriggersChanged && (t.updateTriggersChanged.all || t.updateTriggersChanged.getPolygon);
+    if (e && Array.isArray(t.dataChanged)) {
+      const s = this.state.paths.slice(), i = t.dataChanged.map((o) => As({
+        data: s,
+        getIndex: (r) => r.__source.index,
+        dataRange: o,
+        replace: this._getPaths(o)
+      }));
+      this.setState({ paths: s, pathsDiff: i });
+    } else e && this.setState({
+      paths: this._getPaths(),
+      pathsDiff: null
+    });
+  }
+  _getPaths(t = {}) {
+    const { data: e, getPolygon: s, positionFormat: i, _normalize: o } = this.props, r = [], a = i === "XY" ? 2 : 3, { startRow: c, endRow: h } = t, { iterable: u, objectInfo: l } = be(e, c, h);
+    for (const d of u) {
+      l.index++;
+      let f = s(d, l);
+      o && (f = vs(f, a));
+      const { holeIndices: m } = f, p = f.positions || f;
+      if (m)
+        for (let g = 0; g <= m.length; g++) {
+          const y = p.slice(m[g - 1] || 0, m[g] || p.length);
+          r.push(this.getSubLayerRow({ path: y }, d, l.index));
+        }
+      else
+        r.push(this.getSubLayerRow({ path: p }, d, l.index));
+    }
+    return r;
+  }
+  /* eslint-disable complexity */
+  renderLayers() {
+    const { data: t, _dataDiff: e, stroked: s, filled: i, extruded: o, wireframe: r, _normalize: a, _windingOrder: c, elevationScale: h, transitions: u, positionFormat: l } = this.props, { lineWidthUnits: d, lineWidthScale: f, lineWidthMinPixels: m, lineWidthMaxPixels: p, lineJointRounded: g, lineMiterLimit: y, lineDashJustified: _ } = this.props, { getFillColor: x, getLineColor: w, getLineWidth: T, getLineDashArray: S, getElevation: L, getPolygon: I, updateTriggers: b, material: C } = this.props, { paths: B, pathsDiff: k } = this.state, lt = this.getSubLayerClass("fill", Os), ht = this.getSubLayerClass("stroke", Se), j = this.shouldRenderSubLayer("fill", B) && new lt({
+      _dataDiff: e,
+      extruded: o,
+      elevationScale: h,
+      filled: i,
+      wireframe: r,
+      _normalize: a,
+      _windingOrder: c,
+      getElevation: L,
+      getFillColor: x,
+      getLineColor: o && r ? w : Ie,
+      material: C,
+      transitions: u
+    }, this.getSubLayerProps({
+      id: "fill",
+      updateTriggers: b && {
+        getPolygon: b.getPolygon,
+        getElevation: b.getElevation,
+        getFillColor: b.getFillColor,
+        // using a legacy API to invalid lineColor attributes
+        // if (extruded && wireframe) has changed
+        lineColors: o && r,
+        getLineColor: b.getLineColor
+      }
+    }), {
+      data: t,
+      positionFormat: l,
+      getPolygon: I
+    }), je = !o && s && this.shouldRenderSubLayer("stroke", B) && new ht({
+      _dataDiff: k && (() => k),
+      widthUnits: d,
+      widthScale: f,
+      widthMinPixels: m,
+      widthMaxPixels: p,
+      jointRounded: g,
+      miterLimit: y,
+      dashJustified: _,
+      // Already normalized
+      _pathType: "loop",
+      transitions: u && {
+        getWidth: u.getLineWidth,
+        getColor: u.getLineColor,
+        getPath: u.getPolygon
+      },
+      getColor: this.getSubLayerAccessor(w),
+      getWidth: this.getSubLayerAccessor(T),
+      getDashArray: this.getSubLayerAccessor(S)
+    }, this.getSubLayerProps({
+      id: "stroke",
+      updateTriggers: b && {
+        getWidth: b.getLineWidth,
+        getColor: b.getLineColor,
+        getDashArray: b.getLineDashArray
+      }
+    }), {
+      data: B,
+      positionFormat: l,
+      getPath: (Ye) => Ye.path
+    });
+    return [
+      // If not extruded: flat fill layer is drawn below outlines
+      !o && j,
+      je,
+      // If extruded: draw fill layer last for correct blending behavior
+      o && j
+    ];
+  }
+}
+Pt.layerName = "PolygonLayer";
+Pt.defaultProps = En;
+class Pn {
+  constructor(t) {
+    this.index = t, this.isVisible = !1, this.isSelected = !1, this.parent = null, this.children = [], this.content = null, this._loader = void 0, this._abortController = null, this._loaderId = 0, this._isLoaded = !1, this._isCancelled = !1, this._needsReload = !1;
+  }
+  /** @deprecated use `boundingBox` instead */
+  get bbox() {
+    return this._bbox;
+  }
+  // TODO - remove in v9
+  set bbox(t) {
+    this._bbox || (this._bbox = t, "west" in t ? this.boundingBox = [
+      [t.west, t.south],
+      [t.east, t.north]
+    ] : this.boundingBox = [
+      [t.left, t.top],
+      [t.right, t.bottom]
+    ]);
+  }
+  get data() {
+    return this.isLoading && this._loader ? this._loader.then(() => this.data) : this.content;
+  }
+  get isLoaded() {
+    return this._isLoaded && !this._needsReload;
+  }
+  get isLoading() {
+    return !!this._loader && !this._isCancelled;
+  }
+  get needsReload() {
+    return this._needsReload || this._isCancelled;
+  }
+  get byteLength() {
+    const t = this.content ? this.content.byteLength : 0;
+    return Number.isFinite(t) || console.error("byteLength not defined in tile data"), t;
+  }
+  /* eslint-disable max-statements */
+  async _loadData({ getData: t, requestScheduler: e, onLoad: s, onError: i }) {
+    const { index: o, id: r, bbox: a, userData: c, zoom: h } = this, u = this._loaderId;
+    this._abortController = new AbortController();
+    const { signal: l } = this._abortController, d = await e.scheduleRequest(this, (p) => p.isSelected ? 1 : -1);
+    if (!d) {
+      this._isCancelled = !0;
+      return;
+    }
+    if (this._isCancelled) {
+      d.done();
+      return;
+    }
+    let f = null, m;
+    try {
+      f = await t({ index: o, id: r, bbox: a, userData: c, zoom: h, signal: l });
+    } catch (p) {
+      m = p || !0;
+    } finally {
+      d.done();
+    }
+    if (u === this._loaderId) {
+      if (this._loader = void 0, this.content = f, this._isCancelled && !f) {
+        this._isLoaded = !1;
+        return;
+      }
+      this._isLoaded = !0, this._isCancelled = !1, m ? i(m, this) : s(this);
+    }
+  }
+  loadData(t) {
+    return this._isLoaded = !1, this._isCancelled = !1, this._needsReload = !1, this._loaderId++, this._loader = this._loadData(t), this._loader;
+  }
+  setNeedsReload() {
+    this.isLoading && (this.abort(), this._loader = void 0), this._needsReload = !0;
+  }
+  abort() {
+    this.isLoaded || (this._isCancelled = !0, this._abortController?.abort());
+  }
+}
+const P = {
+  OUTSIDE: -1,
+  // Represents that an object is not contained within the frustum.
+  INTERSECTING: 0,
+  // Represents that an object intersects one of the frustum's planes.
+  INSIDE: 1
+  // Represents that an object is fully within the frustum.
+}, Ht = new M(), Rn = new M();
+class Rt {
+  /**
+   * Creates an instance of an AxisAlignedBoundingBox from the minimum and maximum points along the x, y, and z axes.
+   * @param minimum=[0, 0, 0] The minimum point along the x, y, and z axes.
+   * @param maximum=[0, 0, 0] The maximum point along the x, y, and z axes.
+   * @param center The center of the box; automatically computed if not supplied.
+   */
+  constructor(t = [0, 0, 0], e = [0, 0, 0], s) {
+    s = s || Ht.copy(t).add(e).scale(0.5), this.center = new M(s), this.halfDiagonal = new M(e).subtract(this.center), this.minimum = new M(t), this.maximum = new M(e);
+  }
+  /**
+   * Duplicates a AxisAlignedBoundingBox instance.
+   *
+   * @returns {AxisAlignedBoundingBox} A new AxisAlignedBoundingBox instance.
+   */
+  clone() {
+    return new Rt(this.minimum, this.maximum, this.center);
+  }
+  /**
+   * Compares the provided AxisAlignedBoundingBox componentwise and returns
+   * <code>true</code> if they are equal, <code>false</code> otherwise.
+   *
+   * @param {AxisAlignedBoundingBox} [right] The second AxisAlignedBoundingBox to compare with.
+   * @returns {Boolean} <code>true</code> if left and right are equal, <code>false</code> otherwise.
+   */
+  equals(t) {
+    return this === t || !!t && this.minimum.equals(t.minimum) && this.maximum.equals(t.maximum);
+  }
+  /**
+   * Applies a 4x4 affine transformation matrix to a bounding sphere.
+   * @param transform The transformation matrix to apply to the bounding sphere.
+   * @returns itself, i.e. the modified BoundingVolume.
+   */
+  transform(t) {
+    return this.center.transformAsPoint(t), this.halfDiagonal.transform(t), this.minimum.transform(t), this.maximum.transform(t), this;
+  }
+  /**
+   * Determines which side of a plane a box is located.
+   */
+  intersectPlane(t) {
+    const { halfDiagonal: e } = this, s = Rn.from(t.normal), i = e.x * Math.abs(s.x) + e.y * Math.abs(s.y) + e.z * Math.abs(s.z), o = this.center.dot(s) + t.distance;
+    return o - i > 0 ? P.INSIDE : o + i < 0 ? P.OUTSIDE : P.INTERSECTING;
+  }
+  /** Computes the estimated distance from the closest point on a bounding box to a point. */
+  distanceTo(t) {
+    return Math.sqrt(this.distanceSquaredTo(t));
+  }
+  /** Computes the estimated distance squared from the closest point on a bounding box to a point. */
+  distanceSquaredTo(t) {
+    const e = Ht.from(t).subtract(this.center), { halfDiagonal: s } = this;
+    let i = 0, o;
+    return o = Math.abs(e.x) - s.x, o > 0 && (i += o * o), o = Math.abs(e.y) - s.y, o > 0 && (i += o * o), o = Math.abs(e.z) - s.z, o > 0 && (i += o * o), i;
+  }
+}
+const Y = new M(), Kt = new M();
+class It {
+  /** Creates a bounding sphere */
+  constructor(t = [0, 0, 0], e = 0) {
+    this.radius = -0, this.center = new M(), this.fromCenterRadius(t, e);
+  }
+  /** Sets the bounding sphere from `center` and `radius`. */
+  fromCenterRadius(t, e) {
+    return this.center.from(t), this.radius = e, this;
+  }
+  /**
+   * Computes a bounding sphere from the corner points of an axis-aligned bounding box.  The sphere
+   * tightly and fully encompasses the box.
+   */
+  fromCornerPoints(t, e) {
+    return e = Y.from(e), this.center = new M().from(t).add(e).scale(0.5), this.radius = this.center.distance(e), this;
+  }
+  /** Compares the provided BoundingSphere component wise */
+  equals(t) {
+    return this === t || !!t && this.center.equals(t.center) && this.radius === t.radius;
+  }
+  /** Duplicates a BoundingSphere instance. */
+  clone() {
+    return new It(this.center, this.radius);
+  }
+  /** Computes a bounding sphere that contains both the left and right bounding spheres. */
+  union(t) {
+    const e = this.center, s = this.radius, i = t.center, o = t.radius, r = Y.copy(i).subtract(e), a = r.magnitude();
+    if (s >= a + o)
+      return this.clone();
+    if (o >= a + s)
+      return t.clone();
+    const c = (s + a + o) * 0.5;
+    return Kt.copy(r).scale((-s + c) / a).add(e), this.center.copy(Kt), this.radius = c, this;
+  }
+  /** Computes a bounding sphere by enlarging the provided sphere to contain the provided point. */
+  expand(t) {
+    const s = Y.from(t).subtract(this.center).magnitude();
+    return s > this.radius && (this.radius = s), this;
+  }
+  // BoundingVolume interface
+  /**
+   * Applies a 4x4 affine transformation matrix to a bounding sphere.
+   * @param sphere The bounding sphere to apply the transformation to.
+   * @param transform The transformation matrix to apply to the bounding sphere.
+   * @returns self.
+   */
+  transform(t) {
+    this.center.transform(t);
+    const e = zs(Y, t);
+    return this.radius = Math.max(e[0], Math.max(e[1], e[2])) * this.radius, this;
+  }
+  /** Computes the estimated distance squared from the closest point on a bounding sphere to a point. */
+  distanceSquaredTo(t) {
+    const e = this.distanceTo(t);
+    return e * e;
+  }
+  /** Computes the estimated distance from the closest point on a bounding sphere to a point. */
+  distanceTo(t) {
+    const s = Y.from(t).subtract(this.center);
+    return Math.max(0, s.len() - this.radius);
+  }
+  /** Determines which side of a plane a sphere is located. */
+  intersectPlane(t) {
+    const e = this.center, s = this.radius, o = t.normal.dot(e) + t.distance;
+    return o < -s ? P.OUTSIDE : o < s ? P.INTERSECTING : P.INSIDE;
+  }
+}
+const In = new M(), An = new M(), H = new M(), K = new M(), Q = new M(), vn = new M(), On = new M(), O = {
+  COLUMN0ROW0: 0,
+  COLUMN0ROW1: 1,
+  COLUMN0ROW2: 2,
+  COLUMN1ROW0: 3,
+  COLUMN1ROW1: 4,
+  COLUMN1ROW2: 5,
+  COLUMN2ROW0: 6,
+  COLUMN2ROW1: 7,
+  COLUMN2ROW2: 8
+};
+class At {
+  constructor(t = [0, 0, 0], e = [0, 0, 0, 0, 0, 0, 0, 0, 0]) {
+    this.center = new M().from(t), this.halfAxes = new E(e);
+  }
+  /** Returns an array with three halfSizes for the bounding box */
+  get halfSize() {
+    const t = this.halfAxes.getColumn(0), e = this.halfAxes.getColumn(1), s = this.halfAxes.getColumn(2);
+    return [new M(t).len(), new M(e).len(), new M(s).len()];
+  }
+  /** Returns a quaternion describing the orientation of the bounding box */
+  get quaternion() {
+    const t = this.halfAxes.getColumn(0), e = this.halfAxes.getColumn(1), s = this.halfAxes.getColumn(2), i = new M(t).normalize(), o = new M(e).normalize(), r = new M(s).normalize();
+    return new Zt().fromMatrix3(new E([...i, ...o, ...r]));
+  }
+  /**
+   * Create OrientedBoundingBox from quaternion based OBB,
+   */
+  fromCenterHalfSizeQuaternion(t, e, s) {
+    const i = new Zt(s), o = new E().fromQuaternion(i);
+    return o[0] = o[0] * e[0], o[1] = o[1] * e[0], o[2] = o[2] * e[0], o[3] = o[3] * e[1], o[4] = o[4] * e[1], o[5] = o[5] * e[1], o[6] = o[6] * e[2], o[7] = o[7] * e[2], o[8] = o[8] * e[2], this.center = new M().from(t), this.halfAxes = o, this;
+  }
+  /** Duplicates a OrientedBoundingBox instance. */
+  clone() {
+    return new At(this.center, this.halfAxes);
+  }
+  /** Compares the provided OrientedBoundingBox component wise and returns */
+  equals(t) {
+    return this === t || !!t && this.center.equals(t.center) && this.halfAxes.equals(t.halfAxes);
+  }
+  /** Computes a tight-fitting bounding sphere enclosing the provided oriented bounding box. */
+  getBoundingSphere(t = new It()) {
+    const e = this.halfAxes, s = e.getColumn(0, H), i = e.getColumn(1, K), o = e.getColumn(2, Q), r = In.copy(s).add(i).add(o);
+    return t.center.copy(this.center), t.radius = r.magnitude(), t;
+  }
+  /** Determines which side of a plane the oriented bounding box is located. */
+  intersectPlane(t) {
+    const e = this.center, s = t.normal, i = this.halfAxes, o = s.x, r = s.y, a = s.z, c = Math.abs(o * i[O.COLUMN0ROW0] + r * i[O.COLUMN0ROW1] + a * i[O.COLUMN0ROW2]) + Math.abs(o * i[O.COLUMN1ROW0] + r * i[O.COLUMN1ROW1] + a * i[O.COLUMN1ROW2]) + Math.abs(o * i[O.COLUMN2ROW0] + r * i[O.COLUMN2ROW1] + a * i[O.COLUMN2ROW2]), h = s.dot(e) + t.distance;
+    return h <= -c ? P.OUTSIDE : h >= c ? P.INSIDE : P.INTERSECTING;
+  }
+  /** Computes the estimated distance from the closest point on a bounding box to a point. */
+  distanceTo(t) {
+    return Math.sqrt(this.distanceSquaredTo(t));
+  }
+  /**
+   * Computes the estimated distance squared from the closest point
+   * on a bounding box to a point.
+   * See Geometric Tools for Computer Graphics 10.4.2
+   */
+  distanceSquaredTo(t) {
+    const e = An.from(t).subtract(this.center), s = this.halfAxes, i = s.getColumn(0, H), o = s.getColumn(1, K), r = s.getColumn(2, Q), a = i.magnitude(), c = o.magnitude(), h = r.magnitude();
+    i.normalize(), o.normalize(), r.normalize();
+    let u = 0, l;
+    return l = Math.abs(e.dot(i)) - a, l > 0 && (u += l * l), l = Math.abs(e.dot(o)) - c, l > 0 && (u += l * l), l = Math.abs(e.dot(r)) - h, l > 0 && (u += l * l), u;
+  }
+  /**
+   * The distances calculated by the vector from the center of the bounding box
+   * to position projected onto direction.
+   *
+   * - If you imagine the infinite number of planes with normal direction,
+   *   this computes the smallest distance to the closest and farthest planes
+   *   from `position` that intersect the bounding box.
+   *
+   * @param position The position to calculate the distance from.
+   * @param direction The direction from position.
+   * @param result An Interval (array of length 2) to store the nearest and farthest distances.
+   * @returns Interval (array of length 2) with nearest and farthest distances
+   *   on the bounding box from position in direction.
+   */
+  // eslint-disable-next-line max-statements
+  computePlaneDistances(t, e, s = [-0, -0]) {
+    let i = Number.POSITIVE_INFINITY, o = Number.NEGATIVE_INFINITY;
+    const r = this.center, a = this.halfAxes, c = a.getColumn(0, H), h = a.getColumn(1, K), u = a.getColumn(2, Q), l = vn.copy(c).add(h).add(u).add(r), d = On.copy(l).subtract(t);
+    let f = e.dot(d);
+    return i = Math.min(f, i), o = Math.max(f, o), l.copy(r).add(c).add(h).subtract(u), d.copy(l).subtract(t), f = e.dot(d), i = Math.min(f, i), o = Math.max(f, o), l.copy(r).add(c).subtract(h).add(u), d.copy(l).subtract(t), f = e.dot(d), i = Math.min(f, i), o = Math.max(f, o), l.copy(r).add(c).subtract(h).subtract(u), d.copy(l).subtract(t), f = e.dot(d), i = Math.min(f, i), o = Math.max(f, o), r.copy(l).subtract(c).add(h).add(u), d.copy(l).subtract(t), f = e.dot(d), i = Math.min(f, i), o = Math.max(f, o), r.copy(l).subtract(c).add(h).subtract(u), d.copy(l).subtract(t), f = e.dot(d), i = Math.min(f, i), o = Math.max(f, o), r.copy(l).subtract(c).subtract(h).add(u), d.copy(l).subtract(t), f = e.dot(d), i = Math.min(f, i), o = Math.max(f, o), r.copy(l).subtract(c).subtract(h).subtract(u), d.copy(l).subtract(t), f = e.dot(d), i = Math.min(f, i), o = Math.max(f, o), s[0] = i, s[1] = o, s;
+  }
+  /**
+   * Applies a 4x4 affine transformation matrix to a bounding sphere.
+   * @param transform The transformation matrix to apply to the bounding sphere.
+   * @returns itself, i.e. the modified BoundingVolume.
+   */
+  transform(t) {
+    this.center.transformAsPoint(t);
+    const e = this.halfAxes.getColumn(0, H);
+    e.transformAsPoint(t);
+    const s = this.halfAxes.getColumn(1, K);
+    s.transformAsPoint(t);
+    const i = this.halfAxes.getColumn(2, Q);
+    return i.transformAsPoint(t), this.halfAxes = new E([...e, ...s, ...i]), this;
+  }
+  getTransform() {
+    throw new Error("not implemented");
+  }
+}
+const Qt = new M(), Jt = new M();
+class W {
+  constructor(t = [0, 0, 1], e = 0) {
+    this.normal = new M(), this.distance = -0, this.fromNormalDistance(t, e);
+  }
+  /** Creates a plane from a normal and a distance from the origin. */
+  fromNormalDistance(t, e) {
+    return xt(Number.isFinite(e)), this.normal.from(t).normalize(), this.distance = e, this;
+  }
+  /** Creates a plane from a normal and a point on the plane. */
+  fromPointNormal(t, e) {
+    t = Qt.from(t), this.normal.from(e).normalize();
+    const s = -this.normal.dot(t);
+    return this.distance = s, this;
+  }
+  /** Creates a plane from the general equation */
+  fromCoefficients(t, e, s, i) {
+    return this.normal.set(t, e, s), xt(st(this.normal.len(), 1)), this.distance = i, this;
+  }
+  /** Duplicates a Plane instance. */
+  clone() {
+    return new W(this.normal, this.distance);
+  }
+  /** Compares the provided Planes by normal and distance */
+  equals(t) {
+    return st(this.distance, t.distance) && st(this.normal, t.normal);
+  }
+  /** Computes the signed shortest distance of a point to a plane.
+   * The sign of the distance determines which side of the plane the point is on.
+   */
+  getPointDistance(t) {
+    return this.normal.dot(t) + this.distance;
+  }
+  /** Transforms the plane by the given transformation matrix. */
+  transform(t) {
+    const e = Jt.copy(this.normal).transformAsVector(t).normalize(), s = this.normal.scale(-this.distance).transform(t);
+    return this.fromPointNormal(s, e);
+  }
+  projectPointOntoPlane(t, e = [0, 0, 0]) {
+    const s = Qt.from(t), i = this.getPointDistance(s), o = Jt.copy(this.normal).scale(i);
+    return s.subtract(o).to(e);
+  }
+}
+const te = [new M([1, 0, 0]), new M([0, 1, 0]), new M([0, 0, 1])], ee = new M(), zn = new M();
+class v {
+  /**
+   * Create a new `CullingVolume` bounded by an array of clipping planed
+   * @param planes Array of clipping planes.
+   * */
+  constructor(t = []) {
+    this.planes = t;
+  }
+  /**
+   * Constructs a culling volume from a bounding sphere. Creates six planes that create a box containing the sphere.
+   * The planes are aligned to the x, y, and z axes in world coordinates.
+   */
+  fromBoundingSphere(t) {
+    this.planes.length = 2 * te.length;
+    const e = t.center, s = t.radius;
+    let i = 0;
+    for (const o of te) {
+      let r = this.planes[i], a = this.planes[i + 1];
+      r || (r = this.planes[i] = new W()), a || (a = this.planes[i + 1] = new W());
+      const c = ee.copy(o).scale(-s).add(e);
+      r.fromPointNormal(c, o);
+      const h = ee.copy(o).scale(s).add(e), u = zn.copy(o).negate();
+      a.fromPointNormal(h, u), i += 2;
+    }
+    return this;
+  }
+  /** Determines whether a bounding volume intersects the culling volume. */
+  computeVisibility(t) {
+    let e = P.INSIDE;
+    for (const s of this.planes)
+      switch (t.intersectPlane(s)) {
+        case P.OUTSIDE:
+          return P.OUTSIDE;
+        case P.INTERSECTING:
+          e = P.INTERSECTING;
+          break;
+      }
+    return e;
+  }
+  /**
+   * Determines whether a bounding volume intersects the culling volume.
+   *
+   * @param parentPlaneMask A bit mask from the boundingVolume's parent's check against the same culling
+   *   volume, such that if (planeMask & (1 << planeIndex) === 0), for k < 31, then
+   *   the parent (and therefore this) volume is completely inside plane[planeIndex]
+   *   and that plane check can be skipped.
+   */
+  computeVisibilityWithPlaneMask(t, e) {
+    if (xt(Number.isFinite(e), "parentPlaneMask is required."), e === v.MASK_OUTSIDE || e === v.MASK_INSIDE)
+      return e;
+    let s = v.MASK_INSIDE;
+    const i = this.planes;
+    for (let o = 0; o < this.planes.length; ++o) {
+      const r = o < 31 ? 1 << o : 0;
+      if (o < 31 && (e & r) === 0)
+        continue;
+      const a = i[o], c = t.intersectPlane(a);
+      if (c === P.OUTSIDE)
+        return v.MASK_OUTSIDE;
+      c === P.INTERSECTING && (s |= r);
+    }
+    return s;
+  }
+}
+v.MASK_OUTSIDE = 4294967295;
+v.MASK_INSIDE = 0;
+v.MASK_INDETERMINATE = 2147483647;
+new M();
+new M();
+new M();
+new M();
+new M();
+new M();
+new M();
+new M();
+new M();
+new M();
+new M();
+new M();
+new M();
+new M();
+new M();
+new M();
+new M();
+const A = new E(), Nn = new E(), Fn = new E(), J = new E(), se = new E();
+function qn(n, t = {}) {
+  const e = Cn, s = 10;
+  let i = 0, o = 0;
+  const r = Nn, a = Fn;
+  r.identity(), a.copy(n);
+  const c = e * Bn(a);
+  for (; o < s && Gn(a) > c; )
+    Dn(a, J), se.copy(J).transpose(), a.multiplyRight(J), a.multiplyLeft(se), r.multiplyRight(J), ++i > 2 && (++o, i = 0);
+  return t.unitary = r.toTarget(t.unitary), t.diagonal = a.toTarget(t.diagonal), t;
+}
+function Bn(n) {
+  let t = 0;
+  for (let e = 0; e < 9; ++e) {
+    const s = n[e];
+    t += s * s;
+  }
+  return Math.sqrt(t);
+}
+const wt = [1, 0, 0], Tt = [2, 2, 1];
+function Gn(n) {
+  let t = 0;
+  for (let e = 0; e < 3; ++e) {
+    const s = n[A.getElementIndex(Tt[e], wt[e])];
+    t += 2 * s * s;
+  }
+  return Math.sqrt(t);
+}
+function Dn(n, t) {
+  const e = Sn;
+  let s = 0, i = 1;
+  for (let h = 0; h < 3; ++h) {
+    const u = Math.abs(n[A.getElementIndex(Tt[h], wt[h])]);
+    u > s && (i = h, s = u);
+  }
+  const o = wt[i], r = Tt[i];
+  let a = 1, c = 0;
+  if (Math.abs(n[A.getElementIndex(r, o)]) > e) {
+    const h = n[A.getElementIndex(r, r)], u = n[A.getElementIndex(o, o)], l = n[A.getElementIndex(r, o)], d = (h - u) / 2 / l;
+    let f;
+    d < 0 ? f = -1 / (-d + Math.sqrt(1 + d * d)) : f = 1 / (d + Math.sqrt(1 + d * d)), a = 1 / Math.sqrt(1 + f * f), c = f * a;
+  }
+  return E.IDENTITY.to(t), t[A.getElementIndex(o, o)] = t[A.getElementIndex(r, r)] = a, t[A.getElementIndex(r, o)] = c, t[A.getElementIndex(o, r)] = -c, t;
+}
+const N = new M(), Un = new M(), Wn = new M(), Vn = new M(), kn = new M(), jn = new E(), Yn = {
+  diagonal: new E(),
+  unitary: new E()
+};
+function Ae(n, t = new At()) {
+  if (!n || n.length === 0)
+    return t.halfAxes = new E([0, 0, 0, 0, 0, 0, 0, 0, 0]), t.center = new M(), t;
+  const e = n.length, s = new M(0, 0, 0);
+  for (const b of n)
+    s.add(b);
+  const i = 1 / e;
+  s.multiplyByScalar(i);
+  let o = 0, r = 0, a = 0, c = 0, h = 0, u = 0;
+  for (const b of n) {
+    const C = N.copy(b).subtract(s);
+    o += C.x * C.x, r += C.x * C.y, a += C.x * C.z, c += C.y * C.y, h += C.y * C.z, u += C.z * C.z;
+  }
+  o *= i, r *= i, a *= i, c *= i, h *= i, u *= i;
+  const l = jn;
+  l[0] = o, l[1] = r, l[2] = a, l[3] = r, l[4] = c, l[5] = h, l[6] = a, l[7] = h, l[8] = u;
+  const { unitary: d } = qn(l, Yn), f = t.halfAxes.copy(d);
+  let m = f.getColumn(0, Wn), p = f.getColumn(1, Vn), g = f.getColumn(2, kn), y = -Number.MAX_VALUE, _ = -Number.MAX_VALUE, x = -Number.MAX_VALUE, w = Number.MAX_VALUE, T = Number.MAX_VALUE, S = Number.MAX_VALUE;
+  for (const b of n)
+    N.copy(b), y = Math.max(N.dot(m), y), _ = Math.max(N.dot(p), _), x = Math.max(N.dot(g), x), w = Math.min(N.dot(m), w), T = Math.min(N.dot(p), T), S = Math.min(N.dot(g), S);
+  m = m.multiplyByScalar(0.5 * (w + y)), p = p.multiplyByScalar(0.5 * (T + _)), g = g.multiplyByScalar(0.5 * (S + x)), t.center.copy(m).add(p).add(g);
+  const L = Un.set(y - w, _ - T, x - S).multiplyByScalar(0.5), I = new E([L[0], 0, 0, 0, L[1], 0, 0, 0, L[2]]);
+  return t.halfAxes.multiplyRight(I), t;
+}
+const D = 512, ne = 3, ve = [
+  [0.5, 0.5],
+  [0, 0],
+  [0, 1],
+  [1, 0],
+  [1, 1]
+], Oe = ve.concat([
+  [0, 0.5],
+  [0.5, 0],
+  [1, 0.5],
+  [0.5, 1]
+]), $n = Oe.concat([
+  [0.25, 0.5],
+  [0.75, 0.5]
+]);
+class U {
+  constructor(t, e, s) {
+    this.x = t, this.y = e, this.z = s;
+  }
+  get children() {
+    if (!this._children) {
+      const t = this.x * 2, e = this.y * 2, s = this.z + 1;
+      this._children = [
+        new U(t, e, s),
+        new U(t, e + 1, s),
+        new U(t + 1, e, s),
+        new U(t + 1, e + 1, s)
+      ];
+    }
+    return this._children;
+  }
+  // eslint-disable-next-line complexity
+  update(t) {
+    const { viewport: e, cullingVolume: s, elevationBounds: i, minZ: o, maxZ: r, bounds: a, offset: c, project: h } = t, u = this.getBoundingVolume(i, c, h);
+    if (a && !this.insideBounds(a) || s.computeVisibility(u) < 0)
+      return !1;
+    if (!this.childVisible) {
+      let { z: d } = this;
+      if (d < r && d >= o) {
+        const f = u.distanceTo(e.cameraPosition) * e.scale / e.height;
+        d += Math.floor(Math.log2(f));
+      }
+      if (d >= r)
+        return this.selected = !0, !0;
+    }
+    this.selected = !1, this.childVisible = !0;
+    for (const d of this.children)
+      d.update(t);
+    return !0;
+  }
+  getSelected(t = []) {
+    if (this.selected && t.push(this), this._children)
+      for (const e of this._children)
+        e.getSelected(t);
+    return t;
+  }
+  insideBounds([t, e, s, i]) {
+    const o = Math.pow(2, this.z), r = D / o;
+    return this.x * r < s && this.y * r < i && (this.x + 1) * r > t && (this.y + 1) * r > e;
+  }
+  getBoundingVolume(t, e, s) {
+    if (s) {
+      const c = this.z < 1 ? $n : this.z < 2 ? Oe : ve, h = [];
+      for (const u of c) {
+        const l = St(this.x + u[0], this.y + u[1], this.z);
+        l[2] = t[0], h.push(s(l)), t[0] !== t[1] && (l[2] = t[1], h.push(s(l)));
+      }
+      return Ae(h);
+    }
+    const i = Math.pow(2, this.z), o = D / i, r = this.x * o + e * D, a = D - (this.y + 1) * o;
+    return new Rt([r, a, t[0]], [r + o, a + o, t[1]]);
+  }
+}
+function Xn(n, t, e, s) {
+  const i = n instanceof Ce && n.resolution ? (
+    // eslint-disable-next-line @typescript-eslint/unbound-method
+    n.projectPosition
+  ) : null, o = Object.values(n.getFrustumPlanes()).map(({ normal: f, distance: m }) => new W(f.clone().negate(), m)), r = new v(o), a = n.distanceScales.unitsPerMeter[2], c = e && e[0] * a || 0, h = e && e[1] * a || 0, u = n instanceof kt && n.pitch <= 60 ? t : 0;
+  if (s) {
+    const [f, m, p, g] = s, y = ot([f, g]), _ = ot([p, m]);
+    s = [y[0], D - y[1], _[0], D - _[1]];
+  }
+  const l = new U(0, 0, 0), d = {
+    viewport: n,
+    project: i,
+    cullingVolume: r,
+    elevationBounds: [c, h],
+    minZ: u,
+    maxZ: t,
+    bounds: s,
+    // num. of worlds from the center. For repeated maps
+    offset: 0
+  };
+  if (l.update(d), n instanceof kt && n.subViewports && n.subViewports.length > 1) {
+    for (d.offset = -1; l.update(d) && !(--d.offset < -ne); )
+      ;
+    for (d.offset = 1; l.update(d) && !(++d.offset > ne); )
+      ;
+  }
+  return l.getSelected();
+}
+const z = 512, Zn = [-1 / 0, -1 / 0, 1 / 0, 1 / 0], Hn = {
+  equal: (n, t) => {
+    if (n === t)
+      return !0;
+    if (!Array.isArray(n) || !Array.isArray(t))
+      return !1;
+    const e = n.length;
+    if (e !== t.length)
+      return !1;
+    for (let s = 0; s < e; s++)
+      if (n[s] !== t[s])
+        return !1;
+    return !0;
+  }
+};
+function vt(n, t) {
+  const e = [
+    // top-left
+    t.transformAsPoint([n[0], n[1]]),
+    // top-right
+    t.transformAsPoint([n[2], n[1]]),
+    // bottom-left
+    t.transformAsPoint([n[0], n[3]]),
+    // bottom-right
+    t.transformAsPoint([n[2], n[3]])
+  ];
+  return [
+    // Minimum x coord
+    Math.min(...e.map((i) => i[0])),
+    // Minimum y coord
+    Math.min(...e.map((i) => i[1])),
+    // Max x coord
+    Math.max(...e.map((i) => i[0])),
+    // Max y coord
+    Math.max(...e.map((i) => i[1]))
+  ];
+}
+function Kn(n) {
+  return Math.abs(n.split("").reduce((t, e) => (t << 5) - t + e.charCodeAt(0) | 0, 0));
+}
+function Qn(n, t) {
+  if (!n || !n.length)
+    return null;
+  const { index: e, id: s } = t;
+  if (Array.isArray(n)) {
+    const o = Kn(s) % n.length;
+    n = n[o];
+  }
+  let i = n;
+  for (const o of Object.keys(e)) {
+    const r = new RegExp(`{${o}}`, "g");
+    i = i.replace(r, String(e[o]));
+  }
+  return Number.isInteger(e.y) && Number.isInteger(e.z) && (i = i.replace(/\{-y\}/g, String(Math.pow(2, e.z) - e.y - 1))), i;
+}
+function Jn(n, t, e) {
+  let s;
+  return s = n.getBounds(), n.isGeospatial ? [
+    Math.max(s[0], e[0]),
+    Math.max(s[1], e[1]),
+    Math.min(s[2], e[2]),
+    Math.min(s[3], e[3])
+  ] : [
+    // Top corner should not be more then bottom corner in either direction
+    Math.max(Math.min(s[0], e[2]), e[0]),
+    Math.max(Math.min(s[1], e[3]), e[1]),
+    // Bottom corner should not be less then top corner in either direction
+    Math.min(Math.max(s[2], e[0]), e[2]),
+    Math.min(Math.max(s[3], e[1]), e[3])
+  ];
+}
+function ti({ viewport: n, z: t, cullRect: e }) {
+  return (n.subViewports || [n]).map((i) => bt(i, t || 0, e));
+}
+function bt(n, t, e) {
+  if (!Array.isArray(t)) {
+    const o = e.x - n.x, r = e.y - n.y, { width: a, height: c } = e, h = { targetZ: t }, u = n.unproject([o, r], h), l = n.unproject([o + a, r], h), d = n.unproject([o, r + c], h), f = n.unproject([o + a, r + c], h);
+    return [
+      Math.min(u[0], l[0], d[0], f[0]),
+      Math.min(u[1], l[1], d[1], f[1]),
+      Math.max(u[0], l[0], d[0], f[0]),
+      Math.max(u[1], l[1], d[1], f[1])
+    ];
+  }
+  const s = bt(n, t[0], e), i = bt(n, t[1], e);
+  return [
+    Math.min(s[0], i[0]),
+    Math.min(s[1], i[1]),
+    Math.max(s[2], i[2]),
+    Math.max(s[3], i[3])
+  ];
+}
+function ei(n, t, e) {
+  return e ? vt(n, e).map((i) => i * t / z) : n.map((s) => s * t / z);
+}
+function Ot(n, t) {
+  return Math.pow(2, n) * z / t;
+}
+function St(n, t, e) {
+  const s = Ot(e, z), i = n / s * 360 - 180, o = Math.PI - 2 * Math.PI * t / s, r = 180 / Math.PI * Math.atan(0.5 * (Math.exp(o) - Math.exp(-o)));
+  return [i, r];
+}
+function ie(n, t, e, s) {
+  const i = Ot(e, s);
+  return [n / i * z, t / i * z];
+}
+function si(n, t, e, s, i = z) {
+  if (n.isGeospatial) {
+    const [h, u] = St(t, e, s), [l, d] = St(t + 1, e + 1, s);
+    return { west: h, north: u, east: l, south: d };
+  }
+  const [o, r] = ie(t, e, s, i), [a, c] = ie(t + 1, e + 1, s, i);
+  return { left: o, top: r, right: a, bottom: c };
+}
+function ni(n, t, e, s, i) {
+  const o = Jn(n, null, s), r = Ot(t, e), [a, c, h, u] = ei(o, r, i), l = [];
+  for (let d = Math.floor(a); d < h; d++)
+    for (let f = Math.floor(c); f < u; f++)
+      l.push({ x: d, y: f, z: t });
+  return l;
+}
+function ii({ viewport: n, maxZoom: t, minZoom: e, zRange: s, extent: i, tileSize: o = z, modelMatrix: r, modelMatrixInverse: a, zoomOffset: c = 0 }) {
+  let h = n.isGeospatial ? Math.round(n.zoom + Math.log2(z / o)) + c : Math.ceil(n.zoom) + c;
+  if (typeof e == "number" && Number.isFinite(e) && h < e) {
+    if (!i)
+      return [];
+    h = e;
+  }
+  typeof t == "number" && Number.isFinite(t) && h > t && (h = t);
+  let u = i;
+  return r && a && i && !n.isGeospatial && (u = vt(i, r)), n.isGeospatial ? Xn(n, h, s, i) : ni(n, h, o, u || Zn, a);
+}
+function oi(n) {
+  let t = {}, e;
+  return (s) => {
+    for (const i in s)
+      if (!ri(s[i], t[i])) {
+        e = n(s), t = s;
+        break;
+      }
+    return e;
+  };
+}
+function ri(n, t) {
+  if (n === t)
+    return !0;
+  if (Array.isArray(n)) {
+    const e = n.length;
+    if (!t || t.length !== e)
+      return !1;
+    for (let s = 0; s < e; s++)
+      if (n[s] !== t[s])
+        return !1;
+    return !0;
+  }
+  return !1;
+}
+const oe = 1, at = 2, ai = "never", ci = "no-overlap", zt = "best-available", li = 5, hi = {
+  [zt]: di,
+  [ci]: fi,
+  [ai]: () => {
+  }
+}, ui = {
+  extent: null,
+  tileSize: 512,
+  maxZoom: null,
+  minZoom: null,
+  maxCacheSize: null,
+  maxCacheByteSize: null,
+  refinementStrategy: "best-available",
+  zRange: null,
+  maxRequests: 6,
+  debounceTime: 0,
+  zoomOffset: 0,
+  // onTileLoad: (tile: Tile2DHeader) => void,  // onTileUnload: (tile: Tile2DHeader) => void,  // onTileError: (error: any, tile: Tile2DHeader) => void,  /** Called when all tiles in the current viewport are loaded. */
+  // onViewportLoad: ((tiles: Tile2DHeader<DataT>[]) => void) | null,
+  onTileLoad: () => {
+  },
+  onTileUnload: () => {
+  },
+  onTileError: () => {
+  }
+};
+class Nt {
+  /**
+   * Takes in a function that returns tile data, a cache size, and a max and a min zoom level.
+   * Cache size defaults to 5 * number of tiles in the current viewport
+   */
+  constructor(t) {
+    this._getCullBounds = oi(ti), this.opts = { ...ui, ...t }, this.setOptions(this.opts), this.onTileLoad = (e) => {
+      this.opts.onTileLoad?.(e), this.opts.maxCacheByteSize !== null && (this._cacheByteSize += e.byteLength, this._resizeCache());
+    }, this._requestScheduler = new Hs({
+      throttleRequests: this.opts.maxRequests > 0 || this.opts.debounceTime > 0,
+      maxRequests: this.opts.maxRequests,
+      debounceTime: this.opts.debounceTime
+    }), this._cache = /* @__PURE__ */ new Map(), this._tiles = [], this._dirty = !1, this._cacheByteSize = 0, this._viewport = null, this._zRange = null, this._selectedTiles = null, this._frameNumber = 0, this._modelMatrix = new G(), this._modelMatrixInverse = new G();
+  }
+  /* Public API */
+  get tiles() {
+    return this._tiles;
+  }
+  get selectedTiles() {
+    return this._selectedTiles;
+  }
+  get isLoaded() {
+    return this._selectedTiles !== null && this._selectedTiles.every((t) => t.isLoaded);
+  }
+  get needsReload() {
+    return this._selectedTiles !== null && this._selectedTiles.some((t) => t.needsReload);
+  }
+  setOptions(t) {
+    Object.assign(this.opts, t), Number.isFinite(t.maxZoom) && (this._maxZoom = Math.floor(t.maxZoom)), Number.isFinite(t.minZoom) && (this._minZoom = Math.ceil(t.minZoom));
+  }
+  // Clean up any outstanding tile requests.
+  finalize() {
+    for (const t of this._cache.values())
+      t.isLoading && t.abort();
+    this._cache.clear(), this._tiles = [], this._selectedTiles = null;
+  }
+  reloadAll() {
+    for (const t of this._cache.keys()) {
+      const e = this._cache.get(t);
+      !this._selectedTiles || !this._selectedTiles.includes(e) ? this._cache.delete(t) : e.setNeedsReload();
+    }
+  }
+  /**
+   * Update the cache with the given viewport and model matrix and triggers callback onUpdate.
+   */
+  update(t, { zRange: e, modelMatrix: s } = {
+    zRange: null,
+    modelMatrix: null
+  }) {
+    const i = s ? new G(s) : new G(), o = !i.equals(this._modelMatrix);
+    if (!this._viewport || !t.equals(this._viewport) || !st(this._zRange, e) || o) {
+      o && (this._modelMatrixInverse = i.clone().invert(), this._modelMatrix = i), this._viewport = t, this._zRange = e;
+      const a = this.getTileIndices({
+        viewport: t,
+        maxZoom: this._maxZoom,
+        minZoom: this._minZoom,
+        zRange: e,
+        modelMatrix: this._modelMatrix,
+        modelMatrixInverse: this._modelMatrixInverse
+      });
+      this._selectedTiles = a.map((c) => this._getTile(c, !0)), this._dirty && this._rebuildTree();
+    } else this.needsReload && (this._selectedTiles = this._selectedTiles.map((a) => this._getTile(a.index, !0)));
+    const r = this.updateTileStates();
+    return this._pruneRequests(), this._dirty && this._resizeCache(), r && this._frameNumber++, this._frameNumber;
+  }
+  // eslint-disable-next-line complexity
+  isTileVisible(t, e, s) {
+    if (!t.isVisible)
+      return !1;
+    if (e && this._viewport) {
+      const i = this._getCullBounds({
+        viewport: this._viewport,
+        z: this._zRange,
+        cullRect: e
+      });
+      let { bbox: o } = t;
+      for (const [r, a, c, h] of i) {
+        let u;
+        if ("west" in o)
+          u = o.west < c && o.east > r && o.south < h && o.north > a;
+        else {
+          if (s && !G.IDENTITY.equals(s)) {
+            const [f, m, p, g] = vt([o.left, o.top, o.right, o.bottom], s);
+            o = { left: f, top: m, right: p, bottom: g };
+          }
+          const l = Math.min(o.top, o.bottom), d = Math.max(o.top, o.bottom);
+          u = o.left < c && o.right > r && l < h && d > a;
+        }
+        if (u)
+          return !0;
+      }
+      return !1;
+    }
+    return !0;
+  }
+  /* Public interface for subclassing */
+  /** Returns array of tile indices in the current viewport */
+  getTileIndices({ viewport: t, maxZoom: e, minZoom: s, zRange: i, modelMatrix: o, modelMatrixInverse: r }) {
+    const { tileSize: a, extent: c, zoomOffset: h } = this.opts;
+    return ii({
+      viewport: t,
+      maxZoom: e,
+      minZoom: s,
+      zRange: i,
+      tileSize: a,
+      extent: c,
+      modelMatrix: o,
+      modelMatrixInverse: r,
+      zoomOffset: h
+    });
+  }
+  /** Returns unique string key for a tile index */
+  getTileId(t) {
+    return `${t.x}-${t.y}-${t.z}`;
+  }
+  /** Returns a zoom level for a tile index */
+  getTileZoom(t) {
+    return t.z;
+  }
+  /** Returns additional metadata to add to tile, bbox by default */
+  getTileMetadata(t) {
+    const { tileSize: e } = this.opts;
+    return { bbox: si(this._viewport, t.x, t.y, t.z, e) };
+  }
+  /** Returns index of the parent tile */
+  getParentIndex(t) {
+    const e = Math.floor(t.x / 2), s = Math.floor(t.y / 2), i = t.z - 1;
+    return { x: e, y: s, z: i };
+  }
+  // Returns true if any tile's visibility changed
+  updateTileStates() {
+    const t = this.opts.refinementStrategy || zt, e = new Array(this._cache.size);
+    let s = 0;
+    for (const i of this._cache.values())
+      e[s++] = i.isVisible, i.isSelected = !1, i.isVisible = !1;
+    for (const i of this._selectedTiles)
+      i.isSelected = !0, i.isVisible = !0;
+    (typeof t == "function" ? t : hi[t])(Array.from(this._cache.values())), s = 0;
+    for (const i of this._cache.values())
+      if (e[s++] !== i.isVisible)
+        return !0;
+    return !1;
+  }
+  _pruneRequests() {
+    const { maxRequests: t = 0 } = this.opts, e = [];
+    let s = 0;
+    for (const i of this._cache.values())
+      i.isLoading && (s++, !i.isSelected && !i.isVisible && e.push(i));
+    for (; t > 0 && s > t && e.length > 0; )
+      e.shift().abort(), s--;
+  }
+  // This needs to be called every time some tiles have been added/removed from cache
+  _rebuildTree() {
+    const { _cache: t } = this;
+    for (const e of t.values())
+      e.parent = null, e.children && (e.children.length = 0);
+    for (const e of t.values()) {
+      const s = this._getNearestAncestor(e);
+      e.parent = s, s?.children && s.children.push(e);
+    }
+  }
+  /**
+   * Clear tiles that are not visible when the cache is full
+   */
+  /* eslint-disable complexity */
+  _resizeCache() {
+    const { _cache: t, opts: e } = this, s = e.maxCacheSize ?? // @ts-expect-error called only when selectedTiles is initialized
+    (e.maxCacheByteSize !== null ? 1 / 0 : li * this.selectedTiles.length), i = e.maxCacheByteSize ?? 1 / 0;
+    if (t.size > s || this._cacheByteSize > i) {
+      for (const [r, a] of t)
+        if (!a.isVisible && !a.isSelected && (this._cacheByteSize -= e.maxCacheByteSize !== null ? a.byteLength : 0, t.delete(r), this.opts.onTileUnload?.(a)), t.size <= s && this._cacheByteSize <= i)
+          break;
+      this._rebuildTree(), this._dirty = !0;
+    }
+    this._dirty && (this._tiles = Array.from(this._cache.values()).sort((r, a) => r.zoom - a.zoom), this._dirty = !1);
+  }
+  _getTile(t, e) {
+    const s = this.getTileId(t);
+    let i = this._cache.get(s), o = !1;
+    return !i && e ? (i = new Pn(t), Object.assign(i, this.getTileMetadata(i.index)), Object.assign(i, { id: s, zoom: this.getTileZoom(i.index) }), o = !0, this._cache.set(s, i), this._dirty = !0) : i && i.needsReload && (o = !0), i && o && i.loadData({
+      getData: this.opts.getTileData,
+      requestScheduler: this._requestScheduler,
+      onLoad: this.onTileLoad,
+      onError: this.opts.onTileError
+    }), i;
+  }
+  _getNearestAncestor(t) {
+    const { _minZoom: e = 0 } = this;
+    let s = t.index;
+    for (; this.getTileZoom(s) > e; ) {
+      s = this.getParentIndex(s);
+      const i = this._getTile(s);
+      if (i)
+        return i;
+    }
+    return null;
+  }
+}
+function di(n) {
+  for (const t of n)
+    t.state = 0;
+  for (const t of n)
+    t.isSelected && !ze(t) && Ft(t);
+  for (const t of n)
+    t.isVisible = !!(t.state & at);
+}
+function fi(n) {
+  for (const e of n)
+    e.state = 0;
+  for (const e of n)
+    e.isSelected && ze(e);
+  const t = Array.from(n).sort((e, s) => e.zoom - s.zoom);
+  for (const e of t)
+    if (e.isVisible = !!(e.state & at), e.children && (e.isVisible || e.state & oe))
+      for (const s of e.children)
+        s.state = oe;
+    else e.isSelected && Ft(e);
+}
+function ze(n) {
+  let t = n;
+  for (; t; ) {
+    if (t.isLoaded || t.content)
+      return t.state |= at, !0;
+    t = t.parent;
+  }
+  return !1;
+}
+function Ft(n) {
+  for (const t of n.children)
+    t.isLoaded || t.content ? t.state |= at : Ft(t);
+}
+const mi = {
+  TilesetClass: Nt,
+  data: { type: "data", value: [] },
+  dataComparator: Hn.equal,
+  renderSubLayers: { type: "function", value: (n) => new Fs(n) },
+  getTileData: { type: "function", optional: !0, value: null },
+  // TODO - change to onViewportLoad to align with Tile3DLayer
+  onViewportLoad: { type: "function", optional: !0, value: null },
+  onTileLoad: { type: "function", value: (n) => {
+  } },
+  onTileUnload: { type: "function", value: (n) => {
+  } },
+  // eslint-disable-next-line
+  onTileError: { type: "function", value: (n) => console.error(n) },
+  extent: { type: "array", optional: !0, value: null, compare: !0 },
+  tileSize: 512,
+  maxZoom: null,
+  minZoom: 0,
+  maxCacheSize: null,
+  maxCacheByteSize: null,
+  refinementStrategy: zt,
+  zRange: null,
+  maxRequests: 6,
+  debounceTime: 0,
+  zoomOffset: 0
+};
+class ct extends V {
+  initializeState() {
+    this.state = {
+      tileset: null,
+      isLoaded: !1
+    };
+  }
+  finalizeState() {
+    this.state?.tileset?.finalize();
+  }
+  get isLoaded() {
+    return !!this.state?.tileset?.selectedTiles?.every((t) => t.isLoaded && t.layers && t.layers.every((e) => e.isLoaded));
+  }
+  shouldUpdateState({ changeFlags: t }) {
+    return t.somethingChanged;
+  }
+  updateState({ changeFlags: t }) {
+    let { tileset: e } = this.state;
+    const s = t.propsOrDataChanged || t.updateTriggersChanged, i = t.dataChanged || t.updateTriggersChanged && (t.updateTriggersChanged.all || t.updateTriggersChanged.getTileData);
+    e ? s && (e.setOptions(this._getTilesetOptions()), i ? e.reloadAll() : e.tiles.forEach((o) => {
+      o.layers = null;
+    })) : (e = new this.props.TilesetClass(this._getTilesetOptions()), this.setState({ tileset: e })), this._updateTileset();
+  }
+  _getTilesetOptions() {
+    const { tileSize: t, maxCacheSize: e, maxCacheByteSize: s, refinementStrategy: i, extent: o, maxZoom: r, minZoom: a, maxRequests: c, debounceTime: h, zoomOffset: u } = this.props;
+    return {
+      maxCacheSize: e,
+      maxCacheByteSize: s,
+      maxZoom: r,
+      minZoom: a,
+      tileSize: t,
+      refinementStrategy: i,
+      extent: o,
+      maxRequests: c,
+      debounceTime: h,
+      zoomOffset: u,
+      getTileData: this.getTileData.bind(this),
+      onTileLoad: this._onTileLoad.bind(this),
+      onTileError: this._onTileError.bind(this),
+      onTileUnload: this._onTileUnload.bind(this)
+    };
+  }
+  _updateTileset() {
+    const t = this.state.tileset, { zRange: e, modelMatrix: s } = this.props, i = t.update(this.context.viewport, { zRange: e, modelMatrix: s }), { isLoaded: o } = t, r = this.state.isLoaded !== o, a = this.state.frameNumber !== i;
+    o && (r || a) && this._onViewportLoad(), a && this.setState({ frameNumber: i }), this.state.isLoaded = o;
+  }
+  _onViewportLoad() {
+    const { tileset: t } = this.state, { onViewportLoad: e } = this.props;
+    e && e(t.selectedTiles);
+  }
+  _onTileLoad(t) {
+    this.props.onTileLoad(t), t.layers = null, this.setNeedsUpdate();
+  }
+  _onTileError(t, e) {
+    this.props.onTileError(t), e.layers = null, this.setNeedsUpdate();
+  }
+  _onTileUnload(t) {
+    this.props.onTileUnload(t);
+  }
+  // Methods for subclass to override
+  getTileData(t) {
+    const { data: e, getTileData: s, fetch: i } = this.props, { signal: o } = t;
+    return t.url = typeof e == "string" || Array.isArray(e) ? Qn(e, t) : null, s ? s(t) : i && t.url ? i(t.url, { propName: "data", layer: this, signal: o }) : null;
+  }
+  renderSubLayers(t) {
+    return this.props.renderSubLayers(t);
+  }
+  getSubLayerPropsByTile(t) {
+    return null;
+  }
+  getPickingInfo(t) {
+    const e = t.sourceLayer, s = e.props.tile, i = t.info;
+    return i.picked && (i.tile = s), i.sourceTile = s, i.sourceTileSubLayer = e, i;
+  }
+  _updateAutoHighlight(t) {
+    t.sourceTileSubLayer.updateAutoHighlight(t);
+  }
+  renderLayers() {
+    return this.state.tileset.tiles.map((t) => {
+      const e = this.getSubLayerPropsByTile(t);
+      if (!(!t.isLoaded && !t.content)) if (t.layers)
+        e && t.layers[0] && Object.keys(e).some((s) => t.layers[0].props[s] !== e[s]) && (t.layers = t.layers.map((s) => s.clone(e)));
+      else {
+        const s = this.renderSubLayers({
+          ...this.props,
+          ...this.getSubLayerProps({
+            id: t.id,
+            updateTriggers: this.props.updateTriggers
+          }),
+          data: t.content,
+          _offset: 0,
+          tile: t
+        });
+        t.layers = Ns(s, Boolean).map((i) => i.clone({
+          tile: t,
+          ...e
+        }));
+      }
+      return t.layers;
+    });
+  }
+  filterSubLayer({ layer: t, cullRect: e }) {
+    const { tile: s } = t.props, { modelMatrix: i } = this.props;
+    return this.state.tileset.isTileVisible(s, e, i ? new G(i) : null);
+  }
+}
+ct.defaultProps = mi;
+ct.layerName = "TileLayer";
+const mt = Math.PI / 180, tt = new Float32Array(16), re = new Float32Array(12);
+function ae(n, t, e) {
+  const s = t[0] * mt, i = t[1] * mt, o = t[2] * mt, r = Math.sin(o), a = Math.sin(s), c = Math.sin(i), h = Math.cos(o), u = Math.cos(s), l = Math.cos(i), d = e[0], f = e[1], m = e[2];
+  n[0] = d * l * u, n[1] = d * c * u, n[2] = d * -a, n[3] = f * (-c * h + l * a * r), n[4] = f * (l * h + c * a * r), n[5] = f * u * r, n[6] = m * (c * r + l * a * h), n[7] = m * (-l * r + c * a * h), n[8] = m * u * h;
+}
+function ce(n) {
+  return n[0] = n[0], n[1] = n[1], n[2] = n[2], n[3] = n[4], n[4] = n[5], n[5] = n[6], n[6] = n[8], n[7] = n[9], n[8] = n[10], n[9] = n[12], n[10] = n[13], n[11] = n[14], n.subarray(0, 12);
+}
+const pi = {
+  size: 12,
+  accessor: ["getOrientation", "getScale", "getTranslation", "getTransformMatrix"],
+  shaderAttributes: {
+    instanceModelMatrixCol0: {
+      size: 3,
+      elementOffset: 0
+    },
+    instanceModelMatrixCol1: {
+      size: 3,
+      elementOffset: 3
+    },
+    instanceModelMatrixCol2: {
+      size: 3,
+      elementOffset: 6
+    },
+    instanceTranslation: {
+      size: 3,
+      elementOffset: 9
+    }
+  },
+  update(n, { startRow: t, endRow: e }) {
+    const { data: s, getOrientation: i, getScale: o, getTranslation: r, getTransformMatrix: a } = this.props, c = Array.isArray(a), h = c && a.length === 16, u = Array.isArray(o), l = Array.isArray(i), d = Array.isArray(r), f = h || !c && !!a(s[0]);
+    f ? n.constant = h : n.constant = l && u && d;
+    const m = n.value;
+    if (n.constant) {
+      let p;
+      f ? (tt.set(a), p = ce(tt)) : (p = re, ae(p, i, o), p.set(r, 9)), n.value = new Float32Array(p);
+    } else {
+      let p = t * n.size;
+      const { iterable: g, objectInfo: y } = be(s, t, e);
+      for (const _ of g) {
+        y.index++;
+        let x;
+        if (f)
+          tt.set(h ? a : a(_, y)), x = ce(tt);
+        else {
+          x = re;
+          const w = l ? i : i(_, y), T = u ? o : o(_, y);
+          ae(x, w, T), x.set(d ? r : r(_, y), 9);
+        }
+        m[p++] = x[0], m[p++] = x[1], m[p++] = x[2], m[p++] = x[3], m[p++] = x[4], m[p++] = x[5], m[p++] = x[6], m[p++] = x[7], m[p++] = x[8], m[p++] = x[9], m[p++] = x[10], m[p++] = x[11];
+      }
+    }
+  }
+};
+function gi(n, t) {
+  return t === dt.CARTESIAN || t === dt.METER_OFFSETS || t === dt.DEFAULT && !n.isGeospatial;
+}
+const le = `uniform simpleMeshUniforms {
+  float sizeScale;
+  bool composeModelMatrix;
+  bool hasTexture;
+  bool flatShading;
+} simpleMesh;
+`, yi = {
+  name: "simpleMesh",
+  vs: le,
+  fs: le,
+  uniformTypes: {
+    sizeScale: "f32",
+    composeModelMatrix: "f32",
+    hasTexture: "f32",
+    flatShading: "f32"
+  }
+}, _i = `#version 300 es
+#define SHADER_NAME simple-mesh-layer-vs
+in vec3 positions;
+in vec3 normals;
+in vec3 colors;
+in vec2 texCoords;
+in vec3 instancePositions;
+in vec3 instancePositions64Low;
+in vec4 instanceColors;
+in vec3 instancePickingColors;
+in vec3 instanceModelMatrixCol0;
+in vec3 instanceModelMatrixCol1;
+in vec3 instanceModelMatrixCol2;
+in vec3 instanceTranslation;
+out vec2 vTexCoord;
+out vec3 cameraPosition;
+out vec3 normals_commonspace;
+out vec4 position_commonspace;
+out vec4 vColor;
+void main(void) {
+geometry.worldPosition = instancePositions;
+geometry.uv = texCoords;
+geometry.pickingColor = instancePickingColors;
+vTexCoord = texCoords;
+cameraPosition = project.cameraPosition;
+vColor = vec4(colors * instanceColors.rgb, instanceColors.a);
+mat3 instanceModelMatrix = mat3(instanceModelMatrixCol0, instanceModelMatrixCol1, instanceModelMatrixCol2);
+vec3 pos = (instanceModelMatrix * positions) * simpleMesh.sizeScale + instanceTranslation;
+if (simpleMesh.composeModelMatrix) {
+DECKGL_FILTER_SIZE(pos, geometry);
+normals_commonspace = project_normal(instanceModelMatrix * normals);
+geometry.worldPosition += pos;
+gl_Position = project_position_to_clipspace(pos + instancePositions, instancePositions64Low, vec3(0.0), position_commonspace);
+geometry.position = position_commonspace;
+}
+else {
+pos = project_size(pos);
+DECKGL_FILTER_SIZE(pos, geometry);
+gl_Position = project_position_to_clipspace(instancePositions, instancePositions64Low, pos, position_commonspace);
+geometry.position = position_commonspace;
+normals_commonspace = project_normal(instanceModelMatrix * normals);
+}
+geometry.normal = normals_commonspace;
+DECKGL_FILTER_GL_POSITION(gl_Position, geometry);
+DECKGL_FILTER_COLOR(vColor, geometry);
+}
+`, xi = `#version 300 es
+#define SHADER_NAME simple-mesh-layer-fs
+precision highp float;
+uniform sampler2D sampler;
+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;
+}
+vec4 color = simpleMesh.hasTexture ? texture(sampler, vTexCoord) : vColor;
+DECKGL_FILTER_COLOR(color, geometry);
+vec3 lightColor = lighting_getLightColor(color.rgb, cameraPosition, position_commonspace.xyz, normal);
+fragColor = vec4(lightColor, color.a * layer.opacity);
+}
+`;
+function pt(n) {
+  const t = n.positions || n.POSITION;
+  Te.assert(t, 'no "postions" or "POSITION" attribute in mesh');
+  const e = t.value.length / t.size;
+  let s = n.COLOR_0 || n.colors;
+  s || (s = { size: 3, value: new Float32Array(e * 3).fill(1) });
+  let i = n.NORMAL || n.normals;
+  i || (i = { size: 3, value: new Float32Array(e * 3).fill(0) });
+  let o = n.TEXCOORD_0 || n.texCoords;
+  return o || (o = { size: 2, value: new Float32Array(e * 2).fill(0) }), {
+    positions: t,
+    colors: s,
+    normals: i,
+    texCoords: o
+  };
+}
+function he(n) {
+  return n instanceof ft ? (n.attributes = pt(n.attributes), n) : n.attributes ? new ft({
+    ...n,
+    topology: "triangle-list",
+    attributes: pt(n.attributes)
+  }) : new ft({
+    topology: "triangle-list",
+    attributes: pt(n)
+  });
+}
+const Mi = [0, 0, 0, 255], wi = {
+  mesh: { type: "object", value: null, async: !0 },
+  texture: { type: "image", value: null, async: !0 },
+  sizeScale: { type: "number", value: 1, min: 0 },
+  // _instanced is a hack to use world position instead of meter offsets in mesh
+  // TODO - formalize API
+  _instanced: !0,
+  // NOTE(Tarek): Quick and dirty wireframe. Just draws
+  // the same mesh with LINE_STRIPS. Won't follow edges
+  // of the original mesh.
+  wireframe: !1,
+  // Optional material for 'lighting' shader module
+  material: !0,
+  getPosition: { type: "accessor", value: (n) => n.position },
+  getColor: { type: "accessor", value: Mi },
+  // yaw, pitch and roll are in degrees
+  // https://en.wikipedia.org/wiki/Euler_angles
+  // [pitch, yaw, roll]
+  getOrientation: { type: "accessor", value: [0, 0, 0] },
+  getScale: { type: "accessor", value: [1, 1, 1] },
+  getTranslation: { type: "accessor", value: [0, 0, 0] },
+  // 4x4 matrix
+  getTransformMatrix: { type: "accessor", value: [] },
+  textureParameters: { type: "object", ignore: !0, value: null }
+};
+class rt extends qs {
+  getShaders() {
+    return super.getShaders({
+      vs: _i,
+      fs: xi,
+      modules: [Bs, Re, Gs, yi]
+    });
+  }
+  getBounds() {
+    if (this.props._instanced)
+      return super.getBounds();
+    let t = this.state.positionBounds;
+    if (t)
+      return t;
+    const { mesh: e } = this.props;
+    if (!e)
+      return null;
+    if (t = e.header?.boundingBox, !t) {
+      const { attributes: s } = he(e);
+      s.POSITION = s.POSITION || s.positions, t = Ks(s);
+    }
+    return this.state.positionBounds = t, t;
+  }
+  initializeState() {
+    this.getAttributeManager().addInstanced({
+      instancePositions: {
+        transition: !0,
+        type: "float64",
+        fp64: this.use64bitPositions(),
+        size: 3,
+        accessor: "getPosition"
+      },
+      instanceColors: {
+        type: "unorm8",
+        transition: !0,
+        size: this.props.colorFormat.length,
+        accessor: "getColor",
+        defaultValue: [0, 0, 0, 255]
+      },
+      instanceModelMatrix: pi
+    }), this.setState({
+      // Avoid luma.gl's missing uniform warning
+      // TODO - add feature to luma.gl to specify ignored uniforms?
+      emptyTexture: this.context.device.createTexture({
+        data: new Uint8Array(4),
+        width: 1,
+        height: 1
+      })
+    });
+  }
+  updateState(t) {
+    super.updateState(t);
+    const { props: e, oldProps: s, changeFlags: i } = t;
+    if (e.mesh !== s.mesh || i.extensionsChanged) {
+      if (this.state.positionBounds = null, this.state.model?.destroy(), e.mesh) {
+        this.state.model = this.getModel(e.mesh);
+        const o = e.mesh.attributes || e.mesh;
+        this.setState({
+          hasNormals: !!(o.NORMAL || o.normals)
+        });
+      }
+      this.getAttributeManager().invalidateAll();
+    }
+    e.texture !== s.texture && e.texture instanceof Ds && this.setTexture(e.texture), this.state.model && this.state.model.setTopology(this.props.wireframe ? "line-strip" : "triangle-list");
+  }
+  finalizeState(t) {
+    super.finalizeState(t), this.state.emptyTexture.delete();
+  }
+  draw({ uniforms: t }) {
+    const { model: e } = this.state;
+    if (!e)
+      return;
+    const { viewport: s, renderPass: i } = this.context, { sizeScale: o, coordinateSystem: r, _instanced: a } = this.props, c = {
+      sizeScale: o,
+      composeModelMatrix: !a || gi(s, r),
+      flatShading: !this.state.hasNormals
+    };
+    e.shaderInputs.setProps({ simpleMesh: c }), e.draw(i);
+  }
+  get isLoaded() {
+    return !!(this.state?.model && super.isLoaded);
+  }
+  getModel(t) {
+    const e = new Us(this.context.device, {
+      ...this.getShaders(),
+      id: this.props.id,
+      bufferLayout: this.getAttributeManager().getBufferLayouts(),
+      geometry: he(t),
+      isInstanced: !0
+    }), { texture: s } = this.props, { emptyTexture: i } = this.state, o = {
+      sampler: s || i,
+      hasTexture: !!s
+    };
+    return e.shaderInputs.setProps({ simpleMesh: o }), e;
+  }
+  setTexture(t) {
+    const { emptyTexture: e, model: s } = this.state;
+    if (s) {
+      const i = {
+        sampler: t || e,
+        hasTexture: !!t
+      };
+      s.shaderInputs.setProps({ simpleMesh: i });
+    }
+  }
+}
+rt.defaultProps = wi;
+rt.layerName = "SimpleMeshLayer";
+const Ti = [
+  [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
+], bi = 0.125;
+class Si {
+  reprojectors;
+  width;
+  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, e, s = e) {
+    this.reprojectors = t, this.width = e, this.height = s, this.uvs = [], this.exactOutputPositions = [], this.triangles = [], this._halfedges = [], this._candidatesUV = [], this._queueIndices = [], this._queue = [], this._errors = [], this._pending = [], this._pendingLen = 0;
+    const i = 1, o = 1, r = this._addPoint(0, 0), a = this._addPoint(i, 0), c = this._addPoint(0, o), h = this._addPoint(i, o), u = this._addTriangle(h, r, c, -1, -1, -1);
+    this._addTriangle(r, h, a, u, -1, -1), this._flush();
+  }
+  // refine the mesh until its maximum error gets below the given one
+  run(t = bi) {
+    if (t <= 0)
+      throw new Error("maxError must be positive");
+    for (; this.getMaxError() > t; )
+      this.refine();
+  }
+  // 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 e = this._pending[t];
+      this._findReprojectionCandidate(e);
+    }
+    this._pendingLen = 0;
+  }
+  /**
+   * Conversion of upstream's `_findCandidate` for reprojection error handling.
+   *
+   * @param   {number}  t  The index (into `this.triangles`) of the pending triangle to process.
+   *
+   * @return  {void}    Doesn't return; instead modifies internal state.
+   */
+  _findReprojectionCandidate(t) {
+    const e = 2 * this.triangles[t * 3 + 0], s = 2 * this.triangles[t * 3 + 1], i = 2 * this.triangles[t * 3 + 2], o = this.uvs[e], r = this.uvs[e + 1], a = this.uvs[s], c = this.uvs[s + 1], h = this.uvs[i], u = this.uvs[i + 1], l = this.exactOutputPositions[e], d = this.exactOutputPositions[e + 1], f = this.exactOutputPositions[s], m = this.exactOutputPositions[s + 1], p = this.exactOutputPositions[i], g = this.exactOutputPositions[i + 1];
+    let y = 0, _ = 0, x = 0;
+    for (const w of Ti) {
+      const T = et(o, a, h, w[0], w[1], w[2]), S = et(r, c, u, w[0], w[1], w[2]), L = et(l, f, p, w[0], w[1], w[2]), I = et(d, m, g, w[0], w[1], w[2]), b = T * (this.width - 1), C = S * (this.height - 1), B = this.reprojectors.inverseReproject(L, I), k = this.reprojectors.inverseTransform(B[0], B[1]), lt = b - k[0], ht = C - k[1], j = Math.hypot(lt, ht);
+      j > y && (y = j, _ = T, x = S);
+    }
+    (_ === o && x === r || _ === a && x === c || _ === h && x === u) && (y = 0), this._candidatesUV[2 * t] = _, this._candidatesUV[2 * t + 1] = x, this._queuePush(t, y);
+  }
+  // process the next triangle in the queue, splitting it with a new point
+  _step() {
+    const t = this._queuePop(), e = t * 3 + 0, s = t * 3 + 1, i = t * 3 + 2, o = this.triangles[e], r = this.triangles[s], a = this.triangles[i], c = this.uvs[2 * o], h = this.uvs[2 * o + 1], u = this.uvs[2 * r], l = this.uvs[2 * r + 1], d = this.uvs[2 * a], f = this.uvs[2 * a + 1], m = this._candidatesUV[2 * t], p = this._candidatesUV[2 * t + 1], g = this._addPoint(m, p);
+    if (gt(c, h, u, l, m, p) === 0)
+      this._handleCollinear(g, e);
+    else if (gt(u, l, d, f, m, p) === 0)
+      this._handleCollinear(g, s);
+    else if (gt(d, f, c, h, m, p) === 0)
+      this._handleCollinear(g, i);
+    else {
+      const y = this._halfedges[e], _ = this._halfedges[s], x = this._halfedges[i], w = this._addTriangle(o, r, g, y, -1, -1, e), T = this._addTriangle(r, a, g, _, -1, w + 1), S = this._addTriangle(a, o, g, x, w + 2, T + 1);
+      this._legalize(w), this._legalize(T), this._legalize(S);
+    }
+  }
+  // add coordinates for a new vertex
+  _addPoint(t, e) {
+    const s = this.uvs.length >> 1;
+    this.uvs.push(t, e);
+    const i = t * (this.width - 1), o = e * (this.height - 1), r = this.reprojectors.forwardTransform(i, o), a = this.reprojectors.forwardReproject(r[0], r[1]);
+    return this.exactOutputPositions.push(a[0], a[1]), s;
+  }
+  // add or update a triangle in the mesh
+  _addTriangle(t, e, s, i, o, r, a = this.triangles.length) {
+    const c = a / 3;
+    return this.triangles[a + 0] = t, this.triangles[a + 1] = e, this.triangles[a + 2] = s, this._halfedges[a + 0] = i, this._halfedges[a + 1] = o, this._halfedges[a + 2] = r, i >= 0 && (this._halfedges[i] = a + 0), o >= 0 && (this._halfedges[o] = a + 1), r >= 0 && (this._halfedges[r] = a + 2), this._candidatesUV[2 * c + 0] = 0, this._candidatesUV[2 * c + 1] = 0, this._queueIndices[c] = -1, this._pending[this._pendingLen++] = c, a;
+  }
+  _legalize(t) {
+    const e = this._halfedges[t];
+    if (e < 0)
+      return;
+    const s = t - t % 3, i = e - e % 3, o = s + (t + 1) % 3, r = s + (t + 2) % 3, a = i + (e + 2) % 3, c = i + (e + 1) % 3, h = this.triangles[r], u = this.triangles[t], l = this.triangles[o], d = this.triangles[a], f = this.uvs;
+    if (!Ci(f[2 * h], f[2 * h + 1], f[2 * u], f[2 * u + 1], f[2 * l], f[2 * l + 1], f[2 * d], f[2 * d + 1]))
+      return;
+    const m = this._halfedges[o], p = this._halfedges[r], g = this._halfedges[a], y = this._halfedges[c];
+    this._queueRemove(s / 3), this._queueRemove(i / 3);
+    const _ = this._addTriangle(h, d, l, -1, g, m, s), x = this._addTriangle(d, h, u, _, p, y, i);
+    this._legalize(_ + 1), this._legalize(x + 2);
+  }
+  // handle a case where new vertex is on the edge of a triangle
+  _handleCollinear(t, e) {
+    const s = e - e % 3, i = s + (e + 1) % 3, o = s + (e + 2) % 3, r = this.triangles[o], a = this.triangles[e], c = this.triangles[i], h = this._halfedges[i], u = this._halfedges[o], l = this._halfedges[e];
+    if (l < 0) {
+      const S = this._addTriangle(t, r, a, -1, u, -1, s), L = this._addTriangle(r, t, c, S, -1, h);
+      this._legalize(S + 1), this._legalize(L + 2);
+      return;
+    }
+    const d = l - l % 3, f = d + (l + 2) % 3, m = d + (l + 1) % 3, p = this.triangles[f], g = this._halfedges[f], y = this._halfedges[m];
+    this._queueRemove(d / 3);
+    const _ = this._addTriangle(r, a, t, u, -1, -1, s), x = this._addTriangle(a, p, t, y, -1, _ + 1, d), w = this._addTriangle(p, c, t, g, -1, x + 1), T = this._addTriangle(c, r, t, h, _ + 2, w + 1);
+    this._legalize(_), this._legalize(x), this._legalize(w), this._legalize(T);
+  }
+  // priority queue methods
+  _queuePush(t, e) {
+    const s = this._queue.length;
+    this._queueIndices[t] = s, this._queue.push(t), this._errors.push(e), this._queueUp(s);
+  }
+  _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 e = this._queueIndices[t];
+    if (e < 0) {
+      const i = this._pending.indexOf(t);
+      if (i !== -1)
+        this._pending[i] = this._pending[--this._pendingLen];
+      else
+        throw new Error("Broken triangulation (something went wrong).");
+      return;
+    }
+    const s = this._queue.length - 1;
+    s !== e && (this._queueSwap(e, s), this._queueDown(e, s) || this._queueUp(e)), this._queuePopBack();
+  }
+  _queueLess(t, e) {
+    return this._errors[t] > this._errors[e];
+  }
+  _queueSwap(t, e) {
+    const s = this._queue[t], i = this._queue[e];
+    this._queue[t] = i, this._queue[e] = s, this._queueIndices[s] = e, this._queueIndices[i] = t;
+    const o = this._errors[t];
+    this._errors[t] = this._errors[e], this._errors[e] = o;
+  }
+  _queueUp(t) {
+    let e = t;
+    for (; ; ) {
+      const s = e - 1 >> 1;
+      if (s === e || !this._queueLess(e, s))
+        break;
+      this._queueSwap(s, e), e = s;
+    }
+  }
+  _queueDown(t, e) {
+    let s = t;
+    for (; ; ) {
+      const i = 2 * s + 1;
+      if (i >= e || i < 0)
+        break;
+      const o = i + 1;
+      let r = i;
+      if (o < e && this._queueLess(o, i) && (r = o), !this._queueLess(r, s))
+        break;
+      this._queueSwap(s, r), s = r;
+    }
+    return s > t;
+  }
+}
+function gt(n, t, e, s, i, o) {
+  return (e - i) * (t - o) - (s - o) * (n - i);
+}
+function Ci(n, t, e, s, i, o, r, a) {
+  const c = n - r, h = t - a, u = e - r, l = s - a, d = i - r, f = o - a, m = c * c + h * h, p = u * u + l * l, g = d * d + f * f;
+  return c * (l * g - p * f) - h * (u * g - p * d) + m * (u * f - l * d) < 0;
+}
+function et(n, t, e, s, i, o) {
+  return s * n + i * t + o * e;
+}
+const Li = (
+  /* 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);
+}
+`
+);
+class Ei extends rt {
+  static layerName = "mesh-texture-layer";
+  static defaultProps = rt.defaultProps;
+  getShaders() {
+    const t = super.getShaders(), e = t.modules;
+    for (const s of this.props.renderPipeline)
+      e.push(s.module);
+    return {
+      ...t,
+      // Override upstream's fragment shader with our copy with modified
+      // injection points
+      fs: Li,
+      modules: e
+    };
+  }
+  draw(t) {
+    const e = {};
+    for (const s of this.props.renderPipeline)
+      e[s.module.name] = s.props || {};
+    for (const s of super.getModels())
+      s.shaderInputs.setProps(e);
+    super.draw(t);
+  }
+}
+const Pi = 0.125, ue = [
+  [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
+], Ri = {
+  debug: !1,
+  debugOpacity: 0.5
+};
+class Ne extends V {
+  static layerName = "RasterLayer";
+  static defaultProps = Ri;
+  initializeState() {
+    this.setState({});
+  }
+  updateState(t) {
+    super.updateState(t);
+    const { props: e, oldProps: s, changeFlags: i } = t;
+    (i.dataChanged || e.width !== s.width || e.height !== s.height || e.reprojectionFns !== s.reprojectionFns || e.maxError !== s.maxError) && this._generateMesh();
+  }
+  _generateMesh() {
+    const { width: t, height: e, reprojectionFns: s, maxError: i = Pi } = this.props, o = new Si(s, t + 1, e + 1);
+    o.run(i);
+    const { indices: r, positions: a, texCoords: c } = Ii(o);
+    this.setState({
+      reprojector: o,
+      mesh: {
+        positions: a,
+        indices: r,
+        texCoords: c
+      }
+    });
+  }
+  renderDebugLayer() {
+    const { reprojector: t } = this.state, { debugOpacity: e } = this.props;
+    return t ? new Pt(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: (s, { index: i, data: o }) => {
+        const r = o.reprojector.triangles, a = t.exactOutputPositions, c = r[i * 3], h = r[i * 3 + 1], u = r[i * 3 + 2];
+        return [
+          [a[c * 2], a[c * 2 + 1]],
+          [a[h * 2], a[h * 2 + 1]],
+          [a[u * 2], a[u * 2 + 1]],
+          [a[c * 2], a[c * 2 + 1]]
+        ];
+      },
+      getFillColor: (s, { index: i, target: o }) => {
+        const r = ue[i % ue.length];
+        return o[0] = r[0], o[1] = r[1], o[2] = r[2], o[3] = 255, o;
+      },
+      getLineColor: [0, 0, 0],
+      getLineWidth: 1,
+      lineWidthUnits: "pixels",
+      opacity: e !== void 0 && Number.isFinite(e) ? Math.max(0, Math.min(1, e)) : 1,
+      pickable: !1
+    })) : null;
+  }
+  /** Create assembled render pipeline from the renderPipeline prop input. */
+  _createRenderPipeline() {
+    if (this.props.renderPipeline instanceof ImageData) {
+      const t = this.props.renderPipeline, e = this.context.device.createTexture({
+        format: "rgba8unorm",
+        width: t.width,
+        height: t.height,
+        data: t.data
+      });
+      return [{
+        module: xe,
+        props: {
+          textureName: e
+        }
+      }];
+    } else
+      return this.props.renderPipeline;
+  }
+  renderLayers() {
+    const { mesh: t } = this.state, { debug: e } = this.props;
+    if (!t)
+      return null;
+    const { indices: s, positions: i, texCoords: o } = t, a = [new Ei(this.getSubLayerProps({
+      id: "raster",
+      renderPipeline: this._createRenderPipeline(),
+      // 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: {
+        indices: { value: s, size: 1 },
+        attributes: {
+          POSITION: {
+            value: i,
+            size: 3
+          },
+          TEXCOORD_0: {
+            value: o,
+            size: 2
+          }
+        }
+      },
+      // 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 (e) {
+      const c = this.renderDebugLayer();
+      c && a.push(c);
+    }
+    return a;
+  }
+}
+function Ii(n) {
+  const t = n.uvs.length / 2, e = new Float32Array(t * 3), s = new Float32Array(n.uvs);
+  for (let o = 0; o < t; o++)
+    e[o * 3] = n.exactOutputPositions[o * 2], e[o * 3 + 1] = n.exactOutputPositions[o * 2 + 1], e[o * 3 + 2] = 0;
+  return {
+    indices: new Uint32Array(n.triangles),
+    positions: e,
+    texCoords: s
+  };
+}
+const de = 512, Ai = [
+  [0.5, 0.5],
+  // center
+  [0, 0],
+  // top-left
+  [0, 1],
+  // bottom-left
+  [1, 0],
+  // top-right
+  [1, 1]
+  // bottom-right
+], vi = Ai.concat([
+  [0, 0.5],
+  // left edge
+  [0.5, 0],
+  // top edge
+  [1, 0.5],
+  // right edge
+  [0.5, 1]
+  // bottom edge
+]), Oi = 6378137, Ct = 2 * Math.PI * Oi, fe = Ct / 2, zi = 28e-5;
+class qt {
+  /** Index across a row */
+  x;
+  /** Index down a column */
+  y;
+  /** Zoom index assumed to be (higher = finer detail) */
+  z;
+  metadata;
+  /**
+   * 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, e, s, i) {
+    this.x = t, this.y = e, this.z = s, this.metadata = i;
+  }
+  /** Get overview info for this tile's z level */
+  get tileMatrix() {
+    return this.metadata.tileMatrices[this.z];
+  }
+  /** Get the children of this node.
+   *
+   * Find all tiles at level this.z + 1 whose spatial extent overlaps this tile.
+   *
+   * A TileMatrixSet is not a quadtree, but rather a stack of independent grids. We can't cleanly find child tiles by decimation directly.
+   *
+   */
+  get children() {
+    if (!this._children) {
+      const t = this.metadata.tileMatrices.length - 1;
+      if (this.z >= t)
+        return this._children = null, null;
+      const e = this.tileMatrix, s = this.z + 1, i = this.metadata.tileMatrices[s], o = me({
+        x: this.x,
+        y: this.y,
+        transform: e.geotransform,
+        tileWidth: e.tileWidth,
+        tileHeight: e.tileHeight
+      }), { minCol: r, maxCol: a, minRow: c, maxRow: h } = qi(o, i), u = [];
+      for (let l = c; l <= h; l++)
+        for (let d = r; d <= a; d++)
+          u.push(new qt(d, l, s, this.metadata));
+      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: e, cullingVolume: s, elevationBounds: i, minZ: o, maxZ: r = this.metadata.tileMatrices.length - 1, project: a, bounds: c } = t, { boundingVolume: h, commonSpaceBounds: u } = this.getBoundingVolume(i, a);
+    if (c && !this.insideBounds(c, u) || s.computeVisibility(h) < 0)
+      return !1;
+    const d = this.children;
+    if (!this.childVisible && this.z >= o) {
+      const f = Di(h, e.zoom);
+      if (this.tileMatrix.scaleDenominator * zi <= f || this.z >= r || d === null && this.z >= o)
+        return this.selected = !0, !0;
+    }
+    if (d && d.length > 0) {
+      this.selected = !1;
+      let f = !1;
+      for (const m of d)
+        m.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 OSMNode tiles
+   */
+  getSelected(t = []) {
+    if (this.selected && t.push(this), this._children)
+      for (const e of this._children)
+        e.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, e) {
+    const [s, i, o, r] = t, [a, c, h, u] = e;
+    return a < o && h > s && c < r && u > i;
+  }
+  /**
+   * Calculate the 3D bounding volume for this tile in deck.gl's common
+   * coordinate space for frustum culling.
+   *
+   * TODO: In the future, we can add a fast path in the case that the source
+   * tiling is already in EPSG:3857.
+   */
+  getBoundingVolume(t, e) {
+    return e && Ws(!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 e = this.tileMatrix, { tileWidth: s, tileHeight: i, geotransform: o } = e, [r, a] = t, c = me({
+      x: this.x,
+      y: this.y,
+      transform: o,
+      tileWidth: s,
+      tileHeight: i
+    }), u = Ni(vi, c, this.metadata.projectTo3857).map((y) => Fi(y)), l = [];
+    for (const y of u)
+      l.push([y[0], y[1], r]), r !== a && l.push([y[0], y[1], a]);
+    let d = Number.POSITIVE_INFINITY, f = Number.POSITIVE_INFINITY, m = Number.NEGATIVE_INFINITY, p = Number.NEGATIVE_INFINITY;
+    for (const [y, _] of u)
+      y < d && (d = y), _ < f && (f = _), y > m && (m = y), _ > p && (p = _);
+    const g = [d, f, m, p];
+    return {
+      boundingVolume: Ae(l),
+      commonSpaceBounds: g
+    };
+  }
+}
+function me({ x: n, y: t, transform: e, tileWidth: s, tileHeight: i }) {
+  const [o, r, a, c, h, u] = e;
+  if (r !== 0 || c !== 0)
+    throw new Error(`Rotated/skewed geotransforms not yet supported (b=${r}, d=${c}). Only north-up, non-rotated rasters are currently supported.`);
+  const l = n * s, d = t * i, f = (n + 1) * s, m = (t + 1) * i, p = o * l + r * d + a, g = c * l + h * d + u, y = o * f + r * m + a, _ = c * f + h * m + u;
+  return [
+    Math.min(p, y),
+    Math.min(g, _),
+    Math.max(p, y),
+    Math.max(g, _)
+  ];
+}
+function Ni(n, t, e) {
+  const [s, i, o, r] = t, a = [];
+  for (const [c, h] of n) {
+    const u = s + c * (o - s), l = i + h * (r - i), d = e([u, l]);
+    a.push(d);
+  }
+  return a;
+}
+function Fi([n, t]) {
+  const e = Math.max(-fe, Math.min(fe, t));
+  return [
+    (n / Ct + 0.5) * de,
+    (e / Ct + 0.5) * de
+  ];
+}
+function qi(n, t) {
+  const [e, s, i, o] = n, { tileWidth: r, tileHeight: a, cellSize: c, matrixWidth: h, matrixHeight: u, pointOfOrigin: l } = t, d = r * c, f = a * c, m = l[0], p = l[1];
+  let g = Math.floor((e - m) / d), y = Math.floor((i - m) / d), _ = Math.floor((p - o) / f), x = Math.floor((p - s) / f);
+  return g = Math.max(0, Math.min(h - 1, g)), y = Math.max(0, Math.min(h - 1, y)), _ = Math.max(0, Math.min(u - 1, _)), x = Math.max(0, Math.min(u - 1, x)), { minCol: g, maxCol: y, minRow: _, maxRow: x };
+}
+function Bi(n, t) {
+  const { viewport: e, maxZ: s, zRange: i } = t, o = e instanceof Ce && e.resolution ? e.projectPosition : null, r = Object.values(e.getFrustumPlanes()).map(({ normal: b, distance: C }) => new W(b.clone().negate(), C)), a = new v(r), c = e.distanceScales.unitsPerMeter[2], h = i && i[0] * c || 0, u = i && i[1] * c || 0, l = 0, { lowerLeft: d, upperRight: f } = n.wgsBounds, [m, p] = d, [g, y] = f, _ = ot([m, p]), x = ot([g, y]), w = [
+    _[0],
+    _[1],
+    x[0],
+    x[1]
+  ], T = n.tileMatrices[0], S = [];
+  for (let b = 0; b < T.matrixHeight; b++)
+    for (let C = 0; C < T.matrixWidth; C++)
+      S.push(new qt(C, b, 0, n));
+  const L = {
+    viewport: e,
+    project: o,
+    cullingVolume: a,
+    elevationBounds: [h, u],
+    minZ: l,
+    maxZ: s,
+    bounds: w
+  };
+  for (const b of S)
+    b.update(L);
+  const I = [];
+  for (const b of S)
+    b.getSelected(I);
+  return I;
+}
+function Gi(n, t) {
+  return 40075016686e-3 * Math.cos(n * Math.PI / 180) / 2 ** (t + 8);
+}
+function Di(n, t) {
+  const [e, s] = Vs(n.center);
+  return Gi(s, t);
+}
+class Ui extends Nt {
+  metadata;
+  constructor(t, e) {
+    super(e), this.metadata = t;
+  }
+  /**
+   * Get tile indices visible in viewport
+   * Uses frustum culling similar to OSM implementation
+   *
+   * Overviews follow TileMatrixSet ordering: index 0 = coarsest, higher = finer
+   */
+  getTileIndices(t) {
+    const e = this.metadata.tileMatrices.length - 1, s = typeof t.maxZoom == "number" ? Math.min(t.maxZoom, e) : e;
+    return Bi(this.metadata, {
+      viewport: t.viewport,
+      maxZ: s,
+      zRange: t.zRange ?? null
+    });
+  }
+  getTileId(t) {
+    return `${t.x}-${t.y}-${t.z}`;
+  }
+  getParentIndex(t) {
+    if (t.z === 0)
+      return t;
+    const e = this.metadata.tileMatrices[t.z], s = this.metadata.tileMatrices[t.z - 1], i = e.cellSize / s.cellSize;
+    return {
+      x: Math.floor(t.x / i),
+      y: Math.floor(t.y / i),
+      z: t.z - 1
+    };
+  }
+  getTileZoom(t) {
+    return t.z;
+  }
+  getTileMetadata(t) {
+    const { x: e, y: s, z: i } = t, { tileMatrices: o } = this.metadata, r = o[i], { geotransform: a, tileHeight: c, tileWidth: h } = r, [u, l, d, f, m, p] = a, g = e * h, y = s * c, _ = (e + 1) * h, x = (s + 1) * c, w = [
+      u * g + l * y + d,
+      f * g + m * y + p
+    ], T = [
+      u * _ + l * y + d,
+      f * _ + m * y + p
+    ], S = [
+      u * g + l * x + d,
+      f * g + m * x + p
+    ], L = [
+      u * _ + l * x + d,
+      f * _ + m * x + p
+    ], I = {
+      topLeft: w,
+      topRight: T,
+      bottomLeft: S,
+      bottomRight: L
+    };
+    return {
+      bounds: [
+        Math.min(w[0], T[0], S[0], L[0]),
+        Math.min(w[1], T[1], S[1], L[1]),
+        Math.max(w[0], T[0], S[0], L[0]),
+        Math.max(w[1], T[1], S[1], L[1])
+      ],
+      projectedBounds: I,
+      tileWidth: h,
+      tileHeight: c,
+      tileMatrix: r
+    };
+  }
+}
+const Wi = {
+  MERIT: {
+    a: 6378137
+  },
+  SGS85: {
+    a: 6378136
+  },
+  GRS80: {
+    a: 6378137
+  },
+  IAU76: {
+    a: 6378140
+  },
+  airy: {
+    a: 6377563396e-3,
+    b: 635625691e-2
+  },
+  APL4: {
+    a: 6378137
+  },
+  NWL9D: {
+    a: 6378145
+  },
+  mod_airy: {
+    a: 6377340189e-3,
+    b: 6356034446e-3
+  },
+  andrae: {
+    a: 637710443e-2
+  },
+  aust_SA: {
+    a: 6378160
+  },
+  GRS67: {
+    a: 6378160
+  },
+  bessel: {
+    a: 6377397155e-3
+  },
+  bess_nam: {
+    a: 6377483865e-3
+  },
+  clrk66: {
+    a: 63782064e-1,
+    b: 63565838e-1
+  },
+  clrk80: {
+    a: 6378249145e-3
+  },
+  clrk80ign: {
+    a: 63782492e-1,
+    b: 6356515
+  },
+  clrk58: {
+    a: 6378293645208759e-9
+  },
+  CPM: {
+    a: 63757387e-1
+  },
+  delmbr: {
+    a: 6376428
+  },
+  engelis: {
+    a: 637813605e-2
+  },
+  evrst30: {
+    a: 6377276345e-3
+  },
+  evrst48: {
+    a: 6377304063e-3
+  },
+  evrst56: {
+    a: 6377301243e-3
+  },
+  evrst69: {
+    a: 6377295664e-3
+  },
+  evrstSS: {
+    a: 6377298556e-3
+  },
+  fschr60: {
+    a: 6378166
+  },
+  fschr60m: {
+    a: 6378155
+  },
+  fschr68: {
+    a: 6378150
+  },
+  helmert: {
+    a: 6378200
+  },
+  hough: {
+    a: 6378270
+  },
+  intl: {
+    a: 6378388
+  },
+  kaula: {
+    a: 6378163
+  },
+  lerch: {
+    a: 6378139
+  },
+  mprts: {
+    a: 6397300
+  },
+  new_intl: {
+    a: 63781575e-1,
+    b: 63567722e-1
+  },
+  plessis: {
+    a: 6376523
+  },
+  krass: {
+    a: 6378245
+  },
+  SEasia: {
+    a: 6378155,
+    b: 63567733205e-4
+  },
+  walbeck: {
+    a: 6376896,
+    b: 63558348467e-4
+  },
+  WGS60: {
+    a: 6378165
+  },
+  WGS66: {
+    a: 6378145
+  },
+  WGS7: {
+    a: 6378135
+  },
+  WGS84: {
+    a: 6378137
+  },
+  sphere: {
+    a: 6370997,
+    b: 6370997
+  }
+};
+function Vi(n) {
+  if (ki(n))
+    throw new Error("Cannot invert degenerate transform");
+  const t = 1 / Fe(n), [e, s, i, o, r, a] = n, c = r * t, h = -s * t, u = -o * t, l = e * t;
+  return [
+    c,
+    h,
+    -i * c - a * h,
+    u,
+    l,
+    -i * u - a * l
+  ];
+}
+function ki(n) {
+  return Fe(n) === 0;
+}
+function Fe(n) {
+  const [t, e, s, i, o, r] = n;
+  return t * o - e * i;
+}
+function pe(n, t, e) {
+  const [s, i, o, r, a, c] = e;
+  return [s * n + i * t + o, r * n + a * t + c];
+}
+const ji = {
+  $schema: "https://proj.org/schemas/v0.7/projjson.schema.json",
+  type: "GeographicCRS",
+  name: "WGS 84 (CRS84)",
+  datum_ensemble: {
+    name: "World Geodetic System 1984 ensemble",
+    members: [
+      {
+        name: "World Geodetic System 1984 (Transit)",
+        id: { authority: "EPSG", code: 1166 }
+      },
+      {
+        name: "World Geodetic System 1984 (G730)",
+        id: { authority: "EPSG", code: 1152 }
+      },
+      {
+        name: "World Geodetic System 1984 (G873)",
+        id: { authority: "EPSG", code: 1153 }
+      },
+      {
+        name: "World Geodetic System 1984 (G1150)",
+        id: { authority: "EPSG", code: 1154 }
+      },
+      {
+        name: "World Geodetic System 1984 (G1674)",
+        id: { authority: "EPSG", code: 1155 }
+      },
+      {
+        name: "World Geodetic System 1984 (G1762)",
+        id: { authority: "EPSG", code: 1156 }
+      },
+      {
+        name: "World Geodetic System 1984 (G2139)",
+        id: { authority: "EPSG", code: 1309 }
+      }
+    ],
+    ellipsoid: {
+      name: "WGS 84",
+      semi_major_axis: 6378137,
+      inverse_flattening: 298.257223563
+    },
+    accuracy: "2.0",
+    id: { authority: "EPSG", code: 6326 }
+  },
+  coordinate_system: {
+    subtype: "ellipsoidal",
+    axis: [
+      {
+        name: "Geodetic longitude",
+        abbreviation: "Lon",
+        direction: "east",
+        unit: "degree"
+      },
+      {
+        name: "Geodetic latitude",
+        abbreviation: "Lat",
+        direction: "north",
+        unit: "degree"
+      }
+    ]
+  },
+  scope: "Not known.",
+  area: "World.",
+  bbox: {
+    south_latitude: -90,
+    west_longitude: -180,
+    north_latitude: 90,
+    east_longitude: 180
+  },
+  // @ts-expect-error - proj4 types are incomplete
+  id: { authority: "OGC", code: "CRS84" }
+};
+async function Yi(n, t, e = ji) {
+  const s = await n.getImage(), i = Be(s), o = q(t, e), { forwardTransform: r, inverseTransform: a } = qe(i);
+  return {
+    forwardTransform: r,
+    inverseTransform: a,
+    forwardReproject: (c, h) => o.forward([c, h], !1),
+    inverseReproject: (c, h) => o.inverse([c, h], !1)
+  };
+}
+function qe(n) {
+  const t = Vi(n);
+  return {
+    forwardTransform: (e, s) => pe(e, s, n),
+    inverseTransform: (e, s) => pe(e, s, t)
+  };
+}
+function Be(n) {
+  const t = n.getOrigin(), e = n.getResolution(), i = n.getFileDirectory().ModelTransformation;
+  let o = 0, r = 0;
+  return i && i.length >= 16 && (o = i[1], r = i[4]), [
+    e[0],
+    // a: pixel width
+    o,
+    // b: row rotation
+    t[0],
+    // c: x origin
+    r,
+    // d: column rotation
+    e[1],
+    // e: pixel height (often negative)
+    t[1]
+  ];
+}
+const Ge = 28e-5;
+async function $i(n, t) {
+  const e = await n.getImage();
+  if (!e.isTiled)
+    throw new Error("COG TileMatrixSet requires a tiled GeoTIFF");
+  const s = await n.getImageCount(), i = e.getBoundingBox(), o = e.getWidth(), r = e.getHeight(), a = await t(e.getGeoKeys());
+  if (a === null)
+    throw new Error("Could not determine coordinate reference system from GeoTIFF geo keys");
+  const c = q(a.def, "EPSG:4326").forward, h = q(a.def, "EPSG:3857").forward, u = {
+    lowerLeft: [i[0], i[1]],
+    upperRight: [i[2], i[3]]
+  }, l = Be(e);
+  if (l[1] !== 0 || l[3] !== 0)
+    throw new Error("COG TileMatrixSet with rotation/skewed geotransform is not supported");
+  const d = Math.abs(l[0]), f = e.getTileWidth(), m = e.getTileHeight(), p = [
+    {
+      // Set as highest resolution / finest level
+      id: String(s - 1),
+      scaleDenominator: d * Bt(a.parsed, a.coordinatesUnits) / Ge,
+      cellSize: d,
+      pointOfOrigin: [l[2], l[5]],
+      tileWidth: e.getTileWidth(),
+      tileHeight: e.getTileHeight(),
+      matrixWidth: Math.ceil(o / f),
+      matrixHeight: Math.ceil(r / m),
+      geotransform: l
+    }
+  ];
+  for (let g = 1; g < s; g++) {
+    const y = await n.getImage(g);
+    if (!y.isTiled)
+      throw new Error("COG TileMatrixSet requires a tiled GeoTIFF");
+    const _ = Xi({
+      id: String(s - 1 - g),
+      image: y,
+      fullWidth: o,
+      baseTransform: l,
+      crs: a
+    });
+    p.push(_);
+  }
+  return p.reverse(), {
+    crs: a,
+    boundingBox: u,
+    wgsBounds: Zi(u, c),
+    tileMatrices: p,
+    projectToWgs84: c,
+    projectTo3857: h
+  };
+}
+function Bt(n, t) {
+  const e = (t || n.units)?.toLowerCase();
+  switch (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") {
+    const { a: s } = Wi[n.ellps];
+    return 2 * Math.PI * s / 360;
+  }
+  throw new Error(`Unsupported CRS units: ${e}`);
+}
+function Xi({ id: n, image: t, fullWidth: e, baseTransform: s, crs: i }) {
+  const o = t.getWidth(), r = t.getHeight(), c = e / o, h = [
+    s[0] * c,
+    s[1] * c,
+    s[2],
+    // x origin stays the same
+    s[3] * c,
+    s[4] * c,
+    s[5]
+    // y origin stays the same
+  ], u = Math.abs(h[0]), l = t.getTileWidth(), d = t.getTileHeight();
+  return {
+    id: n,
+    scaleDenominator: u * Bt(i.parsed, i.coordinatesUnits) / Ge,
+    cellSize: u,
+    pointOfOrigin: [h[2], h[5]],
+    tileWidth: l,
+    tileHeight: d,
+    matrixWidth: Math.ceil(o / l),
+    matrixHeight: Math.ceil(r / d),
+    geotransform: h
+  };
+}
+function Zi(n, t) {
+  const e = t(n.lowerLeft), s = t([
+    n.upperRight[0],
+    n.lowerLeft[1]
+  ]), i = t(n.upperRight), o = t([
+    n.lowerLeft[0],
+    n.upperRight[1]
+  ]), r = Math.min(e[0], s[0], i[0], o[0]), a = Math.max(e[0], s[0], i[0], o[0]), c = Math.min(e[1], s[1], i[1], o[1]), h = Math.max(e[1], s[1], i[1], o[1]);
+  return {
+    lowerLeft: [r, c],
+    upperRight: [a, h]
+  };
+}
+const Hi = {
+  metersPerUnit: Bt
+};
+let yt = null;
+function De() {
+  return yt === null && (yt = new Qe()), yt;
+}
+async function Ki(n, t) {
+  const e = {
+    ...t,
+    interleave: !0,
+    enableAlpha: !0
+  }, s = await n.readRGB(e);
+  return {
+    texture: Ue(s),
+    height: s.height,
+    width: s.width
+  };
+}
+function Ue(n) {
+  const { height: t, width: e } = n;
+  if (n.length === t * e * 4)
+    return new ImageData(new Uint8ClampedArray(n), e, t);
+  if (n.length === t * e * 3) {
+    const s = n.length / 3 * 4, i = new Uint8ClampedArray(s);
+    for (let o = 0; o < n.length / 3; ++o)
+      i[o * 4] = n[o * 3], i[o * 4 + 1] = n[o * 3 + 1], i[o * 4 + 2] = n[o * 3 + 2], i[o * 4 + 3] = 255;
+    return new ImageData(i, e, t);
+  } else
+    throw new Error(`Unexpected number of channels in raster data: ${n.length / (t * e)}`);
+}
+function Qi(n) {
+  const t = n.length / 3, e = new Uint8ClampedArray(t * 4), s = 0, i = t, o = t * 2;
+  for (let r = 0; r < t; r++)
+    e[4 * r + 0] = n[s + r] >> 8, e[4 * r + 1] = n[i + r] >> 8, e[4 * r + 2] = n[o + r] >> 8, e[4 * r + 3] = 255;
+  return new ImageData(e, t, 1);
+}
+async function We(n) {
+  return typeof n == "string" ? $e(n) : n instanceof ArrayBuffer ? Xe(n) : n instanceof Blob ? Ze(n) : n instanceof He ? Ke(n) : n;
+}
+function Ve(n, t) {
+  const e = n.getBoundingBox(), [s, i, o, r] = e, a = [
+    t.forward([s, i]),
+    // bottom-left
+    t.forward([o, i]),
+    // bottom-right
+    t.forward([o, r]),
+    // top-right
+    t.forward([s, r])
+    // top-left
+  ], c = a.map((m) => m[0]), h = a.map((m) => m[1]), u = Math.min(...c), l = Math.min(...h), d = Math.max(...c), f = Math.max(...h);
+  return { west: u, south: l, east: d, north: f };
+}
+function Ji(n) {
+  if (!n)
+    return null;
+  const t = n?.[n?.length - 1] === "\0" ? n.slice(0, -1) : n;
+  return t?.length > 0 ? parseFloat(t) : null;
+}
+function to(n, t, e) {
+  const s = n.getFileDirectory(), i = s.SamplesPerPixel, o = Gt(i, s.BitsPerSample, s.SampleFormat);
+  return {
+    data: t,
+    format: o,
+    width: e.width,
+    height: e.height
+  };
+}
+function Gt(n, t, e) {
+  const s = eo(n), i = so(t), o = no(e), r = `${s}:${o}:${i}`, a = io[r];
+  if (!a)
+    throw new Error(`Unsupported texture format for SamplesPerPixel=${n}, BitsPerSample=${t}, SampleFormat=${e}`);
+  return a;
+}
+function eo(n) {
+  if (n === 1 || n === 2 || n === 3 || n === 4)
+    return n;
+  throw new Error(`Unsupported SamplesPerPixel ${n}. Only 1, 2, 3, or 4 are supported.`);
+}
+function so(n) {
+  const t = n[0];
+  for (let e = 1; e < n.length; e++)
+    if (n[e] !== t)
+      throw new Error(`Unsupported varying BitsPerSample ${n}. 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 no(n) {
+  const t = n[0];
+  for (let e = 1; e < n.length; e++)
+    if (n[e] !== t)
+      throw new Error(`Unsupported varying SampleFormat ${n}. All samples must have the same format.`);
+  switch (t) {
+    case 1:
+      return "unorm";
+    case 2:
+      return "sint";
+    case 3:
+      return "float";
+    default:
+      throw new Error(`Unsupported SampleFormat ${n}`);
+  }
+}
+const io = {
+  // 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"
+}, bo = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
+  __proto__: null,
+  createTextureProps: to,
+  inferTextureFormat: Gt
+}, Symbol.toStringTag, { value: "Module" }));
+var F;
+(function(n) {
+  n[n.WhiteIsZero = 0] = "WhiteIsZero", n[n.BlackIsZero = 1] = "BlackIsZero", n[n.RGB = 2] = "RGB", n[n.Palette = 3] = "Palette", n[n.TransparencyMask = 4] = "TransparencyMask", n[n.CMYK = 5] = "CMYK", n[n.YCbCr = 6] = "YCbCr", n[n.CIELab = 8] = "CIELab", n[n.ICCLab = 9] = "ICCLab";
+})(F || (F = {}));
+var ge;
+(function(n) {
+  n[n.Chunky = 1] = "Chunky", n[n.Planar = 2] = "Planar";
+})(ge || (ge = {}));
+function oo(n, t) {
+  const { SampleFormat: e } = n;
+  if (e[0] === 1)
+    return ro(n, t);
+  throw new Error(`Inferring render pipeline for non-unsigned integers not yet supported. Found SampleFormat: ${e}`);
+}
+function ro(n, t) {
+  const { BitsPerSample: e, ColorMap: s, GDAL_NODATA: i, PhotometricInterpretation: o, SampleFormat: r, SamplesPerPixel: a } = n, c = [
+    {
+      module: xe,
+      props: {
+        textureName: (m) => m.texture
+      }
+    }
+  ], h = Ji(i);
+  if (h !== null) {
+    const m = h / 255;
+    c.push({
+      module: ns,
+      props: { value: m }
+    });
+  }
+  const u = ao(o, t, s);
+  u && c.push(u);
+  const l = o === F.Palette ? {
+    magFilter: "nearest",
+    minFilter: "nearest"
+  } : {
+    magFilter: "linear",
+    minFilter: "linear"
+  };
+  return { getTileData: async (m, p) => {
+    const { device: g } = p, y = {
+      ...p,
+      interleave: !0
+    };
+    let _ = await m.readRasters(y), x = a;
+    a === 3 && (_ = Ue(_), x = 4);
+    const w = Gt(
+      // Add one sample for added alpha channel
+      x,
+      e,
+      r
+    );
+    return {
+      texture: g.createTexture({
+        data: _,
+        format: w,
+        width: _.width,
+        height: _.height,
+        sampler: l
+      }),
+      height: _.height,
+      width: _.width
+    };
+  }, renderTile: (m) => c.map((p, g) => co(p, m)) };
+}
+function ao(n, t, e) {
+  switch (n) {
+    case F.RGB:
+      return null;
+    case F.Palette: {
+      if (!e)
+        throw new Error("ColorMap is required for PhotometricInterpretation Palette");
+      const { data: s, width: i, height: o } = Qi(e), r = t.createTexture({
+        data: s,
+        format: "rgba8unorm",
+        width: i,
+        height: o,
+        sampler: {
+          minFilter: "nearest",
+          magFilter: "nearest",
+          addressModeU: "clamp-to-edge",
+          addressModeV: "clamp-to-edge"
+        }
+      });
+      return {
+        module: ss,
+        props: {
+          colormapTexture: r
+        }
+      };
+    }
+    case F.CMYK:
+      return {
+        module: es
+      };
+    case F.YCbCr:
+      return {
+        module: ts
+      };
+    case F.CIELab:
+      return {
+        module: Je
+      };
+    default:
+      throw new Error(`Unsupported PhotometricInterpretation ${n}`);
+  }
+}
+function co(n, t) {
+  const { module: e, props: s } = n;
+  if (!s)
+    return { module: e };
+  const i = {};
+  for (const [o, r] of Object.entries(s)) {
+    const a = typeof r == "function" ? r(t) : r;
+    a !== void 0 && (i[o] = a);
+  }
+  return { module: e, props: i };
+}
+async function Dt(n) {
+  const t = n.ProjectedCSTypeGeoKey || n.GeographicTypeGeoKey || null, e = await lo(t);
+  if (!e)
+    return null;
+  const s = ke(e);
+  return {
+    def: e,
+    parsed: s,
+    coordinatesUnits: s.units
+  };
+}
+async function lo(n) {
+  if (n === null)
+    return null;
+  const t = `https://epsg.io/${n}.json`, e = await fetch(t);
+  if (!e.ok)
+    throw new Error(`Failed to fetch projection data from ${t}`);
+  return await e.json();
+}
+function ke(n) {
+  const t = "__deck.gl-geotiff-internal__";
+  return q.defs(t, n), q.defs(t);
+}
+const So = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
+  __proto__: null,
+  epsgIoGeoKeyParser: Dt,
+  parseCrs: ke
+}, Symbol.toStringTag, { value: "Module" })), ho = {
+  geoKeysParser: Dt,
+  debug: !1,
+  debugOpacity: 0.5
+};
+class Co extends V {
+  static layerName = "COGLayer";
+  static defaultProps = ho;
+  initializeState() {
+    this.setState({});
+  }
+  updateState(t) {
+    super.updateState(t);
+    const { props: e, oldProps: s, changeFlags: i } = t;
+    (i.dataChanged || e.geotiff !== s.geotiff) && this._parseGeoTIFF();
+  }
+  async _parseGeoTIFF() {
+    const t = await We(this.props.geotiff), e = this.props.geoKeysParser, s = await $i(t, e), i = await t.getImage(), o = await t.getImageCount(), r = [];
+    for (let f = 0; f < o; f++)
+      r.push(await t.getImage(f));
+    const a = await e(i.getGeoKeys());
+    if (!a)
+      throw new Error("Could not determine source projection from GeoTIFF geo keys");
+    const c = q(a.def, "EPSG:4326"), h = (f, m) => c.forward([f, m], !1), u = (f, m) => c.inverse([f, m], !1);
+    if (this.props.onGeoTIFFLoad) {
+      const f = Ve(i, c);
+      this.props.onGeoTIFFLoad(t, {
+        projection: a,
+        geographicBounds: f
+      });
+    }
+    const { getTileData: l, renderTile: d } = oo(i.fileDirectory, this.context.device);
+    this.setState({
+      metadata: s,
+      forwardReproject: h,
+      inverseReproject: u,
+      images: r,
+      defaultGetTileData: l,
+      defaultRenderTile: d
+    });
+  }
+  /**
+   * Inner callback passed in to the underlying TileLayer's `getTileData`.
+   */
+  async _getTileData(t, e, s) {
+    const { signal: i } = t, { x: o, y: r, z: a } = t.index, c = e[e.length - 1 - a], h = c.getHeight(), u = c.getWidth(), l = s.tileMatrices[a], { tileWidth: d, tileHeight: f } = l, m = uo(o, r, l), { forwardTransform: p, inverseTransform: g } = qe(m), y = [
+      o * d,
+      r * f,
+      Math.min((o + 1) * d, u),
+      Math.min((r + 1) * f, h)
+    ], _ = this.props.getTileData || this.state.defaultGetTileData, x = i && this.props.signal ? AbortSignal.any([i, this.props.signal]) : i || this.props.signal;
+    return {
+      // @ts-expect-error type mismatch when using provided getTileData
+      data: await _(c, {
+        device: this.context.device,
+        window: y,
+        signal: x,
+        pool: this.props.pool || De()
+      }),
+      forwardTransform: p,
+      inverseTransform: g
+    };
+  }
+  _renderSubLayers(t, e, s, i) {
+    const { maxError: o, debug: r, debugOpacity: a } = this.props, { tile: c } = t;
+    if (!t.data)
+      return null;
+    const { data: h, forwardTransform: u, inverseTransform: l } = t.data, d = [];
+    if (h) {
+      const { height: f, width: m } = h, p = this.props.renderTile || this.state.defaultRenderTile;
+      d.push(new Ne({
+        id: `${t.id}-raster`,
+        width: m,
+        height: f,
+        renderPipeline: p(h),
+        maxError: o,
+        reprojectionFns: {
+          forwardTransform: u,
+          inverseTransform: l,
+          forwardReproject: s,
+          inverseReproject: i
+        },
+        debug: r,
+        debugOpacity: a
+      }));
+    }
+    if (r) {
+      const f = c?.projectedBounds;
+      if (!f || !e)
+        return [];
+      const { topLeft: m, topRight: p, bottomLeft: g, bottomRight: y } = f, _ = e.projectToWgs84(m), x = e.projectToWgs84(p), w = e.projectToWgs84(y), T = e.projectToWgs84(g), S = [
+        _,
+        x,
+        w,
+        T,
+        _
+        // Close the path
+      ];
+      d.push(new Se({
+        id: `${this.id}-${c.id}-bounds`,
+        data: [S],
+        getPath: (L) => L,
+        getColor: [255, 0, 0, 255],
+        // Red
+        getWidth: 2,
+        widthUnits: "pixels",
+        pickable: !1
+      }));
+    }
+    return d;
+  }
+  renderTileLayer(t, e, s, i) {
+    class o extends Ui {
+      constructor(a) {
+        super(t, a);
+      }
+    }
+    return new ct({
+      id: `cog-tile-layer-${this.id}`,
+      TilesetClass: o,
+      getTileData: async (r) => this._getTileData(r, i, t),
+      renderSubLayers: (r) => this._renderSubLayers(r, t, e, s)
+    });
+  }
+  renderLayers() {
+    const { forwardReproject: t, inverseReproject: e, metadata: s, images: i } = this.state;
+    return !t || !e || !s || !i ? null : this.renderTileLayer(s, t, e, i);
+  }
+}
+function uo(n, t, e) {
+  const { tileWidth: s, tileHeight: i } = e, o = n * s, r = t * i, [a, c, h, u, l, d] = e.geotransform, f = a * o + c * r + h, m = u * o + l * r + d;
+  return [a, c, f, u, l, m];
+}
+const fo = {
+  geoKeysParser: Dt
+};
+class Lo extends V {
+  static layerName = "GeoTIFFLayer";
+  static defaultProps = fo;
+  initializeState() {
+    this.setState({});
+  }
+  updateState(t) {
+    super.updateState(t);
+    const { props: e, oldProps: s, changeFlags: i } = t;
+    (i.dataChanged || e.geotiff !== s.geotiff || e.maxError !== s.maxError) && this._parseGeoTIFF();
+  }
+  async _parseGeoTIFF() {
+    const t = await We(this.props.geotiff), e = await t.getImage(), s = this.props.geoKeysParser, i = await s(e.getGeoKeys());
+    if (!i)
+      throw new Error("Could not determine source projection from GeoTIFF geo keys");
+    const o = q(i.def, "EPSG:4326");
+    if (this.props.onGeoTIFFLoad) {
+      const u = Ve(e, o);
+      this.props.onGeoTIFFLoad(t, {
+        projection: i,
+        geographicBounds: u
+      });
+    }
+    const r = await Yi(t, i.def), { texture: a, height: c, width: h } = await Ki(e, {
+      pool: this.props.pool || De()
+    });
+    this.setState({
+      reprojectionFns: r,
+      imageData: a,
+      height: c,
+      width: h
+    });
+  }
+  renderLayers() {
+    const { reprojectionFns: t, imageData: e, height: s, width: i } = this.state;
+    if (!t || !e || !s || !i)
+      return null;
+    const { maxError: o, debug: r, debugOpacity: a } = this.props;
+    return new Ne(this.getSubLayerProps({
+      id: "raster",
+      width: i,
+      height: s,
+      reprojectionFns: t,
+      maxError: o,
+      texture: e,
+      debug: r,
+      debugOpacity: a
+    }));
+  }
+}
+class mo {
+  constructor() {
+    this.ids = [], this.values = [], this.length = 0;
+  }
+  /** Removes all items from the queue. */
+  clear() {
+    this.length = 0;
+  }
+  /**
+   * Adds `item` to the queue with the specified `priority`.
+   *
+   * `priority` must be a number. Items are sorted and returned from low to high priority. Multiple items
+   * with the same priority value can be added to the queue, but there is no guaranteed order between these items.
+   *
+   * @param {T} item
+   * @param {number} priority
+   */
+  push(t, e) {
+    let s = this.length++;
+    for (; s > 0; ) {
+      const i = s - 1 >> 1, o = this.values[i];
+      if (e >= o) break;
+      this.ids[s] = this.ids[i], this.values[s] = o, s = i;
+    }
+    this.ids[s] = t, this.values[s] = e;
+  }
+  /**
+   * Removes and returns the item from the head of this queue, which is one of
+   * the items with the lowest priority. If this queue is empty, returns `undefined`.
+   */
+  pop() {
+    if (this.length === 0) return;
+    const t = this.ids, e = this.values, s = t[0], i = --this.length;
+    if (i > 0) {
+      const o = t[i], r = e[i];
+      let a = 0;
+      const c = i >> 1;
+      for (; a < c; ) {
+        const h = (a << 1) + 1, u = h + 1, l = h + (+(u < i) & +(e[u] < e[h]));
+        if (e[l] >= r) break;
+        t[a] = t[l], e[a] = e[l], a = l;
+      }
+      t[a] = o, e[a] = r;
+    }
+    return s;
+  }
+  /** Returns the item from the head of this queue without removing it. If this queue is empty, returns `undefined`. */
+  peek() {
+    return this.length > 0 ? this.ids[0] : void 0;
+  }
+  /**
+   * Returns the priority value of the item at the head of this queue without
+   * removing it. If this queue is empty, returns `undefined`.
+   */
+  peekValue() {
+    return this.length > 0 ? this.values[0] : void 0;
+  }
+  /**
+   * Shrinks the internal arrays to `this.length`.
+   *
+   * `pop()` and `clear()` calls don't free memory automatically to avoid unnecessary resize operations.
+   * This also means that items that have been added to the queue can't be garbage collected until
+   * a new item is pushed in their place, or this method is called.
+   */
+  shrink() {
+    this.ids.length = this.values.length = this.length;
+  }
+}
+const ye = [Int8Array, Uint8Array, Uint8ClampedArray, Int16Array, Uint16Array, Int32Array, Uint32Array, Float32Array, Float64Array], _t = 3;
+class Ut {
+  /**
+   * Recreate a Flatbush index from raw `ArrayBuffer` or `SharedArrayBuffer` data.
+   * @param {ArrayBufferLike} data
+   * @param {number} [byteOffset=0] byte offset to the start of the Flatbush buffer in the referenced ArrayBuffer.
+   * @returns {Flatbush} index
+   */
+  static from(t, e = 0) {
+    if (e % 8 !== 0)
+      throw new Error("byteOffset must be 8-byte aligned.");
+    if (!t || t.byteLength === void 0 || t.buffer)
+      throw new Error("Data must be an instance of ArrayBuffer or SharedArrayBuffer.");
+    const [s, i] = new Uint8Array(t, e + 0, 2);
+    if (s !== 251)
+      throw new Error("Data does not appear to be in a Flatbush format.");
+    const o = i >> 4;
+    if (o !== _t)
+      throw new Error(`Got v${o} data when expected v${_t}.`);
+    const r = ye[i & 15];
+    if (!r)
+      throw new Error("Unrecognized array type.");
+    const [a] = new Uint16Array(t, e + 2, 1), [c] = new Uint32Array(t, e + 4, 1);
+    return new Ut(c, a, r, void 0, t, e);
+  }
+  /**
+   * Create a Flatbush index that will hold a given number of items.
+   * @param {number} numItems
+   * @param {number} [nodeSize=16] Size of the tree node (16 by default).
+   * @param {TypedArrayConstructor} [ArrayType=Float64Array] The array type used for coordinates storage (`Float64Array` by default).
+   * @param {ArrayBufferConstructor | SharedArrayBufferConstructor} [ArrayBufferType=ArrayBuffer] The array buffer type used to store data (`ArrayBuffer` by default).
+   * @param {ArrayBufferLike} [data] (Only used internally)
+   * @param {number} [byteOffset=0] (Only used internally)
+   */
+  constructor(t, e = 16, s = Float64Array, i = ArrayBuffer, o, r = 0) {
+    if (t === void 0) throw new Error("Missing required argument: numItems.");
+    if (isNaN(t) || t <= 0) throw new Error(`Unexpected numItems value: ${t}.`);
+    this.numItems = +t, this.nodeSize = Math.min(Math.max(+e, 2), 65535), this.byteOffset = r;
+    let a = t, c = a;
+    this._levelBounds = [a * 4];
+    do
+      a = Math.ceil(a / this.nodeSize), c += a, this._levelBounds.push(c * 4);
+    while (a !== 1);
+    this.ArrayType = s, this.IndexArrayType = c < 16384 ? Uint16Array : Uint32Array;
+    const h = ye.indexOf(s), u = c * 4 * s.BYTES_PER_ELEMENT;
+    if (h < 0)
+      throw new Error(`Unexpected typed array class: ${s}.`);
+    if (o)
+      this.data = o, this._boxes = new s(o, r + 8, c * 4), this._indices = new this.IndexArrayType(o, r + 8 + u, c), this._pos = c * 4, this.minX = this._boxes[this._pos - 4], this.minY = this._boxes[this._pos - 3], this.maxX = this._boxes[this._pos - 2], this.maxY = this._boxes[this._pos - 1];
+    else {
+      const l = this.data = new i(8 + u + c * this.IndexArrayType.BYTES_PER_ELEMENT);
+      this._boxes = new s(l, 8, c * 4), this._indices = new this.IndexArrayType(l, 8 + u, c), this._pos = 0, this.minX = 1 / 0, this.minY = 1 / 0, this.maxX = -1 / 0, this.maxY = -1 / 0, new Uint8Array(l, 0, 2).set([251, (_t << 4) + h]), new Uint16Array(l, 2, 1)[0] = e, new Uint32Array(l, 4, 1)[0] = t;
+    }
+    this._queue = new mo();
+  }
+  /**
+   * Add a given rectangle to the index.
+   * @param {number} minX
+   * @param {number} minY
+   * @param {number} maxX
+   * @param {number} maxY
+   * @returns {number} A zero-based, incremental number that represents the newly added rectangle.
+   */
+  add(t, e, s = t, i = e) {
+    const o = this._pos >> 2, r = this._boxes;
+    return this._indices[o] = o, r[this._pos++] = t, r[this._pos++] = e, r[this._pos++] = s, r[this._pos++] = i, t < this.minX && (this.minX = t), e < this.minY && (this.minY = e), s > this.maxX && (this.maxX = s), i > this.maxY && (this.maxY = i), o;
+  }
+  /** Perform indexing of the added rectangles. */
+  finish() {
+    if (this._pos >> 2 !== this.numItems)
+      throw new Error(`Added ${this._pos >> 2} items when expected ${this.numItems}.`);
+    const t = this._boxes;
+    if (this.numItems <= this.nodeSize) {
+      t[this._pos++] = this.minX, t[this._pos++] = this.minY, t[this._pos++] = this.maxX, t[this._pos++] = this.maxY;
+      return;
+    }
+    const e = this.maxX - this.minX || 1, s = this.maxY - this.minY || 1, i = new Uint32Array(this.numItems), o = 65535;
+    for (let r = 0, a = 0; r < this.numItems; r++) {
+      const c = t[a++], h = t[a++], u = t[a++], l = t[a++], d = Math.floor(o * ((c + u) / 2 - this.minX) / e), f = Math.floor(o * ((h + l) / 2 - this.minY) / s);
+      i[r] = go(d, f);
+    }
+    Lt(i, t, this._indices, 0, this.numItems - 1, this.nodeSize);
+    for (let r = 0, a = 0; r < this._levelBounds.length - 1; r++) {
+      const c = this._levelBounds[r];
+      for (; a < c; ) {
+        const h = a;
+        let u = t[a++], l = t[a++], d = t[a++], f = t[a++];
+        for (let m = 1; m < this.nodeSize && a < c; m++)
+          u = Math.min(u, t[a++]), l = Math.min(l, t[a++]), d = Math.max(d, t[a++]), f = Math.max(f, t[a++]);
+        this._indices[this._pos >> 2] = h, t[this._pos++] = u, t[this._pos++] = l, t[this._pos++] = d, t[this._pos++] = f;
+      }
+    }
+  }
+  /**
+   * Search the index by a bounding box.
+   * @param {number} minX
+   * @param {number} minY
+   * @param {number} maxX
+   * @param {number} maxY
+   * @param {(index: number, x0: number, y0: number, x1: number, y1: number) => boolean} [filterFn] An optional function that is called on every found item; if supplied, only items for which this function returns true will be included in the results array.
+   * @returns {number[]} An array of indices of items intersecting or touching the given bounding box.
+   */
+  search(t, e, s, i, o) {
+    if (this._pos !== this._boxes.length)
+      throw new Error("Data not yet indexed - call index.finish().");
+    let r = this._boxes.length - 4;
+    const a = [], c = [];
+    for (; r !== void 0; ) {
+      const h = Math.min(r + this.nodeSize * 4, _e(r, this._levelBounds));
+      for (let u = r; u < h; u += 4) {
+        const l = this._boxes[u];
+        if (s < l) continue;
+        const d = this._boxes[u + 1];
+        if (i < d) continue;
+        const f = this._boxes[u + 2];
+        if (t > f) continue;
+        const m = this._boxes[u + 3];
+        if (e > m) continue;
+        const p = this._indices[u >> 2] | 0;
+        r >= this.numItems * 4 ? a.push(p) : (o === void 0 || o(p, l, d, f, m)) && c.push(p);
+      }
+      r = a.pop();
+    }
+    return c;
+  }
+  /**
+   * Search items in order of distance from the given point.
+   * @param {number} x
+   * @param {number} y
+   * @param {number} [maxResults=Infinity]
+   * @param {number} [maxDistance=Infinity]
+   * @param {(index: number) => boolean} [filterFn] An optional function for filtering the results.
+   * @returns {number[]} An array of indices of items found.
+   */
+  neighbors(t, e, s = 1 / 0, i = 1 / 0, o) {
+    if (this._pos !== this._boxes.length)
+      throw new Error("Data not yet indexed - call index.finish().");
+    let r = this._boxes.length - 4;
+    const a = this._queue, c = [], h = i * i;
+    t: for (; r !== void 0; ) {
+      const u = Math.min(r + this.nodeSize * 4, _e(r, this._levelBounds));
+      for (let l = r; l < u; l += 4) {
+        const d = this._indices[l >> 2] | 0, f = this._boxes[l], m = this._boxes[l + 1], p = this._boxes[l + 2], g = this._boxes[l + 3], y = t < f ? f - t : t > p ? t - p : 0, _ = e < m ? m - e : e > g ? e - g : 0, x = y * y + _ * _;
+        x > h || (r >= this.numItems * 4 ? a.push(d << 1, x) : (o === void 0 || o(d)) && a.push((d << 1) + 1, x));
+      }
+      for (; a.length && a.peek() & 1; )
+        if (a.peekValue() > h || (c.push(a.pop() >> 1), c.length === s)) break t;
+      r = a.length ? a.pop() >> 1 : void 0;
+    }
+    return a.clear(), c;
+  }
+}
+function _e(n, t) {
+  let e = 0, s = t.length - 1;
+  for (; e < s; ) {
+    const i = e + s >> 1;
+    t[i] > n ? s = i : e = i + 1;
+  }
+  return t[e];
+}
+function Lt(n, t, e, s, i, o) {
+  if (Math.floor(s / o) >= Math.floor(i / o)) return;
+  const r = n[s], a = n[s + i >> 1], c = n[i];
+  let h = c;
+  const u = Math.max(r, a);
+  c > u ? h = u : u === r ? h = Math.max(a, c) : u === a && (h = Math.max(r, c));
+  let l = s - 1, d = i + 1;
+  for (; ; ) {
+    do
+      l++;
+    while (n[l] < h);
+    do
+      d--;
+    while (n[d] > h);
+    if (l >= d) break;
+    po(n, t, e, l, d);
+  }
+  Lt(n, t, e, s, d, o), Lt(n, t, e, d + 1, i, o);
+}
+function po(n, t, e, s, i) {
+  const o = n[s];
+  n[s] = n[i], n[i] = o;
+  const r = 4 * s, a = 4 * i, c = t[r], h = t[r + 1], u = t[r + 2], l = t[r + 3];
+  t[r] = t[a], t[r + 1] = t[a + 1], t[r + 2] = t[a + 2], t[r + 3] = t[a + 3], t[a] = c, t[a + 1] = h, t[a + 2] = u, t[a + 3] = l;
+  const d = e[s];
+  e[s] = e[i], e[i] = d;
+}
+function go(n, t) {
+  let e = n ^ t, s = 65535 ^ e, i = 65535 ^ (n | t), o = n & (t ^ 65535), r = e | s >> 1, a = e >> 1 ^ e, c = i >> 1 ^ s & o >> 1 ^ i, h = e & i >> 1 ^ o >> 1 ^ o;
+  e = r, s = a, i = c, o = h, r = e & e >> 2 ^ s & s >> 2, a = e & s >> 2 ^ s & (e ^ s) >> 2, c ^= e & i >> 2 ^ s & o >> 2, h ^= s & i >> 2 ^ (e ^ s) & o >> 2, e = r, s = a, i = c, o = h, r = e & e >> 4 ^ s & s >> 4, a = e & s >> 4 ^ s & (e ^ s) >> 4, c ^= e & i >> 4 ^ s & o >> 4, h ^= s & i >> 4 ^ (e ^ s) & o >> 4, e = r, s = a, i = c, o = h, c ^= e & i >> 8 ^ s & o >> 8, h ^= s & i >> 8 ^ (e ^ s) & o >> 8, e = c ^ c >> 1, s = h ^ h >> 1;
+  let u = n ^ t, l = s | 65535 ^ (u | e);
+  return u = (u | u << 8) & 16711935, u = (u | u << 4) & 252645135, u = (u | u << 2) & 858993459, u = (u | u << 1) & 1431655765, l = (l | l << 8) & 16711935, l = (l | l << 4) & 252645135, l = (l | l << 2) & 858993459, l = (l | l << 1) & 1431655765, (l << 1 | u) >>> 0;
+}
+class yo extends Nt {
+  sources;
+  index;
+  constructor(t, e) {
+    super(e), this.sources = t.map((i, o) => ({
+      x: i.x === void 0 ? o : i.x,
+      y: i.y === void 0 ? 0 : i.y,
+      z: i.z === void 0 ? 0 : i.z,
+      ...i
+    }));
+    const s = new Ut(t.length);
+    for (const i of t) {
+      const [o, r, a, c] = i.bbox;
+      s.add(o, r, a, c);
+    }
+    s.finish(), this.index = s;
+  }
+  getTileIndices({ viewport: t, maxZoom: e, minZoom: s }) {
+    if (t.zoom < (s ?? -1 / 0))
+      return [];
+    if (t.zoom > (e ?? 1 / 0))
+      return [];
+    const i = t.getBounds();
+    return this.index.search(...i).map((r) => this.sources[r]);
+  }
+}
+const _o = {};
+class Eo extends V {
+  static layerName = "MosaicLayer";
+  static defaultProps = _o;
+  renderTileLayer(t, e) {
+    const { id: s, minZoom: i, maxZoom: o, extent: r, maxCacheByteSize: a, maxCacheSize: c, maxRequests: h } = this.props;
+    class u extends yo {
+      constructor(d) {
+        super(t, d);
+      }
+    }
+    return new ct({
+      id: `mosaic-layer-${s}`,
+      TilesetClass: u,
+      minZoom: i,
+      maxZoom: o,
+      extent: r,
+      ...a !== void 0 && { maxCacheByteSize: a },
+      maxCacheSize: c,
+      maxRequests: h,
+      getTileData: async (l) => {
+        const d = l.index, { signal: f } = l, m = this.props.getSource && await this.props.getSource(d, { signal: f });
+        return {
+          source: d,
+          data: m,
+          signal: f
+        };
+      },
+      renderSubLayers: (l) => {
+        const { data: d } = l, { source: f, signal: m, data: p } = d;
+        return e(f, { data: p, signal: m });
+      }
+    });
+  }
+  renderLayers() {
+    const { sources: t, renderSource: e } = this.props;
+    return !t || t.length === 0 ? null : this.renderTileLayer(t, e);
+  }
+}
+const Po = { ...Hi };
+export {
+  Co as COGLayer,
+  Lo as GeoTIFFLayer,
+  Eo as MosaicLayer,
+  yo as MosaicTileset2D,
+  Po as __TEST_EXPORTS,
+  Yi as extractGeotiffReprojectors,
+  qe as fromGeoTransform,
+  Ki as loadRgbImage,
+  $i as parseCOGTileMatrixSet,
+  Qi as parseColormap,
+  So as proj,
+  bo as texture
+};