@voluma/vlam 0.2.4 → 0.3.0

package/dist/chunk-loader-DlNwggfG.js

@@ -0,0 +1,1859 @@
+var g = Object.defineProperty;
+var E = (o, t, n) => t in o ? g(o, t, { enumerable: !0, configurable: !0, writable: !0, value: n }) : o[t] = n;
+var a = (o, t, n) => E(o, typeof t != "symbol" ? t + "" : t, n);
+import { r as _, s as m, b as A, c, d as k, S as x, e as R } from "./loading-wLo8vRbA.js";
+const y = `var bt = Object.defineProperty;
+var gt = (e, t, r) => t in e ? bt(e, t, { enumerable: !0, configurable: !0, writable: !0, value: r }) : e[t] = r;
+var K = (e, t, r) => gt(e, typeof t != "symbol" ? t + "" : t, r);
+const Et = [2047, 1023, 2047];
+function P(e) {
+  return [0, 3, 8, 15][e] ?? 0;
+}
+function Ae(e, t, r, n) {
+  const s = P(r);
+  let o = n ?? 0;
+  if (n === void 0)
+    for (const c of e) o = Math.max(o, Math.abs(c));
+  const a = {
+    min: [-o, -o, -o],
+    max: [o, o, o]
+  }, h = new Uint32Array(t * s), i = o || 1;
+  for (let c = 0; c < h.length; c++) {
+    const f = c * 3, l = (m, b) => Math.min(b, Math.max(0, Math.round((m / i + 1) * 0.5 * b))), d = l(e[f], 2047), u = l(e[f + 1], 1023), y = l(e[f + 2], 2047);
+    h[c] = (d | u << 11 | y << 21) >>> 0;
+  }
+  return { bands: r, packed: h, range: a };
+}
+function _t(e, t, r) {
+  const n = P(r), s = P(e.bands), o = e.paletteWidth, a = new Float32Array(t * n * 3);
+  for (let h = 0; h < t; h++) {
+    const i = e.labels[h], c = i % 64 * s, f = Math.floor(i / 64);
+    if (c + s > o || (f * o + c + s) * 4 > e.palette.length)
+      throw new Error(\`packPaletteSh: splat \${h} has SH label \${i} outside the palette.\`);
+    const l = Math.min(n, s);
+    for (let d = 0; d < l; d++) {
+      const u = (f * o + c + d) * 4, y = (h * n + d) * 3;
+      a[y] = e.palette[u], a[y + 1] = e.palette[u + 1], a[y + 2] = e.palette[u + 2];
+    }
+  }
+  return Ae(a, t, r);
+}
+function At(e) {
+  const t = (r, n, s) => {
+    if (n === r) return 0;
+    const o = (0 - r) / (n - r);
+    return Math.max(0, Math.min(s, Math.round(o * s)));
+  };
+  return (t(e.min[0], e.max[0], 2047) | t(e.min[1], e.max[1], 1023) << 11 | t(e.min[2], e.max[2], 2047) << 21) >>> 0;
+}
+function Rt(e, t) {
+  return e.min[0] === t.min[0] && e.min[1] === t.min[1] && e.min[2] === t.min[2] && e.max[0] === t.max[0] && e.max[1] === t.max[1] && e.max[2] === t.max[2];
+}
+function St(e, t, r) {
+  return e + (t - e) * r;
+}
+function xt(e, t, r) {
+  const n = [e & 2047, e >>> 11 & 1023, e >>> 21 & 2047];
+  let s = 0, o = 0;
+  for (let a = 0; a < 3; a++) {
+    const h = Et[a], i = St(
+      t.min[a],
+      t.max[a],
+      n[a] / h
+    ), c = r.min[a], f = r.max[a], l = f === c ? 0 : (i - c) / (f - c), d = Math.max(0, Math.min(h, Math.round(l * h)));
+    s |= d << o, o += a === 0 ? 11 : 10;
+  }
+  return s >>> 0;
+}
+const Be = 0.28209479177387814;
+function te(e, t, r, n, s, o, a, h, i) {
+  const c = Math.hypot(o, a, h, i) || 1, f = o / c, l = a / c, d = h / c, u = i / c, y = (1 - 2 * (d * d + u * u)) * r, m = 2 * (l * d - f * u) * n, b = 2 * (l * u + f * d) * s, _ = 2 * (l * d + f * u) * r, w = (1 - 2 * (l * l + u * u)) * n, p = 2 * (d * u - f * l) * s, A = 2 * (l * u - f * d) * r, g = 2 * (d * u + f * l) * n, E = (1 - 2 * (l * l + d * d)) * s;
+  e[t * 6 + 0] = y * y + m * m + b * b, e[t * 6 + 1] = y * _ + m * w + b * p, e[t * 6 + 2] = y * A + m * g + b * E, e[t * 6 + 3] = _ * _ + w * w + p * p, e[t * 6 + 4] = _ * A + w * g + p * E, e[t * 6 + 5] = A * A + g * g + E * E;
+}
+const ue = {
+  float: 4,
+  float32: 4,
+  double: 8,
+  float64: 8,
+  int: 4,
+  int32: 4,
+  uint: 4,
+  uint32: 4,
+  short: 2,
+  int16: 2,
+  ushort: 2,
+  uint16: 2,
+  char: 1,
+  int8: 1,
+  uchar: 1,
+  uint8: 1
+};
+function qe(e) {
+  const t = new Uint8Array(e, 0, Math.min(e.byteLength, 65536)), r = new TextDecoder("ascii").decode(t), n = /end_header\\r?\\n/.exec(r);
+  if (!/^ply\\r?\\n/.test(r))
+    throw new Error('Not a PLY file (missing "ply" magic).');
+  if (!n)
+    throw new Error(
+      'Unsupported PLY file: no "end_header" within the first 64 KiB - the header exceeds the supported window, or the file is truncated.'
+    );
+  if (!r.includes("format binary_little_endian 1.0"))
+    throw new Error("Unsupported PLY format; expected binary_little_endian 1.0.");
+  const s = [];
+  for (const i of r.slice(0, n.index).split(\`
+\`)) {
+    const c = i.trim().split(/\\s+/);
+    if (c[0] === "element") {
+      const f = c[1], l = Number(c[2]);
+      if (f === void 0) throw new Error(\`Malformed PLY element: "\${i.trim()}"\`);
+      if (!Number.isSafeInteger(l) || l < 0)
+        throw new Error(\`Invalid PLY \${f} count: \${c[2]}.\`);
+      s.push({
+        name: f,
+        count: l,
+        properties: /* @__PURE__ */ new Map(),
+        propertyNames: [],
+        listProperties: /* @__PURE__ */ new Map(),
+        stride: 0,
+        hasListProperty: !1
+      });
+    } else if (c[0] === "property") {
+      const f = s[s.length - 1];
+      if (!f) throw new Error(\`PLY property declared before any element: "\${i.trim()}"\`);
+      if (c[1] === "list") {
+        const y = c[2] ?? "", m = c[3] ?? "", b = c[4];
+        if (ue[y] === void 0 || ue[m] === void 0 || b === void 0)
+          throw new Error(\`Unsupported PLY property: "\${i.trim()}"\`);
+        if (f.properties.has(b) || f.listProperties.has(b))
+          throw new Error(\`Duplicate PLY property "\${b}" in element "\${f.name}".\`);
+        f.listProperties.set(b, { countType: y, itemType: m }), f.hasListProperty = !0;
+        continue;
+      }
+      const l = c[1] ?? "", d = ue[l], u = c[2];
+      if (d === void 0 || u === void 0)
+        throw new Error(\`Unsupported PLY property: "\${i.trim()}"\`);
+      if (f.properties.has(u) || f.listProperties.has(u))
+        throw new Error(\`Duplicate PLY property "\${u}" in element "\${f.name}".\`);
+      f.properties.set(u, { type: l, offset: f.stride }), f.propertyNames.push(u), f.stride += d;
+    }
+  }
+  let o = n.index + n[0].length, a = !0;
+  const h = [];
+  for (const i of s)
+    h.push({
+      name: i.name,
+      count: i.count,
+      properties: i.properties,
+      propertyNames: i.propertyNames,
+      listProperties: i.listProperties,
+      stride: i.stride,
+      offset: a ? o : -1,
+      hasListProperty: i.hasListProperty
+    }), i.hasListProperty ? a = !1 : o += i.count * i.stride;
+  return {
+    elements: h,
+    element: (i) => h.find((c) => c.name === i)
+  };
+}
+function J(e, t) {
+  if (e.offset < 0)
+    throw new Error(
+      \`Unsupported PLY layout: element "\${e.name}" follows a list property, so its position cannot be determined.\`
+    );
+  const r = e.offset + e.count * e.stride;
+  if (r > t)
+    throw new Error(
+      \`Truncated PLY file: element "\${e.name}" needs \${r} bytes but the file is \${t}.\`
+    );
+}
+function D(e, t) {
+  const r = e.properties.get(t);
+  if (!r)
+    throw new Error(\`PLY element "\${e.name}" is missing property "\${t}".\`);
+  return r.offset;
+}
+function W(e, t, r, n) {
+  for (const s of t) {
+    const o = e.properties.get(s);
+    if (!o)
+      throw new Error(\`\${n}: missing property "\${s}".\`);
+    if (!r.includes(o.type))
+      throw new Error(
+        \`Unsupported PLY property type for "\${s}": expected \${r.join(" or ")}, got \${o.type}.\`
+      );
+  }
+}
+const ae = 256, Ct = [
+  "min_x",
+  "min_y",
+  "min_z",
+  "max_x",
+  "max_y",
+  "max_z",
+  "min_scale_x",
+  "min_scale_y",
+  "min_scale_z",
+  "max_scale_x",
+  "max_scale_y",
+  "max_scale_z"
+], vt = ["min_r", "min_g", "min_b", "max_r", "max_g", "max_b"], kt = [
+  "packed_position",
+  "packed_rotation",
+  "packed_scale",
+  "packed_color"
+], Le = { 1: 3, 2: 8, 3: 15 }, we = -4, ye = 4;
+function ze(e) {
+  const t = e.element("vertex");
+  return t !== void 0 && t.properties.has("packed_position");
+}
+function C(e, t) {
+  const r = (1 << t) - 1;
+  return (e & r) / r;
+}
+function M(e, t, r) {
+  return e + (t - e) * r;
+}
+function Ye(e, t) {
+  const r = t.element("chunk"), n = t.element("vertex");
+  if (!r || !n)
+    throw new Error('Compressed PLY is missing its "chunk" or "vertex" element.');
+  W(n, kt, ["uint", "uint32"], "Compressed PLY vertex"), W(r, Ct, ["float", "float32"], "Compressed PLY chunk");
+  const s = r.properties.has("min_r");
+  s && W(
+    r,
+    vt,
+    ["float", "float32"],
+    "Compressed PLY chunk"
+  ), J(r, e.byteLength), J(n, e.byteLength);
+  const o = n.count, a = Math.ceil(o / ae);
+  if (r.count < a)
+    throw new Error(
+      \`Compressed PLY declares \${r.count} chunks, too few for \${o} splats (needs \${a} at \${ae} splats per chunk).\`
+    );
+  const h = new DataView(e, r.offset), i = new DataView(e, n.offset), c = (w, p) => h.getFloat32(w * r.stride + D(r, p), !0), f = D(n, "packed_position"), l = D(n, "packed_rotation"), d = D(n, "packed_scale"), u = D(n, "packed_color"), y = new Float32Array(o * 3), m = new Uint8Array(o * 4), b = new Float32Array(o * 6);
+  for (let w = 0; w < a; w++) {
+    const p = c(w, "min_x"), A = c(w, "min_y"), g = c(w, "min_z"), E = c(w, "max_x"), v = c(w, "max_y"), U = c(w, "max_z"), T = c(w, "min_scale_x"), F = c(w, "min_scale_y"), N = c(w, "min_scale_z"), V = c(w, "max_scale_x"), S = c(w, "max_scale_y"), X = c(w, "max_scale_z"), B = s ? c(w, "min_r") : 0, j = s ? c(w, "min_g") : 0, k = s ? c(w, "min_b") : 0, x = s ? c(w, "max_r") : 1, Z = s ? c(w, "max_g") : 1, re = s ? c(w, "max_b") : 1, xe = w * ae, ht = Math.min(xe + ae, o);
+    for (let L = xe; L < ht; L++) {
+      const ne = L * n.stride, le = i.getUint32(ne + f, !0);
+      y[L * 3 + 0] = M(p, E, C(le >>> 21, 11)), y[L * 3 + 1] = M(A, v, C(le >>> 11, 10)), y[L * 3 + 2] = M(g, U, C(le, 11));
+      const oe = i.getUint32(ne + u, !0), Ce = C(oe >>> 24, 8), ve = C(oe >>> 16, 8), ke = C(oe >>> 8, 8), ft = C(oe, 8);
+      m[L * 4 + 0] = ie(s ? M(B, x, Ce) : Ce), m[L * 4 + 1] = ie(s ? M(j, Z, ve) : ve), m[L * 4 + 2] = ie(s ? M(k, re, ke) : ke), m[L * 4 + 3] = ie(ft);
+      const de = i.getUint32(ne + d, !0), lt = Math.exp(M(T, V, C(de >>> 21, 11))), dt = Math.exp(M(F, S, C(de >>> 11, 10))), ut = Math.exp(M(N, X, C(de, 11))), q = i.getUint32(ne + l, !0), z = (C(q >>> 20, 10) - 0.5) * Math.SQRT2, Y = (C(q >>> 10, 10) - 0.5) * Math.SQRT2, G = (C(q, 10) - 0.5) * Math.SQRT2, se = Math.sqrt(Math.max(0, 1 - (z * z + Y * Y + G * G))), [wt, yt, mt, pt] = q >>> 30 ? q >>> 30 === 1 ? [z, se, Y, G] : q >>> 30 === 2 ? [z, Y, se, G] : [z, Y, G, se] : [se, z, Y, G];
+      te(b, L, lt, dt, ut, wt, yt, mt, pt);
+    }
+  }
+  const _ = Lt(e, t, o);
+  return { count: o, positions: y, colors: m, covariances: b, ..._ ? { shPacked: _ } : {} };
+}
+function ie(e) {
+  return Math.max(0, Math.min(255, Math.round(e * 255)));
+}
+function Lt(e, t, r) {
+  const n = t.element("sh");
+  if (!n || n.count === 0) return;
+  if (n.count !== r)
+    throw new Error(\`Compressed PLY "sh" element has \${n.count} records for \${r} splats.\`);
+  const s = n.propertyNames.length / 3, o = Number(
+    Object.keys(Le).find((f) => Le[Number(f)] === s)
+  );
+  if (!o)
+    throw new Error(
+      \`Compressed PLY "sh" element has \${n.propertyNames.length} properties, which is not 3, 8 or 15 coefficients across three channels.\`
+    );
+  const a = Array.from({ length: s * 3 }, (f, l) => \`f_rest_\${l}\`);
+  W(n, a, ["uchar", "uint8"], "Compressed PLY sh"), J(n, e.byteLength);
+  const h = new Uint8Array(e, n.offset), i = a.map((f) => D(n, f)), c = new Uint32Array(r * s);
+  for (let f = 0; f < r; f++) {
+    const l = f * n.stride;
+    for (let d = 0; d < s; d++) {
+      const u = h[l + i[d]] / 255, y = h[l + i[s + d]] / 255, m = h[l + i[2 * s + d]] / 255;
+      c[f * s + d] = (Math.round(u * 2047) | Math.round(y * 1023) << 11 | Math.round(m * 2047) << 21) >>> 0;
+    }
+  }
+  return {
+    bands: o,
+    packed: c,
+    range: { min: [we, we, we], max: [ye, ye, ye] }
+  };
+}
+const $t = 100;
+function Ut(e, t = $t) {
+  let r = -1 / 0;
+  return (n, s) => {
+    const o = s > 0 && n >= s, a = Dt();
+    !o && a - r < t || (r = a, e(n, s));
+  };
+}
+class $e extends Error {
+  constructor(r, n) {
+    super(r, { cause: n.cause });
+    K(this, "phase");
+    K(this, "url");
+    K(this, "status");
+    K(this, "retryable");
+    this.name = "SplatLoadError", this.phase = n.phase, this.url = n.url, this.status = n.status, this.retryable = n.retryable;
+  }
+}
+function Re(e, t) {
+  return {
+    ...e != null && e.headers ? { headers: { ...e.headers } } : {},
+    ...e != null && e.credentials ? { credentials: e.credentials } : {},
+    ...e != null && e.mode ? { mode: e.mode } : {},
+    ...e != null && e.cache ? { cache: e.cache } : {},
+    ...t ? { signal: t } : {}
+  };
+}
+const Mt = 2 ** 31;
+function Pt(e) {
+  return \`\${(e / 1e9).toFixed(1)} GB\`;
+}
+async function Ge(e) {
+  if (e.size > Mt)
+    throw new Error(
+      \`\${e.name} is \${Pt(e.size)}. A browser cannot read more than 2 GB of a file at once, and this format has to be decoded in one piece. Convert it to SOG (npx @playcanvas/splat-transform in.ply out.sog) or a compressed .ply.\`
+    );
+  try {
+    return await e.arrayBuffer();
+  } catch (t) {
+    throw $(t) ? t : t instanceof Error && t.name === "NotReadableError" ? new Error(
+      \`\${e.name} could not be read. It may have been moved, renamed or changed since it was dropped, or it may be on a drive the browser cannot reach.\`,
+      { cause: t }
+    ) : t;
+  }
+}
+function $(e) {
+  return e instanceof Error && e.name === "AbortError";
+}
+function R(e, t) {
+  if (e instanceof $e) return e;
+  const r = e instanceof Error ? e.message : String(e);
+  return new $e(r, {
+    ...t,
+    retryable: Ft(t.status, t.phase),
+    cause: e
+  });
+}
+function Tt(e) {
+  return {
+    name: e.name,
+    message: e.message,
+    phase: e.phase,
+    url: e.url,
+    ...e.status === void 0 ? {} : { status: e.status },
+    retryable: e.retryable
+  };
+}
+function Dt() {
+  var e;
+  return ((e = globalThis.performance) == null ? void 0 : e.now()) ?? Date.now();
+}
+function Ft(e, t) {
+  return e !== void 0 ? e === 408 || e === 425 || e === 429 || e >= 500 : t === "fetch" || t === "manifest" || t === "worker";
+}
+const Nt = [
+  "x",
+  "y",
+  "z",
+  "f_dc_0",
+  "f_dc_1",
+  "f_dc_2",
+  "opacity",
+  "scale_0",
+  "scale_1",
+  "scale_2",
+  "rot_0",
+  "rot_1",
+  "rot_2",
+  "rot_3"
+], Ot = { 3: 1, 8: 2, 15: 3 };
+function It(e) {
+  return 1 / (1 + Math.exp(-e));
+}
+function Bt(e) {
+  const t = qe(e);
+  if (ze(t)) return Ye(e, t);
+  const r = He(t);
+  J(r, e.byteLength);
+  const n = Xe(r.count), s = We(r), o = s ? new Float32Array(r.count * s.coefficients * 3) : null;
+  return Ze(
+    new DataView(e, r.offset),
+    je(r),
+    r.stride,
+    0,
+    0,
+    r.count,
+    n
+  ), s && o && Ke(
+    new DataView(e, r.offset),
+    r.stride,
+    0,
+    0,
+    r.count,
+    s,
+    o
+  ), Ve(r.count, n, s, o);
+}
+const qt = 64 * 1024 * 1024, zt = 64 * 1024;
+async function Yt(e, t = {}) {
+  const { signal: r, onProgress: n } = t, s = t.windowBytes ?? qt, o = await e.slice(0, Math.min(e.size, zt)).arrayBuffer(), a = qe(o);
+  if (ze(a)) return Ye(await Ge(e), a);
+  const h = He(a);
+  J(h, e.size), r == null || r.throwIfAborted();
+  const i = h.count, c = h.stride, f = Xe(i), l = je(h), d = We(h), u = d ? new Float32Array(i * d.coefficients * 3) : null, y = Math.max(1, Math.floor(s / c)), m = i * c;
+  n == null || n(0, m);
+  for (let b = 0; b < i; b += y) {
+    r == null || r.throwIfAborted();
+    const _ = Math.min(b + y, i), w = e.slice(h.offset + b * c, h.offset + _ * c), p = new DataView(await w.arrayBuffer());
+    Ze(p, l, c, b, b, _, f), d && u && Ke(p, c, b, b, _, d, u), n == null || n(_ * c, m);
+  }
+  return Ve(i, f, d, u);
+}
+function He(e) {
+  const t = e.element("vertex");
+  if (!t) throw new Error('PLY file is not a Gaussian splat file: no "vertex" element.');
+  return W(
+    t,
+    Nt,
+    ["float", "float32"],
+    "PLY file is not a Gaussian splat file"
+  ), t;
+}
+function We(e) {
+  const t = e.propertyNames.filter((a) => a.startsWith("f_rest_"));
+  if (t.length === 0) return null;
+  if (t.length % 3 !== 0)
+    throw new Error(
+      \`PLY vertex has \${t.length} f_rest_* properties, which is not divisible by three.\`
+    );
+  const r = t.length / 3, n = Ot[r];
+  if (!n)
+    throw new Error(
+      \`PLY vertex has \${r} SH coefficients per channel; expected 3, 8 or 15.\`
+    );
+  const s = Array.from({ length: r * 3 }, (a, h) => \`f_rest_\${h}\`);
+  W(e, s, ["float", "float32"], "PLY f_rest");
+  const o = s.map((a) => D(e, a));
+  return { bands: n, coefficients: r, offsets: o };
+}
+function Ve(e, t, r, n) {
+  const s = r && n ? Ae(n, e, r.bands) : void 0;
+  return { count: e, ...t, ...s ? { shPacked: s } : {} };
+}
+function Xe(e) {
+  return {
+    positions: new Float32Array(e * 3),
+    colors: new Uint8Array(e * 4),
+    covariances: new Float32Array(e * 6)
+  };
+}
+function je(e) {
+  const t = (r) => D(e, r);
+  return {
+    x: t("x"),
+    y: t("y"),
+    z: t("z"),
+    r: t("f_dc_0"),
+    g: t("f_dc_1"),
+    b: t("f_dc_2"),
+    alpha: t("opacity"),
+    s0: t("scale_0"),
+    s1: t("scale_1"),
+    s2: t("scale_2"),
+    q0: t("rot_0"),
+    q1: t("rot_1"),
+    q2: t("rot_2"),
+    q3: t("rot_3")
+  };
+}
+function Ze(e, t, r, n, s, o, a) {
+  const { positions: h, colors: i, covariances: c } = a;
+  for (let f = s; f < o; f++) {
+    const l = (f - n) * r, d = (y) => e.getFloat32(l + y, !0);
+    h[f * 3 + 0] = d(t.x), h[f * 3 + 1] = d(t.y), h[f * 3 + 2] = d(t.z);
+    const u = (y) => Math.max(0, Math.min(255, Math.round((0.5 + Be * y) * 255)));
+    i[f * 4 + 0] = u(d(t.r)), i[f * 4 + 1] = u(d(t.g)), i[f * 4 + 2] = u(d(t.b)), i[f * 4 + 3] = Math.round(It(d(t.alpha)) * 255), te(
+      c,
+      f,
+      Math.exp(d(t.s0)),
+      Math.exp(d(t.s1)),
+      Math.exp(d(t.s2)),
+      d(t.q0),
+      d(t.q1),
+      d(t.q2),
+      d(t.q3)
+    );
+  }
+}
+function Ke(e, t, r, n, s, o, a) {
+  const { coefficients: h, offsets: i } = o;
+  for (let c = n; c < s; c++) {
+    const f = (c - r) * t, l = c * h * 3;
+    for (let d = 0; d < h; d++)
+      a[l + d * 3 + 0] = e.getFloat32(f + i[d], !0), a[l + d * 3 + 1] = e.getFloat32(f + i[h + d], !0), a[l + d * 3 + 2] = e.getFloat32(
+        f + i[2 * h + d],
+        !0
+      );
+  }
+}
+const Ue = 1 << 24;
+async function Gt(e, t = {}) {
+  const r = jt(e);
+  return Qe(async (n) => {
+    const s = r.get(n);
+    if (!s) throw new Error(\`SOG bundle is missing "\${n}".\`);
+    return s();
+  }, t.signal);
+}
+async function Ht(e, t = {}) {
+  const r = e.endsWith("/") ? e : \`\${e}/\`;
+  return Qe(async (n) => {
+    var h;
+    Vt(n);
+    const s = (h = t.files) == null ? void 0 : h[n];
+    if (t.files && s === void 0)
+      throw new Error(\`SOG chunk is missing "\${n}".\`);
+    const o = s === void 0 ? new URL(n, r) : new URL(s);
+    let a;
+    try {
+      a = await fetch(o, Re(t.request, t.signal));
+    } catch (i) {
+      throw $(i) ? i : R(i, { phase: "fetch", url: o.href });
+    }
+    if (!a.ok)
+      throw R(new Error(\`Failed to load \${o.href}: HTTP \${a.status}\`), {
+        phase: "fetch",
+        url: o.href,
+        status: a.status
+      });
+    return new Uint8Array(await a.arrayBuffer());
+  }, t.signal);
+}
+async function Qe(e, t) {
+  const r = JSON.parse(new TextDecoder().decode(await e("meta.json")));
+  Wt(r), t == null || t.throwIfAborted();
+  const [n, s, o, a, h] = await Promise.all([
+    e(r.means.files[0] ?? "means_l.webp").then(O),
+    e(r.means.files[1] ?? "means_u.webp").then(O),
+    e(r.quats.files[0] ?? "quats.webp").then(O),
+    e(r.scales.files[0] ?? "scales.webp").then(O),
+    e(r.sh0.files[0] ?? "sh0.webp").then(O)
+  ]);
+  t == null || t.throwIfAborted();
+  const i = r.count;
+  H(n, "means_l", i), H(s, "means_u", i), H(o, "quats", i), H(a, "scales", i), H(h, "sh0", i);
+  const c = new Float32Array(i * 3), f = new Uint8Array(i * 4), l = new Float32Array(i * 6), { mins: d, maxs: u } = r.means, y = (w) => Math.sign(w) * (Math.exp(Math.abs(w)) - 1), m = (w) => (w / 255 - 0.5) * Math.SQRT2, b = (w) => Math.max(0, Math.min(255, Math.round((0.5 + w * Be) * 255)));
+  for (let w = 0; w < i; w++) {
+    t && (w & 65535) === 0 && w > 0 && (await new Promise((S) => setTimeout(S, 0)), t.throwIfAborted());
+    const p = w * 4;
+    for (let S = 0; S < 3; S++) {
+      const X = (s.data[p + S] << 8 | n.data[p + S]) / 65535, B = d[S], j = u[S];
+      c[w * 3 + S] = y(B + (j - B) * X);
+    }
+    f[p + 0] = b(r.sh0.codebook[h.data[p + 0]]), f[p + 1] = b(r.sh0.codebook[h.data[p + 1]]), f[p + 2] = b(r.sh0.codebook[h.data[p + 2]]), f[p + 3] = h.data[p + 3];
+    const A = m(o.data[p + 0]), g = m(o.data[p + 1]), E = m(o.data[p + 2]), v = Math.sqrt(Math.max(0, 1 - (A * A + g * g + E * E))), U = o.data[p + 3] - 252, [T, F, N, V] = U === 0 ? [v, A, g, E] : U === 1 ? [A, v, g, E] : U === 2 ? [A, g, v, E] : [A, g, E, v];
+    te(
+      l,
+      w,
+      Math.exp(r.scales.codebook[a.data[p + 0]]),
+      Math.exp(r.scales.codebook[a.data[p + 1]]),
+      Math.exp(r.scales.codebook[a.data[p + 2]]),
+      T,
+      F,
+      N,
+      V
+    );
+  }
+  t == null || t.throwIfAborted();
+  const _ = r.shN ? await Xt(r.shN, i, e) : void 0;
+  return { count: i, positions: c, colors: f, covariances: l, sh: _, antialias: r.antialias === !0 };
+}
+function Wt(e) {
+  var t, r, n, s;
+  if (e.version !== 2) throw new Error(\`Unsupported SOG version: \${e.version}.\`);
+  if (!Number.isSafeInteger(e.count) || e.count < 0)
+    throw new Error(\`SOG meta.json declares an invalid splat count: \${e.count}.\`);
+  if (e.count > Ue)
+    throw new Error(
+      \`SOG meta.json declares \${e.count} splats, above the supported maximum of \${Ue}.\`
+    );
+  if (Me((t = e.means) == null ? void 0 : t.mins, "means.mins"), Me((r = e.means) == null ? void 0 : r.maxs, "means.maxs"), me((n = e.scales) == null ? void 0 : n.codebook, "scales"), me((s = e.sh0) == null ? void 0 : s.codebook, "sh0"), e.shN) {
+    me(e.shN.codebook, "shN");
+    const o = e.shN.bands;
+    if (!Number.isInteger(o) || o < 1 || o > 3)
+      throw new Error(\`SOG meta.json declares an invalid shN band count: \${o}.\`);
+  }
+}
+function Me(e, t) {
+  if (!Array.isArray(e) || e.length !== 3 || e.some((r) => typeof r != "number" || !Number.isFinite(r)))
+    throw new Error(\`SOG meta.json: "\${t}" must be an array of 3 finite numbers.\`);
+}
+function me(e, t) {
+  if (!Array.isArray(e) || e.length < 256)
+    throw new Error(\`SOG meta.json: the "\${t}" codebook must contain at least 256 entries.\`);
+  for (const r of e)
+    if (typeof r != "number" || !Number.isFinite(r))
+      throw new Error(\`SOG meta.json: the "\${t}" codebook contains a non-finite entry.\`);
+}
+function H(e, t, r) {
+  if (r > e.width * e.height)
+    throw new Error(
+      \`SOG "\${t}" image (\${e.width}×\${e.height}) holds fewer than the declared \${r} splats.\`
+    );
+}
+function Vt(e) {
+  if (typeof e != "string" || e.length === 0 || /^[a-z][a-z0-9+.-]*:/i.test(e) || e.startsWith("/") || e.includes("\\\\") || e.split("/").some((r) => r === ".."))
+    throw new Error(\`SOG meta.json references a file outside its directory: "\${e}".\`);
+}
+async function Xt(e, t, r) {
+  const [n, s] = await Promise.all([
+    r(e.files[0] ?? "shN_centroids.webp").then(O),
+    r(e.files[1] ?? "shN_labels.webp").then(O)
+  ]);
+  H(s, "shN labels", t);
+  const o = e.bands === 1 ? 3 : e.bands === 2 ? 8 : 15, a = new Uint32Array(t);
+  for (let i = 0; i < t; i++) {
+    const c = s.data[i * 4] | s.data[i * 4 + 1] << 8, f = Math.floor(c / 64), l = c % 64 * o;
+    if (f >= n.height || l + o > n.width)
+      throw new Error(
+        \`SOG shN label \${c} (splat \${i}) lies outside the \${n.width}×\${n.height} centroids palette.\`
+      );
+    a[i] = c;
+  }
+  const h = new Float32Array(n.width * n.height * 4);
+  for (let i = 0; i < n.width * n.height; i++)
+    h[i * 4 + 0] = e.codebook[n.data[i * 4 + 0]], h[i * 4 + 1] = e.codebook[n.data[i * 4 + 1]], h[i * 4 + 2] = e.codebook[n.data[i * 4 + 2]];
+  return {
+    bands: e.bands,
+    labels: a,
+    palette: h,
+    paletteWidth: n.width,
+    paletteHeight: n.height
+  };
+}
+function jt(e) {
+  const t = new DataView(e), r = new Uint8Array(e);
+  let n = -1;
+  const s = Math.max(0, e.byteLength - 65557);
+  for (let i = e.byteLength - 22; i >= s && !(i < 0); i--)
+    if (t.getUint32(i, !0) === 101010256) {
+      n = i;
+      break;
+    }
+  if (n < 0) throw new Error("Not a ZIP archive (no end-of-central-directory record).");
+  const o = t.getUint16(n + 10, !0);
+  let a = t.getUint32(n + 16, !0);
+  const h = /* @__PURE__ */ new Map();
+  for (let i = 0; i < o; i++) {
+    if (a < 0 || a + 46 > e.byteLength)
+      throw new Error("Corrupt ZIP central directory.");
+    if (t.getUint32(a, !0) !== 33639248)
+      throw new Error("Corrupt ZIP central directory.");
+    const c = t.getUint16(a + 10, !0), f = t.getUint32(a + 20, !0), l = t.getUint16(a + 28, !0), d = t.getUint16(a + 30, !0), u = t.getUint16(a + 32, !0), y = t.getUint32(a + 42, !0);
+    if (a + 46 + l > e.byteLength)
+      throw new Error("Corrupt ZIP central directory.");
+    const m = new TextDecoder().decode(r.subarray(a + 46, a + 46 + l));
+    a += 46 + l + d + u, h.set(m, async () => {
+      if (y + 30 > e.byteLength)
+        throw new Error(\`Corrupt ZIP entry "\${m}": local header extends past the archive.\`);
+      const b = t.getUint16(y + 26, !0), _ = t.getUint16(y + 28, !0), w = y + 30 + b + _;
+      if (w + f > e.byteLength)
+        throw new Error(\`Corrupt ZIP entry "\${m}": data extends past the archive.\`);
+      const p = r.subarray(w, w + f);
+      if (c === 0) return p;
+      if (c === 8) {
+        const A = new Blob([p]).stream().pipeThrough(new DecompressionStream("deflate-raw"));
+        return new Uint8Array(await new Response(A).arrayBuffer());
+      }
+      throw new Error(\`Unsupported ZIP compression method \${c} for "\${m}".\`);
+    });
+  }
+  return h;
+}
+let ce;
+function Zt() {
+  if (!("OffscreenCanvas" in globalThis) || !("createImageBitmap" in globalThis)) return;
+  if (ce && !ce.isContextLost()) return ce;
+  const t = new OffscreenCanvas(1, 1).getContext("webgl2", {
+    alpha: !1,
+    antialias: !1,
+    depth: !1,
+    premultipliedAlpha: !1,
+    preserveDrawingBuffer: !0,
+    stencil: !1
+  });
+  if (t)
+    return ce = t, t;
+}
+async function Kt(e, t) {
+  const r = e, n = await createImageBitmap(new Blob([r], { type: "image/webp" }), {
+    colorSpaceConversion: "none",
+    premultiplyAlpha: "none"
+  }), s = t.createTexture(), o = t.createFramebuffer();
+  if (!s || !o)
+    throw n.close(), new Error("Could not allocate a WebGL texture for SOG WebP decoding.");
+  try {
+    if (t.bindTexture(t.TEXTURE_2D, s), t.pixelStorei(t.UNPACK_FLIP_Y_WEBGL, !1), t.pixelStorei(t.UNPACK_PREMULTIPLY_ALPHA_WEBGL, !1), t.pixelStorei(t.UNPACK_COLORSPACE_CONVERSION_WEBGL, t.NONE), t.texParameteri(t.TEXTURE_2D, t.TEXTURE_MIN_FILTER, t.NEAREST), t.texParameteri(t.TEXTURE_2D, t.TEXTURE_MAG_FILTER, t.NEAREST), t.texParameteri(t.TEXTURE_2D, t.TEXTURE_WRAP_S, t.CLAMP_TO_EDGE), t.texParameteri(t.TEXTURE_2D, t.TEXTURE_WRAP_T, t.CLAMP_TO_EDGE), t.texImage2D(
+      t.TEXTURE_2D,
+      0,
+      t.RGBA,
+      t.RGBA,
+      t.UNSIGNED_BYTE,
+      n
+    ), t.bindFramebuffer(t.FRAMEBUFFER, o), t.framebufferTexture2D(
+      t.FRAMEBUFFER,
+      t.COLOR_ATTACHMENT0,
+      t.TEXTURE_2D,
+      s,
+      0
+    ), t.checkFramebufferStatus(t.FRAMEBUFFER) !== t.FRAMEBUFFER_COMPLETE)
+      throw new Error("Could not read the decoded SOG WebP texture.");
+    const a = new Uint8Array(n.width * n.height * 4);
+    return t.readPixels(
+      0,
+      0,
+      n.width,
+      n.height,
+      t.RGBA,
+      t.UNSIGNED_BYTE,
+      a
+    ), { width: n.width, height: n.height, data: a };
+  } finally {
+    t.bindFramebuffer(t.FRAMEBUFFER, null), t.bindTexture(t.TEXTURE_2D, null), t.deleteFramebuffer(o), t.deleteTexture(s), n.close();
+  }
+}
+async function O(e) {
+  const t = Zt();
+  if (t) return Kt(e, t);
+  if ("ImageDecoder" in globalThis) {
+    const h = new ImageDecoder({
+      data: e,
+      type: "image/webp",
+      colorSpaceConversion: "none"
+    }), { image: i } = await h.decode(), c = i.codedWidth, f = i.codedHeight, l = new Uint8Array(c * f * 4);
+    return await i.copyTo(l, { format: "RGBA" }), i.close(), h.close(), { width: c, height: f, data: l };
+  }
+  const r = e, n = await createImageBitmap(new Blob([r], { type: "image/webp" }), {
+    premultiplyAlpha: "none",
+    colorSpaceConversion: "none"
+  }), o = new OffscreenCanvas(n.width, n.height).getContext("2d");
+  if (!o) throw new Error("Could not create a 2D canvas context.");
+  o.drawImage(n, 0, 0);
+  const a = o.getImageData(0, 0, n.width, n.height);
+  return n.close(), {
+    width: a.width,
+    height: a.height,
+    data: new Uint8Array(a.data.buffer)
+  };
+}
+function Se(e) {
+  const t = e & 32768 ? -1 : 1, r = e >>> 10 & 31, n = e & 1023;
+  return r === 0 ? t * 2 ** -14 * (n / 1024) : r === 31 ? n === 0 ? t * (1 / 0) : Number.NaN : t * 2 ** (r - 15) * (1 + n / 1024);
+}
+const Qt = new Float32Array(1);
+new Uint32Array(Qt.buffer);
+function Jt(e) {
+  return e.encoding === "f32" ? 4 : e.encoding === "f16" ? 2 : 1;
+}
+function pe(e) {
+  if (e.min === void 0 || e.max === void 0)
+    throw new Error(\`RAD "\${e.property}" (\${e.encoding}) is missing its min/max range.\`);
+  return { min: e.min, max: e.max };
+}
+function Pe(e) {
+  if (e.max === void 0)
+    throw new Error(\`RAD "\${e.property}" (\${e.encoding}) is missing its max range.\`);
+  return e.max;
+}
+function I(e, t, r, n, s) {
+  if (e.byteLength < n * r * s)
+    throw new Error(
+      \`RAD "\${t.property}" column holds \${e.byteLength} bytes, fewer than the \${n * r * s} its declared \${n} splats need.\`
+    );
+}
+function Q(e, t, r, n) {
+  switch (I(e, t, r, n, Jt(t)), t.encoding) {
+    case "f32":
+      return Je(e, r, n);
+    case "f16":
+      return et(e, r, n);
+    case "f32_lebytes":
+      return or(e, r, n);
+    case "f16_lebytes":
+      return sr(e, r, n);
+    case "r8": {
+      const { min: s, max: o } = pe(t);
+      return ar(e, r, n, s, o);
+    }
+    case "r8_delta": {
+      const { min: s, max: o } = pe(t);
+      return ir(e, r, n, s, o);
+    }
+    case "s8":
+      return cr(e, r, n, Pe(t));
+    case "s8_delta":
+      return hr(e, r, n, Pe(t));
+    case "ln_0r8": {
+      const { min: s, max: o } = pe(t);
+      return fr(e, r, n, s, o);
+    }
+    case "ln_f16":
+      return lr(e, r, n);
+    default:
+      throw new Error(\`Unsupported RAD "\${t.property}" encoding "\${t.encoding}".\`);
+  }
+}
+function er(e, t, r) {
+  if (t.encoding === "oct88r8")
+    return I(e, t, 3, r, 1), dr(e, r);
+  (t.encoding === "f32" || t.encoding === "f16") && I(e, t, 3, r, t.encoding === "f32" ? 4 : 2);
+  const n = t.encoding === "f32" ? Je(e, 3, r) : t.encoding === "f16" ? et(e, 3, r) : void 0;
+  if (!n) throw new Error(\`Unsupported RAD orientation encoding "\${t.encoding}".\`);
+  const s = new Float32Array(r * 4);
+  for (let o = 0; o < r; o++) {
+    const a = n[o * 3 + 0], h = n[o * 3 + 1], i = n[o * 3 + 2];
+    s[o * 4 + 0] = a, s[o * 4 + 1] = h, s[o * 4 + 2] = i, s[o * 4 + 3] = Math.sqrt(Math.max(0, 1 - a * a - h * h - i * i));
+  }
+  return s;
+}
+function tr(e, t, r) {
+  if (t.encoding !== "u16")
+    throw new Error(\`Unsupported RAD child_count encoding "\${t.encoding}".\`);
+  return I(e, t, 1, r, 2), tt(e, r);
+}
+function rr(e, t, r) {
+  if (t.encoding !== "u32")
+    throw new Error(\`Unsupported RAD child_start encoding "\${t.encoding}".\`);
+  return I(e, t, 1, r, 4), rt(e, r);
+}
+const Te = new DataView(new ArrayBuffer(4));
+function nr(e) {
+  return Te.setUint32(0, e, !0), Te.getFloat32(0, !0);
+}
+function Je(e, t, r) {
+  const n = new DataView(e.buffer, e.byteOffset, e.byteLength), s = new Float32Array(r * t);
+  for (let o = 0; o < r; o++) {
+    let a = o * 4;
+    for (let h = 0; h < t; h++)
+      s[o * t + h] = n.getFloat32(a, !0), a += r * 4;
+  }
+  return s;
+}
+function et(e, t, r) {
+  const n = new DataView(e.buffer, e.byteOffset, e.byteLength), s = new Float32Array(r * t);
+  for (let o = 0; o < r; o++) {
+    let a = o * 2;
+    for (let h = 0; h < t; h++)
+      s[o * t + h] = Se(n.getUint16(a, !0)), a += r * 2;
+  }
+  return s;
+}
+function or(e, t, r) {
+  const n = r * t, s = new Float32Array(r * t);
+  for (let o = 0; o < r; o++)
+    for (let a = 0; a < t; a++) {
+      const h = r * a + o, i = (e[h] | e[h + n] << 8 | e[h + n * 2] << 16 | e[h + n * 3] << 24) >>> 0;
+      s[o * t + a] = nr(i);
+    }
+  return s;
+}
+function sr(e, t, r) {
+  const n = r * t, s = new Float32Array(r * t);
+  for (let o = 0; o < r; o++)
+    for (let a = 0; a < t; a++) {
+      const h = r * a + o, i = e[h] | e[h + n] << 8;
+      s[o * t + a] = Se(i);
+    }
+  return s;
+}
+function ar(e, t, r, n, s) {
+  const o = new Float32Array(r * t), a = s - n;
+  for (let h = 0; h < r; h++) {
+    let i = h;
+    for (let c = 0; c < t; c++)
+      o[h * t + c] = e[i] / 255 * a + n, i += r;
+  }
+  return o;
+}
+function ir(e, t, r, n, s) {
+  const o = new Float32Array(r * t), a = s - n, h = new Uint8Array(t);
+  for (let i = 0; i < r; i++) {
+    let c = i;
+    for (let f = 0; f < t; f++) {
+      const l = h[f] + e[c] & 255;
+      h[f] = l, o[i * t + f] = l / 255 * a + n, c += r;
+    }
+  }
+  return o;
+}
+function cr(e, t, r, n) {
+  const s = new Float32Array(r * t);
+  for (let o = 0; o < r; o++) {
+    let a = o;
+    for (let h = 0; h < t; h++) {
+      const i = e[a], c = i >= 128 ? i - 256 : i;
+      s[o * t + h] = c / 127 * n, a += r;
+    }
+  }
+  return s;
+}
+function hr(e, t, r, n) {
+  const s = new Float32Array(r * t), o = new Uint8Array(t);
+  for (let a = 0; a < r; a++) {
+    let h = a;
+    for (let i = 0; i < t; i++) {
+      const c = o[i] + e[h] & 255;
+      o[i] = c;
+      const f = c >= 128 ? c - 256 : c;
+      s[a * t + i] = f / 127 * n, h += r;
+    }
+  }
+  return s;
+}
+function fr(e, t, r, n, s) {
+  const o = new Float32Array(r * t), a = (s - n) / 254;
+  for (let h = 0; h < r; h++) {
+    let i = h;
+    for (let c = 0; c < t; c++) {
+      const f = e[i];
+      o[h * t + c] = f === 0 ? 0 : Math.exp(n + (f - 1) * a), i += r;
+    }
+  }
+  return o;
+}
+function lr(e, t, r) {
+  const n = new DataView(e.buffer, e.byteOffset, e.byteLength), s = new Float32Array(r * t);
+  for (let o = 0; o < r; o++) {
+    let a = o * 2;
+    for (let h = 0; h < t; h++)
+      s[o * t + h] = Math.exp(Se(n.getUint16(a, !0))), a += r * 2;
+  }
+  return s;
+}
+function dr(e, t) {
+  const r = new Float32Array(t * 4);
+  for (let n = 0; n < t; n++) {
+    const s = n * 3, o = e[s], a = e[s + 1], h = e[s + 2];
+    let i = o / 255 * 2 - 1, c = a / 255 * 2 - 1;
+    const f = 1 - Math.abs(i) - Math.abs(c), l = Math.max(-f, 0);
+    i = i >= 0 ? i - l : i + l, c = c >= 0 ? c - l : c + l;
+    const d = Math.hypot(i, c, f) || 1, u = h / 255 * 0.5 * Math.PI, y = Math.sin(u), m = Math.cos(u);
+    r[n * 4 + 0] = i / d * y, r[n * 4 + 1] = c / d * y, r[n * 4 + 2] = f / d * y, r[n * 4 + 3] = m;
+  }
+  return r;
+}
+function tt(e, t) {
+  const r = new DataView(e.buffer, e.byteOffset, e.byteLength), n = new Uint16Array(t);
+  for (let s = 0; s < t; s++) n[s] = r.getUint16(s * 2, !0);
+  return n;
+}
+function rt(e, t) {
+  const r = new DataView(e.buffer, e.byteOffset, e.byteLength), n = new Uint32Array(t);
+  for (let s = 0; s < t; s++) n[s] = r.getUint32(s * 4, !0);
+  return n;
+}
+const ur = 809779538, nt = 1128546642, ee = 1 << 24;
+function ot(e, t) {
+  if (!Number.isSafeInteger(e) || e < 0)
+    throw new Error(\`Invalid RAD \${t} splat count: \${e}.\`);
+}
+function wr(e, t) {
+  if (ot(e, t), e > ee)
+    throw new Error(
+      \`RAD \${t} declares \${e} splats, above the supported maximum of \${ee}.\`
+    );
+}
+async function yr(e) {
+  var c;
+  const t = new Uint8Array(e);
+  if (t.byteLength < 8) throw new Error("Truncated RAD file.");
+  if (new DataView(t.buffer, t.byteOffset, t.byteLength).getUint32(0, !0) === nt)
+    return De([await be(t, 0)]);
+  const { meta: s, chunksStart: o } = mr(e);
+  if (s.count > ee)
+    throw new Error(
+      \`RAD header declares \${s.count} splats, above the supported maximum of \${ee} for a one-shot decode; load this file as a streamed scene instead.\`
+    );
+  const a = [];
+  let h, i;
+  for (const [f, l] of s.chunks.entries()) {
+    if (l.filename !== void 0)
+      throw new Error(
+        \`RAD chunk \${f} is an external .radc file ("\${l.filename}"); one-shot loading only supports a single self-contained .rad file.\`
+      );
+    const d = o + l.offset;
+    if (d + l.bytes > t.byteLength)
+      throw new Error(\`RAD chunk \${f} extends past the file.\`);
+    const u = await be(t, d, !0, h, i);
+    h ?? (h = u.shCodebook), i ?? (i = (c = u.shPacked) == null ? void 0 : c.range.max[0]), a.push(u);
+  }
+  return De(a);
+}
+function mr(e) {
+  const t = new Uint8Array(e);
+  if (t.byteLength < 8) throw new Error("Truncated RAD file.");
+  const r = new DataView(t.buffer, t.byteOffset, t.byteLength), n = r.getUint32(0, !0);
+  if (n !== ur)
+    throw new Error(\`Not a RAD file (magic 0x\${n.toString(16).padStart(8, "0")}).\`);
+  const s = r.getUint32(4, !0);
+  if (t.byteLength < 8 + s) throw new Error("Truncated RAD header.");
+  const o = JSON.parse(at(t, 8, s));
+  if (o.version !== 1) throw new Error(\`Unsupported RAD version \${o.version}.\`);
+  if (o.type !== "gsplat") throw new Error(\`Unsupported RAD type "\${o.type}".\`);
+  if (ot(o.count, "header"), !Array.isArray(o.chunks)) throw new Error("RAD header is missing its chunk list.");
+  const a = o.chunks;
+  for (const [h, i] of a.entries())
+    if (!Number.isSafeInteger(i == null ? void 0 : i.offset) || i.offset < 0 || !Number.isSafeInteger(i == null ? void 0 : i.bytes) || i.bytes < 0)
+      throw new Error(\`RAD chunk \${h} declares an invalid byte range.\`);
+  if (o.chunkSize !== void 0) {
+    if (!Number.isSafeInteger(o.chunkSize) || o.chunkSize <= 0 || o.chunkSize > ee)
+      throw new Error(\`Invalid RAD chunk size: \${o.chunkSize}.\`);
+    if (o.count > o.chunkSize * a.length)
+      throw new Error(
+        \`RAD header declares \${o.count} splats, more than its \${a.length} chunks of \${o.chunkSize} can hold.\`
+      );
+  }
+  return { meta: o, chunksStart: 8 + st(s) };
+}
+async function pr(e, t, r, n = !0) {
+  const s = await be(new Uint8Array(e), 0, !0, t, r);
+  return br(s, n);
+}
+function br(e, t) {
+  const { count: r } = e, n = new Float32Array(r * 3), s = new Uint8Array(r * 4), o = new Float32Array(r * 6);
+  if (!e.childCount || !e.childStart) {
+    for (let u = 0; u < r; u++) ge(e, u, u, n, s, o);
+    return {
+      count: r,
+      positions: n,
+      colors: s,
+      covariances: o,
+      ...e.shPacked ? { shPacked: e.shPacked } : {},
+      ...e.shCodebook ? { radShCodebook: e.shCodebook } : {}
+    };
+  }
+  const a = e.childCount, h = e.childStart, i = t ? _r(a, h, r) : Er(r), c = Ar(e.shPacked, i), f = new Uint16Array(r), l = new Uint32Array(r), d = new Float32Array(r);
+  for (let u = 0; u < r; u++) {
+    const y = i[u];
+    ge(e, y, u, n, s, o), f[u] = a[y], l[u] = h[y], d[u] = gr(e.alpha[y], e.scale, y);
+  }
+  return {
+    count: r,
+    positions: n,
+    colors: s,
+    covariances: o,
+    radTree: { childCount: f, childStart: l, size: d },
+    ...c ? { shPacked: c } : {},
+    ...e.shCodebook ? { radShCodebook: e.shCodebook } : {}
+  };
+}
+function gr(e, t, r) {
+  const n = (t[r * 3] + t[r * 3 + 1] + t[r * 3 + 2]) / 3;
+  return 2 * (Math.max(e, 1) * 4 - 3) * n;
+}
+function Er(e) {
+  const t = new Uint32Array(e);
+  for (let r = 0; r < e; r++) t[r] = r;
+  return t;
+}
+function _r(e, t, r) {
+  const n = new Uint32Array(r);
+  for (let o = 0; o < r; o++) n[o] = o;
+  const s = (o) => e[o] === 0 ? Number.MAX_SAFE_INTEGER : t[o];
+  return n.sort((o, a) => s(a) - s(o));
+}
+async function be(e, t, r, n, s) {
+  const o = new DataView(e.buffer, e.byteOffset, e.byteLength), a = o.getUint32(t, !0);
+  if (a !== nt)
+    throw new Error(\`Not a RAD chunk (magic 0x\${a.toString(16).padStart(8, "0")}).\`);
+  const h = o.getUint32(t + 4, !0), i = t + 8 + st(h), c = JSON.parse(at(e, t + 8, h));
+  if (c.version !== 1)
+    throw new Error(\`Unsupported RAD chunk version \${c.version}.\`);
+  const f = Number(o.getBigUint64(i, !0)), l = i + 8;
+  if (l + f > e.byteLength)
+    throw new Error("RAD chunk payload extends past the file.");
+  const { count: d } = c;
+  wr(d, "chunk");
+  const u = c.lodTree ?? !1;
+  if (!Array.isArray(c.properties))
+    throw new Error("RAD chunk metadata is missing its property list.");
+  const y = c.properties, m = new Map(y.map((k) => [k.property, k])), b = async (k) => {
+    const x = m.get(k);
+    if (!x) return;
+    if (!Number.isSafeInteger(x.offset) || x.offset < 0 || !Number.isSafeInteger(x.bytes) || x.bytes < 0)
+      throw new Error(\`RAD property "\${k}" declares an invalid byte range.\`);
+    const Z = l + x.offset;
+    if (x.offset + x.bytes > f || Z + x.bytes > e.byteLength)
+      throw new Error(\`RAD property "\${k}" extends past its chunk.\`);
+    const re = e.subarray(Z, Z + x.bytes);
+    return x.compression === void 0 ? re : Lr(re);
+  }, _ = u, w = [
+    "center",
+    "alpha",
+    "rgb",
+    "scales",
+    "orientation",
+    ..._ ? ["child_count", "child_start"] : [void 0, void 0],
+    "sh1",
+    "sh2",
+    "sh3",
+    "sh_label",
+    "sh1_code",
+    "sh2_code",
+    "sh3_code"
+  ], [
+    p,
+    A,
+    g,
+    E,
+    v,
+    U,
+    T,
+    F,
+    N,
+    V,
+    S,
+    X,
+    B,
+    j
+  ] = await Promise.all(
+    w.map((k) => k === void 0 ? Promise.resolve(void 0) : b(k))
+  );
+  if (!p) throw new Error('RAD chunk is missing its "center" property.');
+  if (!A) throw new Error('RAD chunk is missing its "alpha" property.');
+  if (!g) throw new Error('RAD chunk is missing its "rgb" property.');
+  if (!E) throw new Error('RAD chunk is missing its "scales" property.');
+  if (!v) throw new Error('RAD chunk is missing its "orientation" property.');
+  return {
+    count: d,
+    lodTree: u,
+    center: Q(p, m.get("center"), 3, d),
+    alpha: Q(A, m.get("alpha"), 1, d),
+    rgb: Q(g, m.get("rgb"), 3, d),
+    scale: Q(E, m.get("scales"), 3, d),
+    quat: er(v, m.get("orientation"), d),
+    ..._ && U ? { childCount: tr(U, m.get("child_count"), d) } : {},
+    ..._ && T ? { childStart: rr(T, m.get("child_start"), d) } : {},
+    ...Rr({
+      count: d,
+      byName: m,
+      sh1Raw: F,
+      sh2Raw: N,
+      sh3Raw: V,
+      shLabelRaw: S,
+      sh1CodeRaw: X,
+      sh2CodeRaw: B,
+      sh3CodeRaw: j,
+      knownShCodebook: n,
+      knownShExtent: s
+    })
+  };
+}
+function De(e) {
+  var i;
+  let t = 0;
+  for (const c of e)
+    t += c.childCount ? kr(c.childCount) : c.count;
+  if (t === 0) throw new Error("RAD file has no leaf splats.");
+  const r = new Float32Array(t * 3), n = new Uint8Array(t * 4), s = new Float32Array(t * 6), o = (i = e.find((c) => c.shPacked)) == null ? void 0 : i.shPacked, a = o ? new Uint32Array(t * P(o.bands)) : void 0;
+  a && o && a.fill(At(o.range));
+  let h = 0;
+  for (const c of e)
+    for (let f = 0; f < c.count; f++)
+      if (!(c.childCount && c.childCount[f] !== 0)) {
+        if (ge(c, f, h, r, n, s), a && c.shPacked) {
+          const l = P(o.bands);
+          a.set(c.shPacked.packed.subarray(f * l, (f + 1) * l), h * l);
+        }
+        h++;
+      }
+  return {
+    count: t,
+    positions: r,
+    colors: n,
+    covariances: s,
+    ...o && a ? { shPacked: { ...o, packed: a } } : {}
+  };
+}
+function Ar(e, t) {
+  if (!e) return;
+  const r = P(e.bands), n = new Uint32Array(e.packed.length);
+  for (let s = 0; s < t.length; s++) {
+    const o = t[s];
+    n.set(e.packed.subarray(o * r, (o + 1) * r), s * r);
+  }
+  return { ...e, packed: n };
+}
+function Rr(e) {
+  const t = [e.sh1Raw, e.sh2Raw, e.sh3Raw], r = [e.sh1CodeRaw, e.sh2CodeRaw, e.sh3CodeRaw], n = t.reduce((c, f, l) => f ? l + 1 : c, 0), s = r.reduce((c, f, l) => f ? l + 1 : c, 0);
+  if (n === 0 && s === 0 && !e.shLabelRaw) return {};
+  if (n > 0 && s > 0)
+    throw new Error("RAD chunk mixes direct and codebook SH columns.");
+  let o, a, h, i;
+  if (n > 0)
+    a = n, o = Fe(t, e.byName, e.count, a), i = Sr(e.byName, a) ?? e.knownShExtent;
+  else {
+    if (h = e.knownShCodebook, !h && s > 0) {
+      a = s;
+      const l = xr(
+        r[s - 1],
+        e.byName.get(\`sh\${s}_code\`)
+      );
+      h = {
+        bands: a,
+        count: l,
+        coefficients: Fe(r, e.byName, l, a, "_code")
+      };
+    }
+    if (!h) throw new Error("RAD SH labels require the codebook stored in chunk zero.");
+    if (!e.shLabelRaw)
+      throw new Error('RAD SH codebook chunk is missing its "sh_label" property.');
+    a = h.bands;
+    const c = vr(e.shLabelRaw, e.byName.get("sh_label"), e.count);
+    o = new Float32Array(e.count * P(a) * 3);
+    const f = P(a) * 3;
+    for (let l = 0; l < e.count; l++) {
+      const d = c[l];
+      if (d >= h.count)
+        throw new Error(\`RAD SH label \${d} exceeds its \${h.count}-entry codebook.\`);
+      o.set(
+        h.coefficients.subarray(d * f, (d + 1) * f),
+        l * f
+      );
+    }
+    i = 0;
+    for (const l of h.coefficients) i = Math.max(i, Math.abs(l));
+  }
+  return {
+    shPacked: Ae(o, e.count, a, i),
+    ...h ? { shCodebook: h } : {}
+  };
+}
+function Sr(e, t, r = "") {
+  let n = 0;
+  for (let s = 1; s <= t; s++) {
+    const o = e.get(\`sh\${s}\${r}\`);
+    if (!o) return;
+    let a;
+    switch (o.encoding) {
+      case "s8":
+      case "s8_delta":
+        if (o.max === void 0) return;
+        a = Math.abs(o.max);
+        break;
+      case "r8":
+      case "r8_delta":
+        if (o.min === void 0 || o.max === void 0) return;
+        a = Math.max(Math.abs(o.min), Math.abs(o.max));
+        break;
+      default:
+        return;
+    }
+    n = Math.max(n, a);
+  }
+  return n;
+}
+function Fe(e, t, r, n, s = "") {
+  const o = P(n), a = new Float32Array(r * o * 3);
+  let h = 0;
+  for (let i = 1; i <= n; i++) {
+    const c = e[i - 1], f = t.get(\`sh\${i}\${s}\`);
+    if (!c || !f) throw new Error(\`RAD SH is missing its "sh\${i}\${s}" column.\`);
+    const l = i === 1 ? 9 : i === 2 ? 15 : 21, d = Q(c, f, l, r);
+    for (let u = 0; u < r; u++) {
+      const y = (u * o + h) * 3;
+      for (let m = 0; m < l; m++) a[y + m] = d[u * l + m];
+    }
+    h += l / 3;
+  }
+  return a;
+}
+function xr(e, t) {
+  const r = t.property.startsWith("sh1") ? 9 : t.property.startsWith("sh2") ? 15 : 21, n = Cr(t);
+  if (e.byteLength % (r * n) !== 0)
+    throw new Error(\`RAD "\${t.property}" has an invalid SH column length.\`);
+  return e.byteLength / (r * n);
+}
+function Cr(e) {
+  switch (e.encoding) {
+    case "f32":
+    case "f32_lebytes":
+      return 4;
+    case "f16":
+    case "f16_lebytes":
+    case "ln_f16":
+      return 2;
+    case "r8":
+    case "r8_delta":
+    case "s8":
+    case "s8_delta":
+    case "ln_0r8":
+      return 1;
+    default:
+      throw new Error(\`Unsupported RAD "\${e.property}" encoding "\${e.encoding}".\`);
+  }
+}
+function vr(e, t, r) {
+  if (t.encoding === "u16")
+    return I(e, t, 1, r, 2), Uint32Array.from(tt(e, r));
+  if (t.encoding === "u32")
+    return I(e, t, 1, r, 4), rt(e, r);
+  throw new Error(\`Unsupported RAD sh_label encoding "\${t.encoding}".\`);
+}
+function ge(e, t, r, n, s, o) {
+  const a = e.alpha[t];
+  n[r * 3 + 0] = e.center[t * 3 + 0], n[r * 3 + 1] = e.center[t * 3 + 1], n[r * 3 + 2] = e.center[t * 3 + 2], s[r * 4 + 0] = he(e.rgb[t * 3 + 0] * 255), s[r * 4 + 1] = he(e.rgb[t * 3 + 1] * 255), s[r * 4 + 2] = he(e.rgb[t * 3 + 2] * 255), s[r * 4 + 3] = he(a * 0.5 * 255), te(
+    o,
+    r,
+    e.scale[t * 3 + 0],
+    e.scale[t * 3 + 1],
+    e.scale[t * 3 + 2],
+    e.quat[t * 4 + 3],
+    // w
+    e.quat[t * 4 + 0],
+    // x
+    e.quat[t * 4 + 1],
+    // y
+    e.quat[t * 4 + 2]
+    // z
+  );
+}
+function kr(e) {
+  let t = 0;
+  for (const r of e) r === 0 && t++;
+  return t;
+}
+function he(e) {
+  return Math.max(0, Math.min(255, Math.round(e)));
+}
+function st(e) {
+  return e + 7 & -8;
+}
+function at(e, t, r) {
+  return new TextDecoder().decode(e.subarray(t, t + r));
+}
+async function Lr(e) {
+  if (typeof DecompressionStream > "u")
+    throw new Error("This runtime does not provide decompression required for RAD files.");
+  const t = e[0] === 31 && e[1] === 139 ? "gzip" : e[0] === 120 ? "deflate" : "deflate-raw", r = new Uint8Array(e.byteLength);
+  r.set(e);
+  const n = new Blob([r.buffer]).stream().pipeThrough(new DecompressionStream(t));
+  return new Uint8Array(await new Response(n).arrayBuffer());
+}
+const fe = 32, Ee = 64, Ne = 1 << 24;
+function $r(e) {
+  return e === 1 ? 3 : e === 2 ? 8 : 15;
+}
+function Ur(e) {
+  const t = e >>> 30 & 3, r = [0, 0, 0, 0];
+  let n = 0;
+  for (let o = 0; o < 4; o++) {
+    if (o === t) continue;
+    const a = e >>> 10 * n & 1023;
+    r[o] = (a - 511) * Mr, n++;
+  }
+  const s = r[0] ** 2 + r[1] ** 2 + r[2] ** 2 + r[3] ** 2;
+  return r[t] = Math.sqrt(Math.max(0, 1 - s)), [r[3], r[0], r[1], r[2]];
+}
+const Mr = 1 / (511 * Math.SQRT2);
+async function Pr(e, t, r, n) {
+  var A;
+  const s = t.stride;
+  if (s !== fe && s !== fe + Ee)
+    throw new Error(\`LCC chunk declares an unsupported \${s}-byte record.\`);
+  if (((A = t.sh) == null ? void 0 : A.source) === "inline" && s === fe)
+    throw new Error("LCC chunk asks for inline SH but its records have no room for it.");
+  if (e.byteLength % s !== 0)
+    throw new Error(
+      \`LCC chunk is \${e.byteLength} bytes, not a multiple of the \${s}-byte record.\`
+    );
+  const o = e.byteLength / s;
+  if (o > Ne)
+    throw new Error(
+      \`LCC chunk holds \${o} splats, above the supported maximum of \${Ne}.\`
+    );
+  const a = new DataView(e), h = new Float32Array(o * 3), i = new Uint8Array(o * 4), c = new Float32Array(o * 6), f = new Uint8Array(e), { min: l, max: d } = t.scale, u = l[0], y = l[1], m = l[2], b = d[0] - l[0], _ = d[1] - l[1], w = d[2] - l[2];
+  for (let g = 0; g < o; g++) {
+    n && (g & 65535) === 0 && g > 0 && (await new Promise((N) => setTimeout(N, 0)), n.throwIfAborted());
+    const E = g * s;
+    h[g * 3 + 0] = a.getFloat32(E, !0), h[g * 3 + 1] = a.getFloat32(E + 4, !0), h[g * 3 + 2] = a.getFloat32(E + 8, !0), i[g * 4 + 0] = f[E + 12], i[g * 4 + 1] = f[E + 13], i[g * 4 + 2] = f[E + 14], i[g * 4 + 3] = f[E + 15];
+    const [v, U, T, F] = Ur(a.getUint32(E + 22, !0));
+    te(
+      c,
+      g,
+      u + b * (a.getUint16(E + 16, !0) / 65535),
+      y + _ * (a.getUint16(E + 18, !0) / 65535),
+      m + w * (a.getUint16(E + 20, !0) / 65535),
+      v,
+      U,
+      T,
+      F
+    );
+  }
+  n == null || n.throwIfAborted();
+  const p = t.sh ? Tr(e, r, t.sh, o, s) : void 0;
+  return {
+    count: o,
+    positions: h,
+    colors: i,
+    covariances: c,
+    ...p ? { shPacked: p } : {}
+  };
+}
+function Tr(e, t, r, n, s) {
+  const o = $r(r.bands), a = new Uint32Array(n * o);
+  if (r.source === "inline") {
+    const c = new DataView(e);
+    for (let f = 0; f < n; f++) {
+      const l = f * s + fe;
+      for (let d = 0; d < o; d++)
+        a[f * o + d] = c.getUint32(l + d * 4, !0);
+    }
+    return Oe(a, r);
+  }
+  if (!t) throw new Error("LCC chunk expected shcoef.bin bytes but none were fetched.");
+  const h = n * Ee;
+  if (t.byteLength !== h)
+    throw new Error(
+      \`LCC shcoef.bin range is \${t.byteLength} bytes; expected \${h} for \${n} splats.\`
+    );
+  const i = new DataView(t);
+  for (let c = 0; c < n; c++) {
+    const f = c * Ee;
+    for (let l = 0; l < o; l++)
+      a[c * o + l] = i.getUint32(f + l * 4, !0);
+  }
+  return Oe(a, r);
+}
+function Oe(e, t) {
+  const r = t.requantizeTo;
+  if (!r || Rt(t.range, r))
+    return { bands: t.bands, packed: e, range: t.range };
+  for (let n = 0; n < e.length; n++)
+    e[n] = xt(e[n], t.range, r);
+  return { bands: t.bands, packed: e, range: r };
+}
+function it(e) {
+  const t = e.indexOf("#");
+  return t < 0 ? e : e.slice(0, t);
+}
+async function _e(e, t, r, n, s) {
+  const o = Re(n, s);
+  let a;
+  try {
+    a = await fetch(e, {
+      ...o,
+      headers: { ...(n == null ? void 0 : n.headers) ?? {}, Range: \`bytes=\${t}-\${t + r - 1}\` }
+    });
+  } catch (i) {
+    throw $(i) ? i : R(i, { phase: "fetch", url: e });
+  }
+  if (!a.ok)
+    throw R(new Error(\`Failed to load \${e}: HTTP \${a.status}\`), {
+      phase: "fetch",
+      url: e,
+      status: a.status
+    });
+  if (a.status !== 206)
+    throw R(
+      new Error(
+        \`\${e} ignored a Range request (HTTP \${a.status}); LCC streaming needs a server that answers 206 Partial Content.\`
+      ),
+      { phase: "fetch", url: e, status: a.status }
+    );
+  let h;
+  try {
+    h = await a.arrayBuffer();
+  } catch (i) {
+    throw $(i) ? i : R(i, { phase: "fetch", url: e });
+  }
+  if (h.byteLength !== r)
+    throw R(
+      new Error(\`\${e} returned \${h.byteLength} bytes for a \${r}-byte range.\`),
+      { phase: "fetch", url: e }
+    );
+  return h;
+}
+async function ct(e, t, r, n) {
+  let s;
+  try {
+    s = await fetch(e, Re(t, r));
+  } catch (o) {
+    throw $(o) ? o : R(o, { phase: "fetch", url: e });
+  }
+  if (!s.ok)
+    throw R(new Error(\`Failed to load \${e}: HTTP \${s.status}\`), {
+      phase: "fetch",
+      url: e,
+      status: s.status
+    });
+  try {
+    return !n || !s.body ? await s.arrayBuffer() : await Dr(s, n);
+  } catch (o) {
+    throw $(o) ? o : R(o, { phase: "fetch", url: e });
+  }
+}
+async function Dr(e, t) {
+  const r = Number(e.headers.get("Content-Length")), n = Number.isSafeInteger(r) && r > 0 ? r : 0, s = e.body.getReader(), o = [], a = n > 0 ? new Uint8Array(n) : null;
+  let h = 0;
+  for (t(0, n); ; ) {
+    const { done: f, value: l } = await s.read();
+    if (f) break;
+    if (a) {
+      if (h + l.byteLength > n)
+        throw new Error(\`Response body is longer than its Content-Length of \${n} bytes.\`);
+      a.set(l, h);
+    } else
+      o.push(l);
+    h += l.byteLength, t(h, n);
+  }
+  if (a) {
+    if (h !== n)
+      throw new Error(\`Response body ended at \${h} bytes, short of its \${n}-byte length.\`);
+    return a.buffer;
+  }
+  const i = new Uint8Array(h);
+  let c = 0;
+  for (const f of o)
+    i.set(f, c), c += f.byteLength;
+  return i.buffer;
+}
+function Fr(e) {
+  const t = /* @__PURE__ */ new Map();
+  self.onmessage = async (r) => {
+    var i;
+    const n = self, s = r.data;
+    if (s.type === "cancel") {
+      (i = t.get(s.id)) == null || i.abort();
+      return;
+    }
+    const o = new AbortController();
+    t.set(s.id, o);
+    const a = s.source.from === "url" ? s.source.url : s.source.file.name, h = s.progress ? Ut((c, f) => {
+      const l = { type: "progress", id: s.id, loaded: c, total: f };
+      n.postMessage(l);
+    }) : void 0;
+    try {
+      const c = await e(s, o.signal, h), f = [c.positions.buffer, c.colors.buffer, c.covariances.buffer];
+      c.sh && f.push(c.sh.labels.buffer, c.sh.palette.buffer), c.shPacked && f.push(c.shPacked.packed.buffer), c.radTree && f.push(
+        c.radTree.childCount.buffer,
+        c.radTree.childStart.buffer,
+        c.radTree.size.buffer
+      );
+      const l = { type: "result", id: s.id, ok: !0, data: c };
+      n.postMessage(l, f);
+    } catch (c) {
+      const f = {
+        type: "result",
+        id: s.id,
+        ok: !1,
+        error: Tt(R(c, { phase: "worker", url: a })),
+        cancelled: o.signal.aborted || $(c)
+      };
+      n.postMessage(f);
+    } finally {
+      t.delete(s.id);
+    }
+  };
+}
+Fr(
+  (e, t, r) => Nr(
+    e.source,
+    e.format,
+    t,
+    e.lcc,
+    e.rad,
+    e.files,
+    e.sog,
+    r
+  )
+);
+async function Nr(e, t, r, n, s, o, a, h) {
+  if (e.from === "url" && e.kind === "directory") {
+    const f = await Ht(e.url, {
+      signal: r,
+      ...e.request ? { request: e.request } : {},
+      ...o ? { files: o } : {}
+    });
+    return a ? Ie(f, a.packShBands) : f;
+  }
+  if (t === "lcc-bin") {
+    if (e.from !== "url") throw new Error("LCC chunks must be loaded from a URL.");
+    if (!n) throw new Error("LCC chunk request is missing its byte range.");
+    return Or(e, n, r);
+  }
+  if (t === "rad-chunk") {
+    if (e.from !== "url") throw new Error("RAD chunks must be loaded from a URL.");
+    if (!s) throw new Error("RAD chunk request is missing its byte range.");
+    return Ir(e, s, r);
+  }
+  const i = e.from === "url" ? e.url : e.file.name;
+  if (e.from === "file" && t === "ply")
+    try {
+      return await Yt(e.file, {
+        signal: r,
+        ...h ? { onProgress: h } : {}
+      });
+    } catch (f) {
+      throw $(f) ? f : R(f, { phase: "decode", url: i });
+    }
+  const c = e.from === "url" ? await ct(e.url, e.request, r, h) : await Ge(e.file);
+  try {
+    switch (t) {
+      case "ply":
+        return Bt(c);
+      case "sog": {
+        const f = await Gt(c, { signal: r });
+        return a ? Ie(f, a.packShBands) : f;
+      }
+      case "rad":
+        return yr(c);
+      // \`ChunkLoader\` routes spz/splat/ksplat to the one-shot worker; reaching
+      // this worker with one of them means the routing table lost an entry.
+      default:
+        throw new Error(\`The streaming worker does not decode \${t}.\`);
+    }
+  } catch (f) {
+    throw $(f) ? f : R(f, { phase: "decode", url: i });
+  }
+}
+function Ie(e, t) {
+  if (!e.sh) return e;
+  const r = _t(e.sh, e.count, t), { sh: n, ...s } = e;
+  return { ...s, shPacked: r };
+}
+async function Or(e, t, r) {
+  var h;
+  const n = it(e.url), s = ((h = t.sh) == null ? void 0 : h.source) === "sidecar" ? t.sh : void 0, [o, a] = await Promise.all([
+    _e(n, t.start, t.length, e.request, r),
+    (s == null ? void 0 : s.url) === void 0 ? Promise.resolve(void 0) : (
+      // shcoef.bin holds 64 bytes per splat against data.bin's 32, aligned
+      // 2:1, so this chunk's SH is exactly its doubled byte range.
+      _e(s.url, t.start * 2, t.length * 2, e.request, r)
+    )
+  ]);
+  try {
+    return await Pr(o, t, a, r);
+  } catch (i) {
+    throw $(i) ? i : R(i, { phase: "decode", url: n });
+  }
+}
+async function Ir(e, t, r) {
+  const n = it(e.url), s = t.start !== void 0 && t.length !== void 0 ? await _e(n, t.start, t.length, e.request, r) : await ct(n, e.request, r);
+  try {
+    return await pr(s, t.shCodebook, t.shExtent, t.reorder ?? !0);
+  } catch (o) {
+    throw $(o) ? o : R(o, { phase: "decode", url: n });
+  }
+}
+//# sourceMappingURL=load-worker-CQhCbUGy.js.map
+`, d = typeof self < "u" && self.Blob && new Blob(["URL.revokeObjectURL(import.meta.url);", y], { type: "text/javascript;charset=utf-8" });
+function U(o) {
+  let t;
+  try {
+    if (t = d && (self.URL || self.webkitURL).createObjectURL(d), !t) throw "";
+    const n = new Worker(t, {
+      type: "module",
+      name: o == null ? void 0 : o.name
+    });
+    return n.addEventListener("error", () => {
+      (self.URL || self.webkitURL).revokeObjectURL(t);
+    }), n;
+  } catch {
+    return new Worker(
+      "data:text/javascript;charset=utf-8," + encodeURIComponent(y),
+      {
+        type: "module",
+        name: o == null ? void 0 : o.name
+      }
+    );
+  }
+}
+const $ = /* @__PURE__ */ new Set(["spz", "splat", "ksplat"]);
+class w {
+  constructor(t) {
+    a(this, "nextRequestId", 0);
+    a(this, "pending", /* @__PURE__ */ new Map());
+    a(this, "disposed", !1);
+    /** Terminal worker failure; subsequent loads reject instead of hanging. */
+    a(this, "workerFailure", null);
+    this.worker = t, this.worker.onmessage = (n) => {
+      var r, s;
+      const e = this.pending.get(n.data.id);
+      if (e) {
+        if (n.data.type === "progress") {
+          (r = e.onProgress) == null || r.call(e, n.data.loaded, n.data.total);
+          return;
+        }
+        this.pending.delete(n.data.id), (s = e.removeAbortListener) == null || s.call(e), n.data.ok ? e.resolve(n.data.data) : n.data.cancelled ? e.reject(c("Chunk load was cancelled.")) : e.reject(k(n.data.error));
+      }
+    }, this.worker.onerror = (n) => {
+      if (this.workerFailure) return;
+      const e = n && typeof n == "object" && "message" in n && typeof n.message == "string" ? n.message : "", r = new x(
+        e ? `Chunk loading worker failed. ${e}` : "Chunk loading worker failed.",
+        { phase: "worker", url: "", retryable: !1 }
+      );
+      this.workerFailure = r, this.worker.terminate(), this.rejectAll(r);
+    };
+  }
+  /** Posts one load to this worker and tracks its pending promise. */
+  request(t, n, e) {
+    if (this.disposed) return Promise.reject(c("ChunkLoader has been disposed."));
+    if (n != null && n.aborted) return Promise.reject(c("Chunk load was cancelled."));
+    if (this.workerFailure) return Promise.reject(this.workerFailure);
+    const r = this.nextRequestId++, s = new Promise((h, i) => {
+      this.pending.set(r, { resolve: h, reject: i, ...e ? { onProgress: e } : {} });
+    });
+    if (n) {
+      const h = () => {
+        const f = this.pending.get(r);
+        if (!f) return;
+        this.pending.delete(r);
+        const u = { type: "cancel", id: r };
+        this.disposed || this.worker.postMessage(u), f.reject(c("Chunk load was cancelled."));
+      };
+      n.addEventListener("abort", h, { once: !0 });
+      const i = this.pending.get(r);
+      i && (i.removeAbortListener = () => n.removeEventListener("abort", h));
+    }
+    const l = { ...t, id: r };
+    return this.worker.postMessage(l), s;
+  }
+  /** Terminates this worker and rejects its in-flight requests. */
+  dispose() {
+    this.disposed || (this.disposed = !0, this.worker.terminate(), this.rejectAll(c("ChunkLoader has been disposed.")));
+  }
+  rejectAll(t) {
+    var n;
+    for (const e of this.pending.values())
+      (n = e.removeAbortListener) == null || n.call(e), e.reject(t);
+    this.pending.clear();
+  }
+}
+class S {
+  constructor() {
+    a(this, "streaming", new w(new U()));
+    /** The in-flight construction; `null` until a one-shot format is requested. */
+    a(this, "oneShot", null);
+    /** The constructed one-shot client, so `dispose` does not have to await. */
+    a(this, "oneShotClient", null);
+    a(this, "disposed", !1);
+  }
+  /**
+   * Fetches and decodes one scene file or chunk directory.
+   *
+   * @param url - Scene URL, absolute or relative to the page.
+   * @param options.kind - 'file' (default) selects a parser by extension;
+   * 'directory' decodes an unbundled SOG chunk directory.
+   * @param options.format - Explicit parser; `lcc-bin` additionally needs
+   * `options.lcc` to say which byte range of the file to fetch.
+   * @param options.signal - Abort signal for cancellation; the returned
+   * promise then rejects with a `DOMException` named `AbortError`.
+   * @param options.lcc - Byte-range plumbing for `lcc-bin`. This path exists
+   * for {@link StreamedSplatMesh} and is **not** part of the stable surface;
+   * the type is nameable as `LccChunkParams` on `@voluma/vlam/formats/lcc`.
+   * @param options.rad - Byte-range plumbing for `rad-chunk`, on the same
+   * footing; the type is `RadChunkRangeRequest` on `@voluma/vlam/formats/rad`.
+   * @throws Rejects only with {@link SplatLoadError} (resolve, fetch, decode or
+   * worker failures - `error.phase` says which; a worker that cannot start at
+   * all, e.g. under a CSP that blocks `blob:` workers, reports
+   * `phase: 'worker'`) or an `Error` named `AbortError` (cancellation or
+   * {@link dispose}).
+   */
+  // `async` so a URL or format that will not resolve rejects the returned
+  // promise rather than throwing synchronously into the caller.
+  async load(t, n = {}) {
+    const e = n.kind ?? "file", r = _(t, n.baseUrl).href, s = v(r, e, n.format ?? "auto"), l = await this.request(
+      {
+        from: "url",
+        url: r,
+        kind: e,
+        ...n.request ? { request: n.request } : {}
+      },
+      s,
+      n.signal,
+      n.lcc,
+      n.rad,
+      n.files,
+      n.sog,
+      n.onProgress
+    );
+    return p(l, s);
+  }
+  /**
+   * Decodes a local file (from a file input or a drop) in the worker - the
+   * bytes are read worker-side, so a multi-million-splat decode still never
+   * blocks the main thread.
+   *
+   * Only self-contained files are supported: `.ply`, `.spz`, `.splat`,
+   * `.ksplat` and bundled `.sog`. An unbundled SOG directory needs sibling
+   * fetches and so requires {@link load} with `kind: 'directory'`.
+   *
+   * @param file - The file; its name selects the parser unless `format` is given.
+   * @throws Rejects only with {@link SplatLoadError} (unknown extension, read
+   * or decode failures) or an `Error` named `AbortError` (cancellation or
+   * {@link dispose}).
+   */
+  // `async` so an unknown extension rejects the returned promise rather than
+  // throwing synchronously into the caller.
+  async loadFile(t, n = {}) {
+    const e = n.format ?? "auto", r = e === "auto" ? m(A(t.name), t.name) : e, s = await this.request(
+      { from: "file", file: t },
+      r,
+      n.signal,
+      void 0,
+      void 0,
+      void 0,
+      void 0,
+      n.onProgress
+    );
+    return p(s, r);
+  }
+  /** Routes one load to the worker that owns its format. */
+  request(t, n, e, r, s, l, h, i) {
+    if (this.disposed) return Promise.reject(c("ChunkLoader has been disposed."));
+    if (e != null && e.aborted) return Promise.reject(c("Chunk load was cancelled."));
+    const f = {
+      type: "load",
+      source: t,
+      format: n,
+      ...r ? { lcc: r } : {},
+      ...s ? { rad: s } : {},
+      ...h ? { sog: h } : {},
+      ...l ? { files: l } : {},
+      ...i ? { progress: !0 } : {}
+    }, u = this.clientFor(n);
+    return u instanceof Promise ? u.then((b) => {
+      if (this.disposed) throw c("ChunkLoader has been disposed.");
+      return b.request(f, e, i);
+    }) : u.request(f, e, i);
+  }
+  /**
+   * The worker for `format`, constructing the one-shot worker on first need.
+   *
+   * The in-flight promise is cached, not just the resolved client, so two
+   * concurrent `.spz` loads share one worker instead of racing to build two.
+   */
+  clientFor(t) {
+    return $.has(t) ? this.oneShotClient ? this.oneShotClient : (this.oneShot ?? (this.oneShot = import("./one-shot-worker-G80btnth.js").then(
+      ({ default: n }) => {
+        const e = new w(new n());
+        return this.oneShotClient = e, this.disposed && e.dispose(), e;
+      }
+    )), this.oneShot) : this.streaming;
+  }
+  /** Terminates both workers and rejects all in-flight requests. */
+  dispose() {
+    var t;
+    this.disposed || (this.disposed = !0, this.streaming.dispose(), (t = this.oneShotClient) == null || t.dispose());
+  }
+}
+const L = ["ply", "spz", "splat", "ksplat", "sog", "rad"];
+function p(o, t) {
+  return L.includes(t) ? { ...o, format: t } : o;
+}
+function v(o, t, n) {
+  return n === "lcc-bin" || n === "rad-chunk" ? n : t === "directory" ? "sog" : n !== "auto" ? n : m(R(new URL(o)), o);
+}
+export {
+  S as C
+};
+//# sourceMappingURL=chunk-loader-DlNwggfG.js.map