three-stdlib 2.16.0 → 2.16.2

package/controls/ArcballControls.mjs

@@ -1,1737 +0,0 @@
-import { Matrix4, EventDispatcher, EllipseCurve, BufferGeometry, MathUtils, Vector3, GridHelper, LineBasicMaterial, Line, Raycaster, Vector2, Quaternion, Group, Box3, Sphere } from "three";
-const STATE = {
-  IDLE: Symbol(),
-  ROTATE: Symbol(),
-  PAN: Symbol(),
-  SCALE: Symbol(),
-  FOV: Symbol(),
-  FOCUS: Symbol(),
-  ZROTATE: Symbol(),
-  TOUCH_MULTI: Symbol(),
-  ANIMATION_FOCUS: Symbol(),
-  ANIMATION_ROTATE: Symbol()
-};
-const INPUT = {
-  NONE: Symbol(),
-  ONE_FINGER: Symbol(),
-  ONE_FINGER_SWITCHED: Symbol(),
-  TWO_FINGER: Symbol(),
-  MULT_FINGER: Symbol(),
-  CURSOR: Symbol()
-};
-const _center = {
-  x: 0,
-  y: 0
-};
-const _transformation = {
-  camera: new Matrix4(),
-  gizmos: new Matrix4()
-};
-const _changeEvent = { type: "change" };
-const _startEvent = { type: "start" };
-const _endEvent = { type: "end" };
-class ArcballControls extends EventDispatcher {
-  constructor(camera, domElement = null, scene = null) {
-    super();
-    this.onWindowResize = () => {
-      const scale = (this._gizmos.scale.x + this._gizmos.scale.y + this._gizmos.scale.z) / 3;
-      if (this.camera) {
-        const tbRadius = this.calculateTbRadius(this.camera);
-        if (tbRadius !== void 0) {
-          this._tbRadius = tbRadius;
-        }
-      }
-      const newRadius = this._tbRadius / scale;
-      const curve = new EllipseCurve(0, 0, newRadius, newRadius);
-      const points = curve.getPoints(this._curvePts);
-      const curveGeometry = new BufferGeometry().setFromPoints(points);
-      for (const gizmo in this._gizmos.children) {
-        const child = this._gizmos.children[gizmo];
-        child.geometry = curveGeometry;
-      }
-      this.dispatchEvent(_changeEvent);
-    };
-    this.onContextMenu = (event) => {
-      if (!this.enabled) {
-        return;
-      }
-      for (let i = 0; i < this.mouseActions.length; i++) {
-        if (this.mouseActions[i].mouse == 2) {
-          event.preventDefault();
-          break;
-        }
-      }
-    };
-    this.onPointerCancel = () => {
-      this._touchStart.splice(0, this._touchStart.length);
-      this._touchCurrent.splice(0, this._touchCurrent.length);
-      this._input = INPUT.NONE;
-    };
-    this.onPointerDown = (event) => {
-      if (event.button == 0 && event.isPrimary) {
-        this._downValid = true;
-        this._downEvents.push(event);
-      } else {
-        this._downValid = false;
-      }
-      if (event.pointerType == "touch" && this._input != INPUT.CURSOR) {
-        this._touchStart.push(event);
-        this._touchCurrent.push(event);
-        switch (this._input) {
-          case INPUT.NONE:
-            this._input = INPUT.ONE_FINGER;
-            this.onSinglePanStart(event, "ROTATE");
-            window.addEventListener("pointermove", this.onPointerMove);
-            window.addEventListener("pointerup", this.onPointerUp);
-            break;
-          case INPUT.ONE_FINGER:
-          case INPUT.ONE_FINGER_SWITCHED:
-            this._input = INPUT.TWO_FINGER;
-            this.onRotateStart();
-            this.onPinchStart();
-            this.onDoublePanStart();
-            break;
-          case INPUT.TWO_FINGER:
-            this._input = INPUT.MULT_FINGER;
-            this.onTriplePanStart();
-            break;
-        }
-      } else if (event.pointerType != "touch" && this._input == INPUT.NONE) {
-        let modifier = null;
-        if (event.ctrlKey || event.metaKey) {
-          modifier = "CTRL";
-        } else if (event.shiftKey) {
-          modifier = "SHIFT";
-        }
-        this._mouseOp = this.getOpFromAction(event.button, modifier);
-        if (this._mouseOp) {
-          window.addEventListener("pointermove", this.onPointerMove);
-          window.addEventListener("pointerup", this.onPointerUp);
-          this._input = INPUT.CURSOR;
-          this._button = event.button;
-          this.onSinglePanStart(event, this._mouseOp);
-        }
-      }
-    };
-    this.onPointerMove = (event) => {
-      if (event.pointerType == "touch" && this._input != INPUT.CURSOR) {
-        switch (this._input) {
-          case INPUT.ONE_FINGER:
-            this.updateTouchEvent(event);
-            this.onSinglePanMove(event, STATE.ROTATE);
-            break;
-          case INPUT.ONE_FINGER_SWITCHED:
-            const movement = this.calculatePointersDistance(this._touchCurrent[0], event) * this._devPxRatio;
-            if (movement >= this._switchSensibility) {
-              this._input = INPUT.ONE_FINGER;
-              this.updateTouchEvent(event);
-              this.onSinglePanStart(event, "ROTATE");
-              break;
-            }
-            break;
-          case INPUT.TWO_FINGER:
-            this.updateTouchEvent(event);
-            this.onRotateMove();
-            this.onPinchMove();
-            this.onDoublePanMove();
-            break;
-          case INPUT.MULT_FINGER:
-            this.updateTouchEvent(event);
-            this.onTriplePanMove();
-            break;
-        }
-      } else if (event.pointerType != "touch" && this._input == INPUT.CURSOR) {
-        let modifier = null;
-        if (event.ctrlKey || event.metaKey) {
-          modifier = "CTRL";
-        } else if (event.shiftKey) {
-          modifier = "SHIFT";
-        }
-        const mouseOpState = this.getOpStateFromAction(this._button, modifier);
-        if (mouseOpState) {
-          this.onSinglePanMove(event, mouseOpState);
-        }
-      }
-      if (this._downValid) {
-        const movement = this.calculatePointersDistance(this._downEvents[this._downEvents.length - 1], event) * this._devPxRatio;
-        if (movement > this._movementThreshold) {
-          this._downValid = false;
-        }
-      }
-    };
-    this.onPointerUp = (event) => {
-      if (event.pointerType == "touch" && this._input != INPUT.CURSOR) {
-        const nTouch = this._touchCurrent.length;
-        for (let i = 0; i < nTouch; i++) {
-          if (this._touchCurrent[i].pointerId == event.pointerId) {
-            this._touchCurrent.splice(i, 1);
-            this._touchStart.splice(i, 1);
-            break;
-          }
-        }
-        switch (this._input) {
-          case INPUT.ONE_FINGER:
-          case INPUT.ONE_FINGER_SWITCHED:
-            window.removeEventListener("pointermove", this.onPointerMove);
-            window.removeEventListener("pointerup", this.onPointerUp);
-            this._input = INPUT.NONE;
-            this.onSinglePanEnd();
-            break;
-          case INPUT.TWO_FINGER:
-            this.onDoublePanEnd();
-            this.onPinchEnd();
-            this.onRotateEnd();
-            this._input = INPUT.ONE_FINGER_SWITCHED;
-            break;
-          case INPUT.MULT_FINGER:
-            if (this._touchCurrent.length == 0) {
-              window.removeEventListener("pointermove", this.onPointerMove);
-              window.removeEventListener("pointerup", this.onPointerUp);
-              this._input = INPUT.NONE;
-              this.onTriplePanEnd();
-            }
-            break;
-        }
-      } else if (event.pointerType != "touch" && this._input == INPUT.CURSOR) {
-        window.removeEventListener("pointermove", this.onPointerMove);
-        window.removeEventListener("pointerup", this.onPointerUp);
-        this._input = INPUT.NONE;
-        this.onSinglePanEnd();
-        this._button = -1;
-      }
-      if (event.isPrimary) {
-        if (this._downValid) {
-          const downTime = event.timeStamp - this._downEvents[this._downEvents.length - 1].timeStamp;
-          if (downTime <= this._maxDownTime) {
-            if (this._nclicks == 0) {
-              this._nclicks = 1;
-              this._clickStart = performance.now();
-            } else {
-              const clickInterval = event.timeStamp - this._clickStart;
-              const movement = this.calculatePointersDistance(this._downEvents[1], this._downEvents[0]) * this._devPxRatio;
-              if (clickInterval <= this._maxInterval && movement <= this._posThreshold) {
-                this._nclicks = 0;
-                this._downEvents.splice(0, this._downEvents.length);
-                this.onDoubleTap(event);
-              } else {
-                this._nclicks = 1;
-                this._downEvents.shift();
-                this._clickStart = performance.now();
-              }
-            }
-          } else {
-            this._downValid = false;
-            this._nclicks = 0;
-            this._downEvents.splice(0, this._downEvents.length);
-          }
-        } else {
-          this._nclicks = 0;
-          this._downEvents.splice(0, this._downEvents.length);
-        }
-      }
-    };
-    this.onWheel = (event) => {
-      var _a, _b, _c, _d, _e;
-      if (this.enabled && this.enableZoom && this.domElement) {
-        let modifier = null;
-        if (event.ctrlKey || event.metaKey) {
-          modifier = "CTRL";
-        } else if (event.shiftKey) {
-          modifier = "SHIFT";
-        }
-        const mouseOp = this.getOpFromAction("WHEEL", modifier);
-        if (mouseOp) {
-          event.preventDefault();
-          this.dispatchEvent(_startEvent);
-          const notchDeltaY = 125;
-          let sgn = event.deltaY / notchDeltaY;
-          let size = 1;
-          if (sgn > 0) {
-            size = 1 / this.scaleFactor;
-          } else if (sgn < 0) {
-            size = this.scaleFactor;
-          }
-          switch (mouseOp) {
-            case "ZOOM":
-              this.updateTbState(STATE.SCALE, true);
-              if (sgn > 0) {
-                size = 1 / Math.pow(this.scaleFactor, sgn);
-              } else if (sgn < 0) {
-                size = Math.pow(this.scaleFactor, -sgn);
-              }
-              if (this.cursorZoom && this.enablePan) {
-                let scalePoint;
-                if (((_a = this.camera) == null ? void 0 : _a.type) === "OrthographicCamera") {
-                  scalePoint = (_b = this.unprojectOnTbPlane(this.camera, event.clientX, event.clientY, this.domElement)) == null ? void 0 : _b.applyQuaternion(this.camera.quaternion).multiplyScalar(1 / this.camera.zoom).add(this._gizmos.position);
-                }
-                if (((_c = this.camera) == null ? void 0 : _c.type) === "PerspectiveCamera") {
-                  scalePoint = (_d = this.unprojectOnTbPlane(this.camera, event.clientX, event.clientY, this.domElement)) == null ? void 0 : _d.applyQuaternion(this.camera.quaternion).add(this._gizmos.position);
-                }
-                if (scalePoint !== void 0)
-                  this.applyTransformMatrix(this.applyScale(size, scalePoint));
-              } else {
-                this.applyTransformMatrix(this.applyScale(size, this._gizmos.position));
-              }
-              if (this._grid) {
-                this.disposeGrid();
-                this.drawGrid();
-              }
-              this.updateTbState(STATE.IDLE, false);
-              this.dispatchEvent(_changeEvent);
-              this.dispatchEvent(_endEvent);
-              break;
-            case "FOV":
-              if (((_e = this.camera) == null ? void 0 : _e.type) === "PerspectiveCamera") {
-                this.updateTbState(STATE.FOV, true);
-                if (event.deltaX != 0) {
-                  sgn = event.deltaX / notchDeltaY;
-                  size = 1;
-                  if (sgn > 0) {
-                    size = 1 / Math.pow(this.scaleFactor, sgn);
-                  } else if (sgn < 0) {
-                    size = Math.pow(this.scaleFactor, -sgn);
-                  }
-                }
-                this._v3_1.setFromMatrixPosition(this._cameraMatrixState);
-                const x = this._v3_1.distanceTo(this._gizmos.position);
-                let xNew = x / size;
-                xNew = MathUtils.clamp(xNew, this.minDistance, this.maxDistance);
-                const y = x * Math.tan(MathUtils.DEG2RAD * this.camera.fov * 0.5);
-                let newFov = MathUtils.RAD2DEG * (Math.atan(y / xNew) * 2);
-                if (newFov > this.maxFov) {
-                  newFov = this.maxFov;
-                } else if (newFov < this.minFov) {
-                  newFov = this.minFov;
-                }
-                const newDistance = y / Math.tan(MathUtils.DEG2RAD * (newFov / 2));
-                size = x / newDistance;
-                this.setFov(newFov);
-                this.applyTransformMatrix(this.applyScale(size, this._gizmos.position, false));
-              }
-              if (this._grid) {
-                this.disposeGrid();
-                this.drawGrid();
-              }
-              this.updateTbState(STATE.IDLE, false);
-              this.dispatchEvent(_changeEvent);
-              this.dispatchEvent(_endEvent);
-              break;
-          }
-        }
-      }
-    };
-    this.onSinglePanStart = (event, operation) => {
-      var _a;
-      if (this.enabled && this.domElement) {
-        this.dispatchEvent(_startEvent);
-        this.setCenter(event.clientX, event.clientY);
-        switch (operation) {
-          case "PAN":
-            if (!this.enablePan)
-              return;
-            if (this._animationId != -1) {
-              cancelAnimationFrame(this._animationId);
-              this._animationId = -1;
-              this._timeStart = -1;
-              this.activateGizmos(false);
-              this.dispatchEvent(_changeEvent);
-            }
-            if (this.camera) {
-              this.updateTbState(STATE.PAN, true);
-              const rayDir = this.unprojectOnTbPlane(this.camera, _center.x, _center.y, this.domElement);
-              if (rayDir !== void 0) {
-                this._startCursorPosition.copy(rayDir);
-              }
-              if (this.enableGrid) {
-                this.drawGrid();
-                this.dispatchEvent(_changeEvent);
-              }
-            }
-            break;
-          case "ROTATE":
-            if (!this.enableRotate)
-              return;
-            if (this._animationId != -1) {
-              cancelAnimationFrame(this._animationId);
-              this._animationId = -1;
-              this._timeStart = -1;
-            }
-            if (this.camera) {
-              this.updateTbState(STATE.ROTATE, true);
-              const rayDir = this.unprojectOnTbSurface(this.camera, _center.x, _center.y, this.domElement, this._tbRadius);
-              if (rayDir !== void 0) {
-                this._startCursorPosition.copy(rayDir);
-              }
-              this.activateGizmos(true);
-              if (this.enableAnimations) {
-                this._timePrev = this._timeCurrent = performance.now();
-                this._angleCurrent = this._anglePrev = 0;
-                this._cursorPosPrev.copy(this._startCursorPosition);
-                this._cursorPosCurr.copy(this._cursorPosPrev);
-                this._wCurr = 0;
-                this._wPrev = this._wCurr;
-              }
-            }
-            this.dispatchEvent(_changeEvent);
-            break;
-          case "FOV":
-            if (!this.enableZoom)
-              return;
-            if (((_a = this.camera) == null ? void 0 : _a.type) === "PerspectiveCamera") {
-              if (this._animationId != -1) {
-                cancelAnimationFrame(this._animationId);
-                this._animationId = -1;
-                this._timeStart = -1;
-                this.activateGizmos(false);
-                this.dispatchEvent(_changeEvent);
-              }
-              this.updateTbState(STATE.FOV, true);
-              this._startCursorPosition.setY(this.getCursorNDC(_center.x, _center.y, this.domElement).y * 0.5);
-              this._currentCursorPosition.copy(this._startCursorPosition);
-            }
-            break;
-          case "ZOOM":
-            if (!this.enableZoom)
-              return;
-            if (this._animationId != -1) {
-              cancelAnimationFrame(this._animationId);
-              this._animationId = -1;
-              this._timeStart = -1;
-              this.activateGizmos(false);
-              this.dispatchEvent(_changeEvent);
-            }
-            this.updateTbState(STATE.SCALE, true);
-            this._startCursorPosition.setY(this.getCursorNDC(_center.x, _center.y, this.domElement).y * 0.5);
-            this._currentCursorPosition.copy(this._startCursorPosition);
-            break;
-        }
-      }
-    };
-    this.onSinglePanMove = (event, opState) => {
-      var _a;
-      if (this.enabled && this.domElement) {
-        const restart = opState != this._state;
-        this.setCenter(event.clientX, event.clientY);
-        switch (opState) {
-          case STATE.PAN:
-            if (this.enablePan && this.camera) {
-              if (restart) {
-                this.dispatchEvent(_endEvent);
-                this.dispatchEvent(_startEvent);
-                this.updateTbState(opState, true);
-                const rayDir = this.unprojectOnTbPlane(this.camera, _center.x, _center.y, this.domElement);
-                if (rayDir !== void 0) {
-                  this._startCursorPosition.copy(rayDir);
-                }
-                if (this.enableGrid) {
-                  this.drawGrid();
-                }
-                this.activateGizmos(false);
-              } else {
-                const rayDir = this.unprojectOnTbPlane(this.camera, _center.x, _center.y, this.domElement);
-                if (rayDir !== void 0) {
-                  this._currentCursorPosition.copy(rayDir);
-                }
-                this.applyTransformMatrix(this.pan(this._startCursorPosition, this._currentCursorPosition));
-              }
-            }
-            break;
-          case STATE.ROTATE:
-            if (this.enableRotate && this.camera) {
-              if (restart) {
-                this.dispatchEvent(_endEvent);
-                this.dispatchEvent(_startEvent);
-                this.updateTbState(opState, true);
-                const rayDir = this.unprojectOnTbSurface(
-                  this.camera,
-                  _center.x,
-                  _center.y,
-                  this.domElement,
-                  this._tbRadius
-                );
-                if (rayDir !== void 0) {
-                  this._startCursorPosition.copy(rayDir);
-                }
-                if (this.enableGrid) {
-                  this.disposeGrid();
-                }
-                this.activateGizmos(true);
-              } else {
-                const rayDir = this.unprojectOnTbSurface(
-                  this.camera,
-                  _center.x,
-                  _center.y,
-                  this.domElement,
-                  this._tbRadius
-                );
-                if (rayDir !== void 0) {
-                  this._currentCursorPosition.copy(rayDir);
-                }
-                const distance = this._startCursorPosition.distanceTo(this._currentCursorPosition);
-                const angle = this._startCursorPosition.angleTo(this._currentCursorPosition);
-                const amount = Math.max(distance / this._tbRadius, angle);
-                this.applyTransformMatrix(
-                  this.rotate(this.calculateRotationAxis(this._startCursorPosition, this._currentCursorPosition), amount)
-                );
-                if (this.enableAnimations) {
-                  this._timePrev = this._timeCurrent;
-                  this._timeCurrent = performance.now();
-                  this._anglePrev = this._angleCurrent;
-                  this._angleCurrent = amount;
-                  this._cursorPosPrev.copy(this._cursorPosCurr);
-                  this._cursorPosCurr.copy(this._currentCursorPosition);
-                  this._wPrev = this._wCurr;
-                  this._wCurr = this.calculateAngularSpeed(
-                    this._anglePrev,
-                    this._angleCurrent,
-                    this._timePrev,
-                    this._timeCurrent
-                  );
-                }
-              }
-            }
-            break;
-          case STATE.SCALE:
-            if (this.enableZoom) {
-              if (restart) {
-                this.dispatchEvent(_endEvent);
-                this.dispatchEvent(_startEvent);
-                this.updateTbState(opState, true);
-                this._startCursorPosition.setY(this.getCursorNDC(_center.x, _center.y, this.domElement).y * 0.5);
-                this._currentCursorPosition.copy(this._startCursorPosition);
-                if (this.enableGrid) {
-                  this.disposeGrid();
-                }
-                this.activateGizmos(false);
-              } else {
-                const screenNotches = 8;
-                this._currentCursorPosition.setY(this.getCursorNDC(_center.x, _center.y, this.domElement).y * 0.5);
-                const movement = this._currentCursorPosition.y - this._startCursorPosition.y;
-                let size = 1;
-                if (movement < 0) {
-                  size = 1 / Math.pow(this.scaleFactor, -movement * screenNotches);
-                } else if (movement > 0) {
-                  size = Math.pow(this.scaleFactor, movement * screenNotches);
-                }
-                this.applyTransformMatrix(this.applyScale(size, this._gizmos.position));
-              }
-            }
-            break;
-          case STATE.FOV:
-            if (this.enableZoom && ((_a = this.camera) == null ? void 0 : _a.type) === "PerspectiveCamera") {
-              if (restart) {
-                this.dispatchEvent(_endEvent);
-                this.dispatchEvent(_startEvent);
-                this.updateTbState(opState, true);
-                this._startCursorPosition.setY(this.getCursorNDC(_center.x, _center.y, this.domElement).y * 0.5);
-                this._currentCursorPosition.copy(this._startCursorPosition);
-                if (this.enableGrid) {
-                  this.disposeGrid();
-                }
-                this.activateGizmos(false);
-              } else {
-                const screenNotches = 8;
-                this._currentCursorPosition.setY(this.getCursorNDC(_center.x, _center.y, this.domElement).y * 0.5);
-                const movement = this._currentCursorPosition.y - this._startCursorPosition.y;
-                let size = 1;
-                if (movement < 0) {
-                  size = 1 / Math.pow(this.scaleFactor, -movement * screenNotches);
-                } else if (movement > 0) {
-                  size = Math.pow(this.scaleFactor, movement * screenNotches);
-                }
-                this._v3_1.setFromMatrixPosition(this._cameraMatrixState);
-                const x = this._v3_1.distanceTo(this._gizmos.position);
-                let xNew = x / size;
-                xNew = MathUtils.clamp(xNew, this.minDistance, this.maxDistance);
-                const y = x * Math.tan(MathUtils.DEG2RAD * this._fovState * 0.5);
-                let newFov = MathUtils.RAD2DEG * (Math.atan(y / xNew) * 2);
-                newFov = MathUtils.clamp(newFov, this.minFov, this.maxFov);
-                const newDistance = y / Math.tan(MathUtils.DEG2RAD * (newFov / 2));
-                size = x / newDistance;
-                this._v3_2.setFromMatrixPosition(this._gizmoMatrixState);
-                this.setFov(newFov);
-                this.applyTransformMatrix(this.applyScale(size, this._v3_2, false));
-                const direction = this._gizmos.position.clone().sub(this.camera.position).normalize().multiplyScalar(newDistance / x);
-                this._m4_1.makeTranslation(direction.x, direction.y, direction.z);
-              }
-            }
-            break;
-        }
-        this.dispatchEvent(_changeEvent);
-      }
-    };
-    this.onSinglePanEnd = () => {
-      if (this._state == STATE.ROTATE) {
-        if (!this.enableRotate) {
-          return;
-        }
-        if (this.enableAnimations) {
-          const deltaTime = performance.now() - this._timeCurrent;
-          if (deltaTime < 120) {
-            const w = Math.abs((this._wPrev + this._wCurr) / 2);
-            const self = this;
-            this._animationId = window.requestAnimationFrame(function(t) {
-              self.updateTbState(STATE.ANIMATION_ROTATE, true);
-              const rotationAxis = self.calculateRotationAxis(self._cursorPosPrev, self._cursorPosCurr);
-              self.onRotationAnim(t, rotationAxis, Math.min(w, self.wMax));
-            });
-          } else {
-            this.updateTbState(STATE.IDLE, false);
-            this.activateGizmos(false);
-            this.dispatchEvent(_changeEvent);
-          }
-        } else {
-          this.updateTbState(STATE.IDLE, false);
-          this.activateGizmos(false);
-          this.dispatchEvent(_changeEvent);
-        }
-      } else if (this._state == STATE.PAN || this._state == STATE.IDLE) {
-        this.updateTbState(STATE.IDLE, false);
-        if (this.enableGrid) {
-          this.disposeGrid();
-        }
-        this.activateGizmos(false);
-        this.dispatchEvent(_changeEvent);
-      }
-      this.dispatchEvent(_endEvent);
-    };
-    this.onDoubleTap = (event) => {
-      if (this.enabled && this.enablePan && this.scene && this.camera && this.domElement) {
-        this.dispatchEvent(_startEvent);
-        this.setCenter(event.clientX, event.clientY);
-        const hitP = this.unprojectOnObj(this.getCursorNDC(_center.x, _center.y, this.domElement), this.camera);
-        if (hitP && this.enableAnimations) {
-          const self = this;
-          if (this._animationId != -1) {
-            window.cancelAnimationFrame(this._animationId);
-          }
-          this._timeStart = -1;
-          this._animationId = window.requestAnimationFrame(function(t) {
-            self.updateTbState(STATE.ANIMATION_FOCUS, true);
-            self.onFocusAnim(t, hitP, self._cameraMatrixState, self._gizmoMatrixState);
-          });
-        } else if (hitP && !this.enableAnimations) {
-          this.updateTbState(STATE.FOCUS, true);
-          this.focus(hitP, this.scaleFactor);
-          this.updateTbState(STATE.IDLE, false);
-          this.dispatchEvent(_changeEvent);
-        }
-      }
-      this.dispatchEvent(_endEvent);
-    };
-    this.onDoublePanStart = () => {
-      if (this.enabled && this.enablePan && this.camera && this.domElement) {
-        this.dispatchEvent(_startEvent);
-        this.updateTbState(STATE.PAN, true);
-        this.setCenter(
-          (this._touchCurrent[0].clientX + this._touchCurrent[1].clientX) / 2,
-          (this._touchCurrent[0].clientY + this._touchCurrent[1].clientY) / 2
-        );
-        const rayDir = this.unprojectOnTbPlane(this.camera, _center.x, _center.y, this.domElement, true);
-        if (rayDir !== void 0) {
-          this._startCursorPosition.copy(rayDir);
-        }
-        this._currentCursorPosition.copy(this._startCursorPosition);
-        this.activateGizmos(false);
-      }
-    };
-    this.onDoublePanMove = () => {
-      if (this.enabled && this.enablePan && this.camera && this.domElement) {
-        this.setCenter(
-          (this._touchCurrent[0].clientX + this._touchCurrent[1].clientX) / 2,
-          (this._touchCurrent[0].clientY + this._touchCurrent[1].clientY) / 2
-        );
-        if (this._state != STATE.PAN) {
-          this.updateTbState(STATE.PAN, true);
-          this._startCursorPosition.copy(this._currentCursorPosition);
-        }
-        const rayDir = this.unprojectOnTbPlane(this.camera, _center.x, _center.y, this.domElement, true);
-        if (rayDir !== void 0)
-          this._currentCursorPosition.copy(rayDir);
-        this.applyTransformMatrix(this.pan(this._startCursorPosition, this._currentCursorPosition, true));
-        this.dispatchEvent(_changeEvent);
-      }
-    };
-    this.onDoublePanEnd = () => {
-      this.updateTbState(STATE.IDLE, false);
-      this.dispatchEvent(_endEvent);
-    };
-    this.onRotateStart = () => {
-      var _a;
-      if (this.enabled && this.enableRotate) {
-        this.dispatchEvent(_startEvent);
-        this.updateTbState(STATE.ZROTATE, true);
-        this._startFingerRotation = this.getAngle(this._touchCurrent[1], this._touchCurrent[0]) + this.getAngle(this._touchStart[1], this._touchStart[0]);
-        this._currentFingerRotation = this._startFingerRotation;
-        (_a = this.camera) == null ? void 0 : _a.getWorldDirection(this._rotationAxis);
-        if (!this.enablePan && !this.enableZoom) {
-          this.activateGizmos(true);
-        }
-      }
-    };
-    this.onRotateMove = () => {
-      var _a;
-      if (this.enabled && this.enableRotate && this.camera && this.domElement) {
-        this.setCenter(
-          (this._touchCurrent[0].clientX + this._touchCurrent[1].clientX) / 2,
-          (this._touchCurrent[0].clientY + this._touchCurrent[1].clientY) / 2
-        );
-        let rotationPoint;
-        if (this._state != STATE.ZROTATE) {
-          this.updateTbState(STATE.ZROTATE, true);
-          this._startFingerRotation = this._currentFingerRotation;
-        }
-        this._currentFingerRotation = this.getAngle(this._touchCurrent[1], this._touchCurrent[0]) + this.getAngle(this._touchStart[1], this._touchStart[0]);
-        if (!this.enablePan) {
-          rotationPoint = new Vector3().setFromMatrixPosition(this._gizmoMatrixState);
-        } else if (this.camera) {
-          this._v3_2.setFromMatrixPosition(this._gizmoMatrixState);
-          rotationPoint = (_a = this.unprojectOnTbPlane(this.camera, _center.x, _center.y, this.domElement)) == null ? void 0 : _a.applyQuaternion(this.camera.quaternion).multiplyScalar(1 / this.camera.zoom).add(this._v3_2);
-        }
-        const amount = MathUtils.DEG2RAD * (this._startFingerRotation - this._currentFingerRotation);
-        if (rotationPoint !== void 0) {
-          this.applyTransformMatrix(this.zRotate(rotationPoint, amount));
-        }
-        this.dispatchEvent(_changeEvent);
-      }
-    };
-    this.onRotateEnd = () => {
-      this.updateTbState(STATE.IDLE, false);
-      this.activateGizmos(false);
-      this.dispatchEvent(_endEvent);
-    };
-    this.onPinchStart = () => {
-      if (this.enabled && this.enableZoom) {
-        this.dispatchEvent(_startEvent);
-        this.updateTbState(STATE.SCALE, true);
-        this._startFingerDistance = this.calculatePointersDistance(this._touchCurrent[0], this._touchCurrent[1]);
-        this._currentFingerDistance = this._startFingerDistance;
-        this.activateGizmos(false);
-      }
-    };
-    this.onPinchMove = () => {
-      var _a, _b, _c, _d;
-      if (this.enabled && this.enableZoom && this.domElement) {
-        this.setCenter(
-          (this._touchCurrent[0].clientX + this._touchCurrent[1].clientX) / 2,
-          (this._touchCurrent[0].clientY + this._touchCurrent[1].clientY) / 2
-        );
-        const minDistance = 12;
-        if (this._state != STATE.SCALE) {
-          this._startFingerDistance = this._currentFingerDistance;
-          this.updateTbState(STATE.SCALE, true);
-        }
-        this._currentFingerDistance = Math.max(
-          this.calculatePointersDistance(this._touchCurrent[0], this._touchCurrent[1]),
-          minDistance * this._devPxRatio
-        );
-        const amount = this._currentFingerDistance / this._startFingerDistance;
-        let scalePoint;
-        if (!this.enablePan) {
-          scalePoint = this._gizmos.position;
-        } else {
-          if (((_a = this.camera) == null ? void 0 : _a.type) === "OrthographicCamera") {
-            scalePoint = (_b = this.unprojectOnTbPlane(this.camera, _center.x, _center.y, this.domElement)) == null ? void 0 : _b.applyQuaternion(this.camera.quaternion).multiplyScalar(1 / this.camera.zoom).add(this._gizmos.position);
-          } else if (((_c = this.camera) == null ? void 0 : _c.type) === "PerspectiveCamera") {
-            scalePoint = (_d = this.unprojectOnTbPlane(this.camera, _center.x, _center.y, this.domElement)) == null ? void 0 : _d.applyQuaternion(this.camera.quaternion).add(this._gizmos.position);
-          }
-        }
-        if (scalePoint !== void 0) {
-          this.applyTransformMatrix(this.applyScale(amount, scalePoint));
-        }
-        this.dispatchEvent(_changeEvent);
-      }
-    };
-    this.onPinchEnd = () => {
-      this.updateTbState(STATE.IDLE, false);
-      this.dispatchEvent(_endEvent);
-    };
-    this.onTriplePanStart = () => {
-      if (this.enabled && this.enableZoom && this.domElement) {
-        this.dispatchEvent(_startEvent);
-        this.updateTbState(STATE.SCALE, true);
-        let clientX = 0;
-        let clientY = 0;
-        const nFingers = this._touchCurrent.length;
-        for (let i = 0; i < nFingers; i++) {
-          clientX += this._touchCurrent[i].clientX;
-          clientY += this._touchCurrent[i].clientY;
-        }
-        this.setCenter(clientX / nFingers, clientY / nFingers);
-        this._startCursorPosition.setY(this.getCursorNDC(_center.x, _center.y, this.domElement).y * 0.5);
-        this._currentCursorPosition.copy(this._startCursorPosition);
-      }
-    };
-    this.onTriplePanMove = () => {
-      if (this.enabled && this.enableZoom && this.camera && this.domElement) {
-        let clientX = 0;
-        let clientY = 0;
-        const nFingers = this._touchCurrent.length;
-        for (let i = 0; i < nFingers; i++) {
-          clientX += this._touchCurrent[i].clientX;
-          clientY += this._touchCurrent[i].clientY;
-        }
-        this.setCenter(clientX / nFingers, clientY / nFingers);
-        const screenNotches = 8;
-        this._currentCursorPosition.setY(this.getCursorNDC(_center.x, _center.y, this.domElement).y * 0.5);
-        const movement = this._currentCursorPosition.y - this._startCursorPosition.y;
-        let size = 1;
-        if (movement < 0) {
-          size = 1 / Math.pow(this.scaleFactor, -movement * screenNotches);
-        } else if (movement > 0) {
-          size = Math.pow(this.scaleFactor, movement * screenNotches);
-        }
-        this._v3_1.setFromMatrixPosition(this._cameraMatrixState);
-        const x = this._v3_1.distanceTo(this._gizmos.position);
-        let xNew = x / size;
-        xNew = MathUtils.clamp(xNew, this.minDistance, this.maxDistance);
-        const y = x * Math.tan(MathUtils.DEG2RAD * this._fovState * 0.5);
-        let newFov = MathUtils.RAD2DEG * (Math.atan(y / xNew) * 2);
-        newFov = MathUtils.clamp(newFov, this.minFov, this.maxFov);
-        const newDistance = y / Math.tan(MathUtils.DEG2RAD * (newFov / 2));
-        size = x / newDistance;
-        this._v3_2.setFromMatrixPosition(this._gizmoMatrixState);
-        this.setFov(newFov);
-        this.applyTransformMatrix(this.applyScale(size, this._v3_2, false));
-        const direction = this._gizmos.position.clone().sub(this.camera.position).normalize().multiplyScalar(newDistance / x);
-        this._m4_1.makeTranslation(direction.x, direction.y, direction.z);
-        this.dispatchEvent(_changeEvent);
-      }
-    };
-    this.onTriplePanEnd = () => {
-      this.updateTbState(STATE.IDLE, false);
-      this.dispatchEvent(_endEvent);
-    };
-    this.setCenter = (clientX, clientY) => {
-      _center.x = clientX;
-      _center.y = clientY;
-    };
-    this.initializeMouseActions = () => {
-      this.setMouseAction("PAN", 0, "CTRL");
-      this.setMouseAction("PAN", 2);
-      this.setMouseAction("ROTATE", 0);
-      this.setMouseAction("ZOOM", "WHEEL");
-      this.setMouseAction("ZOOM", 1);
-      this.setMouseAction("FOV", "WHEEL", "SHIFT");
-      this.setMouseAction("FOV", 1, "SHIFT");
-    };
-    this.setMouseAction = (operation, mouse, key = null) => {
-      const operationInput = ["PAN", "ROTATE", "ZOOM", "FOV"];
-      const mouseInput = [0, 1, 2, "WHEEL"];
-      const keyInput = ["CTRL", "SHIFT", null];
-      let state;
-      if (!operationInput.includes(operation) || !mouseInput.includes(mouse) || !keyInput.includes(key)) {
-        return false;
-      }
-      if (mouse == "WHEEL") {
-        if (operation != "ZOOM" && operation != "FOV") {
-          return false;
-        }
-      }
-      switch (operation) {
-        case "PAN":
-          state = STATE.PAN;
-          break;
-        case "ROTATE":
-          state = STATE.ROTATE;
-          break;
-        case "ZOOM":
-          state = STATE.SCALE;
-          break;
-        case "FOV":
-          state = STATE.FOV;
-          break;
-      }
-      const action = {
-        operation,
-        mouse,
-        key,
-        state
-      };
-      for (let i = 0; i < this.mouseActions.length; i++) {
-        if (this.mouseActions[i].mouse == action.mouse && this.mouseActions[i].key == action.key) {
-          this.mouseActions.splice(i, 1, action);
-          return true;
-        }
-      }
-      this.mouseActions.push(action);
-      return true;
-    };
-    this.getOpFromAction = (mouse, key) => {
-      let action;
-      for (let i = 0; i < this.mouseActions.length; i++) {
-        action = this.mouseActions[i];
-        if (action.mouse == mouse && action.key == key) {
-          return action.operation;
-        }
-      }
-      if (key) {
-        for (let i = 0; i < this.mouseActions.length; i++) {
-          action = this.mouseActions[i];
-          if (action.mouse == mouse && action.key == null) {
-            return action.operation;
-          }
-        }
-      }
-      return null;
-    };
-    this.getOpStateFromAction = (mouse, key) => {
-      let action;
-      for (let i = 0; i < this.mouseActions.length; i++) {
-        action = this.mouseActions[i];
-        if (action.mouse == mouse && action.key == key) {
-          return action.state;
-        }
-      }
-      if (key) {
-        for (let i = 0; i < this.mouseActions.length; i++) {
-          action = this.mouseActions[i];
-          if (action.mouse == mouse && action.key == null) {
-            return action.state;
-          }
-        }
-      }
-      return null;
-    };
-    this.getAngle = (p1, p2) => {
-      return Math.atan2(p2.clientY - p1.clientY, p2.clientX - p1.clientX) * 180 / Math.PI;
-    };
-    this.updateTouchEvent = (event) => {
-      for (let i = 0; i < this._touchCurrent.length; i++) {
-        if (this._touchCurrent[i].pointerId == event.pointerId) {
-          this._touchCurrent.splice(i, 1, event);
-          break;
-        }
-      }
-    };
-    this.calculateAngularSpeed = (p0, p1, t0, t1) => {
-      const s = p1 - p0;
-      const t = (t1 - t0) / 1e3;
-      if (t == 0) {
-        return 0;
-      }
-      return s / t;
-    };
-    this.calculatePointersDistance = (p0, p1) => {
-      return Math.sqrt(Math.pow(p1.clientX - p0.clientX, 2) + Math.pow(p1.clientY - p0.clientY, 2));
-    };
-    this.calculateRotationAxis = (vec1, vec2) => {
-      this._rotationMatrix.extractRotation(this._cameraMatrixState);
-      this._quat.setFromRotationMatrix(this._rotationMatrix);
-      this._rotationAxis.crossVectors(vec1, vec2).applyQuaternion(this._quat);
-      return this._rotationAxis.normalize().clone();
-    };
-    this.calculateTbRadius = (camera2) => {
-      const factor = 0.67;
-      const distance = camera2.position.distanceTo(this._gizmos.position);
-      if (camera2.type == "PerspectiveCamera") {
-        const halfFovV = MathUtils.DEG2RAD * camera2.fov * 0.5;
-        const halfFovH = Math.atan(camera2.aspect * Math.tan(halfFovV));
-        return Math.tan(Math.min(halfFovV, halfFovH)) * distance * factor;
-      } else if (camera2.type == "OrthographicCamera") {
-        return Math.min(camera2.top, camera2.right) * factor;
-      }
-    };
-    this.focus = (point, size, amount = 1) => {
-      if (this.camera) {
-        const focusPoint = point.clone();
-        focusPoint.sub(this._gizmos.position).multiplyScalar(amount);
-        this._translationMatrix.makeTranslation(focusPoint.x, focusPoint.y, focusPoint.z);
-        const gizmoStateTemp = this._gizmoMatrixState.clone();
-        this._gizmoMatrixState.premultiply(this._translationMatrix);
-        this._gizmoMatrixState.decompose(this._gizmos.position, this._gizmos.quaternion, this._gizmos.scale);
-        const cameraStateTemp = this._cameraMatrixState.clone();
-        this._cameraMatrixState.premultiply(this._translationMatrix);
-        this._cameraMatrixState.decompose(this.camera.position, this.camera.quaternion, this.camera.scale);
-        if (this.enableZoom) {
-          this.applyTransformMatrix(this.applyScale(size, this._gizmos.position));
-        }
-        this._gizmoMatrixState.copy(gizmoStateTemp);
-        this._cameraMatrixState.copy(cameraStateTemp);
-      }
-    };
-    this.drawGrid = () => {
-      var _a, _b;
-      if (this.scene) {
-        const color = 8947848;
-        const multiplier = 3;
-        let size, divisions, maxLength, tick;
-        if (((_a = this.camera) == null ? void 0 : _a.type) === "OrthographicCamera") {
-          const width = this.camera.right - this.camera.left;
-          const height = this.camera.bottom - this.camera.top;
-          maxLength = Math.max(width, height);
-          tick = maxLength / 20;
-          size = maxLength / this.camera.zoom * multiplier;
-          divisions = size / tick * this.camera.zoom;
-        } else if (((_b = this.camera) == null ? void 0 : _b.type) === "PerspectiveCamera") {
-          const distance = this.camera.position.distanceTo(this._gizmos.position);
-          const halfFovV = MathUtils.DEG2RAD * this.camera.fov * 0.5;
-          const halfFovH = Math.atan(this.camera.aspect * Math.tan(halfFovV));
-          maxLength = Math.tan(Math.max(halfFovV, halfFovH)) * distance * 2;
-          tick = maxLength / 20;
-          size = maxLength * multiplier;
-          divisions = size / tick;
-        }
-        if (this._grid == null && this.camera) {
-          this._grid = new GridHelper(size, divisions, color, color);
-          this._grid.position.copy(this._gizmos.position);
-          this._gridPosition.copy(this._grid.position);
-          this._grid.quaternion.copy(this.camera.quaternion);
-          this._grid.rotateX(Math.PI * 0.5);
-          this.scene.add(this._grid);
-        }
-      }
-    };
-    this.connect = (domElement2) => {
-      if (domElement2 === document) {
-        console.error(
-          'THREE.ArcballControls: "document" should not be used as the target "domElement". Please use "renderer.domElement" instead.'
-        );
-      }
-      this.domElement = domElement2;
-      this.domElement.style.touchAction = "none";
-      this.domElement.addEventListener("contextmenu", this.onContextMenu);
-      this.domElement.addEventListener("pointerdown", this.onPointerDown);
-      this.domElement.addEventListener("pointercancel", this.onPointerCancel);
-      this.domElement.addEventListener("wheel", this.onWheel);
-    };
-    this.dispose = () => {
-      var _a, _b, _c, _d, _e;
-      if (this._animationId != -1) {
-        window.cancelAnimationFrame(this._animationId);
-      }
-      (_a = this.domElement) == null ? void 0 : _a.removeEventListener("pointerdown", this.onPointerDown);
-      (_b = this.domElement) == null ? void 0 : _b.removeEventListener("pointercancel", this.onPointerCancel);
-      (_c = this.domElement) == null ? void 0 : _c.removeEventListener("wheel", this.onWheel);
-      (_d = this.domElement) == null ? void 0 : _d.removeEventListener("contextmenu", this.onContextMenu);
-      window.removeEventListener("pointermove", this.onPointerMove);
-      window.removeEventListener("pointerup", this.onPointerUp);
-      window.removeEventListener("resize", this.onWindowResize);
-      (_e = this.scene) == null ? void 0 : _e.remove(this._gizmos);
-      this.disposeGrid();
-    };
-    this.disposeGrid = () => {
-      if (this._grid && this.scene) {
-        this.scene.remove(this._grid);
-        this._grid = null;
-      }
-    };
-    this.easeOutCubic = (t) => {
-      return 1 - Math.pow(1 - t, 3);
-    };
-    this.activateGizmos = (isActive) => {
-      for (const gizmo of this._gizmos.children) {
-        ;
-        gizmo.material.setValues({ opacity: isActive ? 1 : 0.6 });
-      }
-    };
-    this.getCursorNDC = (cursorX, cursorY, canvas) => {
-      const canvasRect = canvas.getBoundingClientRect();
-      this._v2_1.setX((cursorX - canvasRect.left) / canvasRect.width * 2 - 1);
-      this._v2_1.setY((canvasRect.bottom - cursorY) / canvasRect.height * 2 - 1);
-      return this._v2_1.clone();
-    };
-    this.getCursorPosition = (cursorX, cursorY, canvas) => {
-      var _a;
-      this._v2_1.copy(this.getCursorNDC(cursorX, cursorY, canvas));
-      if (((_a = this.camera) == null ? void 0 : _a.type) === "OrthographicCamera") {
-        this._v2_1.x *= (this.camera.right - this.camera.left) * 0.5;
-        this._v2_1.y *= (this.camera.top - this.camera.bottom) * 0.5;
-      }
-      return this._v2_1.clone();
-    };
-    this.setCamera = (camera2) => {
-      if (camera2) {
-        camera2.lookAt(this.target);
-        camera2.updateMatrix();
-        if ((camera2 == null ? void 0 : camera2.type) == "PerspectiveCamera") {
-          this._fov0 = camera2.fov;
-          this._fovState = camera2.fov;
-        }
-        this._cameraMatrixState0.copy(camera2.matrix);
-        this._cameraMatrixState.copy(this._cameraMatrixState0);
-        this._cameraProjectionState.copy(camera2.projectionMatrix);
-        this._zoom0 = camera2.zoom;
-        this._zoomState = this._zoom0;
-        this._initialNear = camera2.near;
-        this._nearPos0 = camera2.position.distanceTo(this.target) - camera2.near;
-        this._nearPos = this._initialNear;
-        this._initialFar = camera2.far;
-        this._farPos0 = camera2.position.distanceTo(this.target) - camera2.far;
-        this._farPos = this._initialFar;
-        this._up0.copy(camera2.up);
-        this._upState.copy(camera2.up);
-        this.camera = camera2;
-        this.camera.updateProjectionMatrix();
-        const tbRadius = this.calculateTbRadius(camera2);
-        if (tbRadius !== void 0) {
-          this._tbRadius = tbRadius;
-        }
-        this.makeGizmos(this.target, this._tbRadius);
-      }
-    };
-    this.makeGizmos = (tbCenter, tbRadius) => {
-      const curve = new EllipseCurve(0, 0, tbRadius, tbRadius);
-      const points = curve.getPoints(this._curvePts);
-      const curveGeometry = new BufferGeometry().setFromPoints(points);
-      const curveMaterialX = new LineBasicMaterial({ color: 16744576, fog: false, transparent: true, opacity: 0.6 });
-      const curveMaterialY = new LineBasicMaterial({ color: 8454016, fog: false, transparent: true, opacity: 0.6 });
-      const curveMaterialZ = new LineBasicMaterial({ color: 8421631, fog: false, transparent: true, opacity: 0.6 });
-      const gizmoX = new Line(curveGeometry, curveMaterialX);
-      const gizmoY = new Line(curveGeometry, curveMaterialY);
-      const gizmoZ = new Line(curveGeometry, curveMaterialZ);
-      const rotation = Math.PI * 0.5;
-      gizmoX.rotation.x = rotation;
-      gizmoY.rotation.y = rotation;
-      this._gizmoMatrixState0.identity().setPosition(tbCenter);
-      this._gizmoMatrixState.copy(this._gizmoMatrixState0);
-      if (this.camera && this.camera.zoom != 1) {
-        const size = 1 / this.camera.zoom;
-        this._scaleMatrix.makeScale(size, size, size);
-        this._translationMatrix.makeTranslation(-tbCenter.x, -tbCenter.y, -tbCenter.z);
-        this._gizmoMatrixState.premultiply(this._translationMatrix).premultiply(this._scaleMatrix);
-        this._translationMatrix.makeTranslation(tbCenter.x, tbCenter.y, tbCenter.z);
-        this._gizmoMatrixState.premultiply(this._translationMatrix);
-      }
-      this._gizmoMatrixState.decompose(this._gizmos.position, this._gizmos.quaternion, this._gizmos.scale);
-      this._gizmos.clear();
-      this._gizmos.add(gizmoX);
-      this._gizmos.add(gizmoY);
-      this._gizmos.add(gizmoZ);
-    };
-    this.onFocusAnim = (time, point, cameraMatrix, gizmoMatrix) => {
-      if (this._timeStart == -1) {
-        this._timeStart = time;
-      }
-      if (this._state == STATE.ANIMATION_FOCUS) {
-        const deltaTime = time - this._timeStart;
-        const animTime = deltaTime / this.focusAnimationTime;
-        this._gizmoMatrixState.copy(gizmoMatrix);
-        if (animTime >= 1) {
-          this._gizmoMatrixState.decompose(this._gizmos.position, this._gizmos.quaternion, this._gizmos.scale);
-          this.focus(point, this.scaleFactor);
-          this._timeStart = -1;
-          this.updateTbState(STATE.IDLE, false);
-          this.activateGizmos(false);
-          this.dispatchEvent(_changeEvent);
-        } else {
-          const amount = this.easeOutCubic(animTime);
-          const size = 1 - amount + this.scaleFactor * amount;
-          this._gizmoMatrixState.decompose(this._gizmos.position, this._gizmos.quaternion, this._gizmos.scale);
-          this.focus(point, size, amount);
-          this.dispatchEvent(_changeEvent);
-          const self = this;
-          this._animationId = window.requestAnimationFrame(function(t) {
-            self.onFocusAnim(t, point, cameraMatrix, gizmoMatrix.clone());
-          });
-        }
-      } else {
-        this._animationId = -1;
-        this._timeStart = -1;
-      }
-    };
-    this.onRotationAnim = (time, rotationAxis, w0) => {
-      if (this._timeStart == -1) {
-        this._anglePrev = 0;
-        this._angleCurrent = 0;
-        this._timeStart = time;
-      }
-      if (this._state == STATE.ANIMATION_ROTATE) {
-        const deltaTime = (time - this._timeStart) / 1e3;
-        const w = w0 + -this.dampingFactor * deltaTime;
-        if (w > 0) {
-          this._angleCurrent = 0.5 * -this.dampingFactor * Math.pow(deltaTime, 2) + w0 * deltaTime + 0;
-          this.applyTransformMatrix(this.rotate(rotationAxis, this._angleCurrent));
-          this.dispatchEvent(_changeEvent);
-          const self = this;
-          this._animationId = window.requestAnimationFrame(function(t) {
-            self.onRotationAnim(t, rotationAxis, w0);
-          });
-        } else {
-          this._animationId = -1;
-          this._timeStart = -1;
-          this.updateTbState(STATE.IDLE, false);
-          this.activateGizmos(false);
-          this.dispatchEvent(_changeEvent);
-        }
-      } else {
-        this._animationId = -1;
-        this._timeStart = -1;
-        if (this._state != STATE.ROTATE) {
-          this.activateGizmos(false);
-          this.dispatchEvent(_changeEvent);
-        }
-      }
-    };
-    this.pan = (p0, p1, adjust = false) => {
-      if (this.camera) {
-        const movement = p0.clone().sub(p1);
-        if (this.camera.type === "OrthographicCamera") {
-          movement.multiplyScalar(1 / this.camera.zoom);
-        }
-        if (this.camera.type === "PerspectiveCamera" && adjust) {
-          this._v3_1.setFromMatrixPosition(this._cameraMatrixState0);
-          this._v3_2.setFromMatrixPosition(this._gizmoMatrixState0);
-          const distanceFactor = this._v3_1.distanceTo(this._v3_2) / this.camera.position.distanceTo(this._gizmos.position);
-          movement.multiplyScalar(1 / distanceFactor);
-        }
-        this._v3_1.set(movement.x, movement.y, 0).applyQuaternion(this.camera.quaternion);
-        this._m4_1.makeTranslation(this._v3_1.x, this._v3_1.y, this._v3_1.z);
-        this.setTransformationMatrices(this._m4_1, this._m4_1);
-      }
-      return _transformation;
-    };
-    this.reset = () => {
-      if (this.camera) {
-        this.camera.zoom = this._zoom0;
-        if (this.camera.type === "PerspectiveCamera") {
-          this.camera.fov = this._fov0;
-        }
-        this.camera.near = this._nearPos;
-        this.camera.far = this._farPos;
-        this._cameraMatrixState.copy(this._cameraMatrixState0);
-        this._cameraMatrixState.decompose(this.camera.position, this.camera.quaternion, this.camera.scale);
-        this.camera.up.copy(this._up0);
-        this.camera.updateMatrix();
-        this.camera.updateProjectionMatrix();
-        this._gizmoMatrixState.copy(this._gizmoMatrixState0);
-        this._gizmoMatrixState0.decompose(this._gizmos.position, this._gizmos.quaternion, this._gizmos.scale);
-        this._gizmos.updateMatrix();
-        const tbRadius = this.calculateTbRadius(this.camera);
-        if (tbRadius !== void 0) {
-          this._tbRadius = tbRadius;
-        }
-        this.makeGizmos(this._gizmos.position, this._tbRadius);
-        this.camera.lookAt(this._gizmos.position);
-        this.updateTbState(STATE.IDLE, false);
-        this.dispatchEvent(_changeEvent);
-      }
-    };
-    this.rotate = (axis, angle) => {
-      const point = this._gizmos.position;
-      this._translationMatrix.makeTranslation(-point.x, -point.y, -point.z);
-      this._rotationMatrix.makeRotationAxis(axis, -angle);
-      this._m4_1.makeTranslation(point.x, point.y, point.z);
-      this._m4_1.multiply(this._rotationMatrix);
-      this._m4_1.multiply(this._translationMatrix);
-      this.setTransformationMatrices(this._m4_1);
-      return _transformation;
-    };
-    this.copyState = () => {
-      var _a;
-      if (this.camera) {
-        const state = JSON.stringify(
-          ((_a = this.camera) == null ? void 0 : _a.type) === "OrthographicCamera" ? {
-            arcballState: {
-              cameraFar: this.camera.far,
-              cameraMatrix: this.camera.matrix,
-              cameraNear: this.camera.near,
-              cameraUp: this.camera.up,
-              cameraZoom: this.camera.zoom,
-              gizmoMatrix: this._gizmos.matrix
-            }
-          } : {
-            arcballState: {
-              cameraFar: this.camera.far,
-              cameraFov: this.camera.fov,
-              cameraMatrix: this.camera.matrix,
-              cameraNear: this.camera.near,
-              cameraUp: this.camera.up,
-              cameraZoom: this.camera.zoom,
-              gizmoMatrix: this._gizmos.matrix
-            }
-          }
-        );
-        navigator.clipboard.writeText(state);
-      }
-    };
-    this.pasteState = () => {
-      const self = this;
-      navigator.clipboard.readText().then(function resolved(value) {
-        self.setStateFromJSON(value);
-      });
-    };
-    this.saveState = () => {
-      if (!this.camera)
-        return;
-      this._cameraMatrixState0.copy(this.camera.matrix);
-      this._gizmoMatrixState0.copy(this._gizmos.matrix);
-      this._nearPos = this.camera.near;
-      this._farPos = this.camera.far;
-      this._zoom0 = this.camera.zoom;
-      this._up0.copy(this.camera.up);
-      if (this.camera.type === "PerspectiveCamera") {
-        this._fov0 = this.camera.fov;
-      }
-    };
-    this.applyScale = (size, point, scaleGizmos = true) => {
-      if (!this.camera)
-        return;
-      const scalePoint = point.clone();
-      let sizeInverse = 1 / size;
-      if (this.camera.type === "OrthographicCamera") {
-        this.camera.zoom = this._zoomState;
-        this.camera.zoom *= size;
-        if (this.camera.zoom > this.maxZoom) {
-          this.camera.zoom = this.maxZoom;
-          sizeInverse = this._zoomState / this.maxZoom;
-        } else if (this.camera.zoom < this.minZoom) {
-          this.camera.zoom = this.minZoom;
-          sizeInverse = this._zoomState / this.minZoom;
-        }
-        this.camera.updateProjectionMatrix();
-        this._v3_1.setFromMatrixPosition(this._gizmoMatrixState);
-        this._scaleMatrix.makeScale(sizeInverse, sizeInverse, sizeInverse);
-        this._translationMatrix.makeTranslation(-this._v3_1.x, -this._v3_1.y, -this._v3_1.z);
-        this._m4_2.makeTranslation(this._v3_1.x, this._v3_1.y, this._v3_1.z).multiply(this._scaleMatrix);
-        this._m4_2.multiply(this._translationMatrix);
-        scalePoint.sub(this._v3_1);
-        const amount = scalePoint.clone().multiplyScalar(sizeInverse);
-        scalePoint.sub(amount);
-        this._m4_1.makeTranslation(scalePoint.x, scalePoint.y, scalePoint.z);
-        this._m4_2.premultiply(this._m4_1);
-        this.setTransformationMatrices(this._m4_1, this._m4_2);
-        return _transformation;
-      }
-      if (this.camera.type === "PerspectiveCamera") {
-        this._v3_1.setFromMatrixPosition(this._cameraMatrixState);
-        this._v3_2.setFromMatrixPosition(this._gizmoMatrixState);
-        let distance = this._v3_1.distanceTo(scalePoint);
-        let amount = distance - distance * sizeInverse;
-        const newDistance = distance - amount;
-        if (newDistance < this.minDistance) {
-          sizeInverse = this.minDistance / distance;
-          amount = distance - distance * sizeInverse;
-        } else if (newDistance > this.maxDistance) {
-          sizeInverse = this.maxDistance / distance;
-          amount = distance - distance * sizeInverse;
-        }
-        let direction = scalePoint.clone().sub(this._v3_1).normalize().multiplyScalar(amount);
-        this._m4_1.makeTranslation(direction.x, direction.y, direction.z);
-        if (scaleGizmos) {
-          const pos = this._v3_2;
-          distance = pos.distanceTo(scalePoint);
-          amount = distance - distance * sizeInverse;
-          direction = scalePoint.clone().sub(this._v3_2).normalize().multiplyScalar(amount);
-          this._translationMatrix.makeTranslation(pos.x, pos.y, pos.z);
-          this._scaleMatrix.makeScale(sizeInverse, sizeInverse, sizeInverse);
-          this._m4_2.makeTranslation(direction.x, direction.y, direction.z).multiply(this._translationMatrix);
-          this._m4_2.multiply(this._scaleMatrix);
-          this._translationMatrix.makeTranslation(-pos.x, -pos.y, -pos.z);
-          this._m4_2.multiply(this._translationMatrix);
-          this.setTransformationMatrices(this._m4_1, this._m4_2);
-        } else {
-          this.setTransformationMatrices(this._m4_1);
-        }
-        return _transformation;
-      }
-    };
-    this.setFov = (value) => {
-      var _a;
-      if (((_a = this.camera) == null ? void 0 : _a.type) === "PerspectiveCamera") {
-        this.camera.fov = MathUtils.clamp(value, this.minFov, this.maxFov);
-        this.camera.updateProjectionMatrix();
-      }
-    };
-    this.setTarget = (x, y, z) => {
-      if (this.camera) {
-        this.target.set(x, y, z);
-        this._gizmos.position.set(x, y, z);
-        const tbRadius = this.calculateTbRadius(this.camera);
-        if (tbRadius !== void 0) {
-          this._tbRadius = tbRadius;
-        }
-        this.makeGizmos(this.target, this._tbRadius);
-        this.camera.lookAt(this.target);
-      }
-    };
-    this.zRotate = (point, angle) => {
-      this._rotationMatrix.makeRotationAxis(this._rotationAxis, angle);
-      this._translationMatrix.makeTranslation(-point.x, -point.y, -point.z);
-      this._m4_1.makeTranslation(point.x, point.y, point.z);
-      this._m4_1.multiply(this._rotationMatrix);
-      this._m4_1.multiply(this._translationMatrix);
-      this._v3_1.setFromMatrixPosition(this._gizmoMatrixState).sub(point);
-      this._v3_2.copy(this._v3_1).applyAxisAngle(this._rotationAxis, angle);
-      this._v3_2.sub(this._v3_1);
-      this._m4_2.makeTranslation(this._v3_2.x, this._v3_2.y, this._v3_2.z);
-      this.setTransformationMatrices(this._m4_1, this._m4_2);
-      return _transformation;
-    };
-    this.unprojectOnObj = (cursor, camera2) => {
-      if (!this.scene)
-        return null;
-      const raycaster = new Raycaster();
-      raycaster.near = camera2.near;
-      raycaster.far = camera2.far;
-      raycaster.setFromCamera(cursor, camera2);
-      const intersect = raycaster.intersectObjects(this.scene.children, true);
-      for (let i = 0; i < intersect.length; i++) {
-        if (intersect[i].object.uuid != this._gizmos.uuid && intersect[i].face) {
-          return intersect[i].point.clone();
-        }
-      }
-      return null;
-    };
-    this.unprojectOnTbSurface = (camera2, cursorX, cursorY, canvas, tbRadius) => {
-      if (camera2.type == "OrthographicCamera") {
-        this._v2_1.copy(this.getCursorPosition(cursorX, cursorY, canvas));
-        this._v3_1.set(this._v2_1.x, this._v2_1.y, 0);
-        const x2 = Math.pow(this._v2_1.x, 2);
-        const y2 = Math.pow(this._v2_1.y, 2);
-        const r2 = Math.pow(this._tbRadius, 2);
-        if (x2 + y2 <= r2 * 0.5) {
-          this._v3_1.setZ(Math.sqrt(r2 - (x2 + y2)));
-        } else {
-          this._v3_1.setZ(r2 * 0.5 / Math.sqrt(x2 + y2));
-        }
-        return this._v3_1;
-      }
-      if (camera2.type == "PerspectiveCamera") {
-        this._v2_1.copy(this.getCursorNDC(cursorX, cursorY, canvas));
-        this._v3_1.set(this._v2_1.x, this._v2_1.y, -1);
-        this._v3_1.applyMatrix4(camera2.projectionMatrixInverse);
-        const rayDir = this._v3_1.clone().normalize();
-        const cameraGizmoDistance = camera2.position.distanceTo(this._gizmos.position);
-        const radius2 = Math.pow(tbRadius, 2);
-        const h = this._v3_1.z;
-        const l = Math.sqrt(Math.pow(this._v3_1.x, 2) + Math.pow(this._v3_1.y, 2));
-        if (l == 0) {
-          rayDir.set(this._v3_1.x, this._v3_1.y, tbRadius);
-          return rayDir;
-        }
-        const m = h / l;
-        const q = cameraGizmoDistance;
-        let a = Math.pow(m, 2) + 1;
-        let b = 2 * m * q;
-        let c = Math.pow(q, 2) - radius2;
-        let delta = Math.pow(b, 2) - 4 * a * c;
-        if (delta >= 0) {
-          this._v2_1.setX((-b - Math.sqrt(delta)) / (2 * a));
-          this._v2_1.setY(m * this._v2_1.x + q);
-          const angle = MathUtils.RAD2DEG * this._v2_1.angle();
-          if (angle >= 45) {
-            const rayLength2 = Math.sqrt(Math.pow(this._v2_1.x, 2) + Math.pow(cameraGizmoDistance - this._v2_1.y, 2));
-            rayDir.multiplyScalar(rayLength2);
-            rayDir.z += cameraGizmoDistance;
-            return rayDir;
-          }
-        }
-        a = m;
-        b = q;
-        c = -radius2 * 0.5;
-        delta = Math.pow(b, 2) - 4 * a * c;
-        this._v2_1.setX((-b - Math.sqrt(delta)) / (2 * a));
-        this._v2_1.setY(m * this._v2_1.x + q);
-        const rayLength = Math.sqrt(Math.pow(this._v2_1.x, 2) + Math.pow(cameraGizmoDistance - this._v2_1.y, 2));
-        rayDir.multiplyScalar(rayLength);
-        rayDir.z += cameraGizmoDistance;
-        return rayDir;
-      }
-    };
-    this.unprojectOnTbPlane = (camera2, cursorX, cursorY, canvas, initialDistance = false) => {
-      if (camera2.type == "OrthographicCamera") {
-        this._v2_1.copy(this.getCursorPosition(cursorX, cursorY, canvas));
-        this._v3_1.set(this._v2_1.x, this._v2_1.y, 0);
-        return this._v3_1.clone();
-      }
-      if (camera2.type == "PerspectiveCamera") {
-        this._v2_1.copy(this.getCursorNDC(cursorX, cursorY, canvas));
-        this._v3_1.set(this._v2_1.x, this._v2_1.y, -1);
-        this._v3_1.applyMatrix4(camera2.projectionMatrixInverse);
-        const rayDir = this._v3_1.clone().normalize();
-        const h = this._v3_1.z;
-        const l = Math.sqrt(Math.pow(this._v3_1.x, 2) + Math.pow(this._v3_1.y, 2));
-        let cameraGizmoDistance;
-        if (initialDistance) {
-          cameraGizmoDistance = this._v3_1.setFromMatrixPosition(this._cameraMatrixState0).distanceTo(this._v3_2.setFromMatrixPosition(this._gizmoMatrixState0));
-        } else {
-          cameraGizmoDistance = camera2.position.distanceTo(this._gizmos.position);
-        }
-        if (l == 0) {
-          rayDir.set(0, 0, 0);
-          return rayDir;
-        }
-        const m = h / l;
-        const q = cameraGizmoDistance;
-        const x = -q / m;
-        const rayLength = Math.sqrt(Math.pow(q, 2) + Math.pow(x, 2));
-        rayDir.multiplyScalar(rayLength);
-        rayDir.z = 0;
-        return rayDir;
-      }
-    };
-    this.updateMatrixState = () => {
-      if (!this.camera)
-        return;
-      this._cameraMatrixState.copy(this.camera.matrix);
-      this._gizmoMatrixState.copy(this._gizmos.matrix);
-      if (this.camera.type === "OrthographicCamera") {
-        this._cameraProjectionState.copy(this.camera.projectionMatrix);
-        this.camera.updateProjectionMatrix();
-        this._zoomState = this.camera.zoom;
-      }
-      if (this.camera.type === "PerspectiveCamera") {
-        this._fovState = this.camera.fov;
-      }
-    };
-    this.updateTbState = (newState, updateMatrices) => {
-      this._state = newState;
-      if (updateMatrices) {
-        this.updateMatrixState();
-      }
-    };
-    this.update = () => {
-      const EPS = 1e-6;
-      if (!this.target.equals(this._currentTarget) && this.camera) {
-        this._gizmos.position.set(this.target.x, this.target.y, this.target.z);
-        const tbRadius = this.calculateTbRadius(this.camera);
-        if (tbRadius !== void 0) {
-          this._tbRadius = tbRadius;
-        }
-        this.makeGizmos(this.target, this._tbRadius);
-        this._currentTarget.copy(this.target);
-      }
-      if (!this.camera)
-        return;
-      if (this.camera.type === "OrthographicCamera") {
-        if (this.camera.zoom > this.maxZoom || this.camera.zoom < this.minZoom) {
-          const newZoom = MathUtils.clamp(this.camera.zoom, this.minZoom, this.maxZoom);
-          this.applyTransformMatrix(this.applyScale(newZoom / this.camera.zoom, this._gizmos.position, true));
-        }
-      }
-      if (this.camera.type === "PerspectiveCamera") {
-        const distance = this.camera.position.distanceTo(this._gizmos.position);
-        if (distance > this.maxDistance + EPS || distance < this.minDistance - EPS) {
-          const newDistance = MathUtils.clamp(distance, this.minDistance, this.maxDistance);
-          this.applyTransformMatrix(this.applyScale(newDistance / distance, this._gizmos.position));
-          this.updateMatrixState();
-        }
-        if (this.camera.fov < this.minFov || this.camera.fov > this.maxFov) {
-          this.camera.fov = MathUtils.clamp(this.camera.fov, this.minFov, this.maxFov);
-          this.camera.updateProjectionMatrix();
-        }
-        const oldRadius = this._tbRadius;
-        const tbRadius = this.calculateTbRadius(this.camera);
-        if (tbRadius !== void 0) {
-          this._tbRadius = tbRadius;
-        }
-        if (oldRadius < this._tbRadius - EPS || oldRadius > this._tbRadius + EPS) {
-          const scale = (this._gizmos.scale.x + this._gizmos.scale.y + this._gizmos.scale.z) / 3;
-          const newRadius = this._tbRadius / scale;
-          const curve = new EllipseCurve(0, 0, newRadius, newRadius);
-          const points = curve.getPoints(this._curvePts);
-          const curveGeometry = new BufferGeometry().setFromPoints(points);
-          for (const gizmo in this._gizmos.children) {
-            const child = this._gizmos.children[gizmo];
-            child.geometry = curveGeometry;
-          }
-        }
-      }
-      this.camera.lookAt(this._gizmos.position);
-    };
-    this.setStateFromJSON = (json) => {
-      const state = JSON.parse(json);
-      if (state.arcballState && this.camera) {
-        this._cameraMatrixState.fromArray(state.arcballState.cameraMatrix.elements);
-        this._cameraMatrixState.decompose(this.camera.position, this.camera.quaternion, this.camera.scale);
-        this.camera.up.copy(state.arcballState.cameraUp);
-        this.camera.near = state.arcballState.cameraNear;
-        this.camera.far = state.arcballState.cameraFar;
-        this.camera.zoom = state.arcballState.cameraZoom;
-        if (this.camera.type === "PerspectiveCamera") {
-          this.camera.fov = state.arcballState.cameraFov;
-        }
-        this._gizmoMatrixState.fromArray(state.arcballState.gizmoMatrix.elements);
-        this._gizmoMatrixState.decompose(this._gizmos.position, this._gizmos.quaternion, this._gizmos.scale);
-        this.camera.updateMatrix();
-        this.camera.updateProjectionMatrix();
-        this._gizmos.updateMatrix();
-        const tbRadius = this.calculateTbRadius(this.camera);
-        if (tbRadius !== void 0) {
-          this._tbRadius = tbRadius;
-        }
-        const gizmoTmp = new Matrix4().copy(this._gizmoMatrixState0);
-        this.makeGizmos(this._gizmos.position, this._tbRadius);
-        this._gizmoMatrixState0.copy(gizmoTmp);
-        this.camera.lookAt(this._gizmos.position);
-        this.updateTbState(STATE.IDLE, false);
-        this.dispatchEvent(_changeEvent);
-      }
-    };
-    this.camera = null;
-    this.domElement = domElement;
-    this.scene = scene;
-    this.mouseActions = [];
-    this._mouseOp = null;
-    this._v2_1 = new Vector2();
-    this._v3_1 = new Vector3();
-    this._v3_2 = new Vector3();
-    this._m4_1 = new Matrix4();
-    this._m4_2 = new Matrix4();
-    this._quat = new Quaternion();
-    this._translationMatrix = new Matrix4();
-    this._rotationMatrix = new Matrix4();
-    this._scaleMatrix = new Matrix4();
-    this._rotationAxis = new Vector3();
-    this._cameraMatrixState = new Matrix4();
-    this._cameraProjectionState = new Matrix4();
-    this._fovState = 1;
-    this._upState = new Vector3();
-    this._zoomState = 1;
-    this._nearPos = 0;
-    this._farPos = 0;
-    this._gizmoMatrixState = new Matrix4();
-    this._up0 = new Vector3();
-    this._zoom0 = 1;
-    this._fov0 = 0;
-    this._initialNear = 0;
-    this._nearPos0 = 0;
-    this._initialFar = 0;
-    this._farPos0 = 0;
-    this._cameraMatrixState0 = new Matrix4();
-    this._gizmoMatrixState0 = new Matrix4();
-    this._button = -1;
-    this._touchStart = [];
-    this._touchCurrent = [];
-    this._input = INPUT.NONE;
-    this._switchSensibility = 32;
-    this._startFingerDistance = 0;
-    this._currentFingerDistance = 0;
-    this._startFingerRotation = 0;
-    this._currentFingerRotation = 0;
-    this._devPxRatio = 0;
-    this._downValid = true;
-    this._nclicks = 0;
-    this._downEvents = [];
-    this._clickStart = 0;
-    this._maxDownTime = 250;
-    this._maxInterval = 300;
-    this._posThreshold = 24;
-    this._movementThreshold = 24;
-    this._currentCursorPosition = new Vector3();
-    this._startCursorPosition = new Vector3();
-    this._grid = null;
-    this._gridPosition = new Vector3();
-    this._gizmos = new Group();
-    this._curvePts = 128;
-    this._timeStart = -1;
-    this._animationId = -1;
-    this.focusAnimationTime = 500;
-    this._timePrev = 0;
-    this._timeCurrent = 0;
-    this._anglePrev = 0;
-    this._angleCurrent = 0;
-    this._cursorPosPrev = new Vector3();
-    this._cursorPosCurr = new Vector3();
-    this._wPrev = 0;
-    this._wCurr = 0;
-    this.adjustNearFar = false;
-    this.scaleFactor = 1.1;
-    this.dampingFactor = 25;
-    this.wMax = 20;
-    this.enableAnimations = true;
-    this.enableGrid = false;
-    this.cursorZoom = false;
-    this.minFov = 5;
-    this.maxFov = 90;
-    this.enabled = true;
-    this.enablePan = true;
-    this.enableRotate = true;
-    this.enableZoom = true;
-    this.minDistance = 0;
-    this.maxDistance = Infinity;
-    this.minZoom = 0;
-    this.maxZoom = Infinity;
-    this.target = new Vector3(0, 0, 0);
-    this._currentTarget = new Vector3(0, 0, 0);
-    this._tbRadius = 1;
-    this._state = STATE.IDLE;
-    this.setCamera(camera);
-    if (this.scene) {
-      this.scene.add(this._gizmos);
-    }
-    this._devPxRatio = window.devicePixelRatio;
-    this.initializeMouseActions();
-    if (this.domElement)
-      this.connect(this.domElement);
-    window.addEventListener("resize", this.onWindowResize);
-  }
-  applyTransformMatrix(transformation) {
-    if ((transformation == null ? void 0 : transformation.camera) && this.camera) {
-      this._m4_1.copy(this._cameraMatrixState).premultiply(transformation.camera);
-      this._m4_1.decompose(this.camera.position, this.camera.quaternion, this.camera.scale);
-      this.camera.updateMatrix();
-      if (this._state == STATE.ROTATE || this._state == STATE.ZROTATE || this._state == STATE.ANIMATION_ROTATE) {
-        this.camera.up.copy(this._upState).applyQuaternion(this.camera.quaternion);
-      }
-    }
-    if (transformation == null ? void 0 : transformation.gizmos) {
-      this._m4_1.copy(this._gizmoMatrixState).premultiply(transformation.gizmos);
-      this._m4_1.decompose(this._gizmos.position, this._gizmos.quaternion, this._gizmos.scale);
-      this._gizmos.updateMatrix();
-    }
-    if ((this._state == STATE.SCALE || this._state == STATE.FOCUS || this._state == STATE.ANIMATION_FOCUS) && this.camera) {
-      const tbRadius = this.calculateTbRadius(this.camera);
-      if (tbRadius !== void 0) {
-        this._tbRadius = tbRadius;
-      }
-      if (this.adjustNearFar) {
-        const cameraDistance = this.camera.position.distanceTo(this._gizmos.position);
-        const bb = new Box3();
-        bb.setFromObject(this._gizmos);
-        const sphere = new Sphere();
-        bb.getBoundingSphere(sphere);
-        const adjustedNearPosition = Math.max(this._nearPos0, sphere.radius + sphere.center.length());
-        const regularNearPosition = cameraDistance - this._initialNear;
-        const minNearPos = Math.min(adjustedNearPosition, regularNearPosition);
-        this.camera.near = cameraDistance - minNearPos;
-        const adjustedFarPosition = Math.min(this._farPos0, -sphere.radius + sphere.center.length());
-        const regularFarPosition = cameraDistance - this._initialFar;
-        const minFarPos = Math.min(adjustedFarPosition, regularFarPosition);
-        this.camera.far = cameraDistance - minFarPos;
-        this.camera.updateProjectionMatrix();
-      } else {
-        let update = false;
-        if (this.camera.near != this._initialNear) {
-          this.camera.near = this._initialNear;
-          update = true;
-        }
-        if (this.camera.far != this._initialFar) {
-          this.camera.far = this._initialFar;
-          update = true;
-        }
-        if (update) {
-          this.camera.updateProjectionMatrix();
-        }
-      }
-    }
-  }
-  setGizmosVisible(value) {
-    this._gizmos.visible = value;
-    this.dispatchEvent(_changeEvent);
-  }
-  setTransformationMatrices(camera = null, gizmos = null) {
-    if (camera) {
-      if (_transformation.camera) {
-        _transformation.camera.copy(camera);
-      } else {
-        _transformation.camera = camera.clone();
-      }
-    } else {
-      _transformation.camera = null;
-    }
-    if (gizmos) {
-      if (_transformation.gizmos) {
-        _transformation.gizmos.copy(gizmos);
-      } else {
-        _transformation.gizmos = gizmos.clone();
-      }
-    } else {
-      _transformation.gizmos = null;
-    }
-  }
-}
-export {
-  ArcballControls
-};