@ridp/threejs 1.4.2 → 1.4.4

package/dist/PredictiveLoader-eiPgVdsJ.js

@@ -0,0 +1,3832 @@
+import * as A from "three";
+import { Controls as mt, Vector3 as S, MOUSE as B, TOUCH as V, Quaternion as le, Spherical as Fe, Vector2 as k, Ray as gt, Plane as yt, MathUtils as st, TrianglesDrawMode as _t, TriangleFanDrawMode as Pe, TriangleStripDrawMode as nt, Loader as it, FileLoader as de, SRGBColorSpace as Y, LinearSRGBColorSpace as U, BufferGeometry as ot, BufferAttribute as oe, Color as q, ColorManagement as De, LoaderUtils as re, MeshPhysicalMaterial as j, SpotLight as Tt, PointLight as wt, DirectionalLight as bt, Matrix4 as se, InstancedMesh as Et, InstancedBufferAttribute as xt, Object3D as Ne, TextureLoader as At, ImageBitmapLoader as Rt, InterleavedBuffer as Mt, InterleavedBufferAttribute as St, LinearMipmapLinearFilter as rt, NearestMipmapLinearFilter as Lt, LinearMipmapNearestFilter as Pt, NearestMipmapNearestFilter as Dt, LinearFilter as Ce, NearestFilter as at, RepeatWrapping as Oe, MirroredRepeatWrapping as Ct, ClampToEdgeWrapping as Ot, PointsMaterial as kt, Material as Te, LineBasicMaterial as It, MeshStandardMaterial as ct, DoubleSide as Nt, MeshBasicMaterial as ie, PropertyBinding as vt, SkinnedMesh as Ht, Mesh as Ft, LineSegments as Ut, Line as jt, LineLoop as Gt, Points as Bt, Group as we, PerspectiveCamera as zt, OrthographicCamera as Kt, Skeleton as Wt, AnimationClip as Xt, Bone as Vt, InterpolateDiscrete as Yt, InterpolateLinear as lt, Texture as Ue, VectorKeyframeTrack as je, NumberKeyframeTrack as Ge, QuaternionKeyframeTrack as Be, FrontSide as qt, Interpolant as $t, Box3 as Zt, Sphere as Qt, CameraHelper as Jt, GridHelper as es, BoxHelper as ts, Raycaster as ss, AxesHelper as ns, ArrowHelper as is } from "three";
+import os from "dexie";
+const ze = { type: "change" }, ve = { type: "start" }, ht = { type: "end" }, ue = new gt(), Ke = new yt(), rs = Math.cos(70 * st.DEG2RAD), L = new S(), O = 2 * Math.PI, R = {
+  NONE: -1,
+  ROTATE: 0,
+  DOLLY: 1,
+  PAN: 2,
+  TOUCH_ROTATE: 3,
+  TOUCH_PAN: 4,
+  TOUCH_DOLLY_PAN: 5,
+  TOUCH_DOLLY_ROTATE: 6
+}, be = 1e-6;
+class ut extends mt {
+  /**
+   * Constructs a new controls instance.
+   *
+   * @param {Object3D} object - The object that is managed by the controls.
+   * @param {?HTMLDOMElement} domElement - The HTML element used for event listeners.
+   */
+  constructor(e, t = null) {
+    super(e, t), this.state = R.NONE, this.target = new S(), this.cursor = new S(), this.minDistance = 0, this.maxDistance = 1 / 0, this.minZoom = 0, this.maxZoom = 1 / 0, this.minTargetRadius = 0, this.maxTargetRadius = 1 / 0, this.minPolarAngle = 0, this.maxPolarAngle = Math.PI, this.minAzimuthAngle = -1 / 0, this.maxAzimuthAngle = 1 / 0, this.enableDamping = !1, this.dampingFactor = 0.05, this.enableZoom = !0, this.zoomSpeed = 1, this.enableRotate = !0, this.rotateSpeed = 1, this.keyRotateSpeed = 1, this.enablePan = !0, this.panSpeed = 1, this.screenSpacePanning = !0, this.keyPanSpeed = 7, this.zoomToCursor = !1, this.autoRotate = !1, this.autoRotateSpeed = 2, this.keys = { LEFT: "ArrowLeft", UP: "ArrowUp", RIGHT: "ArrowRight", BOTTOM: "ArrowDown" }, this.mouseButtons = { LEFT: B.ROTATE, MIDDLE: B.DOLLY, RIGHT: B.PAN }, this.touches = { ONE: V.ROTATE, TWO: V.DOLLY_PAN }, this.target0 = this.target.clone(), this.position0 = this.object.position.clone(), this.zoom0 = this.object.zoom, this._domElementKeyEvents = null, this._lastPosition = new S(), this._lastQuaternion = new le(), this._lastTargetPosition = new S(), this._quat = new le().setFromUnitVectors(e.up, new S(0, 1, 0)), this._quatInverse = this._quat.clone().invert(), this._spherical = new Fe(), this._sphericalDelta = new Fe(), this._scale = 1, this._panOffset = new S(), this._rotateStart = new k(), this._rotateEnd = new k(), this._rotateDelta = new k(), this._panStart = new k(), this._panEnd = new k(), this._panDelta = new k(), this._dollyStart = new k(), this._dollyEnd = new k(), this._dollyDelta = new k(), this._dollyDirection = new S(), this._mouse = new k(), this._performCursorZoom = !1, this._pointers = [], this._pointerPositions = {}, this._controlActive = !1, this._onPointerMove = cs.bind(this), this._onPointerDown = as.bind(this), this._onPointerUp = ls.bind(this), this._onContextMenu = gs.bind(this), this._onMouseWheel = ds.bind(this), this._onKeyDown = fs.bind(this), this._onTouchStart = ps.bind(this), this._onTouchMove = ms.bind(this), this._onMouseDown = hs.bind(this), this._onMouseMove = us.bind(this), this._interceptControlDown = ys.bind(this), this._interceptControlUp = _s.bind(this), this.domElement !== null && this.connect(this.domElement), this.update();
+  }
+  connect(e) {
+    super.connect(e), this.domElement.addEventListener("pointerdown", this._onPointerDown), this.domElement.addEventListener("pointercancel", this._onPointerUp), this.domElement.addEventListener("contextmenu", this._onContextMenu), this.domElement.addEventListener("wheel", this._onMouseWheel, { passive: !1 }), this.domElement.getRootNode().addEventListener("keydown", this._interceptControlDown, { passive: !0, capture: !0 }), this.domElement.style.touchAction = "none";
+  }
+  disconnect() {
+    this.domElement.removeEventListener("pointerdown", this._onPointerDown), this.domElement.removeEventListener("pointermove", this._onPointerMove), this.domElement.removeEventListener("pointerup", this._onPointerUp), this.domElement.removeEventListener("pointercancel", this._onPointerUp), this.domElement.removeEventListener("wheel", this._onMouseWheel), this.domElement.removeEventListener("contextmenu", this._onContextMenu), this.stopListenToKeyEvents(), this.domElement.getRootNode().removeEventListener("keydown", this._interceptControlDown, { capture: !0 }), this.domElement.style.touchAction = "auto";
+  }
+  dispose() {
+    this.disconnect();
+  }
+  /**
+   * Get the current vertical rotation, in radians.
+   *
+   * @return {number} The current vertical rotation, in radians.
+   */
+  getPolarAngle() {
+    return this._spherical.phi;
+  }
+  /**
+   * Get the current horizontal rotation, in radians.
+   *
+   * @return {number} The current horizontal rotation, in radians.
+   */
+  getAzimuthalAngle() {
+    return this._spherical.theta;
+  }
+  /**
+   * Returns the distance from the camera to the target.
+   *
+   * @return {number} The distance from the camera to the target.
+   */
+  getDistance() {
+    return this.object.position.distanceTo(this.target);
+  }
+  /**
+   * Adds key event listeners to the given DOM element.
+   * `window` is a recommended argument for using this method.
+   *
+   * @param {HTMLDOMElement} domElement - The DOM element
+   */
+  listenToKeyEvents(e) {
+    e.addEventListener("keydown", this._onKeyDown), this._domElementKeyEvents = e;
+  }
+  /**
+   * Removes the key event listener previously defined with `listenToKeyEvents()`.
+   */
+  stopListenToKeyEvents() {
+    this._domElementKeyEvents !== null && (this._domElementKeyEvents.removeEventListener("keydown", this._onKeyDown), this._domElementKeyEvents = null);
+  }
+  /**
+   * Save the current state of the controls. This can later be recovered with `reset()`.
+   */
+  saveState() {
+    this.target0.copy(this.target), this.position0.copy(this.object.position), this.zoom0 = this.object.zoom;
+  }
+  /**
+   * Reset the controls to their state from either the last time the `saveState()`
+   * was called, or the initial state.
+   */
+  reset() {
+    this.target.copy(this.target0), this.object.position.copy(this.position0), this.object.zoom = this.zoom0, this.object.updateProjectionMatrix(), this.dispatchEvent(ze), this.update(), this.state = R.NONE;
+  }
+  update(e = null) {
+    const t = this.object.position;
+    L.copy(t).sub(this.target), L.applyQuaternion(this._quat), this._spherical.setFromVector3(L), this.autoRotate && this.state === R.NONE && this._rotateLeft(this._getAutoRotationAngle(e)), this.enableDamping ? (this._spherical.theta += this._sphericalDelta.theta * this.dampingFactor, this._spherical.phi += this._sphericalDelta.phi * this.dampingFactor) : (this._spherical.theta += this._sphericalDelta.theta, this._spherical.phi += this._sphericalDelta.phi);
+    let n = this.minAzimuthAngle, s = this.maxAzimuthAngle;
+    isFinite(n) && isFinite(s) && (n < -Math.PI ? n += O : n > Math.PI && (n -= O), s < -Math.PI ? s += O : s > Math.PI && (s -= O), n <= s ? this._spherical.theta = Math.max(n, Math.min(s, this._spherical.theta)) : this._spherical.theta = this._spherical.theta > (n + s) / 2 ? Math.max(n, this._spherical.theta) : Math.min(s, this._spherical.theta)), this._spherical.phi = Math.max(this.minPolarAngle, Math.min(this.maxPolarAngle, this._spherical.phi)), this._spherical.makeSafe(), this.enableDamping === !0 ? this.target.addScaledVector(this._panOffset, this.dampingFactor) : this.target.add(this._panOffset), this.target.sub(this.cursor), this.target.clampLength(this.minTargetRadius, this.maxTargetRadius), this.target.add(this.cursor);
+    let i = !1;
+    if (this.zoomToCursor && this._performCursorZoom || this.object.isOrthographicCamera)
+      this._spherical.radius = this._clampDistance(this._spherical.radius);
+    else {
+      const o = this._spherical.radius;
+      this._spherical.radius = this._clampDistance(this._spherical.radius * this._scale), i = o != this._spherical.radius;
+    }
+    if (L.setFromSpherical(this._spherical), L.applyQuaternion(this._quatInverse), t.copy(this.target).add(L), this.object.lookAt(this.target), this.enableDamping === !0 ? (this._sphericalDelta.theta *= 1 - this.dampingFactor, this._sphericalDelta.phi *= 1 - this.dampingFactor, this._panOffset.multiplyScalar(1 - this.dampingFactor)) : (this._sphericalDelta.set(0, 0, 0), this._panOffset.set(0, 0, 0)), this.zoomToCursor && this._performCursorZoom) {
+      let o = null;
+      if (this.object.isPerspectiveCamera) {
+        const c = L.length();
+        o = this._clampDistance(c * this._scale);
+        const a = c - o;
+        this.object.position.addScaledVector(this._dollyDirection, a), this.object.updateMatrixWorld(), i = !!a;
+      } else if (this.object.isOrthographicCamera) {
+        const c = new S(this._mouse.x, this._mouse.y, 0);
+        c.unproject(this.object);
+        const a = this.object.zoom;
+        this.object.zoom = Math.max(this.minZoom, Math.min(this.maxZoom, this.object.zoom / this._scale)), this.object.updateProjectionMatrix(), i = a !== this.object.zoom;
+        const l = new S(this._mouse.x, this._mouse.y, 0);
+        l.unproject(this.object), this.object.position.sub(l).add(c), this.object.updateMatrixWorld(), o = L.length();
+      } else
+        console.warn("WARNING: OrbitControls.js encountered an unknown camera type - zoom to cursor disabled."), this.zoomToCursor = !1;
+      o !== null && (this.screenSpacePanning ? this.target.set(0, 0, -1).transformDirection(this.object.matrix).multiplyScalar(o).add(this.object.position) : (ue.origin.copy(this.object.position), ue.direction.set(0, 0, -1).transformDirection(this.object.matrix), Math.abs(this.object.up.dot(ue.direction)) < rs ? this.object.lookAt(this.target) : (Ke.setFromNormalAndCoplanarPoint(this.object.up, this.target), ue.intersectPlane(Ke, this.target))));
+    } else if (this.object.isOrthographicCamera) {
+      const o = this.object.zoom;
+      this.object.zoom = Math.max(this.minZoom, Math.min(this.maxZoom, this.object.zoom / this._scale)), o !== this.object.zoom && (this.object.updateProjectionMatrix(), i = !0);
+    }
+    return this._scale = 1, this._performCursorZoom = !1, i || this._lastPosition.distanceToSquared(this.object.position) > be || 8 * (1 - this._lastQuaternion.dot(this.object.quaternion)) > be || this._lastTargetPosition.distanceToSquared(this.target) > be ? (this.dispatchEvent(ze), this._lastPosition.copy(this.object.position), this._lastQuaternion.copy(this.object.quaternion), this._lastTargetPosition.copy(this.target), !0) : !1;
+  }
+  _getAutoRotationAngle(e) {
+    return e !== null ? O / 60 * this.autoRotateSpeed * e : O / 60 / 60 * this.autoRotateSpeed;
+  }
+  _getZoomScale(e) {
+    const t = Math.abs(e * 0.01);
+    return Math.pow(0.95, this.zoomSpeed * t);
+  }
+  _rotateLeft(e) {
+    this._sphericalDelta.theta -= e;
+  }
+  _rotateUp(e) {
+    this._sphericalDelta.phi -= e;
+  }
+  _panLeft(e, t) {
+    L.setFromMatrixColumn(t, 0), L.multiplyScalar(-e), this._panOffset.add(L);
+  }
+  _panUp(e, t) {
+    this.screenSpacePanning === !0 ? L.setFromMatrixColumn(t, 1) : (L.setFromMatrixColumn(t, 0), L.crossVectors(this.object.up, L)), L.multiplyScalar(e), this._panOffset.add(L);
+  }
+  // deltaX and deltaY are in pixels; right and down are positive
+  _pan(e, t) {
+    const n = this.domElement;
+    if (this.object.isPerspectiveCamera) {
+      const s = this.object.position;
+      L.copy(s).sub(this.target);
+      let i = L.length();
+      i *= Math.tan(this.object.fov / 2 * Math.PI / 180), this._panLeft(2 * e * i / n.clientHeight, this.object.matrix), this._panUp(2 * t * i / n.clientHeight, this.object.matrix);
+    } else this.object.isOrthographicCamera ? (this._panLeft(e * (this.object.right - this.object.left) / this.object.zoom / n.clientWidth, this.object.matrix), this._panUp(t * (this.object.top - this.object.bottom) / this.object.zoom / n.clientHeight, this.object.matrix)) : (console.warn("WARNING: OrbitControls.js encountered an unknown camera type - pan disabled."), this.enablePan = !1);
+  }
+  _dollyOut(e) {
+    this.object.isPerspectiveCamera || this.object.isOrthographicCamera ? this._scale /= e : (console.warn("WARNING: OrbitControls.js encountered an unknown camera type - dolly/zoom disabled."), this.enableZoom = !1);
+  }
+  _dollyIn(e) {
+    this.object.isPerspectiveCamera || this.object.isOrthographicCamera ? this._scale *= e : (console.warn("WARNING: OrbitControls.js encountered an unknown camera type - dolly/zoom disabled."), this.enableZoom = !1);
+  }
+  _updateZoomParameters(e, t) {
+    if (!this.zoomToCursor)
+      return;
+    this._performCursorZoom = !0;
+    const n = this.domElement.getBoundingClientRect(), s = e - n.left, i = t - n.top, o = n.width, c = n.height;
+    this._mouse.x = s / o * 2 - 1, this._mouse.y = -(i / c) * 2 + 1, this._dollyDirection.set(this._mouse.x, this._mouse.y, 1).unproject(this.object).sub(this.object.position).normalize();
+  }
+  _clampDistance(e) {
+    return Math.max(this.minDistance, Math.min(this.maxDistance, e));
+  }
+  //
+  // event callbacks - update the object state
+  //
+  _handleMouseDownRotate(e) {
+    this._rotateStart.set(e.clientX, e.clientY);
+  }
+  _handleMouseDownDolly(e) {
+    this._updateZoomParameters(e.clientX, e.clientX), this._dollyStart.set(e.clientX, e.clientY);
+  }
+  _handleMouseDownPan(e) {
+    this._panStart.set(e.clientX, e.clientY);
+  }
+  _handleMouseMoveRotate(e) {
+    this._rotateEnd.set(e.clientX, e.clientY), this._rotateDelta.subVectors(this._rotateEnd, this._rotateStart).multiplyScalar(this.rotateSpeed);
+    const t = this.domElement;
+    this._rotateLeft(O * this._rotateDelta.x / t.clientHeight), this._rotateUp(O * this._rotateDelta.y / t.clientHeight), this._rotateStart.copy(this._rotateEnd), this.update();
+  }
+  _handleMouseMoveDolly(e) {
+    this._dollyEnd.set(e.clientX, e.clientY), this._dollyDelta.subVectors(this._dollyEnd, this._dollyStart), this._dollyDelta.y > 0 ? this._dollyOut(this._getZoomScale(this._dollyDelta.y)) : this._dollyDelta.y < 0 && this._dollyIn(this._getZoomScale(this._dollyDelta.y)), this._dollyStart.copy(this._dollyEnd), this.update();
+  }
+  _handleMouseMovePan(e) {
+    this._panEnd.set(e.clientX, e.clientY), this._panDelta.subVectors(this._panEnd, this._panStart).multiplyScalar(this.panSpeed), this._pan(this._panDelta.x, this._panDelta.y), this._panStart.copy(this._panEnd), this.update();
+  }
+  _handleMouseWheel(e) {
+    this._updateZoomParameters(e.clientX, e.clientY), e.deltaY < 0 ? this._dollyIn(this._getZoomScale(e.deltaY)) : e.deltaY > 0 && this._dollyOut(this._getZoomScale(e.deltaY)), this.update();
+  }
+  _handleKeyDown(e) {
+    let t = !1;
+    switch (e.code) {
+      case this.keys.UP:
+        e.ctrlKey || e.metaKey || e.shiftKey ? this.enableRotate && this._rotateUp(O * this.keyRotateSpeed / this.domElement.clientHeight) : this.enablePan && this._pan(0, this.keyPanSpeed), t = !0;
+        break;
+      case this.keys.BOTTOM:
+        e.ctrlKey || e.metaKey || e.shiftKey ? this.enableRotate && this._rotateUp(-O * this.keyRotateSpeed / this.domElement.clientHeight) : this.enablePan && this._pan(0, -this.keyPanSpeed), t = !0;
+        break;
+      case this.keys.LEFT:
+        e.ctrlKey || e.metaKey || e.shiftKey ? this.enableRotate && this._rotateLeft(O * this.keyRotateSpeed / this.domElement.clientHeight) : this.enablePan && this._pan(this.keyPanSpeed, 0), t = !0;
+        break;
+      case this.keys.RIGHT:
+        e.ctrlKey || e.metaKey || e.shiftKey ? this.enableRotate && this._rotateLeft(-O * this.keyRotateSpeed / this.domElement.clientHeight) : this.enablePan && this._pan(-this.keyPanSpeed, 0), t = !0;
+        break;
+    }
+    t && (e.preventDefault(), this.update());
+  }
+  _handleTouchStartRotate(e) {
+    if (this._pointers.length === 1)
+      this._rotateStart.set(e.pageX, e.pageY);
+    else {
+      const t = this._getSecondPointerPosition(e), n = 0.5 * (e.pageX + t.x), s = 0.5 * (e.pageY + t.y);
+      this._rotateStart.set(n, s);
+    }
+  }
+  _handleTouchStartPan(e) {
+    if (this._pointers.length === 1)
+      this._panStart.set(e.pageX, e.pageY);
+    else {
+      const t = this._getSecondPointerPosition(e), n = 0.5 * (e.pageX + t.x), s = 0.5 * (e.pageY + t.y);
+      this._panStart.set(n, s);
+    }
+  }
+  _handleTouchStartDolly(e) {
+    const t = this._getSecondPointerPosition(e), n = e.pageX - t.x, s = e.pageY - t.y, i = Math.sqrt(n * n + s * s);
+    this._dollyStart.set(0, i);
+  }
+  _handleTouchStartDollyPan(e) {
+    this.enableZoom && this._handleTouchStartDolly(e), this.enablePan && this._handleTouchStartPan(e);
+  }
+  _handleTouchStartDollyRotate(e) {
+    this.enableZoom && this._handleTouchStartDolly(e), this.enableRotate && this._handleTouchStartRotate(e);
+  }
+  _handleTouchMoveRotate(e) {
+    if (this._pointers.length == 1)
+      this._rotateEnd.set(e.pageX, e.pageY);
+    else {
+      const n = this._getSecondPointerPosition(e), s = 0.5 * (e.pageX + n.x), i = 0.5 * (e.pageY + n.y);
+      this._rotateEnd.set(s, i);
+    }
+    this._rotateDelta.subVectors(this._rotateEnd, this._rotateStart).multiplyScalar(this.rotateSpeed);
+    const t = this.domElement;
+    this._rotateLeft(O * this._rotateDelta.x / t.clientHeight), this._rotateUp(O * this._rotateDelta.y / t.clientHeight), this._rotateStart.copy(this._rotateEnd);
+  }
+  _handleTouchMovePan(e) {
+    if (this._pointers.length === 1)
+      this._panEnd.set(e.pageX, e.pageY);
+    else {
+      const t = this._getSecondPointerPosition(e), n = 0.5 * (e.pageX + t.x), s = 0.5 * (e.pageY + t.y);
+      this._panEnd.set(n, s);
+    }
+    this._panDelta.subVectors(this._panEnd, this._panStart).multiplyScalar(this.panSpeed), this._pan(this._panDelta.x, this._panDelta.y), this._panStart.copy(this._panEnd);
+  }
+  _handleTouchMoveDolly(e) {
+    const t = this._getSecondPointerPosition(e), n = e.pageX - t.x, s = e.pageY - t.y, i = Math.sqrt(n * n + s * s);
+    this._dollyEnd.set(0, i), this._dollyDelta.set(0, Math.pow(this._dollyEnd.y / this._dollyStart.y, this.zoomSpeed)), this._dollyOut(this._dollyDelta.y), this._dollyStart.copy(this._dollyEnd);
+    const o = (e.pageX + t.x) * 0.5, c = (e.pageY + t.y) * 0.5;
+    this._updateZoomParameters(o, c);
+  }
+  _handleTouchMoveDollyPan(e) {
+    this.enableZoom && this._handleTouchMoveDolly(e), this.enablePan && this._handleTouchMovePan(e);
+  }
+  _handleTouchMoveDollyRotate(e) {
+    this.enableZoom && this._handleTouchMoveDolly(e), this.enableRotate && this._handleTouchMoveRotate(e);
+  }
+  // pointers
+  _addPointer(e) {
+    this._pointers.push(e.pointerId);
+  }
+  _removePointer(e) {
+    delete this._pointerPositions[e.pointerId];
+    for (let t = 0; t < this._pointers.length; t++)
+      if (this._pointers[t] == e.pointerId) {
+        this._pointers.splice(t, 1);
+        return;
+      }
+  }
+  _isTrackingPointer(e) {
+    for (let t = 0; t < this._pointers.length; t++)
+      if (this._pointers[t] == e.pointerId) return !0;
+    return !1;
+  }
+  _trackPointer(e) {
+    let t = this._pointerPositions[e.pointerId];
+    t === void 0 && (t = new k(), this._pointerPositions[e.pointerId] = t), t.set(e.pageX, e.pageY);
+  }
+  _getSecondPointerPosition(e) {
+    const t = e.pointerId === this._pointers[0] ? this._pointers[1] : this._pointers[0];
+    return this._pointerPositions[t];
+  }
+  //
+  _customWheelEvent(e) {
+    const t = e.deltaMode, n = {
+      clientX: e.clientX,
+      clientY: e.clientY,
+      deltaY: e.deltaY
+    };
+    switch (t) {
+      case 1:
+        n.deltaY *= 16;
+        break;
+      case 2:
+        n.deltaY *= 100;
+        break;
+    }
+    return e.ctrlKey && !this._controlActive && (n.deltaY *= 10), n;
+  }
+}
+function as(r) {
+  this.enabled !== !1 && (this._pointers.length === 0 && (this.domElement.setPointerCapture(r.pointerId), this.domElement.addEventListener("pointermove", this._onPointerMove), this.domElement.addEventListener("pointerup", this._onPointerUp)), !this._isTrackingPointer(r) && (this._addPointer(r), r.pointerType === "touch" ? this._onTouchStart(r) : this._onMouseDown(r)));
+}
+function cs(r) {
+  this.enabled !== !1 && (r.pointerType === "touch" ? this._onTouchMove(r) : this._onMouseMove(r));
+}
+function ls(r) {
+  switch (this._removePointer(r), this._pointers.length) {
+    case 0:
+      this.domElement.releasePointerCapture(r.pointerId), this.domElement.removeEventListener("pointermove", this._onPointerMove), this.domElement.removeEventListener("pointerup", this._onPointerUp), this.dispatchEvent(ht), this.state = R.NONE;
+      break;
+    case 1:
+      const e = this._pointers[0], t = this._pointerPositions[e];
+      this._onTouchStart({ pointerId: e, pageX: t.x, pageY: t.y });
+      break;
+  }
+}
+function hs(r) {
+  let e;
+  switch (r.button) {
+    case 0:
+      e = this.mouseButtons.LEFT;
+      break;
+    case 1:
+      e = this.mouseButtons.MIDDLE;
+      break;
+    case 2:
+      e = this.mouseButtons.RIGHT;
+      break;
+    default:
+      e = -1;
+  }
+  switch (e) {
+    case B.DOLLY:
+      if (this.enableZoom === !1) return;
+      this._handleMouseDownDolly(r), this.state = R.DOLLY;
+      break;
+    case B.ROTATE:
+      if (r.ctrlKey || r.metaKey || r.shiftKey) {
+        if (this.enablePan === !1) return;
+        this._handleMouseDownPan(r), this.state = R.PAN;
+      } else {
+        if (this.enableRotate === !1) return;
+        this._handleMouseDownRotate(r), this.state = R.ROTATE;
+      }
+      break;
+    case B.PAN:
+      if (r.ctrlKey || r.metaKey || r.shiftKey) {
+        if (this.enableRotate === !1) return;
+        this._handleMouseDownRotate(r), this.state = R.ROTATE;
+      } else {
+        if (this.enablePan === !1) return;
+        this._handleMouseDownPan(r), this.state = R.PAN;
+      }
+      break;
+    default:
+      this.state = R.NONE;
+  }
+  this.state !== R.NONE && this.dispatchEvent(ve);
+}
+function us(r) {
+  switch (this.state) {
+    case R.ROTATE:
+      if (this.enableRotate === !1) return;
+      this._handleMouseMoveRotate(r);
+      break;
+    case R.DOLLY:
+      if (this.enableZoom === !1) return;
+      this._handleMouseMoveDolly(r);
+      break;
+    case R.PAN:
+      if (this.enablePan === !1) return;
+      this._handleMouseMovePan(r);
+      break;
+  }
+}
+function ds(r) {
+  this.enabled === !1 || this.enableZoom === !1 || this.state !== R.NONE || (r.preventDefault(), this.dispatchEvent(ve), this._handleMouseWheel(this._customWheelEvent(r)), this.dispatchEvent(ht));
+}
+function fs(r) {
+  this.enabled !== !1 && this._handleKeyDown(r);
+}
+function ps(r) {
+  switch (this._trackPointer(r), this._pointers.length) {
+    case 1:
+      switch (this.touches.ONE) {
+        case V.ROTATE:
+          if (this.enableRotate === !1) return;
+          this._handleTouchStartRotate(r), this.state = R.TOUCH_ROTATE;
+          break;
+        case V.PAN:
+          if (this.enablePan === !1) return;
+          this._handleTouchStartPan(r), this.state = R.TOUCH_PAN;
+          break;
+        default:
+          this.state = R.NONE;
+      }
+      break;
+    case 2:
+      switch (this.touches.TWO) {
+        case V.DOLLY_PAN:
+          if (this.enableZoom === !1 && this.enablePan === !1) return;
+          this._handleTouchStartDollyPan(r), this.state = R.TOUCH_DOLLY_PAN;
+          break;
+        case V.DOLLY_ROTATE:
+          if (this.enableZoom === !1 && this.enableRotate === !1) return;
+          this._handleTouchStartDollyRotate(r), this.state = R.TOUCH_DOLLY_ROTATE;
+          break;
+        default:
+          this.state = R.NONE;
+      }
+      break;
+    default:
+      this.state = R.NONE;
+  }
+  this.state !== R.NONE && this.dispatchEvent(ve);
+}
+function ms(r) {
+  switch (this._trackPointer(r), this.state) {
+    case R.TOUCH_ROTATE:
+      if (this.enableRotate === !1) return;
+      this._handleTouchMoveRotate(r), this.update();
+      break;
+    case R.TOUCH_PAN:
+      if (this.enablePan === !1) return;
+      this._handleTouchMovePan(r), this.update();
+      break;
+    case R.TOUCH_DOLLY_PAN:
+      if (this.enableZoom === !1 && this.enablePan === !1) return;
+      this._handleTouchMoveDollyPan(r), this.update();
+      break;
+    case R.TOUCH_DOLLY_ROTATE:
+      if (this.enableZoom === !1 && this.enableRotate === !1) return;
+      this._handleTouchMoveDollyRotate(r), this.update();
+      break;
+    default:
+      this.state = R.NONE;
+  }
+}
+function gs(r) {
+  this.enabled !== !1 && r.preventDefault();
+}
+function ys(r) {
+  r.key === "Control" && (this._controlActive = !0, this.domElement.getRootNode().addEventListener("keyup", this._interceptControlUp, { passive: !0, capture: !0 }));
+}
+function _s(r) {
+  r.key === "Control" && (this._controlActive = !1, this.domElement.getRootNode().removeEventListener("keyup", this._interceptControlUp, { passive: !0, capture: !0 }));
+}
+class Ts extends ut {
+  constructor(e, t) {
+    super(e, t), this.screenSpacePanning = !1, this.mouseButtons = { LEFT: B.PAN, MIDDLE: B.DOLLY, RIGHT: B.ROTATE }, this.touches = { ONE: V.PAN, TWO: V.DOLLY_ROTATE };
+  }
+}
+function We(r, e) {
+  if (e === _t)
+    return console.warn("THREE.BufferGeometryUtils.toTrianglesDrawMode(): Geometry already defined as triangles."), r;
+  if (e === Pe || e === nt) {
+    let t = r.getIndex();
+    if (t === null) {
+      const o = [], c = r.getAttribute("position");
+      if (c !== void 0) {
+        for (let a = 0; a < c.count; a++)
+          o.push(a);
+        r.setIndex(o), t = r.getIndex();
+      } else
+        return console.error("THREE.BufferGeometryUtils.toTrianglesDrawMode(): Undefined position attribute. Processing not possible."), r;
+    }
+    const n = t.count - 2, s = [];
+    if (e === Pe)
+      for (let o = 1; o <= n; o++)
+        s.push(t.getX(0)), s.push(t.getX(o)), s.push(t.getX(o + 1));
+    else
+      for (let o = 0; o < n; o++)
+        o % 2 === 0 ? (s.push(t.getX(o)), s.push(t.getX(o + 1)), s.push(t.getX(o + 2))) : (s.push(t.getX(o + 2)), s.push(t.getX(o + 1)), s.push(t.getX(o)));
+    s.length / 3 !== n && console.error("THREE.BufferGeometryUtils.toTrianglesDrawMode(): Unable to generate correct amount of triangles.");
+    const i = r.clone();
+    return i.setIndex(s), i.clearGroups(), i;
+  } else
+    return console.error("THREE.BufferGeometryUtils.toTrianglesDrawMode(): Unknown draw mode:", e), r;
+}
+const Ee = /* @__PURE__ */ new WeakMap();
+class ws extends it {
+  /**
+   * Constructs a new Draco loader.
+   *
+   * @param {LoadingManager} [manager] - The loading manager.
+   */
+  constructor(e) {
+    super(e), this.decoderPath = "", this.decoderConfig = {}, this.decoderBinary = null, this.decoderPending = null, this.workerLimit = 4, this.workerPool = [], this.workerNextTaskID = 1, this.workerSourceURL = "", this.defaultAttributeIDs = {
+      position: "POSITION",
+      normal: "NORMAL",
+      color: "COLOR",
+      uv: "TEX_COORD"
+    }, this.defaultAttributeTypes = {
+      position: "Float32Array",
+      normal: "Float32Array",
+      color: "Float32Array",
+      uv: "Float32Array"
+    };
+  }
+  /**
+   * Provides configuration for the decoder libraries. Configuration cannot be changed after decoding begins.
+   *
+   * @param {string} path - The decoder path.
+   * @return {DRACOLoader} A reference to this loader.
+   */
+  setDecoderPath(e) {
+    return this.decoderPath = e, this;
+  }
+  /**
+   * Provides configuration for the decoder libraries. Configuration cannot be changed after decoding begins.
+   *
+   * @param {{type:('js'|'wasm')}} config - The decoder config.
+   * @return {DRACOLoader} A reference to this loader.
+   */
+  setDecoderConfig(e) {
+    return this.decoderConfig = e, this;
+  }
+  /**
+   * Sets the maximum number of Web Workers to be used during decoding.
+   * A lower limit may be preferable if workers are also for other tasks in the application.
+   *
+   * @param {number} workerLimit - The worker limit.
+   * @return {DRACOLoader} A reference to this loader.
+   */
+  setWorkerLimit(e) {
+    return this.workerLimit = e, this;
+  }
+  /**
+   * Starts loading from the given URL and passes the loaded Draco asset
+   * to the `onLoad()` callback.
+   *
+   * @param {string} url - The path/URL of the file to be loaded. This can also be a data URI.
+   * @param {function(BufferGeometry)} onLoad - Executed when the loading process has been finished.
+   * @param {onProgressCallback} onProgress - Executed while the loading is in progress.
+   * @param {onErrorCallback} onError - Executed when errors occur.
+   */
+  load(e, t, n, s) {
+    const i = new de(this.manager);
+    i.setPath(this.path), i.setResponseType("arraybuffer"), i.setRequestHeader(this.requestHeader), i.setWithCredentials(this.withCredentials), i.load(e, (o) => {
+      this.parse(o, t, s);
+    }, n, s);
+  }
+  /**
+   * Parses the given Draco data.
+   *
+   * @param {ArrayBuffer} buffer - The raw Draco data as an array buffer.
+   * @param {function(BufferGeometry)} onLoad - Executed when the loading/parsing process has been finished.
+   * @param {onErrorCallback} onError - Executed when errors occur.
+   */
+  parse(e, t, n = () => {
+  }) {
+    this.decodeDracoFile(e, t, null, null, Y, n).catch(n);
+  }
+  //
+  decodeDracoFile(e, t, n, s, i = U, o = () => {
+  }) {
+    const c = {
+      attributeIDs: n || this.defaultAttributeIDs,
+      attributeTypes: s || this.defaultAttributeTypes,
+      useUniqueIDs: !!n,
+      vertexColorSpace: i
+    };
+    return this.decodeGeometry(e, c).then(t).catch(o);
+  }
+  decodeGeometry(e, t) {
+    const n = JSON.stringify(t);
+    if (Ee.has(e)) {
+      const a = Ee.get(e);
+      if (a.key === n)
+        return a.promise;
+      if (e.byteLength === 0)
+        throw new Error(
+          "THREE.DRACOLoader: Unable to re-decode a buffer with different settings. Buffer has already been transferred."
+        );
+    }
+    let s;
+    const i = this.workerNextTaskID++, o = e.byteLength, c = this._getWorker(i, o).then((a) => (s = a, new Promise((l, u) => {
+      s._callbacks[i] = { resolve: l, reject: u }, s.postMessage({ type: "decode", id: i, taskConfig: t, buffer: e }, [e]);
+    }))).then((a) => this._createGeometry(a.geometry));
+    return c.catch(() => !0).then(() => {
+      s && i && this._releaseTask(s, i);
+    }), Ee.set(e, {
+      key: n,
+      promise: c
+    }), c;
+  }
+  _createGeometry(e) {
+    const t = new ot();
+    e.index && t.setIndex(new oe(e.index.array, 1));
+    for (let n = 0; n < e.attributes.length; n++) {
+      const s = e.attributes[n], i = s.name, o = s.array, c = s.itemSize, a = new oe(o, c);
+      i === "color" && (this._assignVertexColorSpace(a, s.vertexColorSpace), a.normalized = !(o instanceof Float32Array)), t.setAttribute(i, a);
+    }
+    return t;
+  }
+  _assignVertexColorSpace(e, t) {
+    if (t !== Y) return;
+    const n = new q();
+    for (let s = 0, i = e.count; s < i; s++)
+      n.fromBufferAttribute(e, s), De.colorSpaceToWorking(n, Y), e.setXYZ(s, n.r, n.g, n.b);
+  }
+  _loadLibrary(e, t) {
+    const n = new de(this.manager);
+    return n.setPath(this.decoderPath), n.setResponseType(t), n.setWithCredentials(this.withCredentials), new Promise((s, i) => {
+      n.load(e, s, void 0, i);
+    });
+  }
+  preload() {
+    return this._initDecoder(), this;
+  }
+  _initDecoder() {
+    if (this.decoderPending) return this.decoderPending;
+    const e = typeof WebAssembly != "object" || this.decoderConfig.type === "js", t = [];
+    return e ? t.push(this._loadLibrary("draco_decoder.js", "text")) : (t.push(this._loadLibrary("draco_wasm_wrapper.js", "text")), t.push(this._loadLibrary("draco_decoder.wasm", "arraybuffer"))), this.decoderPending = Promise.all(t).then((n) => {
+      const s = n[0];
+      e || (this.decoderConfig.wasmBinary = n[1]);
+      const i = bs.toString(), o = [
+        "/* draco decoder */",
+        s,
+        "",
+        "/* worker */",
+        i.substring(i.indexOf("{") + 1, i.lastIndexOf("}"))
+      ].join(`
+`);
+      this.workerSourceURL = URL.createObjectURL(new Blob([o]));
+    }), this.decoderPending;
+  }
+  _getWorker(e, t) {
+    return this._initDecoder().then(() => {
+      if (this.workerPool.length < this.workerLimit) {
+        const s = new Worker(this.workerSourceURL);
+        s._callbacks = {}, s._taskCosts = {}, s._taskLoad = 0, s.postMessage({ type: "init", decoderConfig: this.decoderConfig }), s.onmessage = function(i) {
+          const o = i.data;
+          switch (o.type) {
+            case "decode":
+              s._callbacks[o.id].resolve(o);
+              break;
+            case "error":
+              s._callbacks[o.id].reject(o);
+              break;
+            default:
+              console.error('THREE.DRACOLoader: Unexpected message, "' + o.type + '"');
+          }
+        }, this.workerPool.push(s);
+      } else
+        this.workerPool.sort(function(s, i) {
+          return s._taskLoad > i._taskLoad ? -1 : 1;
+        });
+      const n = this.workerPool[this.workerPool.length - 1];
+      return n._taskCosts[e] = t, n._taskLoad += t, n;
+    });
+  }
+  _releaseTask(e, t) {
+    e._taskLoad -= e._taskCosts[t], delete e._callbacks[t], delete e._taskCosts[t];
+  }
+  debug() {
+    console.log("Task load: ", this.workerPool.map((e) => e._taskLoad));
+  }
+  dispose() {
+    for (let e = 0; e < this.workerPool.length; ++e)
+      this.workerPool[e].terminate();
+    return this.workerPool.length = 0, this.workerSourceURL !== "" && URL.revokeObjectURL(this.workerSourceURL), this;
+  }
+}
+function bs() {
+  let r, e;
+  onmessage = function(o) {
+    const c = o.data;
+    switch (c.type) {
+      case "init":
+        r = c.decoderConfig, e = new Promise(function(u) {
+          r.onModuleLoaded = function(h) {
+            u({ draco: h });
+          }, DracoDecoderModule(r);
+        });
+        break;
+      case "decode":
+        const a = c.buffer, l = c.taskConfig;
+        e.then((u) => {
+          const h = u.draco, p = new h.Decoder();
+          try {
+            const m = t(h, p, new Int8Array(a), l), _ = m.attributes.map((w) => w.array.buffer);
+            m.index && _.push(m.index.array.buffer), self.postMessage({ type: "decode", id: c.id, geometry: m }, _);
+          } catch (m) {
+            console.error(m), self.postMessage({ type: "error", id: c.id, error: m.message });
+          } finally {
+            h.destroy(p);
+          }
+        });
+        break;
+    }
+  };
+  function t(o, c, a, l) {
+    const u = l.attributeIDs, h = l.attributeTypes;
+    let p, m;
+    const _ = c.GetEncodedGeometryType(a);
+    if (_ === o.TRIANGULAR_MESH)
+      p = new o.Mesh(), m = c.DecodeArrayToMesh(a, a.byteLength, p);
+    else if (_ === o.POINT_CLOUD)
+      p = new o.PointCloud(), m = c.DecodeArrayToPointCloud(a, a.byteLength, p);
+    else
+      throw new Error("THREE.DRACOLoader: Unexpected geometry type.");
+    if (!m.ok() || p.ptr === 0)
+      throw new Error("THREE.DRACOLoader: Decoding failed: " + m.error_msg());
+    const w = { index: null, attributes: [] };
+    for (const d in u) {
+      const f = self[h[d]];
+      let g, T;
+      if (l.useUniqueIDs)
+        T = u[d], g = c.GetAttributeByUniqueId(p, T);
+      else {
+        if (T = c.GetAttributeId(p, o[u[d]]), T === -1) continue;
+        g = c.GetAttribute(p, T);
+      }
+      const y = s(o, c, p, d, f, g);
+      d === "color" && (y.vertexColorSpace = l.vertexColorSpace), w.attributes.push(y);
+    }
+    return _ === o.TRIANGULAR_MESH && (w.index = n(o, c, p)), o.destroy(p), w;
+  }
+  function n(o, c, a) {
+    const u = a.num_faces() * 3, h = u * 4, p = o._malloc(h);
+    c.GetTrianglesUInt32Array(a, h, p);
+    const m = new Uint32Array(o.HEAPF32.buffer, p, u).slice();
+    return o._free(p), { array: m, itemSize: 1 };
+  }
+  function s(o, c, a, l, u, h) {
+    const p = h.num_components(), _ = a.num_points() * p, w = _ * u.BYTES_PER_ELEMENT, d = i(o, u), f = o._malloc(w);
+    c.GetAttributeDataArrayForAllPoints(a, h, d, w, f);
+    const g = new u(o.HEAPF32.buffer, f, _).slice();
+    return o._free(f), {
+      name: l,
+      array: g,
+      itemSize: p
+    };
+  }
+  function i(o, c) {
+    switch (c) {
+      case Float32Array:
+        return o.DT_FLOAT32;
+      case Int8Array:
+        return o.DT_INT8;
+      case Int16Array:
+        return o.DT_INT16;
+      case Int32Array:
+        return o.DT_INT32;
+      case Uint8Array:
+        return o.DT_UINT8;
+      case Uint16Array:
+        return o.DT_UINT16;
+      case Uint32Array:
+        return o.DT_UINT32;
+    }
+  }
+}
+class Es extends it {
+  /**
+   * Constructs a new glTF loader.
+   *
+   * @param {LoadingManager} [manager] - The loading manager.
+   */
+  constructor(e) {
+    super(e), this.dracoLoader = null, this.ktx2Loader = null, this.meshoptDecoder = null, this.pluginCallbacks = [], this.register(function(t) {
+      return new Ss(t);
+    }), this.register(function(t) {
+      return new Ls(t);
+    }), this.register(function(t) {
+      return new Hs(t);
+    }), this.register(function(t) {
+      return new Fs(t);
+    }), this.register(function(t) {
+      return new Us(t);
+    }), this.register(function(t) {
+      return new Ds(t);
+    }), this.register(function(t) {
+      return new Cs(t);
+    }), this.register(function(t) {
+      return new Os(t);
+    }), this.register(function(t) {
+      return new ks(t);
+    }), this.register(function(t) {
+      return new Ms(t);
+    }), this.register(function(t) {
+      return new Is(t);
+    }), this.register(function(t) {
+      return new Ps(t);
+    }), this.register(function(t) {
+      return new vs(t);
+    }), this.register(function(t) {
+      return new Ns(t);
+    }), this.register(function(t) {
+      return new As(t);
+    }), this.register(function(t) {
+      return new js(t);
+    }), this.register(function(t) {
+      return new Gs(t);
+    });
+  }
+  /**
+   * Starts loading from the given URL and passes the loaded glTF asset
+   * to the `onLoad()` callback.
+   *
+   * @param {string} url - The path/URL of the file to be loaded. This can also be a data URI.
+   * @param {function(GLTFLoader~LoadObject)} onLoad - Executed when the loading process has been finished.
+   * @param {onProgressCallback} onProgress - Executed while the loading is in progress.
+   * @param {onErrorCallback} onError - Executed when errors occur.
+   */
+  load(e, t, n, s) {
+    const i = this;
+    let o;
+    if (this.resourcePath !== "")
+      o = this.resourcePath;
+    else if (this.path !== "") {
+      const l = re.extractUrlBase(e);
+      o = re.resolveURL(l, this.path);
+    } else
+      o = re.extractUrlBase(e);
+    this.manager.itemStart(e);
+    const c = function(l) {
+      s ? s(l) : console.error(l), i.manager.itemError(e), i.manager.itemEnd(e);
+    }, a = new de(this.manager);
+    a.setPath(this.path), a.setResponseType("arraybuffer"), a.setRequestHeader(this.requestHeader), a.setWithCredentials(this.withCredentials), a.load(e, function(l) {
+      try {
+        i.parse(l, o, function(u) {
+          t(u), i.manager.itemEnd(e);
+        }, c);
+      } catch (u) {
+        c(u);
+      }
+    }, n, c);
+  }
+  /**
+   * Sets the given Draco loader to this loader. Required for decoding assets
+   * compressed with the `KHR_draco_mesh_compression` extension.
+   *
+   * @param {DRACOLoader} dracoLoader - The Draco loader to set.
+   * @return {GLTFLoader} A reference to this loader.
+   */
+  setDRACOLoader(e) {
+    return this.dracoLoader = e, this;
+  }
+  /**
+   * Sets the given KTX2 loader to this loader. Required for loading KTX2
+   * compressed textures.
+   *
+   * @param {KTX2Loader} ktx2Loader - The KTX2 loader to set.
+   * @return {GLTFLoader} A reference to this loader.
+   */
+  setKTX2Loader(e) {
+    return this.ktx2Loader = e, this;
+  }
+  /**
+   * Sets the given meshopt decoder. Required for decoding assets
+   * compressed with the `EXT_meshopt_compression` extension.
+   *
+   * @param {Object} meshoptDecoder - The meshopt decoder to set.
+   * @return {GLTFLoader} A reference to this loader.
+   */
+  setMeshoptDecoder(e) {
+    return this.meshoptDecoder = e, this;
+  }
+  /**
+   * Registers a plugin callback. This API is internally used to implement the various
+   * glTF extensions but can also used by third-party code to add additional logic
+   * to the loader.
+   *
+   * @param {function(parser:GLTFParser)} callback - The callback function to register.
+   * @return {GLTFLoader} A reference to this loader.
+   */
+  register(e) {
+    return this.pluginCallbacks.indexOf(e) === -1 && this.pluginCallbacks.push(e), this;
+  }
+  /**
+   * Unregisters a plugin callback.
+   *
+   * @param {Function} callback - The callback function to unregister.
+   * @return {GLTFLoader} A reference to this loader.
+   */
+  unregister(e) {
+    return this.pluginCallbacks.indexOf(e) !== -1 && this.pluginCallbacks.splice(this.pluginCallbacks.indexOf(e), 1), this;
+  }
+  /**
+   * Parses the given FBX data and returns the resulting group.
+   *
+   * @param {string|ArrayBuffer} data - The raw glTF data.
+   * @param {string} path - The URL base path.
+   * @param {function(GLTFLoader~LoadObject)} onLoad - Executed when the loading process has been finished.
+   * @param {onErrorCallback} onError - Executed when errors occur.
+   */
+  parse(e, t, n, s) {
+    let i;
+    const o = {}, c = {}, a = new TextDecoder();
+    if (typeof e == "string")
+      i = JSON.parse(e);
+    else if (e instanceof ArrayBuffer)
+      if (a.decode(new Uint8Array(e, 0, 4)) === dt) {
+        try {
+          o[b.KHR_BINARY_GLTF] = new Bs(e);
+        } catch (h) {
+          s && s(h);
+          return;
+        }
+        i = JSON.parse(o[b.KHR_BINARY_GLTF].content);
+      } else
+        i = JSON.parse(a.decode(e));
+    else
+      i = e;
+    if (i.asset === void 0 || i.asset.version[0] < 2) {
+      s && s(new Error("THREE.GLTFLoader: Unsupported asset. glTF versions >=2.0 are supported."));
+      return;
+    }
+    const l = new tn(i, {
+      path: t || this.resourcePath || "",
+      crossOrigin: this.crossOrigin,
+      requestHeader: this.requestHeader,
+      manager: this.manager,
+      ktx2Loader: this.ktx2Loader,
+      meshoptDecoder: this.meshoptDecoder
+    });
+    l.fileLoader.setRequestHeader(this.requestHeader);
+    for (let u = 0; u < this.pluginCallbacks.length; u++) {
+      const h = this.pluginCallbacks[u](l);
+      h.name || console.error("THREE.GLTFLoader: Invalid plugin found: missing name"), c[h.name] = h, o[h.name] = !0;
+    }
+    if (i.extensionsUsed)
+      for (let u = 0; u < i.extensionsUsed.length; ++u) {
+        const h = i.extensionsUsed[u], p = i.extensionsRequired || [];
+        switch (h) {
+          case b.KHR_MATERIALS_UNLIT:
+            o[h] = new Rs();
+            break;
+          case b.KHR_DRACO_MESH_COMPRESSION:
+            o[h] = new zs(i, this.dracoLoader);
+            break;
+          case b.KHR_TEXTURE_TRANSFORM:
+            o[h] = new Ks();
+            break;
+          case b.KHR_MESH_QUANTIZATION:
+            o[h] = new Ws();
+            break;
+          default:
+            p.indexOf(h) >= 0 && c[h] === void 0 && console.warn('THREE.GLTFLoader: Unknown extension "' + h + '".');
+        }
+      }
+    l.setExtensions(o), l.setPlugins(c), l.parse(n, s);
+  }
+  /**
+   * Async version of {@link GLTFLoader#parse}.
+   *
+   * @async
+   * @param {string|ArrayBuffer} data - The raw glTF data.
+   * @param {string} path - The URL base path.
+   * @return {Promise<GLTFLoader~LoadObject>} A Promise that resolves with the loaded glTF when the parsing has been finished.
+   */
+  parseAsync(e, t) {
+    const n = this;
+    return new Promise(function(s, i) {
+      n.parse(e, t, s, i);
+    });
+  }
+}
+function xs() {
+  let r = {};
+  return {
+    get: function(e) {
+      return r[e];
+    },
+    add: function(e, t) {
+      r[e] = t;
+    },
+    remove: function(e) {
+      delete r[e];
+    },
+    removeAll: function() {
+      r = {};
+    }
+  };
+}
+const b = {
+  KHR_BINARY_GLTF: "KHR_binary_glTF",
+  KHR_DRACO_MESH_COMPRESSION: "KHR_draco_mesh_compression",
+  KHR_LIGHTS_PUNCTUAL: "KHR_lights_punctual",
+  KHR_MATERIALS_CLEARCOAT: "KHR_materials_clearcoat",
+  KHR_MATERIALS_DISPERSION: "KHR_materials_dispersion",
+  KHR_MATERIALS_IOR: "KHR_materials_ior",
+  KHR_MATERIALS_SHEEN: "KHR_materials_sheen",
+  KHR_MATERIALS_SPECULAR: "KHR_materials_specular",
+  KHR_MATERIALS_TRANSMISSION: "KHR_materials_transmission",
+  KHR_MATERIALS_IRIDESCENCE: "KHR_materials_iridescence",
+  KHR_MATERIALS_ANISOTROPY: "KHR_materials_anisotropy",
+  KHR_MATERIALS_UNLIT: "KHR_materials_unlit",
+  KHR_MATERIALS_VOLUME: "KHR_materials_volume",
+  KHR_TEXTURE_BASISU: "KHR_texture_basisu",
+  KHR_TEXTURE_TRANSFORM: "KHR_texture_transform",
+  KHR_MESH_QUANTIZATION: "KHR_mesh_quantization",
+  KHR_MATERIALS_EMISSIVE_STRENGTH: "KHR_materials_emissive_strength",
+  EXT_MATERIALS_BUMP: "EXT_materials_bump",
+  EXT_TEXTURE_WEBP: "EXT_texture_webp",
+  EXT_TEXTURE_AVIF: "EXT_texture_avif",
+  EXT_MESHOPT_COMPRESSION: "EXT_meshopt_compression",
+  EXT_MESH_GPU_INSTANCING: "EXT_mesh_gpu_instancing"
+};
+class As {
+  constructor(e) {
+    this.parser = e, this.name = b.KHR_LIGHTS_PUNCTUAL, this.cache = { refs: {}, uses: {} };
+  }
+  _markDefs() {
+    const e = this.parser, t = this.parser.json.nodes || [];
+    for (let n = 0, s = t.length; n < s; n++) {
+      const i = t[n];
+      i.extensions && i.extensions[this.name] && i.extensions[this.name].light !== void 0 && e._addNodeRef(this.cache, i.extensions[this.name].light);
+    }
+  }
+  _loadLight(e) {
+    const t = this.parser, n = "light:" + e;
+    let s = t.cache.get(n);
+    if (s) return s;
+    const i = t.json, a = ((i.extensions && i.extensions[this.name] || {}).lights || [])[e];
+    let l;
+    const u = new q(16777215);
+    a.color !== void 0 && u.setRGB(a.color[0], a.color[1], a.color[2], U);
+    const h = a.range !== void 0 ? a.range : 0;
+    switch (a.type) {
+      case "directional":
+        l = new bt(u), l.target.position.set(0, 0, -1), l.add(l.target);
+        break;
+      case "point":
+        l = new wt(u), l.distance = h;
+        break;
+      case "spot":
+        l = new Tt(u), l.distance = h, a.spot = a.spot || {}, a.spot.innerConeAngle = a.spot.innerConeAngle !== void 0 ? a.spot.innerConeAngle : 0, a.spot.outerConeAngle = a.spot.outerConeAngle !== void 0 ? a.spot.outerConeAngle : Math.PI / 4, l.angle = a.spot.outerConeAngle, l.penumbra = 1 - a.spot.innerConeAngle / a.spot.outerConeAngle, l.target.position.set(0, 0, -1), l.add(l.target);
+        break;
+      default:
+        throw new Error("THREE.GLTFLoader: Unexpected light type: " + a.type);
+    }
+    return l.position.set(0, 0, 0), G(l, a), a.intensity !== void 0 && (l.intensity = a.intensity), l.name = t.createUniqueName(a.name || "light_" + e), s = Promise.resolve(l), t.cache.add(n, s), s;
+  }
+  getDependency(e, t) {
+    if (e === "light")
+      return this._loadLight(t);
+  }
+  createNodeAttachment(e) {
+    const t = this, n = this.parser, i = n.json.nodes[e], c = (i.extensions && i.extensions[this.name] || {}).light;
+    return c === void 0 ? null : this._loadLight(c).then(function(a) {
+      return n._getNodeRef(t.cache, c, a);
+    });
+  }
+}
+class Rs {
+  constructor() {
+    this.name = b.KHR_MATERIALS_UNLIT;
+  }
+  getMaterialType() {
+    return ie;
+  }
+  extendParams(e, t, n) {
+    const s = [];
+    e.color = new q(1, 1, 1), e.opacity = 1;
+    const i = t.pbrMetallicRoughness;
+    if (i) {
+      if (Array.isArray(i.baseColorFactor)) {
+        const o = i.baseColorFactor;
+        e.color.setRGB(o[0], o[1], o[2], U), e.opacity = o[3];
+      }
+      i.baseColorTexture !== void 0 && s.push(n.assignTexture(e, "map", i.baseColorTexture, Y));
+    }
+    return Promise.all(s);
+  }
+}
+class Ms {
+  constructor(e) {
+    this.parser = e, this.name = b.KHR_MATERIALS_EMISSIVE_STRENGTH;
+  }
+  extendMaterialParams(e, t) {
+    const s = this.parser.json.materials[e];
+    if (!s.extensions || !s.extensions[this.name])
+      return Promise.resolve();
+    const i = s.extensions[this.name].emissiveStrength;
+    return i !== void 0 && (t.emissiveIntensity = i), Promise.resolve();
+  }
+}
+class Ss {
+  constructor(e) {
+    this.parser = e, this.name = b.KHR_MATERIALS_CLEARCOAT;
+  }
+  getMaterialType(e) {
+    const n = this.parser.json.materials[e];
+    return !n.extensions || !n.extensions[this.name] ? null : j;
+  }
+  extendMaterialParams(e, t) {
+    const n = this.parser, s = n.json.materials[e];
+    if (!s.extensions || !s.extensions[this.name])
+      return Promise.resolve();
+    const i = [], o = s.extensions[this.name];
+    if (o.clearcoatFactor !== void 0 && (t.clearcoat = o.clearcoatFactor), o.clearcoatTexture !== void 0 && i.push(n.assignTexture(t, "clearcoatMap", o.clearcoatTexture)), o.clearcoatRoughnessFactor !== void 0 && (t.clearcoatRoughness = o.clearcoatRoughnessFactor), o.clearcoatRoughnessTexture !== void 0 && i.push(n.assignTexture(t, "clearcoatRoughnessMap", o.clearcoatRoughnessTexture)), o.clearcoatNormalTexture !== void 0 && (i.push(n.assignTexture(t, "clearcoatNormalMap", o.clearcoatNormalTexture)), o.clearcoatNormalTexture.scale !== void 0)) {
+      const c = o.clearcoatNormalTexture.scale;
+      t.clearcoatNormalScale = new k(c, c);
+    }
+    return Promise.all(i);
+  }
+}
+class Ls {
+  constructor(e) {
+    this.parser = e, this.name = b.KHR_MATERIALS_DISPERSION;
+  }
+  getMaterialType(e) {
+    const n = this.parser.json.materials[e];
+    return !n.extensions || !n.extensions[this.name] ? null : j;
+  }
+  extendMaterialParams(e, t) {
+    const s = this.parser.json.materials[e];
+    if (!s.extensions || !s.extensions[this.name])
+      return Promise.resolve();
+    const i = s.extensions[this.name];
+    return t.dispersion = i.dispersion !== void 0 ? i.dispersion : 0, Promise.resolve();
+  }
+}
+class Ps {
+  constructor(e) {
+    this.parser = e, this.name = b.KHR_MATERIALS_IRIDESCENCE;
+  }
+  getMaterialType(e) {
+    const n = this.parser.json.materials[e];
+    return !n.extensions || !n.extensions[this.name] ? null : j;
+  }
+  extendMaterialParams(e, t) {
+    const n = this.parser, s = n.json.materials[e];
+    if (!s.extensions || !s.extensions[this.name])
+      return Promise.resolve();
+    const i = [], o = s.extensions[this.name];
+    return o.iridescenceFactor !== void 0 && (t.iridescence = o.iridescenceFactor), o.iridescenceTexture !== void 0 && i.push(n.assignTexture(t, "iridescenceMap", o.iridescenceTexture)), o.iridescenceIor !== void 0 && (t.iridescenceIOR = o.iridescenceIor), t.iridescenceThicknessRange === void 0 && (t.iridescenceThicknessRange = [100, 400]), o.iridescenceThicknessMinimum !== void 0 && (t.iridescenceThicknessRange[0] = o.iridescenceThicknessMinimum), o.iridescenceThicknessMaximum !== void 0 && (t.iridescenceThicknessRange[1] = o.iridescenceThicknessMaximum), o.iridescenceThicknessTexture !== void 0 && i.push(n.assignTexture(t, "iridescenceThicknessMap", o.iridescenceThicknessTexture)), Promise.all(i);
+  }
+}
+class Ds {
+  constructor(e) {
+    this.parser = e, this.name = b.KHR_MATERIALS_SHEEN;
+  }
+  getMaterialType(e) {
+    const n = this.parser.json.materials[e];
+    return !n.extensions || !n.extensions[this.name] ? null : j;
+  }
+  extendMaterialParams(e, t) {
+    const n = this.parser, s = n.json.materials[e];
+    if (!s.extensions || !s.extensions[this.name])
+      return Promise.resolve();
+    const i = [];
+    t.sheenColor = new q(0, 0, 0), t.sheenRoughness = 0, t.sheen = 1;
+    const o = s.extensions[this.name];
+    if (o.sheenColorFactor !== void 0) {
+      const c = o.sheenColorFactor;
+      t.sheenColor.setRGB(c[0], c[1], c[2], U);
+    }
+    return o.sheenRoughnessFactor !== void 0 && (t.sheenRoughness = o.sheenRoughnessFactor), o.sheenColorTexture !== void 0 && i.push(n.assignTexture(t, "sheenColorMap", o.sheenColorTexture, Y)), o.sheenRoughnessTexture !== void 0 && i.push(n.assignTexture(t, "sheenRoughnessMap", o.sheenRoughnessTexture)), Promise.all(i);
+  }
+}
+class Cs {
+  constructor(e) {
+    this.parser = e, this.name = b.KHR_MATERIALS_TRANSMISSION;
+  }
+  getMaterialType(e) {
+    const n = this.parser.json.materials[e];
+    return !n.extensions || !n.extensions[this.name] ? null : j;
+  }
+  extendMaterialParams(e, t) {
+    const n = this.parser, s = n.json.materials[e];
+    if (!s.extensions || !s.extensions[this.name])
+      return Promise.resolve();
+    const i = [], o = s.extensions[this.name];
+    return o.transmissionFactor !== void 0 && (t.transmission = o.transmissionFactor), o.transmissionTexture !== void 0 && i.push(n.assignTexture(t, "transmissionMap", o.transmissionTexture)), Promise.all(i);
+  }
+}
+class Os {
+  constructor(e) {
+    this.parser = e, this.name = b.KHR_MATERIALS_VOLUME;
+  }
+  getMaterialType(e) {
+    const n = this.parser.json.materials[e];
+    return !n.extensions || !n.extensions[this.name] ? null : j;
+  }
+  extendMaterialParams(e, t) {
+    const n = this.parser, s = n.json.materials[e];
+    if (!s.extensions || !s.extensions[this.name])
+      return Promise.resolve();
+    const i = [], o = s.extensions[this.name];
+    t.thickness = o.thicknessFactor !== void 0 ? o.thicknessFactor : 0, o.thicknessTexture !== void 0 && i.push(n.assignTexture(t, "thicknessMap", o.thicknessTexture)), t.attenuationDistance = o.attenuationDistance || 1 / 0;
+    const c = o.attenuationColor || [1, 1, 1];
+    return t.attenuationColor = new q().setRGB(c[0], c[1], c[2], U), Promise.all(i);
+  }
+}
+class ks {
+  constructor(e) {
+    this.parser = e, this.name = b.KHR_MATERIALS_IOR;
+  }
+  getMaterialType(e) {
+    const n = this.parser.json.materials[e];
+    return !n.extensions || !n.extensions[this.name] ? null : j;
+  }
+  extendMaterialParams(e, t) {
+    const s = this.parser.json.materials[e];
+    if (!s.extensions || !s.extensions[this.name])
+      return Promise.resolve();
+    const i = s.extensions[this.name];
+    return t.ior = i.ior !== void 0 ? i.ior : 1.5, Promise.resolve();
+  }
+}
+class Is {
+  constructor(e) {
+    this.parser = e, this.name = b.KHR_MATERIALS_SPECULAR;
+  }
+  getMaterialType(e) {
+    const n = this.parser.json.materials[e];
+    return !n.extensions || !n.extensions[this.name] ? null : j;
+  }
+  extendMaterialParams(e, t) {
+    const n = this.parser, s = n.json.materials[e];
+    if (!s.extensions || !s.extensions[this.name])
+      return Promise.resolve();
+    const i = [], o = s.extensions[this.name];
+    t.specularIntensity = o.specularFactor !== void 0 ? o.specularFactor : 1, o.specularTexture !== void 0 && i.push(n.assignTexture(t, "specularIntensityMap", o.specularTexture));
+    const c = o.specularColorFactor || [1, 1, 1];
+    return t.specularColor = new q().setRGB(c[0], c[1], c[2], U), o.specularColorTexture !== void 0 && i.push(n.assignTexture(t, "specularColorMap", o.specularColorTexture, Y)), Promise.all(i);
+  }
+}
+class Ns {
+  constructor(e) {
+    this.parser = e, this.name = b.EXT_MATERIALS_BUMP;
+  }
+  getMaterialType(e) {
+    const n = this.parser.json.materials[e];
+    return !n.extensions || !n.extensions[this.name] ? null : j;
+  }
+  extendMaterialParams(e, t) {
+    const n = this.parser, s = n.json.materials[e];
+    if (!s.extensions || !s.extensions[this.name])
+      return Promise.resolve();
+    const i = [], o = s.extensions[this.name];
+    return t.bumpScale = o.bumpFactor !== void 0 ? o.bumpFactor : 1, o.bumpTexture !== void 0 && i.push(n.assignTexture(t, "bumpMap", o.bumpTexture)), Promise.all(i);
+  }
+}
+class vs {
+  constructor(e) {
+    this.parser = e, this.name = b.KHR_MATERIALS_ANISOTROPY;
+  }
+  getMaterialType(e) {
+    const n = this.parser.json.materials[e];
+    return !n.extensions || !n.extensions[this.name] ? null : j;
+  }
+  extendMaterialParams(e, t) {
+    const n = this.parser, s = n.json.materials[e];
+    if (!s.extensions || !s.extensions[this.name])
+      return Promise.resolve();
+    const i = [], o = s.extensions[this.name];
+    return o.anisotropyStrength !== void 0 && (t.anisotropy = o.anisotropyStrength), o.anisotropyRotation !== void 0 && (t.anisotropyRotation = o.anisotropyRotation), o.anisotropyTexture !== void 0 && i.push(n.assignTexture(t, "anisotropyMap", o.anisotropyTexture)), Promise.all(i);
+  }
+}
+class Hs {
+  constructor(e) {
+    this.parser = e, this.name = b.KHR_TEXTURE_BASISU;
+  }
+  loadTexture(e) {
+    const t = this.parser, n = t.json, s = n.textures[e];
+    if (!s.extensions || !s.extensions[this.name])
+      return null;
+    const i = s.extensions[this.name], o = t.options.ktx2Loader;
+    if (!o) {
+      if (n.extensionsRequired && n.extensionsRequired.indexOf(this.name) >= 0)
+        throw new Error("THREE.GLTFLoader: setKTX2Loader must be called before loading KTX2 textures");
+      return null;
+    }
+    return t.loadTextureImage(e, i.source, o);
+  }
+}
+class Fs {
+  constructor(e) {
+    this.parser = e, this.name = b.EXT_TEXTURE_WEBP;
+  }
+  loadTexture(e) {
+    const t = this.name, n = this.parser, s = n.json, i = s.textures[e];
+    if (!i.extensions || !i.extensions[t])
+      return null;
+    const o = i.extensions[t], c = s.images[o.source];
+    let a = n.textureLoader;
+    if (c.uri) {
+      const l = n.options.manager.getHandler(c.uri);
+      l !== null && (a = l);
+    }
+    return n.loadTextureImage(e, o.source, a);
+  }
+}
+class Us {
+  constructor(e) {
+    this.parser = e, this.name = b.EXT_TEXTURE_AVIF;
+  }
+  loadTexture(e) {
+    const t = this.name, n = this.parser, s = n.json, i = s.textures[e];
+    if (!i.extensions || !i.extensions[t])
+      return null;
+    const o = i.extensions[t], c = s.images[o.source];
+    let a = n.textureLoader;
+    if (c.uri) {
+      const l = n.options.manager.getHandler(c.uri);
+      l !== null && (a = l);
+    }
+    return n.loadTextureImage(e, o.source, a);
+  }
+}
+class js {
+  constructor(e) {
+    this.name = b.EXT_MESHOPT_COMPRESSION, this.parser = e;
+  }
+  loadBufferView(e) {
+    const t = this.parser.json, n = t.bufferViews[e];
+    if (n.extensions && n.extensions[this.name]) {
+      const s = n.extensions[this.name], i = this.parser.getDependency("buffer", s.buffer), o = this.parser.options.meshoptDecoder;
+      if (!o || !o.supported) {
+        if (t.extensionsRequired && t.extensionsRequired.indexOf(this.name) >= 0)
+          throw new Error("THREE.GLTFLoader: setMeshoptDecoder must be called before loading compressed files");
+        return null;
+      }
+      return i.then(function(c) {
+        const a = s.byteOffset || 0, l = s.byteLength || 0, u = s.count, h = s.byteStride, p = new Uint8Array(c, a, l);
+        return o.decodeGltfBufferAsync ? o.decodeGltfBufferAsync(u, h, p, s.mode, s.filter).then(function(m) {
+          return m.buffer;
+        }) : o.ready.then(function() {
+          const m = new ArrayBuffer(u * h);
+          return o.decodeGltfBuffer(new Uint8Array(m), u, h, p, s.mode, s.filter), m;
+        });
+      });
+    } else
+      return null;
+  }
+}
+class Gs {
+  constructor(e) {
+    this.name = b.EXT_MESH_GPU_INSTANCING, this.parser = e;
+  }
+  createNodeMesh(e) {
+    const t = this.parser.json, n = t.nodes[e];
+    if (!n.extensions || !n.extensions[this.name] || n.mesh === void 0)
+      return null;
+    const s = t.meshes[n.mesh];
+    for (const l of s.primitives)
+      if (l.mode !== I.TRIANGLES && l.mode !== I.TRIANGLE_STRIP && l.mode !== I.TRIANGLE_FAN && l.mode !== void 0)
+        return null;
+    const o = n.extensions[this.name].attributes, c = [], a = {};
+    for (const l in o)
+      c.push(this.parser.getDependency("accessor", o[l]).then((u) => (a[l] = u, a[l])));
+    return c.length < 1 ? null : (c.push(this.parser.createNodeMesh(e)), Promise.all(c).then((l) => {
+      const u = l.pop(), h = u.isGroup ? u.children : [u], p = l[0].count, m = [];
+      for (const _ of h) {
+        const w = new se(), d = new S(), f = new le(), g = new S(1, 1, 1), T = new Et(_.geometry, _.material, p);
+        for (let y = 0; y < p; y++)
+          a.TRANSLATION && d.fromBufferAttribute(a.TRANSLATION, y), a.ROTATION && f.fromBufferAttribute(a.ROTATION, y), a.SCALE && g.fromBufferAttribute(a.SCALE, y), T.setMatrixAt(y, w.compose(d, f, g));
+        for (const y in a)
+          if (y === "_COLOR_0") {
+            const E = a[y];
+            T.instanceColor = new xt(E.array, E.itemSize, E.normalized);
+          } else y !== "TRANSLATION" && y !== "ROTATION" && y !== "SCALE" && _.geometry.setAttribute(y, a[y]);
+        Ne.prototype.copy.call(T, _), this.parser.assignFinalMaterial(T), m.push(T);
+      }
+      return u.isGroup ? (u.clear(), u.add(...m), u) : m[0];
+    }));
+  }
+}
+const dt = "glTF", ne = 12, Xe = { JSON: 1313821514, BIN: 5130562 };
+class Bs {
+  constructor(e) {
+    this.name = b.KHR_BINARY_GLTF, this.content = null, this.body = null;
+    const t = new DataView(e, 0, ne), n = new TextDecoder();
+    if (this.header = {
+      magic: n.decode(new Uint8Array(e.slice(0, 4))),
+      version: t.getUint32(4, !0),
+      length: t.getUint32(8, !0)
+    }, this.header.magic !== dt)
+      throw new Error("THREE.GLTFLoader: Unsupported glTF-Binary header.");
+    if (this.header.version < 2)
+      throw new Error("THREE.GLTFLoader: Legacy binary file detected.");
+    const s = this.header.length - ne, i = new DataView(e, ne);
+    let o = 0;
+    for (; o < s; ) {
+      const c = i.getUint32(o, !0);
+      o += 4;
+      const a = i.getUint32(o, !0);
+      if (o += 4, a === Xe.JSON) {
+        const l = new Uint8Array(e, ne + o, c);
+        this.content = n.decode(l);
+      } else if (a === Xe.BIN) {
+        const l = ne + o;
+        this.body = e.slice(l, l + c);
+      }
+      o += c;
+    }
+    if (this.content === null)
+      throw new Error("THREE.GLTFLoader: JSON content not found.");
+  }
+}
+class zs {
+  constructor(e, t) {
+    if (!t)
+      throw new Error("THREE.GLTFLoader: No DRACOLoader instance provided.");
+    this.name = b.KHR_DRACO_MESH_COMPRESSION, this.json = e, this.dracoLoader = t, this.dracoLoader.preload();
+  }
+  decodePrimitive(e, t) {
+    const n = this.json, s = this.dracoLoader, i = e.extensions[this.name].bufferView, o = e.extensions[this.name].attributes, c = {}, a = {}, l = {};
+    for (const u in o) {
+      const h = ke[u] || u.toLowerCase();
+      c[h] = o[u];
+    }
+    for (const u in e.attributes) {
+      const h = ke[u] || u.toLowerCase();
+      if (o[u] !== void 0) {
+        const p = n.accessors[e.attributes[u]], m = te[p.componentType];
+        l[h] = m.name, a[h] = p.normalized === !0;
+      }
+    }
+    return t.getDependency("bufferView", i).then(function(u) {
+      return new Promise(function(h, p) {
+        s.decodeDracoFile(u, function(m) {
+          for (const _ in m.attributes) {
+            const w = m.attributes[_], d = a[_];
+            d !== void 0 && (w.normalized = d);
+          }
+          h(m);
+        }, c, l, U, p);
+      });
+    });
+  }
+}
+class Ks {
+  constructor() {
+    this.name = b.KHR_TEXTURE_TRANSFORM;
+  }
+  extendTexture(e, t) {
+    return (t.texCoord === void 0 || t.texCoord === e.channel) && t.offset === void 0 && t.rotation === void 0 && t.scale === void 0 || (e = e.clone(), t.texCoord !== void 0 && (e.channel = t.texCoord), t.offset !== void 0 && e.offset.fromArray(t.offset), t.rotation !== void 0 && (e.rotation = t.rotation), t.scale !== void 0 && e.repeat.fromArray(t.scale), e.needsUpdate = !0), e;
+  }
+}
+class Ws {
+  constructor() {
+    this.name = b.KHR_MESH_QUANTIZATION;
+  }
+}
+class ft extends $t {
+  constructor(e, t, n, s) {
+    super(e, t, n, s);
+  }
+  copySampleValue_(e) {
+    const t = this.resultBuffer, n = this.sampleValues, s = this.valueSize, i = e * s * 3 + s;
+    for (let o = 0; o !== s; o++)
+      t[o] = n[i + o];
+    return t;
+  }
+  interpolate_(e, t, n, s) {
+    const i = this.resultBuffer, o = this.sampleValues, c = this.valueSize, a = c * 2, l = c * 3, u = s - t, h = (n - t) / u, p = h * h, m = p * h, _ = e * l, w = _ - l, d = -2 * m + 3 * p, f = m - p, g = 1 - d, T = f - p + h;
+    for (let y = 0; y !== c; y++) {
+      const E = o[w + y + c], x = o[w + y + a] * u, M = o[_ + y + c], D = o[_ + y] * u;
+      i[y] = g * E + T * x + d * M + f * D;
+    }
+    return i;
+  }
+}
+const Xs = new le();
+class Vs extends ft {
+  interpolate_(e, t, n, s) {
+    const i = super.interpolate_(e, t, n, s);
+    return Xs.fromArray(i).normalize().toArray(i), i;
+  }
+}
+const I = {
+  POINTS: 0,
+  LINES: 1,
+  LINE_LOOP: 2,
+  LINE_STRIP: 3,
+  TRIANGLES: 4,
+  TRIANGLE_STRIP: 5,
+  TRIANGLE_FAN: 6
+}, te = {
+  5120: Int8Array,
+  5121: Uint8Array,
+  5122: Int16Array,
+  5123: Uint16Array,
+  5125: Uint32Array,
+  5126: Float32Array
+}, Ve = {
+  9728: at,
+  9729: Ce,
+  9984: Dt,
+  9985: Pt,
+  9986: Lt,
+  9987: rt
+}, Ye = {
+  33071: Ot,
+  33648: Ct,
+  10497: Oe
+}, xe = {
+  SCALAR: 1,
+  VEC2: 2,
+  VEC3: 3,
+  VEC4: 4,
+  MAT2: 4,
+  MAT3: 9,
+  MAT4: 16
+}, ke = {
+  POSITION: "position",
+  NORMAL: "normal",
+  TANGENT: "tangent",
+  TEXCOORD_0: "uv",
+  TEXCOORD_1: "uv1",
+  TEXCOORD_2: "uv2",
+  TEXCOORD_3: "uv3",
+  COLOR_0: "color",
+  WEIGHTS_0: "skinWeight",
+  JOINTS_0: "skinIndex"
+}, K = {
+  scale: "scale",
+  translation: "position",
+  rotation: "quaternion",
+  weights: "morphTargetInfluences"
+}, Ys = {
+  CUBICSPLINE: void 0,
+  // We use a custom interpolant (GLTFCubicSplineInterpolation) for CUBICSPLINE tracks. Each
+  // keyframe track will be initialized with a default interpolation type, then modified.
+  LINEAR: lt,
+  STEP: Yt
+}, Ae = {
+  OPAQUE: "OPAQUE",
+  MASK: "MASK",
+  BLEND: "BLEND"
+};
+function qs(r) {
+  return r.DefaultMaterial === void 0 && (r.DefaultMaterial = new ct({
+    color: 16777215,
+    emissive: 0,
+    metalness: 1,
+    roughness: 1,
+    transparent: !1,
+    depthTest: !0,
+    side: qt
+  })), r.DefaultMaterial;
+}
+function Z(r, e, t) {
+  for (const n in t.extensions)
+    r[n] === void 0 && (e.userData.gltfExtensions = e.userData.gltfExtensions || {}, e.userData.gltfExtensions[n] = t.extensions[n]);
+}
+function G(r, e) {
+  e.extras !== void 0 && (typeof e.extras == "object" ? Object.assign(r.userData, e.extras) : console.warn("THREE.GLTFLoader: Ignoring primitive type .extras, " + e.extras));
+}
+function $s(r, e, t) {
+  let n = !1, s = !1, i = !1;
+  for (let l = 0, u = e.length; l < u; l++) {
+    const h = e[l];
+    if (h.POSITION !== void 0 && (n = !0), h.NORMAL !== void 0 && (s = !0), h.COLOR_0 !== void 0 && (i = !0), n && s && i) break;
+  }
+  if (!n && !s && !i) return Promise.resolve(r);
+  const o = [], c = [], a = [];
+  for (let l = 0, u = e.length; l < u; l++) {
+    const h = e[l];
+    if (n) {
+      const p = h.POSITION !== void 0 ? t.getDependency("accessor", h.POSITION) : r.attributes.position;
+      o.push(p);
+    }
+    if (s) {
+      const p = h.NORMAL !== void 0 ? t.getDependency("accessor", h.NORMAL) : r.attributes.normal;
+      c.push(p);
+    }
+    if (i) {
+      const p = h.COLOR_0 !== void 0 ? t.getDependency("accessor", h.COLOR_0) : r.attributes.color;
+      a.push(p);
+    }
+  }
+  return Promise.all([
+    Promise.all(o),
+    Promise.all(c),
+    Promise.all(a)
+  ]).then(function(l) {
+    const u = l[0], h = l[1], p = l[2];
+    return n && (r.morphAttributes.position = u), s && (r.morphAttributes.normal = h), i && (r.morphAttributes.color = p), r.morphTargetsRelative = !0, r;
+  });
+}
+function Zs(r, e) {
+  if (r.updateMorphTargets(), e.weights !== void 0)
+    for (let t = 0, n = e.weights.length; t < n; t++)
+      r.morphTargetInfluences[t] = e.weights[t];
+  if (e.extras && Array.isArray(e.extras.targetNames)) {
+    const t = e.extras.targetNames;
+    if (r.morphTargetInfluences.length === t.length) {
+      r.morphTargetDictionary = {};
+      for (let n = 0, s = t.length; n < s; n++)
+        r.morphTargetDictionary[t[n]] = n;
+    } else
+      console.warn("THREE.GLTFLoader: Invalid extras.targetNames length. Ignoring names.");
+  }
+}
+function Qs(r) {
+  let e;
+  const t = r.extensions && r.extensions[b.KHR_DRACO_MESH_COMPRESSION];
+  if (t ? e = "draco:" + t.bufferView + ":" + t.indices + ":" + Re(t.attributes) : e = r.indices + ":" + Re(r.attributes) + ":" + r.mode, r.targets !== void 0)
+    for (let n = 0, s = r.targets.length; n < s; n++)
+      e += ":" + Re(r.targets[n]);
+  return e;
+}
+function Re(r) {
+  let e = "";
+  const t = Object.keys(r).sort();
+  for (let n = 0, s = t.length; n < s; n++)
+    e += t[n] + ":" + r[t[n]] + ";";
+  return e;
+}
+function Ie(r) {
+  switch (r) {
+    case Int8Array:
+      return 1 / 127;
+    case Uint8Array:
+      return 1 / 255;
+    case Int16Array:
+      return 1 / 32767;
+    case Uint16Array:
+      return 1 / 65535;
+    default:
+      throw new Error("THREE.GLTFLoader: Unsupported normalized accessor component type.");
+  }
+}
+function Js(r) {
+  return r.search(/\.jpe?g($|\?)/i) > 0 || r.search(/^data\:image\/jpeg/) === 0 ? "image/jpeg" : r.search(/\.webp($|\?)/i) > 0 || r.search(/^data\:image\/webp/) === 0 ? "image/webp" : r.search(/\.ktx2($|\?)/i) > 0 || r.search(/^data\:image\/ktx2/) === 0 ? "image/ktx2" : "image/png";
+}
+const en = new se();
+class tn {
+  constructor(e = {}, t = {}) {
+    this.json = e, this.extensions = {}, this.plugins = {}, this.options = t, this.cache = new xs(), this.associations = /* @__PURE__ */ new Map(), this.primitiveCache = {}, this.nodeCache = {}, this.meshCache = { refs: {}, uses: {} }, this.cameraCache = { refs: {}, uses: {} }, this.lightCache = { refs: {}, uses: {} }, this.sourceCache = {}, this.textureCache = {}, this.nodeNamesUsed = {};
+    let n = !1, s = -1, i = !1, o = -1;
+    if (typeof navigator < "u") {
+      const c = navigator.userAgent;
+      n = /^((?!chrome|android).)*safari/i.test(c) === !0;
+      const a = c.match(/Version\/(\d+)/);
+      s = n && a ? parseInt(a[1], 10) : -1, i = c.indexOf("Firefox") > -1, o = i ? c.match(/Firefox\/([0-9]+)\./)[1] : -1;
+    }
+    typeof createImageBitmap > "u" || n && s < 17 || i && o < 98 ? this.textureLoader = new At(this.options.manager) : this.textureLoader = new Rt(this.options.manager), this.textureLoader.setCrossOrigin(this.options.crossOrigin), this.textureLoader.setRequestHeader(this.options.requestHeader), this.fileLoader = new de(this.options.manager), this.fileLoader.setResponseType("arraybuffer"), this.options.crossOrigin === "use-credentials" && this.fileLoader.setWithCredentials(!0);
+  }
+  setExtensions(e) {
+    this.extensions = e;
+  }
+  setPlugins(e) {
+    this.plugins = e;
+  }
+  parse(e, t) {
+    const n = this, s = this.json, i = this.extensions;
+    this.cache.removeAll(), this.nodeCache = {}, this._invokeAll(function(o) {
+      return o._markDefs && o._markDefs();
+    }), Promise.all(this._invokeAll(function(o) {
+      return o.beforeRoot && o.beforeRoot();
+    })).then(function() {
+      return Promise.all([
+        n.getDependencies("scene"),
+        n.getDependencies("animation"),
+        n.getDependencies("camera")
+      ]);
+    }).then(function(o) {
+      const c = {
+        scene: o[0][s.scene || 0],
+        scenes: o[0],
+        animations: o[1],
+        cameras: o[2],
+        asset: s.asset,
+        parser: n,
+        userData: {}
+      };
+      return Z(i, c, s), G(c, s), Promise.all(n._invokeAll(function(a) {
+        return a.afterRoot && a.afterRoot(c);
+      })).then(function() {
+        for (const a of c.scenes)
+          a.updateMatrixWorld();
+        e(c);
+      });
+    }).catch(t);
+  }
+  /**
+   * Marks the special nodes/meshes in json for efficient parse.
+   *
+   * @private
+   */
+  _markDefs() {
+    const e = this.json.nodes || [], t = this.json.skins || [], n = this.json.meshes || [];
+    for (let s = 0, i = t.length; s < i; s++) {
+      const o = t[s].joints;
+      for (let c = 0, a = o.length; c < a; c++)
+        e[o[c]].isBone = !0;
+    }
+    for (let s = 0, i = e.length; s < i; s++) {
+      const o = e[s];
+      o.mesh !== void 0 && (this._addNodeRef(this.meshCache, o.mesh), o.skin !== void 0 && (n[o.mesh].isSkinnedMesh = !0)), o.camera !== void 0 && this._addNodeRef(this.cameraCache, o.camera);
+    }
+  }
+  /**
+   * Counts references to shared node / Object3D resources. These resources
+   * can be reused, or "instantiated", at multiple nodes in the scene
+   * hierarchy. Mesh, Camera, and Light instances are instantiated and must
+   * be marked. Non-scenegraph resources (like Materials, Geometries, and
+   * Textures) can be reused directly and are not marked here.
+   *
+   * Example: CesiumMilkTruck sample model reuses "Wheel" meshes.
+   *
+   * @private
+   * @param {Object} cache
+   * @param {Object3D} index
+   */
+  _addNodeRef(e, t) {
+    t !== void 0 && (e.refs[t] === void 0 && (e.refs[t] = e.uses[t] = 0), e.refs[t]++);
+  }
+  /**
+   * Returns a reference to a shared resource, cloning it if necessary.
+   *
+   * @private
+   * @param {Object} cache
+   * @param {number} index
+   * @param {Object} object
+   * @return {Object}
+   */
+  _getNodeRef(e, t, n) {
+    if (e.refs[t] <= 1) return n;
+    const s = n.clone(), i = (o, c) => {
+      const a = this.associations.get(o);
+      a != null && this.associations.set(c, a);
+      for (const [l, u] of o.children.entries())
+        i(u, c.children[l]);
+    };
+    return i(n, s), s.name += "_instance_" + e.uses[t]++, s;
+  }
+  _invokeOne(e) {
+    const t = Object.values(this.plugins);
+    t.push(this);
+    for (let n = 0; n < t.length; n++) {
+      const s = e(t[n]);
+      if (s) return s;
+    }
+    return null;
+  }
+  _invokeAll(e) {
+    const t = Object.values(this.plugins);
+    t.unshift(this);
+    const n = [];
+    for (let s = 0; s < t.length; s++) {
+      const i = e(t[s]);
+      i && n.push(i);
+    }
+    return n;
+  }
+  /**
+   * Requests the specified dependency asynchronously, with caching.
+   *
+   * @private
+   * @param {string} type
+   * @param {number} index
+   * @return {Promise<Object3D|Material|THREE.Texture|AnimationClip|ArrayBuffer|Object>}
+   */
+  getDependency(e, t) {
+    const n = e + ":" + t;
+    let s = this.cache.get(n);
+    if (!s) {
+      switch (e) {
+        case "scene":
+          s = this.loadScene(t);
+          break;
+        case "node":
+          s = this._invokeOne(function(i) {
+            return i.loadNode && i.loadNode(t);
+          });
+          break;
+        case "mesh":
+          s = this._invokeOne(function(i) {
+            return i.loadMesh && i.loadMesh(t);
+          });
+          break;
+        case "accessor":
+          s = this.loadAccessor(t);
+          break;
+        case "bufferView":
+          s = this._invokeOne(function(i) {
+            return i.loadBufferView && i.loadBufferView(t);
+          });
+          break;
+        case "buffer":
+          s = this.loadBuffer(t);
+          break;
+        case "material":
+          s = this._invokeOne(function(i) {
+            return i.loadMaterial && i.loadMaterial(t);
+          });
+          break;
+        case "texture":
+          s = this._invokeOne(function(i) {
+            return i.loadTexture && i.loadTexture(t);
+          });
+          break;
+        case "skin":
+          s = this.loadSkin(t);
+          break;
+        case "animation":
+          s = this._invokeOne(function(i) {
+            return i.loadAnimation && i.loadAnimation(t);
+          });
+          break;
+        case "camera":
+          s = this.loadCamera(t);
+          break;
+        default:
+          if (s = this._invokeOne(function(i) {
+            return i != this && i.getDependency && i.getDependency(e, t);
+          }), !s)
+            throw new Error("Unknown type: " + e);
+          break;
+      }
+      this.cache.add(n, s);
+    }
+    return s;
+  }
+  /**
+   * Requests all dependencies of the specified type asynchronously, with caching.
+   *
+   * @private
+   * @param {string} type
+   * @return {Promise<Array<Object>>}
+   */
+  getDependencies(e) {
+    let t = this.cache.get(e);
+    if (!t) {
+      const n = this, s = this.json[e + (e === "mesh" ? "es" : "s")] || [];
+      t = Promise.all(s.map(function(i, o) {
+        return n.getDependency(e, o);
+      })), this.cache.add(e, t);
+    }
+    return t;
+  }
+  /**
+   * Specification: https://github.com/KhronosGroup/glTF/blob/master/specification/2.0/README.md#buffers-and-buffer-views
+   *
+   * @private
+   * @param {number} bufferIndex
+   * @return {Promise<ArrayBuffer>}
+   */
+  loadBuffer(e) {
+    const t = this.json.buffers[e], n = this.fileLoader;
+    if (t.type && t.type !== "arraybuffer")
+      throw new Error("THREE.GLTFLoader: " + t.type + " buffer type is not supported.");
+    if (t.uri === void 0 && e === 0)
+      return Promise.resolve(this.extensions[b.KHR_BINARY_GLTF].body);
+    const s = this.options;
+    return new Promise(function(i, o) {
+      n.load(re.resolveURL(t.uri, s.path), i, void 0, function() {
+        o(new Error('THREE.GLTFLoader: Failed to load buffer "' + t.uri + '".'));
+      });
+    });
+  }
+  /**
+   * Specification: https://github.com/KhronosGroup/glTF/blob/master/specification/2.0/README.md#buffers-and-buffer-views
+   *
+   * @private
+   * @param {number} bufferViewIndex
+   * @return {Promise<ArrayBuffer>}
+   */
+  loadBufferView(e) {
+    const t = this.json.bufferViews[e];
+    return this.getDependency("buffer", t.buffer).then(function(n) {
+      const s = t.byteLength || 0, i = t.byteOffset || 0;
+      return n.slice(i, i + s);
+    });
+  }
+  /**
+   * Specification: https://github.com/KhronosGroup/glTF/blob/master/specification/2.0/README.md#accessors
+   *
+   * @private
+   * @param {number} accessorIndex
+   * @return {Promise<BufferAttribute|InterleavedBufferAttribute>}
+   */
+  loadAccessor(e) {
+    const t = this, n = this.json, s = this.json.accessors[e];
+    if (s.bufferView === void 0 && s.sparse === void 0) {
+      const o = xe[s.type], c = te[s.componentType], a = s.normalized === !0, l = new c(s.count * o);
+      return Promise.resolve(new oe(l, o, a));
+    }
+    const i = [];
+    return s.bufferView !== void 0 ? i.push(this.getDependency("bufferView", s.bufferView)) : i.push(null), s.sparse !== void 0 && (i.push(this.getDependency("bufferView", s.sparse.indices.bufferView)), i.push(this.getDependency("bufferView", s.sparse.values.bufferView))), Promise.all(i).then(function(o) {
+      const c = o[0], a = xe[s.type], l = te[s.componentType], u = l.BYTES_PER_ELEMENT, h = u * a, p = s.byteOffset || 0, m = s.bufferView !== void 0 ? n.bufferViews[s.bufferView].byteStride : void 0, _ = s.normalized === !0;
+      let w, d;
+      if (m && m !== h) {
+        const f = Math.floor(p / m), g = "InterleavedBuffer:" + s.bufferView + ":" + s.componentType + ":" + f + ":" + s.count;
+        let T = t.cache.get(g);
+        T || (w = new l(c, f * m, s.count * m / u), T = new Mt(w, m / u), t.cache.add(g, T)), d = new St(T, a, p % m / u, _);
+      } else
+        c === null ? w = new l(s.count * a) : w = new l(c, p, s.count * a), d = new oe(w, a, _);
+      if (s.sparse !== void 0) {
+        const f = xe.SCALAR, g = te[s.sparse.indices.componentType], T = s.sparse.indices.byteOffset || 0, y = s.sparse.values.byteOffset || 0, E = new g(o[1], T, s.sparse.count * f), x = new l(o[2], y, s.sparse.count * a);
+        c !== null && (d = new oe(d.array.slice(), d.itemSize, d.normalized)), d.normalized = !1;
+        for (let M = 0, D = E.length; M < D; M++) {
+          const C = E[M];
+          if (d.setX(C, x[M * a]), a >= 2 && d.setY(C, x[M * a + 1]), a >= 3 && d.setZ(C, x[M * a + 2]), a >= 4 && d.setW(C, x[M * a + 3]), a >= 5) throw new Error("THREE.GLTFLoader: Unsupported itemSize in sparse BufferAttribute.");
+        }
+        d.normalized = _;
+      }
+      return d;
+    });
+  }
+  /**
+   * Specification: https://github.com/KhronosGroup/glTF/tree/master/specification/2.0#textures
+   *
+   * @private
+   * @param {number} textureIndex
+   * @return {Promise<THREE.Texture|null>}
+   */
+  loadTexture(e) {
+    const t = this.json, n = this.options, i = t.textures[e].source, o = t.images[i];
+    let c = this.textureLoader;
+    if (o.uri) {
+      const a = n.manager.getHandler(o.uri);
+      a !== null && (c = a);
+    }
+    return this.loadTextureImage(e, i, c);
+  }
+  loadTextureImage(e, t, n) {
+    const s = this, i = this.json, o = i.textures[e], c = i.images[t], a = (c.uri || c.bufferView) + ":" + o.sampler;
+    if (this.textureCache[a])
+      return this.textureCache[a];
+    const l = this.loadImageSource(t, n).then(function(u) {
+      u.flipY = !1, u.name = o.name || c.name || "", u.name === "" && typeof c.uri == "string" && c.uri.startsWith("data:image/") === !1 && (u.name = c.uri);
+      const p = (i.samplers || {})[o.sampler] || {};
+      return u.magFilter = Ve[p.magFilter] || Ce, u.minFilter = Ve[p.minFilter] || rt, u.wrapS = Ye[p.wrapS] || Oe, u.wrapT = Ye[p.wrapT] || Oe, u.generateMipmaps = !u.isCompressedTexture && u.minFilter !== at && u.minFilter !== Ce, s.associations.set(u, { textures: e }), u;
+    }).catch(function() {
+      return null;
+    });
+    return this.textureCache[a] = l, l;
+  }
+  loadImageSource(e, t) {
+    const n = this, s = this.json, i = this.options;
+    if (this.sourceCache[e] !== void 0)
+      return this.sourceCache[e].then((h) => h.clone());
+    const o = s.images[e], c = self.URL || self.webkitURL;
+    let a = o.uri || "", l = !1;
+    if (o.bufferView !== void 0)
+      a = n.getDependency("bufferView", o.bufferView).then(function(h) {
+        l = !0;
+        const p = new Blob([h], { type: o.mimeType });
+        return a = c.createObjectURL(p), a;
+      });
+    else if (o.uri === void 0)
+      throw new Error("THREE.GLTFLoader: Image " + e + " is missing URI and bufferView");
+    const u = Promise.resolve(a).then(function(h) {
+      return new Promise(function(p, m) {
+        let _ = p;
+        t.isImageBitmapLoader === !0 && (_ = function(w) {
+          const d = new Ue(w);
+          d.needsUpdate = !0, p(d);
+        }), t.load(re.resolveURL(h, i.path), _, void 0, m);
+      });
+    }).then(function(h) {
+      return l === !0 && c.revokeObjectURL(a), G(h, o), h.userData.mimeType = o.mimeType || Js(o.uri), h;
+    }).catch(function(h) {
+      throw console.error("THREE.GLTFLoader: Couldn't load texture", a), h;
+    });
+    return this.sourceCache[e] = u, u;
+  }
+  /**
+   * Asynchronously assigns a texture to the given material parameters.
+   *
+   * @private
+   * @param {Object} materialParams
+   * @param {string} mapName
+   * @param {Object} mapDef
+   * @param {string} [colorSpace]
+   * @return {Promise<Texture>}
+   */
+  assignTexture(e, t, n, s) {
+    const i = this;
+    return this.getDependency("texture", n.index).then(function(o) {
+      if (!o) return null;
+      if (n.texCoord !== void 0 && n.texCoord > 0 && (o = o.clone(), o.channel = n.texCoord), i.extensions[b.KHR_TEXTURE_TRANSFORM]) {
+        const c = n.extensions !== void 0 ? n.extensions[b.KHR_TEXTURE_TRANSFORM] : void 0;
+        if (c) {
+          const a = i.associations.get(o);
+          o = i.extensions[b.KHR_TEXTURE_TRANSFORM].extendTexture(o, c), i.associations.set(o, a);
+        }
+      }
+      return s !== void 0 && (o.colorSpace = s), e[t] = o, o;
+    });
+  }
+  /**
+   * Assigns final material to a Mesh, Line, or Points instance. The instance
+   * already has a material (generated from the glTF material options alone)
+   * but reuse of the same glTF material may require multiple threejs materials
+   * to accommodate different primitive types, defines, etc. New materials will
+   * be created if necessary, and reused from a cache.
+   *
+   * @private
+   * @param {Object3D} mesh Mesh, Line, or Points instance.
+   */
+  assignFinalMaterial(e) {
+    const t = e.geometry;
+    let n = e.material;
+    const s = t.attributes.tangent === void 0, i = t.attributes.color !== void 0, o = t.attributes.normal === void 0;
+    if (e.isPoints) {
+      const c = "PointsMaterial:" + n.uuid;
+      let a = this.cache.get(c);
+      a || (a = new kt(), Te.prototype.copy.call(a, n), a.color.copy(n.color), a.map = n.map, a.sizeAttenuation = !1, this.cache.add(c, a)), n = a;
+    } else if (e.isLine) {
+      const c = "LineBasicMaterial:" + n.uuid;
+      let a = this.cache.get(c);
+      a || (a = new It(), Te.prototype.copy.call(a, n), a.color.copy(n.color), a.map = n.map, this.cache.add(c, a)), n = a;
+    }
+    if (s || i || o) {
+      let c = "ClonedMaterial:" + n.uuid + ":";
+      s && (c += "derivative-tangents:"), i && (c += "vertex-colors:"), o && (c += "flat-shading:");
+      let a = this.cache.get(c);
+      a || (a = n.clone(), i && (a.vertexColors = !0), o && (a.flatShading = !0), s && (a.normalScale && (a.normalScale.y *= -1), a.clearcoatNormalScale && (a.clearcoatNormalScale.y *= -1)), this.cache.add(c, a), this.associations.set(a, this.associations.get(n))), n = a;
+    }
+    e.material = n;
+  }
+  getMaterialType() {
+    return ct;
+  }
+  /**
+   * Specification: https://github.com/KhronosGroup/glTF/blob/master/specification/2.0/README.md#materials
+   *
+   * @private
+   * @param {number} materialIndex
+   * @return {Promise<Material>}
+   */
+  loadMaterial(e) {
+    const t = this, n = this.json, s = this.extensions, i = n.materials[e];
+    let o;
+    const c = {}, a = i.extensions || {}, l = [];
+    if (a[b.KHR_MATERIALS_UNLIT]) {
+      const h = s[b.KHR_MATERIALS_UNLIT];
+      o = h.getMaterialType(), l.push(h.extendParams(c, i, t));
+    } else {
+      const h = i.pbrMetallicRoughness || {};
+      if (c.color = new q(1, 1, 1), c.opacity = 1, Array.isArray(h.baseColorFactor)) {
+        const p = h.baseColorFactor;
+        c.color.setRGB(p[0], p[1], p[2], U), c.opacity = p[3];
+      }
+      h.baseColorTexture !== void 0 && l.push(t.assignTexture(c, "map", h.baseColorTexture, Y)), c.metalness = h.metallicFactor !== void 0 ? h.metallicFactor : 1, c.roughness = h.roughnessFactor !== void 0 ? h.roughnessFactor : 1, h.metallicRoughnessTexture !== void 0 && (l.push(t.assignTexture(c, "metalnessMap", h.metallicRoughnessTexture)), l.push(t.assignTexture(c, "roughnessMap", h.metallicRoughnessTexture))), o = this._invokeOne(function(p) {
+        return p.getMaterialType && p.getMaterialType(e);
+      }), l.push(Promise.all(this._invokeAll(function(p) {
+        return p.extendMaterialParams && p.extendMaterialParams(e, c);
+      })));
+    }
+    i.doubleSided === !0 && (c.side = Nt);
+    const u = i.alphaMode || Ae.OPAQUE;
+    if (u === Ae.BLEND ? (c.transparent = !0, c.depthWrite = !1) : (c.transparent = !1, u === Ae.MASK && (c.alphaTest = i.alphaCutoff !== void 0 ? i.alphaCutoff : 0.5)), i.normalTexture !== void 0 && o !== ie && (l.push(t.assignTexture(c, "normalMap", i.normalTexture)), c.normalScale = new k(1, 1), i.normalTexture.scale !== void 0)) {
+      const h = i.normalTexture.scale;
+      c.normalScale.set(h, h);
+    }
+    if (i.occlusionTexture !== void 0 && o !== ie && (l.push(t.assignTexture(c, "aoMap", i.occlusionTexture)), i.occlusionTexture.strength !== void 0 && (c.aoMapIntensity = i.occlusionTexture.strength)), i.emissiveFactor !== void 0 && o !== ie) {
+      const h = i.emissiveFactor;
+      c.emissive = new q().setRGB(h[0], h[1], h[2], U);
+    }
+    return i.emissiveTexture !== void 0 && o !== ie && l.push(t.assignTexture(c, "emissiveMap", i.emissiveTexture, Y)), Promise.all(l).then(function() {
+      const h = new o(c);
+      return i.name && (h.name = i.name), G(h, i), t.associations.set(h, { materials: e }), i.extensions && Z(s, h, i), h;
+    });
+  }
+  /**
+   * When Object3D instances are targeted by animation, they need unique names.
+   *
+   * @private
+   * @param {string} originalName
+   * @return {string}
+   */
+  createUniqueName(e) {
+    const t = vt.sanitizeNodeName(e || "");
+    return t in this.nodeNamesUsed ? t + "_" + ++this.nodeNamesUsed[t] : (this.nodeNamesUsed[t] = 0, t);
+  }
+  /**
+   * Specification: https://github.com/KhronosGroup/glTF/blob/master/specification/2.0/README.md#geometry
+   *
+   * Creates BufferGeometries from primitives.
+   *
+   * @private
+   * @param {Array<GLTF.Primitive>} primitives
+   * @return {Promise<Array<BufferGeometry>>}
+   */
+  loadGeometries(e) {
+    const t = this, n = this.extensions, s = this.primitiveCache;
+    function i(c) {
+      return n[b.KHR_DRACO_MESH_COMPRESSION].decodePrimitive(c, t).then(function(a) {
+        return qe(a, c, t);
+      });
+    }
+    const o = [];
+    for (let c = 0, a = e.length; c < a; c++) {
+      const l = e[c], u = Qs(l), h = s[u];
+      if (h)
+        o.push(h.promise);
+      else {
+        let p;
+        l.extensions && l.extensions[b.KHR_DRACO_MESH_COMPRESSION] ? p = i(l) : p = qe(new ot(), l, t), s[u] = { primitive: l, promise: p }, o.push(p);
+      }
+    }
+    return Promise.all(o);
+  }
+  /**
+   * Specification: https://github.com/KhronosGroup/glTF/blob/master/specification/2.0/README.md#meshes
+   *
+   * @private
+   * @param {number} meshIndex
+   * @return {Promise<Group|Mesh|SkinnedMesh|Line|Points>}
+   */
+  loadMesh(e) {
+    const t = this, n = this.json, s = this.extensions, i = n.meshes[e], o = i.primitives, c = [];
+    for (let a = 0, l = o.length; a < l; a++) {
+      const u = o[a].material === void 0 ? qs(this.cache) : this.getDependency("material", o[a].material);
+      c.push(u);
+    }
+    return c.push(t.loadGeometries(o)), Promise.all(c).then(function(a) {
+      const l = a.slice(0, a.length - 1), u = a[a.length - 1], h = [];
+      for (let m = 0, _ = u.length; m < _; m++) {
+        const w = u[m], d = o[m];
+        let f;
+        const g = l[m];
+        if (d.mode === I.TRIANGLES || d.mode === I.TRIANGLE_STRIP || d.mode === I.TRIANGLE_FAN || d.mode === void 0)
+          f = i.isSkinnedMesh === !0 ? new Ht(w, g) : new Ft(w, g), f.isSkinnedMesh === !0 && f.normalizeSkinWeights(), d.mode === I.TRIANGLE_STRIP ? f.geometry = We(f.geometry, nt) : d.mode === I.TRIANGLE_FAN && (f.geometry = We(f.geometry, Pe));
+        else if (d.mode === I.LINES)
+          f = new Ut(w, g);
+        else if (d.mode === I.LINE_STRIP)
+          f = new jt(w, g);
+        else if (d.mode === I.LINE_LOOP)
+          f = new Gt(w, g);
+        else if (d.mode === I.POINTS)
+          f = new Bt(w, g);
+        else
+          throw new Error("THREE.GLTFLoader: Primitive mode unsupported: " + d.mode);
+        Object.keys(f.geometry.morphAttributes).length > 0 && Zs(f, i), f.name = t.createUniqueName(i.name || "mesh_" + e), G(f, i), d.extensions && Z(s, f, d), t.assignFinalMaterial(f), h.push(f);
+      }
+      for (let m = 0, _ = h.length; m < _; m++)
+        t.associations.set(h[m], {
+          meshes: e,
+          primitives: m
+        });
+      if (h.length === 1)
+        return i.extensions && Z(s, h[0], i), h[0];
+      const p = new we();
+      i.extensions && Z(s, p, i), t.associations.set(p, { meshes: e });
+      for (let m = 0, _ = h.length; m < _; m++)
+        p.add(h[m]);
+      return p;
+    });
+  }
+  /**
+   * Specification: https://github.com/KhronosGroup/glTF/tree/master/specification/2.0#cameras
+   *
+   * @private
+   * @param {number} cameraIndex
+   * @return {Promise<THREE.Camera>}
+   */
+  loadCamera(e) {
+    let t;
+    const n = this.json.cameras[e], s = n[n.type];
+    if (!s) {
+      console.warn("THREE.GLTFLoader: Missing camera parameters.");
+      return;
+    }
+    return n.type === "perspective" ? t = new zt(st.radToDeg(s.yfov), s.aspectRatio || 1, s.znear || 1, s.zfar || 2e6) : n.type === "orthographic" && (t = new Kt(-s.xmag, s.xmag, s.ymag, -s.ymag, s.znear, s.zfar)), n.name && (t.name = this.createUniqueName(n.name)), G(t, n), Promise.resolve(t);
+  }
+  /**
+   * Specification: https://github.com/KhronosGroup/glTF/tree/master/specification/2.0#skins
+   *
+   * @private
+   * @param {number} skinIndex
+   * @return {Promise<Skeleton>}
+   */
+  loadSkin(e) {
+    const t = this.json.skins[e], n = [];
+    for (let s = 0, i = t.joints.length; s < i; s++)
+      n.push(this._loadNodeShallow(t.joints[s]));
+    return t.inverseBindMatrices !== void 0 ? n.push(this.getDependency("accessor", t.inverseBindMatrices)) : n.push(null), Promise.all(n).then(function(s) {
+      const i = s.pop(), o = s, c = [], a = [];
+      for (let l = 0, u = o.length; l < u; l++) {
+        const h = o[l];
+        if (h) {
+          c.push(h);
+          const p = new se();
+          i !== null && p.fromArray(i.array, l * 16), a.push(p);
+        } else
+          console.warn('THREE.GLTFLoader: Joint "%s" could not be found.', t.joints[l]);
+      }
+      return new Wt(c, a);
+    });
+  }
+  /**
+   * Specification: https://github.com/KhronosGroup/glTF/tree/master/specification/2.0#animations
+   *
+   * @private
+   * @param {number} animationIndex
+   * @return {Promise<AnimationClip>}
+   */
+  loadAnimation(e) {
+    const t = this.json, n = this, s = t.animations[e], i = s.name ? s.name : "animation_" + e, o = [], c = [], a = [], l = [], u = [];
+    for (let h = 0, p = s.channels.length; h < p; h++) {
+      const m = s.channels[h], _ = s.samplers[m.sampler], w = m.target, d = w.node, f = s.parameters !== void 0 ? s.parameters[_.input] : _.input, g = s.parameters !== void 0 ? s.parameters[_.output] : _.output;
+      w.node !== void 0 && (o.push(this.getDependency("node", d)), c.push(this.getDependency("accessor", f)), a.push(this.getDependency("accessor", g)), l.push(_), u.push(w));
+    }
+    return Promise.all([
+      Promise.all(o),
+      Promise.all(c),
+      Promise.all(a),
+      Promise.all(l),
+      Promise.all(u)
+    ]).then(function(h) {
+      const p = h[0], m = h[1], _ = h[2], w = h[3], d = h[4], f = [];
+      for (let g = 0, T = p.length; g < T; g++) {
+        const y = p[g], E = m[g], x = _[g], M = w[g], D = d[g];
+        if (y === void 0) continue;
+        y.updateMatrix && y.updateMatrix();
+        const C = n._createAnimationTracks(y, E, x, M, D);
+        if (C)
+          for (let z = 0; z < C.length; z++)
+            f.push(C[z]);
+      }
+      return new Xt(i, void 0, f);
+    });
+  }
+  createNodeMesh(e) {
+    const t = this.json, n = this, s = t.nodes[e];
+    return s.mesh === void 0 ? null : n.getDependency("mesh", s.mesh).then(function(i) {
+      const o = n._getNodeRef(n.meshCache, s.mesh, i);
+      return s.weights !== void 0 && o.traverse(function(c) {
+        if (c.isMesh)
+          for (let a = 0, l = s.weights.length; a < l; a++)
+            c.morphTargetInfluences[a] = s.weights[a];
+      }), o;
+    });
+  }
+  /**
+   * Specification: https://github.com/KhronosGroup/glTF/tree/master/specification/2.0#nodes-and-hierarchy
+   *
+   * @private
+   * @param {number} nodeIndex
+   * @return {Promise<Object3D>}
+   */
+  loadNode(e) {
+    const t = this.json, n = this, s = t.nodes[e], i = n._loadNodeShallow(e), o = [], c = s.children || [];
+    for (let l = 0, u = c.length; l < u; l++)
+      o.push(n.getDependency("node", c[l]));
+    const a = s.skin === void 0 ? Promise.resolve(null) : n.getDependency("skin", s.skin);
+    return Promise.all([
+      i,
+      Promise.all(o),
+      a
+    ]).then(function(l) {
+      const u = l[0], h = l[1], p = l[2];
+      p !== null && u.traverse(function(m) {
+        m.isSkinnedMesh && m.bind(p, en);
+      });
+      for (let m = 0, _ = h.length; m < _; m++)
+        u.add(h[m]);
+      return u;
+    });
+  }
+  // ._loadNodeShallow() parses a single node.
+  // skin and child nodes are created and added in .loadNode() (no '_' prefix).
+  _loadNodeShallow(e) {
+    const t = this.json, n = this.extensions, s = this;
+    if (this.nodeCache[e] !== void 0)
+      return this.nodeCache[e];
+    const i = t.nodes[e], o = i.name ? s.createUniqueName(i.name) : "", c = [], a = s._invokeOne(function(l) {
+      return l.createNodeMesh && l.createNodeMesh(e);
+    });
+    return a && c.push(a), i.camera !== void 0 && c.push(s.getDependency("camera", i.camera).then(function(l) {
+      return s._getNodeRef(s.cameraCache, i.camera, l);
+    })), s._invokeAll(function(l) {
+      return l.createNodeAttachment && l.createNodeAttachment(e);
+    }).forEach(function(l) {
+      c.push(l);
+    }), this.nodeCache[e] = Promise.all(c).then(function(l) {
+      let u;
+      if (i.isBone === !0 ? u = new Vt() : l.length > 1 ? u = new we() : l.length === 1 ? u = l[0] : u = new Ne(), u !== l[0])
+        for (let h = 0, p = l.length; h < p; h++)
+          u.add(l[h]);
+      if (i.name && (u.userData.name = i.name, u.name = o), G(u, i), i.extensions && Z(n, u, i), i.matrix !== void 0) {
+        const h = new se();
+        h.fromArray(i.matrix), u.applyMatrix4(h);
+      } else
+        i.translation !== void 0 && u.position.fromArray(i.translation), i.rotation !== void 0 && u.quaternion.fromArray(i.rotation), i.scale !== void 0 && u.scale.fromArray(i.scale);
+      if (!s.associations.has(u))
+        s.associations.set(u, {});
+      else if (i.mesh !== void 0 && s.meshCache.refs[i.mesh] > 1) {
+        const h = s.associations.get(u);
+        s.associations.set(u, { ...h });
+      }
+      return s.associations.get(u).nodes = e, u;
+    }), this.nodeCache[e];
+  }
+  /**
+   * Specification: https://github.com/KhronosGroup/glTF/tree/master/specification/2.0#scenes
+   *
+   * @private
+   * @param {number} sceneIndex
+   * @return {Promise<Group>}
+   */
+  loadScene(e) {
+    const t = this.extensions, n = this.json.scenes[e], s = this, i = new we();
+    n.name && (i.name = s.createUniqueName(n.name)), G(i, n), n.extensions && Z(t, i, n);
+    const o = n.nodes || [], c = [];
+    for (let a = 0, l = o.length; a < l; a++)
+      c.push(s.getDependency("node", o[a]));
+    return Promise.all(c).then(function(a) {
+      for (let u = 0, h = a.length; u < h; u++)
+        i.add(a[u]);
+      const l = (u) => {
+        const h = /* @__PURE__ */ new Map();
+        for (const [p, m] of s.associations)
+          (p instanceof Te || p instanceof Ue) && h.set(p, m);
+        return u.traverse((p) => {
+          const m = s.associations.get(p);
+          m != null && h.set(p, m);
+        }), h;
+      };
+      return s.associations = l(i), i;
+    });
+  }
+  _createAnimationTracks(e, t, n, s, i) {
+    const o = [], c = e.name ? e.name : e.uuid, a = [];
+    K[i.path] === K.weights ? e.traverse(function(p) {
+      p.morphTargetInfluences && a.push(p.name ? p.name : p.uuid);
+    }) : a.push(c);
+    let l;
+    switch (K[i.path]) {
+      case K.weights:
+        l = Ge;
+        break;
+      case K.rotation:
+        l = Be;
+        break;
+      case K.translation:
+      case K.scale:
+        l = je;
+        break;
+      default:
+        switch (n.itemSize) {
+          case 1:
+            l = Ge;
+            break;
+          case 2:
+          case 3:
+          default:
+            l = je;
+            break;
+        }
+        break;
+    }
+    const u = s.interpolation !== void 0 ? Ys[s.interpolation] : lt, h = this._getArrayFromAccessor(n);
+    for (let p = 0, m = a.length; p < m; p++) {
+      const _ = new l(
+        a[p] + "." + K[i.path],
+        t.array,
+        h,
+        u
+      );
+      s.interpolation === "CUBICSPLINE" && this._createCubicSplineTrackInterpolant(_), o.push(_);
+    }
+    return o;
+  }
+  _getArrayFromAccessor(e) {
+    let t = e.array;
+    if (e.normalized) {
+      const n = Ie(t.constructor), s = new Float32Array(t.length);
+      for (let i = 0, o = t.length; i < o; i++)
+        s[i] = t[i] * n;
+      t = s;
+    }
+    return t;
+  }
+  _createCubicSplineTrackInterpolant(e) {
+    e.createInterpolant = function(n) {
+      const s = this instanceof Be ? Vs : ft;
+      return new s(this.times, this.values, this.getValueSize() / 3, n);
+    }, e.createInterpolant.isInterpolantFactoryMethodGLTFCubicSpline = !0;
+  }
+}
+function sn(r, e, t) {
+  const n = e.attributes, s = new Zt();
+  if (n.POSITION !== void 0) {
+    const c = t.json.accessors[n.POSITION], a = c.min, l = c.max;
+    if (a !== void 0 && l !== void 0) {
+      if (s.set(
+        new S(a[0], a[1], a[2]),
+        new S(l[0], l[1], l[2])
+      ), c.normalized) {
+        const u = Ie(te[c.componentType]);
+        s.min.multiplyScalar(u), s.max.multiplyScalar(u);
+      }
+    } else {
+      console.warn("THREE.GLTFLoader: Missing min/max properties for accessor POSITION.");
+      return;
+    }
+  } else
+    return;
+  const i = e.targets;
+  if (i !== void 0) {
+    const c = new S(), a = new S();
+    for (let l = 0, u = i.length; l < u; l++) {
+      const h = i[l];
+      if (h.POSITION !== void 0) {
+        const p = t.json.accessors[h.POSITION], m = p.min, _ = p.max;
+        if (m !== void 0 && _ !== void 0) {
+          if (a.setX(Math.max(Math.abs(m[0]), Math.abs(_[0]))), a.setY(Math.max(Math.abs(m[1]), Math.abs(_[1]))), a.setZ(Math.max(Math.abs(m[2]), Math.abs(_[2]))), p.normalized) {
+            const w = Ie(te[p.componentType]);
+            a.multiplyScalar(w);
+          }
+          c.max(a);
+        } else
+          console.warn("THREE.GLTFLoader: Missing min/max properties for accessor POSITION.");
+      }
+    }
+    s.expandByVector(c);
+  }
+  r.boundingBox = s;
+  const o = new Qt();
+  s.getCenter(o.center), o.radius = s.min.distanceTo(s.max) / 2, r.boundingSphere = o;
+}
+function qe(r, e, t) {
+  const n = e.attributes, s = [];
+  function i(o, c) {
+    return t.getDependency("accessor", o).then(function(a) {
+      r.setAttribute(c, a);
+    });
+  }
+  for (const o in n) {
+    const c = ke[o] || o.toLowerCase();
+    c in r.attributes || s.push(i(n[o], c));
+  }
+  if (e.indices !== void 0 && !r.index) {
+    const o = t.getDependency("accessor", e.indices).then(function(c) {
+      r.setIndex(c);
+    });
+    s.push(o);
+  }
+  return De.workingColorSpace !== U && "COLOR_0" in n && console.warn(`THREE.GLTFLoader: Converting vertex colors from "srgb-linear" to "${De.workingColorSpace}" not supported.`), G(r, e), sn(r, e, t), Promise.all(s).then(function() {
+    return e.targets !== void 0 ? $s(r, e.targets, t) : r;
+  });
+}
+const $e = new S(), nn = new le(), Ze = new S();
+class on extends Ne {
+  /**
+   * Constructs a new CSS3D object.
+   *
+   * @param {DOMElement} [element] - The DOM element.
+   */
+  constructor(e = document.createElement("div")) {
+    super(), this.isCSS3DObject = !0, this.element = e, this.element.style.position = "absolute", this.element.style.pointerEvents = "auto", this.element.style.userSelect = "none", this.element.setAttribute("draggable", !1), this.addEventListener("removed", function() {
+      this.traverse(function(t) {
+        t.element instanceof t.element.ownerDocument.defaultView.Element && t.element.parentNode !== null && t.element.remove();
+      });
+    });
+  }
+  copy(e, t) {
+    return super.copy(e, t), this.element = e.element.cloneNode(!0), this;
+  }
+}
+class _n extends on {
+  /**
+   * Constructs a new CSS3D sprite object.
+   *
+   * @param {DOMElement} [element] - The DOM element.
+   */
+  constructor(e) {
+    super(e), this.isCSS3DSprite = !0, this.rotation2D = 0;
+  }
+  copy(e, t) {
+    return super.copy(e, t), this.rotation2D = e.rotation2D, this;
+  }
+}
+const F = new se(), rn = new se();
+class Tn {
+  /**
+   * Constructs a new CSS3D renderer.
+   *
+   * @param {CSS3DRenderer~Parameters} [parameters] - The parameters.
+   */
+  constructor(e = {}) {
+    const t = this;
+    let n, s, i, o;
+    const c = {
+      camera: { style: "" },
+      objects: /* @__PURE__ */ new WeakMap()
+    }, a = e.element !== void 0 ? e.element : document.createElement("div");
+    a.style.overflow = "hidden", this.domElement = a;
+    const l = document.createElement("div");
+    l.style.transformOrigin = "0 0", l.style.pointerEvents = "none", a.appendChild(l);
+    const u = document.createElement("div");
+    u.style.transformStyle = "preserve-3d", l.appendChild(u), this.getSize = function() {
+      return {
+        width: n,
+        height: s
+      };
+    }, this.render = function(d, f) {
+      const g = f.projectionMatrix.elements[5] * o;
+      f.view && f.view.enabled ? (l.style.transform = `translate( ${-f.view.offsetX * (n / f.view.width)}px, ${-f.view.offsetY * (s / f.view.height)}px )`, l.style.transform += `scale( ${f.view.fullWidth / f.view.width}, ${f.view.fullHeight / f.view.height} )`) : l.style.transform = "", d.matrixWorldAutoUpdate === !0 && d.updateMatrixWorld(), f.parent === null && f.matrixWorldAutoUpdate === !0 && f.updateMatrixWorld();
+      let T, y;
+      f.isOrthographicCamera && (T = -(f.right + f.left) / 2, y = (f.top + f.bottom) / 2);
+      const E = f.view && f.view.enabled ? f.view.height / f.view.fullHeight : 1, x = f.isOrthographicCamera ? `scale( ${E} )scale(` + g + ")translate(" + h(T) + "px," + h(y) + "px)" + p(f.matrixWorldInverse) : `scale( ${E} )translateZ(` + g + "px)" + p(f.matrixWorldInverse), D = (f.isPerspectiveCamera ? "perspective(" + g + "px) " : "") + x + "translate(" + i + "px," + o + "px)";
+      c.camera.style !== D && (u.style.transform = D, c.camera.style = D), w(d, d, f);
+    }, this.setSize = function(d, f) {
+      n = d, s = f, i = n / 2, o = s / 2, a.style.width = d + "px", a.style.height = f + "px", l.style.width = d + "px", l.style.height = f + "px", u.style.width = d + "px", u.style.height = f + "px";
+    };
+    function h(d) {
+      return Math.abs(d) < 1e-10 ? 0 : d;
+    }
+    function p(d) {
+      const f = d.elements;
+      return "matrix3d(" + h(f[0]) + "," + h(-f[1]) + "," + h(f[2]) + "," + h(f[3]) + "," + h(f[4]) + "," + h(-f[5]) + "," + h(f[6]) + "," + h(f[7]) + "," + h(f[8]) + "," + h(-f[9]) + "," + h(f[10]) + "," + h(f[11]) + "," + h(f[12]) + "," + h(-f[13]) + "," + h(f[14]) + "," + h(f[15]) + ")";
+    }
+    function m(d) {
+      const f = d.elements;
+      return "translate(-50%,-50%)" + ("matrix3d(" + h(f[0]) + "," + h(f[1]) + "," + h(f[2]) + "," + h(f[3]) + "," + h(-f[4]) + "," + h(-f[5]) + "," + h(-f[6]) + "," + h(-f[7]) + "," + h(f[8]) + "," + h(f[9]) + "," + h(f[10]) + "," + h(f[11]) + "," + h(f[12]) + "," + h(f[13]) + "," + h(f[14]) + "," + h(f[15]) + ")");
+    }
+    function _(d) {
+      d.isCSS3DObject && (d.element.style.display = "none");
+      for (let f = 0, g = d.children.length; f < g; f++)
+        _(d.children[f]);
+    }
+    function w(d, f, g, T) {
+      if (d.visible === !1) {
+        _(d);
+        return;
+      }
+      if (d.isCSS3DObject) {
+        const y = d.layers.test(g.layers) === !0, E = d.element;
+        if (E.style.display = y === !0 ? "" : "none", y === !0) {
+          d.onBeforeRender(t, f, g);
+          let x;
+          d.isCSS3DSprite ? (F.copy(g.matrixWorldInverse), F.transpose(), d.rotation2D !== 0 && F.multiply(rn.makeRotationZ(d.rotation2D)), d.matrixWorld.decompose($e, nn, Ze), F.setPosition($e), F.scale(Ze), F.elements[3] = 0, F.elements[7] = 0, F.elements[11] = 0, F.elements[15] = 1, x = m(F)) : x = m(d.matrixWorld);
+          const M = c.objects.get(d);
+          if (M === void 0 || M.style !== x) {
+            E.style.transform = x;
+            const D = { style: x };
+            c.objects.set(d, D);
+          }
+          E.parentNode !== u && u.appendChild(E), d.onAfterRender(t, f, g);
+        }
+      }
+      for (let y = 0, E = d.children.length; y < E; y++)
+        w(d.children[y], f, g);
+    }
+  }
+}
+var ae = function() {
+  var r = 0, e = document.createElement("div");
+  e.style.cssText = "position:fixed;top:0;left:0;cursor:pointer;opacity:0.9;z-index:10000", e.addEventListener("click", function(u) {
+    u.preventDefault(), n(++r % e.children.length);
+  }, !1);
+  function t(u) {
+    return e.appendChild(u.dom), u;
+  }
+  function n(u) {
+    for (var h = 0; h < e.children.length; h++)
+      e.children[h].style.display = h === u ? "block" : "none";
+    r = u;
+  }
+  var s = (performance || Date).now(), i = s, o = 0, c = t(new ae.Panel("FPS", "#0ff", "#002")), a = t(new ae.Panel("MS", "#0f0", "#020"));
+  if (self.performance && self.performance.memory)
+    var l = t(new ae.Panel("MB", "#f08", "#201"));
+  return n(0), {
+    REVISION: 16,
+    dom: e,
+    addPanel: t,
+    showPanel: n,
+    begin: function() {
+      s = (performance || Date).now();
+    },
+    end: function() {
+      o++;
+      var u = (performance || Date).now();
+      if (a.update(u - s, 200), u >= i + 1e3 && (c.update(o * 1e3 / (u - i), 100), i = u, o = 0, l)) {
+        var h = performance.memory;
+        l.update(h.usedJSHeapSize / 1048576, h.jsHeapSizeLimit / 1048576);
+      }
+      return u;
+    },
+    update: function() {
+      s = this.end();
+    },
+    // Backwards Compatibility
+    domElement: e,
+    setMode: n
+  };
+};
+ae.Panel = function(r, e, t) {
+  var n = 1 / 0, s = 0, i = Math.round, o = i(window.devicePixelRatio || 1), c = 80 * o, a = 48 * o, l = 3 * o, u = 2 * o, h = 3 * o, p = 15 * o, m = 74 * o, _ = 30 * o, w = document.createElement("canvas");
+  w.width = c, w.height = a, w.style.cssText = "width:80px;height:48px";
+  var d = w.getContext("2d");
+  return d.font = "bold " + 9 * o + "px Helvetica,Arial,sans-serif", d.textBaseline = "top", d.fillStyle = t, d.fillRect(0, 0, c, a), d.fillStyle = e, d.fillText(r, l, u), d.fillRect(h, p, m, _), d.fillStyle = t, d.globalAlpha = 0.9, d.fillRect(h, p, m, _), {
+    dom: w,
+    update: function(f, g) {
+      n = Math.min(n, f), s = Math.max(s, f), d.fillStyle = t, d.globalAlpha = 1, d.fillRect(0, 0, c, p), d.fillStyle = e, d.fillText(i(f) + " " + r + " (" + i(n) + "-" + i(s) + ")", l, u), d.drawImage(w, h + o, p, m - o, _, h, p, m - o, _), d.fillRect(h + m - o, p, o, _), d.fillStyle = t, d.globalAlpha = 0.9, d.fillRect(h + m - o, p, o, i((1 - f / g) * _));
+    }
+  };
+};
+function wn(r) {
+  return new Jt(r);
+}
+function bn(r = 150, ...e) {
+  return new es(r, r / 10, ...e);
+}
+function En(r) {
+  return new ts(r, 16776960);
+}
+function xn(r, e) {
+  return new ut(r, e);
+}
+function An(r, e) {
+  return new Ts(r, e);
+}
+function Rn() {
+  const r = new ss(), e = new k(0, 0);
+  return {
+    raycaster: r,
+    pointer: e
+  };
+}
+function Mn(r = 10) {
+  return new ns(r);
+}
+function Sn(r = new S(1, 1, 1), e = new S(10, 10, 10), t = 5, n = 16776960) {
+  return r.normalize(), new is(r, e, t, n);
+}
+function Ln() {
+  const r = new ae();
+  return r.dom.style.cssText = "position:absolute;top:0;left:0;cursor:pointer;opacity:0.9;z-index:10000", r;
+}
+const an = (r) => {
+  r.geometry && r.geometry.dispose(), r.material && (Array.isArray(r.material) ? r.material.forEach((e) => {
+    Qe(e);
+  }) : Qe(r.material)), r.children && r.children.forEach((e) => an(e));
+};
+function Qe(r) {
+  for (const e in r)
+    r[e] && r[e].isTexture && r[e].dispose();
+  r.dispose();
+}
+const Me = {};
+async function Pn(r, e = 50) {
+  const t = {
+    type: r.type,
+    name: r.name,
+    position: r.position.toArray(),
+    rotation: r.rotation.toArray(),
+    scale: r.scale.toArray(),
+    visible: r.visible,
+    children: [],
+    geometry: null,
+    material: null,
+    userData: r.userData
+  };
+  r.isMesh && (t.geometry = fe(r.geometry), t.material = me(r.material));
+  const n = [{ object: r, parentData: t }];
+  let s = 0;
+  for (; n.length > 0; ) {
+    const { object: i, parentData: o } = n.pop();
+    for (const c of i.children) {
+      const a = {
+        type: c.type,
+        name: c.name,
+        position: c.position.toArray(),
+        rotation: c.rotation.toArray(),
+        scale: c.scale.toArray(),
+        visible: c.visible,
+        children: [],
+        geometry: null,
+        material: null,
+        userData: c.userData
+      };
+      c.isMesh && (a.geometry = fe(c.geometry), a.material = me(c.material)), o.children.push(a), n.push({ object: c, parentData: a }), s++, s % e === 0 && await new Promise((l) => requestAnimationFrame(l));
+    }
+  }
+  return t;
+}
+function Dn(r) {
+  const e = {
+    type: r.type,
+    name: r.name,
+    position: r.position.toArray(),
+    rotation: r.rotation.toArray(),
+    scale: r.scale.toArray(),
+    visible: r.visible,
+    children: [],
+    geometry: null,
+    material: null,
+    userData: r.userData
+  };
+  r.isMesh && (e.geometry = fe(r.geometry), e.material = me(r.material));
+  const t = [{ object: r, parentData: e }];
+  for (; t.length > 0; ) {
+    const { object: n, parentData: s } = t.pop();
+    for (const i of n.children) {
+      const o = {
+        type: i.type,
+        name: i.name,
+        position: i.position.toArray(),
+        rotation: i.rotation.toArray(),
+        scale: i.scale.toArray(),
+        visible: i.visible,
+        children: [],
+        geometry: null,
+        material: null,
+        userData: i.userData
+      };
+      i.isMesh && (o.geometry = fe(i.geometry), o.material = me(i.material)), s.children.push(o), t.push({ object: i, parentData: o });
+    }
+  }
+  return e;
+}
+async function cn(r, e = 50) {
+  const t = [];
+  let n;
+  switch (r.type) {
+    case "Mesh":
+      const i = pe(r.geometry), o = ge(r.material);
+      n = new A.Mesh(i, o);
+      break;
+    case "Group":
+      n = new A.Group();
+      break;
+    case "Object3D":
+      n = new A.Object3D();
+      break;
+    default:
+      return console.warn(`Unsupported object type: ${r.type}`), null;
+  }
+  n.name = r.name, n.position.fromArray(r.position), n.rotation.fromArray(r.rotation), n.scale.fromArray(r.scale), n.visible = r.visible, n.userData = r.userData, t.push({ data: r, object: n });
+  let s = 0;
+  for (; t.length > 0; ) {
+    const { data: i, object: o } = t.pop();
+    for (const c of [...i.children].reverse()) {
+      let a;
+      switch (c.type) {
+        case "Mesh":
+          const l = pe(c.geometry), u = ge(c.material);
+          a = new A.Mesh(l, u);
+          break;
+        case "Group":
+          a = new A.Group();
+          break;
+        case "Object3D":
+          a = new A.Object3D();
+          break;
+        default:
+          console.warn(`Unsupported object type: ${c.type}`);
+          continue;
+      }
+      a && (a.name = c.name, a.position.fromArray(c.position), a.rotation.fromArray(c.rotation), a.scale.fromArray(c.scale), a.visible = c.visible, a.userData = c.userData, o.add(a), t.push({ data: c, object: a }), s++, s % e === 0 && await new Promise((l) => requestAnimationFrame(l)));
+    }
+  }
+  return n;
+}
+function Cn(r) {
+  const e = [];
+  let t;
+  switch (r.type) {
+    case "Mesh":
+      const n = pe(r.geometry), s = ge(r.material);
+      t = new A.Mesh(n, s);
+      break;
+    case "Group":
+      t = new A.Group();
+      break;
+    case "Object3D":
+      t = new A.Object3D();
+      break;
+    default:
+      return console.warn(`Unsupported object type: ${r.type}`), null;
+  }
+  for (t.name = r.name, t.position.fromArray(r.position), t.rotation.fromArray(r.rotation), t.scale.fromArray(r.scale), t.visible = r.visible, t.userData = r.userData, e.push({ data: r, object: t }); e.length > 0; ) {
+    const { data: n, object: s } = e.pop();
+    for (const i of [...n.children].reverse()) {
+      let o;
+      switch (i.type) {
+        case "Mesh":
+          const c = pe(i.geometry), a = ge(i.material);
+          o = new A.Mesh(c, a);
+          break;
+        case "Group":
+          o = new A.Group();
+          break;
+        case "Object3D":
+          o = new A.Object3D();
+          break;
+        default:
+          console.warn(`Unsupported object type: ${i.type}`);
+          continue;
+      }
+      o && (o.name = i.name, o.position.fromArray(i.position), o.rotation.fromArray(i.rotation), o.scale.fromArray(i.scale), o.visible = i.visible, o.userData = i.userData, s.add(o), e.push({ data: i, object: o }));
+    }
+  }
+  return t;
+}
+function fe(r) {
+  const e = {}, { attributes: t, index: n, type: s } = r;
+  t.position && (e.position = {
+    type: "Float32Array",
+    array: Array.from(t.position.array),
+    itemSize: 3
+  }), t.normal && (e.normal = {
+    type: "Float32Array",
+    array: Array.from(t.normal.array),
+    itemSize: 3
+  }), t.uv && (e.uv = {
+    type: "Float32Array",
+    array: Array.from(t.uv.array),
+    itemSize: 2
+  });
+  const i = {
+    type: s,
+    attributes: e
+  };
+  return n && n.array && (i.index = {
+    type: "Uint32Array",
+    array: Array.from(n.array),
+    itemSize: 1
+  }), i;
+}
+function pe(r) {
+  const { type: e, attributes: t, index: n } = r, s = new A.BufferGeometry();
+  for (const i in t)
+    if (t.hasOwnProperty(i)) {
+      const { type: o, array: c, itemSize: a } = t[i];
+      s.setAttribute(
+        i,
+        new A.BufferAttribute(new Float32Array(c), a)
+      );
+    }
+  return n && s.setIndex(n.array), s;
+}
+function me(r) {
+  return {
+    type: r.type,
+    color: r.color.getHex(),
+    map: r.map ? r.map.image.src : null,
+    opacity: r.opacity,
+    name: r.name,
+    depthTest: r.depthTest,
+    depthWrite: r.depthWrite,
+    transparent: r.transparent,
+    side: r.side,
+    roughness: r.roughness,
+    metalness: r.metalness,
+    emissive: r.emissive.getHex()
+  };
+}
+function ge(r) {
+  if (Me[r.name]) return Me[r.name];
+  const { type: e, ...t } = r, n = e || "MeshStandardMaterial", s = new A[n]({ ...t });
+  if (r.map) {
+    const i = new A.TextureLoader().load(r.map);
+    s.map = i;
+  }
+  return s.needsUpdate = !0, Me[r.name] = s, s;
+}
+class ln {
+  constructor() {
+    this.stats = {
+      hits: 0,
+      // 缓存命中次数
+      misses: 0,
+      // 缓存未命中次数
+      totalLoadTime: 0,
+      // 总加载时间(ms)
+      cacheSaveTime: 0,
+      // 缓存保存时间(ms)
+      errors: 0
+      // 错误次数
+    }, this.loadHistory = [];
+  }
+  /**
+   * 记录缓存命中
+   * @param {number} loadTime - 加载耗时(ms)
+   */
+  recordHit(e) {
+    this.stats.hits++, this.stats.totalLoadTime += e, this._recordHistory("hit", e);
+  }
+  /**
+   * 记录缓存未命中
+   * @param {number} loadTime - 加载耗时(ms)
+   */
+  recordMiss(e) {
+    this.stats.misses++, this.stats.totalLoadTime += e, this._recordHistory("miss", e);
+  }
+  /**
+   * 记录缓存保存时间
+   * @param {number} saveTime - 保存耗时(ms)
+   */
+  recordCacheSave(e) {
+    this.stats.cacheSaveTime += e;
+  }
+  /**
+   * 记录错误
+   * @param {string} path - 模型路径
+   * @param {Error} error - 错误对象
+   */
+  recordError(e, t) {
+    this.stats.errors++, this._recordHistory("error", 0, { path: e, error: t.message });
+  }
+  /**
+   * 计算缓存命中率
+   * @returns {string} 命中率百分比字符串
+   */
+  getHitRate() {
+    const e = this.stats.hits + this.stats.misses;
+    return e > 0 ? (this.stats.hits / e * 100).toFixed(2) + "%" : "0%";
+  }
+  /**
+   * 计算平均加载时间
+   * @returns {string} 平均加载时间(含单位)
+   */
+  getAvgLoadTime() {
+    const e = this.stats.hits + this.stats.misses;
+    return e > 0 ? (this.stats.totalLoadTime / e).toFixed(2) + "ms" : "0ms";
+  }
+  /**
+   * 获取完整的统计数据
+   * @returns {Object} 统计数据对象
+   */
+  getStats() {
+    const e = this.stats.hits + this.stats.misses;
+    return {
+      命中率: this.getHitRate(),
+      平均加载时间: this.getAvgLoadTime(),
+      缓存命中数: this.stats.hits,
+      缓存未命中数: this.stats.misses,
+      总加载次数: e,
+      总加载时间: this.stats.totalLoadTime.toFixed(2) + "ms",
+      缓存保存时间: this.stats.cacheSaveTime.toFixed(2) + "ms",
+      错误次数: this.stats.errors
+    };
+  }
+  /**
+   * 获取最近N条加载历史
+   * @param {number} count - 获取条数,默认 10
+   * @returns {Array} 历史记录数组
+   */
+  getHistory(e = 10) {
+    return this.loadHistory.slice(-e);
+  }
+  /**
+   * 清空统计数据
+   */
+  reset() {
+    this.stats = {
+      hits: 0,
+      misses: 0,
+      totalLoadTime: 0,
+      cacheSaveTime: 0,
+      errors: 0
+    }, this.loadHistory = [];
+  }
+  /**
+   * 内部方法: 记录历史
+   * @private
+   */
+  _recordHistory(e, t, n = {}) {
+    this.loadHistory.push({
+      type: e,
+      duration: t,
+      timestamp: Date.now(),
+      ...n
+    }), this.loadHistory.length > 100 && this.loadHistory.shift();
+  }
+  /**
+   * 打印统计报告到控制台
+   */
+  logReport() {
+    console.group("📊 缓存性能报告");
+    const e = this.getStats();
+    Object.entries(e).forEach(([t, n]) => {
+      console.log(`${t}: ${n}`);
+    }), console.groupEnd();
+  }
+}
+const W = new ln();
+class ye {
+  /**
+   * 异步操作并支持重试
+   * @param {Function} operation - 要执行的异步操作
+   * @param {RetryOptions} options - 重试配置
+   * @returns {Promise} 操作结果
+   */
+  static async retry(e, t = {}) {
+    const {
+      maxRetries: n = 3,
+      initialDelay: s = 1e3,
+      maxDelay: i = 1e4,
+      backoffFactor: o = 2,
+      shouldRetry: c = ye.defaultShouldRetry
+    } = t;
+    let a, l = s;
+    for (let u = 0; u <= n; u++)
+      try {
+        return await e();
+      } catch (h) {
+        if (a = h, u === n || !c(h, u))
+          throw h;
+        console.warn(
+          `[ RetryHelper ] 操作失败,第 ${u + 1} 次尝试失败,${l}ms 后进行第 ${u + 2} 次尝试...`,
+          h
+        ), await ye.delay(l), l = Math.min(l * o, i);
+      }
+    throw a;
+  }
+  /**
+   * 默认的重试判断逻辑
+   * @param {Error} error - 错误对象
+   * @param {number} attempt - 当前尝试次数
+   * @returns {boolean} 是否应该重试
+   */
+  static defaultShouldRetry(e, t) {
+    if (e.name === "TypeError" && e.message.includes("fetch"))
+      return !0;
+    if (e.message.includes("HTTP error")) {
+      const n = e.message.match(/status:\s*(\d+)/);
+      if (n) {
+        const s = parseInt(n[1], 10);
+        return s >= 500 || s === 429 || s === 408;
+      }
+    }
+    return !1;
+  }
+  /**
+   * 延迟指定时间
+   * @param {number} ms - 延迟毫秒数
+   * @returns {Promise}
+   */
+  static delay(e) {
+    return new Promise((t) => setTimeout(t, e));
+  }
+}
+const Se = {
+  NETWORK: "NETWORK",
+  // 网络错误
+  PARSE: "PARSE",
+  // 解析错误
+  VERSION_MISMATCH: "VERSION",
+  // 版本不匹配
+  UNKNOWN: "UNKNOWN"
+  // 未知错误
+};
+class ce extends Error {
+  constructor(e, t, n, s) {
+    super(e), this.name = "ModelLoadError", this.type = t, this.path = n, this.originalError = s, this.timestamp = Date.now();
+  }
+  /**
+   * 创建网络错误
+   */
+  static networkError(e, t) {
+    return new ce(
+      `网络加载失败: ${e}`,
+      Se.NETWORK,
+      e,
+      t
+    );
+  }
+  /**
+   * 创建解析错误
+   */
+  static parseError(e, t) {
+    return new ce(
+      `模型解析失败: ${e}`,
+      Se.PARSE,
+      e,
+      t
+    );
+  }
+  /**
+   * 创建版本不匹配错误
+   */
+  static versionMismatchError(e, t, n) {
+    return new ce(
+      `版本不匹配: ${e} (期望: ${t}, 实际: ${n})`,
+      Se.VERSION_MISMATCH,
+      e
+    );
+  }
+}
+const Je = 4;
+class et {
+  /**
+   * 构造函数
+   * @param {string} dbName - 数据库名称
+   * @param {CacheOptions} options - 缓存配置选项
+   */
+  constructor(e = "threeJsIDBCache", t = {}) {
+    this.version = Je, this.dbName = e, this.options = {
+      maxSize: t.maxSize || 500 * 1024 * 1024,
+      // 默认 500MB
+      maxEntries: t.maxEntries || 50,
+      // 默认最多 50 个模型
+      evictRatio: t.evictRatio || 0.2
+      // 淘汰 20%
+    }, this.dbInit();
+  }
+  dbInit() {
+    this.db = new os(this.dbName), this.db.version(this.version).stores({
+      models: "&path, version, timestamp, accessCount, size"
+    }).upgrade(async (e) => {
+      console.log("[ IDBCache 版本更新 ] ====> version", Je);
+      const t = e.table("models"), n = await t.toArray();
+      for (const s of n)
+        s.data instanceof ArrayBuffer || await t.delete(s.path);
+    });
+  }
+  /**
+   * 获取 Dexie 数据库实例
+   * @returns {Dexie} Dexie 实例
+   */
+  getDatabase() {
+    return this.db;
+  }
+  async saveModel(e, t, n) {
+    await this.ensureCapacity(n.byteLength), await this.db.table("models").put({
+      path: e,
+      version: t,
+      data: n,
+      size: n.byteLength,
+      timestamp: Date.now(),
+      accessCount: 0
+    });
+  }
+  /**
+   * 确保缓存容量足够,不足时执行 LRU 淘汰
+   * @param {number} requiredSize - 需要的额外空间(字节)
+   */
+  async ensureCapacity(e) {
+    const t = await this.db.table("models").toArray(), n = t.reduce((c, a) => c + (a.size || 0), 0), s = t.length, i = n + e > this.options.maxSize, o = s >= this.options.maxEntries;
+    (i || o) && (console.log(`[ IDBCache ] ====> 容量不足,开始 LRU 淘汰. 总大小: ${(n / 1024 / 1024).toFixed(2)}MB, 条目数: ${s}`), await this.evictLRU(t));
+  }
+  /**
+   * 执行 LRU 淘汰策略
+   * @param {Array} models - 所有缓存记录
+   */
+  async evictLRU(e) {
+    const t = e.sort((c, a) => (c.accessCount || 0) !== (a.accessCount || 0) ? (c.accessCount || 0) - (a.accessCount || 0) : (c.timestamp || 0) - (a.timestamp || 0)), n = Math.max(1, Math.floor(t.length * this.options.evictRatio)), s = t.slice(0, n), i = s.map((c) => c.path);
+    await this.db.table("models").bulkDelete(i);
+    const o = s.reduce((c, a) => c + (a.size || 0), 0);
+    console.log(`[ IDBCache ] ====> LRU 淘汰完成. 删除 ${n} 个条目,释放 ${(o / 1024 / 1024).toFixed(2)}MB`);
+  }
+  async getModel(e, t) {
+    const n = await this.db.table("models").get(e);
+    return n ? n.version !== t ? (console.log("模型版本不一致, 清除当前记录"), await this.db.table("models").delete(e), null) : (await this.db.table("models").update(e, {
+      accessCount: (n.accessCount || 0) + 1,
+      timestamp: Date.now()
+    }), n.data) : (console.warn(`Model "${e}" not found in table models`), null);
+  }
+  // ----------------------------  ---------------------------------
+  /**
+   * 缓存模型到 IndexedDB
+   * @param {string} path - 主键值
+   * @param {THREE.Object3D} model - 要缓存的模型
+   * @param {string} [version] - 缓存模型版本
+   */
+  async cacheModel(e, t, n) {
+    console.log("[  ] ====> path, modelData, version", e, t, n);
+    try {
+      this.db.table("models").put({ version: n, path: e, data: t }).then(() => {
+        console.log(`Model "${e}" cached successfully in table models`);
+      });
+    } catch {
+      console.log(" 缓存模型失败 =====> ");
+    }
+    return t;
+  }
+  /**
+   * 从 IndexedDB 加载缓存的模型
+   * @param {string} path - 主键值
+   * @returns {THREE.Object3D | null} 加载的模型
+   */
+  async loadCachedModel(e, t) {
+    let n = null;
+    try {
+      if (n = await this.db.table("models").get(e), !n)
+        return console.warn(`Model "${t}" not found in table models`), null;
+      if (n.version !== t)
+        return console.log(" =====> 模型版本不一致, 清除当前记录"), await this.db.table("models").delete(e), null;
+    } catch {
+      return console.log("  =====> 查询表中模型失败"), this.db.delete().then(() => {
+        this.init();
+      }), null;
+    }
+    return n.data;
+  }
+  /**
+   * 获取缓存统计信息
+   * @returns {Promise<Object>} 缓存统计数据
+   */
+  async getStats() {
+    const e = await this.db.table("models").toArray(), t = e.reduce((s, i) => s + (i.size || 0), 0), n = e.reduce((s, i) => s + (i.accessCount || 0), 0);
+    return {
+      count: e.length,
+      totalSize: t,
+      totalSizeMB: (t / 1024 / 1024).toFixed(2),
+      maxEntries: this.options.maxEntries,
+      maxSizeMB: (this.options.maxSize / 1024 / 1024).toFixed(2),
+      usagePercentage: (t / this.options.maxSize * 100).toFixed(2),
+      totalAccessCount: n,
+      avgAccessCount: e.length > 0 ? (n / e.length).toFixed(2) : 0
+    };
+  }
+  /**
+   * 清空所有缓存
+   */
+  async clear() {
+    await this.db.table("models").clear(), console.log("[ IDBCache ] ====> 缓存已清空");
+  }
+  /**
+   * 删除指定模型缓存
+   * @param {string} path - 模型路径
+   */
+  async deleteModel(e) {
+    await this.db.table("models").delete(e);
+  }
+}
+function pt(r) {
+  const { geometries: e, materials: t, hierarchy: n } = r, s = /* @__PURE__ */ new Map();
+  e.forEach((a, l) => {
+    const u = hn(a);
+    s.set(l, u);
+  });
+  const i = /* @__PURE__ */ new Map();
+  t.forEach((a, l) => {
+    const u = un(a);
+    i.set(l, u);
+  });
+  const o = new A.Group();
+  o.name = "Scene";
+  const c = /* @__PURE__ */ new Map();
+  return n.forEach((a) => {
+    let l;
+    if (a.type === "Mesh") {
+      const u = a.geometryIndex >= 0 ? s.get(a.geometryIndex) : null, h = a.materialIndex >= 0 ? i.get(a.materialIndex) : null;
+      l = new A.Mesh(u, h);
+    } else a.type === "Group" ? l = new A.Group() : a.type === "Object3D" ? l = new A.Object3D() : l = new A.Object3D();
+    l.name = a.name, l.position.fromArray(a.position), l.rotation.fromArray(a.rotation), l.scale.fromArray(a.scale), l.visible = a.visible, c.set(a.id, l);
+  }), n.forEach((a) => {
+    const l = c.get(a.id);
+    if (a.parentId !== null) {
+      const u = c.get(a.parentId);
+      u && u.add(l);
+    } else
+      o.add(l);
+  }), o;
+}
+function hn(r) {
+  const e = new A.BufferGeometry();
+  for (const t in r.attributes) {
+    const n = r.attributes[t], s = n.array;
+    let i;
+    if (s.byteLength === 0) {
+      console.warn(`[ sceneRebuilder ] 属性 ${t} 的数组为空`);
+      continue;
+    }
+    if (s.buffer && s.buffer.byteLength === 0) {
+      console.warn(`[ sceneRebuilder ] 属性 ${t} 的 buffer 已被转移,尝试重建`);
+      continue;
+    }
+    i = s;
+    const o = new A.BufferAttribute(i, n.itemSize);
+    o.normalized = n.normalized, e.setAttribute(t, o);
+  }
+  if (r.index) {
+    const t = r.index, n = t.array;
+    if (n && n.byteLength > 0) {
+      const s = new A.BufferAttribute(n, t.itemSize);
+      e.setIndex(s);
+    }
+  }
+  return e;
+}
+function un(r) {
+  let e;
+  const t = {
+    color: r.color !== void 0 ? r.color : 16777215,
+    opacity: r.opacity !== void 0 ? r.opacity : 1,
+    transparent: r.transparent !== void 0 ? r.transparent : !1,
+    alphaTest: r.alphaTest !== void 0 ? r.alphaTest : 0,
+    // 关键渲染属性 - 这些缺失会导致渲染抖动和显示错误
+    side: r.side !== void 0 ? r.side : A.FrontSide,
+    depthTest: r.depthTest !== void 0 ? r.depthTest : !0,
+    depthWrite: r.depthWrite !== void 0 ? r.depthWrite : !0,
+    wireframe: r.wireframe !== void 0 ? r.wireframe : !1,
+    vertexColors: r.vertexColors !== void 0 ? r.vertexColors : !1
+  };
+  switch (r.type) {
+    case "MeshStandardMaterial":
+      e = new A.MeshStandardMaterial({
+        ...t,
+        roughness: r.roughness !== void 0 ? r.roughness : 0.5,
+        metalness: r.metalness !== void 0 ? r.metalness : 0.5,
+        emissive: r.emissive !== void 0 ? r.emissive : 0,
+        emissiveIntensity: r.emissiveIntensity !== void 0 ? r.emissiveIntensity : 1
+      });
+      break;
+    case "MeshBasicMaterial":
+      e = new A.MeshBasicMaterial({
+        ...t
+      });
+      break;
+    case "MeshPhongMaterial":
+      e = new A.MeshPhongMaterial({
+        ...t,
+        shininess: r.shininess !== void 0 ? r.shininess : 30,
+        specular: r.specular !== void 0 ? r.specular : 1118481,
+        emissive: r.emissive !== void 0 ? r.emissive : 0,
+        emissiveIntensity: r.emissiveIntensity !== void 0 ? r.emissiveIntensity : 1
+      });
+      break;
+    default:
+      e = new A.MeshStandardMaterial(t);
+  }
+  return e.uuid = r.uuid, e;
+}
+class On {
+  constructor() {
+    this.geometries = [], this.materials = [], this.hierarchy = [], this.geometryMap = /* @__PURE__ */ new Map(), this.materialMap = /* @__PURE__ */ new Map();
+  }
+  /**
+   * 添加场景数据块
+   */
+  addChunk(e) {
+    e.geometries && e.geometries.forEach((t) => {
+      const n = this.geometries.length;
+      this.geometries.push(t), this.geometryMap.set(t.uuid, n);
+    }), e.materials && e.materials.forEach((t) => {
+      const n = this.materials.length;
+      this.materials.push(t), this.materialMap.set(t.uuid, n);
+    }), e.hierarchy && this.hierarchy.push(...e.hierarchy);
+  }
+  /**
+   * 构建当前可渲染的场景
+   */
+  buildCurrent() {
+    const e = {
+      geometries: this.geometries,
+      materials: this.materials,
+      hierarchy: this.hierarchy
+    };
+    return pt(e);
+  }
+  /**
+   * 完成构建
+   */
+  finalize() {
+    return this.buildCurrent();
+  }
+}
+function dn(r) {
+  return new Worker(
+    "" + new URL("assets/gltfParser.worker-D2lwod50.js", import.meta.url).href,
+    {
+      name: r == null ? void 0 : r.name
+    }
+  );
+}
+function fn(r) {
+  return new Worker(
+    "" + new URL("assets/gltfParserOptimized.worker-FT73rIOj.js", import.meta.url).href,
+    {
+      name: r == null ? void 0 : r.name
+    }
+  );
+}
+let ee;
+const Le = "/draco/";
+let Q, J, tt = 0;
+const X = /* @__PURE__ */ new Map(), H = /* @__PURE__ */ new Map(), pn = (r = {}) => {
+  const { debug: e = !1 } = r, t = new Es(), n = new ws();
+  n.setDecoderPath(Le), t.setDRACOLoader(n);
+  const s = {
+    info: (...d) => e && console.log(...d),
+    warn: (...d) => e && console.warn(...d),
+    error: (...d) => console.error(...d),
+    // 错误总是输出
+    time: (d) => e && console.time(d),
+    timeEnd: (d) => e && console.timeEnd(d)
+  };
+  function i(d, f, g, T) {
+    return t.load(d, f, g, T);
+  }
+  function o(d, f) {
+    return new Promise((g, T) => {
+      t.load(d, g, f, T);
+    });
+  }
+  async function c(d, f, g, T = {}) {
+    const y = performance.now();
+    let E = !1;
+    const {
+      maxRetries: x = 3,
+      optimizeMaterials: M = !1,
+      simplifyGeometry: D = !1,
+      simplifyRatio: C = 0.5,
+      simplifyOptions: z = {},
+      useMemoryCache: he = !0
+      // 是否使用内存缓存（默认 true）
+    } = T;
+    if (he) {
+      const P = H.get(d);
+      if (P && P.has(f)) {
+        const N = P.get(f);
+        s.info(`[ 内存缓存命中 ] ${d} (version: ${f})`), s.time("[ 内存缓存克隆耗时 ]");
+        const $ = N.clone(!0);
+        return s.timeEnd("[ 内存缓存克隆耗时 ]"), W.recordHit(performance.now() - y), $;
+      }
+    }
+    try {
+      let P = await l(d, f);
+      if (P)
+        s.info(`[ asyncFetch ] ====> IndexedDB 缓存命中: ${d}`), E = !0;
+      else {
+        s.info(`[ asyncFetch ] ====> 缓存未命中: ${d}`), s.time("[ fetchArrayBuffer ] 加载模型耗时"), P = await ye.retry(
+          () => a(d, g),
+          {
+            maxRetries: x,
+            shouldRetry: (He) => !!(He.name === "TypeError" || He.message.includes("HTTP error! status: 5"))
+          }
+        ), s.timeEnd("[ fetchArrayBuffer ] 加载模型耗时");
+        const v = performance.now();
+        await ee.saveModel(d, f, P);
+        const _e = performance.now() - v;
+        W.recordCacheSave(_e), E = !1;
+      }
+      s.time("[ 解析模型耗时 ]");
+      let N = await u(P);
+      if (s.timeEnd("[ 解析模型耗时 ]"), s.time("[ 模型优化耗时 ]"), M) {
+        s.info("🔧 [ 材质优化 ] 开始合并相同材质...");
+        const { modelOptimizer: v } = await import("./modelOptimizer-D6fRg-DF.js");
+        N = v.optimizeMaterials(N);
+      }
+      if (D) {
+        s.info(`🔧 [ 几何体简化 ] 开始简化模型 (比例: ${C})...`);
+        const { modelOptimizer: v } = await import("./modelOptimizer-D6fRg-DF.js"), _e = {
+          minFaceCount: 100,
+          preserveUVs: !0,
+          ...z
+        };
+        N = v.simplifyModel(N, C, _e);
+      }
+      if (s.timeEnd("[ 模型优化耗时 ]"), he) {
+        H.has(d) || H.set(d, /* @__PURE__ */ new Map());
+        const v = H.get(d);
+        v.has(f) || (s.info(`[ 内存缓存 ] 存储模型 ${d} (version: ${f})`), v.set(f, N.clone(!0)));
+      }
+      const $ = performance.now() - y;
+      return E ? W.recordHit($) : W.recordMiss($), N;
+    } catch (P) {
+      throw s.error(`加载模型 ${d} 失败:`, P), W.recordError(d, P), P.name === "TypeError" && P.message.includes("fetch") ? ce.networkError(d, P) : P;
+    }
+  }
+  async function a(d, f) {
+    return new Promise((g, T) => {
+      fetch(d).then((y) => {
+        if (!y.ok)
+          throw new Error(`HTTP error! status: ${y.status}`);
+        return y;
+      }).then((y) => {
+        const E = y.headers.get("content-length"), x = E ? parseInt(E, 10) : 0;
+        if (f && x > 0) {
+          const M = y.body.getReader();
+          let D = 0;
+          const C = [], z = () => {
+            M.read().then(({ done: he, value: P }) => {
+              if (he) {
+                const N = new Uint8Array(D);
+                let $ = 0;
+                for (const v of C)
+                  N.set(v, $), $ += v.length;
+                g(N.buffer);
+                return;
+              }
+              C.push(P), D += P.length, f(Math.round(D / x * 100)), z();
+            }).catch(T);
+          };
+          z();
+        } else
+          return y.arrayBuffer();
+      }).then((y) => g(y)).catch((y) => {
+        T(y);
+      });
+    });
+  }
+  async function l(d, f) {
+    return ee || (ee = new et()), ee.getModel(d, f);
+  }
+  async function u(d, f = {}) {
+    if (!d) return null;
+    const { useOptimizedParser: g = !0, useProgressive: T = !1 } = f;
+    if (g) {
+      const x = p();
+      if (x)
+        try {
+          s.time("[ 优化解析 ] 使用 Transferable Objects 解析");
+          const M = await m(x, d, T);
+          return s.timeEnd("[ 优化解析 ] 使用 Transferable Objects 解析"), pt(M);
+        } catch (M) {
+          s.warn("[ 优化解析 ] 失败,回退到标准解析", M);
+        }
+    }
+    const y = h();
+    if (y)
+      try {
+        const x = await _(y, d);
+        return cn(x);
+      } catch (x) {
+        s.warn("[ GLTF Worker ] ====> 解析失败，回退到主线程解析", x);
+      }
+    return (await w(d)).scene;
+  }
+  const h = () => {
+    if (typeof window > "u" || typeof Worker > "u")
+      return null;
+    if (!Q)
+      try {
+        s.info("[GLTF Worker] 使用 ?worker 工厂函数创建 Worker..."), Q = dn(), s.info("[GLTF Worker] Worker 创建成功:", Q), Q.onmessage = (d) => {
+          const { id: f, data: g, error: T } = d.data || {};
+          if (!f || !X.has(f)) return;
+          const { resolve: y, reject: E } = X.get(f);
+          X.delete(f), T ? E(new Error(T)) : y(g);
+        }, Q.onmessageerror = (d) => {
+          console.error("[ GLTF Worker ] ====> 消息解析失败", d);
+        }, Q.onerror = (d) => {
+          console.error("[ GLTF Worker ] ====> 运行错误", d);
+        };
+      } catch (d) {
+        console.error("[GLTF Worker] 创建 Worker 失败:", d), console.error("[GLTF Worker] 错误堆栈:", d.stack);
+      }
+    return Q;
+  }, p = () => {
+    if (typeof window > "u" || typeof Worker > "u")
+      return null;
+    if (!J)
+      try {
+        s.info("[Optimized Worker] 使用 ?worker 工厂函数创建 Worker..."), J = fn(), s.info("[Optimized Worker] Worker 创建成功:", J), J.onmessage = (d) => {
+          const { id: f, data: g, error: T, type: y } = d.data || {};
+          if (!f || !X.has(f) || y === "progress")
+            return;
+          const { resolve: E, reject: x } = X.get(f);
+          X.delete(f), T ? x(new Error(T)) : E(g);
+        }, J.onmessageerror = (d) => {
+          console.error("[ 优化 Worker ] ====> 消息解析失败", d);
+        }, J.onerror = (d) => {
+          console.error("[ 优化 Worker ] ====> 运行错误", d);
+        };
+      } catch (d) {
+        return s.warn("[ 优化 Worker ] ====> 创建失败,可能不支持模块化 Worker", d), null;
+      }
+    return J;
+  }, m = (d, f, g = !1) => new Promise((T, y) => {
+    const E = ++tt;
+    X.set(E, { resolve: T, reject: y });
+    const x = {
+      id: E,
+      arrayBuffer: f,
+      dracoPath: Le,
+      mode: g ? "progressive" : "standard"
+    };
+    d.postMessage(x, [f]);
+  }), _ = (d, f) => new Promise((g, T) => {
+    const y = ++tt;
+    X.set(y, { resolve: g, reject: T }), d.postMessage({ id: y, arrayBuffer: f, dracoPath: Le });
+  }), w = (d) => new Promise((f, g) => {
+    t.parse(d, "", f, g);
+  });
+  return {
+    load: i,
+    asyncLoad: o,
+    asyncCacheLoad: c,
+    asyncFetch: c,
+    /**
+     * 获取缓存统计信息
+     * @returns {Object} 统计数据
+     */
+    getCacheStats: () => W.getStats(),
+    /**
+     * 获取缓存实例
+     * @returns {IDBCache} 缓存实例
+     */
+    getCache: () => ee || (ee = new et()),
+    /**
+     * 打印缓存性能报告
+     */
+    logCacheReport: () => W.logReport(),
+    /**
+     * 重置缓存统计
+     */
+    resetCacheStats: () => W.reset(),
+    /**
+     * 清空内存缓存
+     * 释放已缓存的 3D 模型对象内存
+     * @returns {number} 释放的模型数量
+     */
+    clearMemoryCache: () => {
+      let d = 0;
+      for (const [f, g] of H.entries())
+        d += g.size, g.clear();
+      return H.clear(), s.info(`[ 内存缓存 ] 已清空，释放了 ${d} 个模型`), d;
+    },
+    /**
+     * 获取内存缓存信息
+     * @returns {Object} 内存缓存统计
+     * @returns {number} returns.totalPaths - 缓存的不同模型路径数量
+     * @returns {number} returns.totalModels - 缓存的总模型数量
+     * @returns {Array} returns.details - 每个路径的详细信息
+     */
+    getMemoryCacheInfo: () => {
+      const d = [];
+      let f = 0;
+      for (const [g, T] of H.entries()) {
+        const y = Array.from(T.keys());
+        f += y.length, d.push({
+          path: g,
+          versions: y,
+          count: y.length
+        });
+      }
+      return {
+        totalPaths: H.size,
+        totalModels: f,
+        details: d
+      };
+    },
+    /**
+     * 删除指定模型的内存缓存
+     * @param {string} path - 模型路径
+     * @param {string} [version] - 可选的版本号，如果不指定则删除该路径的所有版本
+     * @returns {boolean} 是否删除成功
+     */
+    deleteMemoryCache: (d, f) => {
+      const g = H.get(d);
+      if (!g)
+        return !1;
+      if (f) {
+        const T = g.delete(f);
+        return g.size === 0 && H.delete(d), s.info(`[ 内存缓存 ] 删除模型 ${d} (version: ${f})`), T;
+      } else {
+        const T = g.size;
+        return H.delete(d), s.info(`[ 内存缓存 ] 删除模型 ${d} 及其所有版本 (共 ${T} 个)`), T > 0;
+      }
+    }
+  };
+};
+class mn {
+  constructor(e = {}) {
+    this.options = {
+      maxPreloadCount: e.maxPreloadCount || 5,
+      preloadDelay: e.preloadDelay || 1e3,
+      enableLearning: e.enableLearning !== !1
+    }, this.loadHistory = /* @__PURE__ */ new Map(), this.loadSequence = [], this.associations = /* @__PURE__ */ new Map(), this.preloadQueue = /* @__PURE__ */ new Set(), this.isPreloading = !1, this.loader = null, this.getLoader = () => (this.loader || (this.loader = pn()), this.loader);
+  }
+  /**
+   * 记录模型加载
+   * @param {string} path - 模型路径
+   * @param {string} version - 模型版本
+   */
+  recordLoad(e, t) {
+    const n = Date.now(), s = this.loadHistory.get(e) || {
+      count: 0,
+      lastLoadTime: 0,
+      versions: /* @__PURE__ */ new Set()
+    };
+    s.count++, s.lastLoadTime = n, s.versions.add(t), this.loadHistory.set(e, s), this.loadSequence.push({ path: e, timestamp: n }), this.loadSequence.length > 100 && this.loadSequence.shift(), this.options.enableLearning && this.loadSequence.length >= 2 && this._learnAssociations(e), this._triggerPredictivePreload(e, t);
+  }
+  /**
+   * 学习模型关联规则
+   * @private
+   * @param {string} currentPath - 当前加载的模型
+   */
+  _learnAssociations(e) {
+    const n = this.loadSequence.length - 1;
+    for (let s = Math.max(0, n - 10); s < n; s++) {
+      const { path: i } = this.loadSequence[s];
+      if (this.loadSequence[n].timestamp - this.loadSequence[s].timestamp < 5 * 60 * 1e3 && i !== e) {
+        this.associations.has(i) || this.associations.set(i, /* @__PURE__ */ new Map());
+        const c = this.associations.get(i), a = c.get(e) || 0;
+        c.set(e, a + 1);
+      }
+    }
+  }
+  /**
+   * 触发预测性预加载
+   * @private
+   * @param {string} currentPath - 当前加载的模型
+   * @param {string} version - 模型版本
+   */
+  _triggerPredictivePreload(e, t) {
+    setTimeout(() => {
+      const n = this.predictNext(e);
+      this.preload(n, t);
+    }, this.options.preloadDelay);
+  }
+  /**
+   * 预测下一个可能加载的模型
+   * @param {string} currentPath - 当前模型路径
+   * @returns {Array<string>} 预测的模型路径列表
+   */
+  predictNext(e) {
+    const t = /* @__PURE__ */ new Map(), n = this.associations.get(e);
+    n && n.forEach((c, a) => {
+      t.set(a, (t.get(a) || 0) + c * 2);
+    });
+    const s = Array.from(this.loadHistory.values()).reduce((c, a) => c + a.count, 0) / (this.loadHistory.size || 1);
+    this.loadHistory.forEach((c, a) => {
+      if (a !== e) {
+        const l = c.count / s;
+        t.set(a, (t.get(a) || 0) + l);
+      }
+    });
+    const i = this.loadSequence.slice(-10);
+    return new Set(i.map((c) => c.path)).forEach((c) => {
+      c !== e && t.set(c, (t.get(c) || 0) + 0.5);
+    }), Array.from(t.entries()).sort((c, a) => a[1] - c[1]).slice(0, this.options.maxPreloadCount).map(([c]) => c);
+  }
+  /**
+   * 预加载模型列表
+   * @param {Array<string>} paths - 模型路径列表
+   * @param {string} version - 模型版本
+   */
+  async preload(e, t = "latest") {
+    if (this.isPreloading)
+      return;
+    this.isPreloading = !0;
+    const { asyncFetch: n } = this.getLoader(), s = e.filter((i) => !this.preloadQueue.has(i)).slice(0, this.options.maxPreloadCount).map(async (i) => {
+      this.preloadQueue.add(i);
+      try {
+        console.log(`[ 智能预加载 ] 开始预加载: ${i}`), await n(i, t), console.log(`[ 智能预加载 ] 完成: ${i}`);
+      } catch (o) {
+        console.warn(`[ 智能预加载 ] 失败: ${i}`, o);
+      } finally {
+        this.preloadQueue.delete(i);
+      }
+    });
+    await Promise.all(s), this.isPreloading = !1;
+  }
+  /**
+   * 手动添加关联规则
+   * @param {string} fromPath - 源模型路径
+   * @param {Array<string>} toPaths - 关联的模型路径列表
+   */
+  addAssociation(e, t) {
+    this.associations.has(e) || this.associations.set(e, /* @__PURE__ */ new Map());
+    const n = this.associations.get(e);
+    t.forEach((s) => {
+      const i = n.get(s) || 0;
+      n.set(s, i + 10);
+    });
+  }
+  /**
+   * 获取加载统计信息
+   * @returns {Object} 统计数据
+   */
+  getStats() {
+    const e = Array.from(this.loadHistory.entries()).sort((t, n) => n[1].count - t[1].count).slice(0, 10).map(([t, n]) => ({
+      path: t,
+      loadCount: n.count,
+      lastLoadTime: new Date(n.lastLoadTime).toLocaleString()
+    }));
+    return {
+      totalModelsLoaded: this.loadHistory.size,
+      totalAssociations: this.associations.size,
+      topModels: e,
+      preloadQueueSize: this.preloadQueue.size
+    };
+  }
+  /**
+   * 清空历史记录
+   */
+  clearHistory() {
+    this.loadHistory.clear(), this.loadSequence = [], this.associations.clear();
+  }
+  /**
+   * 导出关联规则(可持久化)
+   * @returns {Object} 关联规则数据
+   */
+  exportAssociations() {
+    const e = {};
+    return this.associations.forEach((t, n) => {
+      e[n] = Array.from(t.entries());
+    }), e;
+  }
+  /**
+   * 导入关联规则
+   * @param {Object} data - 关联规则数据
+   */
+  importAssociations(e) {
+    Object.entries(e).forEach(([t, n]) => {
+      const s = new Map(n);
+      this.associations.set(t, s);
+    });
+  }
+}
+const kn = new mn();
+export {
+  ln as C,
+  Se as E,
+  et as I,
+  ce as M,
+  mn as P,
+  ye as R,
+  ae as S,
+  bn as a,
+  En as b,
+  wn as c,
+  xn as d,
+  An as e,
+  Rn as f,
+  Mn as g,
+  Sn as h,
+  Ln as i,
+  an as j,
+  Dn as k,
+  cn as l,
+  Cn as m,
+  W as n,
+  Pn as o,
+  kn as p,
+  On as q,
+  pt as r,
+  Tn as s,
+  _n as t,
+  pn as u
+};