endset_three_editor 0.0.1 → 0.1.1

package/dist/three-editor.es.js

@@ -0,0 +1,3879 @@
+import { defineComponent as Fe, ref as K, inject as bn, computed as Be, watchEffect as wn, resolveComponent as Tn, openBlock as Y, createElementBlock as q, createElementVNode as g, normalizeClass as xn, withModifiers as vt, unref as En, toDisplayString as st, Fragment as $t, renderList as Jt, createBlock as en, createCommentVNode as tn, watch as Mn, toRef as Sn, provide as vn, withDirectives as H, vModelText as oe, vShow as pe, reactive as Rn, shallowRef as An, onMounted as Pn, createVNode as it } from "vue";
+import * as N from "three";
+import { Controls as nn, Vector3 as E, MOUSE as xe, TOUCH as Te, Quaternion as X, Spherical as Rt, Vector2 as B, Ray as Ln, Plane as In, MathUtils as sn, Raycaster as On, Object3D as je, MeshBasicMaterial as ye, LineBasicMaterial as De, CylinderGeometry as z, BoxGeometry as F, BufferGeometry as He, Float32BufferAttribute as he, Mesh as b, OctahedronGeometry as Ke, Line as re, TorusGeometry as Re, SphereGeometry as Cn, Euler as Dn, Matrix4 as Me, PlaneGeometry as Nn, DoubleSide as on, Loader as rn, FileLoader as Tt, Color as ue, SRGBColorSpace as Se, Group as $e, Material as Ne, PointsMaterial as Ie, MeshPhongMaterial as kn, LineSegments as ft, Points as Je, TrianglesDrawMode as jn, TriangleFanDrawMode as mt, TriangleStripDrawMode as an, LoaderUtils as ke, MeshPhysicalMaterial as ne, LinearSRGBColorSpace as ae, SpotLight as Hn, PointLight as Fn, DirectionalLight as Un, InstancedMesh as zn, InstancedBufferAttribute as Gn, TextureLoader as Xn, ImageBitmapLoader as Yn, BufferAttribute as ot, InterleavedBuffer as Bn, InterleavedBufferAttribute as Kn, LinearMipmapLinearFilter as ln, NearestMipmapLinearFilter as Vn, LinearMipmapNearestFilter as Zn, NearestMipmapNearestFilter as Qn, LinearFilter as gt, NearestFilter as cn, RepeatWrapping as yt, MirroredRepeatWrapping as qn, ClampToEdgeWrapping as Wn, MeshStandardMaterial as hn, PropertyBinding as $n, SkinnedMesh as Jn, LineLoop as es, PerspectiveCamera as ts, OrthographicCamera as ns, Skeleton as ss, AnimationClip as is, Bone as os, InterpolateDiscrete as rs, InterpolateLinear as un, Texture as At, VectorKeyframeTrack as Pt, NumberKeyframeTrack as Lt, QuaternionKeyframeTrack as It, ColorManagement as Ot, FrontSide as as, Interpolant as ls, Box3 as cs, Sphere as hs } from "three";
+import us from "@tweenjs/tween.js";
+const Ct = { type: "change" }, xt = { type: "start" }, dn = { type: "end" }, Ve = new Ln(), Dt = new In(), ds = Math.cos(70 * sn.DEG2RAD), D = new E(), G = 2 * Math.PI, A = {
+  NONE: -1,
+  ROTATE: 0,
+  DOLLY: 1,
+  PAN: 2,
+  TOUCH_ROTATE: 3,
+  TOUCH_PAN: 4,
+  TOUCH_DOLLY_PAN: 5,
+  TOUCH_DOLLY_ROTATE: 6
+}, rt = 1e-6;
+class ps extends nn {
+  /**
+   * Constructs a new controls instance.
+   *
+   * @param {Object3D} object - The object that is managed by the controls.
+   * @param {?HTMLElement} domElement - The HTML element used for event listeners.
+   */
+  constructor(e, t = null) {
+    super(e, t), this.state = A.NONE, this.target = new E(), this.cursor = new E(), 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: xe.ROTATE, MIDDLE: xe.DOLLY, RIGHT: xe.PAN }, this.touches = { ONE: Te.ROTATE, TWO: Te.DOLLY_PAN }, this.target0 = this.target.clone(), this.position0 = this.object.position.clone(), this.zoom0 = this.object.zoom, this._cursorStyle = "auto", this._domElementKeyEvents = null, this._lastPosition = new E(), this._lastQuaternion = new X(), this._lastTargetPosition = new E(), this._quat = new X().setFromUnitVectors(e.up, new E(0, 1, 0)), this._quatInverse = this._quat.clone().invert(), this._spherical = new Rt(), this._sphericalDelta = new Rt(), this._scale = 1, this._panOffset = new E(), this._rotateStart = new B(), this._rotateEnd = new B(), this._rotateDelta = new B(), this._panStart = new B(), this._panEnd = new B(), this._panDelta = new B(), this._dollyStart = new B(), this._dollyEnd = new B(), this._dollyDelta = new B(), this._dollyDirection = new E(), this._mouse = new B(), this._performCursorZoom = !1, this._pointers = [], this._pointerPositions = {}, this._controlActive = !1, this._onPointerMove = ms.bind(this), this._onPointerDown = fs.bind(this), this._onPointerUp = gs.bind(this), this._onContextMenu = Es.bind(this), this._onMouseWheel = bs.bind(this), this._onKeyDown = ws.bind(this), this._onTouchStart = Ts.bind(this), this._onTouchMove = xs.bind(this), this._onMouseDown = ys.bind(this), this._onMouseMove = _s.bind(this), this._interceptControlDown = Ms.bind(this), this._interceptControlUp = Ss.bind(this), this.domElement !== null && this.connect(this.domElement), this.update();
+  }
+  /**
+   * Defines the visual representation of the cursor.
+   *
+   * @type {('auto'|'grab')}
+   * @default 'auto'
+   */
+  set cursorStyle(e) {
+    this._cursorStyle = e, e === "grab" ? this.domElement.style.cursor = "grab" : this.domElement.style.cursor = "auto";
+  }
+  get cursorStyle() {
+    return this._cursorStyle;
+  }
+  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.ownerDocument.removeEventListener("pointermove", this._onPointerMove), this.domElement.ownerDocument.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 = "";
+  }
+  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 {HTMLElement} 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(Ct), this.update(), this.state = A.NONE;
+  }
+  /**
+   * Programmatically pan the camera.
+   *
+   * @param {number} deltaX - The horizontal pan amount in pixels.
+   * @param {number} deltaY - The vertical pan amount in pixels.
+   */
+  pan(e, t) {
+    this._pan(e, t), this.update();
+  }
+  /**
+   * Programmatically dolly in (zoom in for perspective camera).
+   *
+   * @param {number} dollyScale - The dolly scale factor.
+   */
+  dollyIn(e) {
+    this._dollyIn(e), this.update();
+  }
+  /**
+   * Programmatically dolly out (zoom out for perspective camera).
+   *
+   * @param {number} dollyScale - The dolly scale factor.
+   */
+  dollyOut(e) {
+    this._dollyOut(e), this.update();
+  }
+  /**
+   * Programmatically rotate the camera left (around the vertical axis).
+   *
+   * @param {number} angle - The rotation angle in radians.
+   */
+  rotateLeft(e) {
+    this._rotateLeft(e), this.update();
+  }
+  /**
+   * Programmatically rotate the camera up (around the horizontal axis).
+   *
+   * @param {number} angle - The rotation angle in radians.
+   */
+  rotateUp(e) {
+    this._rotateUp(e), this.update();
+  }
+  update(e = null) {
+    const t = this.object.position;
+    D.copy(t).sub(this.target), D.applyQuaternion(this._quat), this._spherical.setFromVector3(D), this.autoRotate && this.state === A.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 s = this.minAzimuthAngle, n = this.maxAzimuthAngle;
+    isFinite(s) && isFinite(n) && (s < -Math.PI ? s += G : s > Math.PI && (s -= G), n < -Math.PI ? n += G : n > Math.PI && (n -= G), s <= n ? this._spherical.theta = Math.max(s, Math.min(n, this._spherical.theta)) : this._spherical.theta = this._spherical.theta > (s + n) / 2 ? Math.max(s, this._spherical.theta) : Math.min(n, 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 (D.setFromSpherical(this._spherical), D.applyQuaternion(this._quatInverse), t.copy(this.target).add(D), 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 a = D.length();
+        o = this._clampDistance(a * this._scale);
+        const l = a - o;
+        this.object.position.addScaledVector(this._dollyDirection, l), this.object.updateMatrixWorld(), i = !!l;
+      } else if (this.object.isOrthographicCamera) {
+        const a = new E(this._mouse.x, this._mouse.y, 0);
+        a.unproject(this.object);
+        const l = this.object.zoom;
+        this.object.zoom = Math.max(this.minZoom, Math.min(this.maxZoom, this.object.zoom / this._scale)), this.object.updateProjectionMatrix(), i = l !== this.object.zoom;
+        const h = new E(this._mouse.x, this._mouse.y, 0);
+        h.unproject(this.object), this.object.position.sub(h).add(a), this.object.updateMatrixWorld(), o = D.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) : (Ve.origin.copy(this.object.position), Ve.direction.set(0, 0, -1).transformDirection(this.object.matrix), Math.abs(this.object.up.dot(Ve.direction)) < ds ? this.object.lookAt(this.target) : (Dt.setFromNormalAndCoplanarPoint(this.object.up, this.target), Ve.intersectPlane(Dt, 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) > rt || 8 * (1 - this._lastQuaternion.dot(this.object.quaternion)) > rt || this._lastTargetPosition.distanceToSquared(this.target) > rt ? (this.dispatchEvent(Ct), this._lastPosition.copy(this.object.position), this._lastQuaternion.copy(this.object.quaternion), this._lastTargetPosition.copy(this.target), !0) : !1;
+  }
+  _getAutoRotationAngle(e) {
+    return e !== null ? G / 60 * this.autoRotateSpeed * e : G / 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) {
+    D.setFromMatrixColumn(t, 0), D.multiplyScalar(-e), this._panOffset.add(D);
+  }
+  _panUp(e, t) {
+    this.screenSpacePanning === !0 ? D.setFromMatrixColumn(t, 1) : (D.setFromMatrixColumn(t, 0), D.crossVectors(this.object.up, D)), D.multiplyScalar(e), this._panOffset.add(D);
+  }
+  // deltaX and deltaY are in pixels; right and down are positive
+  _pan(e, t) {
+    const s = this.domElement;
+    if (this.object.isPerspectiveCamera) {
+      const n = this.object.position;
+      D.copy(n).sub(this.target);
+      let i = D.length();
+      i *= Math.tan(this.object.fov / 2 * Math.PI / 180), this._panLeft(2 * e * i / s.clientHeight, this.object.matrix), this._panUp(2 * t * i / s.clientHeight, this.object.matrix);
+    } else this.object.isOrthographicCamera ? (this._panLeft(e * (this.object.right - this.object.left) / this.object.zoom / s.clientWidth, this.object.matrix), this._panUp(t * (this.object.top - this.object.bottom) / this.object.zoom / s.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 s = this.domElement.getBoundingClientRect(), n = e - s.left, i = t - s.top, o = s.width, a = s.height;
+    this._mouse.x = n / o * 2 - 1, this._mouse.y = -(i / a) * 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(G * this._rotateDelta.x / t.clientHeight), this._rotateUp(G * 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(G * 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(-G * 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(G * 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(-G * 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), s = 0.5 * (e.pageX + t.x), n = 0.5 * (e.pageY + t.y);
+      this._rotateStart.set(s, n);
+    }
+  }
+  _handleTouchStartPan(e) {
+    if (this._pointers.length === 1)
+      this._panStart.set(e.pageX, e.pageY);
+    else {
+      const t = this._getSecondPointerPosition(e), s = 0.5 * (e.pageX + t.x), n = 0.5 * (e.pageY + t.y);
+      this._panStart.set(s, n);
+    }
+  }
+  _handleTouchStartDolly(e) {
+    const t = this._getSecondPointerPosition(e), s = e.pageX - t.x, n = e.pageY - t.y, i = Math.sqrt(s * s + n * n);
+    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 s = this._getSecondPointerPosition(e), n = 0.5 * (e.pageX + s.x), i = 0.5 * (e.pageY + s.y);
+      this._rotateEnd.set(n, i);
+    }
+    this._rotateDelta.subVectors(this._rotateEnd, this._rotateStart).multiplyScalar(this.rotateSpeed);
+    const t = this.domElement;
+    this._rotateLeft(G * this._rotateDelta.x / t.clientHeight), this._rotateUp(G * 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), s = 0.5 * (e.pageX + t.x), n = 0.5 * (e.pageY + t.y);
+      this._panEnd.set(s, n);
+    }
+    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), s = e.pageX - t.x, n = e.pageY - t.y, i = Math.sqrt(s * s + n * n);
+    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, a = (e.pageY + t.y) * 0.5;
+    this._updateZoomParameters(o, a);
+  }
+  _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 B(), 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, s = {
+      clientX: e.clientX,
+      clientY: e.clientY,
+      deltaY: e.deltaY
+    };
+    switch (t) {
+      case 1:
+        s.deltaY *= 16;
+        break;
+      case 2:
+        s.deltaY *= 100;
+        break;
+    }
+    return e.ctrlKey && !this._controlActive && (s.deltaY *= 10), s;
+  }
+}
+function fs(r) {
+  this.enabled !== !1 && (this._pointers.length === 0 && (this.domElement.setPointerCapture(r.pointerId), this.domElement.ownerDocument.addEventListener("pointermove", this._onPointerMove), this.domElement.ownerDocument.addEventListener("pointerup", this._onPointerUp)), !this._isTrackingPointer(r) && (this._addPointer(r), r.pointerType === "touch" ? this._onTouchStart(r) : this._onMouseDown(r), this._cursorStyle === "grab" && (this.domElement.style.cursor = "grabbing")));
+}
+function ms(r) {
+  this.enabled !== !1 && (r.pointerType === "touch" ? this._onTouchMove(r) : this._onMouseMove(r));
+}
+function gs(r) {
+  switch (this._removePointer(r), this._pointers.length) {
+    case 0:
+      this.domElement.releasePointerCapture(r.pointerId), this.domElement.ownerDocument.removeEventListener("pointermove", this._onPointerMove), this.domElement.ownerDocument.removeEventListener("pointerup", this._onPointerUp), this.dispatchEvent(dn), this.state = A.NONE, this._cursorStyle === "grab" && (this.domElement.style.cursor = "grab");
+      break;
+    case 1:
+      const e = this._pointers[0], t = this._pointerPositions[e];
+      this._onTouchStart({ pointerId: e, pageX: t.x, pageY: t.y });
+      break;
+  }
+}
+function ys(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 xe.DOLLY:
+      if (this.enableZoom === !1) return;
+      this._handleMouseDownDolly(r), this.state = A.DOLLY;
+      break;
+    case xe.ROTATE:
+      if (r.ctrlKey || r.metaKey || r.shiftKey) {
+        if (this.enablePan === !1) return;
+        this._handleMouseDownPan(r), this.state = A.PAN;
+      } else {
+        if (this.enableRotate === !1) return;
+        this._handleMouseDownRotate(r), this.state = A.ROTATE;
+      }
+      break;
+    case xe.PAN:
+      if (r.ctrlKey || r.metaKey || r.shiftKey) {
+        if (this.enableRotate === !1) return;
+        this._handleMouseDownRotate(r), this.state = A.ROTATE;
+      } else {
+        if (this.enablePan === !1) return;
+        this._handleMouseDownPan(r), this.state = A.PAN;
+      }
+      break;
+    default:
+      this.state = A.NONE;
+  }
+  this.state !== A.NONE && this.dispatchEvent(xt);
+}
+function _s(r) {
+  switch (this.state) {
+    case A.ROTATE:
+      if (this.enableRotate === !1) return;
+      this._handleMouseMoveRotate(r);
+      break;
+    case A.DOLLY:
+      if (this.enableZoom === !1) return;
+      this._handleMouseMoveDolly(r);
+      break;
+    case A.PAN:
+      if (this.enablePan === !1) return;
+      this._handleMouseMovePan(r);
+      break;
+  }
+}
+function bs(r) {
+  this.enabled === !1 || this.enableZoom === !1 || this.state !== A.NONE || (r.preventDefault(), this.dispatchEvent(xt), this._handleMouseWheel(this._customWheelEvent(r)), this.dispatchEvent(dn));
+}
+function ws(r) {
+  this.enabled !== !1 && this._handleKeyDown(r);
+}
+function Ts(r) {
+  switch (this._trackPointer(r), this._pointers.length) {
+    case 1:
+      switch (this.touches.ONE) {
+        case Te.ROTATE:
+          if (this.enableRotate === !1) return;
+          this._handleTouchStartRotate(r), this.state = A.TOUCH_ROTATE;
+          break;
+        case Te.PAN:
+          if (this.enablePan === !1) return;
+          this._handleTouchStartPan(r), this.state = A.TOUCH_PAN;
+          break;
+        default:
+          this.state = A.NONE;
+      }
+      break;
+    case 2:
+      switch (this.touches.TWO) {
+        case Te.DOLLY_PAN:
+          if (this.enableZoom === !1 && this.enablePan === !1) return;
+          this._handleTouchStartDollyPan(r), this.state = A.TOUCH_DOLLY_PAN;
+          break;
+        case Te.DOLLY_ROTATE:
+          if (this.enableZoom === !1 && this.enableRotate === !1) return;
+          this._handleTouchStartDollyRotate(r), this.state = A.TOUCH_DOLLY_ROTATE;
+          break;
+        default:
+          this.state = A.NONE;
+      }
+      break;
+    default:
+      this.state = A.NONE;
+  }
+  this.state !== A.NONE && this.dispatchEvent(xt);
+}
+function xs(r) {
+  switch (this._trackPointer(r), this.state) {
+    case A.TOUCH_ROTATE:
+      if (this.enableRotate === !1) return;
+      this._handleTouchMoveRotate(r), this.update();
+      break;
+    case A.TOUCH_PAN:
+      if (this.enablePan === !1) return;
+      this._handleTouchMovePan(r), this.update();
+      break;
+    case A.TOUCH_DOLLY_PAN:
+      if (this.enableZoom === !1 && this.enablePan === !1) return;
+      this._handleTouchMoveDollyPan(r), this.update();
+      break;
+    case A.TOUCH_DOLLY_ROTATE:
+      if (this.enableZoom === !1 && this.enableRotate === !1) return;
+      this._handleTouchMoveDollyRotate(r), this.update();
+      break;
+    default:
+      this.state = A.NONE;
+  }
+}
+function Es(r) {
+  this.enabled !== !1 && r.preventDefault();
+}
+function Ms(r) {
+  r.key === "Control" && (this._controlActive = !0, this.domElement.getRootNode().addEventListener("keyup", this._interceptControlUp, { passive: !0, capture: !0 }));
+}
+function Ss(r) {
+  r.key === "Control" && (this._controlActive = !1, this.domElement.getRootNode().removeEventListener("keyup", this._interceptControlUp, { passive: !0, capture: !0 }));
+}
+const fe = new On(), j = new E(), le = new E(), O = new X(), Nt = {
+  X: new E(1, 0, 0),
+  Y: new E(0, 1, 0),
+  Z: new E(0, 0, 1)
+}, at = { type: "change" }, kt = { type: "mouseDown", mode: null }, jt = { type: "mouseUp", mode: null }, Ht = { type: "objectChange" };
+class vs extends nn {
+  /**
+   * Constructs a new controls instance.
+   *
+   * @param {Camera} camera - The camera of the rendered scene.
+   * @param {?HTMLElement} domElement - The HTML element used for event listeners.
+   */
+  constructor(e, t = null) {
+    super(void 0, t);
+    const s = new Os(this);
+    this._root = s;
+    const n = new Cs();
+    this._gizmo = n, s.add(n);
+    const i = new Ds();
+    this._plane = i, s.add(i);
+    const o = this;
+    function a(M, S) {
+      let L = S;
+      Object.defineProperty(o, M, {
+        get: function() {
+          return L !== void 0 ? L : S;
+        },
+        set: function(v) {
+          L !== v && (L = v, i[M] = v, n[M] = v, o.dispatchEvent({ type: M + "-changed", value: v }), o.dispatchEvent(at));
+        }
+      }), o[M] = S, i[M] = S, n[M] = S;
+    }
+    a("camera", e), a("object", void 0), a("enabled", !0), a("axis", null), a("mode", "translate"), a("translationSnap", null), a("rotationSnap", null), a("scaleSnap", null), a("space", "world"), a("size", 1), a("dragging", !1), a("showX", !0), a("showY", !0), a("showZ", !0), a("showXY", !0), a("showYZ", !0), a("showXZ", !0), a("minX", -1 / 0), a("maxX", 1 / 0), a("minY", -1 / 0), a("maxY", 1 / 0), a("minZ", -1 / 0), a("maxZ", 1 / 0);
+    const l = new E(), h = new E(), u = new X(), c = new X(), d = new E(), p = new X(), f = new E(), m = new E(), y = new E(), _ = 0, x = new E();
+    a("worldPosition", l), a("worldPositionStart", h), a("worldQuaternion", u), a("worldQuaternionStart", c), a("cameraPosition", d), a("cameraQuaternion", p), a("pointStart", f), a("pointEnd", m), a("rotationAxis", y), a("rotationAngle", _), a("eye", x), this._offset = new E(), this._startNorm = new E(), this._endNorm = new E(), this._cameraScale = new E(), this._parentPosition = new E(), this._parentQuaternion = new X(), this._parentQuaternionInv = new X(), this._parentScale = new E(), this._worldScaleStart = new E(), this._worldQuaternionInv = new X(), this._worldScale = new E(), this._positionStart = new E(), this._quaternionStart = new X(), this._scaleStart = new E(), this._getPointer = Rs.bind(this), this._onPointerDown = Ps.bind(this), this._onPointerHover = As.bind(this), this._onPointerMove = Ls.bind(this), this._onPointerUp = Is.bind(this), t !== null && this.connect(t);
+  }
+  connect(e) {
+    super.connect(e), this.domElement.addEventListener("pointerdown", this._onPointerDown), this.domElement.addEventListener("pointermove", this._onPointerHover), this.domElement.addEventListener("pointerup", this._onPointerUp), this.domElement.style.touchAction = "none";
+  }
+  disconnect() {
+    this.domElement.removeEventListener("pointerdown", this._onPointerDown), this.domElement.removeEventListener("pointermove", this._onPointerHover), this.domElement.removeEventListener("pointermove", this._onPointerMove), this.domElement.removeEventListener("pointerup", this._onPointerUp), this.domElement.style.touchAction = "";
+  }
+  /**
+   * Returns the visual representation of the controls. Add the helper to your scene to
+   * visually transform the attached  3D object.
+   *
+   * @return {TransformControlsRoot} The helper.
+   */
+  getHelper() {
+    return this._root;
+  }
+  pointerHover(e) {
+    if (this.object === void 0 || this.dragging === !0) return;
+    e !== null && fe.setFromCamera(e, this.camera);
+    const t = lt(this._gizmo.picker[this.mode], fe);
+    t ? this.axis = t.object.name : this.axis = null;
+  }
+  pointerDown(e) {
+    if (!(this.object === void 0 || this.dragging === !0 || e != null && e.button !== 0) && this.axis !== null) {
+      e !== null && fe.setFromCamera(e, this.camera);
+      const t = lt(this._plane, fe, !0);
+      t && (this.object.updateMatrixWorld(), this.object.parent.updateMatrixWorld(), this._positionStart.copy(this.object.position), this._quaternionStart.copy(this.object.quaternion), this._scaleStart.copy(this.object.scale), this.object.matrixWorld.decompose(this.worldPositionStart, this.worldQuaternionStart, this._worldScaleStart), this.pointStart.copy(t.point).sub(this.worldPositionStart)), this.dragging = !0, kt.mode = this.mode, this.dispatchEvent(kt);
+    }
+  }
+  pointerMove(e) {
+    const t = this.axis, s = this.mode, n = this.object;
+    let i = this.space;
+    if (s === "scale" ? i = "local" : (t === "E" || t === "XYZE" || t === "XYZ") && (i = "world"), n === void 0 || t === null || this.dragging === !1 || e !== null && e.button !== -1) return;
+    e !== null && fe.setFromCamera(e, this.camera);
+    const o = lt(this._plane, fe, !0);
+    if (o) {
+      if (this.pointEnd.copy(o.point).sub(this.worldPositionStart), s === "translate")
+        this._offset.copy(this.pointEnd).sub(this.pointStart), i === "local" && t !== "XYZ" && this._offset.applyQuaternion(this._worldQuaternionInv), t.indexOf("X") === -1 && (this._offset.x = 0), t.indexOf("Y") === -1 && (this._offset.y = 0), t.indexOf("Z") === -1 && (this._offset.z = 0), i === "local" && t !== "XYZ" ? this._offset.applyQuaternion(this._quaternionStart).divide(this._parentScale) : this._offset.applyQuaternion(this._parentQuaternionInv).divide(this._parentScale), n.position.copy(this._offset).add(this._positionStart), this.translationSnap && (i === "local" && (n.position.applyQuaternion(O.copy(this._quaternionStart).invert()), t.search("X") !== -1 && (n.position.x = Math.round(n.position.x / this.translationSnap) * this.translationSnap), t.search("Y") !== -1 && (n.position.y = Math.round(n.position.y / this.translationSnap) * this.translationSnap), t.search("Z") !== -1 && (n.position.z = Math.round(n.position.z / this.translationSnap) * this.translationSnap), n.position.applyQuaternion(this._quaternionStart)), i === "world" && (n.parent && n.position.add(j.setFromMatrixPosition(n.parent.matrixWorld)), t.search("X") !== -1 && (n.position.x = Math.round(n.position.x / this.translationSnap) * this.translationSnap), t.search("Y") !== -1 && (n.position.y = Math.round(n.position.y / this.translationSnap) * this.translationSnap), t.search("Z") !== -1 && (n.position.z = Math.round(n.position.z / this.translationSnap) * this.translationSnap), n.parent && n.position.sub(j.setFromMatrixPosition(n.parent.matrixWorld)))), n.position.x = Math.max(this.minX, Math.min(this.maxX, n.position.x)), n.position.y = Math.max(this.minY, Math.min(this.maxY, n.position.y)), n.position.z = Math.max(this.minZ, Math.min(this.maxZ, n.position.z));
+      else if (s === "scale") {
+        if (t.search("XYZ") !== -1) {
+          let a = this.pointEnd.length() / this.pointStart.length();
+          this.pointEnd.dot(this.pointStart) < 0 && (a *= -1), le.set(a, a, a);
+        } else
+          j.copy(this.pointStart), le.copy(this.pointEnd), j.applyQuaternion(this._worldQuaternionInv), le.applyQuaternion(this._worldQuaternionInv), le.divide(j), t.search("X") === -1 && (le.x = 1), t.search("Y") === -1 && (le.y = 1), t.search("Z") === -1 && (le.z = 1);
+        n.scale.copy(this._scaleStart).multiply(le), this.scaleSnap && (t.search("X") !== -1 && (n.scale.x = Math.round(n.scale.x / this.scaleSnap) * this.scaleSnap || this.scaleSnap), t.search("Y") !== -1 && (n.scale.y = Math.round(n.scale.y / this.scaleSnap) * this.scaleSnap || this.scaleSnap), t.search("Z") !== -1 && (n.scale.z = Math.round(n.scale.z / this.scaleSnap) * this.scaleSnap || this.scaleSnap));
+      } else if (s === "rotate") {
+        this._offset.copy(this.pointEnd).sub(this.pointStart);
+        const a = 20 / this.worldPosition.distanceTo(j.setFromMatrixPosition(this.camera.matrixWorld));
+        let l = !1;
+        t === "XYZE" ? (this.rotationAxis.copy(this._offset).cross(this.eye).normalize(), this.rotationAngle = this._offset.dot(j.copy(this.rotationAxis).cross(this.eye)) * a) : (t === "X" || t === "Y" || t === "Z") && (this.rotationAxis.copy(Nt[t]), j.copy(Nt[t]), i === "local" && j.applyQuaternion(this.worldQuaternion), j.cross(this.eye), j.length() === 0 ? l = !0 : this.rotationAngle = this._offset.dot(j.normalize()) * a), (t === "E" || l) && (this.rotationAxis.copy(this.eye), this.rotationAngle = this.pointEnd.angleTo(this.pointStart), this._startNorm.copy(this.pointStart).normalize(), this._endNorm.copy(this.pointEnd).normalize(), this.rotationAngle *= this._endNorm.cross(this._startNorm).dot(this.eye) < 0 ? 1 : -1), this.rotationSnap && (this.rotationAngle = Math.round(this.rotationAngle / this.rotationSnap) * this.rotationSnap), i === "local" && t !== "E" && t !== "XYZE" ? (n.quaternion.copy(this._quaternionStart), n.quaternion.multiply(O.setFromAxisAngle(this.rotationAxis, this.rotationAngle)).normalize()) : (this.rotationAxis.applyQuaternion(this._parentQuaternionInv), n.quaternion.copy(O.setFromAxisAngle(this.rotationAxis, this.rotationAngle)), n.quaternion.multiply(this._quaternionStart).normalize());
+      }
+      this.dispatchEvent(at), this.dispatchEvent(Ht);
+    }
+  }
+  pointerUp(e) {
+    e !== null && e.button !== 0 || (this.dragging && this.axis !== null && (jt.mode = this.mode, this.dispatchEvent(jt)), this.dragging = !1, this.axis = null);
+  }
+  dispose() {
+    this.disconnect(), this._root.dispose();
+  }
+  /**
+   * Sets the 3D object that should be transformed and ensures the controls UI is visible.
+   *
+   * @param {Object3D} object -  The 3D object that should be transformed.
+   * @return {TransformControls} A reference to this controls.
+   */
+  attach(e) {
+    return this.object = e, this._root.visible = !0, this;
+  }
+  /**
+   * Removes the current 3D object from the controls and makes the helper UI invisible.
+   *
+   * @return {TransformControls} A reference to this controls.
+   */
+  detach() {
+    return this.object = void 0, this.axis = null, this._root.visible = !1, this;
+  }
+  /**
+   * Resets the object's position, rotation and scale to when the current transform began.
+   */
+  reset() {
+    this.enabled && this.dragging && (this.object.position.copy(this._positionStart), this.object.quaternion.copy(this._quaternionStart), this.object.scale.copy(this._scaleStart), this.dispatchEvent(at), this.dispatchEvent(Ht), this.pointStart.copy(this.pointEnd));
+  }
+  /**
+   * Returns the raycaster that is used for user interaction. This object is shared between all
+   * instances of `TransformControls`.
+   *
+   * @returns {Raycaster} The internal raycaster.
+   */
+  getRaycaster() {
+    return fe;
+  }
+  /**
+   * Returns the transformation mode.
+   *
+   * @returns {'translate'|'rotate'|'scale'} The transformation mode.
+   */
+  getMode() {
+    return this.mode;
+  }
+  /**
+   * Sets the given transformation mode.
+   *
+   * @param {'translate'|'rotate'|'scale'} mode - The transformation mode to set.
+   */
+  setMode(e) {
+    this.mode = e;
+  }
+  /**
+   * Sets the translation snap.
+   *
+   * @param {?number} translationSnap - The translation snap to set.
+   */
+  setTranslationSnap(e) {
+    this.translationSnap = e;
+  }
+  /**
+   * Sets the rotation snap.
+   *
+   * @param {?number} rotationSnap - The rotation snap to set.
+   */
+  setRotationSnap(e) {
+    this.rotationSnap = e;
+  }
+  /**
+   * Sets the scale snap.
+   *
+   * @param {?number} scaleSnap - The scale snap to set.
+   */
+  setScaleSnap(e) {
+    this.scaleSnap = e;
+  }
+  /**
+   * Sets the size of the helper UI.
+   *
+   * @param {number} size - The size to set.
+   */
+  setSize(e) {
+    this.size = e;
+  }
+  /**
+   * Sets the coordinate space in which transformations are applied.
+   *
+   * @param {'world'|'local'} space - The space to set.
+   */
+  setSpace(e) {
+    this.space = e;
+  }
+  /**
+   * Sets the colors of the control's gizmo.
+   *
+   * @param {number|Color|string} xAxis - The x-axis color.
+   * @param {number|Color|string} yAxis - The y-axis color.
+   * @param {number|Color|string} zAxis - The z-axis color.
+   * @param {number|Color|string} active - The color for active elements.
+   */
+  setColors(e, t, s, n) {
+    const i = this._gizmo.materialLib;
+    i.xAxis.color.set(e), i.yAxis.color.set(t), i.zAxis.color.set(s), i.active.color.set(n), i.xAxisTransparent.color.set(e), i.yAxisTransparent.color.set(t), i.zAxisTransparent.color.set(s), i.activeTransparent.color.set(n), i.xAxis._color && i.xAxis._color.set(e), i.yAxis._color && i.yAxis._color.set(t), i.zAxis._color && i.zAxis._color.set(s), i.active._color && i.active._color.set(n), i.xAxisTransparent._color && i.xAxisTransparent._color.set(e), i.yAxisTransparent._color && i.yAxisTransparent._color.set(t), i.zAxisTransparent._color && i.zAxisTransparent._color.set(s), i.activeTransparent._color && i.activeTransparent._color.set(n);
+  }
+}
+function Rs(r) {
+  if (this.domElement.ownerDocument.pointerLockElement)
+    return {
+      x: 0,
+      y: 0,
+      button: r.button
+    };
+  {
+    const e = this.domElement.getBoundingClientRect();
+    return {
+      x: (r.clientX - e.left) / e.width * 2 - 1,
+      y: -(r.clientY - e.top) / e.height * 2 + 1,
+      button: r.button
+    };
+  }
+}
+function As(r) {
+  if (this.enabled)
+    switch (r.pointerType) {
+      case "mouse":
+      case "pen":
+        this.pointerHover(this._getPointer(r));
+        break;
+    }
+}
+function Ps(r) {
+  this.enabled && (document.pointerLockElement || this.domElement.setPointerCapture(r.pointerId), this.domElement.addEventListener("pointermove", this._onPointerMove), this.pointerHover(this._getPointer(r)), this.pointerDown(this._getPointer(r)));
+}
+function Ls(r) {
+  this.enabled && this.pointerMove(this._getPointer(r));
+}
+function Is(r) {
+  this.enabled && (this.domElement.releasePointerCapture(r.pointerId), this.domElement.removeEventListener("pointermove", this._onPointerMove), this.pointerUp(this._getPointer(r)));
+}
+function lt(r, e, t) {
+  const s = e.intersectObject(r, !0);
+  for (let n = 0; n < s.length; n++)
+    if (s[n].object.visible || t)
+      return s[n];
+  return !1;
+}
+const Ze = new Dn(), P = new E(0, 1, 0), Ft = new E(0, 0, 0), Ut = new Me(), Qe = new X(), et = new X(), ee = new E(), zt = new Me(), Oe = new E(1, 0, 0), ge = new E(0, 1, 0), Ce = new E(0, 0, 1), qe = new E(), Ae = new E(), Pe = new E();
+class Os extends je {
+  constructor(e) {
+    super(), this.isTransformControlsRoot = !0, this.controls = e, this.visible = !1;
+  }
+  // updateMatrixWorld updates key transformation variables
+  updateMatrixWorld(e) {
+    const t = this.controls;
+    t.object !== void 0 && (t.object.updateMatrixWorld(), t.object.parent === null ? console.error("TransformControls: The attached 3D object must be a part of the scene graph.") : t.object.parent.matrixWorld.decompose(t._parentPosition, t._parentQuaternion, t._parentScale), t.object.matrixWorld.decompose(t.worldPosition, t.worldQuaternion, t._worldScale), t._parentQuaternionInv.copy(t._parentQuaternion).invert(), t._worldQuaternionInv.copy(t.worldQuaternion).invert()), t.camera.updateMatrixWorld(), t.camera.matrixWorld.decompose(t.cameraPosition, t.cameraQuaternion, t._cameraScale), t.camera.isOrthographicCamera ? t.camera.getWorldDirection(t.eye).negate() : t.eye.copy(t.cameraPosition).sub(t.worldPosition).normalize(), super.updateMatrixWorld(e);
+  }
+  dispose() {
+    this.traverse(function(e) {
+      e.geometry && e.geometry.dispose(), e.material && e.material.dispose();
+    });
+  }
+}
+class Cs extends je {
+  constructor() {
+    super(), this.isTransformControlsGizmo = !0, this.type = "TransformControlsGizmo";
+    const e = new ye({
+      depthTest: !1,
+      depthWrite: !1,
+      fog: !1,
+      toneMapped: !1,
+      transparent: !0
+    }), t = new De({
+      depthTest: !1,
+      depthWrite: !1,
+      fog: !1,
+      toneMapped: !1,
+      transparent: !0
+    }), s = e.clone();
+    s.opacity = 0.15;
+    const n = t.clone();
+    n.opacity = 0.5;
+    const i = e.clone();
+    i.color.setHex(16711680);
+    const o = e.clone();
+    o.color.setHex(65280);
+    const a = e.clone();
+    a.color.setHex(255);
+    const l = e.clone();
+    l.color.setHex(16711680), l.opacity = 0.5;
+    const h = e.clone();
+    h.color.setHex(65280), h.opacity = 0.5;
+    const u = e.clone();
+    u.color.setHex(255), u.opacity = 0.5;
+    const c = e.clone();
+    c.opacity = 0.25;
+    const d = e.clone();
+    d.color.setHex(16776960), d.opacity = 0.25;
+    const p = e.clone();
+    p.color.setHex(16776960);
+    const f = e.clone();
+    f.color.setHex(7895160), this.materialLib = {
+      xAxis: i,
+      yAxis: o,
+      zAxis: a,
+      active: p,
+      xAxisTransparent: l,
+      yAxisTransparent: h,
+      zAxisTransparent: u,
+      activeTransparent: d
+    };
+    const m = new z(0, 0.04, 0.1, 12);
+    m.translate(0, 0.05, 0);
+    const y = new F(0.08, 0.08, 0.08);
+    y.translate(0, 0.04, 0);
+    const _ = new He();
+    _.setAttribute("position", new he([0, 0, 0, 1, 0, 0], 3));
+    const x = new z(75e-4, 75e-4, 0.5, 3);
+    x.translate(0, 0.25, 0);
+    function M(V, ze) {
+      const $ = new Re(V, 75e-4, 3, 64, ze * Math.PI * 2);
+      return $.rotateY(Math.PI / 2), $.rotateX(Math.PI / 2), $;
+    }
+    function S() {
+      const V = new He();
+      return V.setAttribute("position", new he([0, 0, 0, 1, 1, 1], 3)), V;
+    }
+    const L = {
+      X: [
+        [new b(m, i), [0.5, 0, 0], [0, 0, -Math.PI / 2]],
+        [new b(m, i), [-0.5, 0, 0], [0, 0, Math.PI / 2]],
+        [new b(x, i), [0, 0, 0], [0, 0, -Math.PI / 2]]
+      ],
+      Y: [
+        [new b(m, o), [0, 0.5, 0]],
+        [new b(m, o), [0, -0.5, 0], [Math.PI, 0, 0]],
+        [new b(x, o)]
+      ],
+      Z: [
+        [new b(m, a), [0, 0, 0.5], [Math.PI / 2, 0, 0]],
+        [new b(m, a), [0, 0, -0.5], [-Math.PI / 2, 0, 0]],
+        [new b(x, a), null, [Math.PI / 2, 0, 0]]
+      ],
+      XYZ: [
+        [new b(new Ke(0.1, 0), c), [0, 0, 0]]
+      ],
+      XY: [
+        [new b(new F(0.15, 0.15, 0.01), u), [0.15, 0.15, 0]]
+      ],
+      YZ: [
+        [new b(new F(0.15, 0.15, 0.01), l), [0, 0.15, 0.15], [0, Math.PI / 2, 0]]
+      ],
+      XZ: [
+        [new b(new F(0.15, 0.15, 0.01), h), [0.15, 0, 0.15], [-Math.PI / 2, 0, 0]]
+      ]
+    }, v = {
+      X: [
+        [new b(new z(0.2, 0, 0.6, 4), s), [0.3, 0, 0], [0, 0, -Math.PI / 2]],
+        [new b(new z(0.2, 0, 0.6, 4), s), [-0.3, 0, 0], [0, 0, Math.PI / 2]]
+      ],
+      Y: [
+        [new b(new z(0.2, 0, 0.6, 4), s), [0, 0.3, 0]],
+        [new b(new z(0.2, 0, 0.6, 4), s), [0, -0.3, 0], [0, 0, Math.PI]]
+      ],
+      Z: [
+        [new b(new z(0.2, 0, 0.6, 4), s), [0, 0, 0.3], [Math.PI / 2, 0, 0]],
+        [new b(new z(0.2, 0, 0.6, 4), s), [0, 0, -0.3], [-Math.PI / 2, 0, 0]]
+      ],
+      XYZ: [
+        [new b(new Ke(0.2, 0), s)]
+      ],
+      XY: [
+        [new b(new F(0.2, 0.2, 0.01), s), [0.15, 0.15, 0]]
+      ],
+      YZ: [
+        [new b(new F(0.2, 0.2, 0.01), s), [0, 0.15, 0.15], [0, Math.PI / 2, 0]]
+      ],
+      XZ: [
+        [new b(new F(0.2, 0.2, 0.01), s), [0.15, 0, 0.15], [-Math.PI / 2, 0, 0]]
+      ]
+    }, I = {
+      START: [
+        [new b(new Ke(0.01, 2), n), null, null, null, "helper"]
+      ],
+      END: [
+        [new b(new Ke(0.01, 2), n), null, null, null, "helper"]
+      ],
+      DELTA: [
+        [new re(S(), n), null, null, null, "helper"]
+      ],
+      X: [
+        [new re(_, n), [-1e3, 0, 0], null, [1e6, 1, 1], "helper"]
+      ],
+      Y: [
+        [new re(_, n), [0, -1e3, 0], [0, 0, Math.PI / 2], [1e6, 1, 1], "helper"]
+      ],
+      Z: [
+        [new re(_, n), [0, 0, -1e3], [0, -Math.PI / 2, 0], [1e6, 1, 1], "helper"]
+      ]
+    }, se = {
+      XYZE: [
+        [new b(M(0.5, 1), f), null, [0, Math.PI / 2, 0]]
+      ],
+      X: [
+        [new b(M(0.5, 0.5), i)]
+      ],
+      Y: [
+        [new b(M(0.5, 0.5), o), null, [0, 0, -Math.PI / 2]]
+      ],
+      Z: [
+        [new b(M(0.5, 0.5), a), null, [0, Math.PI / 2, 0]]
+      ],
+      E: [
+        [new b(M(0.75, 1), d), null, [0, Math.PI / 2, 0]]
+      ]
+    }, J = {
+      AXIS: [
+        [new re(_, n), [-1e3, 0, 0], null, [1e6, 1, 1], "helper"]
+      ]
+    }, de = {
+      XYZE: [
+        [new b(new Cn(0.25, 10, 8), s)]
+      ],
+      X: [
+        [new b(new Re(0.5, 0.1, 4, 24), s), [0, 0, 0], [0, -Math.PI / 2, -Math.PI / 2]]
+      ],
+      Y: [
+        [new b(new Re(0.5, 0.1, 4, 24), s), [0, 0, 0], [Math.PI / 2, 0, 0]]
+      ],
+      Z: [
+        [new b(new Re(0.5, 0.1, 4, 24), s), [0, 0, 0], [0, 0, -Math.PI / 2]]
+      ],
+      E: [
+        [new b(new Re(0.75, 0.1, 2, 24), s)]
+      ]
+    }, W = {
+      X: [
+        [new b(y, i), [0.5, 0, 0], [0, 0, -Math.PI / 2]],
+        [new b(x, i), [0, 0, 0], [0, 0, -Math.PI / 2]],
+        [new b(y, i), [-0.5, 0, 0], [0, 0, Math.PI / 2]]
+      ],
+      Y: [
+        [new b(y, o), [0, 0.5, 0]],
+        [new b(x, o)],
+        [new b(y, o), [0, -0.5, 0], [0, 0, Math.PI]]
+      ],
+      Z: [
+        [new b(y, a), [0, 0, 0.5], [Math.PI / 2, 0, 0]],
+        [new b(x, a), [0, 0, 0], [Math.PI / 2, 0, 0]],
+        [new b(y, a), [0, 0, -0.5], [-Math.PI / 2, 0, 0]]
+      ],
+      XY: [
+        [new b(new F(0.15, 0.15, 0.01), u), [0.15, 0.15, 0]]
+      ],
+      YZ: [
+        [new b(new F(0.15, 0.15, 0.01), l), [0, 0.15, 0.15], [0, Math.PI / 2, 0]]
+      ],
+      XZ: [
+        [new b(new F(0.15, 0.15, 0.01), h), [0.15, 0, 0.15], [-Math.PI / 2, 0, 0]]
+      ],
+      XYZ: [
+        [new b(new F(0.1, 0.1, 0.1), c)]
+      ]
+    }, T = {
+      X: [
+        [new b(new z(0.2, 0, 0.6, 4), s), [0.3, 0, 0], [0, 0, -Math.PI / 2]],
+        [new b(new z(0.2, 0, 0.6, 4), s), [-0.3, 0, 0], [0, 0, Math.PI / 2]]
+      ],
+      Y: [
+        [new b(new z(0.2, 0, 0.6, 4), s), [0, 0.3, 0]],
+        [new b(new z(0.2, 0, 0.6, 4), s), [0, -0.3, 0], [0, 0, Math.PI]]
+      ],
+      Z: [
+        [new b(new z(0.2, 0, 0.6, 4), s), [0, 0, 0.3], [Math.PI / 2, 0, 0]],
+        [new b(new z(0.2, 0, 0.6, 4), s), [0, 0, -0.3], [-Math.PI / 2, 0, 0]]
+      ],
+      XY: [
+        [new b(new F(0.2, 0.2, 0.01), s), [0.15, 0.15, 0]]
+      ],
+      YZ: [
+        [new b(new F(0.2, 0.2, 0.01), s), [0, 0.15, 0.15], [0, Math.PI / 2, 0]]
+      ],
+      XZ: [
+        [new b(new F(0.2, 0.2, 0.01), s), [0.15, 0, 0.15], [-Math.PI / 2, 0, 0]]
+      ],
+      XYZ: [
+        [new b(new F(0.2, 0.2, 0.2), s), [0, 0, 0]]
+      ]
+    }, k = {
+      X: [
+        [new re(_, n), [-1e3, 0, 0], null, [1e6, 1, 1], "helper"]
+      ],
+      Y: [
+        [new re(_, n), [0, -1e3, 0], [0, 0, Math.PI / 2], [1e6, 1, 1], "helper"]
+      ],
+      Z: [
+        [new re(_, n), [0, 0, -1e3], [0, -Math.PI / 2, 0], [1e6, 1, 1], "helper"]
+      ]
+    };
+    function ie(V) {
+      const ze = new je();
+      for (const $ in V)
+        for (let we = V[$].length; we--; ) {
+          const U = V[$][we][0].clone(), Ge = V[$][we][1], Xe = V[$][we][2], Ye = V[$][we][3], _n = V[$][we][4];
+          U.name = $, U.tag = _n, Ge && U.position.set(Ge[0], Ge[1], Ge[2]), Xe && U.rotation.set(Xe[0], Xe[1], Xe[2]), Ye && U.scale.set(Ye[0], Ye[1], Ye[2]), U.updateMatrix();
+          const St = U.geometry.clone();
+          St.applyMatrix4(U.matrix), U.geometry = St, U.renderOrder = 1 / 0, U.position.set(0, 0, 0), U.rotation.set(0, 0, 0), U.scale.set(1, 1, 1), ze.add(U);
+        }
+      return ze;
+    }
+    this.gizmo = {}, this.picker = {}, this.helper = {}, this.add(this.gizmo.translate = ie(L)), this.add(this.gizmo.rotate = ie(se)), this.add(this.gizmo.scale = ie(W)), this.add(this.picker.translate = ie(v)), this.add(this.picker.rotate = ie(de)), this.add(this.picker.scale = ie(T)), this.add(this.helper.translate = ie(I)), this.add(this.helper.rotate = ie(J)), this.add(this.helper.scale = ie(k)), this.picker.translate.visible = !1, this.picker.rotate.visible = !1, this.picker.scale.visible = !1;
+  }
+  // updateMatrixWorld will update transformations and appearance of individual handles
+  updateMatrixWorld(e) {
+    const s = (this.mode === "scale" ? "local" : this.space) === "local" ? this.worldQuaternion : et;
+    this.gizmo.translate.visible = this.mode === "translate", this.gizmo.rotate.visible = this.mode === "rotate", this.gizmo.scale.visible = this.mode === "scale", this.helper.translate.visible = this.mode === "translate", this.helper.rotate.visible = this.mode === "rotate", this.helper.scale.visible = this.mode === "scale";
+    let n = [];
+    n = n.concat(this.picker[this.mode].children), n = n.concat(this.gizmo[this.mode].children), n = n.concat(this.helper[this.mode].children);
+    for (let i = 0; i < n.length; i++) {
+      const o = n[i];
+      o.visible = !0, o.rotation.set(0, 0, 0), o.position.copy(this.worldPosition);
+      let a;
+      if (this.camera.isOrthographicCamera ? a = (this.camera.top - this.camera.bottom) / this.camera.zoom : a = this.worldPosition.distanceTo(this.cameraPosition) * Math.min(1.9 * Math.tan(Math.PI * this.camera.fov / 360) / this.camera.zoom, 7), o.scale.set(1, 1, 1).multiplyScalar(a * this.size / 4), o.tag === "helper") {
+        o.visible = !1, o.name === "AXIS" ? (o.visible = !!this.axis, this.axis === "X" && (O.setFromEuler(Ze.set(0, 0, 0)), o.quaternion.copy(s).multiply(O), Math.abs(P.copy(Oe).applyQuaternion(s).dot(this.eye)) > 0.9 && (o.visible = !1)), this.axis === "Y" && (O.setFromEuler(Ze.set(0, 0, Math.PI / 2)), o.quaternion.copy(s).multiply(O), Math.abs(P.copy(ge).applyQuaternion(s).dot(this.eye)) > 0.9 && (o.visible = !1)), this.axis === "Z" && (O.setFromEuler(Ze.set(0, Math.PI / 2, 0)), o.quaternion.copy(s).multiply(O), Math.abs(P.copy(Ce).applyQuaternion(s).dot(this.eye)) > 0.9 && (o.visible = !1)), this.axis === "XYZE" && (O.setFromEuler(Ze.set(0, Math.PI / 2, 0)), P.copy(this.rotationAxis), o.quaternion.setFromRotationMatrix(Ut.lookAt(Ft, P, ge)), o.quaternion.multiply(O), o.visible = this.dragging), this.axis === "E" && (o.visible = !1)) : o.name === "START" ? (o.position.copy(this.worldPositionStart), o.visible = this.dragging) : o.name === "END" ? (o.position.copy(this.worldPosition), o.visible = this.dragging) : o.name === "DELTA" ? (o.position.copy(this.worldPositionStart), o.quaternion.copy(this.worldQuaternionStart), j.set(1e-10, 1e-10, 1e-10).add(this.worldPositionStart).sub(this.worldPosition).multiplyScalar(-1), j.applyQuaternion(this.worldQuaternionStart.clone().invert()), o.scale.copy(j), o.visible = this.dragging) : (o.quaternion.copy(s), this.dragging ? o.position.copy(this.worldPositionStart) : o.position.copy(this.worldPosition), this.axis && (o.visible = this.axis.search(o.name) !== -1));
+        continue;
+      }
+      o.quaternion.copy(s), this.mode === "translate" || this.mode === "scale" ? (o.name === "X" && Math.abs(P.copy(Oe).applyQuaternion(s).dot(this.eye)) > 0.99 && (o.scale.set(1e-10, 1e-10, 1e-10), o.visible = !1), o.name === "Y" && Math.abs(P.copy(ge).applyQuaternion(s).dot(this.eye)) > 0.99 && (o.scale.set(1e-10, 1e-10, 1e-10), o.visible = !1), o.name === "Z" && Math.abs(P.copy(Ce).applyQuaternion(s).dot(this.eye)) > 0.99 && (o.scale.set(1e-10, 1e-10, 1e-10), o.visible = !1), o.name === "XY" && Math.abs(P.copy(Ce).applyQuaternion(s).dot(this.eye)) < 0.2 && (o.scale.set(1e-10, 1e-10, 1e-10), o.visible = !1), o.name === "YZ" && Math.abs(P.copy(Oe).applyQuaternion(s).dot(this.eye)) < 0.2 && (o.scale.set(1e-10, 1e-10, 1e-10), o.visible = !1), o.name === "XZ" && Math.abs(P.copy(ge).applyQuaternion(s).dot(this.eye)) < 0.2 && (o.scale.set(1e-10, 1e-10, 1e-10), o.visible = !1)) : this.mode === "rotate" && (Qe.copy(s), P.copy(this.eye).applyQuaternion(O.copy(s).invert()), o.name.search("E") !== -1 && o.quaternion.setFromRotationMatrix(Ut.lookAt(this.eye, Ft, ge)), o.name === "X" && (O.setFromAxisAngle(Oe, Math.atan2(-P.y, P.z)), O.multiplyQuaternions(Qe, O), o.quaternion.copy(O)), o.name === "Y" && (O.setFromAxisAngle(ge, Math.atan2(P.x, P.z)), O.multiplyQuaternions(Qe, O), o.quaternion.copy(O)), o.name === "Z" && (O.setFromAxisAngle(Ce, Math.atan2(P.y, P.x)), O.multiplyQuaternions(Qe, O), o.quaternion.copy(O))), o.visible = o.visible && (o.name.indexOf("X") === -1 || this.showX), o.visible = o.visible && (o.name.indexOf("Y") === -1 || this.showY), o.visible = o.visible && (o.name.indexOf("Z") === -1 || this.showZ), o.visible = o.visible && (o.name.indexOf("E") === -1 || this.showX && this.showY && this.showZ), o.visible = o.visible && (o.name.indexOf("XY") === -1 || this.showXY), o.visible = o.visible && (o.name.indexOf("YZ") === -1 || this.showYZ), o.visible = o.visible && (o.name.indexOf("XZ") === -1 || this.showXZ), o.material._color = o.material._color || o.material.color.clone(), o.material._opacity = o.material._opacity || o.material.opacity, o.material.color.copy(o.material._color), o.material.opacity = o.material._opacity, this.enabled && this.axis && (o.name === this.axis ? (o.material.color.copy(this.materialLib.active.color), o.material.opacity = 1) : this.axis.split("").some(function(l) {
+        return o.name === l;
+      }) && (o.material.color.copy(this.materialLib.active.color), o.material.opacity = 1));
+    }
+    super.updateMatrixWorld(e);
+  }
+}
+class Ds extends b {
+  constructor() {
+    super(
+      new Nn(1e5, 1e5, 2, 2),
+      new ye({ visible: !1, wireframe: !0, side: on, transparent: !0, opacity: 0.1, toneMapped: !1 })
+    ), this.isTransformControlsPlane = !0, this.type = "TransformControlsPlane";
+  }
+  updateMatrixWorld(e) {
+    let t = this.space;
+    switch (this.position.copy(this.worldPosition), this.mode === "scale" && (t = "local"), qe.copy(Oe).applyQuaternion(t === "local" ? this.worldQuaternion : et), Ae.copy(ge).applyQuaternion(t === "local" ? this.worldQuaternion : et), Pe.copy(Ce).applyQuaternion(t === "local" ? this.worldQuaternion : et), P.copy(Ae), this.mode) {
+      case "translate":
+      case "scale":
+        switch (this.axis) {
+          case "X":
+            P.copy(this.eye).cross(qe), ee.copy(qe).cross(P);
+            break;
+          case "Y":
+            P.copy(this.eye).cross(Ae), ee.copy(Ae).cross(P);
+            break;
+          case "Z":
+            P.copy(this.eye).cross(Pe), ee.copy(Pe).cross(P);
+            break;
+          case "XY":
+            ee.copy(Pe);
+            break;
+          case "YZ":
+            ee.copy(qe);
+            break;
+          case "XZ":
+            P.copy(Pe), ee.copy(Ae);
+            break;
+          case "XYZ":
+          case "E":
+            ee.set(0, 0, 0);
+            break;
+        }
+        break;
+      case "rotate":
+      default:
+        ee.set(0, 0, 0);
+    }
+    ee.length() === 0 ? this.quaternion.copy(this.cameraQuaternion) : (zt.lookAt(j.set(0, 0, 0), ee, P), this.quaternion.setFromRotationMatrix(zt)), super.updateMatrixWorld(e);
+  }
+}
+const w = {
+  /** Three.js 场景 */
+  scene: null,
+  /** 透视相机 */
+  camera: null,
+  /** WebGL 渲染器 */
+  renderer: null,
+  /** 轨道控制器（用于场景浏览） */
+  orbitControls: null,
+  /** 变换控制器（用于平移/旋转/缩放物体） */
+  transformControls: null,
+  /** 编辑器挂载的 DOM 容器 */
+  container: null,
+  /** 网格辅助对象（地板） */
+  gridHelper: null,
+  /** 当前选中的物体 */
+  selectedObject: null
+};
+let ct = !1, ve = !1, _e = null, _t = null, tt = null, be = [];
+function Ns(r) {
+  w.container = r, ks(), js(), Hs(), Fs(), zs(), Us(), Qs(), Gs(), pn(), r.addEventListener("click", Ys), window.addEventListener("resize", Xs);
+}
+function ks() {
+  const r = new N.WebGLRenderer({ antialias: !0, alpha: !0 });
+  r.setSize(w.container.clientWidth, w.container.clientHeight), r.setPixelRatio(Math.min(window.devicePixelRatio, 2)), w.container.appendChild(r.domElement), w.renderer = r;
+}
+function js() {
+  w.scene = new N.Scene(), w.scene.name = "sl_scene";
+}
+function Hs() {
+  const r = new N.GridHelper(30, 30, 8956671, 3364232);
+  r.name = "地板", w.scene.add(r), w.gridHelper = r;
+}
+function Fs() {
+  const r = w.container, e = r.clientWidth / r.clientHeight, t = new N.PerspectiveCamera(45, e, 0.1, 1e3);
+  t.position.set(0, 6, 15), t.lookAt(0, 0, 0), w.camera = t;
+}
+function Us() {
+  const r = new ps(w.camera, w.renderer.domElement);
+  r.minDistance = 0, r.maxDistance = 1 / 0, r.addEventListener("start", () => {
+    ct = !1;
+  }), r.addEventListener("change", () => {
+    ct = !0;
+  }), r.addEventListener("end", () => {
+    ct && (ve = !0, setTimeout(() => {
+      ve = !1;
+    }, 200));
+  }), w.orbitControls = r;
+}
+function zs() {
+  const r = new vs(
+    w.camera,
+    w.renderer.domElement
+  );
+  r.addEventListener("dragging-changed", (e) => {
+    w.orbitControls.enabled = !e.value, e.value || (ve = !0, setTimeout(() => {
+      ve = !1;
+    }, 200));
+  }), r.addEventListener("objectChange", () => {
+    _t && w.selectedObject && _t(w.selectedObject);
+  }), w.scene.add(r.getHelper()), w.transformControls = r;
+}
+function Gs() {
+  const r = new N.AmbientLight(16777215, 2);
+  w.scene.add(r);
+  const e = new N.DirectionalLight(16777215, 3);
+  e.position.set(48, 104, 138), w.scene.add(e);
+  const t = new N.BoxGeometry(1, 1, 1), s = new N.MeshStandardMaterial({ color: 16777215 }), n = new N.Mesh(t, s);
+  n.position.y = 1, n.userData.isMovable = !0, n.name = "默认立方体", nt(n, !0);
+}
+function pn() {
+  var r, e;
+  requestAnimationFrame(pn), us.update(), (r = w.orbitControls) == null || r.update(), (e = w.renderer) == null || e.render(w.scene, w.camera);
+}
+function Xs() {
+  if (!w.container || !w.camera || !w.renderer) return;
+  const r = w.container.clientWidth, e = w.container.clientHeight;
+  r === 0 || e === 0 || (w.camera.aspect = r / e, w.camera.updateProjectionMatrix(), w.renderer.setSize(r, e));
+}
+function Et(r) {
+  w.selectedObject !== r && (w.selectedObject && w.transformControls.detach(), w.selectedObject = r, w.transformControls.attach(r), w.transformControls.setMode("translate"), w.transformControls.showX = !0, w.transformControls.showY = !0, w.transformControls.showZ = !0, _e == null || _e(r));
+}
+function fn() {
+  w.selectedObject && (w.transformControls.detach(), w.selectedObject = null, _e == null || _e(null));
+}
+function Ys(r) {
+  if (ve) {
+    ve = !1;
+    return;
+  }
+  const e = w.renderer.domElement.getBoundingClientRect(), t = new N.Vector2(
+    (r.clientX - e.left) / e.width * 2 - 1,
+    -((r.clientY - e.top) / e.height) * 2 + 1
+  ), s = new N.Raycaster();
+  s.setFromCamera(t, w.camera);
+  const n = [];
+  w.scene.traverse((o) => {
+    o.type === "Mesh" && o.userData.isMovable && n.push(o);
+  });
+  const i = s.intersectObjects(n);
+  i.length > 0 ? Et(i[0].object) : fn();
+}
+function nt(r, e = !1) {
+  w.scene.add(r), r.userData.isMovable && (Vs(r), Mt()), e && Et(r);
+}
+function Bs(r) {
+  w.selectedObject === r && fn(), r.parent ? r.parent.remove(r) : w.scene.remove(r), Zs(r), Mt();
+}
+function Ks(r) {
+  const e = w.scene.getObjectByProperty("uuid", r);
+  e && Bs(e);
+}
+function Vs(r) {
+  r.userData.isMovable && r.parent === w.scene && (be.includes(r) || be.push(r));
+}
+function Zs(r) {
+  const e = be.indexOf(r);
+  e !== -1 && be.splice(e, 1);
+}
+function Qs() {
+  const r = [];
+  w.scene.children.forEach((e) => {
+    e.userData.isMovable && r.push(e);
+  }), be = r, Mt();
+}
+function Mt() {
+  tt == null || tt([...be]);
+}
+function qs(r) {
+  _e = r;
+}
+function Ws(r) {
+  _t = r;
+}
+function $s(r) {
+  tt = r;
+}
+function Js() {
+  return be;
+}
+const ei = /^[og]\s*(.+)?/, ti = /^mtllib /, ni = /^usemtl /, si = /^usemap /, Gt = /\s+/, Xt = new E(), ht = new E(), Yt = new E(), Bt = new E(), Z = new E(), We = new ue();
+function ii() {
+  const r = {
+    objects: [],
+    object: {},
+    vertices: [],
+    normals: [],
+    colors: [],
+    uvs: [],
+    materials: {},
+    materialLibraries: [],
+    startObject: function(e, t) {
+      if (this.object && this.object.fromDeclaration === !1) {
+        this.object.name = e, this.object.fromDeclaration = t !== !1;
+        return;
+      }
+      const s = this.object && typeof this.object.currentMaterial == "function" ? this.object.currentMaterial() : void 0;
+      if (this.object && typeof this.object._finalize == "function" && this.object._finalize(!0), this.object = {
+        name: e || "",
+        fromDeclaration: t !== !1,
+        geometry: {
+          vertices: [],
+          normals: [],
+          colors: [],
+          uvs: [],
+          hasUVIndices: !1
+        },
+        materials: [],
+        smooth: !0,
+        startMaterial: function(n, i) {
+          const o = this._finalize(!1);
+          o && (o.inherited || o.groupCount <= 0) && this.materials.splice(o.index, 1);
+          const a = {
+            index: this.materials.length,
+            name: n || "",
+            mtllib: Array.isArray(i) && i.length > 0 ? i[i.length - 1] : "",
+            smooth: o !== void 0 ? o.smooth : this.smooth,
+            groupStart: o !== void 0 ? o.groupEnd : 0,
+            groupEnd: -1,
+            groupCount: -1,
+            inherited: !1,
+            clone: function(l) {
+              const h = {
+                index: typeof l == "number" ? l : this.index,
+                name: this.name,
+                mtllib: this.mtllib,
+                smooth: this.smooth,
+                groupStart: 0,
+                groupEnd: -1,
+                groupCount: -1,
+                inherited: !1
+              };
+              return h.clone = this.clone.bind(h), h;
+            }
+          };
+          return this.materials.push(a), a;
+        },
+        currentMaterial: function() {
+          if (this.materials.length > 0)
+            return this.materials[this.materials.length - 1];
+        },
+        _finalize: function(n) {
+          const i = this.currentMaterial();
+          if (i && i.groupEnd === -1 && (i.groupEnd = this.geometry.vertices.length / 3, i.groupCount = i.groupEnd - i.groupStart, i.inherited = !1), n && this.materials.length > 1)
+            for (let o = this.materials.length - 1; o >= 0; o--)
+              this.materials[o].groupCount <= 0 && this.materials.splice(o, 1);
+          return n && this.materials.length === 0 && this.materials.push({
+            name: "",
+            smooth: this.smooth
+          }), i;
+        }
+      }, s && s.name && typeof s.clone == "function") {
+        const n = s.clone(0);
+        n.inherited = !0, this.object.materials.push(n);
+      }
+      this.objects.push(this.object);
+    },
+    finalize: function() {
+      this.object && typeof this.object._finalize == "function" && this.object._finalize(!0);
+    },
+    parseVertexIndex: function(e, t) {
+      const s = parseInt(e, 10);
+      return (s >= 0 ? s - 1 : s + t / 3) * 3;
+    },
+    parseNormalIndex: function(e, t) {
+      const s = parseInt(e, 10);
+      return (s >= 0 ? s - 1 : s + t / 3) * 3;
+    },
+    parseUVIndex: function(e, t) {
+      const s = parseInt(e, 10);
+      return (s >= 0 ? s - 1 : s + t / 2) * 2;
+    },
+    addVertex: function(e, t, s) {
+      const n = this.vertices, i = this.object.geometry.vertices;
+      i.push(n[e + 0], n[e + 1], n[e + 2]), i.push(n[t + 0], n[t + 1], n[t + 2]), i.push(n[s + 0], n[s + 1], n[s + 2]);
+    },
+    addVertexPoint: function(e) {
+      const t = this.vertices;
+      this.object.geometry.vertices.push(t[e + 0], t[e + 1], t[e + 2]);
+    },
+    addVertexLine: function(e) {
+      const t = this.vertices;
+      this.object.geometry.vertices.push(t[e + 0], t[e + 1], t[e + 2]);
+    },
+    addNormal: function(e, t, s) {
+      const n = this.normals, i = this.object.geometry.normals;
+      i.push(n[e + 0], n[e + 1], n[e + 2]), i.push(n[t + 0], n[t + 1], n[t + 2]), i.push(n[s + 0], n[s + 1], n[s + 2]);
+    },
+    addFaceNormal: function(e, t, s) {
+      const n = this.vertices, i = this.object.geometry.normals;
+      Xt.fromArray(n, e), ht.fromArray(n, t), Yt.fromArray(n, s), Z.subVectors(Yt, ht), Bt.subVectors(Xt, ht), Z.cross(Bt), Z.normalize(), i.push(Z.x, Z.y, Z.z), i.push(Z.x, Z.y, Z.z), i.push(Z.x, Z.y, Z.z);
+    },
+    addColor: function(e, t, s) {
+      const n = this.colors, i = this.object.geometry.colors;
+      n[e] !== void 0 && i.push(n[e + 0], n[e + 1], n[e + 2]), n[t] !== void 0 && i.push(n[t + 0], n[t + 1], n[t + 2]), n[s] !== void 0 && i.push(n[s + 0], n[s + 1], n[s + 2]);
+    },
+    addUV: function(e, t, s) {
+      const n = this.uvs, i = this.object.geometry.uvs;
+      i.push(n[e + 0], n[e + 1]), i.push(n[t + 0], n[t + 1]), i.push(n[s + 0], n[s + 1]);
+    },
+    addDefaultUV: function() {
+      const e = this.object.geometry.uvs;
+      e.push(0, 0), e.push(0, 0), e.push(0, 0);
+    },
+    addUVLine: function(e) {
+      const t = this.uvs;
+      this.object.geometry.uvs.push(t[e + 0], t[e + 1]);
+    },
+    addFace: function(e, t, s, n, i, o, a, l, h) {
+      const u = this.vertices.length;
+      let c = this.parseVertexIndex(e, u), d = this.parseVertexIndex(t, u), p = this.parseVertexIndex(s, u);
+      if (this.addVertex(c, d, p), this.addColor(c, d, p), a !== void 0 && a !== "") {
+        const f = this.normals.length;
+        c = this.parseNormalIndex(a, f), d = this.parseNormalIndex(l, f), p = this.parseNormalIndex(h, f), this.addNormal(c, d, p);
+      } else
+        this.addFaceNormal(c, d, p);
+      if (n !== void 0 && n !== "") {
+        const f = this.uvs.length;
+        c = this.parseUVIndex(n, f), d = this.parseUVIndex(i, f), p = this.parseUVIndex(o, f), this.addUV(c, d, p), this.object.geometry.hasUVIndices = !0;
+      } else
+        this.addDefaultUV();
+    },
+    addPointGeometry: function(e) {
+      this.object.geometry.type = "Points";
+      const t = this.vertices.length;
+      for (let s = 0, n = e.length; s < n; s++) {
+        const i = this.parseVertexIndex(e[s], t);
+        this.addVertexPoint(i), this.addColor(i);
+      }
+    },
+    addLineGeometry: function(e, t) {
+      this.object.geometry.type = "Line";
+      const s = this.vertices.length, n = this.uvs.length;
+      for (let i = 0, o = e.length; i < o; i++)
+        this.addVertexLine(this.parseVertexIndex(e[i], s));
+      for (let i = 0, o = t.length; i < o; i++)
+        this.addUVLine(this.parseUVIndex(t[i], n));
+    }
+  };
+  return r.startObject("", !1), r;
+}
+class oi extends rn {
+  /**
+   * Constructs a new OBJ loader.
+   *
+   * @param {LoadingManager} [manager] - The loading manager.
+   */
+  constructor(e) {
+    super(e), this.materials = null;
+  }
+  /**
+   * Starts loading from the given URL and passes the loaded OBJ 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(Group)} 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, s, n) {
+    const i = this, o = new Tt(this.manager);
+    o.setPath(this.path), o.setRequestHeader(this.requestHeader), o.setWithCredentials(this.withCredentials), o.load(e, function(a) {
+      try {
+        t(i.parse(a));
+      } catch (l) {
+        n ? n(l) : console.error(l), i.manager.itemError(e);
+      }
+    }, s, n);
+  }
+  /**
+   * Sets the material creator for this OBJ. This object is loaded via {@link MTLLoader}.
+   *
+   * @param {MaterialCreator} materials - An object that creates the materials for this OBJ.
+   * @return {OBJLoader} A reference to this loader.
+   */
+  setMaterials(e) {
+    return this.materials = e, this;
+  }
+  /**
+   * Parses the given OBJ data and returns the resulting group.
+   *
+   * @param {string} text - The raw OBJ data as a string.
+   * @return {Group} The parsed OBJ.
+   */
+  parse(e) {
+    const t = new ii();
+    e.indexOf(`\r
+`) !== -1 && (e = e.replace(/\r\n/g, `
+`)), e.indexOf(`\\
+`) !== -1 && (e = e.replace(/\\\n/g, ""));
+    const s = e.split(`
+`);
+    let n = [];
+    for (let a = 0, l = s.length; a < l; a++) {
+      const h = s[a].trimStart();
+      if (h.length === 0) continue;
+      const u = h.charAt(0);
+      if (u !== "#")
+        if (u === "v") {
+          const c = h.split(Gt);
+          switch (c[0]) {
+            case "v":
+              t.vertices.push(
+                parseFloat(c[1]),
+                parseFloat(c[2]),
+                parseFloat(c[3])
+              ), c.length >= 7 ? (We.setRGB(
+                parseFloat(c[4]),
+                parseFloat(c[5]),
+                parseFloat(c[6]),
+                Se
+              ), t.colors.push(We.r, We.g, We.b)) : t.colors.push(void 0, void 0, void 0);
+              break;
+            case "vn":
+              t.normals.push(
+                parseFloat(c[1]),
+                parseFloat(c[2]),
+                parseFloat(c[3])
+              );
+              break;
+            case "vt":
+              t.uvs.push(
+                parseFloat(c[1]),
+                parseFloat(c[2])
+              );
+              break;
+          }
+        } else if (u === "f") {
+          const d = h.slice(1).trim().split(Gt), p = [];
+          for (let m = 0, y = d.length; m < y; m++) {
+            const _ = d[m];
+            if (_.length > 0) {
+              const x = _.split("/");
+              p.push(x);
+            }
+          }
+          const f = p[0];
+          for (let m = 1, y = p.length - 1; m < y; m++) {
+            const _ = p[m], x = p[m + 1];
+            t.addFace(
+              f[0],
+              _[0],
+              x[0],
+              f[1],
+              _[1],
+              x[1],
+              f[2],
+              _[2],
+              x[2]
+            );
+          }
+        } else if (u === "l") {
+          const c = h.substring(1).trim().split(" ");
+          let d = [];
+          const p = [];
+          if (h.indexOf("/") === -1)
+            d = c;
+          else
+            for (let f = 0, m = c.length; f < m; f++) {
+              const y = c[f].split("/");
+              y[0] !== "" && d.push(y[0]), y[1] !== "" && p.push(y[1]);
+            }
+          t.addLineGeometry(d, p);
+        } else if (u === "p") {
+          const d = h.slice(1).trim().split(" ");
+          t.addPointGeometry(d);
+        } else if ((n = ei.exec(h)) !== null) {
+          const c = (" " + n[0].slice(1).trim()).slice(1);
+          t.startObject(c);
+        } else if (ni.test(h))
+          t.object.startMaterial(h.substring(7).trim(), t.materialLibraries);
+        else if (ti.test(h))
+          t.materialLibraries.push(h.substring(7).trim());
+        else if (si.test(h))
+          console.warn('THREE.OBJLoader: Rendering identifier "usemap" not supported. Textures must be defined in MTL files.');
+        else if (u === "s") {
+          if (n = h.split(" "), n.length > 1) {
+            const d = n[1].trim().toLowerCase();
+            t.object.smooth = d !== "0" && d !== "off";
+          } else
+            t.object.smooth = !0;
+          const c = t.object.currentMaterial();
+          c && (c.smooth = t.object.smooth);
+        } else {
+          if (h === "\0") continue;
+          console.warn('THREE.OBJLoader: Unexpected line: "' + h + '"');
+        }
+    }
+    t.finalize();
+    const i = new $e();
+    if (i.materialLibraries = [].concat(t.materialLibraries), !(t.objects.length === 1 && t.objects[0].geometry.vertices.length === 0) === !0)
+      for (let a = 0, l = t.objects.length; a < l; a++) {
+        const h = t.objects[a], u = h.geometry, c = h.materials, d = u.type === "Line", p = u.type === "Points";
+        let f = !1;
+        if (u.vertices.length === 0) continue;
+        const m = new He();
+        m.setAttribute("position", new he(u.vertices, 3)), u.normals.length > 0 && m.setAttribute("normal", new he(u.normals, 3)), u.colors.length > 0 && (f = !0, m.setAttribute("color", new he(u.colors, 3))), u.hasUVIndices === !0 && m.setAttribute("uv", new he(u.uvs, 2));
+        const y = [];
+        for (let x = 0, M = c.length; x < M; x++) {
+          const S = c[x], L = S.name + "_" + S.smooth + "_" + f;
+          let v = t.materials[L];
+          if (this.materials !== null) {
+            if (v = this.materials.create(S.name), d && v && !(v instanceof De)) {
+              const I = new De();
+              Ne.prototype.copy.call(I, v), I.color.copy(v.color), v = I;
+            } else if (p && v && !(v instanceof Ie)) {
+              const I = new Ie({ size: 10, sizeAttenuation: !1 });
+              Ne.prototype.copy.call(I, v), I.color.copy(v.color), I.map = v.map, v = I;
+            }
+          }
+          v === void 0 && (d ? v = new De() : p ? v = new Ie({ size: 1, sizeAttenuation: !1 }) : v = new kn(), v.name = S.name, v.flatShading = !S.smooth, v.vertexColors = f, t.materials[L] = v), y.push(v);
+        }
+        let _;
+        if (y.length > 1) {
+          for (let x = 0, M = c.length; x < M; x++) {
+            const S = c[x];
+            m.addGroup(S.groupStart, S.groupCount, x);
+          }
+          d ? _ = new ft(m, y) : p ? _ = new Je(m, y) : _ = new b(m, y);
+        } else
+          d ? _ = new ft(m, y[0]) : p ? _ = new Je(m, y[0]) : _ = new b(m, y[0]);
+        _.name = h.name, i.add(_);
+      }
+    else if (t.vertices.length > 0) {
+      const a = new Ie({ size: 1, sizeAttenuation: !1 }), l = new He();
+      l.setAttribute("position", new he(t.vertices, 3)), t.colors.length > 0 && t.colors[0] !== void 0 && (l.setAttribute("color", new he(t.colors, 3)), a.vertexColors = !0);
+      const h = new Je(l, a);
+      i.add(h);
+    }
+    return i;
+  }
+}
+function Kt(r, e) {
+  if (e === jn)
+    return console.warn("THREE.BufferGeometryUtils.toTrianglesDrawMode(): Geometry already defined as triangles."), r;
+  if (e === mt || e === an) {
+    let t = r.getIndex();
+    if (t === null) {
+      const o = [], a = r.getAttribute("position");
+      if (a !== void 0) {
+        for (let l = 0; l < a.count; l++)
+          o.push(l);
+        r.setIndex(o), t = r.getIndex();
+      } else
+        return console.error("THREE.BufferGeometryUtils.toTrianglesDrawMode(): Undefined position attribute. Processing not possible."), r;
+    }
+    const s = t.count - 2, n = [];
+    if (e === mt)
+      for (let o = 1; o <= s; o++)
+        n.push(t.getX(0)), n.push(t.getX(o)), n.push(t.getX(o + 1));
+    else
+      for (let o = 0; o < s; o++)
+        o % 2 === 0 ? (n.push(t.getX(o)), n.push(t.getX(o + 1)), n.push(t.getX(o + 2))) : (n.push(t.getX(o + 2)), n.push(t.getX(o + 1)), n.push(t.getX(o)));
+    n.length / 3 !== s && console.error("THREE.BufferGeometryUtils.toTrianglesDrawMode(): Unable to generate correct amount of triangles.");
+    const i = r.clone();
+    return i.setIndex(n), i.clearGroups(), i;
+  } else
+    return console.error("THREE.BufferGeometryUtils.toTrianglesDrawMode(): Unknown draw mode:", e), r;
+}
+function ri(r) {
+  const e = /* @__PURE__ */ new Map(), t = /* @__PURE__ */ new Map(), s = r.clone();
+  return mn(r, s, function(n, i) {
+    e.set(i, n), t.set(n, i);
+  }), s.traverse(function(n) {
+    if (!n.isSkinnedMesh) return;
+    const i = n, o = e.get(n), a = o.skeleton.bones;
+    i.skeleton = o.skeleton.clone(), i.bindMatrix.copy(o.bindMatrix), i.skeleton.bones = a.map(function(l) {
+      return t.get(l);
+    }), i.bind(i.skeleton, i.bindMatrix);
+  }), s;
+}
+function mn(r, e, t) {
+  t(r, e);
+  for (let s = 0; s < r.children.length; s++)
+    mn(r.children[s], e.children[s], t);
+}
+class ai extends rn {
+  /**
+   * 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 di(t);
+    }), this.register(function(t) {
+      return new pi(t);
+    }), this.register(function(t) {
+      return new xi(t);
+    }), this.register(function(t) {
+      return new Ei(t);
+    }), this.register(function(t) {
+      return new Mi(t);
+    }), this.register(function(t) {
+      return new mi(t);
+    }), this.register(function(t) {
+      return new gi(t);
+    }), this.register(function(t) {
+      return new yi(t);
+    }), this.register(function(t) {
+      return new _i(t);
+    }), this.register(function(t) {
+      return new ui(t);
+    }), this.register(function(t) {
+      return new bi(t);
+    }), this.register(function(t) {
+      return new fi(t);
+    }), this.register(function(t) {
+      return new Ti(t);
+    }), this.register(function(t) {
+      return new wi(t);
+    }), this.register(function(t) {
+      return new ci(t);
+    }), this.register(function(t) {
+      return new Vt(t, R.EXT_MESHOPT_COMPRESSION);
+    }), this.register(function(t) {
+      return new Vt(t, R.KHR_MESHOPT_COMPRESSION);
+    }), this.register(function(t) {
+      return new Si(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, s, n) {
+    const i = this;
+    let o;
+    if (this.resourcePath !== "")
+      o = this.resourcePath;
+    else if (this.path !== "") {
+      const h = ke.extractUrlBase(e);
+      o = ke.resolveURL(h, this.path);
+    } else
+      o = ke.extractUrlBase(e);
+    this.manager.itemStart(e);
+    const a = function(h) {
+      n ? n(h) : console.error(h), i.manager.itemError(e), i.manager.itemEnd(e);
+    }, l = new Tt(this.manager);
+    l.setPath(this.path), l.setResponseType("arraybuffer"), l.setRequestHeader(this.requestHeader), l.setWithCredentials(this.withCredentials), l.load(e, function(h) {
+      try {
+        i.parse(h, o, function(u) {
+          t(u), i.manager.itemEnd(e);
+        }, a);
+      } catch (u) {
+        a(u);
+      }
+    }, s, a);
+  }
+  /**
+   * 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 glTF 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, s, n) {
+    let i;
+    const o = {}, a = {}, l = new TextDecoder();
+    if (typeof e == "string")
+      i = JSON.parse(e);
+    else if (e instanceof ArrayBuffer)
+      if (l.decode(new Uint8Array(e, 0, 4)) === gn) {
+        try {
+          o[R.KHR_BINARY_GLTF] = new vi(e);
+        } catch (c) {
+          n && n(c);
+          return;
+        }
+        i = JSON.parse(o[R.KHR_BINARY_GLTF].content);
+      } else
+        i = JSON.parse(l.decode(e));
+    else
+      i = e;
+    if (i.asset === void 0 || i.asset.version[0] < 2) {
+      n && n(new Error("THREE.GLTFLoader: Unsupported asset. glTF versions >=2.0 are supported."));
+      return;
+    }
+    const h = new Fi(i, {
+      path: t || this.resourcePath || "",
+      crossOrigin: this.crossOrigin,
+      requestHeader: this.requestHeader,
+      manager: this.manager,
+      ktx2Loader: this.ktx2Loader,
+      meshoptDecoder: this.meshoptDecoder
+    });
+    h.fileLoader.setRequestHeader(this.requestHeader);
+    for (let u = 0; u < this.pluginCallbacks.length; u++) {
+      const c = this.pluginCallbacks[u](h);
+      c.name || console.error("THREE.GLTFLoader: Invalid plugin found: missing name"), a[c.name] = c, o[c.name] = !0;
+    }
+    if (i.extensionsUsed)
+      for (let u = 0; u < i.extensionsUsed.length; ++u) {
+        const c = i.extensionsUsed[u], d = i.extensionsRequired || [];
+        switch (c) {
+          case R.KHR_MATERIALS_UNLIT:
+            o[c] = new hi();
+            break;
+          case R.KHR_DRACO_MESH_COMPRESSION:
+            o[c] = new Ri(i, this.dracoLoader);
+            break;
+          case R.KHR_TEXTURE_TRANSFORM:
+            o[c] = new Ai();
+            break;
+          case R.KHR_MESH_QUANTIZATION:
+            o[c] = new Pi();
+            break;
+          default:
+            d.indexOf(c) >= 0 && a[c] === void 0 && console.warn('THREE.GLTFLoader: Unknown extension "' + c + '".');
+        }
+      }
+    h.setExtensions(o), h.setPlugins(a), h.parse(s, n);
+  }
+  /**
+   * 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 s = this;
+    return new Promise(function(n, i) {
+      s.parse(e, t, n, i);
+    });
+  }
+}
+function li() {
+  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 = {};
+    }
+  };
+}
+function C(r, e, t) {
+  const s = r.json.materials[e];
+  return s.extensions && s.extensions[t] ? s.extensions[t] : null;
+}
+const R = {
+  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",
+  KHR_MESHOPT_COMPRESSION: "KHR_meshopt_compression",
+  EXT_MESH_GPU_INSTANCING: "EXT_mesh_gpu_instancing"
+};
+class ci {
+  constructor(e) {
+    this.parser = e, this.name = R.KHR_LIGHTS_PUNCTUAL, this.cache = { refs: {}, uses: {} };
+  }
+  _markDefs() {
+    const e = this.parser, t = this.parser.json.nodes || [];
+    for (let s = 0, n = t.length; s < n; s++) {
+      const i = t[s];
+      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, s = "light:" + e;
+    let n = t.cache.get(s);
+    if (n) return n;
+    const i = t.json, l = ((i.extensions && i.extensions[this.name] || {}).lights || [])[e];
+    let h;
+    const u = new ue(16777215);
+    l.color !== void 0 && u.setRGB(l.color[0], l.color[1], l.color[2], ae);
+    const c = l.range !== void 0 ? l.range : 0;
+    switch (l.type) {
+      case "directional":
+        h = new Un(u), h.target.position.set(0, 0, -1), h.add(h.target);
+        break;
+      case "point":
+        h = new Fn(u), h.distance = c;
+        break;
+      case "spot":
+        h = new Hn(u), h.distance = c, l.spot = l.spot || {}, l.spot.innerConeAngle = l.spot.innerConeAngle !== void 0 ? l.spot.innerConeAngle : 0, l.spot.outerConeAngle = l.spot.outerConeAngle !== void 0 ? l.spot.outerConeAngle : Math.PI / 4, h.angle = l.spot.outerConeAngle, h.penumbra = 1 - l.spot.innerConeAngle / l.spot.outerConeAngle, h.target.position.set(0, 0, -1), h.add(h.target);
+        break;
+      default:
+        throw new Error("THREE.GLTFLoader: Unexpected light type: " + l.type);
+    }
+    return h.position.set(0, 0, 0), te(h, l), l.intensity !== void 0 && (h.intensity = l.intensity), h.name = t.createUniqueName(l.name || "light_" + e), n = Promise.resolve(h), t.cache.add(s, n), n;
+  }
+  getDependency(e, t) {
+    if (e === "light")
+      return this._loadLight(t);
+  }
+  createNodeAttachment(e) {
+    const t = this, s = this.parser, i = s.json.nodes[e], a = (i.extensions && i.extensions[this.name] || {}).light;
+    return a === void 0 ? null : this._loadLight(a).then(function(l) {
+      return s._getNodeRef(t.cache, a, l);
+    });
+  }
+}
+class hi {
+  constructor() {
+    this.name = R.KHR_MATERIALS_UNLIT;
+  }
+  getMaterialType() {
+    return ye;
+  }
+  extendParams(e, t, s) {
+    const n = [];
+    e.color = new ue(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], ae), e.opacity = o[3];
+      }
+      i.baseColorTexture !== void 0 && n.push(s.assignTexture(e, "map", i.baseColorTexture, Se));
+    }
+    return Promise.all(n);
+  }
+}
+class ui {
+  constructor(e) {
+    this.parser = e, this.name = R.KHR_MATERIALS_EMISSIVE_STRENGTH;
+  }
+  extendMaterialParams(e, t) {
+    const s = C(this.parser, e, this.name);
+    return s === null || s.emissiveStrength !== void 0 && (t.emissiveIntensity = s.emissiveStrength), Promise.resolve();
+  }
+}
+class di {
+  constructor(e) {
+    this.parser = e, this.name = R.KHR_MATERIALS_CLEARCOAT;
+  }
+  getMaterialType(e) {
+    return C(this.parser, e, this.name) !== null ? ne : null;
+  }
+  extendMaterialParams(e, t) {
+    const s = C(this.parser, e, this.name);
+    if (s === null) return Promise.resolve();
+    const n = [];
+    if (s.clearcoatFactor !== void 0 && (t.clearcoat = s.clearcoatFactor), s.clearcoatTexture !== void 0 && n.push(this.parser.assignTexture(t, "clearcoatMap", s.clearcoatTexture)), s.clearcoatRoughnessFactor !== void 0 && (t.clearcoatRoughness = s.clearcoatRoughnessFactor), s.clearcoatRoughnessTexture !== void 0 && n.push(this.parser.assignTexture(t, "clearcoatRoughnessMap", s.clearcoatRoughnessTexture)), s.clearcoatNormalTexture !== void 0 && (n.push(this.parser.assignTexture(t, "clearcoatNormalMap", s.clearcoatNormalTexture)), s.clearcoatNormalTexture.scale !== void 0)) {
+      const i = s.clearcoatNormalTexture.scale;
+      t.clearcoatNormalScale = new B(i, i);
+    }
+    return Promise.all(n);
+  }
+}
+class pi {
+  constructor(e) {
+    this.parser = e, this.name = R.KHR_MATERIALS_DISPERSION;
+  }
+  getMaterialType(e) {
+    return C(this.parser, e, this.name) !== null ? ne : null;
+  }
+  extendMaterialParams(e, t) {
+    const s = C(this.parser, e, this.name);
+    return s === null || (t.dispersion = s.dispersion !== void 0 ? s.dispersion : 0), Promise.resolve();
+  }
+}
+class fi {
+  constructor(e) {
+    this.parser = e, this.name = R.KHR_MATERIALS_IRIDESCENCE;
+  }
+  getMaterialType(e) {
+    return C(this.parser, e, this.name) !== null ? ne : null;
+  }
+  extendMaterialParams(e, t) {
+    const s = C(this.parser, e, this.name);
+    if (s === null) return Promise.resolve();
+    const n = [];
+    return s.iridescenceFactor !== void 0 && (t.iridescence = s.iridescenceFactor), s.iridescenceTexture !== void 0 && n.push(this.parser.assignTexture(t, "iridescenceMap", s.iridescenceTexture)), s.iridescenceIor !== void 0 && (t.iridescenceIOR = s.iridescenceIor), t.iridescenceThicknessRange === void 0 && (t.iridescenceThicknessRange = [100, 400]), s.iridescenceThicknessMinimum !== void 0 && (t.iridescenceThicknessRange[0] = s.iridescenceThicknessMinimum), s.iridescenceThicknessMaximum !== void 0 && (t.iridescenceThicknessRange[1] = s.iridescenceThicknessMaximum), s.iridescenceThicknessTexture !== void 0 && n.push(this.parser.assignTexture(t, "iridescenceThicknessMap", s.iridescenceThicknessTexture)), Promise.all(n);
+  }
+}
+class mi {
+  constructor(e) {
+    this.parser = e, this.name = R.KHR_MATERIALS_SHEEN;
+  }
+  getMaterialType(e) {
+    return C(this.parser, e, this.name) !== null ? ne : null;
+  }
+  extendMaterialParams(e, t) {
+    const s = C(this.parser, e, this.name);
+    if (s === null) return Promise.resolve();
+    const n = [];
+    if (t.sheenColor = new ue(0, 0, 0), t.sheenRoughness = 0, t.sheen = 1, s.sheenColorFactor !== void 0) {
+      const i = s.sheenColorFactor;
+      t.sheenColor.setRGB(i[0], i[1], i[2], ae);
+    }
+    return s.sheenRoughnessFactor !== void 0 && (t.sheenRoughness = s.sheenRoughnessFactor), s.sheenColorTexture !== void 0 && n.push(this.parser.assignTexture(t, "sheenColorMap", s.sheenColorTexture, Se)), s.sheenRoughnessTexture !== void 0 && n.push(this.parser.assignTexture(t, "sheenRoughnessMap", s.sheenRoughnessTexture)), Promise.all(n);
+  }
+}
+class gi {
+  constructor(e) {
+    this.parser = e, this.name = R.KHR_MATERIALS_TRANSMISSION;
+  }
+  getMaterialType(e) {
+    return C(this.parser, e, this.name) !== null ? ne : null;
+  }
+  extendMaterialParams(e, t) {
+    const s = C(this.parser, e, this.name);
+    if (s === null) return Promise.resolve();
+    const n = [];
+    return s.transmissionFactor !== void 0 && (t.transmission = s.transmissionFactor), s.transmissionTexture !== void 0 && n.push(this.parser.assignTexture(t, "transmissionMap", s.transmissionTexture)), Promise.all(n);
+  }
+}
+class yi {
+  constructor(e) {
+    this.parser = e, this.name = R.KHR_MATERIALS_VOLUME;
+  }
+  getMaterialType(e) {
+    return C(this.parser, e, this.name) !== null ? ne : null;
+  }
+  extendMaterialParams(e, t) {
+    const s = C(this.parser, e, this.name);
+    if (s === null) return Promise.resolve();
+    const n = [];
+    t.thickness = s.thicknessFactor !== void 0 ? s.thicknessFactor : 0, s.thicknessTexture !== void 0 && n.push(this.parser.assignTexture(t, "thicknessMap", s.thicknessTexture)), t.attenuationDistance = s.attenuationDistance || 1 / 0;
+    const i = s.attenuationColor || [1, 1, 1];
+    return t.attenuationColor = new ue().setRGB(i[0], i[1], i[2], ae), Promise.all(n);
+  }
+}
+class _i {
+  constructor(e) {
+    this.parser = e, this.name = R.KHR_MATERIALS_IOR;
+  }
+  getMaterialType(e) {
+    return C(this.parser, e, this.name) !== null ? ne : null;
+  }
+  extendMaterialParams(e, t) {
+    const s = C(this.parser, e, this.name);
+    return s === null || (t.ior = s.ior !== void 0 ? s.ior : 1.5, t.ior === 0 && (t.ior = 1e3)), Promise.resolve();
+  }
+}
+class bi {
+  constructor(e) {
+    this.parser = e, this.name = R.KHR_MATERIALS_SPECULAR;
+  }
+  getMaterialType(e) {
+    return C(this.parser, e, this.name) !== null ? ne : null;
+  }
+  extendMaterialParams(e, t) {
+    const s = C(this.parser, e, this.name);
+    if (s === null) return Promise.resolve();
+    const n = [];
+    t.specularIntensity = s.specularFactor !== void 0 ? s.specularFactor : 1, s.specularTexture !== void 0 && n.push(this.parser.assignTexture(t, "specularIntensityMap", s.specularTexture));
+    const i = s.specularColorFactor || [1, 1, 1];
+    return t.specularColor = new ue().setRGB(i[0], i[1], i[2], ae), s.specularColorTexture !== void 0 && n.push(this.parser.assignTexture(t, "specularColorMap", s.specularColorTexture, Se)), Promise.all(n);
+  }
+}
+class wi {
+  constructor(e) {
+    this.parser = e, this.name = R.EXT_MATERIALS_BUMP;
+  }
+  getMaterialType(e) {
+    return C(this.parser, e, this.name) !== null ? ne : null;
+  }
+  extendMaterialParams(e, t) {
+    const s = C(this.parser, e, this.name);
+    if (s === null) return Promise.resolve();
+    const n = [];
+    return t.bumpScale = s.bumpFactor !== void 0 ? s.bumpFactor : 1, s.bumpTexture !== void 0 && n.push(this.parser.assignTexture(t, "bumpMap", s.bumpTexture)), Promise.all(n);
+  }
+}
+class Ti {
+  constructor(e) {
+    this.parser = e, this.name = R.KHR_MATERIALS_ANISOTROPY;
+  }
+  getMaterialType(e) {
+    return C(this.parser, e, this.name) !== null ? ne : null;
+  }
+  extendMaterialParams(e, t) {
+    const s = C(this.parser, e, this.name);
+    if (s === null) return Promise.resolve();
+    const n = [];
+    return s.anisotropyStrength !== void 0 && (t.anisotropy = s.anisotropyStrength), s.anisotropyRotation !== void 0 && (t.anisotropyRotation = s.anisotropyRotation), s.anisotropyTexture !== void 0 && n.push(this.parser.assignTexture(t, "anisotropyMap", s.anisotropyTexture)), Promise.all(n);
+  }
+}
+class xi {
+  constructor(e) {
+    this.parser = e, this.name = R.KHR_TEXTURE_BASISU;
+  }
+  loadTexture(e) {
+    const t = this.parser, s = t.json, n = s.textures[e];
+    if (!n.extensions || !n.extensions[this.name])
+      return null;
+    const i = n.extensions[this.name], o = t.options.ktx2Loader;
+    if (!o) {
+      if (s.extensionsRequired && s.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 Ei {
+  constructor(e) {
+    this.parser = e, this.name = R.EXT_TEXTURE_WEBP;
+  }
+  loadTexture(e) {
+    const t = this.name, s = this.parser, n = s.json, i = n.textures[e];
+    if (!i.extensions || !i.extensions[t])
+      return null;
+    const o = i.extensions[t], a = n.images[o.source];
+    let l = s.textureLoader;
+    if (a.uri) {
+      const h = s.options.manager.getHandler(a.uri);
+      h !== null && (l = h);
+    }
+    return s.loadTextureImage(e, o.source, l);
+  }
+}
+class Mi {
+  constructor(e) {
+    this.parser = e, this.name = R.EXT_TEXTURE_AVIF;
+  }
+  loadTexture(e) {
+    const t = this.name, s = this.parser, n = s.json, i = n.textures[e];
+    if (!i.extensions || !i.extensions[t])
+      return null;
+    const o = i.extensions[t], a = n.images[o.source];
+    let l = s.textureLoader;
+    if (a.uri) {
+      const h = s.options.manager.getHandler(a.uri);
+      h !== null && (l = h);
+    }
+    return s.loadTextureImage(e, o.source, l);
+  }
+}
+class Vt {
+  constructor(e, t) {
+    this.name = t, this.parser = e;
+  }
+  loadBufferView(e) {
+    const t = this.parser.json, s = t.bufferViews[e];
+    if (s.extensions && s.extensions[this.name]) {
+      const n = s.extensions[this.name], i = this.parser.getDependency("buffer", n.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(a) {
+        const l = n.byteOffset || 0, h = n.byteLength || 0, u = n.count, c = n.byteStride, d = new Uint8Array(a, l, h);
+        return o.decodeGltfBufferAsync ? o.decodeGltfBufferAsync(u, c, d, n.mode, n.filter).then(function(p) {
+          return p.buffer;
+        }) : o.ready.then(function() {
+          const p = new ArrayBuffer(u * c);
+          return o.decodeGltfBuffer(new Uint8Array(p), u, c, d, n.mode, n.filter), p;
+        });
+      });
+    } else
+      return null;
+  }
+}
+class Si {
+  constructor(e) {
+    this.name = R.EXT_MESH_GPU_INSTANCING, this.parser = e;
+  }
+  createNodeMesh(e) {
+    const t = this.parser.json, s = t.nodes[e];
+    if (!s.extensions || !s.extensions[this.name] || s.mesh === void 0)
+      return null;
+    const n = t.meshes[s.mesh];
+    for (const h of n.primitives)
+      if (h.mode !== Q.TRIANGLES && h.mode !== Q.TRIANGLE_STRIP && h.mode !== Q.TRIANGLE_FAN && h.mode !== void 0)
+        return null;
+    const o = s.extensions[this.name].attributes, a = [], l = {};
+    for (const h in o)
+      a.push(this.parser.getDependency("accessor", o[h]).then((u) => (l[h] = u, l[h])));
+    return a.length < 1 ? null : (a.push(this.parser.createNodeMesh(e)), Promise.all(a).then((h) => {
+      const u = h.pop(), c = u.isGroup ? u.children : [u], d = h[0].count, p = [];
+      for (const f of c) {
+        const m = new Me(), y = new E(), _ = new X(), x = new E(1, 1, 1), M = new zn(f.geometry, f.material, d);
+        for (let S = 0; S < d; S++)
+          l.TRANSLATION && y.fromBufferAttribute(l.TRANSLATION, S), l.ROTATION && _.fromBufferAttribute(l.ROTATION, S), l.SCALE && x.fromBufferAttribute(l.SCALE, S), M.setMatrixAt(S, m.compose(y, _, x));
+        for (const S in l)
+          if (S === "_COLOR_0") {
+            const L = l[S];
+            M.instanceColor = new Gn(L.array, L.itemSize, L.normalized);
+          } else S !== "TRANSLATION" && S !== "ROTATION" && S !== "SCALE" && f.geometry.setAttribute(S, l[S]);
+        je.prototype.copy.call(M, f), this.parser.assignFinalMaterial(M), p.push(M);
+      }
+      return u.isGroup ? (u.clear(), u.add(...p), u) : p[0];
+    }));
+  }
+}
+const gn = "glTF", Le = 12, Zt = { JSON: 1313821514, BIN: 5130562 };
+class vi {
+  constructor(e) {
+    this.name = R.KHR_BINARY_GLTF, this.content = null, this.body = null;
+    const t = new DataView(e, 0, Le), s = new TextDecoder();
+    if (this.header = {
+      magic: s.decode(new Uint8Array(e.slice(0, 4))),
+      version: t.getUint32(4, !0),
+      length: t.getUint32(8, !0)
+    }, this.header.magic !== gn)
+      throw new Error("THREE.GLTFLoader: Unsupported glTF-Binary header.");
+    if (this.header.version < 2)
+      throw new Error("THREE.GLTFLoader: Legacy binary file detected.");
+    const n = this.header.length - Le, i = new DataView(e, Le);
+    let o = 0;
+    for (; o < n; ) {
+      const a = i.getUint32(o, !0);
+      o += 4;
+      const l = i.getUint32(o, !0);
+      if (o += 4, l === Zt.JSON) {
+        const h = new Uint8Array(e, Le + o, a);
+        this.content = s.decode(h);
+      } else if (l === Zt.BIN) {
+        const h = Le + o;
+        this.body = e.slice(h, h + a);
+      }
+      o += a;
+    }
+    if (this.content === null)
+      throw new Error("THREE.GLTFLoader: JSON content not found.");
+  }
+}
+class Ri {
+  constructor(e, t) {
+    if (!t)
+      throw new Error("THREE.GLTFLoader: No DRACOLoader instance provided.");
+    this.name = R.KHR_DRACO_MESH_COMPRESSION, this.json = e, this.dracoLoader = t, this.dracoLoader.preload();
+  }
+  decodePrimitive(e, t) {
+    const s = this.json, n = this.dracoLoader, i = e.extensions[this.name].bufferView, o = e.extensions[this.name].attributes, a = {}, l = {}, h = {};
+    for (const u in o) {
+      const c = bt[u] || u.toLowerCase();
+      a[c] = o[u];
+    }
+    for (const u in e.attributes) {
+      const c = bt[u] || u.toLowerCase();
+      if (o[u] !== void 0) {
+        const d = s.accessors[e.attributes[u]], p = Ee[d.componentType];
+        h[c] = p.name, l[c] = d.normalized === !0;
+      }
+    }
+    return t.getDependency("bufferView", i).then(function(u) {
+      return new Promise(function(c, d) {
+        n.decodeDracoFile(u, function(p) {
+          for (const f in p.attributes) {
+            const m = p.attributes[f], y = l[f];
+            y !== void 0 && (m.normalized = y);
+          }
+          c(p);
+        }, a, h, ae, d);
+      });
+    });
+  }
+}
+class Ai {
+  constructor() {
+    this.name = R.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 Pi {
+  constructor() {
+    this.name = R.KHR_MESH_QUANTIZATION;
+  }
+}
+class yn extends ls {
+  constructor(e, t, s, n) {
+    super(e, t, s, n);
+  }
+  copySampleValue_(e) {
+    const t = this.resultBuffer, s = this.sampleValues, n = this.valueSize, i = e * n * 3 + n;
+    for (let o = 0; o !== n; o++)
+      t[o] = s[i + o];
+    return t;
+  }
+  interpolate_(e, t, s, n) {
+    const i = this.resultBuffer, o = this.sampleValues, a = this.valueSize, l = a * 2, h = a * 3, u = n - t, c = (s - t) / u, d = c * c, p = d * c, f = e * h, m = f - h, y = -2 * p + 3 * d, _ = p - d, x = 1 - y, M = _ - d + c;
+    for (let S = 0; S !== a; S++) {
+      const L = o[m + S + a], v = o[m + S + l] * u, I = o[f + S + a], se = o[f + S] * u;
+      i[S] = x * L + M * v + y * I + _ * se;
+    }
+    return i;
+  }
+}
+const Li = new X();
+class Ii extends yn {
+  interpolate_(e, t, s, n) {
+    const i = super.interpolate_(e, t, s, n);
+    return Li.fromArray(i).normalize().toArray(i), i;
+  }
+}
+const Q = {
+  POINTS: 0,
+  LINES: 1,
+  LINE_LOOP: 2,
+  LINE_STRIP: 3,
+  TRIANGLES: 4,
+  TRIANGLE_STRIP: 5,
+  TRIANGLE_FAN: 6
+}, Ee = {
+  5120: Int8Array,
+  5121: Uint8Array,
+  5122: Int16Array,
+  5123: Uint16Array,
+  5125: Uint32Array,
+  5126: Float32Array
+}, Qt = {
+  9728: cn,
+  9729: gt,
+  9984: Qn,
+  9985: Zn,
+  9986: Vn,
+  9987: ln
+}, qt = {
+  33071: Wn,
+  33648: qn,
+  10497: yt
+}, ut = {
+  SCALAR: 1,
+  VEC2: 2,
+  VEC3: 3,
+  VEC4: 4,
+  MAT2: 4,
+  MAT3: 9,
+  MAT4: 16
+}, bt = {
+  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"
+}, ce = {
+  scale: "scale",
+  translation: "position",
+  rotation: "quaternion",
+  weights: "morphTargetInfluences"
+}, Oi = {
+  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: un,
+  STEP: rs
+}, dt = {
+  OPAQUE: "OPAQUE",
+  MASK: "MASK",
+  BLEND: "BLEND"
+};
+function Ci(r) {
+  return r.DefaultMaterial === void 0 && (r.DefaultMaterial = new hn({
+    color: 16777215,
+    emissive: 0,
+    metalness: 1,
+    roughness: 1,
+    transparent: !1,
+    depthTest: !0,
+    side: as
+  })), r.DefaultMaterial;
+}
+function me(r, e, t) {
+  for (const s in t.extensions)
+    r[s] === void 0 && (e.userData.gltfExtensions = e.userData.gltfExtensions || {}, e.userData.gltfExtensions[s] = t.extensions[s]);
+}
+function te(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 Di(r, e, t) {
+  let s = !1, n = !1, i = !1;
+  for (let h = 0, u = e.length; h < u; h++) {
+    const c = e[h];
+    if (c.POSITION !== void 0 && (s = !0), c.NORMAL !== void 0 && (n = !0), c.COLOR_0 !== void 0 && (i = !0), s && n && i) break;
+  }
+  if (!s && !n && !i) return Promise.resolve(r);
+  const o = [], a = [], l = [];
+  for (let h = 0, u = e.length; h < u; h++) {
+    const c = e[h];
+    if (s) {
+      const d = c.POSITION !== void 0 ? t.getDependency("accessor", c.POSITION) : r.attributes.position;
+      o.push(d);
+    }
+    if (n) {
+      const d = c.NORMAL !== void 0 ? t.getDependency("accessor", c.NORMAL) : r.attributes.normal;
+      a.push(d);
+    }
+    if (i) {
+      const d = c.COLOR_0 !== void 0 ? t.getDependency("accessor", c.COLOR_0) : r.attributes.color;
+      l.push(d);
+    }
+  }
+  return Promise.all([
+    Promise.all(o),
+    Promise.all(a),
+    Promise.all(l)
+  ]).then(function(h) {
+    const u = h[0], c = h[1], d = h[2];
+    return s && (r.morphAttributes.position = u), n && (r.morphAttributes.normal = c), i && (r.morphAttributes.color = d), r.morphTargetsRelative = !0, r;
+  });
+}
+function Ni(r, e) {
+  if (r.updateMorphTargets(), e.weights !== void 0)
+    for (let t = 0, s = e.weights.length; t < s; 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 s = 0, n = t.length; s < n; s++)
+        r.morphTargetDictionary[t[s]] = s;
+    } else
+      console.warn("THREE.GLTFLoader: Invalid extras.targetNames length. Ignoring names.");
+  }
+}
+function ki(r) {
+  let e;
+  const t = r.extensions && r.extensions[R.KHR_DRACO_MESH_COMPRESSION];
+  if (t ? e = "draco:" + t.bufferView + ":" + t.indices + ":" + pt(t.attributes) : e = r.indices + ":" + pt(r.attributes) + ":" + r.mode, r.targets !== void 0)
+    for (let s = 0, n = r.targets.length; s < n; s++)
+      e += ":" + pt(r.targets[s]);
+  return e;
+}
+function pt(r) {
+  let e = "";
+  const t = Object.keys(r).sort();
+  for (let s = 0, n = t.length; s < n; s++)
+    e += t[s] + ":" + r[t[s]] + ";";
+  return e;
+}
+function wt(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 ji(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 Hi = new Me();
+class Fi {
+  constructor(e = {}, t = {}) {
+    this.json = e, this.extensions = {}, this.plugins = {}, this.options = t, this.cache = new li(), 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 s = !1, n = -1, i = !1, o = -1;
+    if (typeof navigator < "u" && typeof navigator.userAgent < "u") {
+      const a = navigator.userAgent;
+      s = /^((?!chrome|android).)*safari/i.test(a) === !0;
+      const l = a.match(/Version\/(\d+)/);
+      n = s && l ? parseInt(l[1], 10) : -1, i = a.indexOf("Firefox") > -1, o = i ? a.match(/Firefox\/([0-9]+)\./)[1] : -1;
+    }
+    typeof createImageBitmap > "u" || s && n < 17 || i && o < 98 ? this.textureLoader = new Xn(this.options.manager) : this.textureLoader = new Yn(this.options.manager), this.textureLoader.setCrossOrigin(this.options.crossOrigin), this.textureLoader.setRequestHeader(this.options.requestHeader), this.fileLoader = new Tt(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 s = this, n = 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([
+        s.getDependencies("scene"),
+        s.getDependencies("animation"),
+        s.getDependencies("camera")
+      ]);
+    }).then(function(o) {
+      const a = {
+        scene: o[0][n.scene || 0],
+        scenes: o[0],
+        animations: o[1],
+        cameras: o[2],
+        asset: n.asset,
+        parser: s,
+        userData: {}
+      };
+      return me(i, a, n), te(a, n), Promise.all(s._invokeAll(function(l) {
+        return l.afterRoot && l.afterRoot(a);
+      })).then(function() {
+        for (const l of a.scenes)
+          l.updateMatrixWorld();
+        e(a);
+      });
+    }).catch(t);
+  }
+  /**
+   * Marks the special nodes/meshes in json for efficient parse.
+   *
+   * @private
+   */
+  _markDefs() {
+    const e = this.json.nodes || [], t = this.json.skins || [], s = this.json.meshes || [];
+    for (let n = 0, i = t.length; n < i; n++) {
+      const o = t[n].joints;
+      for (let a = 0, l = o.length; a < l; a++)
+        e[o[a]].isBone = !0;
+    }
+    for (let n = 0, i = e.length; n < i; n++) {
+      const o = e[n];
+      o.mesh !== void 0 && (this._addNodeRef(this.meshCache, o.mesh), o.skin !== void 0 && (s[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, s) {
+    if (e.refs[t] <= 1) return s;
+    const n = s.clone(), i = (o, a) => {
+      const l = this.associations.get(o);
+      l != null && this.associations.set(a, l);
+      for (const [h, u] of o.children.entries())
+        i(u, a.children[h]);
+    };
+    return i(s, n), n.name += "_instance_" + e.uses[t]++, n;
+  }
+  _invokeOne(e) {
+    const t = Object.values(this.plugins);
+    t.push(this);
+    for (let s = 0; s < t.length; s++) {
+      const n = e(t[s]);
+      if (n) return n;
+    }
+    return null;
+  }
+  _invokeAll(e) {
+    const t = Object.values(this.plugins);
+    t.unshift(this);
+    const s = [];
+    for (let n = 0; n < t.length; n++) {
+      const i = e(t[n]);
+      i && s.push(i);
+    }
+    return s;
+  }
+  /**
+   * Requests the specified dependency asynchronously, with caching.
+   *
+   * @private
+   * @param {string} type
+   * @param {number} index
+   * @return {Promise<Object3D|Material|Texture|AnimationClip|ArrayBuffer|Object>}
+   */
+  getDependency(e, t) {
+    const s = e + ":" + t;
+    let n = this.cache.get(s);
+    if (!n) {
+      switch (e) {
+        case "scene":
+          n = this.loadScene(t);
+          break;
+        case "node":
+          n = this._invokeOne(function(i) {
+            return i.loadNode && i.loadNode(t);
+          });
+          break;
+        case "mesh":
+          n = this._invokeOne(function(i) {
+            return i.loadMesh && i.loadMesh(t);
+          });
+          break;
+        case "accessor":
+          n = this.loadAccessor(t);
+          break;
+        case "bufferView":
+          n = this._invokeOne(function(i) {
+            return i.loadBufferView && i.loadBufferView(t);
+          });
+          break;
+        case "buffer":
+          n = this.loadBuffer(t);
+          break;
+        case "material":
+          n = this._invokeOne(function(i) {
+            return i.loadMaterial && i.loadMaterial(t);
+          });
+          break;
+        case "texture":
+          n = this._invokeOne(function(i) {
+            return i.loadTexture && i.loadTexture(t);
+          });
+          break;
+        case "skin":
+          n = this.loadSkin(t);
+          break;
+        case "animation":
+          n = this._invokeOne(function(i) {
+            return i.loadAnimation && i.loadAnimation(t);
+          });
+          break;
+        case "camera":
+          n = this.loadCamera(t);
+          break;
+        default:
+          if (n = this._invokeOne(function(i) {
+            return i != this && i.getDependency && i.getDependency(e, t);
+          }), !n)
+            throw new Error("Unknown type: " + e);
+          break;
+      }
+      this.cache.add(s, n);
+    }
+    return n;
+  }
+  /**
+   * 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 s = this, n = this.json[e + (e === "mesh" ? "es" : "s")] || [];
+      t = Promise.all(n.map(function(i, o) {
+        return s.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], s = 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[R.KHR_BINARY_GLTF].body);
+    const n = this.options;
+    return new Promise(function(i, o) {
+      s.load(ke.resolveURL(t.uri, n.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(s) {
+      const n = t.byteLength || 0, i = t.byteOffset || 0;
+      return s.slice(i, i + n);
+    });
+  }
+  /**
+   * 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, s = this.json, n = this.json.accessors[e];
+    if (n.bufferView === void 0 && n.sparse === void 0) {
+      const o = ut[n.type], a = Ee[n.componentType], l = n.normalized === !0, h = new a(n.count * o);
+      return Promise.resolve(new ot(h, o, l));
+    }
+    const i = [];
+    return n.bufferView !== void 0 ? i.push(this.getDependency("bufferView", n.bufferView)) : i.push(null), n.sparse !== void 0 && (i.push(this.getDependency("bufferView", n.sparse.indices.bufferView)), i.push(this.getDependency("bufferView", n.sparse.values.bufferView))), Promise.all(i).then(function(o) {
+      const a = o[0], l = ut[n.type], h = Ee[n.componentType], u = h.BYTES_PER_ELEMENT, c = u * l, d = n.byteOffset || 0, p = n.bufferView !== void 0 ? s.bufferViews[n.bufferView].byteStride : void 0, f = n.normalized === !0;
+      let m, y;
+      if (p && p !== c) {
+        const _ = Math.floor(d / p), x = "InterleavedBuffer:" + n.bufferView + ":" + n.componentType + ":" + _ + ":" + n.count;
+        let M = t.cache.get(x);
+        M || (m = new h(a, _ * p, n.count * p / u), M = new Bn(m, p / u), t.cache.add(x, M)), y = new Kn(M, l, d % p / u, f);
+      } else
+        a === null ? m = new h(n.count * l) : m = new h(a, d, n.count * l), y = new ot(m, l, f);
+      if (n.sparse !== void 0) {
+        const _ = ut.SCALAR, x = Ee[n.sparse.indices.componentType], M = n.sparse.indices.byteOffset || 0, S = n.sparse.values.byteOffset || 0, L = new x(o[1], M, n.sparse.count * _), v = new h(o[2], S, n.sparse.count * l);
+        a !== null && (y = new ot(y.array.slice(), y.itemSize, y.normalized)), y.normalized = !1;
+        for (let I = 0, se = L.length; I < se; I++) {
+          const J = L[I];
+          if (y.setX(J, v[I * l]), l >= 2 && y.setY(J, v[I * l + 1]), l >= 3 && y.setZ(J, v[I * l + 2]), l >= 4 && y.setW(J, v[I * l + 3]), l >= 5) throw new Error("THREE.GLTFLoader: Unsupported itemSize in sparse BufferAttribute.");
+        }
+        y.normalized = f;
+      }
+      return y;
+    });
+  }
+  /**
+   * Specification: https://github.com/KhronosGroup/glTF/tree/master/specification/2.0#textures
+   *
+   * @private
+   * @param {number} textureIndex
+   * @return {Promise<?Texture>}
+   */
+  loadTexture(e) {
+    const t = this.json, s = this.options, i = t.textures[e].source, o = t.images[i];
+    let a = this.textureLoader;
+    if (o.uri) {
+      const l = s.manager.getHandler(o.uri);
+      l !== null && (a = l);
+    }
+    return this.loadTextureImage(e, i, a);
+  }
+  loadTextureImage(e, t, s) {
+    const n = this, i = this.json, o = i.textures[e], a = i.images[t], l = (a.uri || a.bufferView) + ":" + o.sampler;
+    if (this.textureCache[l])
+      return this.textureCache[l];
+    const h = this.loadImageSource(t, s).then(function(u) {
+      u.flipY = !1, u.name = o.name || a.name || "", u.name === "" && typeof a.uri == "string" && a.uri.startsWith("data:image/") === !1 && (u.name = a.uri);
+      const d = (i.samplers || {})[o.sampler] || {};
+      return u.magFilter = Qt[d.magFilter] || gt, u.minFilter = Qt[d.minFilter] || ln, u.wrapS = qt[d.wrapS] || yt, u.wrapT = qt[d.wrapT] || yt, u.generateMipmaps = !u.isCompressedTexture && u.minFilter !== cn && u.minFilter !== gt, n.associations.set(u, { textures: e }), u;
+    }).catch(function() {
+      return null;
+    });
+    return this.textureCache[l] = h, h;
+  }
+  loadImageSource(e, t) {
+    const s = this, n = this.json, i = this.options;
+    if (this.sourceCache[e] !== void 0)
+      return this.sourceCache[e].then((c) => c.clone());
+    const o = n.images[e], a = self.URL || self.webkitURL;
+    let l = o.uri || "", h = !1;
+    if (o.bufferView !== void 0)
+      l = s.getDependency("bufferView", o.bufferView).then(function(c) {
+        h = !0;
+        const d = new Blob([c], { type: o.mimeType });
+        return l = a.createObjectURL(d), l;
+      });
+    else if (o.uri === void 0)
+      throw new Error("THREE.GLTFLoader: Image " + e + " is missing URI and bufferView");
+    const u = Promise.resolve(l).then(function(c) {
+      return new Promise(function(d, p) {
+        let f = d;
+        t.isImageBitmapLoader === !0 && (f = function(m) {
+          const y = new At(m);
+          y.needsUpdate = !0, d(y);
+        }), t.load(ke.resolveURL(c, i.path), f, void 0, p);
+      });
+    }).then(function(c) {
+      return h === !0 && a.revokeObjectURL(l), te(c, o), c.userData.mimeType = o.mimeType || ji(o.uri), c;
+    }).catch(function(c) {
+      throw console.error("THREE.GLTFLoader: Couldn't load texture", l), c;
+    });
+    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, s, n) {
+    const i = this;
+    return this.getDependency("texture", s.index).then(function(o) {
+      if (!o) return null;
+      if (s.texCoord !== void 0 && s.texCoord > 0 && (o = o.clone(), o.channel = s.texCoord), i.extensions[R.KHR_TEXTURE_TRANSFORM]) {
+        const a = s.extensions !== void 0 ? s.extensions[R.KHR_TEXTURE_TRANSFORM] : void 0;
+        if (a) {
+          const l = i.associations.get(o);
+          o = i.extensions[R.KHR_TEXTURE_TRANSFORM].extendTexture(o, a), i.associations.set(o, l);
+        }
+      }
+      return n !== void 0 && (o.colorSpace = n), 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 s = e.material;
+    const n = t.attributes.tangent === void 0, i = t.attributes.color !== void 0, o = t.attributes.normal === void 0;
+    if (e.isPoints) {
+      const a = "PointsMaterial:" + s.uuid;
+      let l = this.cache.get(a);
+      l || (l = new Ie(), Ne.prototype.copy.call(l, s), l.color.copy(s.color), l.map = s.map, l.sizeAttenuation = !1, this.cache.add(a, l)), s = l;
+    } else if (e.isLine) {
+      const a = "LineBasicMaterial:" + s.uuid;
+      let l = this.cache.get(a);
+      l || (l = new De(), Ne.prototype.copy.call(l, s), l.color.copy(s.color), l.map = s.map, this.cache.add(a, l)), s = l;
+    }
+    if (n || i || o) {
+      let a = "ClonedMaterial:" + s.uuid + ":";
+      n && (a += "derivative-tangents:"), i && (a += "vertex-colors:"), o && (a += "flat-shading:");
+      let l = this.cache.get(a);
+      l || (l = s.clone(), i && (l.vertexColors = !0), o && (l.flatShading = !0), n && (l.normalScale && (l.normalScale.y *= -1), l.clearcoatNormalScale && (l.clearcoatNormalScale.y *= -1)), this.cache.add(a, l), this.associations.set(l, this.associations.get(s))), s = l;
+    }
+    e.material = s;
+  }
+  getMaterialType() {
+    return hn;
+  }
+  /**
+   * 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, s = this.json, n = this.extensions, i = s.materials[e];
+    let o;
+    const a = {}, l = i.extensions || {}, h = [];
+    if (l[R.KHR_MATERIALS_UNLIT]) {
+      const c = n[R.KHR_MATERIALS_UNLIT];
+      o = c.getMaterialType(), h.push(c.extendParams(a, i, t));
+    } else {
+      const c = i.pbrMetallicRoughness || {};
+      if (a.color = new ue(1, 1, 1), a.opacity = 1, Array.isArray(c.baseColorFactor)) {
+        const d = c.baseColorFactor;
+        a.color.setRGB(d[0], d[1], d[2], ae), a.opacity = d[3];
+      }
+      c.baseColorTexture !== void 0 && h.push(t.assignTexture(a, "map", c.baseColorTexture, Se)), a.metalness = c.metallicFactor !== void 0 ? c.metallicFactor : 1, a.roughness = c.roughnessFactor !== void 0 ? c.roughnessFactor : 1, c.metallicRoughnessTexture !== void 0 && (h.push(t.assignTexture(a, "metalnessMap", c.metallicRoughnessTexture)), h.push(t.assignTexture(a, "roughnessMap", c.metallicRoughnessTexture))), o = this._invokeOne(function(d) {
+        return d.getMaterialType && d.getMaterialType(e);
+      }), h.push(Promise.all(this._invokeAll(function(d) {
+        return d.extendMaterialParams && d.extendMaterialParams(e, a);
+      })));
+    }
+    i.doubleSided === !0 && (a.side = on);
+    const u = i.alphaMode || dt.OPAQUE;
+    if (u === dt.BLEND ? (a.transparent = !0, a.depthWrite = !1) : (a.transparent = !1, u === dt.MASK && (a.alphaTest = i.alphaCutoff !== void 0 ? i.alphaCutoff : 0.5)), i.normalTexture !== void 0 && o !== ye && (h.push(t.assignTexture(a, "normalMap", i.normalTexture)), a.normalScale = new B(1, 1), i.normalTexture.scale !== void 0)) {
+      const c = i.normalTexture.scale;
+      a.normalScale.set(c, c);
+    }
+    if (i.occlusionTexture !== void 0 && o !== ye && (h.push(t.assignTexture(a, "aoMap", i.occlusionTexture)), i.occlusionTexture.strength !== void 0 && (a.aoMapIntensity = i.occlusionTexture.strength)), i.emissiveFactor !== void 0 && o !== ye) {
+      const c = i.emissiveFactor;
+      a.emissive = new ue().setRGB(c[0], c[1], c[2], ae);
+    }
+    return i.emissiveTexture !== void 0 && o !== ye && h.push(t.assignTexture(a, "emissiveMap", i.emissiveTexture, Se)), Promise.all(h).then(function() {
+      const c = new o(a);
+      return i.name && (c.name = i.name), te(c, i), t.associations.set(c, { materials: e }), i.extensions && me(n, c, i), c;
+    });
+  }
+  /**
+   * When Object3D instances are targeted by animation, they need unique names.
+   *
+   * @private
+   * @param {string} originalName
+   * @return {string}
+   */
+  createUniqueName(e) {
+    const t = $n.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, s = this.extensions, n = this.primitiveCache;
+    function i(a) {
+      return s[R.KHR_DRACO_MESH_COMPRESSION].decodePrimitive(a, t).then(function(l) {
+        return Wt(l, a, t);
+      });
+    }
+    const o = [];
+    for (let a = 0, l = e.length; a < l; a++) {
+      const h = e[a], u = ki(h), c = n[u];
+      if (c)
+        o.push(c.promise);
+      else {
+        let d;
+        h.extensions && h.extensions[R.KHR_DRACO_MESH_COMPRESSION] ? d = i(h) : d = Wt(new He(), h, t), n[u] = { primitive: h, promise: d }, o.push(d);
+      }
+    }
+    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, s = this.json, n = this.extensions, i = s.meshes[e], o = i.primitives, a = [];
+    for (let l = 0, h = o.length; l < h; l++) {
+      const u = o[l].material === void 0 ? Ci(this.cache) : this.getDependency("material", o[l].material);
+      a.push(u);
+    }
+    return a.push(t.loadGeometries(o)), Promise.all(a).then(function(l) {
+      const h = l.slice(0, l.length - 1), u = l[l.length - 1], c = [];
+      for (let p = 0, f = u.length; p < f; p++) {
+        const m = u[p], y = o[p];
+        let _;
+        const x = h[p];
+        if (y.mode === Q.TRIANGLES || y.mode === Q.TRIANGLE_STRIP || y.mode === Q.TRIANGLE_FAN || y.mode === void 0)
+          _ = i.isSkinnedMesh === !0 ? new Jn(m, x) : new b(m, x), _.isSkinnedMesh === !0 && _.normalizeSkinWeights(), y.mode === Q.TRIANGLE_STRIP ? _.geometry = Kt(_.geometry, an) : y.mode === Q.TRIANGLE_FAN && (_.geometry = Kt(_.geometry, mt));
+        else if (y.mode === Q.LINES)
+          _ = new ft(m, x);
+        else if (y.mode === Q.LINE_STRIP)
+          _ = new re(m, x);
+        else if (y.mode === Q.LINE_LOOP)
+          _ = new es(m, x);
+        else if (y.mode === Q.POINTS)
+          _ = new Je(m, x);
+        else
+          throw new Error("THREE.GLTFLoader: Primitive mode unsupported: " + y.mode);
+        Object.keys(_.geometry.morphAttributes).length > 0 && Ni(_, i), _.name = t.createUniqueName(i.name || "mesh_" + e), te(_, i), y.extensions && me(n, _, y), t.assignFinalMaterial(_), c.push(_);
+      }
+      for (let p = 0, f = c.length; p < f; p++)
+        t.associations.set(c[p], {
+          meshes: e,
+          primitives: p
+        });
+      if (c.length === 1)
+        return i.extensions && me(n, c[0], i), c[0];
+      const d = new $e();
+      i.extensions && me(n, d, i), t.associations.set(d, { meshes: e });
+      for (let p = 0, f = c.length; p < f; p++)
+        d.add(c[p]);
+      return d;
+    });
+  }
+  /**
+   * Specification: https://github.com/KhronosGroup/glTF/tree/master/specification/2.0#cameras
+   *
+   * @private
+   * @param {number} cameraIndex
+   * @return {Promise<Camera>|undefined}
+   */
+  loadCamera(e) {
+    let t;
+    const s = this.json.cameras[e], n = s[s.type];
+    if (!n) {
+      console.warn("THREE.GLTFLoader: Missing camera parameters.");
+      return;
+    }
+    return s.type === "perspective" ? t = new ts(sn.radToDeg(n.yfov), n.aspectRatio || 1, n.znear || 1, n.zfar || 2e6) : s.type === "orthographic" && (t = new ns(-n.xmag, n.xmag, n.ymag, -n.ymag, n.znear, n.zfar)), s.name && (t.name = this.createUniqueName(s.name)), te(t, s), 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], s = [];
+    for (let n = 0, i = t.joints.length; n < i; n++)
+      s.push(this._loadNodeShallow(t.joints[n]));
+    return t.inverseBindMatrices !== void 0 ? s.push(this.getDependency("accessor", t.inverseBindMatrices)) : s.push(null), Promise.all(s).then(function(n) {
+      const i = n.pop(), o = n, a = [], l = [];
+      for (let h = 0, u = o.length; h < u; h++) {
+        const c = o[h];
+        if (c) {
+          a.push(c);
+          const d = new Me();
+          i !== null && d.fromArray(i.array, h * 16), l.push(d);
+        } else
+          console.warn('THREE.GLTFLoader: Joint "%s" could not be found.', t.joints[h]);
+      }
+      return new ss(a, l);
+    });
+  }
+  /**
+   * 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, s = this, n = t.animations[e], i = n.name ? n.name : "animation_" + e, o = [], a = [], l = [], h = [], u = [];
+    for (let c = 0, d = n.channels.length; c < d; c++) {
+      const p = n.channels[c], f = n.samplers[p.sampler], m = p.target, y = m.node, _ = n.parameters !== void 0 ? n.parameters[f.input] : f.input, x = n.parameters !== void 0 ? n.parameters[f.output] : f.output;
+      m.node !== void 0 && (o.push(this.getDependency("node", y)), a.push(this.getDependency("accessor", _)), l.push(this.getDependency("accessor", x)), h.push(f), u.push(m));
+    }
+    return Promise.all([
+      Promise.all(o),
+      Promise.all(a),
+      Promise.all(l),
+      Promise.all(h),
+      Promise.all(u)
+    ]).then(function(c) {
+      const d = c[0], p = c[1], f = c[2], m = c[3], y = c[4], _ = [];
+      for (let M = 0, S = d.length; M < S; M++) {
+        const L = d[M], v = p[M], I = f[M], se = m[M], J = y[M];
+        if (L === void 0) continue;
+        L.updateMatrix && L.updateMatrix();
+        const de = s._createAnimationTracks(L, v, I, se, J);
+        if (de)
+          for (let W = 0; W < de.length; W++)
+            _.push(de[W]);
+      }
+      const x = new is(i, void 0, _);
+      return te(x, n), x;
+    });
+  }
+  createNodeMesh(e) {
+    const t = this.json, s = this, n = t.nodes[e];
+    return n.mesh === void 0 ? null : s.getDependency("mesh", n.mesh).then(function(i) {
+      const o = s._getNodeRef(s.meshCache, n.mesh, i);
+      return n.weights !== void 0 && o.traverse(function(a) {
+        if (a.isMesh)
+          for (let l = 0, h = n.weights.length; l < h; l++)
+            a.morphTargetInfluences[l] = n.weights[l];
+      }), 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, s = this, n = t.nodes[e], i = s._loadNodeShallow(e), o = [], a = n.children || [];
+    for (let h = 0, u = a.length; h < u; h++)
+      o.push(s.getDependency("node", a[h]));
+    const l = n.skin === void 0 ? Promise.resolve(null) : s.getDependency("skin", n.skin);
+    return Promise.all([
+      i,
+      Promise.all(o),
+      l
+    ]).then(function(h) {
+      const u = h[0], c = h[1], d = h[2];
+      d !== null && u.traverse(function(p) {
+        p.isSkinnedMesh && p.bind(d, Hi);
+      });
+      for (let p = 0, f = c.length; p < f; p++)
+        u.add(c[p]);
+      if (u.userData.pivot !== void 0 && c.length > 0) {
+        const p = u.userData.pivot, f = c[0];
+        u.pivot = new E().fromArray(p), u.position.x -= p[0], u.position.y -= p[1], u.position.z -= p[2], f.position.set(0, 0, 0), delete u.userData.pivot;
+      }
+      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, s = this.extensions, n = this;
+    if (this.nodeCache[e] !== void 0)
+      return this.nodeCache[e];
+    const i = t.nodes[e], o = i.name ? n.createUniqueName(i.name) : "", a = [], l = n._invokeOne(function(h) {
+      return h.createNodeMesh && h.createNodeMesh(e);
+    });
+    return l && a.push(l), i.camera !== void 0 && a.push(n.getDependency("camera", i.camera).then(function(h) {
+      return n._getNodeRef(n.cameraCache, i.camera, h);
+    })), n._invokeAll(function(h) {
+      return h.createNodeAttachment && h.createNodeAttachment(e);
+    }).forEach(function(h) {
+      a.push(h);
+    }), this.nodeCache[e] = Promise.all(a).then(function(h) {
+      let u;
+      if (i.isBone === !0 ? u = new os() : h.length > 1 ? u = new $e() : h.length === 1 ? u = h[0] : u = new je(), u !== h[0])
+        for (let c = 0, d = h.length; c < d; c++)
+          u.add(h[c]);
+      if (i.name && (u.userData.name = i.name, u.name = o), te(u, i), i.extensions && me(s, u, i), i.matrix !== void 0) {
+        const c = new Me();
+        c.fromArray(i.matrix), u.applyMatrix4(c);
+      } 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 (!n.associations.has(u))
+        n.associations.set(u, {});
+      else if (i.mesh !== void 0 && n.meshCache.refs[i.mesh] > 1) {
+        const c = n.associations.get(u);
+        n.associations.set(u, { ...c });
+      }
+      return n.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, s = this.json.scenes[e], n = this, i = new $e();
+    s.name && (i.name = n.createUniqueName(s.name)), te(i, s), s.extensions && me(t, i, s);
+    const o = s.nodes || [], a = [];
+    for (let l = 0, h = o.length; l < h; l++)
+      a.push(n.getDependency("node", o[l]));
+    return Promise.all(a).then(function(l) {
+      for (let u = 0, c = l.length; u < c; u++) {
+        const d = l[u];
+        d.parent !== null ? i.add(ri(d)) : i.add(d);
+      }
+      const h = (u) => {
+        const c = /* @__PURE__ */ new Map();
+        for (const [d, p] of n.associations)
+          (d instanceof Ne || d instanceof At) && c.set(d, p);
+        return u.traverse((d) => {
+          const p = n.associations.get(d);
+          p != null && c.set(d, p);
+        }), c;
+      };
+      return n.associations = h(i), i;
+    });
+  }
+  _createAnimationTracks(e, t, s, n, i) {
+    const o = [], a = e.name ? e.name : e.uuid, l = [];
+    function h(p) {
+      p.morphTargetInfluences && l.push(p.name ? p.name : p.uuid);
+    }
+    ce[i.path] === ce.weights ? (h(e), e.isGroup && e.children.forEach(h)) : l.push(a);
+    let u;
+    switch (ce[i.path]) {
+      case ce.weights:
+        u = Lt;
+        break;
+      case ce.rotation:
+        u = It;
+        break;
+      case ce.translation:
+      case ce.scale:
+        u = Pt;
+        break;
+      default:
+        switch (s.itemSize) {
+          case 1:
+            u = Lt;
+            break;
+          case 2:
+          case 3:
+          default:
+            u = Pt;
+            break;
+        }
+        break;
+    }
+    const c = n.interpolation !== void 0 ? Oi[n.interpolation] : un, d = this._getArrayFromAccessor(s);
+    for (let p = 0, f = l.length; p < f; p++) {
+      const m = new u(
+        l[p] + "." + ce[i.path],
+        t.array,
+        d,
+        c
+      );
+      n.interpolation === "CUBICSPLINE" && this._createCubicSplineTrackInterpolant(m), o.push(m);
+    }
+    return o;
+  }
+  _getArrayFromAccessor(e) {
+    let t = e.array;
+    if (e.normalized) {
+      const s = wt(t.constructor), n = new Float32Array(t.length);
+      for (let i = 0, o = t.length; i < o; i++)
+        n[i] = t[i] * s;
+      t = n;
+    }
+    return t;
+  }
+  _createCubicSplineTrackInterpolant(e) {
+    e.createInterpolant = function(s) {
+      const n = this instanceof It ? Ii : yn;
+      return new n(this.times, this.values, this.getValueSize() / 3, s);
+    }, e.createInterpolant.isInterpolantFactoryMethodGLTFCubicSpline = !0;
+  }
+}
+function Ui(r, e, t) {
+  const s = e.attributes, n = new cs();
+  if (s.POSITION !== void 0) {
+    const a = t.json.accessors[s.POSITION], l = a.min, h = a.max;
+    if (l !== void 0 && h !== void 0) {
+      if (n.set(
+        new E(l[0], l[1], l[2]),
+        new E(h[0], h[1], h[2])
+      ), a.normalized) {
+        const u = wt(Ee[a.componentType]);
+        n.min.multiplyScalar(u), n.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 a = new E(), l = new E();
+    for (let h = 0, u = i.length; h < u; h++) {
+      const c = i[h];
+      if (c.POSITION !== void 0) {
+        const d = t.json.accessors[c.POSITION], p = d.min, f = d.max;
+        if (p !== void 0 && f !== void 0) {
+          if (l.setX(Math.max(Math.abs(p[0]), Math.abs(f[0]))), l.setY(Math.max(Math.abs(p[1]), Math.abs(f[1]))), l.setZ(Math.max(Math.abs(p[2]), Math.abs(f[2]))), d.normalized) {
+            const m = wt(Ee[d.componentType]);
+            l.multiplyScalar(m);
+          }
+          a.max(l);
+        } else
+          console.warn("THREE.GLTFLoader: Missing min/max properties for accessor POSITION.");
+      }
+    }
+    n.expandByVector(a);
+  }
+  r.boundingBox = n;
+  const o = new hs();
+  n.getCenter(o.center), o.radius = n.min.distanceTo(n.max) / 2, r.boundingSphere = o;
+}
+function Wt(r, e, t) {
+  const s = e.attributes, n = [];
+  function i(o, a) {
+    return t.getDependency("accessor", o).then(function(l) {
+      r.setAttribute(a, l);
+    });
+  }
+  for (const o in s) {
+    const a = bt[o] || o.toLowerCase();
+    a in r.attributes || n.push(i(s[o], a));
+  }
+  if (e.indices !== void 0 && !r.index) {
+    const o = t.getDependency("accessor", e.indices).then(function(a) {
+      r.setIndex(a);
+    });
+    n.push(o);
+  }
+  return Ot.workingColorSpace !== ae && "COLOR_0" in s && console.warn(`THREE.GLTFLoader: Converting vertex colors from "srgb-linear" to "${Ot.workingColorSpace}" not supported.`), te(r, e), Ui(r, e, t), Promise.all(n).then(function() {
+    return e.targets !== void 0 ? Di(r, e.targets, t) : r;
+  });
+}
+function zi() {
+  const r = new N.BoxGeometry(1, 1, 1), e = new N.MeshStandardMaterial({ color: 43775 }), t = new N.Mesh(r, e);
+  return t.position.y = 0.5, t.userData.isMovable = !0, t.name = "正方体", nt(t, !0), t;
+}
+function Gi() {
+  const r = new N.SphereGeometry(0.6, 32, 32), e = new N.MeshStandardMaterial({ color: 16746496 }), t = new N.Mesh(r, e);
+  return t.position.y = 0.6, t.userData.isMovable = !0, t.name = "球体", nt(t, !0), t;
+}
+function Xi(r) {
+  return new Promise((e, t) => {
+    var o;
+    const s = (o = r.name.split(".").pop()) == null ? void 0 : o.toLowerCase(), n = URL.createObjectURL(r);
+    let i;
+    if (s === "obj") i = new oi();
+    else if (s === "gltf" || s === "glb") i = new ai();
+    else {
+      t(new Error("不支持的文件格式，请使用 .obj, .gltf, .glb"));
+      return;
+    }
+    i.load(
+      n,
+      (a) => {
+        const l = s === "gltf" || s === "glb" ? a.scene : a;
+        l.traverse((c) => {
+          var d;
+          c.userData.isMovable = !0, c.name || (c.name = c.type), c.type === "Mesh" && (c.frustumCulled = !0, (d = c.geometry) == null || d.computeVertexNormals());
+        });
+        const u = new N.Box3().setFromObject(l).getCenter(new N.Vector3());
+        l.position.sub(u), nt(l, !0), e(l);
+      },
+      void 0,
+      (a) => t(a)
+    );
+  });
+}
+function Yi(r) {
+  switch (r) {
+    case "box":
+      zi();
+      break;
+    case "sphere":
+      Gi();
+      break;
+  }
+}
+const Bi = {
+  key: 1,
+  class: "toggle-placeholder"
+}, Ki = { class: "tree-icon" }, Vi = { class: "tree-name" }, Zi = {
+  key: 0,
+  class: "tree-children"
+}, Qi = /* @__PURE__ */ Fe({
+  __name: "TreeItem",
+  props: {
+    node: {},
+    selectedObject: {},
+    version: {}
+  },
+  emits: ["select", "delete"],
+  setup(r, { emit: e }) {
+    const t = r, s = e, n = K(null), { expandedSet: i, toggleExpand: o } = bn("treeExpand"), a = Be(() => i.value.has(t.node.uuid)), l = Be(() => (t.version, t.node.children.some((m) => m.userData.isMovable === !0))), h = Be(() => (t.version, t.node.children.filter(
+      (m) => m.userData.isMovable === !0
+    ))), u = Be(
+      () => {
+        var m;
+        return ((m = t.selectedObject) == null ? void 0 : m.uuid) === t.node.uuid;
+      }
+    );
+    wn(
+      () => {
+        u.value && n.value && n.value.scrollIntoView({
+          block: "nearest",
+          // 仅当元素不在可视区域时才滚动
+          behavior: "smooth"
+          // 平滑滚动
+        });
+      },
+      { flush: "post" }
+    );
+    const c = (m) => {
+      m.stopPropagation(), s("select", t.node);
+    }, d = (m) => {
+      m.stopPropagation(), s("delete", t.node);
+    }, p = (m) => m.type === "Mesh" || m.type === "Sprite" ? "🟦" : m.type === "Light" ? "💡" : "📦", f = (m) => m.name || `${m.type} (${m.id})`;
+    return (m, y) => {
+      const _ = Tn("TreeItem", !0);
+      return Y(), q("div", {
+        class: "tree-node",
+        ref_key: "nodeRef",
+        ref: n
+      }, [
+        g("div", {
+          class: xn(["tree-item", { selected: u.value }]),
+          onClick: c
+        }, [
+          l.value ? (Y(), q("span", {
+            key: 0,
+            class: "toggle-icon",
+            onClick: y[0] || (y[0] = vt((x) => En(o)(r.node.uuid), ["stop"]))
+          }, st(a.value ? "▼" : "▶"), 1)) : (Y(), q("span", Bi)),
+          g("span", Ki, st(p(r.node)), 1),
+          g("span", Vi, st(f(r.node)), 1),
+          g("button", {
+            class: "tree-delete",
+            onClick: vt(d, ["stop"])
+          }, "×")
+        ], 2),
+        a.value && l.value ? (Y(), q("div", Zi, [
+          (Y(!0), q($t, null, Jt(h.value, (x) => (Y(), en(_, {
+            key: x.uuid,
+            node: x,
+            "selected-object": r.selectedObject,
+            version: r.version,
+            onSelect: y[1] || (y[1] = (M) => s("select", M)),
+            onDelete: y[2] || (y[2] = (M) => s("delete", M))
+          }, null, 8, ["node", "selected-object", "version"]))), 128))
+        ])) : tn("", !0)
+      ], 512);
+    };
+  }
+}), Ue = (r, e) => {
+  const t = r.__vccOpts || r;
+  for (const [s, n] of e)
+    t[s] = n;
+  return t;
+}, qi = /* @__PURE__ */ Ue(Qi, [["__scopeId", "data-v-5ad9c842"]]);
+function Wi(r) {
+  const e = K(/* @__PURE__ */ new Set()), t = (n) => {
+    const i = new Set(e.value);
+    i.has(n) ? i.delete(n) : i.add(n), e.value = i;
+  }, s = (n) => {
+    if (!n) return;
+    const i = new Set(e.value);
+    let o = n.parent;
+    for (; o && o.type !== "Scene"; )
+      i.add(o.uuid), o = o.parent;
+    e.value = i;
+  };
+  return Mn(
+    r,
+    (n) => {
+      n && s(n);
+    },
+    { immediate: !0 }
+  ), { expandedSet: e, toggleExpand: t };
+}
+const $i = {
+  key: 0,
+  class: "property-panel"
+}, Ji = { class: "property-group tree-group" }, eo = { class: "tree-container" }, to = {
+  key: 0,
+  class: "tree-empty"
+}, no = { class: "property-group" }, so = { class: "row" }, io = { class: "property-group" }, oo = { class: "row" }, ro = { class: "property-group" }, ao = { class: "row" }, lo = {
+  key: 1,
+  class: "property-panel empty"
+}, co = /* @__PURE__ */ Fe({
+  __name: "PropertyPanel",
+  props: {
+    transform: {},
+    treeData: {},
+    selectedObject: {}
+  },
+  emits: ["propertyChange", "treeSelect", "treeDelete"],
+  setup(r, { emit: e }) {
+    const t = r, s = e, n = () => s("propertyChange"), i = K(0), o = Sn(t, "selectedObject"), { expandedSet: a, toggleExpand: l } = Wi(o);
+    vn("treeExpand", { expandedSet: a, toggleExpand: l });
+    const h = (u) => {
+      i.value++, s("treeDelete", u);
+    };
+    return (u, c) => r.transform ? (Y(), q("div", $i, [
+      c[23] || (c[23] = g("h3", null, "属性面板", -1)),
+      g("div", Ji, [
+        c[10] || (c[10] = g("label", null, "场景物体", -1)),
+        g("div", eo, [
+          (Y(!0), q($t, null, Jt(r.treeData, (d) => (Y(), en(qi, {
+            key: d.uuid,
+            node: d,
+            "selected-object": r.selectedObject,
+            version: i.value,
+            onSelect: c[0] || (c[0] = (p) => s("treeSelect", p)),
+            onDelete: h
+          }, null, 8, ["node", "selected-object", "version"]))), 128)),
+          r.treeData.length === 0 ? (Y(), q("div", to, "暂无物体")) : tn("", !0)
+        ])
+      ]),
+      g("div", no, [
+        c[14] || (c[14] = g("label", null, "位置", -1)),
+        g("div", so, [
+          c[11] || (c[11] = g("span", null, "X:", -1)),
+          H(g("input", {
+            type: "number",
+            "onUpdate:modelValue": c[1] || (c[1] = (d) => r.transform.position.x = d),
+            step: "0.01",
+            onInput: n
+          }, null, 544), [
+            [
+              oe,
+              r.transform.position.x,
+              void 0,
+              { number: !0 }
+            ]
+          ]),
+          c[12] || (c[12] = g("span", null, "Y:", -1)),
+          H(g("input", {
+            type: "number",
+            "onUpdate:modelValue": c[2] || (c[2] = (d) => r.transform.position.y = d),
+            step: "0.01",
+            onInput: n
+          }, null, 544), [
+            [
+              oe,
+              r.transform.position.y,
+              void 0,
+              { number: !0 }
+            ]
+          ]),
+          c[13] || (c[13] = g("span", null, "Z:", -1)),
+          H(g("input", {
+            type: "number",
+            "onUpdate:modelValue": c[3] || (c[3] = (d) => r.transform.position.z = d),
+            step: "0.01",
+            onInput: n
+          }, null, 544), [
+            [
+              oe,
+              r.transform.position.z,
+              void 0,
+              { number: !0 }
+            ]
+          ])
+        ])
+      ]),
+      g("div", io, [
+        c[18] || (c[18] = g("label", null, "旋转 (弧度)", -1)),
+        g("div", oo, [
+          c[15] || (c[15] = g("span", null, "X:", -1)),
+          H(g("input", {
+            type: "number",
+            "onUpdate:modelValue": c[4] || (c[4] = (d) => r.transform.rotation.x = d),
+            step: "0.01",
+            onInput: n
+          }, null, 544), [
+            [
+              oe,
+              r.transform.rotation.x,
+              void 0,
+              { number: !0 }
+            ]
+          ]),
+          c[16] || (c[16] = g("span", null, "Y:", -1)),
+          H(g("input", {
+            type: "number",
+            "onUpdate:modelValue": c[5] || (c[5] = (d) => r.transform.rotation.y = d),
+            step: "0.01",
+            onInput: n
+          }, null, 544), [
+            [
+              oe,
+              r.transform.rotation.y,
+              void 0,
+              { number: !0 }
+            ]
+          ]),
+          c[17] || (c[17] = g("span", null, "Z:", -1)),
+          H(g("input", {
+            type: "number",
+            "onUpdate:modelValue": c[6] || (c[6] = (d) => r.transform.rotation.z = d),
+            step: "0.01",
+            onInput: n
+          }, null, 544), [
+            [
+              oe,
+              r.transform.rotation.z,
+              void 0,
+              { number: !0 }
+            ]
+          ])
+        ])
+      ]),
+      g("div", ro, [
+        c[22] || (c[22] = g("label", null, "缩放", -1)),
+        g("div", ao, [
+          c[19] || (c[19] = g("span", null, "X:", -1)),
+          H(g("input", {
+            type: "number",
+            "onUpdate:modelValue": c[7] || (c[7] = (d) => r.transform.scale.x = d),
+            step: "0.01",
+            onInput: n
+          }, null, 544), [
+            [
+              oe,
+              r.transform.scale.x,
+              void 0,
+              { number: !0 }
+            ]
+          ]),
+          c[20] || (c[20] = g("span", null, "Y:", -1)),
+          H(g("input", {
+            type: "number",
+            "onUpdate:modelValue": c[8] || (c[8] = (d) => r.transform.scale.y = d),
+            step: "0.01",
+            onInput: n
+          }, null, 544), [
+            [
+              oe,
+              r.transform.scale.y,
+              void 0,
+              { number: !0 }
+            ]
+          ]),
+          c[21] || (c[21] = g("span", null, "Z:", -1)),
+          H(g("input", {
+            type: "number",
+            "onUpdate:modelValue": c[9] || (c[9] = (d) => r.transform.scale.z = d),
+            step: "0.01",
+            onInput: n
+          }, null, 544), [
+            [
+              oe,
+              r.transform.scale.z,
+              void 0,
+              { number: !0 }
+            ]
+          ])
+        ])
+      ])
+    ])) : (Y(), q("div", lo, [...c[24] || (c[24] = [
+      g("p", null, "未选中任何模型", -1)
+    ])]));
+  }
+}), ho = /* @__PURE__ */ Ue(co, [["__scopeId", "data-v-94ef5fd1"]]), uo = { class: "top-bar" }, po = { class: "left-section" }, fo = { class: "dropdown-menu" }, mo = { class: "dropdown-menu sub-menu" }, go = { class: "dropdown-menu" }, yo = { class: "dropdown-menu sub-menu" }, _o = { class: "dropdown-menu" }, bo = { class: "dropdown-menu" }, wo = { class: "dropdown-menu" }, To = /* @__PURE__ */ Fe({
+  __name: "TopBar",
+  emits: ["addModel", "importModel"],
+  setup(r, { emit: e }) {
+    const t = K(!1), s = K(!1), n = K(!1), i = K(!1), o = K(!1), a = K(!1), l = K(!1), h = e, u = K(null), c = () => {
+      var W;
+      return (W = u.value) == null ? void 0 : W.click();
+    }, d = (W) => {
+      const T = W.target;
+      T.files && T.files.length > 0 && (h("importModel", T.files[0]), T.value = "");
+    }, p = () => console.log("新建项目"), f = () => console.log("保存场景"), m = () => console.log("导出模型"), y = () => console.log("撤销"), _ = () => console.log("重做"), x = () => console.log("复制物体"), M = () => console.log("删除物体"), S = () => console.log("重置相机"), L = () => console.log("切换网格"), v = () => console.log("打开帮助"), I = () => console.log("关于编辑器"), se = () => console.log("打开项目"), J = () => console.log("打开模型"), de = () => console.log("打开场景");
+    return (W, T) => (Y(), q("div", uo, [
+      g("div", po, [
+        g("div", {
+          class: "dropdown-wrapper",
+          onMouseenter: T[2] || (T[2] = (k) => t.value = !0),
+          onMouseleave: T[3] || (T[3] = (k) => t.value = !1)
+        }, [
+          T[17] || (T[17] = g("button", { class: "menu-btn" }, "文件", -1)),
+          H(g("div", fo, [
+            g("div", {
+              class: "menu-item",
+              onClick: p
+            }, "新建"),
+            g("div", {
+              class: "menu-item dropdown-wrapper sub-trigger",
+              onMouseenter: T[0] || (T[0] = (k) => a.value = !0),
+              onMouseleave: T[1] || (T[1] = (k) => a.value = !1)
+            }, [
+              T[16] || (T[16] = g("span", null, "打开", -1)),
+              H(g("div", mo, [
+                g("div", {
+                  class: "menu-item",
+                  onClick: se
+                }, "打开项目"),
+                g("div", {
+                  class: "menu-item",
+                  onClick: J
+                }, "打开模型"),
+                g("div", {
+                  class: "menu-item",
+                  onClick: de
+                }, "打开场景")
+              ], 512), [
+                [pe, a.value]
+              ])
+            ], 32),
+            g("div", {
+              class: "menu-item",
+              onClick: f
+            }, "保存"),
+            g("div", {
+              class: "menu-item",
+              onClick: m
+            }, "导出")
+          ], 512), [
+            [pe, t.value]
+          ])
+        ], 32),
+        g("div", {
+          class: "dropdown-wrapper",
+          onMouseenter: T[8] || (T[8] = (k) => o.value = !0),
+          onMouseleave: T[9] || (T[9] = (k) => o.value = !1)
+        }, [
+          T[19] || (T[19] = g("button", { class: "menu-btn" }, "添加", -1)),
+          H(g("div", go, [
+            g("div", {
+              class: "menu-item",
+              onClick: y
+            }, "组"),
+            g("div", {
+              class: "menu-item dropdown-wrapper sub-trigger",
+              onMouseenter: T[6] || (T[6] = (k) => l.value = !0),
+              onMouseleave: T[7] || (T[7] = (k) => l.value = !1)
+            }, [
+              T[18] || (T[18] = g("span", null, "网格", -1)),
+              H(g("div", yo, [
+                g("div", {
+                  class: "menu-item",
+                  onClick: T[4] || (T[4] = (k) => h("addModel", "box"))
+                }, " 正方体 "),
+                g("div", {
+                  class: "menu-item",
+                  onClick: T[5] || (T[5] = (k) => h("addModel", "sphere"))
+                }, " 球体 "),
+                g("div", {
+                  class: "menu-item",
+                  onClick: c
+                }, "导入")
+              ], 512), [
+                [pe, l.value]
+              ])
+            ], 32),
+            g("div", {
+              class: "menu-item",
+              onClick: x
+            }, "光源"),
+            g("div", {
+              class: "menu-item",
+              onClick: M
+            }, "摄像机")
+          ], 512), [
+            [pe, o.value]
+          ])
+        ], 32),
+        g("div", {
+          class: "dropdown-wrapper",
+          onMouseenter: T[10] || (T[10] = (k) => s.value = !0),
+          onMouseleave: T[11] || (T[11] = (k) => s.value = !1)
+        }, [
+          T[20] || (T[20] = g("button", { class: "menu-btn" }, "编辑", -1)),
+          H(g("div", _o, [
+            g("div", {
+              class: "menu-item",
+              onClick: y
+            }, "撤销"),
+            g("div", {
+              class: "menu-item",
+              onClick: _
+            }, "重做"),
+            g("div", {
+              class: "menu-item",
+              onClick: x
+            }, "复制"),
+            g("div", {
+              class: "menu-item",
+              onClick: M
+            }, "删除")
+          ], 512), [
+            [pe, s.value]
+          ])
+        ], 32),
+        g("div", {
+          class: "dropdown-wrapper",
+          onMouseenter: T[12] || (T[12] = (k) => n.value = !0),
+          onMouseleave: T[13] || (T[13] = (k) => n.value = !1)
+        }, [
+          T[21] || (T[21] = g("button", { class: "menu-btn" }, "视图", -1)),
+          H(g("div", bo, [
+            g("div", {
+              class: "menu-item",
+              onClick: S
+            }, "重置相机"),
+            g("div", {
+              class: "menu-item",
+              onClick: L
+            }, "显示网格")
+          ], 512), [
+            [pe, n.value]
+          ])
+        ], 32),
+        g("div", {
+          class: "dropdown-wrapper",
+          onMouseenter: T[14] || (T[14] = (k) => i.value = !0),
+          onMouseleave: T[15] || (T[15] = (k) => i.value = !1)
+        }, [
+          T[22] || (T[22] = g("button", { class: "menu-btn" }, "帮助", -1)),
+          H(g("div", wo, [
+            g("div", {
+              class: "menu-item",
+              onClick: v
+            }, "使用帮助"),
+            g("div", {
+              class: "menu-item",
+              onClick: I
+            }, "关于")
+          ], 512), [
+            [pe, i.value]
+          ])
+        ], 32)
+      ]),
+      T[23] || (T[23] = g("div", { class: "right-section" }, [
+        g("span", { class: "app-title" }, "3D 模型编辑器")
+      ], -1)),
+      g("input", {
+        type: "file",
+        ref_key: "fileInput",
+        ref: u,
+        accept: ".obj,.gltf,.glb",
+        style: { display: "none" },
+        onChange: d
+      }, null, 544)
+    ]));
+  }
+}), xo = /* @__PURE__ */ Ue(To, [["__scopeId", "data-v-6bb4762f"]]), Eo = { class: "bottom-bar" }, Mo = /* @__PURE__ */ Fe({
+  __name: "BottomBar",
+  setup(r) {
+    return (e, t) => (Y(), q("div", Eo, [...t[0] || (t[0] = [
+      g("div", { class: "status-left" }, [
+        g("span", null, "就绪")
+      ], -1),
+      g("div", { class: "status-right" }, [
+        g("span", null, "顶点: 0 | 面: 0")
+      ], -1)
+    ])]));
+  }
+}), So = /* @__PURE__ */ Ue(Mo, [["__scopeId", "data-v-3427bb27"]]), vo = { class: "app-layout" }, Ro = { class: "editor-container" }, Ao = /* @__PURE__ */ Fe({
+  __name: "DrawingBoard",
+  setup(r) {
+    const e = K(null), t = Rn({
+      position: { x: 0, y: 0, z: 0 },
+      rotation: { x: 0, y: 0, z: 0 },
+      scale: { x: 1, y: 1, z: 1 }
+    }), s = (f) => {
+      t.position.x = Number(f.position.x.toFixed(3)), t.position.y = Number(f.position.y.toFixed(3)), t.position.z = Number(f.position.z.toFixed(3)), t.rotation.x = Number(f.rotation.x.toFixed(3)), t.rotation.y = Number(f.rotation.y.toFixed(3)), t.rotation.z = Number(f.rotation.z.toFixed(3)), t.scale.x = Number(f.scale.x.toFixed(3)), t.scale.y = Number(f.scale.y.toFixed(3)), t.scale.z = Number(f.scale.z.toFixed(3));
+    }, n = (f) => {
+      f.position.set(
+        t.position.x,
+        t.position.y,
+        t.position.z
+      ), f.rotation.set(
+        t.rotation.x,
+        t.rotation.y,
+        t.rotation.z
+      ), f.scale.set(t.scale.x, t.scale.y, t.scale.z);
+    };
+    qs((f) => {
+      e.value = f, f && s(f);
+    }), Ws((f) => {
+      s(f);
+    });
+    const i = () => {
+      e.value && n(e.value);
+    }, o = (f) => Yi(f), a = async (f) => {
+      try {
+        await Xi(f);
+      } catch (m) {
+        console.error("导入失败:", m), alert("导入失败：" + m.message);
+      }
+    }, l = An([]);
+    $s((f) => {
+      l.value = f;
+    });
+    const h = () => {
+      const f = Js();
+      f && (l.value = f);
+    }, u = (f) => Et(f), c = (f) => Ks(f.uuid), d = K(null);
+    return Pn(() => {
+      d.value && Ns(d.value), h();
+    }), (f, m) => (Y(), q("div", vo, [
+      it(xo, {
+        onAddModel: o,
+        onImportModel: a
+      }),
+      g("div", Ro, [
+        g("div", {
+          class: "canvas",
+          ref_key: "containerRef",
+          ref: d
+        }, null, 512),
+        it(ho, {
+          transform: t,
+          "tree-data": l.value,
+          "selected-object": e.value,
+          onPropertyChange: i,
+          onTreeSelect: u,
+          onTreeDelete: c
+        }, null, 8, ["transform", "tree-data", "selected-object"])
+      ]),
+      it(So)
+    ]));
+  }
+}), Oo = /* @__PURE__ */ Ue(Ao, [["__scopeId", "data-v-a7595f5b"]]);
+export {
+  Oo as DrawingBoard
+};
+//# sourceMappingURL=three-editor.es.js.map