@manycore/aholo-viewer 1.0.0-alpha.0

package/dist/splat-worker.js

@@ -0,0 +1,3728 @@
+// ../../node_modules/.pnpm/fflate@0.8.2/node_modules/fflate/esm/browser.js
+var u8 = Uint8Array;
+var u16 = Uint16Array;
+var i32 = Int32Array;
+var fleb = new u8([
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  1,
+  1,
+  1,
+  1,
+  2,
+  2,
+  2,
+  2,
+  3,
+  3,
+  3,
+  3,
+  4,
+  4,
+  4,
+  4,
+  5,
+  5,
+  5,
+  5,
+  0,
+  /* unused */
+  0,
+  0,
+  /* impossible */
+  0
+]);
+var fdeb = new u8([
+  0,
+  0,
+  0,
+  0,
+  1,
+  1,
+  2,
+  2,
+  3,
+  3,
+  4,
+  4,
+  5,
+  5,
+  6,
+  6,
+  7,
+  7,
+  8,
+  8,
+  9,
+  9,
+  10,
+  10,
+  11,
+  11,
+  12,
+  12,
+  13,
+  13,
+  /* unused */
+  0,
+  0
+]);
+var clim = new u8([16, 17, 18, 0, 8, 7, 9, 6, 10, 5, 11, 4, 12, 3, 13, 2, 14, 1, 15]);
+var freb = function(eb, start) {
+  var b = new u16(31);
+  for (var i = 0; i < 31; ++i) {
+    b[i] = start += 1 << eb[i - 1];
+  }
+  var r = new i32(b[30]);
+  for (var i = 1; i < 30; ++i) {
+    for (var j = b[i]; j < b[i + 1]; ++j) {
+      r[j] = j - b[i] << 5 | i;
+    }
+  }
+  return { b, r };
+};
+var _a = freb(fleb, 2);
+var fl = _a.b;
+var revfl = _a.r;
+fl[28] = 258, revfl[258] = 28;
+var _b = freb(fdeb, 0);
+var fd = _b.b;
+var revfd = _b.r;
+var rev = new u16(32768);
+for (i = 0; i < 32768; ++i) {
+  x = (i & 43690) >> 1 | (i & 21845) << 1;
+  x = (x & 52428) >> 2 | (x & 13107) << 2;
+  x = (x & 61680) >> 4 | (x & 3855) << 4;
+  rev[i] = ((x & 65280) >> 8 | (x & 255) << 8) >> 1;
+}
+var x;
+var i;
+var hMap = (function(cd, mb, r) {
+  var s = cd.length;
+  var i = 0;
+  var l = new u16(mb);
+  for (; i < s; ++i) {
+    if (cd[i])
+      ++l[cd[i] - 1];
+  }
+  var le = new u16(mb);
+  for (i = 1; i < mb; ++i) {
+    le[i] = le[i - 1] + l[i - 1] << 1;
+  }
+  var co;
+  if (r) {
+    co = new u16(1 << mb);
+    var rvb = 15 - mb;
+    for (i = 0; i < s; ++i) {
+      if (cd[i]) {
+        var sv = i << 4 | cd[i];
+        var r_1 = mb - cd[i];
+        var v = le[cd[i] - 1]++ << r_1;
+        for (var m = v | (1 << r_1) - 1; v <= m; ++v) {
+          co[rev[v] >> rvb] = sv;
+        }
+      }
+    }
+  } else {
+    co = new u16(s);
+    for (i = 0; i < s; ++i) {
+      if (cd[i]) {
+        co[i] = rev[le[cd[i] - 1]++] >> 15 - cd[i];
+      }
+    }
+  }
+  return co;
+});
+var flt = new u8(288);
+for (i = 0; i < 144; ++i)
+  flt[i] = 8;
+var i;
+for (i = 144; i < 256; ++i)
+  flt[i] = 9;
+var i;
+for (i = 256; i < 280; ++i)
+  flt[i] = 7;
+var i;
+for (i = 280; i < 288; ++i)
+  flt[i] = 8;
+var i;
+var fdt = new u8(32);
+for (i = 0; i < 32; ++i)
+  fdt[i] = 5;
+var i;
+var flrm = /* @__PURE__ */ hMap(flt, 9, 1);
+var fdrm = /* @__PURE__ */ hMap(fdt, 5, 1);
+var max = function(a) {
+  var m = a[0];
+  for (var i = 1; i < a.length; ++i) {
+    if (a[i] > m)
+      m = a[i];
+  }
+  return m;
+};
+var bits = function(d, p, m) {
+  var o = p / 8 | 0;
+  return (d[o] | d[o + 1] << 8) >> (p & 7) & m;
+};
+var bits16 = function(d, p) {
+  var o = p / 8 | 0;
+  return (d[o] | d[o + 1] << 8 | d[o + 2] << 16) >> (p & 7);
+};
+var shft = function(p) {
+  return (p + 7) / 8 | 0;
+};
+var slc = function(v, s, e) {
+  if (s == null || s < 0)
+    s = 0;
+  if (e == null || e > v.length)
+    e = v.length;
+  return new u8(v.subarray(s, e));
+};
+var ec = [
+  "unexpected EOF",
+  "invalid block type",
+  "invalid length/literal",
+  "invalid distance",
+  "stream finished",
+  "no stream handler",
+  ,
+  "no callback",
+  "invalid UTF-8 data",
+  "extra field too long",
+  "date not in range 1980-2099",
+  "filename too long",
+  "stream finishing",
+  "invalid zip data"
+  // determined by unknown compression method
+];
+var err = function(ind, msg, nt) {
+  var e = new Error(msg || ec[ind]);
+  e.code = ind;
+  if (Error.captureStackTrace)
+    Error.captureStackTrace(e, err);
+  if (!nt)
+    throw e;
+  return e;
+};
+var inflt = function(dat, st, buf, dict) {
+  var sl = dat.length, dl = dict ? dict.length : 0;
+  if (!sl || st.f && !st.l)
+    return buf || new u8(0);
+  var noBuf = !buf;
+  var resize = noBuf || st.i != 2;
+  var noSt = st.i;
+  if (noBuf)
+    buf = new u8(sl * 3);
+  var cbuf = function(l2) {
+    var bl = buf.length;
+    if (l2 > bl) {
+      var nbuf = new u8(Math.max(bl * 2, l2));
+      nbuf.set(buf);
+      buf = nbuf;
+    }
+  };
+  var final = st.f || 0, pos = st.p || 0, bt = st.b || 0, lm = st.l, dm = st.d, lbt = st.m, dbt = st.n;
+  var tbts = sl * 8;
+  do {
+    if (!lm) {
+      final = bits(dat, pos, 1);
+      var type = bits(dat, pos + 1, 3);
+      pos += 3;
+      if (!type) {
+        var s = shft(pos) + 4, l = dat[s - 4] | dat[s - 3] << 8, t = s + l;
+        if (t > sl) {
+          if (noSt)
+            err(0);
+          break;
+        }
+        if (resize)
+          cbuf(bt + l);
+        buf.set(dat.subarray(s, t), bt);
+        st.b = bt += l, st.p = pos = t * 8, st.f = final;
+        continue;
+      } else if (type == 1)
+        lm = flrm, dm = fdrm, lbt = 9, dbt = 5;
+      else if (type == 2) {
+        var hLit = bits(dat, pos, 31) + 257, hcLen = bits(dat, pos + 10, 15) + 4;
+        var tl = hLit + bits(dat, pos + 5, 31) + 1;
+        pos += 14;
+        var ldt = new u8(tl);
+        var clt = new u8(19);
+        for (var i = 0; i < hcLen; ++i) {
+          clt[clim[i]] = bits(dat, pos + i * 3, 7);
+        }
+        pos += hcLen * 3;
+        var clb = max(clt), clbmsk = (1 << clb) - 1;
+        var clm = hMap(clt, clb, 1);
+        for (var i = 0; i < tl; ) {
+          var r = clm[bits(dat, pos, clbmsk)];
+          pos += r & 15;
+          var s = r >> 4;
+          if (s < 16) {
+            ldt[i++] = s;
+          } else {
+            var c = 0, n = 0;
+            if (s == 16)
+              n = 3 + bits(dat, pos, 3), pos += 2, c = ldt[i - 1];
+            else if (s == 17)
+              n = 3 + bits(dat, pos, 7), pos += 3;
+            else if (s == 18)
+              n = 11 + bits(dat, pos, 127), pos += 7;
+            while (n--)
+              ldt[i++] = c;
+          }
+        }
+        var lt = ldt.subarray(0, hLit), dt = ldt.subarray(hLit);
+        lbt = max(lt);
+        dbt = max(dt);
+        lm = hMap(lt, lbt, 1);
+        dm = hMap(dt, dbt, 1);
+      } else
+        err(1);
+      if (pos > tbts) {
+        if (noSt)
+          err(0);
+        break;
+      }
+    }
+    if (resize)
+      cbuf(bt + 131072);
+    var lms = (1 << lbt) - 1, dms = (1 << dbt) - 1;
+    var lpos = pos;
+    for (; ; lpos = pos) {
+      var c = lm[bits16(dat, pos) & lms], sym = c >> 4;
+      pos += c & 15;
+      if (pos > tbts) {
+        if (noSt)
+          err(0);
+        break;
+      }
+      if (!c)
+        err(2);
+      if (sym < 256)
+        buf[bt++] = sym;
+      else if (sym == 256) {
+        lpos = pos, lm = null;
+        break;
+      } else {
+        var add = sym - 254;
+        if (sym > 264) {
+          var i = sym - 257, b = fleb[i];
+          add = bits(dat, pos, (1 << b) - 1) + fl[i];
+          pos += b;
+        }
+        var d = dm[bits16(dat, pos) & dms], dsym = d >> 4;
+        if (!d)
+          err(3);
+        pos += d & 15;
+        var dt = fd[dsym];
+        if (dsym > 3) {
+          var b = fdeb[dsym];
+          dt += bits16(dat, pos) & (1 << b) - 1, pos += b;
+        }
+        if (pos > tbts) {
+          if (noSt)
+            err(0);
+          break;
+        }
+        if (resize)
+          cbuf(bt + 131072);
+        var end = bt + add;
+        if (bt < dt) {
+          var shift = dl - dt, dend = Math.min(dt, end);
+          if (shift + bt < 0)
+            err(3);
+          for (; bt < dend; ++bt)
+            buf[bt] = dict[shift + bt];
+        }
+        for (; bt < end; ++bt)
+          buf[bt] = buf[bt - dt];
+      }
+    }
+    st.l = lm, st.p = lpos, st.b = bt, st.f = final;
+    if (lm)
+      final = 1, st.m = lbt, st.d = dm, st.n = dbt;
+  } while (!final);
+  return bt != buf.length && noBuf ? slc(buf, 0, bt) : buf.subarray(0, bt);
+};
+var et = /* @__PURE__ */ new u8(0);
+var b2 = function(d, b) {
+  return d[b] | d[b + 1] << 8;
+};
+var b4 = function(d, b) {
+  return (d[b] | d[b + 1] << 8 | d[b + 2] << 16 | d[b + 3] << 24) >>> 0;
+};
+var b8 = function(d, b) {
+  return b4(d, b) + b4(d, b + 4) * 4294967296;
+};
+function inflateSync(data, opts) {
+  return inflt(data, { i: 2 }, opts && opts.out, opts && opts.dictionary);
+}
+var td = typeof TextDecoder != "undefined" && /* @__PURE__ */ new TextDecoder();
+var tds = 0;
+try {
+  td.decode(et, { stream: true });
+  tds = 1;
+} catch (e) {
+}
+var dutf8 = function(d) {
+  for (var r = "", i = 0; ; ) {
+    var c = d[i++];
+    var eb = (c > 127) + (c > 223) + (c > 239);
+    if (i + eb > d.length)
+      return { s: r, r: slc(d, i - 1) };
+    if (!eb)
+      r += String.fromCharCode(c);
+    else if (eb == 3) {
+      c = ((c & 15) << 18 | (d[i++] & 63) << 12 | (d[i++] & 63) << 6 | d[i++] & 63) - 65536, r += String.fromCharCode(55296 | c >> 10, 56320 | c & 1023);
+    } else if (eb & 1)
+      r += String.fromCharCode((c & 31) << 6 | d[i++] & 63);
+    else
+      r += String.fromCharCode((c & 15) << 12 | (d[i++] & 63) << 6 | d[i++] & 63);
+  }
+};
+function strFromU8(dat, latin1) {
+  if (latin1) {
+    var r = "";
+    for (var i = 0; i < dat.length; i += 16384)
+      r += String.fromCharCode.apply(null, dat.subarray(i, i + 16384));
+    return r;
+  } else if (td) {
+    return td.decode(dat);
+  } else {
+    var _a2 = dutf8(dat), s = _a2.s, r = _a2.r;
+    if (r.length)
+      err(8);
+    return s;
+  }
+}
+var slzh = function(d, b) {
+  return b + 30 + b2(d, b + 26) + b2(d, b + 28);
+};
+var zh = function(d, b, z) {
+  var fnl = b2(d, b + 28), fn = strFromU8(d.subarray(b + 46, b + 46 + fnl), !(b2(d, b + 8) & 2048)), es = b + 46 + fnl, bs = b4(d, b + 20);
+  var _a2 = z && bs == 4294967295 ? z64e(d, es) : [bs, b4(d, b + 24), b4(d, b + 42)], sc = _a2[0], su = _a2[1], off = _a2[2];
+  return [b2(d, b + 10), sc, su, fn, es + b2(d, b + 30) + b2(d, b + 32), off];
+};
+var z64e = function(d, b) {
+  for (; b2(d, b) != 1; b += 4 + b2(d, b + 2))
+    ;
+  return [b8(d, b + 12), b8(d, b + 4), b8(d, b + 20)];
+};
+function unzipSync(data, opts) {
+  var files = {};
+  var e = data.length - 22;
+  for (; b4(data, e) != 101010256; --e) {
+    if (!e || data.length - e > 65558)
+      err(13);
+  }
+  ;
+  var c = b2(data, e + 8);
+  if (!c)
+    return {};
+  var o = b4(data, e + 16);
+  var z = o == 4294967295 || c == 65535;
+  if (z) {
+    var ze = b4(data, e - 12);
+    z = b4(data, ze) == 101075792;
+    if (z) {
+      c = b4(data, ze + 32);
+      o = b4(data, ze + 48);
+    }
+  }
+  var fltr = opts && opts.filter;
+  for (var i = 0; i < c; ++i) {
+    var _a2 = zh(data, o, z), c_2 = _a2[0], sc = _a2[1], su = _a2[2], fn = _a2[3], no = _a2[4], off = _a2[5], b = slzh(data, off);
+    o = no;
+    if (!fltr || fltr({
+      name: fn,
+      size: sc,
+      originalSize: su,
+      compression: c_2
+    })) {
+      if (!c_2)
+        files[fn] = slc(data, b, b + sc);
+      else if (c_2 == 8)
+        files[fn] = inflateSync(data.subarray(b, b + sc), { out: new u8(su) });
+      else
+        err(14, "unknown compression type " + c_2);
+    }
+  }
+  return files;
+}
+
+// ../../external/egs-core/packages/loaders/splat-loader/utils.ts
+var DEPTH_INFINITY = 31743;
+var buckets = new Uint32Array(65536);
+function sortSplats(counts, sorting, order) {
+  buckets.fill(0);
+  for (let i = 0; i < counts; i++) {
+    buckets[sorting[i]]++;
+  }
+  let activeSplats = 0;
+  for (let i = DEPTH_INFINITY - 1; i >= 0; i--) {
+    const v = buckets[i];
+    buckets[i] = activeSplats;
+    activeSplats += v;
+  }
+  for (let i = 0; i < counts; i++) {
+    const v = sorting[i];
+    if (v < DEPTH_INFINITY) {
+      order[buckets[v]++] = i;
+    }
+  }
+  return activeSplats;
+}
+
+// ../../external/egs-core/packages/egs-lib/src/env.ts
+var isDebugEnable;
+try {
+  if (isDebugEnable == null && (CONFIG.IS_DEV || CONFIG.IS_TESTING || CONFIG.IS_DEV_OR_TESTING)) {
+    isDebugEnable = true;
+  }
+} catch (e) {
+}
+try {
+  if (isDebugEnable == null && true) {
+    isDebugEnable = true;
+  }
+} catch (e) {
+}
+try {
+  if (isDebugEnable == null) {
+    const urlParam = new URLSearchParams(location.search);
+    if (urlParam.has("__enable_debug__")) {
+      isDebugEnable = true;
+    } else if (urlParam.has("__disable_debug__")) {
+      isDebugEnable = false;
+    }
+  }
+} catch (e) {
+}
+if (isDebugEnable == null) {
+  isDebugEnable = false;
+}
+var ENV = {
+  isDebugEnable
+};
+
+// ../../external/egs-core/packages/egs-lib/src/logger.ts
+var _Logger = class _Logger {
+  constructor() {
+    this.exceptionCount = 0;
+  }
+  info(...param) {
+    if (!ENV.isDebugEnable) {
+      return;
+    }
+    console.log("EGS:", ...param);
+  }
+  warn(...param) {
+    if (!ENV.isDebugEnable) {
+      return;
+    }
+    console.warn("EGS:", ...param);
+  }
+  error(content, type = "Unreachable" /* Unreachable */) {
+    if (!ENV.isDebugEnable && this.exceptionCount >= _Logger.MAX_EXCEPTION_SIZE) {
+      return;
+    }
+    const error = typeof content === "string" ? new Error(`EGS Exception: <${type}> ${content}`) : content;
+    console.error(error);
+  }
+  // logic error
+  unreachable(content) {
+    this.error(content, "Unreachable" /* Unreachable */);
+  }
+  // platform issue
+  unsupported(content) {
+    this.error(content, "Unsupported" /* Unsupported */);
+  }
+  // user input invalid
+  invalidInput(content) {
+    this.error(content, "InvalidInput" /* InvalidInput */);
+  }
+  // webgl error
+  webglError(content) {
+    this.error(content, "WebglError" /* WebglError */);
+  }
+  webGpuError(content) {
+    this.error(content, "WebGpuError" /* WebGpuError */);
+  }
+};
+_Logger.MAX_EXCEPTION_SIZE = 1024;
+var Logger = _Logger;
+var logger = new Logger();
+
+// ../../external/egs-core/packages/egs-lib/src/promise.ts
+function deferred() {
+  let resolve = () => {
+  };
+  let reject = () => {
+  };
+  const promise = new Promise(function(resolveInner, rejectInner) {
+    resolve = resolveInner;
+    reject = rejectInner;
+  });
+  return {
+    promise,
+    resolve,
+    reject
+  };
+}
+
+// ../../external/egs-core/packages/egs-lib/src/worker.ts
+var WorkerFlags = {
+  BUSY: 1,
+  ALIVE: 2,
+  PERMANENT: 4,
+  KEEP: 1 | 4
+};
+
+// ../../external/egs-core/packages/loaders/splat-loader/splat/SplatData.ts
+var SplatData = class {
+  constructor(maxShDegree = 3, maxTextureSize = 16384, blockCounts = 1) {
+    this.totalBlockCounts = 0;
+    this.totalBlockShDegree = 3;
+    this.blockOffsets = [];
+    this.blockExecs = [];
+    this.currentBlockIndex = 0;
+    this.blockCounts = blockCounts;
+    this.maxShDegree = maxShDegree;
+    this.maxTextureSize = maxTextureSize;
+  }
+  initBlock(counts, shDegree) {
+    this.blockOffsets.push(this.totalBlockCounts);
+    this.totalBlockCounts += counts;
+    this.totalBlockShDegree = Math.min(shDegree, this.totalBlockShDegree);
+    const { promise, resolve } = deferred();
+    this.blockExecs.push(resolve);
+    if (this.blockOffsets.length === this.blockCounts) {
+      this.init(this.totalBlockCounts, this.totalBlockShDegree);
+      this.blockExecs[this.currentBlockIndex](this.blockOffsets[0]);
+    }
+    return promise;
+  }
+  finishBlock() {
+    this.currentBlockIndex++;
+    this.blockExecs[this.currentBlockIndex]?.(this.blockOffsets[this.currentBlockIndex]);
+  }
+};
+
+// ../../external/egs-core/packages/loaders/splat-loader/splat/utils.ts
+var SH_MAPS = {
+  0: 0,
+  1: 9,
+  2: 24,
+  3: 45
+};
+function computeTextureSize(counts, maxTextureSize) {
+  if (counts === 0) {
+    return { w: 0, h: 0, d: 0 };
+  }
+  const width = Math.min(Math.ceil(Math.sqrt(counts) / 2) * 2, maxTextureSize);
+  const height = Math.min(Math.ceil(counts / width), maxTextureSize);
+  const depth = Math.ceil(counts / (width * height));
+  return { w: width, h: height, d: depth };
+}
+function clamp(v, min, max2) {
+  return Math.min(Math.max(v, min), max2);
+}
+var f32buffer = new Float32Array(1);
+var u32buffer = new Uint32Array(f32buffer.buffer);
+function toHalf(f) {
+  f32buffer[0] = f;
+  const bits2 = u32buffer[0];
+  const sign = bits2 >> 31 & 1;
+  const exp = bits2 >> 23 & 255;
+  const frac = bits2 & 8388607;
+  const halfSign = sign << 15;
+  if (exp === 255) {
+    if (frac !== 0) {
+      return halfSign | 32767;
+    }
+    return halfSign | 31744;
+  }
+  const newExp = exp - 127 + 15;
+  if (newExp >= 31) {
+    return halfSign | 31744;
+  }
+  if (newExp <= 0) {
+    if (newExp < -10) {
+      return halfSign;
+    }
+    const subFrac = (frac | 8388608) >> 1 - newExp + 13;
+    return halfSign | subFrac;
+  }
+  const halfFrac = frac >> 13;
+  return halfSign | newExp << 10 | halfFrac;
+}
+function fromHalf(h) {
+  const sign = h >> 15 & 1;
+  const exp = h >> 10 & 31;
+  const frac = h & 1023;
+  let f32bits;
+  if (exp === 0) {
+    if (frac === 0) {
+      f32bits = sign << 31;
+    } else {
+      let mant = frac;
+      let e = -14;
+      while ((mant & 1024) === 0) {
+        mant <<= 1;
+        e--;
+      }
+      mant &= 1023;
+      const newExp = e + 127;
+      const newFrac = mant << 13;
+      f32bits = sign << 31 | newExp << 23 | newFrac;
+    }
+  } else if (exp === 31) {
+    if (frac === 0) {
+      f32bits = sign << 31 | 2139095040;
+    } else {
+      f32bits = sign << 31 | 2143289344;
+    }
+  } else {
+    const newExp = exp - 15 + 127;
+    const newFrac = frac << 13;
+    f32bits = sign << 31 | newExp << 23 | newFrac;
+  }
+  u32buffer[0] = f32bits;
+  return f32buffer[0];
+}
+var Vector3 = class {
+  constructor(x, y, z) {
+    this.x = x;
+    this.y = y;
+    this.z = z;
+  }
+  set(x, y, z) {
+    this.x = x;
+    this.y = y;
+    this.z = z;
+    return this;
+  }
+  length() {
+    return Math.sqrt(this.x * this.x + this.y * this.y + this.z * this.z);
+  }
+  divideScalar(scalar) {
+    const invLength = 1 / scalar;
+    this.x *= invLength;
+    this.y *= invLength;
+    this.z *= invLength;
+    return this;
+  }
+  normalize() {
+    return this.divideScalar(this.length() || 1);
+  }
+};
+var Quaternion = class {
+  constructor(x, y, z, w) {
+    this.x = x;
+    this.y = y;
+    this.z = z;
+    this.w = w;
+  }
+  set(x, y, z, w) {
+    this.x = x;
+    this.y = y;
+    this.z = z;
+    this.w = w;
+    return this;
+  }
+  normalize() {
+    const length = Math.sqrt(
+      this.x * this.x + this.y * this.y + this.z * this.z + this.w * this.w
+    );
+    if (length === 0) {
+      return this;
+    }
+    const invLength = 1 / length;
+    this.x *= invLength;
+    this.y *= invLength;
+    this.z *= invLength;
+    this.w *= invLength;
+    return this;
+  }
+};
+var tempArr = new Array(4);
+var tempVec = new Vector3(0, 0, 0);
+var tempQuat = new Quaternion(0, 0, 0, 1);
+function encodeQuatOct(x, y, z, w) {
+  const q = tempQuat.set(x, y, z, w).normalize();
+  if (q.w < 0) {
+    q.set(-q.x, -q.y, -q.z, -q.w);
+  }
+  const theta = 2 * Math.acos(q.w);
+  const xyz_norm = Math.sqrt(
+    q.x * q.x + q.y * q.y + q.z * q.z
+  );
+  const axis = xyz_norm < 1e-6 ? tempVec.set(1, 0, 0) : tempVec.set(q.x, q.y, q.z).divideScalar(xyz_norm);
+  const sum = Math.abs(axis.x) + Math.abs(axis.y) + Math.abs(axis.z);
+  let p_x = axis.x / sum;
+  let p_y = axis.y / sum;
+  if (axis.z < 0) {
+    const tmp = p_x;
+    p_x = (1 - Math.abs(p_y)) * (p_x >= 0 ? 1 : -1);
+    p_y = (1 - Math.abs(tmp)) * (p_y >= 0 ? 1 : -1);
+  }
+  tempArr[0] = p_x;
+  tempArr[1] = p_y;
+  tempArr[2] = theta / Math.PI;
+  return tempArr;
+}
+function decodeQuatOct(u, v, angle) {
+  let f_x = u;
+  let f_y = v;
+  const f_z = 1 - (Math.abs(f_x) + Math.abs(f_y));
+  const t = Math.max(-f_z, 0);
+  f_x += f_x >= 0 ? -t : t;
+  f_y += f_y >= 0 ? -t : t;
+  const axis = tempVec.set(f_x, f_y, f_z).normalize();
+  const theta = angle * Math.PI;
+  const halfTheta = theta * 0.5;
+  const s = Math.sin(halfTheta);
+  tempArr[0] = axis.x * s;
+  tempArr[1] = axis.y * s;
+  tempArr[2] = axis.z * s;
+  tempArr[3] = Math.cos(halfTheta);
+  return tempArr;
+}
+
+// ../../external/egs-core/packages/loaders/splat-loader/splat/RawSplatData.ts
+var tempQuat2 = new Quaternion(0, 0, 0, 1);
+var RawSplatData = class extends SplatData {
+  init(counts, shDegree) {
+    this.counts = counts;
+    this.shDegree = Math.min(shDegree, this.maxShDegree);
+    const shCounts = this.shCounts = SH_MAPS[shDegree];
+    this.table = new Array(14 + shCounts).fill(0).map(() => new Float32Array(counts));
+  }
+  set(i, single) {
+    const { table } = this;
+    table[0 /* x */][i] = single.x;
+    table[1 /* y */][i] = single.y;
+    table[2 /* z */][i] = single.z;
+    table[3 /* sx */][i] = single.sx;
+    table[4 /* sy */][i] = single.sy;
+    table[5 /* sz */][i] = single.sz;
+    tempQuat2.set(single.qx, single.qy, single.qz, single.qw).normalize();
+    table[6 /* qx */][i] = tempQuat2.x;
+    table[7 /* qy */][i] = tempQuat2.y;
+    table[8 /* qz */][i] = tempQuat2.z;
+    table[9 /* qw */][i] = tempQuat2.w;
+    table[10 /* r */][i] = single.r;
+    table[11 /* g */][i] = single.g;
+    table[12 /* b */][i] = single.b;
+    table[13 /* a */][i] = single.a;
+  }
+  setCenter(i, x, y, z) {
+    const { table } = this;
+    table[0 /* x */][i] = x;
+    table[1 /* y */][i] = y;
+    table[2 /* z */][i] = z;
+  }
+  setScale(i, sx, sy, sz) {
+    const { table } = this;
+    table[3 /* sx */][i] = sx;
+    table[4 /* sy */][i] = sy;
+    table[5 /* sz */][i] = sz;
+  }
+  setQuat(i, qx, qy, qz, qw) {
+    const { table } = this;
+    tempQuat2.set(qx, qy, qz, qw).normalize();
+    table[6 /* qx */][i] = tempQuat2.x;
+    table[7 /* qy */][i] = tempQuat2.y;
+    table[8 /* qz */][i] = tempQuat2.z;
+    table[9 /* qw */][i] = tempQuat2.w;
+  }
+  setColor(i, r, g, b) {
+    const { table } = this;
+    table[10 /* r */][i] = r;
+    table[11 /* g */][i] = g;
+    table[12 /* b */][i] = b;
+  }
+  setAlpha(i, a) {
+    const { table } = this;
+    table[13 /* a */][i] = a;
+  }
+  setShN(i, shN) {
+    const { table, shCounts } = this;
+    const offset = 13 /* a */ + 1;
+    for (let j = 0; j < shCounts; j++) {
+      table[offset + j][i] = shN[j];
+    }
+  }
+  get(i, single) {
+    const { table } = this;
+    single.x = table[0 /* x */][i];
+    single.y = table[1 /* y */][i];
+    single.z = table[2 /* z */][i];
+    single.sx = table[3 /* sx */][i];
+    single.sy = table[4 /* sy */][i];
+    single.sz = table[5 /* sz */][i];
+    single.qx = table[6 /* qx */][i];
+    single.qy = table[7 /* qy */][i];
+    single.qz = table[8 /* qz */][i];
+    single.qw = table[9 /* qw */][i];
+    single.r = table[10 /* r */][i];
+    single.g = table[11 /* g */][i];
+    single.b = table[12 /* b */][i];
+    single.a = table[13 /* a */][i];
+  }
+  getCenter(i, single) {
+    const { table } = this;
+    single.x = table[0 /* x */][i];
+    single.y = table[1 /* y */][i];
+    single.z = table[2 /* z */][i];
+  }
+  getScale(i, single) {
+    const { table } = this;
+    single.sx = table[3 /* sx */][i];
+    single.sy = table[4 /* sy */][i];
+    single.sz = table[5 /* sz */][i];
+  }
+  getQuat(i, single) {
+    const { table } = this;
+    single.qx = table[6 /* qx */][i];
+    single.qy = table[7 /* qy */][i];
+    single.qz = table[8 /* qz */][i];
+    single.qw = table[9 /* qw */][i];
+  }
+  getColor(i, single) {
+    const { table } = this;
+    single.r = table[10 /* r */][i];
+    single.g = table[11 /* g */][i];
+    single.b = table[12 /* b */][i];
+  }
+  getAlpha(i, single) {
+    const { table } = this;
+    single.a = table[13 /* a */][i];
+  }
+  getShN(i, shN) {
+    const { shCounts, table } = this;
+    const offset = 13 /* a */ + 1;
+    for (let j = 0; j < shCounts; j++) {
+      shN[j] = table[offset + j][i];
+    }
+  }
+  fillCenters(centers) {
+    const { counts, table } = this;
+    const xBuffer = table[0 /* x */];
+    const yBuffer = table[1 /* y */];
+    const zBuffer = table[2 /* z */];
+    for (let i = 0; i < counts; i++) {
+      const i3 = i * 3;
+      centers[i3 + 0] = xBuffer[i];
+      centers[i3 + 1] = yBuffer[i];
+      centers[i3 + 2] = zBuffer[i];
+    }
+  }
+  serialize() {
+    return {
+      counts: this.counts,
+      shDegree: this.shDegree,
+      samplers: this.table.map((buffer) => ({
+        width: this.counts,
+        height: 1,
+        depth: 1,
+        format: 1 /* RGBA_UINT */,
+        source: new Uint8Array(buffer.buffer)
+      }))
+    };
+  }
+  deserialize(data) {
+    const { counts, shDegree, samplers } = data;
+    this.counts = counts;
+    this.shDegree = shDegree;
+    this.shCounts = SH_MAPS[shDegree];
+    this.table = samplers.map((sampler) => new Float32Array(sampler.source.buffer));
+  }
+};
+
+// ../../external/egs-core/packages/loaders/splat-loader/splat/CompressedSplatData.ts
+function encode111011s(a, b, c) {
+  return clamp((a * 0.5 + 0.5) * 2047 | 0, 0, 2047) << 21 | clamp((b * 0.5 + 0.5) * 1023 | 0, 0, 1023) << 11 | clamp((c * 0.5 + 0.5) * 2047 | 0, 0, 2047);
+}
+function decode111011s(decode, out, offset) {
+  out[offset + 0] = (decode >>> 21 & 2047) / 2047 * 2 - 1;
+  out[offset + 1] = (decode >>> 11 & 1023) / 1023 * 2 - 1;
+  out[offset + 2] = (decode & 2047) / 2047 * 2 - 1;
+}
+var CompressedSplatData = class extends SplatData {
+  init(counts, shDegree) {
+    this.counts = counts;
+    this.shDegree = Math.min(shDegree, this.maxShDegree);
+    const { w: width, h: height, d: depth } = computeTextureSize(counts, this.maxTextureSize);
+    const pixelCounts = width * height * depth;
+    const splat1Sampler = this.splat1Sampler = {
+      width,
+      height,
+      depth,
+      format: 1 /* RGBA_UINT */,
+      source: new Uint8Array(16 * pixelCounts)
+    };
+    this.splat1Float32Buffer = new Float32Array(splat1Sampler.source.buffer);
+    this.splat1Uint16Buffer = new Uint16Array(splat1Sampler.source.buffer);
+    const splat2Sampler = this.splat2Sampler = {
+      width,
+      height,
+      depth,
+      format: 1 /* RGBA_UINT */,
+      source: new Uint8Array(16 * pixelCounts)
+    };
+    this.splat2Uint16Buffer = new Uint16Array(splat2Sampler.source.buffer);
+    this.splat2Uint32Buffer = new Uint32Array(splat2Sampler.source.buffer);
+    const sh1Sampler = this.sh1Sampler = {
+      width,
+      height,
+      depth,
+      format: 1 /* RGBA_UINT */,
+      source: new Uint8Array((shDegree >= 1 ? 16 : 0) * pixelCounts)
+    };
+    this.sh1Uint32Buffer = new Uint32Array(sh1Sampler.source.buffer);
+    const sh2Sampler = this.sh2Sampler = {
+      width,
+      height,
+      depth,
+      format: 1 /* RGBA_UINT */,
+      source: new Uint8Array((shDegree >= 2 ? 16 : 0) * pixelCounts)
+    };
+    this.sh2Uint32Buffer = new Uint32Array(sh2Sampler.source.buffer);
+    const sh3Sampler = this.sh3Sampler = {
+      width,
+      height,
+      depth,
+      format: 1 /* RGBA_UINT */,
+      source: new Uint8Array((shDegree >= 3 ? 16 : 0) * pixelCounts)
+    };
+    this.sh3Uint32Buffer = new Uint32Array(sh3Sampler.source.buffer);
+    const sh4Sampler = this.sh4Sampler = {
+      width,
+      height,
+      depth,
+      format: 1 /* RGBA_UINT */,
+      source: new Uint8Array((shDegree >= 3 ? 16 : 0) * pixelCounts)
+    };
+    this.sh4Uint32Buffer = new Uint32Array(sh4Sampler.source.buffer);
+  }
+  set(i, single) {
+    const { splat1Float32Buffer, splat1Uint16Buffer, splat2Uint16Buffer, splat2Uint32Buffer } = this;
+    const i4 = i * 4;
+    const i8 = i * 8;
+    splat1Float32Buffer[i4 + 0] = single.x;
+    splat1Float32Buffer[i4 + 1] = single.y;
+    splat1Float32Buffer[i4 + 2] = single.z;
+    splat1Uint16Buffer[i8 + 6] = toHalf(single.a);
+    splat2Uint16Buffer[i8 + 0] = toHalf(single.r);
+    splat2Uint16Buffer[i8 + 1] = toHalf(single.g);
+    splat2Uint16Buffer[i8 + 2] = toHalf(single.b);
+    splat2Uint16Buffer[i8 + 3] = toHalf(Math.log(single.sx));
+    splat2Uint16Buffer[i8 + 4] = toHalf(Math.log(single.sy));
+    splat2Uint16Buffer[i8 + 5] = toHalf(Math.log(single.sz));
+    const oct = encodeQuatOct(single.qx, single.qy, single.qz, single.qw);
+    const quantU = clamp((oct[0] * 0.5 + 0.5) * 1023 | 0, 0, 1023);
+    const quantV = clamp((oct[1] * 0.5 + 0.5) * 1023 | 0, 0, 1023);
+    const angleInt = clamp(oct[2] * 4095 | 0, 0, 4095);
+    splat2Uint32Buffer[i4 + 3] = angleInt << 20 | quantV << 10 | quantU;
+  }
+  setCenter(i, x, y, z) {
+    const { splat1Float32Buffer } = this;
+    const i4 = i * 4;
+    splat1Float32Buffer[i4 + 0] = x;
+    splat1Float32Buffer[i4 + 1] = y;
+    splat1Float32Buffer[i4 + 2] = z;
+  }
+  setScale(i, sx, sy, sz) {
+    const { splat2Uint16Buffer } = this;
+    const i8 = i * 8;
+    splat2Uint16Buffer[i8 + 3] = toHalf(Math.log(sx));
+    splat2Uint16Buffer[i8 + 4] = toHalf(Math.log(sy));
+    splat2Uint16Buffer[i8 + 5] = toHalf(Math.log(sz));
+  }
+  setQuat(i, qx, qy, qz, qw) {
+    const { splat2Uint32Buffer } = this;
+    const i4 = i * 4;
+    const oct = encodeQuatOct(qx, qy, qz, qw);
+    const quantU = clamp((oct[0] * 0.5 + 0.5) * 1023 | 0, 0, 1023);
+    const quantV = clamp((oct[1] * 0.5 + 0.5) * 1023 | 0, 0, 1023);
+    const angleInt = clamp(oct[2] * 4095 | 0, 0, 4095);
+    splat2Uint32Buffer[i4 + 3] = angleInt << 20 | quantV << 10 | quantU;
+  }
+  setColor(i, r, g, b) {
+    const { splat2Uint16Buffer } = this;
+    const i8 = i * 8;
+    splat2Uint16Buffer[i8 + 0] = toHalf(r);
+    splat2Uint16Buffer[i8 + 1] = toHalf(g);
+    splat2Uint16Buffer[i8 + 2] = toHalf(b);
+  }
+  setAlpha(i, a) {
+    const { splat1Uint16Buffer } = this;
+    const i8 = i * 8;
+    splat1Uint16Buffer[i8 + 6] = toHalf(a);
+  }
+  setShN(i, shN) {
+    const { shDegree, sh1Uint32Buffer, sh2Uint32Buffer } = this;
+    const o = i * 4;
+    if (shDegree >= 1) {
+      sh1Uint32Buffer[o + 0] = encode111011s(shN[0], shN[1], shN[2]);
+      sh1Uint32Buffer[o + 1] = encode111011s(shN[3], shN[4], shN[5]);
+      sh1Uint32Buffer[o + 2] = encode111011s(shN[6], shN[7], shN[8]);
+    }
+    if (shDegree >= 2) {
+      sh1Uint32Buffer[o + 3] = encode111011s(shN[9], shN[10], shN[11]);
+      sh2Uint32Buffer[o + 0] = encode111011s(shN[12], shN[13], shN[14]);
+      sh2Uint32Buffer[o + 1] = encode111011s(shN[15], shN[16], shN[17]);
+      sh2Uint32Buffer[o + 2] = encode111011s(shN[18], shN[19], shN[20]);
+      sh2Uint32Buffer[o + 3] = encode111011s(shN[21], shN[22], shN[23]);
+    }
+    if (shDegree >= 3) {
+      const { sh3Uint32Buffer, sh4Uint32Buffer } = this;
+      sh3Uint32Buffer[o + 0] = encode111011s(shN[24], shN[25], shN[26]);
+      sh3Uint32Buffer[o + 1] = encode111011s(shN[27], shN[28], shN[29]);
+      sh3Uint32Buffer[o + 2] = encode111011s(shN[30], shN[31], shN[32]);
+      sh3Uint32Buffer[o + 3] = encode111011s(shN[33], shN[34], shN[35]);
+      sh4Uint32Buffer[o + 0] = encode111011s(shN[36], shN[37], shN[38]);
+      sh4Uint32Buffer[o + 1] = encode111011s(shN[39], shN[40], shN[41]);
+      sh4Uint32Buffer[o + 2] = encode111011s(shN[42], shN[43], shN[44]);
+    }
+  }
+  get(i, single) {
+    const { splat1Float32Buffer, splat1Uint16Buffer, splat2Uint16Buffer, splat2Uint32Buffer } = this;
+    const i4 = i * 4;
+    const i8 = i * 8;
+    single.x = splat1Float32Buffer[i4 + 0];
+    single.y = splat1Float32Buffer[i4 + 1];
+    single.z = splat1Float32Buffer[i4 + 2];
+    single.a = fromHalf(splat1Uint16Buffer[i8 + 6]);
+    single.r = fromHalf(splat2Uint16Buffer[i8 + 0]);
+    single.g = fromHalf(splat2Uint16Buffer[i8 + 1]);
+    single.b = fromHalf(splat2Uint16Buffer[i8 + 2]);
+    single.sx = Math.exp(fromHalf(splat2Uint16Buffer[i8 + 3]));
+    single.sy = Math.exp(fromHalf(splat2Uint16Buffer[i8 + 4]));
+    single.sz = Math.exp(fromHalf(splat2Uint16Buffer[i8 + 5]));
+    const quatEncode = splat2Uint32Buffer[i4 + 3];
+    const u = (quatEncode & 1023 / 1023) * 2 - 1;
+    const v = (quatEncode >>> 10 & 1023 / 1023) * 2 - 1;
+    const angle = quatEncode >>> 20 & 4095 / 4095;
+    const quat = decodeQuatOct(u, v, angle);
+    single.qx = quat[0];
+    single.qy = quat[1];
+    single.qz = quat[2];
+    single.qw = quat[3];
+  }
+  getCenter(i, single) {
+    const { splat1Float32Buffer } = this;
+    const i4 = i * 4;
+    single.x = splat1Float32Buffer[i4 + 0];
+    single.y = splat1Float32Buffer[i4 + 1];
+    single.z = splat1Float32Buffer[i4 + 2];
+  }
+  getScale(i, single) {
+    const { splat2Uint16Buffer } = this;
+    const i8 = i * 8;
+    single.sx = Math.exp(fromHalf(splat2Uint16Buffer[i8 + 3]));
+    single.sy = Math.exp(fromHalf(splat2Uint16Buffer[i8 + 4]));
+    single.sz = Math.exp(fromHalf(splat2Uint16Buffer[i8 + 5]));
+  }
+  getQuat(i, single) {
+    const { splat2Uint32Buffer } = this;
+    const i4 = i * 4;
+    const quatEncode = splat2Uint32Buffer[i4 + 3];
+    const u = (quatEncode & 1023 / 1023) * 2 - 1;
+    const v = (quatEncode >>> 10 & 1023 / 1023) * 2 - 1;
+    const angle = quatEncode >>> 20 & 4095 / 4095;
+    const quat = decodeQuatOct(u, v, angle);
+    single.qx = quat[0];
+    single.qy = quat[1];
+    single.qz = quat[2];
+    single.qw = quat[3];
+  }
+  getColor(i, single) {
+    const { splat2Uint16Buffer } = this;
+    const i8 = i * 8;
+    single.r = fromHalf(splat2Uint16Buffer[i8 + 0]);
+    single.g = fromHalf(splat2Uint16Buffer[i8 + 1]);
+    single.b = fromHalf(splat2Uint16Buffer[i8 + 2]);
+  }
+  getAlpha(i, single) {
+    const { splat1Uint16Buffer } = this;
+    const i8 = i * 8;
+    single.a = fromHalf(splat1Uint16Buffer[i8 + 6]);
+  }
+  getShN(i, shN) {
+    const { shDegree, sh1Uint32Buffer, sh2Uint32Buffer } = this;
+    const o = i * 4;
+    if (shDegree >= 1) {
+      decode111011s(sh1Uint32Buffer[o + 0], shN, 0);
+      decode111011s(sh1Uint32Buffer[o + 1], shN, 3);
+      decode111011s(sh1Uint32Buffer[o + 2], shN, 6);
+    }
+    if (shDegree >= 2) {
+      decode111011s(sh1Uint32Buffer[o + 3], shN, 9);
+      decode111011s(sh2Uint32Buffer[o + 0], shN, 12);
+      decode111011s(sh2Uint32Buffer[o + 1], shN, 15);
+      decode111011s(sh2Uint32Buffer[o + 2], shN, 18);
+      decode111011s(sh2Uint32Buffer[o + 3], shN, 21);
+    }
+    if (shDegree >= 3) {
+      const { sh3Uint32Buffer, sh4Uint32Buffer } = this;
+      decode111011s(sh3Uint32Buffer[o + 0], shN, 24);
+      decode111011s(sh3Uint32Buffer[o + 1], shN, 27);
+      decode111011s(sh3Uint32Buffer[o + 2], shN, 30);
+      decode111011s(sh3Uint32Buffer[o + 3], shN, 33);
+      decode111011s(sh4Uint32Buffer[o + 0], shN, 36);
+      decode111011s(sh4Uint32Buffer[o + 1], shN, 39);
+      decode111011s(sh4Uint32Buffer[o + 2], shN, 42);
+    }
+  }
+  fillCenters(centers) {
+    const { counts, splat1Float32Buffer } = this;
+    for (let i = 0; i < counts; i++) {
+      const i3 = i * 3;
+      const i4 = i * 4;
+      centers[i3 + 0] = splat1Float32Buffer[i4 + 0];
+      centers[i3 + 1] = splat1Float32Buffer[i4 + 1];
+      centers[i3 + 2] = splat1Float32Buffer[i4 + 2];
+    }
+  }
+  serialize() {
+    return {
+      counts: this.counts,
+      shDegree: this.shDegree,
+      samplers: [
+        this.splat1Sampler,
+        this.splat2Sampler,
+        this.sh1Sampler,
+        this.sh2Sampler,
+        this.sh3Sampler,
+        this.sh4Sampler
+      ]
+    };
+  }
+  deserialize(data) {
+    const { counts, shDegree, samplers } = data;
+    this.counts = counts;
+    this.shDegree = shDegree;
+    const { w: width, h: height, d: depth } = computeTextureSize(counts, this.maxTextureSize);
+    const pixelCounts = width * height * depth;
+    const splat1Sampler = this.splat1Sampler = samplers[0] ?? {
+      width,
+      height,
+      depth,
+      format: 1 /* RGBA_UINT */,
+      source: new Uint8Array(16 * pixelCounts)
+    };
+    this.splat1Float32Buffer = new Float32Array(splat1Sampler.source.buffer);
+    this.splat1Uint16Buffer = new Uint16Array(splat1Sampler.source.buffer);
+    const splat2Sampler = this.splat2Sampler = samplers[1] ?? {
+      width,
+      height,
+      depth,
+      format: 1 /* RGBA_UINT */,
+      source: new Uint8Array(16 * pixelCounts)
+    };
+    this.splat2Uint16Buffer = new Uint16Array(splat2Sampler.source.buffer);
+    this.splat2Uint32Buffer = new Uint32Array(splat2Sampler.source.buffer);
+    const sh1Sampler = this.sh1Sampler = samplers[2] ?? {
+      width,
+      height,
+      depth,
+      format: 1 /* RGBA_UINT */,
+      source: new Uint8Array((shDegree >= 1 ? 16 : 0) * pixelCounts)
+    };
+    this.sh1Uint32Buffer = new Uint32Array(sh1Sampler.source.buffer);
+    const sh2Sampler = this.sh2Sampler = samplers[3] ?? {
+      width,
+      height,
+      depth,
+      format: 1 /* RGBA_UINT */,
+      source: new Uint8Array((shDegree >= 2 ? 16 : 0) * pixelCounts)
+    };
+    this.sh2Uint32Buffer = new Uint32Array(sh2Sampler.source.buffer);
+    const sh3Sampler = this.sh3Sampler = samplers[4] ?? {
+      width,
+      height,
+      depth,
+      format: 1 /* RGBA_UINT */,
+      source: new Uint8Array((shDegree >= 3 ? 16 : 0) * pixelCounts)
+    };
+    this.sh3Uint32Buffer = new Uint32Array(sh3Sampler.source.buffer);
+    const sh4Sampler = this.sh4Sampler = samplers[5] ?? {
+      width,
+      height,
+      depth,
+      format: 1 /* RGBA_UINT */,
+      source: new Uint8Array((shDegree >= 3 ? 16 : 0) * pixelCounts)
+    };
+    this.sh4Uint32Buffer = new Uint32Array(sh4Sampler.source.buffer);
+  }
+};
+
+// ../../external/egs-core/packages/loaders/splat-loader/splat/SuperCompressedSplatData.ts
+function packSint5x9ToUint32x2(data, out, offset) {
+  const q0 = (data[0] * 16 + 16.5 | 0) & 31;
+  const q1 = (data[1] * 16 + 16.5 | 0) & 31;
+  const q2 = (data[2] * 16 + 16.5 | 0) & 31;
+  const q3 = (data[3] * 16 + 16.5 | 0) & 31;
+  const q4 = (data[4] * 16 + 16.5 | 0) & 31;
+  const q5 = (data[5] * 16 + 16.5 | 0) & 31;
+  const q6 = (data[6] * 16 + 16.5 | 0) & 31;
+  const q7 = (data[7] * 16 + 16.5 | 0) & 31;
+  const q8 = (data[8] * 16 + 16.5 | 0) & 31;
+  let low = 0;
+  let high = 0;
+  low |= q0 << 0;
+  low |= q1 << 5;
+  low |= q2 << 10;
+  low |= q3 << 15;
+  low |= q4 << 20;
+  low |= q5 << 25;
+  low |= (q6 & 3) << 30;
+  high |= q6 >>> 2;
+  high |= q7 << 3;
+  high |= q8 << 8;
+  out[offset] = low;
+  out[offset + 1] = high;
+}
+function unpackSint5x9FromUint32x2(low, high, out, offset) {
+  out[offset + 0] = ((low >>> 0 & 31) - 16) * 0.0625;
+  out[offset + 1] = ((low >>> 5 & 31) - 16) * 0.0625;
+  out[offset + 2] = ((low >>> 10 & 31) - 16) * 0.0625;
+  out[offset + 3] = ((low >>> 15 & 31) - 16) * 0.0625;
+  out[offset + 4] = ((low >>> 20 & 31) - 16) * 0.0625;
+  out[offset + 5] = ((low >>> 25 & 31) - 16) * 0.0625;
+  const lowBits = low >>> 30 & 3;
+  const highBits = (high & 7) << 2;
+  out[offset + 6] = ((lowBits | highBits) - 16) * 0.0625;
+  out[offset + 7] = ((high >>> 3 & 31) - 16) * 0.0625;
+  out[offset + 8] = ((high >>> 8 & 31) - 16) * 0.0625;
+}
+function packSint4ToUint8(v0, v1) {
+  const l = (v0 * 8 + 8.5 | 0) & 15;
+  const h = (v1 * 8 + 8.5 | 0) & 15;
+  return h << 4 | l;
+}
+function unpackUint8ToSint4x2(value, out, offset) {
+  out[offset] = (value & 15) * 0.125 - 1;
+  out[offset + 1] = (value >> 4 & 15) * 0.125 - 1;
+}
+function toUnsignedChar(v) {
+  return clamp(v * 128 + 128.5 | 0, 0, 255);
+}
+function fromUnsignedChar(v) {
+  return (v - 128) / 128;
+}
+function toUnsignedCharV2(v) {
+  return clamp(v * 255 + 0.5 | 0, 0, 255);
+}
+var LN_SCALE_MIN = -12;
+var LN_SCALE_MAX = 9;
+var LN_SCALE = 254 / (LN_SCALE_MAX - LN_SCALE_MIN);
+var LN_SCALE_INV = 1 / LN_SCALE;
+var SuperCompressedSplatData = class extends SplatData {
+  init(counts, shDegree) {
+    this.counts = counts;
+    this.shDegree = Math.min(shDegree, this.maxShDegree);
+    const { w: width, h: height, d: depth } = computeTextureSize(counts, this.maxTextureSize);
+    const pixelCounts = width * height * depth;
+    const splatSampler = this.splatSampler = {
+      width,
+      height,
+      depth,
+      format: 1 /* RGBA_UINT */,
+      source: new Uint8Array(16 * pixelCounts)
+    };
+    this.splatUint8Buffer = splatSampler.source;
+    this.splatUint16Buffer = new Uint16Array(splatSampler.source.buffer);
+    const sh1Sampler = this.sh1Sampler = {
+      width,
+      height,
+      depth,
+      format: shDegree === 1 ? 0 /* RG_UINT */ : 1 /* RGBA_UINT */,
+      source: new Uint8Array((shDegree >= 1 ? shDegree === 1 ? 8 : 16 : 0) * pixelCounts)
+    };
+    this.sh1Uint8Buffer = sh1Sampler.source;
+    this.sh1Uint32Buffer = new Uint32Array(sh1Sampler.source.buffer);
+    const sh2Sampler = this.sh2Sampler = {
+      width,
+      height,
+      depth,
+      format: 1 /* RGBA_UINT */,
+      source: new Uint8Array((shDegree >= 3 ? 16 : 0) * pixelCounts)
+    };
+    this.sh2Uint8Buffer = sh2Sampler.source;
+  }
+  set(i, single) {
+    const { splatUint16Buffer, splatUint8Buffer } = this;
+    const i8 = i * 8;
+    const i16 = i * 16;
+    splatUint16Buffer[i8 + 0] = toHalf(single.x);
+    splatUint16Buffer[i8 + 1] = toHalf(single.y);
+    splatUint16Buffer[i8 + 2] = toHalf(single.z);
+    splatUint8Buffer[i16 + 6] = clamp((Math.log(single.sx) - LN_SCALE_MIN) * LN_SCALE + 1.5 | 0, 0, 255);
+    splatUint8Buffer[i16 + 7] = clamp((Math.log(single.sy) - LN_SCALE_MIN) * LN_SCALE + 1.5 | 0, 0, 255);
+    splatUint8Buffer[i16 + 8] = clamp((Math.log(single.sz) - LN_SCALE_MIN) * LN_SCALE + 1.5 | 0, 0, 255);
+    const oct = encodeQuatOct(single.qx, single.qy, single.qz, single.qw);
+    splatUint8Buffer[i16 + 9] = toUnsignedChar(oct[0]);
+    splatUint8Buffer[i16 + 10] = toUnsignedChar(oct[1]);
+    splatUint8Buffer[i16 + 11] = toUnsignedCharV2(oct[2]);
+    splatUint8Buffer[i16 + 12] = toUnsignedCharV2(single.r);
+    splatUint8Buffer[i16 + 13] = toUnsignedCharV2(single.g);
+    splatUint8Buffer[i16 + 14] = toUnsignedCharV2(single.b);
+    splatUint8Buffer[i16 + 15] = toUnsignedCharV2(single.a);
+  }
+  setCenter(i, x, y, z) {
+    const { splatUint16Buffer } = this;
+    const offset = i * 8;
+    splatUint16Buffer[offset + 0] = toHalf(x);
+    splatUint16Buffer[offset + 1] = toHalf(y);
+    splatUint16Buffer[offset + 2] = toHalf(z);
+  }
+  setScale(i, sx, sy, sz) {
+    const { splatUint8Buffer } = this;
+    const offset = i * 16;
+    splatUint8Buffer[offset + 6] = clamp((Math.log(sx) - LN_SCALE_MIN) * LN_SCALE + 1.5 | 0, 0, 255);
+    splatUint8Buffer[offset + 7] = clamp((Math.log(sy) - LN_SCALE_MIN) * LN_SCALE + 1.5 | 0, 0, 255);
+    splatUint8Buffer[offset + 8] = clamp((Math.log(sz) - LN_SCALE_MIN) * LN_SCALE + 1.5 | 0, 0, 255);
+  }
+  setQuat(i, qx, qy, qz, qw) {
+    const { splatUint8Buffer } = this;
+    const offset = i * 16;
+    const oct = encodeQuatOct(qx, qy, qz, qw);
+    splatUint8Buffer[offset + 9] = toUnsignedChar(oct[0]);
+    splatUint8Buffer[offset + 10] = toUnsignedChar(oct[1]);
+    splatUint8Buffer[offset + 11] = toUnsignedCharV2(oct[2]);
+  }
+  setColor(i, r, g, b) {
+    const { splatUint8Buffer } = this;
+    const offset = i * 16;
+    splatUint8Buffer[offset + 12] = toUnsignedCharV2(r);
+    splatUint8Buffer[offset + 13] = toUnsignedCharV2(g);
+    splatUint8Buffer[offset + 14] = toUnsignedCharV2(b);
+  }
+  setAlpha(i, a) {
+    const { splatUint8Buffer } = this;
+    const offset = i * 16;
+    splatUint8Buffer[offset + 15] = toUnsignedCharV2(a);
+  }
+  setShN(i, shN) {
+    const { shDegree, sh1Uint32Buffer, sh1Uint8Buffer, sh2Uint8Buffer } = this;
+    if (shDegree >= 1) {
+      const offset = (shDegree === 1 ? 2 : 4) * i;
+      packSint5x9ToUint32x2(shN, sh1Uint32Buffer, offset);
+    }
+    if (shDegree >= 2) {
+      const offset = 16 * i + 8;
+      sh1Uint8Buffer[offset + 0] = packSint4ToUint8(shN[9], shN[10]);
+      sh1Uint8Buffer[offset + 1] = packSint4ToUint8(shN[11], shN[12]);
+      sh1Uint8Buffer[offset + 2] = packSint4ToUint8(shN[13], shN[14]);
+      sh1Uint8Buffer[offset + 3] = packSint4ToUint8(shN[15], shN[16]);
+      sh1Uint8Buffer[offset + 4] = packSint4ToUint8(shN[17], shN[18]);
+      sh1Uint8Buffer[offset + 5] = packSint4ToUint8(shN[19], shN[20]);
+      sh1Uint8Buffer[offset + 6] = packSint4ToUint8(shN[21], shN[22]);
+      sh1Uint8Buffer[offset + 7] = packSint4ToUint8(shN[23], 0);
+    }
+    if (shDegree >= 3) {
+      const offset = 16 * i;
+      sh2Uint8Buffer[offset + 0] = packSint4ToUint8(shN[24], shN[25]);
+      sh2Uint8Buffer[offset + 1] = packSint4ToUint8(shN[26], shN[27]);
+      sh2Uint8Buffer[offset + 2] = packSint4ToUint8(shN[28], shN[29]);
+      sh2Uint8Buffer[offset + 3] = packSint4ToUint8(shN[30], shN[31]);
+      sh2Uint8Buffer[offset + 4] = packSint4ToUint8(shN[32], shN[33]);
+      sh2Uint8Buffer[offset + 5] = packSint4ToUint8(shN[34], shN[35]);
+      sh2Uint8Buffer[offset + 6] = packSint4ToUint8(shN[36], shN[37]);
+      sh2Uint8Buffer[offset + 7] = packSint4ToUint8(shN[38], shN[39]);
+      sh2Uint8Buffer[offset + 8] = packSint4ToUint8(shN[40], shN[41]);
+      sh2Uint8Buffer[offset + 9] = packSint4ToUint8(shN[42], shN[43]);
+      sh2Uint8Buffer[offset + 10] = packSint4ToUint8(shN[44], 0);
+    }
+  }
+  get(i, single) {
+    const { splatUint16Buffer, splatUint8Buffer } = this;
+    const i8 = i * 8;
+    const i16 = i * 16;
+    single.x = fromHalf(splatUint16Buffer[i8 + 0]);
+    single.y = fromHalf(splatUint16Buffer[i8 + 1]);
+    single.z = fromHalf(splatUint16Buffer[i8 + 2]);
+    const uScaleX = splatUint8Buffer[i16 + 6];
+    const uScaleY = splatUint8Buffer[i16 + 7];
+    const uScaleZ = splatUint8Buffer[i16 + 8];
+    single.sx = Math.exp(LN_SCALE_MIN + (uScaleX - 1) * LN_SCALE_INV);
+    single.sy = Math.exp(LN_SCALE_MIN + (uScaleY - 1) * LN_SCALE_INV);
+    single.sz = Math.exp(LN_SCALE_MIN + (uScaleZ - 1) * LN_SCALE_INV);
+    const u = fromUnsignedChar(splatUint8Buffer[i16 + 9]);
+    const v = fromUnsignedChar(splatUint8Buffer[i16 + 10]);
+    const angle = splatUint8Buffer[i16 + 11] / 255;
+    const quat = decodeQuatOct(u, v, angle);
+    single.qx = quat[0];
+    single.qy = quat[1];
+    single.qz = quat[2];
+    single.qw = quat[3];
+    single.r = splatUint8Buffer[i16 + 12] / 255;
+    single.g = splatUint8Buffer[i16 + 13] / 255;
+    single.b = splatUint8Buffer[i16 + 14] / 255;
+    single.a = splatUint8Buffer[i16 + 15] / 255;
+  }
+  getCenter(i, single) {
+    const { splatUint16Buffer } = this;
+    const i8 = i * 8;
+    single.x = fromHalf(splatUint16Buffer[i8 + 0]);
+    single.y = fromHalf(splatUint16Buffer[i8 + 1]);
+    single.z = fromHalf(splatUint16Buffer[i8 + 2]);
+  }
+  getScale(i, single) {
+    const { splatUint8Buffer } = this;
+    const i16 = i * 16;
+    const uScaleX = splatUint8Buffer[i16 + 6];
+    const uScaleY = splatUint8Buffer[i16 + 7];
+    const uScaleZ = splatUint8Buffer[i16 + 8];
+    single.sx = Math.exp(LN_SCALE_MIN + (uScaleX - 1) * LN_SCALE_INV);
+    single.sy = Math.exp(LN_SCALE_MIN + (uScaleY - 1) * LN_SCALE_INV);
+    single.sz = Math.exp(LN_SCALE_MIN + (uScaleZ - 1) * LN_SCALE_INV);
+  }
+  getQuat(i, single) {
+    const { splatUint8Buffer } = this;
+    const i16 = i * 16;
+    const u = fromUnsignedChar(splatUint8Buffer[i16 + 9]);
+    const v = fromUnsignedChar(splatUint8Buffer[i16 + 10]);
+    const angle = splatUint8Buffer[i16 + 11] / 255;
+    const quat = decodeQuatOct(u, v, angle);
+    single.qx = quat[0];
+    single.qy = quat[1];
+    single.qz = quat[2];
+    single.qw = quat[3];
+  }
+  getColor(i, single) {
+    const { splatUint8Buffer } = this;
+    const i16 = i * 16;
+    single.r = splatUint8Buffer[i16 + 12] / 255;
+    single.g = splatUint8Buffer[i16 + 13] / 255;
+    single.b = splatUint8Buffer[i16 + 14] / 255;
+  }
+  getAlpha(i, single) {
+    const { splatUint8Buffer } = this;
+    const i16 = i * 16;
+    single.a = splatUint8Buffer[i16 + 15] / 255;
+  }
+  getShN(i, shN) {
+    const { shDegree, sh1Uint32Buffer, sh1Uint8Buffer, sh2Uint8Buffer } = this;
+    if (shDegree >= 1) {
+      const offset = (shDegree === 1 ? 2 : 4) * i;
+      const low = sh1Uint32Buffer[offset];
+      const high = sh1Uint32Buffer[offset + 1];
+      unpackSint5x9FromUint32x2(low, high, shN, 0);
+    }
+    if (shDegree >= 2) {
+      const offset = 16 * i + 8;
+      unpackUint8ToSint4x2(sh1Uint8Buffer[offset + 0], shN, 9);
+      unpackUint8ToSint4x2(sh1Uint8Buffer[offset + 1], shN, 11);
+      unpackUint8ToSint4x2(sh1Uint8Buffer[offset + 2], shN, 13);
+      unpackUint8ToSint4x2(sh1Uint8Buffer[offset + 3], shN, 15);
+      unpackUint8ToSint4x2(sh1Uint8Buffer[offset + 5], shN, 17);
+      unpackUint8ToSint4x2(sh1Uint8Buffer[offset + 6], shN, 19);
+      unpackUint8ToSint4x2(sh1Uint8Buffer[offset + 7], shN, 21);
+      shN[23] = (sh2Uint8Buffer[offset + 8] & 15) * 0.125 - 1;
+    }
+    if (shDegree >= 3) {
+      const offset = 16 * i;
+      unpackUint8ToSint4x2(sh2Uint8Buffer[offset + 0], shN, 24);
+      unpackUint8ToSint4x2(sh2Uint8Buffer[offset + 1], shN, 26);
+      unpackUint8ToSint4x2(sh2Uint8Buffer[offset + 2], shN, 28);
+      unpackUint8ToSint4x2(sh2Uint8Buffer[offset + 3], shN, 30);
+      unpackUint8ToSint4x2(sh2Uint8Buffer[offset + 4], shN, 32);
+      unpackUint8ToSint4x2(sh2Uint8Buffer[offset + 5], shN, 34);
+      unpackUint8ToSint4x2(sh2Uint8Buffer[offset + 6], shN, 36);
+      unpackUint8ToSint4x2(sh2Uint8Buffer[offset + 7], shN, 38);
+      unpackUint8ToSint4x2(sh2Uint8Buffer[offset + 8], shN, 40);
+      unpackUint8ToSint4x2(sh2Uint8Buffer[offset + 9], shN, 42);
+      shN[44] = (sh2Uint8Buffer[offset + 10] & 15) * 0.125 - 1;
+    }
+  }
+  fillCenters(centers) {
+    const { counts, splatUint16Buffer } = this;
+    for (let i = 0; i < counts; i++) {
+      const i3 = i * 3;
+      const i8 = i * 8;
+      centers[i3 + 0] = fromHalf(splatUint16Buffer[i8 + 0]);
+      centers[i3 + 1] = fromHalf(splatUint16Buffer[i8 + 1]);
+      centers[i3 + 2] = fromHalf(splatUint16Buffer[i8 + 2]);
+    }
+  }
+  serialize() {
+    return {
+      counts: this.counts,
+      shDegree: this.shDegree,
+      samplers: [this.splatSampler, this.sh1Sampler, this.sh2Sampler]
+    };
+  }
+  deserialize(data) {
+    const { counts, shDegree, samplers } = data;
+    this.counts = counts;
+    this.shDegree = shDegree;
+    const { w: width, h: height, d: depth } = computeTextureSize(counts, this.maxTextureSize);
+    const pixelCounts = width * height * depth;
+    const splatSampler = this.splatSampler = samplers[0] ?? {
+      width,
+      height,
+      depth,
+      format: 1 /* RGBA_UINT */,
+      source: new Uint8Array(16 * pixelCounts)
+    };
+    this.splatUint8Buffer = new Uint8Array(splatSampler.source.buffer);
+    this.splatUint16Buffer = new Uint16Array(splatSampler.source.buffer);
+    const sh1Sampler = this.sh1Sampler = samplers[1] ?? {
+      width,
+      height,
+      depth,
+      format: shDegree === 1 ? 0 /* RG_UINT */ : 1 /* RGBA_UINT */,
+      source: new Uint8Array((shDegree >= 1 ? shDegree === 1 ? 8 : 16 : 0) * pixelCounts)
+    };
+    this.sh1Uint8Buffer = sh1Sampler.source;
+    this.sh1Uint32Buffer = new Uint32Array(sh1Sampler.source.buffer);
+    const sh2Sampler = this.sh2Sampler = samplers[2] ?? {
+      width,
+      height,
+      depth,
+      format: 1 /* RGBA_UINT */,
+      source: new Uint8Array((shDegree >= 3 ? 16 : 0) * pixelCounts)
+    };
+    this.sh2Uint8Buffer = sh2Sampler.source;
+  }
+};
+
+// ../../external/egs-core/packages/loaders/splat-loader/splat/SogSplatData.ts
+var SogSplatData = class extends SplatData {
+  constructor() {
+    super(...arguments);
+    this.counts = 0;
+    this.shDegree = 0;
+  }
+  init(_counts, _shDegree) {
+    throw new Error("Method not implemented.");
+  }
+  load(meta, meansL, meansU, quats, scales, colors, shNLabels, shNCentroids) {
+    this.meta = meta;
+    this.meansL = meansL;
+    this.meansU = meansU;
+    this.quats = quats;
+    this.scales = scales;
+    this.colors = colors;
+    this.shNLabels = shNLabels;
+    this.shNCentroids = shNCentroids;
+  }
+  set(_i, _single) {
+    throw new Error("Method not implemented.");
+  }
+  setCenter(_i, _x, _y, _z) {
+    throw new Error("Method not implemented.");
+  }
+  setScale(_i, _sx, _sy, _sz) {
+    throw new Error("Method not implemented.");
+  }
+  setQuat(_i, _qx, _qy, _qz, _qw) {
+    throw new Error("Method not implemented.");
+  }
+  setColor(_i, _r, _g, _b2) {
+    throw new Error("Method not implemented.");
+  }
+  setAlpha(_i, _a2) {
+    throw new Error("Method not implemented.");
+  }
+  setShN(_i, _shN) {
+    throw new Error("Method not implemented.");
+  }
+  get(_i, _single) {
+    throw new Error("Method not implemented.");
+  }
+  getCenter(_i, _single) {
+    throw new Error("Method not implemented.");
+  }
+  getScale(_i, _single) {
+    throw new Error("Method not implemented.");
+  }
+  getQuat(_i, _single) {
+    throw new Error("Method not implemented.");
+  }
+  getColor(_i, _single) {
+    throw new Error("Method not implemented.");
+  }
+  getAlpha(_i, _single) {
+    throw new Error("Method not implemented.");
+  }
+  getShN(_i, _shN) {
+    throw new Error("Method not implemented.");
+  }
+  fillCenters(_centers) {
+    throw new Error("Method not implemented.");
+  }
+  serialize() {
+    return {
+      counts: this.meta.counts,
+      shDegree: this.meta.shDegree,
+      samplers: [
+        this.meansL,
+        this.meansU,
+        this.quats,
+        this.scales,
+        this.colors,
+        this.shNLabels,
+        this.shNCentroids
+      ].filter((v) => !!v).map((v) => ({
+        width: 1,
+        height: 1,
+        depth: 1,
+        format: 1 /* RGBA_UINT */,
+        source: v
+      })),
+      extras: [this.meta]
+    };
+  }
+  deserialize(data) {
+    const { samplers, extras = [] } = data;
+    this.meta = extras[0];
+    this.meansL = samplers[0].source;
+    this.meansU = samplers[1].source;
+    this.quats = samplers[2].source;
+    this.scales = samplers[3].source;
+    this.colors = samplers[4].source;
+    if (samplers[5]) {
+      this.shNLabels = samplers[5].source;
+    }
+    if (samplers[6]) {
+      this.shNCentroids = samplers[6].source;
+    }
+  }
+};
+
+// ../../external/egs-core/packages/loaders/splat-loader/file/utils.ts
+var SH_C0 = 0.28209479177387814;
+var SH_MAPS2 = {
+  0: 0,
+  1: 9,
+  2: 24,
+  3: 45
+};
+var NUM_F_REST_TO_SH_DEGREE = {
+  0: 0,
+  9: 1,
+  24: 2,
+  45: 3
+};
+var BufferReader = class {
+  constructor(buffer = new Uint8Array()) {
+    this.head = 0;
+    this.tail = 0;
+    this.buffer = buffer;
+    this.view = new DataView(this.buffer.buffer);
+  }
+  get remaining() {
+    return this.tail - this.head;
+  }
+  grow(required) {
+    const newCap = Math.max(required, this.buffer.length * 2);
+    const next = new Uint8Array(newCap);
+    next.set(this.buffer.subarray(this.head, this.tail), 0);
+    this.tail -= this.head;
+    this.head = 0;
+    this.buffer = next;
+    this.view = new DataView(next.buffer);
+  }
+  compact() {
+    if (this.head === 0) {
+      return;
+    }
+    this.buffer.copyWithin(0, this.head, this.tail);
+    this.tail -= this.head;
+    this.head = 0;
+  }
+  write(chunk) {
+    const remaining = this.tail - this.head;
+    const required = remaining + chunk.length;
+    if (this.buffer.length < required) {
+      this.grow(required);
+    } else if (this.head > 0 && this.buffer.length - this.tail < chunk.length) {
+      this.compact();
+    }
+    this.buffer.set(chunk, this.tail);
+    this.tail += chunk.length;
+  }
+  read(counts) {
+    const head = this.head;
+    const tail = this.head = head + counts;
+    return this.buffer.subarray(head, tail);
+  }
+};
+var StreamChunkDecoder = class {
+  constructor(reader) {
+    this.currentIndex = 0;
+    this.reader = reader;
+  }
+  setDecoders(decoders) {
+    this.decoders = decoders;
+    this.decodedTotals = new Uint32Array(decoders.length);
+    const [totals, itemSize] = decoders[this.currentIndex].init();
+    this.currentTotals = totals;
+    this.currentItemSize = itemSize;
+  }
+  flush() {
+    const { reader, decoders, decodedTotals, currentIndex, currentTotals, currentItemSize } = this;
+    const stage = decoders[currentIndex];
+    const decoded = decodedTotals[currentIndex];
+    const counts = Math.min(currentTotals - decoded, reader.remaining / currentItemSize | 0);
+    const buf = reader.read(counts * currentItemSize);
+    stage.decode(decoded, counts, buf);
+    decodedTotals[currentIndex] += counts;
+    if (decodedTotals[currentIndex] === currentTotals) {
+      this.currentIndex++;
+      if (this.currentIndex < decoders.length) {
+        const [totals, itemSize] = decoders[this.currentIndex].init();
+        this.currentTotals = totals;
+        this.currentItemSize = itemSize;
+        this.flush();
+      }
+    }
+  }
+};
+var f32buffer2 = new Float32Array(1);
+var u32buffer2 = new Uint32Array(f32buffer2.buffer);
+function fromHalf2(h) {
+  const sign = h >> 15 & 1;
+  const exp = h >> 10 & 31;
+  const frac = h & 1023;
+  let f32bits;
+  if (exp === 0) {
+    if (frac === 0) {
+      f32bits = sign << 31;
+    } else {
+      let mant = frac;
+      let e = -14;
+      while ((mant & 1024) === 0) {
+        mant <<= 1;
+        e--;
+      }
+      mant &= 1023;
+      const newExp = e + 127;
+      const newFrac = mant << 13;
+      f32bits = sign << 31 | newExp << 23 | newFrac;
+    }
+  } else if (exp === 31) {
+    if (frac === 0) {
+      f32bits = sign << 31 | 2139095040;
+    } else {
+      f32bits = sign << 31 | 2143289344;
+    }
+  } else {
+    const newExp = exp - 15 + 127;
+    const newFrac = frac << 13;
+    f32bits = sign << 31 | newExp << 23 | newFrac;
+  }
+  u32buffer2[0] = f32bits;
+  return f32buffer2[0];
+}
+function clamp2(v, min, max2) {
+  return Math.min(Math.max(v, min), max2);
+}
+function isUrl(str) {
+  let url;
+  try {
+    url = new URL(str);
+  } catch {
+    return false;
+  }
+  return url.protocol === "http:" || url.protocol === "https:";
+}
+var canvas;
+var context;
+async function decodeImage(fileBytes) {
+  if (!context) {
+    canvas = new OffscreenCanvas(1, 1);
+    context = canvas.getContext("2d", { willReadFrequently: true }) ?? void 0;
+  }
+  if (!context) {
+    throw new Error("Failed to create context");
+  }
+  const imageBlob = new Blob([fileBytes]);
+  const bitmap = await createImageBitmap(imageBlob, {
+    premultiplyAlpha: "none"
+  });
+  const { width, height } = bitmap;
+  canvas.width = width;
+  canvas.height = height;
+  context.drawImage(bitmap, 0, 0, width, height);
+  const data = context.getImageData(0, 0, width, height);
+  return {
+    data: new Uint8Array(data.data.buffer, data.data.byteOffset, data.data.length),
+    width,
+    height
+  };
+}
+function extractFromRootDir(entries) {
+  let dir = "";
+  for (const path in entries) {
+    if (path.endsWith("/")) {
+      dir = path;
+      break;
+    }
+  }
+  const result = {};
+  for (const path in entries) {
+    result[path.replace(dir, "")] = entries[path];
+  }
+  return result;
+}
+
+// ../../external/egs-core/packages/loaders/splat-loader/file/ksplat.ts
+var KSPLAT_COMPRESSION = {
+  0: {
+    bytesPerCenter: 12,
+    bytesPerScale: 12,
+    bytesPerRotation: 16,
+    bytesPerColor: 4,
+    bytesPerSphericalHarmonicsComponent: 4,
+    scaleOffsetBytes: 12,
+    rotationOffsetBytes: 24,
+    colorOffsetBytes: 40,
+    sphericalHarmonicsOffsetBytes: 44,
+    scaleRange: 1
+  },
+  1: {
+    bytesPerCenter: 6,
+    bytesPerScale: 6,
+    bytesPerRotation: 8,
+    bytesPerColor: 4,
+    bytesPerSphericalHarmonicsComponent: 2,
+    scaleOffsetBytes: 6,
+    rotationOffsetBytes: 12,
+    colorOffsetBytes: 20,
+    sphericalHarmonicsOffsetBytes: 24,
+    scaleRange: 32767
+  },
+  2: {
+    bytesPerCenter: 6,
+    bytesPerScale: 6,
+    bytesPerRotation: 8,
+    bytesPerColor: 4,
+    bytesPerSphericalHarmonicsComponent: 1,
+    scaleOffsetBytes: 6,
+    rotationOffsetBytes: 12,
+    colorOffsetBytes: 20,
+    sphericalHarmonicsOffsetBytes: 24,
+    scaleRange: 32767
+  }
+};
+var SHIndex = [
+  0,
+  3,
+  6,
+  1,
+  4,
+  7,
+  2,
+  5,
+  8,
+  // sh1
+  9,
+  14,
+  19,
+  10,
+  15,
+  20,
+  11,
+  16,
+  21,
+  12,
+  17,
+  22,
+  13,
+  18,
+  23,
+  // sh2
+  24,
+  31,
+  38,
+  25,
+  32,
+  39,
+  26,
+  33,
+  40,
+  27,
+  34,
+  41,
+  28,
+  35,
+  42,
+  29,
+  36,
+  43,
+  30,
+  37,
+  44
+  // sh3
+];
+var HEADER_BYTES = 4096;
+var SECTION_BYTES = 1024;
+var KsplatFile = class {
+  constructor() {
+    this.counts = 0;
+    this.shDegree = 0;
+  }
+  load(buffer) {
+    this.buffer = buffer;
+    const header = new DataView(buffer.buffer, 0, HEADER_BYTES);
+    const versionMajor = header.getUint8(0);
+    const versionMinor = header.getUint8(1);
+    if (versionMajor !== 0 || versionMinor < 1) {
+      throw new Error(`Unsupported .ksplat version: ${versionMajor}.${versionMinor}`);
+    }
+    const maxSectionCount = header.getUint32(4, true);
+    const sectionCount = header.getUint32(8, true);
+    const maxSplatCount = header.getUint32(12, true);
+    const splatCount = header.getUint32(16, true);
+    const compressionLevel = header.getUint16(20, true);
+    if (compressionLevel < 0 || compressionLevel > 2) {
+      throw new Error(`Invalid .ksplat compression level: ${compressionLevel}`);
+    }
+    const sceneCenterX = header.getFloat32(24, true);
+    const sceneCenterY = header.getFloat32(28, true);
+    const sceneCenterZ = header.getFloat32(32, true);
+    const minSH = header.getFloat32(36, true) || -1.5;
+    const maxSH = header.getFloat32(40, true) || 1.5;
+    let maxSHDegree = 0;
+    const sections = [];
+    for (let i = 0; i < maxSectionCount; i++) {
+      const section = new DataView(buffer.buffer, HEADER_BYTES + i * SECTION_BYTES, SECTION_BYTES);
+      const sectionSplatCount = section.getUint32(0, true);
+      const sectionMaxSplatCount = section.getUint32(4, true);
+      const bucketSize = section.getUint32(8, true);
+      const bucketCount = section.getUint32(12, true);
+      const bucketBlockSize = section.getFloat32(16, true);
+      const bucketStorageSizeBytes = section.getUint16(20, true);
+      const compressionScaleRange = section.getUint32(24, true);
+      const fullBucketCount = section.getUint32(32, true);
+      const partiallyFilledBucketCount = section.getUint32(36, true);
+      const shDegree = section.getUint16(40, true);
+      maxSHDegree = Math.max(maxSHDegree, shDegree);
+      sections.push({
+        sectionSplatCount,
+        sectionMaxSplatCount,
+        bucketSize,
+        bucketCount,
+        bucketBlockSize,
+        bucketStorageSizeBytes,
+        compressionScaleRange: compressionScaleRange || KSPLAT_COMPRESSION[compressionLevel].scaleRange,
+        fullBucketCount,
+        partiallyFilledBucketCount,
+        shDegree
+      });
+    }
+    this.header = {
+      versionMajor,
+      versionMinor,
+      maxSectionCount,
+      sectionCount,
+      maxSplatCount,
+      splatCount,
+      compressionLevel,
+      sceneCenter: [sceneCenterX, sceneCenterY, sceneCenterZ],
+      shRange: [minSH, maxSH]
+    };
+    this.sections = sections;
+    this.counts = splatCount;
+    this.shDegree = maxSHDegree;
+  }
+  async read(stream, contentLength, data) {
+    let BlockOffset = 0;
+    {
+      const buffer2 = new Uint8Array(contentLength);
+      const reader = stream.getReader();
+      let offset = 0;
+      while (true) {
+        const { done, value } = await reader.read();
+        if (done) {
+          break;
+        }
+        buffer2.set(value, offset);
+        offset += value.length;
+      }
+      this.load(buffer2);
+      BlockOffset = await data.initBlock(this.counts, this.shDegree);
+    }
+    const setFn = data.set.bind(data);
+    const setShFn = data.setShN.bind(data);
+    const { buffer, header, sections, shDegree: maxSHDegree } = this;
+    const { maxSectionCount, compressionLevel, shRange: [minSH, maxSH] } = header;
+    const isHighQualitySplatData = compressionLevel === 0;
+    const single = {
+      x: 0,
+      y: 0,
+      z: 0,
+      sx: 0,
+      sy: 0,
+      sz: 0,
+      qx: 0,
+      qy: 0,
+      qz: 0,
+      qw: 0,
+      r: 0,
+      g: 0,
+      b: 0,
+      a: 0,
+      shN: []
+    };
+    const maxSHSize = SH_MAPS2[maxSHDegree];
+    const shData = new Array(maxSHSize);
+    let sectionBase = HEADER_BYTES + maxSectionCount * SECTION_BYTES;
+    for (let i = 0; i < maxSectionCount; i++) {
+      const {
+        sectionSplatCount,
+        sectionMaxSplatCount,
+        bucketSize,
+        bucketCount,
+        bucketBlockSize,
+        bucketStorageSizeBytes,
+        fullBucketCount,
+        partiallyFilledBucketCount,
+        compressionScaleRange,
+        shDegree
+      } = sections[i];
+      const fullBucketSplats = fullBucketCount * bucketSize;
+      const bucketsMetaDataSizeBytes = partiallyFilledBucketCount * 4;
+      const bucketsStorageSizeBytes = bucketStorageSizeBytes * bucketCount + bucketsMetaDataSizeBytes;
+      const shComponents = SH_MAPS2[shDegree];
+      const {
+        bytesPerCenter,
+        bytesPerScale,
+        bytesPerRotation,
+        bytesPerColor,
+        bytesPerSphericalHarmonicsComponent,
+        scaleOffsetBytes,
+        rotationOffsetBytes,
+        colorOffsetBytes,
+        sphericalHarmonicsOffsetBytes
+      } = KSPLAT_COMPRESSION[compressionLevel];
+      const bytesPerSplat = bytesPerCenter + bytesPerScale + bytesPerRotation + bytesPerColor + shComponents * bytesPerSphericalHarmonicsComponent;
+      const splatDataStorageSizeBytes = bytesPerSplat * sectionMaxSplatCount;
+      const storageSizeBytes = splatDataStorageSizeBytes + bucketsStorageSizeBytes;
+      const compressionScaleFactor = bucketBlockSize / 2 / compressionScaleRange;
+      const bucketsBase = sectionBase + bucketsMetaDataSizeBytes;
+      const dataBase = sectionBase + bucketsStorageSizeBytes;
+      const data2 = new DataView(buffer.buffer, dataBase, splatDataStorageSizeBytes);
+      const bucketArray = new Float32Array(buffer.buffer, bucketsBase, bucketCount * 3);
+      const partiallyFilledBucketLengths = new Uint32Array(buffer.buffer, sectionBase, partiallyFilledBucketCount);
+      let partialBucketIndex = fullBucketCount;
+      let partialBucketBase = fullBucketSplats;
+      for (let j = 0; j < sectionSplatCount; j++) {
+        const splatOffset = j * bytesPerSplat;
+        let bucketIndex;
+        if (j < fullBucketSplats) {
+          bucketIndex = Math.floor(j / bucketSize);
+        } else {
+          const bucketLength = partiallyFilledBucketLengths[partialBucketIndex - fullBucketCount];
+          if (j >= partialBucketBase + bucketLength) {
+            partialBucketIndex += 1;
+            partialBucketBase += bucketLength;
+          }
+          bucketIndex = partialBucketIndex;
+        }
+        if (isHighQualitySplatData) {
+          single.x = data2.getFloat32(splatOffset + 0, true);
+          single.y = data2.getFloat32(splatOffset + 4, true);
+          single.z = data2.getFloat32(splatOffset + 8, true);
+          single.sx = data2.getFloat32(splatOffset + scaleOffsetBytes + 0, true);
+          single.sy = data2.getFloat32(splatOffset + scaleOffsetBytes + 4, true);
+          single.sz = data2.getFloat32(splatOffset + scaleOffsetBytes + 8, true);
+          single.qw = data2.getFloat32(splatOffset + rotationOffsetBytes + 0, true);
+          single.qx = data2.getFloat32(splatOffset + rotationOffsetBytes + 4, true);
+          single.qy = data2.getFloat32(splatOffset + rotationOffsetBytes + 8, true);
+          single.qz = data2.getFloat32(splatOffset + rotationOffsetBytes + 12, true);
+        } else {
+          single.x = (data2.getUint16(splatOffset + 0, true) - compressionScaleRange) * compressionScaleFactor + bucketArray[3 * bucketIndex + 0];
+          single.y = (data2.getUint16(splatOffset + 2, true) - compressionScaleRange) * compressionScaleFactor + bucketArray[3 * bucketIndex + 1];
+          single.z = (data2.getUint16(splatOffset + 4, true) - compressionScaleRange) * compressionScaleFactor + bucketArray[3 * bucketIndex + 2];
+          single.sx = fromHalf2(data2.getUint16(splatOffset + scaleOffsetBytes + 0, true));
+          single.sy = fromHalf2(data2.getUint16(splatOffset + scaleOffsetBytes + 2, true));
+          single.sz = fromHalf2(data2.getUint16(splatOffset + scaleOffsetBytes + 4, true));
+          single.qw = fromHalf2(data2.getUint16(splatOffset + rotationOffsetBytes + 0, true));
+          single.qx = fromHalf2(data2.getUint16(splatOffset + rotationOffsetBytes + 2, true));
+          single.qy = fromHalf2(data2.getUint16(splatOffset + rotationOffsetBytes + 4, true));
+          single.qz = fromHalf2(data2.getUint16(splatOffset + rotationOffsetBytes + 6, true));
+        }
+        single.r = data2.getUint8(splatOffset + colorOffsetBytes + 0) / 255;
+        single.g = data2.getUint8(splatOffset + colorOffsetBytes + 1) / 255;
+        single.b = data2.getUint8(splatOffset + colorOffsetBytes + 2) / 255;
+        single.a = data2.getUint8(splatOffset + colorOffsetBytes + 3) / 255;
+        setFn(j + BlockOffset, single);
+        const shOffsetBytes = splatOffset + sphericalHarmonicsOffsetBytes;
+        for (let k = 0; k < shComponents; k++) {
+          shData[k] = compressionLevel === 0 ? data2.getFloat32(shOffsetBytes + SHIndex[k] * 4, true) : compressionLevel === 1 ? fromHalf2(data2.getUint16(shOffsetBytes + SHIndex[k] * 2, true)) : minSH + data2.getUint8(shOffsetBytes + SHIndex[k]) / 255 * (maxSH - minSH);
+        }
+        for (let k = maxSHSize - 1; k >= shComponents; k--) {
+          shData[k] = 0;
+        }
+        setShFn(j + BlockOffset, shData);
+      }
+      sectionBase += storageSizeBytes;
+    }
+    data.finishBlock();
+  }
+  async write(_stream, _data) {
+    throw new Error("Method not implemented.");
+  }
+};
+
+// ../../external/egs-core/packages/loaders/splat-loader/file/ply.ts
+var F_REST_REGEX = /^f_rest_([0-9]{1,2})$/;
+function createEmptyBlock(properties, shDegree) {
+  const result = {
+    f_rest: new Array(SH_MAPS2[shDegree])
+  };
+  for (const name of Object.keys(properties)) {
+    if (F_REST_REGEX.test(name)) {
+      continue;
+    }
+    result[name] = 0;
+  }
+  return result;
+}
+var FIELD_BYTES = {
+  char: 1,
+  uchar: 1,
+  short: 2,
+  ushort: 2,
+  int: 4,
+  uint: 4,
+  float: 4,
+  double: 8
+};
+function createParseFn(properties, littleEndian, shDegree) {
+  function createPropertyParse(type) {
+    switch (type) {
+      case "char":
+        return "data.getInt8(offset)";
+      case "uchar":
+        return "data.getUint8(offset)";
+      case "short":
+        return `data.getInt16(offset, ${littleEndian})`;
+      case "ushort":
+        return `data.getUint16(offset, ${littleEndian})`;
+      case "int":
+        return `data.getInt32(offset, ${littleEndian})`;
+      case "uint":
+        return `data.getUint32(offset, ${littleEndian})`;
+      case "float":
+        return `data.getFloat32(offset, ${littleEndian})`;
+      case "double":
+        return `data.getFloat64(offset, ${littleEndian})`;
+    }
+  }
+  let itemSize = 0;
+  const parserSrc = [];
+  const shLen = SH_MAPS2[shDegree] / 3;
+  for (const [propertyName, propertyType] of Object.entries(properties)) {
+    const fRestMatch = propertyName.match(F_REST_REGEX);
+    if (fRestMatch) {
+      let fRestIndex = parseInt(fRestMatch[1], 10);
+      fRestIndex = fRestIndex % shLen * 3 + Math.floor(fRestIndex / shLen);
+      parserSrc.push(`item.f_rest[${fRestIndex}] = ${createPropertyParse(propertyType)};`);
+    } else {
+      parserSrc.push(`item.${propertyName} = ${createPropertyParse(propertyType)};`);
+    }
+    parserSrc.push(`offset += ${FIELD_BYTES[propertyType]};`);
+    itemSize += FIELD_BYTES[propertyType];
+  }
+  return [itemSize, new Function("data", "offset", "item", parserSrc.join("\n"))];
+}
+var HeaderTerminator = "end_header\n";
+var PlyFile = class {
+  constructor() {
+    this.littleEndian = true;
+    this.comments = [];
+    this.elements = {};
+    this.isSuperSplatCompressed = false;
+    this.counts = 0;
+    this.shDegree = 0;
+  }
+  initHeader(header) {
+    let curElement;
+    const lines = header.trim().split("\n").map((v) => v.trim()).filter((v) => !!v);
+    for (let i = 0; i < lines.length; i++) {
+      const line = lines[i];
+      if (i === 0) {
+        if (line !== "ply") {
+          throw new Error("Invalid PLY header");
+        }
+        continue;
+      }
+      const fields = line.split(" ");
+      switch (fields[0]) {
+        case "format":
+          if (fields[1] === "binary_little_endian") {
+            this.littleEndian = true;
+          } else if (fields[1] === "binary_big_endian") {
+            this.littleEndian = false;
+          } else {
+            throw new Error(`Unsupported PLY format: ${fields[1]}`);
+          }
+          if (fields[2] !== "1.0") {
+            throw new Error(`Unsupported PLY version: ${fields[2]}`);
+          }
+          break;
+        case "comment":
+          this.comments.push(line.slice("comment ".length));
+          break;
+        case "element": {
+          const name = fields[1];
+          curElement = this.elements[name] = {
+            name,
+            count: parseInt(fields[2], 10),
+            properties: {}
+          };
+          break;
+        }
+        case "property":
+          if (!curElement) {
+            throw new Error("Property must be inside an element");
+          }
+          if (!FIELD_BYTES[fields[1]]) {
+            throw new Error(`Unsupported property type '${fields[1]}'`);
+          }
+          curElement.properties[fields[2]] = fields[1];
+          break;
+        case "end_header":
+          break;
+        default:
+          console.warn(`Skipping unsupported PLY keyword: ${fields[0]}`);
+          break;
+      }
+    }
+    const { elements } = this;
+    const isSuperSplatCompressed = this.isSuperSplatCompressed = !!elements.chunk;
+    this.counts = elements.vertex?.count ?? 0;
+    const shElement = isSuperSplatCompressed ? elements.sh : elements.vertex;
+    if (shElement) {
+      const { properties } = shElement;
+      let num_f_rest = 0;
+      while (properties[`f_rest_${num_f_rest}`]) {
+        num_f_rest += 1;
+      }
+      const shDegree = NUM_F_REST_TO_SH_DEGREE[num_f_rest];
+      if (shDegree === void 0) {
+        throw new Error(`Unsupported number of SH coefficients: ${num_f_rest}`);
+      }
+      this.shDegree = shDegree;
+    }
+    for (const name in elements) {
+      const { properties } = elements[name];
+      if (isSuperSplatCompressed) {
+        if (name === "chunk") {
+          const {
+            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,
+            min_r,
+            min_g,
+            min_b,
+            max_r,
+            max_g,
+            max_b
+          } = properties;
+          if (!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 || !min_r || !min_g || !min_b || !max_r || !max_g || !max_b) {
+            throw new Error("Missing Compressed PLY chunk properties");
+          }
+        } else if (name === "vertex") {
+          const { packed_position, packed_rotation, packed_scale, packed_color } = properties;
+          if (!packed_position || !packed_rotation || !packed_scale || !packed_color) {
+            throw new Error("Missing Compressed PLY vertex properties");
+          }
+        }
+      } else {
+        if (name === "vertex") {
+          const {
+            x,
+            y,
+            z,
+            scale_0,
+            scale_1,
+            scale_2,
+            rot_0,
+            rot_1,
+            rot_2,
+            rot_3,
+            f_dc_0,
+            f_dc_1,
+            f_dc_2,
+            opacity
+          } = properties;
+          if (!x || !y || !z || !scale_0 || !scale_1 || !scale_2 || !rot_0 || !rot_1 || !rot_2 || !rot_3 || !f_dc_0 || !f_dc_1 || !f_dc_2 || !opacity) {
+            throw new Error("Missing PLY vertex properties");
+          }
+        }
+      }
+    }
+  }
+  async read(stream, _contentLength, data) {
+    const setFn = data.set.bind(data);
+    const setShFn = data.setShN.bind(data);
+    let headerParsed = false;
+    let header = "";
+    const reader = new BufferReader();
+    const decoder = new StreamChunkDecoder(reader);
+    let BlockOffset = 0;
+    const chunks = [];
+    const single = {
+      x: 0,
+      y: 0,
+      z: 0,
+      sx: 0,
+      sy: 0,
+      sz: 0,
+      qx: 0,
+      qy: 0,
+      qz: 0,
+      qw: 0,
+      r: 0,
+      g: 0,
+      b: 0,
+      a: 0,
+      shN: []
+    };
+    const initDecoder = () => {
+      const { elements, littleEndian, isSuperSplatCompressed, shDegree } = this;
+      const chunkDecoders = [];
+      for (const name in elements) {
+        const { count, properties } = elements[name];
+        const block = createEmptyBlock(properties, shDegree);
+        const [itemSize, parseFn] = createParseFn(properties, littleEndian, shDegree);
+        let fn = () => {
+        };
+        if (isSuperSplatCompressed) {
+          if (name === "chunk") {
+            fn = (i, item) => {
+              chunks[i - BlockOffset] = { ...item };
+            };
+          } else if (name === "sh") {
+            fn = (i, item) => {
+              setShFn(i, item.f_rest.map((v) => v * 8 / 255 - 4));
+            };
+          } else if (name === "vertex") {
+            fn = (i, item) => {
+              const chunk = chunks[i - BlockOffset >>> 8];
+              if (!chunk) {
+                throw new Error("Missing PLY chunk");
+              }
+              const {
+                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,
+                min_r,
+                min_g,
+                min_b,
+                max_r,
+                max_g,
+                max_b
+              } = chunk;
+              const { packed_position, packed_rotation, packed_scale, packed_color } = item;
+              single.x = (packed_position >>> 21 & 2047) / 2047 * (max_x - min_x) + min_x;
+              single.y = (packed_position >>> 11 & 1023) / 1023 * (max_y - min_y) + min_y;
+              single.z = (packed_position & 2047) / 2047 * (max_z - min_z) + min_z;
+              const r0 = ((packed_rotation >>> 20 & 1023) / 1023 - 0.5) * Math.SQRT2;
+              const r1 = ((packed_rotation >>> 10 & 1023) / 1023 - 0.5) * Math.SQRT2;
+              const r2 = ((packed_rotation & 1023) / 1023 - 0.5) * Math.SQRT2;
+              const rr = Math.sqrt(Math.max(0, 1 - r0 * r0 - r1 * r1 - r2 * r2));
+              const rOrder = packed_rotation >>> 30;
+              single.qx = rOrder === 0 ? r0 : rOrder === 1 ? rr : r1;
+              single.qy = rOrder <= 1 ? r1 : rOrder === 2 ? rr : r2;
+              single.qz = rOrder <= 2 ? r2 : rr;
+              single.qw = rOrder === 0 ? rr : r0;
+              single.sx = Math.exp((packed_scale >>> 21 & 2047) / 2047 * (max_scale_x - min_scale_x) + min_scale_x);
+              single.sy = Math.exp((packed_scale >>> 11 & 1023) / 1023 * (max_scale_y - min_scale_y) + min_scale_y);
+              single.sz = Math.exp((packed_scale & 2047) / 2047 * (max_scale_z - min_scale_z) + min_scale_z);
+              single.r = (packed_color >>> 24 & 255) / 255 * (max_r - min_r) + min_r;
+              single.g = (packed_color >>> 16 & 255) / 255 * (max_g - min_g) + min_g;
+              single.b = (packed_color >>> 8 & 255) / 255 * (max_b - min_b) + min_b;
+              single.a = (packed_color & 255) / 255;
+              setFn(i, single);
+            };
+          }
+        } else if (name === "vertex") {
+          fn = (i, item) => {
+            single.x = item.x;
+            single.y = item.y;
+            single.z = item.z;
+            single.sx = Math.exp(item.scale_0);
+            single.sy = Math.exp(item.scale_1);
+            single.sz = Math.exp(item.scale_2);
+            single.qx = item.rot_1;
+            single.qy = item.rot_2;
+            single.qz = item.rot_3;
+            single.qw = item.rot_0;
+            single.r = item.f_dc_0 * SH_C0 + 0.5;
+            single.g = item.f_dc_1 * SH_C0 + 0.5;
+            single.b = item.f_dc_2 * SH_C0 + 0.5;
+            single.a = 1 / (1 + Math.exp(-item.opacity));
+            setFn(i, single);
+            setShFn(i, item.f_rest);
+          };
+        }
+        chunkDecoders.push({
+          init: () => [count, itemSize],
+          decode: (offset, counts, buffer) => {
+            offset += BlockOffset;
+            const dataview = new DataView(buffer.buffer, buffer.byteOffset, buffer.byteLength);
+            for (let i = 0; i < counts; i++) {
+              parseFn(dataview, i * itemSize, block);
+              fn(offset + i, block);
+            }
+          }
+        });
+      }
+      decoder.setDecoders(chunkDecoders);
+    };
+    const textDecoder = new TextDecoder();
+    const source = stream.getReader();
+    while (true) {
+      const { done, value } = await source.read();
+      if (done) {
+        break;
+      }
+      reader.write(value);
+      if (!headerParsed) {
+        const HeaderReadBlockSize = 4096;
+        const counts = Math.ceil(reader.remaining / HeaderReadBlockSize);
+        for (let i = 0; i < counts; i++) {
+          const chunk = reader.read(HeaderReadBlockSize);
+          header += textDecoder.decode(chunk, { stream: true });
+          const idx = header.indexOf(HeaderTerminator);
+          if (idx >= 0) {
+            header = header.slice(0, idx + HeaderTerminator.length);
+            reader.head -= HeaderReadBlockSize - new TextEncoder().encode(header).length % HeaderReadBlockSize;
+            this.initHeader(header);
+            initDecoder();
+            BlockOffset = await data.initBlock(this.counts, this.shDegree);
+            headerParsed = true;
+            break;
+          }
+        }
+        if (!headerParsed) {
+          continue;
+        }
+      }
+      decoder.flush();
+    }
+    data.finishBlock();
+  }
+  async write(stream, data) {
+    const writer2 = stream.getWriter();
+    const counts = data.counts;
+    const shDegree = data.shDegree;
+    const shCounts = SH_MAPS2[shDegree];
+    const shCoeffs = shCounts / 3;
+    const header = [
+      "ply",
+      "format binary_little_endian 1.0",
+      `comment Generated by EGS`,
+      `element vertex ${counts}`,
+      "property float x",
+      "property float y",
+      "property float z",
+      "property float scale_0",
+      "property float scale_1",
+      "property float scale_2",
+      "property float rot_1",
+      "property float rot_2",
+      "property float rot_3",
+      "property float rot_0",
+      "property float f_dc_0",
+      "property float f_dc_1",
+      "property float f_dc_2",
+      "property float opacity",
+      new Array(shCounts).fill(0).map((_, i) => `property float f_rest_${i}`),
+      "end_header",
+      ""
+    ].flat().join("\n");
+    writer2.write(new TextEncoder().encode(header));
+    const ItemSize2 = 14 + shCounts;
+    const chunkSize = 1024;
+    const chunkCounts = Math.ceil(counts / chunkSize);
+    const single = {
+      x: 0,
+      y: 0,
+      z: 0,
+      sx: 0,
+      sy: 0,
+      sz: 0,
+      qx: 0,
+      qy: 0,
+      qz: 0,
+      qw: 0,
+      r: 0,
+      g: 0,
+      b: 0,
+      a: 0,
+      shN: new Array(shCounts)
+    };
+    const shN = single.shN;
+    for (let i = 0; i < chunkCounts; i++) {
+      if (writer2.desiredSize <= 0) {
+        await writer2.ready;
+      }
+      const currentChunkSize = Math.min(chunkSize, counts - i * chunkSize);
+      const chunk = new Float32Array(currentChunkSize * ItemSize2);
+      const offset = i * chunkSize;
+      for (let j = 0; j < currentChunkSize; j++) {
+        data.get(offset + j, single);
+        data.getShN(offset + j, shN);
+        const o = j * ItemSize2;
+        chunk[o + 0] = single.x;
+        chunk[o + 1] = single.y;
+        chunk[o + 2] = single.z;
+        chunk[o + 3] = Math.log(single.sx);
+        chunk[o + 4] = Math.log(single.sy);
+        chunk[o + 5] = Math.log(single.sz);
+        chunk[o + 6] = single.qx;
+        chunk[o + 7] = single.qy;
+        chunk[o + 8] = single.qz;
+        chunk[o + 9] = single.qw;
+        chunk[o + 10] = (single.r - 0.5) / SH_C0;
+        chunk[o + 11] = (single.g - 0.5) / SH_C0;
+        chunk[o + 12] = (single.b - 0.5) / SH_C0;
+        chunk[o + 13] = single.a === 0 ? -100 : -Math.log(1 / single.a - 1);
+        for (let k = 0; k < shCounts; k++) {
+          chunk[o + 14 + k] = shN[k % shCoeffs * 3 + (k / shCoeffs | 0)];
+        }
+      }
+      writer2.write(new Uint8Array(chunk.buffer));
+      await Promise.resolve();
+    }
+    await writer2.close();
+  }
+};
+
+// ../../external/egs-core/packages/loaders/splat-loader/file/sog.ts
+var ZIP_MAGIC = 67324752;
+var PERM_TABLE = [
+  // original quat idx ---> actual storage idx
+  [0, 1, 2, 3],
+  [3, 1, 2, 0],
+  [1, 3, 2, 0],
+  [1, 2, 3, 0]
+];
+var TEMP_ROT = new Float32Array(4);
+var SogFile = class {
+  constructor() {
+    this.counts = 0;
+    this.shDegree = 0;
+    /**
+     * @internal
+     */
+    this.refs = {};
+  }
+  async load(stream, contentLength) {
+    const buffer = new Uint8Array(contentLength);
+    const reader = stream.getReader();
+    let offset = 0;
+    while (true) {
+      const { done, value } = await reader.read();
+      if (done) {
+        break;
+      }
+      buffer.set(value, offset);
+      offset += value.length;
+    }
+    let metaBuffer = buffer;
+    const view = new DataView(buffer.buffer);
+    if (view.getUint32(0, true) === ZIP_MAGIC) {
+      this.refs = extractFromRootDir(unzipSync(buffer));
+      metaBuffer = this.refs["meta.json"];
+      if (!metaBuffer) {
+        throw new Error("SOG meta.json not found in the zip archive.");
+      }
+    }
+    this.meta = JSON.parse(new TextDecoder().decode(metaBuffer));
+    if (this.meta.version === void 0) {
+      const { means, quats, shN } = this.meta;
+      if (quats.encoding !== "quaternion_packed") {
+        throw new Error("Unsupported quaternion encoding");
+      }
+      this.counts = means.shape[0];
+      this.shDegree = shN ? NUM_F_REST_TO_SH_DEGREE[shN.shape[1]] : 0;
+      this.version = 1;
+    } else {
+      const { version, count, shN } = this.meta;
+      if (version !== 2) {
+        throw new Error(`Unsupported SOGS version: ${version}`);
+      }
+      this.counts = count;
+      this.shDegree = shN?.bands ?? 0;
+      this.version = version;
+    }
+  }
+  parse_v1(data, offset) {
+    const setFn = data.set.bind(data);
+    const setShFn = data.setShN.bind(data);
+    const { meta, counts, shDegree, cached } = this;
+    const [mean0, mean1, scale0, quat0, color0, centroids, labels] = cached.map((v) => v.data);
+    const {
+      means: { mins: [centerMinX, centerMinY, centerMinZ], maxs: [centerMaxX, centerMaxY, centerMaxZ] },
+      scales: { mins: [scaleMinX, scaleMinY, scaleMinZ], maxs: [scaleMaxX, scaleMaxY, scaleMaxZ] },
+      sh0: { mins: [colorMinR, colorMinG, colorMinB, colorMinA], maxs: [colorMaxR, colorMaxG, colorMaxB, colorMaxA] },
+      shN
+    } = meta;
+    const rangeX = (centerMaxX - centerMinX) / 65535;
+    const rangeY = (centerMaxY - centerMinY) / 65535;
+    const rangeZ = (centerMaxZ - centerMinZ) / 65535;
+    const SX_LUT = new Float32Array(256);
+    const SY_LUT = new Float32Array(256);
+    const SZ_LUT = new Float32Array(256);
+    const scaleRangeX = (scaleMaxX - scaleMinX) / 255;
+    const scaleRangeY = (scaleMaxY - scaleMinY) / 255;
+    const scaleRangeZ = (scaleMaxZ - scaleMinZ) / 255;
+    for (let i = 0; i < 256; i++) {
+      SX_LUT[i] = Math.exp(scaleMinX + scaleRangeX * i);
+      SY_LUT[i] = Math.exp(scaleMinY + scaleRangeY * i);
+      SZ_LUT[i] = Math.exp(scaleMinZ + scaleRangeZ * i);
+    }
+    const A_LUT = new Float32Array(256);
+    const colorRangeR = (colorMaxR - colorMinR) / 255;
+    const colorRangeG = (colorMaxG - colorMinG) / 255;
+    const colorRangeB = (colorMaxB - colorMinB) / 255;
+    const colorRangeA = (colorMaxA - colorMinA) / 255;
+    for (let i = 0; i < 256; i++) {
+      A_LUT[i] = 1 / (1 + Math.exp(-(colorMinA + colorRangeA * i)));
+    }
+    const single = {
+      x: 0,
+      y: 0,
+      z: 0,
+      sx: 0,
+      sy: 0,
+      sz: 0,
+      qx: 0,
+      qy: 0,
+      qz: 0,
+      qw: 0,
+      r: 0,
+      g: 0,
+      b: 0,
+      a: 0,
+      shN: []
+    };
+    for (let i = 0; i < counts; i++) {
+      const i4 = i * 4;
+      const x = centerMinX + rangeX * (mean0[i4 + 0] + (mean1[i4 + 0] << 8));
+      const y = centerMinY + rangeY * (mean0[i4 + 1] + (mean1[i4 + 1] << 8));
+      const z = centerMinZ + rangeZ * (mean0[i4 + 2] + (mean1[i4 + 2] << 8));
+      single.x = Math.sign(x) * (Math.exp(Math.abs(x)) - 1);
+      single.y = Math.sign(y) * (Math.exp(Math.abs(y)) - 1);
+      single.z = Math.sign(z) * (Math.exp(Math.abs(z)) - 1);
+      single.sx = SX_LUT[scale0[i4 + 0]];
+      single.sy = SY_LUT[scale0[i4 + 1]];
+      single.sz = SZ_LUT[scale0[i4 + 2]];
+      TEMP_ROT[0] = (quat0[i4 + 0] / 255 - 0.5) * Math.SQRT2;
+      TEMP_ROT[1] = (quat0[i4 + 1] / 255 - 0.5) * Math.SQRT2;
+      TEMP_ROT[2] = (quat0[i4 + 2] / 255 - 0.5) * Math.SQRT2;
+      TEMP_ROT[3] = Math.sqrt(Math.max(0, 1 - TEMP_ROT[0] * TEMP_ROT[0] - TEMP_ROT[1] * TEMP_ROT[1] - TEMP_ROT[2] * TEMP_ROT[2]));
+      const PERM = PERM_TABLE[quat0[i4 + 3] - 252];
+      single.qx = TEMP_ROT[PERM[0]];
+      single.qy = TEMP_ROT[PERM[1]];
+      single.qz = TEMP_ROT[PERM[2]];
+      single.qw = TEMP_ROT[PERM[3]];
+      single.r = SH_C0 * (colorMinR + colorRangeR * color0[i4 + 0]) + 0.5;
+      single.g = SH_C0 * (colorMinG + colorRangeG * color0[i4 + 1]) + 0.5;
+      single.b = SH_C0 * (colorMinB + colorRangeB * color0[i4 + 2]) + 0.5;
+      single.a = A_LUT[color0[i4 + 3]];
+      setFn(offset + i, single);
+    }
+    if (shN) {
+      const centroidTexWidth = cached[5].width;
+      const { mins: min, maxs: max2 } = shN;
+      const range = (max2 - min) / 255;
+      const shCounts = SH_MAPS2[shDegree];
+      const sh = new Array(shCounts);
+      const shCoeffs = shCounts / 3;
+      for (let i = 0; i < counts; i++) {
+        const i4 = i * 4;
+        const label = labels[i4] + (labels[i4 + 1] << 8);
+        const o = ((label >>> 6) * centroidTexWidth + (label & 63) * 15) * 4;
+        for (let j = 0; j < shCoeffs; j++) {
+          sh[j * 3 + 0] = min + range * centroids[o + j * 4 + 0];
+          sh[j * 3 + 1] = min + range * centroids[o + j * 4 + 1];
+          sh[j * 3 + 2] = min + range * centroids[o + j * 4 + 2];
+        }
+        setShFn(offset + i, sh);
+      }
+    }
+  }
+  parse_v2(data, offset) {
+    const setFn = data.set.bind(data);
+    const setShFn = data.setShN.bind(data);
+    const { meta, counts, shDegree, cached } = this;
+    const { means, scales, sh0, shN } = meta;
+    const {
+      mins: [centerMinX, centerMinY, centerMinZ],
+      maxs: [centerMaxX, centerMaxY, centerMaxZ]
+    } = means;
+    const { codebook: scaleCodebook } = scales;
+    const { codebook: sh0Codebook } = sh0;
+    const [mean0, mean1, scale0, quat0, color0, centroids, labels] = cached.map((img) => img.data);
+    const rangeX = (centerMaxX - centerMinX) / 65535;
+    const rangeY = (centerMaxY - centerMinY) / 65535;
+    const rangeZ = (centerMaxZ - centerMinZ) / 65535;
+    const SCALE_LUT = scaleCodebook.map((v) => Math.exp(v));
+    const single = {
+      x: 0,
+      y: 0,
+      z: 0,
+      sx: 0,
+      sy: 0,
+      sz: 0,
+      qx: 0,
+      qy: 0,
+      qz: 0,
+      qw: 0,
+      r: 0,
+      g: 0,
+      b: 0,
+      a: 0,
+      shN: []
+    };
+    for (let i = 0; i < counts; i++) {
+      const i4 = i * 4;
+      const x = centerMinX + rangeX * (mean0[i4 + 0] + (mean1[i4 + 0] << 8));
+      const y = centerMinY + rangeY * (mean0[i4 + 1] + (mean1[i4 + 1] << 8));
+      const z = centerMinZ + rangeZ * (mean0[i4 + 2] + (mean1[i4 + 2] << 8));
+      single.x = Math.sign(x) * (Math.exp(Math.abs(x)) - 1);
+      single.y = Math.sign(y) * (Math.exp(Math.abs(y)) - 1);
+      single.z = Math.sign(z) * (Math.exp(Math.abs(z)) - 1);
+      single.sx = SCALE_LUT[scale0[i4 + 0]];
+      single.sy = SCALE_LUT[scale0[i4 + 1]];
+      single.sz = SCALE_LUT[scale0[i4 + 2]];
+      TEMP_ROT[0] = (quat0[i4 + 0] / 255 - 0.5) * Math.SQRT2;
+      TEMP_ROT[1] = (quat0[i4 + 1] / 255 - 0.5) * Math.SQRT2;
+      TEMP_ROT[2] = (quat0[i4 + 2] / 255 - 0.5) * Math.SQRT2;
+      TEMP_ROT[3] = Math.sqrt(Math.max(0, 1 - TEMP_ROT[0] * TEMP_ROT[0] - TEMP_ROT[1] * TEMP_ROT[1] - TEMP_ROT[2] * TEMP_ROT[2]));
+      const PERM = PERM_TABLE[quat0[i4 + 3] - 252];
+      single.qx = TEMP_ROT[PERM[0]];
+      single.qy = TEMP_ROT[PERM[1]];
+      single.qz = TEMP_ROT[PERM[2]];
+      single.qw = TEMP_ROT[PERM[3]];
+      single.r = SH_C0 * sh0Codebook[color0[i4 + 0]] + 0.5;
+      single.g = SH_C0 * sh0Codebook[color0[i4 + 1]] + 0.5;
+      single.b = SH_C0 * sh0Codebook[color0[i4 + 2]] + 0.5;
+      single.a = color0[i4 + 3] / 255;
+      setFn(offset + i, single);
+    }
+    if (shN) {
+      const { codebook } = shN;
+      const shCounts = SH_MAPS2[shDegree];
+      const shCoeffs = shCounts / 3;
+      const offsetItemSize = shCoeffs * 4;
+      const sh = new Array(shCounts);
+      for (let i = 0; i < counts; i++) {
+        const i4 = i * 4;
+        const o = (labels[i4 + 0] + (labels[i4 + 1] << 8)) * offsetItemSize;
+        for (let j = 0; j < shCoeffs; j++) {
+          sh[j * 3] = codebook[centroids[o + j * 4 + 0]];
+          sh[j * 3 + 1] = codebook[centroids[o + j * 4 + 1]];
+          sh[j * 3 + 2] = codebook[centroids[o + j * 4 + 2]];
+        }
+        setShFn(offset + i, sh);
+      }
+    }
+  }
+  async loadTexture(path) {
+    let buffer = this.refs[path];
+    if (!buffer && isUrl(path)) {
+      buffer = await fetch(path).then((res) => res.arrayBuffer()).then((buf) => new Uint8Array(buf));
+    }
+    if (!buffer) {
+      throw new Error(`Cannot load texture: ${path}`);
+    }
+    return decodeImage(buffer.buffer);
+  }
+  async read(stream, contentLength, data) {
+    await this.load(stream, contentLength);
+    const BlockOffset = await data.initBlock(this.counts, this.shDegree);
+    const { means, scales, quats, sh0, shN } = this.meta;
+    this.cached = await Promise.all([
+      means.files[0],
+      means.files[1],
+      scales.files[0],
+      quats.files[0],
+      sh0.files[0],
+      shN?.files[0],
+      shN?.files[1]
+    ].filter((path) => !!path).map((path) => this.loadTexture(path)));
+    if (this.version === 1) {
+      this.parse_v1(data, BlockOffset);
+    } else if (this.version === 2) {
+      this.parse_v2(data, BlockOffset);
+    } else {
+      throw new Error(`Unsupported SOG version: ${this.version}`);
+    }
+    data.finishBlock();
+  }
+  async write(_stream, _data) {
+    throw new Error("Method not implemented.");
+  }
+};
+
+// ../../external/egs-core/packages/loaders/splat-loader/file/splat.ts
+var ItemSize = 32;
+var SplatFile = class {
+  async read(stream, contentLength, data) {
+    const setFn = data.set.bind(data);
+    const counts = Math.floor(contentLength / ItemSize);
+    const BlockOffset = await data.initBlock(counts, 0);
+    const reader = new BufferReader();
+    const decoder = new StreamChunkDecoder(reader);
+    const single = {
+      x: 0,
+      y: 0,
+      z: 0,
+      sx: 0,
+      sy: 0,
+      sz: 0,
+      qx: 0,
+      qy: 0,
+      qz: 0,
+      qw: 0,
+      r: 0,
+      g: 0,
+      b: 0,
+      a: 0,
+      shN: []
+    };
+    decoder.setDecoders([
+      {
+        init: () => [counts, ItemSize],
+        decode: (offset, counts2, buffer) => {
+          offset += BlockOffset;
+          const f32Array = new Float32Array(buffer.buffer);
+          let o = 0;
+          for (let i = 0; i < counts2; i++) {
+            o = i * 8;
+            single.x = f32Array[o];
+            single.y = f32Array[o + 1];
+            single.z = f32Array[o + 2];
+            single.sx = f32Array[o + 3];
+            single.sy = f32Array[o + 4];
+            single.sz = f32Array[o + 5];
+            o = i * 32;
+            single.r = buffer[o + 24] / 255;
+            single.g = buffer[o + 25] / 255;
+            single.b = buffer[o + 26] / 255;
+            single.a = buffer[o + 27] / 255;
+            single.qw = (buffer[o + 28] - 128) / 128;
+            single.qx = (buffer[o + 29] - 128) / 128;
+            single.qy = (buffer[o + 30] - 128) / 128;
+            single.qz = (buffer[o + 31] - 128) / 128;
+            setFn(offset + i, single);
+          }
+        }
+      }
+    ]);
+    const source = stream.getReader();
+    while (true) {
+      const { done, value } = await source.read();
+      if (done) {
+        break;
+      }
+      reader.write(value);
+      decoder.flush();
+    }
+    data.finishBlock();
+  }
+  async write(stream, data) {
+    const writer2 = stream.getWriter();
+    const chunkSize = 2048;
+    const chunkCounts = Math.ceil(data.counts / chunkSize);
+    const single = {
+      x: 0,
+      y: 0,
+      z: 0,
+      sx: 0,
+      sy: 0,
+      sz: 0,
+      qx: 0,
+      qy: 0,
+      qz: 0,
+      qw: 0,
+      r: 0,
+      g: 0,
+      b: 0,
+      a: 0,
+      shN: []
+    };
+    for (let i = 0; i < chunkCounts; i++) {
+      if (writer2.desiredSize <= 0) {
+        await writer2.ready;
+      }
+      const currentChunkSize = Math.min(chunkSize, data.counts - i * chunkSize);
+      const chunk = new Uint8Array(currentChunkSize * ItemSize);
+      const dataView = new DataView(chunk.buffer);
+      const offset = i * chunkSize;
+      for (let j = 0; j < currentChunkSize; j++) {
+        data.get(offset + j, single);
+        const o = j * ItemSize;
+        dataView.setFloat32(o, single.x, true);
+        dataView.setFloat32(o + 4, single.y, true);
+        dataView.setFloat32(o + 8, single.z, true);
+        dataView.setFloat32(o + 12, single.sx, true);
+        dataView.setFloat32(o + 16, single.sy, true);
+        dataView.setFloat32(o + 20, single.sz, true);
+        dataView.setUint8(o + 24, clamp2(Math.round(single.r * 255), 0, 255));
+        dataView.setUint8(o + 25, clamp2(Math.round(single.g * 255), 0, 255));
+        dataView.setUint8(o + 26, clamp2(Math.round(single.b * 255), 0, 255));
+        dataView.setUint8(o + 27, clamp2(Math.round(single.a * 255), 0, 255));
+        dataView.setUint8(o + 28, clamp2(Math.round(single.qw * 128 + 128), 0, 255));
+        dataView.setUint8(o + 29, clamp2(Math.round(single.qx * 128 + 128), 0, 255));
+        dataView.setUint8(o + 30, clamp2(Math.round(single.qy * 128 + 128), 0, 255));
+        dataView.setUint8(o + 31, clamp2(Math.round(single.qz * 128 + 128), 0, 255));
+      }
+      writer2.write(chunk);
+      await Promise.resolve();
+    }
+    await writer2.close();
+  }
+};
+
+// ../../external/egs-core/packages/loaders/splat-loader/file/spz.ts
+var SPZ_MAGIC = 1347635022;
+var SPZ_VERSION = 3;
+var FLAG_ANTIALIASED = 1;
+var COLOR_SCALE = SH_C0 / 0.15;
+var rotation = new Array(4);
+var SH_SCALE1 = 1 << 3;
+var SH_SCALE2 = 1 << 4;
+var SpzFile = class {
+  async read(stream, _contentLength, data) {
+    const setCenter = data.setCenter.bind(data);
+    const setAlpha = data.setAlpha.bind(data);
+    const setColor = data.setColor.bind(data);
+    const setScale = data.setScale.bind(data);
+    const setQuat = data.setQuat.bind(data);
+    const setShN = data.setShN.bind(data);
+    const SCALE_LUT = new Float32Array(256);
+    for (let i = 0; i < 256; i++) {
+      SCALE_LUT[i] = Math.exp(i / 16 - 10);
+    }
+    const COLOR_LUT = new Float32Array(256);
+    for (let i = 0; i < 256; i++) {
+      COLOR_LUT[i] = (i / 255 - 0.5) * COLOR_SCALE + 0.5;
+    }
+    let version = SPZ_VERSION;
+    let counts = 0;
+    let shDegree = 0;
+    let fractionalBits = 12;
+    let flags = FLAG_ANTIALIASED;
+    let reserved = 0;
+    let isF16 = false;
+    let useSmallestThreeQuat = true;
+    let fraction = 1;
+    let fractionInv = 1;
+    let shCounts = 0;
+    let BlockOffset = 0;
+    const shN = [];
+    const reader = new BufferReader();
+    const decoder = new StreamChunkDecoder(reader);
+    decoder.setDecoders([
+      {
+        init: () => [1, 16],
+        decode: async (_offset, _counts, buf) => {
+          const header = new DataView(buf.buffer);
+          if (header.getUint32(0, true) !== SPZ_MAGIC) {
+            throw new Error("Invalid SPZ file");
+          }
+          version = header.getUint32(4, true);
+          if (version < 1 || version > 3) {
+            throw new Error(`Unsupported SPZ version: ${version}`);
+          }
+          counts = header.getUint32(8, true);
+          shDegree = header.getUint8(12);
+          fractionalBits = header.getUint8(13);
+          flags = header.getUint8(14);
+          reserved = header.getUint8(15);
+          isF16 = version < 2;
+          useSmallestThreeQuat = version >= 3;
+          fraction = 1 << fractionalBits;
+          fractionInv = 1 / fraction;
+          shCounts = SH_MAPS2[shDegree];
+          BlockOffset = await data.initBlock(counts, shDegree);
+          if (flags || reserved) {
+          }
+        }
+      },
+      {
+        init: () => [counts, isF16 ? 6 : 9],
+        decode: (offset, counts2, buf) => {
+          offset += BlockOffset;
+          let x, y, z;
+          for (let i = 0; i < counts2; i++) {
+            if (isF16) {
+              const o = i * 6;
+              x = fromHalf2(buf[o + 1] << 8 | buf[o]);
+              y = fromHalf2(buf[o + 3] << 8 | buf[o + 2]);
+              z = fromHalf2(buf[o + 5] << 8 | buf[o + 4]);
+            } else {
+              const o = i * 9;
+              x = ((buf[o + 2] << 24 | buf[o + 1] << 16 | buf[o] << 8) >> 8) * fractionInv;
+              y = ((buf[o + 5] << 24 | buf[o + 4] << 16 | buf[o + 3] << 8) >> 8) * fractionInv;
+              z = ((buf[o + 8] << 24 | buf[o + 7] << 16 | buf[o + 6] << 8) >> 8) * fractionInv;
+            }
+            setCenter(offset + i, x, y, z);
+          }
+        }
+      },
+      {
+        init: () => [counts, 1],
+        decode: (offset, counts2, buf) => {
+          offset += BlockOffset;
+          for (let i = 0; i < counts2; i++) {
+            setAlpha(offset + i, buf[i] / 255);
+          }
+        }
+      },
+      {
+        init: () => [counts, 3],
+        decode: (offset, counts2, buf) => {
+          offset += BlockOffset;
+          for (let i = 0; i < counts2; i++) {
+            const o = i * 3;
+            setColor(offset + i, COLOR_LUT[buf[o]], COLOR_LUT[buf[o + 1]], COLOR_LUT[buf[o + 2]]);
+          }
+        }
+      },
+      {
+        init: () => [counts, 3],
+        decode: (offset, counts2, buf) => {
+          offset += BlockOffset;
+          for (let i = 0; i < counts2; i++) {
+            const o = i * 3;
+            setScale(offset + i, SCALE_LUT[buf[o]], SCALE_LUT[buf[o + 1]], SCALE_LUT[buf[o + 2]]);
+          }
+        }
+      },
+      {
+        init: () => [counts, useSmallestThreeQuat ? 4 : 3],
+        decode: (offset, counts2, buf) => {
+          offset += BlockOffset;
+          let qx, qy, qz, qw;
+          for (let i = 0; i < counts2; i++) {
+            if (!useSmallestThreeQuat) {
+              const o = i * 3;
+              qx = buf[o] / 127.5 - 1;
+              qy = buf[o + 1] / 127.5 - 1;
+              qz = buf[o + 2] / 127.5 - 1;
+              qw = Math.sqrt(Math.max(0, 1 - qx * qx - qy * qy - qz * qz));
+            } else {
+              const o = i * 4;
+              const packed = buf[o] | buf[o + 1] << 8 | buf[o + 2] << 16 | buf[o + 3] << 24;
+              const largest = packed >>> 30;
+              let temp = packed;
+              let sum = 0;
+              for (let j = 3; j >= 0; j--) {
+                if (j === largest) {
+                  continue;
+                }
+                const mag = temp & 511;
+                const sign = temp >>> 9 & 1;
+                temp >>>= 10;
+                const v = Math.SQRT1_2 * (mag / 511) * (sign ? -1 : 1);
+                rotation[j] = v;
+                sum += v * v;
+              }
+              rotation[largest] = Math.sqrt(1 - sum);
+              qx = rotation[0];
+              qy = rotation[1];
+              qz = rotation[2];
+              qw = rotation[3];
+            }
+            setQuat(offset + i, qx, qy, qz, qw);
+          }
+        }
+      },
+      {
+        init: () => [counts, shCounts],
+        decode: (offset, counts2, buf) => {
+          offset += BlockOffset;
+          for (let i = 0; i < counts2; i++) {
+            const o = i * shCounts;
+            for (let j = 0; j < shCounts; j++) {
+              shN[j] = (buf[o + j] - 128) / 128;
+            }
+            setShN(offset + i, shN);
+          }
+        }
+      }
+    ]);
+    const source = stream.pipeThrough(new self.DecompressionStream("gzip")).getReader();
+    while (true) {
+      const { done, value } = await source.read();
+      if (done) {
+        break;
+      }
+      reader.write(value);
+      decoder.flush();
+    }
+    data.finishBlock();
+  }
+  async write(writeStream, data) {
+    const compressStream = new self.CompressionStream("gzip");
+    const pipePromise = compressStream.readable.pipeTo(writeStream);
+    const writer2 = compressStream.writable.getWriter();
+    const version = SPZ_VERSION;
+    const counts = data.counts;
+    const shDegree = data.shDegree;
+    const fractionalBits = 12;
+    const flags = FLAG_ANTIALIASED;
+    const reserved = 0;
+    const fraction = 1 << fractionalBits;
+    const shCounts = SH_MAPS2[shDegree];
+    {
+      const buffer = new Uint8Array(16);
+      const header = new DataView(buffer.buffer);
+      header.setUint32(0, SPZ_MAGIC, true);
+      header.setUint32(4, version, true);
+      header.setUint32(8, counts, true);
+      header.setUint8(12, shDegree);
+      header.setUint8(13, fractionalBits);
+      header.setUint8(14, flags);
+      header.setUint8(15, reserved);
+      writer2.write(buffer);
+    }
+    const single = {
+      x: 0,
+      y: 0,
+      z: 0,
+      sx: 0,
+      sy: 0,
+      sz: 0,
+      qx: 0,
+      qy: 0,
+      qz: 0,
+      qw: 0,
+      r: 0,
+      g: 0,
+      b: 0,
+      a: 0,
+      shN: new Array(shCounts)
+    };
+    {
+      const ItemSize2 = 9;
+      const chunkSize = 4096;
+      const chunkCounts = Math.ceil(data.counts / chunkSize);
+      for (let i = 0; i < chunkCounts; i++) {
+        if (writer2.desiredSize <= 0) {
+          await writer2.ready;
+        }
+        const currentChunkSize = Math.min(chunkSize, data.counts - i * chunkSize);
+        const chunk = new Uint8Array(currentChunkSize * ItemSize2);
+        const offset = i * chunkSize;
+        for (let j = 0; j < currentChunkSize; j++) {
+          data.getCenter(offset + j, single);
+          const o = j * ItemSize2;
+          const ix = clamp2(single.x * fraction, -8388607, 8388607);
+          chunk[o + 0] = ix & 255;
+          chunk[o + 1] = ix >> 8 & 255;
+          chunk[o + 2] = ix >> 16 & 255;
+          const iy = clamp2(single.y * fraction, -8388607, 8388607);
+          chunk[o + 3] = iy & 255;
+          chunk[o + 4] = iy >> 8 & 255;
+          chunk[o + 5] = iy >> 16 & 255;
+          const iz = clamp2(single.z * fraction, -8388607, 8388607);
+          chunk[o + 6] = iz & 255;
+          chunk[o + 7] = iz >> 8 & 255;
+          chunk[o + 8] = iz >> 16 & 255;
+        }
+        writer2.write(chunk);
+        await Promise.resolve();
+      }
+    }
+    {
+      const chunkSize = 65536;
+      const chunkCounts = Math.ceil(data.counts / chunkSize);
+      for (let i = 0; i < chunkCounts; i++) {
+        if (writer2.desiredSize <= 0) {
+          await writer2.ready;
+        }
+        const currentChunkSize = Math.min(chunkSize, data.counts - i * chunkSize);
+        const chunk = new Uint8Array(currentChunkSize);
+        const offset = i * chunkSize;
+        for (let j = 0; j < currentChunkSize; j++) {
+          data.getAlpha(offset + j, single);
+          chunk[j] = clamp2(Math.round(single.a * 255), 0, 255);
+        }
+        writer2.write(chunk);
+        await Promise.resolve();
+      }
+    }
+    {
+      const ItemSize2 = 3;
+      const chunkSize = 16384;
+      const chunkCounts = Math.ceil(data.counts / chunkSize);
+      for (let i = 0; i < chunkCounts; i++) {
+        if (writer2.desiredSize <= 0) {
+          await writer2.ready;
+        }
+        const currentChunkSize = Math.min(chunkSize, data.counts - i * chunkSize);
+        const chunk = new Uint8Array(currentChunkSize * ItemSize2);
+        const offset = i * chunkSize;
+        for (let j = 0; j < currentChunkSize; j++) {
+          data.getColor(offset + j, single);
+          const o = j * ItemSize2;
+          chunk[o + 0] = clamp2(Math.round(((single.r - 0.5) / COLOR_SCALE + 0.5) * 255), 0, 255);
+          chunk[o + 1] = clamp2(Math.round(((single.g - 0.5) / COLOR_SCALE + 0.5) * 255), 0, 255);
+          chunk[o + 2] = clamp2(Math.round(((single.b - 0.5) / COLOR_SCALE + 0.5) * 255), 0, 255);
+        }
+        writer2.write(chunk);
+        await Promise.resolve();
+      }
+    }
+    {
+      const ItemSize2 = 3;
+      const chunkSize = 16384;
+      const chunkCounts = Math.ceil(data.counts / chunkSize);
+      for (let i = 0; i < chunkCounts; i++) {
+        if (writer2.desiredSize <= 0) {
+          await writer2.ready;
+        }
+        const currentChunkSize = Math.min(chunkSize, data.counts - i * chunkSize);
+        const chunk = new Uint8Array(currentChunkSize * ItemSize2);
+        const offset = i * chunkSize;
+        for (let j = 0; j < currentChunkSize; j++) {
+          data.getScale(offset + j, single);
+          const o = j * ItemSize2;
+          chunk[o + 0] = clamp2(Math.round((Math.log(single.sx) + 10) * 16), 0, 255);
+          chunk[o + 1] = clamp2(Math.round((Math.log(single.sy) + 10) * 16), 0, 255);
+          chunk[o + 2] = clamp2(Math.round((Math.log(single.sz) + 10) * 16), 0, 255);
+        }
+        writer2.write(chunk);
+        await Promise.resolve();
+      }
+    }
+    {
+      const ItemSize2 = 4;
+      const chunkSize = 16384;
+      const chunkCounts = Math.ceil(data.counts / chunkSize);
+      for (let i = 0; i < chunkCounts; i++) {
+        if (writer2.desiredSize <= 0) {
+          await writer2.ready;
+        }
+        const currentChunkSize = Math.min(chunkSize, data.counts - i * chunkSize);
+        const chunk = new Uint8Array(currentChunkSize * ItemSize2);
+        const offset = i * chunkSize;
+        for (let j = 0; j < currentChunkSize; j++) {
+          data.getQuat(offset + j, single);
+          const o = j * ItemSize2;
+          rotation[0] = single.qx;
+          rotation[1] = single.qy;
+          rotation[2] = single.qz;
+          rotation[3] = single.qw;
+          let iLargest = 0;
+          for (let i2 = 1; i2 < 4; ++i2) {
+            if (Math.abs(rotation[i2]) > Math.abs(rotation[iLargest])) {
+              iLargest = i2;
+            }
+          }
+          const negate = rotation[iLargest] < 0 ? 1 : 0;
+          let comp = iLargest;
+          for (let i2 = 0; i2 < 4; ++i2) {
+            if (i2 !== iLargest) {
+              const negbit = (rotation[i2] < 0 ? 1 : 0) ^ negate;
+              const mag = Math.floor(((1 << 9) - 1) * (Math.abs(rotation[i2]) / Math.SQRT1_2) + 0.5);
+              comp = comp << 10 | negbit << 9 | mag;
+            }
+          }
+          chunk[o + 0] = comp & 255;
+          chunk[o + 1] = comp >> 8 & 255;
+          chunk[o + 2] = comp >> 16 & 255;
+          chunk[o + 3] = comp >> 24 & 255;
+        }
+        writer2.write(chunk);
+        await Promise.resolve();
+      }
+    }
+    if (shDegree > 0) {
+      const shN = single.shN;
+      const ItemSize2 = shCounts;
+      const chunkSize = 1024;
+      const chunkCounts = Math.ceil(data.counts / chunkSize);
+      for (let i = 0; i < chunkCounts; i++) {
+        if (writer2.desiredSize <= 0) {
+          await writer2.ready;
+        }
+        const currentChunkSize = Math.min(chunkSize, data.counts - i * chunkSize);
+        const chunk = new Uint8Array(currentChunkSize * ItemSize2);
+        const offset = i * chunkSize;
+        for (let j = 0; j < currentChunkSize; j++) {
+          data.getShN(offset + j, shN);
+          const o = j * ItemSize2;
+          for (let k = 0; k < ItemSize2; k++) {
+            if (k < 9) {
+              chunk[o + k] = clamp2(Math.floor((Math.round(shN[k] * 128) + 128 + SH_SCALE1 / 2) / SH_SCALE1) * SH_SCALE1, 0, 255);
+              continue;
+            }
+            chunk[o + k] = clamp2(Math.floor((Math.round(shN[k] * 128) + 128 + SH_SCALE2 / 2) / SH_SCALE2) * SH_SCALE2, 0, 255);
+          }
+        }
+        writer2.write(chunk);
+        await Promise.resolve();
+      }
+    }
+    await writer2.close();
+    await pipePromise;
+  }
+};
+
+// ../../external/egs-core/packages/loaders/splat-loader/file/lcc.ts
+var ZIP_MAGIC2 = 67324752;
+var SQRT_2 = 1.414213562373095;
+var SQRT_2_INV = 0.7071067811865475;
+function decodeRotation(v) {
+  const d0 = (v & 1023) / 1023;
+  const d1 = (v >> 10 & 1023) / 1023;
+  const d2 = (v >> 20 & 1023) / 1023;
+  const d3 = v >> 30 & 3;
+  const qx = d0 * SQRT_2 - SQRT_2_INV;
+  const qy = d1 * SQRT_2 - SQRT_2_INV;
+  const qz = d2 * SQRT_2 - SQRT_2_INV;
+  let sum = qx * qx + qy * qy + qz * qz;
+  sum = Math.min(1, sum);
+  const qw = Math.sqrt(1 - sum);
+  if (d3 === 0) {
+    return [qw, qx, qy, qz];
+  } else if (d3 === 1) {
+    return [qx, qw, qy, qz];
+  } else if (d3 === 2) {
+    return [qx, qy, qw, qz];
+  }
+  return [qx, qy, qz, qw];
+}
+function DecodePacked_11_10_11(enc) {
+  return [
+    (enc & 2047) / 2047,
+    (enc >> 11 & 1023) / 1023,
+    (enc >> 21 & 2047) / 2047
+  ];
+}
+function mix(min, max2, s) {
+  return (1 - s) * min + s * max2;
+}
+var LccFile = class {
+  constructor() {
+    this.counts = 0;
+    this.shDegree = 0;
+    this.refs = {};
+  }
+  load(buffer) {
+    const view = new DataView(buffer.buffer);
+    if (view.getUint32(0, true) !== ZIP_MAGIC2) {
+      throw new Error("LCC file is not a valid zip archive.");
+    }
+    this.refs = extractFromRootDir(unzipSync(buffer));
+    if (!["meta.lcc", "index.bin", "data.bin"].every((name) => !!this.refs[name])) {
+      throw new Error("LCC file is missing required files.");
+    }
+    this.meta = JSON.parse(new TextDecoder().decode(this.refs["meta.lcc"]));
+    this.counts = this.meta.splats[0];
+    this.shDegree = !!this.refs["shcoef.bin"] ? 3 : 0;
+  }
+  async read(stream, contentLength, data) {
+    let BlockOffset = 0;
+    {
+      const buffer = new Uint8Array(contentLength);
+      const reader = stream.getReader();
+      let offset = 0;
+      while (true) {
+        const { done, value } = await reader.read();
+        if (done) {
+          break;
+        }
+        buffer.set(value, offset);
+        offset += value.length;
+      }
+      this.load(buffer);
+      BlockOffset = await data.initBlock(this.counts, this.shDegree);
+    }
+    const setFn = data.set.bind(data);
+    const setShFn = data.setShN.bind(data);
+    const { meta, refs } = this;
+    const infos = [];
+    {
+      const index2 = new DataView(refs["index.bin"].buffer);
+      const infoCounts = Math.floor(index2.byteLength / (4 + 16 * meta.totalLevel));
+      let offset = 0;
+      for (let i = 0; i < infoCounts; i++) {
+        const x = index2.getInt16(offset, true);
+        offset += 2;
+        const y = index2.getInt16(offset, true);
+        offset += 2;
+        const lods = [];
+        for (let j = 0; j < meta.totalLevel; j++) {
+          const points = index2.getInt32(offset, true);
+          offset += 4;
+          const ldOffset = Number(index2.getBigInt64(offset, true));
+          offset += 8;
+          const size = index2.getInt32(offset, true);
+          offset += 4;
+          lods.push({ points, offset: ldOffset, size });
+        }
+        infos.push({ x, y, lods });
+      }
+    }
+    const attributes = meta.attributes.reduce((p, c) => {
+      p[c.name] = c;
+      return p;
+    }, {});
+    const { scale: { min: scaleMin, max: scaleMax }, shcoef: { min: shMin, max: shMax } } = attributes;
+    const single = {
+      x: 0,
+      y: 0,
+      z: 0,
+      sx: 0,
+      sy: 0,
+      sz: 0,
+      qx: 0,
+      qy: 0,
+      qz: 0,
+      qw: 0,
+      r: 0,
+      g: 0,
+      b: 0,
+      a: 0,
+      shN: []
+    };
+    const shData = new Array(45);
+    let index = BlockOffset;
+    for (let i = 0; i < infos.length; i++) {
+      const info = infos[i];
+      const { points, offset, size } = info.lods[0];
+      const dataview = new DataView(refs["data.bin"].buffer, offset, size);
+      const shN = refs["shcoef.bin"] ? new DataView(refs["shcoef.bin"].buffer, offset * 2, size * 2) : void 0;
+      for (let j = 0; j < points; j++) {
+        const off = j * 32;
+        single.x = dataview.getFloat32(off + 0, true);
+        single.y = dataview.getFloat32(off + 4, true);
+        single.z = dataview.getFloat32(off + 8, true);
+        single.r = dataview.getUint8(off + 12) / 255;
+        single.g = dataview.getUint8(off + 13) / 255;
+        single.b = dataview.getUint8(off + 14) / 255;
+        single.a = dataview.getUint8(off + 15) / 255;
+        single.sx = mix(scaleMin[0], scaleMax[0], dataview.getUint16(off + 16, true) / 65535);
+        single.sy = mix(scaleMin[1], scaleMax[1], dataview.getUint16(off + 18, true) / 65535);
+        single.sz = mix(scaleMin[2], scaleMax[2], dataview.getUint16(off + 20, true) / 65535);
+        const quat = decodeRotation(dataview.getUint32(off + 22, true));
+        single.qx = quat[0];
+        single.qy = quat[1];
+        single.qz = quat[2];
+        single.qw = quat[3];
+        setFn(index, single);
+        if (shN) {
+          const shOff = off * 2;
+          for (let k = 0; k < 15; k++) {
+            const v = DecodePacked_11_10_11(shN.getUint32(shOff + k * 4, true));
+            shData[k * 3] = mix(shMin[0], shMax[0], v[0]);
+            shData[k * 3 + 1] = mix(shMin[1], shMax[1], v[1]);
+            shData[k * 3 + 2] = mix(shMin[2], shMax[2], v[2]);
+          }
+          setShFn(index, shData);
+        }
+        index++;
+      }
+    }
+    data.finishBlock();
+  }
+  async write(_stream, _data) {
+    throw new Error("Method not implemented.");
+  }
+};
+
+// ../../external/egs-core/packages/loaders/splat-loader/worker.ts
+var writer;
+self.onmessage = async (event) => {
+  try {
+    const message = event.data;
+    switch (message.taskType) {
+      case "ParseSplat" /* ParseSplat */: {
+        const { type, packType, stream, contentLength, extras: { maxShDegree, maxTextureSize } } = event.data.payload;
+        let splatData;
+        switch (packType) {
+          case 0 /* Raw */: {
+            splatData = new RawSplatData(maxShDegree, maxTextureSize);
+            break;
+          }
+          case 1 /* Compressed */: {
+            splatData = new CompressedSplatData(maxShDegree, maxTextureSize);
+            break;
+          }
+          case 2 /* SuperCompressed */: {
+            splatData = new SuperCompressedSplatData(maxShDegree, maxTextureSize);
+            break;
+          }
+          case 3 /* Sog */: {
+            splatData = new SogSplatData(maxShDegree, maxTextureSize);
+          }
+        }
+        let file;
+        switch (type) {
+          case 0 /* PLY */: {
+            file = new PlyFile();
+            break;
+          }
+          case 1 /* SPZ */: {
+            file = new SpzFile();
+            break;
+          }
+          case 3 /* KSPLAT */: {
+            file = new KsplatFile();
+            break;
+          }
+          case 2 /* SPLAT */: {
+            file = new SplatFile();
+            break;
+          }
+          case 4 /* SOG */: {
+            file = new SogFile();
+            break;
+          }
+          case 5 /* LCC */: {
+            file = new LccFile();
+            break;
+          }
+        }
+        let reader = stream;
+        if (!reader) {
+          const stream2 = new TransformStream();
+          writer = stream2.writable.getWriter();
+          reader = stream2.readable;
+        }
+        if (packType === 3 /* Sog */) {
+          await file.load(reader, contentLength);
+          const { meta, refs } = file;
+          let splatMeta;
+          if (meta.version === void 0) {
+            const m = meta;
+            splatMeta = {
+              version: 1,
+              counts: m.means.shape[0],
+              shDegree: NUM_F_REST_TO_SH_DEGREE[m.shN?.shape?.[1] ?? 0],
+              means: {
+                mins: [m.means.mins[0], m.means.mins[1], m.means.mins[2]],
+                maxs: [m.means.maxs[0], m.means.maxs[1], m.means.maxs[2]]
+              },
+              scales: {
+                mins: [m.scales.mins[0], m.scales.mins[1], m.scales.mins[2]],
+                maxs: [m.scales.maxs[0], m.scales.maxs[1], m.scales.maxs[2]]
+              },
+              sh0: {
+                mins: [m.sh0.mins[0], m.sh0.mins[1], m.sh0.mins[2], m.sh0.mins[3]],
+                maxs: [m.sh0.maxs[0], m.sh0.maxs[1], m.sh0.maxs[2], m.sh0.maxs[3]]
+              },
+              shN: m.shN ? {
+                mins: m.shN.mins,
+                maxs: m.shN.maxs
+              } : void 0
+            };
+          } else {
+            const m = meta;
+            splatMeta = {
+              version: 2,
+              counts: m.count,
+              shDegree: m.shN?.bands ?? 0,
+              means: {
+                mins: [m.means.mins[0], m.means.mins[1], m.means.mins[2]],
+                maxs: [m.means.maxs[0], m.means.maxs[1], m.means.maxs[2]]
+              },
+              scales: {
+                codebook: m.scales.codebook
+              },
+              sh0: {
+                codebook: m.sh0.codebook
+              },
+              shN: m.shN ? {
+                codebook: m.shN.codebook
+              } : void 0
+            };
+          }
+          splatData.load(
+            splatMeta,
+            refs[meta.means.files[0]],
+            refs[meta.means.files[1]],
+            refs[meta.scales.files[0]],
+            refs[meta.quats.files[0]],
+            refs[meta.sh0.files[0]],
+            ...meta.shN ? [
+              refs[meta.shN.files[0]],
+              refs[meta.shN.files[1]]
+            ] : []
+          );
+        } else {
+          await file.read(reader, contentLength, splatData);
+        }
+        writer = void 0;
+        const splats = splatData.serialize();
+        const payload = { status: 0 /* Success */, payload: splats };
+        postMessage(
+          payload,
+          splats.samplers.map((v) => v.source.buffer)
+        );
+        return;
+      }
+      case "PostStreamChunk" /* PostStreamChunk */: {
+        const { chunk } = event.data.payload;
+        if (!writer) {
+          return;
+        }
+        if (chunk) {
+          writer.write(chunk);
+        } else {
+          writer.close();
+        }
+        return;
+      }
+      case "SortSplats" /* SortSplats */: {
+        const { splatCounts, sorting, ordering } = event.data.payload;
+        const activeSplats = sortSplats(splatCounts, sorting, ordering);
+        const payload = { status: 0 /* Success */, payload: { activeSplats, sorting, ordering } };
+        postMessage(payload, [sorting.buffer, ordering.buffer]);
+        return;
+      }
+      default: {
+        const check = message.taskType;
+        throw new Error(`Unsupported task type: ${check}.`);
+      }
+    }
+  } catch (e) {
+    console.error(e);
+    postMessage({ status: 1 /* Fail */, payload: e.toString() });
+  }
+};
+//# sourceMappingURL=splat-worker.js.map