u-space 0.0.3 → 0.0.7

package/dist/index.js

@@ -1,20 +1,27 @@
-import { Raycaster, Vector2, RenderPipeline as RenderPipeline$1, Sphere, Box3, Spherical, Matrix4, Quaternion, Vector4, Vector3, MathUtils, PMREMGenerator, OrthographicCamera, TimestampQuery, Cache, EventDispatcher, Timer, PerspectiveCamera, WebGPURenderer, PCFShadowMap, AgXToneMapping, Scene, Color, MeshStandardNodeMaterial, Loader, LoaderUtils, FileLoader, TextureLoader, Group, SRGBColorSpace, RepeatWrapping, BufferGeometry, BufferAttribute, Mesh, FrontSide, BackSide, DoubleSide, REVISION, CubeTextureLoader, EquirectangularReflectionMapping, Sprite, SphereGeometry, TubeGeometry, LineCurve3, CatmullRomCurve3, SpriteNodeMaterial, CanvasTexture, ShapeGeometry, Shape, ExtrudeGeometry, PlaneGeometry, CircleGeometry } from "three/webgpu";
-import { pass, blendColor, color, uv, time, pow, sin, mix, mx_noise_float, Fn, userData, materialColor, select, materialOpacity, vec3 } from "three/tsl";
-import CameraControlsBase from "camera-controls";
-import { RoomEnvironment as RoomEnvironment$1 } from "three/addons/environments/RoomEnvironment.js";
-import { ViewHelper } from "three/addons/helpers/ViewHelper.js";
-import { GLTFLoader } from "three/addons/loaders/GLTFLoader.js";
-import { FBXLoader } from "three/addons/loaders/FBXLoader.js";
-import { OBJLoader } from "three/addons/loaders/OBJLoader.js";
-import { STLLoader } from "three/addons/loaders/STLLoader.js";
-import { DRACOLoader } from "three/addons/loaders/DRACOLoader.js";
-import { KTX2Loader } from "three/addons/loaders/KTX2Loader.js";
-import { MeshoptDecoder } from "three/addons/libs/meshopt_decoder.module.js";
-import { HDRLoader } from "three/addons/loaders/HDRLoader.js";
-import { clone } from "three/addons/utils/SkeletonUtils.js";
-import { Color as Color$1 } from "three";
-import { Easing, Tween as Tween$1 } from "three/addons/libs/tween.module.js";
-class InteractionEvent {
+import { Raycaster as Te, Vector2 as R, RenderPipeline as $e, PerspectiveCamera as K, Sphere as Se, Box3 as xe, Spherical as C, Matrix4 as We, Quaternion as Ke, Vector4 as Qe, Vector3 as oe, MathUtils as Xe, PMREMGenerator as qe, OrthographicCamera as Q, TimestampQuery as Ye, Cache as Je, EventDispatcher as Ze, Timer as Ve, WebGPURenderer as et, PCFShadowMap as tt, AgXToneMapping as st, Scene as it, Color as V, MeshStandardNodeMaterial as L, Loader as nt, LoaderUtils as I, FileLoader as Ee, TextureLoader as Me, Group as ee, SRGBColorSpace as Pe, RepeatWrapping as ce, BufferGeometry as rt, BufferAttribute as he, Mesh as z, FrontSide as at, BackSide as ot, DoubleSide as ct, REVISION as le, CubeTextureLoader as ht, EquirectangularReflectionMapping as lt, Sprite as dt, AnimationMixer as pt, LoopRepeat as ut, LoopOnce as mt, SphereGeometry as gt, TubeGeometry as ft, LineCurve3 as yt, CatmullRomCurve3 as wt, SpriteNodeMaterial as vt, CanvasTexture as bt, ShapeGeometry as Ct, Shape as Oe, ExtrudeGeometry as Tt, PlaneGeometry as St, CircleGeometry as xt } from "three/webgpu";
+import { pass as re, mrt as Et, output as Mt, add as de, blendColor as Pt, emissive as Ot, normalView as Rt, velocity as It, color as j, uv as pe, time as X, pow as q, sin as ae, mix as Y, mx_noise_float as ue, Fn as Re, userData as O, materialColor as me, select as J, materialOpacity as Lt, vec3 as At } from "three/tsl";
+import { bloom as Nt } from "three/addons/tsl/display/BloomNode.js";
+import { ssgi as Bt } from "three/addons/tsl/display/SSGINode.js";
+import { traa as _t } from "three/addons/tsl/display/TRAANode.js";
+import Ie from "camera-controls";
+import { RoomEnvironment as Dt } from "three/addons/environments/RoomEnvironment.js";
+import { ViewHelper as jt } from "three/addons/helpers/ViewHelper.js";
+import { CSS2DRenderer as Ut, CSS2DObject as kt } from "three/addons/renderers/CSS2DRenderer.js";
+import { CSS2DObject as pi } from "three/addons/renderers/CSS2DRenderer.js";
+import { CSS3DRenderer as Gt, CSS3DSprite as Ft, CSS3DObject as zt } from "three/addons/renderers/CSS3DRenderer.js";
+import { CSS3DObject as mi, CSS3DSprite as gi } from "three/addons/renderers/CSS3DRenderer.js";
+import { GLTFLoader as Le } from "three/addons/loaders/GLTFLoader.js";
+import { FBXLoader as Ht } from "three/addons/loaders/FBXLoader.js";
+import { OBJLoader as $t } from "three/addons/loaders/OBJLoader.js";
+import { STLLoader as Wt } from "three/addons/loaders/STLLoader.js";
+import { DRACOLoader as Kt } from "three/addons/loaders/DRACOLoader.js";
+import { KTX2Loader as Qt } from "three/addons/loaders/KTX2Loader.js";
+import { MeshoptDecoder as ge } from "three/addons/libs/meshopt_decoder.module.js";
+import { HDRLoader as Xt } from "three/addons/loaders/HDRLoader.js";
+import { clone as qt } from "three/addons/utils/SkeletonUtils.js";
+import { Color as U } from "three";
+import { Easing as u, Tween as Yt } from "three/addons/libs/tween.module.js";
+class Jt {
   /** The type of event (e.g., 'click', 'pointerdown'). */
   type;
   /** The original 3D object that triggered the event. */
@@ -25,19 +32,15 @@ class InteractionEvent {
   intersect;
   /** The original DOM event, or undefined if not applicable. */
   originalEvent;
-  _propagationStopped = false;
-  constructor(init) {
-    this.type = init.type;
-    this.target = init.target;
-    this.currentTarget = init.target;
-    this.intersect = init.intersect;
-    this.originalEvent = init.originalEvent;
+  _propagationStopped = !1;
+  constructor(e) {
+    this.type = e.type, this.target = e.target, this.currentTarget = e.target, this.intersect = e.intersect, this.originalEvent = e.originalEvent;
   }
   /**
    * Stops the event from bubbling up the parent chain.
    */
   stopPropagation() {
-    this._propagationStopped = true;
+    this._propagationStopped = !0;
   }
   /**
    * Returns true if `stopPropagation()` has been called.
@@ -46,15 +49,15 @@ class InteractionEvent {
     return this._propagationStopped;
   }
 }
-class InteractionManager {
+class Zt {
   domElement;
   scene;
   camera;
-  raycaster = new Raycaster();
-  pointer = new Vector2();
+  raycaster = new Te();
+  pointer = new R();
   hoveredObject = null;
   pointerDownTime = 0;
-  pointerDownPos = new Vector2();
+  pointerDownPos = new R();
   clickTimer = null;
   longPressThreshold = 500;
   moveThreshold = 0.01;
@@ -66,142 +69,92 @@ class InteractionManager {
    * Whether to enable pointer move events (pointermove, pointerenter, pointerleave).
    * Disabled by default for performance optimization.
    */
-  pointerMoveEventsEnabled = false;
-  constructor(domElement, scene, camera) {
-    this.domElement = domElement;
-    this.scene = scene;
-    this.camera = camera;
-    this.raycaster.params.Points.threshold = 0.1;
-    this.raycaster.params.Line.threshold = 0.1;
-    this.targetObjects = this.scene.children;
-    this._bindEvents();
+  pointerMoveEventsEnabled = !1;
+  constructor(e, t, s) {
+    this.domElement = e, this.scene = t, this.camera = s, this.raycaster.params.Points.threshold = 0.1, this.raycaster.params.Line.threshold = 0.1, this.targetObjects = this.scene.children, this._bindEvents();
   }
   /**
    * Updates the camera reference (useful when switching cameras).
    */
-  setCamera(camera) {
-    this.camera = camera;
+  setCamera(e) {
+    this.camera = e;
   }
   _bindEvents() {
-    this.domElement.addEventListener("click", this._onClick);
-    this.domElement.addEventListener("dblclick", this._onDblClick);
-    this.domElement.addEventListener("contextmenu", this._onContextMenu);
-    this.domElement.addEventListener("pointerdown", this._onPointerDown);
-    this.domElement.addEventListener("pointerup", this._onPointerUp);
-    this.domElement.addEventListener("pointermove", this._onPointerMove);
-  }
-  _updatePointer(event) {
-    const rect = this.domElement.getBoundingClientRect();
-    this.pointer.x = (event.clientX - rect.left) / rect.width * 2 - 1;
-    this.pointer.y = -((event.clientY - rect.top) / rect.height) * 2 + 1;
+    this.domElement.addEventListener("click", this._onClick), this.domElement.addEventListener("dblclick", this._onDblClick), this.domElement.addEventListener("contextmenu", this._onContextMenu), this.domElement.addEventListener("pointerdown", this._onPointerDown), this.domElement.addEventListener("pointerup", this._onPointerUp), this.domElement.addEventListener("pointermove", this._onPointerMove);
+  }
+  _updatePointer(e) {
+    const t = this.domElement.getBoundingClientRect();
+    this.pointer.x = (e.clientX - t.left) / t.width * 2 - 1, this.pointer.y = -((e.clientY - t.top) / t.height) * 2 + 1;
   }
   _getIntersects() {
-    this.raycaster.setFromCamera(this.pointer, this.camera);
-    return this.raycaster.intersectObjects(this.targetObjects, true);
+    return this.raycaster.setFromCamera(this.pointer, this.camera), this.raycaster.intersectObjects(this.targetObjects, !0);
   }
   /**
    * Dispatches an event to the target object and bubbles up the parent chain.
    */
-  _dispatchToTarget(type, target, intersect, originalEvent) {
-    const event3d = new InteractionEvent({
-      type,
-      target,
-      intersect,
-      originalEvent
+  _dispatchToTarget(e, t, s, i) {
+    const n = new Jt({
+      type: e,
+      target: t,
+      intersect: s,
+      originalEvent: i
     });
-    let current = target;
-    while (current && !event3d.propagationStopped) {
-      event3d.currentTarget = current;
-      current.dispatchEvent({ type, event: event3d });
-      current = current.parent;
-    }
+    let r = t;
+    for (; r && !n.propagationStopped; )
+      n.currentTarget = r, r.dispatchEvent({ type: e, event: n }), r = r.parent;
   }
   /**
    * Handles a DOM event by raycasting and dispatching to the first intersected object.
    */
-  _handleEvent(type, originalEvent) {
-    this._updatePointer(originalEvent);
-    const intersects = this._getIntersects();
-    if (intersects.length === 0) return;
-    const hit = intersects[0];
-    this._dispatchToTarget(type, hit.object, hit, originalEvent);
+  _handleEvent(e, t) {
+    this._updatePointer(t);
+    const s = this._getIntersects();
+    if (s.length === 0) return;
+    const i = s[0];
+    this._dispatchToTarget(e, i.object, i, t);
   }
   _onClick = (e) => {
-    const duration = Date.now() - this.pointerDownTime;
-    const moveDistance = this.pointer.distanceTo(this.pointerDownPos);
-    if (duration > this.longPressThreshold || moveDistance > this.moveThreshold) {
-      return;
-    }
-    if (this.clickTimer) {
-      clearTimeout(this.clickTimer);
-      this.clickTimer = null;
-      return;
+    const t = Date.now() - this.pointerDownTime, s = this.pointer.distanceTo(this.pointerDownPos);
+    if (!(t > this.longPressThreshold || s > this.moveThreshold)) {
+      if (this.clickTimer) {
+        clearTimeout(this.clickTimer), this.clickTimer = null;
+        return;
+      }
+      this.clickTimer = setTimeout(() => {
+        this._handleEvent("click", e), this.clickTimer = null;
+      }, 200);
     }
-    this.clickTimer = setTimeout(() => {
-      this._handleEvent("click", e);
-      this.clickTimer = null;
-    }, 200);
   };
   _onDblClick = (e) => {
-    if (this.clickTimer) {
-      clearTimeout(this.clickTimer);
-      this.clickTimer = null;
-    }
-    this._handleEvent("dblclick", e);
+    this.clickTimer && (clearTimeout(this.clickTimer), this.clickTimer = null), this._handleEvent("dblclick", e);
   };
   _onContextMenu = (e) => {
     e.preventDefault();
   };
   _onPointerDown = (e) => {
-    this.pointerDownTime = Date.now();
-    this._updatePointer(e);
-    this.pointerDownPos.copy(this.pointer);
-    this._handleEvent("pointerdown", e);
+    this.pointerDownTime = Date.now(), this._updatePointer(e), this.pointerDownPos.copy(this.pointer), this._handleEvent("pointerdown", e);
   };
   _onPointerUp = (e) => {
-    this._updatePointer(e);
-    if (e.button === 2) {
-      const duration = Date.now() - this.pointerDownTime;
-      const moveDistance = this.pointer.distanceTo(this.pointerDownPos);
-      if (duration <= this.longPressThreshold && moveDistance <= this.moveThreshold) {
-        this._handleEvent("rightclick", e);
-      }
+    if (this._updatePointer(e), e.button === 2) {
+      const t = Date.now() - this.pointerDownTime, s = this.pointer.distanceTo(this.pointerDownPos);
+      t <= this.longPressThreshold && s <= this.moveThreshold && this._handleEvent("rightclick", e);
     }
     this._handleEvent("pointerup", e);
   };
   _onPointerMove = (e) => {
     if (!this.pointerMoveEventsEnabled) return;
     this._updatePointer(e);
-    const intersects = this._getIntersects();
-    const hitObject = intersects.length > 0 ? intersects[0].object : null;
-    const intersect = intersects.length > 0 ? intersects[0] : null;
-    if (this.hoveredObject !== hitObject) {
-      if (this.hoveredObject) {
-        this._dispatchToTarget("pointerleave", this.hoveredObject, null, e);
-      }
-      this.hoveredObject = hitObject;
-      if (hitObject && intersect) {
-        this._dispatchToTarget("pointerenter", hitObject, intersect, e);
-      }
-    }
-    if (hitObject && intersect) {
-      this._dispatchToTarget("pointermove", hitObject, intersect, e);
-    }
+    const t = this._getIntersects(), s = t.length > 0 ? t[0].object : null, i = t.length > 0 ? t[0] : null;
+    this.hoveredObject !== s && (this.hoveredObject && this._dispatchToTarget("pointerleave", this.hoveredObject, null, e), this.hoveredObject = s, s && i && this._dispatchToTarget("pointerenter", s, i, e)), s && i && this._dispatchToTarget("pointermove", s, i, e);
   };
   /**
    * Cleans up event listeners.
    */
   dispose() {
-    this.domElement.removeEventListener("click", this._onClick);
-    this.domElement.removeEventListener("dblclick", this._onDblClick);
-    this.domElement.removeEventListener("contextmenu", this._onContextMenu);
-    this.domElement.removeEventListener("pointerdown", this._onPointerDown);
-    this.domElement.removeEventListener("pointerup", this._onPointerUp);
-    this.domElement.removeEventListener("pointermove", this._onPointerMove);
-    this.hoveredObject = null;
+    this.domElement.removeEventListener("click", this._onClick), this.domElement.removeEventListener("dblclick", this._onDblClick), this.domElement.removeEventListener("contextmenu", this._onContextMenu), this.domElement.removeEventListener("pointerdown", this._onPointerDown), this.domElement.removeEventListener("pointerup", this._onPointerUp), this.domElement.removeEventListener("pointermove", this._onPointerMove), this.hoveredObject = null;
   }
 }
-class ObjectManager {
+class Vt {
   idMap = /* @__PURE__ */ new Map();
   nameMap = /* @__PURE__ */ new Map();
   typeMap = /* @__PURE__ */ new Map();
@@ -211,117 +164,85 @@ class ObjectManager {
    * Add an object with a custom id.
    * One object can have multiple ids.
    */
-  add(id, object) {
-    if (this.idMap.has(id)) {
-      console.warn(`ObjectManager: Object with id ${id} already exists.`);
+  add(e, t) {
+    if (this.idMap.has(e)) {
+      console.warn(`ObjectManager: Object with id ${e} already exists.`);
       return;
     }
-    this.idMap.set(id, object);
-    this.allObjects.add(object);
-    if (!this.objectIds.has(object)) {
-      this.objectIds.set(object, /* @__PURE__ */ new Set());
-    }
-    this.objectIds.get(object).add(id);
-    if (object.name) {
-      if (!this.nameMap.has(object.name)) {
-        this.nameMap.set(object.name, /* @__PURE__ */ new Set());
-      }
-      this.nameMap.get(object.name).add(object);
-    }
-    if (object.type) {
-      if (!this.typeMap.has(object.type)) {
-        this.typeMap.set(object.type, /* @__PURE__ */ new Set());
-      }
-      this.typeMap.get(object.type).add(object);
-    }
+    this.idMap.set(e, t), this.allObjects.add(t), this.objectIds.has(t) || this.objectIds.set(t, /* @__PURE__ */ new Set()), this.objectIds.get(t).add(e), t.name && (this.nameMap.has(t.name) || this.nameMap.set(t.name, /* @__PURE__ */ new Set()), this.nameMap.get(t.name).add(t)), t.type && (this.typeMap.has(t.type) || this.typeMap.set(t.type, /* @__PURE__ */ new Set()), this.typeMap.get(t.type).add(t));
   }
   /**
    * Get an object by its custom id.
    */
-  getById(id) {
-    return this.idMap.get(id);
+  getById(e) {
+    return this.idMap.get(e);
   }
   /**
    * Get all objects with a given name.
    */
-  getByName(name) {
-    return this.nameMap.get(name) || /* @__PURE__ */ new Set();
+  getByName(e) {
+    return this.nameMap.get(e) || /* @__PURE__ */ new Set();
   }
   /**
    * Get all objects with a given type.
    */
-  getByType(type) {
-    return this.typeMap.get(type) || /* @__PURE__ */ new Set();
+  getByType(e) {
+    return this.typeMap.get(e) || /* @__PURE__ */ new Set();
   }
   /**
    * Get all ids associated with an object.
    */
-  getObjectIds(object) {
-    return this.objectIds.get(object) || /* @__PURE__ */ new Set();
+  getObjectIds(e) {
+    return this.objectIds.get(e) || /* @__PURE__ */ new Set();
   }
   /**
    * Remove an object and all its associated ids.
    */
-  remove(object) {
-    const ids = this.objectIds.get(object);
-    if (ids) {
-      for (const id of ids) {
-        this.idMap.delete(id);
-      }
-      this.objectIds.delete(object);
+  remove(e) {
+    const t = this.objectIds.get(e);
+    if (t) {
+      for (const s of t)
+        this.idMap.delete(s);
+      this.objectIds.delete(e);
     }
-    if (object.name && this.nameMap.has(object.name)) {
-      const set = this.nameMap.get(object.name);
-      set.delete(object);
-      if (set.size === 0) {
-        this.nameMap.delete(object.name);
-      }
+    if (e.name && this.nameMap.has(e.name)) {
+      const s = this.nameMap.get(e.name);
+      s.delete(e), s.size === 0 && this.nameMap.delete(e.name);
     }
-    if (object.type && this.typeMap.has(object.type)) {
-      const set = this.typeMap.get(object.type);
-      set.delete(object);
-      if (set.size === 0) {
-        this.typeMap.delete(object.type);
-      }
+    if (e.type && this.typeMap.has(e.type)) {
+      const s = this.typeMap.get(e.type);
+      s.delete(e), s.size === 0 && this.typeMap.delete(e.type);
     }
-    this.allObjects.delete(object);
+    this.allObjects.delete(e);
   }
   /**
    * Remove an object by its id.
    */
-  removeById(id) {
-    const object = this.idMap.get(id);
-    if (object) {
-      this.remove(object);
-    }
+  removeById(e) {
+    const t = this.idMap.get(e);
+    t && this.remove(t);
   }
   /**
    * Remove all objects with a given name.
    */
-  removeByName(name) {
-    const objects = this.getByName(name);
-    for (const object of objects) {
-      this.remove(object);
-    }
+  removeByName(e) {
+    const t = this.getByName(e);
+    for (const s of t)
+      this.remove(s);
   }
   /**
    * Remove all objects with a given type.
    */
-  removeByType(type) {
-    const objects = this.getByType(type);
-    for (const object of objects) {
-      this.remove(object);
-    }
+  removeByType(e) {
+    const t = this.getByType(e);
+    for (const s of t)
+      this.remove(s);
   }
   /**
    * Clear all cached objects.
    */
   clear() {
-    this.idMap.clear();
-    this.nameMap.clear();
-    this.typeMap.clear();
-    this.objectIds.clear();
-    this.allObjects.clear();
+    this.idMap.clear(), this.nameMap.clear(), this.typeMap.clear(), this.objectIds.clear(), this.allObjects.clear();
   }
   /**
    * Get all cached objects as a Set.
@@ -336,202 +257,287 @@ class ObjectManager {
     return this.allObjects.size;
   }
 }
-class RenderPipeline extends RenderPipeline$1 {
+class es extends $e {
   scene;
   camera;
-  currentOutputNode;
+  scenePass;
   needsUpdateOutputNode;
-  #overlayPasses;
-  constructor(...args) {
-    const [renderer, scene, camera] = args;
-    super(renderer);
-    this.scene = scene;
-    this.camera = camera;
-    this.currentOutputNode = pass(scene, camera);
-    this.needsUpdateOutputNode = true;
-    this.#overlayPasses = /* @__PURE__ */ new Set();
-  }
-  addOverlayPass(pass2) {
-    this.#overlayPasses.add(pass2);
-    this.needsUpdateOutputNode = true;
-  }
-  removeOverlayPass(pass2) {
-    this.#overlayPasses.delete(pass2);
-    this.needsUpdateOutputNode = true;
-  }
-  setCamera(camera) {
-    this.camera = camera;
-    this.needsUpdateOutputNode = true;
-  }
-  setCurrentOutputNode(node) {
-    this.currentOutputNode.dispose();
-    this.currentOutputNode = node;
-    this.needsUpdateOutputNode = true;
+  #r;
+  #t;
+  #s = !1;
+  #a = { strength: 1, radius: 0, threshold: 0 };
+  #c = null;
+  #n = !1;
+  #e = {
+    sliceCount: 1,
+    stepCount: 12,
+    aoIntensity: 1,
+    giIntensity: 10,
+    radius: 12,
+    thickness: 1
+  };
+  #h = null;
+  #o = !1;
+  #l = null;
+  #d = null;
+  constructor(...e) {
+    const [t, s, i] = e;
+    super(t), this.scene = s, this.camera = i, this.scenePass = re(s, i), this.needsUpdateOutputNode = !0, this.#r = /* @__PURE__ */ new Set(), this.#t = [], this.#p();
+  }
+  /** @deprecated Use `scenePass` instead */
+  get currentOutputNode() {
+    return this.scenePass;
+  }
+  addOverlayPass(e) {
+    this.#r.add(e), this.needsUpdateOutputNode = !0;
+  }
+  removeOverlayPass(e) {
+    this.#r.delete(e), this.needsUpdateOutputNode = !0;
   }
+  setCamera(e) {
+    this.camera = e, this.#i();
+  }
+  /** @deprecated Use `setOutputComposer` instead */
+  setCurrentOutputNode(e) {
+    this.setOutputComposer(() => e);
+  }
+  /** @deprecated Use `setOutputComposer(null)` instead */
   resetCurrentOutputNode() {
-    this.currentOutputNode.dispose();
-    this.currentOutputNode = pass(this.scene, this.camera);
-    this.needsUpdateOutputNode = true;
-  }
-  #updateOutputNode() {
-    let currentNode = this.currentOutputNode;
-    if (this.#overlayPasses.size > 0) {
-      this.#overlayPasses.forEach((overlayPass) => {
-        currentNode = blendColor(currentNode, overlayPass);
-      });
+    this.setOutputComposer(null);
+  }
+  setOutputComposer(e) {
+    this.#d = e, this.needsUpdateOutputNode = !0;
+  }
+  enableBloom(e) {
+    e && Object.assign(this.#a, e), this.#s = !0, this.#i();
+  }
+  disableBloom() {
+    this.#s = !1, this.#c = null, this.#i();
+  }
+  updateBloom(e) {
+    Object.assign(this.#a, e), this.#s && (this.needsUpdateOutputNode = !0);
+  }
+  enableSSGI(e) {
+    e && Object.assign(this.#e, e), this.#n = !0, this.#i();
+  }
+  disableSSGI() {
+    this.#n = !1, this.#h = null, this.#i();
+  }
+  updateSSGI(e) {
+    if (Object.assign(this.#e, e), this.#h) {
+      const t = this.#h;
+      e.sliceCount !== void 0 && (t.sliceCount.value = e.sliceCount), e.stepCount !== void 0 && (t.stepCount.value = e.stepCount), e.aoIntensity !== void 0 && (t.aoIntensity.value = e.aoIntensity), e.giIntensity !== void 0 && (t.giIntensity.value = e.giIntensity), e.radius !== void 0 && (t.radius.value = e.radius), e.thickness !== void 0 && (t.thickness.value = e.thickness);
     }
-    this.outputNode = currentNode;
-    this.needsUpdate = true;
   }
-  render() {
-    if (this.needsUpdateOutputNode) {
-      this.#updateOutputNode();
-      this.needsUpdateOutputNode = false;
+  enableTRAA() {
+    this.#o = !0, this.#i();
+  }
+  disableTRAA() {
+    this.#o = !1, this.#l = null, this.#i();
+  }
+  #i() {
+    const e = this.scenePass;
+    this.scenePass = re(this.scene, this.camera), this.#p(), this.needsUpdateOutputNode = !0, e.dispose();
+  }
+  #p() {
+    if (this.#s || this.#n || this.#o) {
+      const t = { output: Mt };
+      this.#s && (t.emissive = Ot), this.#n && (t.normal = Rt), this.#o && (t.velocity = It), this.scenePass.setMRT(Et(t));
     }
-    super.render();
+  }
+  #u() {
+    for (const e of this.#t)
+      e.dispose();
+    this.#t = [];
+  }
+  #m() {
+    let e = this.scenePass.getTextureNode();
+    if (this.#n)
+      if (!(this.camera instanceof K))
+        console.warn("RenderPipeline: SSGI requires a PerspectiveCamera, skipping.");
+      else {
+        const t = this.scenePass.getTextureNode(), s = this.scenePass.getTextureNode("depth"), i = this.scenePass.getTextureNode("normal"), n = Bt(t, s, i, this.camera);
+        n.sliceCount.value = this.#e.sliceCount, n.stepCount.value = this.#e.stepCount, n.aoIntensity.value = this.#e.aoIntensity, n.giIntensity.value = this.#e.giIntensity, n.radius.value = this.#e.radius, n.thickness.value = this.#e.thickness, this.#h = n, e = de(e, n), this.#t.push(n);
+      }
+    if (this.#s) {
+      const t = this.scenePass.getTextureNode("emissive");
+      this.#c = Nt(
+        t,
+        this.#a.strength,
+        this.#a.radius,
+        this.#a.threshold
+      ), e = de(e, this.#c), this.#t.push(this.#c);
+    }
+    return e;
+  }
+  #g() {
+    this.#u();
+    let e;
+    if (this.#d ? e = this.#d(this.scenePass) : this.#s || this.#n ? e = this.#m() : e = this.scenePass, this.#o) {
+      const t = this.scenePass.getTextureNode("depth"), s = this.scenePass.getTextureNode("velocity");
+      this.#l = _t(e, t, s, this.camera), this.#t.push(this.#l), e = this.#l;
+    }
+    this.#r.size > 0 && this.#r.forEach((t) => {
+      const s = Pt(e, t);
+      this.#t.push(s), e = s;
+    }), this.outputNode = e, this.needsUpdate = !0;
+  }
+  render() {
+    this.needsUpdateOutputNode && (this.#g(), this.needsUpdateOutputNode = !1), super.render();
+  }
+  dispose() {
+    this.#u(), this.scenePass.dispose(), super.dispose();
   }
 }
-const subsetOfTHREE = {
-  Vector2,
-  Vector3,
-  Vector4,
-  Quaternion,
-  Matrix4,
-  Spherical,
-  Box3,
-  Sphere,
-  Raycaster
+const ts = {
+  Vector2: R,
+  Vector3: oe,
+  Vector4: Qe,
+  Quaternion: Ke,
+  Matrix4: We,
+  Spherical: C,
+  Box3: xe,
+  Sphere: Se,
+  Raycaster: Te
 };
-CameraControlsBase.install({ THREE: subsetOfTHREE });
-class CameraControls extends CameraControlsBase {
-  constructor(...args) {
-    super(...args);
-    this.minDistance = 0.2;
-    this.smoothTime = 0.2;
-    this.dollySpeed = 0.2;
+Ie.install({ THREE: ts });
+class ss extends Ie {
+  constructor(...e) {
+    super(...e), this.minDistance = 0.2, this.smoothTime = 0.2, this.dollySpeed = 0.2;
   }
   /**
    * Set absolute angle for azimuth to avoid spinning
    */
   absoluteRotations() {
-    this.azimuthAngle = absoluteAngle(this.azimuthAngle, 0);
+    this.azimuthAngle = is(this.azimuthAngle, 0);
   }
-  async flyToBox(box, options = {}) {
-    if (box.isEmpty()) {
-      console.warn("CameraControls.flyToBox: The provided Box3 is empty.");
-      return false;
-    }
+  async flyToBox(e, t = {}) {
+    if (e.isEmpty())
+      return console.warn("CameraControls.flyToBox: The provided Box3 is empty."), !1;
     this.absoluteRotations();
-    const { viewpoint = "frontTop", enableTransition = true, padding = 0.1, cover = false } = options;
-    const promises = [];
-    if (viewpoint !== "current") {
-      const spherical = viewpointsSpherical[viewpoint.toUpperCase()] ?? viewpointsSpherical.FRONTTOP;
-      const azimuthAngle = spherical.theta, polarAngle = spherical.phi;
-      promises.push(
-        this.fitToBox(box, enableTransition, {
-          paddingLeft: padding,
-          paddingRight: padding,
-          paddingTop: padding,
-          paddingBottom: padding,
-          cover
+    const { viewpoint: s = "frontTop", enableTransition: i = !0, padding: n = 0.1, cover: r = !1 } = t, o = [];
+    if (s !== "current") {
+      const c = fe[s.toUpperCase()] ?? fe.FRONTTOP, h = c.theta, l = c.phi;
+      o.push(
+        this.fitToBox(e, i, {
+          paddingLeft: n,
+          paddingRight: n,
+          paddingTop: n,
+          paddingBottom: n,
+          cover: r
         })
-      );
-      promises.push(this.rotateTo(azimuthAngle, polarAngle, enableTransition));
+      ), o.push(this.rotateTo(h, l, i));
     } else {
-      const sphere = new Sphere();
-      box.getBoundingSphere(sphere);
-      sphere.radius += padding;
-      promises.push(this.fitToSphere(sphere, enableTransition));
+      const c = new Se();
+      e.getBoundingSphere(c), c.radius += n, o.push(this.fitToSphere(c, i));
     }
-    await Promise.all(promises);
-    return true;
+    return await Promise.all(o), !0;
   }
-  async flyToObject(object, options = {}) {
-    const box = new Box3().setFromObject(object);
-    return this.flyToBox(box, options);
+  async flyToObject(e, t = {}) {
+    const s = new xe().setFromObject(e);
+    return this.flyToBox(s, t);
+  }
+  async setCameraViewpoint(e, t = !0) {
+    const { position: s, target: i, zoom: n = this.camera.zoom } = e;
+    return Promise.all([
+      this.zoomTo(n, t),
+      this.setLookAt(s.x, s.y, s.z, i.x, i.y, i.z, t)
+    ]);
   }
 }
-const viewpointsSpherical = {
-  LEFT: new Spherical(0, Math.PI / 2, -Math.PI / 2),
-  RIGHT: new Spherical(0, Math.PI / 2, Math.PI / 2),
-  FRONT: new Spherical(0, Math.PI / 2, 0),
-  BACK: new Spherical(0, Math.PI / 2, Math.PI),
-  TOP: new Spherical(0, 0, 0),
-  BOTTOM: new Spherical(0, Math.PI, 0),
-  FRONTTOP: new Spherical(0, Math.PI / 4, 0),
-  BACKTOP: new Spherical(0, Math.PI / 4, Math.PI),
-  LEFTTOP: new Spherical(0, Math.PI / 4, -Math.PI / 2),
-  RIGHTTOP: new Spherical(0, Math.PI / 4, Math.PI / 2),
-  LEFTFRONTTOP: new Spherical(0, Math.PI / 4, -Math.PI / 4),
-  RIGHTFRONTTOP: new Spherical(0, Math.PI / 4, Math.PI / 4),
-  LEFTBACKTOP: new Spherical(0, Math.PI / 4, -Math.PI / 4 * 3),
-  RIGHTBACKTOP: new Spherical(0, Math.PI / 4, Math.PI / 4 * 3)
+const fe = {
+  LEFT: new C(0, Math.PI / 2, -Math.PI / 2),
+  RIGHT: new C(0, Math.PI / 2, Math.PI / 2),
+  FRONT: new C(0, Math.PI / 2, 0),
+  BACK: new C(0, Math.PI / 2, Math.PI),
+  TOP: new C(0, 0, 0),
+  BOTTOM: new C(0, Math.PI, 0),
+  FRONTTOP: new C(0, Math.PI / 4, 0),
+  BACKTOP: new C(0, Math.PI / 4, Math.PI),
+  LEFTTOP: new C(0, Math.PI / 4, -Math.PI / 2),
+  RIGHTTOP: new C(0, Math.PI / 4, Math.PI / 2),
+  LEFTFRONTTOP: new C(0, Math.PI / 4, -Math.PI / 4),
+  RIGHTFRONTTOP: new C(0, Math.PI / 4, Math.PI / 4),
+  LEFTBACKTOP: new C(0, Math.PI / 4, -Math.PI / 4 * 3),
+  RIGHTBACKTOP: new C(0, Math.PI / 4, Math.PI / 4 * 3)
 };
-function absoluteAngle(targetAngle, sourceAngle) {
-  const angle = targetAngle - sourceAngle;
-  return MathUtils.euclideanModulo(angle + Math.PI, Math.PI * 2) - Math.PI;
+function is(a, e) {
+  const t = a - e;
+  return Xe.euclideanModulo(t + Math.PI, Math.PI * 2) - Math.PI;
 }
-class RoomEnvironment {
-  environment = new RoomEnvironment$1();
+class ns {
+  environment = new Dt();
   renderer;
   pmremGenerator;
   envMap = null;
-  constructor(renderer) {
-    this.renderer = renderer;
-    this.pmremGenerator = new PMREMGenerator(renderer);
+  constructor(e) {
+    this.renderer = e, this.pmremGenerator = new qe(e);
   }
   update() {
-    if (!this.envMap) {
-      this.envMap = this.pmremGenerator.fromScene(this.environment).texture;
-    }
+    this.envMap || (this.envMap = this.pmremGenerator.fromScene(this.environment).texture);
   }
   dispose() {
-    this.pmremGenerator.dispose();
-    this.envMap?.dispose();
+    this.pmremGenerator.dispose(), this.envMap?.dispose();
   }
 }
-const dim = 128;
-class ViewerHelper extends ViewHelper {
+const $ = 128;
+class rs extends jt {
   viewer;
   overlayPass;
-  constructor(viewer) {
-    super(viewer.camera, viewer.el);
-    this.viewer = viewer;
-    const orthoCamera = new OrthographicCamera(-2, 2, 2, -2, 0, 4);
-    orthoCamera.position.set(0, 0, 2);
-    this.overlayPass = pass(this, orthoCamera);
-    this.setLabels("x", "y", "z");
+  constructor(e) {
+    super(e.camera, e.el), this.viewer = e;
+    const t = new Q(-2, 2, 2, -2, 0, 4);
+    t.position.set(0, 0, 2), this.overlayPass = re(this, t), this.setLabels("x", "y", "z");
   }
   _update = () => {
     this.quaternion.copy(this.viewer.camera.quaternion).invert();
-    const location = this.location;
-    let x, y;
-    if (location.left !== null) {
-      x = location.left;
-    } else {
-      x = this.viewer.el.offsetWidth - dim - location.right;
-    }
-    if (location.top !== null) {
-      y = location.top;
-    } else {
-      y = this.viewer.el.offsetHeight - dim - location.bottom;
-    }
-    this.overlayPass.setViewport(x, y, dim, dim);
+    const e = this.location;
+    let t, s;
+    e.left !== null ? t = e.left : t = this.viewer.el.offsetWidth - $ - e.right, e.top !== null ? s = e.top : s = this.viewer.el.offsetHeight - $ - e.bottom, this.overlayPass.setViewport(t, s, $, $);
   };
   enable() {
-    this.viewer.renderPipeline.addOverlayPass(this.overlayPass);
-    this.viewer.addEventListener("beforeRender", this._update);
-    this.viewer.render();
-    return this;
+    return this.viewer.renderPipeline.addOverlayPass(this.overlayPass), this.viewer.addEventListener("beforeRender", this._update), this.viewer.render(), this;
   }
   disable() {
-    this.viewer.renderPipeline.removeOverlayPass(this.overlayPass);
-    this.viewer.removeEventListener("beforeRender", this._update);
-    this.viewer.render();
-    return this;
+    return this.viewer.renderPipeline.removeOverlayPass(this.overlayPass), this.viewer.removeEventListener("beforeRender", this._update), this.viewer.render(), this;
   }
 }
-class Info {
+const Ae = "position:absolute;top:0;left:0;width:100%;height:100%;pointer-events:none;overflow:hidden;", as = Ae + "z-index:0;", os = Ae + "z-index:1;";
+class cs {
+  el;
+  css2dRenderer = null;
+  css3dRenderer = null;
+  constructor(e) {
+    this.el = e, getComputedStyle(e).position === "static" && (e.style.position = "relative");
+  }
+  initCSS2DRenderer() {
+    const e = new Ut();
+    return e.setSize(this.el.clientWidth, this.el.clientHeight), e.domElement.style.cssText = os, this.el.appendChild(e.domElement), this.css2dRenderer = e, e;
+  }
+  initCSS3DRenderer() {
+    const e = new Gt();
+    return e.setSize(this.el.clientWidth, this.el.clientHeight), e.domElement.style.cssText = as, this.el.appendChild(e.domElement), this.css3dRenderer = e, e;
+  }
+  createCSS2DObject(e) {
+    return this.css2dRenderer || this.initCSS2DRenderer(), new kt(e);
+  }
+  createCSS25DObject(e) {
+    return this.css3dRenderer || this.initCSS3DRenderer(), new Ft(e);
+  }
+  createCSS3DObject(e) {
+    return this.css3dRenderer || this.initCSS3DRenderer(), new zt(e);
+  }
+  render(e, t) {
+    this.css2dRenderer && this.css2dRenderer.render(e, t), this.css3dRenderer && this.css3dRenderer.render(e, t);
+  }
+  resize(e, t) {
+    this.css2dRenderer && this.css2dRenderer.setSize(e, t), this.css3dRenderer && this.css3dRenderer.setSize(e, t);
+  }
+  dispose() {
+    this.css2dRenderer && (this.el.removeChild(this.css2dRenderer.domElement), this.css2dRenderer = null), this.css3dRenderer && (this.el.removeChild(this.css3dRenderer.domElement), this.css3dRenderer = null);
+  }
+}
+class hs {
   el;
   renderer;
   container;
@@ -541,79 +547,40 @@ class Info {
   pointsText;
   linesText;
   timestampText;
-  _enabled = false;
-  constructor(el, renderer) {
-    this.el = el;
-    this.renderer = renderer;
-    const container = document.createElement("div");
-    container.style.position = "absolute";
-    container.style.left = "12px";
-    container.style.bottom = "12px";
-    container.style.fontSize = "12px";
-    container.style.color = "#fff";
-    container.style.pointerEvents = "none";
-    this.container = container;
-    function createTextEl(text, isMarginLeft = true) {
-      const el2 = document.createElement("span");
-      if (isMarginLeft) el2.style.marginLeft = "6px";
-      el2.innerText = text;
-      return el2;
-    }
-    function createBr() {
+  _enabled = !1;
+  constructor(e, t) {
+    this.el = e, this.renderer = t;
+    const s = document.createElement("div");
+    s.style.position = "absolute", s.style.left = "12px", s.style.bottom = "12px", s.style.fontSize = "12px", s.style.color = "#fff", s.style.pointerEvents = "none", this.container = s;
+    function i(r, o = !0) {
+      const c = document.createElement("span");
+      return o && (c.style.marginLeft = "6px"), c.innerText = r, c;
+    }
+    function n() {
       return document.createElement("br");
     }
-    this.drawCallsText = createTextEl("0");
-    this.frameCallsText = createTextEl("0");
-    this.trianglesText = createTextEl("0");
-    this.linesText = createTextEl("0");
-    this.pointsText = createTextEl("0");
-    this.timestampText = createTextEl("0");
-    this.container.appendChild(createTextEl("draw calls", false));
-    this.container.appendChild(this.drawCallsText);
-    this.container.appendChild(createBr());
-    this.container.appendChild(createTextEl("frame calls", false));
-    this.container.appendChild(this.frameCallsText);
-    this.container.appendChild(createBr());
-    this.container.appendChild(createTextEl("triangles", false));
-    this.container.appendChild(this.trianglesText);
-    this.container.appendChild(createBr());
-    this.container.appendChild(createTextEl("points", false));
-    this.container.appendChild(this.pointsText);
-    this.container.appendChild(createBr());
-    this.container.appendChild(createTextEl("lines", false));
-    this.container.appendChild(this.linesText);
-    this.container.appendChild(createBr());
-    this.container.appendChild(createTextEl("timestamp", false));
-    this.container.appendChild(this.timestampText);
-    this.container.appendChild(createBr());
+    this.drawCallsText = i("0"), this.frameCallsText = i("0"), this.trianglesText = i("0"), this.linesText = i("0"), this.pointsText = i("0"), this.timestampText = i("0"), this.container.appendChild(i("draw calls", !1)), this.container.appendChild(this.drawCallsText), this.container.appendChild(n()), this.container.appendChild(i("frame calls", !1)), this.container.appendChild(this.frameCallsText), this.container.appendChild(n()), this.container.appendChild(i("triangles", !1)), this.container.appendChild(this.trianglesText), this.container.appendChild(n()), this.container.appendChild(i("points", !1)), this.container.appendChild(this.pointsText), this.container.appendChild(n()), this.container.appendChild(i("lines", !1)), this.container.appendChild(this.linesText), this.container.appendChild(n()), this.container.appendChild(i("timestamp", !1)), this.container.appendChild(this.timestampText), this.container.appendChild(n());
   }
   update() {
     if (this._enabled) {
-      const { render } = this.renderer.info;
-      this.drawCallsText.innerText = render.drawCalls.toString();
-      this.frameCallsText.innerText = render.frameCalls.toString();
-      this.trianglesText.innerText = render.triangles.toString();
-      this.pointsText.innerText = render.points.toString();
-      this.linesText.innerText = render.lines.toString();
-      this.renderer.resolveTimestampsAsync(TimestampQuery.RENDER).then((timestamps) => {
-        this.timestampText.innerText = timestamps?.toFixed(2) ?? "0";
+      const { render: e } = this.renderer.info;
+      this.drawCallsText.innerText = e.drawCalls.toString(), this.frameCallsText.innerText = e.frameCalls.toString(), this.trianglesText.innerText = e.triangles.toString(), this.pointsText.innerText = e.points.toString(), this.linesText.innerText = e.lines.toString(), this.renderer.resolveTimestampsAsync(Ye.RENDER).then((t) => {
+        this.timestampText.innerText = t?.toFixed(2) ?? "0";
       });
     }
   }
   enable() {
-    this._enabled = true;
-    this.el.appendChild(this.container);
+    this._enabled = !0, this.el.appendChild(this.container);
   }
   disable() {
-    this._enabled = false;
-    this.container.remove();
+    this._enabled = !1, this.container.remove();
   }
   dispose() {
     this.disable();
   }
 }
-Cache.enabled = true;
-class Viewer extends EventDispatcher {
+Je.enabled = !0;
+class ei extends Ze {
   el;
   renderer;
   scene;
@@ -626,121 +593,60 @@ class Viewer extends EventDispatcher {
   interactionManager;
   objectManager;
   viewerHelper;
+  cssRenderer;
   frameCount = 1;
   frameloop = "demand";
-  constructor({ el, rendererOptions }) {
-    super();
-    this.el = el;
-    this.renderer = this._initRenderer(rendererOptions);
-    this.scene = this.createScene();
-    this.camera = this.createPerspectiveCamera();
-    this.info = new Info(this.el, this.renderer);
-    this.controls = new CameraControls(this.camera, this.renderer.domElement);
-    this.renderPipeline = new RenderPipeline(this.renderer, this.scene, this.camera);
-    this.timer = new Timer();
-    this.roomEnvironment = new RoomEnvironment(this.renderer);
-    this.interactionManager = new InteractionManager(this.renderer.domElement, this.scene, this.camera);
-    this.objectManager = new ObjectManager();
-    this.viewerHelper = new ViewerHelper(this);
-    window.addEventListener("resize", this.onWindowResize);
+  constructor({ el: e, rendererOptions: t }) {
+    super(), this.el = e, this.renderer = this._initRenderer(t), this.scene = this.createScene(), this.camera = this.createPerspectiveCamera(), this.info = new hs(this.el, this.renderer), this.controls = new ss(this.camera, this.renderer.domElement), this.renderPipeline = new es(this.renderer, this.scene, this.camera), this.timer = new Ve(), this.roomEnvironment = new ns(this.renderer), this.interactionManager = new Zt(this.renderer.domElement, this.scene, this.camera), this.objectManager = new Vt(), this.viewerHelper = new rs(this), this.cssRenderer = new cs(this.el), window.addEventListener("resize", this.onWindowResize);
   }
   onWindowResize = () => {
-    const width = this.el.clientWidth;
-    const height = this.el.clientHeight;
-    if (this.camera instanceof PerspectiveCamera) {
-      this.camera.aspect = width / height;
-      this.camera.updateProjectionMatrix();
-    } else if (this.camera instanceof OrthographicCamera) {
-      this.camera.left = -width / 2;
-      this.camera.right = width / 2;
-      this.camera.top = height / 2;
-      this.camera.bottom = -height / 2;
-      this.camera.updateProjectionMatrix();
-    }
-    this.renderer.setSize(width, height);
-    this.render();
+    const e = this.el.clientWidth, t = this.el.clientHeight;
+    this.camera instanceof K ? (this.camera.aspect = e / t, this.camera.updateProjectionMatrix()) : this.camera instanceof Q && (this.camera.left = -e / 2, this.camera.right = e / 2, this.camera.top = t / 2, this.camera.bottom = -t / 2, this.camera.updateProjectionMatrix()), this.renderer.setSize(e, t), this.cssRenderer.resize(e, t), this.render();
   };
   async init() {
-    await this.renderer.init();
-    this.roomEnvironment.update();
-    this.scene.environment = this.roomEnvironment.envMap;
-  }
-  setCamera(camera) {
-    this.camera = camera;
-    this.controls.camera = camera;
-    this.interactionManager.setCamera(camera);
-    this.renderPipeline.setCamera(camera);
-    this.onWindowResize();
-    this.dispatchEvent({ type: "cameraChange", camera });
-  }
-  setCameraByType(type) {
-    if (type === "perspective" && !(this.camera instanceof PerspectiveCamera)) {
-      this.setCamera(this.createPerspectiveCamera());
-    } else if (type === "orthographic" && !(this.camera instanceof OrthographicCamera)) {
-      this.setCamera(this.createOrthographicCamera());
-    }
+    await this.renderer.init(), this.roomEnvironment.update(), this.scene.environment = this.roomEnvironment.envMap;
+  }
+  setCamera(e) {
+    this.camera = e, this.controls.camera = e, this.interactionManager.setCamera(e), this.renderPipeline.setCamera(e), this.onWindowResize(), this.dispatchEvent({ type: "cameraChange", camera: e });
   }
-  render(frame = 1) {
-    this.frameCount += frame;
-    return new Promise((resolve) => {
-      const fn = () => {
-        this.removeEventListener("afterRender", fn);
-        resolve();
+  setCameraByType(e) {
+    e === "perspective" && !(this.camera instanceof K) ? this.setCamera(this.createPerspectiveCamera()) : e === "orthographic" && !(this.camera instanceof Q) && this.setCamera(this.createOrthographicCamera());
+  }
+  render(e = 1) {
+    return this.frameCount += e, new Promise((t) => {
+      const s = () => {
+        this.removeEventListener("afterRender", s), t();
       };
-      this.addEventListener("afterRender", fn);
+      this.addEventListener("afterRender", s);
     });
   }
-  animate = (time2) => {
-    this.timer.update(time2);
-    this.dispatchEvent({ type: "beforeControlsUpdate", time: time2 });
-    let needsRender = this.controls.update(this.timer.getDelta());
-    this.dispatchEvent({ type: "afterControlsUpdate", time: time2 });
-    if (this.frameCount > 0) {
-      this.frameCount--;
-      needsRender = true;
-    }
-    if (this.frameloop === "always") {
-      needsRender = true;
-    }
-    if (needsRender) {
-      this.dispatchEvent({ type: "beforeRender", time: time2 });
-      this.renderer.info.reset();
-      this.renderPipeline.render();
-      this.info.update();
-      this.dispatchEvent({ type: "afterRender", time: time2 });
-    }
+  animate = (e) => {
+    this.timer.update(e);
+    const t = this.timer.getDelta();
+    this.dispatchEvent({ type: "beforeControlsUpdate", time: e, delta: t });
+    let s = this.controls.update(t);
+    this.dispatchEvent({ type: "afterControlsUpdate", time: e, delta: t }), this.frameCount > 0 && (this.frameCount--, s = !0), this.frameloop === "always" && (s = !0), s && (this.dispatchEvent({ type: "beforeRender", time: e, delta: t }), this.renderer.info.reset(), this.renderPipeline.render(), this.cssRenderer.render(this.scene, this.camera), this.info.update(), this.dispatchEvent({ type: "afterRender", time: e, delta: t }));
   };
-  _initRenderer(rendererOptions) {
-    const renderer = new WebGPURenderer({
-      logarithmicDepthBuffer: true,
-      antialias: false,
-      depth: false,
-      trackTimestamp: true,
-      ...rendererOptions
+  _initRenderer(e) {
+    const t = new et({
+      logarithmicDepthBuffer: !0,
+      antialias: !1,
+      depth: !1,
+      trackTimestamp: !0,
+      ...e
     });
-    renderer.setSize(this.el.clientWidth, this.el.clientHeight);
-    renderer.shadowMap.enabled = true;
-    renderer.shadowMap.type = PCFShadowMap;
-    renderer.toneMapping = AgXToneMapping;
-    renderer.toneMappingExposure = 1;
-    renderer.info.autoReset = false;
-    renderer.setPixelRatio(window.devicePixelRatio);
-    renderer.setAnimationLoop(this.animate);
-    this.el.appendChild(renderer.domElement);
-    return renderer;
+    return t.setSize(this.el.clientWidth, this.el.clientHeight), t.shadowMap.enabled = !0, t.shadowMap.type = tt, t.toneMapping = st, t.toneMappingExposure = 1, t.info.autoReset = !1, t.setPixelRatio(window.devicePixelRatio), t.setAnimationLoop(this.animate), this.el.appendChild(t.domElement), t;
   }
   createScene() {
-    const scene = new Scene();
-    scene.background = new Color(0);
-    return scene;
+    const e = new it();
+    return e.background = new V(0), e;
   }
   createPerspectiveCamera() {
-    const camera = new PerspectiveCamera(50, this.el.clientWidth / this.el.clientHeight, 0.1, 1e5);
-    camera.position.setScalar(5);
-    return camera;
+    const e = new K(50, this.el.clientWidth / this.el.clientHeight, 0.1, 1e5);
+    return e.position.setScalar(5), e;
   }
   createOrthographicCamera() {
-    const camera = new OrthographicCamera(
+    const e = new Q(
       -this.el.clientWidth / 2,
       this.el.clientWidth / 2,
       this.el.clientHeight / 2,
@@ -748,621 +654,444 @@ class Viewer extends EventDispatcher {
       0.1,
       1e5
     );
-    camera.position.setScalar(5);
-    return camera;
+    return e.position.setScalar(5), e;
   }
   dispose() {
-    this.el.removeChild(this.renderer.domElement);
-    window.removeEventListener("resize", this.onWindowResize);
-    this.info.dispose();
-    this.interactionManager.dispose();
-    this.roomEnvironment.dispose();
-    this.renderPipeline.dispose();
-    this.renderer.dispose();
+    this.el.removeChild(this.renderer.domElement), window.removeEventListener("resize", this.onWindowResize), this.info.dispose(), this.interactionManager.dispose(), this.roomEnvironment.dispose(), this.cssRenderer.dispose(), this.renderPipeline.dispose(), this.renderer.dispose();
   }
 }
-class SBMXLoader extends GLTFLoader {
-  constructor(manager) {
-    super(manager);
-  }
-  parse(data, path, onLoad, onError) {
-    const formatName = getAsciiString(data.slice(0, 8));
-    switch (formatName) {
-      case "SBMG----": {
-        const swappedBuffer = swapBytes(data.slice(8));
-        return super.parse(swappedBuffer, path, onLoad, onError);
-      }
-      default: {
-        return super.parse(data, path, onLoad, onError);
-      }
-    }
+class ls extends Le {
+  constructor(e) {
+    super(e);
+  }
+  parse(e, t, s, i) {
+    if (ds(e.slice(0, 8)) === "SBMG----") {
+      const r = ps(e.slice(8));
+      return super.parse(r, t, s, i);
+    } else
+      return super.parse(e, t, s, i);
   }
 }
-function getAsciiString(buf) {
-  const decoder = new TextDecoder();
-  return decoder.decode(new Uint8Array(buf));
+function ds(a) {
+  return new TextDecoder().decode(new Uint8Array(a));
 }
-function swapBytes(buffer) {
-  const view = new DataView(buffer);
-  for (let i = 0; i < view.byteLength; i++) {
-    const byte = view.getUint8(i);
-    const swappedByte = (byte >> 4 & 15) + (byte << 4 & 240);
-    view.setUint8(i, swappedByte);
-  }
-  return view.buffer;
+function ps(a) {
+  const e = new DataView(a);
+  for (let t = 0; t < e.byteLength; t++) {
+    const s = e.getUint8(t), i = (s >> 4 & 15) + (s << 4 & 240);
+    e.setUint8(t, i);
+  }
+  return e.buffer;
 }
-const BYTE_LENGTH_MAGIC = 8;
-const BYTE_LENGTH_HEAD = 130;
-const BYTE_LENGTH_ATTACH = 66;
-const MAGIC_SBK = "SBK-----";
-const MAGIC_SBM = "SBM-----";
-const textDecoder = new TextDecoder();
-const textEncoder = new TextEncoder();
-function decodeSbk(buffer) {
-  let read = BYTE_LENGTH_MAGIC;
-  const magicBytes = new Uint8Array(buffer, 0, read);
-  const magic = textDecoder.decode(magicBytes);
-  if (magic !== MAGIC_SBK) {
-    return buffer;
-  }
-  read += BYTE_LENGTH_HEAD;
-  const headBytes = new Uint8Array(buffer, 0, read);
-  const version = headBytes[40];
-  if (version === 1) {
-    const magicBuf = textEncoder.encode(MAGIC_SBM);
-    const versionBuf = new Uint8Array([headBytes[41]]);
-    const sbmKey = getSbmKey(headBytes);
-    const encodeKey = getLeftKey(sbmKey);
-    let j = BYTE_LENGTH_ATTACH % encodeKey.length;
-    const offset = read + BYTE_LENGTH_ATTACH;
-    const bodyBytes = new Uint8Array(buffer, offset);
-    const bodyBuf = new Uint8Array(bodyBytes.length);
-    for (let i = 0; i < bodyBytes.length; i++) {
-      bodyBuf[i] = bodyBytes[i] ^ encodeKey[j];
-      j = (j + 1) % encodeKey.length;
-    }
-    const buf = new Uint8Array(magicBuf.length + versionBuf.length + bodyBuf.length);
-    buf.set(magicBuf);
-    buf.set(versionBuf, magicBuf.length);
-    buf.set(bodyBuf, magicBuf.length + versionBuf.length);
-    return buf.buffer;
+const us = 8, ms = 130, ye = 66, gs = "SBK-----", fs = "SBM-----", Ne = new TextDecoder(), ys = new TextEncoder();
+function ws(a) {
+  let e = us;
+  const t = new Uint8Array(a, 0, e);
+  if (Ne.decode(t) !== gs)
+    return a;
+  e += ms;
+  const i = new Uint8Array(a, 0, e);
+  if (i[40] === 1) {
+    const r = ys.encode(fs), o = new Uint8Array([i[41]]), c = vs(i), h = bs(c);
+    let l = ye % h.length;
+    const d = e + ye, g = new Uint8Array(a, d), p = new Uint8Array(g.length);
+    for (let v = 0; v < g.length; v++)
+      p[v] = g[v] ^ h[l], l = (l + 1) % h.length;
+    const y = new Uint8Array(r.length + o.length + p.length);
+    return y.set(r), y.set(o, r.length), y.set(p, r.length + o.length), y.buffer;
   }
 }
-function getSbmKey(headBuffer) {
-  const bytes = new Uint8Array(128);
-  bytes.set(headBuffer.slice(42, 42 + 32), 0);
-  bytes.set(headBuffer.slice(74, 74 + 64), 32);
-  bytes.set(headBuffer.slice(8, 8 + 32), 96);
-  return bytes;
+function vs(a) {
+  const e = new Uint8Array(128);
+  return e.set(a.slice(42, 74), 0), e.set(a.slice(74, 138), 32), e.set(a.slice(8, 40), 96), e;
 }
-function getLeftKey(sbmKey) {
-  const bytes = new Uint8Array(64);
-  bytes.set(sbmKey.slice(0, 8), 0);
-  bytes.set(sbmKey.slice(24, 24 + 8), 8);
-  bytes.set(sbmKey.slice(40, 40 + 16), 16);
-  bytes.set(sbmKey.slice(64, 64 + 24), 32);
-  bytes.set(sbmKey.slice(96, 96 + 8), 56);
-  return bytes;
+function bs(a) {
+  const e = new Uint8Array(64);
+  return e.set(a.slice(0, 8), 0), e.set(a.slice(24, 32), 8), e.set(a.slice(40, 56), 16), e.set(a.slice(64, 88), 32), e.set(a.slice(96, 104), 56), e;
 }
-const getTextureName = (dataView, texnamelen, offset) => {
-  const temp = dataView.buffer.slice(offset, offset + texnamelen);
-  let textureName = textDecoder.decode(temp);
-  textureName = textureName.replace("\\", "/");
-  if (!textureName.startsWith("Maps/")) {
-    textureName = `Maps/${textureName}`;
-  }
-  return textureName;
-};
-const generateSbmMaterial = (materialId, arr, png) => {
-  const [d0, d1, d2, d3, side] = arr;
-  const trans = png || d3 < 1;
-  const material = new MeshStandardNodeMaterial({
-    name: materialId,
-    color: new Color(d0, d1, d2),
-    opacity: d3,
-    transparent: trans,
+const Cs = (a, e, t) => {
+  const s = a.buffer.slice(t, t + e);
+  let i = Ne.decode(s);
+  return i = i.replace("\\", "/"), i.startsWith("Maps/") || (i = `Maps/${i}`), i;
+}, Ts = (a, e, t) => {
+  const [s, i, n, r, o] = e, c = t || r < 1;
+  return new L({
+    name: a,
+    color: new V(s, i, n),
+    opacity: r,
+    transparent: c,
     alphaTest: 0.01,
-    side
+    side: o
   });
-  return material;
-};
-const isPNG = (textureUrl) => {
-  return textureUrl?.toLowerCase().endsWith(".png") ?? false;
-};
-class SBMParser {
+}, Ss = (a) => a?.toLowerCase().endsWith(".png") ?? !1;
+class xs {
   data;
   options;
   textureLoader;
-  littleEndian = true;
+  littleEndian = !0;
   materials = /* @__PURE__ */ new Map();
-  constructor(data, options) {
-    this.data = data;
-    this.options = options;
-    this.textureLoader = new TextureLoader(options.manager);
-    this.textureLoader.setCrossOrigin(options.crossOrigin);
-    this.textureLoader.setRequestHeader(options.requestHeader);
-  }
-  parse(onLoad, onError) {
-    let buffer = this.data;
-    const decodeBuffer = decodeSbk(this.data);
-    if (decodeBuffer) {
-      buffer = decodeBuffer;
-    }
-    const dataView = new DataView(buffer);
-    let offset = 8;
-    const version = dataView.getUint8(offset);
-    offset += 1;
-    if (version === 1) {
-      this._parseV2(dataView, offset, onLoad);
-    } else if (version === 2) {
-      this._parseV2(dataView, offset, onLoad);
-    } else if (version === 3) {
-      this._parseV3(dataView, offset, onLoad);
-    } else {
-      onError?.(new Error(`SBMLoader: Unsupported SBM version: ${version}`));
-    }
-  }
-  _parseV2(dataView, offset, onLoad) {
-    const sbm = new Group();
-    const materialCount = dataView.getUint16(offset, this.littleEndian);
-    offset += 2;
-    const meshCount = dataView.getUint16(offset, this.littleEndian);
-    offset += 2;
-    for (let i = 0; i < materialCount; ++i) {
-      const materialId = dataView.getUint16(offset, this.littleEndian).toString();
-      offset += 2;
-      offset += 4;
-      offset += 4;
-      offset += 4;
-      offset += 4;
-      const d0 = dataView.getFloat32(offset, this.littleEndian);
-      offset += 4;
-      const d1 = dataView.getFloat32(offset, this.littleEndian);
-      offset += 4;
-      const d2 = dataView.getFloat32(offset, this.littleEndian);
-      offset += 4;
-      const d3 = dataView.getFloat32(offset, this.littleEndian);
-      offset += 4;
-      offset += 4;
-      offset += 4;
-      offset += 4;
-      offset += 4;
-      let side = dataView.getUint8(offset);
-      offset += 1;
-      if (side === 0) side = FrontSide;
-      else if (side === 1) side = BackSide;
-      else if (side === 2) side = DoubleSide;
-      const textureNameLength = dataView.getUint16(offset, this.littleEndian);
-      offset += 2;
-      const textureName = textureNameLength > 0 ? getTextureName(dataView, textureNameLength, offset) : "";
-      offset += textureNameLength;
-      if (!this.materials.has(materialId)) {
-        const materialInfo = [d0, d1, d2, d3, side];
-        const material = generateSbmMaterial(materialId, materialInfo, isPNG(textureName));
-        this.materials.set(materialId, material);
-        if (textureName && this.options.path) {
-          this.textureLoader.load(LoaderUtils.resolveURL(textureName, this.options.path), (texture) => {
-            texture.colorSpace = SRGBColorSpace;
-            texture.wrapS = RepeatWrapping;
-            texture.wrapT = RepeatWrapping;
-            texture.flipY = false;
-            texture.anisotropy = 16;
-            material.map = texture;
-          });
-        }
+  constructor(e, t) {
+    this.data = e, this.options = t, this.textureLoader = new Me(t.manager), this.textureLoader.setCrossOrigin(t.crossOrigin), this.textureLoader.setRequestHeader(t.requestHeader);
+  }
+  parse(e, t) {
+    let s = this.data;
+    const i = ws(this.data);
+    i && (s = i);
+    const n = new DataView(s);
+    let r = 8;
+    const o = n.getUint8(r);
+    r += 1, o === 1 ? this._parseV2(n, r, e) : o === 2 ? this._parseV2(n, r, e) : o === 3 ? this._parseV3(n, r, e) : t?.(new Error(`SBMLoader: Unsupported SBM version: ${o}`));
+  }
+  _parseV2(e, t, s) {
+    const i = new ee(), n = e.getUint16(t, this.littleEndian);
+    t += 2;
+    const r = e.getUint16(t, this.littleEndian);
+    t += 2;
+    for (let o = 0; o < n; ++o) {
+      const c = e.getUint16(t, this.littleEndian).toString();
+      t += 2, t += 4, t += 4, t += 4, t += 4;
+      const h = e.getFloat32(t, this.littleEndian);
+      t += 4;
+      const l = e.getFloat32(t, this.littleEndian);
+      t += 4;
+      const d = e.getFloat32(t, this.littleEndian);
+      t += 4;
+      const g = 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 = at : p === 1 ? p = ot : p === 2 && (p = ct);
+      const y = e.getUint16(t, this.littleEndian);
+      t += 2;
+      const v = y > 0 ? Cs(e, y, t) : "";
+      if (t += y, !this.materials.has(c)) {
+        const b = Ts(c, [h, l, d, g, p], Ss(v));
+        this.materials.set(c, b), v && this.options.path && this.textureLoader.load(I.resolveURL(v, this.options.path), (f) => {
+          f.colorSpace = Pe, f.wrapS = ce, f.wrapT = ce, f.flipY = !1, f.anisotropy = 16, b.map = f;
+        });
       }
     }
-    for (let i = 0; i < meshCount; ++i) {
-      const meshId = dataView.getUint16(offset, this.littleEndian).toString();
-      offset += 2;
-      const materialId = dataView.getUint16(offset, this.littleEndian).toString();
-      offset += 2;
-      const vertices = [];
-      const texcoords = [];
-      const faces = [];
-      const faceVertexUvs = [];
-      const verticesCount = dataView.getUint16(offset, this.littleEndian);
-      offset += 2;
-      if (verticesCount > 0) {
-        for (let j = 0; j < verticesCount; j++) {
-          const vector3 = new Vector3();
-          vector3.setX(dataView.getFloat32(offset, this.littleEndian));
-          offset += 4;
-          vector3.setY(dataView.getFloat32(offset, this.littleEndian));
-          offset += 4;
-          vector3.setZ(dataView.getFloat32(offset, this.littleEndian));
-          offset += 4;
-          vertices.push(vector3);
-        }
-      }
-      const normalsCount = dataView.getUint16(offset, this.littleEndian);
-      offset += 2;
-      if (normalsCount > 0) {
-        for (let j = 0; j < normalsCount; j++) {
-          offset += 4;
-          offset += 4;
-          offset += 4;
-        }
-      }
-      const texcoordCount = dataView.getUint16(offset, this.littleEndian);
-      offset += 2;
-      if (texcoordCount > 0) {
-        for (let j = 0; j < texcoordCount; j++) {
-          const texcoord = new Vector2();
-          texcoord.setX(dataView.getFloat32(offset, this.littleEndian));
-          offset += 4;
-          texcoord.setY(dataView.getFloat32(offset, this.littleEndian));
-          offset += 4;
-          texcoords.push(texcoord);
+    for (let o = 0; o < r; ++o) {
+      const c = e.getUint16(t, this.littleEndian).toString();
+      t += 2;
+      const h = e.getUint16(t, this.littleEndian).toString();
+      t += 2;
+      const l = [], d = [], g = [], p = [], y = e.getUint16(t, this.littleEndian);
+      if (t += 2, y > 0)
+        for (let m = 0; m < y; m++) {
+          const w = new oe();
+          w.setX(e.getFloat32(t, this.littleEndian)), t += 4, w.setY(e.getFloat32(t, this.littleEndian)), t += 4, w.setZ(e.getFloat32(t, this.littleEndian)), t += 4, l.push(w);
         }
-      }
-      const idxCount = dataView.getUint16(offset, this.littleEndian);
-      offset += 2;
-      if (idxCount > 0) {
-        for (let j = 0; j < idxCount; j++) {
-          const a = dataView.getUint16(offset, this.littleEndian);
-          offset += 2;
-          const b = dataView.getUint16(offset, this.littleEndian);
-          offset += 2;
-          const c = dataView.getUint16(offset, this.littleEndian);
-          offset += 2;
-          const face = [a, b, c];
-          faces.push(face);
-          if (texcoords.length > 0) {
-            faceVertexUvs.push([texcoords[face[0]], texcoords[face[1]], texcoords[face[2]]]);
-          }
+      const v = e.getUint16(t, this.littleEndian);
+      if (t += 2, v > 0)
+        for (let m = 0; m < v; m++)
+          t += 4, t += 4, t += 4;
+      const S = e.getUint16(t, this.littleEndian);
+      if (t += 2, S > 0)
+        for (let m = 0; m < S; m++) {
+          const w = new R();
+          w.setX(e.getFloat32(t, this.littleEndian)), t += 4, w.setY(e.getFloat32(t, this.littleEndian)), t += 4, d.push(w);
         }
-      }
-      const positions = [], uvs = [];
-      for (let i2 = 0; i2 < faces.length; i2++) {
-        const face = faces[i2];
-        const vertex = vertices[face[0]], vertex2 = vertices[face[1]], vertex3 = vertices[face[2]];
-        positions.push(...vertex.toArray(), ...vertex2.toArray(), ...vertex3.toArray());
-        let uv2 = new Vector2(), uv22 = new Vector2(), uv3 = new Vector2();
-        const vertexUvs = faceVertexUvs[i2];
-        if (vertexUvs !== void 0) {
-          uv2 = vertexUvs[0];
-          uv22 = vertexUvs[1];
-          uv3 = vertexUvs[2];
+      const b = e.getUint16(t, this.littleEndian);
+      if (t += 2, b > 0)
+        for (let m = 0; m < b; m++) {
+          const w = e.getUint16(t, this.littleEndian);
+          t += 2;
+          const A = e.getUint16(t, this.littleEndian);
+          t += 2;
+          const N = e.getUint16(t, this.littleEndian);
+          t += 2;
+          const E = [w, A, N];
+          g.push(E), d.length > 0 && p.push([d[E[0]], d[E[1]], d[E[2]]]);
         }
-        uvs.push(...uv2.toArray(), ...uv22.toArray(), ...uv3.toArray());
+      const f = [], T = [];
+      for (let m = 0; m < g.length; m++) {
+        const w = g[m], A = l[w[0]], N = l[w[1]], E = l[w[2]];
+        f.push(...A.toArray(), ...N.toArray(), ...E.toArray());
+        let H = new R(), G = new R(), _ = new R();
+        const D = p[m];
+        D !== void 0 && (H = D[0], G = D[1], _ = D[2]), T.push(...H.toArray(), ...G.toArray(), ..._.toArray());
       }
-      const positionArray = new Float32Array(positions), uvArray = new Float32Array(uvs);
-      const bufferGeometry = new BufferGeometry();
-      if (positionArray.length > 0) {
-        bufferGeometry.setAttribute("position", new BufferAttribute(positionArray, 3));
-      }
-      if (uvArray.length > 0) {
-        bufferGeometry.setAttribute("uv", new BufferAttribute(uvArray, 2));
-      }
-      bufferGeometry.computeVertexNormals();
-      if (this.materials.has(materialId)) {
-        const sbmChild = new Mesh(bufferGeometry, this.materials.get(materialId));
-        sbmChild.name = meshId;
-        sbmChild.castShadow = true;
-        sbmChild.receiveShadow = true;
-        sbm.add(sbmChild);
+      const M = new Float32Array(f), P = new Float32Array(T), x = new rt();
+      if (M.length > 0 && x.setAttribute("position", new he(M, 3)), P.length > 0 && x.setAttribute("uv", new he(P, 2)), x.computeVertexNormals(), this.materials.has(h)) {
+        const m = new z(x, this.materials.get(h));
+        m.name = c, m.castShadow = !0, m.receiveShadow = !0, i.add(m);
       }
     }
-    onLoad(sbm);
+    s(i);
   }
-  _parseV3(_dataView, _offset, onLoad) {
-    const sbm = new Group();
-    console.warn("SBMLoader: SBM version 3 is not supported yet.");
-    onLoad(sbm);
+  _parseV3(e, t, s) {
+    const i = new ee();
+    console.warn("SBMLoader: SBM version 3 is not supported yet."), s(i);
   }
 }
-class SBMLoader extends Loader {
-  load(url, onLoad, onProgress, onError) {
-    let resourcePath;
-    if (this.resourcePath !== "") {
-      resourcePath = this.resourcePath;
-    } else if (this.path !== "") {
-      const relativeUrl = LoaderUtils.extractUrlBase(url);
-      resourcePath = LoaderUtils.resolveURL(relativeUrl, this.path);
-    } else {
-      resourcePath = LoaderUtils.extractUrlBase(url);
-    }
-    this.manager.itemStart(url);
-    const _onError = (e) => {
-      if (onError) {
-        onError(e);
-      } else {
-        console.error(e);
-      }
-      this.manager.itemError(url);
-      this.manager.itemEnd(url);
-    };
-    const loader = new FileLoader(this.manager);
-    loader.setPath(this.path);
-    loader.setResponseType("arraybuffer");
-    loader.setRequestHeader(this.requestHeader);
-    loader.setWithCredentials(this.withCredentials);
-    loader.load(
-      url,
-      (data) => {
+class Es extends nt {
+  load(e, t, s, i) {
+    let n;
+    if (this.resourcePath !== "")
+      n = this.resourcePath;
+    else if (this.path !== "") {
+      const c = I.extractUrlBase(e);
+      n = I.resolveURL(c, this.path);
+    } else
+      n = I.extractUrlBase(e);
+    this.manager.itemStart(e);
+    const r = (c) => {
+      i ? i(c) : console.error(c), this.manager.itemError(e), this.manager.itemEnd(e);
+    }, o = new Ee(this.manager);
+    o.setPath(this.path), o.setResponseType("arraybuffer"), o.setRequestHeader(this.requestHeader), o.setWithCredentials(this.withCredentials), o.load(
+      e,
+      (c) => {
         try {
           this.parse(
-            data,
-            resourcePath,
-            (sbm) => {
-              onLoad(sbm);
-              this.manager.itemEnd(url);
+            c,
+            n,
+            (h) => {
+              t(h), this.manager.itemEnd(e);
             },
-            _onError
+            r
           );
-        } catch (e) {
-          _onError(e);
+        } catch (h) {
+          r(h);
         }
       },
-      onProgress,
-      _onError
+      s,
+      r
     );
   }
-  parse(data, path, onLoad, onError) {
-    const formatName = new TextDecoder().decode(data.slice(0, 8));
-    if (formatName !== "SBK-----" && formatName !== "SBM-----") {
-      onError?.(new Error(`SBMLoader: Invalid SBM format: ${formatName}`));
+  parse(e, t, s, i) {
+    const n = new TextDecoder().decode(e.slice(0, 8));
+    if (n !== "SBK-----" && n !== "SBM-----") {
+      i?.(new Error(`SBMLoader: Invalid SBM format: ${n}`));
       return;
     }
-    const parser = new SBMParser(data, {
-      path,
+    new xs(e, {
+      path: t,
       crossOrigin: this.crossOrigin,
       requestHeader: this.requestHeader,
       manager: this.manager
-    });
-    parser.parse(onLoad, onError);
+    }).parse(s, i);
   }
-  parseAsync(data, path) {
-    return new Promise((resolve, reject) => {
+  parseAsync(e, t) {
+    return new Promise((s, i) => {
       this.parse(
-        data,
-        path,
-        (sbm) => {
-          resolve(sbm);
+        e,
+        t,
+        (n) => {
+          s(n);
         },
-        (err) => {
-          reject(err);
+        (n) => {
+          i(n);
         }
       );
     });
   }
 }
-class ModelLoaderManager {
+class B {
   static CACHE_NAME = "u-space-model-loader-cache";
-  static fileLoader = new FileLoader().setResponseType("arraybuffer");
-  static dracoLoader = new DRACOLoader().setDecoderPath(
-    `https://cdn.jsdelivr.net/npm/three@0.${REVISION}.0/examples/jsm/libs/draco/`
+  static fileLoader = new Ee().setResponseType("arraybuffer");
+  static dracoLoader = new Kt().setDecoderPath(
+    `https://cdn.jsdelivr.net/npm/three@0.${le}.0/examples/jsm/libs/draco/`
   );
-  static ktx2Loader = new KTX2Loader().setTranscoderPath(
-    `https://cdn.jsdelivr.net/npm/three@0.${REVISION}.0/examples/jsm/libs/basis/`
+  static ktx2Loader = new Qt().setTranscoderPath(
+    `https://cdn.jsdelivr.net/npm/three@0.${le}.0/examples/jsm/libs/basis/`
   );
-  static gltfLoader = new GLTFLoader().setDRACOLoader(ModelLoaderManager.dracoLoader).setKTX2Loader(ModelLoaderManager.ktx2Loader).setMeshoptDecoder(MeshoptDecoder);
-  static sbmxLoader = new SBMXLoader().setDRACOLoader(ModelLoaderManager.dracoLoader).setKTX2Loader(ModelLoaderManager.ktx2Loader).setMeshoptDecoder(MeshoptDecoder);
-  static sbmLoader = new SBMLoader();
-  static fbxLoader = new FBXLoader();
-  static objLoader = new OBJLoader();
-  static stlLoader = new STLLoader();
-  static setLoadingManager(loadingManager) {
-    this.fileLoader.manager = loadingManager;
-    this.dracoLoader.manager = loadingManager;
-    this.ktx2Loader.manager = loadingManager;
-    this.gltfLoader.manager = loadingManager;
-    this.sbmxLoader.manager = loadingManager;
-    this.sbmLoader.manager = loadingManager;
-    this.fbxLoader.manager = loadingManager;
-    this.objLoader.manager = loadingManager;
-    this.stlLoader.manager = loadingManager;
+  static gltfLoader = new Le().setDRACOLoader(B.dracoLoader).setKTX2Loader(B.ktx2Loader).setMeshoptDecoder(ge);
+  static sbmxLoader = new ls().setDRACOLoader(B.dracoLoader).setKTX2Loader(B.ktx2Loader).setMeshoptDecoder(ge);
+  static sbmLoader = new Es();
+  static fbxLoader = new Ht();
+  static objLoader = new $t();
+  static stlLoader = new Wt();
+  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;
   }
   /**
    * Set the renderer to enable KTX2 support and other renderer-dependent features.
    */
-  static async setRenderer(renderer) {
-    await renderer.init();
-    this.ktx2Loader.detectSupport(renderer);
+  static async setRenderer(e) {
+    await e.init(), this.ktx2Loader.detectSupport(e);
   }
   /**
    * Configure Draco decoder path.
    */
-  static setDracoPath(path) {
-    this.dracoLoader.setDecoderPath(path);
+  static setDracoPath(e) {
+    this.dracoLoader.setDecoderPath(e);
   }
   /**
    * Configure KTX2 transcoder path.
    */
-  static setKTX2Path(path) {
-    this.ktx2Loader.setTranscoderPath(path);
-  }
-  static async loadAsync(url, parameters = { persistent: true }) {
-    const extension = url.split(".").pop()?.split("?")[0].toLowerCase();
-    let buffer;
-    if (parameters.persistent && typeof caches !== "undefined") {
-      buffer = await this.getPersistentData(url);
-    } else {
-      buffer = await this.fileLoader.loadAsync(url);
-    }
-    switch (extension) {
+  static setKTX2Path(e) {
+    this.ktx2Loader.setTranscoderPath(e);
+  }
+  static async loadAsync(e, t = { persistent: !0 }) {
+    const s = e.split(".").pop()?.split("?")[0].toLowerCase();
+    let i;
+    switch (t.persistent && typeof caches < "u" ? i = await this.getPersistentData(e) : i = await this.fileLoader.loadAsync(e), s) {
       case "gltf":
       case "glb":
-        const gltf = await this.gltfLoader.parseAsync(buffer, LoaderUtils.extractUrlBase(url));
-        return gltf.scene;
+        const n = await this.gltfLoader.parseAsync(i, I.extractUrlBase(e));
+        return n.scene.animations = n.animations, n.scene;
       case "sbmx":
-        const sbmx = await this.sbmxLoader.parseAsync(buffer, LoaderUtils.extractUrlBase(url));
-        return sbmx.scene;
+        const r = await this.sbmxLoader.parseAsync(i, I.extractUrlBase(e));
+        return r.scene.animations = r.animations, r.scene;
       case "sbm":
-        const sbm = await this.sbmLoader.parseAsync(buffer, LoaderUtils.extractUrlBase(url));
-        return sbm;
+        return await this.sbmLoader.parseAsync(i, I.extractUrlBase(e));
       case "fbx":
-        const fbx = this.fbxLoader.parse(buffer, LoaderUtils.extractUrlBase(url));
-        return fbx;
+        return this.fbxLoader.parse(i, I.extractUrlBase(e));
       case "obj":
-        const text = new TextDecoder().decode(buffer);
-        const obj = this.objLoader.parse(text);
-        return obj;
+        const h = new TextDecoder().decode(i);
+        return this.objLoader.parse(h);
       case "stl":
-        const geometry = this.stlLoader.parse(buffer);
-        const mesh = new Mesh(geometry, new MeshStandardNodeMaterial());
-        return mesh;
+        const d = this.stlLoader.parse(i);
+        return new z(d, new L());
       default:
-        throw new Error(`Unsupported model format: ${extension}`);
+        throw new Error(`Unsupported model format: ${s}`);
     }
   }
-  static async getPersistentData(url) {
+  static async getPersistentData(e) {
     try {
-      const cache = await caches.open(this.CACHE_NAME);
-      const cachedResponse = await cache.match(url);
-      if (cachedResponse) {
-        return await cachedResponse.arrayBuffer();
-      }
-      const buffer = await this.fileLoader.loadAsync(url);
-      const response = new Response(buffer);
-      await cache.put(url, response);
-      return buffer;
-    } catch (error) {
-      console.warn(`[LoaderManager] Failed to use Cache API for ${url}:`, error);
-      return await this.fileLoader.loadAsync(url);
+      const t = await caches.open(this.CACHE_NAME), s = await t.match(e);
+      if (s)
+        return await s.arrayBuffer();
+      const i = await this.fileLoader.loadAsync(e), n = new Response(i);
+      return await t.put(e, n), i;
+    } catch (t) {
+      return console.warn(`[LoaderManager] Failed to use Cache API for ${e}:`, t), await this.fileLoader.loadAsync(e);
     }
   }
 }
-class TextureLoaderManager {
-  static textureLoader = new TextureLoader();
-  static hdrLoader = new HDRLoader();
-  static cubeTextureLoader = new CubeTextureLoader();
-  static setLoadingManager(loadingManager) {
-    this.textureLoader.manager = loadingManager;
-    this.hdrLoader.manager = loadingManager;
-    this.cubeTextureLoader.manager = loadingManager;
-  }
-  static async loadAsyncTexture(url) {
-    const texture = await this.textureLoader.loadAsync(url);
-    return texture;
-  }
-  static async loadAsyncHDR(url) {
-    const dataTexture = await this.hdrLoader.loadAsync(url);
-    dataTexture.mapping = EquirectangularReflectionMapping;
-    return dataTexture;
-  }
-  static async loadAsyncCubeTexture(path, urls) {
-    this.cubeTextureLoader.setPath(path);
-    const cubeTexture = await this.cubeTextureLoader.loadAsync(urls);
-    return cubeTexture;
+class ti {
+  static textureLoader = new Me();
+  static hdrLoader = new Xt();
+  static cubeTextureLoader = new ht();
+  static setLoadingManager(e) {
+    this.textureLoader.manager = e, this.hdrLoader.manager = e, this.cubeTextureLoader.manager = e;
+  }
+  static async loadAsyncTexture(e) {
+    return await this.textureLoader.loadAsync(e);
+  }
+  static async loadAsyncHDR(e) {
+    const t = await this.hdrLoader.loadAsync(e);
+    return t.mapping = lt, t;
+  }
+  static async loadAsyncCubeTexture(e, t) {
+    return this.cubeTextureLoader.setPath(e), await this.cubeTextureLoader.loadAsync(t);
   }
 }
-class BaseMesh extends Mesh {
-  isBaseMesh = true;
+class k extends z {
+  isBaseMesh = !0;
   type = "BaseMesh";
-  ignoreInvisibleWhenRaycast = true;
-  constructor(...args) {
-    super(...args);
+  ignoreInvisibleWhenRaycast = !0;
+  constructor(...e) {
+    super(...e);
   }
-  raycast(raycaster, intersects) {
-    if (this.visible === false && this.ignoreInvisibleWhenRaycast === true) {
-      return false;
-    }
-    return super.raycast(raycaster, intersects);
+  raycast(e, t) {
+    return this.visible === !1 && this.ignoreInvisibleWhenRaycast === !0 ? !1 : super.raycast(e, t);
   }
 }
-class BaseGroup extends Group {
-  isBaseGroup = true;
+class Be extends ee {
+  isBaseGroup = !0;
   type = "BaseGroup";
-  ignoreInvisibleWhenRaycast = true;
-  constructor(...args) {
-    super(...args);
+  ignoreInvisibleWhenRaycast = !0;
+  constructor(...e) {
+    super(...e);
   }
-  raycast(raycaster, intersects) {
-    if (this.visible === false && this.ignoreInvisibleWhenRaycast === true) {
-      return false;
-    }
-    return super.raycast(raycaster, intersects);
+  raycast(e, t) {
+    return this.visible === !1 && this.ignoreInvisibleWhenRaycast === !0 ? !1 : super.raycast(e, t);
   }
 }
-class BaseSprite extends Sprite {
-  isBaseSprite = true;
+class Ms extends dt {
+  isBaseSprite = !0;
   type = "BaseSprite";
-  ignoreInvisibleWhenRaycast = true;
-  constructor(...args) {
-    super(...args);
+  ignoreInvisibleWhenRaycast = !0;
+  constructor(...e) {
+    super(...e);
   }
-  raycast(raycaster, intersects) {
-    if (this.visible === false && this.ignoreInvisibleWhenRaycast === true) {
-      return false;
-    }
-    return super.raycast(raycaster, intersects);
+  raycast(e, t) {
+    return this.visible === !1 && this.ignoreInvisibleWhenRaycast === !0 ? !1 : super.raycast(e, t);
   }
 }
-class Model extends BaseGroup {
-  isModel = true;
+class Z extends Be {
+  isModel = !0;
   type = "Model";
   static memoryCache = /* @__PURE__ */ new Map();
+  mixer = null;
+  animations = [];
+  actions = /* @__PURE__ */ new Map();
   constructor() {
     super();
   }
-  async loadAsync(parameters) {
-    const { url, cache = true, persistent = true } = parameters;
+  async loadAsync(e) {
+    const { url: t, cache: s = !0, persistent: i = !0 } = e;
     try {
-      let objectPromise;
-      if (cache) {
-        if (Model.memoryCache.has(url)) {
-          objectPromise = Model.memoryCache.get(url);
-        } else {
-          objectPromise = ModelLoaderManager.loadAsync(url, { persistent });
-          Model.memoryCache.set(url, objectPromise);
-        }
-      } else {
-        objectPromise = ModelLoaderManager.loadAsync(url, { persistent });
-      }
-      const object = await objectPromise;
-      const clonedObject = clone(object);
-      this.add(clonedObject);
-      return clonedObject;
-    } catch (error) {
-      console.error(`[Model] Failed to load model from ${url}:`, error);
-      return null;
+      let n;
+      s ? Z.memoryCache.has(t) ? n = Z.memoryCache.get(t) : (n = B.loadAsync(t, { persistent: i }), Z.memoryCache.set(t, n)) : n = B.loadAsync(t, { persistent: i });
+      const r = await n, o = qt(r);
+      return this.add(o), o.animations && o.animations.length > 0 && (this.animations = o.animations, this.mixer = new pt(o)), o;
+    } catch (n) {
+      return console.error(`[Model] Failed to load model from ${t}:`, n), null;
+    }
+  }
+  playAnimation(e, t = {}) {
+    if (!this.mixer || this.animations.length === 0) return null;
+    const { loop: s = !0, repetitions: i = 1 / 0, timeScale: n = 1, clampWhenFinished: r = !1 } = t;
+    let o;
+    if (e === void 0 ? o = this.animations[0] : typeof e == "number" ? o = this.animations[e] : o = this.animations.find((h) => h.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 ? ut : mt, i), c.clampWhenFinished = r, c.timeScale = n, c.reset().play(), c;
+  }
+  playAllAnimations(e = {}) {
+    return this.animations.map((t, s) => this.playAnimation(s, e)).filter((t) => t !== null);
+  }
+  stopAnimation(e) {
+    if (!this.mixer) return;
+    if (e === void 0) {
+      this.mixer.stopAllAction();
+      return;
     }
+    let t;
+    typeof e == "number" ? t = this.animations[e]?.name : t = e, t && this.actions.get(t)?.stop();
+  }
+  updateAnimation(e) {
+    this.mixer?.update(e);
   }
   static clearMemoryCache() {
     this.memoryCache.clear();
   }
   static async clearPersistentCache() {
-    if (typeof caches !== "undefined") {
-      await caches.delete("u-space-loader-cache");
-    }
+    typeof caches < "u" && await caches.delete("u-space-loader-cache");
   }
 }
-class SphereMesh extends BaseMesh {
-  isSphereMesh = true;
+class Ps extends k {
+  isSphereMesh = !0;
   type = "SphereMesh";
-  constructor({ geometryParameters, materialParameters } = {}) {
-    super();
-    this.geometry = new SphereGeometry(
-      geometryParameters?.radius,
-      geometryParameters?.widthSegments,
-      geometryParameters?.heightSegments,
-      geometryParameters?.phiStart,
-      geometryParameters?.phiLength,
-      geometryParameters?.thetaStart,
-      geometryParameters?.thetaLength
-    );
-    this.material = new MeshStandardNodeMaterial(materialParameters);
+  constructor({ geometryParameters: e, materialParameters: t } = {}) {
+    super(), this.geometry = new gt(
+      e?.radius,
+      e?.widthSegments,
+      e?.heightSegments,
+      e?.phiStart,
+      e?.phiLength,
+      e?.thetaStart,
+      e?.thetaLength
+    ), this.material = new L(t);
   }
 }
-class TubeMesh extends BaseMesh {
-  isTubeMesh = true;
+class we extends k {
+  isTubeMesh = !0;
   type = "TubeMesh";
-  constructor({ geometryParameters, materialParameters } = {}) {
-    super();
-    this.geometry = new TubeGeometry(
-      geometryParameters?.path,
-      geometryParameters?.tubularSegments,
-      geometryParameters?.radius,
-      geometryParameters?.radialSegments,
-      geometryParameters?.closed
-    );
-    this.material = new MeshStandardNodeMaterial(materialParameters);
+  constructor({ geometryParameters: e, materialParameters: t } = {}) {
+    super(), this.geometry = new ft(
+      e?.path,
+      e?.tubularSegments,
+      e?.radius,
+      e?.radialSegments,
+      e?.closed
+    ), this.material = new L(t);
   }
 }
-class Topology extends BaseGroup {
-  isTopology = true;
+class si extends Be {
+  isTopology = !0;
   type = "Topology";
   // Visuals
   parameters = {
@@ -1377,37 +1106,27 @@ class Topology extends BaseGroup {
   adjacencyMap = /* @__PURE__ */ new Map();
   graphGroup = null;
   pathMeshes = [];
-  constructor(parameters) {
-    super();
-    if (parameters) {
-      Object.assign(this.parameters, parameters);
-    }
+  constructor(e) {
+    super(), e && Object.assign(this.parameters, e);
   }
   /**
    * Add a node to the topology graph.
    * @param id Unique identifier for the node
    * @param position 3D position of the node
    */
-  addNode(id, position) {
-    if (this.nodes.has(id)) {
-      console.warn(`[Topology] Node ${id} already exists. Overwriting.`);
-    }
-    this.nodes.set(id, position);
-    if (!this.adjacencyMap.has(id)) {
-      this.adjacencyMap.set(id, /* @__PURE__ */ new Map());
-    }
+  addNode(e, t) {
+    this.nodes.has(e) && console.warn(`[Topology] Node ${e} already exists. Overwriting.`), this.nodes.set(e, t), this.adjacencyMap.has(e) || this.adjacencyMap.set(e, /* @__PURE__ */ new Map());
   }
   /**
    * Remove a node from the topology graph.
    * @param id Unique identifier for the node
    */
-  removeNode(id) {
-    if (!this.nodes.has(id)) {
-      console.warn(`[Topology] Node ${id} does not exist.`);
+  removeNode(e) {
+    if (!this.nodes.has(e)) {
+      console.warn(`[Topology] Node ${e} does not exist.`);
       return;
     }
-    this.nodes.delete(id);
-    this.adjacencyMap.delete(id);
+    this.nodes.delete(e), this.adjacencyMap.delete(e);
   }
   /**
    * Add an edge between two nodes.
@@ -1416,18 +1135,14 @@ class Topology extends BaseGroup {
    * @param weight Cost of the edge. Defaults to Euclidean distance.
    * @param bidirectional If true, adds the reverse edge as well. Default true.
    */
-  addEdge(from, to, weight, bidirectional = true) {
-    const fromPos = this.nodes.get(from);
-    const toPos = this.nodes.get(to);
-    if (!fromPos || !toPos) {
-      console.error(`[Topology] Cannot add edge. One or both nodes not found: ${from}, ${to}`);
+  addEdge(e, t, s, i = !0) {
+    const n = this.nodes.get(e), r = this.nodes.get(t);
+    if (!n || !r) {
+      console.error(`[Topology] Cannot add edge. One or both nodes not found: ${e}, ${t}`);
       return;
     }
-    const dist = weight ?? fromPos.distanceTo(toPos);
-    this.getNeighbors(from)?.set(to, dist);
-    if (bidirectional) {
-      this.getNeighbors(to)?.set(from, dist);
-    }
+    const o = s ?? n.distanceTo(r);
+    this.getNeighbors(e)?.set(t, o), i && this.getNeighbors(t)?.set(e, o);
   }
   /**
    * Remove an edge between two nodes.
@@ -1435,80 +1150,51 @@ class Topology extends BaseGroup {
    * @param to Node ID
    * @param bidirectional If true, removes the reverse edge as well. Default true.
    */
-  removeEdge(from, to, bidirectional = true) {
-    const fromNeighbors = this.getNeighbors(from);
-    fromNeighbors?.delete(to);
-    if (bidirectional) {
-      const toNeighbors = this.getNeighbors(to);
-      toNeighbors?.delete(from);
-    }
+  removeEdge(e, t, s = !0) {
+    this.getNeighbors(e)?.delete(t), s && this.getNeighbors(t)?.delete(e);
   }
   /**
    * Find the shortest path between start and end nodes using Dijkstra's algorithm.
    */
-  getShortestPath(startId, endId) {
-    if (!this.nodes.has(startId) || !this.nodes.has(endId)) {
-      console.warn(`[Topology] Start or End node not found.`);
-      return [];
-    }
-    const distances = /* @__PURE__ */ new Map();
-    const previous = /* @__PURE__ */ new Map();
-    const unvisited = /* @__PURE__ */ new Set();
-    for (const [id] of this.nodes) {
-      distances.set(id, Infinity);
-      previous.set(id, null);
-      unvisited.add(id);
-    }
-    distances.set(startId, 0);
-    while (unvisited.size > 0) {
-      let currentId = null;
-      let minDist = Infinity;
-      for (const id of unvisited) {
-        const d = distances.get(id);
-        if (d < minDist) {
-          minDist = d;
-          currentId = id;
-        }
-      }
-      if (currentId === null || currentId === endId) {
-        break;
+  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(), i = /* @__PURE__ */ new Map(), n = /* @__PURE__ */ new Set();
+    for (const [c] of this.nodes)
+      s.set(c, 1 / 0), i.set(c, null), n.add(c);
+    for (s.set(e, 0); n.size > 0; ) {
+      let c = null, h = 1 / 0;
+      for (const d of n) {
+        const g = s.get(d);
+        g < h && (h = g, c = d);
       }
-      if (minDist === Infinity) {
+      if (c === null || c === t || h === 1 / 0)
         break;
-      }
-      unvisited.delete(currentId);
-      const neighbors = this.adjacencyMap?.get(currentId);
-      if (!neighbors) {
-        continue;
-      }
-      for (const [to, weight] of neighbors) {
-        if (!unvisited.has(to)) continue;
-        const alt = distances.get(currentId) + weight;
-        if (alt < distances.get(to)) {
-          distances.set(to, alt);
-          previous.set(to, currentId);
+      n.delete(c);
+      const l = this.adjacencyMap?.get(c);
+      if (l)
+        for (const [d, g] of l) {
+          if (!n.has(d)) continue;
+          const p = s.get(c) + g;
+          p < s.get(d) && (s.set(d, p), i.set(d, c));
         }
-      }
     }
-    const path = [];
-    let curr = endId;
-    if (previous.get(endId) === null && startId !== endId) {
+    const r = [];
+    let o = t;
+    if (i.get(t) === null && e !== t)
       return [];
+    for (; o !== null; ) {
+      const c = this.nodes.get(o);
+      c && r.unshift(c), o = i.get(o) || null;
     }
-    while (curr !== null) {
-      const pos = this.nodes.get(curr);
-      if (pos) path.unshift(pos);
-      curr = previous.get(curr) || null;
-    }
-    return path;
+    return r;
   }
   /**
    * Renders the entire topology graph structure using TubeGeometry and Spheres.
    */
   renderGraph() {
-    this.clearGraph();
-    this.graphGroup = new Group();
-    const _dummySphere = new SphereMesh({
+    this.clearGraph(), this.graphGroup = new ee();
+    const e = new Ps({
       geometryParameters: {
         radius: this.parameters.nodeRadius,
         widthSegments: 16,
@@ -1518,128 +1204,97 @@ class Topology extends BaseGroup {
         color: this.parameters.nodeColor
       }
     });
-    this.nodes.forEach((pos, id) => {
-      const nodeMesh = _dummySphere.clone();
-      nodeMesh.position.copy(pos);
-      Object.assign(nodeMesh.userData, { id, type: "node" });
-      this.graphGroup.add(nodeMesh);
+    this.nodes.forEach((s, i) => {
+      const n = e.clone();
+      n.position.copy(s), Object.assign(n.userData, { id: i, type: "node" }), this.graphGroup.add(n);
     });
-    const processedEdges = /* @__PURE__ */ new Set();
-    this.adjacencyMap.forEach((edges, from) => {
-      edges.forEach((weight, to) => {
-        const key = [from, to].sort().join("-");
-        if (processedEdges.has(key)) return;
-        processedEdges.add(key);
-        const p1 = this.nodes.get(from);
-        const p2 = this.nodes.get(to);
-        if (p1 && p2) {
-          const path = new LineCurve3(p1, p2);
-          const tubeMesh = new TubeMesh({
+    const t = /* @__PURE__ */ new Set();
+    this.adjacencyMap.forEach((s, i) => {
+      s.forEach((n, r) => {
+        const o = [i, r].sort().join("-");
+        if (t.has(o)) return;
+        t.add(o);
+        const c = this.nodes.get(i), h = this.nodes.get(r);
+        if (c && h) {
+          const l = new yt(c, h), d = new we({
             geometryParameters: {
-              path,
+              path: l,
               tubularSegments: 1,
               radius: this.parameters.edgeRadius,
               radialSegments: 8,
-              closed: false
+              closed: !1
             },
             materialParameters: {
               color: this.parameters.edgeColor
             }
           });
-          Object.assign(tubeMesh.userData, { from, to, weight, type: "edge" });
-          this.graphGroup.add(tubeMesh);
+          Object.assign(d.userData, { from: i, to: r, weight: n, type: "edge" }), this.graphGroup.add(d);
         }
       });
-    });
-    this.add(this.graphGroup);
+    }), this.add(this.graphGroup);
   }
   clearGraph() {
-    if (this.graphGroup) {
-      this.remove(this.graphGroup);
-      this.graphGroup.traverse((child) => {
-        if (child instanceof Mesh) {
-          child.geometry.dispose();
-          child.material.dispose();
-        }
-      });
-      this.graphGroup = null;
-    }
+    this.graphGroup && (this.remove(this.graphGroup), this.graphGroup.traverse((e) => {
+      e instanceof z && (e.geometry.dispose(), e.material.dispose());
+    }), this.graphGroup = null);
   }
   /**
    * Visualizes a path using TubeGeometry (CatmullRomCurve3).
    */
-  renderPath(points, color2 = this.parameters.pathColor) {
-    if (points.length < 2) return;
-    const curve = new CatmullRomCurve3(points, false, "catmullrom", 0);
-    const mesh = new TubeMesh({
+  renderPath(e, t = this.parameters.pathColor) {
+    if (e.length < 2) return;
+    const s = new wt(e, !1, "catmullrom", 0), i = new we({
       geometryParameters: {
-        path: curve,
-        tubularSegments: points.length * 10,
+        path: s,
+        tubularSegments: e.length * 10,
         radius: this.parameters.pathRadius,
-        closed: false
+        closed: !1
       },
       materialParameters: {
-        color: color2
+        color: t
       }
     });
-    this.add(mesh);
-    this.pathMeshes.push(mesh);
-    return mesh;
+    return this.add(i), this.pathMeshes.push(i), i;
   }
   clearPaths() {
-    this.pathMeshes.forEach((m) => {
-      this.remove(m);
-      m.geometry.dispose();
-      m.material.dispose();
-    });
-    this.pathMeshes = [];
+    this.pathMeshes.forEach((e) => {
+      this.remove(e), e.geometry.dispose(), e.material.dispose();
+    }), this.pathMeshes = [];
   }
   /** Export nodes and edges as a JSON-serializable object. */
   exportData() {
-    const nodes = {};
-    this.nodes.forEach((pos, id) => {
-      nodes[id] = { x: pos.x, y: pos.y, z: pos.z };
+    const e = {};
+    this.nodes.forEach((i, n) => {
+      e[n] = { x: i.x, y: i.y, z: i.z };
     });
-    const edges = [];
-    const processed = /* @__PURE__ */ new Set();
-    this.adjacencyMap.forEach((neighbors, from) => {
-      neighbors.forEach((weight, to) => {
-        const key = [from, to].sort().join("-");
-        if (!processed.has(key)) {
-          processed.add(key);
-          edges.push({ from, to, weight });
-        }
+    const t = [], s = /* @__PURE__ */ new Set();
+    return this.adjacencyMap.forEach((i, n) => {
+      i.forEach((r, o) => {
+        const c = [n, o].sort().join("-");
+        s.has(c) || (s.add(c), t.push({ from: n, to: o, weight: r }));
       });
-    });
-    return { nodes, edges };
+    }), { nodes: e, edges: t };
   }
   /**
    * Load topology from a previously exported data object.
    * Replaces all current nodes, edges, and path meshes, then re-renders the graph.
    */
-  importData(data) {
-    this.clearGraph();
-    this.clearPaths();
-    this.nodes.clear();
-    this.adjacencyMap.clear();
-    Object.entries(data.nodes).forEach(([id, pos]) => {
-      this.addNode(id, new Vector3(pos.x, pos.y, pos.z));
-    });
-    data.edges.forEach(({ from, to, weight }) => {
-      this.addEdge(from, to, weight);
-    });
-    this.renderGraph();
+  importData(e) {
+    this.clearGraph(), this.clearPaths(), this.nodes.clear(), this.adjacencyMap.clear(), Object.entries(e.nodes).forEach(([t, s]) => {
+      this.addNode(t, new oe(s.x, s.y, s.z));
+    }), e.edges.forEach(({ from: t, to: s, weight: i }) => {
+      this.addEdge(t, s, i);
+    }), this.renderGraph();
   }
   dispose() {
-    this.clearGraph();
-    this.clearPaths();
+    this.clearGraph(), this.clearPaths();
   }
-  getNeighbors(id) {
-    return this.adjacencyMap.get(id);
+  getNeighbors(e) {
+    return this.adjacencyMap.get(e);
   }
 }
-class Poi extends BaseSprite {
-  isPoi = true;
+class ii extends Ms {
+  isPoi = !0;
   type = "Poi";
   parameters = {
     img: "",
@@ -1656,419 +1311,332 @@ class Poi extends BaseSprite {
   };
   _canvas = document.createElement("canvas");
   _lastParametersJSON = "";
-  constructor(parameters = {}) {
-    super(new SpriteNodeMaterial());
-    Object.assign(this.parameters, parameters);
-    this.updateAsync();
+  constructor(e = {}) {
+    super(new vt()), Object.assign(this.parameters, e), this.updateAsync();
   }
   /**
    * Update the POI with new parameters
    * @param parameters Partial POI parameters
    */
-  async updateAsync(parameters = {}) {
-    Object.assign(this.parameters, parameters);
-    const json = JSON.stringify(this.parameters);
-    if (json === this._lastParametersJSON) return;
-    this._lastParametersJSON = json;
-    const canvas = this._canvas;
-    const ctx = canvas.getContext("2d");
-    if (!ctx) return;
-    ctx.font = `${this.parameters.fontSize}px ${this.parameters.fontFamily}`;
-    let image = null;
-    if (this.parameters.img) {
-      image = await this._loadImage(this.parameters.img);
-    }
-    const { text, fontSize, color: color2, iconSize, padding, backgroundColor, borderRadius, textPosition, scaleFactor } = this.parameters;
-    const textMetrics = ctx.measureText(text);
-    const textWidth = text ? textMetrics.width : 0;
-    const textHeight = text ? fontSize : 0;
-    let contentWidth = 0;
-    let contentHeight = 0;
-    let iconX = 0, iconY = 0;
-    let textX = 0, textY = 0;
-    const hasImage = !!image;
-    const hasText = !!text;
-    if (hasImage && hasText) {
-      switch (textPosition) {
+  async updateAsync(e = {}) {
+    Object.assign(this.parameters, e);
+    const t = JSON.stringify(this.parameters);
+    if (t === this._lastParametersJSON) return;
+    this._lastParametersJSON = t;
+    const s = this._canvas, i = s.getContext("2d");
+    if (!i) return;
+    i.font = `${this.parameters.fontSize}px ${this.parameters.fontFamily}`;
+    let n = null;
+    this.parameters.img && (n = await this._loadImage(this.parameters.img));
+    const { text: r, fontSize: o, color: c, iconSize: h, padding: l, backgroundColor: d, borderRadius: g, textPosition: p, scaleFactor: y } = this.parameters, v = i.measureText(r), S = r ? v.width : 0, b = r ? o : 0;
+    let f = 0, T = 0, M = 0, P = 0, x = 0, m = 0;
+    const w = !!n, A = !!r;
+    if (w && A)
+      switch (p) {
         case "top":
-          contentWidth = Math.max(iconSize, textWidth);
-          contentHeight = iconSize + padding + textHeight;
-          textX = (contentWidth - textWidth) / 2;
-          textY = textHeight / 2;
-          iconX = (contentWidth - iconSize) / 2;
-          iconY = textHeight + padding;
+          f = Math.max(h, S), T = h + l + b, x = (f - S) / 2, m = b / 2, M = (f - h) / 2, P = b + l;
           break;
         case "bottom":
-          contentWidth = Math.max(iconSize, textWidth);
-          contentHeight = iconSize + padding + textHeight;
-          iconX = (contentWidth - iconSize) / 2;
-          iconY = 0;
-          textX = (contentWidth - textWidth) / 2;
-          textY = iconSize + padding + textHeight / 2;
+          f = Math.max(h, S), T = h + l + b, M = (f - h) / 2, P = 0, x = (f - S) / 2, m = h + l + b / 2;
           break;
         case "left":
-          contentWidth = iconSize + padding + textWidth;
-          contentHeight = Math.max(iconSize, textHeight);
-          textX = 0;
-          textY = contentHeight / 2;
-          iconX = textWidth + padding;
-          iconY = (contentHeight - iconSize) / 2;
+          f = h + l + S, T = Math.max(h, b), x = 0, m = T / 2, M = S + l, P = (T - h) / 2;
           break;
-        case "right":
         default:
-          contentWidth = iconSize + padding + textWidth;
-          contentHeight = Math.max(iconSize, textHeight);
-          iconX = 0;
-          iconY = (contentHeight - iconSize) / 2;
-          textX = iconSize + padding;
-          textY = contentHeight / 2;
+          f = h + l + S, T = Math.max(h, b), M = 0, P = (T - h) / 2, x = h + l, m = T / 2;
           break;
       }
-    } else if (hasImage) {
-      contentWidth = iconSize;
-      contentHeight = iconSize;
-      iconX = 0;
-      iconY = 0;
-    } else if (hasText) {
-      contentWidth = textWidth;
-      contentHeight = textHeight;
-      textX = 0;
-      textY = textHeight / 2;
-    }
-    const canvasWidth = contentWidth + padding * 2;
-    const canvasHeight = contentHeight + padding * 2;
-    canvas.width = canvasWidth;
-    canvas.height = canvasHeight;
-    ctx.font = `${fontSize}px ${this.parameters.fontFamily}`;
-    if (backgroundColor) {
-      ctx.fillStyle = backgroundColor;
-      this._drawRoundedRect(ctx, 0, 0, canvasWidth, canvasHeight, borderRadius);
-      ctx.fill();
-    }
-    if (hasImage) {
-      ctx.drawImage(image, iconX + padding, iconY + padding, iconSize, iconSize);
-    }
-    if (hasText) {
-      ctx.fillStyle = color2;
-      const metrics = ctx.measureText(text);
-      const actualTextHeight = metrics.actualBoundingBoxAscent + metrics.actualBoundingBoxDescent;
-      const baselineOffset = metrics.actualBoundingBoxAscent - actualTextHeight / 2;
-      ctx.textBaseline = "alphabetic";
-      ctx.fillText(text, textX + padding, textY + padding + baselineOffset);
-    }
-    const oldTexture = this.material.map;
-    const texture = new CanvasTexture(canvas);
-    texture.colorSpace = SRGBColorSpace;
-    this.material.map = texture;
-    oldTexture?.dispose();
-    this.scale.set(canvasWidth * scaleFactor, canvasHeight * scaleFactor, 1);
-  }
-  _loadImage(img) {
-    return new Promise((resolve, reject) => {
-      if (typeof img === "string") {
-        const _img = new Image();
-        _img.crossOrigin = "Anonymous";
-        _img.onload = () => resolve(_img);
-        _img.onerror = () => reject(new Error(`Failed to load image: ${img}`));
-        _img.src = img;
-      } else {
-        resolve(img);
-      }
+    else w ? (f = h, T = h, M = 0, P = 0) : A && (f = S, T = b, x = 0, m = b / 2);
+    const N = f + l * 2, E = T + l * 2;
+    if (s.width = N, s.height = E, i.font = `${o}px ${this.parameters.fontFamily}`, d && (i.fillStyle = d, this._drawRoundedRect(i, 0, 0, N, E, g), i.fill()), w && i.drawImage(n, M + l, P + l, h, h), A) {
+      i.fillStyle = c;
+      const _ = i.measureText(r), D = _.actualBoundingBoxAscent + _.actualBoundingBoxDescent, He = _.actualBoundingBoxAscent - D / 2;
+      i.textBaseline = "alphabetic", i.fillText(r, x + l, m + l + He);
+    }
+    const H = this.material.map, G = new bt(s);
+    G.colorSpace = Pe, this.material.map = G, H?.dispose(), this.scale.set(N * y, E * y, 1);
+  }
+  _loadImage(e) {
+    return new Promise((t, s) => {
+      if (typeof e == "string") {
+        const i = new Image();
+        i.crossOrigin = "Anonymous", i.onload = () => t(i), i.onerror = () => s(new Error(`Failed to load image: ${e}`)), i.src = e;
+      } else
+        t(e);
     });
   }
-  _drawRoundedRect(ctx, x, y, width, height, radius) {
-    ctx.beginPath();
-    ctx.moveTo(x + radius, y);
-    ctx.lineTo(x + width - radius, y);
-    ctx.quadraticCurveTo(x + width, y, x + width, y + radius);
-    ctx.lineTo(x + width, y + height - radius);
-    ctx.quadraticCurveTo(x + width, y + height, x + width - radius, y + height);
-    ctx.lineTo(x + radius, y + height);
-    ctx.quadraticCurveTo(x, y + height, x, y + height - radius);
-    ctx.lineTo(x, y + radius);
-    ctx.quadraticCurveTo(x, y, x + radius, y);
-    ctx.closePath();
+  _drawRoundedRect(e, t, s, i, n, r) {
+    e.beginPath(), e.moveTo(t + r, s), e.lineTo(t + i - r, s), e.quadraticCurveTo(t + i, s, t + i, s + r), e.lineTo(t + i, s + n - r), e.quadraticCurveTo(t + i, s + n, t + i - r, s + n), e.lineTo(t + r, s + n), e.quadraticCurveTo(t, s + n, t, s + n - r), e.lineTo(t, s + r), e.quadraticCurveTo(t, s, t + r, s), e.closePath();
   }
   dispose() {
-    this.material.map?.dispose();
-    this.material.dispose();
+    this.material.map?.dispose(), this.material.dispose();
   }
 }
-class ShapeMesh extends BaseMesh {
-  isShapeMesh = true;
+class _e extends k {
+  isShapeMesh = !0;
   type = "ShapeMesh";
-  constructor({ geometryParameters, materialParameters } = {}) {
-    super();
-    this.geometry = new ShapeGeometry(geometryParameters?.shape, geometryParameters?.curveSegments);
-    this.material = new MeshStandardNodeMaterial(materialParameters);
-    this.geometry.rotateX(-Math.PI / 2);
+  constructor({ geometryParameters: e, materialParameters: t } = {}) {
+    super(), this.geometry = new Ct(e?.shape, e?.curveSegments), this.material = new L(t), this.geometry.rotateX(-Math.PI / 2);
   }
-  static createFromPoints(points, parameters = {}) {
-    return new ShapeMesh({
-      ...parameters,
+  static createFromPoints(e, t = {}) {
+    return new _e({
+      ...t,
       geometryParameters: {
-        ...parameters.geometryParameters,
-        shape: new Shape(points.map((point) => new Vector2(point.x, -point.z)))
+        ...t.geometryParameters,
+        shape: new Oe(e.map((s) => new R(s.x, -s.z)))
       }
     });
   }
 }
-class ExtrudeMesh extends BaseMesh {
-  isExtrudeMesh = true;
+class De extends k {
+  isExtrudeMesh = !0;
   type = "ExtrudeMesh";
-  constructor({ geometryParameters, materialParameters } = {}) {
-    super();
-    this.geometry = new ExtrudeGeometry(geometryParameters?.shape, geometryParameters?.options);
-    this.material = new MeshStandardNodeMaterial(materialParameters);
-    this.geometry.rotateX(-Math.PI / 2);
+  constructor({ geometryParameters: e, materialParameters: t } = {}) {
+    super(), this.geometry = new Tt(e?.shape, e?.options), this.material = new L(t), this.geometry.rotateX(-Math.PI / 2);
   }
-  static createFromPoints(points, parameters = {}) {
-    return new ExtrudeMesh({
-      ...parameters,
+  static createFromPoints(e, t = {}) {
+    return new De({
+      ...t,
       geometryParameters: {
-        ...parameters.geometryParameters,
-        shape: new Shape(points.map((point) => new Vector2(point.x, -point.z)))
+        ...t.geometryParameters,
+        shape: new Oe(e.map((s) => new R(s.x, -s.z)))
       }
     });
   }
 }
-class PlaneMesh extends BaseMesh {
-  isPlaneMesh = true;
+class ni extends k {
+  isPlaneMesh = !0;
   type = "PlaneMesh";
-  constructor({ geometryParameters, materialParameters } = {}) {
-    super();
-    this.geometry = new PlaneGeometry(
-      geometryParameters?.width,
-      geometryParameters?.height,
-      geometryParameters?.widthSegments,
-      geometryParameters?.heightSegments
-    );
-    this.material = new MeshStandardNodeMaterial(materialParameters);
+  constructor({ geometryParameters: e, materialParameters: t } = {}) {
+    super(), this.geometry = new St(
+      e?.width,
+      e?.height,
+      e?.widthSegments,
+      e?.heightSegments
+    ), this.material = new L(t);
   }
 }
-class CircleMesh extends BaseMesh {
-  isCircleMesh = true;
+class ri extends k {
+  isCircleMesh = !0;
   type = "CircleMesh";
-  constructor({ geometryParameters, materialParameters } = {}) {
+  constructor({ geometryParameters: e, materialParameters: t } = {}) {
     super(
-      new CircleGeometry(
-        geometryParameters?.radius,
-        geometryParameters?.segments,
-        geometryParameters?.thetaStart,
-        geometryParameters?.thetaLength
+      new xt(
+        e?.radius,
+        e?.segments,
+        e?.thetaStart,
+        e?.thetaLength
       ),
-      new MeshStandardNodeMaterial(materialParameters)
-    );
-    this.geometry.rotateX(-Math.PI / 2);
+      new L(t)
+    ), this.geometry.rotateX(-Math.PI / 2);
   }
 }
-class ObjectUtils {
-  static traverseMeshes(object, callback) {
-    object.traverse((child) => {
-      if (child instanceof Mesh) {
-        callback(child);
-      }
+class W {
+  static traverseMeshes(e, t) {
+    e.traverse((s) => {
+      s instanceof z && t(s);
     });
   }
 }
-class TSLEffects {
-  static flow(parameters = {}) {
-    const { baseColor = 16777215, flowColor = 65280, speed = 1, scale = 3, intensity = 4 } = parameters;
-    const baseColorNode = color(new Color$1(baseColor));
-    const flowColorNode = color(new Color$1(flowColor));
-    const flow = uv().x.mul(scale).sub(time.mul(speed));
-    const pattern = pow(sin(flow).add(1).mul(0.5), intensity);
-    return mix(baseColorNode, flowColorNode, pattern);
-  }
-  static breathe(parameters = {}) {
-    const { baseColor = 16777215, breathColor = 65280, speed = 1, intensity = 2 } = parameters;
-    const baseColorNode = color(new Color$1(baseColor));
-    const breathColorNode = color(new Color$1(breathColor));
-    const osc = sin(time.mul(speed)).add(1).mul(0.5);
-    const pattern = pow(osc, intensity);
-    return mix(baseColorNode, breathColorNode, pattern);
-  }
-  static fluid(parameters = {}) {
+class ai {
+  static flow(e = {}) {
+    const { baseColor: t = 16777215, flowColor: s = 65280, speed: i = 1, scale: n = 3, intensity: r = 4 } = e, o = j(new U(t)), c = j(new U(s)), h = pe().x.mul(n).sub(X.mul(i)), l = q(ae(h).add(1).mul(0.5), r);
+    return Y(o, c, l);
+  }
+  static breathe(e = {}) {
+    const { baseColor: t = 16777215, breathColor: s = 65280, speed: i = 1, intensity: n = 2 } = e, r = j(new U(t)), o = j(new U(s)), c = ae(X.mul(i)).add(1).mul(0.5), h = q(c, n);
+    return Y(r, o, h);
+  }
+  static fluid(e = {}) {
     const {
-      baseColor = 16777215,
-      flowColor = 255,
-      speed = 1,
-      scale = 1,
-      intensity = 1,
-      distortion = 0.5
-    } = parameters;
-    const baseColorNode = color(new Color$1(baseColor));
-    const flowColorNode = color(new Color$1(flowColor));
-    const uvNode = uv().mul(scale);
-    const timeNode = time.mul(speed);
-    const noiseNode = mx_noise_float(uvNode.add(timeNode), 1, 0);
-    const distortedUV = uvNode.add(noiseNode.mul(distortion));
-    const pattern = mx_noise_float(distortedUV, 1, 0).add(1).mul(0.5);
-    const fluidPattern = pow(pattern, intensity);
-    return mix(baseColorNode, flowColorNode, fluidPattern);
+      baseColor: t = 16777215,
+      flowColor: s = 255,
+      speed: i = 1,
+      scale: n = 1,
+      intensity: r = 1,
+      distortion: o = 0.5
+    } = e, c = j(new U(t)), h = j(new U(s)), l = pe().mul(n), d = X.mul(i), g = ue(l.add(d), 1, 0), p = l.add(g.mul(o)), y = ue(p, 1, 0).add(1).mul(0.5), v = q(y, r);
+    return Y(c, h, v);
   }
 }
-function reinterpretType(_value) {
+function oi(a) {
 }
-const _highlightKey = "uSpaceHighlight";
-const _highlightEnabledKey = `${_highlightKey}/enabled`;
-const _highlightOpacityKey = `${_highlightKey}/opacity`;
-const _highlightColorKey = `${_highlightKey}/color`;
-const _highlightOverwriteKey = `${_highlightKey}/overwrite`;
-const _highlightColorNode = Fn(() => {
-  const enabled = userData(_highlightEnabledKey, "uint");
-  const colorUint = userData(_highlightColorKey, "uint");
-  const overwrite = userData(_highlightOverwriteKey, "uint");
-  const hlColorRaw = uintToColor(colorUint);
-  const tintedColor = materialColor.mul(hlColorRaw);
-  const finalHlColor = select(overwrite.greaterThan(0), hlColorRaw, tintedColor);
-  const hlColor = select(enabled.greaterThan(0), finalHlColor, materialColor);
-  return hlColor;
-})();
-const _highlightOpacityNode = Fn(() => {
-  const enabled = userData(_highlightEnabledKey, "uint");
-  const opacity = userData(_highlightOpacityKey, "float");
-  const hlOpacity = select(enabled.greaterThan(0), opacity, materialOpacity);
-  return hlOpacity;
+const ie = "uSpaceHighlight", F = `${ie}/enabled`, je = `${ie}/opacity`, Ue = `${ie}/color`, ke = `${ie}/overwrite`, ne = "uSpaceBreathe", te = `${ne}/enabled`, Ge = `${ne}/color`, Fe = `${ne}/speed`, ze = `${ne}/intensity`, se = /* @__PURE__ */ new WeakMap(), Os = Re(() => {
+  const a = O(F, "uint"), e = O(Ue, "uint"), t = O(ke, "uint"), s = Ce(e), i = me.mul(s), n = J(t.greaterThan(0), s, i), r = J(a.greaterThan(0), n, me), o = O(te, "uint"), c = O(Ge, "uint"), h = O(Fe, "float"), l = O(ze, "float"), d = Ce(c), g = ae(X.mul(h)).add(1).mul(0.5), p = q(g, l), y = Y(r, d, p);
+  return J(o.greaterThan(0), y, r);
+})(), Rs = Re(() => {
+  const a = O(F, "uint"), e = O(je, "float");
+  return J(a.greaterThan(0), e, Lt);
 })();
-class MaterialEffects {
-  static highlight(object, options = {}) {
-    const highlightOptions = Object.assign(
+function ve(a) {
+  const e = a.material;
+  if (!e || Array.isArray(e)) return;
+  let t = se.get(e);
+  t || (t = {
+    colorNode: e.colorNode,
+    opacityNode: e.opacityNode,
+    transparent: e.transparent,
+    activeMeshes: /* @__PURE__ */ new Set()
+  }, se.set(e, t)), t.activeMeshes.add(a), e.transparent = !0, e.colorNode = Os, e.opacityNode = Rs, e.needsUpdate = !0;
+}
+function be(a) {
+  const e = a.userData[F], t = a.userData[te];
+  if (e || t) return;
+  const s = a.material;
+  if (!s || Array.isArray(s)) return;
+  const i = se.get(s);
+  i && (i.activeMeshes.delete(a), !(i.activeMeshes.size > 0) && (s.colorNode = i.colorNode, s.opacityNode = i.opacityNode, s.transparent = i.transparent, s.needsUpdate = !0, se.delete(s)));
+}
+class ci {
+  static highlightColor(e, t = {}) {
+    const s = Array.isArray(e) ? e : [e], i = Object.assign(
       {
-        enabled: true,
         opacity: 0.5,
         color: 16711680,
-        overwrite: false
+        overwrite: !1
       },
-      options
+      t
     );
-    highlightOptions.color = new Color(highlightOptions.color).getHex();
-    ObjectUtils.traverseMeshes(object, (mesh) => {
-      mesh.userData[_highlightEnabledKey] = highlightOptions.enabled ? 1 : 0;
-      mesh.userData[_highlightOpacityKey] = highlightOptions.opacity;
-      mesh.userData[_highlightColorKey] = highlightOptions.color;
-      mesh.userData[_highlightOverwriteKey] = highlightOptions.overwrite ? 1 : 0;
-      const material = mesh.material;
-      if (material && !Array.isArray(material)) {
-        material.transparent = true;
-        material.colorNode = _highlightColorNode;
-        material.opacityNode = _highlightOpacityNode;
-        material.needsUpdate = true;
-      }
-    });
+    i.color = new V(i.color).getHex();
+    for (const n of s)
+      W.traverseMeshes(n, (r) => {
+        r.userData[F] = 1, r.userData[je] = i.opacity, r.userData[Ue] = i.color, r.userData[ke] = i.overwrite ? 1 : 0, ve(r);
+      });
+  }
+  static removeHighlightColor(e) {
+    const t = Array.isArray(e) ? e : [e];
+    for (const s of t)
+      W.traverseMeshes(s, (i) => {
+        i.userData[F] = 0, be(i);
+      });
+  }
+  static breatheColor(e, t = {}) {
+    const s = Array.isArray(e) ? e : [e], i = Object.assign(
+      {
+        color: 65280,
+        speed: 1,
+        intensity: 2
+      },
+      t
+    );
+    i.color = new V(i.color).getHex();
+    for (const n of s)
+      W.traverseMeshes(n, (r) => {
+        r.userData[te] = 1, r.userData[Ge] = i.color, r.userData[Fe] = i.speed, r.userData[ze] = i.intensity, ve(r);
+      });
+  }
+  static removeBreatheColor(e) {
+    const t = Array.isArray(e) ? e : [e];
+    for (const s of t)
+      W.traverseMeshes(s, (i) => {
+        i.userData[te] = 0, be(i);
+      });
   }
 }
-const uintToColor = (colorUint) => {
-  const r = colorUint.shiftRight(16).bitAnd(255).toFloat().div(255);
-  const g = colorUint.shiftRight(8).bitAnd(255).toFloat().div(255);
-  const b = colorUint.bitAnd(255).toFloat().div(255);
-  return vec3(r, g, b);
+const Ce = (a) => {
+  const e = a.shiftRight(16).bitAnd(255).toFloat().div(255), t = a.shiftRight(8).bitAnd(255).toFloat().div(255), s = a.bitAnd(255).toFloat().div(255);
+  return At(e, t, s);
 };
-class Tween extends Tween$1 {
+class Is extends Yt {
   viewer;
-  constructor(viewer, source) {
-    super(source);
-    this.viewer = viewer;
-  }
-  _update = ({ time: time2 }) => {
-    const needsRender = this.update(time2);
-    if (needsRender) {
-      this.viewer.render();
-    }
+  constructor(e, t) {
+    super(t), this.viewer = e;
+  }
+  _update = ({ time: e }) => {
+    this.update(e) && this.viewer.render();
   };
-  easingByMode(mode) {
-    const tweenModeFunc = animationModeEnum[mode];
-    return super.easing(tweenModeFunc);
+  easingByMode(e) {
+    const t = Ls[e];
+    return super.easing(t);
   }
-  start(time2, overrideStartingValues) {
-    this.viewer.addEventListener("afterControlsUpdate", this._update);
-    return super.start(time2, overrideStartingValues);
+  start(e, t) {
+    return this.viewer.addEventListener("afterControlsUpdate", this._update), super.start(e, t);
   }
   stop() {
-    this.viewer.removeEventListener("afterControlsUpdate", this._update);
-    return super.stop();
+    return this.viewer.removeEventListener("afterControlsUpdate", this._update), super.stop();
   }
 }
-function tweenAnimation(viewer, source, target, options = {}, onUpdate, onStart) {
-  return new Promise((resolve, reject) => {
-    const { duration = 1e3, delay = 0, repeat = false, mode = "Linear.None", yoyo = false } = options;
-    const tween = new Tween(viewer, source).to(target, duration).easingByMode(mode).delay(delay).onUpdate((e) => {
-      onUpdate?.(e, tween);
+function hi(a, e, t, s = {}, i, n) {
+  return new Promise((r, o) => {
+    const { duration: c = 1e3, delay: h = 0, repeat: l = !1, mode: d = "Linear.None", yoyo: g = !1 } = s, p = new Is(a, e).to(t, c).easingByMode(d).delay(h).onUpdate((y) => {
+      i?.(y, p);
     }).onComplete(() => {
-      resolve();
+      r();
     }).onStop(() => {
-      reject("animation stop");
+      o("animation stop");
     }).onStart(() => {
-      onStart?.(tween);
+      n?.(p);
     });
-    if (typeof repeat === "number") tween.repeat(repeat);
-    else if (typeof repeat === "boolean" && repeat) tween.repeat(Infinity);
-    if (yoyo) tween.repeatDelay(20);
-    tween.yoyo(yoyo);
-    tween.start();
+    typeof l == "number" ? p.repeat(l) : typeof l == "boolean" && l && p.repeat(1 / 0), g && p.repeatDelay(20), p.yoyo(g), p.start();
   });
 }
-const animationModeEnum = {
-  "Linear.None": Easing.Linear.None,
-  "Quadratic.In": Easing.Quadratic.In,
-  "Quadratic.Out": Easing.Quadratic.Out,
-  "Quadratic.InOut": Easing.Quadratic.InOut,
-  "Cubic.In": Easing.Cubic.In,
-  "Cubic.Out": Easing.Cubic.Out,
-  "Cubic.InOut": Easing.Cubic.InOut,
-  "Quartic.In": Easing.Quartic.In,
-  "Quartic.Out": Easing.Quartic.Out,
-  "Quartic.InOut": Easing.Quartic.InOut,
-  "Quintic.In": Easing.Quintic.In,
-  "Quintic.Out": Easing.Quintic.Out,
-  "Quintic.InOut": Easing.Quintic.InOut,
-  "Sinusoidal.In": Easing.Sinusoidal.In,
-  "Sinusoidal.Out": Easing.Sinusoidal.Out,
-  "Sinusoidal.InOut": Easing.Sinusoidal.InOut,
-  "Exponential.In": Easing.Exponential.In,
-  "Exponential.Out": Easing.Exponential.Out,
-  "Exponential.InOut": Easing.Exponential.InOut,
-  "Circular.In": Easing.Circular.In,
-  "Circular.Out": Easing.Circular.Out,
-  "Circular.InOut": Easing.Circular.InOut,
-  "Elastic.In": Easing.Elastic.In,
-  "Elastic.Out": Easing.Elastic.Out,
-  "Elastic.InOut": Easing.Elastic.InOut,
-  "Back.In": Easing.Back.In,
-  "Back.Out": Easing.Back.Out,
-  "Back.InOut": Easing.Back.InOut,
-  "Bounce.In": Easing.Bounce.In,
-  "Bounce.Out": Easing.Bounce.Out,
-  "Bounce.InOut": Easing.Bounce.InOut
-};
+const Ls = {
+  "Linear.None": u.Linear.None,
+  "Quadratic.In": u.Quadratic.In,
+  "Quadratic.Out": u.Quadratic.Out,
+  "Quadratic.InOut": u.Quadratic.InOut,
+  "Cubic.In": u.Cubic.In,
+  "Cubic.Out": u.Cubic.Out,
+  "Cubic.InOut": u.Cubic.InOut,
+  "Quartic.In": u.Quartic.In,
+  "Quartic.Out": u.Quartic.Out,
+  "Quartic.InOut": u.Quartic.InOut,
+  "Quintic.In": u.Quintic.In,
+  "Quintic.Out": u.Quintic.Out,
+  "Quintic.InOut": u.Quintic.InOut,
+  "Sinusoidal.In": u.Sinusoidal.In,
+  "Sinusoidal.Out": u.Sinusoidal.Out,
+  "Sinusoidal.InOut": u.Sinusoidal.InOut,
+  "Exponential.In": u.Exponential.In,
+  "Exponential.Out": u.Exponential.Out,
+  "Exponential.InOut": u.Exponential.InOut,
+  "Circular.In": u.Circular.In,
+  "Circular.Out": u.Circular.Out,
+  "Circular.InOut": u.Circular.InOut,
+  "Elastic.In": u.Elastic.In,
+  "Elastic.Out": u.Elastic.Out,
+  "Elastic.InOut": u.Elastic.InOut,
+  "Back.In": u.Back.In,
+  "Back.Out": u.Back.Out,
+  "Back.InOut": u.Back.InOut,
+  "Bounce.In": u.Bounce.In,
+  "Bounce.Out": u.Bounce.Out,
+  "Bounce.InOut": u.Bounce.InOut
+}, As = "0.0.5";
+window.__USPACE__ = { version: As };
 export {
-  BaseGroup,
-  BaseMesh,
-  BaseSprite,
-  CameraControls,
-  CircleMesh,
-  ExtrudeMesh,
-  InteractionEvent,
-  InteractionManager,
-  MaterialEffects,
-  Model,
-  ModelLoaderManager,
-  ObjectManager,
-  ObjectUtils,
-  PlaneMesh,
-  Poi,
-  RoomEnvironment,
-  SBMLoader,
-  SBMXLoader,
-  ShapeMesh,
-  SphereMesh,
-  TSLEffects,
-  TextureLoaderManager,
-  Topology,
-  TubeMesh,
-  Tween,
-  Viewer,
-  reinterpretType,
-  tweenAnimation
+  Be as BaseGroup,
+  k as BaseMesh,
+  Ms as BaseSprite,
+  pi as CSS2DObject,
+  mi as CSS3DObject,
+  gi as CSS3DSprite,
+  cs as CSSRenderer,
+  ss as CameraControls,
+  ri as CircleMesh,
+  De as ExtrudeMesh,
+  Jt as InteractionEvent,
+  Zt as InteractionManager,
+  ci as MaterialEffects,
+  Z as Model,
+  B as ModelLoaderManager,
+  Vt as ObjectManager,
+  W as ObjectUtils,
+  ni as PlaneMesh,
+  ii as Poi,
+  es as RenderPipeline,
+  ns as RoomEnvironment,
+  Es as SBMLoader,
+  ls as SBMXLoader,
+  _e as ShapeMesh,
+  Ps as SphereMesh,
+  ai as TSLEffects,
+  ti as TextureLoaderManager,
+  si as Topology,
+  we as TubeMesh,
+  Is as Tween,
+  ei as Viewer,
+  oi as reinterpretType,
+  hi as tweenAnimation,
+  As as version
 };
-//# sourceMappingURL=index.js.map