@ridp/threejs 1.1.7 → 1.2.1

package/dist/modelSerialize-5oJb1ka7.js

@@ -0,0 +1,965 @@
+import * as F from "three";
+import { Matrix4 as dt, Vector3 as x, Quaternion as et, Object3D as yt, Controls as gt, MOUSE as z, TOUCH as G, Spherical as nt, Vector2 as L, Ray as Et, Plane as bt, MathUtils as wt, CameraHelper as Dt, GridHelper as St, BoxHelper as Pt, Raycaster as Tt, AxesHelper as Mt, ArrowHelper as Rt, DataTextureLoader as xt, HalfFloatType as X, FloatType as $, DataUtils as V, LinearSRGBColorSpace as At, LinearFilter as at, EquirectangularReflectionMapping as Ot } from "three";
+var K = function() {
+  var e = 0, t = document.createElement("div");
+  t.style.cssText = "position:fixed;top:0;left:0;cursor:pointer;opacity:0.9;z-index:10000", t.addEventListener("click", function(m) {
+    m.preventDefault(), o(++e % t.children.length);
+  }, !1);
+  function i(m) {
+    return t.appendChild(m.dom), m;
+  }
+  function o(m) {
+    for (var h = 0; h < t.children.length; h++)
+      t.children[h].style.display = h === m ? "block" : "none";
+    e = m;
+  }
+  var r = (performance || Date).now(), c = r, a = 0, f = i(new K.Panel("FPS", "#0ff", "#002")), P = i(new K.Panel("MS", "#0f0", "#020"));
+  if (self.performance && self.performance.memory)
+    var b = i(new K.Panel("MB", "#f08", "#201"));
+  return o(0), {
+    REVISION: 16,
+    dom: t,
+    addPanel: i,
+    showPanel: o,
+    begin: function() {
+      r = (performance || Date).now();
+    },
+    end: function() {
+      a++;
+      var m = (performance || Date).now();
+      if (P.update(m - r, 200), m >= c + 1e3 && (f.update(a * 1e3 / (m - c), 100), c = m, a = 0, b)) {
+        var h = performance.memory;
+        b.update(h.usedJSHeapSize / 1048576, h.jsHeapSizeLimit / 1048576);
+      }
+      return m;
+    },
+    update: function() {
+      r = this.end();
+    },
+    // Backwards Compatibility
+    domElement: t,
+    setMode: o
+  };
+};
+K.Panel = function(e, t, i) {
+  var o = 1 / 0, r = 0, c = Math.round, a = c(window.devicePixelRatio || 1), f = 80 * a, P = 48 * a, b = 3 * a, m = 2 * a, h = 3 * a, O = 15 * a, v = 74 * a, C = 30 * a, k = document.createElement("canvas");
+  k.width = f, k.height = P, k.style.cssText = "width:80px;height:48px";
+  var n = k.getContext("2d");
+  return n.font = "bold " + 9 * a + "px Helvetica,Arial,sans-serif", n.textBaseline = "top", n.fillStyle = i, n.fillRect(0, 0, f, P), n.fillStyle = t, n.fillText(e, b, m), n.fillRect(h, O, v, C), n.fillStyle = i, n.globalAlpha = 0.9, n.fillRect(h, O, v, C), {
+    dom: k,
+    update: function(s, T) {
+      o = Math.min(o, s), r = Math.max(r, s), n.fillStyle = i, n.globalAlpha = 1, n.fillRect(0, 0, f, O), n.fillStyle = t, n.fillText(c(s) + " " + e + " (" + c(o) + "-" + c(r) + ")", b, m), n.drawImage(k, h + a, O, v - a, C, h, O, v - a, C), n.fillRect(h + v - a, O, a, C), n.fillStyle = i, n.globalAlpha = 0.9, n.fillRect(h + v - a, O, a, c((1 - s / T) * C));
+    }
+  };
+};
+const rt = new x(), Lt = new et(), ht = new x();
+class vt extends yt {
+  /**
+   * Constructs a new CSS3D object.
+   *
+   * @param {DOMElement} [element] - The DOM element.
+   */
+  constructor(t = document.createElement("div")) {
+    super(), this.isCSS3DObject = !0, this.element = t, this.element.style.position = "absolute", this.element.style.pointerEvents = "auto", this.element.style.userSelect = "none", this.element.setAttribute("draggable", !1), this.addEventListener("removed", function() {
+      this.traverse(function(i) {
+        i.element instanceof i.element.ownerDocument.defaultView.Element && i.element.parentNode !== null && i.element.remove();
+      });
+    });
+  }
+  copy(t, i) {
+    return super.copy(t, i), this.element = t.element.cloneNode(!0), this;
+  }
+}
+class se extends vt {
+  /**
+   * Constructs a new CSS3D sprite object.
+   *
+   * @param {DOMElement} [element] - The DOM element.
+   */
+  constructor(t) {
+    super(t), this.isCSS3DSprite = !0, this.rotation2D = 0;
+  }
+  copy(t, i) {
+    return super.copy(t, i), this.rotation2D = t.rotation2D, this;
+  }
+}
+const H = new dt(), Ct = new dt();
+class oe {
+  /**
+   * Constructs a new CSS3D renderer.
+   *
+   * @param {CSS3DRenderer~Parameters} [parameters] - The parameters.
+   */
+  constructor(t = {}) {
+    const i = this;
+    let o, r, c, a;
+    const f = {
+      camera: { style: "" },
+      objects: /* @__PURE__ */ new WeakMap()
+    }, P = t.element !== void 0 ? t.element : document.createElement("div");
+    P.style.overflow = "hidden", this.domElement = P;
+    const b = document.createElement("div");
+    b.style.transformOrigin = "0 0", b.style.pointerEvents = "none", P.appendChild(b);
+    const m = document.createElement("div");
+    m.style.transformStyle = "preserve-3d", b.appendChild(m), this.getSize = function() {
+      return {
+        width: o,
+        height: r
+      };
+    }, this.render = function(n, s) {
+      const T = s.projectionMatrix.elements[5] * a;
+      s.view && s.view.enabled ? (b.style.transform = `translate( ${-s.view.offsetX * (o / s.view.width)}px, ${-s.view.offsetY * (r / s.view.height)}px )`, b.style.transform += `scale( ${s.view.fullWidth / s.view.width}, ${s.view.fullHeight / s.view.height} )`) : b.style.transform = "", n.matrixWorldAutoUpdate === !0 && n.updateMatrixWorld(), s.parent === null && s.matrixWorldAutoUpdate === !0 && s.updateMatrixWorld();
+      let B, M;
+      s.isOrthographicCamera && (B = -(s.right + s.left) / 2, M = (s.top + s.bottom) / 2);
+      const A = s.view && s.view.enabled ? s.view.height / s.view.fullHeight : 1, I = s.isOrthographicCamera ? `scale( ${A} )scale(` + T + ")translate(" + h(B) + "px," + h(M) + "px)" + O(s.matrixWorldInverse) : `scale( ${A} )translateZ(` + T + "px)" + O(s.matrixWorldInverse), l = (s.isPerspectiveCamera ? "perspective(" + T + "px) " : "") + I + "translate(" + c + "px," + a + "px)";
+      f.camera.style !== l && (m.style.transform = l, f.camera.style = l), k(n, n, s);
+    }, this.setSize = function(n, s) {
+      o = n, r = s, c = o / 2, a = r / 2, P.style.width = n + "px", P.style.height = s + "px", b.style.width = n + "px", b.style.height = s + "px", m.style.width = n + "px", m.style.height = s + "px";
+    };
+    function h(n) {
+      return Math.abs(n) < 1e-10 ? 0 : n;
+    }
+    function O(n) {
+      const s = n.elements;
+      return "matrix3d(" + h(s[0]) + "," + h(-s[1]) + "," + h(s[2]) + "," + h(s[3]) + "," + h(s[4]) + "," + h(-s[5]) + "," + h(s[6]) + "," + h(s[7]) + "," + h(s[8]) + "," + h(-s[9]) + "," + h(s[10]) + "," + h(s[11]) + "," + h(s[12]) + "," + h(-s[13]) + "," + h(s[14]) + "," + h(s[15]) + ")";
+    }
+    function v(n) {
+      const s = n.elements;
+      return "translate(-50%,-50%)" + ("matrix3d(" + h(s[0]) + "," + h(s[1]) + "," + h(s[2]) + "," + h(s[3]) + "," + h(-s[4]) + "," + h(-s[5]) + "," + h(-s[6]) + "," + h(-s[7]) + "," + h(s[8]) + "," + h(s[9]) + "," + h(s[10]) + "," + h(s[11]) + "," + h(s[12]) + "," + h(s[13]) + "," + h(s[14]) + "," + h(s[15]) + ")");
+    }
+    function C(n) {
+      n.isCSS3DObject && (n.element.style.display = "none");
+      for (let s = 0, T = n.children.length; s < T; s++)
+        C(n.children[s]);
+    }
+    function k(n, s, T, B) {
+      if (n.visible === !1) {
+        C(n);
+        return;
+      }
+      if (n.isCSS3DObject) {
+        const M = n.layers.test(T.layers) === !0, A = n.element;
+        if (A.style.display = M === !0 ? "" : "none", M === !0) {
+          n.onBeforeRender(i, s, T);
+          let I;
+          n.isCSS3DSprite ? (H.copy(T.matrixWorldInverse), H.transpose(), n.rotation2D !== 0 && H.multiply(Ct.makeRotationZ(n.rotation2D)), n.matrixWorld.decompose(rt, Lt, ht), H.setPosition(rt), H.scale(ht), H.elements[3] = 0, H.elements[7] = 0, H.elements[11] = 0, H.elements[15] = 1, I = v(H)) : I = v(n.matrixWorld);
+          const N = f.objects.get(n);
+          if (N === void 0 || N.style !== I) {
+            A.style.transform = I;
+            const l = { style: I };
+            f.objects.set(n, l);
+          }
+          A.parentNode !== m && m.appendChild(A), n.onAfterRender(i, s, T);
+        }
+      }
+      for (let M = 0, A = n.children.length; M < A; M++)
+        k(n.children[M], s, T);
+    }
+  }
+}
+const lt = { type: "change" }, it = { type: "start" }, ut = { type: "end" }, q = new Et(), ct = new bt(), kt = Math.cos(70 * wt.DEG2RAD), S = new x(), R = 2 * Math.PI, d = {
+  NONE: -1,
+  ROTATE: 0,
+  DOLLY: 1,
+  PAN: 2,
+  TOUCH_ROTATE: 3,
+  TOUCH_PAN: 4,
+  TOUCH_DOLLY_PAN: 5,
+  TOUCH_DOLLY_ROTATE: 6
+}, Q = 1e-6;
+class mt extends gt {
+  /**
+   * Constructs a new controls instance.
+   *
+   * @param {Object3D} object - The object that is managed by the controls.
+   * @param {?HTMLDOMElement} domElement - The HTML element used for event listeners.
+   */
+  constructor(t, i = null) {
+    super(t, i), this.state = d.NONE, this.target = new x(), this.cursor = new x(), 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: z.ROTATE, MIDDLE: z.DOLLY, RIGHT: z.PAN }, this.touches = { ONE: G.ROTATE, TWO: G.DOLLY_PAN }, this.target0 = this.target.clone(), this.position0 = this.object.position.clone(), this.zoom0 = this.object.zoom, this._domElementKeyEvents = null, this._lastPosition = new x(), this._lastQuaternion = new et(), this._lastTargetPosition = new x(), this._quat = new et().setFromUnitVectors(t.up, new x(0, 1, 0)), this._quatInverse = this._quat.clone().invert(), this._spherical = new nt(), this._sphericalDelta = new nt(), this._scale = 1, this._panOffset = new x(), this._rotateStart = new L(), this._rotateEnd = new L(), this._rotateDelta = new L(), this._panStart = new L(), this._panEnd = new L(), this._panDelta = new L(), this._dollyStart = new L(), this._dollyEnd = new L(), this._dollyDelta = new L(), this._dollyDirection = new x(), this._mouse = new L(), this._performCursorZoom = !1, this._pointers = [], this._pointerPositions = {}, this._controlActive = !1, this._onPointerMove = Nt.bind(this), this._onPointerDown = It.bind(this), this._onPointerUp = Ht.bind(this), this._onContextMenu = Bt.bind(this), this._onMouseWheel = Yt.bind(this), this._onKeyDown = zt.bind(this), this._onTouchStart = Gt.bind(this), this._onTouchMove = Ft.bind(this), this._onMouseDown = jt.bind(this), this._onMouseMove = Ut.bind(this), this._interceptControlDown = Zt.bind(this), this._interceptControlUp = Wt.bind(this), this.domElement !== null && this.connect(this.domElement), this.update();
+  }
+  connect(t) {
+    super.connect(t), this.domElement.addEventListener("pointerdown", this._onPointerDown), this.domElement.addEventListener("pointercancel", this._onPointerUp), this.domElement.addEventListener("contextmenu", this._onContextMenu), this.domElement.addEventListener("wheel", this._onMouseWheel, { passive: !1 }), this.domElement.getRootNode().addEventListener("keydown", this._interceptControlDown, { passive: !0, capture: !0 }), this.domElement.style.touchAction = "none";
+  }
+  disconnect() {
+    this.domElement.removeEventListener("pointerdown", this._onPointerDown), this.domElement.removeEventListener("pointermove", this._onPointerMove), this.domElement.removeEventListener("pointerup", this._onPointerUp), this.domElement.removeEventListener("pointercancel", this._onPointerUp), this.domElement.removeEventListener("wheel", this._onMouseWheel), this.domElement.removeEventListener("contextmenu", this._onContextMenu), this.stopListenToKeyEvents(), this.domElement.getRootNode().removeEventListener("keydown", this._interceptControlDown, { capture: !0 }), this.domElement.style.touchAction = "auto";
+  }
+  dispose() {
+    this.disconnect();
+  }
+  /**
+   * Get the current vertical rotation, in radians.
+   *
+   * @return {number} The current vertical rotation, in radians.
+   */
+  getPolarAngle() {
+    return this._spherical.phi;
+  }
+  /**
+   * Get the current horizontal rotation, in radians.
+   *
+   * @return {number} The current horizontal rotation, in radians.
+   */
+  getAzimuthalAngle() {
+    return this._spherical.theta;
+  }
+  /**
+   * Returns the distance from the camera to the target.
+   *
+   * @return {number} The distance from the camera to the target.
+   */
+  getDistance() {
+    return this.object.position.distanceTo(this.target);
+  }
+  /**
+   * Adds key event listeners to the given DOM element.
+   * `window` is a recommended argument for using this method.
+   *
+   * @param {HTMLDOMElement} domElement - The DOM element
+   */
+  listenToKeyEvents(t) {
+    t.addEventListener("keydown", this._onKeyDown), this._domElementKeyEvents = t;
+  }
+  /**
+   * 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(lt), this.update(), this.state = d.NONE;
+  }
+  update(t = null) {
+    const i = this.object.position;
+    S.copy(i).sub(this.target), S.applyQuaternion(this._quat), this._spherical.setFromVector3(S), this.autoRotate && this.state === d.NONE && this._rotateLeft(this._getAutoRotationAngle(t)), 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 o = this.minAzimuthAngle, r = this.maxAzimuthAngle;
+    isFinite(o) && isFinite(r) && (o < -Math.PI ? o += R : o > Math.PI && (o -= R), r < -Math.PI ? r += R : r > Math.PI && (r -= R), o <= r ? this._spherical.theta = Math.max(o, Math.min(r, this._spherical.theta)) : this._spherical.theta = this._spherical.theta > (o + r) / 2 ? Math.max(o, this._spherical.theta) : Math.min(r, 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 c = !1;
+    if (this.zoomToCursor && this._performCursorZoom || this.object.isOrthographicCamera)
+      this._spherical.radius = this._clampDistance(this._spherical.radius);
+    else {
+      const a = this._spherical.radius;
+      this._spherical.radius = this._clampDistance(this._spherical.radius * this._scale), c = a != this._spherical.radius;
+    }
+    if (S.setFromSpherical(this._spherical), S.applyQuaternion(this._quatInverse), i.copy(this.target).add(S), 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 a = null;
+      if (this.object.isPerspectiveCamera) {
+        const f = S.length();
+        a = this._clampDistance(f * this._scale);
+        const P = f - a;
+        this.object.position.addScaledVector(this._dollyDirection, P), this.object.updateMatrixWorld(), c = !!P;
+      } else if (this.object.isOrthographicCamera) {
+        const f = new x(this._mouse.x, this._mouse.y, 0);
+        f.unproject(this.object);
+        const P = this.object.zoom;
+        this.object.zoom = Math.max(this.minZoom, Math.min(this.maxZoom, this.object.zoom / this._scale)), this.object.updateProjectionMatrix(), c = P !== this.object.zoom;
+        const b = new x(this._mouse.x, this._mouse.y, 0);
+        b.unproject(this.object), this.object.position.sub(b).add(f), this.object.updateMatrixWorld(), a = S.length();
+      } else
+        console.warn("WARNING: OrbitControls.js encountered an unknown camera type - zoom to cursor disabled."), this.zoomToCursor = !1;
+      a !== null && (this.screenSpacePanning ? this.target.set(0, 0, -1).transformDirection(this.object.matrix).multiplyScalar(a).add(this.object.position) : (q.origin.copy(this.object.position), q.direction.set(0, 0, -1).transformDirection(this.object.matrix), Math.abs(this.object.up.dot(q.direction)) < kt ? this.object.lookAt(this.target) : (ct.setFromNormalAndCoplanarPoint(this.object.up, this.target), q.intersectPlane(ct, this.target))));
+    } else if (this.object.isOrthographicCamera) {
+      const a = this.object.zoom;
+      this.object.zoom = Math.max(this.minZoom, Math.min(this.maxZoom, this.object.zoom / this._scale)), a !== this.object.zoom && (this.object.updateProjectionMatrix(), c = !0);
+    }
+    return this._scale = 1, this._performCursorZoom = !1, c || this._lastPosition.distanceToSquared(this.object.position) > Q || 8 * (1 - this._lastQuaternion.dot(this.object.quaternion)) > Q || this._lastTargetPosition.distanceToSquared(this.target) > Q ? (this.dispatchEvent(lt), this._lastPosition.copy(this.object.position), this._lastQuaternion.copy(this.object.quaternion), this._lastTargetPosition.copy(this.target), !0) : !1;
+  }
+  _getAutoRotationAngle(t) {
+    return t !== null ? R / 60 * this.autoRotateSpeed * t : R / 60 / 60 * this.autoRotateSpeed;
+  }
+  _getZoomScale(t) {
+    const i = Math.abs(t * 0.01);
+    return Math.pow(0.95, this.zoomSpeed * i);
+  }
+  _rotateLeft(t) {
+    this._sphericalDelta.theta -= t;
+  }
+  _rotateUp(t) {
+    this._sphericalDelta.phi -= t;
+  }
+  _panLeft(t, i) {
+    S.setFromMatrixColumn(i, 0), S.multiplyScalar(-t), this._panOffset.add(S);
+  }
+  _panUp(t, i) {
+    this.screenSpacePanning === !0 ? S.setFromMatrixColumn(i, 1) : (S.setFromMatrixColumn(i, 0), S.crossVectors(this.object.up, S)), S.multiplyScalar(t), this._panOffset.add(S);
+  }
+  // deltaX and deltaY are in pixels; right and down are positive
+  _pan(t, i) {
+    const o = this.domElement;
+    if (this.object.isPerspectiveCamera) {
+      const r = this.object.position;
+      S.copy(r).sub(this.target);
+      let c = S.length();
+      c *= Math.tan(this.object.fov / 2 * Math.PI / 180), this._panLeft(2 * t * c / o.clientHeight, this.object.matrix), this._panUp(2 * i * c / o.clientHeight, this.object.matrix);
+    } else this.object.isOrthographicCamera ? (this._panLeft(t * (this.object.right - this.object.left) / this.object.zoom / o.clientWidth, this.object.matrix), this._panUp(i * (this.object.top - this.object.bottom) / this.object.zoom / o.clientHeight, this.object.matrix)) : (console.warn("WARNING: OrbitControls.js encountered an unknown camera type - pan disabled."), this.enablePan = !1);
+  }
+  _dollyOut(t) {
+    this.object.isPerspectiveCamera || this.object.isOrthographicCamera ? this._scale /= t : (console.warn("WARNING: OrbitControls.js encountered an unknown camera type - dolly/zoom disabled."), this.enableZoom = !1);
+  }
+  _dollyIn(t) {
+    this.object.isPerspectiveCamera || this.object.isOrthographicCamera ? this._scale *= t : (console.warn("WARNING: OrbitControls.js encountered an unknown camera type - dolly/zoom disabled."), this.enableZoom = !1);
+  }
+  _updateZoomParameters(t, i) {
+    if (!this.zoomToCursor)
+      return;
+    this._performCursorZoom = !0;
+    const o = this.domElement.getBoundingClientRect(), r = t - o.left, c = i - o.top, a = o.width, f = o.height;
+    this._mouse.x = r / a * 2 - 1, this._mouse.y = -(c / f) * 2 + 1, this._dollyDirection.set(this._mouse.x, this._mouse.y, 1).unproject(this.object).sub(this.object.position).normalize();
+  }
+  _clampDistance(t) {
+    return Math.max(this.minDistance, Math.min(this.maxDistance, t));
+  }
+  //
+  // event callbacks - update the object state
+  //
+  _handleMouseDownRotate(t) {
+    this._rotateStart.set(t.clientX, t.clientY);
+  }
+  _handleMouseDownDolly(t) {
+    this._updateZoomParameters(t.clientX, t.clientX), this._dollyStart.set(t.clientX, t.clientY);
+  }
+  _handleMouseDownPan(t) {
+    this._panStart.set(t.clientX, t.clientY);
+  }
+  _handleMouseMoveRotate(t) {
+    this._rotateEnd.set(t.clientX, t.clientY), this._rotateDelta.subVectors(this._rotateEnd, this._rotateStart).multiplyScalar(this.rotateSpeed);
+    const i = this.domElement;
+    this._rotateLeft(R * this._rotateDelta.x / i.clientHeight), this._rotateUp(R * this._rotateDelta.y / i.clientHeight), this._rotateStart.copy(this._rotateEnd), this.update();
+  }
+  _handleMouseMoveDolly(t) {
+    this._dollyEnd.set(t.clientX, t.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(t) {
+    this._panEnd.set(t.clientX, t.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(t) {
+    this._updateZoomParameters(t.clientX, t.clientY), t.deltaY < 0 ? this._dollyIn(this._getZoomScale(t.deltaY)) : t.deltaY > 0 && this._dollyOut(this._getZoomScale(t.deltaY)), this.update();
+  }
+  _handleKeyDown(t) {
+    let i = !1;
+    switch (t.code) {
+      case this.keys.UP:
+        t.ctrlKey || t.metaKey || t.shiftKey ? this.enableRotate && this._rotateUp(R * this.keyRotateSpeed / this.domElement.clientHeight) : this.enablePan && this._pan(0, this.keyPanSpeed), i = !0;
+        break;
+      case this.keys.BOTTOM:
+        t.ctrlKey || t.metaKey || t.shiftKey ? this.enableRotate && this._rotateUp(-R * this.keyRotateSpeed / this.domElement.clientHeight) : this.enablePan && this._pan(0, -this.keyPanSpeed), i = !0;
+        break;
+      case this.keys.LEFT:
+        t.ctrlKey || t.metaKey || t.shiftKey ? this.enableRotate && this._rotateLeft(R * this.keyRotateSpeed / this.domElement.clientHeight) : this.enablePan && this._pan(this.keyPanSpeed, 0), i = !0;
+        break;
+      case this.keys.RIGHT:
+        t.ctrlKey || t.metaKey || t.shiftKey ? this.enableRotate && this._rotateLeft(-R * this.keyRotateSpeed / this.domElement.clientHeight) : this.enablePan && this._pan(-this.keyPanSpeed, 0), i = !0;
+        break;
+    }
+    i && (t.preventDefault(), this.update());
+  }
+  _handleTouchStartRotate(t) {
+    if (this._pointers.length === 1)
+      this._rotateStart.set(t.pageX, t.pageY);
+    else {
+      const i = this._getSecondPointerPosition(t), o = 0.5 * (t.pageX + i.x), r = 0.5 * (t.pageY + i.y);
+      this._rotateStart.set(o, r);
+    }
+  }
+  _handleTouchStartPan(t) {
+    if (this._pointers.length === 1)
+      this._panStart.set(t.pageX, t.pageY);
+    else {
+      const i = this._getSecondPointerPosition(t), o = 0.5 * (t.pageX + i.x), r = 0.5 * (t.pageY + i.y);
+      this._panStart.set(o, r);
+    }
+  }
+  _handleTouchStartDolly(t) {
+    const i = this._getSecondPointerPosition(t), o = t.pageX - i.x, r = t.pageY - i.y, c = Math.sqrt(o * o + r * r);
+    this._dollyStart.set(0, c);
+  }
+  _handleTouchStartDollyPan(t) {
+    this.enableZoom && this._handleTouchStartDolly(t), this.enablePan && this._handleTouchStartPan(t);
+  }
+  _handleTouchStartDollyRotate(t) {
+    this.enableZoom && this._handleTouchStartDolly(t), this.enableRotate && this._handleTouchStartRotate(t);
+  }
+  _handleTouchMoveRotate(t) {
+    if (this._pointers.length == 1)
+      this._rotateEnd.set(t.pageX, t.pageY);
+    else {
+      const o = this._getSecondPointerPosition(t), r = 0.5 * (t.pageX + o.x), c = 0.5 * (t.pageY + o.y);
+      this._rotateEnd.set(r, c);
+    }
+    this._rotateDelta.subVectors(this._rotateEnd, this._rotateStart).multiplyScalar(this.rotateSpeed);
+    const i = this.domElement;
+    this._rotateLeft(R * this._rotateDelta.x / i.clientHeight), this._rotateUp(R * this._rotateDelta.y / i.clientHeight), this._rotateStart.copy(this._rotateEnd);
+  }
+  _handleTouchMovePan(t) {
+    if (this._pointers.length === 1)
+      this._panEnd.set(t.pageX, t.pageY);
+    else {
+      const i = this._getSecondPointerPosition(t), o = 0.5 * (t.pageX + i.x), r = 0.5 * (t.pageY + i.y);
+      this._panEnd.set(o, r);
+    }
+    this._panDelta.subVectors(this._panEnd, this._panStart).multiplyScalar(this.panSpeed), this._pan(this._panDelta.x, this._panDelta.y), this._panStart.copy(this._panEnd);
+  }
+  _handleTouchMoveDolly(t) {
+    const i = this._getSecondPointerPosition(t), o = t.pageX - i.x, r = t.pageY - i.y, c = Math.sqrt(o * o + r * r);
+    this._dollyEnd.set(0, c), 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 a = (t.pageX + i.x) * 0.5, f = (t.pageY + i.y) * 0.5;
+    this._updateZoomParameters(a, f);
+  }
+  _handleTouchMoveDollyPan(t) {
+    this.enableZoom && this._handleTouchMoveDolly(t), this.enablePan && this._handleTouchMovePan(t);
+  }
+  _handleTouchMoveDollyRotate(t) {
+    this.enableZoom && this._handleTouchMoveDolly(t), this.enableRotate && this._handleTouchMoveRotate(t);
+  }
+  // pointers
+  _addPointer(t) {
+    this._pointers.push(t.pointerId);
+  }
+  _removePointer(t) {
+    delete this._pointerPositions[t.pointerId];
+    for (let i = 0; i < this._pointers.length; i++)
+      if (this._pointers[i] == t.pointerId) {
+        this._pointers.splice(i, 1);
+        return;
+      }
+  }
+  _isTrackingPointer(t) {
+    for (let i = 0; i < this._pointers.length; i++)
+      if (this._pointers[i] == t.pointerId) return !0;
+    return !1;
+  }
+  _trackPointer(t) {
+    let i = this._pointerPositions[t.pointerId];
+    i === void 0 && (i = new L(), this._pointerPositions[t.pointerId] = i), i.set(t.pageX, t.pageY);
+  }
+  _getSecondPointerPosition(t) {
+    const i = t.pointerId === this._pointers[0] ? this._pointers[1] : this._pointers[0];
+    return this._pointerPositions[i];
+  }
+  //
+  _customWheelEvent(t) {
+    const i = t.deltaMode, o = {
+      clientX: t.clientX,
+      clientY: t.clientY,
+      deltaY: t.deltaY
+    };
+    switch (i) {
+      case 1:
+        o.deltaY *= 16;
+        break;
+      case 2:
+        o.deltaY *= 100;
+        break;
+    }
+    return t.ctrlKey && !this._controlActive && (o.deltaY *= 10), o;
+  }
+}
+function It(e) {
+  this.enabled !== !1 && (this._pointers.length === 0 && (this.domElement.setPointerCapture(e.pointerId), this.domElement.addEventListener("pointermove", this._onPointerMove), this.domElement.addEventListener("pointerup", this._onPointerUp)), !this._isTrackingPointer(e) && (this._addPointer(e), e.pointerType === "touch" ? this._onTouchStart(e) : this._onMouseDown(e)));
+}
+function Nt(e) {
+  this.enabled !== !1 && (e.pointerType === "touch" ? this._onTouchMove(e) : this._onMouseMove(e));
+}
+function Ht(e) {
+  switch (this._removePointer(e), this._pointers.length) {
+    case 0:
+      this.domElement.releasePointerCapture(e.pointerId), this.domElement.removeEventListener("pointermove", this._onPointerMove), this.domElement.removeEventListener("pointerup", this._onPointerUp), this.dispatchEvent(ut), this.state = d.NONE;
+      break;
+    case 1:
+      const t = this._pointers[0], i = this._pointerPositions[t];
+      this._onTouchStart({ pointerId: t, pageX: i.x, pageY: i.y });
+      break;
+  }
+}
+function jt(e) {
+  let t;
+  switch (e.button) {
+    case 0:
+      t = this.mouseButtons.LEFT;
+      break;
+    case 1:
+      t = this.mouseButtons.MIDDLE;
+      break;
+    case 2:
+      t = this.mouseButtons.RIGHT;
+      break;
+    default:
+      t = -1;
+  }
+  switch (t) {
+    case z.DOLLY:
+      if (this.enableZoom === !1) return;
+      this._handleMouseDownDolly(e), this.state = d.DOLLY;
+      break;
+    case z.ROTATE:
+      if (e.ctrlKey || e.metaKey || e.shiftKey) {
+        if (this.enablePan === !1) return;
+        this._handleMouseDownPan(e), this.state = d.PAN;
+      } else {
+        if (this.enableRotate === !1) return;
+        this._handleMouseDownRotate(e), this.state = d.ROTATE;
+      }
+      break;
+    case z.PAN:
+      if (e.ctrlKey || e.metaKey || e.shiftKey) {
+        if (this.enableRotate === !1) return;
+        this._handleMouseDownRotate(e), this.state = d.ROTATE;
+      } else {
+        if (this.enablePan === !1) return;
+        this._handleMouseDownPan(e), this.state = d.PAN;
+      }
+      break;
+    default:
+      this.state = d.NONE;
+  }
+  this.state !== d.NONE && this.dispatchEvent(it);
+}
+function Ut(e) {
+  switch (this.state) {
+    case d.ROTATE:
+      if (this.enableRotate === !1) return;
+      this._handleMouseMoveRotate(e);
+      break;
+    case d.DOLLY:
+      if (this.enableZoom === !1) return;
+      this._handleMouseMoveDolly(e);
+      break;
+    case d.PAN:
+      if (this.enablePan === !1) return;
+      this._handleMouseMovePan(e);
+      break;
+  }
+}
+function Yt(e) {
+  this.enabled === !1 || this.enableZoom === !1 || this.state !== d.NONE || (e.preventDefault(), this.dispatchEvent(it), this._handleMouseWheel(this._customWheelEvent(e)), this.dispatchEvent(ut));
+}
+function zt(e) {
+  this.enabled !== !1 && this._handleKeyDown(e);
+}
+function Gt(e) {
+  switch (this._trackPointer(e), this._pointers.length) {
+    case 1:
+      switch (this.touches.ONE) {
+        case G.ROTATE:
+          if (this.enableRotate === !1) return;
+          this._handleTouchStartRotate(e), this.state = d.TOUCH_ROTATE;
+          break;
+        case G.PAN:
+          if (this.enablePan === !1) return;
+          this._handleTouchStartPan(e), this.state = d.TOUCH_PAN;
+          break;
+        default:
+          this.state = d.NONE;
+      }
+      break;
+    case 2:
+      switch (this.touches.TWO) {
+        case G.DOLLY_PAN:
+          if (this.enableZoom === !1 && this.enablePan === !1) return;
+          this._handleTouchStartDollyPan(e), this.state = d.TOUCH_DOLLY_PAN;
+          break;
+        case G.DOLLY_ROTATE:
+          if (this.enableZoom === !1 && this.enableRotate === !1) return;
+          this._handleTouchStartDollyRotate(e), this.state = d.TOUCH_DOLLY_ROTATE;
+          break;
+        default:
+          this.state = d.NONE;
+      }
+      break;
+    default:
+      this.state = d.NONE;
+  }
+  this.state !== d.NONE && this.dispatchEvent(it);
+}
+function Ft(e) {
+  switch (this._trackPointer(e), this.state) {
+    case d.TOUCH_ROTATE:
+      if (this.enableRotate === !1) return;
+      this._handleTouchMoveRotate(e), this.update();
+      break;
+    case d.TOUCH_PAN:
+      if (this.enablePan === !1) return;
+      this._handleTouchMovePan(e), this.update();
+      break;
+    case d.TOUCH_DOLLY_PAN:
+      if (this.enableZoom === !1 && this.enablePan === !1) return;
+      this._handleTouchMoveDollyPan(e), this.update();
+      break;
+    case d.TOUCH_DOLLY_ROTATE:
+      if (this.enableZoom === !1 && this.enableRotate === !1) return;
+      this._handleTouchMoveDollyRotate(e), this.update();
+      break;
+    default:
+      this.state = d.NONE;
+  }
+}
+function Bt(e) {
+  this.enabled !== !1 && e.preventDefault();
+}
+function Zt(e) {
+  e.key === "Control" && (this._controlActive = !0, this.domElement.getRootNode().addEventListener("keyup", this._interceptControlUp, { passive: !0, capture: !0 }));
+}
+function Wt(e) {
+  e.key === "Control" && (this._controlActive = !1, this.domElement.getRootNode().removeEventListener("keyup", this._interceptControlUp, { passive: !0, capture: !0 }));
+}
+class Kt extends mt {
+  constructor(t, i) {
+    super(t, i), this.screenSpacePanning = !1, this.mouseButtons = { LEFT: z.PAN, MIDDLE: z.DOLLY, RIGHT: z.ROTATE }, this.touches = { ONE: G.PAN, TWO: G.DOLLY_ROTATE };
+  }
+}
+function ne(e) {
+  return new Dt(e);
+}
+function ae(e = 150, ...t) {
+  return new St(e, e / 10, ...t);
+}
+function re(e) {
+  return new Pt(e, 16776960);
+}
+function he(e, t) {
+  return new mt(e, t);
+}
+function le(e, t) {
+  return new Kt(e, t);
+}
+function ce() {
+  const e = new Tt(), t = new L(0, 0);
+  return {
+    raycaster: e,
+    pointer: t
+  };
+}
+function pe(e = 10) {
+  return new Mt(e);
+}
+function de(e = new x(1, 1, 1), t = new x(10, 10, 10), i = 5, o = 16776960) {
+  return e.normalize(), new Rt(e, t, i, o);
+}
+function ue() {
+  const e = new K();
+  return e.dom.style.cssText = "position:absolute;top:0;left:0;cursor:pointer;opacity:0.9;z-index:10000", e;
+}
+class Xt extends xt {
+  /**
+   * Constructs a new RGBE loader.
+   *
+   * @param {LoadingManager} [manager] - The loading manager.
+   */
+  constructor(t) {
+    super(t), this.type = X;
+  }
+  /**
+   * Parses the given RGBE texture data.
+   *
+   * @param {ArrayBuffer} buffer - The raw texture data.
+   * @return {DataTextureLoader~TexData} An object representing the parsed texture data.
+   */
+  parse(t) {
+    const a = function(l, u) {
+      switch (l) {
+        case 1:
+          throw new Error("THREE.RGBELoader: Read Error: " + (u || ""));
+        case 2:
+          throw new Error("THREE.RGBELoader: Write Error: " + (u || ""));
+        case 3:
+          throw new Error("THREE.RGBELoader: Bad File Format: " + (u || ""));
+        default:
+        case 4:
+          throw new Error("THREE.RGBELoader: Memory Error: " + (u || ""));
+      }
+    }, m = `
+`, h = function(l, u, y) {
+      u = u || 1024;
+      let w = l.pos, E = -1, p = 0, D = "", _ = String.fromCharCode.apply(null, new Uint16Array(l.subarray(w, w + 128)));
+      for (; 0 > (E = _.indexOf(m)) && p < u && w < l.byteLength; )
+        D += _, p += _.length, w += 128, _ += String.fromCharCode.apply(null, new Uint16Array(l.subarray(w, w + 128)));
+      return -1 < E ? (l.pos += p + E + 1, D + _.slice(0, E)) : !1;
+    }, O = function(l) {
+      const u = /^#\?(\S+)/, y = /^\s*GAMMA\s*=\s*(\d+(\.\d+)?)\s*$/, g = /^\s*EXPOSURE\s*=\s*(\d+(\.\d+)?)\s*$/, w = /^\s*FORMAT=(\S+)\s*$/, E = /^\s*\-Y\s+(\d+)\s+\+X\s+(\d+)\s*$/, p = {
+        valid: 0,
+        /* indicate which fields are valid */
+        string: "",
+        /* the actual header string */
+        comments: "",
+        /* comments found in header */
+        programtype: "RGBE",
+        /* listed at beginning of file to identify it after "#?". defaults to "RGBE" */
+        format: "",
+        /* RGBE format, default 32-bit_rle_rgbe */
+        gamma: 1,
+        /* image has already been gamma corrected with given gamma. defaults to 1.0 (no correction) */
+        exposure: 1,
+        /* a value of 1.0 in an image corresponds to <exposure> watts/steradian/m^2. defaults to 1.0 */
+        width: 0,
+        height: 0
+        /* image dimensions, width/height */
+      };
+      let D, _;
+      for ((l.pos >= l.byteLength || !(D = h(l))) && a(1, "no header found"), (_ = D.match(u)) || a(3, "bad initial token"), p.valid |= 1, p.programtype = _[1], p.string += D + `
+`; D = h(l), D !== !1; ) {
+        if (p.string += D + `
+`, D.charAt(0) === "#") {
+          p.comments += D + `
+`;
+          continue;
+        }
+        if ((_ = D.match(y)) && (p.gamma = parseFloat(_[1])), (_ = D.match(g)) && (p.exposure = parseFloat(_[1])), (_ = D.match(w)) && (p.valid |= 2, p.format = _[1]), (_ = D.match(E)) && (p.valid |= 4, p.height = parseInt(_[1], 10), p.width = parseInt(_[2], 10)), p.valid & 2 && p.valid & 4) break;
+      }
+      return p.valid & 2 || a(3, "missing format specifier"), p.valid & 4 || a(3, "missing image size specifier"), p;
+    }, v = function(l, u, y) {
+      const g = u;
+      if (
+        // run length encoding is not allowed so read flat
+        g < 8 || g > 32767 || // this file is not run length encoded
+        l[0] !== 2 || l[1] !== 2 || l[2] & 128
+      )
+        return new Uint8Array(l);
+      g !== (l[2] << 8 | l[3]) && a(3, "wrong scanline width");
+      const w = new Uint8Array(4 * u * y);
+      w.length || a(4, "unable to allocate buffer space");
+      let E = 0, p = 0;
+      const D = 4 * g, _ = new Uint8Array(4), Z = new Uint8Array(D);
+      let st = y;
+      for (; st > 0 && p < l.byteLength; ) {
+        p + 4 > l.byteLength && a(1), _[0] = l[p++], _[1] = l[p++], _[2] = l[p++], _[3] = l[p++], (_[0] != 2 || _[1] != 2 || (_[2] << 8 | _[3]) != g) && a(3, "bad rgbe scanline format");
+        let W = 0, j;
+        for (; W < D && p < l.byteLength; ) {
+          j = l[p++];
+          const U = j > 128;
+          if (U && (j -= 128), (j === 0 || W + j > D) && a(3, "bad scanline data"), U) {
+            const Y = l[p++];
+            for (let ot = 0; ot < j; ot++)
+              Z[W++] = Y;
+          } else
+            Z.set(l.subarray(p, p + j), W), W += j, p += j;
+        }
+        const ft = g;
+        for (let U = 0; U < ft; U++) {
+          let Y = 0;
+          w[E] = Z[U + Y], Y += g, w[E + 1] = Z[U + Y], Y += g, w[E + 2] = Z[U + Y], Y += g, w[E + 3] = Z[U + Y], E += 4;
+        }
+        st--;
+      }
+      return w;
+    }, C = function(l, u, y, g) {
+      const w = l[u + 3], E = Math.pow(2, w - 128) / 255;
+      y[g + 0] = l[u + 0] * E, y[g + 1] = l[u + 1] * E, y[g + 2] = l[u + 2] * E, y[g + 3] = 1;
+    }, k = function(l, u, y, g) {
+      const w = l[u + 3], E = Math.pow(2, w - 128) / 255;
+      y[g + 0] = V.toHalfFloat(Math.min(l[u + 0] * E, 65504)), y[g + 1] = V.toHalfFloat(Math.min(l[u + 1] * E, 65504)), y[g + 2] = V.toHalfFloat(Math.min(l[u + 2] * E, 65504)), y[g + 3] = V.toHalfFloat(1);
+    }, n = new Uint8Array(t);
+    n.pos = 0;
+    const s = O(n), T = s.width, B = s.height, M = v(n.subarray(n.pos), T, B);
+    let A, I, N;
+    switch (this.type) {
+      case $:
+        N = M.length / 4;
+        const l = new Float32Array(N * 4);
+        for (let y = 0; y < N; y++)
+          C(M, y * 4, l, y * 4);
+        A = l, I = $;
+        break;
+      case X:
+        N = M.length / 4;
+        const u = new Uint16Array(N * 4);
+        for (let y = 0; y < N; y++)
+          k(M, y * 4, u, y * 4);
+        A = u, I = X;
+        break;
+      default:
+        throw new Error("THREE.RGBELoader: Unsupported type: " + this.type);
+    }
+    return {
+      width: T,
+      height: B,
+      data: A,
+      header: s.string,
+      gamma: s.gamma,
+      exposure: s.exposure,
+      type: I
+    };
+  }
+  /**
+   * Sets the texture type.
+   *
+   * @param {(HalfFloatType|FloatType)} value - The texture type to set.
+   * @return {RGBELoader} A reference to this loader.
+   */
+  setDataType(t) {
+    return this.type = t, this;
+  }
+  load(t, i, o, r) {
+    function c(a, f) {
+      switch (a.type) {
+        case $:
+        case X:
+          a.colorSpace = At, a.minFilter = at, a.magFilter = at, a.generateMipmaps = !1, a.flipY = !0;
+          break;
+      }
+      i && i(a, f);
+    }
+    return super.load(t, c, o, r);
+  }
+}
+const Vt = (e) => {
+  e.geometry && e.geometry.dispose(), e.material && (Array.isArray(e.material) ? e.material.forEach((t) => {
+    pt(t);
+  }) : pt(e.material)), e.children && e.children.forEach((t) => Vt(t));
+};
+function pt(e) {
+  for (const t in e)
+    e[t] && e[t].isTexture && e[t].dispose();
+  e.dispose();
+}
+const J = {}, _t = new Xt();
+async function me(e, t) {
+  if (t) {
+    if (J[t]) {
+      const i = J[t];
+      e.environment = i;
+      return;
+    }
+    return new Promise((i, o) => {
+      _t.load(t, i, void 0, o);
+    }).then((i) => {
+      i.mapping = Ot, e.environment = i, J[t] = i;
+    }).catch((i) => {
+      console.log("  =====> e:", i);
+    });
+  }
+}
+async function _e(e) {
+  return new Promise((t, i) => {
+    _t.load(e, t, void 0, i);
+  });
+}
+const tt = {};
+function qt(e) {
+  const t = {
+    type: e.type,
+    name: e.name,
+    position: e.position.toArray(),
+    rotation: e.rotation.toArray(),
+    scale: e.scale.toArray(),
+    visible: e.visible,
+    children: [],
+    geometry: null,
+    material: null,
+    userData: e.userData
+  };
+  e.isMesh && (t.geometry = Qt(e.geometry), t.material = te(e.material));
+  for (const i of e.children)
+    t.children.push(qt(i));
+  return t;
+}
+function $t(e) {
+  let t;
+  switch (e.type) {
+    case "Mesh":
+      const i = Jt(e.geometry), o = ee(e.material);
+      t = new F.Mesh(i, o);
+      break;
+    case "Group":
+      t = new F.Group();
+      break;
+    case "Object3D":
+      t = new F.Object3D();
+      break;
+    default:
+      return console.warn(`Unsupported object type: ${e.type}`), null;
+  }
+  t.name = e.name, t.position.fromArray(e.position), t.rotation.fromArray(e.rotation), t.scale.fromArray(e.scale), t.visible = e.visible, t.userData = e.userData;
+  for (const i of e.children) {
+    const o = $t(i);
+    o && t.add(o);
+  }
+  return t;
+}
+function Qt(e) {
+  const t = [], { attributes: i, index: o, type: r } = e;
+  i.position && (t.position = {
+    type: "Float32Array",
+    array: Array.from(i.position.array),
+    itemSize: 3
+  }), i.normal && (t.normal = {
+    type: "Float32Array",
+    array: Array.from(i.normal.array),
+    itemSize: 3
+  }), i.uv && (t.uv = {
+    type: "Float32Array",
+    array: Array.from(i.uv.array),
+    itemSize: 2
+  });
+  const c = {
+    type: r,
+    attributes: t
+  };
+  return o && o.array && (c.index = {
+    type: "Uint32Array",
+    array: Array.from(o.array),
+    itemSize: 1
+  }), c;
+}
+function Jt(e) {
+  const { type: t, attributes: i, index: o } = e, r = new F.BufferGeometry();
+  return Object.keys(i).forEach((c) => {
+    const { type: a, array: f, itemSize: P } = i[c];
+    r.setAttribute(
+      c,
+      new F.BufferAttribute(new Float32Array(f), P)
+    );
+  }), o && r.setIndex(o.array), r;
+}
+function te(e) {
+  return {
+    type: e.type,
+    color: e.color.getHex(),
+    map: e.map ? e.map.image.src : null,
+    opacity: e.opacity,
+    name: e.name,
+    depthTest: e.depthTest,
+    depthWrite: e.depthWrite,
+    transparent: e.transparent,
+    side: e.side,
+    roughness: e.roughness,
+    metalness: e.metalness,
+    emissive: e.emissive.getHex()
+  };
+}
+function ee(e) {
+  if (tt[e.name]) return tt[e.name];
+  const { type: t, ...i } = e, o = t || "MeshStandardMaterial", r = new F[o]({ ...i });
+  if (e.map) {
+    const c = new F.TextureLoader().load(e.map);
+    r.map = c;
+  }
+  return r.needsUpdate = !0, tt[e.name] = r, r;
+}
+export {
+  oe as C,
+  _e as I,
+  K as S,
+  ae as a,
+  re as b,
+  ne as c,
+  he as d,
+  le as e,
+  ce as f,
+  pe as g,
+  de as h,
+  ue as i,
+  Vt as j,
+  me as k,
+  $t as l,
+  se as m,
+  qt as o
+};