@speridlabs/visus 2.3.0 → 2.4.0

package/dist/react.es.js

@@ -1,9 +1,9 @@
-var be = Object.defineProperty;
-var Se = (x, e, o) => e in x ? be(x, e, { enumerable: !0, configurable: !0, writable: !0, value: o }) : x[e] = o;
-var f = (x, e, o) => Se(x, typeof e != "symbol" ? e + "" : e, o);
-import Me, { useState as Ce, useRef as Ae, useEffect as Te } from "react";
-import * as l from "three";
-var ce = { exports: {} }, ae = {};
+var Ye = Object.defineProperty;
+var $e = (n, e, t) => e in n ? Ye(n, e, { enumerable: !0, configurable: !0, writable: !0, value: t }) : n[e] = t;
+var M = (n, e, t) => $e(n, typeof e != "symbol" ? e + "" : e, t);
+import He, { useState as Xe, useRef as Ze, useEffect as Je } from "react";
+import * as h from "three";
+var we = { exports: {} }, pe = {};
 /**
  * @license React
  * react-jsx-runtime.production.js
@@ -13,29 +13,29 @@ var ce = { exports: {} }, ae = {};
  * This source code is licensed under the MIT license found in the
  * LICENSE file in the root directory of this source tree.
  */
-var me;
-function _e() {
-  if (me) return ae;
-  me = 1;
-  var x = Symbol.for("react.transitional.element"), e = Symbol.for("react.fragment");
-  function o(t, r, n) {
-    var a = null;
-    if (n !== void 0 && (a = "" + n), r.key !== void 0 && (a = "" + r.key), "key" in r) {
-      n = {};
-      for (var i in r)
-        i !== "key" && (n[i] = r[i]);
-    } else n = r;
-    return r = n.ref, {
-      $$typeof: x,
-      type: t,
-      key: a,
-      ref: r !== void 0 ? r : null,
-      props: n
+var Pe;
+function Qe() {
+  if (Pe) return pe;
+  Pe = 1;
+  var n = Symbol.for("react.transitional.element"), e = Symbol.for("react.fragment");
+  function t(r, s, a) {
+    var o = null;
+    if (a !== void 0 && (o = "" + a), s.key !== void 0 && (o = "" + s.key), "key" in s) {
+      a = {};
+      for (var i in s)
+        i !== "key" && (a[i] = s[i]);
+    } else a = s;
+    return s = a.ref, {
+      $$typeof: n,
+      type: r,
+      key: o,
+      ref: s !== void 0 ? s : null,
+      props: a
     };
   }
-  return ae.Fragment = e, ae.jsx = o, ae.jsxs = o, ae;
+  return pe.Fragment = e, pe.jsx = t, pe.jsxs = t, pe;
 }
-var ie = {};
+var xe = {};
 /**
  * @license React
  * react-jsx-runtime.development.js
@@ -45,251 +45,251 @@ var ie = {};
  * This source code is licensed under the MIT license found in the
  * LICENSE file in the root directory of this source tree.
  */
-var xe;
-function ke() {
-  return xe || (xe = 1, process.env.NODE_ENV !== "production" && function() {
-    function x(s) {
-      if (s == null) return null;
-      if (typeof s == "function")
-        return s.$$typeof === v ? null : s.displayName || s.name || null;
-      if (typeof s == "string") return s;
-      switch (s) {
-        case I:
+var Be;
+function Ke() {
+  return Be || (Be = 1, process.env.NODE_ENV !== "production" && function() {
+    function n(c) {
+      if (c == null) return null;
+      if (typeof c == "function")
+        return c.$$typeof === p ? null : c.displayName || c.name || null;
+      if (typeof c == "string") return c;
+      switch (c) {
+        case v:
           return "Fragment";
-        case j:
+        case E:
           return "Profiler";
-        case P:
+        case b:
           return "StrictMode";
         case L:
           return "Suspense";
         case A:
           return "SuspenseList";
-        case T:
+        case w:
           return "Activity";
       }
-      if (typeof s == "object")
-        switch (typeof s.tag == "number" && console.error(
+      if (typeof c == "object")
+        switch (typeof c.tag == "number" && console.error(
           "Received an unexpected object in getComponentNameFromType(). This is likely a bug in React. Please file an issue."
-        ), s.$$typeof) {
-          case S:
+        ), c.$$typeof) {
+          case g:
             return "Portal";
-          case W:
-            return (s.displayName || "Context") + ".Provider";
+          case P:
+            return (c.displayName || "Context") + ".Provider";
+          case T:
+            return (c._context.displayName || "Context") + ".Consumer";
           case H:
-            return (s._context.displayName || "Context") + ".Consumer";
-          case oe:
-            var p = s.render;
-            return s = s.displayName, s || (s = p.displayName || p.name || "", s = s !== "" ? "ForwardRef(" + s + ")" : "ForwardRef"), s;
-          case g:
-            return p = s.displayName || null, p !== null ? p : x(s.type) || "Memo";
-          case D:
-            p = s._payload, s = s._init;
+            var k = c.render;
+            return c = c.displayName, c || (c = k.displayName || k.name || "", c = c !== "" ? "ForwardRef(" + c + ")" : "ForwardRef"), c;
+          case C:
+            return k = c.displayName || null, k !== null ? k : n(c.type) || "Memo";
+          case _:
+            k = c._payload, c = c._init;
             try {
-              return x(s(p));
+              return n(c(k));
             } catch {
             }
         }
       return null;
     }
-    function e(s) {
-      return "" + s;
+    function e(c) {
+      return "" + c;
     }
-    function o(s) {
+    function t(c) {
       try {
-        e(s);
-        var p = !1;
+        e(c);
+        var k = !1;
       } catch {
-        p = !0;
+        k = !0;
       }
-      if (p) {
-        p = console;
-        var M = p.error, E = typeof Symbol == "function" && Symbol.toStringTag && s[Symbol.toStringTag] || s.constructor.name || "Object";
-        return M.call(
-          p,
+      if (k) {
+        k = console;
+        var B = k.error, F = typeof Symbol == "function" && Symbol.toStringTag && c[Symbol.toStringTag] || c.constructor.name || "Object";
+        return B.call(
+          k,
           "The provided key is an unsupported type %s. This value must be coerced to a string before using it here.",
-          E
-        ), e(s);
+          F
+        ), e(c);
       }
     }
-    function t(s) {
-      if (s === I) return "<>";
-      if (typeof s == "object" && s !== null && s.$$typeof === D)
+    function r(c) {
+      if (c === v) return "<>";
+      if (typeof c == "object" && c !== null && c.$$typeof === _)
         return "<...>";
       try {
-        var p = x(s);
-        return p ? "<" + p + ">" : "<...>";
+        var k = n(c);
+        return k ? "<" + k + ">" : "<...>";
       } catch {
         return "<...>";
       }
     }
-    function r() {
-      var s = R.A;
-      return s === null ? null : s.getOwner();
+    function s() {
+      var c = R.A;
+      return c === null ? null : c.getOwner();
     }
-    function n() {
+    function a() {
       return Error("react-stack-top-frame");
     }
-    function a(s) {
-      if (B.call(s, "key")) {
-        var p = Object.getOwnPropertyDescriptor(s, "key").get;
-        if (p && p.isReactWarning) return !1;
+    function o(c) {
+      if (q.call(c, "key")) {
+        var k = Object.getOwnPropertyDescriptor(c, "key").get;
+        if (k && k.isReactWarning) return !1;
       }
-      return s.key !== void 0;
+      return c.key !== void 0;
     }
-    function i(s, p) {
-      function M() {
-        Z || (Z = !0, console.error(
+    function i(c, k) {
+      function B() {
+        V || (V = !0, console.error(
           "%s: `key` is not a prop. Trying to access it will result in `undefined` being returned. If you need to access the same value within the child component, you should pass it as a different prop. (https://react.dev/link/special-props)",
-          p
+          k
         ));
       }
-      M.isReactWarning = !0, Object.defineProperty(s, "key", {
-        get: M,
+      B.isReactWarning = !0, Object.defineProperty(c, "key", {
+        get: B,
         configurable: !0
       });
     }
-    function u() {
-      var s = x(this.type);
-      return U[s] || (U[s] = !0, console.error(
+    function m() {
+      var c = n(this.type);
+      return D[c] || (D[c] = !0, console.error(
         "Accessing element.ref was removed in React 19. ref is now a regular prop. It will be removed from the JSX Element type in a future release."
-      )), s = this.props.ref, s !== void 0 ? s : null;
+      )), c = this.props.ref, c !== void 0 ? c : null;
     }
-    function w(s, p, M, E, m, c, y, z) {
-      return M = c.ref, s = {
-        $$typeof: b,
-        type: s,
-        key: p,
-        props: c,
-        _owner: m
-      }, (M !== void 0 ? M : null) !== null ? Object.defineProperty(s, "ref", {
+    function f(c, k, B, F, I, d, z, W) {
+      return B = d.ref, c = {
+        $$typeof: x,
+        type: c,
+        key: k,
+        props: d,
+        _owner: I
+      }, (B !== void 0 ? B : null) !== null ? Object.defineProperty(c, "ref", {
         enumerable: !1,
-        get: u
-      }) : Object.defineProperty(s, "ref", { enumerable: !1, value: null }), s._store = {}, Object.defineProperty(s._store, "validated", {
+        get: m
+      }) : Object.defineProperty(c, "ref", { enumerable: !1, value: null }), c._store = {}, Object.defineProperty(c._store, "validated", {
         configurable: !1,
         enumerable: !1,
         writable: !0,
         value: 0
-      }), Object.defineProperty(s, "_debugInfo", {
+      }), Object.defineProperty(c, "_debugInfo", {
         configurable: !1,
         enumerable: !1,
         writable: !0,
         value: null
-      }), Object.defineProperty(s, "_debugStack", {
+      }), Object.defineProperty(c, "_debugStack", {
         configurable: !1,
         enumerable: !1,
         writable: !0,
-        value: y
-      }), Object.defineProperty(s, "_debugTask", {
+        value: z
+      }), Object.defineProperty(c, "_debugTask", {
         configurable: !1,
         enumerable: !1,
         writable: !0,
-        value: z
-      }), Object.freeze && (Object.freeze(s.props), Object.freeze(s)), s;
+        value: W
+      }), Object.freeze && (Object.freeze(c.props), Object.freeze(c)), c;
     }
-    function C(s, p, M, E, m, c, y, z) {
-      var d = p.children;
-      if (d !== void 0)
-        if (E)
-          if ($(d)) {
-            for (E = 0; E < d.length; E++)
-              _(d[E]);
-            Object.freeze && Object.freeze(d);
+    function y(c, k, B, F, I, d, z, W) {
+      var S = k.children;
+      if (S !== void 0)
+        if (F)
+          if (j(S)) {
+            for (F = 0; F < S.length; F++)
+              l(S[F]);
+            Object.freeze && Object.freeze(S);
           } else
             console.error(
               "React.jsx: Static children should always be an array. You are likely explicitly calling React.jsxs or React.jsxDEV. Use the Babel transform instead."
             );
-        else _(d);
-      if (B.call(p, "key")) {
-        d = x(s);
-        var k = Object.keys(p).filter(function(q) {
-          return q !== "key";
+        else l(S);
+      if (q.call(k, "key")) {
+        S = n(c);
+        var U = Object.keys(k).filter(function(X) {
+          return X !== "key";
         });
-        E = 0 < k.length ? "{key: someKey, " + k.join(": ..., ") + ": ...}" : "{key: someKey}", te[d + E] || (k = 0 < k.length ? "{" + k.join(": ..., ") + ": ...}" : "{}", console.error(
+        F = 0 < U.length ? "{key: someKey, " + U.join(": ..., ") + ": ...}" : "{key: someKey}", N[S + F] || (U = 0 < U.length ? "{" + U.join(": ..., ") + ": ...}" : "{}", console.error(
           `A props object containing a "key" prop is being spread into JSX:
   let props = %s;
   <%s {...props} />
 React keys must be passed directly to JSX without using spread:
   let props = %s;
   <%s key={someKey} {...props} />`,
-          E,
-          d,
-          k,
-          d
-        ), te[d + E] = !0);
+          F,
+          S,
+          U,
+          S
+        ), N[S + F] = !0);
       }
-      if (d = null, M !== void 0 && (o(M), d = "" + M), a(p) && (o(p.key), d = "" + p.key), "key" in p) {
-        M = {};
-        for (var O in p)
-          O !== "key" && (M[O] = p[O]);
-      } else M = p;
-      return d && i(
-        M,
-        typeof s == "function" ? s.displayName || s.name || "Unknown" : s
-      ), w(
-        s,
-        d,
+      if (S = null, B !== void 0 && (t(B), S = "" + B), o(k) && (t(k.key), S = "" + k.key), "key" in k) {
+        B = {};
+        for (var $ in k)
+          $ !== "key" && (B[$] = k[$]);
+      } else B = k;
+      return S && i(
+        B,
+        typeof c == "function" ? c.displayName || c.name || "Unknown" : c
+      ), f(
         c,
-        m,
-        r(),
-        M,
-        y,
-        z
+        S,
+        d,
+        I,
+        s(),
+        B,
+        z,
+        W
       );
     }
-    function _(s) {
-      typeof s == "object" && s !== null && s.$$typeof === b && s._store && (s._store.validated = 1);
+    function l(c) {
+      typeof c == "object" && c !== null && c.$$typeof === x && c._store && (c._store.validated = 1);
     }
-    var h = Me, b = Symbol.for("react.transitional.element"), S = Symbol.for("react.portal"), I = Symbol.for("react.fragment"), P = Symbol.for("react.strict_mode"), j = Symbol.for("react.profiler"), H = Symbol.for("react.consumer"), W = Symbol.for("react.context"), oe = Symbol.for("react.forward_ref"), L = Symbol.for("react.suspense"), A = Symbol.for("react.suspense_list"), g = Symbol.for("react.memo"), D = Symbol.for("react.lazy"), T = Symbol.for("react.activity"), v = Symbol.for("react.client.reference"), R = h.__CLIENT_INTERNALS_DO_NOT_USE_OR_WARN_USERS_THEY_CANNOT_UPGRADE, B = Object.prototype.hasOwnProperty, $ = Array.isArray, X = console.createTask ? console.createTask : function() {
+    var u = He, x = Symbol.for("react.transitional.element"), g = Symbol.for("react.portal"), v = Symbol.for("react.fragment"), b = Symbol.for("react.strict_mode"), E = Symbol.for("react.profiler"), T = Symbol.for("react.consumer"), P = Symbol.for("react.context"), H = Symbol.for("react.forward_ref"), L = Symbol.for("react.suspense"), A = Symbol.for("react.suspense_list"), C = Symbol.for("react.memo"), _ = Symbol.for("react.lazy"), w = Symbol.for("react.activity"), p = Symbol.for("react.client.reference"), R = u.__CLIENT_INTERNALS_DO_NOT_USE_OR_WARN_USERS_THEY_CANNOT_UPGRADE, q = Object.prototype.hasOwnProperty, j = Array.isArray, Y = console.createTask ? console.createTask : function() {
       return null;
     };
-    h = {
-      "react-stack-bottom-frame": function(s) {
-        return s();
+    u = {
+      "react-stack-bottom-frame": function(c) {
+        return c();
       }
     };
-    var Z, U = {}, F = h["react-stack-bottom-frame"].bind(
-      h,
-      n
-    )(), N = X(t(n)), te = {};
-    ie.Fragment = I, ie.jsx = function(s, p, M, E, m) {
-      var c = 1e4 > R.recentlyCreatedOwnerStacks++;
-      return C(
-        s,
-        p,
-        M,
+    var V, D = {}, O = u["react-stack-bottom-frame"].bind(
+      u,
+      a
+    )(), J = Y(r(a)), N = {};
+    xe.Fragment = v, xe.jsx = function(c, k, B, F, I) {
+      var d = 1e4 > R.recentlyCreatedOwnerStacks++;
+      return y(
+        c,
+        k,
+        B,
         !1,
-        E,
-        m,
-        c ? Error("react-stack-top-frame") : F,
-        c ? X(t(s)) : N
+        F,
+        I,
+        d ? Error("react-stack-top-frame") : O,
+        d ? Y(r(c)) : J
       );
-    }, ie.jsxs = function(s, p, M, E, m) {
-      var c = 1e4 > R.recentlyCreatedOwnerStacks++;
-      return C(
-        s,
-        p,
-        M,
+    }, xe.jsxs = function(c, k, B, F, I) {
+      var d = 1e4 > R.recentlyCreatedOwnerStacks++;
+      return y(
+        c,
+        k,
+        B,
         !0,
-        E,
-        m,
-        c ? Error("react-stack-top-frame") : F,
-        c ? X(t(s)) : N
+        F,
+        I,
+        d ? Error("react-stack-top-frame") : O,
+        d ? Y(r(c)) : J
       );
     };
-  }()), ie;
+  }()), xe;
 }
-var ge;
-function Ee() {
-  return ge || (ge = 1, process.env.NODE_ENV === "production" ? ce.exports = _e() : ce.exports = ke()), ce.exports;
+var De;
+function et() {
+  return De || (De = 1, process.env.NODE_ENV === "production" ? we.exports = Qe() : we.exports = Ke()), we.exports;
 }
-var Ie = Ee();
-class fe {
+var tt = et();
+class be {
   constructor() {
-    f(this, "min", new l.Vector3(1 / 0, 1 / 0, 1 / 0));
-    f(this, "max", new l.Vector3(-1 / 0, -1 / 0, -1 / 0));
-    f(this, "center", new l.Vector3());
+    M(this, "min", new h.Vector3(1 / 0, 1 / 0, 1 / 0));
+    M(this, "max", new h.Vector3(-1 / 0, -1 / 0, -1 / 0));
+    M(this, "center", new h.Vector3());
     /** Half extents (size/2) */
-    f(this, "halfExtents", new l.Vector3());
+    M(this, "halfExtents", new h.Vector3());
   }
   /**
    * Reset the bounding box to its initial state
@@ -330,27 +330,26 @@ class fe {
    * @returns THREE.Box3 representation
    */
   toBox3() {
-    return new l.Box3().set(this.min, this.max);
+    return new h.Box3().set(this.min, this.max);
   }
   /**
    * Create a clone of this bounding box
    * @returns New bounding box with the same values
    */
   clone() {
-    const e = new fe();
+    const e = new be();
     return e.min.copy(this.min), e.max.copy(this.max), e.center.copy(this.center), e.halfExtents.copy(this.halfExtents), e;
   }
 }
-class Re {
-  // TODO: there is no sh spherical harmonics
+class rt {
   constructor(e = 0) {
-    f(this, "numSplats", 0);
-    f(this, "positions");
-    f(this, "rotations");
-    f(this, "scales");
-    f(this, "colors");
-    f(this, "opacities");
-    f(this, "boundingBox", new fe());
+    M(this, "numSplats", 0);
+    M(this, "positions");
+    M(this, "rotations");
+    M(this, "scales");
+    M(this, "colors");
+    M(this, "opacities");
+    M(this, "boundingBox", new be());
     this.numSplats = e, this.allocateBuffers(e);
   }
   allocateBuffers(e) {
@@ -365,13 +364,13 @@ class Re {
    * @param color Color
    * @param opacity Opacity value
    */
-  setSplat(e, o, t, r, n, a) {
+  setSplat(e, t, r, s, a, o) {
     if (e >= this.numSplats)
       throw new Error(
         `Splat index out of bounds: ${e} >= ${this.numSplats}`
       );
-    const i = e * 3, u = e * 4, w = e * 3, C = e * 3;
-    this.positions[i] = o.x, this.positions[i + 1] = o.y, this.positions[i + 2] = o.z, this.rotations[u] = t.x, this.rotations[u + 1] = t.y, this.rotations[u + 2] = t.z, this.rotations[u + 3] = t.w, this.scales[w] = r.x, this.scales[w + 1] = r.y, this.scales[w + 2] = r.z, this.colors[C] = n.r, this.colors[C + 1] = n.g, this.colors[C + 2] = n.b, this.opacities[e] = a;
+    const i = e * 3, m = e * 4, f = e * 3, y = e * 3;
+    this.positions[i] = t.x, this.positions[i + 1] = t.y, this.positions[i + 2] = t.z, this.rotations[m] = r.x, this.rotations[m + 1] = r.y, this.rotations[m + 2] = r.z, this.rotations[m + 3] = r.w, this.scales[f] = s.x, this.scales[f + 1] = s.y, this.scales[f + 2] = s.z, this.colors[y] = a.r, this.colors[y + 1] = a.g, this.colors[y + 2] = a.b, this.opacities[e] = o;
   }
   /**
    * Get a splat's data
@@ -383,29 +382,29 @@ class Re {
       throw new Error(
         `Splat index out of bounds: ${e} >= ${this.numSplats}`
       );
-    const o = e * 3, t = e * 4, r = e * 3, n = e * 3;
+    const t = e * 3, r = e * 4, s = e * 3, a = e * 3;
     return {
-      position: new l.Vector3(
-        this.positions[o],
-        this.positions[o + 1],
-        this.positions[o + 2]
+      position: new h.Vector3(
+        this.positions[t],
+        this.positions[t + 1],
+        this.positions[t + 2]
       ),
-      rotation: new l.Quaternion(
-        this.rotations[t],
-        this.rotations[t + 1],
-        this.rotations[t + 2],
-        this.rotations[t + 3]
+      rotation: new h.Quaternion(
+        this.rotations[r],
+        this.rotations[r + 1],
+        this.rotations[r + 2],
+        this.rotations[r + 3]
       ),
       // Convert log scale back to linear scale for external use
-      scale: new l.Vector3(
-        Math.exp(this.scales[r]),
-        Math.exp(this.scales[r + 1]),
-        Math.exp(this.scales[r + 2])
+      scale: new h.Vector3(
+        Math.exp(this.scales[s]),
+        Math.exp(this.scales[s + 1]),
+        Math.exp(this.scales[s + 2])
       ),
-      color: new l.Color(
-        this.colors[n],
-        this.colors[n + 1],
-        this.colors[n + 2]
+      color: new h.Color(
+        this.colors[a],
+        this.colors[a + 1],
+        this.colors[a + 2]
       ),
       opacity: this.opacities[e]
     };
@@ -416,13 +415,13 @@ class Re {
    */
   calculateBoundingBox() {
     this.boundingBox.reset();
-    const e = new l.Vector3();
-    for (let o = 0; o < this.numSplats; o++) {
-      const t = o * 3;
+    const e = new h.Vector3();
+    for (let t = 0; t < this.numSplats; t++) {
+      const r = t * 3;
       e.set(
-        this.positions[t],
-        this.positions[t + 1],
-        this.positions[t + 2]
+        this.positions[r],
+        this.positions[r + 1],
+        this.positions[r + 2]
       ), this.boundingBox.expandByPoint(e);
     }
     return this.boundingBox;
@@ -432,68 +431,265 @@ class Re {
    * This is for visualization/debugging purposes only, not for rendering
    */
   createDebugGeometry() {
-    const e = new l.BufferGeometry();
+    const e = new h.BufferGeometry();
     e.setAttribute(
       "position",
-      new l.BufferAttribute(this.positions, 3)
+      new h.BufferAttribute(this.positions, 3)
     );
-    const o = new Float32Array(this.numSplats * 3), t = new l.Quaternion(), r = new l.Euler();
-    for (let n = 0; n < this.numSplats; n++) {
-      const a = n * 4, i = n * 3;
-      t.set(
-        this.rotations[a],
-        this.rotations[a + 1],
-        this.rotations[a + 2],
-        this.rotations[a + 3]
-      ), r.setFromQuaternion(t), o[i] = r.x, o[i + 1] = r.y, o[i + 2] = r.z;
+    const t = new Float32Array(this.numSplats * 3), r = new h.Quaternion(), s = new h.Euler();
+    for (let a = 0; a < this.numSplats; a++) {
+      const o = a * 4, i = a * 3;
+      r.set(
+        this.rotations[o],
+        this.rotations[o + 1],
+        this.rotations[o + 2],
+        this.rotations[o + 3]
+      ), s.setFromQuaternion(r), t[i] = s.x, t[i + 1] = s.y, t[i + 2] = s.z;
     }
     return e.setAttribute(
       "rotation",
-      new l.BufferAttribute(o, 3)
+      new h.BufferAttribute(t, 3)
     ), e.setAttribute(
       "scale",
-      new l.BufferAttribute(this.scales, 3)
+      new h.BufferAttribute(this.scales, 3)
     ), e.setAttribute(
       "color",
-      new l.BufferAttribute(this.colors, 3)
+      new h.BufferAttribute(this.colors, 3)
     ), e.setAttribute(
       "opacity",
-      new l.BufferAttribute(this.opacities, 1)
+      new h.BufferAttribute(this.opacities, 1)
     ), e;
   }
+  dispose() {
+    this.numSplats = 0, this.scales = new Float32Array(0), this.colors = new Float32Array(0), this.positions = new Float32Array(0), this.rotations = new Float32Array(0), this.opacities = new Float32Array(0);
+  }
+}
+class Fe {
+  // Upper 8 bits of 16-bit means
+  constructor(e, t, r) {
+    M(this, "ranges");
+    M(this, "numSplats", 0);
+    M(this, "boundingBox", new be());
+    // Original SOGS textures
+    M(this, "sh0");
+    // SH DC coefficients + alpha
+    M(this, "quats");
+    // Quaternion components + mode
+    M(this, "scales");
+    // Scale values (8-bit)
+    M(this, "means_l");
+    // Lower 8 bits of 16-bit means
+    M(this, "means_u");
+    this.ranges = t, this.numSplats = e, this.sh0 = r.sh0, this.quats = r.quats, this.scales = r.scales, this.means_l = r.means_l, this.means_u = r.means_u, this.boundingBox = this.calculateBoundingBox();
+  }
+  calculateBoundingBox() {
+    this.boundingBox.reset();
+    const { mins: e, maxs: t } = this.ranges.means, r = (s) => Math.sign(s) * (Math.exp(Math.abs(s)) - 1);
+    return this.boundingBox.center.set(
+      (r(e[0]) + r(t[0])) * 0.5,
+      (r(e[1]) + r(t[1])) * 0.5,
+      (r(e[2]) + r(t[2])) * 0.5
+    ), this.boundingBox.halfExtents.set(
+      (r(t[0]) - r(e[0])) * 0.5,
+      (r(t[1]) - r(e[1])) * 0.5,
+      (r(t[2]) - r(e[2])) * 0.5
+    ), this.boundingBox;
+  }
+  dispose() {
+    this.sh0.dispose(), this.quats.dispose(), this.scales.dispose(), this.means_l.dispose(), this.means_u.dispose();
+  }
 }
-class ze extends l.Loader {
-  constructor(o) {
-    super(o);
-    f(this, "requestId", 0);
-    f(this, "worker");
-    f(this, "pendingCallbacks", /* @__PURE__ */ new Map());
+class qe {
+  // RGBA32UI - (Position + Rotation + Scale)
+  // RGBA32UI Texture Content:
+  // .r = Means Lower (RGB)
+  // .g = Means Upper (RGB)
+  // .b = Rotation (RGBA)
+  // .a = Scale (RGB)
+  constructor(e, t, r, s, a, o, i, m) {
+    // Info data - cpu
+    M(this, "numSplats");
+    M(this, "textureWidth");
+    M(this, "textureHeight");
+    M(this, "ranges");
+    M(this, "centers");
+    // TODO: see if necesary or can be compressed somehow
+    M(this, "boundingBox");
+    // GPU Textures
+    M(this, "packedColor");
+    // RGBA8 - (Color + Opacity)
+    // RGBA8 Texture Content:
+    // .rgb = Color, .a = Opacity
+    M(this, "packedGeometry");
+    this.numSplats = e, this.textureWidth = t, this.textureHeight = r, this.boundingBox = m, this.ranges = i, this.centers = s, this.packedColor = o, this.packedGeometry = a;
+  }
+  /**
+   * Optional: Reconstruct a full JS object for a specific splat.
+   * Useful for raycasting or debugging.
+   */
+  // public getSplat(index: number) {
+  //     throw new Error('Not implemented yet');
+  // }
+  dispose() {
+    this.centers = new Float32Array(0), this.packedColor = new Uint8Array(0), this.packedGeometry = new Uint32Array(0);
+  }
+  // public abstract deserialize(): ISplat;
+  // public abstract returnPacked(): ISplat;
+}
+const me = 0.28209479177387814;
+class Ce {
+  /**
+   * Packs PLY data (Float32) into the Unified SOGS-like Format.
+   */
+  // prettier-ignore
+  static packPly(e) {
+    const t = e.numSplats, r = Math.ceil(Math.sqrt(t)), s = Math.ceil(t / r), a = r * s, { ranges: o, colorScale: i } = this.calculatePlyRanges(e), m = new Uint32Array(a * 4), f = new Uint8Array(a * 4), y = new h.Quaternion();
+    for (let l = 0; l < t; l++) {
+      const u = l * 4, x = l * 3, g = l * 4, v = e.positions[x + 0], b = e.positions[x + 1], E = e.positions[x + 2], T = this.clamp01(this.norm(v, o.means.min.x, o.means.max.x)), P = this.clamp01(this.norm(b, o.means.min.y, o.means.max.y)), H = this.clamp01(this.norm(E, o.means.min.z, o.means.max.z)), L = T * 65535 | 0, A = P * 65535 | 0, C = H * 65535 | 0;
+      m[u + 0] = this.pack4Bytes(L & 255, A & 255, C & 255, 0), m[u + 1] = this.pack4Bytes(L >> 8, A >> 8, C >> 8, 0), y.set(e.rotations[g], e.rotations[g + 1], e.rotations[g + 2], e.rotations[g + 3]).normalize();
+      let _ = y.w, w = y.x, p = y.y, R = y.z;
+      const q = Math.abs(_), j = Math.abs(w), Y = Math.abs(p), V = Math.abs(R);
+      let D = 0, O = q;
+      j > O && (O = j, D = 1), Y > O && (O = Y, D = 2), V > O && (O = V, D = 3), (D === 0 ? _ : D === 1 ? w : D === 2 ? p : R) < 0 && (_ = -_, w = -w, p = -p, R = -R);
+      let N = 0, c = 0, k = 0;
+      D === 0 && (N = w, c = p, k = R), D === 1 && (N = _, c = p, k = R), D === 2 && (N = _, c = w, k = R), D === 3 && (N = _, c = w, k = p);
+      const B = (se) => Math.min(255, Math.max(0, Math.round((0.5 + se / Math.SQRT2) * 255)));
+      m[u + 2] = this.pack4Bytes(B(N), B(c), B(k), D);
+      const F = this.norm(e.scales[x + 0], o.scales.min.x, o.scales.max.x), I = this.norm(e.scales[x + 1], o.scales.min.y, o.scales.max.y), d = this.norm(e.scales[x + 2], o.scales.min.z, o.scales.max.z);
+      m[u + 3] = this.pack4Bytes(Math.floor(F * 255), Math.floor(I * 255), Math.floor(d * 255), 0);
+      const z = this.clamp01(e.colors[x + 0] * i), W = this.clamp01(e.colors[x + 1] * i), S = this.clamp01(e.colors[x + 2] * i), U = (z - 0.5) / me, $ = (W - 0.5) / me, X = (S - 0.5) / me, Q = this.clamp01(this.norm(U, o.sh0.min.x, o.sh0.max.x)), Z = this.clamp01(this.norm($, o.sh0.min.y, o.sh0.max.y)), K = this.clamp01(this.norm(X, o.sh0.min.z, o.sh0.max.z)), re = this.clamp01(e.opacities[l]);
+      f[u + 0] = Math.round(Q * 255), f[u + 1] = Math.round(Z * 255), f[u + 2] = Math.round(K * 255), f[u + 3] = Math.round(re * 255);
+    }
+    return new qe(t, r, s, e.positions, m, f, o, e.boundingBox);
+  }
+  /**
+   * Packs SOGS data.
+   * Interleaves the separate textures into the Unified RGBA32UI buffer.
+   * Decodes centers for sorting.
+   */
+  // prettier-ignore
+  static packSogs(e) {
+    const t = e.numSplats, r = Math.ceil(Math.sqrt(t)), s = Math.ceil(t / r), a = r * s, o = this.convertSogsRanges(e.ranges), i = e.ranges.means.mins[0], m = e.ranges.means.mins[1], f = e.ranges.means.mins[2], y = e.ranges.means.maxs[0], l = e.ranges.means.maxs[1], u = e.ranges.means.maxs[2], x = (w) => Math.sign(w) * (Math.exp(Math.abs(w)) - 1), g = new h.Vector3(
+      x(i),
+      x(m),
+      x(f)
+    ), v = new h.Vector3(
+      x(y),
+      x(l),
+      x(u)
+    );
+    o.means.min.copy(g), o.means.max.copy(v);
+    const b = e, E = this.getPixels(b.means_l), T = this.getPixels(b.means_u), P = this.getPixels(b.quats), H = this.getPixels(b.scales), L = this.getPixels(b.sh0), A = new Uint32Array(a * 4), C = new Uint8Array(a * 4), _ = new Float32Array(t * 3);
+    for (let w = 0; w < t; w++) {
+      const p = w * 4, R = T[p + 0], q = E[p + 0], j = T[p + 1], Y = E[p + 1], V = T[p + 2], D = E[p + 2], O = (R << 8 | q) / 65535, J = (j << 8 | Y) / 65535, N = (V << 8 | D) / 65535, c = this.sogsDecode(O, i, y), k = this.sogsDecode(J, m, l), B = this.sogsDecode(N, f, u);
+      _[w * 3 + 0] = c, _[w * 3 + 1] = k, _[w * 3 + 2] = B;
+      const F = this.clamp01(this.norm(c, g.x, v.x)) * 65535 | 0, I = this.clamp01(this.norm(k, g.y, v.y)) * 65535 | 0, d = this.clamp01(this.norm(B, g.z, v.z)) * 65535 | 0;
+      A[p + 0] = this.pack4Bytes(F & 255, I & 255, d & 255, 0), A[p + 1] = this.pack4Bytes(F >> 8, I >> 8, d >> 8, 0), A[p + 3] = this.pack4Bytes(H[p], H[p + 1], H[p + 2], 0);
+      const W = P[p + 3] - 252;
+      A[p + 2] = this.pack4Bytes(P[p + 0], P[p + 1], P[p + 2], W), C[p + 0] = L[p], C[p + 1] = L[p + 1], C[p + 2] = L[p + 2];
+      const S = L[p + 3] / 255, U = e.ranges.sh0.mins[3] + (e.ranges.sh0.maxs[3] - e.ranges.sh0.mins[3]) * S, $ = 1 / (1 + Math.exp(-U));
+      C[p + 3] = Math.round(Math.max(0, Math.min(1, $)) * 255);
+    }
+    return new qe(t, r, s, _, A, C, o, e.boundingBox);
+  }
+  // --- Helpers ---
+  // prettier-ignore
+  static pack4Bytes(e, t, r, s) {
+    return (e & 255) << 24 | (t & 255) << 16 | (r & 255) << 8 | s & 255;
+  }
+  // prettier-ignore
+  static getPixels(e) {
+    const t = e.image, r = t.width, s = t.height;
+    if (t.data && (t.data instanceof Uint8Array || t.data instanceof Uint8ClampedArray)) return new Uint8Array(t.data);
+    const a = document.createElement("canvas");
+    a.width = r, a.height = s;
+    const o = a.getContext("2d", { willReadFrequently: !0 });
+    if (!o) throw new Error("Canvas init failed");
+    return o.drawImage(t, 0, 0), new Uint8Array(o.getImageData(0, 0, r, s).data);
+  }
+  static convertSogsRanges(e) {
+    const t = (r) => new h.Vector3(r[0], r[1], r[2]);
+    return {
+      sh0: { min: t(e.sh0.mins), max: t(e.sh0.maxs) },
+      means: { min: t(e.means.mins), max: t(e.means.maxs) },
+      scales: { min: t(e.scales.mins), max: t(e.scales.maxs) }
+    };
+  }
+  static calculatePlyRanges(e) {
+    const t = new h.Vector3(1 / 0, 1 / 0, 1 / 0), r = new h.Vector3(-1 / 0, -1 / 0, -1 / 0), s = new h.Vector3(1 / 0, 1 / 0, 1 / 0), a = new h.Vector3(-1 / 0, -1 / 0, -1 / 0), o = new h.Vector3(1 / 0, 1 / 0, 1 / 0), i = new h.Vector3(-1 / 0, -1 / 0, -1 / 0);
+    let m = 0;
+    for (let y = 0; y < e.numSplats; y++) {
+      const l = y * 3, u = e.positions[l + 0], x = e.positions[l + 1], g = e.positions[l + 2];
+      t.x = Math.min(t.x, u), r.x = Math.max(r.x, u), t.y = Math.min(t.y, x), r.y = Math.max(r.y, x), t.z = Math.min(t.z, g), r.z = Math.max(r.z, g), s.x = Math.min(s.x, e.scales[l]), a.x = Math.max(a.x, e.scales[l]), s.y = Math.min(s.y, e.scales[l + 1]), a.y = Math.max(a.y, e.scales[l + 1]), s.z = Math.min(s.z, e.scales[l + 2]), a.z = Math.max(a.z, e.scales[l + 2]), m = Math.max(
+        m,
+        e.colors[l],
+        e.colors[l + 1],
+        e.colors[l + 2]
+      );
+    }
+    const f = m > 1.5 ? 1 / 255 : 1;
+    for (let y = 0; y < e.numSplats; y++) {
+      const l = y * 3, u = this.clamp01(e.colors[l + 0] * f), x = this.clamp01(e.colors[l + 1] * f), g = this.clamp01(e.colors[l + 2] * f), v = (u - 0.5) / me, b = (x - 0.5) / me, E = (g - 0.5) / me;
+      o.x = Math.min(o.x, v), i.x = Math.max(i.x, v), o.y = Math.min(o.y, b), i.y = Math.max(i.y, b), o.z = Math.min(o.z, E), i.z = Math.max(i.z, E);
+    }
+    return {
+      colorScale: f,
+      ranges: {
+        sh0: { min: o, max: i },
+        means: { min: t, max: r },
+        scales: { min: s, max: a }
+      }
+    };
+  }
+  static clamp01(e) {
+    return Math.max(0, Math.min(1, e));
+  }
+  // prettier-ignore
+  // private static lerp(a: number, b: number, t: number) { return a + (b - a) * t; } // prettier-ignore
+  // private static invSogsMap(v: number) { return Math.sign(v) * Math.log(Math.abs(v) + 1) } // prettier-ignore
+  static norm(e, t, r) {
+    return (e - t) / (r - t || 1);
+  }
+  // prettier-ignore
+  static sogsDecode(e, t, r) {
+    const s = t + (r - t) * e;
+    return Math.sign(s) * (Math.exp(Math.abs(s)) - 1);
+  }
+}
+class st extends h.Loader {
+  constructor(t) {
+    super(t);
+    M(this, "requestId", 0);
+    M(this, "worker");
+    M(this, "pendingCallbacks", /* @__PURE__ */ new Map());
     this.withCredentials = !0;
-    const t = this.createWorkerCode(), r = new Blob([t], { type: "application/javascript" });
-    this.worker = new Worker(URL.createObjectURL(r)), this.worker.onmessage = this.onWorkerMessage.bind(this);
+    const r = this.createWorkerCode(), s = new Blob([r], { type: "application/javascript" });
+    this.worker = new Worker(URL.createObjectURL(s)), this.worker.onmessage = this.onWorkerMessage.bind(this);
   }
   /**
    * Handles messages received from the parsing worker
    * @param event The message event from the worker
    */
-  onWorkerMessage(o) {
-    const { requestId: t, error: r, result: n } = o.data, a = this.pendingCallbacks.get(t);
-    if (!a) return console.warn(`PlyLoader: Received response for unknown request ${t}`);
-    if (this.pendingCallbacks.delete(t), r) return a.reject(new Error(r));
-    if (!n) return a.reject(new Error("Worker returned no result"));
+  onWorkerMessage(t) {
+    const { requestId: r, error: s, result: a } = t.data, o = this.pendingCallbacks.get(r);
+    if (!o) return console.warn(`PlyLoader: Received response for unknown request ${r}`);
+    if (this.pendingCallbacks.delete(r), s) return o.reject(new Error(s));
+    if (!a) return o.reject(new Error("Worker returned no result"));
     try {
-      const i = new Re(0);
-      i.numSplats = n.numSplats, i.positions = new Float32Array(n.positions), i.rotations = new Float32Array(n.rotations), i.scales = new Float32Array(n.scales), i.colors = new Float32Array(n.colors), i.opacities = new Float32Array(n.opacities), i.boundingBox.min.set(
-        n.boundingBox.minX,
-        n.boundingBox.minY,
-        n.boundingBox.minZ
+      const i = new rt(0);
+      i.numSplats = a.numSplats, i.positions = new Float32Array(a.positions), i.rotations = new Float32Array(a.rotations), i.scales = new Float32Array(a.scales), i.colors = new Float32Array(a.colors), i.opacities = new Float32Array(a.opacities), i.boundingBox.min.set(
+        a.boundingBox.minX,
+        a.boundingBox.minY,
+        a.boundingBox.minZ
       ), i.boundingBox.max.set(
-        n.boundingBox.maxX,
-        n.boundingBox.maxY,
-        n.boundingBox.maxZ
-      ), this.worker.terminate(), a.resolve(i);
+        a.boundingBox.maxX,
+        a.boundingBox.maxY,
+        a.boundingBox.maxZ
+      ), this.worker.terminate();
+      const m = Ce.packPly(i);
+      i.dispose(), o.resolve(m);
     } catch (i) {
-      a.reject(i);
+      o.reject(i);
     }
   }
   /**
@@ -503,19 +699,19 @@ class ze extends l.Loader {
    * @param onProgress Optional progress callback
    * @param onError Optional error callback
    */
-  load(o, t, r, n) {
-    const a = new l.FileLoader(this.manager);
-    a.setResponseType("arraybuffer"), a.setRequestHeader(this.requestHeader), a.setPath(this.path), a.setWithCredentials(this.withCredentials), a.load(
-      o,
+  load(t, r, s, a) {
+    const o = new h.FileLoader(this.manager);
+    o.setResponseType("arraybuffer"), o.setRequestHeader(this.requestHeader), o.setPath(this.path), o.setWithCredentials(this.withCredentials), o.load(
+      t,
       (i) => {
-        this.parseAsync(i).then((u) => {
-          t && t(u);
-        }).catch((u) => {
-          n ? n(u) : console.error(u), this.manager.itemError(o);
+        this.parseAsync(i).then((m) => {
+          r && r(m);
+        }).catch((m) => {
+          a ? a(m) : console.error(m), this.manager.itemError(t);
         });
       },
-      r,
-      n
+      s,
+      a
     );
   }
   /**
@@ -524,19 +720,19 @@ class ze extends l.Loader {
    * @param onProgress Optional progress callback
    * @returns A Promise that resolves with the parsed SplatData
    */
-  loadAsync(o, t) {
-    return new Promise((r, n) => {
-      const a = new l.FileLoader(this.manager);
-      a.setResponseType("arraybuffer"), a.setRequestHeader(this.requestHeader), a.setPath(this.path), a.setWithCredentials(this.withCredentials), a.load(
-        o,
+  loadAsync(t, r) {
+    return new Promise((s, a) => {
+      const o = new h.FileLoader(this.manager);
+      o.setResponseType("arraybuffer"), o.setRequestHeader(this.requestHeader), o.setPath(this.path), o.setWithCredentials(this.withCredentials), o.load(
+        t,
         (i) => {
-          this.parseAsync(i).then(r).catch((u) => {
-            n(u), this.manager.itemError(o);
+          this.parseAsync(i).then(s).catch((m) => {
+            a(m), this.manager.itemError(t);
           });
         },
-        t,
+        r,
         (i) => {
-          n(i), this.manager.itemError(o);
+          a(i), this.manager.itemError(t);
         }
       );
     });
@@ -546,15 +742,15 @@ class ze extends l.Loader {
    * @param buffer ArrayBuffer containing PLY data
    * @returns Promise that resolves with parsed SplatData
    */
-  parseAsync(o) {
-    return new Promise((t, r) => {
-      const n = this.requestId++;
-      this.pendingCallbacks.set(n, { resolve: t, reject: r });
-      const a = {
-        requestId: n,
-        buffer: o
+  parseAsync(t) {
+    return new Promise((r, s) => {
+      const a = this.requestId++;
+      this.pendingCallbacks.set(a, { resolve: r, reject: s });
+      const o = {
+        requestId: a,
+        buffer: t
       };
-      this.worker.postMessage(a, [o]);
+      this.worker.postMessage(o, [t]);
     });
   }
   /**
@@ -569,14 +765,14 @@ class ze extends l.Loader {
    */
   createWorkerCode() {
     return `(${(function() {
-      self.onmessage = (r) => {
-        const { requestId: n, buffer: a } = r.data;
+      self.onmessage = (s) => {
+        const { requestId: a, buffer: o } = s.data;
         try {
-          const i = t(a), u = {
-            requestId: n,
+          const i = r(o), m = {
+            requestId: a,
             result: i
           };
-          self.postMessage(u, [
+          self.postMessage(m, [
             i.positions,
             i.rotations,
             i.scales,
@@ -584,215 +780,747 @@ class ze extends l.Loader {
             i.opacities
           ]);
         } catch (i) {
-          const u = {
-            requestId: n,
+          const m = {
+            requestId: a,
             error: i instanceof Error ? i.message : String(i)
           };
-          self.postMessage(u);
+          self.postMessage(m);
         }
       };
-      function t(r) {
-        const n = new TextDecoder(), a = new Uint8Array(r), i = [112, 108, 121, 10], u = `
+      function r(s) {
+        const a = new TextDecoder(), o = new Uint8Array(s), i = [112, 108, 121, 10], m = `
 end_header
 `;
-        for (let m = 0; m < i.length; m++)
-          if (a[m] !== i[m])
+        for (let I = 0; I < i.length; I++)
+          if (o[I] !== i[I])
             throw new Error(
               "Invalid PLY file: Missing magic bytes"
             );
-        let w = 0;
-        for (let m = 0; m < a.length - u.length; m++) {
-          let c = !0;
-          for (let y = 0; y < u.length; y++)
-            if (a[m + y] !== u.charCodeAt(y)) {
-              c = !1;
+        let f = 0;
+        for (let I = 0; I < o.length - m.length; I++) {
+          let d = !0;
+          for (let z = 0; z < m.length; z++)
+            if (o[I + z] !== m.charCodeAt(z)) {
+              d = !1;
               break;
             }
-          if (c) {
-            w = m + u.length;
+          if (d) {
+            f = I + m.length;
             break;
           }
         }
-        if (w === 0)
+        if (f === 0)
           throw new Error(
             "Invalid PLY file: Could not find end of header"
           );
-        const _ = n.decode(
-          a.subarray(0, w)
+        const l = a.decode(
+          o.subarray(0, f)
         ).split(`
-`), h = [];
-        let b = null;
-        for (let m = 1; m < _.length; m++) {
-          const c = _[m].trim();
-          if (c === "" || c === "end_header") continue;
-          const y = c.split(" ");
-          switch (y[0]) {
+`), u = [];
+        let x = null;
+        for (let I = 1; I < l.length; I++) {
+          const d = l[I].trim();
+          if (d === "" || d === "end_header") continue;
+          const z = d.split(" ");
+          switch (z[0]) {
             case "format":
-              b = y[1];
+              x = z[1];
               break;
             case "element":
-              h.push({
-                name: y[1],
-                count: parseInt(y[2], 10),
+              u.push({
+                name: z[1],
+                count: parseInt(z[2], 10),
                 properties: []
               });
               break;
             case "property":
-              if (h.length === 0)
+              if (u.length === 0)
                 throw new Error(
                   "Invalid PLY file: Property without element"
                 );
-              h[h.length - 1].properties.push({
-                type: y[1],
-                name: y[2]
+              u[u.length - 1].properties.push({
+                type: z[1],
+                name: z[2]
               });
               break;
           }
         }
-        if (b !== "binary_little_endian")
-          throw new Error(`Unsupported PLY format: ${b}`);
-        const S = h.find((m) => m.name === "vertex");
-        if (!S)
+        if (x !== "binary_little_endian")
+          throw new Error(`Unsupported PLY format: ${x}`);
+        const g = u.find((I) => I.name === "vertex");
+        if (!g)
           throw new Error(
             "Invalid PLY file: No vertex element found"
           );
-        const I = S.count, P = new Float32Array(I * 3), j = new Float32Array(I * 4), H = new Float32Array(I * 3), W = new Float32Array(I * 3), oe = new Float32Array(I), L = new DataView(r);
-        let A = w;
-        const g = (m) => S.properties.findIndex(
-          (c) => c.name === m
-        ), D = g("x"), T = g("y"), v = g("z"), R = [
-          g("rot_0"),
-          g("rot_1"),
-          g("rot_2"),
-          g("rot_3")
-        ], B = [
-          g("scale_0"),
-          g("scale_1"),
-          g("scale_2")
-        ], $ = [
-          g("f_dc_0"),
-          g("f_dc_1"),
-          g("f_dc_2")
-        ], X = g("opacity");
+        const v = g.count, b = new Float32Array(v * 3), E = new Float32Array(v * 4), T = new Float32Array(v * 3), P = new Float32Array(v * 3), H = new Float32Array(v), L = new DataView(s);
+        let A = f;
+        const C = (I) => g.properties.findIndex(
+          (d) => d.name === I
+        ), _ = C("x"), w = C("y"), p = C("z"), R = [
+          C("rot_0"),
+          C("rot_1"),
+          C("rot_2"),
+          C("rot_3")
+        ], q = [
+          C("scale_0"),
+          C("scale_1"),
+          C("scale_2")
+        ], j = [
+          C("f_dc_0"),
+          C("f_dc_1"),
+          C("f_dc_2")
+        ], Y = C("opacity");
         if ([
-          D,
-          T,
-          v,
+          _,
+          w,
+          p,
           ...R,
-          ...B,
-          ...$,
-          X
-        ].some((m) => m === -1))
+          ...q,
+          ...j,
+          Y
+        ].some((I) => I === -1))
           throw new Error(
             "Invalid PLY file: Missing required properties"
           );
-        const U = 0.28209479177387814, F = (m) => {
-          if (m > 0) return 1 / (1 + Math.exp(-m));
-          const c = Math.exp(m);
-          return c / (1 + c);
+        const D = 0.28209479177387814, O = (I) => {
+          if (I > 0) return 1 / (1 + Math.exp(-I));
+          const d = Math.exp(I);
+          return d / (1 + d);
         };
-        let N = 1 / 0, te = 1 / 0, s = 1 / 0, p = -1 / 0, M = -1 / 0, E = -1 / 0;
-        for (let m = 0; m < I; m++) {
-          const c = [];
-          for (let he = 0; he < S.properties.length; he++) {
-            const pe = S.properties[he].type;
-            let ee;
-            switch (pe) {
+        let J = 1 / 0, N = 1 / 0, c = 1 / 0, k = -1 / 0, B = -1 / 0, F = -1 / 0;
+        for (let I = 0; I < v; I++) {
+          const d = [];
+          for (let Se = 0; Se < g.properties.length; Se++) {
+            const ze = g.properties[Se].type;
+            let ce;
+            switch (ze) {
               case "char":
-                ee = L.getInt8(A), A += 1;
+                ce = L.getInt8(A), A += 1;
                 break;
               case "uchar":
-                ee = L.getUint8(A), A += 1;
+                ce = L.getUint8(A), A += 1;
                 break;
               case "short":
-                ee = L.getInt16(A, !0), A += 2;
+                ce = L.getInt16(A, !0), A += 2;
                 break;
               case "ushort":
-                ee = L.getUint16(A, !0), A += 2;
+                ce = L.getUint16(A, !0), A += 2;
                 break;
               case "int":
-                ee = L.getInt32(A, !0), A += 4;
+                ce = L.getInt32(A, !0), A += 4;
                 break;
               case "uint":
-                ee = L.getUint32(A, !0), A += 4;
+                ce = L.getUint32(A, !0), A += 4;
                 break;
               case "float":
-                ee = L.getFloat32(A, !0), A += 4;
+                ce = L.getFloat32(A, !0), A += 4;
                 break;
               case "double":
-                ee = L.getFloat64(A, !0), A += 8;
+                ce = L.getFloat64(A, !0), A += 8;
                 break;
               default:
                 throw new Error(
-                  `Unsupported property type: ${pe}`
+                  `Unsupported property type: ${ze}`
                 );
             }
-            c.push(ee);
+            d.push(ce);
           }
-          const y = c[D], z = c[T], d = c[v], k = m * 3;
-          P[k] = y, P[k + 1] = z, P[k + 2] = d, N = Math.min(N, y), te = Math.min(te, z), s = Math.min(s, d), p = Math.max(p, y), M = Math.max(M, z), E = Math.max(E, d);
-          let O = c[R[1]], q = c[R[2]], G = c[R[3]], V = c[R[0]];
-          const Y = Math.sqrt(
-            O * O + q * q + G * G + V * V
+          const z = d[_], W = d[w], S = d[p], U = I * 3;
+          b[U] = z, b[U + 1] = W, b[U + 2] = S, J = Math.min(J, z), N = Math.min(N, W), c = Math.min(c, S), k = Math.max(k, z), B = Math.max(B, W), F = Math.max(F, S);
+          let $ = d[R[1]], X = d[R[2]], Q = d[R[3]], Z = d[R[0]];
+          const K = Math.sqrt(
+            $ * $ + X * X + Q * Q + Z * Z
           );
-          Y > 0 && (O /= Y, q /= Y, G /= Y, V /= Y), V < 0 && (O = -O, q = -q, G = -G, V = -V);
-          const K = m * 4;
-          j[K] = O, j[K + 1] = q, j[K + 2] = G, j[K + 3] = V;
-          const Q = m * 3;
-          H[Q] = c[B[0]], H[Q + 1] = c[B[1]], H[Q + 2] = c[B[2]];
-          let re = 0.5 + c[$[0]] * U, ne = 0.5 + c[$[1]] * U, J = 0.5 + c[$[2]] * U;
-          re = Math.max(0, Math.min(1, re)), ne = Math.max(0, Math.min(1, ne)), J = Math.max(0, Math.min(1, J));
-          const ue = m * 3;
-          W[ue] = re, W[ue + 1] = ne, W[ue + 2] = J, oe[m] = F(c[X]);
+          K > 0 && ($ /= K, X /= K, Q /= K, Z /= K), Z < 0 && ($ = -$, X = -X, Q = -Q, Z = -Z);
+          const re = I * 4;
+          E[re] = $, E[re + 1] = X, E[re + 2] = Q, E[re + 3] = Z;
+          const se = I * 3;
+          T[se] = d[q[0]], T[se + 1] = d[q[1]], T[se + 2] = d[q[2]];
+          let ue = 0.5 + d[j[0]] * D, he = 0.5 + d[j[1]] * D, oe = 0.5 + d[j[2]] * D;
+          ue = Math.max(0, Math.min(1, ue)), he = Math.max(0, Math.min(1, he)), oe = Math.max(0, Math.min(1, oe));
+          const Me = I * 3;
+          P[Me] = ue, P[Me + 1] = he, P[Me + 2] = oe, H[I] = O(d[Y]);
         }
         return {
-          numSplats: I,
-          positions: P.buffer,
-          rotations: j.buffer,
-          scales: H.buffer,
-          colors: W.buffer,
-          opacities: oe.buffer,
+          numSplats: v,
+          positions: b.buffer,
+          rotations: E.buffer,
+          scales: T.buffer,
+          colors: P.buffer,
+          opacities: H.buffer,
           boundingBox: {
-            minX: N,
-            minY: te,
-            minZ: s,
-            maxX: p,
-            maxY: M,
-            maxZ: E
+            minX: J,
+            minY: N,
+            minZ: c,
+            maxX: k,
+            maxY: B,
+            maxZ: F
           }
         };
       }
     }).toString()})();`;
   }
 }
-class Pe extends l.EventDispatcher {
+var ee = Uint8Array, fe = Uint16Array, nt = Int32Array, Ue = new ee([
+  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
+]), Ve = new ee([
+  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
+]), at = new ee([16, 17, 18, 0, 8, 7, 9, 6, 10, 5, 11, 4, 12, 3, 13, 2, 14, 1, 15]), Le = function(n, e) {
+  for (var t = new fe(31), r = 0; r < 31; ++r)
+    t[r] = e += 1 << n[r - 1];
+  for (var s = new nt(t[30]), r = 1; r < 30; ++r)
+    for (var a = t[r]; a < t[r + 1]; ++a)
+      s[a] = a - t[r] << 5 | r;
+  return { b: t, r: s };
+}, je = Le(Ue, 2), We = je.b, ot = je.r;
+We[28] = 258, ot[258] = 28;
+var it = Le(Ve, 0), ct = it.b, Ie = new fe(32768);
+for (var G = 0; G < 32768; ++G) {
+  var le = (G & 43690) >> 1 | (G & 21845) << 1;
+  le = (le & 52428) >> 2 | (le & 13107) << 2, le = (le & 61680) >> 4 | (le & 3855) << 4, Ie[G] = ((le & 65280) >> 8 | (le & 255) << 8) >> 1;
+}
+var ye = function(n, e, t) {
+  for (var r = n.length, s = 0, a = new fe(e); s < r; ++s)
+    n[s] && ++a[n[s] - 1];
+  var o = new fe(e);
+  for (s = 1; s < e; ++s)
+    o[s] = o[s - 1] + a[s - 1] << 1;
+  var i;
+  if (t) {
+    i = new fe(1 << e);
+    var m = 15 - e;
+    for (s = 0; s < r; ++s)
+      if (n[s])
+        for (var f = s << 4 | n[s], y = e - n[s], l = o[n[s] - 1]++ << y, u = l | (1 << y) - 1; l <= u; ++l)
+          i[Ie[l] >> m] = f;
+  } else
+    for (i = new fe(r), s = 0; s < r; ++s)
+      n[s] && (i[s] = Ie[o[n[s] - 1]++] >> 15 - n[s]);
+  return i;
+}, ge = new ee(288);
+for (var G = 0; G < 144; ++G)
+  ge[G] = 8;
+for (var G = 144; G < 256; ++G)
+  ge[G] = 9;
+for (var G = 256; G < 280; ++G)
+  ge[G] = 7;
+for (var G = 280; G < 288; ++G)
+  ge[G] = 8;
+var Ge = new ee(32);
+for (var G = 0; G < 32; ++G)
+  Ge[G] = 5;
+var lt = /* @__PURE__ */ ye(ge, 9, 1), ut = /* @__PURE__ */ ye(Ge, 5, 1), Ae = function(n) {
+  for (var e = n[0], t = 1; t < n.length; ++t)
+    n[t] > e && (e = n[t]);
+  return e;
+}, ne = function(n, e, t) {
+  var r = e / 8 | 0;
+  return (n[r] | n[r + 1] << 8) >> (e & 7) & t;
+}, ke = function(n, e) {
+  var t = e / 8 | 0;
+  return (n[t] | n[t + 1] << 8 | n[t + 2] << 16) >> (e & 7);
+}, ht = function(n) {
+  return (n + 7) / 8 | 0;
+}, _e = function(n, e, t) {
+  return (e == null || e < 0) && (e = 0), (t == null || t > n.length) && (t = n.length), new ee(n.subarray(e, t));
+}, mt = [
+  "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
+], te = function(n, e, t) {
+  var r = new Error(e || mt[n]);
+  if (r.code = n, Error.captureStackTrace && Error.captureStackTrace(r, te), !t)
+    throw r;
+  return r;
+}, ft = function(n, e, t, r) {
+  var s = n.length, a = r ? r.length : 0;
+  if (!s || e.f && !e.l)
+    return t || new ee(0);
+  var o = !t, i = o || e.i != 2, m = e.i;
+  o && (t = new ee(s * 3));
+  var f = function(X) {
+    var Q = t.length;
+    if (X > Q) {
+      var Z = new ee(Math.max(Q * 2, X));
+      Z.set(t), t = Z;
+    }
+  }, y = e.f || 0, l = e.p || 0, u = e.b || 0, x = e.l, g = e.d, v = e.m, b = e.n, E = s * 8;
+  do {
+    if (!x) {
+      y = ne(n, l, 1);
+      var T = ne(n, l + 1, 3);
+      if (l += 3, T)
+        if (T == 1)
+          x = lt, g = ut, v = 9, b = 5;
+        else if (T == 2) {
+          var A = ne(n, l, 31) + 257, C = ne(n, l + 10, 15) + 4, _ = A + ne(n, l + 5, 31) + 1;
+          l += 14;
+          for (var w = new ee(_), p = new ee(19), R = 0; R < C; ++R)
+            p[at[R]] = ne(n, l + R * 3, 7);
+          l += C * 3;
+          for (var q = Ae(p), j = (1 << q) - 1, Y = ye(p, q, 1), R = 0; R < _; ) {
+            var V = Y[ne(n, l, j)];
+            l += V & 15;
+            var P = V >> 4;
+            if (P < 16)
+              w[R++] = P;
+            else {
+              var D = 0, O = 0;
+              for (P == 16 ? (O = 3 + ne(n, l, 3), l += 2, D = w[R - 1]) : P == 17 ? (O = 3 + ne(n, l, 7), l += 3) : P == 18 && (O = 11 + ne(n, l, 127), l += 7); O--; )
+                w[R++] = D;
+            }
+          }
+          var J = w.subarray(0, A), N = w.subarray(A);
+          v = Ae(J), b = Ae(N), x = ye(J, v, 1), g = ye(N, b, 1);
+        } else
+          te(1);
+      else {
+        var P = ht(l) + 4, H = n[P - 4] | n[P - 3] << 8, L = P + H;
+        if (L > s) {
+          m && te(0);
+          break;
+        }
+        i && f(u + H), t.set(n.subarray(P, L), u), e.b = u += H, e.p = l = L * 8, e.f = y;
+        continue;
+      }
+      if (l > E) {
+        m && te(0);
+        break;
+      }
+    }
+    i && f(u + 131072);
+    for (var c = (1 << v) - 1, k = (1 << b) - 1, B = l; ; B = l) {
+      var D = x[ke(n, l) & c], F = D >> 4;
+      if (l += D & 15, l > E) {
+        m && te(0);
+        break;
+      }
+      if (D || te(2), F < 256)
+        t[u++] = F;
+      else if (F == 256) {
+        B = l, x = null;
+        break;
+      } else {
+        var I = F - 254;
+        if (F > 264) {
+          var R = F - 257, d = Ue[R];
+          I = ne(n, l, (1 << d) - 1) + We[R], l += d;
+        }
+        var z = g[ke(n, l) & k], W = z >> 4;
+        z || te(3), l += z & 15;
+        var N = ct[W];
+        if (W > 3) {
+          var d = Ve[W];
+          N += ke(n, l) & (1 << d) - 1, l += d;
+        }
+        if (l > E) {
+          m && te(0);
+          break;
+        }
+        i && f(u + 131072);
+        var S = u + I;
+        if (u < N) {
+          var U = a - N, $ = Math.min(N, S);
+          for (U + u < 0 && te(3); u < $; ++u)
+            t[u] = r[U + u];
+        }
+        for (; u < S; ++u)
+          t[u] = t[u - N];
+      }
+    }
+    e.l = x, e.p = B, e.b = u, e.f = y, x && (y = 1, e.m = v, e.d = g, e.n = b);
+  } while (!y);
+  return u != t.length && o ? _e(t, 0, u) : t.subarray(0, u);
+}, dt = /* @__PURE__ */ new ee(0), ie = function(n, e) {
+  return n[e] | n[e + 1] << 8;
+}, ae = function(n, e) {
+  return (n[e] | n[e + 1] << 8 | n[e + 2] << 16 | n[e + 3] << 24) >>> 0;
+}, Ee = function(n, e) {
+  return ae(n, e) + ae(n, e + 4) * 4294967296;
+};
+function pt(n, e) {
+  return ft(n, { i: 2 }, e && e.out, e && e.dictionary);
+}
+var Re = typeof TextDecoder < "u" && /* @__PURE__ */ new TextDecoder(), xt = 0;
+try {
+  Re.decode(dt, { stream: !0 }), xt = 1;
+} catch {
+}
+var yt = function(n) {
+  for (var e = "", t = 0; ; ) {
+    var r = n[t++], s = (r > 127) + (r > 223) + (r > 239);
+    if (t + s > n.length)
+      return { s: e, r: _e(n, t - 1) };
+    s ? s == 3 ? (r = ((r & 15) << 18 | (n[t++] & 63) << 12 | (n[t++] & 63) << 6 | n[t++] & 63) - 65536, e += String.fromCharCode(55296 | r >> 10, 56320 | r & 1023)) : s & 1 ? e += String.fromCharCode((r & 31) << 6 | n[t++] & 63) : e += String.fromCharCode((r & 15) << 12 | (n[t++] & 63) << 6 | n[t++] & 63) : e += String.fromCharCode(r);
+  }
+};
+function gt(n, e) {
+  if (e) {
+    for (var t = "", r = 0; r < n.length; r += 16384)
+      t += String.fromCharCode.apply(null, n.subarray(r, r + 16384));
+    return t;
+  } else {
+    if (Re)
+      return Re.decode(n);
+    var s = yt(n), a = s.s, t = s.r;
+    return t.length && te(8), a;
+  }
+}
+var wt = function(n, e) {
+  return e + 30 + ie(n, e + 26) + ie(n, e + 28);
+}, vt = function(n, e, t) {
+  var r = ie(n, e + 28), s = gt(n.subarray(e + 46, e + 46 + r), !(ie(n, e + 8) & 2048)), a = e + 46 + r, o = ae(n, e + 20), i = t && o == 4294967295 ? bt(n, a) : [o, ae(n, e + 24), ae(n, e + 42)], m = i[0], f = i[1], y = i[2];
+  return [ie(n, e + 10), m, f, s, a + ie(n, e + 30) + ie(n, e + 32), y];
+}, bt = function(n, e) {
+  for (; ie(n, e) != 1; e += 4 + ie(n, e + 2))
+    ;
+  return [Ee(n, e + 12), Ee(n, e + 4), Ee(n, e + 20)];
+};
+function Mt(n, e) {
+  for (var t = {}, r = n.length - 22; ae(n, r) != 101010256; --r)
+    (!r || n.length - r > 65558) && te(13);
+  var s = ie(n, r + 8);
+  if (!s)
+    return {};
+  var a = ae(n, r + 16), o = a == 4294967295 || s == 65535;
+  if (o) {
+    var i = ae(n, r - 12);
+    o = ae(n, i) == 101075792, o && (s = ae(n, i + 32), a = ae(n, i + 48));
+  }
+  for (var m = 0; m < s; ++m) {
+    var f = vt(n, a, o), y = f[0], l = f[1], u = f[2], x = f[3], g = f[4], v = f[5], b = wt(n, v);
+    a = g, y ? y == 8 ? t[x] = pt(n.subarray(b, b + l), { out: new ee(u) }) : te(14, "unknown compression type " + y) : t[x] = _e(n, b, b + l);
+  }
+  return t;
+}
+const Oe = (n) => {
+  if (typeof n != "object" || n === null) throw new Error("Invalid SOGS metadata: not an object");
+  const e = n, t = e.version ?? 1;
+  if (t !== 1) throw new Error(`Unsupported SOGS version: ${String(t)}`);
+  const r = (v) => {
+    const b = e[v];
+    if (typeof b != "object" || b === null) throw new Error(`Invalid SOGS metadata section: ${v}`);
+    return b;
+  }, s = r("means"), a = r("sh0"), o = r("quats"), i = r("scales"), m = typeof e.count == "number" && Number.isFinite(e.count) ? e.count : void 0, f = Array.isArray(s.shape) ? s.shape : void 0, y = f && typeof f[0] == "number" ? f[0] : void 0;
+  if (m === void 0 && y === void 0)
+    throw new Error(
+      "Invalid SOGS metadata: unable to determine splat count"
+    );
+  if (m !== void 0 && y !== void 0 && m !== y)
+    throw new Error(
+      "Inconsistent SOGS metadata: count does not match means.shape[0]"
+    );
+  const l = m ?? y, u = (v, b) => {
+    const E = v.mins, T = v.maxs;
+    if (!Array.isArray(E) || E.length !== 3)
+      throw new Error(`${b}.mins must be length-3`);
+    if (!Array.isArray(T) || T.length !== 3)
+      throw new Error(`${b}.maxs must be length-3`);
+    if (![...E, ...T].every(
+      (P) => typeof P == "number" && Number.isFinite(P)
+    ))
+      throw new Error(`${b}.mins/maxs must be finite numbers`);
+    return {
+      mins: [E[0], E[1], E[2]],
+      maxs: [T[0], T[1], T[2]]
+    };
+  }, x = (v, b) => {
+    const E = v.mins, T = v.maxs;
+    if (!Array.isArray(E) || E.length !== 4)
+      throw new Error(`${b}.mins must be length-4`);
+    if (!Array.isArray(T) || T.length !== 4)
+      throw new Error(`${b}.maxs must be length-4`);
+    if (![...E, ...T].every(
+      (P) => typeof P == "number" && Number.isFinite(P)
+    ))
+      throw new Error(`${b}.mins/maxs must be finite numbers`);
+    return {
+      mins: [E[0], E[1], E[2], E[3]],
+      maxs: [T[0], T[1], T[2], T[3]]
+    };
+  }, g = (v, b) => {
+    const E = v.files;
+    if (!Array.isArray(E)) throw new Error(`${b}.files is not an array`);
+    if (!E.every((T) => typeof T == "string")) throw new Error(`${b}.files contains non-strings`);
+    return E;
+  };
+  return {
+    numSplats: l,
+    files: {
+      sh0: g(a, "sh0"),
+      means: g(s, "means"),
+      quats: g(o, "quats"),
+      scales: g(i, "scales")
+    },
+    ranges: {
+      sh0: x(a, "sh0"),
+      means: u(s, "means"),
+      scales: u(i, "scales")
+    }
+  };
+};
+class St extends h.Loader {
+  /**
+   * Detect if a buffer is a ZIP file by checking magic bytes
+   * ZIP files start with signature: PK\x03\x04 (0x50 0x4B 0x03 0x04)
+   */
+  isZipBuffer(e) {
+    if (e.byteLength < 4) return !1;
+    const t = new Uint8Array(e, 0, 4);
+    return t[0] === 80 && t[1] === 75 && t[2] === 3 && t[3] === 4;
+  }
+  /**
+   * Load a SOGS file (meta.json + textures)
+   * @param url URL of the meta.json file
+   * @param onLoad Optional callback when loading is complete
+   * @param onProgress Optional progress callback
+   * @param onError Optional error callback
+   */
+  load(e, t, r, s) {
+    const a = new h.FileLoader(this.manager);
+    a.setResponseType("arraybuffer"), a.setRequestHeader(this.requestHeader), a.setPath(this.path), a.setWithCredentials(this.withCredentials), a.load(
+      e,
+      (o) => {
+        this.parseAsync(e, o).then((i) => {
+          t && t(i);
+        }).catch((i) => {
+          this.manager.itemError(e), s && s(i), console.error("Error loading SOGS meta:", i);
+        });
+      },
+      r,
+      s
+    );
+  }
+  /**
+   * Load a SOGS file asynchronously and return a Promise
+   * @param url URL of the meta.json file
+   * @param onProgress Optional progress callback
+   * @returns A Promise that resolves with the parsed SplatData
+   */
+  loadAsync(e, t) {
+    return new Promise((r, s) => {
+      const a = new h.FileLoader(this.manager);
+      a.setResponseType("arraybuffer"), a.setRequestHeader(this.requestHeader), a.setPath(this.path), a.setWithCredentials(this.withCredentials), a.load(
+        e,
+        (o) => {
+          this.parseAsync(e, o).then(r).catch((i) => {
+            s(i), this.manager.itemError(e);
+          });
+        },
+        t,
+        (o) => {
+          s(o), this.manager.itemError(e);
+        }
+      );
+    });
+  }
+  async parseAsync(e, t) {
+    if (!(t instanceof ArrayBuffer)) throw new Error("SOGS loader: expected ArrayBuffer payload");
+    if (this.isZipBuffer(t)) return this.parseZipAsync(t);
+    const s = new TextDecoder("utf-8").decode(t), a = JSON.parse(s);
+    return this.parseMetaAsync(e, a);
+  }
+  async parseMetaAsync(e, t) {
+    const { numSplats: r, files: s, ranges: a } = Oe(t), o = new h.TextureLoader(this.manager);
+    o.setPath(this.path), o.setRequestHeader(this.requestHeader), o.setWithCredentials(this.withCredentials);
+    const i = (E, T) => {
+      try {
+        return new URL(T, E).toString();
+      } catch {
+        return E.substring(0, E.lastIndexOf("/") + 1) + T;
+      }
+    }, m = (E, T) => {
+      const P = i(e, E);
+      return new Promise((H, L) => {
+        o.load(
+          P,
+          (A) => {
+            A.generateMipmaps = !1, A.magFilter = h.NearestFilter, A.minFilter = h.NearestFilter, A.flipY = !1, H(A);
+          },
+          void 0,
+          (A) => {
+            const C = A instanceof Error ? A.message : String(A);
+            L(
+              new Error(
+                `SOGS loader: failed to load ${T} (${E}): ${C}`
+              )
+            );
+          }
+        );
+      });
+    };
+    if (!Array.isArray(s.sh0) || s.sh0.length < 1) throw new Error("SOGS loader: files.sh0 must have at least 1 entry (sh0)");
+    if (!Array.isArray(s.means) || s.means.length < 2) throw new Error("SOGS loader: files.means must have at least 2 entries (means_l, means_u)");
+    if (!Array.isArray(s.quats) || s.quats.length < 1) throw new Error("SOGS loader: files.quats must have at least 1 entry");
+    if (!Array.isArray(s.scales) || s.scales.length < 1) throw new Error("SOGS loader: files.scales must have at least 1 entry");
+    const [f, y, l, u, x] = await Promise.all([
+      m(s.means[0], "means_l"),
+      m(s.means[1], "means_u"),
+      m(s.quats[0], "quats"),
+      m(s.scales[0], "scales"),
+      m(s.sh0[0], "sh0")
+    ]), g = { means_l: f, means_u: y, quats: l, scales: u, sh0: x }, v = new Fe(r, a, g), b = Ce.packSogs(v);
+    return v.dispose(), b;
+  }
+  async parseZipAsync(e) {
+    const t = Mt(new Uint8Array(e)), r = Object.keys(t), s = r.find((_) => _.toLowerCase().endsWith("meta.json")) ?? null;
+    if (!s) throw new Error("SOGS loader: zip missing meta.json");
+    const a = s.includes("/") ? s.slice(0, s.lastIndexOf("/") + 1) : "", o = new TextDecoder(), i = JSON.parse(o.decode(t[s])), { numSplats: m, files: f, ranges: y } = Oe(i), l = (_) => _.replace(/\\/g, "/").replace(/^\.?\//, ""), u = (_) => {
+      const w = l(_), p = [l(a + w), w];
+      for (const j of p) {
+        const Y = t[j];
+        if (Y) return Y;
+      }
+      const R = w.split("/").pop(), q = r.find((j) => l(j).endsWith("/" + w)) ?? r.find((j) => l(j).endsWith("/" + R)) ?? r.find((j) => l(j) === R) ?? null;
+      if (q) return t[q];
+      throw new Error(`SOGS loader: zip missing file "${_}"`);
+    }, x = (_) => {
+      const w = _.toLowerCase();
+      return w.endsWith(".png") ? "image/png" : w.endsWith(".jpg") || w.endsWith(".jpeg") ? "image/jpeg" : w.endsWith(".webp") ? "image/webp" : "application/octet-stream";
+    }, g = new h.TextureLoader(this.manager);
+    g.setRequestHeader(this.requestHeader), g.setWithCredentials(this.withCredentials);
+    const v = (_, w) => {
+      const p = u(_), R = new Blob([p], {
+        type: x(_)
+      }), q = URL.createObjectURL(R);
+      return new Promise((j, Y) => {
+        g.load(
+          q,
+          (V) => {
+            URL.revokeObjectURL(q), V.generateMipmaps = !1, V.magFilter = h.NearestFilter, V.minFilter = h.NearestFilter, V.flipY = !1, j(V);
+          },
+          void 0,
+          (V) => {
+            URL.revokeObjectURL(q);
+            const D = V instanceof Error ? V.message : String(V);
+            Y(
+              new Error(
+                `SOGS loader: failed to load ${w} from zip (${_}): ${D}`
+              )
+            );
+          }
+        );
+      });
+    };
+    if (!Array.isArray(f.sh0) || f.sh0.length < 1) throw new Error("SOGS loader: files.sh0 must have at least 1 entry (sh0)");
+    if (!Array.isArray(f.means) || f.means.length < 2) throw new Error("SOGS loader: files.means must have at least 2 entries (means_l, means_u)");
+    if (!Array.isArray(f.quats) || f.quats.length < 1) throw new Error("SOGS loader: files.quats must have at least 1 entry");
+    if (!Array.isArray(f.scales) || f.scales.length < 1) throw new Error("SOGS loader: files.scales must have at least 1 entry");
+    const [b, E, T, P, H] = await Promise.all([
+      v(f.means[0], "means_l"),
+      v(f.means[1], "means_u"),
+      v(f.quats[0], "quats"),
+      v(f.scales[0], "scales"),
+      v(f.sh0[0], "sh0")
+    ]), L = { means_l: b, means_u: E, quats: T, scales: P, sh0: H }, A = new Fe(m, y, L), C = Ce.packSogs(A);
+    return A.dispose(), C;
+  }
+}
+class At extends h.EventDispatcher {
   constructor() {
     super();
-    f(this, "worker");
-    f(this, "centers", null);
-    f(this, "orderTexture", null);
+    M(this, "worker");
+    M(this, "centers", null);
+    M(this, "orderTexture", null);
     /** Bounding box data for optimization */
-    f(this, "chunks", null);
-    f(this, "lastCameraPosition", new l.Vector3());
-    f(this, "lastCameraDirection", new l.Vector3());
-    const o = this.createWorkerCode(), t = new Blob([o], { type: "application/javascript" });
-    this.worker = new Worker(URL.createObjectURL(t)), this.worker.onmessage = this.onWorkerMessage.bind(this);
+    M(this, "chunks", null);
+    M(this, "lastCameraPosition", new h.Vector3());
+    M(this, "lastCameraDirection", new h.Vector3());
+    const t = this.createWorkerCode(), r = new Blob([t], { type: "application/javascript" });
+    this.worker = new Worker(URL.createObjectURL(r)), this.worker.onmessage = this.onWorkerMessage.bind(this);
   }
   /**
    * Handles messages received from the sorting worker.
    * @param event The message event from the worker.
    */
-  onWorkerMessage(o) {
+  onWorkerMessage(t) {
     if (!this.orderTexture || !this.orderTexture.image)
       return console.error("SplatSorter: Order texture not initialized!");
-    const { order: t, count: r } = o.data, n = this.orderTexture.image.data;
-    if (!(n instanceof Uint32Array))
+    const { order: r, count: s } = t.data, a = this.orderTexture.image.data;
+    if (!(a instanceof Uint32Array))
       return console.error(
         "SplatSorter: Order texture data is not a Uint32Array!"
       );
-    n.set(new Uint32Array(t)), this.orderTexture.source.data.updateRanges || (this.orderTexture.source.data.updateRanges = []), this.orderTexture.needsUpdate = !0;
-    const a = n.buffer.slice(0), i = { order: a };
-    this.worker.postMessage(i, [a]), this.dispatchEvent({ type: "updated", count: r });
+    a.set(new Uint32Array(r)), this.orderTexture.source.data.updateRanges || (this.orderTexture.source.data.updateRanges = []), this.orderTexture.needsUpdate = !0;
+    const o = a.buffer.slice(0), i = { order: o };
+    this.worker.postMessage(i, [o]), this.dispatchEvent({ type: "updated", count: s });
   }
   /**
    * Initializes the sorter with necessary data and textures.
@@ -801,38 +1529,38 @@ class Pe extends l.EventDispatcher {
    * @param chunks Optional: A Float32Array containing bounding box chunk data [minX, minY, minZ, maxX, maxY, maxZ, ...] for optimization.
    * @param transferOwnership Optional: If true, transfers ownership of centers buffer to worker (saves memory, main thread loses access). Default: false.
    */
-  init(o, t, r, n = !1) {
-    if (!o || !(o.image.data instanceof Uint32Array))
+  init(t, r, s, a = !1) {
+    if (!t || !(t.image.data instanceof Uint32Array))
       throw new Error("SplatSorter: Invalid orderTexture provided. Must be DataTexture with Uint32Array data.");
-    if (!t || t.length % 3 !== 0)
+    if (!r || r.length % 3 !== 0)
       throw new Error("SplatSorter: Invalid centers array provided. Length must be multiple of 3.");
-    if (o.image.data.length < t.length / 3)
+    if (t.image.data.length < r.length / 3)
       throw new Error("SplatSorter: orderTexture data buffer is smaller than the number of splats.");
-    if (t.buffer.byteLength === 0)
+    if (r.buffer.byteLength === 0)
       throw new Error(
         "SplatSorter: positions buffer is detached (likely React StrictMode + cached asset). "
       );
-    const a = t.length / 3;
-    this.orderTexture = o, n ? this.centers = null : this.centers = t.slice();
+    const o = r.length / 3;
+    this.orderTexture = t, a ? this.centers = null : this.centers = r.slice();
     const i = this.orderTexture.image.data;
-    for (let h = 0; h < a; h++) i[h] = h;
+    for (let u = 0; u < o; u++) i[u] = u;
     this.orderTexture.source.data.updateRanges || (this.orderTexture.source.data.updateRanges = []), this.orderTexture.needsUpdate = !0;
-    const u = i.buffer.slice(0), w = n ? t.buffer : t.buffer.slice(0), C = {
-      order: u,
-      centers: w
-    }, _ = [
-      u,
-      w
+    const m = i.buffer.slice(0), f = a ? r.buffer : r.buffer.slice(0), y = {
+      order: m,
+      centers: f
+    }, l = [
+      m,
+      f
     ];
-    if (r) {
-      this.chunks = r.slice();
-      const h = this.chunks.buffer.slice(0);
-      C.chunks = h, _.push(h);
+    if (s) {
+      this.chunks = s.slice();
+      const u = this.chunks.buffer.slice(0);
+      y.chunks = u, l.push(u);
     }
-    this.worker.postMessage(C, _), queueMicrotask(() => {
+    this.worker.postMessage(y, l), queueMicrotask(() => {
       this.dispatchEvent({
         type: "updated",
-        count: a
+        count: o
       });
     });
   }
@@ -841,53 +1569,53 @@ class Pe extends l.EventDispatcher {
    * The sorter will only consider splats whose original indices are present in the mapping.
    * @param mapping A Uint32Array where each element is the *original* index of a splat to include, or null to reset mapping.
    */
-  setMapping(o) {
+  setMapping(t) {
     if (!this.centers)
       return console.warn(
         "SplatSorter: Cannot set mapping before initialization."
       );
-    let t;
-    const r = [];
-    if (!o) {
-      const u = this.centers.buffer.slice(0);
-      return t = {
-        centers: u,
+    let r;
+    const s = [];
+    if (!t) {
+      const m = this.centers.buffer.slice(0);
+      return r = {
+        centers: m,
         mapping: null
-      }, r.push(u), this.worker.postMessage(t, r);
+      }, s.push(m), this.worker.postMessage(r, s);
     }
-    const n = new Float32Array(o.length * 3);
-    for (let u = 0; u < o.length; u++) {
-      const w = o[u];
-      if (w * 3 + 2 >= this.centers.length) {
+    const a = new Float32Array(t.length * 3);
+    for (let m = 0; m < t.length; m++) {
+      const f = t[m];
+      if (f * 3 + 2 >= this.centers.length) {
         console.warn(
-          `SplatSorter: Mapping index ${w} out of bounds.`
+          `SplatSorter: Mapping index ${f} out of bounds.`
         );
         continue;
       }
-      const C = w * 3, _ = u * 3;
-      n[_ + 0] = this.centers[C + 0], n[_ + 1] = this.centers[C + 1], n[_ + 2] = this.centers[C + 2];
+      const y = f * 3, l = m * 3;
+      a[l + 0] = this.centers[y + 0], a[l + 1] = this.centers[y + 1], a[l + 2] = this.centers[y + 2];
     }
-    const a = n.buffer.slice(0), i = o.buffer.slice(0);
-    t = {
-      centers: a,
+    const o = a.buffer.slice(0), i = t.buffer.slice(0);
+    r = {
+      centers: o,
       mapping: i
-    }, r.push(a, i), this.worker.postMessage(t, r);
+    }, s.push(o, i), this.worker.postMessage(r, s);
   }
   /**
    * Updates the camera parameters used for sorting.
    * @param position The camera's position in the sorter's local coordinate space.
    * @param direction The camera's forward direction in the sorter's local coordinate space.
    */
-  setCamera(o, t) {
-    const r = this.lastCameraPosition.distanceToSquared(o) > 1e-7, n = this.lastCameraDirection.dot(t) < 0.9999;
-    if (!r && !n)
+  setCamera(t, r) {
+    const s = this.lastCameraPosition.distanceToSquared(t) > 1e-7, a = this.lastCameraDirection.dot(r) < 0.9999;
+    if (!s && !a)
       return;
-    this.lastCameraPosition.copy(o), this.lastCameraDirection.copy(t);
-    const a = {
-      cameraPosition: { x: o.x, y: o.y, z: o.z },
-      cameraDirection: { x: t.x, y: t.y, z: t.z }
+    this.lastCameraPosition.copy(t), this.lastCameraDirection.copy(r);
+    const o = {
+      cameraPosition: { x: t.x, y: t.y, z: t.z },
+      cameraDirection: { x: r.x, y: r.y, z: r.z }
     };
-    this.worker.postMessage(a);
+    this.worker.postMessage(o);
   }
   /**
    * Terminates the Web Worker and cleans up resources.
@@ -901,258 +1629,186 @@ class Pe extends l.EventDispatcher {
    */
   createWorkerCode() {
     return `(${(function() {
-      let t = null, r = null, n = null, a = null, i = null, u = null, w = !1;
-      const C = { x: 0, y: 0, z: 0 }, _ = { x: 0, y: 0, z: 0 }, h = { x: 0, y: 0, z: 0 }, b = { x: 0, y: 0, z: 0 };
-      let S = null, I = null;
-      const P = 32, j = new Array(P).fill(0), H = new Array(P).fill(0), W = new Array(P).fill(0), oe = (A, g, D) => {
-        for (; A <= g; ) {
-          const T = g + A >> 1, v = D(T);
-          if (v > 0) A = T + 1;
-          else if (v < 0) g = T - 1;
-          else return T;
+      let r = null, s = null, a = null, o = null, i = null, m = null, f = !1;
+      const y = { x: 0, y: 0, z: 0 }, l = { x: 0, y: 0, z: 0 }, u = { x: 0, y: 0, z: 0 }, x = { x: 0, y: 0, z: 0 };
+      let g = null, v = null;
+      const b = 32, E = new Array(b).fill(0), T = new Array(b).fill(0), P = new Array(b).fill(0), H = (A, C, _) => {
+        for (; A <= C; ) {
+          const w = C + A >> 1, p = _(w);
+          if (p > 0) A = w + 1;
+          else if (p < 0) C = w - 1;
+          else return w;
         }
         return ~A;
       }, L = () => {
-        if (!t || !r || !i || !u)
+        if (!r || !s || !i || !m)
           return;
-        if (r.length === 0) {
-          const c = {
-            order: t.buffer,
+        if (s.length === 0) {
+          const d = {
+            order: r.buffer,
             count: 0
           };
-          self.postMessage(c, [t.buffer]), t = null;
+          self.postMessage(d, [r.buffer]), r = null;
           return;
         }
-        const A = i.x, g = i.y, D = i.z, T = u.x, v = u.y, R = u.z, B = 1e-4, $ = Math.abs(A - C.x) > B || Math.abs(g - C.y) > B || Math.abs(D - C.z) > B, X = Math.abs(T - _.x) > B || Math.abs(v - _.y) > B || Math.abs(R - _.z) > B;
-        if (!w && !$ && !X)
+        const A = i.x, C = i.y, _ = i.z, w = m.x, p = m.y, R = m.z, q = 1e-4, j = Math.abs(A - y.x) > q || Math.abs(C - y.y) > q || Math.abs(_ - y.z) > q, Y = Math.abs(w - l.x) > q || Math.abs(p - l.y) > q || Math.abs(R - l.z) > q;
+        if (!f && !j && !Y)
           return;
-        w = !1, C.x = A, C.y = g, C.z = D, _.x = T, _.y = v, _.z = R;
-        let Z = 1 / 0, U = -1 / 0;
-        for (let c = 0; c < 8; ++c) {
-          const y = c & 1 ? h.x : b.x, z = c & 2 ? h.y : b.y, d = c & 4 ? h.z : b.z, k = y * T + z * v + d * R;
-          Z = Math.min(Z, k), U = Math.max(U, k);
+        f = !1, y.x = A, y.y = C, y.z = _, l.x = w, l.y = p, l.z = R;
+        let V = 1 / 0, D = -1 / 0;
+        for (let d = 0; d < 8; ++d) {
+          const z = d & 1 ? u.x : x.x, W = d & 2 ? u.y : x.y, S = d & 4 ? u.z : x.z, U = z * w + W * p + S * R;
+          V = Math.min(V, U), D = Math.max(D, U);
         }
-        const F = r.length / 3, N = U - Z, s = (1 << Math.max(
+        const O = s.length / 3, J = D - V, c = (1 << Math.max(
           10,
-          Math.min(20, Math.ceil(Math.log2(F / 4)))
+          Math.min(20, Math.ceil(Math.log2(O / 4)))
         )) + 1;
-        if ((!S || S.length !== F) && (S = new Uint32Array(F)), !I || I.length !== s ? I = new Uint32Array(s) : I.fill(0), N < 1e-7) {
-          for (let c = 0; c < F; ++c) S[c] = 0;
-          I[0] = F;
-        } else if (n && n.length > 0) {
-          const c = n.length / 6;
-          j.fill(0);
-          for (let d = 0; d < c; ++d) {
-            const k = d * 6, O = n[k + 0], q = n[k + 1], G = n[k + 2], V = n[k + 3], Y = O * T + q * v + G * R - Z, K = Y - V, Q = Y + V, re = Math.max(
+        if ((!g || g.length !== O) && (g = new Uint32Array(O)), !v || v.length !== c ? v = new Uint32Array(c) : v.fill(0), J < 1e-7) {
+          for (let d = 0; d < O; ++d) g[d] = 0;
+          v[0] = O;
+        } else if (a && a.length > 0) {
+          const d = a.length / 6;
+          E.fill(0);
+          for (let S = 0; S < d; ++S) {
+            const U = S * 6, $ = a[U + 0], X = a[U + 1], Q = a[U + 2], Z = a[U + 3], K = $ * w + X * p + Q * R - V, re = K - Z, se = K + Z, ue = Math.max(
               0,
-              Math.floor(K * P / N)
-            ), ne = Math.min(
-              P,
-              Math.ceil(Q * P / N)
+              Math.floor(re * b / J)
+            ), he = Math.min(
+              b,
+              Math.ceil(se * b / J)
             );
-            for (let J = re; J < ne; ++J)
-              j[J]++;
+            for (let oe = ue; oe < he; ++oe)
+              E[oe]++;
           }
-          let y = 0;
-          for (let d = 0; d < P; ++d) y += j[d];
-          W[0] = 0, H[0] = 0;
-          for (let d = 1; d < P; ++d)
-            W[d - 1] = j[d - 1] / y * s >>> 0, H[d] = H[d - 1] + W[d - 1];
-          W[P - 1] = j[P - 1] / y * s >>> 0;
-          const z = N / P;
-          for (let d = 0; d < F; ++d) {
-            const k = d * 3, O = r[k + 0], q = r[k + 1], G = r[k + 2], V = O * T + q * v + G * R, K = (U - V) / z, Q = Math.max(
+          let z = 0;
+          for (let S = 0; S < b; ++S) z += E[S];
+          P[0] = 0, T[0] = 0;
+          for (let S = 1; S < b; ++S)
+            P[S - 1] = E[S - 1] / z * c >>> 0, T[S] = T[S - 1] + P[S - 1];
+          P[b - 1] = E[b - 1] / z * c >>> 0;
+          const W = J / b;
+          for (let S = 0; S < O; ++S) {
+            const U = S * 3, $ = s[U + 0], X = s[U + 1], Q = s[U + 2], Z = $ * w + X * p + Q * R, re = (D - Z) / W, se = Math.max(
               0,
               Math.min(
-                P - 1,
-                Math.floor(K)
+                b - 1,
+                Math.floor(re)
               )
-            ), re = K - Q, ne = H[Q] + W[Q] * re >>> 0, J = Math.min(ne, s - 1);
-            S[d] = J, I[J]++;
+            ), ue = re - se, he = T[se] + P[se] * ue >>> 0, oe = Math.min(he, c - 1);
+            g[S] = oe, v[oe]++;
           }
         } else {
-          const c = (s - 1) / N;
-          for (let y = 0; y < F; ++y) {
-            const z = y * 3, d = r[z + 0], k = r[z + 1], O = r[z + 2], q = d * T + k * v + O * R, V = (U - q) * c >>> 0, Y = Math.min(V, s - 1);
-            S[y] = Y, I[Y]++;
+          const d = (c - 1) / J;
+          for (let z = 0; z < O; ++z) {
+            const W = z * 3, S = s[W + 0], U = s[W + 1], $ = s[W + 2], X = S * w + U * p + $ * R, Z = (D - X) * d >>> 0, K = Math.min(Z, c - 1);
+            g[z] = K, v[K]++;
           }
         }
-        for (let c = 1; c < s; c++)
-          I[c] += I[c - 1];
-        for (let c = F - 1; c >= 0; c--) {
-          const y = S[c], z = --I[y];
-          t[z] = a ? a[c] : c;
+        for (let d = 1; d < c; d++)
+          v[d] += v[d - 1];
+        for (let d = O - 1; d >= 0; d--) {
+          const z = g[d], W = --v[z];
+          r[W] = o ? o[d] : d;
         }
-        const p = A * T + g * v + D * R, M = (c) => {
-          if (!t) return -1 / 0;
-          const y = t[c], z = y;
-          if (!r || z * 3 + 2 >= r.length)
+        const k = A * w + C * p + _ * R, B = (d) => {
+          if (!r) return -1 / 0;
+          const z = r[d], W = z;
+          if (!s || W * 3 + 2 >= s.length)
             return -1 / 0;
-          const d = z * 3;
-          return r[d] * T + r[d + 1] * v + r[d + 2] * R - p;
+          const S = W * 3;
+          return s[S] * w + s[S + 1] * p + s[S + 2] * R - k;
         };
-        let E = F;
-        if (F > 0 && M(F - 1) < 0) {
-          const c = oe(
+        let F = O;
+        if (O > 0 && B(O - 1) < 0) {
+          const d = H(
             0,
-            F - 1,
-            M
+            O - 1,
+            B
           );
-          E = c < 0 ? ~c : c;
+          F = d < 0 ? ~d : d;
         }
-        const m = {
-          order: t.buffer,
-          count: E
+        const I = {
+          order: r.buffer,
+          count: F
         };
-        self.postMessage(m, [t.buffer]), t = null;
+        self.postMessage(I, [r.buffer]), r = null;
       };
       self.onmessage = (A) => {
-        const g = A.data;
-        g.order && (t = new Uint32Array(g.order));
-        let D = !1;
-        if (g.centers && (r = new Float32Array(g.centers), D = !0, w = !0), Object.prototype.hasOwnProperty.call(g, "mapping") && (a = g.mapping ? new Uint32Array(g.mapping) : null, w = !0), g.chunks) {
-          if (n = new Float32Array(g.chunks), n.length > 0 && n[3] > 0)
-            for (let T = 0; T < n.length / 6; ++T) {
-              const v = T * 6, R = n[v + 0], B = n[v + 1], $ = n[v + 2], X = n[v + 3], Z = n[v + 4], U = n[v + 5];
-              n[v + 0] = (R + X) * 0.5, n[v + 1] = (B + Z) * 0.5, n[v + 2] = ($ + U) * 0.5, n[v + 3] = Math.sqrt(
-                (X - R) ** 2 + (Z - B) ** 2 + (U - $) ** 2
+        const C = A.data;
+        C.order && (r = new Uint32Array(C.order));
+        let _ = !1;
+        if (C.centers && (s = new Float32Array(C.centers), _ = !0, f = !0), Object.prototype.hasOwnProperty.call(C, "mapping") && (o = C.mapping ? new Uint32Array(C.mapping) : null, f = !0), C.chunks) {
+          if (a = new Float32Array(C.chunks), a.length > 0 && a[3] > 0)
+            for (let w = 0; w < a.length / 6; ++w) {
+              const p = w * 6, R = a[p + 0], q = a[p + 1], j = a[p + 2], Y = a[p + 3], V = a[p + 4], D = a[p + 5];
+              a[p + 0] = (R + Y) * 0.5, a[p + 1] = (q + V) * 0.5, a[p + 2] = (j + D) * 0.5, a[p + 3] = Math.sqrt(
+                (Y - R) ** 2 + (V - q) ** 2 + (D - j) ** 2
               ) * 0.5;
             }
-          w = !0;
+          f = !0;
         }
-        if (D && r && r.length > 0) {
-          h.x = b.x = r[0], h.y = b.y = r[1], h.z = b.z = r[2];
-          for (let T = 1; T < r.length / 3; T++) {
-            const v = T * 3;
-            h.x = Math.min(h.x, r[v + 0]), b.x = Math.max(b.x, r[v + 0]), h.y = Math.min(h.y, r[v + 1]), b.y = Math.max(b.y, r[v + 1]), h.z = Math.min(h.z, r[v + 2]), b.z = Math.max(b.z, r[v + 2]);
+        if (_ && s && s.length > 0) {
+          u.x = x.x = s[0], u.y = x.y = s[1], u.z = x.z = s[2];
+          for (let w = 1; w < s.length / 3; w++) {
+            const p = w * 3;
+            u.x = Math.min(u.x, s[p + 0]), x.x = Math.max(x.x, s[p + 0]), u.y = Math.min(u.y, s[p + 1]), x.y = Math.max(x.y, s[p + 1]), u.z = Math.min(u.z, s[p + 2]), x.z = Math.max(x.z, s[p + 2]);
           }
-        } else D && r && r.length === 0 && (h.x = b.x = h.y = b.y = h.z = b.z = 0);
-        g.cameraPosition && (i = g.cameraPosition), g.cameraDirection && (u = g.cameraDirection), L();
+        } else _ && s && s.length === 0 && (u.x = x.x = u.y = x.y = u.z = x.z = 0);
+        C.cameraPosition && (i = C.cameraPosition), C.cameraDirection && (m = C.cameraDirection), L();
       };
     }).toString()})();`;
   }
 }
-const Be = (x, e) => {
-  const o = ye(x), t = ye(e);
-  return o | t << 16;
-};
-function ye(x) {
-  const e = new Float32Array([x]), t = new Int32Array(e.buffer)[0];
-  let r = t >> 16 & 32768, n = t >> 12 & 2047;
-  const a = t >> 23 & 255;
-  return a < 103 ? r : a > 142 ? (r |= 31744, r |= (a === 255 ? 0 : 1) && t & 8388607, r) : a < 113 ? (n |= 2048, r |= (n >> 114 - a) + (n >> 113 - a & 1), r) : (r |= a - 112 << 10 | n >> 1, r += n & 1, r);
-}
-const Fe = new ArrayBuffer(4), ve = new DataView(Fe), Oe = (x) => (ve.setUint32(0, x, !0), ve.getFloat32(0, !0));
-class De {
-  /**
-   * Create a new TextureManager for a set of splats
-   * @param splatData The splat data to manage textures for
-   */
+class kt {
   constructor(e) {
-    f(this, "textureWidth");
-    f(this, "textureHeight");
-    f(this, "transformA");
-    // position xyz and rotation quaternion y,z components
-    f(this, "transformB");
-    // rotation quaternion x and scale xyz
-    f(this, "colorTexture");
-    // color an opacity
-    f(this, "orderTexture");
-    const o = e.numSplats;
-    this.textureWidth = Math.ceil(Math.sqrt(o)), this.textureHeight = Math.ceil(o / this.textureWidth), this.transformA = this.createTransformATexture(e), this.transformB = this.createTransformBTexture(e), this.colorTexture = this.createColorTexture(e), this.orderTexture = this.createOrderTexture(o);
-  }
-  /**
-   * Create the transform A texture (positions and quaternion w component)
-   * @param splatData The splat data
-   * @returns DataTexture containing position data
-   */
-  createTransformATexture(e) {
-    const o = e.numSplats, t = new Float32Array(
-      this.textureWidth * this.textureHeight * 4
-    );
-    for (let n = 0; n < o; n++) {
-      const a = n * 4, i = n * 3, u = n * 4;
-      t[a] = e.positions[i], t[a + 1] = e.positions[i + 1], t[a + 2] = e.positions[i + 2];
-      const w = e.rotations[u + 0], C = e.rotations[u + 1], _ = Be(w, C);
-      t[a + 3] = Oe(_);
-    }
-    const r = new l.DataTexture(
-      t,
-      this.textureWidth,
-      this.textureHeight,
-      l.RGBAFormat,
-      l.FloatType
-      // Store as Float32, shader will reinterpret bits
-    );
-    return r.magFilter = l.NearestFilter, r.minFilter = l.NearestFilter, r.source.data.updateRanges || (r.source.data.updateRanges = []), r.needsUpdate = !0, r;
+    M(this, "packedGeometry");
+    // RGBA32UI
+    M(this, "packedColor");
+    // RGBA8
+    M(this, "orderTexture");
+    // RB32UI
+    M(this, "width");
+    M(this, "height");
+    this.width = e.textureWidth, this.height = e.textureHeight, this.packedColor = this.createColorTexture(e), this.packedGeometry = this.createGeometryTexture(e), this.orderTexture = this.createOrderTexture(e.numSplats);
   }
-  /**
-   * Create the transform B texture (scale and rotation xyz)
-   * @param splatData The splat data
-   * @returns DataTexture containing scale and rotation data
-   */
-  createTransformBTexture(e) {
-    const o = e.numSplats, t = new Float32Array(
-      this.textureWidth * this.textureHeight * 4
-    );
-    for (let n = 0; n < o; n++) {
-      const a = n * 4, i = n * 3, u = n * 4;
-      t[a] = e.scales[i], t[a + 1] = e.scales[i + 1], t[a + 2] = e.scales[i + 2], t[a + 3] = e.rotations[u + 2];
-    }
-    const r = new l.DataTexture(
-      t,
-      this.textureWidth,
-      this.textureHeight,
-      l.RGBAFormat,
-      l.FloatType
+  createGeometryTexture(e) {
+    const t = new h.DataTexture(
+      e.packedGeometry,
+      this.width,
+      this.height,
+      h.RGBAIntegerFormat,
+      h.UnsignedIntType
     );
-    return r.magFilter = l.NearestFilter, r.minFilter = l.NearestFilter, r.source.data.updateRanges || (r.source.data.updateRanges = []), r.needsUpdate = !0, r;
+    return t.internalFormat = "RGBA32UI", t.minFilter = h.NearestFilter, t.magFilter = h.NearestFilter, t.needsUpdate = !0, t;
   }
-  /**
-   * Create the color texture (RGB and opacity)
-   * @param splatData The splat data
-   * @returns DataTexture containing color data
-   */
   createColorTexture(e) {
-    const o = e.numSplats, t = new Float32Array(
-      this.textureWidth * this.textureHeight * 4
-    );
-    for (let n = 0; n < o; n++) {
-      const a = n * 4, i = n * 3;
-      t[a] = e.colors[i], t[a + 1] = e.colors[i + 1], t[a + 2] = e.colors[i + 2], t[a + 3] = e.opacities[n];
-    }
-    const r = new l.DataTexture(
-      t,
-      this.textureWidth,
-      this.textureHeight,
-      l.RGBAFormat,
-      l.FloatType
+    const t = new h.DataTexture(
+      e.packedColor,
+      this.width,
+      this.height,
+      h.RGBAFormat,
+      h.UnsignedByteType
     );
-    return r.source.data.updateRanges || (r.source.data.updateRanges = []), r.needsUpdate = !0, r;
+    return t.minFilter = h.NearestFilter, t.magFilter = h.NearestFilter, t.needsUpdate = !0, t;
   }
-  /**
-   * Create the order texture for sorting
-   * @param numSplats Number of splats
-   * @returns DataTexture for storing order indices
-   */
   createOrderTexture(e) {
-    const o = new Uint32Array(this.textureWidth * this.textureHeight);
-    for (let r = 0; r < e; r++)
-      o[r] = r;
-    const t = new l.DataTexture(
-      o,
-      this.textureWidth,
-      this.textureHeight,
-      l.RedIntegerFormat,
-      l.UnsignedIntType
+    const t = new Uint32Array(this.width * this.height);
+    for (let s = 0; s < e; s++) t[s] = s;
+    const r = new h.DataTexture(
+      t,
+      this.width,
+      this.height,
+      h.RedIntegerFormat,
+      h.UnsignedIntType
     );
-    return t.source.data.updateRanges || (t.source.data.updateRanges = []), t.needsUpdate = !0, t;
+    return r.minFilter = h.NearestFilter, r.magFilter = h.NearestFilter, r.needsUpdate = !0, r;
   }
   dispose() {
-    this.transformA.dispose(), this.transformB.dispose(), this.colorTexture.dispose(), this.orderTexture.dispose();
+    this.packedGeometry.dispose(), this.packedColor.dispose(), this.orderTexture.dispose();
   }
 }
-const Ue = (
+const Et = (
   /* glsl */
   `
 precision highp float;
@@ -1160,55 +1816,47 @@ precision highp int;
 precision highp usampler2D;
 precision highp sampler2D;
 
-// --- Uniforms (Provided by Three.js) ---
-// uniform mat4 modelViewMatrix; // Don't redeclare
-// uniform mat4 projectionMatrix; // Don't redeclare
-uniform vec2 viewport;          // Viewport dimensions (width, height)
-uniform uint numSplats;         // Total number of splats potentially renderable by sorter
+uniform int texWidth;
+uniform vec2 viewport;
+uniform uint numSplats;
 
-// Textures
-uniform highp sampler2D transformA;   // vec4: pos.xyz, packed_rot.yz
-uniform highp sampler2D transformB;   // vec4: log_scale.xyz, rot.x
-uniform highp sampler2D splatColor;   // vec4: color.rgb, opacity
-uniform highp usampler2D splatOrder;  // uint: original splat index
+// --- Unified Packed Textures ---
+uniform usampler2D packedGeometry; // RGBA32UI: Geometry (Pos, Rot, Scale)
+uniform sampler2D packedColor;    // RGBA8: Color (RGB) + Opacity (A)
+uniform usampler2D splatOrder;    // R32UI: Sort Index
 
-// --- Attributes ---
-// Instancing attribute: base index for this block of splats
-attribute uint splatInstanceIndex;
+// --- Decompression Ranges ---
+uniform vec3 meansMin;
+uniform vec3 meansMax;
+uniform vec3 scalesMin;
+uniform vec3 scalesMax;
+uniform vec3 sh0Min;
+uniform vec3 sh0Max;
 
-// Per-vertex attribute of the quad (Built-in, don't redeclare 'position')
-// attribute vec3 position; // Use the built-in 'position'
-// position.xy: corner coords (-1..1)
-// position.z: index within the instance block (0..INSTANCE_BUFFER_SIZE-1)
+// --- Attributes ---
+in uint splatInstanceIndex;
 
-// --- Varyings ---
-varying vec4 vColor;
-varying vec2 vUv; // For gaussian calculation in fragment shader
+// --- Outputs ---
+out vec4 vColor;
+out vec2 vUv;
 
 // --- Constants ---
-#define INSTANCE_BUFFER_SIZE 128.0 // Must match the size in SplatMesh
+const vec4 DISCARD_VERTEX = vec4(0.0, 0.0, 2.0, 1.0);
+const float SH_C0 = 0.28209479177387814; // 1/(2*sqrt(pi))
+const float QUAT_NORM = 1.41421356237; // sqrt(2)
 
 // --- Helper Functions ---
 
-// Use GLSL built-in unpackHalf2x16 for proper half-float unpacking
-
-// Reconstruct quaternion from packed components (xy_packed, z)
-// Returns (w,x,y,z) format for quatToMat3 compatibility  
-vec4 unpackRotation(float xy_packed, float z) {
-    vec2 xy = unpackHalf2x16(floatBitsToUint(xy_packed));
-    float x = xy.x;
-    float y = xy.y;
-    float w_squared = 1.0 - x*x - y*y - z*z;
-    float w = (w_squared < 0.0) ? 0.0 : sqrt(w_squared);
-    return vec4(w, x, y, z); // Return (w,x,y,z) 
+// Extract raw bytes as integers (no /255 )
+uvec4 unpackBytes(uint v) {
+    return (uvec4(v) >> uvec4(24u, 16u, 8u, 0u)) & 0xffu;
 }
 
-// Convert quaternion to 3x3 rotation matrix
 mat3 quatToMat3(vec4 R) {
     vec4 R2 = R + R;
     float X = R2.x * R.w;
-    vec4 Y  = R2.y * R;
-    vec4 Z  = R2.z * R;
+    vec4 Y = R2.y * R;
+    vec4 Z = R2.z * R;
     float W = R2.w * R.w;
 
     return mat3(
@@ -1224,199 +1872,176 @@ mat3 quatToMat3(vec4 R) {
     );
 }
 
-// Calculate model-space covariance components
 void getModelCovariance(vec3 scale, vec4 rotation, out vec3 covA, out vec3 covB) {
     mat3 rot = quatToMat3(rotation);
-    
-    // M = S * R (scale COLUMNS, then transpose)
     mat3 M = transpose(mat3(
-        scale.x * rot[0],  // scale.x * column 0
-        scale.y * rot[1],  // scale.y * column 1
-        scale.z * rot[2]   // scale.z * column 2
+        scale.x * rot[0],
+        scale.y * rot[1],
+        scale.z * rot[2]
     ));
 
     covA = vec3(dot(M[0], M[0]), dot(M[0], M[1]), dot(M[0], M[2]));
     covB = vec3(dot(M[1], M[1]), dot(M[1], M[2]), dot(M[2], M[2]));
 }
 
-// --- Main Function ---
-void main(void) {
-    // Calculate the final splat index for this vertex
-    uint instanceOffset = uint(position.z); // Read index within instance from Z
-    uint orderedSplatIndex = splatInstanceIndex + instanceOffset;
+// --- Main ---
+void main() {
+    // Calculate Instance ID & Source Data UV
+    uint instanceOffset = uint(position.z);
+    uint orderIndex = splatInstanceIndex + instanceOffset;
 
-    // Discard if this splat index is beyond the sorted count
-    if (orderedSplatIndex >= numSplats) {
-        gl_Position = vec4(2.0, 2.0, 2.0, 1.0); // Off-screen
+    if (orderIndex >= numSplats) {
+        gl_Position = DISCARD_VERTEX;
         return;
     }
 
-    // --- Source Data Lookup ---
-    uint texWidth = uint(textureSize(splatOrder, 0).x);
-    ivec2 orderUV = ivec2(orderedSplatIndex % texWidth, orderedSplatIndex / texWidth);
-    uint originalSplatIndex = texelFetch(splatOrder, orderUV, 0).r;
+    uint w = uint(texWidth);
+    ivec2 orderUV = ivec2(int(orderIndex % w), int(orderIndex / w));
 
-    ivec2 dataUV = ivec2(originalSplatIndex % texWidth, originalSplatIndex / texWidth);
+    // Fetch original splat ID from the order texture
+    uint splatID = texelFetch(splatOrder, orderUV, 0).r;
+    ivec2 dataUV = ivec2(int(splatID % w), int(splatID / w));
 
-    // Fetch data from textures
-    vec4 texTransformA = texelFetch(transformA, dataUV, 0);
-    vec4 texTransformB = texelFetch(transformB, dataUV, 0);
-    vec4 texColor = texelFetch(splatColor, dataUV, 0);
+    // Fetch Packed Data
+    // x: Means Low, y: Means High, z: Rotation, w: Scale
+    uvec4 geom = texelFetch(packedGeometry, dataUV, 0); 
+    vec4 colorRaw = texelFetch(packedColor, dataUV, 0);
 
-    vec3 splatPosition = texTransformA.xyz;
-    vec3 splatLogScale = texTransformB.xyz; // Assume stored as log scale
-    vec4 splatRotation = unpackRotation(texTransformA.w, texTransformB.w); // Unpack rot xy, z
-    vec3 splatColor = texColor.rgb;
-    float splatOpacity = texColor.a;
+    // Decompress Position (Means) (assume world-space)
+    // Reconstruct 16-bit values from two 8-bit channels
+    uvec3 lo = unpackBytes(geom.x).xyz;
+    uvec3 hi = unpackBytes(geom.y).xyz;
 
-    vec3 splatScale = exp(splatLogScale); // Convert log scale to actual scale
+    // (hi << 8) | lo  => 0..65535  then normalize
+    vec3 meansNorm = vec3((hi << 8u) | lo) * (1.0 / 65535.0);
+    vec3 modelCenter = mix(meansMin, meansMax, meansNorm);
 
-    // --- Center Projection ---
+    // Decompress Rotation (Quaternions)
+    uvec4 qB = unpackBytes(geom.z);
+    vec3 abc = (vec3(qB.xyz) * (1.0 / 255.0) - 0.5) * QUAT_NORM;
+    float d = sqrt(max(0.0, 1.0 - dot(abc, abc)));
+    uint mode = qB.w; // already 0..3
 
-    // Compute normalized view-space center
-    vec4 centerClipRaw = modelViewMatrix * vec4(splatPosition, 1.0);
-    vec3 centerView  = centerClipRaw.xyz / centerClipRaw.w;
 
-    // Early out if splat is behind the camera
-    if (centerView.z > -0.2) { // Use small epsilon
-        gl_Position = vec4(2.0, 2.0, 2.0, 1.0);
-        return;
-    }
+    // Reconstruct Quaternion (x, y, z, w)
+    // quat in (w,x,y,z)
+    vec4 quat;
+    if (mode == 0u)      quat = vec4(d, abc);            // (w, x, y, z)
+    else if (mode == 1u) quat = vec4(abc.x, d, abc.yz);  // stored (w,y,z)
+    else if (mode == 2u) quat = vec4(abc.xy, d, abc.z);  // stored (w,x,z)
+    else                 quat = vec4(abc, d);            // stored (w,x,y)
 
-    // Project to clip space
-    vec4 centerClip = projectionMatrix * centerClipRaw;
+    // Decompress Scale
+    uvec3 sB = unpackBytes(geom.w).xyz;
+    vec3 sNorm = vec3(sB) * (1.0 / 255.0);
+    vec3 sLerp = mix(scalesMin, scalesMax, sNorm);
+    vec3 scale = exp(sLerp); // log scale stored
 
-    // --- Covariance Calculation & Projection ---
+    // Decompress Color & Opacity
+    vec4 clr;
+    vec3 sh = mix(sh0Min, sh0Max, colorRaw.rgb);
+    clr.rgb = vec3(0.5) + sh * SH_C0;
+    clr.a = colorRaw.a; // Opacity passed directly (linear or sigmoid handled by loader)
 
-    // Calculating model space covariance (Vrk)
+    // --- Standard Gaussian Splat Projection ---
+
+    // View Space Setup
+    mat4 modelView = modelViewMatrix;
+    vec4 centerView = modelView * vec4(modelCenter, 1.0);
+
+    // Cull behind camera
+    if (centerView.z > -0.2) {
+        gl_Position = DISCARD_VERTEX;
+        return;
+    }
+
+    // Covariance in 3D
     vec3 covA, covB;
-    getModelCovariance(splatScale, splatRotation, covA, covB);
-    mat3 Vrk = mat3(
-        covA.x, covA.y, covA.z,
-        covA.y, covB.x, covB.y, // covB.x is Vrk[1][1]
-        covA.z, covB.y, covB.z  // covB.y is Vrk[1][2], covB.z is Vrk[2][2]
-    );
+    getModelCovariance(scale, quat, covA, covB);
 
-    // Calculate Jacobian J (screen space change wrt view space change)
-    //    Requres focal lenghts and view-space center depth (tz)
+    // Project to 2D
     float focalX = viewport.x * projectionMatrix[0][0];
     float focalY = viewport.y * projectionMatrix[1][1];
-    float tz = centerView.z;
-    float tz2 = tz * tz;
+    float J1 = focalX / centerView.z;
+    vec2 J2 = -J1 / centerView.z * centerView.xy;
 
-    // Jacobian J = [fx/tz,  0,    -fx*tx/tz^2]
-    //              [0,     fy/tz, -fy*ty/tz^2]
     mat3 J = mat3(
-        focalX / tz,     0.0,  -focalX * centerView.x / tz2,
-        0.0,     focalY / tz,  -focalY * centerView.y / tz2,
-        0.0,             0.0,                0.0
+        J1,   0.0,  J2.x,
+        0.0,  J1,   J2.y,
+        0.0,  0.0,  0.0
     );
 
-    // Calculate W 
-    mat3 W = transpose(mat3(modelViewMatrix));
-    // Calculate T = W * J
+    mat3 W = transpose(mat3(modelView));
     mat3 T = W * J;
-    // Calculate Projected 2D Covariance: SigmaProj = transpose(T) * Vrk * T
-    mat3 SigmaProj = transpose(T) * Vrk * T;
-
-    // Extract 2D components and add bias
-    float cov2D_11 = SigmaProj[0][0] + 0.3;
-    float cov2D_12 = SigmaProj[0][1];
-    float cov2D_22 = SigmaProj[1][1] + 0.3;
-
-    // --- Calculate 2D Screen Space Rotation & Scale ---
-
-    float det = cov2D_11 * cov2D_22 - cov2D_12 * cov2D_12;
-    // Ensure determinant is non-negative before sqrt
-    if (det <= 0.0) {
-      gl_Position = vec4(2.0, 2.0, 2.0, 1.0); // Discard degenerated
-      return;
-    }
-
-    float trace = cov2D_11 + cov2D_22;
-    float traceOver2 = 0.5 * trace;
-    float discriminantSqrt = sqrt(max(traceOver2 * traceOver2 - det, 0.0)); // Avoid sqrt(negative)
-
-    float lambda1 = traceOver2 + discriminantSqrt; // Larger eigenvalue
-    float lambda2 = max(0.1, traceOver2 - discriminantSqrt); // Smaller eigenvalue, clamped
-
-    // Compute eigenvectors 
-
-    vec2 v1_eigen, v2_eigen;
-    
-    // Handle diagonal case
-    if(abs(cov2D_12) < 1e-16) {
-        v1_eigen = vec2(1.0, 0.0);
-    } else {
-        v1_eigen = normalize(vec2(cov2D_12, lambda1 - cov2D_11)); // diagonal choice
-    }
+    mat3 Vrk = mat3(
+        covA.x, covA.y, covA.z,
+        covA.y, covB.x, covB.y,
+        covA.z, covB.y, covB.z
+    );
+    mat3 cov = transpose(T) * Vrk * T;
 
-    v2_eigen = vec2(-v1_eigen.y, v1_eigen.x); // Perpendicular eigenvector
+    // Eigendecomposition for Quad dimensions
+    float diagonal1 = cov[0][0] + 0.3;
+    float offDiagonal = cov[0][1];
+    float diagonal2 = cov[1][1] + 0.3;
 
-    // Calculate SCALED vectors (l1, l2, incorparate factor)
-    float scaleFactor = 2.0 * sqrt(2.0); // ~2.8284
-    float l1 = sqrt(lambda1) * scaleFactor; // scaleX
-    float l2 = sqrt(lambda2) * scaleFactor; // scaleY
+    float mid = 0.5 * (diagonal1 + diagonal2);
+    float radius = length(vec2((diagonal1 - diagonal2) * 0.5, offDiagonal));
+    float lambda1 = mid + radius;
+    float lambda2 = max(mid - radius, 0.1);
 
-    float vmin = min(512.0, min(viewport.x, viewport.y));
-    l1 = min(l1, 2.0 * vmin);
-    l2 = min(l2, 2.0 * vmin);
+    // Screen space quad vectors
+    float vmin = min(1024.0, min(viewport.x, viewport.y)); // Safety clamp
+    float l1 = 2.0 * min(sqrt(2.0 * lambda1), vmin);
+    float l2 = 2.0 * min(sqrt(2.0 * lambda2), vmin);
 
-    // Early out tiny splats
-    if (l1 < 2.0 && l2 < 2.0) { // Check if smaller than ~2 pixel
-         gl_Position = vec4(2.0, 2.0, 2.0, 1.0);
-         return;
+    // Discard tiny splats
+    if (l1 < 2.0 && l2 < 2.0) {
+        gl_Position = DISCARD_VERTEX;
+        return;
     }
 
-    // Scaled eigenvectors for offset calculation
-    vec2 v1_scaled = l1 * v1_eigen;
-    vec2 v2_scaled = l2 * v2_eigen;
+    vec2 diagVec = normalize(vec2(offDiagonal, lambda1 - diagonal1));
+    vec2 v1 = l1 * diagVec;
+    vec2 v2 = l2 * vec2(diagVec.y, -diagVec.x);
 
-    // --- FRUSTUM CHECK (laxo, estilo PlayCanvas) ---
-
-    vec2 c = centerClip.ww / viewport;  // pixel to clip
-    float r = max(l1, l2);              // radius in pixels
-
-    // Remove if the center - radius is already out of -w..w
-    if (any(greaterThan(abs(centerClip.xy) - vec2(r) * c, centerClip.ww))) {
-        gl_Position = vec4(2.0, 2.0, 2.0, 1.0);
+    // Vertex Position (Quad Expansion)
+    vec4 centerProj = projectionMatrix * centerView;
+    vec2 c = centerProj.ww / viewport; // Correction for clip space
+    
+    // Frustum cull
+    if (any(greaterThan(abs(centerProj.xy) - vec2(max(l1, l2)) * c, centerProj.ww))) {
+        gl_Position = DISCARD_VERTEX;
         return;
     }
 
-    // --- END FRUSTUM CHECK ---
-
-    // --- Final Vertex Position ---
-
-    vec2 cornerOffset = position.xy; // (-1,-1) to (1,1)
-
-    // Clip the quad so only high-alpha core is visible
-    float alpha = max(splatOpacity, 1e-6);     // avoid log(0)
-    float clip  = min(1.0, sqrt(-log(1.0 / 255.0 / alpha)) / 2.0);
-
-    // Apply clip to the corner offset *before* calculating screen space offset
-    vec2 clippedCornerOffset = cornerOffset * clip;
-    vec2 screenOffsetPixels = clippedCornerOffset.x * v1_scaled + clippedCornerOffset.y * v2_scaled;
-
-    // Convert pixel offset to clip space offset
-    vec2 clipOffset = screenOffsetPixels * (centerClip.w / viewport);
-
-
-    // Apply offset to center clip position
-    gl_Position = centerClip + vec4(clipOffset, 0.0, 0.0);
-
-    // --- Pass data to Fragment Shader ---
+    // Quad offset based on 'position' attribute (-1 to 1)
+    vec2 offset = (position.x * v1 + position.y * v2) * c;
+    
+    // Corner Clipping (for gaussian shape)
+    // Assuming simple linear opacity here, otherwise inverse sigmoid logic required
+    float alpha = max(clr.a, 1.0/255.0);
+    float clip = min(1.0, sqrt(-log(1.0 / 255.0 / alpha)) / 2.0);
+    
+    offset *= clip;
+    vec2 clippedUV = position.xy * clip;
 
-    vColor = vec4(splatColor, splatOpacity);
-    vUv = clippedCornerOffset;
+    gl_Position = centerProj + vec4(offset, 0.0, 0.0);
+    
+    // Outputs
+    vUv = clippedUV;
+    vColor = vec4(max(clr.rgb, vec3(0.0)), clr.a);
 }
 `
-), qe = (
+), Ct = (
   /* glsl */
   `
 precision highp float;
 
-varying vec4 vColor; // Color and opacity passed from vertex shader
-varying vec2 vUv;    // Quad UV coordinates (-1 to 1) passed from vertex shader
+in vec4 vColor; // Color and opacity passed from vertex shader
+in vec2 vUv;    // Quad UV coordinates (-1 to 1) passed from vertex shader
+
+out vec4 fragColor; // Output variable
 
 // Fast approximate e^x based on https://nic.schraudolph.org/pubs/Schraudolph99.pdf
 const float EXP_A = 12102203.0;     // ≈ 2^23 / ln(2)
@@ -1440,88 +2065,86 @@ void main(void) {
     if (alpha < 1.0 / 255.0) discard; // Discard fragments with very low alpha
 
     // Premultiply color by alpha (required for correct blending)
-    gl_FragColor = vec4(vColor.rgb * alpha, alpha);
+    fragColor = vec4(vColor.rgb * alpha, alpha);
 }
 `
 );
-class Ve extends l.ShaderMaterial {
+class It extends h.ShaderMaterial {
   constructor(e = {}) {
-    const o = {
-      // Textures (values set via methods)
-      transformA: { value: null },
-      transformB: { value: null },
-      splatColor: { value: null },
+    const t = {
+      // Packed Textures
+      packedGeometry: { value: null },
+      // RGBA32UI: .r=MeansLow, .g=MeansHigh, .b=Quats, .a=Scales
+      packedColor: { value: null },
+      // RGBA8: .rgb=Color, .a=Opacity
       splatOrder: { value: null },
-      // Other uniforms
-      viewport: { value: new l.Vector2(1, 1) },
-      // Will be updated
+      // Index map
+      // Decompression Ranges
+      meansMin: { value: new h.Vector3() },
+      meansMax: { value: new h.Vector3() },
+      scalesMin: { value: new h.Vector3() },
+      scalesMax: { value: new h.Vector3() },
+      sh0Min: { value: new h.Vector3() },
+      sh0Max: { value: new h.Vector3() },
+      // Render State
+      texWidth: { value: 0 },
+      viewport: { value: new h.Vector2(1, 1) },
       numSplats: { value: 0 }
-      // Max splats to render (updated by sorter)
     };
     super({
-      vertexShader: Ue,
-      fragmentShader: qe,
-      uniforms: o,
+      uniforms: t,
+      vertexShader: Et,
+      fragmentShader: Ct,
       transparent: !0,
-      blending: l.CustomBlending,
-      // Premultiplied alpha blending:
-      // color = src_color * src_alpha + dst_color * (1 - src_alpha)
-      // alpha = src_alpha * 1 + dst_alpha * (1 - src_alpha)
-      blendSrc: l.OneFactor,
-      // Using ONE because shader outputs premultiplied color (color * alpha)
-      blendDst: l.OneMinusSrcAlphaFactor,
-      blendSrcAlpha: l.OneFactor,
-      // source alpha comes from shader
-      blendDstAlpha: l.OneMinusSrcAlphaFactor,
-      blendEquation: l.AddEquation,
-      blendEquationAlpha: l.AddEquation,
+      glslVersion: h.GLSL3,
+      blendSrc: h.OneFactor,
+      blendSrcAlpha: h.OneFactor,
+      blending: h.CustomBlending,
+      blendEquation: h.AddEquation,
+      blendEquationAlpha: h.AddEquation,
+      blendDst: h.OneMinusSrcAlphaFactor,
+      blendDstAlpha: h.OneMinusSrcAlphaFactor,
       depthTest: !0,
       depthWrite: !1,
-      // Disable depth write for transparency
-      side: l.DoubleSide,
-      // Render both sides (or CULLFACE_NONE equivalent)
-      // Optional settings from constructor
-      alphaTest: e.alphaTest !== void 0 ? e.alphaTest : 0,
-      // Typically 0 for blending
-      toneMapped: e.toneMapped !== void 0 ? e.toneMapped : !1
-      // prettier-ignore
-    }), e.alphaHash && (this.alphaHash = !0, this.depthWrite = !0, this.blending = l.NoBlending);
+      side: h.DoubleSide,
+      alphaTest: e.alphaTest ?? 0,
+      toneMapped: e.toneMapped ?? !1
+    }), e.alphaHash && (this.alphaHash = !0, this.depthWrite = !0, this.blending = h.NoBlending);
+  }
+  setTexWidth(e) {
+    this.uniforms.texWidth.value = e | 0;
   }
   /**
    * Update the viewport size
    * @param width Viewport width
    * @param height Viewport height
    */
-  updateViewport(e, o) {
-    this.uniforms.viewport.value.set(e, o);
+  updateViewport(e, t) {
+    this.uniforms.viewport.value.set(e, t);
   }
   /**
-   * Set transform texture A (positions)
-   * @param texture Texture containing positions
+   * Set the main packed geometry texture (RGBA32UI)
    */
-  setTransformA(e) {
-    this.uniforms.transformA.value = e;
+  setPackedGeometry(e) {
+    this.uniforms.packedGeometry.value = e;
   }
   /**
-   * Set transform texture B (rotation, scale)
-   * @param texture Texture containing rotation and scale data
+   * Set the packed color texture (RGBA8)
    */
-  setTransformB(e) {
-    this.uniforms.transformB.value = e;
+  setPackedColor(e) {
+    this.uniforms.packedColor.value = e;
   }
   /**
-   * Set color texture
-   * @param texture Texture containing colors
+   * Set order texture for sorting
    */
-  setColorTexture(e) {
-    this.uniforms.splatColor.value = e;
+  setOrderTexture(e) {
+    this.uniforms.splatOrder.value = e;
   }
   /**
-   * Set order texture
-   * @param texture Texture containing sort order
+   * Set the ranges needed to decompress the packed floats
    */
-  setOrderTexture(e) {
-    this.uniforms.splatOrder.value = e;
+  setRanges(e) {
+    this.uniforms.meansMin.value.copy(e.means.min), this.uniforms.meansMax.value.copy(e.means.max), this.uniforms.scalesMin.value.copy(e.scales.min), this.uniforms.scalesMax.value.copy(e.scales.max), this.uniforms.sh0Min.value.copy(e.sh0.min), this.uniforms.sh0Max.value.copy(e.sh0.max);
   }
   /**
    * Set number of splats to render
@@ -1531,48 +2154,40 @@ class Ve extends l.ShaderMaterial {
     this.uniforms.numSplats.value = e;
   }
 }
-const se = class se extends l.Mesh {
+const de = class de extends h.Mesh {
   // Match shader constant
   /**
    * Create a new SplatMesh for rendering Gaussian splats
    * @param splatData The splat data to render
    * @param options Rendering options
    */
-  constructor(o, t = {}) {
-    const r = new Ve(t), n = se.createInstancedGeometry(o.numSplats, se.INSTANCE_SIZE);
-    super(n, r);
-    f(this, "sorter");
-    f(this, "splatData");
-    f(this, "options");
-    f(this, "textureManager");
-    f(this, "material");
-    f(this, "geometry");
-    f(this, "lastCameraPositionLocal", new l.Vector3());
-    f(this, "lastCameraDirectionLocal", new l.Vector3());
-    f(this, "invModelMatrix", new l.Matrix4());
+  constructor(t, r = {}) {
+    const s = new It(r), a = de.createInstancedGeometry(t.numSplats, de.INSTANCE_SIZE);
+    super(a, s);
+    M(this, "sorter");
+    M(this, "options");
+    M(this, "splatData");
+    M(this, "textureManager");
+    M(this, "material");
+    M(this, "geometry");
+    M(this, "lastCameraPositionLocal", new h.Vector3());
+    M(this, "lastCameraDirectionLocal", new h.Vector3());
+    M(this, "invModelMatrix", new h.Matrix4());
     // Cached inverse matrix
-    f(this, "_vpW", -1);
-    f(this, "_vpH", -1);
-    f(this, "_size", new l.Vector2());
-    f(this, "_camPosW", new l.Vector3());
-    f(this, "_camDirW", new l.Vector3());
-    f(this, "_camPosL", new l.Vector3());
-    f(this, "_camDirL", new l.Vector3());
-    f(this, "onSorterUpdated", (o) => {
-      const t = o.count;
-      this.geometry.instanceCount = Math.ceil(t / se.INSTANCE_SIZE), this.material.setNumSplats(t);
+    M(this, "_vpW", -1);
+    M(this, "_vpH", -1);
+    M(this, "_size", new h.Vector2());
+    M(this, "_camPosW", new h.Vector3());
+    M(this, "_camDirW", new h.Vector3());
+    M(this, "_camPosL", new h.Vector3());
+    M(this, "_camDirL", new h.Vector3());
+    M(this, "onSorterUpdated", (t) => {
+      const r = t.count;
+      this.geometry.instanceCount = Math.ceil(r / de.INSTANCE_SIZE), this.material.setNumSplats(r);
     });
-    this.geometry = n, this.material = r, this.splatData = o, this.frustumCulled = !1, this.options = {
-      autoSort: !0,
-      ...t
-    }, this.textureManager = new De(o), this.sorter = new Pe();
-    let a = this.createChunks() || void 0;
-    a === null && console.warn("Visus: Could not create sorter chunks, bounding box might be invalid."), a = void 0, this.sorter.addEventListener("updated", this.onSorterUpdated), this.sorter.init(
-      this.textureManager.orderTexture,
-      this.splatData.positions,
-      a ?? void 0,
-      !this.options.keepSplatData
-    ), this.material.setTransformA(this.textureManager.transformA), this.material.setTransformB(this.textureManager.transformB), this.material.setColorTexture(this.textureManager.colorTexture), this.material.setOrderTexture(this.textureManager.orderTexture), this.material.setNumSplats(0), this.geometry.boundingBox = o.boundingBox.toBox3(), this.geometry.boundingSphere = new l.Sphere(), this.geometry.boundingBox.getBoundingSphere(this.geometry.boundingSphere), this.options.keepSplatData || (this.splatData = null);
+    this.geometry = a, this.material = s, this.options = { autoSort: !0, ...r }, this.splatData = t, this.frustumCulled = !1, this.sorter = new At(), this.textureManager = new kt(t);
+    let o = this.createChunks() || void 0;
+    o === null && console.warn("Visus: Could not create sorter chunks, bounding box might be invalid."), o = void 0, this.sorter.addEventListener("updated", this.onSorterUpdated), this.sorter.init(this.textureManager.orderTexture, this.splatData.centers, o ?? void 0, !this.options.keepSplatData), this.material.setRanges(t.ranges), this.material.setTexWidth(t.textureWidth), this.material.setPackedColor(this.textureManager.packedColor), this.material.setOrderTexture(this.textureManager.orderTexture), this.material.setPackedGeometry(this.textureManager.packedGeometry), this.material.setNumSplats(0), this.geometry.boundingBox = t.boundingBox.toBox3(), this.geometry.boundingSphere = new h.Sphere(), this.geometry.boundingBox.getBoundingSphere(this.geometry.boundingSphere), this.options.keepSplatData || (this.splatData = null);
   }
   /**
    * Creates the instanced geometry for rendering splats.
@@ -1580,8 +2195,8 @@ const se = class se extends l.Mesh {
    * @param instanceSize Number of splats per instance.
    * @returns InstancedBufferGeometry
    */
-  static createInstancedGeometry(o, t) {
-    const r = Math.ceil(o / t), n = new l.BufferGeometry(), a = new Float32Array([
+  static createInstancedGeometry(t, r) {
+    const s = Math.ceil(t / r), a = new h.BufferGeometry(), o = new Float32Array([
       // x, y, splat_index_in_instance
       -1,
       -1,
@@ -1595,24 +2210,24 @@ const se = class se extends l.Mesh {
       -1,
       1,
       0
-    ]), i = new Uint16Array([0, 1, 2, 0, 2, 3]), u = new Float32Array(4 * 3 * t);
-    for (let h = 0; h < t; h++) {
-      const b = h * 4 * 3;
-      for (let S = 0; S < 4; S++)
-        u[b + S * 3 + 0] = a[S * 3 + 0], u[b + S * 3 + 1] = a[S * 3 + 1], u[b + S * 3 + 2] = h;
+    ]), i = new Uint16Array([0, 1, 2, 0, 2, 3]), m = new Float32Array(4 * 3 * r);
+    for (let u = 0; u < r; u++) {
+      const x = u * 4 * 3;
+      for (let g = 0; g < 4; g++)
+        m[x + g * 3 + 0] = o[g * 3 + 0], m[x + g * 3 + 1] = o[g * 3 + 1], m[x + g * 3 + 2] = u;
     }
-    const w = new Uint32Array(6 * t);
-    for (let h = 0; h < t; h++) {
-      const b = h * 6, S = h * 4;
-      w[b + 0] = i[0] + S, w[b + 1] = i[1] + S, w[b + 2] = i[2] + S, w[b + 3] = i[3] + S, w[b + 4] = i[4] + S, w[b + 5] = i[5] + S;
+    const f = new Uint32Array(6 * r);
+    for (let u = 0; u < r; u++) {
+      const x = u * 6, g = u * 4;
+      f[x + 0] = i[0] + g, f[x + 1] = i[1] + g, f[x + 2] = i[2] + g, f[x + 3] = i[3] + g, f[x + 4] = i[4] + g, f[x + 5] = i[5] + g;
     }
-    n.setAttribute("position", new l.BufferAttribute(u, 3)), n.setIndex(new l.BufferAttribute(w, 1));
-    const C = new l.InstancedBufferGeometry();
-    C.index = n.index, C.setAttribute("position", n.getAttribute("position"));
-    const _ = new Uint32Array(r);
-    for (let h = 0; h < r; h++)
-      _[h] = h * t;
-    return C.setAttribute("splatInstanceIndex", new l.InstancedBufferAttribute(_, 1, !1)), C.instanceCount = 0, C;
+    a.setAttribute("position", new h.BufferAttribute(m, 3)), a.setIndex(new h.BufferAttribute(f, 1));
+    const y = new h.InstancedBufferGeometry();
+    y.index = a.index, y.setAttribute("position", a.getAttribute("position"));
+    const l = new Uint32Array(s);
+    for (let u = 0; u < s; u++)
+      l[u] = u * r;
+    return y.setAttribute("splatInstanceIndex", new h.InstancedBufferAttribute(l, 1, !1)), y.instanceCount = 0, y;
   }
   /**
    * Create chunks data (bounding box min/max) for the sorter.
@@ -1621,14 +2236,14 @@ const se = class se extends l.Mesh {
   createChunks() {
     if (!this.splatData)
       return null;
-    const o = this.splatData.boundingBox;
-    return o.min.x === 1 / 0 || o.max.x === -1 / 0 ? null : new Float32Array([
-      o.min.x,
-      o.min.y,
-      o.min.z,
-      o.max.x,
-      o.max.y,
-      o.max.z
+    const t = this.splatData.boundingBox;
+    return t.min.x === 1 / 0 || t.max.x === -1 / 0 ? null : new Float32Array([
+      t.min.x,
+      t.min.y,
+      t.min.z,
+      t.max.x,
+      t.max.y,
+      t.max.z
     ]);
   }
   /**
@@ -1636,17 +2251,17 @@ const se = class se extends l.Mesh {
    * @param width Viewport width
    * @param height Viewport height
    */
-  updateViewport(o, t) {
-    o === this._vpW && t === this._vpH || (this._vpW = o, this._vpH = t, this.material.updateViewport(o, t));
+  updateViewport(t, r) {
+    t === this._vpW && r === this._vpH || (this._vpW = t, this._vpH = r, this.material.updateViewport(t, r));
   }
   /**
    * Sorts splats based on camera position and direction.
    * @param camera The camera to sort against.
    */
-  sort(o) {
-    o.getWorldPosition(this._camPosW), o.getWorldDirection(this._camDirW), this.invModelMatrix.copy(this.matrixWorld).invert(), this._camPosL.copy(this._camPosW).applyMatrix4(this.invModelMatrix), this._camDirL.copy(this._camDirW).transformDirection(this.invModelMatrix);
-    const t = this.lastCameraPositionLocal.distanceToSquared(this._camPosL) > 1e-6, r = this.lastCameraDirectionLocal.dot(this._camDirL) < 0.999;
-    this.options.autoSort && (t || r) && (this.lastCameraPositionLocal.copy(this._camPosL), this.lastCameraDirectionLocal.copy(this._camDirL), this.sorter.setCamera(this._camPosL, this._camDirL));
+  sort(t) {
+    t.getWorldPosition(this._camPosW), t.getWorldDirection(this._camDirW), this.invModelMatrix.copy(this.matrixWorld).invert(), this._camPosL.copy(this._camPosW).applyMatrix4(this.invModelMatrix), this._camDirL.copy(this._camDirW).transformDirection(this.invModelMatrix);
+    const r = this.lastCameraPositionLocal.distanceToSquared(this._camPosL) > 1e-6, s = this.lastCameraDirectionLocal.dot(this._camDirL) < 0.999;
+    this.options.autoSort && (r || s) && (this.lastCameraPositionLocal.copy(this._camPosL), this.lastCameraDirectionLocal.copy(this._camDirL), this.sorter.setCamera(this._camPosL, this._camDirL));
   }
   /**
    * THREE.js hook called before rendering the object.
@@ -1657,8 +2272,8 @@ const se = class se extends l.Mesh {
    */
   // prettier-ignore
   // @ts-expect-error scene is not used
-  onBeforeRender(o, t, r) {
-    this.sort(r), o.getSize(this._size), this.updateViewport(this._size.x, this._size.y);
+  onBeforeRender(t, r, s) {
+    this.sort(s), t.getSize(this._size), this.updateViewport(this._size.x, this._size.y);
   }
   /**
    * Dispose of resources
@@ -1668,39 +2283,51 @@ const se = class se extends l.Mesh {
   }
 };
 /** Number of splats combined into a single instanced draw call. */
-f(se, "INSTANCE_SIZE", 128);
-let de = se;
-const le = /* @__PURE__ */ new Map(), He = ({
-  plyUrl: x,
-  debug: e = !1,
-  splatOptions: o = {},
-  ...t
+M(de, "INSTANCE_SIZE", 128);
+let Te = de;
+const ve = /* @__PURE__ */ new Map(), Ft = ({
+  url: n,
+  type: e,
+  debug: t = !1,
+  splatOptions: r = {},
+  ...s
 }) => {
-  e && console.debug("SPLAT: rendering", { plyUrl: x, splatOptions: o, meshProps: t });
-  const [r, n] = Ce(null), a = Ae(null);
-  return Te(() => {
-    const i = we(x, o);
-    return je(x, o).then(
-      (u) => {
-        n(u);
+  if (!n) throw new Error('Splat component requires either "url" or "plyUrl" prop');
+  const a = Tt(n, e);
+  t && console.debug("SPLAT: rendering", { url: n, type: a, splatOptions: r, meshProps: s });
+  const [o, i] = Xe(null), m = Ze(null);
+  return Je(() => {
+    const f = Ne(n, a, r);
+    return _t(n, a, r).then(
+      (y) => {
+        i(y);
       }
     ), () => {
-      e && console.debug("SPLAT: releasing mesh for", x), We(i);
+      t && console.debug("SPLAT: releasing mesh for", n), zt(f);
     };
-  }, [x, o, e]), r ? /* @__PURE__ */ Ie.jsx("primitive", { ref: a, object: r, ...t }) : null;
-}, we = (x, e) => `${x}:${JSON.stringify(e)}`, je = async (x, e) => {
-  const o = we(x, e), t = le.get(o);
-  if (t)
-    return t.refCount++, t.mesh;
-  const n = await new ze().loadAsync(x), a = new de(n, e);
-  return le.set(o, { mesh: a, refCount: 1 }), a;
+  }, [n, a, r, t]), o ? /* @__PURE__ */ tt.jsx("primitive", { ref: m, object: o, ...s }) : null;
+}, Rt = (n) => {
+  const e = n.toLowerCase();
+  return e.endsWith(".ply") ? "ply" : e.endsWith(".sogs") || e.endsWith(".zip") || e.endsWith(".json") ? "sogs" : null;
+}, Tt = (n, e) => {
+  if (e) return e;
+  const t = Rt(n);
+  if (t) return t;
+  throw new Error(`Cannot determine file type from URL: "${n}". `);
+}, Ne = (n, e, t) => `${n}:${e}:${JSON.stringify(t)}`, _t = async (n, e, t) => {
+  const r = Ne(n, e, t), s = ve.get(r);
+  if (s)
+    return s.refCount++, s.mesh;
+  const o = await (e === "ply" ? new st() : new St()).loadAsync(n), i = new Te(o, t);
+  return ve.set(r, { mesh: i, refCount: 1 }), i;
 };
-function We(x) {
-  const e = le.get(x);
-  e && (e.refCount--, e.refCount <= 0 && (e.mesh.dispose(), le.delete(x)));
+function zt(n) {
+  const e = ve.get(n);
+  e && (e.refCount--, e.refCount <= 0 && (e.mesh.dispose(), ve.delete(n)));
 }
 export {
-  ze as PlyLoader,
-  He as Splat,
-  de as SplatMesh
+  st as PlyLoader,
+  St as SogsLoader,
+  Ft as Splat,
+  Te as SplatMesh
 };