u-space 0.0.30 → 0.0.32

package/dist/index.js

@@ -1,22 +1,23 @@
-import { g as Et } from "./Viewer-Cs_y7IiH.js";
-import { C as Qi, a as qi, I as Yi, b as Vi, O as Ji, R as Zi, c as er, V as tr, e as sr } from "./Viewer-Cs_y7IiH.js";
-import { EventDispatcher as qt, Vector2 as z, Box2 as Yt, Matrix4 as L, Vector3 as C, Scene as Vt, Color as A, AmbientLight as Jt, DirectionalLight as Pe, PointLight as Ne, SpotLight as ze, HemisphereLight as De, DirectionalLightHelper as Zt, PointLightHelper as es, SpotLightHelper as ts, HemisphereLightHelper as ss, MeshStandardNodeMaterial as K, Loader as ns, LoaderUtils as G, FileLoader as _t, TextureLoader as Ct, Group as H, SRGBColorSpace as Ot, RepeatWrapping as Re, BufferGeometry as Q, BufferAttribute as je, Mesh as P, FrontSide as is, BackSide as rs, DoubleSide as as, REVISION as ke, CubeTextureLoader as os, EquirectangularReflectionMapping as cs, Sprite as ls, AnimationMixer as hs, LoopRepeat as us, LoopOnce as ds, Box3 as $, SphereGeometry as ps, TubeGeometry as ms, LineCurve3 as fs, CatmullRomCurve3 as gs, SpriteNodeMaterial as ys, CanvasTexture as bs, ShapeGeometry as ws, Shape as At, ExtrudeGeometry as xs, PlaneGeometry as Ms, CircleGeometry as Is, Quaternion as Ss, BoxGeometry as vs, MeshBasicNodeMaterial as Bs, ClippingGroup as Es, Plane as _s, PlaneHelper as Cs, LineBasicMaterial as me, Line as fe, Object3D as Os, Sphere as ne, Float32BufferAttribute as As, SkinnedMesh as Ts, DataTexture as Ls, RGBAFormat as Ps, FloatType as Ns, NearestFilter as Ue, Texture as zs, Frustum as Ds, InstancedBufferAttribute as We, DynamicDrawUsage as Be, InstancedMesh as Rs, StorageInstancedBufferAttribute as js } from "three/webgpu";
-import { GLTFLoader as Tt } from "three/addons/loaders/GLTFLoader.js";
-import { FBXLoader as ks } from "three/addons/loaders/FBXLoader.js";
-import { OBJLoader as Us } from "three/addons/loaders/OBJLoader.js";
-import { STLLoader as Ws } from "three/addons/loaders/STLLoader.js";
-import { DRACOLoader as Hs } from "three/addons/loaders/DRACOLoader.js";
-import { KTX2Loader as Fs } from "three/addons/loaders/KTX2Loader.js";
-import { MeshoptDecoder as He } from "three/addons/libs/meshopt_decoder.module.js";
-import { HDRLoader as Gs } from "three/addons/loaders/HDRLoader.js";
-import { clone as Le } from "three/addons/utils/SkeletonUtils.js";
-import { color as V, uv as Fe, time as ge, pow as ye, sin as Ce, mix as be, mx_noise_float as Ge, uniform as ae, add as $s, vec4 as Ks, Fn as Lt, userData as U, materialColor as xe, select as F, materialOpacity as Oe, vec3 as Xs, attribute as Qs, int as $e, textureSize as qs, textureLoad as Ke, ivec2 as Ys, instancedBufferAttribute as Xe, float as Vs } from "three/tsl";
-import { outline as Js } from "three/addons/tsl/display/OutlineNode.js";
-import { Easing as x, Tween as Zs } from "three/addons/libs/tween.module.js";
-import { mergeGeometries as en } from "three/addons/utils/BufferGeometryUtils.js";
-import { CSS2DObject as ir } from "three/addons/renderers/CSS2DRenderer.js";
-import { CSS3DObject as ar, CSS3DSprite as or } from "three/addons/renderers/CSS3DRenderer.js";
-class Ci extends qt {
+import { g as jt } from "./Viewer-Cs_y7IiH.js";
+import { C as vi, a as Si, I as Ii, b as Ei, O as Ci, R as Ai, c as Oi, V as Bi, e as _i } from "./Viewer-Cs_y7IiH.js";
+import { EventDispatcher as hs, Vector2 as j, Box2 as ds, Matrix4 as R, Vector3 as D, Scene as us, Color as P, AmbientLight as ps, DirectionalLight as Fe, PointLight as He, SpotLight as $e, HemisphereLight as Ge, DirectionalLightHelper as fs, PointLightHelper as ms, SpotLightHelper as gs, HemisphereLightHelper as ys, MeshStandardNodeMaterial as q, Loader as bs, LoaderUtils as he, FileLoader as Wt, TextureLoader as Ft, Group as W, SRGBColorSpace as Se, RepeatWrapping as Ie, BufferGeometry as G, BufferAttribute as Pe, Mesh as k, FrontSide as ws, BackSide as xs, DoubleSide as Ht, InterleavedBufferAttribute as Ke, MeshStandardMaterial as Ms, LinearSRGBColorSpace as qe, InterleavedBuffer as vs, Texture as $t, NearestFilter as Ee, LinearFilter as Ve, LinearMipmapLinearFilter as Ss, NearestMipmapLinearFilter as Is, LinearMipmapNearestFilter as Es, NearestMipmapNearestFilter as Cs, MirroredRepeatWrapping as Xe, ClampToEdgeWrapping as Ye, NoColorSpace as fe, REVISION as Qe, LoadingManager as As, CubeTextureLoader as Os, EquirectangularReflectionMapping as Bs, Sprite as _s, AnimationMixer as Ts, LoopRepeat as Ls, LoopOnce as Ns, Box3 as K, SphereGeometry as Ds, TubeGeometry as Ps, LineCurve3 as Rs, CatmullRomCurve3 as ks, SpriteNodeMaterial as zs, CanvasTexture as Us, ShapeGeometry as js, Shape as Gt, ExtrudeGeometry as Ws, PlaneGeometry as Fs, CircleGeometry as Hs, Quaternion as $s, BoxGeometry as Gs, MeshBasicNodeMaterial as Ks, ClippingGroup as qs, Plane as Vs, PlaneHelper as Xs, LineBasicMaterial as ye, Line as be, Object3D as Ys, Sphere as ne, Float32BufferAttribute as Qs, SkinnedMesh as Js, DataTexture as Zs, RGBAFormat as en, FloatType as tn, Frustum as sn, InstancedBufferAttribute as Je, DynamicDrawUsage as Te, InstancedMesh as nn, StorageInstancedBufferAttribute as rn } from "three/webgpu";
+import { GLTFLoader as Re } from "three/addons/loaders/GLTFLoader.js";
+import { FBXLoader as Ze } from "three/addons/loaders/FBXLoader.js";
+import { OBJLoader as an } from "three/addons/loaders/OBJLoader.js";
+import { STLLoader as on } from "three/addons/loaders/STLLoader.js";
+import { DRACOLoader as cn } from "three/addons/loaders/DRACOLoader.js";
+import { KTX2Loader as ln } from "three/addons/loaders/KTX2Loader.js";
+import { MeshoptDecoder as Le } from "three/addons/libs/meshopt_decoder.module.js";
+import { M as et, v as hn, U as Kt } from "./modelDecodeProtocol-wDB7ksYw.js";
+import { HDRLoader as dn } from "three/addons/loaders/HDRLoader.js";
+import { clone as We } from "three/addons/utils/SkeletonUtils.js";
+import { color as Y, uv as tt, time as we, pow as xe, sin as ke, mix as Me, mx_noise_float as st, uniform as ae, add as un, vec4 as pn, Fn as qt, userData as F, materialColor as Ce, select as $, materialOpacity as ze, vec3 as fn, attribute as mn, int as nt, textureSize as gn, textureLoad as rt, ivec2 as yn, instancedBufferAttribute as it, float as bn } from "three/tsl";
+import { outline as wn } from "three/addons/tsl/display/OutlineNode.js";
+import { Easing as T, Tween as xn } from "three/addons/libs/tween.module.js";
+import { mergeGeometries as Mn } from "three/addons/utils/BufferGeometryUtils.js";
+import { CSS2DObject as Li } from "three/addons/renderers/CSS2DRenderer.js";
+import { CSS3DObject as Di, CSS3DSprite as Pi } from "three/addons/renderers/CSS3DRenderer.js";
+class si extends hs {
   scene;
   camera;
   domElement;
@@ -26,8 +27,8 @@ class Ci extends qt {
   // Box selection state
   _boxSelectionEnabled = !1;
   _isSelecting = !1;
-  _startPoint = new z();
-  _endPoint = new z();
+  _startPoint = new j();
+  _endPoint = new j();
   _selectionBox = null;
   _deep = !0;
   /**
@@ -126,33 +127,33 @@ class Ci extends qt {
     this._selectionBox.style.left = `${e}px`, this._selectionBox.style.top = `${t}px`, this._selectionBox.style.width = `${s}px`, this._selectionBox.style.height = `${n}px`;
   }
   _getObjectsInBox() {
-    const e = this._container.getBoundingClientRect(), t = e.width, s = e.height, n = new z(
+    const e = this._container.getBoundingClientRect(), t = e.width, s = e.height, n = new j(
       this._startPoint.x / t * 2 - 1,
       -(this._startPoint.y / s) * 2 + 1
-    ), i = new z(
+    ), r = new j(
       this._endPoint.x / t * 2 - 1,
       -(this._endPoint.y / s) * 2 + 1
-    ), a = new Yt(
-      new z(Math.min(n.x, i.x), Math.min(n.y, i.y)),
-      new z(Math.max(n.x, i.x), Math.max(n.y, i.y))
-    ), o = this.targetObjects || this.scene.children, c = [], l = new L();
+    ), a = new ds(
+      new j(Math.min(n.x, r.x), Math.min(n.y, r.y)),
+      new j(Math.max(n.x, r.x), Math.max(n.y, r.y))
+    ), o = this.targetObjects || this.scene.children, c = [], l = new R();
     l.multiplyMatrices(this.camera.projectionMatrix, this.camera.matrixWorldInverse);
-    const h = (u) => {
-      if (!u.visible) return;
-      const d = new C();
-      if (d.setFromMatrixPosition(u.matrixWorld), d.applyMatrix4(l), d.z > -1 && d.z < 1 && a.containsPoint(new z(d.x, d.y)) && c.push(u), this._deep)
-        for (const p of u.children)
+    const h = (d) => {
+      if (!d.visible) return;
+      const u = new D();
+      if (u.setFromMatrixPosition(d.matrixWorld), u.applyMatrix4(l), u.z > -1 && u.z < 1 && a.containsPoint(new j(u.x, u.y)) && c.push(d), this._deep)
+        for (const p of d.children)
           h(p);
     };
-    for (const u of o)
-      h(u);
+    for (const d of o)
+      h(d);
     return c;
   }
   dispose() {
     this.disableBoxSelection(), this._selected.clear();
   }
 }
-class Oi {
+class ni {
   scenes = /* @__PURE__ */ new Map();
   _activeSceneKey = null;
   /**
@@ -165,8 +166,8 @@ class Oi {
    * Create and register a new scene.
    */
   create(e, t = {}) {
-    const s = new Vt();
-    return t.background !== void 0 && (s.background = new A(t.background)), this.scenes.set(e, s), s;
+    const s = new us();
+    return t.background !== void 0 && (s.background = new P(t.background)), this.scenes.set(e, s), s;
   }
   /**
    * Get a scene by key.
@@ -205,7 +206,7 @@ class Oi {
     const t = this.scenes.get(e);
     if (!t) return null;
     let s = null;
-    return t.background instanceof A && (s = `#${t.background.getHexString()}`), {
+    return t.background instanceof P && (s = `#${t.background.getHexString()}`), {
       name: t.name || e,
       background: s,
       environmentRotation: {
@@ -226,7 +227,7 @@ class Oi {
     return this.scenes.size;
   }
 }
-class Ai {
+class ri {
   scene;
   lights = /* @__PURE__ */ new Map();
   helpers = /* @__PURE__ */ new Map();
@@ -234,33 +235,33 @@ class Ai {
     this.scene = e;
   }
   addAmbient(e, t = {}) {
-    const { color: s = 16777215, intensity: n = 0.5 } = t, i = new Jt(s, n);
-    return i.name = e, this._register(e, i), i;
+    const { color: s = 16777215, intensity: n = 0.5 } = t, r = new ps(s, n);
+    return r.name = e, this._register(e, r), r;
   }
   addDirectional(e, t = {}) {
-    const { color: s = 16777215, intensity: n = 1, position: i = { x: 5, y: 10, z: 5 }, castShadow: a = !1, shadowMapSize: o = 1024 } = t, c = new Pe(s, n);
-    return c.position.set(i.x, i.y, i.z), c.castShadow = a, a && c.shadow.mapSize.setScalar(o), c.name = e, this._register(e, c), c;
+    const { color: s = 16777215, intensity: n = 1, position: r = { x: 5, y: 10, z: 5 }, castShadow: a = !1, shadowMapSize: o = 1024 } = t, c = new Fe(s, n);
+    return c.position.set(r.x, r.y, r.z), c.castShadow = a, a && c.shadow.mapSize.setScalar(o), c.name = e, this._register(e, c), c;
   }
   addPoint(e, t = {}) {
-    const { color: s = 16777215, intensity: n = 1, distance: i = 0, decay: a = 2, position: o = { x: 0, y: 5, z: 0 }, castShadow: c = !1 } = t, l = new Ne(s, n, i, a);
+    const { color: s = 16777215, intensity: n = 1, distance: r = 0, decay: a = 2, position: o = { x: 0, y: 5, z: 0 }, castShadow: c = !1 } = t, l = new He(s, n, r, a);
     return l.position.set(o.x, o.y, o.z), l.castShadow = c, l.name = e, this._register(e, l), l;
   }
   addSpot(e, t = {}) {
     const {
       color: s = 16777215,
       intensity: n = 1,
-      distance: i = 0,
+      distance: r = 0,
       angle: a = Math.PI / 6,
       penumbra: o = 0.1,
       decay: c = 2,
       position: l = { x: 0, y: 10, z: 0 },
       target: h,
-      castShadow: u = !1
-    } = t, d = new ze(s, n, i, a, o, c);
-    return d.position.set(l.x, l.y, l.z), h && d.target.position.set(h.x, h.y, h.z), d.castShadow = u, d.name = e, this._register(e, d), d;
+      castShadow: d = !1
+    } = t, u = new $e(s, n, r, a, o, c);
+    return u.position.set(l.x, l.y, l.z), h && u.target.position.set(h.x, h.y, h.z), u.castShadow = d, u.name = e, this._register(e, u), u;
   }
   addHemisphere(e, t = {}) {
-    const { skyColor: s = 8900331, groundColor: n = 3549447, intensity: i = 0.6 } = t, a = new De(s, n, i);
+    const { skyColor: s = 8900331, groundColor: n = 3549447, intensity: r = 0.6 } = t, a = new Ge(s, n, r);
     return a.name = e, this._register(e, a), a;
   }
   /**
@@ -311,7 +312,7 @@ class Ai {
     const t = this.lights.get(e);
     if (!t) return;
     let s = null;
-    t instanceof Pe ? s = new Zt(t, 1) : t instanceof Ne ? s = new es(t, 0.5) : t instanceof ze ? s = new ts(t) : t instanceof De && (s = new ss(t, 1)), s && (this.scene.add(s), this.helpers.set(e, s));
+    t instanceof Fe ? s = new fs(t, 1) : t instanceof He ? s = new ms(t, 0.5) : t instanceof $e ? s = new gs(t) : t instanceof Ge && (s = new ys(t, 1)), s && (this.scene.add(s), this.helpers.set(e, s));
   }
   /**
    * Hide (remove) the helper for a light.
@@ -342,113 +343,113 @@ class Ai {
     this.removeAll(), this.hideAllHelpers();
   }
 }
-class tn extends Tt {
+class at extends Re {
   constructor(e) {
     super(e);
   }
   parse(e, t, s, n) {
-    if (sn(e.slice(0, 8)) === "SBMG----") {
-      const a = nn(e.slice(8));
+    if (vn(e.slice(0, 8)) === "SBMG----") {
+      const a = Sn(e.slice(8));
       return super.parse(a, t, s, n);
     } else
       return super.parse(e, t, s, n);
   }
 }
-function sn(r) {
-  return new TextDecoder().decode(new Uint8Array(r));
+function vn(i) {
+  return new TextDecoder().decode(new Uint8Array(i));
 }
-function nn(r) {
-  const e = new DataView(r);
+function Sn(i) {
+  const e = new DataView(i);
   for (let t = 0; t < e.byteLength; t++) {
     const s = e.getUint8(t), n = (s >> 4 & 15) + (s << 4 & 240);
     e.setUint8(t, n);
   }
   return e.buffer;
 }
-const rn = 8, an = 130, Qe = 66, on = "SBK-----", cn = "SBM-----", Pt = new TextDecoder(), ln = new TextEncoder();
-function hn(r) {
-  let e = rn;
-  const t = new Uint8Array(r, 0, e);
-  if (Pt.decode(t) !== on)
-    return r;
-  e += an;
-  const n = new Uint8Array(r, 0, e);
+const In = 8, En = 130, ot = 66, Cn = "SBK-----", An = "SBM-----", Vt = new TextDecoder(), On = new TextEncoder();
+function Bn(i) {
+  let e = In;
+  const t = new Uint8Array(i, 0, e);
+  if (Vt.decode(t) !== Cn)
+    return i;
+  e += En;
+  const n = new Uint8Array(i, 0, e);
   if (n[40] === 1) {
-    const a = ln.encode(cn), o = new Uint8Array([n[41]]), c = un(n), l = dn(c);
-    let h = Qe % l.length;
-    const u = e + Qe, d = new Uint8Array(r, u), p = new Uint8Array(d.length);
-    for (let b = 0; b < d.length; b++)
-      p[b] = d[b] ^ l[h], h = (h + 1) % l.length;
-    const m = new Uint8Array(a.length + o.length + p.length);
-    return m.set(a), m.set(o, a.length), m.set(p, a.length + o.length), m.buffer;
+    const a = On.encode(An), o = new Uint8Array([n[41]]), c = _n(n), l = Tn(c);
+    let h = ot % l.length;
+    const d = e + ot, u = new Uint8Array(i, d), p = new Uint8Array(u.length);
+    for (let I = 0; I < u.length; I++)
+      p[I] = u[I] ^ l[h], h = (h + 1) % l.length;
+    const x = new Uint8Array(a.length + o.length + p.length);
+    return x.set(a), x.set(o, a.length), x.set(p, a.length + o.length), x.buffer;
   }
 }
-function un(r) {
+function _n(i) {
   const e = new Uint8Array(128);
-  return e.set(r.slice(42, 74), 0), e.set(r.slice(74, 138), 32), e.set(r.slice(8, 40), 96), e;
+  return e.set(i.slice(42, 74), 0), e.set(i.slice(74, 138), 32), e.set(i.slice(8, 40), 96), e;
 }
-function dn(r) {
+function Tn(i) {
   const e = new Uint8Array(64);
-  return e.set(r.slice(0, 8), 0), e.set(r.slice(24, 32), 8), e.set(r.slice(40, 56), 16), e.set(r.slice(64, 88), 32), e.set(r.slice(96, 104), 56), e;
+  return e.set(i.slice(0, 8), 0), e.set(i.slice(24, 32), 8), e.set(i.slice(40, 56), 16), e.set(i.slice(64, 88), 32), e.set(i.slice(96, 104), 56), e;
 }
-const pn = (r, e, t) => {
-  const s = r.buffer.slice(t, t + e);
-  let n = Pt.decode(s);
+const Ln = (i, e, t) => {
+  const s = i.buffer.slice(t, t + e);
+  let n = Vt.decode(s);
   return n = n.replace("\\", "/"), n.startsWith("Maps/") || (n = `Maps/${n}`), n;
-}, mn = (r, e, t) => {
-  const [s, n, i, a, o] = e, c = t || a < 1;
-  return new K({
-    name: r,
-    color: new A(s, n, i),
+}, Nn = (i, e, t) => {
+  const [s, n, r, a, o] = e, c = t || a < 1;
+  return new q({
+    name: i,
+    color: new P(s, n, r),
     opacity: a,
     transparent: c,
     alphaTest: 0.01,
     side: o
   });
-}, fn = (r) => r?.toLowerCase().endsWith(".png") ?? !1;
-class gn {
+}, Dn = (i) => i?.toLowerCase().endsWith(".png") ?? !1;
+class Pn {
   data;
   options;
   textureLoader;
   littleEndian = !0;
   materials = /* @__PURE__ */ new Map();
   constructor(e, t) {
-    this.data = e, this.options = t, this.textureLoader = new Ct(t.manager), this.textureLoader.setCrossOrigin(t.crossOrigin), this.textureLoader.setRequestHeader(t.requestHeader);
+    this.data = e, this.options = t, this.textureLoader = new Ft(t.manager), this.textureLoader.setCrossOrigin(t.crossOrigin), this.textureLoader.setRequestHeader(t.requestHeader);
   }
   parse(e, t) {
     let s = this.data;
-    const n = hn(this.data);
+    const n = Bn(this.data);
     n && (s = n);
-    const i = new DataView(s);
+    const r = new DataView(s);
     let a = 8;
-    const o = i.getUint8(a);
-    a += 1, o === 1 ? this._parseV2(i, a, e) : o === 2 ? this._parseV2(i, a, e) : o === 3 ? this._parseV3(i, a, e) : t?.(new Error(`SBMLoader: Unsupported SBM version: ${o}`));
+    const o = r.getUint8(a);
+    a += 1, o === 1 ? this._parseV2(r, a, e) : o === 2 ? this._parseV2(r, a, e) : o === 3 ? this._parseV3(r, a, e) : t?.(new Error(`SBMLoader: Unsupported SBM version: ${o}`));
   }
   _parseV2(e, t, s) {
-    const n = new H(), i = e.getUint16(t, this.littleEndian);
+    const n = new W(), r = e.getUint16(t, this.littleEndian);
     t += 2;
     const a = e.getUint16(t, this.littleEndian);
     t += 2;
-    for (let o = 0; o < i; ++o) {
+    for (let o = 0; o < r; ++o) {
       const c = e.getUint16(t, this.littleEndian).toString();
       t += 2, t += 4, t += 4, t += 4, t += 4;
       const l = e.getFloat32(t, this.littleEndian);
       t += 4;
       const h = e.getFloat32(t, this.littleEndian);
       t += 4;
-      const u = e.getFloat32(t, this.littleEndian);
-      t += 4;
       const d = e.getFloat32(t, this.littleEndian);
+      t += 4;
+      const u = e.getFloat32(t, this.littleEndian);
       t += 4, t += 4, t += 4, t += 4, t += 4;
       let p = e.getUint8(t);
-      t += 1, p === 0 ? p = is : p === 1 ? p = rs : p === 2 && (p = as);
-      const m = e.getUint16(t, this.littleEndian);
+      t += 1, p === 0 ? p = ws : p === 1 ? p = xs : p === 2 && (p = Ht);
+      const x = e.getUint16(t, this.littleEndian);
       t += 2;
-      const b = m > 0 ? pn(e, m, t) : "";
-      if (t += m, !this.materials.has(c)) {
-        const w = mn(c, [l, h, u, d, p], fn(b));
-        this.materials.set(c, w), b && this.options.path && this.textureLoader.load(G.resolveURL(b, this.options.path), (g) => {
-          g.colorSpace = Ot, g.wrapS = Re, g.wrapT = Re, g.flipY = !1, g.anisotropy = 16, w.map = g;
+      const I = x > 0 ? Ln(e, x, t) : "";
+      if (t += x, !this.materials.has(c)) {
+        const C = Nn(c, [l, h, d, u, p], Dn(I));
+        this.materials.set(c, C), I && this.options.path && this.textureLoader.load(he.resolveURL(I, this.options.path), (y) => {
+          y.colorSpace = Se, y.wrapS = Ie, y.wrapT = Ie, y.flipY = !1, y.anisotropy = 16, C.map = y;
         });
       }
     }
@@ -457,76 +458,76 @@ class gn {
       t += 2;
       const l = e.getUint16(t, this.littleEndian).toString();
       t += 2;
-      const h = [], u = [], d = [], p = [], m = e.getUint16(t, this.littleEndian);
-      if (t += 2, m > 0)
-        for (let y = 0; y < m; y++) {
-          const _ = new C();
-          _.setX(e.getFloat32(t, this.littleEndian)), t += 4, _.setY(e.getFloat32(t, this.littleEndian)), t += 4, _.setZ(e.getFloat32(t, this.littleEndian)), t += 4, h.push(_);
+      const h = [], d = [], u = [], p = [], x = e.getUint16(t, this.littleEndian);
+      if (t += 2, x > 0)
+        for (let b = 0; b < x; b++) {
+          const S = new D();
+          S.setX(e.getFloat32(t, this.littleEndian)), t += 4, S.setY(e.getFloat32(t, this.littleEndian)), t += 4, S.setZ(e.getFloat32(t, this.littleEndian)), t += 4, h.push(S);
         }
-      const b = e.getUint16(t, this.littleEndian);
-      if (t += 2, b > 0)
-        for (let y = 0; y < b; y++)
+      const I = e.getUint16(t, this.littleEndian);
+      if (t += 2, I > 0)
+        for (let b = 0; b < I; b++)
           t += 4, t += 4, t += 4;
-      const S = e.getUint16(t, this.littleEndian);
-      if (t += 2, S > 0)
-        for (let y = 0; y < S; y++) {
-          const _ = new z();
-          _.setX(e.getFloat32(t, this.littleEndian)), t += 4, _.setY(e.getFloat32(t, this.littleEndian)), t += 4, u.push(_);
+      const _ = e.getUint16(t, this.littleEndian);
+      if (t += 2, _ > 0)
+        for (let b = 0; b < _; b++) {
+          const S = new j();
+          S.setX(e.getFloat32(t, this.littleEndian)), t += 4, S.setY(e.getFloat32(t, this.littleEndian)), t += 4, d.push(S);
         }
-      const w = e.getUint16(t, this.littleEndian);
-      if (t += 2, w > 0)
-        for (let y = 0; y < w; y++) {
-          const _ = e.getUint16(t, this.littleEndian);
+      const C = e.getUint16(t, this.littleEndian);
+      if (t += 2, C > 0)
+        for (let b = 0; b < C; b++) {
+          const S = e.getUint16(t, this.littleEndian);
           t += 2;
-          const k = e.getUint16(t, this.littleEndian);
+          const A = e.getUint16(t, this.littleEndian);
           t += 2;
-          const N = e.getUint16(t, this.littleEndian);
+          const v = e.getUint16(t, this.littleEndian);
           t += 2;
-          const D = [_, k, N];
-          d.push(D), u.length > 0 && p.push([u[D[0]], u[D[1]], u[D[2]]]);
+          const E = [S, A, v];
+          u.push(E), d.length > 0 && p.push([d[E[0]], d[E[1]], d[E[2]]]);
         }
-      const g = [], I = [];
-      for (let y = 0; y < d.length; y++) {
-        const _ = d[y], k = h[_[0]], N = h[_[1]], D = h[_[2]];
-        g.push(...k.toArray(), ...N.toArray(), ...D.toArray());
-        let Y = new z(), R = new z(), f = new z();
-        const E = p[y];
-        E !== void 0 && (Y = E[0], R = E[1], f = E[2]), I.push(...Y.toArray(), ...R.toArray(), ...f.toArray());
+      const y = [], w = [];
+      for (let b = 0; b < u.length; b++) {
+        const S = u[b], A = h[S[0]], v = h[S[1]], E = h[S[2]];
+        y.push(...A.toArray(), ...v.toArray(), ...E.toArray());
+        let z = new j(), N = new j(), f = new j();
+        const L = p[b];
+        L !== void 0 && (z = L[0], N = L[1], f = L[2]), w.push(...z.toArray(), ...N.toArray(), ...f.toArray());
       }
-      const B = new Float32Array(g), O = new Float32Array(I), T = new Q();
-      if (B.length > 0 && T.setAttribute("position", new je(B, 3)), O.length > 0 && T.setAttribute("uv", new je(O, 2)), T.computeVertexNormals(), this.materials.has(l)) {
-        const y = new P(T, this.materials.get(l));
-        y.name = c, y.castShadow = !0, y.receiveShadow = !0, n.add(y);
+      const g = new Float32Array(y), m = new Float32Array(w), M = new G();
+      if (g.length > 0 && M.setAttribute("position", new Pe(g, 3)), m.length > 0 && M.setAttribute("uv", new Pe(m, 2)), M.computeVertexNormals(), this.materials.has(l)) {
+        const b = new k(M, this.materials.get(l));
+        b.name = c, b.castShadow = !0, b.receiveShadow = !0, n.add(b);
       }
     }
     s(n);
   }
   _parseV3(e, t, s) {
-    const n = new H();
+    const n = new W();
     console.warn("SBMLoader: SBM version 3 is not supported yet."), s(n);
   }
 }
-class yn extends ns {
+class ct extends bs {
   load(e, t, s, n) {
-    let i;
+    let r;
     if (this.resourcePath !== "")
-      i = this.resourcePath;
+      r = this.resourcePath;
     else if (this.path !== "") {
-      const c = G.extractUrlBase(e);
-      i = G.resolveURL(c, this.path);
+      const c = he.extractUrlBase(e);
+      r = he.resolveURL(c, this.path);
     } else
-      i = G.extractUrlBase(e);
+      r = he.extractUrlBase(e);
     this.manager.itemStart(e);
     const a = (c) => {
       n ? n(c) : console.error(c), this.manager.itemError(e), this.manager.itemEnd(e);
-    }, o = new _t(this.manager);
+    }, o = new Wt(this.manager);
     o.setPath(this.path), o.setResponseType("arraybuffer"), o.setRequestHeader(this.requestHeader), o.setWithCredentials(this.withCredentials), o.load(
       e,
       (c) => {
         try {
           this.parse(
             c,
-            i,
+            r,
             (l) => {
               t(l), this.manager.itemEnd(e);
             },
@@ -541,12 +542,12 @@ class yn extends ns {
     );
   }
   parse(e, t, s, n) {
-    const i = new TextDecoder().decode(e.slice(0, 8));
-    if (i !== "SBK-----" && i !== "SBM-----") {
-      n?.(new Error(`SBMLoader: Invalid SBM format: ${i}`));
+    const r = new TextDecoder().decode(e.slice(0, 8));
+    if (r !== "SBK-----" && r !== "SBM-----") {
+      n?.(new Error(`SBMLoader: Invalid SBM format: ${r}`));
       return;
     }
-    new gn(e, {
+    new Pn(e, {
       path: t,
       crossOrigin: this.crossOrigin,
       requestHeader: this.requestHeader,
@@ -558,17 +559,427 @@ class yn extends ns {
       this.parse(
         e,
         t,
-        (i) => {
-          s(i);
+        (r) => {
+          s(r);
         },
-        (i) => {
-          n(i);
+        (r) => {
+          n(r);
         }
       );
     });
   }
 }
-const bn = [
+const Rn = {
+  5120: Int8Array,
+  5121: Uint8Array,
+  5122: Int16Array,
+  5123: Uint16Array,
+  5125: Uint32Array,
+  5126: Float32Array
+}, kn = {
+  SCALAR: 1,
+  VEC2: 2,
+  VEC3: 3,
+  VEC4: 4,
+  MAT2: 4,
+  MAT3: 9,
+  MAT4: 16
+}, zn = {
+  POSITION: "position",
+  NORMAL: "normal",
+  TANGENT: "tangent",
+  TEXCOORD_0: "uv",
+  TEXCOORD_1: "uv1",
+  TEXCOORD_2: "uv2",
+  TEXCOORD_3: "uv3",
+  COLOR_0: "color"
+};
+function oe(i, e) {
+  e && typeof e == "object" && !Array.isArray(e) && Object.assign(i.userData, e);
+}
+function Un(i) {
+  if (i.protocolVersion !== et)
+    throw new Error(
+      `Unsupported model decode protocol ${i.protocolVersion}; expected ${et}.`
+    );
+  const { document: e, buffers: t, images: s } = i;
+  hn(e);
+  const n = /* @__PURE__ */ new Map(), r = /* @__PURE__ */ new Map(), a = /* @__PURE__ */ new Map(), o = /* @__PURE__ */ new Map(), c = /* @__PURE__ */ new Map(), l = (w) => {
+    const g = n.get(w);
+    if (g) return g;
+    const m = e.accessors?.[w];
+    if (!m || m.bufferView === void 0)
+      throw new Error(`Decoded glTF references missing accessor ${w}.`);
+    const M = e.bufferViews?.[m.bufferView];
+    if (!M) throw new Error(`Decoded glTF references missing bufferView ${m.bufferView}.`);
+    const b = t[M.buffer];
+    if (!b) throw new Error(`Decoded glTF references missing buffer ${M.buffer}.`);
+    const S = Rn[m.componentType], A = kn[m.type];
+    if (!S || !A)
+      throw new Error(`Unsupported decoded glTF accessor type ${m.componentType}/${m.type}.`);
+    const v = S.BYTES_PER_ELEMENT, E = M.byteOffset ?? 0, z = m.byteOffset ?? 0;
+    let N;
+    const f = A * v;
+    if (M.byteStride && M.byteStride !== f) {
+      if (M.byteStride % v !== 0 || z % v !== 0)
+        throw new Error(`Decoded glTF accessor ${w} has an invalid interleaved alignment.`);
+      const L = Math.floor(z / M.byteStride), O = [
+        m.bufferView,
+        m.componentType,
+        L,
+        m.count
+      ].join(":");
+      let B = r.get(O);
+      if (!B) {
+        const U = new S(
+          b,
+          E + L * M.byteStride,
+          m.count * M.byteStride / v
+        );
+        B = new vs(U, M.byteStride / v), r.set(O, B);
+      }
+      N = new Ke(
+        B,
+        A,
+        z % M.byteStride / v,
+        m.normalized ?? !1
+      );
+    } else {
+      const L = new S(
+        b,
+        E + z,
+        m.count * A
+      );
+      N = new Pe(L, A, m.normalized ?? !1);
+    }
+    return N.name = m.name ?? "", n.set(w, N), N;
+  }, h = (w, g, m) => {
+    const M = `${w}:${g}:${m}`, b = c.get(M);
+    if (b) return b;
+    const S = e.textures?.[w];
+    if (!S || S.source === void 0)
+      throw new Error(`Decoded glTF references missing texture ${w}.`);
+    const A = s[S.source];
+    if (!A) throw new Error(`Decoded glTF references missing image ${S.source}.`);
+    const v = S.sampler === void 0 ? void 0 : e.samplers?.[S.sampler], E = new $t(A);
+    return E.name = S.name ?? e.images?.[S.source]?.name ?? "", E.flipY = !1, E.colorSpace = g, E.channel = m, E.magFilter = v?.magFilter === 9728 ? Ee : Ve, E.minFilter = (() => {
+      switch (v?.minFilter) {
+        case 9728:
+          return Ee;
+        case 9729:
+          return Ve;
+        case 9984:
+          return Cs;
+        case 9985:
+          return Es;
+        case 9986:
+          return Is;
+        default:
+          return Ss;
+      }
+    })(), E.wrapS = (() => {
+      switch (v?.wrapS) {
+        case 33071:
+          return Ye;
+        case 33648:
+          return Xe;
+        default:
+          return Ie;
+      }
+    })(), E.wrapT = (() => {
+      switch (v?.wrapT) {
+        case 33071:
+          return Ye;
+        case 33648:
+          return Xe;
+        default:
+          return Ie;
+      }
+    })(), E.needsUpdate = !0, c.set(M, E), E;
+  }, d = (w, g, m, M) => {
+    m && (w[g] = h(m.index, M, m.texCoord ?? 0));
+  }, u = (w, g, m, M) => {
+    const b = [
+      w ?? "default",
+      g ? "derivative-tangents" : "",
+      m ? "vertex-colors" : "",
+      M ? "flat-shading" : ""
+    ].join(":"), S = o.get(b);
+    if (S) return S;
+    const A = w === void 0 ? void 0 : e.materials?.[w];
+    if (w !== void 0 && !A)
+      throw new Error(`Decoded glTF references missing material ${w}.`);
+    const v = A ?? {}, E = v.pbrMetallicRoughness ?? {}, z = E.baseColorFactor ?? [1, 1, 1, 1], N = v.alphaMode ?? "OPAQUE", f = new Ms({
+      color: new P().setRGB(
+        z[0] ?? 1,
+        z[1] ?? 1,
+        z[2] ?? 1,
+        qe
+      ),
+      opacity: z[3] ?? 1,
+      metalness: E.metallicFactor ?? 1,
+      roughness: E.roughnessFactor ?? 1,
+      transparent: N === "BLEND",
+      depthWrite: N !== "BLEND",
+      alphaTest: N === "MASK" ? v.alphaCutoff ?? 0.5 : 0
+    });
+    return v.doubleSided && (f.side = Ht), f.vertexColors = m, f.flatShading = M, f.name = v.name ?? "", d(f, "map", E.baseColorTexture, Se), d(f, "metalnessMap", E.metallicRoughnessTexture, fe), d(f, "roughnessMap", E.metallicRoughnessTexture, fe), d(f, "normalMap", v.normalTexture, fe), d(f, "aoMap", v.occlusionTexture, fe), d(f, "emissiveMap", v.emissiveTexture, Se), v.normalTexture?.scale !== void 0 && (f.normalScale = new j(
+      v.normalTexture.scale,
+      v.normalTexture.scale
+    )), g && (f.normalScale.y *= -1), v.occlusionTexture?.strength !== void 0 && (f.aoMapIntensity = v.occlusionTexture.strength), v.emissiveFactor && f.emissive.setRGB(
+      v.emissiveFactor[0] ?? 0,
+      v.emissiveFactor[1] ?? 0,
+      v.emissiveFactor[2] ?? 0,
+      qe
+    ), oe(f, v.extras), o.set(b, f), f;
+  }, p = (w, g) => {
+    const m = `${w}:${g}`, M = a.get(m);
+    if (M) return M;
+    const b = e.meshes?.[w]?.primitives[g];
+    if (!b) throw new Error(`Decoded glTF references missing primitive ${m}.`);
+    const S = new G();
+    for (const [A, v] of Object.entries(b.attributes)) {
+      const E = zn[A] ?? A.toLowerCase();
+      S.setAttribute(E, l(v));
+    }
+    if (b.indices !== void 0) {
+      const A = l(b.indices);
+      if (A instanceof Ke)
+        throw new Error(`Decoded glTF index accessor ${b.indices} cannot be interleaved.`);
+      S.setIndex(A);
+    }
+    return a.set(m, S), S;
+  }, x = (w) => {
+    const g = e.meshes?.[w];
+    if (!g) throw new Error(`Decoded glTF references missing mesh ${w}.`);
+    const m = g.primitives.map((b, S) => {
+      const A = new k(
+        p(w, S),
+        u(
+          b.material,
+          b.attributes.TANGENT === void 0,
+          b.attributes.COLOR_0 !== void 0,
+          b.attributes.NORMAL === void 0
+        )
+      );
+      return A.name = g.name ?? "", A;
+    });
+    if (m.length === 1)
+      return oe(m[0], g.extras), m[0];
+    const M = new W();
+    return M.name = g.name ?? "", M.add(...m), oe(M, g.extras), M;
+  }, I = (w) => {
+    const g = e.nodes?.[w];
+    if (!g) throw new Error(`Decoded glTF references missing node ${w}.`);
+    const m = g.mesh === void 0 ? new W() : x(g.mesh);
+    m.name = g.name ?? m.name, g.matrix ? new R().fromArray(g.matrix).decompose(m.position, m.quaternion, m.scale) : (g.translation && m.position.fromArray(g.translation), g.rotation && m.quaternion.fromArray(g.rotation), g.scale && m.scale.fromArray(g.scale)), oe(m, g.extras);
+    for (const M of g.children ?? [])
+      m.add(I(M));
+    return m;
+  }, _ = e.scene ?? 0, C = e.scenes?.[_];
+  if (!C) throw new Error(`Decoded glTF references missing scene ${_}.`);
+  const y = new W();
+  y.name = C.name ?? "", oe(y, C.extras);
+  for (const w of C.nodes ?? []) y.add(I(w));
+  return y.animations = [], y;
+}
+const jn = 256;
+function Wn(i) {
+  return i instanceof Error ? { message: i.message, name: i.name, stack: i.stack } : { message: String(i) };
+}
+function Fn(i) {
+  const e = new Error(i.message);
+  return e.name = i.name ?? "Error", e.stack = i.stack, e;
+}
+class ve extends Error {
+  name = "ModelDecodeWorkerUnavailableError";
+  constructor(e, t) {
+    super(e, t);
+  }
+}
+function Hn(i, e, t = jn) {
+  if (i.images.length !== i.imageKeys.length)
+    throw new Error("Decoded model image identities do not match its image payload.");
+  const s = [];
+  for (let n = 0; n < i.images.length; n++) {
+    const r = i.imageKeys[n], a = i.images[n], o = e.get(r);
+    if (o)
+      e.delete(r), e.set(r, o), o !== a && a.close(), i.images[n] = o;
+    else
+      for (e.set(r, a), s.push(r); e.size > Math.max(0, t); ) {
+        const c = e.keys().next().value;
+        if (c === void 0) break;
+        e.delete(c);
+      }
+  }
+  return s;
+}
+class $n {
+  worker;
+  #s;
+  #a = 1;
+  #t = /* @__PURE__ */ new Map();
+  #e = /* @__PURE__ */ new Map();
+  #r = !1;
+  constructor(e, t = {}) {
+    this.worker = e, this.#s = t.onFatal, e.addEventListener("message", this.#o), e.addEventListener("error", this.#l), e.addEventListener("messageerror", this.#d);
+  }
+  get disposed() {
+    return this.#r;
+  }
+  supports(e) {
+    const t = e.split(/[?#]/, 1)[0].split(".").pop()?.toLowerCase();
+    return t === "sbmx" || t === "gltf" || t === "glb";
+  }
+  async loadAsync(e, t = {}) {
+    if (this.#r)
+      throw new ve("Model decode Worker is unavailable.");
+    const s = this.#a++, { signal: n, loadingManager: r, ...a } = t;
+    if (n?.aborted) throw n.reason ?? new DOMException("Aborted", "AbortError");
+    const o = await new Promise((l, h) => {
+      const d = {
+        resolve: l,
+        reject: h,
+        manager: r,
+        rootUrl: e,
+        resources: /* @__PURE__ */ new Map()
+      };
+      if (r?.itemStart(e), n) {
+        const u = () => {
+          this.#t.delete(s), this.#h(d, n.reason ?? new DOMException("Aborted", "AbortError")), h(n.reason ?? new DOMException("Aborted", "AbortError"));
+          try {
+            this.#n({ type: "cancel", id: s });
+          } catch {
+          }
+        };
+        d.cleanup = () => n.removeEventListener("abort", u), n.addEventListener("abort", u, { once: !0 });
+      }
+      this.#t.set(s, d);
+      try {
+        this.#n({ type: "decode", id: s, url: e, options: a });
+      } catch (u) {
+        this.#t.delete(s), d.cleanup?.();
+        const p = u instanceof Error ? u : new Error(String(u));
+        this.#h(d, p), h(p);
+      }
+    }), c = [];
+    try {
+      return c.push(...Hn(o, this.#e)), Un(o);
+    } catch (l) {
+      const h = /* @__PURE__ */ new Set();
+      for (const d of c) {
+        const u = o.imageKeys.indexOf(d), p = this.#e.get(d) ?? o.images[u];
+        this.#e.get(d) === p && this.#e.delete(d), p && !h.has(p) && (p.close(), h.add(p));
+      }
+      throw l;
+    } finally {
+      try {
+        this.#n({ type: "ack", id: s });
+      } catch {
+      }
+    }
+  }
+  dispose() {
+    if (!this.#r) {
+      this.#r = !0;
+      try {
+        this.#n({ type: "dispose" });
+      } catch {
+      }
+      this.#i(), this.worker.terminate(), this.#p(new ve("Model decode Worker was disposed.")), this.#e.clear();
+    }
+  }
+  #n(e) {
+    this.worker.postMessage(e);
+  }
+  #o = (e) => {
+    const t = e.data;
+    if (t.type === "disposed") return;
+    if (t.type === "resolve-resource") {
+      this.#c(t.id, t.resourceId, t.url);
+      return;
+    }
+    if (t.type === "resource-complete") {
+      const n = this.#t.get(t.id), r = n?.resources.get(t.resourceId);
+      n && r !== void 0 && (n.resources.delete(t.resourceId), t.ok || n.manager?.itemError(r), n.manager?.itemEnd(r));
+      return;
+    }
+    const s = this.#t.get(t.id);
+    if (!s) {
+      if (t.type === "decoded") {
+        t.packet.images.forEach((n) => n.close());
+        try {
+          this.#n({ type: "ack", id: t.id });
+        } catch {
+        }
+      }
+      return;
+    }
+    if (this.#t.delete(t.id), s.cleanup?.(), t.type === "decoded")
+      this.#h(s), s.resolve(t.packet);
+    else if (t.type === "unsupported")
+      this.#h(s, void 0, !1), s.reject(new Kt(t.reason));
+    else {
+      const n = Fn(t.error);
+      this.#h(s, n), s.reject(n);
+    }
+  };
+  #c(e, t, s) {
+    const n = this.#t.get(e);
+    if (!n) {
+      try {
+        this.#n({
+          type: "resource-resolved",
+          id: e,
+          resourceId: t,
+          error: { message: "The model decode request is no longer active.", name: "AbortError" }
+        });
+      } catch {
+      }
+      return;
+    }
+    let r;
+    try {
+      r = n.manager?.resolveURL(s) ?? s, n.manager?.itemStart(r), n.manager && n.resources.set(t, r), this.#n({ type: "resource-resolved", id: e, resourceId: t, url: r });
+    } catch (a) {
+      r !== void 0 && n.resources.delete(t) && (n.manager?.itemError(r), n.manager?.itemEnd(r));
+      try {
+        this.#n({ type: "resource-resolved", id: e, resourceId: t, error: Wn(a) });
+      } catch (o) {
+        this.#u(o instanceof Error ? o : new Error(String(o)));
+      }
+    }
+  }
+  #l = (e) => {
+    this.#u(e.error instanceof Error ? e.error : new Error(e.message));
+  };
+  #d = () => {
+    this.#u(new Error("Failed to deserialize a model decode Worker response."));
+  };
+  #u(e) {
+    if (this.#r) return;
+    this.#r = !0, this.#i(), this.worker.terminate();
+    const t = new ve(
+      `Model decode Worker failed: ${e.message}`,
+      { cause: e }
+    );
+    this.#p(t), this.#e.clear(), this.#s?.(t);
+  }
+  #i() {
+    this.worker.removeEventListener("message", this.#o), this.worker.removeEventListener("error", this.#l), this.worker.removeEventListener("messageerror", this.#d);
+  }
+  #h(e, t, s = t !== void 0) {
+    for (const n of e.resources.values())
+      t && e.manager?.itemError(n), e.manager?.itemEnd(n);
+    e.resources.clear(), s && e.manager?.itemError(e.rootUrl), e.manager?.itemEnd(e.rootUrl);
+  }
+  #p(e) {
+    for (const t of this.#t.values())
+      t.cleanup?.(), this.#h(t, e), t.reject(e);
+    this.#t.clear();
+  }
+}
+const Gn = [
   "map",
   "alphaMap",
   "aoMap",
@@ -595,36 +1006,59 @@ const bn = [
   "thicknessMap",
   "transmissionMap"
 ];
-function oe(r) {
-  return r.traverse((e) => {
-    if (!(e instanceof P)) return;
+function ce(i) {
+  return i.traverse((e) => {
+    if (!(e instanceof k)) return;
     const t = Array.isArray(e.material) ? e.material : [e.material];
     for (const s of t) {
       if (!s) continue;
       let n = !1;
-      for (const i of bn) {
-        const a = s[i];
-        a?.isTexture && a.image == null && (a.dispose(), s[i] = null, n = !0);
+      for (const r of Gn) {
+        const a = s[r];
+        a?.isTexture && a.image == null && (a.dispose(), s[r] = null, n = !0);
       }
       n && (s.needsUpdate = !0);
     }
-  }), r;
+  }), i;
 }
-class X {
+class V {
   static CACHE_NAME = "u-space-model-loader-cache";
-  static fileLoader = new _t().setResponseType("arraybuffer");
-  static dracoLoader = new Hs().setDecoderPath(
-    `https://cdn.jsdelivr.net/npm/three@0.${ke}.0/examples/jsm/libs/draco/`
+  static fileLoader = new Wt().setResponseType("arraybuffer");
+  static dracoLoader = new cn().setDecoderPath(
+    `https://cdn.jsdelivr.net/npm/three@0.${Qe}.0/examples/jsm/libs/draco/`
   );
-  static ktx2Loader = new Fs().setTranscoderPath(
-    `https://cdn.jsdelivr.net/npm/three@0.${ke}.0/examples/jsm/libs/basis/`
+  static ktx2Loader = new ln().setTranscoderPath(
+    `https://cdn.jsdelivr.net/npm/three@0.${Qe}.0/examples/jsm/libs/basis/`
   );
-  static gltfLoader = new Tt().setDRACOLoader(X.dracoLoader).setKTX2Loader(X.ktx2Loader).setMeshoptDecoder(He);
-  static sbmxLoader = new tn().setDRACOLoader(X.dracoLoader).setKTX2Loader(X.ktx2Loader).setMeshoptDecoder(He);
-  static sbmLoader = new yn();
-  static fbxLoader = new ks();
-  static objLoader = new Us();
-  static stlLoader = new Ws();
+  static gltfLoader = new Re().setDRACOLoader(V.dracoLoader).setKTX2Loader(V.ktx2Loader).setMeshoptDecoder(Le);
+  static sbmxLoader = new at().setDRACOLoader(V.dracoLoader).setKTX2Loader(V.ktx2Loader).setMeshoptDecoder(Le);
+  static sbmLoader = new ct();
+  static fbxLoader = new Ze();
+  static objLoader = new an();
+  static stlLoader = new on();
+  static decodeWorkerClient = null;
+  /**
+   * Routes supported static glTF/GLB/SBMX models through a dedicated decoder
+   * Worker. ModelLoaderManager owns the supplied Worker and terminates it when
+   * replaced or cleared. The returned disposer only clears this specific
+   * Worker, so a late owner cleanup cannot terminate a newer replacement.
+   */
+  static setDecodeWorker(e) {
+    const t = this.decodeWorkerClient;
+    if (this.decodeWorkerClient = null, t?.dispose(), !e) return () => {
+    };
+    let s;
+    return s = new $n(e, {
+      onFatal: () => {
+        this.decodeWorkerClient === s && (this.decodeWorkerClient = null);
+      }
+    }), this.decodeWorkerClient = s, () => {
+      this.decodeWorkerClient === s && (this.decodeWorkerClient = null, s.dispose());
+    };
+  }
+  static get decodeWorkerEnabled() {
+    return this.decodeWorkerClient !== null && !this.decodeWorkerClient.disposed;
+  }
   static setLoadingManager(e) {
     this.fileLoader.manager = e, this.dracoLoader.manager = e, this.ktx2Loader.manager = e, this.gltfLoader.manager = e, this.sbmxLoader.manager = e, this.sbmLoader.manager = e, this.fbxLoader.manager = e, this.objLoader.manager = e, this.stlLoader.manager = e;
   }
@@ -647,48 +1081,124 @@ class X {
     this.ktx2Loader.setTranscoderPath(e);
   }
   static async loadAsync(e, t = { persistent: !0 }) {
-    const s = e.split(".").pop()?.split("?")[0].toLowerCase();
-    let n;
-    switch (t.persistent && typeof caches < "u" ? n = await this.getPersistentData(e) : n = await this.fileLoader.loadAsync(e), s) {
-      case "gltf":
-      case "glb":
-        const i = await this.gltfLoader.parseAsync(n, G.extractUrlBase(e));
-        return i.scene.animations = i.animations, oe(i.scene);
-      case "sbmx":
-        const a = await this.sbmxLoader.parseAsync(n, G.extractUrlBase(e));
-        return a.scene.animations = a.animations, oe(a.scene);
-      case "sbm":
-        const o = await this.sbmLoader.parseAsync(n, G.extractUrlBase(e));
-        return oe(o);
-      case "fbx":
-        const c = this.fbxLoader.parse(n, G.extractUrlBase(e));
-        return oe(c);
-      case "obj":
-        const l = new TextDecoder().decode(n), h = this.objLoader.parse(l);
-        return oe(h);
-      case "stl":
-        const u = this.stlLoader.parse(n);
-        return new P(u, new K());
-      default:
-        throw new Error(`Unsupported model format: ${s}`);
+    const s = e.split(/[?#]/, 1)[0].split(".").pop()?.toLowerCase(), n = t.persistent ?? !0, r = t.signal;
+    this.throwIfAborted(r);
+    const a = this.decodeWorkerClient;
+    if (a?.supports(e)) {
+      const h = this.fileLoader.manager.resolveURL(e), d = typeof location > "u" ? e : new URL(e, location.href).href, u = typeof location > "u" ? h : new URL(h, location.href).href;
+      try {
+        return await a.loadAsync(u, {
+          persistent: n,
+          headers: this.fileLoader.requestHeader,
+          credentials: this.fileLoader.withCredentials ? "include" : "same-origin",
+          resourceBaseUrl: d,
+          signal: r,
+          loadingManager: this.fileLoader.manager
+        });
+      } catch (p) {
+        if (this.throwIfAborted(r), !(p instanceof Kt) && !(p instanceof ve)) throw p;
+        console.info(`[ModelLoaderManager] Decode Worker fallback for ${e}: ${p.message}`);
+      }
+    }
+    const o = await this.loadSourceBuffer(e, n, r);
+    this.throwIfAborted(r);
+    const c = he.extractUrlBase(e), l = this.createParseLoadingManager(r);
+    try {
+      switch (s) {
+        case "gltf":
+        case "glb": {
+          const d = await this.configureGltfLoader(new Re(l.manager)).parseAsync(o, c);
+          return this.throwIfAborted(r), d.scene.animations = d.animations, ce(d.scene);
+        }
+        case "sbmx": {
+          const d = await this.configureGltfLoader(new at(l.manager)).parseAsync(o, c);
+          return this.throwIfAborted(r), d.scene.animations = d.animations, ce(d.scene);
+        }
+        case "sbm": {
+          const d = await new ct(l.manager).setCrossOrigin(this.sbmLoader.crossOrigin).setRequestHeader(this.sbmLoader.requestHeader).setWithCredentials(this.sbmLoader.withCredentials).parseAsync(o, c);
+          return this.throwIfAborted(r), ce(d);
+        }
+        case "fbx": {
+          const d = new Ze(l.manager).setCrossOrigin(this.fbxLoader.crossOrigin).setRequestHeader(this.fbxLoader.requestHeader).setWithCredentials(this.fbxLoader.withCredentials).parse(o, c);
+          return this.throwIfAborted(r), ce(d);
+        }
+        case "obj": {
+          const h = new TextDecoder().decode(o), d = this.objLoader.parse(h);
+          return this.throwIfAborted(r), ce(d);
+        }
+        case "stl": {
+          const h = this.stlLoader.parse(o);
+          return this.throwIfAborted(r), new k(h, new q());
+        }
+        default:
+          throw new Error(`Unsupported model format: ${s}`);
+      }
+    } finally {
+      l.cleanup();
     }
   }
-  static async getPersistentData(e) {
+  static configureGltfLoader(e) {
+    return e.setDRACOLoader(this.dracoLoader).setKTX2Loader(this.ktx2Loader).setMeshoptDecoder(Le).setCrossOrigin(this.gltfLoader.crossOrigin).setRequestHeader(this.gltfLoader.requestHeader).setWithCredentials(this.gltfLoader.withCredentials), e;
+  }
+  static createParseLoadingManager(e) {
+    this.throwIfAborted(e);
+    const t = this.fileLoader.manager, s = new As();
+    s.setURLModifier((r) => t.resolveURL(r)), s.itemStart = (r) => t.itemStart(r), s.itemEnd = (r) => t.itemEnd(r), s.itemError = (r) => t.itemError(r);
+    const n = () => s.abort();
+    return e?.addEventListener("abort", n, { once: !0 }), {
+      manager: s,
+      cleanup: () => e?.removeEventListener("abort", n)
+    };
+  }
+  static async loadSourceBuffer(e, t, s) {
+    this.throwIfAborted(s);
+    const n = this.fileLoader.manager, r = n.resolveURL(e);
+    n.itemStart(r);
     try {
-      const t = await caches.open(this.CACHE_NAME), s = await t.match(e);
-      if (s)
-        return await s.arrayBuffer();
-      const n = await this.fileLoader.loadAsync(e), i = new Response(n);
-      return await t.put(e, i), n;
-    } catch (t) {
-      return console.warn(`[LoaderManager] Failed to use Cache API for ${e}:`, t), await this.fileLoader.loadAsync(e);
+      let a;
+      if (t && typeof caches < "u")
+        try {
+          a = await caches.open(this.CACHE_NAME);
+          const d = await a.match(r);
+          if (this.throwIfAborted(s), d) {
+            const u = await d.arrayBuffer();
+            return this.throwIfAborted(s), u;
+          }
+        } catch (d) {
+          this.throwIfAborted(s), console.warn(`[ModelLoaderManager] Failed to read Cache Storage for ${r}:`, d);
+        }
+      const o = n.abortController.signal, c = s && typeof AbortSignal.any == "function" ? AbortSignal.any([s, o]) : s ?? o, l = await fetch(r, {
+        headers: this.fileLoader.requestHeader,
+        credentials: this.fileLoader.withCredentials ? "include" : "same-origin",
+        signal: c
+      });
+      if (!l.ok)
+        throw new Error(
+          `Failed to load model ${r}: ${l.status} ${l.statusText}`
+        );
+      const h = await l.arrayBuffer();
+      if (this.throwIfAborted(s), a)
+        try {
+          await a.put(r, new Response(h.slice(0)));
+        } catch (d) {
+          this.throwIfAborted(s), console.warn(`[ModelLoaderManager] Failed to write Cache Storage for ${r}:`, d);
+        }
+      return h;
+    } catch (a) {
+      throw n.itemError(r), a;
+    } finally {
+      n.itemEnd(r);
     }
   }
+  static throwIfAborted(e) {
+    if (e?.aborted)
+      throw e.reason ?? new DOMException("Aborted", "AbortError");
+  }
 }
-class Ti {
-  static textureLoader = new Ct();
-  static hdrLoader = new Gs();
-  static cubeTextureLoader = new os();
+class ii {
+  static textureLoader = new Ft();
+  static hdrLoader = new dn();
+  static cubeTextureLoader = new Os();
   static setLoadingManager(e) {
     this.textureLoader.manager = e, this.hdrLoader.manager = e, this.cubeTextureLoader.manager = e;
   }
@@ -697,13 +1207,13 @@ class Ti {
   }
   static async loadAsyncHDR(e) {
     const t = await this.hdrLoader.loadAsync(e);
-    return t.mapping = cs, t;
+    return t.mapping = Bs, t;
   }
   static async loadAsyncCubeTexture(e, t) {
     return this.cubeTextureLoader.setPath(e), await this.cubeTextureLoader.loadAsync(t);
   }
 }
-class q extends P {
+class X extends k {
   isBaseMesh = !0;
   type = "BaseMesh";
   castShadow = !0;
@@ -716,7 +1226,7 @@ class q extends P {
     return this.visible === !1 && this.ignoreInvisibleWhenRaycast === !0 ? !1 : super.raycast(e, t);
   }
 }
-class ue extends H {
+class pe extends W {
   isBaseGroup = !0;
   type = "BaseGroup";
   ignoreInvisibleWhenRaycast = !0;
@@ -727,7 +1237,7 @@ class ue extends H {
     return this.visible === !1 && this.ignoreInvisibleWhenRaycast === !0 ? !1 : super.raycast(e, t);
   }
 }
-class wn extends ls {
+class Kn extends _s {
   isBaseSprite = !0;
   type = "BaseSprite";
   ignoreInvisibleWhenRaycast = !0;
@@ -738,7 +1248,7 @@ class wn extends ls {
     return this.visible === !1 && this.ignoreInvisibleWhenRaycast === !0 ? !1 : super.raycast(e, t);
   }
 }
-class we extends ue {
+class te extends pe {
   isModel = !0;
   type = "Model";
   static memoryCache = /* @__PURE__ */ new Map();
@@ -749,24 +1259,34 @@ class we extends ue {
     super();
   }
   async loadAsync(e) {
-    const { url: t, cache: s = !0, persistent: n = !0 } = e;
+    const { url: t, cache: s = !0, persistent: n = !0, signal: r } = e;
     try {
-      let i;
-      s ? we.memoryCache.has(t) ? i = we.memoryCache.get(t) : (i = X.loadAsync(t, { persistent: n }), we.memoryCache.set(t, i)) : i = X.loadAsync(t, { persistent: n });
-      const a = await i, o = Le(a);
-      return this.add(o), o.animations && o.animations.length > 0 && (this.animations = o.animations, this.mixer = new hs(o)), o;
-    } catch (i) {
-      return console.error(`[Model] Failed to load model from ${t}:`, i), null;
+      let a;
+      if (s && !r)
+        if (te.memoryCache.has(t))
+          a = te.memoryCache.get(t);
+        else {
+          const h = V.loadAsync(t, { persistent: n, signal: r }).catch((d) => {
+            throw te.memoryCache.get(t) === h && te.memoryCache.delete(t), d;
+          });
+          te.memoryCache.set(t, h), a = h;
+        }
+      else
+        a = V.loadAsync(t, { persistent: n, signal: r });
+      const o = await a, c = We(o);
+      return this.add(c), c.animations && c.animations.length > 0 && (this.animations = c.animations, this.mixer = new Ts(c)), c;
+    } catch (a) {
+      return console.error(`[Model] Failed to load model from ${t}:`, a), null;
     }
   }
   playAnimation(e, t = {}) {
     if (!this.mixer || this.animations.length === 0) return null;
-    const { loop: s = !0, repetitions: n = 1 / 0, timeScale: i = 1, clampWhenFinished: a = !1 } = t;
+    const { loop: s = !0, repetitions: n = 1 / 0, timeScale: r = 1, clampWhenFinished: a = !1 } = t;
     let o;
     if (e === void 0 ? o = this.animations[0] : typeof e == "number" ? o = this.animations[e] : o = this.animations.find((l) => l.name === e), !o)
       return console.warn(`[Model] Animation not found: ${e}`), null;
     let c = this.actions.get(o.name);
-    return c || (c = this.mixer.clipAction(o), this.actions.set(o.name, c)), c.setLoop(s ? us : ds, n), c.clampWhenFinished = a, c.timeScale = i, c.reset().play(), c;
+    return c || (c = this.mixer.clipAction(o), this.actions.set(o.name, c)), c.setLoop(s ? Ls : Ns, n), c.clampWhenFinished = a, c.timeScale = r, c.reset().play(), c;
   }
   playAllAnimations(e = {}) {
     return this.animations.map((t, s) => this.playAnimation(s, e)).filter((t) => t !== null);
@@ -787,13 +1307,13 @@ class we extends ue {
    * Get the axis-aligned bounding box of this model.
    */
   getBoundingBox() {
-    return new $().setFromObject(this);
+    return new K().setFromObject(this);
   }
   /**
    * Get the center point of this model's bounding box.
    */
   getCenter() {
-    const e = new C();
+    const e = new D();
     return this.getBoundingBox().getCenter(e), e;
   }
   /**
@@ -801,21 +1321,21 @@ class we extends ue {
    */
   setMaterial(e) {
     this.traverse((t) => {
-      t instanceof P && (t.material = e);
+      t instanceof k && (t.material = e);
     });
   }
   static clearMemoryCache() {
     this.memoryCache.clear();
   }
   static async clearPersistentCache() {
-    typeof caches < "u" && await caches.delete("u-space-loader-cache");
+    typeof caches < "u" && await caches.delete("u-space-model-loader-cache");
   }
 }
-class xn extends q {
+class qn extends X {
   isSphereMesh = !0;
   type = "SphereMesh";
   constructor({ geometryParameters: e, materialParameters: t } = {}) {
-    super(), this.geometry = new ps(
+    super(), this.geometry = new Ds(
       e?.radius,
       e?.widthSegments,
       e?.heightSegments,
@@ -823,23 +1343,23 @@ class xn extends q {
       e?.phiLength,
       e?.thetaStart,
       e?.thetaLength
-    ), this.material = new K(t);
+    ), this.material = new q(t);
   }
 }
-class qe extends q {
+class lt extends X {
   isTubeMesh = !0;
   type = "TubeMesh";
   constructor({ geometryParameters: e, materialParameters: t } = {}) {
-    super(), this.geometry = new ms(
+    super(), this.geometry = new Ps(
       e?.path,
       e?.tubularSegments,
       e?.radius,
       e?.radialSegments,
       e?.closed
-    ), this.material = new K(t);
+    ), this.material = new q(t);
   }
 }
-class Li extends ue {
+class ai extends pe {
   isTopology = !0;
   type = "Topology";
   // Visuals
@@ -885,12 +1405,12 @@ class Li extends ue {
    * @param bidirectional If true, adds the reverse edge as well. Default true.
    */
   addEdge(e, t, s, n = !0) {
-    const i = this.nodes.get(e), a = this.nodes.get(t);
-    if (!i || !a) {
+    const r = this.nodes.get(e), a = this.nodes.get(t);
+    if (!r || !a) {
       console.error(`[Topology] Cannot add edge. One or both nodes not found: ${e}, ${t}`);
       return;
     }
-    const o = s ?? i.distanceTo(a);
+    const o = s ?? r.distanceTo(a);
     this.getNeighbors(e)?.set(t, o), n && this.getNeighbors(t)?.set(e, o);
   }
   /**
@@ -908,24 +1428,24 @@ class Li extends ue {
   getShortestPath(e, t) {
     if (!this.nodes.has(e) || !this.nodes.has(t))
       return console.warn("[Topology] Start or End node not found."), [];
-    const s = /* @__PURE__ */ new Map(), n = /* @__PURE__ */ new Map(), i = /* @__PURE__ */ new Set();
+    const s = /* @__PURE__ */ new Map(), n = /* @__PURE__ */ new Map(), r = /* @__PURE__ */ new Set();
     for (const [c] of this.nodes)
-      s.set(c, 1 / 0), n.set(c, null), i.add(c);
-    for (s.set(e, 0); i.size > 0; ) {
+      s.set(c, 1 / 0), n.set(c, null), r.add(c);
+    for (s.set(e, 0); r.size > 0; ) {
       let c = null, l = 1 / 0;
-      for (const u of i) {
-        const d = s.get(u);
-        d < l && (l = d, c = u);
+      for (const d of r) {
+        const u = s.get(d);
+        u < l && (l = u, c = d);
       }
       if (c === null || c === t || l === 1 / 0)
         break;
-      i.delete(c);
+      r.delete(c);
       const h = this.adjacencyMap?.get(c);
       if (h)
-        for (const [u, d] of h) {
-          if (!i.has(u)) continue;
-          const p = s.get(c) + d;
-          p < s.get(u) && (s.set(u, p), n.set(u, c));
+        for (const [d, u] of h) {
+          if (!r.has(d)) continue;
+          const p = s.get(c) + u;
+          p < s.get(d) && (s.set(d, p), n.set(d, c));
         }
     }
     const a = [];
@@ -942,8 +1462,8 @@ class Li extends ue {
    * Renders the entire topology graph structure using TubeGeometry and Spheres.
    */
   renderGraph() {
-    this.clearGraph(), this.graphGroup = new H();
-    const e = new xn({
+    this.clearGraph(), this.graphGroup = new W();
+    const e = new qn({
       geometryParameters: {
         radius: this.parameters.nodeRadius,
         widthSegments: 16,
@@ -954,18 +1474,18 @@ class Li extends ue {
       }
     });
     this.nodes.forEach((s, n) => {
-      const i = e.clone();
-      i.position.copy(s), Object.assign(i.userData, { id: n, type: "node" }), this.graphGroup.add(i);
+      const r = e.clone();
+      r.position.copy(s), Object.assign(r.userData, { id: n, type: "node" }), this.graphGroup.add(r);
     });
     const t = /* @__PURE__ */ new Set();
     this.adjacencyMap.forEach((s, n) => {
-      s.forEach((i, a) => {
+      s.forEach((r, a) => {
         const o = [n, a].sort().join("-");
         if (t.has(o)) return;
         t.add(o);
         const c = this.nodes.get(n), l = this.nodes.get(a);
         if (c && l) {
-          const h = new fs(c, l), u = new qe({
+          const h = new Rs(c, l), d = new lt({
             geometryParameters: {
               path: h,
               tubularSegments: 1,
@@ -977,14 +1497,14 @@ class Li extends ue {
               color: this.parameters.edgeColor
             }
           });
-          Object.assign(u.userData, { from: n, to: a, weight: i, type: "edge" }), this.graphGroup.add(u);
+          Object.assign(d.userData, { from: n, to: a, weight: r, type: "edge" }), this.graphGroup.add(d);
         }
       });
     }), this.add(this.graphGroup);
   }
   clearGraph() {
     this.graphGroup && (this.remove(this.graphGroup), this.graphGroup.traverse((e) => {
-      e instanceof P && (e.geometry.dispose(), e.material.dispose());
+      e instanceof k && (e.geometry.dispose(), e.material.dispose());
     }), this.graphGroup = null);
   }
   /**
@@ -992,7 +1512,7 @@ class Li extends ue {
    */
   renderPath(e, t = this.parameters.pathColor) {
     if (e.length < 2) return;
-    const s = new gs(e, !1, "catmullrom", 0), n = new qe({
+    const s = new ks(e, !1, "catmullrom", 0), n = new lt({
       geometryParameters: {
         path: s,
         tubularSegments: e.length * 10,
@@ -1013,14 +1533,14 @@ class Li extends ue {
   /** Export nodes and edges as a JSON-serializable object. */
   exportData() {
     const e = {};
-    this.nodes.forEach((n, i) => {
-      e[i] = { x: n.x, y: n.y, z: n.z };
+    this.nodes.forEach((n, r) => {
+      e[r] = { x: n.x, y: n.y, z: n.z };
     });
     const t = [], s = /* @__PURE__ */ new Set();
-    return this.adjacencyMap.forEach((n, i) => {
+    return this.adjacencyMap.forEach((n, r) => {
       n.forEach((a, o) => {
-        const c = [i, o].sort().join("-");
-        s.has(c) || (s.add(c), t.push({ from: i, to: o, weight: a }));
+        const c = [r, o].sort().join("-");
+        s.has(c) || (s.add(c), t.push({ from: r, to: o, weight: a }));
       });
     }), { nodes: e, edges: t };
   }
@@ -1030,7 +1550,7 @@ class Li extends ue {
    */
   importData(e) {
     this.clearGraph(), this.clearPaths(), this.nodes.clear(), this.adjacencyMap.clear(), Object.entries(e.nodes).forEach(([t, s]) => {
-      this.addNode(t, new C(s.x, s.y, s.z));
+      this.addNode(t, new D(s.x, s.y, s.z));
     }), e.edges.forEach(({ from: t, to: s, weight: n }) => {
       this.addEdge(t, s, n);
     }), this.renderGraph();
@@ -1042,7 +1562,7 @@ class Li extends ue {
     return this.adjacencyMap.get(e);
   }
 }
-class Pi extends wn {
+class oi extends Kn {
   isPoi = !0;
   type = "Poi";
   parameters = {
@@ -1061,7 +1581,7 @@ class Pi extends wn {
   _canvas = document.createElement("canvas");
   _lastParametersJSON = "";
   constructor(e = {}) {
-    super(new ys()), Object.assign(this.parameters, e), this.updateAsync();
+    super(new zs()), Object.assign(this.parameters, e), this.updateAsync();
   }
   /**
    * Update the POI with new parameters
@@ -1075,35 +1595,35 @@ class Pi extends wn {
     const s = this._canvas, n = s.getContext("2d");
     if (!n) return;
     n.font = `${this.parameters.fontSize}px ${this.parameters.fontFamily}`;
-    let i = null;
-    this.parameters.img && (i = await this._loadImage(this.parameters.img));
-    const { text: a, fontSize: o, color: c, iconSize: l, padding: h, backgroundColor: u, borderRadius: d, textPosition: p, scaleFactor: m } = this.parameters, b = n.measureText(a), S = a ? b.width : 0, w = a ? o : 0;
-    let g = 0, I = 0, B = 0, O = 0, T = 0, y = 0;
-    const _ = !!i, k = !!a;
-    if (_ && k)
+    let r = null;
+    this.parameters.img && (r = await this._loadImage(this.parameters.img));
+    const { text: a, fontSize: o, color: c, iconSize: l, padding: h, backgroundColor: d, borderRadius: u, textPosition: p, scaleFactor: x } = this.parameters, I = n.measureText(a), _ = a ? I.width : 0, C = a ? o : 0;
+    let y = 0, w = 0, g = 0, m = 0, M = 0, b = 0;
+    const S = !!r, A = !!a;
+    if (S && A)
       switch (p) {
         case "top":
-          g = Math.max(l, S), I = l + h + w, T = (g - S) / 2, y = w / 2, B = (g - l) / 2, O = w + h;
+          y = Math.max(l, _), w = l + h + C, M = (y - _) / 2, b = C / 2, g = (y - l) / 2, m = C + h;
           break;
         case "bottom":
-          g = Math.max(l, S), I = l + h + w, B = (g - l) / 2, O = 0, T = (g - S) / 2, y = l + h + w / 2;
+          y = Math.max(l, _), w = l + h + C, g = (y - l) / 2, m = 0, M = (y - _) / 2, b = l + h + C / 2;
           break;
         case "left":
-          g = l + h + S, I = Math.max(l, w), T = 0, y = I / 2, B = S + h, O = (I - l) / 2;
+          y = l + h + _, w = Math.max(l, C), M = 0, b = w / 2, g = _ + h, m = (w - l) / 2;
           break;
         default:
-          g = l + h + S, I = Math.max(l, w), B = 0, O = (I - l) / 2, T = l + h, y = I / 2;
+          y = l + h + _, w = Math.max(l, C), g = 0, m = (w - l) / 2, M = l + h, b = w / 2;
           break;
       }
-    else _ ? (g = l, I = l, B = 0, O = 0) : k && (g = S, I = w, T = 0, y = w / 2);
-    const N = g + h * 2, D = I + h * 2;
-    if (s.width = N, s.height = D, n.font = `${o}px ${this.parameters.fontFamily}`, u && (n.fillStyle = u, this._drawRoundedRect(n, 0, 0, N, D, d), n.fill()), _ && n.drawImage(i, B + h, O + h, l, l), k) {
+    else S ? (y = l, w = l, g = 0, m = 0) : A && (y = _, w = C, M = 0, b = C / 2);
+    const v = y + h * 2, E = w + h * 2;
+    if (s.width = v, s.height = E, n.font = `${o}px ${this.parameters.fontFamily}`, d && (n.fillStyle = d, this._drawRoundedRect(n, 0, 0, v, E, u), n.fill()), S && n.drawImage(r, g + h, m + h, l, l), A) {
       n.fillStyle = c;
-      const f = n.measureText(a), E = f.actualBoundingBoxAscent + f.actualBoundingBoxDescent, M = f.actualBoundingBoxAscent - E / 2;
-      n.textBaseline = "alphabetic", n.fillText(a, T + h, y + h + M);
+      const f = n.measureText(a), L = f.actualBoundingBoxAscent + f.actualBoundingBoxDescent, O = f.actualBoundingBoxAscent - L / 2;
+      n.textBaseline = "alphabetic", n.fillText(a, M + h, b + h + O);
     }
-    const Y = this.material.map, R = new bs(s);
-    R.colorSpace = Ot, this.material.map = R, Y?.dispose(), this.scale.set(N * m, D * m, 1);
+    const z = this.material.map, N = new Us(s);
+    N.colorSpace = Se, this.material.map = N, z?.dispose(), this.scale.set(v * x, E * x, 1);
   }
   _loadImage(e) {
     return new Promise((t, s) => {
@@ -1114,256 +1634,256 @@ class Pi extends wn {
         t(e);
     });
   }
-  _drawRoundedRect(e, t, s, n, i, a) {
-    e.beginPath(), e.moveTo(t + a, s), e.lineTo(t + n - a, s), e.quadraticCurveTo(t + n, s, t + n, s + a), e.lineTo(t + n, s + i - a), e.quadraticCurveTo(t + n, s + i, t + n - a, s + i), e.lineTo(t + a, s + i), e.quadraticCurveTo(t, s + i, t, s + i - a), e.lineTo(t, s + a), e.quadraticCurveTo(t, s, t + a, s), e.closePath();
+  _drawRoundedRect(e, t, s, n, r, a) {
+    e.beginPath(), e.moveTo(t + a, s), e.lineTo(t + n - a, s), e.quadraticCurveTo(t + n, s, t + n, s + a), e.lineTo(t + n, s + r - a), e.quadraticCurveTo(t + n, s + r, t + n - a, s + r), e.lineTo(t + a, s + r), e.quadraticCurveTo(t, s + r, t, s + r - a), e.lineTo(t, s + a), e.quadraticCurveTo(t, s, t + a, s), e.closePath();
   }
   dispose() {
     this.material.map?.dispose(), this.material.dispose();
   }
 }
-class Nt extends q {
+class Xt extends X {
   isShapeMesh = !0;
   type = "ShapeMesh";
   constructor({ geometryParameters: e, materialParameters: t } = {}) {
-    super(), this.geometry = new ws(e?.shape, e?.curveSegments), this.material = new K(t), this.geometry.rotateX(-Math.PI / 2);
+    super(), this.geometry = new js(e?.shape, e?.curveSegments), this.material = new q(t), this.geometry.rotateX(-Math.PI / 2);
   }
   static createFromPoints(e, t = {}) {
-    return new Nt({
+    return new Xt({
       ...t,
       geometryParameters: {
         ...t.geometryParameters,
-        shape: new At(e.map((s) => new z(s.x, -s.z)))
+        shape: new Gt(e.map((s) => new j(s.x, -s.z)))
       }
     });
   }
 }
-class zt extends q {
+class Yt extends X {
   isExtrudeMesh = !0;
   type = "ExtrudeMesh";
   constructor({ geometryParameters: e, materialParameters: t } = {}) {
-    super(), this.geometry = new xs(e?.shape, e?.options), this.material = new K(t), this.geometry.rotateX(-Math.PI / 2);
+    super(), this.geometry = new Ws(e?.shape, e?.options), this.material = new q(t), this.geometry.rotateX(-Math.PI / 2);
   }
   static createFromPoints(e, t = {}) {
-    return e && e.length === 0 && (e = void 0), new zt({
+    return e && e.length === 0 && (e = void 0), new Yt({
       ...t,
       geometryParameters: {
         ...t.geometryParameters,
-        shape: new At(e?.map((s) => new z(s.x, -s.z)))
+        shape: new Gt(e?.map((s) => new j(s.x, -s.z)))
       }
     });
   }
 }
-class Ni extends q {
+class ci extends X {
   isPlaneMesh = !0;
   type = "PlaneMesh";
   constructor({ geometryParameters: e, materialParameters: t } = {}) {
-    super(), this.geometry = new Ms(
+    super(), this.geometry = new Fs(
       e?.width,
       e?.height,
       e?.widthSegments,
       e?.heightSegments
-    ), this.material = new K(t);
+    ), this.material = new q(t);
   }
 }
-class zi extends q {
+class li extends X {
   isCircleMesh = !0;
   type = "CircleMesh";
   constructor({ geometryParameters: e, materialParameters: t } = {}) {
     super(
-      new Is(
+      new Hs(
         e?.radius,
         e?.segments,
         e?.thetaStart,
         e?.thetaLength
       ),
-      new K(t)
+      new q(t)
     ), this.geometry.rotateX(-Math.PI / 2);
   }
 }
-class J {
+class Q {
   static traverseMeshes(e, t) {
     e.traverse((s) => {
-      s instanceof P && t(s);
+      s instanceof k && t(s);
     });
   }
 }
-const Mn = 3, In = 1, Sn = 0, vn = 2, Bn = 1e-3, Ye = new C(), Z = new C(), En = new Ss();
-function Ve(r) {
-  return r.isInstanceObject === !0;
+const Vn = 3, Xn = 1, Yn = 0, Qn = 2, Jn = 1e-3, ht = new D(), J = new D(), Zn = new $s();
+function dt(i) {
+  return i.isInstanceObject === !0;
 }
-function Je(r) {
+function ut(i) {
   let e = !1;
-  return r.traverse((t) => {
+  return i.traverse((t) => {
     if (e) return;
     const s = t;
     e = s.isMesh === !0 || s.isSprite === !0;
   }), e;
 }
-function _n(r) {
-  let e = r;
+function er(i) {
+  let e = i;
   for (; e; ) {
     if (!e.visible) return !1;
     e = e.parent;
   }
   return !0;
 }
-function Ze(r) {
-  return r === void 0 || !Number.isFinite(r) || r <= 0 ? vn : r;
+function pt(i) {
+  return i === void 0 || !Number.isFinite(i) || i <= 0 ? Qn : i;
 }
-class Di {
+class hi {
   static flow(e = {}) {
-    const { baseColor: t = 16777215, flowColor: s = 65280, speed: n = 1, scale: i = 3, intensity: a = 4 } = e, o = V(new A(t)), c = V(new A(s)), l = Fe().x.mul(i).sub(ge.mul(n)), h = ye(Ce(l).add(1).mul(0.5), a);
-    return be(o, c, h);
+    const { baseColor: t = 16777215, flowColor: s = 65280, speed: n = 1, scale: r = 3, intensity: a = 4 } = e, o = Y(new P(t)), c = Y(new P(s)), l = tt().x.mul(r).sub(we.mul(n)), h = xe(ke(l).add(1).mul(0.5), a);
+    return Me(o, c, h);
   }
   static breathe(e = {}) {
-    const { baseColor: t = 16777215, breathColor: s = 65280, speed: n = 1, intensity: i = 2 } = e, a = V(new A(t)), o = V(new A(s)), c = Ce(ge.mul(n)).add(1).mul(0.5), l = ye(c, i);
-    return be(a, o, l);
+    const { baseColor: t = 16777215, breathColor: s = 65280, speed: n = 1, intensity: r = 2 } = e, a = Y(new P(t)), o = Y(new P(s)), c = ke(we.mul(n)).add(1).mul(0.5), l = xe(c, r);
+    return Me(a, o, l);
   }
   static fluid(e = {}) {
     const {
       baseColor: t = 16777215,
       flowColor: s = 255,
       speed: n = 1,
-      scale: i = 1,
+      scale: r = 1,
       intensity: a = 1,
       distortion: o = 0.5
-    } = e, c = V(new A(t)), l = V(new A(s)), h = Fe().mul(i), u = ge.mul(n), d = Ge(h.add(u), 1, 0), p = h.add(d.mul(o)), m = Ge(p, 1, 0).add(1).mul(0.5), b = ye(m, a);
-    return be(c, l, b);
+    } = e, c = Y(new P(t)), l = Y(new P(s)), h = tt().mul(r), d = we.mul(n), u = st(h.add(d), 1, 0), p = h.add(u.mul(o)), x = st(p, 1, 0).add(1).mul(0.5), I = xe(x, a);
+    return Me(c, l, I);
   }
   static outline(e = {}) {
     let t = [...e.selectedObjects ?? []];
-    const s = [], n = /* @__PURE__ */ new Map(), i = new $();
-    let a = null, o = null, c = null, l = null, h = null, u = e.instanceBoundsProxy ?? !0, d = e.instanceBoundsPadding ?? 0, p = e.instanceBoundsMinSize ?? Bn, m = Ze(e.downSampleRatio);
-    const b = ae(e.edgeStrength ?? Mn), S = ae(e.edgeThickness ?? In), w = ae(e.edgeGlow ?? Sn), g = ae(new A(e.visibleEdgeColor ?? 16777215)), I = ae(new A(e.hiddenEdgeColor ?? 5125686)), B = () => (l ??= new vs(1, 1, 1), l), O = () => (h || (h = new Bs({ color: 16777215 }), h.colorWrite = !1, h.depthWrite = !1, h.name = "u-space.outline.instanceBoundsProxy"), h), T = (f) => {
-      const { source: E, mesh: M } = f, v = E.getInstanceBoundingBox?.(i, !0);
-      if (!v || v.isEmpty() || !_n(E)) {
-        M.visible = !1;
+    const s = [], n = /* @__PURE__ */ new Map(), r = new K();
+    let a = null, o = null, c = null, l = null, h = null, d = e.instanceBoundsProxy ?? !0, u = e.instanceBoundsPadding ?? 0, p = e.instanceBoundsMinSize ?? Jn, x = pt(e.downSampleRatio);
+    const I = ae(e.edgeStrength ?? Vn), _ = ae(e.edgeThickness ?? Xn), C = ae(e.edgeGlow ?? Yn), y = ae(new P(e.visibleEdgeColor ?? 16777215)), w = ae(new P(e.hiddenEdgeColor ?? 5125686)), g = () => (l ??= new Gs(1, 1, 1), l), m = () => (h || (h = new Ks({ color: 16777215 }), h.colorWrite = !1, h.depthWrite = !1, h.name = "u-space.outline.instanceBoundsProxy"), h), M = (f) => {
+      const { source: L, mesh: O } = f, B = L.getInstanceBoundingBox?.(r, !0);
+      if (!B || B.isEmpty() || !er(L)) {
+        O.visible = !1;
         return;
       }
-      v.getCenter(Ye), v.getSize(Z);
-      const j = Math.max(0, d), re = Math.max(0, p);
-      Z.set(
-        Math.max(Z.x + j * 2, re),
-        Math.max(Z.y + j * 2, re),
-        Math.max(Z.z + j * 2, re)
-      ), M.visible = !0, M.layers.mask = E.layers.mask, M.matrix.compose(Ye, En, Z), M.matrixWorldNeedsUpdate = !0;
-    }, y = (f) => {
+      B.getCenter(ht), B.getSize(J);
+      const U = Math.max(0, u), ie = Math.max(0, p);
+      J.set(
+        Math.max(J.x + U * 2, ie),
+        Math.max(J.y + U * 2, ie),
+        Math.max(J.z + U * 2, ie)
+      ), O.visible = !0, O.layers.mask = L.layers.mask, O.matrix.compose(ht, Zn, J), O.matrixWorldNeedsUpdate = !0;
+    }, b = (f) => {
       f.unsubscribe?.(), f.mesh.removeFromParent();
-    }, _ = (f, E) => {
-      let M = n.get(f);
-      if (!M) {
-        const v = new P(B(), O());
-        v.name = `u-space.outline.instanceBoundsProxy:${f.uuid}`, v.matrixAutoUpdate = !1, v.castShadow = !1, v.receiveShadow = !1, v.frustumCulled = !1, v.raycast = () => {
-        }, v.userData.instanceObject = f, M = {
+    }, S = (f, L) => {
+      let O = n.get(f);
+      if (!O) {
+        const B = new k(g(), m());
+        B.name = `u-space.outline.instanceBoundsProxy:${f.uuid}`, B.matrixAutoUpdate = !1, B.castShadow = !1, B.receiveShadow = !1, B.frustumCulled = !1, B.raycast = () => {
+        }, B.userData.instanceObject = f, O = {
           source: f,
-          mesh: v,
-          unsubscribe: f.onInstanceRenderDirty?.(() => T(M)) ?? null
-        }, n.set(f, M);
+          mesh: B,
+          unsubscribe: f.onInstanceRenderDirty?.(() => M(O)) ?? null
+        }, n.set(f, O);
       }
-      return M.mesh.parent !== E && (M.mesh.removeFromParent(), E.add(M.mesh)), T(M), M.mesh.visible ? M.mesh : null;
-    }, k = (f, E) => {
-      const M = f.getInstanceRenderObject?.();
-      return M && Je(M) ? M : Je(f) ? f : u && f.getInstanceBoundingBox ? _(f, E) : null;
-    }, N = (f) => {
-      const E = /* @__PURE__ */ new Set(), M = /* @__PURE__ */ new Set();
-      for (const v of t) {
-        const j = Ve(v) ? k(v, f) : v;
-        j && (E.add(j), Ve(v) && n.get(v)?.mesh === j && M.add(v));
+      return O.mesh.parent !== L && (O.mesh.removeFromParent(), L.add(O.mesh)), M(O), O.mesh.visible ? O.mesh : null;
+    }, A = (f, L) => {
+      const O = f.getInstanceRenderObject?.();
+      return O && ut(O) ? O : ut(f) ? f : d && f.getInstanceBoundingBox ? S(f, L) : null;
+    }, v = (f) => {
+      const L = /* @__PURE__ */ new Set(), O = /* @__PURE__ */ new Set();
+      for (const B of t) {
+        const U = dt(B) ? A(B, f) : B;
+        U && (L.add(U), dt(B) && n.get(B)?.mesh === U && O.add(B));
       }
-      n.forEach((v, j) => {
-        M.has(j) || (y(v), n.delete(j));
-      }), s.length = 0, E.forEach((v) => s.push(v));
-    }, D = () => {
+      n.forEach((B, U) => {
+        O.has(U) || (b(B), n.delete(U));
+      }), s.length = 0, L.forEach((B) => s.push(B));
+    }, E = () => {
       a?.dispose(), a = null;
-    }, Y = (f, E) => {
-      if (a && o === f && c === E)
-        return a.downSampleRatio = m, a;
-      D(), o = f, c = E, a = Js(f, E, {
+    }, z = (f, L) => {
+      if (a && o === f && c === L)
+        return a.downSampleRatio = x, a;
+      E(), o = f, c = L, a = wn(f, L, {
         selectedObjects: s,
-        edgeThickness: S,
-        edgeGlow: w,
-        downSampleRatio: m
+        edgeThickness: _,
+        edgeGlow: C,
+        downSampleRatio: x
       });
-      const M = a.updateBefore.bind(a);
-      return a.updateBefore = (v) => (N(f), M(v)), a;
-    }, R = ((f, E) => {
-      const M = f.scene, v = f.camera;
-      N(M);
-      const j = Y(M, v), re = j.visibleEdge.mul(g).add(j.hiddenEdge.mul(I)).mul(b);
-      return $s(E, Ks(re, 0));
+      const O = a.updateBefore.bind(a);
+      return a.updateBefore = (B) => (v(f), O(B)), a;
+    }, N = ((f, L) => {
+      const O = f.scene, B = f.camera;
+      v(O);
+      const U = z(O, B), ie = U.visibleEdge.mul(y).add(U.hiddenEdge.mul(w)).mul(I);
+      return un(L, pn(ie, 0));
     });
-    return Object.defineProperties(R, {
+    return Object.defineProperties(N, {
       outlineNode: {
         get: () => a
       },
       selectedObjects: {
         get: () => t
       }
-    }), R.setSelectedObjects = (f) => (t = [...f], o && N(o), R), R.update = (f) => (f.edgeStrength !== void 0 && (b.value = f.edgeStrength), f.edgeThickness !== void 0 && (S.value = f.edgeThickness), f.edgeGlow !== void 0 && (w.value = f.edgeGlow), f.visibleEdgeColor !== void 0 && g.value.set(f.visibleEdgeColor), f.hiddenEdgeColor !== void 0 && I.value.set(f.hiddenEdgeColor), f.instanceBoundsProxy !== void 0 && (u = f.instanceBoundsProxy), f.instanceBoundsPadding !== void 0 && (d = f.instanceBoundsPadding), f.instanceBoundsMinSize !== void 0 && (p = f.instanceBoundsMinSize), f.downSampleRatio !== void 0 && (m = Ze(f.downSampleRatio), a && (a.downSampleRatio = m)), o && N(o), R), R.dispose = () => {
-      D(), n.forEach(y), n.clear(), l?.dispose(), h?.dispose(), l = null, h = null, t = [], s.length = 0, o = null, c = null;
-    }, R;
+    }), N.setSelectedObjects = (f) => (t = [...f], o && v(o), N), N.update = (f) => (f.edgeStrength !== void 0 && (I.value = f.edgeStrength), f.edgeThickness !== void 0 && (_.value = f.edgeThickness), f.edgeGlow !== void 0 && (C.value = f.edgeGlow), f.visibleEdgeColor !== void 0 && y.value.set(f.visibleEdgeColor), f.hiddenEdgeColor !== void 0 && w.value.set(f.hiddenEdgeColor), f.instanceBoundsProxy !== void 0 && (d = f.instanceBoundsProxy), f.instanceBoundsPadding !== void 0 && (u = f.instanceBoundsPadding), f.instanceBoundsMinSize !== void 0 && (p = f.instanceBoundsMinSize), f.downSampleRatio !== void 0 && (x = pt(f.downSampleRatio), a && (a.downSampleRatio = x)), o && v(o), N), N.dispose = () => {
+      E(), n.forEach(b), n.clear(), l?.dispose(), h?.dispose(), l = null, h = null, t = [], s.length = 0, o = null, c = null;
+    }, N;
   }
 }
-function Ri(r) {
+function di(i) {
 }
-const ie = "uSpaceHighlight", he = `${ie}/enabled`, Dt = `${ie}/opacity`, Rt = `${ie}/color`, jt = `${ie}/overwrite`, kt = `${ie}/multiplyOpacity`, Me = `${ie}/instancedOriginalOpacity`, ve = "uSpaceBreathe", Ie = `${ve}/enabled`, Ut = `${ve}/color`, Wt = `${ve}/speed`, Ht = `${ve}/intensity`, Se = /* @__PURE__ */ new WeakMap(), Cn = Lt(() => {
-  const r = U(he, "uint"), e = U(Rt, "uint"), t = U(jt, "uint"), s = st(e), n = xe.mul(s), i = F(t.greaterThan(0), s, n), a = F(r.greaterThan(0), i, xe), o = U(Ie, "uint"), c = U(Ut, "uint"), l = U(Wt, "float"), h = U(Ht, "float"), u = st(c), d = Ce(ge.mul(l)).add(1).mul(0.5), p = ye(d, h), m = be(a, u, p);
-  return F(o.greaterThan(0), m, a);
-})(), On = Lt(() => {
-  const r = U(he, "uint"), e = U(Dt, "float"), t = U(kt, "uint"), s = F(t.greaterThan(0), Oe.mul(e), e);
-  return F(r.greaterThan(0), s, Oe);
+const re = "uSpaceHighlight", ue = `${re}/enabled`, Qt = `${re}/opacity`, Jt = `${re}/color`, Zt = `${re}/overwrite`, es = `${re}/multiplyOpacity`, Ae = `${re}/instancedOriginalOpacity`, _e = "uSpaceBreathe", Oe = `${_e}/enabled`, ts = `${_e}/color`, ss = `${_e}/speed`, ns = `${_e}/intensity`, Be = /* @__PURE__ */ new WeakMap(), tr = qt(() => {
+  const i = F(ue, "uint"), e = F(Jt, "uint"), t = F(Zt, "uint"), s = gt(e), n = Ce.mul(s), r = $(t.greaterThan(0), s, n), a = $(i.greaterThan(0), r, Ce), o = F(Oe, "uint"), c = F(ts, "uint"), l = F(ss, "float"), h = F(ns, "float"), d = gt(c), u = ke(we.mul(l)).add(1).mul(0.5), p = xe(u, h), x = Me(a, d, p);
+  return $(o.greaterThan(0), x, a);
+})(), sr = qt(() => {
+  const i = F(ue, "uint"), e = F(Qt, "float"), t = F(es, "uint"), s = $(t.greaterThan(0), ze.mul(e), e);
+  return $(i.greaterThan(0), s, ze);
 })();
-function le(r) {
-  return Array.isArray(r.material) ? r.material : [r.material];
+function de(i) {
+  return Array.isArray(i.material) ? i.material : [i.material];
 }
-function et(r) {
-  le(r).forEach((t) => {
+function ft(i) {
+  de(i).forEach((t) => {
     if (!t) return;
-    let s = Se.get(t);
+    let s = Be.get(t);
     s || (s = {
       colorNode: t.colorNode,
       opacityNode: t.opacityNode,
       transparent: t.transparent,
       depthWrite: t.depthWrite,
       activeMeshes: /* @__PURE__ */ new Set()
-    }, Se.set(t, s)), s.activeMeshes.add(r), t.transparent = !0, t.colorNode = Cn, t.opacityNode = On, t.needsUpdate = !0;
+    }, Be.set(t, s)), s.activeMeshes.add(i), t.transparent = !0, t.colorNode = tr, t.opacityNode = sr, t.needsUpdate = !0;
   });
 }
-function tt(r) {
-  const e = r.userData[he], t = r.userData[Ie];
+function mt(i) {
+  const e = i.userData[ue], t = i.userData[Oe];
   if (e || t) return;
-  le(r).forEach((n) => {
+  de(i).forEach((n) => {
     if (!n) return;
-    const i = Se.get(n);
-    i && (i.activeMeshes.delete(r), !(i.activeMeshes.size > 0) && (n.colorNode = i.colorNode, n.opacityNode = i.opacityNode, n.transparent = i.transparent, n.depthWrite = i.depthWrite, n.needsUpdate = !0, Se.delete(n)));
+    const r = Be.get(n);
+    r && (r.activeMeshes.delete(i), !(r.activeMeshes.size > 0) && (n.colorNode = r.colorNode, n.opacityNode = r.opacityNode, n.transparent = r.transparent, n.depthWrite = r.depthWrite, n.needsUpdate = !0, Be.delete(n)));
   });
 }
-function An(r, e, t, s) {
-  const n = r, i = n.setInstanceHighlight;
-  if (i)
-    return i.call(r, e, t, s), !0;
+function nr(i, e, t, s) {
+  const n = i, r = n.setInstanceHighlight;
+  if (r)
+    return r.call(i, e, t, s), !0;
   const a = n.setInstanceColor, o = n.setInstanceOpacity, c = n.getInstanceOpacity, l = n.getInstanceColor, h = n.hasInstanceColor;
-  return !a || !o ? !1 : (r.userData[Me] === void 0 && (r.userData[Me] = {
-    hasColor: h?.call(r) ?? !1,
-    color: l?.call(r, new A()).getHex() ?? 16777215,
-    opacity: c?.call(r) ?? 1
-  }), a.call(r, e), o.call(r, t), !0);
-}
-function Tn(r) {
-  const e = r, t = e.clearInstanceHighlight;
+  return !a || !o ? !1 : (i.userData[Ae] === void 0 && (i.userData[Ae] = {
+    hasColor: h?.call(i) ?? !1,
+    color: l?.call(i, new P()).getHex() ?? 16777215,
+    opacity: c?.call(i) ?? 1
+  }), a.call(i, e), o.call(i, t), !0);
+}
+function rr(i) {
+  const e = i, t = e.clearInstanceHighlight;
   if (t)
-    return t.call(r), !0;
-  const s = e.resetInstanceColor, n = e.setInstanceColor, i = e.setInstanceOpacity;
-  if (!s || !i) return !1;
-  const a = r.userData[Me];
-  return a && (a.hasColor && n ? n.call(r, a.color) : s.call(r), i.call(r, a.opacity), Reflect.deleteProperty(r.userData, Me)), !0;
+    return t.call(i), !0;
+  const s = e.resetInstanceColor, n = e.setInstanceColor, r = e.setInstanceOpacity;
+  if (!s || !r) return !1;
+  const a = i.userData[Ae];
+  return a && (a.hasColor && n ? n.call(i, a.color) : s.call(i), r.call(i, a.opacity), Reflect.deleteProperty(i.userData, Ae)), !0;
 }
 class se {
   static highlightColor(e, t = {}) {
-    const s = Array.isArray(e) ? e : [e], { opacity: n = 0.5, color: i = 16711680, overwrite: a = !1, depthWrite: o, multiplyOpacity: c = !1 } = t, l = new A(i).getHex();
+    const s = Array.isArray(e) ? e : [e], { opacity: n = 0.5, color: r = 16711680, overwrite: a = !1, depthWrite: o, multiplyOpacity: c = !1 } = t, l = new P(r).getHex();
     for (const h of s)
-      An(h, i, n, a) || J.traverseMeshes(h, (u) => {
-        u.userData[he] = 1, u.userData[Dt] = n, u.userData[Rt] = l, u.userData[jt] = a ? 1 : 0, u.userData[kt] = c ? 1 : 0, et(u), o !== void 0 && le(u).forEach((p) => {
+      nr(h, r, n, a) || Q.traverseMeshes(h, (d) => {
+        d.userData[ue] = 1, d.userData[Qt] = n, d.userData[Jt] = l, d.userData[Zt] = a ? 1 : 0, d.userData[es] = c ? 1 : 0, ft(d), o !== void 0 && de(d).forEach((p) => {
           p && (p.depthWrite = o);
         });
       });
@@ -1371,8 +1891,8 @@ class se {
   static removeHighlightColor(e) {
     const t = Array.isArray(e) ? e : [e];
     for (const s of t)
-      Tn(s) || J.traverseMeshes(s, (n) => {
-        n.userData[he] = 0, tt(n);
+      rr(s) || Q.traverseMeshes(s, (n) => {
+        n.userData[ue] = 0, mt(n);
       });
   }
   static breatheColor(e, t = {}) {
@@ -1384,17 +1904,17 @@ class se {
       },
       t
     );
-    n.color = new A(n.color).getHex();
-    for (const i of s)
-      J.traverseMeshes(i, (a) => {
-        a.userData[Ie] = 1, a.userData[Ut] = n.color, a.userData[Wt] = n.speed, a.userData[Ht] = n.intensity, et(a);
+    n.color = new P(n.color).getHex();
+    for (const r of s)
+      Q.traverseMeshes(r, (a) => {
+        a.userData[Oe] = 1, a.userData[ts] = n.color, a.userData[ss] = n.speed, a.userData[ns] = n.intensity, ft(a);
       });
   }
   static removeBreatheColor(e) {
     const t = Array.isArray(e) ? e : [e];
     for (const s of t)
-      J.traverseMeshes(s, (n) => {
-        n.userData[Ie] = 0, tt(n);
+      Q.traverseMeshes(s, (n) => {
+        n.userData[Oe] = 0, mt(n);
       });
   }
   /**
@@ -1403,8 +1923,8 @@ class se {
   static wireframe(e, t = !0) {
     const s = Array.isArray(e) ? e : [e];
     for (const n of s)
-      J.traverseMeshes(n, (i) => {
-        le(i).forEach((a) => {
+      Q.traverseMeshes(n, (r) => {
+        de(r).forEach((a) => {
           if (!a) return;
           const o = a;
           o.wireframe = t, o.needsUpdate = !0;
@@ -1434,17 +1954,17 @@ class se {
     return se._fade(e, 1, 0, s);
   }
   static _fade(e, t, s, n) {
-    const i = Array.isArray(e) ? e : [e], a = /* @__PURE__ */ new Map();
-    for (const o of i)
-      J.traverseMeshes(o, (c) => {
-        le(c).forEach((l) => {
+    const r = Array.isArray(e) ? e : [e], a = /* @__PURE__ */ new Map();
+    for (const o of r)
+      Q.traverseMeshes(o, (c) => {
+        de(c).forEach((l) => {
           if (!l || a.has(l)) return;
-          const h = l.opacity, u = l.transparent, d = s >= 1 ? h : s;
+          const h = l.opacity, d = l.transparent, u = s >= 1 ? h : s;
           a.set(l, {
             material: l,
-            targetOpacity: d,
+            targetOpacity: u,
             originalOpacity: h,
-            originalTransparent: u
+            originalTransparent: d
           }), l.transparent = !0, l.opacity = t, l.needsUpdate = !0;
         });
       });
@@ -1452,19 +1972,19 @@ class se {
       const c = performance.now();
       let l = 0;
       const h = () => {
-        const u = performance.now() - c, d = Math.min(u / n, 1);
-        if (!i[0].parent) {
+        const d = performance.now() - c, u = Math.min(d / n, 1);
+        if (!r[0].parent) {
           cancelAnimationFrame(l), o();
           return;
         }
-        for (const { material: m, targetOpacity: b } of a.values())
-          m.opacity = t + (b - t) * d, m.needsUpdate = !0;
-        if (d < 1)
+        for (const { material: x, targetOpacity: I } of a.values())
+          x.opacity = t + (I - t) * u, x.needsUpdate = !0;
+        if (u < 1)
           l = requestAnimationFrame(h);
         else {
           if (s >= 1)
-            for (const { material: m, originalOpacity: b, originalTransparent: S } of a.values())
-              m.opacity = b, m.transparent = S, m.needsUpdate = !0;
+            for (const { material: x, originalOpacity: I, originalTransparent: _ } of a.values())
+              x.opacity = I, x.transparent = _, x.needsUpdate = !0;
           o();
         }
       };
@@ -1472,11 +1992,11 @@ class se {
     });
   }
 }
-const st = (r) => {
-  const e = r.shiftRight(16).bitAnd(255).toFloat().div(255), t = r.shiftRight(8).bitAnd(255).toFloat().div(255), s = r.bitAnd(255).toFloat().div(255);
-  return Xs(e, t, s);
+const gt = (i) => {
+  const e = i.shiftRight(16).bitAnd(255).toFloat().div(255), t = i.shiftRight(8).bitAnd(255).toFloat().div(255), s = i.bitAnd(255).toFloat().div(255);
+  return fn(e, t, s);
 };
-class Ln extends Zs {
+class ir extends xn {
   viewer;
   constructor(e, t) {
     super(t), this.viewer = e;
@@ -1486,7 +2006,7 @@ class Ln extends Zs {
     this.viewer.invalidate(), t || this.viewer.removeEventListener("afterControlsUpdate", this._update);
   };
   easingByMode(e) {
-    const t = Pn[e];
+    const t = ar[e];
     return super.easing(t);
   }
   start(e, t) {
@@ -1496,54 +2016,54 @@ class Ln extends Zs {
     return this.viewer.removeEventListener("afterControlsUpdate", this._update), super.stop();
   }
 }
-function ji(r, e, t, s = {}, n, i) {
+function ui(i, e, t, s = {}, n, r) {
   return new Promise((a, o) => {
-    const { duration: c = 1e3, delay: l = 0, repeat: h = !1, mode: u = "Linear.None", yoyo: d = !1 } = s, p = new Ln(r, e).to(t, c).easingByMode(u).delay(l).onUpdate((m) => {
-      n?.(m, p);
+    const { duration: c = 1e3, delay: l = 0, repeat: h = !1, mode: d = "Linear.None", yoyo: u = !1 } = s, p = new ir(i, e).to(t, c).easingByMode(d).delay(l).onUpdate((x) => {
+      n?.(x, p);
     }).onComplete(() => {
       a();
     }).onStop(() => {
       o("animation stop");
     }).onStart(() => {
-      i?.(p);
+      r?.(p);
     });
-    typeof h == "number" ? p.repeat(h) : typeof h == "boolean" && h && p.repeat(1 / 0), d && p.repeatDelay(20), p.yoyo(d), p.start();
+    typeof h == "number" ? p.repeat(h) : typeof h == "boolean" && h && p.repeat(1 / 0), u && p.repeatDelay(20), p.yoyo(u), p.start();
   });
 }
-const Pn = {
-  "Linear.None": x.Linear.None,
-  "Quadratic.In": x.Quadratic.In,
-  "Quadratic.Out": x.Quadratic.Out,
-  "Quadratic.InOut": x.Quadratic.InOut,
-  "Cubic.In": x.Cubic.In,
-  "Cubic.Out": x.Cubic.Out,
-  "Cubic.InOut": x.Cubic.InOut,
-  "Quartic.In": x.Quartic.In,
-  "Quartic.Out": x.Quartic.Out,
-  "Quartic.InOut": x.Quartic.InOut,
-  "Quintic.In": x.Quintic.In,
-  "Quintic.Out": x.Quintic.Out,
-  "Quintic.InOut": x.Quintic.InOut,
-  "Sinusoidal.In": x.Sinusoidal.In,
-  "Sinusoidal.Out": x.Sinusoidal.Out,
-  "Sinusoidal.InOut": x.Sinusoidal.InOut,
-  "Exponential.In": x.Exponential.In,
-  "Exponential.Out": x.Exponential.Out,
-  "Exponential.InOut": x.Exponential.InOut,
-  "Circular.In": x.Circular.In,
-  "Circular.Out": x.Circular.Out,
-  "Circular.InOut": x.Circular.InOut,
-  "Elastic.In": x.Elastic.In,
-  "Elastic.Out": x.Elastic.Out,
-  "Elastic.InOut": x.Elastic.InOut,
-  "Back.In": x.Back.In,
-  "Back.Out": x.Back.Out,
-  "Back.InOut": x.Back.InOut,
-  "Bounce.In": x.Bounce.In,
-  "Bounce.Out": x.Bounce.Out,
-  "Bounce.InOut": x.Bounce.InOut
+const ar = {
+  "Linear.None": T.Linear.None,
+  "Quadratic.In": T.Quadratic.In,
+  "Quadratic.Out": T.Quadratic.Out,
+  "Quadratic.InOut": T.Quadratic.InOut,
+  "Cubic.In": T.Cubic.In,
+  "Cubic.Out": T.Cubic.Out,
+  "Cubic.InOut": T.Cubic.InOut,
+  "Quartic.In": T.Quartic.In,
+  "Quartic.Out": T.Quartic.Out,
+  "Quartic.InOut": T.Quartic.InOut,
+  "Quintic.In": T.Quintic.In,
+  "Quintic.Out": T.Quintic.Out,
+  "Quintic.InOut": T.Quintic.InOut,
+  "Sinusoidal.In": T.Sinusoidal.In,
+  "Sinusoidal.Out": T.Sinusoidal.Out,
+  "Sinusoidal.InOut": T.Sinusoidal.InOut,
+  "Exponential.In": T.Exponential.In,
+  "Exponential.Out": T.Exponential.Out,
+  "Exponential.InOut": T.Exponential.InOut,
+  "Circular.In": T.Circular.In,
+  "Circular.Out": T.Circular.Out,
+  "Circular.InOut": T.Circular.InOut,
+  "Elastic.In": T.Elastic.In,
+  "Elastic.Out": T.Elastic.Out,
+  "Elastic.InOut": T.Elastic.InOut,
+  "Back.In": T.Back.In,
+  "Back.Out": T.Back.Out,
+  "Back.InOut": T.Back.InOut,
+  "Bounce.In": T.Bounce.In,
+  "Bounce.Out": T.Bounce.Out,
+  "Bounce.InOut": T.Bounce.InOut
 };
-class ki {
+class pi {
   scene;
   planes = /* @__PURE__ */ new Map();
   helpers = /* @__PURE__ */ new Map();
@@ -1552,7 +2072,7 @@ class ki {
    */
   group;
   constructor(e) {
-    this.scene = e, this.group = new Es(), this.group.name = "__clippingToolGroup", this.scene.add(this.group);
+    this.scene = e, this.group = new qs(), this.group.name = "__clippingToolGroup", this.scene.add(this.group);
   }
   /**
    * Move all current scene children (except the clipping group itself) into the ClippingGroup,
@@ -1590,18 +2110,18 @@ class ki {
     const {
       normal: s = { x: 0, y: -1, z: 0 },
       constant: n = 0,
-      showHelper: i = !1,
+      showHelper: r = !1,
       helperSize: a = 5,
       helperColor: o = 16711680
-    } = t, c = new _s(new C(s.x, s.y, s.z), n);
-    return this.planes.set(e, c), this._syncPlanes(), i && this.showHelper(e, a, o), c;
+    } = t, c = new Vs(new D(s.x, s.y, s.z), n);
+    return this.planes.set(e, c), this._syncPlanes(), r && this.showHelper(e, a, o), c;
   }
   /**
    * Add six clipping planes that form a box around a Box3.
    * Returns the six plane ids: `${id}_+x`, `${id}_-x`, etc.
    */
   addBox(e, t, s = {}) {
-    const { showHelpers: n = !1, helperColor: i = 16711680 } = s, a = t.min, o = t.max, c = [
+    const { showHelpers: n = !1, helperColor: r = 16711680 } = s, a = t.min, o = t.max, c = [
       { suffix: "+x", normal: { x: -1, y: 0, z: 0 }, constant: o.x },
       { suffix: "-x", normal: { x: 1, y: 0, z: 0 }, constant: -a.x },
       { suffix: "+y", normal: { x: 0, y: -1, z: 0 }, constant: o.y },
@@ -1610,8 +2130,8 @@ class ki {
       { suffix: "-z", normal: { x: 0, y: 0, z: 1 }, constant: -a.z }
     ], l = [];
     for (const h of c) {
-      const u = `${e}_${h.suffix}`;
-      this.addPlane(u, { normal: h.normal, constant: h.constant, showHelper: n, helperColor: i }), l.push(u);
+      const d = `${e}_${h.suffix}`;
+      this.addPlane(d, { normal: h.normal, constant: h.constant, showHelper: n, helperColor: r }), l.push(d);
     }
     return l;
   }
@@ -1619,8 +2139,8 @@ class ki {
    * Add a clipping box from an object's bounding box with optional padding.
    */
   addBoxFromObject(e, t, s = 0, n = {}) {
-    const i = new $().setFromObject(t);
-    return i.expandByScalar(s), this.addBox(e, i, n);
+    const r = new K().setFromObject(t);
+    return r.expandByScalar(s), this.addBox(e, r, n);
   }
   /**
    * Update a plane's constant (distance from origin).
@@ -1659,8 +2179,8 @@ class ki {
     this.hideHelper(e);
     const n = this.planes.get(e);
     if (!n) return;
-    const i = new Cs(n, t, new A(s).getHex());
-    i.name = e, this.helpers.set(e, i), this.scene.add(i);
+    const r = new Xs(n, t, new P(s).getHex());
+    r.name = e, this.helpers.set(e, r), this.scene.add(r);
   }
   /**
    * Hide a plane helper.
@@ -1685,7 +2205,7 @@ class ki {
     this.detach(), this.removeAll(), this.scene.remove(this.group);
   }
 }
-class Ui {
+class fi {
   scene;
   measurements = /* @__PURE__ */ new Map();
   _idCounter = 0;
@@ -1696,16 +2216,16 @@ class Ui {
    * Measure distance between two points.
    */
   measureDistance(e, t, s = {}) {
-    const { lineColor: n = 16776960 } = s, i = new C(e.x, e.y, e.z), a = new C(t.x, t.y, t.z), o = i.distanceTo(a), c = `measure_dist_${this._idCounter++}`, l = new H();
+    const { lineColor: n = 16776960 } = s, r = new D(e.x, e.y, e.z), a = new D(t.x, t.y, t.z), o = r.distanceTo(a), c = `measure_dist_${this._idCounter++}`, l = new W();
     l.name = c;
-    const h = new Q().setFromPoints([i, a]), u = new me({ color: n }), d = new fe(h, u);
-    l.add(d), this.scene.add(l);
+    const h = new G().setFromPoints([r, a]), d = new ye({ color: n }), u = new be(h, d);
+    l.add(u), this.scene.add(l);
     const p = {
       id: c,
       type: "distance",
       value: o,
       unit: "m",
-      points: [i, a],
+      points: [r, a],
       object: l
     };
     return this.measurements.set(c, p), p;
@@ -1717,37 +2237,37 @@ class Ui {
     const { lineColor: s = 65280 } = t;
     if (e.length < 3)
       throw new Error("MeasureTool.measureArea requires at least 3 points");
-    const n = e.map((p) => new C(p.x, p.y, p.z)), i = this._calculatePolygonArea(n), a = `measure_area_${this._idCounter++}`, o = new H();
+    const n = e.map((p) => new D(p.x, p.y, p.z)), r = this._calculatePolygonArea(n), a = `measure_area_${this._idCounter++}`, o = new W();
     o.name = a;
-    const c = [...n, n[0]], l = new Q().setFromPoints(c), h = new me({ color: s }), u = new fe(l, h);
-    o.add(u), this.scene.add(o);
-    const d = {
+    const c = [...n, n[0]], l = new G().setFromPoints(c), h = new ye({ color: s }), d = new be(l, h);
+    o.add(d), this.scene.add(o);
+    const u = {
       id: a,
       type: "area",
-      value: i,
+      value: r,
       unit: "m²",
       points: n,
       object: o
     };
-    return this.measurements.set(a, d), d;
+    return this.measurements.set(a, u), u;
   }
   /**
    * Measure the angle between three points (vertex at the middle point).
    */
   measureAngle(e, t, s, n = {}) {
-    const { lineColor: i = 16746496 } = n, a = new C(e.x, e.y, e.z), o = new C(t.x, t.y, t.z), c = new C(s.x, s.y, s.z), l = a.clone().sub(o).normalize(), h = c.clone().sub(o).normalize(), d = Math.acos(Math.max(-1, Math.min(1, l.dot(h)))) * 180 / Math.PI, p = `measure_angle_${this._idCounter++}`, m = new H();
-    m.name = p;
-    const b = new Q().setFromPoints([a, o, c]), S = new me({ color: i }), w = new fe(b, S);
-    m.add(w), this.scene.add(m);
-    const g = {
+    const { lineColor: r = 16746496 } = n, a = new D(e.x, e.y, e.z), o = new D(t.x, t.y, t.z), c = new D(s.x, s.y, s.z), l = a.clone().sub(o).normalize(), h = c.clone().sub(o).normalize(), u = Math.acos(Math.max(-1, Math.min(1, l.dot(h)))) * 180 / Math.PI, p = `measure_angle_${this._idCounter++}`, x = new W();
+    x.name = p;
+    const I = new G().setFromPoints([a, o, c]), _ = new ye({ color: r }), C = new be(I, _);
+    x.add(C), this.scene.add(x);
+    const y = {
       id: p,
       type: "angle",
-      value: d,
+      value: u,
       unit: "°",
       points: [a, o, c],
-      object: m
+      object: x
     };
-    return this.measurements.set(p, g), g;
+    return this.measurements.set(p, y), y;
   }
   /**
    * Get a measurement result by id.
@@ -1782,15 +2302,15 @@ class Ui {
    * Calculate polygon area using cross product method (Newell's method).
    */
   _calculatePolygonArea(e) {
-    const t = e.length, s = new C();
-    for (let i = 0; i < t; i++) {
-      const a = e[i], o = e[(i + 1) % t], c = new C().crossVectors(a, o);
+    const t = e.length, s = new D();
+    for (let r = 0; r < t; r++) {
+      const a = e[r], o = e[(r + 1) % t], c = new D().crossVectors(a, o);
       s.add(c);
     }
-    const n = new C();
+    const n = new D();
     if (t >= 3) {
-      const i = e[1].clone().sub(e[0]), a = e[2].clone().sub(e[0]);
-      n.crossVectors(i, a).normalize();
+      const r = e[1].clone().sub(e[0]), a = e[2].clone().sub(e[0]);
+      n.crossVectors(r, a).normalize();
     }
     return Math.abs(s.dot(n)) / 2;
   }
@@ -1798,7 +2318,7 @@ class Ui {
     this.removeAll();
   }
 }
-class Wi {
+class mi {
   scene;
   annotations = /* @__PURE__ */ new Map();
   _idCounter = 0;
@@ -1818,12 +2338,12 @@ class Wi {
    */
   add(e, t) {
     this.annotations.has(e) && this.remove(e);
-    const s = new H();
+    const s = new W();
     s.name = `annotation_${e}`;
-    const n = new C(t.position.x, t.position.y, t.position.z);
+    const n = new D(t.position.x, t.position.y, t.position.z);
     s.position.copy(n);
-    const i = document.createElement("div");
-    if (i.innerHTML = t.content, i.style.cssText = `
+    const r = document.createElement("div");
+    if (r.innerHTML = t.content, r.style.cssText = `
       padding: 4px 8px;
       background: rgba(0, 0, 0, 0.75);
       color: #fff;
@@ -1834,19 +2354,19 @@ class Wi {
     `, t.labelStyle)
       for (const l of Object.keys(t.labelStyle)) {
         const h = t.labelStyle[l];
-        h !== void 0 && (i.style[l] = h);
+        h !== void 0 && (r.style[l] = h);
       }
     let a = null;
     const o = t.labelOffset || { x: 0, y: 2, z: 0 };
     if (t.showLeaderLine !== !1) {
-      const { lineColor: l = 16777215 } = t, h = new Q().setFromPoints([
-        new C(0, 0, 0),
-        new C(o.x, o.y, o.z)
-      ]), u = new me({ color: l });
-      a = new fe(h, u), s.add(a);
+      const { lineColor: l = 16777215 } = t, h = new G().setFromPoints([
+        new D(0, 0, 0),
+        new D(o.x, o.y, o.z)
+      ]), d = new ye({ color: l });
+      a = new be(h, d), s.add(a);
     }
     if (this._createCSSObject) {
-      const l = this._createCSSObject(i);
+      const l = this._createCSSObject(r);
       l.position.set(o.x, o.y, o.z), s.add(l);
     }
     this.scene.add(s);
@@ -1854,7 +2374,7 @@ class Wi {
       id: e,
       options: t,
       group: s,
-      labelElement: i,
+      labelElement: r,
       line: a
     };
     return this.annotations.set(e, c), c;
@@ -1951,80 +2471,80 @@ class Wi {
     this.removeAll();
   }
 }
-const nt = new L(), Nn = 1e-6, zn = 1e-6, it = "uSpaceInstanceOriginalMaterialState", rt = 0, Ee = 1, Dn = 2;
-function Rn(r) {
-  let e = r;
+const yt = new R(), or = 1e-6, cr = 1e-6, bt = "uSpaceInstanceOriginalMaterialState", wt = 0, Ne = 1, lr = 2;
+function hr(i) {
+  let e = i;
   for (; e; ) {
     if (!e.visible) return !1;
     e = e.parent;
   }
   return !0;
 }
-function jn(r, e) {
-  const t = r.elements, s = e.elements;
+function dr(i, e) {
+  const t = i.elements, s = e.elements;
   for (let n = 0; n < 16; n++)
-    if (Math.abs(t[n] - s[n]) > Nn) return !1;
+    if (Math.abs(t[n] - s[n]) > or) return !1;
   return !0;
 }
-function Ft(r) {
-  const e = r.material;
+function rs(i) {
+  const e = i.material;
   return Array.isArray(e) ? e : [e];
 }
-function Gt(r) {
-  const e = r.userData, t = e[it];
+function is(i) {
+  const e = i.userData, t = e[bt];
   if (t) return t;
   const s = {
-    transparent: r.transparent,
-    opacity: r.opacity
+    transparent: i.transparent,
+    opacity: i.opacity
   };
-  return e[it] = s, s;
+  return e[bt] = s, s;
 }
-function kn(r, e) {
-  r.traverse((t) => {
+function ur(i, e) {
+  i.traverse((t) => {
     const s = t;
-    s.isMesh && Ft(s).forEach((n) => {
+    s.isMesh && rs(s).forEach((n) => {
       if (!n) return;
-      const i = n, a = Gt(i), o = a.opacity * e;
-      i.transparent = a.transparent || o < 1, i.opacity = o, i.needsUpdate = !0;
+      const r = n, a = is(r), o = a.opacity * e;
+      r.transparent = a.transparent || o < 1, r.opacity = o, r.needsUpdate = !0;
     });
   });
 }
-function Un(r) {
-  r.traverse((e) => {
+function pr(i) {
+  i.traverse((e) => {
     const t = e;
-    t.isMesh && Ft(t).forEach((s) => {
+    t.isMesh && rs(t).forEach((s) => {
       if (!s) return;
-      const n = s, i = Gt(n);
-      n.transparent = i.transparent, n.opacity = i.opacity, n.needsUpdate = !0;
+      const n = s, r = is(n);
+      n.transparent = r.transparent, n.opacity = r.opacity, n.needsUpdate = !0;
     });
   });
 }
-class Hi extends ue {
+class gi extends pe {
   isInstanceObject = !0;
   type = "InstanceObject";
   instanceId = "";
   instanceKind = "";
   instanceName = "";
-  geometry = new Q();
+  geometry = new G();
   boundingBox = null;
   boundingSphere = null;
-  #t = {
+  #s = {
     color: null,
-    colorMode: rt,
+    colorMode: wt,
     opacity: 1
   };
   #a = null;
-  #s = null;
+  #t = null;
   #e = null;
-  #n = null;
-  #i = /* @__PURE__ */ new Set();
-  #o = new L();
+  #r = null;
+  #n = /* @__PURE__ */ new Set();
+  #o = new R();
   #c = !1;
   #l = !0;
-  #h = !1;
-  #d;
+  #d = !1;
+  #u;
   constructor(e = {}) {
-    super(), this.#d = e.boundsName ?? "InstanceBounds";
+    super(), this.#u = e.boundsName ?? "InstanceBounds";
   }
   setInstanceIdentity(e) {
     let t = !1;
@@ -2044,33 +2564,33 @@ class Hi extends ue {
   }
   setInstanceBounds(e) {
     if (e.isEmpty()) return this;
-    this.#s && this.remove(this.#s);
-    const t = new Q();
+    this.#t && this.remove(this.#t);
+    const t = new G();
     t.boundingBox = e.clone();
-    const s = new Os();
-    return s.name = this.#d, s.visible = !1, s.geometry = t, s.raycast = () => {
-    }, this.#s = s, this.add(s), this.#p(), this.markInstanceRenderDirty(), this;
+    const s = new Ys();
+    return s.name = this.#u, s.visible = !1, s.geometry = t, s.raycast = () => {
+    }, this.#t = s, this.add(s), this.#h(), this.markInstanceRenderDirty(), this;
   }
   setInstanceRenderObject(e) {
-    return this.#e && this.#e !== e && this.#e.parent === this && this.remove(this.#e), this.#e = e, e && e.parent !== this && this.add(e), this.#u(), this.#p(), this.markInstanceRenderDirty(), this;
+    return this.#e && this.#e !== e && this.#e.parent === this && this.remove(this.#e), this.#e = e, e && e.parent !== this && this.add(e), this.#f(), this.#h(), this.markInstanceRenderDirty(), this;
   }
   getInstanceRenderObject() {
     return this.#e;
   }
   setInstanceMaterializer(e) {
-    return this.#n = e, this;
+    return this.#r = e, this;
   }
   hasInstanceMaterializer(e) {
-    return this.#n === e;
+    return this.#r === e;
   }
   clearInstanceMaterializer(e) {
-    return (e === void 0 || this.#n === e) && (this.#n = null), this;
+    return (e === void 0 || this.#r === e) && (this.#r = null), this;
   }
   materialize() {
-    return this.#n?.() ?? this.#e ?? null;
+    return this.#r?.() ?? this.#e ?? null;
   }
   computeBoundingBox() {
-    this.boundingBox === null && (this.boundingBox = new $()), this.getInstanceBoundingBox(this.boundingBox, !1);
+    this.boundingBox === null && (this.boundingBox = new K()), this.getInstanceBoundingBox(this.boundingBox, !1);
   }
   computeBoundingSphere() {
     if (this.boundingSphere === null && (this.boundingSphere = new ne()), this.boundingBox === null && this.computeBoundingBox(), !this.boundingBox || this.boundingBox.isEmpty()) {
@@ -2079,167 +2599,167 @@ class Hi extends ue {
     }
     this.boundingBox.getBoundingSphere(this.boundingSphere);
   }
-  getInstanceBoundingBox(e = new $(), t = !1) {
-    const s = this.#s?.geometry?.boundingBox;
-    return s ? (e.copy(s), t && (this.updateWorldMatrix(!0, !1), e.applyMatrix4(this.matrixWorld)), e) : this.#e ? (e.setFromObject(this.#e), t || (this.updateWorldMatrix(!0, !1), nt.copy(this.matrixWorld).invert(), e.applyMatrix4(nt)), e) : e.makeEmpty();
+  getInstanceBoundingBox(e = new K(), t = !1) {
+    const s = this.#t?.geometry?.boundingBox;
+    return s ? (e.copy(s), t && (this.updateWorldMatrix(!0, !1), e.applyMatrix4(this.matrixWorld)), e) : this.#e ? (e.setFromObject(this.#e), t || (this.updateWorldMatrix(!0, !1), yt.copy(this.matrixWorld).invert(), e.applyMatrix4(yt)), e) : e.makeEmpty();
   }
   setInstanceVisible(e) {
     return this.visible === e ? this : (this.visible = e, this.markInstanceRenderDirty(), this);
   }
   setInstanceColor(e) {
-    return this.#t.color = new A(e), this.#t.colorMode = Ee, this.#u(), this.markInstanceRenderDirty(), this;
+    return this.#s.color = new P(e), this.#s.colorMode = Ne, this.#f(), this.markInstanceRenderDirty(), this;
   }
   resetInstanceColor() {
-    return this.#t.color === null ? this : (this.#t.color = null, this.#t.colorMode = rt, this.#u(), this.markInstanceRenderDirty(), this);
+    return this.#s.color === null ? this : (this.#s.color = null, this.#s.colorMode = wt, this.#f(), this.markInstanceRenderDirty(), this);
   }
   setInstanceOpacity(e) {
     const t = Math.max(0, Math.min(1, e));
-    return Math.abs(this.#t.opacity - t) <= zn ? this : (this.#t.opacity = t, this.#u(), this.markInstanceRenderDirty(), this);
+    return Math.abs(this.#s.opacity - t) <= cr ? this : (this.#s.opacity = t, this.#f(), this.markInstanceRenderDirty(), this);
   }
-  getInstanceColor(e = new A()) {
-    const t = this.#m();
+  getInstanceColor(e = new P()) {
+    const t = this.#p();
     return t.color ? e.copy(t.color) : e.setRGB(1, 1, 1);
   }
   hasInstanceColor() {
-    return this.#m().color !== null;
+    return this.#p().color !== null;
   }
   getInstanceOpacity() {
-    return this.#m().opacity;
+    return this.#p().opacity;
   }
   setInstanceHighlight(e, t, s = !1) {
     return this.#a = {
-      color: new A(e),
-      colorMode: s ? Ee : Dn,
+      color: new P(e),
+      colorMode: s ? Ne : lr,
       opacity: Math.max(0, Math.min(1, t))
-    }, this.#u(), this.markInstanceRenderDirty(), this;
+    }, this.#f(), this.markInstanceRenderDirty(), this;
   }
   clearInstanceHighlight() {
-    return this.#a === null ? this : (this.#a = null, this.#u(), this.markInstanceRenderDirty(), this);
+    return this.#a === null ? this : (this.#a = null, this.#f(), this.markInstanceRenderDirty(), this);
   }
   getInstanceColorMode() {
-    return this.#m().colorMode;
+    return this.#p().colorMode;
   }
   onInstanceRenderDirty(e) {
-    return this.#i.add(e), () => this.#i.delete(e);
+    return this.#n.add(e), () => this.#n.delete(e);
   }
   markInstanceRenderDirty() {
-    return this.#i.forEach((e) => e()), this;
+    return this.#n.forEach((e) => e()), this;
   }
   updateMatrixWorld(e) {
-    super.updateMatrixWorld(e), this.#r();
+    super.updateMatrixWorld(e), this.#i();
   }
   updateWorldMatrix(e, t) {
-    super.updateWorldMatrix(e, t), this.#r();
+    super.updateWorldMatrix(e, t), this.#i();
   }
-  #r() {
-    const e = Rn(this);
-    (!this.#c || !jn(this.matrixWorld, this.#o) || !this.#h || e !== this.#l) && (this.#c = !0, this.#h = !0, this.#o.copy(this.matrixWorld), this.#l = e, this.markInstanceRenderDirty());
+  #i() {
+    const e = hr(this);
+    (!this.#c || !dr(this.matrixWorld, this.#o) || !this.#d || e !== this.#l) && (this.#c = !0, this.#d = !0, this.#o.copy(this.matrixWorld), this.#l = e, this.markInstanceRenderDirty());
   }
-  #p() {
+  #h() {
     this.boundingBox = null, this.boundingSphere = null;
   }
-  #m() {
-    return this.#a ?? this.#t;
+  #p() {
+    return this.#a ?? this.#s;
   }
-  #u() {
+  #f() {
     if (!this.#e) return;
-    const e = this.#m();
+    const e = this.#p();
     if (e.color) {
-      Un(this.#e), se.highlightColor(this.#e, {
+      pr(this.#e), se.highlightColor(this.#e, {
         color: e.color,
         opacity: e.opacity,
-        overwrite: e.colorMode === Ee,
+        overwrite: e.colorMode === Ne,
         multiplyOpacity: !0
       });
       return;
     }
-    se.removeHighlightColor(this.#e), kn(this.#e, e.opacity);
+    se.removeHighlightColor(this.#e), ur(this.#e, e.opacity);
   }
 }
-function Fi(r) {
-  return r.isInstanceObject === !0;
+function yi(i) {
+  return i.isInstanceObject === !0;
 }
-const Wn = /* @__PURE__ */ new Set([
+const fr = /* @__PURE__ */ new Set([
   "MeshBasicMaterial",
   "MeshLambertMaterial",
   "MeshPhongMaterial",
   "MeshStandardMaterial",
   "MeshPhysicalMaterial"
-]), at = /* @__PURE__ */ new WeakMap();
-let Hn = 1;
-const ot = new L(), ce = new L(), ct = new L();
-function Fn(r, e, t = 1e-6) {
-  const s = r.elements, n = e.elements;
-  for (let i = 0; i < 16; i++)
-    if (Math.abs(s[i] - n[i]) > t) return !1;
+]), xt = /* @__PURE__ */ new WeakMap();
+let mr = 1;
+const Mt = new R(), le = new R(), vt = new R();
+function gr(i, e, t = 1e-6) {
+  const s = i.elements, n = e.elements;
+  for (let r = 0; r < 16; r++)
+    if (Math.abs(s[r] - n[r]) > t) return !1;
   return !0;
 }
-function $t(r) {
-  let e = r;
+function as(i) {
+  let e = i;
   for (; e; ) {
     if (!e.visible) return !1;
     e = e.parent;
   }
   return !0;
 }
-function Gn(r) {
-  const e = r.source.data;
+function yr(i) {
+  const e = i.source.data;
   if (!e || typeof e != "object" && typeof e != "function")
-    return `texture:${r.uuid}`;
-  let t = at.get(e);
-  return t === void 0 && (t = Hn++, at.set(e, t)), `source:${t}`;
+    return `texture:${i.uuid}`;
+  let t = xt.get(e);
+  return t === void 0 && (t = mr++, xt.set(e, t)), `source:${t}`;
 }
-function $n(r) {
+function br(i) {
   return JSON.stringify([
-    Gn(r),
-    r.mapping,
-    r.channel,
-    r.wrapS,
-    r.wrapT,
-    r.magFilter,
-    r.minFilter,
-    r.anisotropy,
-    r.format,
-    r.internalFormat,
-    r.type,
-    r.offset.toArray(),
-    r.repeat.toArray(),
-    r.center.toArray(),
-    r.rotation,
-    r.matrixAutoUpdate,
-    r.matrix.toArray(),
-    r.generateMipmaps,
-    r.premultiplyAlpha,
-    r.flipY,
-    r.unpackAlignment,
-    r.colorSpace,
-    "compareFunction" in r ? r.compareFunction : null
+    yr(i),
+    i.mapping,
+    i.channel,
+    i.wrapS,
+    i.wrapT,
+    i.magFilter,
+    i.minFilter,
+    i.anisotropy,
+    i.format,
+    i.internalFormat,
+    i.type,
+    i.offset.toArray(),
+    i.repeat.toArray(),
+    i.center.toArray(),
+    i.rotation,
+    i.matrixAutoUpdate,
+    i.matrix.toArray(),
+    i.generateMipmaps,
+    i.premultiplyAlpha,
+    i.flipY,
+    i.unpackAlignment,
+    i.colorSpace,
+    "compareFunction" in i ? i.compareFunction : null
   ]);
 }
-function Ae(r) {
-  if (Array.isArray(r)) return r.map(Ae);
-  if (!r || typeof r != "object") return r;
-  const e = r;
+function Ue(i) {
+  if (Array.isArray(i)) return i.map(Ue);
+  if (!i || typeof i != "object") return i;
+  const e = i;
   return Object.fromEntries(
-    Object.keys(e).sort().map((t) => [t, Ae(e[t])])
+    Object.keys(e).sort().map((t) => [t, Ue(e[t])])
   );
 }
-function Te(r, e) {
-  if (Array.isArray(r)) return r.map((s) => Te(s, e));
-  if (!r || typeof r != "object")
-    return typeof r == "string" ? e.get(r) ?? r : r;
-  const t = r;
+function je(i, e) {
+  if (Array.isArray(i)) return i.map((s) => je(s, e));
+  if (!i || typeof i != "object")
+    return typeof i == "string" ? e.get(i) ?? i : i;
+  const t = i;
   return Object.fromEntries(
-    Object.keys(t).filter((s) => s !== "metadata" && s !== "uuid" && s !== "name").sort().map((s) => [s, Te(t[s], e)])
+    Object.keys(t).filter((s) => s !== "metadata" && s !== "uuid" && s !== "name").sort().map((s) => [s, je(t[s], e)])
   );
 }
-function Kn(r) {
-  if (!Wn.has(r.type) || r.transparent || r.opacity < 0.999 || r.visible === !1) return null;
-  const e = r;
-  if (Object.keys(e).some((i) => i.endsWith("Node") && e[i] != null) || Object.hasOwn(r, "onBeforeCompile")) return null;
+function wr(i) {
+  if (!fr.has(i.type) || i.transparent || i.opacity < 0.999 || i.visible === !1) return null;
+  const e = i;
+  if (Object.keys(e).some((r) => r.endsWith("Node") && e[r] != null) || Object.hasOwn(i, "onBeforeCompile")) return null;
   const t = /* @__PURE__ */ new Map();
-  Object.values(e).forEach((i) => {
-    i instanceof zs && t.set(i.uuid, $n(i));
+  Object.values(e).forEach((r) => {
+    r instanceof $t && t.set(r.uuid, br(r));
   });
   const s = {
     geometries: {},
@@ -2250,26 +2770,26 @@ function Kn(r) {
     skeletons: {},
     animations: {},
     nodes: {}
-  }, n = r.toJSON(s);
-  return JSON.stringify(Ae(Te(n, t)));
+  }, n = i.toJSON(s);
+  return JSON.stringify(Ue(je(n, t)));
 }
-function Xn(r) {
-  if (Object.keys(r.morphAttributes).length > 0 || r.drawRange.start !== 0 || r.drawRange.count !== 1 / 0) return null;
-  const e = Object.entries(r.attributes).sort(([t], [s]) => t.localeCompare(s)).map(([t, s]) => "isInterleavedBufferAttribute" in s ? null : [t, s.itemSize, s.normalized, s.array.constructor.name, s.gpuType]);
+function xr(i) {
+  if (Object.keys(i.morphAttributes).length > 0 || i.drawRange.start !== 0 || i.drawRange.count !== 1 / 0) return null;
+  const e = Object.entries(i.attributes).sort(([t], [s]) => t.localeCompare(s)).map(([t, s]) => "isInterleavedBufferAttribute" in s ? null : [t, s.itemSize, s.normalized, s.array.constructor.name, s.gpuType]);
   return e.some((t) => t === null) ? null : JSON.stringify([
-    r.index?.array.constructor.name ?? "non-indexed",
+    i.index?.array.constructor.name ?? "non-indexed",
     e
   ]);
 }
-function Qn(r, e) {
-  const t = [], s = /* @__PURE__ */ new Set(), n = /* @__PURE__ */ new Set(), i = !e && (r.animations.length > 0 || r.mixer !== null);
-  return i && n.add("animation"), r.updateWorldMatrix(!0, !0), ot.copy(r.matrixWorld).invert(), r.traverseVisible((a) => {
-    if (!(a instanceof P)) return;
-    if (i) {
+function Mr(i, e) {
+  const t = [], s = /* @__PURE__ */ new Set(), n = /* @__PURE__ */ new Set(), r = !e && (i.animations.length > 0 || i.mixer !== null);
+  return r && n.add("animation"), i.updateWorldMatrix(!0, !0), Mt.copy(i.matrixWorld).invert(), i.traverseVisible((a) => {
+    if (!(a instanceof k)) return;
+    if (r) {
       s.add(a);
       return;
     }
-    if (a instanceof Ts) {
+    if (a instanceof Js) {
       s.add(a), n.add("skinned");
       return;
     }
@@ -2281,7 +2801,7 @@ function Qn(r, e) {
       s.add(a), n.add("material-array");
       return;
     }
-    const o = Kn(a.material), c = Xn(a.geometry);
+    const o = wr(a.material), c = xr(a.geometry);
     if (!o) {
       s.add(a), n.add(a.material.transparent || a.material.opacity < 0.999 ? "transparent" : `material:${a.material.type}`);
       return;
@@ -2296,7 +2816,7 @@ function Qn(r, e) {
     }
     t.push({
       mesh: a,
-      localMatrix: ot.clone().multiply(a.matrixWorld),
+      localMatrix: Mt.clone().multiply(a.matrixWorld),
       materialKey: o,
       geometryKey: c
     });
@@ -2306,63 +2826,63 @@ function Qn(r, e) {
     fallbackReasons: n
   };
 }
-function qn(r, e) {
-  const t = Le(r), s = [], n = [];
-  return r.traverse((i) => {
-    i instanceof P && s.push(i);
-  }), t.traverse((i) => {
-    i instanceof P && n.push(i);
-  }), s.forEach((i, a) => {
-    e.has(i) && n[a] && (n[a].visible = !1);
+function vr(i, e) {
+  const t = We(i), s = [], n = [];
+  return i.traverse((r) => {
+    r instanceof k && s.push(r);
+  }), t.traverse((r) => {
+    r instanceof k && n.push(r);
+  }), s.forEach((r, a) => {
+    e.has(r) && n[a] && (n[a].visible = !1);
   }), t;
 }
-function Yn(r) {
-  const e = Le(r), t = /* @__PURE__ */ new Map(), s = (n) => {
-    let i = t.get(n);
-    return i || (i = n.clone(), t.set(n, i)), i;
+function Sr(i) {
+  const e = We(i), t = /* @__PURE__ */ new Map(), s = (n) => {
+    let r = t.get(n);
+    return r || (r = n.clone(), t.set(n, r)), r;
   };
   return e.traverse((n) => {
-    n instanceof P && (n.material = Array.isArray(n.material) ? n.material.map(s) : s(n.material));
+    n instanceof k && (n.material = Array.isArray(n.material) ? n.material.map(s) : s(n.material));
   }), e;
 }
-function Vn(r) {
-  return Math.max(1, Math.ceil(Math.sqrt(Math.max(1, r))));
+function Ir(i) {
+  return Math.max(1, Math.ceil(Math.sqrt(Math.max(1, i))));
 }
-function Jn(r) {
-  const e = new Ls(new Float32Array(r * r * 4), r, r, Ps, Ns);
-  return e.magFilter = Ue, e.minFilter = Ue, e.generateMipmaps = !1, e.needsUpdate = !0, e;
+function Er(i) {
+  const e = new Zs(new Float32Array(i * i * 4), i, i, en, tn);
+  return e.magFilter = Ee, e.minFilter = Ee, e.generateMipmaps = !1, e.needsUpdate = !0, e;
 }
-function Zn(r, e) {
-  const t = r.clone(), s = Qs("batchObjectIndex", "float").toInt(), n = $e(qs(Ke(e), $e(0)).x).toConst(), i = s.mod(n).toConst(), a = s.div(n).toConst(), o = Ke(e, Ys(i, a)), c = t.colorNode ?? xe, l = F(o.a.greaterThan(1.5), c.mul(o.rgb), o.rgb);
-  return t.colorNode = F(o.a.greaterThan(0.5), l, c), t.maskNode = o.a.greaterThan(-0.5), t.needsUpdate = !0, t;
+function Cr(i, e) {
+  const t = i.clone(), s = mn("batchObjectIndex", "float").toInt(), n = nt(gn(rt(e), nt(0)).x).toConst(), r = s.mod(n).toConst(), a = s.div(n).toConst(), o = rt(e, yn(r, a)), c = t.colorNode ?? Ce, l = $(o.a.greaterThan(1.5), c.mul(o.rgb), o.rgb);
+  return t.colorNode = $(o.a.greaterThan(0.5), l, c), t.maskNode = o.a.greaterThan(-0.5), t.needsUpdate = !0, t;
 }
-function lt(r) {
-  let e = 0, t = r.parent;
+function St(i) {
+  let e = 0, t = i.parent;
   for (; t; )
     e++, t = t.parent;
   return e;
 }
-class ei extends q {
+class Ar extends X {
   objectIndices;
   states;
-  #t;
+  #s;
   constructor(e, t, s, n) {
     super(e, t), this.objectIndices = s, this.states = n, this.userData.editableGeometryBatch = !0;
   }
   raycast(e, t) {
     if (this.visible === !1 && this.ignoreInvisibleWhenRaycast === !0)
       return !1;
-    this.#t === void 0 && (this.#t = Et(this.geometry));
+    this.#s === void 0 && (this.#s = jt(this.geometry));
     const s = [];
-    this.#t ? this.#t.raycastObject3D(this, e, s) : super.raycast(e, s), s.forEach((n) => {
-      const i = n.faceIndex;
-      if (i == null) return;
-      const a = i * 3, o = this.geometry.index?.getX(a) ?? a, c = this.objectIndices[o], l = c === void 0 ? void 0 : this.states[c], h = l?.instance;
-      !l || l.materialized || !h || !$t(h) || h.getInstanceOpacity() <= 1e-3 || (n.object = h, n.batchObjectIndex = c, t.push(n));
+    this.#s ? this.#s.raycastObject3D(this, e, s) : super.raycast(e, s), s.forEach((n) => {
+      const r = n.faceIndex;
+      if (r == null) return;
+      const a = r * 3, o = this.geometry.index?.getX(a) ?? a, c = this.objectIndices[o], l = c === void 0 ? void 0 : this.states[c], h = l?.instance;
+      !l || l.materialized || !h || !as(h) || h.getInstanceOpacity() <= 1e-3 || (n.object = h, n.batchObjectIndex = c, t.push(n));
     });
   }
 }
-class Gi extends ue {
+class bi extends pe {
   isEditableGeometryBatchLayer = !0;
   type = "EditableGeometryBatchLayer";
   options;
@@ -2376,16 +2896,16 @@ class Gi extends ue {
     unsupportedInstances: 0,
     unsupportedByReason: {}
   };
-  #t = [];
-  #a = /* @__PURE__ */ new Set();
   #s = [];
+  #a = /* @__PURE__ */ new Set();
+  #t = [];
   #e = /* @__PURE__ */ new Map();
-  #n = /* @__PURE__ */ new Set();
-  #i = null;
-  #o = new L();
+  #r = /* @__PURE__ */ new Set();
+  #n = null;
+  #o = new R();
   #c = !1;
   #l = !1;
-  #h = !1;
+  #d = !1;
   constructor(e = {}) {
     super(), this.name = "EditableGeometryBatches", this.options = {
       maxVerticesPerBatch: e.maxVerticesPerBatch ?? 15e5,
@@ -2396,228 +2916,228 @@ class Gi extends ue {
   addSource(e) {
     if (this.#l) throw new Error("EditableGeometryBatchLayer has been disposed.");
     if (this.#c) throw new Error("EditableGeometryBatchLayer has already been built.");
-    const { key: t, template: s, instances: n } = e, i = /* @__PURE__ */ new Set();
+    const { key: t, template: s, instances: n } = e, r = /* @__PURE__ */ new Set();
     n.forEach((l) => {
-      if (i.has(l) || this.#a.has(l))
+      if (r.has(l) || this.#a.has(l))
         throw new Error(
           "EditableGeometryBatchLayer cannot batch the same InstanceObject more than once."
         );
-      i.add(l);
+      r.add(l);
     });
-    const { meshes: a, fallbackMeshes: o, fallbackReasons: c } = Qn(
+    const { meshes: a, fallbackMeshes: o, fallbackReasons: c } = Mr(
       s,
       this.options.freezeAnimations
     );
-    return i.forEach((l) => this.#a.add(l)), this.#t.push({
+    return r.forEach((l) => this.#a.add(l)), this.#s.push({
       key: t,
       template: s,
       instances: [...n],
       meshes: a,
       fallbackMeshes: o,
       fallbackReasons: c,
-      bounds: new $().setFromObject(s)
+      bounds: new K().setFromObject(s)
     }), a.length > 0;
   }
   build() {
     if (this.#l) throw new Error("EditableGeometryBatchLayer has been disposed.");
     if (this.#c) throw new Error("EditableGeometryBatchLayer.build() can only be called once.");
     this.#c = !0, this.updateWorldMatrix(!0, !1), this.#o.copy(this.matrixWorld).invert();
-    const e = [], t = /* @__PURE__ */ new Map(), s = (i, a, o, c) => {
+    const e = [], t = /* @__PURE__ */ new Map(), s = (r, a, o, c) => {
       if (o.length === 0) return;
       const l = c.size > 0 ? [...c] : ["unknown"];
-      e.push({ key: i.key, template: a, instances: o, reasons: l }), l.forEach((h) => {
+      e.push({ key: r.key, template: a, instances: o, reasons: l }), l.forEach((h) => {
         this.stats.unsupportedByReason[h] = (this.stats.unsupportedByReason[h] ?? 0) + o.length;
       });
     };
-    this.#t.forEach((i) => {
+    this.#s.forEach((r) => {
       const a = [], o = [];
-      i.instances.forEach((l) => {
-        l.updateWorldMatrix(!0, !1), ce.multiplyMatrices(this.#o, l.matrixWorld), ce.determinant() <= 0 ? o.push(l) : a.push({ instance: l, matrix: ce.clone() });
+      r.instances.forEach((l) => {
+        l.updateWorldMatrix(!0, !1), le.multiplyMatrices(this.#o, l.matrixWorld), le.determinant() <= 0 ? o.push(l) : a.push({ instance: l, matrix: le.clone() });
       });
-      const c = i.fallbackReasons.size > 0 ? i.fallbackReasons : /* @__PURE__ */ new Set(["unknown"]);
-      if (i.meshes.length === 0) {
+      const c = r.fallbackReasons.size > 0 ? r.fallbackReasons : /* @__PURE__ */ new Set(["unknown"]);
+      if (r.meshes.length === 0) {
         s(
-          i,
-          i.template,
+          r,
+          r.template,
           a.map(({ instance: l }) => l),
           c
         ), s(
-          i,
-          i.template,
+          r,
+          r.template,
           o,
           /* @__PURE__ */ new Set([...c, "negative-scale"])
         );
         return;
       }
-      i.fallbackMeshes.size > 0 && s(
-        i,
-        qn(
-          i.template,
-          new Set(i.meshes.map(({ mesh: l }) => l))
+      r.fallbackMeshes.size > 0 && s(
+        r,
+        vr(
+          r.template,
+          new Set(r.meshes.map(({ mesh: l }) => l))
         ),
         a.map(({ instance: l }) => l),
         c
       ), s(
-        i,
-        i.template,
+        r,
+        r.template,
         o,
-        /* @__PURE__ */ new Set([...i.fallbackReasons, "negative-scale"])
+        /* @__PURE__ */ new Set([...r.fallbackReasons, "negative-scale"])
       ), a.forEach(({ instance: l, matrix: h }) => {
-        const u = this.#s.length, d = () => this.materialize(l), p = {
+        const d = this.#t.length, u = () => this.materialize(l), p = {
           instance: l,
-          template: i.template,
+          template: r.template,
           initialMatrix: h,
-          objectIndex: u,
+          objectIndex: d,
           materialized: !1,
-          materializer: d,
+          materializer: u,
           unsubscribe: () => {
           }
         };
-        p.unsubscribe = l.onInstanceRenderDirty(() => this.#p(p)), this.#s.push(p), this.#e.set(l, p), l.setInstanceBounds(i.bounds), l.setInstanceMaterializer(d), this.#n.add(p), i.meshes.forEach(({ mesh: m, localMatrix: b, materialKey: S, geometryKey: w }) => {
-          ct.multiplyMatrices(h, b);
-          const g = m.geometry.clone().applyMatrix4(ct), I = g.getAttribute("position");
-          g.setAttribute(
+        p.unsubscribe = l.onInstanceRenderDirty(() => this.#h(p)), this.#t.push(p), this.#e.set(l, p), l.setInstanceBounds(r.bounds), l.setInstanceMaterializer(u), this.#r.add(p), r.meshes.forEach(({ mesh: x, localMatrix: I, materialKey: _, geometryKey: C }) => {
+          vt.multiplyMatrices(h, I);
+          const y = x.geometry.clone().applyMatrix4(vt), w = y.getAttribute("position");
+          y.setAttribute(
             "batchObjectIndex",
-            new As(new Float32Array(I.count).fill(u), 1)
+            new Qs(new Float32Array(w.count).fill(d), 1)
           );
-          const B = JSON.stringify([
-            S,
-            w,
-            m.castShadow,
-            m.receiveShadow,
-            m.renderOrder
-          ]), O = t.get(B), T = {
-            geometry: g,
-            material: m.material,
-            castShadow: m.castShadow,
-            receiveShadow: m.receiveShadow,
-            renderOrder: m.renderOrder,
-            objectIndices: new Array(I.count).fill(u)
+          const g = JSON.stringify([
+            _,
+            C,
+            x.castShadow,
+            x.receiveShadow,
+            x.renderOrder
+          ]), m = t.get(g), M = {
+            geometry: y,
+            material: x.material,
+            castShadow: x.castShadow,
+            receiveShadow: x.receiveShadow,
+            renderOrder: x.renderOrder,
+            objectIndices: new Array(w.count).fill(d)
           };
-          O ? O.push(T) : t.set(B, [T]), this.stats.sourceMeshes++, this.stats.vertices += I.count, this.stats.indices += g.index?.count ?? I.count;
+          m ? m.push(M) : t.set(g, [M]), this.stats.sourceMeshes++, this.stats.vertices += w.count, this.stats.indices += y.index?.count ?? w.count;
         });
       });
-    }), this.stats.instances = this.#s.length, this.stats.unsupportedInstances = e.reduce((i, a) => i + a.instances.length, 0);
-    const n = Vn(this.#s.length);
-    return this.#i = Jn(n), this.#r(), t.forEach((i) => this.#d(i)), this.stats.batches = this.children.length, this.stats.drawCallsSaved = Math.max(0, this.stats.sourceMeshes - this.stats.batches), this.children.forEach((i) => {
-      i instanceof P && (i.onBeforeRender = () => this.#r());
+    }), this.stats.instances = this.#t.length, this.stats.unsupportedInstances = e.reduce((r, a) => r + a.instances.length, 0);
+    const n = Ir(this.#t.length);
+    return this.#n = Er(n), this.#i(), t.forEach((r) => this.#u(r)), this.stats.batches = this.children.length, this.stats.drawCallsSaved = Math.max(0, this.stats.sourceMeshes - this.stats.batches), this.children.forEach((r) => {
+      r instanceof k && (r.onBeforeRender = () => this.#i());
     }), { stats: { ...this.stats }, unsupported: e };
   }
   materialize(e) {
     const t = this.#e.get(e);
     if (!t || t.materialized) return e.getInstanceRenderObject();
-    const s = Yn(t.template);
-    return s.position.set(0, 0, 0), s.quaternion.identity(), s.scale.set(1, 1, 1), s.matrix.identity(), t.materialized = !0, e.setInstanceRenderObject(s), s.updateWorldMatrix(!0, !0), this.#n.add(t), this.dispatchEvent({ type: "materialize", instance: e, object: s }), s;
+    const s = Sr(t.template);
+    return s.position.set(0, 0, 0), s.quaternion.identity(), s.scale.set(1, 1, 1), s.matrix.identity(), t.materialized = !0, e.setInstanceRenderObject(s), s.updateWorldMatrix(!0, !0), this.#r.add(t), this.dispatchEvent({ type: "materialize", instance: e, object: s }), s;
   }
-  #d(e) {
+  #u(e) {
     const t = [];
-    let s = [], n = 0, i = 0;
+    let s = [], n = 0, r = 0;
     e.forEach((a) => {
       const o = a.geometry.getAttribute("position").count, c = a.geometry.index?.count ?? o;
-      s.length > 0 && (n + o > this.options.maxVerticesPerBatch || i + c > this.options.maxIndicesPerBatch) && (t.push(s), s = [], n = 0, i = 0), s.push(a), n += o, i += c;
+      s.length > 0 && (n + o > this.options.maxVerticesPerBatch || r + c > this.options.maxIndicesPerBatch) && (t.push(s), s = [], n = 0, r = 0), s.push(a), n += o, r += c;
     }), s.length > 0 && t.push(s), t.forEach((a) => {
-      const o = en(a.map((d) => d.geometry), !1);
-      if (a.forEach((d) => d.geometry.dispose()), !o || !this.#i) return;
+      const o = Mn(a.map((u) => u.geometry), !1);
+      if (a.forEach((u) => u.geometry.dispose()), !o || !this.#n) return;
       o.computeBoundingBox(), o.computeBoundingSphere();
-      const c = a[0], l = a.flatMap((d) => d.objectIndices), h = Zn(c.material, this.#i), u = new ei(
+      const c = a[0], l = a.flatMap((u) => u.objectIndices), h = Cr(c.material, this.#n), d = new Ar(
         o,
         h,
         l,
-        this.#s
+        this.#t
       );
-      u.name = `EditableGeometryBatch:${this.children.length}`, u.castShadow = c.castShadow, u.receiveShadow = c.receiveShadow, u.renderOrder = c.renderOrder, u.matrixAutoUpdate = !1, this.add(u);
+      d.name = `EditableGeometryBatch:${this.children.length}`, d.castShadow = c.castShadow, d.receiveShadow = c.receiveShadow, d.renderOrder = c.renderOrder, d.matrixAutoUpdate = !1, this.add(d);
     });
   }
-  #r() {
-    if (!(!this.#i || this.#n.size === 0 || this.#h)) {
-      this.#h = !0;
+  #i() {
+    if (!(!this.#n || this.#r.size === 0 || this.#d)) {
+      this.#d = !0;
       try {
         this.updateWorldMatrix(!0, !1), this.#o.copy(this.matrixWorld).invert();
-        const e = this.#i.image.data;
-        [...this.#n].sort((t, s) => lt(t.instance) - lt(s.instance)).forEach((t) => {
+        const e = this.#n.image.data;
+        [...this.#r].sort((t, s) => St(t.instance) - St(s.instance)).forEach((t) => {
           const { instance: s, objectIndex: n } = t;
-          s.updateWorldMatrix(!0, !1), ce.multiplyMatrices(this.#o, s.matrixWorld), !t.materialized && s.getInstanceRenderObject() !== null && !s.hasInstanceMaterializer(t.materializer) && (t.materialized = !0), !t.materialized && !Fn(ce, t.initialMatrix) && this.materialize(s), !t.materialized && s.getInstanceOpacity() < 0.999 && this.materialize(s);
-          const i = n * 4, a = !t.materialized && $t(s) && s.getInstanceOpacity() > 1e-3, o = s.getInstanceColor();
-          e[i] = o.r, e[i + 1] = o.g, e[i + 2] = o.b, e[i + 3] = a ? s.getInstanceColorMode() : -1, this.#n.delete(t);
-        }), this.#i.needsUpdate = !0;
+          s.updateWorldMatrix(!0, !1), le.multiplyMatrices(this.#o, s.matrixWorld), !t.materialized && s.getInstanceRenderObject() !== null && !s.hasInstanceMaterializer(t.materializer) && (t.materialized = !0), !t.materialized && !gr(le, t.initialMatrix) && this.materialize(s), !t.materialized && s.getInstanceOpacity() < 0.999 && this.materialize(s);
+          const r = n * 4, a = !t.materialized && as(s) && s.getInstanceOpacity() > 1e-3, o = s.getInstanceColor();
+          e[r] = o.r, e[r + 1] = o.g, e[r + 2] = o.b, e[r + 3] = a ? s.getInstanceColorMode() : -1, this.#r.delete(t);
+        }), this.#n.needsUpdate = !0;
       } finally {
-        this.#h = !1;
+        this.#d = !1;
       }
-      this.#n.size > 0 && this.#r();
+      this.#r.size > 0 && this.#i();
     }
   }
-  #p(e) {
-    this.#n.add(e), this.#r();
+  #h(e) {
+    this.#r.add(e), this.#i();
   }
   dispose() {
-    this.#l || (this.#l = !0, this.#s.forEach((e) => {
+    this.#l || (this.#l = !0, this.#t.forEach((e) => {
       e.unsubscribe(), e.instance.clearInstanceMaterializer(e.materializer);
-    }), this.#s.length = 0, this.#e.clear(), this.#a.clear(), this.#n.clear(), this.#t.length = 0, this.#i?.dispose(), this.#i = null, this.traverse((e) => {
-      if (!(e instanceof P)) return;
+    }), this.#t.length = 0, this.#e.clear(), this.#a.clear(), this.#r.clear(), this.#s.length = 0, this.#n?.dispose(), this.#n = null, this.traverse((e) => {
+      if (!(e instanceof k)) return;
       e.geometry.dispose(), (Array.isArray(e.material) ? e.material : [e.material]).forEach((s) => s.dispose());
     }), this.clear());
   }
 }
-const ht = new L(), de = new L(), ut = new L(), dt = new L(), pt = new $(), mt = new ne(), ft = new ne(), ti = new Ds(), ee = new A(), gt = new z(), yt = new C(), bt = new L(), wt = new L(), xt = new ne(), pe = [], Kt = 1e-6, W = 1e-6, Xt = 0.999, si = 0, Mt = 1;
-function ni(r, e, t) {
-  const s = r.elements;
+const It = new R(), me = new R(), Et = new R(), Ct = new R(), At = new K(), Ot = new ne(), Bt = new ne(), Or = new sn(), Z = new P(), _t = new j(), Tt = new D(), Lt = new R(), Nt = new R(), Dt = new ne(), ge = [], os = 1e-6, H = 1e-6, cs = 0.999, Br = 0, Pt = 1;
+function _r(i, e, t) {
+  const s = i.elements;
   for (let n = 0; n < 16; n++)
-    if (Math.abs(s[n] - e[t + n]) > Kt) return !1;
+    if (Math.abs(s[n] - e[t + n]) > os) return !1;
   return !0;
 }
-function ii(r, e, t, s) {
-  return Math.abs(r.r - t[s]) <= W && Math.abs(r.g - t[s + 1]) <= W && Math.abs(r.b - t[s + 2]) <= W && Math.abs(e - t[s + 3]) <= W;
+function Tr(i, e, t, s) {
+  return Math.abs(i.r - t[s]) <= H && Math.abs(i.g - t[s + 1]) <= H && Math.abs(i.b - t[s + 2]) <= H && Math.abs(e - t[s + 3]) <= H;
 }
-function It(r, e) {
-  const t = r.elements, s = e.elements;
+function Rt(i, e) {
+  const t = i.elements, s = e.elements;
   for (let n = 0; n < 16; n++)
-    if (Math.abs(t[n] - s[n]) > Kt) return !1;
+    if (Math.abs(t[n] - s[n]) > os) return !1;
   return !0;
 }
-function _e(r) {
-  let e = r;
+function De(i) {
+  let e = i;
   for (; e; ) {
     if (!e.visible) return !1;
     e = e.parent;
   }
   return !0;
 }
-function ri(r) {
-  const e = r.geometry.morphAttributes;
+function Lr(i) {
+  const e = i.geometry.morphAttributes;
   return Object.values(e).some((t) => t?.length);
 }
-function ai(r) {
-  const e = r.material;
+function Nr(i) {
+  const e = i.material;
   if (!Array.isArray(e)) return !0;
   if (e.length === 0 || !e.every(Boolean)) return !1;
-  const t = r.geometry.groups;
+  const t = i.geometry.groups;
   return t.length === 0 ? !1 : t.every((s) => {
     const n = s.materialIndex ?? 0;
     return Number.isInteger(s.start) && s.start >= 0 && Number.isInteger(s.count) && s.count > 0 && Number.isInteger(n) && n >= 0 && n < e.length;
   });
 }
-function oi(r) {
-  return !r.isSkinnedMesh && !ri(r) && ai(r);
+function Dr(i) {
+  return !i.isSkinnedMesh && !Lr(i) && Nr(i);
 }
-function St(r) {
-  return Array.isArray(r) ? r : [r];
+function kt(i) {
+  return Array.isArray(i) ? i : [i];
 }
-function Qt(r) {
-  return r.transparent || r.opacity < Xt;
+function ls(i) {
+  return i.transparent || i.opacity < cs;
 }
-function vt(r, e, t) {
-  const s = r.clone(), n = Xe(e, "vec4", 4, 0), i = Xe(t, "float", 1, 0), a = s.colorNode ?? xe, o = s.opacityNode ? Vs(s.opacityNode) : Oe, c = F(n.a.greaterThan(1.5), a.mul(n.rgb), n.rgb);
-  return s.colorNode = F(n.a.greaterThan(0.5), c, a), s.opacityNode = o.mul(i), s.transparent = Qt(r), s.needsUpdate = !0, s;
+function zt(i, e, t) {
+  const s = i.clone(), n = it(e, "vec4", 4, 0), r = it(t, "float", 1, 0), a = s.colorNode ?? Ce, o = s.opacityNode ? bn(s.opacityNode) : ze, c = $(n.a.greaterThan(1.5), a.mul(n.rgb), n.rgb);
+  return s.colorNode = $(n.a.greaterThan(0.5), c, a), s.opacityNode = o.mul(r), s.transparent = ls(i), s.needsUpdate = !0, s;
 }
-function ci(r, e, t) {
-  return Array.isArray(r) ? r.map((s) => vt(s, e, t)) : vt(r, e, t);
+function Pr(i, e, t) {
+  return Array.isArray(i) ? i.map((s) => zt(s, e, t)) : zt(i, e, t);
 }
-function li(r) {
-  const e = [], t = new L();
+function Rr(i) {
+  const e = [], t = new R();
   let s = !1;
-  return r.updateWorldMatrix(!0, !0), t.copy(r.matrixWorld).invert(), r.traverse((n) => {
-    if (!s && !(!(n instanceof P) || !n.visible)) {
-      if (!oi(n)) {
+  return i.updateWorldMatrix(!0, !0), t.copy(i.matrixWorld).invert(), i.traverse((n) => {
+    if (!s && !(!(n instanceof k) || !n.visible)) {
+      if (!Dr(n)) {
         s = !0;
         return;
       }
@@ -2628,48 +3148,48 @@ function li(r) {
     }
   }), s ? [] : e;
 }
-function hi(r) {
-  const e = new $();
-  return r.forEach(({ mesh: t, localMatrix: s }) => {
+function kr(i) {
+  const e = new K();
+  return i.forEach(({ mesh: t, localMatrix: s }) => {
     const n = t.geometry;
-    n.boundingBox || n.computeBoundingBox(), n.boundingBox && (pt.copy(n.boundingBox).applyMatrix4(s), e.union(pt));
+    n.boundingBox || n.computeBoundingBox(), n.boundingBox && (At.copy(n.boundingBox).applyMatrix4(s), e.union(At));
   }), e;
 }
-function te(r) {
-  const e = r;
+function ee(i) {
+  const e = i;
   "needsUpdate" in e && (e.needsUpdate = !0);
 }
-function Bt(r, e = Mt) {
-  let t = Math.max(Mt, e);
-  for (; t < r; )
+function Ut(i, e = Pt) {
+  let t = Math.max(Pt, e);
+  for (; t < i; )
     t *= 2;
   return t;
 }
-function ui(r) {
-  return r !== null && typeof r == "object" && Symbol.iterator in r;
+function zr(i) {
+  return i !== null && typeof i == "object" && Symbol.iterator in i;
 }
-class $i extends ue {
+class wi extends pe {
   isModelInstancedLayer = !0;
   type = "ModelInstancedLayer";
-  #t = [];
+  #s = [];
   #a = /* @__PURE__ */ new Map();
-  #s = /* @__PURE__ */ new Map();
+  #t = /* @__PURE__ */ new Map();
   #e = /* @__PURE__ */ new Map();
-  #n = !0;
-  #i = !1;
+  #r = !0;
+  #n = !1;
   #o = !0;
-  #c = si;
+  #c = Br;
   #l;
-  #h;
+  #d;
   constructor(e = {}) {
-    super(), this.name = e.name ?? "ModelInstances", this.#l = e.instanceKind ?? "", this.#h = e.getHitUserData ?? (() => ({}));
+    super(), this.name = e.name ?? "ModelInstances", this.#l = e.instanceKind ?? "", this.#d = e.getHitUserData ?? (() => ({}));
   }
   get instanceKind() {
     return this.#l;
   }
   getInstances() {
     const e = [];
-    return this.#r((t) => e.push(t)), e;
+    return this.#i((t) => e.push(t)), e;
   }
   getInstanceById(e) {
     return this.#w(), this.#e.get(e);
@@ -2679,124 +3199,124 @@ class $i extends ue {
   }
   getInstanceCulling() {
     return {
-      enabled: this.#i,
+      enabled: this.#n,
       frustum: this.#o,
       minScreenRadius: this.#c
     };
   }
   setInstanceCulling(e = {}) {
     let t = !1;
-    if (e.enabled !== void 0 && this.#i !== e.enabled && (this.#i = e.enabled, t = !0), e.frustum !== void 0 && this.#o !== e.frustum && (this.#o = e.frustum, t = !0), e.minScreenRadius !== void 0) {
+    if (e.enabled !== void 0 && this.#n !== e.enabled && (this.#n = e.enabled, t = !0), e.frustum !== void 0 && this.#o !== e.frustum && (this.#o = e.frustum, t = !0), e.minScreenRadius !== void 0) {
       const s = Math.max(0, e.minScreenRadius);
-      Math.abs(this.#c - s) > W && (this.#c = s, t = !0);
+      Math.abs(this.#c - s) > H && (this.#c = s, t = !0);
     }
-    return t && this.#t.forEach((s) => this.#v(s)), this;
+    return t && this.#s.forEach((s) => this.#I(s)), this;
   }
   setInstanceVisible(e) {
-    return this.visible !== e && (this.visible = e), this.#r((t) => {
+    return this.visible !== e && (this.visible = e), this.#i((t) => {
       t.setInstanceVisible(e);
     }), this;
   }
   setInstanceColor(e) {
-    return this.#r((t) => {
+    return this.#i((t) => {
       t.setInstanceColor(e);
     }), this;
   }
   resetInstanceColor() {
-    return this.#r((e) => {
+    return this.#i((e) => {
       e.resetInstanceColor();
     }), this;
   }
   setInstanceOpacity(e) {
-    return this.#r((t) => {
+    return this.#i((t) => {
       t.setInstanceOpacity(e);
     }), this;
   }
   setInstanceHighlight(e, t, s = !1) {
-    return this.#r((n) => {
+    return this.#i((n) => {
       n.setInstanceHighlight(e, t, s);
     }), this;
   }
   clearInstanceHighlight() {
-    return this.#r((e) => {
+    return this.#i((e) => {
       e.clearInstanceHighlight();
     }), this;
   }
   reserveBatch(e, t, s) {
     const n = Math.floor(s);
-    return n <= 0 ? !1 : this.#d(e, t, n) !== null;
+    return n <= 0 ? !1 : this.#u(e, t, n) !== null;
   }
   addInstance(e, t, s) {
     return this.addInstances(e, t, [s]);
   }
   addInstances(e, t, s) {
     if (s.length === 0) return !1;
-    const n = this.#a.has(e), i = this.#d(e, t, s.length);
-    if (!i) return !1;
+    const n = this.#a.has(e), r = this.#u(e, t, s.length);
+    if (!r) return !1;
     const a = [], o = /* @__PURE__ */ new Set();
     return s.forEach((c) => {
-      o.has(c) || (o.add(c), this.#s.get(c) === i) || a.push(c);
-    }), a.length === 0 ? !0 : this.#E(a) ? (a.forEach((c) => {
-      const l = this.#s.get(c);
-      l && l !== i && this.#I(l, c);
-    }), this.#M(i, i.instances.length + a.length), a.forEach((c) => {
-      c.setInstanceBounds(i.templateBounds), i.instances.push(c), this.#s.set(c, i), i.unsubscribeByInstance.set(
+      o.has(c) || (o.add(c), this.#t.get(c) === r) || a.push(c);
+    }), a.length === 0 ? !0 : this.#C(a) ? (a.forEach((c) => {
+      const l = this.#t.get(c);
+      l && l !== r && this.#v(l, c);
+    }), this.#M(r, r.instances.length + a.length), a.forEach((c) => {
+      c.setInstanceBounds(r.templateBounds), r.instances.push(c), this.#t.set(c, r), r.unsubscribeByInstance.set(
         c,
         c.onInstanceRenderDirty(() => {
-          this.#g(), this.#y(i);
+          this.#g(), this.#y(r);
         })
       );
-    }), this.#g(), this.#b(i), this.#y(i), !0) : (!n && i.instances.length === 0 && this.#f(i), !1);
+    }), this.#g(), this.#b(r), this.#y(r), !0) : (!n && r.instances.length === 0 && this.#m(r), !1);
   }
   removeInstance(e) {
     return this.removeInstances([e]) > 0;
   }
   removeInstances(e) {
-    const t = /* @__PURE__ */ new Set(), s = /* @__PURE__ */ new Set(), n = typeof e == "string" || !ui(e) ? [e] : e;
+    const t = /* @__PURE__ */ new Set(), s = /* @__PURE__ */ new Set(), n = typeof e == "string" || !zr(e) ? [e] : e;
     for (const a of n)
-      typeof a == "string" ? t.add(a) : this.#s.has(a) && s.add(a);
+      typeof a == "string" ? t.add(a) : this.#t.has(a) && s.add(a);
     t.size > 0 && (this.#w(), t.forEach((a) => {
       const o = this.#e.get(a);
       o && s.add(o);
     }));
-    let i = 0;
+    let r = 0;
     return s.forEach((a) => {
-      const o = this.#s.get(a);
-      o && this.#I(o, a) && i++;
-    }), i;
+      const o = this.#t.get(a);
+      o && this.#v(o, a) && r++;
+    }), r;
   }
   removeBatch(e) {
     const t = this.#a.get(e);
-    return t ? (this.#f(t), !0) : !1;
+    return t ? (this.#m(t), !0) : !1;
   }
   clearBatches() {
-    return [...this.#a.values()].forEach((e) => this.#f(e)), this;
+    return [...this.#a.values()].forEach((e) => this.#m(e)), this;
   }
-  #d(e, t, s) {
+  #u(e, t, s) {
     const n = this.#a.get(e);
     if (n)
       return this.#M(n, s), n;
     if (t.animations?.length) return null;
-    const i = li(t);
-    if (i.length === 0) return null;
-    const a = hi(i), o = new H();
+    const r = Rr(t);
+    if (r.length === 0) return null;
+    const a = kr(r), o = new W();
     o.name = e, this.add(o);
     const c = {
       url: e,
       batch: o,
-      templateMeshes: i,
+      templateMeshes: r,
       templateBounds: a,
       records: [],
       instances: [],
       unsubscribeByInstance: /* @__PURE__ */ new Map(),
-      capacity: Bt(s)
+      capacity: Ut(s)
     };
-    return i.forEach(({ mesh: l, localMatrix: h }, u) => {
-      const d = this.#p(c, l, h, u);
-      c.records.push(d), this.#t.push(d);
+    return r.forEach(({ mesh: l, localMatrix: h }, d) => {
+      const u = this.#h(c, l, h, d);
+      c.records.push(u), this.#s.push(u);
     }), this.#a.set(e, c), this.#b(c), c;
   }
-  #r(e) {
+  #i(e) {
     const t = /* @__PURE__ */ new Set();
     this.#a.forEach((s) => {
       s.instances.forEach((n) => {
@@ -2804,91 +3324,91 @@ class $i extends ue {
       });
     });
   }
-  #p(e, t, s, n) {
-    const i = new We(new Float32Array(e.capacity * 4), 4), a = new We(new Float32Array(e.capacity).fill(1), 1);
-    i.setUsage(Be), a.setUsage(Be);
-    const o = ci(
+  #h(e, t, s, n) {
+    const r = new Je(new Float32Array(e.capacity * 4), 4), a = new Je(new Float32Array(e.capacity).fill(1), 1);
+    r.setUsage(Te), a.setUsage(Te);
+    const o = Pr(
       t.material,
-      i,
+      r,
       a
-    ), c = St(o), l = St(t.material).some(
-      Qt
-    ), h = new Rs(t.geometry, o, e.capacity);
-    h.instanceMatrix = new js(e.capacity, 16), h.count = 0, h.name = t.name || `${e.url}#${n}`, h.castShadow = t.castShadow, h.receiveShadow = t.receiveShadow, h.frustumCulled = !0, h.matrixAutoUpdate = !1, h.instanceMatrix.setUsage(Be), h.userData.url = e.url;
-    const u = new P(t.geometry, o);
-    u.matrixAutoUpdate = !1;
-    const d = {
+    ), c = kt(o), l = kt(t.material).some(
+      ls
+    ), h = new nn(t.geometry, o, e.capacity);
+    h.instanceMatrix = new rn(e.capacity, 16), h.count = 0, h.name = t.name || `${e.url}#${n}`, h.castShadow = t.castShadow, h.receiveShadow = t.receiveShadow, h.frustumCulled = !0, h.matrixAutoUpdate = !1, h.instanceMatrix.setUsage(Te), h.userData.url = e.url;
+    const d = new k(t.geometry, o);
+    d.matrixAutoUpdate = !1;
+    const u = {
       batchRecord: e,
       mesh: h,
       boundsTree: void 0,
-      raycastMesh: u,
+      raycastMesh: d,
       localMatrix: s.clone(),
       fullBoundingSphere: new ne(),
       materials: c,
       hasSourceTransparency: l,
-      colorAttribute: i,
+      colorAttribute: r,
       opacityAttribute: a,
       renderedInstances: [],
       visibleInstances: [],
-      lastCameraMatrixWorldInverse: new L(),
-      lastCameraProjectionMatrix: new L(),
+      lastCameraMatrixWorldInverse: new R(),
+      lastCameraProjectionMatrix: new R(),
       lastViewportHeight: 0,
       hasLastCameraState: !1,
       dirty: !0
     };
-    h.userData.getInstanceObjectByRenderIndex = (m) => d.renderedInstances[m], h.userData.raycastAcceleration = "lazy";
+    h.userData.getInstanceObjectByRenderIndex = (x) => u.renderedInstances[x], h.userData.raycastAcceleration = "lazy";
     const p = h.raycast.bind(h);
-    return h.raycast = (m, b) => {
-      if (this.#B(d), !this.#m(d, m)) return;
-      d.boundsTree === void 0 && (d.boundsTree = Et(d.mesh.geometry), d.mesh.userData.raycastAcceleration = d.boundsTree ? "three-mesh-bvh" : "default");
-      const S = b.length;
-      d.boundsTree ? this.#u(d, m, b) : p(m, b);
-      for (let w = S; w < b.length; ) {
-        const g = b[w], I = g.instanceId;
-        if (I === void 0) {
-          w++;
+    return h.raycast = (x, I) => {
+      if (this.#E(u), !this.#p(u, x)) return;
+      u.boundsTree === void 0 && (u.boundsTree = jt(u.mesh.geometry), u.mesh.userData.raycastAcceleration = u.boundsTree ? "three-mesh-bvh" : "default");
+      const _ = I.length;
+      u.boundsTree ? this.#f(u, x, I) : p(x, I);
+      for (let C = _; C < I.length; ) {
+        const y = I[C], w = y.instanceId;
+        if (w === void 0) {
+          C++;
           continue;
         }
-        const B = d.renderedInstances[I];
-        if (!B || !_e(B)) {
-          b.splice(w, 1);
+        const g = u.renderedInstances[w];
+        if (!g || !De(g)) {
+          I.splice(C, 1);
           continue;
         }
-        g.object = B, g.instanceObject = B, g.instanceObjectId = B.instanceId, g.instanceKind = B.instanceKind || this.#l, g.instanceName = B.instanceName, g.instanceIndex = I, Object.assign(g, this.#h(B, I)), w++;
+        y.object = g, y.instanceObject = g, y.instanceObjectId = g.instanceId, y.instanceKind = g.instanceKind || this.#l, y.instanceName = g.instanceName, y.instanceIndex = w, Object.assign(y, this.#d(g, w)), C++;
       }
-    }, h.onBeforeRender = (m, b, S) => this.#B(d, m, S), e.batch.add(h), d;
+    }, h.onBeforeRender = (x, I, _) => this.#E(u, x, _), e.batch.add(h), u;
   }
-  #m(e, t) {
+  #p(e, t) {
     const { mesh: s } = e;
-    return s.count === 0 ? !1 : (s.boundingSphere === null && s.computeBoundingSphere(), s.boundingSphere ? (xt.copy(s.boundingSphere).applyMatrix4(s.matrixWorld), t.ray.intersectsSphere(xt)) : !0);
+    return s.count === 0 ? !1 : (s.boundingSphere === null && s.computeBoundingSphere(), s.boundingSphere ? (Dt.copy(s.boundingSphere).applyMatrix4(s.matrixWorld), t.ray.intersectsSphere(Dt)) : !0);
   }
-  #u(e, t, s) {
-    const { mesh: n, boundsTree: i, raycastMesh: a } = e;
-    if (!(!i || n.count === 0)) {
+  #f(e, t, s) {
+    const { mesh: n, boundsTree: r, raycastMesh: a } = e;
+    if (!(!r || n.count === 0)) {
       a.geometry = n.geometry, a.material = n.material;
       for (let o = 0; o < n.count; o++)
-        n.getMatrixAt(o, bt), wt.multiplyMatrices(n.matrixWorld, bt), a.matrixWorld.copy(wt), pe.length = 0, i.raycastObject3D(a, t, pe), pe.forEach((c) => {
+        n.getMatrixAt(o, Lt), Nt.multiplyMatrices(n.matrixWorld, Lt), a.matrixWorld.copy(Nt), ge.length = 0, r.raycastObject3D(a, t, ge), ge.forEach((c) => {
           c.instanceId = o, c.object = n, s.push(c);
-        }), pe.length = 0;
+        }), ge.length = 0;
     }
   }
   #M(e, t) {
     if (t <= e.capacity) return;
-    e.capacity = Bt(t, e.capacity);
+    e.capacity = Ut(t, e.capacity);
     const s = new Set(e.records);
-    s.forEach((n) => this.#S(n)), this.#t = this.#t.filter((n) => !s.has(n)), e.records = e.templateMeshes.map(({ mesh: n, localMatrix: i }, a) => {
-      const o = this.#p(e, n, i, a);
-      return this.#t.push(o), o;
+    s.forEach((n) => this.#S(n)), this.#s = this.#s.filter((n) => !s.has(n)), e.records = e.templateMeshes.map(({ mesh: n, localMatrix: r }, a) => {
+      const o = this.#h(e, n, r, a);
+      return this.#s.push(o), o;
     }), this.#y(e);
   }
-  #I(e, t) {
+  #v(e, t) {
     const s = e.instances.indexOf(t);
-    return s === -1 ? !1 : (e.instances.splice(s, 1), e.records.forEach((n) => n.visibleInstances.splice(s, 1)), this.#s.delete(t), this.#g(), e.unsubscribeByInstance.get(t)?.(), e.unsubscribeByInstance.delete(t), e.instances.length === 0 ? (this.#f(e), !0) : (this.#b(e), this.#y(e), !0));
+    return s === -1 ? !1 : (e.instances.splice(s, 1), e.records.forEach((n) => n.visibleInstances.splice(s, 1)), this.#t.delete(t), this.#g(), e.unsubscribeByInstance.get(t)?.(), e.unsubscribeByInstance.delete(t), e.instances.length === 0 ? (this.#m(e), !0) : (this.#b(e), this.#y(e), !0));
   }
-  #f(e) {
-    e.unsubscribeByInstance.forEach((s) => s()), e.instances.forEach((s) => this.#s.delete(s)), e.unsubscribeByInstance.clear(), e.instances.length = 0, this.#g();
+  #m(e) {
+    e.unsubscribeByInstance.forEach((s) => s()), e.instances.forEach((s) => this.#t.delete(s)), e.unsubscribeByInstance.clear(), e.instances.length = 0, this.#g();
     const t = new Set(e.records);
-    t.forEach((s) => this.#S(s)), this.#t = this.#t.filter((s) => !t.has(s)), e.records.length = 0, e.templateMeshes.length = 0, this.#a.delete(e.url), this.remove(e.batch);
+    t.forEach((s) => this.#S(s)), this.#s = this.#s.filter((s) => !t.has(s)), e.records.length = 0, e.templateMeshes.length = 0, this.#a.delete(e.url), this.remove(e.batch);
   }
   #S(e) {
     e.batchRecord.batch.remove(e.mesh), e.mesh.dispose(), e.materials.forEach((t) => t.dispose());
@@ -2903,27 +3423,27 @@ class $i extends ue {
       delete t.mesh.userData.instances;
     });
   }
-  #E(e) {
+  #C(e) {
     const t = new Set(e), s = /* @__PURE__ */ new Map();
-    for (const i of e) {
-      const { instanceId: a } = i;
+    for (const r of e) {
+      const { instanceId: a } = r;
       if (!a) continue;
       const o = s.get(a);
-      if (o && o !== i) return !1;
-      s.set(a, i);
+      if (o && o !== r) return !1;
+      s.set(a, r);
     }
     let n = !0;
-    return s.forEach((i, a) => {
-      n && this.#r((o) => {
+    return s.forEach((r, a) => {
+      n && this.#i((o) => {
         !n || t.has(o) || o.instanceId === a && (n = !1);
       });
     }), n;
   }
   #w() {
-    if (!this.#n) return;
+    if (!this.#r) return;
     this.#e.clear();
     const e = /* @__PURE__ */ new Set();
-    this.#r((t) => {
+    this.#i((t) => {
       const { instanceId: s } = t;
       if (!s || e.has(s)) return;
       const n = this.#e.get(s);
@@ -2932,128 +3452,131 @@ class $i extends ue {
         return;
       }
       this.#e.set(s, t);
-    }), this.#n = !1;
+    }), this.#r = !1;
   }
   #g() {
-    this.#n = !0;
+    this.#r = !0;
   }
   #y(e) {
-    e.records.forEach((t) => this.#v(t));
+    e.records.forEach((t) => this.#I(t));
   }
-  #v(e) {
-    e.dirty = !0, e.hasLastCameraState = !1, e.mesh.visible = !0, e.mesh.frustumCulled = !1, te(e.batchRecord.batch);
+  #I(e) {
+    e.dirty = !0, e.hasLastCameraState = !1, e.mesh.visible = !0, e.mesh.frustumCulled = !1, ee(e.batchRecord.batch);
   }
-  #B(e, t, s) {
-    const n = this.#C(t), i = this.#O(e, s, n);
-    !e.dirty && !this.#_(e) && !i || this.#P(e, s, n);
+  #E(e, t, s) {
+    const n = this.#O(t), r = this.#B(e, s, n);
+    !e.dirty && !this.#A(e) && !r || this.#N(e, s, n);
   }
-  #_(e) {
+  #A(e) {
     const { instances: t } = e.batchRecord;
     for (let s = 0; s < t.length; s++)
-      if (e.visibleInstances[s] !== _e(t[s]))
-        return e.dirty = !0, te(e.batchRecord.batch), !0;
+      if (e.visibleInstances[s] !== De(t[s]))
+        return e.dirty = !0, ee(e.batchRecord.batch), !0;
     return !1;
   }
-  #C(e) {
-    return e?.getDrawingBufferSize ? (e.getDrawingBufferSize(gt), gt.y) : 0;
+  #O(e) {
+    return e?.getDrawingBufferSize ? (e.getDrawingBufferSize(_t), _t.y) : 0;
   }
-  #O(e, t, s) {
-    return this.#x(t, s) ? e.hasLastCameraState ? !It(e.lastCameraMatrixWorldInverse, t.matrixWorldInverse) || !It(e.lastCameraProjectionMatrix, t.projectionMatrix) || Math.abs(e.lastViewportHeight - s) > W : !0 : !1;
+  #B(e, t, s) {
+    return this.#x(t, s) ? e.hasLastCameraState ? !Rt(e.lastCameraMatrixWorldInverse, t.matrixWorldInverse) || !Rt(e.lastCameraProjectionMatrix, t.projectionMatrix) || Math.abs(e.lastViewportHeight - s) > H : !0 : !1;
   }
   #x(e, t) {
-    return this.#i && e !== void 0 && (this.#o || this.#c > 0 && t > 0);
+    return this.#n && e !== void 0 && (this.#o || this.#c > 0 && t > 0);
   }
-  #A(e, t) {
+  #_(e, t) {
     if (!this.#x(e, t)) return null;
     let s = null;
-    return this.#o && (dt.multiplyMatrices(e.projectionMatrix, e.matrixWorldInverse), s = ti.setFromProjectionMatrix(dt)), { camera: e, frustum: s, viewportHeight: t };
+    return this.#o && (Ct.multiplyMatrices(e.projectionMatrix, e.matrixWorldInverse), s = Or.setFromProjectionMatrix(Ct)), { camera: e, frustum: s, viewportHeight: t };
   }
   #T(e, t) {
     return t ? t.frustum && !t.frustum.intersectsSphere(e) ? !1 : this.#c <= 0 || t.viewportHeight <= 0 ? !0 : this.#L(e, t.camera, t.viewportHeight) >= this.#c : !0;
   }
   #L(e, t, s) {
     const n = Math.abs(t.projectionMatrix.elements[5]);
-    if (n <= W) return 1 / 0;
+    if (n <= H) return 1 / 0;
     if (t.isOrthographicCamera)
       return e.radius * n * s * 0.5;
-    yt.copy(e.center).applyMatrix4(t.matrixWorldInverse);
-    const i = -yt.z;
-    return i <= W ? 1 / 0 : e.radius * n * s * 0.5 / i;
-  }
-  #P(e, t, s = 0) {
-    this.updateWorldMatrix(!0, !1), ht.copy(this.matrixWorld).invert();
-    const n = e.mesh.instanceMatrix.array, i = e.colorAttribute.array, a = e.opacityAttribute.array, o = e.mesh.geometry;
-    let c = !1, l = !1, h = !1, u = 0, d = 0, p = !1;
-    const m = e.mesh.count, b = this.#A(t, s);
-    o.boundingSphere || o.computeBoundingSphere(), e.fullBoundingSphere.makeEmpty(), e.renderedInstances.length = 0, e.batchRecord.instances.forEach((g, I) => {
-      const B = _e(g);
-      e.visibleInstances[I] = B, g.updateWorldMatrix(!0, !1), de.multiplyMatrices(ht, g.matrixWorld).multiply(e.localMatrix);
-      const O = g.getInstanceOpacity();
-      if (!(B && O > W) || (d++, o.boundingSphere && (mt.copy(o.boundingSphere).applyMatrix4(de), e.fullBoundingSphere.union(mt), b && (ut.multiplyMatrices(g.matrixWorld, e.localMatrix), ft.copy(o.boundingSphere).applyMatrix4(ut), !this.#T(ft, b)))))
+    Tt.copy(e.center).applyMatrix4(t.matrixWorldInverse);
+    const r = -Tt.z;
+    return r <= H ? 1 / 0 : e.radius * n * s * 0.5 / r;
+  }
+  #N(e, t, s = 0) {
+    this.updateWorldMatrix(!0, !1), It.copy(this.matrixWorld).invert();
+    const n = e.mesh.instanceMatrix.array, r = e.colorAttribute.array, a = e.opacityAttribute.array, o = e.mesh.geometry;
+    let c = !1, l = !1, h = !1, d = 0, u = 0, p = !1;
+    const x = e.mesh.count, I = this.#_(t, s);
+    o.boundingSphere || o.computeBoundingSphere(), e.fullBoundingSphere.makeEmpty(), e.renderedInstances.length = 0, e.batchRecord.instances.forEach((y, w) => {
+      const g = De(y);
+      e.visibleInstances[w] = g, y.updateWorldMatrix(!0, !1), me.multiplyMatrices(It, y.matrixWorld).multiply(e.localMatrix);
+      const m = y.getInstanceOpacity();
+      if (!(g && m > H) || (u++, o.boundingSphere && (Ot.copy(o.boundingSphere).applyMatrix4(me), e.fullBoundingSphere.union(Ot), I && (Et.multiplyMatrices(y.matrixWorld, e.localMatrix), Bt.copy(o.boundingSphere).applyMatrix4(Et), !this.#T(Bt, I)))))
         return;
-      const y = u, _ = y * 16;
-      ni(de, n, _) || (e.mesh.setMatrixAt(y, de), c = !0), ee.copy(g.getInstanceColor(ee));
-      const k = g.getInstanceColorMode(), N = y * 4;
-      ii(ee, k, i, N) || (e.colorAttribute.setXYZW(y, ee.r, ee.g, ee.b, k), l = !0), O < Xt && (p = !0), Math.abs(O - a[y]) > W && (e.opacityAttribute.setX(y, O), h = !0), e.renderedInstances[y] = g, u++;
-    }), e.mesh.count = u, m !== u && (c = !0, l = !0, h = !0, te(e.batchRecord.batch));
-    const S = d > 0;
-    e.mesh.visible !== S && (e.mesh.visible = S, te(e.batchRecord.batch)), e.mesh.frustumCulled !== !0 && (e.mesh.frustumCulled = !0, te(e.batchRecord.batch)), c && (e.mesh.instanceMatrix.needsUpdate = !0), l && (e.colorAttribute.needsUpdate = !0), h && (e.opacityAttribute.needsUpdate = !0), e.mesh.boundingSphere === null && (e.mesh.boundingSphere = new ne()), e.mesh.boundingSphere.copy(e.fullBoundingSphere);
-    const w = e.hasSourceTransparency || p;
-    e.materials.forEach((g) => {
-      g.transparent !== w && (g.transparent = w, g.needsUpdate = !0, te(e.batchRecord.batch));
+      const b = d, S = b * 16;
+      _r(me, n, S) || (e.mesh.setMatrixAt(b, me), c = !0), Z.copy(y.getInstanceColor(Z));
+      const A = y.getInstanceColorMode(), v = b * 4;
+      Tr(Z, A, r, v) || (e.colorAttribute.setXYZW(b, Z.r, Z.g, Z.b, A), l = !0), m < cs && (p = !0), Math.abs(m - a[b]) > H && (e.opacityAttribute.setX(b, m), h = !0), e.renderedInstances[b] = y, d++;
+    }), e.mesh.count = d, x !== d && (c = !0, l = !0, h = !0, ee(e.batchRecord.batch));
+    const _ = u > 0;
+    e.mesh.visible !== _ && (e.mesh.visible = _, ee(e.batchRecord.batch)), e.mesh.frustumCulled !== !0 && (e.mesh.frustumCulled = !0, ee(e.batchRecord.batch)), c && (e.mesh.instanceMatrix.needsUpdate = !0), l && (e.colorAttribute.needsUpdate = !0), h && (e.opacityAttribute.needsUpdate = !0), e.mesh.boundingSphere === null && (e.mesh.boundingSphere = new ne()), e.mesh.boundingSphere.copy(e.fullBoundingSphere);
+    const C = e.hasSourceTransparency || p;
+    e.materials.forEach((y) => {
+      y.transparent !== C && (y.transparent = C, y.needsUpdate = !0, ee(e.batchRecord.batch));
     }), t && this.#x(t, s) ? (e.lastCameraMatrixWorldInverse.copy(t.matrixWorldInverse), e.lastCameraProjectionMatrix.copy(t.projectionMatrix), e.lastViewportHeight = s, e.hasLastCameraState = !0) : e.hasLastCameraState = !1, e.dirty = !1;
   }
 }
-const di = "0.0.30";
-typeof window < "u" && (window.__USPACE__ = { version: di });
+const Ur = "0.0.32";
+typeof window < "u" && (window.__USPACE__ = { version: Ur });
 export {
-  Wi as AnnotationManager,
-  ue as BaseGroup,
-  q as BaseMesh,
-  wn as BaseSprite,
-  ir as CSS2DObject,
-  ar as CSS3DObject,
-  or as CSS3DSprite,
-  Qi as CSSRenderer,
-  qi as CameraControls,
-  zi as CircleMesh,
-  ki as ClippingTool,
-  Gi as EditableGeometryBatchLayer,
-  zt as ExtrudeMesh,
-  rt as INSTANCE_COLOR_MODE_NONE,
-  Ee as INSTANCE_COLOR_MODE_OVERRIDE,
-  Dn as INSTANCE_COLOR_MODE_TINT,
-  Hi as InstanceObject,
-  Yi as InteractionEvent,
-  Vi as InteractionManager,
-  Ai as LightManager,
+  mi as AnnotationManager,
+  pe as BaseGroup,
+  X as BaseMesh,
+  Kn as BaseSprite,
+  Li as CSS2DObject,
+  Di as CSS3DObject,
+  Pi as CSS3DSprite,
+  vi as CSSRenderer,
+  Si as CameraControls,
+  li as CircleMesh,
+  pi as ClippingTool,
+  bi as EditableGeometryBatchLayer,
+  Yt as ExtrudeMesh,
+  wt as INSTANCE_COLOR_MODE_NONE,
+  Ne as INSTANCE_COLOR_MODE_OVERRIDE,
+  lr as INSTANCE_COLOR_MODE_TINT,
+  gi as InstanceObject,
+  Ii as InteractionEvent,
+  Ei as InteractionManager,
+  ri as LightManager,
   se as MaterialEffects,
-  Ui as MeasureTool,
-  we as Model,
-  $i as ModelInstancedLayer,
-  X as ModelLoaderManager,
-  Ji as ObjectManager,
-  J as ObjectUtils,
-  Ni as PlaneMesh,
-  Pi as Poi,
-  Zi as RenderPipeline,
-  er as RoomEnvironment,
-  yn as SBMLoader,
-  tn as SBMXLoader,
-  Oi as SceneManager,
-  Ci as Selection,
-  Nt as ShapeMesh,
-  xn as SphereMesh,
-  Di as TSLEffects,
-  Ti as TextureLoaderManager,
-  Li as Topology,
-  qe as TubeMesh,
-  Ln as Tween,
-  tr as Viewer,
-  sr as enableMeshBVHRaycast,
-  Et as getGeometryBoundsTree,
-  Fi as isInstanceObject,
-  Ri as reinterpretType,
-  ji as tweenAnimation,
-  di as version
+  fi as MeasureTool,
+  te as Model,
+  $n as ModelDecodeWorkerClient,
+  ve as ModelDecodeWorkerUnavailableError,
+  wi as ModelInstancedLayer,
+  V as ModelLoaderManager,
+  Ci as ObjectManager,
+  Q as ObjectUtils,
+  ci as PlaneMesh,
+  oi as Poi,
+  Ai as RenderPipeline,
+  Oi as RoomEnvironment,
+  ct as SBMLoader,
+  at as SBMXLoader,
+  ni as SceneManager,
+  si as Selection,
+  Xt as ShapeMesh,
+  qn as SphereMesh,
+  hi as TSLEffects,
+  ii as TextureLoaderManager,
+  ai as Topology,
+  lt as TubeMesh,
+  ir as Tween,
+  Bi as Viewer,
+  _i as enableMeshBVHRaycast,
+  jt as getGeometryBoundsTree,
+  yi as isInstanceObject,
+  di as reinterpretType,
+  Hn as reuseDecodedImageContent,
+  ui as tweenAnimation,
+  Ur as version
 };