u-space 0.0.5 → 0.0.9

package/dist/index.js

@@ -1,20 +1,27 @@
-import { Raycaster as me, Vector2 as S, RenderPipeline as Ae, Sphere as ge, Box3 as fe, Spherical as T, Matrix4 as Re, Quaternion as _e, Vector4 as Ne, Vector3 as ee, MathUtils as Ue, PMREMGenerator as De, OrthographicCamera as $, TimestampQuery as je, Cache as ke, EventDispatcher as Ge, Timer as Fe, PerspectiveCamera as X, WebGPURenderer as He, PCFShadowMap as ze, AgXToneMapping as $e, Scene as We, Color as te, MeshStandardNodeMaterial as I, Loader as Qe, LoaderUtils as L, FileLoader as we, TextureLoader as ye, Group as Q, SRGBColorSpace as ve, RepeatWrapping as ne, BufferGeometry as Ke, BufferAttribute as ie, Mesh as F, FrontSide as Xe, BackSide as qe, DoubleSide as Ye, REVISION as re, CubeTextureLoader as Je, EquirectangularReflectionMapping as Ze, Sprite as Ve, AnimationMixer as et, LoopRepeat as tt, LoopOnce as st, SphereGeometry as nt, TubeGeometry as it, LineCurve3 as rt, CatmullRomCurve3 as at, SpriteNodeMaterial as ot, CanvasTexture as ct, ShapeGeometry as ht, Shape as be, ExtrudeGeometry as lt, PlaneGeometry as dt, CircleGeometry as pt } from "three/webgpu";
-import { pass as Z, blendColor as ut, color as U, uv as ae, time as q, pow as Y, sin as oe, mix as J, mx_noise_float as ce, Fn as Te, userData as G, materialColor as he, select as V, materialOpacity as mt, vec3 as gt } from "three/tsl";
-import Ce from "camera-controls";
-import { RoomEnvironment as ft } from "three/addons/environments/RoomEnvironment.js";
-import { ViewHelper as wt } from "three/addons/helpers/ViewHelper.js";
-import { GLTFLoader as xe } from "three/addons/loaders/GLTFLoader.js";
-import { FBXLoader as yt } from "three/addons/loaders/FBXLoader.js";
-import { OBJLoader as vt } from "three/addons/loaders/OBJLoader.js";
-import { STLLoader as bt } from "three/addons/loaders/STLLoader.js";
-import { DRACOLoader as Tt } from "three/addons/loaders/DRACOLoader.js";
-import { KTX2Loader as Ct } from "three/addons/loaders/KTX2Loader.js";
-import { MeshoptDecoder as le } from "three/addons/libs/meshopt_decoder.module.js";
-import { HDRLoader as xt } from "three/addons/loaders/HDRLoader.js";
-import { clone as Mt } from "three/addons/utils/SkeletonUtils.js";
-import { Color as D } from "three";
-import { Easing as d, Tween as Et } from "three/addons/libs/tween.module.js";
-class Ot {
+import { Raycaster as Be, Vector2 as S, EventDispatcher as Le, Box2 as tt, Matrix4 as Ie, Vector3 as w, Box3 as q, Scene as Re, Color as B, AmbientLight as st, DirectionalLight as ue, PointLight as me, SpotLight as ge, HemisphereLight as fe, DirectionalLightHelper as nt, PointLightHelper as it, SpotLightHelper as rt, HemisphereLightHelper as ot, RenderPipeline as at, PerspectiveCamera as J, Sphere as ze, Spherical as C, Quaternion as ct, Vector4 as ht, MathUtils as lt, PMREMGenerator as dt, OrthographicCamera as V, TimestampQuery as pt, Cache as ut, Timer as mt, WebGPURenderer as gt, PCFShadowMap as ft, AgXToneMapping as yt, Fog as wt, FogExp2 as bt, MeshStandardNodeMaterial as R, Loader as vt, LoaderUtils as L, FileLoader as Ne, TextureLoader as je, Group as I, SRGBColorSpace as De, RepeatWrapping as ye, BufferGeometry as K, BufferAttribute as we, Mesh as G, FrontSide as xt, BackSide as St, DoubleSide as Ct, REVISION as be, CubeTextureLoader as _t, EquirectangularReflectionMapping as Mt, Sprite as Tt, AnimationMixer as Pt, LoopRepeat as Et, LoopOnce as Ot, SphereGeometry as At, TubeGeometry as Bt, LineCurve3 as Lt, CatmullRomCurve3 as It, SpriteNodeMaterial as Rt, CanvasTexture as zt, ShapeGeometry as Nt, Shape as ke, ExtrudeGeometry as jt, PlaneGeometry as Dt, CircleGeometry as kt, ClippingGroup as Ht, Plane as Ut, PlaneHelper as Ft, LineBasicMaterial as Z, Line as ee } from "three/webgpu";
+import { pass as de, mrt as Gt, output as $t, add as ve, blendColor as Wt, emissive as Kt, normalView as Qt, velocity as qt, color as H, uv as xe, time as te, pow as se, sin as pe, mix as ne, mx_noise_float as Se, Fn as He, userData as A, materialColor as Ce, select as ie, materialOpacity as Xt, vec3 as Yt } from "three/tsl";
+import { bloom as Jt } from "three/addons/tsl/display/BloomNode.js";
+import { ssgi as Vt } from "three/addons/tsl/display/SSGINode.js";
+import { traa as Zt } from "three/addons/tsl/display/TRAANode.js";
+import Ue from "camera-controls";
+import { RoomEnvironment as es } from "three/addons/environments/RoomEnvironment.js";
+import { ViewHelper as ts } from "three/addons/helpers/ViewHelper.js";
+import { CSS2DRenderer as ss, CSS2DObject as ns } from "three/addons/renderers/CSS2DRenderer.js";
+import { CSS2DObject as Nn } from "three/addons/renderers/CSS2DRenderer.js";
+import { CSS3DRenderer as is, CSS3DSprite as rs, CSS3DObject as os } from "three/addons/renderers/CSS3DRenderer.js";
+import { CSS3DObject as Dn, CSS3DSprite as kn } from "three/addons/renderers/CSS3DRenderer.js";
+import { GLTFLoader as Fe } from "three/addons/loaders/GLTFLoader.js";
+import { FBXLoader as as } from "three/addons/loaders/FBXLoader.js";
+import { OBJLoader as cs } from "three/addons/loaders/OBJLoader.js";
+import { STLLoader as hs } from "three/addons/loaders/STLLoader.js";
+import { DRACOLoader as ls } from "three/addons/loaders/DRACOLoader.js";
+import { KTX2Loader as ds } from "three/addons/loaders/KTX2Loader.js";
+import { MeshoptDecoder as _e } from "three/addons/libs/meshopt_decoder.module.js";
+import { HDRLoader as ps } from "three/addons/loaders/HDRLoader.js";
+import { clone as us } from "three/addons/utils/SkeletonUtils.js";
+import { Color as U } from "three";
+import { Easing as m, Tween as ms } from "three/addons/libs/tween.module.js";
+class gs {
   /** The type of event (e.g., 'click', 'pointerdown'). */
   type;
   /** The original 3D object that triggered the event. */
@@ -42,11 +49,11 @@ class Ot {
     return this._propagationStopped;
   }
 }
-class Pt {
+class fs {
   domElement;
   scene;
   camera;
-  raycaster = new me();
+  raycaster = new Be();
   pointer = new S();
   hoveredObject = null;
   pointerDownTime = 0;
@@ -63,6 +70,14 @@ class Pt {
    * Disabled by default for performance optimization.
    */
   pointerMoveEventsEnabled = !1;
+  /**
+   * Whether interaction is enabled globally.
+   */
+  _enabled = !0;
+  /**
+   * Objects excluded from raycasting (via addIgnore or setInteractable(false)).
+   */
+  _excludeSet = /* @__PURE__ */ new Set();
   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();
   }
@@ -72,6 +87,39 @@ class Pt {
   setCamera(e) {
     this.camera = e;
   }
+  /**
+   * Enable all interactions.
+   */
+  enable() {
+    this._enabled = !0;
+  }
+  /**
+   * Disable all interactions.
+   */
+  disable() {
+    this._enabled = !1;
+  }
+  /**
+   * Set whether a specific object is interactable.
+   * When set to false, the object and its children are excluded from raycasting.
+   */
+  setInteractable(e, t) {
+    t ? this._excludeSet.delete(e) : this._excludeSet.add(e);
+  }
+  /**
+   * Add an object to the exclude list (will not receive any events).
+   * Alias for `setInteractable(object, false)`.
+   */
+  addIgnore(e) {
+    this._excludeSet.add(e);
+  }
+  /**
+   * Remove an object from the exclude list.
+   * Alias for `setInteractable(object, true)`.
+   */
+  removeIgnore(e) {
+    this._excludeSet.delete(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);
   }
@@ -80,13 +128,23 @@ class Pt {
     this.pointer.x = (e.clientX - t.left) / t.width * 2 - 1, this.pointer.y = -((e.clientY - t.top) / t.height) * 2 + 1;
   }
   _getIntersects() {
-    return this.raycaster.setFromCamera(this.pointer, this.camera), this.raycaster.intersectObjects(this.targetObjects, !0);
+    this.raycaster.setFromCamera(this.pointer, this.camera);
+    const e = this.raycaster.intersectObjects(this.targetObjects, !0);
+    return this._excludeSet.size > 0 ? e.filter((t) => {
+      let s = t.object;
+      for (; s; ) {
+        if (this._excludeSet.has(s))
+          return !1;
+        s = s.parent;
+      }
+      return !0;
+    }) : e;
   }
   /**
    * Dispatches an event to the target object and bubbles up the parent chain.
    */
   _dispatchToTarget(e, t, s, n) {
-    const i = new Ot({
+    const i = new gs({
       type: e,
       target: t,
       intersect: s,
@@ -100,6 +158,7 @@ class Pt {
    * Handles a DOM event by raycasting and dispatching to the first intersected object.
    */
   _handleEvent(e, t) {
+    if (!this._enabled) return;
     this._updatePointer(t);
     const s = this._getIntersects();
     if (s.length === 0) return;
@@ -135,7 +194,7 @@ class Pt {
     this._handleEvent("pointerup", e);
   };
   _onPointerMove = (e) => {
-    if (!this.pointerMoveEventsEnabled) return;
+    if (!this._enabled || !this.pointerMoveEventsEnabled) return;
     this._updatePointer(e);
     const t = this._getIntersects(), s = t.length > 0 ? t[0].object : null, n = t.length > 0 ? t[0] : null;
     this.hoveredObject !== s && (this.hoveredObject && this._dispatchToTarget("pointerleave", this.hoveredObject, null, e), this.hoveredObject = s, s && n && this._dispatchToTarget("pointerenter", s, n, e)), s && n && this._dispatchToTarget("pointermove", s, n, e);
@@ -144,10 +203,146 @@ class Pt {
    * 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.clickTimer && (clearTimeout(this.clickTimer), this.clickTimer = null), this.hoveredObject = null, this._excludeSet.clear();
+  }
+}
+class bn extends Le {
+  scene;
+  camera;
+  domElement;
+  /** The container element for the selection box overlay (domElement's parent). */
+  _container;
+  _selected = /* @__PURE__ */ new Set();
+  // Box selection state
+  _boxSelectionEnabled = !1;
+  _isSelecting = !1;
+  _startPoint = new S();
+  _endPoint = new S();
+  _selectionBox = null;
+  _deep = !0;
+  /**
+   * Objects available for selection (defaults to scene.children).
+   */
+  targetObjects = null;
+  constructor(e, t, s) {
+    super(), this.domElement = e, this._container = e.parentElement ?? e, this.scene = t, this.camera = s;
+  }
+  get selected() {
+    return this._selected;
+  }
+  get selectedArray() {
+    return Array.from(this._selected);
+  }
+  /**
+   * Select one or more objects.
+   */
+  select(e) {
+    const t = Array.isArray(e) ? e : [e], s = [];
+    for (const n of t)
+      this._selected.has(n) || (this._selected.add(n), s.push(n));
+    s.length > 0 && (this.dispatchEvent({ type: "select", objects: s }), this.dispatchEvent({ type: "change", selected: this._selected }));
+  }
+  /**
+   * Deselect one or more objects.
+   */
+  deselect(e) {
+    const t = Array.isArray(e) ? e : [e], s = [];
+    for (const n of t)
+      this._selected.delete(n) && s.push(n);
+    s.length > 0 && (this.dispatchEvent({ type: "deselect", objects: s }), this.dispatchEvent({ type: "change", selected: this._selected }));
+  }
+  /**
+   * Toggle selection of an object.
+   */
+  toggle(e) {
+    this._selected.has(e) ? this.deselect(e) : this.select(e);
+  }
+  /**
+   * Clear all selections.
+   */
+  clear() {
+    if (this._selected.size === 0) return;
+    const e = Array.from(this._selected);
+    this._selected.clear(), this.dispatchEvent({ type: "deselect", objects: e }), this.dispatchEvent({ type: "change", selected: this._selected });
+  }
+  /**
+   * Check if an object is selected.
+   */
+  isSelected(e) {
+    return this._selected.has(e);
+  }
+  /**
+   * Enable rubber-band box selection mode.
+   */
+  enableBoxSelection(e = {}) {
+    this._boxSelectionEnabled || (this._boxSelectionEnabled = !0, this._deep = e.deep ?? !0, this._selectionBox = document.createElement("div"), this._selectionBox.style.cssText = `
+      position: absolute;
+      border: 1px dashed #55aaff;
+      background: rgba(75, 160, 255, 0.15);
+      pointer-events: none;
+      display: none;
+      z-index: 9999;
+    `, e.className && (this._selectionBox.className = e.className), this._container.style.position = this._container.style.position || "relative", this._container.appendChild(this._selectionBox), this.domElement.addEventListener("pointerdown", this._onBoxPointerDown), this.domElement.addEventListener("pointermove", this._onBoxPointerMove), this.domElement.addEventListener("pointerup", this._onBoxPointerUp));
+  }
+  /**
+   * Disable box selection mode.
+   */
+  disableBoxSelection() {
+    this._boxSelectionEnabled && (this._boxSelectionEnabled = !1, this.domElement.removeEventListener("pointerdown", this._onBoxPointerDown), this.domElement.removeEventListener("pointermove", this._onBoxPointerMove), this.domElement.removeEventListener("pointerup", this._onBoxPointerUp), this._selectionBox && (this._selectionBox.remove(), this._selectionBox = null));
+  }
+  setCamera(e) {
+    this.camera = e;
+  }
+  _onBoxPointerDown = (e) => {
+    if (e.button !== 0) return;
+    this._isSelecting = !0;
+    const t = this._container.getBoundingClientRect();
+    this._startPoint.set(e.clientX - t.left, e.clientY - t.top), this._endPoint.copy(this._startPoint), this._selectionBox && (this._selectionBox.style.display = "block", this._updateBoxElement());
+  };
+  _onBoxPointerMove = (e) => {
+    if (!this._isSelecting) return;
+    const t = this._container.getBoundingClientRect();
+    this._endPoint.set(e.clientX - t.left, e.clientY - t.top), this._updateBoxElement();
+  };
+  _onBoxPointerUp = () => {
+    if (!this._isSelecting) return;
+    this._isSelecting = !1, this._selectionBox && (this._selectionBox.style.display = "none");
+    const e = this._getObjectsInBox();
+    this.clear(), e.length > 0 && this.select(e);
+  };
+  _updateBoxElement() {
+    if (!this._selectionBox) return;
+    const e = Math.min(this._startPoint.x, this._endPoint.x), t = Math.min(this._startPoint.y, this._endPoint.y), s = Math.abs(this._endPoint.x - this._startPoint.x), n = Math.abs(this._endPoint.y - this._startPoint.y);
+    this._selectionBox.style.left = `${e}px`, this._selectionBox.style.top = `${t}px`, this._selectionBox.style.width = `${s}px`, this._selectionBox.style.height = `${n}px`;
+  }
+  _getObjectsInBox() {
+    const e = this._container.getBoundingClientRect(), t = e.width, s = e.height, n = new S(
+      this._startPoint.x / t * 2 - 1,
+      -(this._startPoint.y / s) * 2 + 1
+    ), i = new S(
+      this._endPoint.x / t * 2 - 1,
+      -(this._endPoint.y / s) * 2 + 1
+    ), r = new tt(
+      new S(Math.min(n.x, i.x), Math.min(n.y, i.y)),
+      new S(Math.max(n.x, i.x), Math.max(n.y, i.y))
+    ), o = this.targetObjects || this.scene.children, a = [], c = new Ie();
+    c.multiplyMatrices(this.camera.projectionMatrix, this.camera.matrixWorldInverse);
+    const h = (d) => {
+      if (!d.visible) return;
+      const p = new w();
+      if (p.setFromMatrixPosition(d.matrixWorld), p.applyMatrix4(c), p.z > -1 && p.z < 1 && r.containsPoint(new S(p.x, p.y)) && a.push(d), this._deep)
+        for (const u of d.children)
+          h(u);
+    };
+    for (const d of o)
+      h(d);
+    return a;
+  }
+  dispose() {
+    this.disableBoxSelection(), this._selected.clear();
   }
 }
-class St {
+class ys {
   idMap = /* @__PURE__ */ new Map();
   nameMap = /* @__PURE__ */ new Map();
   typeMap = /* @__PURE__ */ new Map();
@@ -249,55 +444,416 @@ class St {
   get size() {
     return this.allObjects.size;
   }
+  /**
+   * Show an object by id.
+   */
+  show(e) {
+    const t = this.idMap.get(e);
+    t && (t.visible = !0);
+  }
+  /**
+   * Hide an object by id.
+   */
+  hide(e) {
+    const t = this.idMap.get(e);
+    t && (t.visible = !1);
+  }
+  /**
+   * Show only the specified objects, hide all others.
+   */
+  isolate(e) {
+    const t = new Set(e);
+    for (const [s, n] of this.idMap)
+      n.visible = t.has(s);
+  }
+  /**
+   * Set the opacity of an object's materials.
+   */
+  setOpacity(e, t) {
+    const s = this.idMap.get(e);
+    s && s.traverse((n) => {
+      if (!n.isMesh) return;
+      const i = n.material;
+      if (!i) return;
+      const r = Array.isArray(i) ? i : [i];
+      for (const o of r)
+        o.transparent = t < 1, o.opacity = t, o.needsUpdate = !0;
+    });
+  }
+  /**
+   * Get the bounding box of an object by id, or all objects if no id provided.
+   */
+  getBoundingBox(e) {
+    const t = new q();
+    if (e) {
+      const s = this.idMap.get(e);
+      s && t.setFromObject(s);
+    } else
+      for (const s of this.allObjects)
+        t.expandByObject(s);
+    return t;
+  }
+  /**
+   * Iterate over all managed objects.
+   */
+  forEach(e) {
+    for (const t of this.allObjects) {
+      const s = this.objectIds.get(t) || /* @__PURE__ */ new Set();
+      e(t, s);
+    }
+  }
+  /**
+   * Filter objects by a predicate.
+   */
+  filter(e) {
+    const t = [];
+    for (const s of this.allObjects)
+      e(s) && t.push(s);
+    return t;
+  }
+  /**
+   * Show all managed objects.
+   */
+  showAll() {
+    for (const e of this.allObjects)
+      e.visible = !0;
+  }
 }
-class Lt extends Ae {
+class vn {
+  scenes = /* @__PURE__ */ new Map();
+  _activeSceneKey = null;
+  /**
+   * Add a scene with a key.
+   */
+  add(e, t) {
+    this.scenes.set(e, t);
+  }
+  /**
+   * Create and register a new scene.
+   */
+  create(e, t = {}) {
+    const s = new Re();
+    return t.background !== void 0 && (s.background = new B(t.background)), this.scenes.set(e, s), s;
+  }
+  /**
+   * Get a scene by key.
+   */
+  get(e) {
+    return this.scenes.get(e);
+  }
+  /**
+   * Remove a scene by key.
+   */
+  remove(e) {
+    this.scenes.delete(e), this._activeSceneKey === e && (this._activeSceneKey = null);
+  }
+  /**
+   * Get the currently active scene key.
+   */
+  get activeKey() {
+    return this._activeSceneKey;
+  }
+  /**
+   * Set the active scene key (for external use to track which scene is active).
+   */
+  set activeKey(e) {
+    this._activeSceneKey = e;
+  }
+  /**
+   * List all registered scene keys.
+   */
+  keys() {
+    return Array.from(this.scenes.keys());
+  }
+  /**
+   * Serialize scene metadata to JSON (children names/ids, background, etc.).
+   */
+  serialize(e) {
+    const t = this.scenes.get(e);
+    if (!t) return null;
+    let s = null;
+    return t.background instanceof B && (s = `#${t.background.getHexString()}`), {
+      name: t.name || e,
+      background: s,
+      environmentRotation: {
+        x: t.environmentRotation?.x ?? 0,
+        y: t.environmentRotation?.y ?? 0,
+        z: t.environmentRotation?.z ?? 0
+      },
+      children: t.children.map((n) => n.name || n.uuid)
+    };
+  }
+  /**
+   * Clear all scenes.
+   */
+  clear() {
+    this.scenes.clear(), this._activeSceneKey = null;
+  }
+  get size() {
+    return this.scenes.size;
+  }
+}
+class xn {
+  scene;
+  lights = /* @__PURE__ */ new Map();
+  helpers = /* @__PURE__ */ new Map();
+  constructor(e) {
+    this.scene = e;
+  }
+  addAmbient(e, t = {}) {
+    const { color: s = 16777215, intensity: n = 0.5 } = t, i = new st(s, n);
+    return i.name = e, this._register(e, i), i;
+  }
+  addDirectional(e, t = {}) {
+    const { color: s = 16777215, intensity: n = 1, position: i = { x: 5, y: 10, z: 5 }, castShadow: r = !1, shadowMapSize: o = 1024 } = t, a = new ue(s, n);
+    return a.position.set(i.x, i.y, i.z), a.castShadow = r, r && a.shadow.mapSize.setScalar(o), a.name = e, this._register(e, a), a;
+  }
+  addPoint(e, t = {}) {
+    const { color: s = 16777215, intensity: n = 1, distance: i = 0, decay: r = 2, position: o = { x: 0, y: 5, z: 0 }, castShadow: a = !1 } = t, c = new me(s, n, i, r);
+    return c.position.set(o.x, o.y, o.z), c.castShadow = a, c.name = e, this._register(e, c), c;
+  }
+  addSpot(e, t = {}) {
+    const {
+      color: s = 16777215,
+      intensity: n = 1,
+      distance: i = 0,
+      angle: r = Math.PI / 6,
+      penumbra: o = 0.1,
+      decay: a = 2,
+      position: c = { x: 0, y: 10, z: 0 },
+      target: h,
+      castShadow: d = !1
+    } = t, p = new ge(s, n, i, r, o, a);
+    return p.position.set(c.x, c.y, c.z), h && p.target.position.set(h.x, h.y, h.z), p.castShadow = d, p.name = e, this._register(e, p), p;
+  }
+  addHemisphere(e, t = {}) {
+    const { skyColor: s = 8900331, groundColor: n = 3549447, intensity: i = 0.6 } = t, r = new fe(s, n, i);
+    return r.name = e, this._register(e, r), r;
+  }
+  /**
+   * Apply a lighting preset to the scene.
+   */
+  applyPreset(e) {
+    switch (this.removeAll(), e) {
+      case "indoor":
+        this.addAmbient("preset_ambient", { intensity: 0.4 }), this.addPoint("preset_point1", { position: { x: 0, y: 3, z: 0 }, intensity: 1, castShadow: !0 }), this.addPoint("preset_point2", { position: { x: 3, y: 2, z: -3 }, intensity: 0.5 });
+        break;
+      case "outdoor":
+        this.addHemisphere("preset_hemi", { skyColor: 8900331, groundColor: 3549447, intensity: 0.6 }), this.addDirectional("preset_sun", { position: { x: 10, y: 20, z: 10 }, intensity: 1.5, castShadow: !0, shadowMapSize: 2048 });
+        break;
+      case "studio":
+        this.addAmbient("preset_ambient", { intensity: 0.3 }), this.addDirectional("preset_key", { position: { x: 5, y: 8, z: 5 }, intensity: 1.2, castShadow: !0 }), this.addDirectional("preset_fill", { position: { x: -5, y: 5, z: -2 }, intensity: 0.6 }), this.addDirectional("preset_back", { position: { x: 0, y: 5, z: -8 }, intensity: 0.4 });
+        break;
+      case "warehouse":
+        this.addAmbient("preset_ambient", { intensity: 0.2 }), this.addPoint("preset_light1", { position: { x: -5, y: 6, z: -5 }, intensity: 2, distance: 20 }), this.addPoint("preset_light2", { position: { x: 5, y: 6, z: -5 }, intensity: 2, distance: 20 }), this.addPoint("preset_light3", { position: { x: -5, y: 6, z: 5 }, intensity: 2, distance: 20 }), this.addPoint("preset_light4", { position: { x: 5, y: 6, z: 5 }, intensity: 2, distance: 20 });
+        break;
+    }
+  }
+  /**
+   * Get a light by id.
+   */
+  get(e) {
+    return this.lights.get(e);
+  }
+  /**
+   * Remove a light by id.
+   */
+  remove(e) {
+    const t = this.lights.get(e);
+    t && (this.scene.remove(t), this.lights.delete(e)), this.hideHelper(e);
+  }
+  /**
+   * Remove all lights managed by this manager.
+   */
+  removeAll() {
+    const e = Array.from(this.lights.keys());
+    for (const t of e)
+      this.remove(t);
+  }
+  /**
+   * Show a visual helper for a light.
+   */
+  showHelper(e) {
+    if (this.helpers.has(e)) return;
+    const t = this.lights.get(e);
+    if (!t) return;
+    let s = null;
+    t instanceof ue ? s = new nt(t, 1) : t instanceof me ? s = new it(t, 0.5) : t instanceof ge ? s = new rt(t) : t instanceof fe && (s = new ot(t, 1)), s && (this.scene.add(s), this.helpers.set(e, s));
+  }
+  /**
+   * Hide (remove) the helper for a light.
+   */
+  hideHelper(e) {
+    const t = this.helpers.get(e);
+    t && (this.scene.remove(t), this.helpers.delete(e));
+  }
+  /**
+   * Show helpers for all lights.
+   */
+  showAllHelpers() {
+    for (const [e] of this.lights)
+      this.showHelper(e);
+  }
+  /**
+   * Hide all helpers.
+   */
+  hideAllHelpers() {
+    const e = Array.from(this.helpers.keys());
+    for (const t of e)
+      this.hideHelper(t);
+  }
+  _register(e, t) {
+    this.lights.has(e) && this.remove(e), this.lights.set(e, t), this.scene.add(t);
+  }
+  dispose() {
+    this.removeAll(), this.hideAllHelpers();
+  }
+}
+class ws extends at {
   scene;
   camera;
-  currentOutputNode;
+  scenePass;
   needsUpdateOutputNode;
-  #e;
+  #r;
+  #t;
+  #s = !1;
+  #o = { strength: 1, radius: 0, threshold: 0 };
+  #c = null;
+  #i = !1;
+  #e = {
+    sliceCount: 1,
+    stepCount: 12,
+    aoIntensity: 1,
+    giIntensity: 10,
+    radius: 12,
+    thickness: 1
+  };
+  #h = null;
+  #a = !1;
+  #l = null;
+  #d = null;
   constructor(...e) {
     const [t, s, n] = e;
-    super(t), this.scene = s, this.camera = n, this.currentOutputNode = Z(s, n), this.needsUpdateOutputNode = !0, this.#e = /* @__PURE__ */ new Set();
+    super(t), this.scene = s, this.camera = n, this.scenePass = de(s, n), this.needsUpdateOutputNode = !0, this.#r = /* @__PURE__ */ new Set(), this.#t = [], this.#p();
+  }
+  /** @deprecated Use `scenePass` instead */
+  get currentOutputNode() {
+    return this.scenePass;
   }
   addOverlayPass(e) {
-    this.#e.add(e), this.needsUpdateOutputNode = !0;
+    this.#r.add(e), this.needsUpdateOutputNode = !0;
   }
   removeOverlayPass(e) {
-    this.#e.delete(e), this.needsUpdateOutputNode = !0;
+    this.#r.delete(e), this.needsUpdateOutputNode = !0;
   }
   setCamera(e) {
-    this.camera = e, this.needsUpdateOutputNode = !0;
+    this.camera = e, this.#n();
   }
+  /** @deprecated Use `setOutputComposer` instead */
   setCurrentOutputNode(e) {
-    this.currentOutputNode.dispose(), this.currentOutputNode = e, this.needsUpdateOutputNode = !0;
+    this.setOutputComposer(() => e);
   }
+  /** @deprecated Use `setOutputComposer(null)` instead */
   resetCurrentOutputNode() {
-    this.currentOutputNode.dispose(), this.currentOutputNode = Z(this.scene, this.camera), this.needsUpdateOutputNode = !0;
+    this.setOutputComposer(null);
+  }
+  setOutputComposer(e) {
+    this.#d = e, this.needsUpdateOutputNode = !0;
+  }
+  enableBloom(e) {
+    e && Object.assign(this.#o, e), this.#s = !0, this.#n();
+  }
+  disableBloom() {
+    this.#s = !1, this.#c = null, this.#n();
+  }
+  updateBloom(e) {
+    Object.assign(this.#o, e), this.#s && (this.needsUpdateOutputNode = !0);
+  }
+  enableSSGI(e) {
+    e && Object.assign(this.#e, e), this.#i = !0, this.#n();
+  }
+  disableSSGI() {
+    this.#i = !1, this.#h = null, this.#n();
+  }
+  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);
+    }
+  }
+  enableTRAA() {
+    this.#a = !0, this.#n();
+  }
+  disableTRAA() {
+    this.#a = !1, this.#l = null, this.#n();
+  }
+  #n() {
+    const e = this.scenePass;
+    this.scenePass = de(this.scene, this.camera), this.#p(), this.needsUpdateOutputNode = !0, e.dispose();
   }
-  #t() {
-    let e = this.currentOutputNode;
-    this.#e.size > 0 && this.#e.forEach((t) => {
-      e = ut(e, t);
+  #p() {
+    if (this.#s || this.#i || this.#a) {
+      const t = { output: $t };
+      this.#s && (t.emissive = Kt), this.#i && (t.normal = Qt), this.#a && (t.velocity = qt), this.scenePass.setMRT(Gt(t));
+    }
+  }
+  #u() {
+    for (const e of this.#t)
+      e.dispose();
+    this.#t = [];
+  }
+  #m() {
+    let e = this.scenePass.getTextureNode();
+    if (this.#i)
+      if (!(this.camera instanceof J))
+        console.warn("RenderPipeline: SSGI requires a PerspectiveCamera, skipping.");
+      else {
+        const t = this.scenePass.getTextureNode(), s = this.scenePass.getTextureNode("depth"), n = this.scenePass.getTextureNode("normal"), i = Vt(t, s, n, this.camera);
+        i.sliceCount.value = this.#e.sliceCount, i.stepCount.value = this.#e.stepCount, i.aoIntensity.value = this.#e.aoIntensity, i.giIntensity.value = this.#e.giIntensity, i.radius.value = this.#e.radius, i.thickness.value = this.#e.thickness, this.#h = i, e = ve(e, i), this.#t.push(i);
+      }
+    if (this.#s) {
+      const t = this.scenePass.getTextureNode("emissive");
+      this.#c = Jt(
+        t,
+        this.#o.strength,
+        this.#o.radius,
+        this.#o.threshold
+      ), e = ve(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.#i ? e = this.#m() : e = this.scenePass, this.#a) {
+      const t = this.scenePass.getTextureNode("depth"), s = this.scenePass.getTextureNode("velocity");
+      this.#l = Zt(e, t, s, this.camera), this.#t.push(this.#l), e = this.#l;
+    }
+    this.#r.size > 0 && this.#r.forEach((t) => {
+      const s = Wt(e, t);
+      this.#t.push(s), e = s;
     }), this.outputNode = e, this.needsUpdate = !0;
   }
   render() {
-    this.needsUpdateOutputNode && (this.#t(), this.needsUpdateOutputNode = !1), super.render();
+    this.needsUpdateOutputNode && (this.#g(), this.needsUpdateOutputNode = !1), super.render();
+  }
+  dispose() {
+    this.#u(), this.scenePass.dispose(), super.dispose();
   }
 }
-const It = {
+const bs = {
   Vector2: S,
-  Vector3: ee,
-  Vector4: Ne,
-  Quaternion: _e,
-  Matrix4: Re,
-  Spherical: T,
-  Box3: fe,
-  Sphere: ge,
-  Raycaster: me
+  Vector3: w,
+  Vector4: ht,
+  Quaternion: ct,
+  Matrix4: Ie,
+  Spherical: C,
+  Box3: q,
+  Sphere: ze,
+  Raycaster: Be
 };
-Ce.install({ THREE: It });
-class Bt extends Ce {
+Ue.install({ THREE: bs });
+class vs extends Ue {
   constructor(...e) {
     super(...e), this.minDistance = 0.2, this.smoothTime = 0.2, this.dollySpeed = 0.2;
   }
@@ -305,16 +861,16 @@ class Bt extends Ce {
    * Set absolute angle for azimuth to avoid spinning
    */
   absoluteRotations() {
-    this.azimuthAngle = At(this.azimuthAngle, 0);
+    this.azimuthAngle = xs(this.azimuthAngle, 0);
   }
   async flyToBox(e, t = {}) {
     if (e.isEmpty())
       return console.warn("CameraControls.flyToBox: The provided Box3 is empty."), !1;
     this.absoluteRotations();
-    const { viewpoint: s = "frontTop", enableTransition: n = !0, padding: i = 0.1, cover: r = !1 } = t, a = [];
+    const { viewpoint: s = "frontTop", enableTransition: n = !0, padding: i = 0.1, cover: r = !1 } = t, o = [];
     if (s !== "current") {
-      const o = de[s.toUpperCase()] ?? de.FRONTTOP, h = o.theta, l = o.phi;
-      a.push(
+      const a = Me[s.toUpperCase()] ?? Me.FRONTTOP, c = a.theta, h = a.phi;
+      o.push(
         this.fitToBox(e, n, {
           paddingLeft: i,
           paddingRight: i,
@@ -322,45 +878,92 @@ class Bt extends Ce {
           paddingBottom: i,
           cover: r
         })
-      ), a.push(this.rotateTo(h, l, n));
+      ), o.push(this.rotateTo(c, h, n));
     } else {
-      const o = new ge();
-      e.getBoundingSphere(o), o.radius += i, a.push(this.fitToSphere(o, n));
+      const a = new ze();
+      e.getBoundingSphere(a), a.radius += i, o.push(this.fitToSphere(a, n));
     }
-    return await Promise.all(a), !0;
+    return await Promise.all(o), !0;
   }
   async flyToObject(e, t = {}) {
-    const s = new fe().setFromObject(e);
+    const s = new q().setFromObject(e);
     return this.flyToBox(s, t);
   }
+  /**
+   * Fly camera to a specific position and look-at target.
+   */
+  async flyTo(e, t, s = {}) {
+    const { enableTransition: n = !0 } = s;
+    return this.absoluteRotations(), this.setLookAt(e.x, e.y, e.z, t.x, t.y, t.z, n);
+  }
+  /**
+   * Get the current camera viewpoint data (position, target, zoom).
+   */
+  getCameraViewpoint() {
+    const e = new w(), t = new w();
+    return this.getPosition(e), this.getTarget(t), {
+      position: { x: e.x, y: e.y, z: e.z },
+      target: { x: t.x, y: t.y, z: t.z },
+      zoom: this.camera.zoom
+    };
+  }
+  /**
+   * Lock camera controls (disable all user interaction).
+   */
+  lock() {
+    this.enabled = !1;
+  }
+  /**
+   * Unlock camera controls (re-enable user interaction).
+   */
+  unlock() {
+    this.enabled = !0;
+  }
+  /**
+   * Switch between 2D top-down and 3D perspective views.
+   */
+  async setViewMode(e, t = !0) {
+    if (e === "2d") {
+      const s = new w();
+      this.getTarget(s), await this.rotateTo(0, 0, t), this.minPolarAngle = 0, this.maxPolarAngle = 0;
+    } else
+      this.minPolarAngle = 0, this.maxPolarAngle = Math.PI, await this.rotateTo(0, Math.PI / 4, t);
+  }
+  async setCameraViewpoint(e, t = !0) {
+    const { position: s, target: n, zoom: i = this.camera.zoom } = e;
+    return Promise.all([
+      this.zoomTo(i, t),
+      this.setLookAt(s.x, s.y, s.z, n.x, n.y, n.z, t)
+    ]);
+  }
 }
-const de = {
-  LEFT: new T(0, Math.PI / 2, -Math.PI / 2),
-  RIGHT: new T(0, Math.PI / 2, Math.PI / 2),
-  FRONT: new T(0, Math.PI / 2, 0),
-  BACK: new T(0, Math.PI / 2, Math.PI),
-  TOP: new T(0, 0, 0),
-  BOTTOM: new T(0, Math.PI, 0),
-  FRONTTOP: new T(0, Math.PI / 4, 0),
-  BACKTOP: new T(0, Math.PI / 4, Math.PI),
-  LEFTTOP: new T(0, Math.PI / 4, -Math.PI / 2),
-  RIGHTTOP: new T(0, Math.PI / 4, Math.PI / 2),
-  LEFTFRONTTOP: new T(0, Math.PI / 4, -Math.PI / 4),
-  RIGHTFRONTTOP: new T(0, Math.PI / 4, Math.PI / 4),
-  LEFTBACKTOP: new T(0, Math.PI / 4, -Math.PI / 4 * 3),
-  RIGHTBACKTOP: new T(0, Math.PI / 4, Math.PI / 4 * 3)
+const Me = {
+  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 At(c, e) {
-  const t = c - e;
-  return Ue.euclideanModulo(t + Math.PI, Math.PI * 2) - Math.PI;
+function xs(l, e) {
+  const t = l - e;
+  return lt.euclideanModulo(t + Math.PI, Math.PI * 2) - Math.PI;
 }
-class Rt {
-  environment = new ft();
+class Ss {
+  environment = new es();
   renderer;
   pmremGenerator;
   envMap = null;
   constructor(e) {
-    this.renderer = e, this.pmremGenerator = new De(e);
+    this.renderer = e, this.pmremGenerator = new dt(e);
   }
   update() {
     this.envMap || (this.envMap = this.pmremGenerator.fromScene(this.environment).texture);
@@ -369,20 +972,20 @@ class Rt {
     this.pmremGenerator.dispose(), this.envMap?.dispose();
   }
 }
-const z = 128;
-class _t extends wt {
+const Y = 128;
+class Cs extends ts {
   viewer;
   overlayPass;
   constructor(e) {
     super(e.camera, e.el), this.viewer = e;
-    const t = new $(-2, 2, 2, -2, 0, 4);
-    t.position.set(0, 0, 2), this.overlayPass = Z(this, t), this.setLabels("x", "y", "z");
+    const t = new V(-2, 2, 2, -2, 0, 4);
+    t.position.set(0, 0, 2), this.overlayPass = de(this, t), this.setLabels("x", "y", "z");
   }
   _update = () => {
     this.quaternion.copy(this.viewer.camera.quaternion).invert();
     const e = this.location;
     let t, s;
-    e.left !== null ? t = e.left : t = this.viewer.el.offsetWidth - z - e.right, e.top !== null ? s = e.top : s = this.viewer.el.offsetHeight - z - e.bottom, this.overlayPass.setViewport(t, s, z, z);
+    e.left !== null ? t = e.left : t = this.viewer.el.offsetWidth - Y - e.right, e.top !== null ? s = e.top : s = this.viewer.el.offsetHeight - Y - e.bottom, this.overlayPass.setViewport(t, s, Y, Y);
   };
   enable() {
     return this.viewer.renderPipeline.addOverlayPass(this.overlayPass), this.viewer.addEventListener("beforeRender", this._update), this.viewer.render(), this;
@@ -391,7 +994,42 @@ class _t extends wt {
     return this.viewer.renderPipeline.removeOverlayPass(this.overlayPass), this.viewer.removeEventListener("beforeRender", this._update), this.viewer.render(), this;
   }
 }
-class Nt {
+const Ge = "position:absolute;top:0;left:0;width:100%;height:100%;pointer-events:none;overflow:hidden;", _s = Ge + "z-index:0;", Ms = Ge + "z-index:1;";
+class Ts {
+  el;
+  css2dRenderer = null;
+  css3dRenderer = null;
+  constructor(e) {
+    this.el = e, getComputedStyle(e).position === "static" && (e.style.position = "relative");
+  }
+  initCSS2DRenderer() {
+    const e = new ss();
+    return e.setSize(this.el.clientWidth, this.el.clientHeight), e.domElement.style.cssText = Ms, this.el.appendChild(e.domElement), this.css2dRenderer = e, e;
+  }
+  initCSS3DRenderer() {
+    const e = new is();
+    return e.setSize(this.el.clientWidth, this.el.clientHeight), e.domElement.style.cssText = _s, this.el.appendChild(e.domElement), this.css3dRenderer = e, e;
+  }
+  createCSS2DObject(e) {
+    return this.css2dRenderer || this.initCSS2DRenderer(), new ns(e);
+  }
+  createCSS25DObject(e) {
+    return this.css3dRenderer || this.initCSS3DRenderer(), new rs(e);
+  }
+  createCSS3DObject(e) {
+    return this.css3dRenderer || this.initCSS3DRenderer(), new os(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 Ps {
   el;
   renderer;
   container;
@@ -406,9 +1044,9 @@ class Nt {
     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 n(r, a = !0) {
-      const o = document.createElement("span");
-      return a && (o.style.marginLeft = "6px"), o.innerText = r, o;
+    function n(r, o = !0) {
+      const a = document.createElement("span");
+      return o && (a.style.marginLeft = "6px"), a.innerText = r, a;
     }
     function i() {
       return document.createElement("br");
@@ -418,7 +1056,7 @@ class Nt {
   update() {
     if (this._enabled) {
       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(je.RENDER).then((t) => {
+      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(pt.RENDER).then((t) => {
         this.timestampText.innerText = t?.toFixed(2) ?? "0";
       });
     }
@@ -433,8 +1071,8 @@ class Nt {
     this.disable();
   }
 }
-ke.enabled = !0;
-class Cs extends Ge {
+ut.enabled = !0;
+class Sn extends Le {
   el;
   renderer;
   scene;
@@ -447,14 +1085,15 @@ class Cs extends Ge {
   interactionManager;
   objectManager;
   viewerHelper;
+  cssRenderer;
   frameCount = 1;
   frameloop = "demand";
   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 Nt(this.el, this.renderer), this.controls = new Bt(this.camera, this.renderer.domElement), this.renderPipeline = new Lt(this.renderer, this.scene, this.camera), this.timer = new Fe(), this.roomEnvironment = new Rt(this.renderer), this.interactionManager = new Pt(this.renderer.domElement, this.scene, this.camera), this.objectManager = new St(), this.viewerHelper = new _t(this), window.addEventListener("resize", this.onWindowResize);
+    super(), this.el = e, this.renderer = this._initRenderer(t), this.scene = this.createScene(), this.camera = this.createPerspectiveCamera(), this.info = new Ps(this.el, this.renderer), this.controls = new vs(this.camera, this.renderer.domElement), this.renderPipeline = new ws(this.renderer, this.scene, this.camera), this.timer = new mt(), this.roomEnvironment = new Ss(this.renderer), this.interactionManager = new fs(this.renderer.domElement, this.scene, this.camera), this.objectManager = new ys(), this.viewerHelper = new Cs(this), this.cssRenderer = new Ts(this.el), window.addEventListener("resize", this.onWindowResize);
   }
   onWindowResize = () => {
     const e = this.el.clientWidth, t = this.el.clientHeight;
-    this.camera instanceof X ? (this.camera.aspect = e / t, this.camera.updateProjectionMatrix()) : this.camera instanceof $ && (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.render();
+    this.camera instanceof J ? (this.camera.aspect = e / t, this.camera.updateProjectionMatrix()) : this.camera instanceof V && (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;
@@ -463,7 +1102,7 @@ class Cs extends Ge {
     this.camera = e, this.controls.camera = e, this.interactionManager.setCamera(e), this.renderPipeline.setCamera(e), this.onWindowResize(), this.dispatchEvent({ type: "cameraChange", camera: e });
   }
   setCameraByType(e) {
-    e === "perspective" && !(this.camera instanceof X) ? this.setCamera(this.createPerspectiveCamera()) : e === "orthographic" && !(this.camera instanceof $) && this.setCamera(this.createOrthographicCamera());
+    e === "perspective" && !(this.camera instanceof J) ? this.setCamera(this.createPerspectiveCamera()) : e === "orthographic" && !(this.camera instanceof V) && this.setCamera(this.createOrthographicCamera());
   }
   render(e = 1) {
     return this.frameCount += e, new Promise((t) => {
@@ -478,28 +1117,28 @@ class Cs extends Ge {
     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.info.update(), this.dispatchEvent({ type: "afterRender", time: e, delta: 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(e) {
-    const t = new He({
+    const t = new gt({
       logarithmicDepthBuffer: !0,
       antialias: !1,
       depth: !1,
       trackTimestamp: !0,
       ...e
     });
-    return t.setSize(this.el.clientWidth, this.el.clientHeight), t.shadowMap.enabled = !0, t.shadowMap.type = ze, t.toneMapping = $e, t.toneMappingExposure = 1, t.info.autoReset = !1, t.setPixelRatio(window.devicePixelRatio), t.setAnimationLoop(this.animate), this.el.appendChild(t.domElement), t;
+    return t.setSize(this.el.clientWidth, this.el.clientHeight), t.shadowMap.enabled = !0, t.shadowMap.type = ft, t.toneMapping = yt, t.toneMappingExposure = 1, t.info.autoReset = !1, t.setPixelRatio(window.devicePixelRatio), t.setAnimationLoop(this.animate), this.el.appendChild(t.domElement), t;
   }
   createScene() {
-    const e = new We();
-    return e.background = new te(0), e;
+    const e = new Re();
+    return e.background = new B(0), e;
   }
   createPerspectiveCamera() {
-    const e = new X(50, this.el.clientWidth / this.el.clientHeight, 0.1, 1e5);
+    const e = new J(50, this.el.clientWidth / this.el.clientHeight, 0.1, 1e5);
     return e.position.setScalar(5), e;
   }
   createOrthographicCamera() {
-    const e = new $(
+    const e = new V(
       -this.el.clientWidth / 2,
       this.el.clientWidth / 2,
       this.el.clientHeight / 2,
@@ -509,202 +1148,261 @@ class Cs extends Ge {
     );
     return e.position.setScalar(5), e;
   }
+  /**
+   * Manually trigger a resize update.
+   */
+  resize(e, t) {
+    e !== void 0 && t !== void 0 && (this.el.style.width = `${e}px`, this.el.style.height = `${t}px`), this.onWindowResize();
+  }
+  /**
+   * Capture a screenshot of the current render.
+   */
+  async screenshot(e = {}) {
+    const { type: t = "image/png", quality: s = 1 } = e, n = this.el.clientWidth, i = this.el.clientHeight, r = e.width && e.height;
+    r && this.renderer.setSize(e.width, e.height), await this.render();
+    const o = this.renderer.domElement.toDataURL(t, s);
+    return r && (this.renderer.setSize(n, i), this.onWindowResize()), o;
+  }
+  /**
+   * Set the scene background color, texture, or null.
+   */
+  setBackground(e) {
+    e === null ? this.scene.background = null : e instanceof B || typeof e == "number" || typeof e == "string" ? this.scene.background = new B(e) : this.scene.background = e, this.render();
+  }
+  /**
+   * Set the scene environment map for reflections / IBL.
+   */
+  setEnvironment(e) {
+    this.scene.environment = e, this.render();
+  }
+  /**
+   * Enable shadow rendering.
+   */
+  enableShadow() {
+    this.renderer.shadowMap.enabled = !0, this.render();
+  }
+  /**
+   * Disable shadow rendering.
+   */
+  disableShadow() {
+    this.renderer.shadowMap.enabled = !1, this.render();
+  }
+  /**
+   * Enable linear fog.
+   */
+  enableFog(e = {}) {
+    const { color: t = 13421772, near: s = 10, far: n = 100 } = e;
+    this.scene.fog = new wt(t, s, n), this.render();
+  }
+  /**
+   * Enable exponential fog.
+   */
+  enableFogExp2(e = {}) {
+    const { color: t = 13421772, density: s = 0.01 } = e;
+    this.scene.fog = new bt(t, s), this.render();
+  }
+  /**
+   * Disable fog.
+   */
+  disableFog() {
+    this.scene.fog = null, this.render();
+  }
   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 Ut extends xe {
+class Es extends Fe {
   constructor(e) {
     super(e);
   }
   parse(e, t, s, n) {
-    if (Dt(e.slice(0, 8)) === "SBMG----") {
-      const r = jt(e.slice(8));
+    if (Os(e.slice(0, 8)) === "SBMG----") {
+      const r = As(e.slice(8));
       return super.parse(r, t, s, n);
     } else
       return super.parse(e, t, s, n);
   }
 }
-function Dt(c) {
-  return new TextDecoder().decode(new Uint8Array(c));
+function Os(l) {
+  return new TextDecoder().decode(new Uint8Array(l));
 }
-function jt(c) {
-  const e = new DataView(c);
+function As(l) {
+  const e = new DataView(l);
   for (let t = 0; t < e.byteLength; t++) {
     const s = e.getUint8(t), n = (s >> 4 & 15) + (s << 4 & 240);
     e.setUint8(t, n);
   }
   return e.buffer;
 }
-const kt = 8, Gt = 130, pe = 66, Ft = "SBK-----", Ht = "SBM-----", Me = new TextDecoder(), zt = new TextEncoder();
-function $t(c) {
-  let e = kt;
-  const t = new Uint8Array(c, 0, e);
-  if (Me.decode(t) !== Ft)
-    return c;
-  e += Gt;
-  const n = new Uint8Array(c, 0, e);
+const Bs = 8, Ls = 130, Te = 66, Is = "SBK-----", Rs = "SBM-----", $e = new TextDecoder(), zs = new TextEncoder();
+function Ns(l) {
+  let e = Bs;
+  const t = new Uint8Array(l, 0, e);
+  if ($e.decode(t) !== Is)
+    return l;
+  e += Ls;
+  const n = new Uint8Array(l, 0, e);
   if (n[40] === 1) {
-    const r = zt.encode(Ht), a = new Uint8Array([n[41]]), o = Wt(n), h = Qt(o);
-    let l = pe % h.length;
-    const p = e + pe, g = new Uint8Array(c, p), u = new Uint8Array(g.length);
-    for (let v = 0; v < g.length; v++)
-      u[v] = g[v] ^ h[l], l = (l + 1) % h.length;
-    const w = new Uint8Array(r.length + a.length + u.length);
-    return w.set(r), w.set(a, r.length), w.set(u, r.length + a.length), w.buffer;
+    const r = zs.encode(Rs), o = new Uint8Array([n[41]]), a = js(n), c = Ds(a);
+    let h = Te % c.length;
+    const d = e + Te, p = new Uint8Array(l, d), u = new Uint8Array(p.length);
+    for (let b = 0; b < p.length; b++)
+      u[b] = p[b] ^ c[h], h = (h + 1) % c.length;
+    const g = new Uint8Array(r.length + o.length + u.length);
+    return g.set(r), g.set(o, r.length), g.set(u, r.length + o.length), g.buffer;
   }
 }
-function Wt(c) {
+function js(l) {
   const e = new Uint8Array(128);
-  return e.set(c.slice(42, 74), 0), e.set(c.slice(74, 138), 32), e.set(c.slice(8, 40), 96), e;
+  return e.set(l.slice(42, 74), 0), e.set(l.slice(74, 138), 32), e.set(l.slice(8, 40), 96), e;
 }
-function Qt(c) {
+function Ds(l) {
   const e = new Uint8Array(64);
-  return e.set(c.slice(0, 8), 0), e.set(c.slice(24, 32), 8), e.set(c.slice(40, 56), 16), e.set(c.slice(64, 88), 32), e.set(c.slice(96, 104), 56), e;
+  return e.set(l.slice(0, 8), 0), e.set(l.slice(24, 32), 8), e.set(l.slice(40, 56), 16), e.set(l.slice(64, 88), 32), e.set(l.slice(96, 104), 56), e;
 }
-const Kt = (c, e, t) => {
-  const s = c.buffer.slice(t, t + e);
-  let n = Me.decode(s);
+const ks = (l, e, t) => {
+  const s = l.buffer.slice(t, t + e);
+  let n = $e.decode(s);
   return n = n.replace("\\", "/"), n.startsWith("Maps/") || (n = `Maps/${n}`), n;
-}, Xt = (c, e, t) => {
-  const [s, n, i, r, a] = e, o = t || r < 1;
-  return new I({
-    name: c,
-    color: new te(s, n, i),
+}, Hs = (l, e, t) => {
+  const [s, n, i, r, o] = e, a = t || r < 1;
+  return new R({
+    name: l,
+    color: new B(s, n, i),
     opacity: r,
-    transparent: o,
+    transparent: a,
     alphaTest: 0.01,
-    side: a
+    side: o
   });
-}, qt = (c) => c?.toLowerCase().endsWith(".png") ?? !1;
-class Yt {
+}, Us = (l) => l?.toLowerCase().endsWith(".png") ?? !1;
+class Fs {
   data;
   options;
   textureLoader;
   littleEndian = !0;
   materials = /* @__PURE__ */ new Map();
   constructor(e, t) {
-    this.data = e, this.options = t, this.textureLoader = new ye(t.manager), this.textureLoader.setCrossOrigin(t.crossOrigin), this.textureLoader.setRequestHeader(t.requestHeader);
+    this.data = e, this.options = t, this.textureLoader = new je(t.manager), this.textureLoader.setCrossOrigin(t.crossOrigin), this.textureLoader.setRequestHeader(t.requestHeader);
   }
   parse(e, t) {
     let s = this.data;
-    const n = $t(this.data);
+    const n = Ns(this.data);
     n && (s = n);
     const i = new DataView(s);
     let r = 8;
-    const a = i.getUint8(r);
-    r += 1, a === 1 ? this._parseV2(i, r, e) : a === 2 ? this._parseV2(i, r, e) : a === 3 ? this._parseV3(i, r, e) : t?.(new Error(`SBMLoader: Unsupported SBM version: ${a}`));
+    const o = i.getUint8(r);
+    r += 1, o === 1 ? this._parseV2(i, r, e) : o === 2 ? this._parseV2(i, r, e) : o === 3 ? this._parseV3(i, r, e) : t?.(new Error(`SBMLoader: Unsupported SBM version: ${o}`));
   }
   _parseV2(e, t, s) {
-    const n = new Q(), i = e.getUint16(t, this.littleEndian);
+    const n = new I(), i = e.getUint16(t, this.littleEndian);
     t += 2;
     const r = e.getUint16(t, this.littleEndian);
     t += 2;
-    for (let a = 0; a < i; ++a) {
-      const o = e.getUint16(t, this.littleEndian).toString();
+    for (let o = 0; o < i; ++o) {
+      const a = e.getUint16(t, this.littleEndian).toString();
       t += 2, t += 4, t += 4, t += 4, t += 4;
+      const c = e.getFloat32(t, this.littleEndian);
+      t += 4;
       const h = e.getFloat32(t, this.littleEndian);
       t += 4;
-      const l = e.getFloat32(t, this.littleEndian);
+      const d = e.getFloat32(t, this.littleEndian);
       t += 4;
       const p = 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 u = e.getUint8(t);
-      t += 1, u === 0 ? u = Xe : u === 1 ? u = qe : u === 2 && (u = Ye);
-      const w = e.getUint16(t, this.littleEndian);
+      t += 1, u === 0 ? u = xt : u === 1 ? u = St : u === 2 && (u = Ct);
+      const g = e.getUint16(t, this.littleEndian);
       t += 2;
-      const v = w > 0 ? Kt(e, w, t) : "";
-      if (t += w, !this.materials.has(o)) {
-        const b = Xt(o, [h, l, p, g, u], qt(v));
-        this.materials.set(o, b), v && this.options.path && this.textureLoader.load(L.resolveURL(v, this.options.path), (f) => {
-          f.colorSpace = ve, f.wrapS = ne, f.wrapT = ne, f.flipY = !1, f.anisotropy = 16, b.map = f;
+      const b = g > 0 ? ks(e, g, t) : "";
+      if (t += g, !this.materials.has(a)) {
+        const x = Hs(a, [c, h, d, p, u], Us(b));
+        this.materials.set(a, x), b && this.options.path && this.textureLoader.load(L.resolveURL(b, this.options.path), (y) => {
+          y.colorSpace = De, y.wrapS = ye, y.wrapT = ye, y.flipY = !1, y.anisotropy = 16, x.map = y;
         });
       }
     }
-    for (let a = 0; a < r; ++a) {
-      const o = e.getUint16(t, this.littleEndian).toString();
+    for (let o = 0; o < r; ++o) {
+      const a = e.getUint16(t, this.littleEndian).toString();
       t += 2;
-      const h = e.getUint16(t, this.littleEndian).toString();
+      const c = e.getUint16(t, this.littleEndian).toString();
       t += 2;
-      const l = [], p = [], g = [], u = [], w = e.getUint16(t, this.littleEndian);
-      if (t += 2, w > 0)
-        for (let m = 0; m < w; m++) {
-          const y = new ee();
-          y.setX(e.getFloat32(t, this.littleEndian)), t += 4, y.setY(e.getFloat32(t, this.littleEndian)), t += 4, y.setZ(e.getFloat32(t, this.littleEndian)), t += 4, l.push(y);
+      const h = [], d = [], p = [], u = [], g = e.getUint16(t, this.littleEndian);
+      if (t += 2, g > 0)
+        for (let f = 0; f < g; f++) {
+          const v = new w();
+          v.setX(e.getFloat32(t, this.littleEndian)), t += 4, v.setY(e.getFloat32(t, this.littleEndian)), t += 4, v.setZ(e.getFloat32(t, this.littleEndian)), t += 4, h.push(v);
         }
-      const v = e.getUint16(t, this.littleEndian);
-      if (t += 2, v > 0)
-        for (let m = 0; m < v; m++)
+      const b = e.getUint16(t, this.littleEndian);
+      if (t += 2, b > 0)
+        for (let f = 0; f < b; f++)
           t += 4, t += 4, t += 4;
+      const _ = e.getUint16(t, this.littleEndian);
+      if (t += 2, _ > 0)
+        for (let f = 0; f < _; f++) {
+          const v = new S();
+          v.setX(e.getFloat32(t, this.littleEndian)), t += 4, v.setY(e.getFloat32(t, this.littleEndian)), t += 4, d.push(v);
+        }
       const x = e.getUint16(t, this.littleEndian);
       if (t += 2, x > 0)
-        for (let m = 0; m < x; m++) {
-          const y = new S();
-          y.setX(e.getFloat32(t, this.littleEndian)), t += 4, y.setY(e.getFloat32(t, this.littleEndian)), t += 4, p.push(y);
-        }
-      const b = e.getUint16(t, this.littleEndian);
-      if (t += 2, b > 0)
-        for (let m = 0; m < b; m++) {
-          const y = e.getUint16(t, this.littleEndian);
+        for (let f = 0; f < x; f++) {
+          const v = e.getUint16(t, this.littleEndian);
           t += 2;
-          const B = e.getUint16(t, this.littleEndian);
+          const z = e.getUint16(t, this.littleEndian);
           t += 2;
-          const A = e.getUint16(t, this.littleEndian);
+          const N = e.getUint16(t, this.littleEndian);
           t += 2;
-          const E = [y, B, A];
-          g.push(E), p.length > 0 && u.push([p[E[0]], p[E[1]], p[E[2]]]);
+          const P = [v, z, N];
+          p.push(P), d.length > 0 && u.push([d[P[0]], d[P[1]], d[P[2]]]);
         }
-      const f = [], C = [];
-      for (let m = 0; m < g.length; m++) {
-        const y = g[m], B = l[y[0]], A = l[y[1]], E = l[y[2]];
-        f.push(...B.toArray(), ...A.toArray(), ...E.toArray());
-        let H = new S(), k = new S(), _ = new S();
-        const N = u[m];
-        N !== void 0 && (H = N[0], k = N[1], _ = N[2]), C.push(...H.toArray(), ...k.toArray(), ..._.toArray());
+      const y = [], M = [];
+      for (let f = 0; f < p.length; f++) {
+        const v = p[f], z = h[v[0]], N = h[v[1]], P = h[v[2]];
+        y.push(...z.toArray(), ...N.toArray(), ...P.toArray());
+        let X = new S(), W = new S(), D = new S();
+        const k = u[f];
+        k !== void 0 && (X = k[0], W = k[1], D = k[2]), M.push(...X.toArray(), ...W.toArray(), ...D.toArray());
       }
-      const O = new Float32Array(f), P = new Float32Array(C), M = new Ke();
-      if (O.length > 0 && M.setAttribute("position", new ie(O, 3)), P.length > 0 && M.setAttribute("uv", new ie(P, 2)), M.computeVertexNormals(), this.materials.has(h)) {
-        const m = new F(M, this.materials.get(h));
-        m.name = o, m.castShadow = !0, m.receiveShadow = !0, n.add(m);
+      const E = new Float32Array(y), O = new Float32Array(M), T = new K();
+      if (E.length > 0 && T.setAttribute("position", new we(E, 3)), O.length > 0 && T.setAttribute("uv", new we(O, 2)), T.computeVertexNormals(), this.materials.has(c)) {
+        const f = new G(T, this.materials.get(c));
+        f.name = a, f.castShadow = !0, f.receiveShadow = !0, n.add(f);
       }
     }
     s(n);
   }
   _parseV3(e, t, s) {
-    const n = new Q();
+    const n = new I();
     console.warn("SBMLoader: SBM version 3 is not supported yet."), s(n);
   }
 }
-class Jt extends Qe {
+class Gs extends vt {
   load(e, t, s, n) {
     let i;
     if (this.resourcePath !== "")
       i = this.resourcePath;
     else if (this.path !== "") {
-      const o = L.extractUrlBase(e);
-      i = L.resolveURL(o, this.path);
+      const a = L.extractUrlBase(e);
+      i = L.resolveURL(a, this.path);
     } else
       i = L.extractUrlBase(e);
     this.manager.itemStart(e);
-    const r = (o) => {
-      n ? n(o) : console.error(o), this.manager.itemError(e), this.manager.itemEnd(e);
-    }, a = new we(this.manager);
-    a.setPath(this.path), a.setResponseType("arraybuffer"), a.setRequestHeader(this.requestHeader), a.setWithCredentials(this.withCredentials), a.load(
+    const r = (a) => {
+      n ? n(a) : console.error(a), this.manager.itemError(e), this.manager.itemEnd(e);
+    }, o = new Ne(this.manager);
+    o.setPath(this.path), o.setResponseType("arraybuffer"), o.setRequestHeader(this.requestHeader), o.setWithCredentials(this.withCredentials), o.load(
       e,
-      (o) => {
+      (a) => {
         try {
           this.parse(
-            o,
+            a,
             i,
-            (h) => {
-              t(h), this.manager.itemEnd(e);
+            (c) => {
+              t(c), this.manager.itemEnd(e);
             },
             r
           );
-        } catch (h) {
-          r(h);
+        } catch (c) {
+          r(c);
         }
       },
       s,
@@ -717,7 +1415,7 @@ class Jt extends Qe {
       n?.(new Error(`SBMLoader: Invalid SBM format: ${i}`));
       return;
     }
-    new Yt(e, {
+    new Fs(e, {
       path: t,
       crossOrigin: this.crossOrigin,
       requestHeader: this.requestHeader,
@@ -739,21 +1437,21 @@ class Jt extends Qe {
     });
   }
 }
-class R {
+class j {
   static CACHE_NAME = "u-space-model-loader-cache";
-  static fileLoader = new we().setResponseType("arraybuffer");
-  static dracoLoader = new Tt().setDecoderPath(
-    `https://cdn.jsdelivr.net/npm/three@0.${re}.0/examples/jsm/libs/draco/`
+  static fileLoader = new Ne().setResponseType("arraybuffer");
+  static dracoLoader = new ls().setDecoderPath(
+    `https://cdn.jsdelivr.net/npm/three@0.${be}.0/examples/jsm/libs/draco/`
   );
-  static ktx2Loader = new Ct().setTranscoderPath(
-    `https://cdn.jsdelivr.net/npm/three@0.${re}.0/examples/jsm/libs/basis/`
+  static ktx2Loader = new ds().setTranscoderPath(
+    `https://cdn.jsdelivr.net/npm/three@0.${be}.0/examples/jsm/libs/basis/`
   );
-  static gltfLoader = new xe().setDRACOLoader(R.dracoLoader).setKTX2Loader(R.ktx2Loader).setMeshoptDecoder(le);
-  static sbmxLoader = new Ut().setDRACOLoader(R.dracoLoader).setKTX2Loader(R.ktx2Loader).setMeshoptDecoder(le);
-  static sbmLoader = new Jt();
-  static fbxLoader = new yt();
-  static objLoader = new vt();
-  static stlLoader = new bt();
+  static gltfLoader = new Fe().setDRACOLoader(j.dracoLoader).setKTX2Loader(j.ktx2Loader).setMeshoptDecoder(_e);
+  static sbmxLoader = new Es().setDRACOLoader(j.dracoLoader).setKTX2Loader(j.ktx2Loader).setMeshoptDecoder(_e);
+  static sbmLoader = new Gs();
+  static fbxLoader = new as();
+  static objLoader = new cs();
+  static stlLoader = new hs();
   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;
   }
@@ -791,11 +1489,11 @@ class R {
       case "fbx":
         return this.fbxLoader.parse(n, L.extractUrlBase(e));
       case "obj":
-        const h = new TextDecoder().decode(n);
-        return this.objLoader.parse(h);
+        const c = new TextDecoder().decode(n);
+        return this.objLoader.parse(c);
       case "stl":
-        const p = this.stlLoader.parse(n);
-        return new F(p, new I());
+        const d = this.stlLoader.parse(n);
+        return new G(d, new R());
       default:
         throw new Error(`Unsupported model format: ${s}`);
     }
@@ -812,10 +1510,10 @@ class R {
     }
   }
 }
-class xs {
-  static textureLoader = new ye();
-  static hdrLoader = new xt();
-  static cubeTextureLoader = new Je();
+class Cn {
+  static textureLoader = new je();
+  static hdrLoader = new ps();
+  static cubeTextureLoader = new _t();
   static setLoadingManager(e) {
     this.textureLoader.manager = e, this.hdrLoader.manager = e, this.cubeTextureLoader.manager = e;
   }
@@ -824,13 +1522,13 @@ class xs {
   }
   static async loadAsyncHDR(e) {
     const t = await this.hdrLoader.loadAsync(e);
-    return t.mapping = Ze, t;
+    return t.mapping = Mt, t;
   }
   static async loadAsyncCubeTexture(e, t) {
     return this.cubeTextureLoader.setPath(e), await this.cubeTextureLoader.loadAsync(t);
   }
 }
-class j extends F {
+class $ extends G {
   isBaseMesh = !0;
   type = "BaseMesh";
   ignoreInvisibleWhenRaycast = !0;
@@ -841,7 +1539,7 @@ class j extends F {
     return this.visible === !1 && this.ignoreInvisibleWhenRaycast === !0 ? !1 : super.raycast(e, t);
   }
 }
-class Ee extends Q {
+class We extends I {
   isBaseGroup = !0;
   type = "BaseGroup";
   ignoreInvisibleWhenRaycast = !0;
@@ -852,7 +1550,7 @@ class Ee extends Q {
     return this.visible === !1 && this.ignoreInvisibleWhenRaycast === !0 ? !1 : super.raycast(e, t);
   }
 }
-class Zt extends Ve {
+class $s extends Tt {
   isBaseSprite = !0;
   type = "BaseSprite";
   ignoreInvisibleWhenRaycast = !0;
@@ -863,7 +1561,7 @@ class Zt extends Ve {
     return this.visible === !1 && this.ignoreInvisibleWhenRaycast === !0 ? !1 : super.raycast(e, t);
   }
 }
-class W extends Ee {
+class re extends We {
   isModel = !0;
   type = "Model";
   static memoryCache = /* @__PURE__ */ new Map();
@@ -877,9 +1575,9 @@ class W extends Ee {
     const { url: t, cache: s = !0, persistent: n = !0 } = e;
     try {
       let i;
-      s ? W.memoryCache.has(t) ? i = W.memoryCache.get(t) : (i = R.loadAsync(t, { persistent: n }), W.memoryCache.set(t, i)) : i = R.loadAsync(t, { persistent: n });
-      const r = await i, a = Mt(r);
-      return this.add(a), a.animations && a.animations.length > 0 && (this.animations = a.animations, this.mixer = new et(a)), a;
+      s ? re.memoryCache.has(t) ? i = re.memoryCache.get(t) : (i = j.loadAsync(t, { persistent: n }), re.memoryCache.set(t, i)) : i = j.loadAsync(t, { persistent: n });
+      const r = await i, o = us(r);
+      return this.add(o), o.animations && o.animations.length > 0 && (this.animations = o.animations, this.mixer = new Pt(o)), o;
     } catch (i) {
       return console.error(`[Model] Failed to load model from ${t}:`, i), null;
     }
@@ -887,11 +1585,11 @@ class W extends Ee {
   playAnimation(e, t = {}) {
     if (!this.mixer || this.animations.length === 0) return null;
     const { loop: s = !0, repetitions: n = 1 / 0, timeScale: i = 1, clampWhenFinished: r = !1 } = t;
-    let a;
-    if (e === void 0 ? a = this.animations[0] : typeof e == "number" ? a = this.animations[e] : a = this.animations.find((h) => h.name === e), !a)
+    let o;
+    if (e === void 0 ? o = this.animations[0] : typeof e == "number" ? o = this.animations[e] : o = this.animations.find((c) => c.name === e), !o)
       return console.warn(`[Model] Animation not found: ${e}`), null;
-    let o = this.actions.get(a.name);
-    return o || (o = this.mixer.clipAction(a), this.actions.set(a.name, o)), o.setLoop(s ? tt : st, n), o.clampWhenFinished = r, o.timeScale = i, o.reset().play(), o;
+    let a = this.actions.get(o.name);
+    return a || (a = this.mixer.clipAction(o), this.actions.set(o.name, a)), a.setLoop(s ? Et : Ot, n), a.clampWhenFinished = r, a.timeScale = i, a.reset().play(), a;
   }
   playAllAnimations(e = {}) {
     return this.animations.map((t, s) => this.playAnimation(s, e)).filter((t) => t !== null);
@@ -908,6 +1606,27 @@ class W extends Ee {
   updateAnimation(e) {
     this.mixer?.update(e);
   }
+  /**
+   * Get the axis-aligned bounding box of this model.
+   */
+  getBoundingBox() {
+    return new q().setFromObject(this);
+  }
+  /**
+   * Get the center point of this model's bounding box.
+   */
+  getCenter() {
+    const e = new w();
+    return this.getBoundingBox().getCenter(e), e;
+  }
+  /**
+   * Set the material for all meshes in this model.
+   */
+  setMaterial(e) {
+    this.traverse((t) => {
+      t instanceof G && (t.material = e);
+    });
+  }
   static clearMemoryCache() {
     this.memoryCache.clear();
   }
@@ -915,11 +1634,11 @@ class W extends Ee {
     typeof caches < "u" && await caches.delete("u-space-loader-cache");
   }
 }
-class Vt extends j {
+class Ws extends $ {
   isSphereMesh = !0;
   type = "SphereMesh";
   constructor({ geometryParameters: e, materialParameters: t } = {}) {
-    super(), this.geometry = new nt(
+    super(), this.geometry = new At(
       e?.radius,
       e?.widthSegments,
       e?.heightSegments,
@@ -927,23 +1646,23 @@ class Vt extends j {
       e?.phiLength,
       e?.thetaStart,
       e?.thetaLength
-    ), this.material = new I(t);
+    ), this.material = new R(t);
   }
 }
-class ue extends j {
+class Pe extends $ {
   isTubeMesh = !0;
   type = "TubeMesh";
   constructor({ geometryParameters: e, materialParameters: t } = {}) {
-    super(), this.geometry = new it(
+    super(), this.geometry = new Bt(
       e?.path,
       e?.tubularSegments,
       e?.radius,
       e?.radialSegments,
       e?.closed
-    ), this.material = new I(t);
+    ), this.material = new R(t);
   }
 }
-class Ms extends Ee {
+class _n extends We {
   isTopology = !0;
   type = "Topology";
   // Visuals
@@ -994,8 +1713,8 @@ class Ms extends Ee {
       console.error(`[Topology] Cannot add edge. One or both nodes not found: ${e}, ${t}`);
       return;
     }
-    const a = s ?? i.distanceTo(r);
-    this.getNeighbors(e)?.set(t, a), n && this.getNeighbors(t)?.set(e, a);
+    const o = s ?? i.distanceTo(r);
+    this.getNeighbors(e)?.set(t, o), n && this.getNeighbors(t)?.set(e, o);
   }
   /**
    * Remove an edge between two nodes.
@@ -1013,32 +1732,32 @@ class Ms extends Ee {
     if (!this.nodes.has(e) || !this.nodes.has(t))
       return console.warn("[Topology] Start or End node not found."), [];
     const s = /* @__PURE__ */ new Map(), n = /* @__PURE__ */ new Map(), i = /* @__PURE__ */ new Set();
-    for (const [o] of this.nodes)
-      s.set(o, 1 / 0), n.set(o, null), i.add(o);
+    for (const [a] of this.nodes)
+      s.set(a, 1 / 0), n.set(a, null), i.add(a);
     for (s.set(e, 0); i.size > 0; ) {
-      let o = null, h = 1 / 0;
-      for (const p of i) {
-        const g = s.get(p);
-        g < h && (h = g, o = p);
+      let a = null, c = 1 / 0;
+      for (const d of i) {
+        const p = s.get(d);
+        p < c && (c = p, a = d);
       }
-      if (o === null || o === t || h === 1 / 0)
+      if (a === null || a === t || c === 1 / 0)
         break;
-      i.delete(o);
-      const l = this.adjacencyMap?.get(o);
-      if (l)
-        for (const [p, g] of l) {
-          if (!i.has(p)) continue;
-          const u = s.get(o) + g;
-          u < s.get(p) && (s.set(p, u), n.set(p, o));
+      i.delete(a);
+      const h = this.adjacencyMap?.get(a);
+      if (h)
+        for (const [d, p] of h) {
+          if (!i.has(d)) continue;
+          const u = s.get(a) + p;
+          u < s.get(d) && (s.set(d, u), n.set(d, a));
         }
     }
     const r = [];
-    let a = t;
+    let o = t;
     if (n.get(t) === null && e !== t)
       return [];
-    for (; a !== null; ) {
-      const o = this.nodes.get(a);
-      o && r.unshift(o), a = n.get(a) || null;
+    for (; o !== null; ) {
+      const a = this.nodes.get(o);
+      a && r.unshift(a), o = n.get(o) || null;
     }
     return r;
   }
@@ -1046,8 +1765,8 @@ class Ms extends Ee {
    * Renders the entire topology graph structure using TubeGeometry and Spheres.
    */
   renderGraph() {
-    this.clearGraph(), this.graphGroup = new Q();
-    const e = new Vt({
+    this.clearGraph(), this.graphGroup = new I();
+    const e = new Ws({
       geometryParameters: {
         radius: this.parameters.nodeRadius,
         widthSegments: 16,
@@ -1064,14 +1783,14 @@ class Ms extends Ee {
     const t = /* @__PURE__ */ new Set();
     this.adjacencyMap.forEach((s, n) => {
       s.forEach((i, r) => {
-        const a = [n, r].sort().join("-");
-        if (t.has(a)) return;
-        t.add(a);
-        const o = this.nodes.get(n), h = this.nodes.get(r);
-        if (o && h) {
-          const l = new rt(o, h), p = new ue({
+        const o = [n, r].sort().join("-");
+        if (t.has(o)) return;
+        t.add(o);
+        const a = this.nodes.get(n), c = this.nodes.get(r);
+        if (a && c) {
+          const h = new Lt(a, c), d = new Pe({
             geometryParameters: {
-              path: l,
+              path: h,
               tubularSegments: 1,
               radius: this.parameters.edgeRadius,
               radialSegments: 8,
@@ -1081,14 +1800,14 @@ class Ms extends Ee {
               color: this.parameters.edgeColor
             }
           });
-          Object.assign(p.userData, { from: n, to: r, weight: i, type: "edge" }), this.graphGroup.add(p);
+          Object.assign(d.userData, { from: n, to: r, weight: i, type: "edge" }), this.graphGroup.add(d);
         }
       });
     }), this.add(this.graphGroup);
   }
   clearGraph() {
     this.graphGroup && (this.remove(this.graphGroup), this.graphGroup.traverse((e) => {
-      e instanceof F && (e.geometry.dispose(), e.material.dispose());
+      e instanceof G && (e.geometry.dispose(), e.material.dispose());
     }), this.graphGroup = null);
   }
   /**
@@ -1096,7 +1815,7 @@ class Ms extends Ee {
    */
   renderPath(e, t = this.parameters.pathColor) {
     if (e.length < 2) return;
-    const s = new at(e, !1, "catmullrom", 0), n = new ue({
+    const s = new It(e, !1, "catmullrom", 0), n = new Pe({
       geometryParameters: {
         path: s,
         tubularSegments: e.length * 10,
@@ -1122,9 +1841,9 @@ class Ms extends Ee {
     });
     const t = [], s = /* @__PURE__ */ new Set();
     return this.adjacencyMap.forEach((n, i) => {
-      n.forEach((r, a) => {
-        const o = [i, a].sort().join("-");
-        s.has(o) || (s.add(o), t.push({ from: i, to: a, weight: r }));
+      n.forEach((r, o) => {
+        const a = [i, o].sort().join("-");
+        s.has(a) || (s.add(a), t.push({ from: i, to: o, weight: r }));
       });
     }), { nodes: e, edges: t };
   }
@@ -1134,7 +1853,7 @@ class Ms extends Ee {
    */
   importData(e) {
     this.clearGraph(), this.clearPaths(), this.nodes.clear(), this.adjacencyMap.clear(), Object.entries(e.nodes).forEach(([t, s]) => {
-      this.addNode(t, new ee(s.x, s.y, s.z));
+      this.addNode(t, new w(s.x, s.y, s.z));
     }), e.edges.forEach(({ from: t, to: s, weight: n }) => {
       this.addEdge(t, s, n);
     }), this.renderGraph();
@@ -1146,7 +1865,7 @@ class Ms extends Ee {
     return this.adjacencyMap.get(e);
   }
 }
-class Es extends Zt {
+class Mn extends $s {
   isPoi = !0;
   type = "Poi";
   parameters = {
@@ -1165,7 +1884,7 @@ class Es extends Zt {
   _canvas = document.createElement("canvas");
   _lastParametersJSON = "";
   constructor(e = {}) {
-    super(new ot()), Object.assign(this.parameters, e), this.updateAsync();
+    super(new Rt()), Object.assign(this.parameters, e), this.updateAsync();
   }
   /**
    * Update the POI with new parameters
@@ -1181,33 +1900,33 @@ class Es extends Zt {
     n.font = `${this.parameters.fontSize}px ${this.parameters.fontFamily}`;
     let i = null;
     this.parameters.img && (i = await this._loadImage(this.parameters.img));
-    const { text: r, fontSize: a, color: o, iconSize: h, padding: l, backgroundColor: p, borderRadius: g, textPosition: u, scaleFactor: w } = this.parameters, v = n.measureText(r), x = r ? v.width : 0, b = r ? a : 0;
-    let f = 0, C = 0, O = 0, P = 0, M = 0, m = 0;
-    const y = !!i, B = !!r;
-    if (y && B)
+    const { text: r, fontSize: o, color: a, iconSize: c, padding: h, backgroundColor: d, borderRadius: p, textPosition: u, scaleFactor: g } = this.parameters, b = n.measureText(r), _ = r ? b.width : 0, x = r ? o : 0;
+    let y = 0, M = 0, E = 0, O = 0, T = 0, f = 0;
+    const v = !!i, z = !!r;
+    if (v && z)
       switch (u) {
         case "top":
-          f = Math.max(h, x), C = h + l + b, M = (f - x) / 2, m = b / 2, O = (f - h) / 2, P = b + l;
+          y = Math.max(c, _), M = c + h + x, T = (y - _) / 2, f = x / 2, E = (y - c) / 2, O = x + h;
           break;
         case "bottom":
-          f = Math.max(h, x), C = h + l + b, O = (f - h) / 2, P = 0, M = (f - x) / 2, m = h + l + b / 2;
+          y = Math.max(c, _), M = c + h + x, E = (y - c) / 2, O = 0, T = (y - _) / 2, f = c + h + x / 2;
           break;
         case "left":
-          f = h + l + x, C = Math.max(h, b), M = 0, m = C / 2, O = x + l, P = (C - h) / 2;
+          y = c + h + _, M = Math.max(c, x), T = 0, f = M / 2, E = _ + h, O = (M - c) / 2;
           break;
         default:
-          f = h + l + x, C = Math.max(h, b), O = 0, P = (C - h) / 2, M = h + l, m = C / 2;
+          y = c + h + _, M = Math.max(c, x), E = 0, O = (M - c) / 2, T = c + h, f = M / 2;
           break;
       }
-    else y ? (f = h, C = h, O = 0, P = 0) : B && (f = x, C = b, M = 0, m = b / 2);
-    const A = f + l * 2, E = C + l * 2;
-    if (s.width = A, s.height = E, n.font = `${a}px ${this.parameters.fontFamily}`, p && (n.fillStyle = p, this._drawRoundedRect(n, 0, 0, A, E, g), n.fill()), y && n.drawImage(i, O + l, P + l, h, h), B) {
-      n.fillStyle = o;
-      const _ = n.measureText(r), N = _.actualBoundingBoxAscent + _.actualBoundingBoxDescent, Be = _.actualBoundingBoxAscent - N / 2;
-      n.textBaseline = "alphabetic", n.fillText(r, M + l, m + l + Be);
+    else v ? (y = c, M = c, E = 0, O = 0) : z && (y = _, M = x, T = 0, f = x / 2);
+    const N = y + h * 2, P = M + h * 2;
+    if (s.width = N, s.height = P, n.font = `${o}px ${this.parameters.fontFamily}`, d && (n.fillStyle = d, this._drawRoundedRect(n, 0, 0, N, P, p), n.fill()), v && n.drawImage(i, E + h, O + h, c, c), z) {
+      n.fillStyle = a;
+      const D = n.measureText(r), k = D.actualBoundingBoxAscent + D.actualBoundingBoxDescent, et = D.actualBoundingBoxAscent - k / 2;
+      n.textBaseline = "alphabetic", n.fillText(r, T + h, f + h + et);
     }
-    const H = this.material.map, k = new ct(s);
-    k.colorSpace = ve, this.material.map = k, H?.dispose(), this.scale.set(A * w, E * w, 1);
+    const X = this.material.map, W = new zt(s);
+    W.colorSpace = De, this.material.map = W, X?.dispose(), this.scale.set(N * g, P * g, 1);
   }
   _loadImage(e) {
     return new Promise((t, s) => {
@@ -1225,80 +1944,80 @@ class Es extends Zt {
     this.material.map?.dispose(), this.material.dispose();
   }
 }
-class Oe extends j {
+class Ke extends $ {
   isShapeMesh = !0;
   type = "ShapeMesh";
   constructor({ geometryParameters: e, materialParameters: t } = {}) {
-    super(), this.geometry = new ht(e?.shape, e?.curveSegments), this.material = new I(t), this.geometry.rotateX(-Math.PI / 2);
+    super(), this.geometry = new Nt(e?.shape, e?.curveSegments), this.material = new R(t), this.geometry.rotateX(-Math.PI / 2);
   }
   static createFromPoints(e, t = {}) {
-    return new Oe({
+    return new Ke({
       ...t,
       geometryParameters: {
         ...t.geometryParameters,
-        shape: new be(e.map((s) => new S(s.x, -s.z)))
+        shape: new ke(e.map((s) => new S(s.x, -s.z)))
       }
     });
   }
 }
-class Pe extends j {
+class Qe extends $ {
   isExtrudeMesh = !0;
   type = "ExtrudeMesh";
   constructor({ geometryParameters: e, materialParameters: t } = {}) {
-    super(), this.geometry = new lt(e?.shape, e?.options), this.material = new I(t), this.geometry.rotateX(-Math.PI / 2);
+    super(), this.geometry = new jt(e?.shape, e?.options), this.material = new R(t), this.geometry.rotateX(-Math.PI / 2);
   }
   static createFromPoints(e, t = {}) {
-    return new Pe({
+    return new Qe({
       ...t,
       geometryParameters: {
         ...t.geometryParameters,
-        shape: new be(e.map((s) => new S(s.x, -s.z)))
+        shape: new ke(e.map((s) => new S(s.x, -s.z)))
       }
     });
   }
 }
-class Os extends j {
+class Tn extends $ {
   isPlaneMesh = !0;
   type = "PlaneMesh";
   constructor({ geometryParameters: e, materialParameters: t } = {}) {
-    super(), this.geometry = new dt(
+    super(), this.geometry = new Dt(
       e?.width,
       e?.height,
       e?.widthSegments,
       e?.heightSegments
-    ), this.material = new I(t);
+    ), this.material = new R(t);
   }
 }
-class Ps extends j {
+class Pn extends $ {
   isCircleMesh = !0;
   type = "CircleMesh";
   constructor({ geometryParameters: e, materialParameters: t } = {}) {
     super(
-      new pt(
+      new kt(
         e?.radius,
         e?.segments,
         e?.thetaStart,
         e?.thetaLength
       ),
-      new I(t)
+      new R(t)
     ), this.geometry.rotateX(-Math.PI / 2);
   }
 }
-class es {
+class F {
   static traverseMeshes(e, t) {
     e.traverse((s) => {
-      s instanceof F && t(s);
+      s instanceof G && t(s);
     });
   }
 }
-class Ss {
+class En {
   static flow(e = {}) {
-    const { baseColor: t = 16777215, flowColor: s = 65280, speed: n = 1, scale: i = 3, intensity: r = 4 } = e, a = U(new D(t)), o = U(new D(s)), h = ae().x.mul(i).sub(q.mul(n)), l = Y(oe(h).add(1).mul(0.5), r);
-    return J(a, o, l);
+    const { baseColor: t = 16777215, flowColor: s = 65280, speed: n = 1, scale: i = 3, intensity: r = 4 } = e, o = H(new U(t)), a = H(new U(s)), c = xe().x.mul(i).sub(te.mul(n)), h = se(pe(c).add(1).mul(0.5), r);
+    return ne(o, a, h);
   }
   static breathe(e = {}) {
-    const { baseColor: t = 16777215, breathColor: s = 65280, speed: n = 1, intensity: i = 2 } = e, r = U(new D(t)), a = U(new D(s)), o = oe(q.mul(n)).add(1).mul(0.5), h = Y(o, i);
-    return J(r, a, h);
+    const { baseColor: t = 16777215, breathColor: s = 65280, speed: n = 1, intensity: i = 2 } = e, r = H(new U(t)), o = H(new U(s)), a = pe(te.mul(n)).add(1).mul(0.5), c = se(a, i);
+    return ne(r, o, c);
   }
   static fluid(e = {}) {
     const {
@@ -1307,43 +2026,149 @@ class Ss {
       speed: n = 1,
       scale: i = 1,
       intensity: r = 1,
-      distortion: a = 0.5
-    } = e, o = U(new D(t)), h = U(new D(s)), l = ae().mul(i), p = q.mul(n), g = ce(l.add(p), 1, 0), u = l.add(g.mul(a)), w = ce(u, 1, 0).add(1).mul(0.5), v = Y(w, r);
-    return J(o, h, v);
+      distortion: o = 0.5
+    } = e, a = H(new U(t)), c = H(new U(s)), h = xe().mul(i), d = te.mul(n), p = Se(h.add(d), 1, 0), u = h.add(p.mul(o)), g = Se(u, 1, 0).add(1).mul(0.5), b = se(g, r);
+    return ne(a, c, b);
   }
 }
-function Ls(c) {
+function On(l) {
 }
-const K = "uSpaceHighlight", se = `${K}/enabled`, Se = `${K}/opacity`, Le = `${K}/color`, Ie = `${K}/overwrite`, ts = Te(() => {
-  const c = G(se, "uint"), e = G(Le, "uint"), t = G(Ie, "uint"), s = ns(e), n = he.mul(s), i = V(t.greaterThan(0), s, n);
-  return V(c.greaterThan(0), i, he);
-})(), ss = Te(() => {
-  const c = G(se, "uint"), e = G(Se, "float");
-  return V(c.greaterThan(0), e, mt);
+const he = "uSpaceHighlight", Q = `${he}/enabled`, qe = `${he}/opacity`, Xe = `${he}/color`, Ye = `${he}/overwrite`, le = "uSpaceBreathe", ae = `${le}/enabled`, Je = `${le}/color`, Ve = `${le}/speed`, Ze = `${le}/intensity`, ce = /* @__PURE__ */ new WeakMap(), Ks = He(() => {
+  const l = A(Q, "uint"), e = A(Xe, "uint"), t = A(Ye, "uint"), s = Ae(e), n = Ce.mul(s), i = ie(t.greaterThan(0), s, n), r = ie(l.greaterThan(0), i, Ce), o = A(ae, "uint"), a = A(Je, "uint"), c = A(Ve, "float"), h = A(Ze, "float"), d = Ae(a), p = pe(te.mul(c)).add(1).mul(0.5), u = se(p, h), g = ne(r, d, u);
+  return ie(o.greaterThan(0), g, r);
+})(), Qs = He(() => {
+  const l = A(Q, "uint"), e = A(qe, "float");
+  return ie(l.greaterThan(0), e, Xt);
 })();
-class Is {
-  static highlight(e, t = {}) {
-    const s = Object.assign(
+function Ee(l) {
+  const e = l.material;
+  if (!e || Array.isArray(e)) return;
+  let t = ce.get(e);
+  t || (t = {
+    colorNode: e.colorNode,
+    opacityNode: e.opacityNode,
+    transparent: e.transparent,
+    depthWrite: e.depthWrite,
+    activeMeshes: /* @__PURE__ */ new Set()
+  }, ce.set(e, t)), t.activeMeshes.add(l), e.transparent = !0, e.colorNode = Ks, e.opacityNode = Qs, e.needsUpdate = !0;
+}
+function Oe(l) {
+  const e = l.userData[Q], t = l.userData[ae];
+  if (e || t) return;
+  const s = l.material;
+  if (!s || Array.isArray(s)) return;
+  const n = ce.get(s);
+  n && (n.activeMeshes.delete(l), !(n.activeMeshes.size > 0) && (s.colorNode = n.colorNode, s.opacityNode = n.opacityNode, s.transparent = n.transparent, s.depthWrite = n.depthWrite, s.needsUpdate = !0, ce.delete(s)));
+}
+class oe {
+  static highlightColor(e, t = {}) {
+    const s = Array.isArray(e) ? e : [e], { opacity: n = 0.5, color: i = 16711680, overwrite: r = !1, depthWrite: o } = t, a = new B(i).getHex();
+    for (const c of s)
+      F.traverseMeshes(c, (h) => {
+        if (h.userData[Q] = 1, h.userData[qe] = n, h.userData[Xe] = a, h.userData[Ye] = r ? 1 : 0, Ee(h), o !== void 0) {
+          const d = h.material;
+          d && !Array.isArray(d) && (d.depthWrite = o);
+        }
+      });
+  }
+  static removeHighlightColor(e) {
+    const t = Array.isArray(e) ? e : [e];
+    for (const s of t)
+      F.traverseMeshes(s, (n) => {
+        n.userData[Q] = 0, Oe(n);
+      });
+  }
+  static breatheColor(e, t = {}) {
+    const s = Array.isArray(e) ? e : [e], n = Object.assign(
       {
-        enabled: !0,
-        opacity: 0.5,
-        color: 16711680,
-        overwrite: !1
+        color: 65280,
+        speed: 1,
+        intensity: 2
       },
       t
     );
-    s.color = new te(s.color).getHex(), es.traverseMeshes(e, (n) => {
-      n.userData[se] = s.enabled ? 1 : 0, n.userData[Se] = s.opacity, n.userData[Le] = s.color, n.userData[Ie] = s.overwrite ? 1 : 0;
-      const i = n.material;
-      i && !Array.isArray(i) && (i.transparent = !0, i.colorNode = ts, i.opacityNode = ss, i.needsUpdate = !0);
+    n.color = new B(n.color).getHex();
+    for (const i of s)
+      F.traverseMeshes(i, (r) => {
+        r.userData[ae] = 1, r.userData[Je] = n.color, r.userData[Ve] = n.speed, r.userData[Ze] = n.intensity, Ee(r);
+      });
+  }
+  static removeBreatheColor(e) {
+    const t = Array.isArray(e) ? e : [e];
+    for (const s of t)
+      F.traverseMeshes(s, (n) => {
+        n.userData[ae] = 0, Oe(n);
+      });
+  }
+  /**
+   * Enable wireframe mode on object(s).
+   */
+  static wireframe(e, t = !0) {
+    const s = Array.isArray(e) ? e : [e];
+    for (const n of s)
+      F.traverseMeshes(n, (i) => {
+        const r = i.material;
+        !r || Array.isArray(r) || (r.wireframe = t, r.needsUpdate = !0);
+      });
+  }
+  /**
+   * Remove wireframe mode.
+   */
+  static removeWireframe(e) {
+    oe.wireframe(e, !1);
+  }
+  /**
+   * Fade in object(s) from fully transparent to original opacity.
+   * Returns a promise that resolves when animation is complete.
+   */
+  static fadeIn(e, t = {}) {
+    const { duration: s = 500 } = t;
+    return oe._fade(e, 0, 1, s);
+  }
+  /**
+   * Fade out object(s) to fully transparent.
+   * Returns a promise that resolves when animation is complete.
+   */
+  static fadeOut(e, t = {}) {
+    const { duration: s = 500 } = t;
+    return oe._fade(e, 1, 0, s);
+  }
+  static _fade(e, t, s, n) {
+    const i = Array.isArray(e) ? e : [e], r = [];
+    for (const o of i)
+      F.traverseMeshes(o, (a) => {
+        const c = a.material;
+        !c || Array.isArray(c) || (c.transparent = !0, c.opacity = t, c.needsUpdate = !0, r.push({ material: c, targetOpacity: s }));
+      });
+    return r.length === 0 ? Promise.resolve() : new Promise((o) => {
+      const a = performance.now();
+      let c = 0;
+      const h = () => {
+        const d = performance.now() - a, p = Math.min(d / n, 1);
+        if (!i[0].parent) {
+          cancelAnimationFrame(c), o();
+          return;
+        }
+        for (const { material: g, targetOpacity: b } of r)
+          g.opacity = t + (b - t) * p, g.needsUpdate = !0;
+        if (p < 1)
+          c = requestAnimationFrame(h);
+        else {
+          if (s >= 1)
+            for (const { material: g } of r)
+              g.transparent = !1;
+          o();
+        }
+      };
+      c = requestAnimationFrame(h);
     });
   }
 }
-const ns = (c) => {
-  const e = c.shiftRight(16).bitAnd(255).toFloat().div(255), t = c.shiftRight(8).bitAnd(255).toFloat().div(255), s = c.bitAnd(255).toFloat().div(255);
-  return gt(e, t, s);
+const Ae = (l) => {
+  const e = l.shiftRight(16).bitAnd(255).toFloat().div(255), t = l.shiftRight(8).bitAnd(255).toFloat().div(255), s = l.bitAnd(255).toFloat().div(255);
+  return Yt(e, t, s);
 };
-class is extends Et {
+class qs extends ms {
   viewer;
   constructor(e, t) {
     super(t), this.viewer = e;
@@ -1352,7 +2177,7 @@ class is extends Et {
     this.update(e) && this.viewer.render();
   };
   easingByMode(e) {
-    const t = rs[e];
+    const t = Xs[e];
     return super.easing(t);
   }
   start(e, t) {
@@ -1362,80 +2187,500 @@ class is extends Et {
     return this.viewer.removeEventListener("afterControlsUpdate", this._update), super.stop();
   }
 }
-function Bs(c, e, t, s = {}, n, i) {
-  return new Promise((r, a) => {
-    const { duration: o = 1e3, delay: h = 0, repeat: l = !1, mode: p = "Linear.None", yoyo: g = !1 } = s, u = new is(c, e).to(t, o).easingByMode(p).delay(h).onUpdate((w) => {
-      n?.(w, u);
+function An(l, e, t, s = {}, n, i) {
+  return new Promise((r, o) => {
+    const { duration: a = 1e3, delay: c = 0, repeat: h = !1, mode: d = "Linear.None", yoyo: p = !1 } = s, u = new qs(l, e).to(t, a).easingByMode(d).delay(c).onUpdate((g) => {
+      n?.(g, u);
     }).onComplete(() => {
       r();
     }).onStop(() => {
-      a("animation stop");
+      o("animation stop");
     }).onStart(() => {
       i?.(u);
     });
-    typeof l == "number" ? u.repeat(l) : typeof l == "boolean" && l && u.repeat(1 / 0), g && u.repeatDelay(20), u.yoyo(g), u.start();
+    typeof h == "number" ? u.repeat(h) : typeof h == "boolean" && h && u.repeat(1 / 0), p && u.repeatDelay(20), u.yoyo(p), u.start();
   });
 }
-const rs = {
-  "Linear.None": d.Linear.None,
-  "Quadratic.In": d.Quadratic.In,
-  "Quadratic.Out": d.Quadratic.Out,
-  "Quadratic.InOut": d.Quadratic.InOut,
-  "Cubic.In": d.Cubic.In,
-  "Cubic.Out": d.Cubic.Out,
-  "Cubic.InOut": d.Cubic.InOut,
-  "Quartic.In": d.Quartic.In,
-  "Quartic.Out": d.Quartic.Out,
-  "Quartic.InOut": d.Quartic.InOut,
-  "Quintic.In": d.Quintic.In,
-  "Quintic.Out": d.Quintic.Out,
-  "Quintic.InOut": d.Quintic.InOut,
-  "Sinusoidal.In": d.Sinusoidal.In,
-  "Sinusoidal.Out": d.Sinusoidal.Out,
-  "Sinusoidal.InOut": d.Sinusoidal.InOut,
-  "Exponential.In": d.Exponential.In,
-  "Exponential.Out": d.Exponential.Out,
-  "Exponential.InOut": d.Exponential.InOut,
-  "Circular.In": d.Circular.In,
-  "Circular.Out": d.Circular.Out,
-  "Circular.InOut": d.Circular.InOut,
-  "Elastic.In": d.Elastic.In,
-  "Elastic.Out": d.Elastic.Out,
-  "Elastic.InOut": d.Elastic.InOut,
-  "Back.In": d.Back.In,
-  "Back.Out": d.Back.Out,
-  "Back.InOut": d.Back.InOut,
-  "Bounce.In": d.Bounce.In,
-  "Bounce.Out": d.Bounce.Out,
-  "Bounce.InOut": d.Bounce.InOut
+const Xs = {
+  "Linear.None": m.Linear.None,
+  "Quadratic.In": m.Quadratic.In,
+  "Quadratic.Out": m.Quadratic.Out,
+  "Quadratic.InOut": m.Quadratic.InOut,
+  "Cubic.In": m.Cubic.In,
+  "Cubic.Out": m.Cubic.Out,
+  "Cubic.InOut": m.Cubic.InOut,
+  "Quartic.In": m.Quartic.In,
+  "Quartic.Out": m.Quartic.Out,
+  "Quartic.InOut": m.Quartic.InOut,
+  "Quintic.In": m.Quintic.In,
+  "Quintic.Out": m.Quintic.Out,
+  "Quintic.InOut": m.Quintic.InOut,
+  "Sinusoidal.In": m.Sinusoidal.In,
+  "Sinusoidal.Out": m.Sinusoidal.Out,
+  "Sinusoidal.InOut": m.Sinusoidal.InOut,
+  "Exponential.In": m.Exponential.In,
+  "Exponential.Out": m.Exponential.Out,
+  "Exponential.InOut": m.Exponential.InOut,
+  "Circular.In": m.Circular.In,
+  "Circular.Out": m.Circular.Out,
+  "Circular.InOut": m.Circular.InOut,
+  "Elastic.In": m.Elastic.In,
+  "Elastic.Out": m.Elastic.Out,
+  "Elastic.InOut": m.Elastic.InOut,
+  "Back.In": m.Back.In,
+  "Back.Out": m.Back.Out,
+  "Back.InOut": m.Back.InOut,
+  "Bounce.In": m.Bounce.In,
+  "Bounce.Out": m.Bounce.Out,
+  "Bounce.InOut": m.Bounce.InOut
 };
+class Bn {
+  scene;
+  planes = /* @__PURE__ */ new Map();
+  helpers = /* @__PURE__ */ new Map();
+  /**
+   * The ClippingGroup node. Objects must be descendants of this group to be clipped.
+   */
+  group;
+  constructor(e) {
+    this.scene = e, this.group = new Ht(), this.group.name = "__clippingToolGroup", this.scene.add(this.group);
+  }
+  /**
+   * Move all current scene children (except the clipping group itself) into the ClippingGroup,
+   * so they are all subject to clipping.
+   */
+  attach() {
+    const e = [...this.scene.children];
+    for (const t of e)
+      t !== this.group && this.group.add(t);
+  }
+  /**
+   * Move all children out of the ClippingGroup back to the scene root.
+   */
+  detach() {
+    const e = [...this.group.children];
+    for (const t of e)
+      this.helpers.has(t.name) || this.scene.add(t);
+  }
+  /**
+   * Enable clipping.
+   */
+  enable() {
+    this.group.enabled = !0;
+  }
+  /**
+   * Disable clipping.
+   */
+  disable() {
+    this.group.enabled = !1;
+  }
+  /**
+   * Add a clipping plane.
+   */
+  addPlane(e, t = {}) {
+    const {
+      normal: s = { x: 0, y: -1, z: 0 },
+      constant: n = 0,
+      showHelper: i = !1,
+      helperSize: r = 5,
+      helperColor: o = 16711680
+    } = t, a = new Ut(new w(s.x, s.y, s.z), n);
+    return this.planes.set(e, a), this._syncPlanes(), i && this.showHelper(e, r, o), a;
+  }
+  /**
+   * Add six clipping planes that form a box around a Box3.
+   * Returns the six plane ids: `${id}_+x`, `${id}_-x`, etc.
+   */
+  addBox(e, t, s = {}) {
+    const { showHelpers: n = !1, helperColor: i = 16711680 } = s, r = t.min, o = t.max, a = [
+      { suffix: "+x", normal: { x: -1, y: 0, z: 0 }, constant: o.x },
+      { suffix: "-x", normal: { x: 1, y: 0, z: 0 }, constant: -r.x },
+      { suffix: "+y", normal: { x: 0, y: -1, z: 0 }, constant: o.y },
+      { suffix: "-y", normal: { x: 0, y: 1, z: 0 }, constant: -r.y },
+      { suffix: "+z", normal: { x: 0, y: 0, z: -1 }, constant: o.z },
+      { suffix: "-z", normal: { x: 0, y: 0, z: 1 }, constant: -r.z }
+    ], c = [];
+    for (const h of a) {
+      const d = `${e}_${h.suffix}`;
+      this.addPlane(d, { normal: h.normal, constant: h.constant, showHelper: n, helperColor: i }), c.push(d);
+    }
+    return c;
+  }
+  /**
+   * Add a clipping box from an object's bounding box with optional padding.
+   */
+  addBoxFromObject(e, t, s = 0, n = {}) {
+    const i = new q().setFromObject(t);
+    return i.expandByScalar(s), this.addBox(e, i, n);
+  }
+  /**
+   * Update a plane's constant (distance from origin).
+   */
+  setPlaneConstant(e, t) {
+    const s = this.planes.get(e);
+    s && (s.constant = t);
+  }
+  /**
+   * Remove a clipping plane.
+   */
+  removePlane(e) {
+    this.planes.delete(e), this.hideHelper(e), this._syncPlanes();
+  }
+  /**
+   * Remove a clipping box (all 6 associated planes).
+   */
+  removeBox(e) {
+    const t = ["+x", "-x", "+y", "-y", "+z", "-z"];
+    for (const s of t)
+      this.removePlane(`${e}_${s}`);
+  }
+  /**
+   * Remove all clipping planes.
+   */
+  removeAll() {
+    const e = Array.from(this.helpers.keys());
+    for (const t of e)
+      this.hideHelper(t);
+    this.planes.clear(), this._syncPlanes();
+  }
+  /**
+   * Show a helper visualization for a clipping plane.
+   */
+  showHelper(e, t = 5, s = 16711680) {
+    this.hideHelper(e);
+    const n = this.planes.get(e);
+    if (!n) return;
+    const i = new Ft(n, t, new B(s).getHex());
+    i.name = e, this.helpers.set(e, i), this.scene.add(i);
+  }
+  /**
+   * Hide a plane helper.
+   */
+  hideHelper(e) {
+    const t = this.helpers.get(e);
+    t && (this.scene.remove(t), t.dispose(), this.helpers.delete(e));
+  }
+  /**
+   * Get a plane by id.
+   */
+  get(e) {
+    return this.planes.get(e);
+  }
+  /**
+   * Sync the planes map into the ClippingGroup's clippingPlanes array.
+   */
+  _syncPlanes() {
+    this.group.clippingPlanes = Array.from(this.planes.values());
+  }
+  dispose() {
+    this.detach(), this.removeAll(), this.scene.remove(this.group);
+  }
+}
+class Ln {
+  scene;
+  measurements = /* @__PURE__ */ new Map();
+  _idCounter = 0;
+  constructor(e) {
+    this.scene = e;
+  }
+  /**
+   * Measure distance between two points.
+   */
+  measureDistance(e, t, s = {}) {
+    const { lineColor: n = 16776960 } = s, i = new w(e.x, e.y, e.z), r = new w(t.x, t.y, t.z), o = i.distanceTo(r), a = `measure_dist_${this._idCounter++}`, c = new I();
+    c.name = a;
+    const h = new K().setFromPoints([i, r]), d = new Z({ color: n }), p = new ee(h, d);
+    c.add(p), this.scene.add(c);
+    const u = {
+      id: a,
+      type: "distance",
+      value: o,
+      unit: "m",
+      points: [i, r],
+      object: c
+    };
+    return this.measurements.set(a, u), u;
+  }
+  /**
+   * Measure the area of a polygon defined by 3+ coplanar points.
+   */
+  measureArea(e, t = {}) {
+    const { lineColor: s = 65280 } = t;
+    if (e.length < 3)
+      throw new Error("MeasureTool.measureArea requires at least 3 points");
+    const n = e.map((u) => new w(u.x, u.y, u.z)), i = this._calculatePolygonArea(n), r = `measure_area_${this._idCounter++}`, o = new I();
+    o.name = r;
+    const a = [...n, n[0]], c = new K().setFromPoints(a), h = new Z({ color: s }), d = new ee(c, h);
+    o.add(d), this.scene.add(o);
+    const p = {
+      id: r,
+      type: "area",
+      value: i,
+      unit: "m²",
+      points: n,
+      object: o
+    };
+    return this.measurements.set(r, p), p;
+  }
+  /**
+   * Measure the angle between three points (vertex at the middle point).
+   */
+  measureAngle(e, t, s, n = {}) {
+    const { lineColor: i = 16746496 } = n, r = new w(e.x, e.y, e.z), o = new w(t.x, t.y, t.z), a = new w(s.x, s.y, s.z), c = r.clone().sub(o).normalize(), h = a.clone().sub(o).normalize(), p = Math.acos(Math.max(-1, Math.min(1, c.dot(h)))) * 180 / Math.PI, u = `measure_angle_${this._idCounter++}`, g = new I();
+    g.name = u;
+    const b = new K().setFromPoints([r, o, a]), _ = new Z({ color: i }), x = new ee(b, _);
+    g.add(x), this.scene.add(g);
+    const y = {
+      id: u,
+      type: "angle",
+      value: p,
+      unit: "°",
+      points: [r, o, a],
+      object: g
+    };
+    return this.measurements.set(u, y), y;
+  }
+  /**
+   * Get a measurement result by id.
+   */
+  get(e) {
+    return this.measurements.get(e);
+  }
+  /**
+   * Remove a measurement by id.
+   */
+  remove(e) {
+    const t = this.measurements.get(e);
+    t && (this.scene.remove(t.object), t.object.traverse((s) => {
+      s.geometry?.dispose(), s.material?.dispose();
+    }), this.measurements.delete(e));
+  }
+  /**
+   * Remove all measurements.
+   */
+  removeAll() {
+    const e = Array.from(this.measurements.keys());
+    for (const t of e)
+      this.remove(t);
+  }
+  /**
+   * Get all measurement results.
+   */
+  getAll() {
+    return Array.from(this.measurements.values());
+  }
+  /**
+   * Calculate polygon area using cross product method (Newell's method).
+   */
+  _calculatePolygonArea(e) {
+    const t = e.length, s = new w();
+    for (let i = 0; i < t; i++) {
+      const r = e[i], o = e[(i + 1) % t], a = new w().crossVectors(r, o);
+      s.add(a);
+    }
+    const n = new w();
+    if (t >= 3) {
+      const i = e[1].clone().sub(e[0]), r = e[2].clone().sub(e[0]);
+      n.crossVectors(i, r).normalize();
+    }
+    return Math.abs(s.dot(n)) / 2;
+  }
+  dispose() {
+    this.removeAll();
+  }
+}
+class In {
+  scene;
+  annotations = /* @__PURE__ */ new Map();
+  _idCounter = 0;
+  _createCSSObject = null;
+  constructor(e) {
+    this.scene = e;
+  }
+  /**
+   * Set the CSS object factory function (from CSSRenderer).
+   * This allows annotations to be rendered as CSS2D/CSS2.5D objects.
+   */
+  setCSSObjectFactory(e) {
+    this._createCSSObject = e;
+  }
+  /**
+   * Add an annotation.
+   */
+  add(e, t) {
+    this.annotations.has(e) && this.remove(e);
+    const s = new I();
+    s.name = `annotation_${e}`;
+    const n = new w(t.position.x, t.position.y, t.position.z);
+    s.position.copy(n);
+    const i = document.createElement("div");
+    if (i.innerHTML = t.content, i.style.cssText = `
+      padding: 4px 8px;
+      background: rgba(0, 0, 0, 0.75);
+      color: #fff;
+      font-size: 12px;
+      border-radius: 4px;
+      pointer-events: auto;
+      white-space: nowrap;
+    `, t.labelStyle)
+      for (const [c, h] of Object.entries(t.labelStyle))
+        h !== void 0 && (i.style[c] = h);
+    let r = null;
+    const o = t.labelOffset || { x: 0, y: 2, z: 0 };
+    if (t.showLeaderLine !== !1) {
+      const { lineColor: c = 16777215 } = t, h = new K().setFromPoints([
+        new w(0, 0, 0),
+        new w(o.x, o.y, o.z)
+      ]), d = new Z({ color: c });
+      r = new ee(h, d), s.add(r);
+    }
+    if (this._createCSSObject) {
+      const c = this._createCSSObject(i);
+      c.position.set(o.x, o.y, o.z), s.add(c);
+    }
+    this.scene.add(s);
+    const a = {
+      id: e,
+      options: t,
+      group: s,
+      labelElement: i,
+      line: r
+    };
+    return this.annotations.set(e, a), a;
+  }
+  /**
+   * Quick-add a text annotation.
+   */
+  addText(e, t, s = {}) {
+    const n = `annotation_${this._idCounter++}`;
+    return this.add(n, {
+      position: t,
+      content: e,
+      ...s
+    });
+  }
+  /**
+   * Update an annotation's content.
+   */
+  updateContent(e, t) {
+    const s = this.annotations.get(e);
+    s && (s.labelElement.innerHTML = t, s.options.content = t);
+  }
+  /**
+   * Update an annotation's position.
+   */
+  updatePosition(e, t) {
+    const s = this.annotations.get(e);
+    s && (s.group.position.set(t.x, t.y, t.z), s.options.position = t);
+  }
+  /**
+   * Show an annotation.
+   */
+  show(e) {
+    const t = this.annotations.get(e);
+    t && (t.group.visible = !0);
+  }
+  /**
+   * Hide an annotation.
+   */
+  hide(e) {
+    const t = this.annotations.get(e);
+    t && (t.group.visible = !1);
+  }
+  /**
+   * Get an annotation by id.
+   */
+  get(e) {
+    return this.annotations.get(e);
+  }
+  /**
+   * Remove an annotation.
+   */
+  remove(e) {
+    const t = this.annotations.get(e);
+    if (t) {
+      const s = [...t.group.children];
+      for (const n of s)
+        t.group.remove(n), n.geometry?.dispose(), n.material?.dispose();
+      this.scene.remove(t.group), this.annotations.delete(e);
+    }
+  }
+  /**
+   * Remove all annotations.
+   */
+  removeAll() {
+    const e = Array.from(this.annotations.keys());
+    for (const t of e)
+      this.remove(t);
+  }
+  /**
+   * Show all annotations.
+   */
+  showAll() {
+    for (const e of this.annotations.values())
+      e.group.visible = !0;
+  }
+  /**
+   * Hide all annotations.
+   */
+  hideAll() {
+    for (const e of this.annotations.values())
+      e.group.visible = !1;
+  }
+  /**
+   * Get all annotation ids.
+   */
+  keys() {
+    return Array.from(this.annotations.keys());
+  }
+  get size() {
+    return this.annotations.size;
+  }
+  dispose() {
+    this.removeAll();
+  }
+}
+const Ys = "0.0.8";
+window.__USPACE__ = { version: Ys };
 export {
-  Ee as BaseGroup,
-  j as BaseMesh,
-  Zt as BaseSprite,
-  Bt as CameraControls,
-  Ps as CircleMesh,
-  Pe as ExtrudeMesh,
-  Ot as InteractionEvent,
-  Pt as InteractionManager,
-  Is as MaterialEffects,
-  W as Model,
-  R as ModelLoaderManager,
-  St as ObjectManager,
-  es as ObjectUtils,
-  Os as PlaneMesh,
-  Es as Poi,
-  Rt as RoomEnvironment,
-  Jt as SBMLoader,
-  Ut as SBMXLoader,
-  Oe as ShapeMesh,
-  Vt as SphereMesh,
-  Ss as TSLEffects,
-  xs as TextureLoaderManager,
-  Ms as Topology,
-  ue as TubeMesh,
-  is as Tween,
-  Cs as Viewer,
-  Ls as reinterpretType,
-  Bs as tweenAnimation
+  In as AnnotationManager,
+  We as BaseGroup,
+  $ as BaseMesh,
+  $s as BaseSprite,
+  Nn as CSS2DObject,
+  Dn as CSS3DObject,
+  kn as CSS3DSprite,
+  Ts as CSSRenderer,
+  vs as CameraControls,
+  Pn as CircleMesh,
+  Bn as ClippingTool,
+  Qe as ExtrudeMesh,
+  gs as InteractionEvent,
+  fs as InteractionManager,
+  xn as LightManager,
+  oe as MaterialEffects,
+  Ln as MeasureTool,
+  re as Model,
+  j as ModelLoaderManager,
+  ys as ObjectManager,
+  F as ObjectUtils,
+  Tn as PlaneMesh,
+  Mn as Poi,
+  ws as RenderPipeline,
+  Ss as RoomEnvironment,
+  Gs as SBMLoader,
+  Es as SBMXLoader,
+  vn as SceneManager,
+  bn as Selection,
+  Ke as ShapeMesh,
+  Ws as SphereMesh,
+  En as TSLEffects,
+  Cn as TextureLoaderManager,
+  _n as Topology,
+  Pe as TubeMesh,
+  qs as Tween,
+  Sn as Viewer,
+  On as reinterpretType,
+  An as tweenAnimation,
+  Ys as version
 };