u-space 0.0.1 → 0.0.3

package/dist/index.js

@@ -1,20 +1,20 @@
-import { Raycaster as ue, Vector2 as P, RenderPipeline as Be, Sphere as me, Box3 as ge, Spherical as C, Matrix4 as Re, Quaternion as _e, Vector4 as Ae, Vector3 as we, MathUtils as Ne, PMREMGenerator as Ue, OrthographicCamera as F, TimestampQuery as De, Cache as je, EventDispatcher as ke, Timer as Ge, PerspectiveCamera as W, WebGPURenderer as Fe, PCFShadowMap as He, AgXToneMapping as ze, Scene as $e, Color as J, MeshStandardNodeMaterial as I, Loader as We, LoaderUtils as L, FileLoader as fe, TextureLoader as ye, Group as z, SRGBColorSpace as ve, RepeatWrapping as se, BufferGeometry as Qe, BufferAttribute as ne, Mesh as j, FrontSide as Ke, BackSide as Xe, DoubleSide as qe, REVISION as ie, CubeTextureLoader as Ye, EquirectangularReflectionMapping as Je, Sprite as Ze, SphereGeometry as Ve, TubeGeometry as et, LineCurve3 as tt, CatmullRomCurve3 as st, SpriteNodeMaterial as nt, CanvasTexture as it, ShapeGeometry as rt, Shape as be, ExtrudeGeometry as at, PlaneGeometry as ot, CircleGeometry as ct } from "three/webgpu";
-import { pass as q, blendColor as ht, color as A, uv as re, time as Q, pow as K, sin as ae, mix as X, mx_noise_float as oe, Fn as Te, userData as D, materialColor as ce, select as Y, materialOpacity as lt, vec3 as dt } from "three/tsl";
-import Ce from "camera-controls";
-import { RoomEnvironment as pt } from "three/addons/environments/RoomEnvironment.js";
-import { ViewHelper as ut } from "three/addons/helpers/ViewHelper.js";
-import { GLTFLoader as Me } from "three/addons/loaders/GLTFLoader.js";
-import { FBXLoader as mt } from "three/addons/loaders/FBXLoader.js";
-import { OBJLoader as gt } from "three/addons/loaders/OBJLoader.js";
-import { STLLoader as wt } from "three/addons/loaders/STLLoader.js";
-import { DRACOLoader as ft } from "three/addons/loaders/DRACOLoader.js";
-import { KTX2Loader as yt } from "three/addons/loaders/KTX2Loader.js";
-import { MeshoptDecoder as he } from "three/addons/libs/meshopt_decoder.module.js";
-import { HDRLoader as vt } from "three/addons/loaders/HDRLoader.js";
-import { clone as bt } from "three/addons/utils/SkeletonUtils.js";
-import { Color as N } from "three";
-import { Easing as d, Tween as Tt } from "three/addons/libs/tween.module.js";
-class Ct {
+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 {
   /** The type of event (e.g., 'click', 'pointerdown'). */
   type;
   /** The original 3D object that triggered the event. */
@@ -25,15 +25,19 @@ class Ct {
   intersect;
   /** The original DOM event, or undefined if not applicable. */
   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;
+  _propagationStopped = false;
+  constructor(init) {
+    this.type = init.type;
+    this.target = init.target;
+    this.currentTarget = init.target;
+    this.intersect = init.intersect;
+    this.originalEvent = init.originalEvent;
   }
   /**
    * Stops the event from bubbling up the parent chain.
    */
   stopPropagation() {
-    this._propagationStopped = !0;
+    this._propagationStopped = true;
   }
   /**
    * Returns true if `stopPropagation()` has been called.
@@ -42,109 +46,162 @@ class Ct {
     return this._propagationStopped;
   }
 }
-class Mt {
+class InteractionManager {
   domElement;
   scene;
   camera;
-  raycaster = new ue();
-  pointer = new P();
+  raycaster = new Raycaster();
+  pointer = new Vector2();
   hoveredObject = null;
   pointerDownTime = 0;
-  pointerDownPos = new P();
+  pointerDownPos = new Vector2();
   clickTimer = null;
   longPressThreshold = 500;
   moveThreshold = 0.01;
   /**
-   * The objects to check for intersections.
-   * If not set, it defaults to the children of the scene.
+   * The objects to check for intersections. default to all children of the scene (including nested).
    */
-  targetObjects = null;
+  targetObjects;
   /**
    * Whether to enable pointer move events (pointermove, pointerenter, pointerleave).
    * Disabled by default for performance optimization.
    */
-  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._bindEvents();
+  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();
   }
   /**
    * Updates the camera reference (useful when switching cameras).
    */
-  setCamera(e) {
-    this.camera = e;
+  setCamera(camera) {
+    this.camera = camera;
   }
   _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(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;
+    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;
   }
   _getIntersects() {
     this.raycaster.setFromCamera(this.pointer, this.camera);
-    const e = this.targetObjects || this.scene.children;
-    return this.raycaster.intersectObjects(e, !0);
+    return this.raycaster.intersectObjects(this.targetObjects, true);
   }
   /**
    * Dispatches an event to the target object and bubbles up the parent chain.
    */
-  _dispatchToTarget(e, t, s, n) {
-    const i = new Ct({
-      type: e,
-      target: t,
-      intersect: s,
-      originalEvent: n
+  _dispatchToTarget(type, target, intersect, originalEvent) {
+    const event3d = new InteractionEvent({
+      type,
+      target,
+      intersect,
+      originalEvent
     });
-    let a = t;
-    for (; a && !i.propagationStopped; )
-      i.currentTarget = a, a.dispatchEvent({ type: e, event: i }), a = a.parent;
+    let current = target;
+    while (current && !event3d.propagationStopped) {
+      event3d.currentTarget = current;
+      current.dispatchEvent({ type, event: event3d });
+      current = current.parent;
+    }
   }
   /**
    * Handles a DOM event by raycasting and dispatching to the first intersected object.
    */
-  _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);
+  _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);
   }
   _onClick = (e) => {
-    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);
+    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;
+    }
+    this.clickTimer = setTimeout(() => {
+      this._handleEvent("click", e);
+      this.clickTimer = null;
+    }, 200);
   };
   _onDblClick = (e) => {
-    this.clickTimer && (clearTimeout(this.clickTimer), this.clickTimer = null), this._handleEvent("dblclick", e);
+    if (this.clickTimer) {
+      clearTimeout(this.clickTimer);
+      this.clickTimer = null;
+    }
+    this._handleEvent("dblclick", e);
   };
   _onContextMenu = (e) => {
-    e.preventDefault(), this._handleEvent("contextmenu", 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);
+      }
+    }
+    this._handleEvent("pointerup", e);
   };
-  _onPointerUp = (e) => this._handleEvent("pointerup", e);
   _onPointerMove = (e) => {
     if (!this.pointerMoveEventsEnabled) return;
     this._updatePointer(e);
-    const t = this._getIntersects(), s = t.length > 0 ? t[0].object : null, n = t.length > 0 ? t[0] : null;
-    this.hoveredObject !== s && (this.hoveredObject && this._dispatchToTarget("pointerleave", this.hoveredObject, null, e), this.hoveredObject = s, s && n && this._dispatchToTarget("pointerenter", s, n, e)), s && n && this._dispatchToTarget("pointermove", s, n, e);
+    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);
+    }
   };
   /**
    * 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 xt {
+class ObjectManager {
   idMap = /* @__PURE__ */ new Map();
   nameMap = /* @__PURE__ */ new Map();
   typeMap = /* @__PURE__ */ new Map();
@@ -154,85 +211,117 @@ class xt {
    * Add an object with a custom id.
    * One object can have multiple ids.
    */
-  add(e, t) {
-    if (this.idMap.has(e)) {
-      console.warn(`ObjectManager: Object with id ${e} already exists.`);
+  add(id, object) {
+    if (this.idMap.has(id)) {
+      console.warn(`ObjectManager: Object with id ${id} already exists.`);
       return;
     }
-    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));
+    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);
+    }
   }
   /**
    * Get an object by its custom id.
    */
-  getById(e) {
-    return this.idMap.get(e);
+  getById(id) {
+    return this.idMap.get(id);
   }
   /**
    * Get all objects with a given name.
    */
-  getByName(e) {
-    return this.nameMap.get(e) || /* @__PURE__ */ new Set();
+  getByName(name) {
+    return this.nameMap.get(name) || /* @__PURE__ */ new Set();
   }
   /**
    * Get all objects with a given type.
    */
-  getByType(e) {
-    return this.typeMap.get(e) || /* @__PURE__ */ new Set();
+  getByType(type) {
+    return this.typeMap.get(type) || /* @__PURE__ */ new Set();
   }
   /**
    * Get all ids associated with an object.
    */
-  getObjectIds(e) {
-    return this.objectIds.get(e) || /* @__PURE__ */ new Set();
+  getObjectIds(object) {
+    return this.objectIds.get(object) || /* @__PURE__ */ new Set();
   }
   /**
    * Remove an object and all its associated ids.
    */
-  remove(e) {
-    const t = this.objectIds.get(e);
-    if (t) {
-      for (const s of t)
-        this.idMap.delete(s);
-      this.objectIds.delete(e);
+  remove(object) {
+    const ids = this.objectIds.get(object);
+    if (ids) {
+      for (const id of ids) {
+        this.idMap.delete(id);
+      }
+      this.objectIds.delete(object);
     }
-    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.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.type && this.typeMap.has(e.type)) {
-      const s = this.typeMap.get(e.type);
-      s.delete(e), s.size === 0 && this.typeMap.delete(e.type);
+    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);
+      }
     }
-    this.allObjects.delete(e);
+    this.allObjects.delete(object);
   }
   /**
    * Remove an object by its id.
    */
-  removeById(e) {
-    const t = this.idMap.get(e);
-    t && this.remove(t);
+  removeById(id) {
+    const object = this.idMap.get(id);
+    if (object) {
+      this.remove(object);
+    }
   }
   /**
    * Remove all objects with a given name.
    */
-  removeByName(e) {
-    const t = this.getByName(e);
-    for (const s of t)
-      this.remove(s);
+  removeByName(name) {
+    const objects = this.getByName(name);
+    for (const object of objects) {
+      this.remove(object);
+    }
   }
   /**
    * Remove all objects with a given type.
    */
-  removeByType(e) {
-    const t = this.getByType(e);
-    for (const s of t)
-      this.remove(s);
+  removeByType(type) {
+    const objects = this.getByType(type);
+    for (const object of objects) {
+      this.remove(object);
+    }
   }
   /**
    * 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.
@@ -247,148 +336,202 @@ class xt {
     return this.allObjects.size;
   }
 }
-class Et extends Be {
+class RenderPipeline extends RenderPipeline$1 {
   scene;
   camera;
   currentOutputNode;
   needsUpdateOutputNode;
-  #e;
-  constructor(...e) {
-    const [t, s, n] = e;
-    super(t), this.scene = s, this.camera = n, this.currentOutputNode = q(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;
+  #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;
   }
   resetCurrentOutputNode() {
-    this.currentOutputNode.dispose(), this.currentOutputNode = q(this.scene, this.camera), this.needsUpdateOutputNode = !0;
-  }
-  #t() {
-    let e = this.currentOutputNode;
-    this.#e.size > 0 && this.#e.forEach((t) => {
-      e = ht(e, t);
-    }), this.outputNode = e, this.needsUpdate = !0;
+    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;
   }
   render() {
-    this.needsUpdateOutputNode && (this.#t(), this.needsUpdateOutputNode = !1), super.render();
+    if (this.needsUpdateOutputNode) {
+      this.#updateOutputNode();
+      this.needsUpdateOutputNode = false;
+    }
+    super.render();
   }
 }
-const Ot = {
-  Vector2: P,
-  Vector3: we,
-  Vector4: Ae,
-  Quaternion: _e,
-  Matrix4: Re,
-  Spherical: C,
-  Box3: ge,
-  Sphere: me,
-  Raycaster: ue
+const subsetOfTHREE = {
+  Vector2,
+  Vector3,
+  Vector4,
+  Quaternion,
+  Matrix4,
+  Spherical,
+  Box3,
+  Sphere,
+  Raycaster
 };
-Ce.install({ THREE: Ot });
-class Pt extends Ce {
-  constructor(...e) {
-    super(...e), this.minDistance = 0.2, this.smoothTime = 0.2, this.dollySpeed = 0.2;
+CameraControlsBase.install({ THREE: subsetOfTHREE });
+class CameraControls extends CameraControlsBase {
+  constructor(...args) {
+    super(...args);
+    this.minDistance = 0.2;
+    this.smoothTime = 0.2;
+    this.dollySpeed = 0.2;
   }
   /**
    * Set absolute angle for azimuth to avoid spinning
    */
   absoluteRotations() {
-    this.azimuthAngle = St(this.azimuthAngle, 0);
+    this.azimuthAngle = absoluteAngle(this.azimuthAngle, 0);
   }
-  async flyToBox(e, t = {}) {
-    if (e.isEmpty())
-      return console.warn("CameraControls.flyToBox: The provided Box3 is empty."), !1;
+  async flyToBox(box, options = {}) {
+    if (box.isEmpty()) {
+      console.warn("CameraControls.flyToBox: The provided Box3 is empty.");
+      return false;
+    }
     this.absoluteRotations();
-    const { viewpoint: s = "frontTop", enableTransition: n = !0, padding: i = 0.1, cover: a = !1 } = t, c = [];
-    if (s !== "current") {
-      const r = le[s.toUpperCase()] ?? le.FRONTTOP, h = r.theta, l = r.phi;
-      c.push(
-        this.fitToBox(e, n, {
-          paddingLeft: i,
-          paddingRight: i,
-          paddingTop: i,
-          paddingBottom: i,
-          cover: a
+    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
         })
-      ), c.push(this.rotateTo(h, l, n));
+      );
+      promises.push(this.rotateTo(azimuthAngle, polarAngle, enableTransition));
     } else {
-      const r = new me();
-      e.getBoundingSphere(r), r.radius += i, c.push(this.fitToSphere(r, n));
+      const sphere = new Sphere();
+      box.getBoundingSphere(sphere);
+      sphere.radius += padding;
+      promises.push(this.fitToSphere(sphere, enableTransition));
     }
-    return await Promise.all(c), !0;
+    await Promise.all(promises);
+    return true;
   }
-  async flyToObject(e, t = {}) {
-    const s = new ge().setFromObject(e);
-    return this.flyToBox(s, t);
+  async flyToObject(object, options = {}) {
+    const box = new Box3().setFromObject(object);
+    return this.flyToBox(box, options);
   }
 }
-const le = {
-  LEFT: new C(0, Math.PI / 2, -Math.PI / 2),
-  RIGHT: new C(0, Math.PI / 2, Math.PI / 2),
-  FRONT: new C(0, Math.PI / 2, 0),
-  BACK: new C(0, Math.PI / 2, Math.PI),
-  TOP: new C(0, 0, 0),
-  BOTTOM: new C(0, Math.PI, 0),
-  FRONTTOP: new C(0, Math.PI / 4, 0),
-  BACKTOP: new C(0, Math.PI / 4, Math.PI),
-  LEFTTOP: new C(0, Math.PI / 4, -Math.PI / 2),
-  RIGHTTOP: new C(0, Math.PI / 4, Math.PI / 2),
-  LEFTFRONTTOP: new C(0, Math.PI / 4, -Math.PI / 4),
-  RIGHTFRONTTOP: new C(0, Math.PI / 4, Math.PI / 4),
-  LEFTBACKTOP: new C(0, Math.PI / 4, -Math.PI / 4 * 3),
-  RIGHTBACKTOP: new C(0, Math.PI / 4, Math.PI / 4 * 3)
+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)
 };
-function St(o, e) {
-  const t = o - e;
-  return Ne.euclideanModulo(t + Math.PI, Math.PI * 2) - Math.PI;
+function absoluteAngle(targetAngle, sourceAngle) {
+  const angle = targetAngle - sourceAngle;
+  return MathUtils.euclideanModulo(angle + Math.PI, Math.PI * 2) - Math.PI;
 }
-class Lt {
-  environment = new pt();
+class RoomEnvironment {
+  environment = new RoomEnvironment$1();
   renderer;
   pmremGenerator;
   envMap = null;
-  constructor(e) {
-    this.renderer = e, this.pmremGenerator = new Ue(e);
+  constructor(renderer) {
+    this.renderer = renderer;
+    this.pmremGenerator = new PMREMGenerator(renderer);
   }
   update() {
-    this.envMap || (this.envMap = this.pmremGenerator.fromScene(this.environment).texture);
+    if (!this.envMap) {
+      this.envMap = this.pmremGenerator.fromScene(this.environment).texture;
+    }
   }
   dispose() {
-    this.pmremGenerator.dispose(), this.envMap?.dispose();
+    this.pmremGenerator.dispose();
+    this.envMap?.dispose();
   }
 }
-const G = 128;
-class It extends ut {
+const dim = 128;
+class ViewerHelper extends ViewHelper {
   viewer;
   overlayPass;
-  constructor(e) {
-    super(e.camera, e.el), this.viewer = e;
-    const t = new F(-2, 2, 2, -2, 0, 4);
-    t.position.set(0, 0, 2), this.overlayPass = q(this, t), this.setLabels("x", "y", "z");
+  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");
   }
   _update = () => {
     this.quaternion.copy(this.viewer.camera.quaternion).invert();
-    const e = this.location;
-    let t, s;
-    e.left !== null ? t = e.left : t = this.viewer.el.offsetWidth - G - e.right, e.top !== null ? s = e.top : s = this.viewer.el.offsetHeight - G - e.bottom, this.overlayPass.setViewport(t, s, G, G);
+    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);
   };
   enable() {
-    return this.viewer.renderPipeline.addOverlayPass(this.overlayPass), this.viewer.addEventListener("beforeRender", this._update), this.viewer.render(), this;
+    this.viewer.renderPipeline.addOverlayPass(this.overlayPass);
+    this.viewer.addEventListener("beforeRender", this._update);
+    this.viewer.render();
+    return this;
   }
   disable() {
-    return this.viewer.renderPipeline.removeOverlayPass(this.overlayPass), this.viewer.removeEventListener("beforeRender", this._update), this.viewer.render(), this;
+    this.viewer.renderPipeline.removeOverlayPass(this.overlayPass);
+    this.viewer.removeEventListener("beforeRender", this._update);
+    this.viewer.render();
+    return this;
   }
 }
-class Bt {
+class Info {
   el;
   renderer;
   container;
@@ -398,40 +541,79 @@ class Bt {
   pointsText;
   linesText;
   timestampText;
-  _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(a, c = !0) {
-      const r = document.createElement("span");
-      return c && (r.style.marginLeft = "6px"), r.innerText = a, r;
-    }
-    function i() {
+  _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() {
       return document.createElement("br");
     }
-    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());
+    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());
   }
   update() {
     if (this._enabled) {
-      const { render: e } = this.renderer.info;
-      this.drawCallsText.innerText = e.drawCalls.toString(), this.frameCallsText.innerText = e.frameCalls.toString(), this.trianglesText.innerText = e.triangles.toString(), this.pointsText.innerText = e.points.toString(), this.linesText.innerText = e.lines.toString(), this.renderer.resolveTimestampsAsync(De.RENDER).then((t) => {
-        this.timestampText.innerText = t?.toFixed(2) ?? "0";
+      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";
       });
     }
   }
   enable() {
-    this._enabled = !0, this.el.appendChild(this.container);
+    this._enabled = true;
+    this.el.appendChild(this.container);
   }
   disable() {
-    this._enabled = !1, this.container.remove();
+    this._enabled = false;
+    this.container.remove();
   }
   dispose() {
     this.disable();
   }
 }
-je.enabled = !0;
-class ys extends ke {
+Cache.enabled = true;
+class Viewer extends EventDispatcher {
   el;
   renderer;
   scene;
@@ -446,55 +628,119 @@ class ys extends ke {
   viewerHelper;
   frameCount = 1;
   frameloop = "demand";
-  constructor({ el: e, rendererOptions: t }) {
-    super(), this.el = e, this.renderer = this._initRenderer(t), this.scene = this.createScene(), this.camera = this.createPerspectiveCamera(), this.info = new Bt(this.el, this.renderer), this.controls = new Pt(this.camera, this.renderer.domElement), this.renderPipeline = new Et(this.renderer, this.scene, this.camera), this.timer = new Ge(), this.roomEnvironment = new Lt(this.renderer), this.interactionManager = new Mt(this.renderer.domElement, this.scene, this.camera), this.objectManager = new xt(), this.viewerHelper = new It(this), window.addEventListener("resize", this.onWindowResize);
+  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);
   }
   onWindowResize = () => {
-    const e = this.el.clientWidth, t = this.el.clientHeight;
-    this.camera instanceof W ? (this.camera.aspect = e / t, this.camera.updateProjectionMatrix()) : this.camera instanceof F && (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();
+    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();
   };
   async init() {
-    await this.renderer.init(), this.roomEnvironment.update(), this.scene.environment = this.roomEnvironment.envMap;
-  }
-  setCamera(e) {
-    this.camera = e, this.controls.camera = e, this.interactionManager.setCamera(e), this.renderPipeline.setCamera(e), this.onWindowResize(), this.dispatchEvent({ type: "cameraChange", camera: e });
-  }
-  setCameraByType(e) {
-    e === "perspective" && !(this.camera instanceof W) ? this.setCamera(this.createPerspectiveCamera()) : e === "orthographic" && !(this.camera instanceof F) && this.setCamera(this.createOrthographicCamera());
+    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());
+    }
   }
-  render(e = 1) {
-    return this.frameCount += e, new Promise((t) => {
-      const s = () => {
-        this.removeEventListener("afterRender", s), t();
+  render(frame = 1) {
+    this.frameCount += frame;
+    return new Promise((resolve) => {
+      const fn = () => {
+        this.removeEventListener("afterRender", fn);
+        resolve();
       };
-      this.addEventListener("afterRender", s);
+      this.addEventListener("afterRender", fn);
     });
   }
-  animate = (e) => {
-    this.timer.update(e), this.dispatchEvent({ type: "beforeControlsUpdate", time: e });
-    let t = this.controls.update(this.timer.getDelta());
-    this.dispatchEvent({ type: "afterControlsUpdate", time: e }), this.frameCount > 0 && (this.frameCount--, t = !0), this.frameloop === "always" && (t = !0), t && (this.dispatchEvent({ type: "beforeRender", time: e }), this.renderer.info.reset(), this.renderPipeline.render(), this.info.update(), this.dispatchEvent({ type: "afterRender", time: e }));
+  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 });
+    }
   };
-  _initRenderer(e) {
-    const t = new Fe({
-      logarithmicDepthBuffer: !0,
-      antialias: !1,
-      depth: !1,
-      trackTimestamp: !0,
-      ...e
+  _initRenderer(rendererOptions) {
+    const renderer = new WebGPURenderer({
+      logarithmicDepthBuffer: true,
+      antialias: false,
+      depth: false,
+      trackTimestamp: true,
+      ...rendererOptions
     });
-    return t.setSize(this.el.clientWidth, this.el.clientHeight), t.shadowMap.enabled = !0, t.shadowMap.type = He, t.toneMapping = ze, t.toneMappingExposure = 1, t.info.autoReset = !1, t.setPixelRatio(window.devicePixelRatio), t.setAnimationLoop(this.animate), this.el.appendChild(t.domElement), t;
+    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;
   }
   createScene() {
-    const e = new $e();
-    return e.background = new J(0), e;
+    const scene = new Scene();
+    scene.background = new Color(0);
+    return scene;
   }
   createPerspectiveCamera() {
-    const e = new W(50, this.el.clientWidth / this.el.clientHeight, 0.1, 1e5);
-    return e.position.setScalar(5), e;
+    const camera = new PerspectiveCamera(50, this.el.clientWidth / this.el.clientHeight, 0.1, 1e5);
+    camera.position.setScalar(5);
+    return camera;
   }
   createOrthographicCamera() {
-    const e = new F(
+    const camera = new OrthographicCamera(
       -this.el.clientWidth / 2,
       this.el.clientWidth / 2,
       this.el.clientHeight / 2,
@@ -502,415 +748,621 @@ class ys extends ke {
       0.1,
       1e5
     );
-    return e.position.setScalar(5), e;
+    camera.position.setScalar(5);
+    return camera;
   }
   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 Rt extends Me {
-  constructor(e) {
-    super(e);
-  }
-  parse(e, t, s, n) {
-    if (_t(e.slice(0, 8)) === "SBMG----") {
-      const a = At(e.slice(8));
-      return super.parse(a, t, s, n);
-    } else
-      return super.parse(e, t, s, n);
+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);
+      }
+    }
   }
 }
-function _t(o) {
-  return new TextDecoder().decode(new Uint8Array(o));
+function getAsciiString(buf) {
+  const decoder = new TextDecoder();
+  return decoder.decode(new Uint8Array(buf));
 }
-function At(o) {
-  const e = new DataView(o);
-  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;
+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;
 }
-const Nt = 8, Ut = 130, de = 66, Dt = "SBK-----", jt = "SBM-----", xe = new TextDecoder(), kt = new TextEncoder();
-function Gt(o) {
-  let e = Nt;
-  const t = new Uint8Array(o, 0, e);
-  if (xe.decode(t) !== Dt)
-    return o;
-  e += Ut;
-  const n = new Uint8Array(o, 0, e);
-  if (n[40] === 1) {
-    const a = kt.encode(jt), c = new Uint8Array([n[41]]), r = Ft(n), h = Ht(r);
-    let l = de % h.length;
-    const u = e + de, f = new Uint8Array(o, u), p = new Uint8Array(f.length);
-    for (let w = 0; w < f.length; w++)
-      p[w] = f[w] ^ h[l], l = (l + 1) % h.length;
-    const g = new Uint8Array(a.length + c.length + p.length);
-    return g.set(a), g.set(c, a.length), g.set(p, a.length + c.length), g.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;
   }
 }
-function Ft(o) {
-  const e = new Uint8Array(128);
-  return e.set(o.slice(42, 74), 0), e.set(o.slice(74, 138), 32), e.set(o.slice(8, 40), 96), e;
+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 Ht(o) {
-  const e = new Uint8Array(64);
-  return e.set(o.slice(0, 8), 0), e.set(o.slice(24, 32), 8), e.set(o.slice(40, 56), 16), e.set(o.slice(64, 88), 32), e.set(o.slice(96, 104), 56), 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;
 }
-const zt = (o, e, t) => {
-  const s = o.buffer.slice(t, t + e);
-  let n = xe.decode(s);
-  return n = n.replace("\\", "/"), n.startsWith("Maps/") || (n = `Maps/${n}`), n;
-}, $t = (o, e, t) => {
-  const [s, n, i, a, c] = e, r = t || a < 1;
-  return new I({
-    name: o,
-    color: new J(s, n, i),
-    opacity: a,
-    transparent: r,
+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,
     alphaTest: 0.01,
-    side: c
+    side
   });
-}, Wt = (o) => o?.toLowerCase().endsWith(".png") ?? !1;
-class Qt {
+  return material;
+};
+const isPNG = (textureUrl) => {
+  return textureUrl?.toLowerCase().endsWith(".png") ?? false;
+};
+class SBMParser {
   data;
   options;
   textureLoader;
-  littleEndian = !0;
+  littleEndian = true;
   materials = /* @__PURE__ */ new Map();
-  constructor(e, t) {
-    this.data = e, this.options = t, this.textureLoader = new ye(t.manager), this.textureLoader.setCrossOrigin(t.crossOrigin), this.textureLoader.setRequestHeader(t.requestHeader);
-  }
-  parse(e, t) {
-    let s = this.data;
-    const n = Gt(this.data);
-    n && (s = n);
-    const i = new DataView(s);
-    let a = 8;
-    const c = i.getUint8(a);
-    a += 1, c === 1 ? this._parseV2(i, a, e) : c === 2 ? this._parseV2(i, a, e) : c === 3 ? this._parseV3(i, a, e) : t?.(new Error(`SBMLoader: Unsupported SBM version: ${c}`));
-  }
-  _parseV2(e, t, s) {
-    const n = new z(), i = e.getUint16(t, this.littleEndian);
-    t += 2;
-    const a = e.getUint16(t, this.littleEndian);
-    t += 2;
-    for (let c = 0; c < i; ++c) {
-      const r = 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 u = e.getFloat32(t, this.littleEndian);
-      t += 4;
-      const f = e.getFloat32(t, this.littleEndian);
-      t += 4, t += 4, t += 4, t += 4, t += 4;
-      let p = e.getUint8(t);
-      t += 1, p === 0 ? p = Ke : p === 1 ? p = Xe : p === 2 && (p = qe);
-      const g = e.getUint16(t, this.littleEndian);
-      t += 2;
-      const w = g > 0 ? zt(e, g, t) : "";
-      if (t += g, !this.materials.has(r)) {
-        const v = $t(r, [h, l, u, f, p], Wt(w));
-        this.materials.set(r, v), w && this.options.path && this.textureLoader.load(L.resolveURL(w, this.options.path), (b) => {
-          b.colorSpace = ve, b.wrapS = se, b.wrapT = se, b.flipY = !1, b.anisotropy = 16, v.map = b;
-        });
+  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;
+          });
+        }
       }
     }
-    for (let c = 0; c < a; ++c) {
-      const r = e.getUint16(t, this.littleEndian).toString();
-      t += 2;
-      const h = e.getUint16(t, this.littleEndian).toString();
-      t += 2;
-      const l = [], u = [], f = [], p = [], g = e.getUint16(t, this.littleEndian);
-      if (t += 2, g > 0)
-        for (let m = 0; m < g; m++) {
-          const y = new we();
-          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);
+    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 w = e.getUint16(t, this.littleEndian);
-      if (t += 2, w > 0)
-        for (let m = 0; m < w; m++)
-          t += 4, t += 4, t += 4;
-      const T = e.getUint16(t, this.littleEndian);
-      if (t += 2, T > 0)
-        for (let m = 0; m < T; m++) {
-          const y = new P();
-          y.setX(e.getFloat32(t, this.littleEndian)), t += 4, y.setY(e.getFloat32(t, this.littleEndian)), t += 4, u.push(y);
+      }
+      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 v = e.getUint16(t, this.littleEndian);
-      if (t += 2, v > 0)
-        for (let m = 0; m < v; m++) {
-          const y = e.getUint16(t, this.littleEndian);
-          t += 2;
-          const B = e.getUint16(t, this.littleEndian);
-          t += 2;
-          const _ = e.getUint16(t, this.littleEndian);
-          t += 2;
-          const O = [y, B, _];
-          f.push(O), u.length > 0 && p.push([u[O[0]], u[O[1]], u[O[2]]]);
+      }
+      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);
+        }
+      }
+      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 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 = [], M = [];
-      for (let m = 0; m < f.length; m++) {
-        const y = f[m], B = l[y[0]], _ = l[y[1]], O = l[y[2]];
-        b.push(...B.toArray(), ..._.toArray(), ...O.toArray());
-        let V = new P(), ee = new P(), te = new P();
-        const k = p[m];
-        k !== void 0 && (V = k[0], ee = k[1], te = k[2]), M.push(...V.toArray(), ...ee.toArray(), ...te.toArray());
+        uvs.push(...uv2.toArray(), ...uv22.toArray(), ...uv3.toArray());
       }
-      const x = new Float32Array(b), E = new Float32Array(M), S = new Qe();
-      if (x.length > 0 && S.setAttribute("position", new ne(x, 3)), E.length > 0 && S.setAttribute("uv", new ne(E, 2)), S.computeVertexNormals(), this.materials.has(h)) {
-        const m = new j(S, this.materials.get(h));
-        m.name = r, m.castShadow = !0, m.receiveShadow = !0, n.add(m);
+      const positionArray = new Float32Array(positions), uvArray = new Float32Array(uvs);
+      const bufferGeometry = new BufferGeometry();
+      if (positionArray.length > 0) {
+        bufferGeometry.setAttribute("position", new BufferAttribute(positionArray, 3));
+      }
+      if (uvArray.length > 0) {
+        bufferGeometry.setAttribute("uv", new BufferAttribute(uvArray, 2));
+      }
+      bufferGeometry.computeVertexNormals();
+      if (this.materials.has(materialId)) {
+        const sbmChild = new Mesh(bufferGeometry, this.materials.get(materialId));
+        sbmChild.name = meshId;
+        sbmChild.castShadow = true;
+        sbmChild.receiveShadow = true;
+        sbm.add(sbmChild);
       }
     }
-    s(n);
+    onLoad(sbm);
   }
-  _parseV3(e, t, s) {
-    const n = new z();
-    console.warn("SBMLoader: SBM version 3 is not supported yet."), s(n);
+  _parseV3(_dataView, _offset, onLoad) {
+    const sbm = new Group();
+    console.warn("SBMLoader: SBM version 3 is not supported yet.");
+    onLoad(sbm);
   }
 }
-class Kt extends We {
-  load(e, t, s, n) {
-    let i;
-    if (this.resourcePath !== "")
-      i = this.resourcePath;
-    else if (this.path !== "") {
-      const r = L.extractUrlBase(e);
-      i = L.resolveURL(r, this.path);
-    } else
-      i = L.extractUrlBase(e);
-    this.manager.itemStart(e);
-    const a = (r) => {
-      n ? n(r) : console.error(r), this.manager.itemError(e), this.manager.itemEnd(e);
-    }, c = new fe(this.manager);
-    c.setPath(this.path), c.setResponseType("arraybuffer"), c.setRequestHeader(this.requestHeader), c.setWithCredentials(this.withCredentials), c.load(
-      e,
-      (r) => {
+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) => {
         try {
           this.parse(
-            r,
-            i,
-            (h) => {
-              t(h), this.manager.itemEnd(e);
+            data,
+            resourcePath,
+            (sbm) => {
+              onLoad(sbm);
+              this.manager.itemEnd(url);
             },
-            a
+            _onError
           );
-        } catch (h) {
-          a(h);
+        } catch (e) {
+          _onError(e);
         }
       },
-      s,
-      a
+      onProgress,
+      _onError
     );
   }
-  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}`));
+  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}`));
       return;
     }
-    new Qt(e, {
-      path: t,
+    const parser = new SBMParser(data, {
+      path,
       crossOrigin: this.crossOrigin,
       requestHeader: this.requestHeader,
       manager: this.manager
-    }).parse(s, n);
+    });
+    parser.parse(onLoad, onError);
   }
-  parseAsync(e, t) {
-    return new Promise((s, n) => {
+  parseAsync(data, path) {
+    return new Promise((resolve, reject) => {
       this.parse(
-        e,
-        t,
-        (i) => {
-          s(i);
+        data,
+        path,
+        (sbm) => {
+          resolve(sbm);
         },
-        (i) => {
-          n(i);
+        (err) => {
+          reject(err);
         }
       );
     });
   }
 }
-class R {
+class ModelLoaderManager {
   static CACHE_NAME = "u-space-model-loader-cache";
-  static fileLoader = new fe().setResponseType("arraybuffer");
-  static dracoLoader = new ft().setDecoderPath(
-    `https://cdn.jsdelivr.net/npm/three@0.${ie}.0/examples/jsm/libs/draco/`
+  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 ktx2Loader = new yt().setTranscoderPath(
-    `https://cdn.jsdelivr.net/npm/three@0.${ie}.0/examples/jsm/libs/basis/`
+  static ktx2Loader = new KTX2Loader().setTranscoderPath(
+    `https://cdn.jsdelivr.net/npm/three@0.${REVISION}.0/examples/jsm/libs/basis/`
   );
-  static gltfLoader = new Me().setDRACOLoader(R.dracoLoader).setKTX2Loader(R.ktx2Loader).setMeshoptDecoder(he);
-  static sbmxLoader = new Rt().setDRACOLoader(R.dracoLoader).setKTX2Loader(R.ktx2Loader).setMeshoptDecoder(he);
-  static sbmLoader = new Kt();
-  static fbxLoader = new mt();
-  static objLoader = new gt();
-  static stlLoader = new wt();
-  static setLoadingManager(e) {
-    this.fileLoader.manager = e, this.dracoLoader.manager = e, this.ktx2Loader.manager = e, this.gltfLoader.manager = e, this.sbmxLoader.manager = e, this.sbmLoader.manager = e, this.fbxLoader.manager = e, this.objLoader.manager = e, this.stlLoader.manager = e;
+  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;
   }
   /**
    * Set the renderer to enable KTX2 support and other renderer-dependent features.
    */
-  static async setRenderer(e) {
-    await e.init(), this.ktx2Loader.detectSupport(e);
+  static async setRenderer(renderer) {
+    await renderer.init();
+    this.ktx2Loader.detectSupport(renderer);
   }
   /**
    * Configure Draco decoder path.
    */
-  static setDracoPath(e) {
-    this.dracoLoader.setDecoderPath(e);
+  static setDracoPath(path) {
+    this.dracoLoader.setDecoderPath(path);
   }
   /**
    * Configure KTX2 transcoder path.
    */
-  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) {
+  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) {
       case "gltf":
       case "glb":
-        return (await this.gltfLoader.parseAsync(n, L.extractUrlBase(e))).scene;
+        const gltf = await this.gltfLoader.parseAsync(buffer, LoaderUtils.extractUrlBase(url));
+        return gltf.scene;
       case "sbmx":
-        return (await this.sbmxLoader.parseAsync(n, L.extractUrlBase(e))).scene;
+        const sbmx = await this.sbmxLoader.parseAsync(buffer, LoaderUtils.extractUrlBase(url));
+        return sbmx.scene;
       case "sbm":
-        return await this.sbmLoader.parseAsync(n, L.extractUrlBase(e));
+        const sbm = await this.sbmLoader.parseAsync(buffer, LoaderUtils.extractUrlBase(url));
+        return sbm;
       case "fbx":
-        return this.fbxLoader.parse(n, L.extractUrlBase(e));
+        const fbx = this.fbxLoader.parse(buffer, LoaderUtils.extractUrlBase(url));
+        return fbx;
       case "obj":
-        const h = new TextDecoder().decode(n);
-        return this.objLoader.parse(h);
+        const text = new TextDecoder().decode(buffer);
+        const obj = this.objLoader.parse(text);
+        return obj;
       case "stl":
-        const u = this.stlLoader.parse(n);
-        return new j(u, new I());
+        const geometry = this.stlLoader.parse(buffer);
+        const mesh = new Mesh(geometry, new MeshStandardNodeMaterial());
+        return mesh;
       default:
-        throw new Error(`Unsupported model format: ${s}`);
+        throw new Error(`Unsupported model format: ${extension}`);
     }
   }
-  static async getPersistentData(e) {
+  static async getPersistentData(url) {
     try {
-      const t = await caches.open(this.CACHE_NAME), s = await t.match(e);
-      if (s)
-        return await s.arrayBuffer();
-      const n = await this.fileLoader.loadAsync(e), i = new Response(n);
-      return await t.put(e, i), n;
-    } catch (t) {
-      return console.warn(`[LoaderManager] Failed to use Cache API for ${e}:`, t), await this.fileLoader.loadAsync(e);
+      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);
     }
   }
 }
-class vs {
-  static textureLoader = new ye();
-  static hdrLoader = new vt();
-  static cubeTextureLoader = new Ye();
-  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 = Je, t;
-  }
-  static async loadAsyncCubeTexture(e, t) {
-    return this.cubeTextureLoader.setPath(e), await this.cubeTextureLoader.loadAsync(t);
+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 U extends j {
-  isBaseMesh = !0;
+class BaseMesh extends Mesh {
+  isBaseMesh = true;
   type = "BaseMesh";
-  ignoreInvisibleWhenRaycast = !0;
-  constructor(...e) {
-    super(...e);
+  ignoreInvisibleWhenRaycast = true;
+  constructor(...args) {
+    super(...args);
   }
-  raycast(e, t) {
-    return this.visible === !1 && this.ignoreInvisibleWhenRaycast === !0 ? !1 : super.raycast(e, t);
+  raycast(raycaster, intersects) {
+    if (this.visible === false && this.ignoreInvisibleWhenRaycast === true) {
+      return false;
+    }
+    return super.raycast(raycaster, intersects);
   }
 }
-class Ee extends z {
-  isBaseGroup = !0;
+class BaseGroup extends Group {
+  isBaseGroup = true;
   type = "BaseGroup";
-  ignoreInvisibleWhenRaycast = !0;
-  constructor(...e) {
-    super(...e);
+  ignoreInvisibleWhenRaycast = true;
+  constructor(...args) {
+    super(...args);
   }
-  raycast(e, t) {
-    return this.visible === !1 && this.ignoreInvisibleWhenRaycast === !0 ? !1 : super.raycast(e, t);
+  raycast(raycaster, intersects) {
+    if (this.visible === false && this.ignoreInvisibleWhenRaycast === true) {
+      return false;
+    }
+    return super.raycast(raycaster, intersects);
   }
 }
-class Xt extends Ze {
-  isBaseSprite = !0;
+class BaseSprite extends Sprite {
+  isBaseSprite = true;
   type = "BaseSprite";
-  ignoreInvisibleWhenRaycast = !0;
-  constructor(...e) {
-    super(...e);
+  ignoreInvisibleWhenRaycast = true;
+  constructor(...args) {
+    super(...args);
   }
-  raycast(e, t) {
-    return this.visible === !1 && this.ignoreInvisibleWhenRaycast === !0 ? !1 : super.raycast(e, t);
+  raycast(raycaster, intersects) {
+    if (this.visible === false && this.ignoreInvisibleWhenRaycast === true) {
+      return false;
+    }
+    return super.raycast(raycaster, intersects);
   }
 }
-class H extends Ee {
-  isModel = !0;
+class Model extends BaseGroup {
+  isModel = true;
   type = "Model";
   static memoryCache = /* @__PURE__ */ new Map();
   constructor() {
     super();
   }
-  async loadAsync(e) {
-    const { url: t, cache: s = !0, persistent: n = !0 } = e;
+  async loadAsync(parameters) {
+    const { url, cache = true, persistent = true } = parameters;
     try {
-      let i;
-      s ? H.memoryCache.has(t) ? i = H.memoryCache.get(t) : (i = R.loadAsync(t, { persistent: n }), H.memoryCache.set(t, i)) : i = R.loadAsync(t, { persistent: n });
-      const a = await i, c = bt(a);
-      return this.add(c), c;
-    } catch (i) {
-      return console.error(`[Model] Failed to load model from ${t}:`, i), null;
+      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;
     }
   }
   static clearMemoryCache() {
     this.memoryCache.clear();
   }
   static async clearPersistentCache() {
-    typeof caches < "u" && await caches.delete("u-space-loader-cache");
+    if (typeof caches !== "undefined") {
+      await caches.delete("u-space-loader-cache");
+    }
   }
 }
-class qt extends U {
-  isSphereMesh = !0;
+class SphereMesh extends BaseMesh {
+  isSphereMesh = true;
   type = "SphereMesh";
-  constructor({ geometryParameters: e, materialParameters: t } = {}) {
-    super(), this.geometry = new Ve(
-      e?.radius,
-      e?.widthSegments,
-      e?.heightSegments,
-      e?.phiStart,
-      e?.phiLength,
-      e?.thetaStart,
-      e?.thetaLength
-    ), this.material = new I(t);
+  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);
   }
 }
-class pe extends U {
-  isTubeMesh = !0;
+class TubeMesh extends BaseMesh {
+  isTubeMesh = true;
   type = "TubeMesh";
-  constructor({ geometryParameters: e, materialParameters: t } = {}) {
-    super(), this.geometry = new et(
-      e?.path,
-      e?.tubularSegments,
-      e?.radius,
-      e?.radialSegments,
-      e?.closed
-    ), this.material = new I(t);
+  constructor({ geometryParameters, materialParameters } = {}) {
+    super();
+    this.geometry = new TubeGeometry(
+      geometryParameters?.path,
+      geometryParameters?.tubularSegments,
+      geometryParameters?.radius,
+      geometryParameters?.radialSegments,
+      geometryParameters?.closed
+    );
+    this.material = new MeshStandardNodeMaterial(materialParameters);
   }
 }
-class bs extends Ee {
-  isTopology = !0;
+class Topology extends BaseGroup {
+  isTopology = true;
   type = "Topology";
   // Visuals
   parameters = {
@@ -925,27 +1377,37 @@ class bs extends Ee {
   adjacencyMap = /* @__PURE__ */ new Map();
   graphGroup = null;
   pathMeshes = [];
-  constructor(e) {
-    super(), e && Object.assign(this.parameters, e);
+  constructor(parameters) {
+    super();
+    if (parameters) {
+      Object.assign(this.parameters, parameters);
+    }
   }
   /**
    * Add a node to the topology graph.
    * @param id Unique identifier for the node
    * @param position 3D position of the node
    */
-  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());
+  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());
+    }
   }
   /**
    * Remove a node from the topology graph.
    * @param id Unique identifier for the node
    */
-  removeNode(e) {
-    if (!this.nodes.has(e)) {
-      console.warn(`[Topology] Node ${e} does not exist.`);
+  removeNode(id) {
+    if (!this.nodes.has(id)) {
+      console.warn(`[Topology] Node ${id} does not exist.`);
       return;
     }
-    this.nodes.delete(e), this.adjacencyMap.delete(e);
+    this.nodes.delete(id);
+    this.adjacencyMap.delete(id);
   }
   /**
    * Add an edge between two nodes.
@@ -954,14 +1416,18 @@ class bs extends Ee {
    * @param weight Cost of the edge. Defaults to Euclidean distance.
    * @param bidirectional If true, adds the reverse edge as well. Default true.
    */
-  addEdge(e, t, s, n = !0) {
-    const i = this.nodes.get(e), a = this.nodes.get(t);
-    if (!i || !a) {
-      console.error(`[Topology] Cannot add edge. One or both nodes not found: ${e}, ${t}`);
+  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}`);
       return;
     }
-    const c = s ?? i.distanceTo(a);
-    this.getNeighbors(e)?.set(t, c), n && this.getNeighbors(t)?.set(e, c);
+    const dist = weight ?? fromPos.distanceTo(toPos);
+    this.getNeighbors(from)?.set(to, dist);
+    if (bidirectional) {
+      this.getNeighbors(to)?.set(from, dist);
+    }
   }
   /**
    * Remove an edge between two nodes.
@@ -969,51 +1435,80 @@ class bs extends Ee {
    * @param to Node ID
    * @param bidirectional If true, removes the reverse edge as well. Default true.
    */
-  removeEdge(e, t, s = !0) {
-    this.getNeighbors(e)?.delete(t), s && this.getNeighbors(t)?.delete(e);
+  removeEdge(from, to, bidirectional = true) {
+    const fromNeighbors = this.getNeighbors(from);
+    fromNeighbors?.delete(to);
+    if (bidirectional) {
+      const toNeighbors = this.getNeighbors(to);
+      toNeighbors?.delete(from);
+    }
   }
   /**
    * Find the shortest path between start and end nodes using Dijkstra's algorithm.
    */
-  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 [r] of this.nodes)
-      s.set(r, 1 / 0), n.set(r, null), i.add(r);
-    for (s.set(e, 0); i.size > 0; ) {
-      let r = null, h = 1 / 0;
-      for (const u of i) {
-        const f = s.get(u);
-        f < h && (h = f, r = u);
+  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;
       }
-      if (r === null || r === t || h === 1 / 0)
+      if (minDist === Infinity) {
         break;
-      i.delete(r);
-      const l = this.adjacencyMap?.get(r);
-      if (l)
-        for (const [u, f] of l) {
-          if (!i.has(u)) continue;
-          const p = s.get(r) + f;
-          p < s.get(u) && (s.set(u, p), n.set(u, r));
+      }
+      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);
         }
+      }
     }
-    const a = [];
-    let c = t;
-    if (n.get(t) === null && e !== t)
+    const path = [];
+    let curr = endId;
+    if (previous.get(endId) === null && startId !== endId) {
       return [];
-    for (; c !== null; ) {
-      const r = this.nodes.get(c);
-      r && a.unshift(r), c = n.get(c) || null;
     }
-    return a;
+    while (curr !== null) {
+      const pos = this.nodes.get(curr);
+      if (pos) path.unshift(pos);
+      curr = previous.get(curr) || null;
+    }
+    return path;
   }
   /**
    * Renders the entire topology graph structure using TubeGeometry and Spheres.
    */
   renderGraph() {
-    this.clearGraph(), this.graphGroup = new z();
-    const e = new qt({
+    this.clearGraph();
+    this.graphGroup = new Group();
+    const _dummySphere = new SphereMesh({
       geometryParameters: {
         radius: this.parameters.nodeRadius,
         widthSegments: 16,
@@ -1023,72 +1518,128 @@ class bs extends Ee {
         color: this.parameters.nodeColor
       }
     });
-    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);
+    this.nodes.forEach((pos, id) => {
+      const nodeMesh = _dummySphere.clone();
+      nodeMesh.position.copy(pos);
+      Object.assign(nodeMesh.userData, { id, type: "node" });
+      this.graphGroup.add(nodeMesh);
     });
-    const t = /* @__PURE__ */ new Set();
-    this.adjacencyMap.forEach((s, n) => {
-      s.forEach((i, a) => {
-        const c = [n, a].sort().join("-");
-        if (t.has(c)) return;
-        t.add(c);
-        const r = this.nodes.get(n), h = this.nodes.get(a);
-        if (r && h) {
-          const l = new tt(r, h), u = new pe({
+    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({
             geometryParameters: {
-              path: l,
+              path,
               tubularSegments: 1,
               radius: this.parameters.edgeRadius,
               radialSegments: 8,
-              closed: !1
+              closed: false
             },
             materialParameters: {
               color: this.parameters.edgeColor
             }
           });
-          Object.assign(u.userData, { from: n, to: a, weight: i, type: "edge" }), this.graphGroup.add(u);
+          Object.assign(tubeMesh.userData, { from, to, weight, type: "edge" });
+          this.graphGroup.add(tubeMesh);
         }
       });
-    }), this.add(this.graphGroup);
+    });
+    this.add(this.graphGroup);
   }
   clearGraph() {
-    this.graphGroup && (this.remove(this.graphGroup), this.graphGroup.traverse((e) => {
-      e instanceof j && (e.geometry.dispose(), e.material.dispose());
-    }), this.graphGroup = null);
+    if (this.graphGroup) {
+      this.remove(this.graphGroup);
+      this.graphGroup.traverse((child) => {
+        if (child instanceof Mesh) {
+          child.geometry.dispose();
+          child.material.dispose();
+        }
+      });
+      this.graphGroup = null;
+    }
   }
   /**
    * Visualizes a path using TubeGeometry (CatmullRomCurve3).
    */
-  renderPath(e, t = this.parameters.pathColor) {
-    if (e.length < 2) return;
-    const s = new st(e, !1, "catmullrom", 0), n = new pe({
+  renderPath(points, color2 = this.parameters.pathColor) {
+    if (points.length < 2) return;
+    const curve = new CatmullRomCurve3(points, false, "catmullrom", 0);
+    const mesh = new TubeMesh({
       geometryParameters: {
-        path: s,
-        tubularSegments: e.length * 10,
+        path: curve,
+        tubularSegments: points.length * 10,
         radius: this.parameters.pathRadius,
-        closed: !1
+        closed: false
       },
       materialParameters: {
-        color: t
+        color: color2
       }
     });
-    return this.add(n), this.pathMeshes.push(n), n;
+    this.add(mesh);
+    this.pathMeshes.push(mesh);
+    return mesh;
   }
   clearPaths() {
-    this.pathMeshes.forEach((e) => {
-      this.remove(e), e.geometry.dispose(), e.material.dispose();
-    }), this.pathMeshes = [];
+    this.pathMeshes.forEach((m) => {
+      this.remove(m);
+      m.geometry.dispose();
+      m.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 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 });
+        }
+      });
+    });
+    return { nodes, edges };
+  }
+  /**
+   * 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();
   }
   dispose() {
-    this.clearGraph(), this.clearPaths();
+    this.clearGraph();
+    this.clearPaths();
   }
-  getNeighbors(e) {
-    return this.adjacencyMap.get(e);
+  getNeighbors(id) {
+    return this.adjacencyMap.get(id);
   }
 }
-class Ts extends Xt {
-  isPoi = !0;
+class Poi extends BaseSprite {
+  isPoi = true;
   type = "Poi";
   parameters = {
     img: "",
@@ -1098,277 +1649,426 @@ class Ts extends Xt {
     color: "#ffffff",
     iconSize: 64,
     padding: 10,
-    backgroundColor: "rgba(0, 0, 0, 0.5)",
+    backgroundColor: "rgba(0, 0, 0, 0)",
     borderRadius: 8,
-    textPosition: "right"
+    textPosition: "right",
+    scaleFactor: 0.01
   };
-  constructor(e = {}) {
-    super(new nt()), Object.assign(this.parameters, e);
+  _canvas = document.createElement("canvas");
+  _lastParametersJSON = "";
+  constructor(parameters = {}) {
+    super(new SpriteNodeMaterial());
+    Object.assign(this.parameters, parameters);
+    this.updateAsync();
   }
   /**
    * Update the POI with new parameters
    * @param parameters Partial POI parameters
    */
-  async updateAsync(e = {}) {
-    Object.assign(this.parameters, e);
-    const t = document.createElement("canvas"), s = t.getContext("2d");
-    if (!s) return;
-    s.font = `${this.parameters.fontSize}px ${this.parameters.fontFamily}`;
-    let n = null;
-    this.parameters.img && (n = await this._loadImage(this.parameters.img));
-    const { text: i, fontSize: a, color: c, iconSize: r, padding: h, backgroundColor: l, borderRadius: u, textPosition: f } = this.parameters, p = s.measureText(i), g = i ? p.width : 0, w = i ? a : 0;
-    let T = 0, v = 0, b = 0, M = 0, x = 0, E = 0;
-    const S = !!n, m = !!i;
-    if (S && m)
-      switch (f) {
+  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) {
         case "top":
-          T = Math.max(r, g), v = r + h + w, x = (T - g) / 2, E = w / 2, b = (T - r) / 2, M = w + h;
+          contentWidth = Math.max(iconSize, textWidth);
+          contentHeight = iconSize + padding + textHeight;
+          textX = (contentWidth - textWidth) / 2;
+          textY = textHeight / 2;
+          iconX = (contentWidth - iconSize) / 2;
+          iconY = textHeight + padding;
           break;
         case "bottom":
-          T = Math.max(r, g), v = r + h + w, b = (T - r) / 2, M = 0, x = (T - g) / 2, E = r + h + w / 2;
+          contentWidth = Math.max(iconSize, textWidth);
+          contentHeight = iconSize + padding + textHeight;
+          iconX = (contentWidth - iconSize) / 2;
+          iconY = 0;
+          textX = (contentWidth - textWidth) / 2;
+          textY = iconSize + padding + textHeight / 2;
           break;
         case "left":
-          T = r + h + g, v = Math.max(r, w), x = 0, E = v / 2, b = g + h, M = (v - r) / 2;
+          contentWidth = iconSize + padding + textWidth;
+          contentHeight = Math.max(iconSize, textHeight);
+          textX = 0;
+          textY = contentHeight / 2;
+          iconX = textWidth + padding;
+          iconY = (contentHeight - iconSize) / 2;
           break;
+        case "right":
         default:
-          T = r + h + g, v = Math.max(r, w), b = 0, M = (v - r) / 2, x = r + h, E = v / 2;
+          contentWidth = iconSize + padding + textWidth;
+          contentHeight = Math.max(iconSize, textHeight);
+          iconX = 0;
+          iconY = (contentHeight - iconSize) / 2;
+          textX = iconSize + padding;
+          textY = contentHeight / 2;
           break;
       }
-    else S ? (T = r, v = r, b = 0, M = 0) : m && (T = g, v = w, x = 0, E = w / 2);
-    const y = T + h * 2, B = v + h * 2;
-    t.width = y, t.height = B, s.font = `${a}px ${this.parameters.fontFamily}`, s.textBaseline = "middle", l && (s.fillStyle = l, this._drawRoundedRect(s, 0, 0, y, B, u), s.fill()), S && s.drawImage(n, b + h, M + h, r, r), m && (s.fillStyle = c, s.fillText(i, x + h, E + h)), this.material.map?.dispose();
-    const _ = new it(t);
-    _.colorSpace = ve, this.material.map = _;
-    const O = 0.01;
-    this.scale.set(y * O, B * O, 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 = (i) => s(i), n.src = e;
-      } else
-        t(e);
+    } 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);
+      }
     });
   }
-  _drawRoundedRect(e, t, s, n, i, a) {
-    e.beginPath(), e.moveTo(t + a, s), e.lineTo(t + n - a, s), e.quadraticCurveTo(t + n, s, t + n, s + a), e.lineTo(t + n, s + i - a), e.quadraticCurveTo(t + n, s + i, t + n - a, s + i), e.lineTo(t + a, s + i), e.quadraticCurveTo(t, s + i, t, s + i - a), e.lineTo(t, s + a), e.quadraticCurveTo(t, s, t + a, s), e.closePath();
+  _drawRoundedRect(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();
   }
   dispose() {
-    this.material.map?.dispose(), this.material.dispose();
+    this.material.map?.dispose();
+    this.material.dispose();
   }
 }
-class Oe extends U {
-  isShapeMesh = !0;
+class ShapeMesh extends BaseMesh {
+  isShapeMesh = true;
   type = "ShapeMesh";
-  constructor({ geometryParameters: e, materialParameters: t } = {}) {
-    super(), this.geometry = new rt(e?.shape, e?.curveSegments), this.material = new I(t), this.geometry.rotateX(-Math.PI / 2);
+  constructor({ geometryParameters, materialParameters } = {}) {
+    super();
+    this.geometry = new ShapeGeometry(geometryParameters?.shape, geometryParameters?.curveSegments);
+    this.material = new MeshStandardNodeMaterial(materialParameters);
+    this.geometry.rotateX(-Math.PI / 2);
   }
-  static createFromPoints(e, t = {}) {
-    return new Oe({
-      ...t,
+  static createFromPoints(points, parameters = {}) {
+    return new ShapeMesh({
+      ...parameters,
       geometryParameters: {
-        ...t.geometryParameters,
-        shape: new be(e.map((s) => new P(s.x, -s.z)))
+        ...parameters.geometryParameters,
+        shape: new Shape(points.map((point) => new Vector2(point.x, -point.z)))
       }
     });
   }
 }
-class Pe extends U {
-  isExtrudeMesh = !0;
+class ExtrudeMesh extends BaseMesh {
+  isExtrudeMesh = true;
   type = "ExtrudeMesh";
-  constructor({ geometryParameters: e, materialParameters: t } = {}) {
-    super(), this.geometry = new at(e?.shape, e?.options), this.material = new I(t), this.geometry.rotateX(-Math.PI / 2);
+  constructor({ geometryParameters, materialParameters } = {}) {
+    super();
+    this.geometry = new ExtrudeGeometry(geometryParameters?.shape, geometryParameters?.options);
+    this.material = new MeshStandardNodeMaterial(materialParameters);
+    this.geometry.rotateX(-Math.PI / 2);
   }
-  static createFromPoints(e, t = {}) {
-    return new Pe({
-      ...t,
+  static createFromPoints(points, parameters = {}) {
+    return new ExtrudeMesh({
+      ...parameters,
       geometryParameters: {
-        ...t.geometryParameters,
-        shape: new be(e.map((s) => new P(s.x, -s.z)))
+        ...parameters.geometryParameters,
+        shape: new Shape(points.map((point) => new Vector2(point.x, -point.z)))
       }
     });
   }
 }
-class Cs extends U {
-  isPlaneMesh = !0;
+class PlaneMesh extends BaseMesh {
+  isPlaneMesh = true;
   type = "PlaneMesh";
-  constructor({ geometryParameters: e, materialParameters: t } = {}) {
-    super(), this.geometry = new ot(
-      e?.width,
-      e?.height,
-      e?.widthSegments,
-      e?.heightSegments
-    ), this.material = new I(t);
+  constructor({ geometryParameters, materialParameters } = {}) {
+    super();
+    this.geometry = new PlaneGeometry(
+      geometryParameters?.width,
+      geometryParameters?.height,
+      geometryParameters?.widthSegments,
+      geometryParameters?.heightSegments
+    );
+    this.material = new MeshStandardNodeMaterial(materialParameters);
   }
 }
-class Ms extends U {
-  isCircleMesh = !0;
+class CircleMesh extends BaseMesh {
+  isCircleMesh = true;
   type = "CircleMesh";
-  constructor({ geometryParameters: e, materialParameters: t } = {}) {
+  constructor({ geometryParameters, materialParameters } = {}) {
     super(
-      new ct(
-        e?.radius,
-        e?.segments,
-        e?.thetaStart,
-        e?.thetaLength
+      new CircleGeometry(
+        geometryParameters?.radius,
+        geometryParameters?.segments,
+        geometryParameters?.thetaStart,
+        geometryParameters?.thetaLength
       ),
-      new I(t)
-    ), this.geometry.rotateX(-Math.PI / 2);
+      new MeshStandardNodeMaterial(materialParameters)
+    );
+    this.geometry.rotateX(-Math.PI / 2);
   }
 }
-class Yt {
-  static traverseMeshes(e, t) {
-    e.traverse((s) => {
-      s instanceof j && t(s);
+class ObjectUtils {
+  static traverseMeshes(object, callback) {
+    object.traverse((child) => {
+      if (child instanceof Mesh) {
+        callback(child);
+      }
     });
   }
 }
-class xs {
-  static flow(e = {}) {
-    const { baseColor: t = 16777215, flowColor: s = 65280, speed: n = 1, scale: i = 3, intensity: a = 4 } = e, c = A(new N(t)), r = A(new N(s)), h = re().x.mul(i).sub(Q.mul(n)), l = K(ae(h).add(1).mul(0.5), a);
-    return X(c, r, l);
-  }
-  static breathe(e = {}) {
-    const { baseColor: t = 16777215, breathColor: s = 65280, speed: n = 1, intensity: i = 2 } = e, a = A(new N(t)), c = A(new N(s)), r = ae(Q.mul(n)).add(1).mul(0.5), h = K(r, i);
-    return X(a, c, h);
-  }
-  static fluid(e = {}) {
+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 = {}) {
     const {
-      baseColor: t = 16777215,
-      flowColor: s = 255,
-      speed: n = 1,
-      scale: i = 1,
-      intensity: a = 1,
-      distortion: c = 0.5
-    } = e, r = A(new N(t)), h = A(new N(s)), l = re().mul(i), u = Q.mul(n), f = oe(l.add(u), 1, 0), p = l.add(f.mul(c)), g = oe(p, 1, 0).add(1).mul(0.5), w = K(g, a);
-    return X(r, h, w);
+      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);
   }
 }
-function Es(o) {
+function reinterpretType(_value) {
 }
-const $ = "uSpaceHighlight", Z = `${$}/enabled`, Se = `${$}/opacity`, Le = `${$}/color`, Ie = `${$}/overwrite`, Jt = Te(() => {
-  const o = D(Z, "uint"), e = D(Le, "uint"), t = D(Ie, "uint"), s = Vt(e), n = ce.mul(s), i = Y(t.greaterThan(0), s, n);
-  return Y(o.greaterThan(0), i, ce);
-})(), Zt = Te(() => {
-  const o = D(Z, "uint"), e = D(Se, "float");
-  return Y(o.greaterThan(0), e, lt);
+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;
 })();
-class Os {
-  static highlight(e, t = {}) {
-    const s = Object.assign(
+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(
       {
-        enabled: !0,
+        enabled: true,
         opacity: 0.5,
         color: 16711680,
-        overwrite: !1
+        overwrite: false
       },
-      t
+      options
     );
-    s.color = new J(s.color).getHex(), Yt.traverseMeshes(e, (n) => {
-      n.userData[Z] = 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 = Jt, i.opacityNode = Zt, i.needsUpdate = !0);
+    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;
+      }
     });
   }
 }
-const Vt = (o) => {
-  const e = o.shiftRight(16).bitAnd(255).toFloat().div(255), t = o.shiftRight(8).bitAnd(255).toFloat().div(255), s = o.bitAnd(255).toFloat().div(255);
-  return dt(e, t, s);
+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);
 };
-class es extends Tt {
+class Tween extends Tween$1 {
   viewer;
-  constructor(e, t) {
-    super(t), this.viewer = e;
-  }
-  _update = ({ time: e }) => {
-    this.update(e) && this.viewer.render();
+  constructor(viewer, source) {
+    super(source);
+    this.viewer = viewer;
+  }
+  _update = ({ time: time2 }) => {
+    const needsRender = this.update(time2);
+    if (needsRender) {
+      this.viewer.render();
+    }
   };
-  easingByMode(e) {
-    const t = ts[e];
-    return super.easing(t);
+  easingByMode(mode) {
+    const tweenModeFunc = animationModeEnum[mode];
+    return super.easing(tweenModeFunc);
   }
-  start(e, t) {
-    return this.viewer.addEventListener("afterControlsUpdate", this._update), super.start(e, t);
+  start(time2, overrideStartingValues) {
+    this.viewer.addEventListener("afterControlsUpdate", this._update);
+    return super.start(time2, overrideStartingValues);
   }
   stop() {
-    return this.viewer.removeEventListener("afterControlsUpdate", this._update), super.stop();
+    this.viewer.removeEventListener("afterControlsUpdate", this._update);
+    return super.stop();
   }
 }
-function Ps(o, e, t, s = {}, n, i) {
-  return new Promise((a, c) => {
-    const { duration: r = 1e3, delay: h = 0, repeat: l = !1, mode: u = "Linear.None", yoyo: f = !1 } = s, p = new es(o, e).to(t, r).easingByMode(u).delay(h).onUpdate((g) => {
-      n?.(g, p);
+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);
     }).onComplete(() => {
-      a();
+      resolve();
     }).onStop(() => {
-      c("animation stop");
+      reject("animation stop");
     }).onStart(() => {
-      i?.(p);
+      onStart?.(tween);
     });
-    typeof l == "number" ? p.repeat(l) : typeof l == "boolean" && l && p.repeat(1 / 0), f && p.repeatDelay(20), p.yoyo(f), p.start();
+    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();
   });
 }
-const ts = {
-  "Linear.None": d.Linear.None,
-  "Quadratic.In": d.Quadratic.In,
-  "Quadratic.Out": d.Quadratic.Out,
-  "Quadratic.InOut": d.Quadratic.InOut,
-  "Cubic.In": d.Cubic.In,
-  "Cubic.Out": d.Cubic.Out,
-  "Cubic.InOut": d.Cubic.InOut,
-  "Quartic.In": d.Quartic.In,
-  "Quartic.Out": d.Quartic.Out,
-  "Quartic.InOut": d.Quartic.InOut,
-  "Quintic.In": d.Quintic.In,
-  "Quintic.Out": d.Quintic.Out,
-  "Quintic.InOut": d.Quintic.InOut,
-  "Sinusoidal.In": d.Sinusoidal.In,
-  "Sinusoidal.Out": d.Sinusoidal.Out,
-  "Sinusoidal.InOut": d.Sinusoidal.InOut,
-  "Exponential.In": d.Exponential.In,
-  "Exponential.Out": d.Exponential.Out,
-  "Exponential.InOut": d.Exponential.InOut,
-  "Circular.In": d.Circular.In,
-  "Circular.Out": d.Circular.Out,
-  "Circular.InOut": d.Circular.InOut,
-  "Elastic.In": d.Elastic.In,
-  "Elastic.Out": d.Elastic.Out,
-  "Elastic.InOut": d.Elastic.InOut,
-  "Back.In": d.Back.In,
-  "Back.Out": d.Back.Out,
-  "Back.InOut": d.Back.InOut,
-  "Bounce.In": d.Bounce.In,
-  "Bounce.Out": d.Bounce.Out,
-  "Bounce.InOut": d.Bounce.InOut
+const 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
 };
 export {
-  Ee as BaseGroup,
-  U as BaseMesh,
-  Xt as BaseSprite,
-  Pt as CameraControls,
-  Ms as CircleMesh,
-  Pe as ExtrudeMesh,
-  Ct as InteractionEvent,
-  Mt as InteractionManager,
-  Os as MaterialEffects,
-  H as Model,
-  R as ModelLoaderManager,
-  xt as ObjectManager,
-  Yt as ObjectUtils,
-  Cs as PlaneMesh,
-  Ts as Poi,
-  Lt as RoomEnvironment,
-  Kt as SBMLoader,
-  Rt as SBMXLoader,
-  Oe as ShapeMesh,
-  qt as SphereMesh,
-  xs as TSLEffects,
-  vs as TextureLoaderManager,
-  bs as Topology,
-  pe as TubeMesh,
-  es as Tween,
-  ys as Viewer,
-  Es as reinterpretType,
-  Ps as tweenAnimation
+  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
 };
+//# sourceMappingURL=index.js.map