u-space 0.0.3 → 0.0.5

package/dist/index.js

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