u-space 0.0.0-alpha.1

package/dist/index.js

@@ -0,0 +1,1374 @@
+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 {
+  /** The type of event (e.g., 'click', 'pointerdown'). */
+  type;
+  /** The original 3D object that triggered the event. */
+  target;
+  /** The current 3D object during the bubbling phase. */
+  currentTarget;
+  /** The intersection data from raycasting, or null if not applicable. */
+  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;
+  }
+  /**
+   * Stops the event from bubbling up the parent chain.
+   */
+  stopPropagation() {
+    this._propagationStopped = !0;
+  }
+  /**
+   * Returns true if `stopPropagation()` has been called.
+   */
+  get propagationStopped() {
+    return this._propagationStopped;
+  }
+}
+class Mt {
+  domElement;
+  scene;
+  camera;
+  raycaster = new ue();
+  pointer = new P();
+  hoveredObject = null;
+  pointerDownTime = 0;
+  pointerDownPos = new P();
+  clickTimer = null;
+  longPressThreshold = 500;
+  moveThreshold = 0.01;
+  /**
+   * The objects to check for intersections.
+   * If not set, it defaults to the children of the scene.
+   */
+  targetObjects = null;
+  /**
+   * 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();
+  }
+  /**
+   * Updates the camera reference (useful when switching cameras).
+   */
+  setCamera(e) {
+    this.camera = e;
+  }
+  _bindEvents() {
+    this.domElement.addEventListener("click", this._onClick), this.domElement.addEventListener("dblclick", this._onDblClick), this.domElement.addEventListener("contextmenu", this._onContextMenu), this.domElement.addEventListener("pointerdown", this._onPointerDown), this.domElement.addEventListener("pointerup", this._onPointerUp), this.domElement.addEventListener("pointermove", this._onPointerMove);
+  }
+  _updatePointer(e) {
+    const t = this.domElement.getBoundingClientRect();
+    this.pointer.x = (e.clientX - t.left) / t.width * 2 - 1, this.pointer.y = -((e.clientY - t.top) / t.height) * 2 + 1;
+  }
+  _getIntersects() {
+    this.raycaster.setFromCamera(this.pointer, this.camera);
+    const e = this.targetObjects || this.scene.children;
+    return this.raycaster.intersectObjects(e, !0);
+  }
+  /**
+   * 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
+    });
+    let a = t;
+    for (; a && !i.propagationStopped; )
+      i.currentTarget = a, a.dispatchEvent({ type: e, event: i }), a = a.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);
+  }
+  _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);
+    }
+  };
+  _onDblClick = (e) => {
+    this.clickTimer && (clearTimeout(this.clickTimer), this.clickTimer = null), this._handleEvent("dblclick", e);
+  };
+  _onContextMenu = (e) => {
+    e.preventDefault(), this._handleEvent("contextmenu", e);
+  };
+  _onPointerDown = (e) => {
+    this.pointerDownTime = Date.now(), this._updatePointer(e), this.pointerDownPos.copy(this.pointer), this._handleEvent("pointerdown", 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);
+  };
+  /**
+   * 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;
+  }
+}
+class xt {
+  idMap = /* @__PURE__ */ new Map();
+  nameMap = /* @__PURE__ */ new Map();
+  typeMap = /* @__PURE__ */ new Map();
+  objectIds = /* @__PURE__ */ new Map();
+  allObjects = /* @__PURE__ */ new Set();
+  /**
+   * 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.`);
+      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));
+  }
+  /**
+   * Get an object by its custom id.
+   */
+  getById(e) {
+    return this.idMap.get(e);
+  }
+  /**
+   * Get all objects with a given name.
+   */
+  getByName(e) {
+    return this.nameMap.get(e) || /* @__PURE__ */ new Set();
+  }
+  /**
+   * Get all objects with a given type.
+   */
+  getByType(e) {
+    return this.typeMap.get(e) || /* @__PURE__ */ new Set();
+  }
+  /**
+   * Get all ids associated with an object.
+   */
+  getObjectIds(e) {
+    return this.objectIds.get(e) || /* @__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);
+    }
+    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 (e.type && this.typeMap.has(e.type)) {
+      const s = this.typeMap.get(e.type);
+      s.delete(e), s.size === 0 && this.typeMap.delete(e.type);
+    }
+    this.allObjects.delete(e);
+  }
+  /**
+   * Remove an object by its id.
+   */
+  removeById(e) {
+    const t = this.idMap.get(e);
+    t && this.remove(t);
+  }
+  /**
+   * Remove all objects with a given name.
+   */
+  removeByName(e) {
+    const t = this.getByName(e);
+    for (const s of t)
+      this.remove(s);
+  }
+  /**
+   * Remove all objects with a given type.
+   */
+  removeByType(e) {
+    const t = this.getByType(e);
+    for (const s of t)
+      this.remove(s);
+  }
+  /**
+   * Clear all cached objects.
+   */
+  clear() {
+    this.idMap.clear(), this.nameMap.clear(), this.typeMap.clear(), this.objectIds.clear(), this.allObjects.clear();
+  }
+  /**
+   * Get all cached objects as a Set.
+   */
+  getAll() {
+    return this.allObjects;
+  }
+  /**
+   * Get the number of unique cached objects.
+   */
+  get size() {
+    return this.allObjects.size;
+  }
+}
+class Et extends Be {
+  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;
+  }
+  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;
+  }
+  render() {
+    this.needsUpdateOutputNode && (this.#t(), this.needsUpdateOutputNode = !1), super.render();
+  }
+}
+const Ot = {
+  Vector2: P,
+  Vector3: we,
+  Vector4: Ae,
+  Quaternion: _e,
+  Matrix4: Re,
+  Spherical: C,
+  Box3: ge,
+  Sphere: me,
+  Raycaster: ue
+};
+Ce.install({ THREE: Ot });
+class Pt extends Ce {
+  constructor(...e) {
+    super(...e), this.minDistance = 0.2, this.smoothTime = 0.2, this.dollySpeed = 0.2;
+  }
+  /**
+   * Set absolute angle for azimuth to avoid spinning
+   */
+  absoluteRotations() {
+    this.azimuthAngle = St(this.azimuthAngle, 0);
+  }
+  async flyToBox(e, t = {}) {
+    if (e.isEmpty())
+      return console.warn("CameraControls.flyToBox: The provided Box3 is empty."), !1;
+    this.absoluteRotations();
+    const { viewpoint: s = "frontTop", enableTransition: n = !0, padding: i = 0.1, cover: 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
+        })
+      ), c.push(this.rotateTo(h, l, n));
+    } else {
+      const r = new me();
+      e.getBoundingSphere(r), r.radius += i, c.push(this.fitToSphere(r, n));
+    }
+    return await Promise.all(c), !0;
+  }
+  async flyToObject(e, t = {}) {
+    const s = new ge().setFromObject(e);
+    return this.flyToBox(s, t);
+  }
+}
+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)
+};
+function St(o, e) {
+  const t = o - e;
+  return Ne.euclideanModulo(t + Math.PI, Math.PI * 2) - Math.PI;
+}
+class Lt {
+  environment = new pt();
+  renderer;
+  pmremGenerator;
+  envMap = null;
+  constructor(e) {
+    this.renderer = e, this.pmremGenerator = new Ue(e);
+  }
+  update() {
+    this.envMap || (this.envMap = this.pmremGenerator.fromScene(this.environment).texture);
+  }
+  dispose() {
+    this.pmremGenerator.dispose(), this.envMap?.dispose();
+  }
+}
+const G = 128;
+class It extends ut {
+  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");
+  }
+  _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);
+  };
+  enable() {
+    return this.viewer.renderPipeline.addOverlayPass(this.overlayPass), this.viewer.addEventListener("beforeRender", this._update), this.viewer.render(), this;
+  }
+  disable() {
+    return this.viewer.renderPipeline.removeOverlayPass(this.overlayPass), this.viewer.removeEventListener("beforeRender", this._update), this.viewer.render(), this;
+  }
+}
+class Bt {
+  el;
+  renderer;
+  container;
+  drawCallsText;
+  frameCallsText;
+  trianglesText;
+  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() {
+      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());
+  }
+  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";
+      });
+    }
+  }
+  enable() {
+    this._enabled = !0, this.el.appendChild(this.container);
+  }
+  disable() {
+    this._enabled = !1, this.container.remove();
+  }
+  dispose() {
+    this.disable();
+  }
+}
+je.enabled = !0;
+class ys extends ke {
+  el;
+  renderer;
+  scene;
+  camera;
+  info;
+  controls;
+  renderPipeline;
+  timer;
+  roomEnvironment;
+  interactionManager;
+  objectManager;
+  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);
+  }
+  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();
+  };
+  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());
+  }
+  render(e = 1) {
+    return this.frameCount += e, new Promise((t) => {
+      const s = () => {
+        this.removeEventListener("afterRender", s), t();
+      };
+      this.addEventListener("afterRender", s);
+    });
+  }
+  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 }));
+  };
+  _initRenderer(e) {
+    const t = new Fe({
+      logarithmicDepthBuffer: !0,
+      antialias: !1,
+      depth: !1,
+      trackTimestamp: !0,
+      ...e
+    });
+    return t.setSize(this.el.clientWidth, this.el.clientHeight), t.shadowMap.enabled = !0, t.shadowMap.type = 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;
+  }
+  createScene() {
+    const e = new $e();
+    return e.background = new J(0), e;
+  }
+  createPerspectiveCamera() {
+    const e = new W(50, this.el.clientWidth / this.el.clientHeight, 0.1, 1e5);
+    return e.position.setScalar(5), e;
+  }
+  createOrthographicCamera() {
+    const e = new F(
+      -this.el.clientWidth / 2,
+      this.el.clientWidth / 2,
+      this.el.clientHeight / 2,
+      -this.el.clientHeight / 2,
+      0.1,
+      1e5
+    );
+    return e.position.setScalar(5), e;
+  }
+  dispose() {
+    this.el.removeChild(this.renderer.domElement), window.removeEventListener("resize", this.onWindowResize), this.info.dispose(), this.interactionManager.dispose(), this.roomEnvironment.dispose(), this.renderPipeline.dispose(), this.renderer.dispose();
+  }
+}
+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);
+  }
+}
+function _t(o) {
+  return new TextDecoder().decode(new Uint8Array(o));
+}
+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;
+}
+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;
+  }
+}
+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 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;
+}
+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,
+    alphaTest: 0.01,
+    side: c
+  });
+}, Wt = (o) => o?.toLowerCase().endsWith(".png") ?? !1;
+class Qt {
+  data;
+  options;
+  textureLoader;
+  littleEndian = !0;
+  materials = /* @__PURE__ */ new Map();
+  constructor(e, t) {
+    this.data = e, this.options = t, this.textureLoader = new ye(t.manager), this.textureLoader.setCrossOrigin(t.crossOrigin), this.textureLoader.setRequestHeader(t.requestHeader);
+  }
+  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;
+        });
+      }
+    }
+    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);
+        }
+      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 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 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());
+      }
+      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);
+      }
+    }
+    s(n);
+  }
+  _parseV3(e, t, s) {
+    const n = new z();
+    console.warn("SBMLoader: SBM version 3 is not supported yet."), s(n);
+  }
+}
+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) => {
+        try {
+          this.parse(
+            r,
+            i,
+            (h) => {
+              t(h), this.manager.itemEnd(e);
+            },
+            a
+          );
+        } catch (h) {
+          a(h);
+        }
+      },
+      s,
+      a
+    );
+  }
+  parse(e, t, s, n) {
+    const i = new TextDecoder().decode(e.slice(0, 8));
+    if (i !== "SBK-----" && i !== "SBM-----") {
+      n?.(new Error(`SBMLoader: Invalid SBM format: ${i}`));
+      return;
+    }
+    new Qt(e, {
+      path: t,
+      crossOrigin: this.crossOrigin,
+      requestHeader: this.requestHeader,
+      manager: this.manager
+    }).parse(s, n);
+  }
+  parseAsync(e, t) {
+    return new Promise((s, n) => {
+      this.parse(
+        e,
+        t,
+        (i) => {
+          s(i);
+        },
+        (i) => {
+          n(i);
+        }
+      );
+    });
+  }
+}
+class R {
+  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 ktx2Loader = new yt().setTranscoderPath(
+    `https://cdn.jsdelivr.net/npm/three@0.${ie}.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;
+  }
+  /**
+   * Set the renderer to enable KTX2 support and other renderer-dependent features.
+   */
+  static async setRenderer(e) {
+    await e.init(), this.ktx2Loader.detectSupport(e);
+  }
+  /**
+   * Configure Draco decoder path.
+   */
+  static setDracoPath(e) {
+    this.dracoLoader.setDecoderPath(e);
+  }
+  /**
+   * 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) {
+      case "gltf":
+      case "glb":
+        return (await this.gltfLoader.parseAsync(n, L.extractUrlBase(e))).scene;
+      case "sbmx":
+        return (await this.sbmxLoader.parseAsync(n, L.extractUrlBase(e))).scene;
+      case "sbm":
+        return await this.sbmLoader.parseAsync(n, L.extractUrlBase(e));
+      case "fbx":
+        return this.fbxLoader.parse(n, L.extractUrlBase(e));
+      case "obj":
+        const h = new TextDecoder().decode(n);
+        return this.objLoader.parse(h);
+      case "stl":
+        const u = this.stlLoader.parse(n);
+        return new j(u, new I());
+      default:
+        throw new Error(`Unsupported model format: ${s}`);
+    }
+  }
+  static async getPersistentData(e) {
+    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);
+    }
+  }
+}
+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 U extends j {
+  isBaseMesh = !0;
+  type = "BaseMesh";
+  ignoreInvisibleWhenRaycast = !0;
+  constructor(...e) {
+    super(...e);
+  }
+  raycast(e, t) {
+    return this.visible === !1 && this.ignoreInvisibleWhenRaycast === !0 ? !1 : super.raycast(e, t);
+  }
+}
+class Ee extends z {
+  isBaseGroup = !0;
+  type = "BaseGroup";
+  ignoreInvisibleWhenRaycast = !0;
+  constructor(...e) {
+    super(...e);
+  }
+  raycast(e, t) {
+    return this.visible === !1 && this.ignoreInvisibleWhenRaycast === !0 ? !1 : super.raycast(e, t);
+  }
+}
+class Xt extends Ze {
+  isBaseSprite = !0;
+  type = "BaseSprite";
+  ignoreInvisibleWhenRaycast = !0;
+  constructor(...e) {
+    super(...e);
+  }
+  raycast(e, t) {
+    return this.visible === !1 && this.ignoreInvisibleWhenRaycast === !0 ? !1 : super.raycast(e, t);
+  }
+}
+class H extends Ee {
+  isModel = !0;
+  type = "Model";
+  static memoryCache = /* @__PURE__ */ new Map();
+  constructor() {
+    super();
+  }
+  async loadAsync(e) {
+    const { url: t, cache: s = !0, persistent: n = !0 } = e;
+    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;
+    }
+  }
+  static clearMemoryCache() {
+    this.memoryCache.clear();
+  }
+  static async clearPersistentCache() {
+    typeof caches < "u" && await caches.delete("u-space-loader-cache");
+  }
+}
+class qt extends U {
+  isSphereMesh = !0;
+  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);
+  }
+}
+class pe extends U {
+  isTubeMesh = !0;
+  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);
+  }
+}
+class bs extends Ee {
+  isTopology = !0;
+  type = "Topology";
+  // Visuals
+  parameters = {
+    nodeColor: 255,
+    nodeRadius: 0.5,
+    edgeColor: 65280,
+    edgeRadius: 0.1,
+    pathColor: 16711935,
+    pathRadius: 0.2
+  };
+  nodes = /* @__PURE__ */ new Map();
+  adjacencyMap = /* @__PURE__ */ new Map();
+  graphGroup = null;
+  pathMeshes = [];
+  constructor(e) {
+    super(), e && Object.assign(this.parameters, e);
+  }
+  /**
+   * Add a node to the topology graph.
+   * @param id Unique identifier for the node
+   * @param position 3D position of the node
+   */
+  addNode(e, t) {
+    this.nodes.has(e) && console.warn(`[Topology] Node ${e} already exists. Overwriting.`), this.nodes.set(e, t), this.adjacencyMap.has(e) || this.adjacencyMap.set(e, /* @__PURE__ */ new Map());
+  }
+  /**
+   * Remove a node from the topology graph.
+   * @param id Unique identifier for the node
+   */
+  removeNode(e) {
+    if (!this.nodes.has(e)) {
+      console.warn(`[Topology] Node ${e} does not exist.`);
+      return;
+    }
+    this.nodes.delete(e), this.adjacencyMap.delete(e);
+  }
+  /**
+   * Add an edge between two nodes.
+   * @param from Node ID
+   * @param to Node ID
+   * @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}`);
+      return;
+    }
+    const c = s ?? i.distanceTo(a);
+    this.getNeighbors(e)?.set(t, c), n && this.getNeighbors(t)?.set(e, c);
+  }
+  /**
+   * Remove an edge between two nodes.
+   * @param from Node ID
+   * @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);
+  }
+  /**
+   * 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);
+      }
+      if (r === null || r === t || h === 1 / 0)
+        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));
+        }
+    }
+    const a = [];
+    let c = t;
+    if (n.get(t) === null && e !== t)
+      return [];
+    for (; c !== null; ) {
+      const r = this.nodes.get(c);
+      r && a.unshift(r), c = n.get(c) || null;
+    }
+    return a;
+  }
+  /**
+   * Renders the entire topology graph structure using TubeGeometry and Spheres.
+   */
+  renderGraph() {
+    this.clearGraph(), this.graphGroup = new z();
+    const e = new qt({
+      geometryParameters: {
+        radius: this.parameters.nodeRadius,
+        widthSegments: 16,
+        heightSegments: 16
+      },
+      materialParameters: {
+        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);
+    });
+    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({
+            geometryParameters: {
+              path: l,
+              tubularSegments: 1,
+              radius: this.parameters.edgeRadius,
+              radialSegments: 8,
+              closed: !1
+            },
+            materialParameters: {
+              color: this.parameters.edgeColor
+            }
+          });
+          Object.assign(u.userData, { from: n, to: a, weight: i, type: "edge" }), this.graphGroup.add(u);
+        }
+      });
+    }), 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);
+  }
+  /**
+   * 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({
+      geometryParameters: {
+        path: s,
+        tubularSegments: e.length * 10,
+        radius: this.parameters.pathRadius,
+        closed: !1
+      },
+      materialParameters: {
+        color: t
+      }
+    });
+    return this.add(n), this.pathMeshes.push(n), n;
+  }
+  clearPaths() {
+    this.pathMeshes.forEach((e) => {
+      this.remove(e), e.geometry.dispose(), e.material.dispose();
+    }), this.pathMeshes = [];
+  }
+  dispose() {
+    this.clearGraph(), this.clearPaths();
+  }
+  getNeighbors(e) {
+    return this.adjacencyMap.get(e);
+  }
+}
+class Ts extends Xt {
+  isPoi = !0;
+  type = "Poi";
+  parameters = {
+    img: "",
+    text: "",
+    fontSize: 32,
+    fontFamily: "Arial",
+    color: "#ffffff",
+    iconSize: 64,
+    padding: 10,
+    backgroundColor: "rgba(0, 0, 0, 0.5)",
+    borderRadius: 8,
+    textPosition: "right"
+  };
+  constructor(e = {}) {
+    super(new nt()), Object.assign(this.parameters, e);
+  }
+  /**
+   * 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) {
+        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;
+          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;
+          break;
+        case "left":
+          T = r + h + g, v = Math.max(r, w), x = 0, E = v / 2, b = g + h, M = (v - r) / 2;
+          break;
+        default:
+          T = r + h + g, v = Math.max(r, w), b = 0, M = (v - r) / 2, x = r + h, E = v / 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);
+    });
+  }
+  _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();
+  }
+  dispose() {
+    this.material.map?.dispose(), this.material.dispose();
+  }
+}
+class Oe extends U {
+  isShapeMesh = !0;
+  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);
+  }
+  static createFromPoints(e, t = {}) {
+    return new Oe({
+      ...t,
+      geometryParameters: {
+        ...t.geometryParameters,
+        shape: new be(e.map((s) => new P(s.x, -s.z)))
+      }
+    });
+  }
+}
+class Pe extends U {
+  isExtrudeMesh = !0;
+  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);
+  }
+  static createFromPoints(e, t = {}) {
+    return new Pe({
+      ...t,
+      geometryParameters: {
+        ...t.geometryParameters,
+        shape: new be(e.map((s) => new P(s.x, -s.z)))
+      }
+    });
+  }
+}
+class Cs extends U {
+  isPlaneMesh = !0;
+  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);
+  }
+}
+class Ms extends U {
+  isCircleMesh = !0;
+  type = "CircleMesh";
+  constructor({ geometryParameters: e, materialParameters: t } = {}) {
+    super(
+      new ct(
+        e?.radius,
+        e?.segments,
+        e?.thetaStart,
+        e?.thetaLength
+      ),
+      new I(t)
+    ), this.geometry.rotateX(-Math.PI / 2);
+  }
+}
+class Yt {
+  static traverseMeshes(e, t) {
+    e.traverse((s) => {
+      s instanceof j && t(s);
+    });
+  }
+}
+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 = {}) {
+    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);
+  }
+}
+function Es(o) {
+}
+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);
+})();
+class Os {
+  static highlight(e, t = {}) {
+    const s = Object.assign(
+      {
+        enabled: !0,
+        opacity: 0.5,
+        color: 16711680,
+        overwrite: !1
+      },
+      t
+    );
+    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);
+    });
+  }
+}
+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);
+};
+class es extends Tt {
+  viewer;
+  constructor(e, t) {
+    super(t), this.viewer = e;
+  }
+  _update = ({ time: e }) => {
+    this.update(e) && this.viewer.render();
+  };
+  easingByMode(e) {
+    const t = ts[e];
+    return super.easing(t);
+  }
+  start(e, t) {
+    return this.viewer.addEventListener("afterControlsUpdate", this._update), super.start(e, t);
+  }
+  stop() {
+    return this.viewer.removeEventListener("afterControlsUpdate", this._update), 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);
+    }).onComplete(() => {
+      a();
+    }).onStop(() => {
+      c("animation stop");
+    }).onStart(() => {
+      i?.(p);
+    });
+    typeof l == "number" ? p.repeat(l) : typeof l == "boolean" && l && p.repeat(1 / 0), f && p.repeatDelay(20), p.yoyo(f), p.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
+};
+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
+};