@ridp/threejs 1.1.7 → 1.2.0

package/dist/ImageLoader-D9uANgrl.js

@@ -1,1475 +0,0 @@
-import { Object3D, Matrix4, Vector3, Quaternion, Controls, MOUSE, TOUCH, Spherical, Vector2, Ray, Plane, MathUtils, CameraHelper, GridHelper, BoxHelper, Raycaster, AxesHelper, ArrowHelper, DataTextureLoader, HalfFloatType, FloatType, DataUtils, LinearSRGBColorSpace, LinearFilter, EquirectangularReflectionMapping } from "three";
-var Stats = function() {
-  var mode = 0;
-  var container = document.createElement("div");
-  container.style.cssText = "position:fixed;top:0;left:0;cursor:pointer;opacity:0.9;z-index:10000";
-  container.addEventListener("click", function(event) {
-    event.preventDefault();
-    showPanel(++mode % container.children.length);
-  }, false);
-  function addPanel(panel) {
-    container.appendChild(panel.dom);
-    return panel;
-  }
-  function showPanel(id) {
-    for (var i = 0; i < container.children.length; i++) {
-      container.children[i].style.display = i === id ? "block" : "none";
-    }
-    mode = id;
-  }
-  var beginTime = (performance || Date).now(), prevTime = beginTime, frames = 0;
-  var fpsPanel = addPanel(new Stats.Panel("FPS", "#0ff", "#002"));
-  var msPanel = addPanel(new Stats.Panel("MS", "#0f0", "#020"));
-  if (self.performance && self.performance.memory) {
-    var memPanel = addPanel(new Stats.Panel("MB", "#f08", "#201"));
-  }
-  showPanel(0);
-  return {
-    REVISION: 16,
-    dom: container,
-    addPanel,
-    showPanel,
-    begin: function() {
-      beginTime = (performance || Date).now();
-    },
-    end: function() {
-      frames++;
-      var time = (performance || Date).now();
-      msPanel.update(time - beginTime, 200);
-      if (time >= prevTime + 1e3) {
-        fpsPanel.update(frames * 1e3 / (time - prevTime), 100);
-        prevTime = time;
-        frames = 0;
-        if (memPanel) {
-          var memory = performance.memory;
-          memPanel.update(memory.usedJSHeapSize / 1048576, memory.jsHeapSizeLimit / 1048576);
-        }
-      }
-      return time;
-    },
-    update: function() {
-      beginTime = this.end();
-    },
-    // Backwards Compatibility
-    domElement: container,
-    setMode: showPanel
-  };
-};
-Stats.Panel = function(name, fg, bg) {
-  var min = Infinity, max = 0, round = Math.round;
-  var PR = round(window.devicePixelRatio || 1);
-  var WIDTH = 80 * PR, HEIGHT = 48 * PR, TEXT_X = 3 * PR, TEXT_Y = 2 * PR, GRAPH_X = 3 * PR, GRAPH_Y = 15 * PR, GRAPH_WIDTH = 74 * PR, GRAPH_HEIGHT = 30 * PR;
-  var canvas = document.createElement("canvas");
-  canvas.width = WIDTH;
-  canvas.height = HEIGHT;
-  canvas.style.cssText = "width:80px;height:48px";
-  var context = canvas.getContext("2d");
-  context.font = "bold " + 9 * PR + "px Helvetica,Arial,sans-serif";
-  context.textBaseline = "top";
-  context.fillStyle = bg;
-  context.fillRect(0, 0, WIDTH, HEIGHT);
-  context.fillStyle = fg;
-  context.fillText(name, TEXT_X, TEXT_Y);
-  context.fillRect(GRAPH_X, GRAPH_Y, GRAPH_WIDTH, GRAPH_HEIGHT);
-  context.fillStyle = bg;
-  context.globalAlpha = 0.9;
-  context.fillRect(GRAPH_X, GRAPH_Y, GRAPH_WIDTH, GRAPH_HEIGHT);
-  return {
-    dom: canvas,
-    update: function(value, maxValue) {
-      min = Math.min(min, value);
-      max = Math.max(max, value);
-      context.fillStyle = bg;
-      context.globalAlpha = 1;
-      context.fillRect(0, 0, WIDTH, GRAPH_Y);
-      context.fillStyle = fg;
-      context.fillText(round(value) + " " + name + " (" + round(min) + "-" + round(max) + ")", TEXT_X, TEXT_Y);
-      context.drawImage(canvas, GRAPH_X + PR, GRAPH_Y, GRAPH_WIDTH - PR, GRAPH_HEIGHT, GRAPH_X, GRAPH_Y, GRAPH_WIDTH - PR, GRAPH_HEIGHT);
-      context.fillRect(GRAPH_X + GRAPH_WIDTH - PR, GRAPH_Y, PR, GRAPH_HEIGHT);
-      context.fillStyle = bg;
-      context.globalAlpha = 0.9;
-      context.fillRect(GRAPH_X + GRAPH_WIDTH - PR, GRAPH_Y, PR, round((1 - value / maxValue) * GRAPH_HEIGHT));
-    }
-  };
-};
-const _position = new Vector3();
-const _quaternion = new Quaternion();
-const _scale = new Vector3();
-class CSS3DObject extends Object3D {
-  /**
-   * Constructs a new CSS3D object.
-   *
-   * @param {DOMElement} [element] - The DOM element.
-   */
-  constructor(element = document.createElement("div")) {
-    super();
-    this.isCSS3DObject = true;
-    this.element = element;
-    this.element.style.position = "absolute";
-    this.element.style.pointerEvents = "auto";
-    this.element.style.userSelect = "none";
-    this.element.setAttribute("draggable", false);
-    this.addEventListener("removed", function() {
-      this.traverse(function(object) {
-        if (object.element instanceof object.element.ownerDocument.defaultView.Element && object.element.parentNode !== null) {
-          object.element.remove();
-        }
-      });
-    });
-  }
-  copy(source, recursive) {
-    super.copy(source, recursive);
-    this.element = source.element.cloneNode(true);
-    return this;
-  }
-}
-class CSS3DSprite extends CSS3DObject {
-  /**
-   * Constructs a new CSS3D sprite object.
-   *
-   * @param {DOMElement} [element] - The DOM element.
-   */
-  constructor(element) {
-    super(element);
-    this.isCSS3DSprite = true;
-    this.rotation2D = 0;
-  }
-  copy(source, recursive) {
-    super.copy(source, recursive);
-    this.rotation2D = source.rotation2D;
-    return this;
-  }
-}
-const _matrix = new Matrix4();
-const _matrix2 = new Matrix4();
-class CSS3DRenderer {
-  /**
-   * Constructs a new CSS3D renderer.
-   *
-   * @param {CSS3DRenderer~Parameters} [parameters] - The parameters.
-   */
-  constructor(parameters = {}) {
-    const _this = this;
-    let _width, _height;
-    let _widthHalf, _heightHalf;
-    const cache = {
-      camera: { style: "" },
-      objects: /* @__PURE__ */ new WeakMap()
-    };
-    const domElement = parameters.element !== void 0 ? parameters.element : document.createElement("div");
-    domElement.style.overflow = "hidden";
-    this.domElement = domElement;
-    const viewElement = document.createElement("div");
-    viewElement.style.transformOrigin = "0 0";
-    viewElement.style.pointerEvents = "none";
-    domElement.appendChild(viewElement);
-    const cameraElement = document.createElement("div");
-    cameraElement.style.transformStyle = "preserve-3d";
-    viewElement.appendChild(cameraElement);
-    this.getSize = function() {
-      return {
-        width: _width,
-        height: _height
-      };
-    };
-    this.render = function(scene, camera) {
-      const fov = camera.projectionMatrix.elements[5] * _heightHalf;
-      if (camera.view && camera.view.enabled) {
-        viewElement.style.transform = `translate( ${-camera.view.offsetX * (_width / camera.view.width)}px, ${-camera.view.offsetY * (_height / camera.view.height)}px )`;
-        viewElement.style.transform += `scale( ${camera.view.fullWidth / camera.view.width}, ${camera.view.fullHeight / camera.view.height} )`;
-      } else {
-        viewElement.style.transform = "";
-      }
-      if (scene.matrixWorldAutoUpdate === true) scene.updateMatrixWorld();
-      if (camera.parent === null && camera.matrixWorldAutoUpdate === true) camera.updateMatrixWorld();
-      let tx, ty;
-      if (camera.isOrthographicCamera) {
-        tx = -(camera.right + camera.left) / 2;
-        ty = (camera.top + camera.bottom) / 2;
-      }
-      const scaleByViewOffset = camera.view && camera.view.enabled ? camera.view.height / camera.view.fullHeight : 1;
-      const cameraCSSMatrix = camera.isOrthographicCamera ? `scale( ${scaleByViewOffset} )scale(` + fov + ")translate(" + epsilon(tx) + "px," + epsilon(ty) + "px)" + getCameraCSSMatrix(camera.matrixWorldInverse) : `scale( ${scaleByViewOffset} )translateZ(` + fov + "px)" + getCameraCSSMatrix(camera.matrixWorldInverse);
-      const perspective = camera.isPerspectiveCamera ? "perspective(" + fov + "px) " : "";
-      const style = perspective + cameraCSSMatrix + "translate(" + _widthHalf + "px," + _heightHalf + "px)";
-      if (cache.camera.style !== style) {
-        cameraElement.style.transform = style;
-        cache.camera.style = style;
-      }
-      renderObject(scene, scene, camera);
-    };
-    this.setSize = function(width, height) {
-      _width = width;
-      _height = height;
-      _widthHalf = _width / 2;
-      _heightHalf = _height / 2;
-      domElement.style.width = width + "px";
-      domElement.style.height = height + "px";
-      viewElement.style.width = width + "px";
-      viewElement.style.height = height + "px";
-      cameraElement.style.width = width + "px";
-      cameraElement.style.height = height + "px";
-    };
-    function epsilon(value) {
-      return Math.abs(value) < 1e-10 ? 0 : value;
-    }
-    function getCameraCSSMatrix(matrix) {
-      const elements = matrix.elements;
-      return "matrix3d(" + epsilon(elements[0]) + "," + epsilon(-elements[1]) + "," + epsilon(elements[2]) + "," + epsilon(elements[3]) + "," + epsilon(elements[4]) + "," + epsilon(-elements[5]) + "," + epsilon(elements[6]) + "," + epsilon(elements[7]) + "," + epsilon(elements[8]) + "," + epsilon(-elements[9]) + "," + epsilon(elements[10]) + "," + epsilon(elements[11]) + "," + epsilon(elements[12]) + "," + epsilon(-elements[13]) + "," + epsilon(elements[14]) + "," + epsilon(elements[15]) + ")";
-    }
-    function getObjectCSSMatrix(matrix) {
-      const elements = matrix.elements;
-      const matrix3d = "matrix3d(" + epsilon(elements[0]) + "," + epsilon(elements[1]) + "," + epsilon(elements[2]) + "," + epsilon(elements[3]) + "," + epsilon(-elements[4]) + "," + epsilon(-elements[5]) + "," + epsilon(-elements[6]) + "," + epsilon(-elements[7]) + "," + epsilon(elements[8]) + "," + epsilon(elements[9]) + "," + epsilon(elements[10]) + "," + epsilon(elements[11]) + "," + epsilon(elements[12]) + "," + epsilon(elements[13]) + "," + epsilon(elements[14]) + "," + epsilon(elements[15]) + ")";
-      return "translate(-50%,-50%)" + matrix3d;
-    }
-    function hideObject(object) {
-      if (object.isCSS3DObject) object.element.style.display = "none";
-      for (let i = 0, l = object.children.length; i < l; i++) {
-        hideObject(object.children[i]);
-      }
-    }
-    function renderObject(object, scene, camera, cameraCSSMatrix) {
-      if (object.visible === false) {
-        hideObject(object);
-        return;
-      }
-      if (object.isCSS3DObject) {
-        const visible = object.layers.test(camera.layers) === true;
-        const element = object.element;
-        element.style.display = visible === true ? "" : "none";
-        if (visible === true) {
-          object.onBeforeRender(_this, scene, camera);
-          let style;
-          if (object.isCSS3DSprite) {
-            _matrix.copy(camera.matrixWorldInverse);
-            _matrix.transpose();
-            if (object.rotation2D !== 0) _matrix.multiply(_matrix2.makeRotationZ(object.rotation2D));
-            object.matrixWorld.decompose(_position, _quaternion, _scale);
-            _matrix.setPosition(_position);
-            _matrix.scale(_scale);
-            _matrix.elements[3] = 0;
-            _matrix.elements[7] = 0;
-            _matrix.elements[11] = 0;
-            _matrix.elements[15] = 1;
-            style = getObjectCSSMatrix(_matrix);
-          } else {
-            style = getObjectCSSMatrix(object.matrixWorld);
-          }
-          const cachedObject = cache.objects.get(object);
-          if (cachedObject === void 0 || cachedObject.style !== style) {
-            element.style.transform = style;
-            const objectData = { style };
-            cache.objects.set(object, objectData);
-          }
-          if (element.parentNode !== cameraElement) {
-            cameraElement.appendChild(element);
-          }
-          object.onAfterRender(_this, scene, camera);
-        }
-      }
-      for (let i = 0, l = object.children.length; i < l; i++) {
-        renderObject(object.children[i], scene, camera);
-      }
-    }
-  }
-}
-const _changeEvent = { type: "change" };
-const _startEvent = { type: "start" };
-const _endEvent = { type: "end" };
-const _ray = new Ray();
-const _plane = new Plane();
-const _TILT_LIMIT = Math.cos(70 * MathUtils.DEG2RAD);
-const _v = new Vector3();
-const _twoPI = 2 * Math.PI;
-const _STATE = {
-  NONE: -1,
-  ROTATE: 0,
-  DOLLY: 1,
-  PAN: 2,
-  TOUCH_ROTATE: 3,
-  TOUCH_PAN: 4,
-  TOUCH_DOLLY_PAN: 5,
-  TOUCH_DOLLY_ROTATE: 6
-};
-const _EPS = 1e-6;
-class OrbitControls extends Controls {
-  /**
-   * 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(object, domElement = null) {
-    super(object, domElement);
-    this.state = _STATE.NONE;
-    this.target = new Vector3();
-    this.cursor = new Vector3();
-    this.minDistance = 0;
-    this.maxDistance = Infinity;
-    this.minZoom = 0;
-    this.maxZoom = Infinity;
-    this.minTargetRadius = 0;
-    this.maxTargetRadius = Infinity;
-    this.minPolarAngle = 0;
-    this.maxPolarAngle = Math.PI;
-    this.minAzimuthAngle = -Infinity;
-    this.maxAzimuthAngle = Infinity;
-    this.enableDamping = false;
-    this.dampingFactor = 0.05;
-    this.enableZoom = true;
-    this.zoomSpeed = 1;
-    this.enableRotate = true;
-    this.rotateSpeed = 1;
-    this.keyRotateSpeed = 1;
-    this.enablePan = true;
-    this.panSpeed = 1;
-    this.screenSpacePanning = true;
-    this.keyPanSpeed = 7;
-    this.zoomToCursor = false;
-    this.autoRotate = false;
-    this.autoRotateSpeed = 2;
-    this.keys = { LEFT: "ArrowLeft", UP: "ArrowUp", RIGHT: "ArrowRight", BOTTOM: "ArrowDown" };
-    this.mouseButtons = { LEFT: MOUSE.ROTATE, MIDDLE: MOUSE.DOLLY, RIGHT: MOUSE.PAN };
-    this.touches = { ONE: TOUCH.ROTATE, TWO: TOUCH.DOLLY_PAN };
-    this.target0 = this.target.clone();
-    this.position0 = this.object.position.clone();
-    this.zoom0 = this.object.zoom;
-    this._domElementKeyEvents = null;
-    this._lastPosition = new Vector3();
-    this._lastQuaternion = new Quaternion();
-    this._lastTargetPosition = new Vector3();
-    this._quat = new Quaternion().setFromUnitVectors(object.up, new Vector3(0, 1, 0));
-    this._quatInverse = this._quat.clone().invert();
-    this._spherical = new Spherical();
-    this._sphericalDelta = new Spherical();
-    this._scale = 1;
-    this._panOffset = new Vector3();
-    this._rotateStart = new Vector2();
-    this._rotateEnd = new Vector2();
-    this._rotateDelta = new Vector2();
-    this._panStart = new Vector2();
-    this._panEnd = new Vector2();
-    this._panDelta = new Vector2();
-    this._dollyStart = new Vector2();
-    this._dollyEnd = new Vector2();
-    this._dollyDelta = new Vector2();
-    this._dollyDirection = new Vector3();
-    this._mouse = new Vector2();
-    this._performCursorZoom = false;
-    this._pointers = [];
-    this._pointerPositions = {};
-    this._controlActive = false;
-    this._onPointerMove = onPointerMove.bind(this);
-    this._onPointerDown = onPointerDown.bind(this);
-    this._onPointerUp = onPointerUp.bind(this);
-    this._onContextMenu = onContextMenu.bind(this);
-    this._onMouseWheel = onMouseWheel.bind(this);
-    this._onKeyDown = onKeyDown.bind(this);
-    this._onTouchStart = onTouchStart.bind(this);
-    this._onTouchMove = onTouchMove.bind(this);
-    this._onMouseDown = onMouseDown.bind(this);
-    this._onMouseMove = onMouseMove.bind(this);
-    this._interceptControlDown = interceptControlDown.bind(this);
-    this._interceptControlUp = interceptControlUp.bind(this);
-    if (this.domElement !== null) {
-      this.connect(this.domElement);
-    }
-    this.update();
-  }
-  connect(element) {
-    super.connect(element);
-    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: false });
-    const document2 = this.domElement.getRootNode();
-    document2.addEventListener("keydown", this._interceptControlDown, { passive: true, capture: true });
-    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();
-    const document2 = this.domElement.getRootNode();
-    document2.removeEventListener("keydown", this._interceptControlDown, { capture: true });
-    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(domElement) {
-    domElement.addEventListener("keydown", this._onKeyDown);
-    this._domElementKeyEvents = domElement;
-  }
-  /**
-   * Removes the key event listener previously defined with `listenToKeyEvents()`.
-   */
-  stopListenToKeyEvents() {
-    if (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(_changeEvent);
-    this.update();
-    this.state = _STATE.NONE;
-  }
-  update(deltaTime = null) {
-    const position = this.object.position;
-    _v.copy(position).sub(this.target);
-    _v.applyQuaternion(this._quat);
-    this._spherical.setFromVector3(_v);
-    if (this.autoRotate && this.state === _STATE.NONE) {
-      this._rotateLeft(this._getAutoRotationAngle(deltaTime));
-    }
-    if (this.enableDamping) {
-      this._spherical.theta += this._sphericalDelta.theta * this.dampingFactor;
-      this._spherical.phi += this._sphericalDelta.phi * this.dampingFactor;
-    } else {
-      this._spherical.theta += this._sphericalDelta.theta;
-      this._spherical.phi += this._sphericalDelta.phi;
-    }
-    let min = this.minAzimuthAngle;
-    let max = this.maxAzimuthAngle;
-    if (isFinite(min) && isFinite(max)) {
-      if (min < -Math.PI) min += _twoPI;
-      else if (min > Math.PI) min -= _twoPI;
-      if (max < -Math.PI) max += _twoPI;
-      else if (max > Math.PI) max -= _twoPI;
-      if (min <= max) {
-        this._spherical.theta = Math.max(min, Math.min(max, this._spherical.theta));
-      } else {
-        this._spherical.theta = this._spherical.theta > (min + max) / 2 ? Math.max(min, this._spherical.theta) : Math.min(max, this._spherical.theta);
-      }
-    }
-    this._spherical.phi = Math.max(this.minPolarAngle, Math.min(this.maxPolarAngle, this._spherical.phi));
-    this._spherical.makeSafe();
-    if (this.enableDamping === true) {
-      this.target.addScaledVector(this._panOffset, this.dampingFactor);
-    } else {
-      this.target.add(this._panOffset);
-    }
-    this.target.sub(this.cursor);
-    this.target.clampLength(this.minTargetRadius, this.maxTargetRadius);
-    this.target.add(this.cursor);
-    let zoomChanged = false;
-    if (this.zoomToCursor && this._performCursorZoom || this.object.isOrthographicCamera) {
-      this._spherical.radius = this._clampDistance(this._spherical.radius);
-    } else {
-      const prevRadius = this._spherical.radius;
-      this._spherical.radius = this._clampDistance(this._spherical.radius * this._scale);
-      zoomChanged = prevRadius != this._spherical.radius;
-    }
-    _v.setFromSpherical(this._spherical);
-    _v.applyQuaternion(this._quatInverse);
-    position.copy(this.target).add(_v);
-    this.object.lookAt(this.target);
-    if (this.enableDamping === true) {
-      this._sphericalDelta.theta *= 1 - this.dampingFactor;
-      this._sphericalDelta.phi *= 1 - this.dampingFactor;
-      this._panOffset.multiplyScalar(1 - this.dampingFactor);
-    } else {
-      this._sphericalDelta.set(0, 0, 0);
-      this._panOffset.set(0, 0, 0);
-    }
-    if (this.zoomToCursor && this._performCursorZoom) {
-      let newRadius = null;
-      if (this.object.isPerspectiveCamera) {
-        const prevRadius = _v.length();
-        newRadius = this._clampDistance(prevRadius * this._scale);
-        const radiusDelta = prevRadius - newRadius;
-        this.object.position.addScaledVector(this._dollyDirection, radiusDelta);
-        this.object.updateMatrixWorld();
-        zoomChanged = !!radiusDelta;
-      } else if (this.object.isOrthographicCamera) {
-        const mouseBefore = new Vector3(this._mouse.x, this._mouse.y, 0);
-        mouseBefore.unproject(this.object);
-        const prevZoom = this.object.zoom;
-        this.object.zoom = Math.max(this.minZoom, Math.min(this.maxZoom, this.object.zoom / this._scale));
-        this.object.updateProjectionMatrix();
-        zoomChanged = prevZoom !== this.object.zoom;
-        const mouseAfter = new Vector3(this._mouse.x, this._mouse.y, 0);
-        mouseAfter.unproject(this.object);
-        this.object.position.sub(mouseAfter).add(mouseBefore);
-        this.object.updateMatrixWorld();
-        newRadius = _v.length();
-      } else {
-        console.warn("WARNING: OrbitControls.js encountered an unknown camera type - zoom to cursor disabled.");
-        this.zoomToCursor = false;
-      }
-      if (newRadius !== null) {
-        if (this.screenSpacePanning) {
-          this.target.set(0, 0, -1).transformDirection(this.object.matrix).multiplyScalar(newRadius).add(this.object.position);
-        } else {
-          _ray.origin.copy(this.object.position);
-          _ray.direction.set(0, 0, -1).transformDirection(this.object.matrix);
-          if (Math.abs(this.object.up.dot(_ray.direction)) < _TILT_LIMIT) {
-            this.object.lookAt(this.target);
-          } else {
-            _plane.setFromNormalAndCoplanarPoint(this.object.up, this.target);
-            _ray.intersectPlane(_plane, this.target);
-          }
-        }
-      }
-    } else if (this.object.isOrthographicCamera) {
-      const prevZoom = this.object.zoom;
-      this.object.zoom = Math.max(this.minZoom, Math.min(this.maxZoom, this.object.zoom / this._scale));
-      if (prevZoom !== this.object.zoom) {
-        this.object.updateProjectionMatrix();
-        zoomChanged = true;
-      }
-    }
-    this._scale = 1;
-    this._performCursorZoom = false;
-    if (zoomChanged || this._lastPosition.distanceToSquared(this.object.position) > _EPS || 8 * (1 - this._lastQuaternion.dot(this.object.quaternion)) > _EPS || this._lastTargetPosition.distanceToSquared(this.target) > _EPS) {
-      this.dispatchEvent(_changeEvent);
-      this._lastPosition.copy(this.object.position);
-      this._lastQuaternion.copy(this.object.quaternion);
-      this._lastTargetPosition.copy(this.target);
-      return true;
-    }
-    return false;
-  }
-  _getAutoRotationAngle(deltaTime) {
-    if (deltaTime !== null) {
-      return _twoPI / 60 * this.autoRotateSpeed * deltaTime;
-    } else {
-      return _twoPI / 60 / 60 * this.autoRotateSpeed;
-    }
-  }
-  _getZoomScale(delta) {
-    const normalizedDelta = Math.abs(delta * 0.01);
-    return Math.pow(0.95, this.zoomSpeed * normalizedDelta);
-  }
-  _rotateLeft(angle) {
-    this._sphericalDelta.theta -= angle;
-  }
-  _rotateUp(angle) {
-    this._sphericalDelta.phi -= angle;
-  }
-  _panLeft(distance, objectMatrix) {
-    _v.setFromMatrixColumn(objectMatrix, 0);
-    _v.multiplyScalar(-distance);
-    this._panOffset.add(_v);
-  }
-  _panUp(distance, objectMatrix) {
-    if (this.screenSpacePanning === true) {
-      _v.setFromMatrixColumn(objectMatrix, 1);
-    } else {
-      _v.setFromMatrixColumn(objectMatrix, 0);
-      _v.crossVectors(this.object.up, _v);
-    }
-    _v.multiplyScalar(distance);
-    this._panOffset.add(_v);
-  }
-  // deltaX and deltaY are in pixels; right and down are positive
-  _pan(deltaX, deltaY) {
-    const element = this.domElement;
-    if (this.object.isPerspectiveCamera) {
-      const position = this.object.position;
-      _v.copy(position).sub(this.target);
-      let targetDistance = _v.length();
-      targetDistance *= Math.tan(this.object.fov / 2 * Math.PI / 180);
-      this._panLeft(2 * deltaX * targetDistance / element.clientHeight, this.object.matrix);
-      this._panUp(2 * deltaY * targetDistance / element.clientHeight, this.object.matrix);
-    } else if (this.object.isOrthographicCamera) {
-      this._panLeft(deltaX * (this.object.right - this.object.left) / this.object.zoom / element.clientWidth, this.object.matrix);
-      this._panUp(deltaY * (this.object.top - this.object.bottom) / this.object.zoom / element.clientHeight, this.object.matrix);
-    } else {
-      console.warn("WARNING: OrbitControls.js encountered an unknown camera type - pan disabled.");
-      this.enablePan = false;
-    }
-  }
-  _dollyOut(dollyScale) {
-    if (this.object.isPerspectiveCamera || this.object.isOrthographicCamera) {
-      this._scale /= dollyScale;
-    } else {
-      console.warn("WARNING: OrbitControls.js encountered an unknown camera type - dolly/zoom disabled.");
-      this.enableZoom = false;
-    }
-  }
-  _dollyIn(dollyScale) {
-    if (this.object.isPerspectiveCamera || this.object.isOrthographicCamera) {
-      this._scale *= dollyScale;
-    } else {
-      console.warn("WARNING: OrbitControls.js encountered an unknown camera type - dolly/zoom disabled.");
-      this.enableZoom = false;
-    }
-  }
-  _updateZoomParameters(x, y) {
-    if (!this.zoomToCursor) {
-      return;
-    }
-    this._performCursorZoom = true;
-    const rect = this.domElement.getBoundingClientRect();
-    const dx = x - rect.left;
-    const dy = y - rect.top;
-    const w = rect.width;
-    const h = rect.height;
-    this._mouse.x = dx / w * 2 - 1;
-    this._mouse.y = -(dy / h) * 2 + 1;
-    this._dollyDirection.set(this._mouse.x, this._mouse.y, 1).unproject(this.object).sub(this.object.position).normalize();
-  }
-  _clampDistance(dist) {
-    return Math.max(this.minDistance, Math.min(this.maxDistance, dist));
-  }
-  //
-  // event callbacks - update the object state
-  //
-  _handleMouseDownRotate(event) {
-    this._rotateStart.set(event.clientX, event.clientY);
-  }
-  _handleMouseDownDolly(event) {
-    this._updateZoomParameters(event.clientX, event.clientX);
-    this._dollyStart.set(event.clientX, event.clientY);
-  }
-  _handleMouseDownPan(event) {
-    this._panStart.set(event.clientX, event.clientY);
-  }
-  _handleMouseMoveRotate(event) {
-    this._rotateEnd.set(event.clientX, event.clientY);
-    this._rotateDelta.subVectors(this._rotateEnd, this._rotateStart).multiplyScalar(this.rotateSpeed);
-    const element = this.domElement;
-    this._rotateLeft(_twoPI * this._rotateDelta.x / element.clientHeight);
-    this._rotateUp(_twoPI * this._rotateDelta.y / element.clientHeight);
-    this._rotateStart.copy(this._rotateEnd);
-    this.update();
-  }
-  _handleMouseMoveDolly(event) {
-    this._dollyEnd.set(event.clientX, event.clientY);
-    this._dollyDelta.subVectors(this._dollyEnd, this._dollyStart);
-    if (this._dollyDelta.y > 0) {
-      this._dollyOut(this._getZoomScale(this._dollyDelta.y));
-    } else if (this._dollyDelta.y < 0) {
-      this._dollyIn(this._getZoomScale(this._dollyDelta.y));
-    }
-    this._dollyStart.copy(this._dollyEnd);
-    this.update();
-  }
-  _handleMouseMovePan(event) {
-    this._panEnd.set(event.clientX, event.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(event) {
-    this._updateZoomParameters(event.clientX, event.clientY);
-    if (event.deltaY < 0) {
-      this._dollyIn(this._getZoomScale(event.deltaY));
-    } else if (event.deltaY > 0) {
-      this._dollyOut(this._getZoomScale(event.deltaY));
-    }
-    this.update();
-  }
-  _handleKeyDown(event) {
-    let needsUpdate = false;
-    switch (event.code) {
-      case this.keys.UP:
-        if (event.ctrlKey || event.metaKey || event.shiftKey) {
-          if (this.enableRotate) {
-            this._rotateUp(_twoPI * this.keyRotateSpeed / this.domElement.clientHeight);
-          }
-        } else {
-          if (this.enablePan) {
-            this._pan(0, this.keyPanSpeed);
-          }
-        }
-        needsUpdate = true;
-        break;
-      case this.keys.BOTTOM:
-        if (event.ctrlKey || event.metaKey || event.shiftKey) {
-          if (this.enableRotate) {
-            this._rotateUp(-_twoPI * this.keyRotateSpeed / this.domElement.clientHeight);
-          }
-        } else {
-          if (this.enablePan) {
-            this._pan(0, -this.keyPanSpeed);
-          }
-        }
-        needsUpdate = true;
-        break;
-      case this.keys.LEFT:
-        if (event.ctrlKey || event.metaKey || event.shiftKey) {
-          if (this.enableRotate) {
-            this._rotateLeft(_twoPI * this.keyRotateSpeed / this.domElement.clientHeight);
-          }
-        } else {
-          if (this.enablePan) {
-            this._pan(this.keyPanSpeed, 0);
-          }
-        }
-        needsUpdate = true;
-        break;
-      case this.keys.RIGHT:
-        if (event.ctrlKey || event.metaKey || event.shiftKey) {
-          if (this.enableRotate) {
-            this._rotateLeft(-_twoPI * this.keyRotateSpeed / this.domElement.clientHeight);
-          }
-        } else {
-          if (this.enablePan) {
-            this._pan(-this.keyPanSpeed, 0);
-          }
-        }
-        needsUpdate = true;
-        break;
-    }
-    if (needsUpdate) {
-      event.preventDefault();
-      this.update();
-    }
-  }
-  _handleTouchStartRotate(event) {
-    if (this._pointers.length === 1) {
-      this._rotateStart.set(event.pageX, event.pageY);
-    } else {
-      const position = this._getSecondPointerPosition(event);
-      const x = 0.5 * (event.pageX + position.x);
-      const y = 0.5 * (event.pageY + position.y);
-      this._rotateStart.set(x, y);
-    }
-  }
-  _handleTouchStartPan(event) {
-    if (this._pointers.length === 1) {
-      this._panStart.set(event.pageX, event.pageY);
-    } else {
-      const position = this._getSecondPointerPosition(event);
-      const x = 0.5 * (event.pageX + position.x);
-      const y = 0.5 * (event.pageY + position.y);
-      this._panStart.set(x, y);
-    }
-  }
-  _handleTouchStartDolly(event) {
-    const position = this._getSecondPointerPosition(event);
-    const dx = event.pageX - position.x;
-    const dy = event.pageY - position.y;
-    const distance = Math.sqrt(dx * dx + dy * dy);
-    this._dollyStart.set(0, distance);
-  }
-  _handleTouchStartDollyPan(event) {
-    if (this.enableZoom) this._handleTouchStartDolly(event);
-    if (this.enablePan) this._handleTouchStartPan(event);
-  }
-  _handleTouchStartDollyRotate(event) {
-    if (this.enableZoom) this._handleTouchStartDolly(event);
-    if (this.enableRotate) this._handleTouchStartRotate(event);
-  }
-  _handleTouchMoveRotate(event) {
-    if (this._pointers.length == 1) {
-      this._rotateEnd.set(event.pageX, event.pageY);
-    } else {
-      const position = this._getSecondPointerPosition(event);
-      const x = 0.5 * (event.pageX + position.x);
-      const y = 0.5 * (event.pageY + position.y);
-      this._rotateEnd.set(x, y);
-    }
-    this._rotateDelta.subVectors(this._rotateEnd, this._rotateStart).multiplyScalar(this.rotateSpeed);
-    const element = this.domElement;
-    this._rotateLeft(_twoPI * this._rotateDelta.x / element.clientHeight);
-    this._rotateUp(_twoPI * this._rotateDelta.y / element.clientHeight);
-    this._rotateStart.copy(this._rotateEnd);
-  }
-  _handleTouchMovePan(event) {
-    if (this._pointers.length === 1) {
-      this._panEnd.set(event.pageX, event.pageY);
-    } else {
-      const position = this._getSecondPointerPosition(event);
-      const x = 0.5 * (event.pageX + position.x);
-      const y = 0.5 * (event.pageY + position.y);
-      this._panEnd.set(x, y);
-    }
-    this._panDelta.subVectors(this._panEnd, this._panStart).multiplyScalar(this.panSpeed);
-    this._pan(this._panDelta.x, this._panDelta.y);
-    this._panStart.copy(this._panEnd);
-  }
-  _handleTouchMoveDolly(event) {
-    const position = this._getSecondPointerPosition(event);
-    const dx = event.pageX - position.x;
-    const dy = event.pageY - position.y;
-    const distance = Math.sqrt(dx * dx + dy * dy);
-    this._dollyEnd.set(0, distance);
-    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 centerX = (event.pageX + position.x) * 0.5;
-    const centerY = (event.pageY + position.y) * 0.5;
-    this._updateZoomParameters(centerX, centerY);
-  }
-  _handleTouchMoveDollyPan(event) {
-    if (this.enableZoom) this._handleTouchMoveDolly(event);
-    if (this.enablePan) this._handleTouchMovePan(event);
-  }
-  _handleTouchMoveDollyRotate(event) {
-    if (this.enableZoom) this._handleTouchMoveDolly(event);
-    if (this.enableRotate) this._handleTouchMoveRotate(event);
-  }
-  // pointers
-  _addPointer(event) {
-    this._pointers.push(event.pointerId);
-  }
-  _removePointer(event) {
-    delete this._pointerPositions[event.pointerId];
-    for (let i = 0; i < this._pointers.length; i++) {
-      if (this._pointers[i] == event.pointerId) {
-        this._pointers.splice(i, 1);
-        return;
-      }
-    }
-  }
-  _isTrackingPointer(event) {
-    for (let i = 0; i < this._pointers.length; i++) {
-      if (this._pointers[i] == event.pointerId) return true;
-    }
-    return false;
-  }
-  _trackPointer(event) {
-    let position = this._pointerPositions[event.pointerId];
-    if (position === void 0) {
-      position = new Vector2();
-      this._pointerPositions[event.pointerId] = position;
-    }
-    position.set(event.pageX, event.pageY);
-  }
-  _getSecondPointerPosition(event) {
-    const pointerId = event.pointerId === this._pointers[0] ? this._pointers[1] : this._pointers[0];
-    return this._pointerPositions[pointerId];
-  }
-  //
-  _customWheelEvent(event) {
-    const mode = event.deltaMode;
-    const newEvent = {
-      clientX: event.clientX,
-      clientY: event.clientY,
-      deltaY: event.deltaY
-    };
-    switch (mode) {
-      case 1:
-        newEvent.deltaY *= 16;
-        break;
-      case 2:
-        newEvent.deltaY *= 100;
-        break;
-    }
-    if (event.ctrlKey && !this._controlActive) {
-      newEvent.deltaY *= 10;
-    }
-    return newEvent;
-  }
-}
-function onPointerDown(event) {
-  if (this.enabled === false) return;
-  if (this._pointers.length === 0) {
-    this.domElement.setPointerCapture(event.pointerId);
-    this.domElement.addEventListener("pointermove", this._onPointerMove);
-    this.domElement.addEventListener("pointerup", this._onPointerUp);
-  }
-  if (this._isTrackingPointer(event)) return;
-  this._addPointer(event);
-  if (event.pointerType === "touch") {
-    this._onTouchStart(event);
-  } else {
-    this._onMouseDown(event);
-  }
-}
-function onPointerMove(event) {
-  if (this.enabled === false) return;
-  if (event.pointerType === "touch") {
-    this._onTouchMove(event);
-  } else {
-    this._onMouseMove(event);
-  }
-}
-function onPointerUp(event) {
-  this._removePointer(event);
-  switch (this._pointers.length) {
-    case 0:
-      this.domElement.releasePointerCapture(event.pointerId);
-      this.domElement.removeEventListener("pointermove", this._onPointerMove);
-      this.domElement.removeEventListener("pointerup", this._onPointerUp);
-      this.dispatchEvent(_endEvent);
-      this.state = _STATE.NONE;
-      break;
-    case 1:
-      const pointerId = this._pointers[0];
-      const position = this._pointerPositions[pointerId];
-      this._onTouchStart({ pointerId, pageX: position.x, pageY: position.y });
-      break;
-  }
-}
-function onMouseDown(event) {
-  let mouseAction;
-  switch (event.button) {
-    case 0:
-      mouseAction = this.mouseButtons.LEFT;
-      break;
-    case 1:
-      mouseAction = this.mouseButtons.MIDDLE;
-      break;
-    case 2:
-      mouseAction = this.mouseButtons.RIGHT;
-      break;
-    default:
-      mouseAction = -1;
-  }
-  switch (mouseAction) {
-    case MOUSE.DOLLY:
-      if (this.enableZoom === false) return;
-      this._handleMouseDownDolly(event);
-      this.state = _STATE.DOLLY;
-      break;
-    case MOUSE.ROTATE:
-      if (event.ctrlKey || event.metaKey || event.shiftKey) {
-        if (this.enablePan === false) return;
-        this._handleMouseDownPan(event);
-        this.state = _STATE.PAN;
-      } else {
-        if (this.enableRotate === false) return;
-        this._handleMouseDownRotate(event);
-        this.state = _STATE.ROTATE;
-      }
-      break;
-    case MOUSE.PAN:
-      if (event.ctrlKey || event.metaKey || event.shiftKey) {
-        if (this.enableRotate === false) return;
-        this._handleMouseDownRotate(event);
-        this.state = _STATE.ROTATE;
-      } else {
-        if (this.enablePan === false) return;
-        this._handleMouseDownPan(event);
-        this.state = _STATE.PAN;
-      }
-      break;
-    default:
-      this.state = _STATE.NONE;
-  }
-  if (this.state !== _STATE.NONE) {
-    this.dispatchEvent(_startEvent);
-  }
-}
-function onMouseMove(event) {
-  switch (this.state) {
-    case _STATE.ROTATE:
-      if (this.enableRotate === false) return;
-      this._handleMouseMoveRotate(event);
-      break;
-    case _STATE.DOLLY:
-      if (this.enableZoom === false) return;
-      this._handleMouseMoveDolly(event);
-      break;
-    case _STATE.PAN:
-      if (this.enablePan === false) return;
-      this._handleMouseMovePan(event);
-      break;
-  }
-}
-function onMouseWheel(event) {
-  if (this.enabled === false || this.enableZoom === false || this.state !== _STATE.NONE) return;
-  event.preventDefault();
-  this.dispatchEvent(_startEvent);
-  this._handleMouseWheel(this._customWheelEvent(event));
-  this.dispatchEvent(_endEvent);
-}
-function onKeyDown(event) {
-  if (this.enabled === false) return;
-  this._handleKeyDown(event);
-}
-function onTouchStart(event) {
-  this._trackPointer(event);
-  switch (this._pointers.length) {
-    case 1:
-      switch (this.touches.ONE) {
-        case TOUCH.ROTATE:
-          if (this.enableRotate === false) return;
-          this._handleTouchStartRotate(event);
-          this.state = _STATE.TOUCH_ROTATE;
-          break;
-        case TOUCH.PAN:
-          if (this.enablePan === false) return;
-          this._handleTouchStartPan(event);
-          this.state = _STATE.TOUCH_PAN;
-          break;
-        default:
-          this.state = _STATE.NONE;
-      }
-      break;
-    case 2:
-      switch (this.touches.TWO) {
-        case TOUCH.DOLLY_PAN:
-          if (this.enableZoom === false && this.enablePan === false) return;
-          this._handleTouchStartDollyPan(event);
-          this.state = _STATE.TOUCH_DOLLY_PAN;
-          break;
-        case TOUCH.DOLLY_ROTATE:
-          if (this.enableZoom === false && this.enableRotate === false) return;
-          this._handleTouchStartDollyRotate(event);
-          this.state = _STATE.TOUCH_DOLLY_ROTATE;
-          break;
-        default:
-          this.state = _STATE.NONE;
-      }
-      break;
-    default:
-      this.state = _STATE.NONE;
-  }
-  if (this.state !== _STATE.NONE) {
-    this.dispatchEvent(_startEvent);
-  }
-}
-function onTouchMove(event) {
-  this._trackPointer(event);
-  switch (this.state) {
-    case _STATE.TOUCH_ROTATE:
-      if (this.enableRotate === false) return;
-      this._handleTouchMoveRotate(event);
-      this.update();
-      break;
-    case _STATE.TOUCH_PAN:
-      if (this.enablePan === false) return;
-      this._handleTouchMovePan(event);
-      this.update();
-      break;
-    case _STATE.TOUCH_DOLLY_PAN:
-      if (this.enableZoom === false && this.enablePan === false) return;
-      this._handleTouchMoveDollyPan(event);
-      this.update();
-      break;
-    case _STATE.TOUCH_DOLLY_ROTATE:
-      if (this.enableZoom === false && this.enableRotate === false) return;
-      this._handleTouchMoveDollyRotate(event);
-      this.update();
-      break;
-    default:
-      this.state = _STATE.NONE;
-  }
-}
-function onContextMenu(event) {
-  if (this.enabled === false) return;
-  event.preventDefault();
-}
-function interceptControlDown(event) {
-  if (event.key === "Control") {
-    this._controlActive = true;
-    const document2 = this.domElement.getRootNode();
-    document2.addEventListener("keyup", this._interceptControlUp, { passive: true, capture: true });
-  }
-}
-function interceptControlUp(event) {
-  if (event.key === "Control") {
-    this._controlActive = false;
-    const document2 = this.domElement.getRootNode();
-    document2.removeEventListener("keyup", this._interceptControlUp, { passive: true, capture: true });
-  }
-}
-class MapControls extends OrbitControls {
-  constructor(object, domElement) {
-    super(object, domElement);
-    this.screenSpacePanning = false;
-    this.mouseButtons = { LEFT: MOUSE.PAN, MIDDLE: MOUSE.DOLLY, RIGHT: MOUSE.ROTATE };
-    this.touches = { ONE: TOUCH.PAN, TWO: TOUCH.DOLLY_ROTATE };
-  }
-}
-function createCameraHelper(camera) {
-  return new CameraHelper(camera);
-}
-function createGridHelper(size = 150, ...args) {
-  return new GridHelper(size, size / 10, ...args);
-}
-function createBox3Helper(model) {
-  return new BoxHelper(model, 16776960);
-}
-function createOrbitControl(camera, dom) {
-  return new OrbitControls(camera, dom);
-}
-function createMapControls(camera, dom) {
-  return new MapControls(camera, dom);
-}
-function createRaycaster() {
-  const raycaster = new Raycaster();
-  const pointer = new Vector2(0, 0);
-  return {
-    raycaster,
-    pointer
-  };
-}
-function createAxesHelper(size = 10) {
-  return new AxesHelper(size);
-}
-function createArrowHelper(dir = new Vector3(1, 1, 1), ori = new Vector3(10, 10, 10), length = 5, hex = 16776960) {
-  dir.normalize();
-  return new ArrowHelper(dir, ori, length, hex);
-}
-function createStats() {
-  const stats = new Stats();
-  stats.dom.style.cssText = "position:absolute;top:0;left:0;cursor:pointer;opacity:0.9;z-index:10000";
-  return stats;
-}
-class RGBELoader extends DataTextureLoader {
-  /**
-   * Constructs a new RGBE loader.
-   *
-   * @param {LoadingManager} [manager] - The loading manager.
-   */
-  constructor(manager) {
-    super(manager);
-    this.type = HalfFloatType;
-  }
-  /**
-   * Parses the given RGBE texture data.
-   *
-   * @param {ArrayBuffer} buffer - The raw texture data.
-   * @return {DataTextureLoader~TexData} An object representing the parsed texture data.
-   */
-  parse(buffer) {
-    const rgbe_read_error = 1, rgbe_write_error = 2, rgbe_format_error = 3, rgbe_memory_error = 4, rgbe_error = function(rgbe_error_code, msg) {
-      switch (rgbe_error_code) {
-        case rgbe_read_error:
-          throw new Error("THREE.RGBELoader: Read Error: " + (msg || ""));
-        case rgbe_write_error:
-          throw new Error("THREE.RGBELoader: Write Error: " + (msg || ""));
-        case rgbe_format_error:
-          throw new Error("THREE.RGBELoader: Bad File Format: " + (msg || ""));
-        default:
-        case rgbe_memory_error:
-          throw new Error("THREE.RGBELoader: Memory Error: " + (msg || ""));
-      }
-    }, RGBE_VALID_PROGRAMTYPE = 1, RGBE_VALID_FORMAT = 2, RGBE_VALID_DIMENSIONS = 4, NEWLINE = "\n", fgets = function(buffer2, lineLimit, consume) {
-      const chunkSize = 128;
-      lineLimit = !lineLimit ? 1024 : lineLimit;
-      let p = buffer2.pos, i = -1, len = 0, s = "", chunk = String.fromCharCode.apply(null, new Uint16Array(buffer2.subarray(p, p + chunkSize)));
-      while (0 > (i = chunk.indexOf(NEWLINE)) && len < lineLimit && p < buffer2.byteLength) {
-        s += chunk;
-        len += chunk.length;
-        p += chunkSize;
-        chunk += String.fromCharCode.apply(null, new Uint16Array(buffer2.subarray(p, p + chunkSize)));
-      }
-      if (-1 < i) {
-        buffer2.pos += len + i + 1;
-        return s + chunk.slice(0, i);
-      }
-      return false;
-    }, RGBE_ReadHeader = function(buffer2) {
-      const magic_token_re = /^#\?(\S+)/, gamma_re = /^\s*GAMMA\s*=\s*(\d+(\.\d+)?)\s*$/, exposure_re = /^\s*EXPOSURE\s*=\s*(\d+(\.\d+)?)\s*$/, format_re = /^\s*FORMAT=(\S+)\s*$/, dimensions_re = /^\s*\-Y\s+(\d+)\s+\+X\s+(\d+)\s*$/, header = {
-        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 line, match;
-      if (buffer2.pos >= buffer2.byteLength || !(line = fgets(buffer2))) {
-        rgbe_error(rgbe_read_error, "no header found");
-      }
-      if (!(match = line.match(magic_token_re))) {
-        rgbe_error(rgbe_format_error, "bad initial token");
-      }
-      header.valid |= RGBE_VALID_PROGRAMTYPE;
-      header.programtype = match[1];
-      header.string += line + "\n";
-      while (true) {
-        line = fgets(buffer2);
-        if (false === line) break;
-        header.string += line + "\n";
-        if ("#" === line.charAt(0)) {
-          header.comments += line + "\n";
-          continue;
-        }
-        if (match = line.match(gamma_re)) {
-          header.gamma = parseFloat(match[1]);
-        }
-        if (match = line.match(exposure_re)) {
-          header.exposure = parseFloat(match[1]);
-        }
-        if (match = line.match(format_re)) {
-          header.valid |= RGBE_VALID_FORMAT;
-          header.format = match[1];
-        }
-        if (match = line.match(dimensions_re)) {
-          header.valid |= RGBE_VALID_DIMENSIONS;
-          header.height = parseInt(match[1], 10);
-          header.width = parseInt(match[2], 10);
-        }
-        if (header.valid & RGBE_VALID_FORMAT && header.valid & RGBE_VALID_DIMENSIONS) break;
-      }
-      if (!(header.valid & RGBE_VALID_FORMAT)) {
-        rgbe_error(rgbe_format_error, "missing format specifier");
-      }
-      if (!(header.valid & RGBE_VALID_DIMENSIONS)) {
-        rgbe_error(rgbe_format_error, "missing image size specifier");
-      }
-      return header;
-    }, RGBE_ReadPixels_RLE = function(buffer2, w2, h2) {
-      const scanline_width = w2;
-      if (
-        // run length encoding is not allowed so read flat
-        scanline_width < 8 || scanline_width > 32767 || // this file is not run length encoded
-        (2 !== buffer2[0] || 2 !== buffer2[1] || buffer2[2] & 128)
-      ) {
-        return new Uint8Array(buffer2);
-      }
-      if (scanline_width !== (buffer2[2] << 8 | buffer2[3])) {
-        rgbe_error(rgbe_format_error, "wrong scanline width");
-      }
-      const data_rgba = new Uint8Array(4 * w2 * h2);
-      if (!data_rgba.length) {
-        rgbe_error(rgbe_memory_error, "unable to allocate buffer space");
-      }
-      let offset = 0, pos = 0;
-      const ptr_end = 4 * scanline_width;
-      const rgbeStart = new Uint8Array(4);
-      const scanline_buffer = new Uint8Array(ptr_end);
-      let num_scanlines = h2;
-      while (num_scanlines > 0 && pos < buffer2.byteLength) {
-        if (pos + 4 > buffer2.byteLength) {
-          rgbe_error(rgbe_read_error);
-        }
-        rgbeStart[0] = buffer2[pos++];
-        rgbeStart[1] = buffer2[pos++];
-        rgbeStart[2] = buffer2[pos++];
-        rgbeStart[3] = buffer2[pos++];
-        if (2 != rgbeStart[0] || 2 != rgbeStart[1] || (rgbeStart[2] << 8 | rgbeStart[3]) != scanline_width) {
-          rgbe_error(rgbe_format_error, "bad rgbe scanline format");
-        }
-        let ptr = 0, count;
-        while (ptr < ptr_end && pos < buffer2.byteLength) {
-          count = buffer2[pos++];
-          const isEncodedRun = count > 128;
-          if (isEncodedRun) count -= 128;
-          if (0 === count || ptr + count > ptr_end) {
-            rgbe_error(rgbe_format_error, "bad scanline data");
-          }
-          if (isEncodedRun) {
-            const byteValue = buffer2[pos++];
-            for (let i = 0; i < count; i++) {
-              scanline_buffer[ptr++] = byteValue;
-            }
-          } else {
-            scanline_buffer.set(buffer2.subarray(pos, pos + count), ptr);
-            ptr += count;
-            pos += count;
-          }
-        }
-        const l = scanline_width;
-        for (let i = 0; i < l; i++) {
-          let off = 0;
-          data_rgba[offset] = scanline_buffer[i + off];
-          off += scanline_width;
-          data_rgba[offset + 1] = scanline_buffer[i + off];
-          off += scanline_width;
-          data_rgba[offset + 2] = scanline_buffer[i + off];
-          off += scanline_width;
-          data_rgba[offset + 3] = scanline_buffer[i + off];
-          offset += 4;
-        }
-        num_scanlines--;
-      }
-      return data_rgba;
-    };
-    const RGBEByteToRGBFloat = function(sourceArray, sourceOffset, destArray, destOffset) {
-      const e = sourceArray[sourceOffset + 3];
-      const scale = Math.pow(2, e - 128) / 255;
-      destArray[destOffset + 0] = sourceArray[sourceOffset + 0] * scale;
-      destArray[destOffset + 1] = sourceArray[sourceOffset + 1] * scale;
-      destArray[destOffset + 2] = sourceArray[sourceOffset + 2] * scale;
-      destArray[destOffset + 3] = 1;
-    };
-    const RGBEByteToRGBHalf = function(sourceArray, sourceOffset, destArray, destOffset) {
-      const e = sourceArray[sourceOffset + 3];
-      const scale = Math.pow(2, e - 128) / 255;
-      destArray[destOffset + 0] = DataUtils.toHalfFloat(Math.min(sourceArray[sourceOffset + 0] * scale, 65504));
-      destArray[destOffset + 1] = DataUtils.toHalfFloat(Math.min(sourceArray[sourceOffset + 1] * scale, 65504));
-      destArray[destOffset + 2] = DataUtils.toHalfFloat(Math.min(sourceArray[sourceOffset + 2] * scale, 65504));
-      destArray[destOffset + 3] = DataUtils.toHalfFloat(1);
-    };
-    const byteArray = new Uint8Array(buffer);
-    byteArray.pos = 0;
-    const rgbe_header_info = RGBE_ReadHeader(byteArray);
-    const w = rgbe_header_info.width, h = rgbe_header_info.height, image_rgba_data = RGBE_ReadPixels_RLE(byteArray.subarray(byteArray.pos), w, h);
-    let data, type;
-    let numElements;
-    switch (this.type) {
-      case FloatType:
-        numElements = image_rgba_data.length / 4;
-        const floatArray = new Float32Array(numElements * 4);
-        for (let j = 0; j < numElements; j++) {
-          RGBEByteToRGBFloat(image_rgba_data, j * 4, floatArray, j * 4);
-        }
-        data = floatArray;
-        type = FloatType;
-        break;
-      case HalfFloatType:
-        numElements = image_rgba_data.length / 4;
-        const halfArray = new Uint16Array(numElements * 4);
-        for (let j = 0; j < numElements; j++) {
-          RGBEByteToRGBHalf(image_rgba_data, j * 4, halfArray, j * 4);
-        }
-        data = halfArray;
-        type = HalfFloatType;
-        break;
-      default:
-        throw new Error("THREE.RGBELoader: Unsupported type: " + this.type);
-    }
-    return {
-      width: w,
-      height: h,
-      data,
-      header: rgbe_header_info.string,
-      gamma: rgbe_header_info.gamma,
-      exposure: rgbe_header_info.exposure,
-      type
-    };
-  }
-  /**
-   * Sets the texture type.
-   *
-   * @param {(HalfFloatType|FloatType)} value - The texture type to set.
-   * @return {RGBELoader} A reference to this loader.
-   */
-  setDataType(value) {
-    this.type = value;
-    return this;
-  }
-  load(url, onLoad, onProgress, onError) {
-    function onLoadCallback(texture, texData) {
-      switch (texture.type) {
-        case FloatType:
-        case HalfFloatType:
-          texture.colorSpace = LinearSRGBColorSpace;
-          texture.minFilter = LinearFilter;
-          texture.magFilter = LinearFilter;
-          texture.generateMipmaps = false;
-          texture.flipY = true;
-          break;
-      }
-      if (onLoad) onLoad(texture, texData);
-    }
-    return super.load(url, onLoadCallback, onProgress, onError);
-  }
-}
-const disposeThreeObject = (object) => {
-  if (object.geometry) {
-    object.geometry.dispose();
-  }
-  if (object.material) {
-    if (Array.isArray(object.material)) {
-      object.material.forEach((material) => {
-        disposeMaterial(material);
-      });
-    } else {
-      disposeMaterial(object.material);
-    }
-  }
-  if (object.children) {
-    object.children.forEach((child) => disposeThreeObject(child));
-  }
-};
-function disposeMaterial(material) {
-  for (const key in material) {
-    if (material[key] && material[key].isTexture) {
-      material[key].dispose();
-    }
-  }
-  material.dispose();
-}
-const cacheHdr = {};
-const rgbeLoader = new RGBELoader();
-async function initEnvImage(scene, path) {
-  if (!path) return;
-  if (cacheHdr[path]) {
-    const texture = cacheHdr[path];
-    scene.environment = texture;
-    return;
-  }
-  return new Promise((resolve, reject) => {
-    rgbeLoader.load(path, resolve, void 0, reject);
-  }).then((texture) => {
-    texture.mapping = EquirectangularReflectionMapping;
-    scene.environment = texture;
-    cacheHdr[path] = texture;
-  }).catch((e) => {
-    console.log("  =====> e:", e);
-  });
-}
-async function ImageLoader(path) {
-  return new Promise((resolve, reject) => {
-    rgbeLoader.load(path, resolve, void 0, reject);
-  });
-}
-export {
-  CSS3DSprite as C,
-  ImageLoader as I,
-  Stats as S,
-  createGridHelper as a,
-  createBox3Helper as b,
-  createCameraHelper as c,
-  createOrbitControl as d,
-  createMapControls as e,
-  createRaycaster as f,
-  createAxesHelper as g,
-  createArrowHelper as h,
-  createStats as i,
-  disposeThreeObject as j,
-  initEnvImage as k,
-  CSS3DRenderer as l
-};