three-stdlib 2.16.0 → 2.16.2

package/controls/TrackballControls.js

@@ -1,87 +1,166 @@
-"use strict";
-Object.defineProperties(exports, { __esModule: { value: true }, [Symbol.toStringTag]: { value: "Module" } });
-const THREE = require("three");
-class TrackballControls extends THREE.EventDispatcher {
-  constructor(object, domElement) {
+import _defineProperty from '@babel/runtime/helpers/esm/defineProperty';
+import { EventDispatcher, MOUSE, Vector3, Vector2, Quaternion } from 'three';
+
+class TrackballControls extends EventDispatcher {
+  // internals
+  // events
+  constructor(object, _domElement) {
     super();
-    this.enabled = true;
-    this.screen = { left: 0, top: 0, width: 0, height: 0 };
-    this.rotateSpeed = 1;
-    this.zoomSpeed = 1.2;
-    this.panSpeed = 0.3;
-    this.noRotate = false;
-    this.noZoom = false;
-    this.noPan = false;
-    this.staticMoving = false;
-    this.dynamicDampingFactor = 0.2;
-    this.minDistance = 0;
-    this.maxDistance = Infinity;
-    this.keys = ["KeyA", "KeyS", "KeyD"];
-    this.mouseButtons = {
-      LEFT: THREE.MOUSE.ROTATE,
-      MIDDLE: THREE.MOUSE.DOLLY,
-      RIGHT: THREE.MOUSE.PAN
-    };
-    this.cursorZoom = false;
-    this.target = new THREE.Vector3();
-    this.mousePosition = new THREE.Vector2();
-    this.STATE = {
+
+    _defineProperty(this, "enabled", true);
+
+    _defineProperty(this, "screen", {
+      left: 0,
+      top: 0,
+      width: 0,
+      height: 0
+    });
+
+    _defineProperty(this, "rotateSpeed", 1.0);
+
+    _defineProperty(this, "zoomSpeed", 1.2);
+
+    _defineProperty(this, "panSpeed", 0.3);
+
+    _defineProperty(this, "noRotate", false);
+
+    _defineProperty(this, "noZoom", false);
+
+    _defineProperty(this, "noPan", false);
+
+    _defineProperty(this, "staticMoving", false);
+
+    _defineProperty(this, "dynamicDampingFactor", 0.2);
+
+    _defineProperty(this, "minDistance", 0);
+
+    _defineProperty(this, "maxDistance", Infinity);
+
+    _defineProperty(this, "keys", ['KeyA'
+    /*A*/
+    , 'KeyS'
+    /*S*/
+    , 'KeyD'
+    /*D*/
+    ]);
+
+    _defineProperty(this, "mouseButtons", {
+      LEFT: MOUSE.ROTATE,
+      MIDDLE: MOUSE.DOLLY,
+      RIGHT: MOUSE.PAN
+    });
+
+    _defineProperty(this, "object", void 0);
+
+    _defineProperty(this, "domElement", void 0);
+
+    _defineProperty(this, "cursorZoom", false);
+
+    _defineProperty(this, "target", new Vector3());
+
+    _defineProperty(this, "mousePosition", new Vector2());
+
+    _defineProperty(this, "STATE", {
       NONE: -1,
       ROTATE: 0,
       ZOOM: 1,
       PAN: 2,
       TOUCH_ROTATE: 3,
       TOUCH_ZOOM_PAN: 4
-    };
-    this.EPS = 1e-6;
-    this.lastZoom = 1;
-    this.lastPosition = new THREE.Vector3();
-    this.cursorVector = new THREE.Vector3();
-    this.targetVector = new THREE.Vector3();
-    this._state = this.STATE.NONE;
-    this._keyState = this.STATE.NONE;
-    this._eye = new THREE.Vector3();
-    this._movePrev = new THREE.Vector2();
-    this._moveCurr = new THREE.Vector2();
-    this._lastAxis = new THREE.Vector3();
-    this._lastAngle = 0;
-    this._zoomStart = new THREE.Vector2();
-    this._zoomEnd = new THREE.Vector2();
-    this._touchZoomDistanceStart = 0;
-    this._touchZoomDistanceEnd = 0;
-    this._panStart = new THREE.Vector2();
-    this._panEnd = new THREE.Vector2();
-    this.changeEvent = { type: "change" };
-    this.startEvent = { type: "start" };
-    this.endEvent = { type: "end" };
-    this.onScreenVector = new THREE.Vector2();
-    this.getMouseOnScreen = (pageX, pageY) => {
-      this.onScreenVector.set(
-        (pageX - this.screen.left) / this.screen.width,
-        (pageY - this.screen.top) / this.screen.height
-      );
+    });
+
+    _defineProperty(this, "EPS", 0.000001);
+
+    _defineProperty(this, "lastZoom", 1);
+
+    _defineProperty(this, "lastPosition", new Vector3());
+
+    _defineProperty(this, "cursorVector", new Vector3());
+
+    _defineProperty(this, "targetVector", new Vector3());
+
+    _defineProperty(this, "_state", this.STATE.NONE);
+
+    _defineProperty(this, "_keyState", this.STATE.NONE);
+
+    _defineProperty(this, "_eye", new Vector3());
+
+    _defineProperty(this, "_movePrev", new Vector2());
+
+    _defineProperty(this, "_moveCurr", new Vector2());
+
+    _defineProperty(this, "_lastAxis", new Vector3());
+
+    _defineProperty(this, "_lastAngle", 0);
+
+    _defineProperty(this, "_zoomStart", new Vector2());
+
+    _defineProperty(this, "_zoomEnd", new Vector2());
+
+    _defineProperty(this, "_touchZoomDistanceStart", 0);
+
+    _defineProperty(this, "_touchZoomDistanceEnd", 0);
+
+    _defineProperty(this, "_panStart", new Vector2());
+
+    _defineProperty(this, "_panEnd", new Vector2());
+
+    _defineProperty(this, "target0", void 0);
+
+    _defineProperty(this, "position0", void 0);
+
+    _defineProperty(this, "up0", void 0);
+
+    _defineProperty(this, "zoom0", void 0);
+
+    _defineProperty(this, "changeEvent", {
+      type: 'change'
+    });
+
+    _defineProperty(this, "startEvent", {
+      type: 'start'
+    });
+
+    _defineProperty(this, "endEvent", {
+      type: 'end'
+    });
+
+    _defineProperty(this, "onScreenVector", new Vector2());
+
+    _defineProperty(this, "getMouseOnScreen", (pageX, pageY) => {
+      this.onScreenVector.set((pageX - this.screen.left) / this.screen.width, (pageY - this.screen.top) / this.screen.height);
       return this.onScreenVector;
-    };
-    this.onCircleVector = new THREE.Vector2();
-    this.getMouseOnCircle = (pageX, pageY) => {
-      this.onCircleVector.set(
-        (pageX - this.screen.width * 0.5 - this.screen.left) / (this.screen.width * 0.5),
-        (this.screen.height + 2 * (this.screen.top - pageY)) / this.screen.width
+    });
+
+    _defineProperty(this, "onCircleVector", new Vector2());
+
+    _defineProperty(this, "getMouseOnCircle", (pageX, pageY) => {
+      this.onCircleVector.set((pageX - this.screen.width * 0.5 - this.screen.left) / (this.screen.width * 0.5), (this.screen.height + 2 * (this.screen.top - pageY)) / this.screen.width // screen.width intentional
       );
       return this.onCircleVector;
-    };
-    this.axis = new THREE.Vector3();
-    this.quaternion = new THREE.Quaternion();
-    this.eyeDirection = new THREE.Vector3();
-    this.objectUpDirection = new THREE.Vector3();
-    this.objectSidewaysDirection = new THREE.Vector3();
-    this.moveDirection = new THREE.Vector3();
-    this.angle = 0;
-    this.rotateCamera = () => {
+    });
+
+    _defineProperty(this, "axis", new Vector3());
+
+    _defineProperty(this, "quaternion", new Quaternion());
+
+    _defineProperty(this, "eyeDirection", new Vector3());
+
+    _defineProperty(this, "objectUpDirection", new Vector3());
+
+    _defineProperty(this, "objectSidewaysDirection", new Vector3());
+
+    _defineProperty(this, "moveDirection", new Vector3());
+
+    _defineProperty(this, "angle", 0);
+
+    _defineProperty(this, "rotateCamera", () => {
       this.moveDirection.set(this._moveCurr.x - this._movePrev.x, this._moveCurr.y - this._movePrev.y, 0);
       this.angle = this.moveDirection.length();
+
       if (this.angle) {
         this._eye.copy(this.object.position).sub(this.target);
+
         this.eyeDirection.copy(this._eye).normalize();
         this.objectUpDirection.copy(this.object.up).normalize();
         this.objectSidewaysDirection.crossVectors(this.objectUpDirection, this.eyeDirection).normalize();
@@ -91,71 +170,96 @@ class TrackballControls extends THREE.EventDispatcher {
         this.axis.crossVectors(this.moveDirection, this._eye).normalize();
         this.angle *= this.rotateSpeed;
         this.quaternion.setFromAxisAngle(this.axis, this.angle);
+
         this._eye.applyQuaternion(this.quaternion);
+
         this.object.up.applyQuaternion(this.quaternion);
+
         this._lastAxis.copy(this.axis);
+
         this._lastAngle = this.angle;
       } else if (!this.staticMoving && this._lastAngle) {
-        this._lastAngle *= Math.sqrt(1 - this.dynamicDampingFactor);
+        this._lastAngle *= Math.sqrt(1.0 - this.dynamicDampingFactor);
+
         this._eye.copy(this.object.position).sub(this.target);
+
         this.quaternion.setFromAxisAngle(this._lastAxis, this._lastAngle);
+
         this._eye.applyQuaternion(this.quaternion);
+
         this.object.up.applyQuaternion(this.quaternion);
       }
+
       this._movePrev.copy(this._moveCurr);
-    };
-    this.zoomCamera = () => {
+    });
+
+    _defineProperty(this, "zoomCamera", () => {
       let factor;
+
       if (this._state === this.STATE.TOUCH_ZOOM_PAN) {
         factor = this._touchZoomDistanceStart / this._touchZoomDistanceEnd;
         this._touchZoomDistanceStart = this._touchZoomDistanceEnd;
+
         if (this.object.isPerspectiveCamera) {
           this._eye.multiplyScalar(factor);
         } else if (this.object.isOrthographicCamera) {
           this.object.zoom /= factor;
           this.object.updateProjectionMatrix();
         } else {
-          console.warn("THREE.TrackballControls: Unsupported camera type");
+          console.warn('THREE.TrackballControls: Unsupported camera type');
         }
       } else {
-        factor = 1 + (this._zoomEnd.y - this._zoomStart.y) * this.zoomSpeed;
-        if (Math.abs(factor - 1) > this.EPS && factor > 0) {
+        factor = 1.0 + (this._zoomEnd.y - this._zoomStart.y) * this.zoomSpeed;
+
+        if (Math.abs(factor - 1.0) > this.EPS && factor > 0.0) {
           if (this.object.isPerspectiveCamera) {
-            if (factor > 1 && this._eye.length() >= this.maxDistance - this.EPS) {
-              factor = 1;
+            if (factor > 1.0 && this._eye.length() >= this.maxDistance - this.EPS) {
+              factor = 1.0;
             }
+
             this._eye.multiplyScalar(factor);
           } else if (this.object.isOrthographicCamera) {
-            if (factor > 1 && this.object.zoom < this.maxDistance * this.maxDistance) {
-              factor = 1;
+            if (factor > 1.0 && this.object.zoom < this.maxDistance * this.maxDistance) {
+              factor = 1.0;
             }
+
             this.object.zoom /= factor;
           } else {
-            console.warn("THREE.TrackballControls: Unsupported camera type");
+            console.warn('THREE.TrackballControls: Unsupported camera type');
           }
         }
+
         if (this.staticMoving) {
           this._zoomStart.copy(this._zoomEnd);
         } else {
           this._zoomStart.y += (this._zoomEnd.y - this._zoomStart.y) * this.dynamicDampingFactor;
         }
+
         if (this.cursorZoom) {
+          //determine 3D position of mouse cursor (on target plane)
           this.targetVector.copy(this.target).project(this.object);
-          let worldPos = this.cursorVector.set(this.mousePosition.x, this.mousePosition.y, this.targetVector.z).unproject(this.object);
+          let worldPos = this.cursorVector.set(this.mousePosition.x, this.mousePosition.y, this.targetVector.z).unproject(this.object); //adjust target point so that "point" stays in place
+
           this.target.lerpVectors(worldPos, this.target, factor);
-        }
+        } // Update the projection matrix after all properties are changed
+
+
         if (this.object.isOrthographicCamera) {
           this.object.updateProjectionMatrix();
         }
       }
-    };
-    this.mouseChange = new THREE.Vector2();
-    this.objectUp = new THREE.Vector3();
-    this.pan = new THREE.Vector3();
-    this.panCamera = () => {
-      if (!this.domElement)
-        return;
+    });
+
+    _defineProperty(this, "mouseChange", new Vector2());
+
+    _defineProperty(this, "objectUp", new Vector3());
+
+    _defineProperty(this, "pan", new Vector3());
+
+    _defineProperty(this, "panCamera", () => {
+      if (!this.domElement) return;
       this.mouseChange.copy(this._panEnd).sub(this._panStart);
+
       if (this.mouseChange.lengthSq() > this.EPS) {
         if (this.object.isOrthographicCamera) {
           const orthoObject = this.object;
@@ -166,72 +270,86 @@ class TrackballControls extends THREE.EventDispatcher {
         } else {
           this.mouseChange.multiplyScalar(this._eye.length() * this.panSpeed);
         }
+
         this.pan.copy(this._eye).cross(this.object.up).setLength(this.mouseChange.x);
         this.pan.add(this.objectUp.copy(this.object.up).setLength(this.mouseChange.y));
         this.object.position.add(this.pan);
         this.target.add(this.pan);
+
         if (this.staticMoving) {
           this._panStart.copy(this._panEnd);
         } else {
-          this._panStart.add(
-            this.mouseChange.subVectors(this._panEnd, this._panStart).multiplyScalar(this.dynamicDampingFactor)
-          );
+          this._panStart.add(this.mouseChange.subVectors(this._panEnd, this._panStart).multiplyScalar(this.dynamicDampingFactor));
         }
       }
-    };
-    this.checkDistances = () => {
+    });
+
+    _defineProperty(this, "checkDistances", () => {
       if (!this.noZoom || !this.noPan) {
         if (this._eye.lengthSq() > this.maxDistance * this.maxDistance) {
           this.object.position.addVectors(this.target, this._eye.setLength(this.maxDistance));
+
           this._zoomStart.copy(this._zoomEnd);
         }
+
         if (this._eye.lengthSq() < this.minDistance * this.minDistance) {
           this.object.position.addVectors(this.target, this._eye.setLength(this.minDistance));
+
           this._zoomStart.copy(this._zoomEnd);
         }
       }
-    };
-    this.handleResize = () => {
-      if (!this.domElement)
-        return;
-      const box = this.domElement.getBoundingClientRect();
+    });
+
+    _defineProperty(this, "handleResize", () => {
+      if (!this.domElement) return;
+      const box = this.domElement.getBoundingClientRect(); // adjustments come from similar code in the jquery offset() function
+
       const d = this.domElement.ownerDocument.documentElement;
       this.screen.left = box.left + window.pageXOffset - d.clientLeft;
       this.screen.top = box.top + window.pageYOffset - d.clientTop;
       this.screen.width = box.width;
       this.screen.height = box.height;
-    };
-    this.update = () => {
+    });
+
+    _defineProperty(this, "update", () => {
       this._eye.subVectors(this.object.position, this.target);
+
       if (!this.noRotate) {
         this.rotateCamera();
       }
+
       if (!this.noZoom) {
         this.zoomCamera();
       }
+
       if (!this.noPan) {
         this.panCamera();
       }
+
       this.object.position.addVectors(this.target, this._eye);
+
       if (this.object.isPerspectiveCamera) {
         this.checkDistances();
         this.object.lookAt(this.target);
+
         if (this.lastPosition.distanceToSquared(this.object.position) > this.EPS) {
           this.dispatchEvent(this.changeEvent);
           this.lastPosition.copy(this.object.position);
         }
       } else if (this.object.isOrthographicCamera) {
         this.object.lookAt(this.target);
+
         if (this.lastPosition.distanceToSquared(this.object.position) > this.EPS || this.lastZoom !== this.object.zoom) {
           this.dispatchEvent(this.changeEvent);
           this.lastPosition.copy(this.object.position);
           this.lastZoom = this.object.zoom;
         }
       } else {
-        console.warn("THREE.TrackballControls: Unsupported camera type");
+        console.warn('THREE.TrackballControls: Unsupported camera type');
       }
-    };
-    this.reset = () => {
+    });
+
+    _defineProperty(this, "reset", () => {
       this._state = this.STATE.NONE;
       this._keyState = this.STATE.NONE;
       this.target.copy(this.target0);
@@ -239,16 +357,19 @@ class TrackballControls extends THREE.EventDispatcher {
       this.object.up.copy(this.up0);
       this.object.zoom = this.zoom0;
       this.object.updateProjectionMatrix();
+
       this._eye.subVectors(this.object.position, this.target);
+
       this.object.lookAt(this.target);
       this.dispatchEvent(this.changeEvent);
       this.lastPosition.copy(this.object.position);
       this.lastZoom = this.object.zoom;
-    };
-    this.keydown = (event) => {
-      if (this.enabled === false)
-        return;
-      window.removeEventListener("keydown", this.keydown);
+    });
+
+    _defineProperty(this, "keydown", event => {
+      if (this.enabled === false) return;
+      window.removeEventListener('keydown', this.keydown);
+
       if (this._keyState !== this.STATE.NONE) {
         return;
       } else if (event.code === this.keys[this.STATE.ROTATE] && !this.noRotate) {
@@ -258,224 +379,275 @@ class TrackballControls extends THREE.EventDispatcher {
       } else if (event.code === this.keys[this.STATE.PAN] && !this.noPan) {
         this._keyState = this.STATE.PAN;
       }
-    };
-    this.onPointerDown = (event) => {
-      if (this.enabled === false)
-        return;
+    });
+
+    _defineProperty(this, "onPointerDown", event => {
+      if (this.enabled === false) return;
+
       switch (event.pointerType) {
-        case "mouse":
-        case "pen":
+        case 'mouse':
+        case 'pen':
           this.onMouseDown(event);
           break;
+        // TODO touch
       }
-    };
-    this.onPointerMove = (event) => {
-      if (this.enabled === false)
-        return;
+    });
+
+    _defineProperty(this, "onPointerMove", event => {
+      if (this.enabled === false) return;
+
       switch (event.pointerType) {
-        case "mouse":
-        case "pen":
+        case 'mouse':
+        case 'pen':
           this.onMouseMove(event);
           break;
+        // TODO touch
       }
-    };
-    this.onPointerUp = (event) => {
-      if (this.enabled === false)
-        return;
+    });
+
+    _defineProperty(this, "onPointerUp", event => {
+      if (this.enabled === false) return;
+
       switch (event.pointerType) {
-        case "mouse":
-        case "pen":
+        case 'mouse':
+        case 'pen':
           this.onMouseUp();
           break;
+        // TODO touch
       }
-    };
-    this.keyup = () => {
-      if (this.enabled === false)
-        return;
+    });
+
+    _defineProperty(this, "keyup", () => {
+      if (this.enabled === false) return;
       this._keyState = this.STATE.NONE;
-      window.addEventListener("keydown", this.keydown);
-    };
-    this.onMouseDown = (event) => {
-      if (!this.domElement)
-        return;
+      window.addEventListener('keydown', this.keydown);
+    });
+
+    _defineProperty(this, "onMouseDown", event => {
+      if (!this.domElement) return;
+
       if (this._state === this.STATE.NONE) {
         switch (event.button) {
           case this.mouseButtons.LEFT:
             this._state = this.STATE.ROTATE;
             break;
+
           case this.mouseButtons.MIDDLE:
             this._state = this.STATE.ZOOM;
             break;
+
           case this.mouseButtons.RIGHT:
             this._state = this.STATE.PAN;
             break;
+
           default:
             this._state = this.STATE.NONE;
         }
       }
+
       const state = this._keyState !== this.STATE.NONE ? this._keyState : this._state;
+
       if (state === this.STATE.ROTATE && !this.noRotate) {
         this._moveCurr.copy(this.getMouseOnCircle(event.pageX, event.pageY));
+
         this._movePrev.copy(this._moveCurr);
       } else if (state === this.STATE.ZOOM && !this.noZoom) {
         this._zoomStart.copy(this.getMouseOnScreen(event.pageX, event.pageY));
+
         this._zoomEnd.copy(this._zoomStart);
       } else if (state === this.STATE.PAN && !this.noPan) {
         this._panStart.copy(this.getMouseOnScreen(event.pageX, event.pageY));
+
         this._panEnd.copy(this._panStart);
       }
-      this.domElement.ownerDocument.addEventListener("pointermove", this.onPointerMove);
-      this.domElement.ownerDocument.addEventListener("pointerup", this.onPointerUp);
+
+      this.domElement.ownerDocument.addEventListener('pointermove', this.onPointerMove);
+      this.domElement.ownerDocument.addEventListener('pointerup', this.onPointerUp);
       this.dispatchEvent(this.startEvent);
-    };
-    this.onMouseMove = (event) => {
-      if (this.enabled === false)
-        return;
+    });
+
+    _defineProperty(this, "onMouseMove", event => {
+      if (this.enabled === false) return;
       const state = this._keyState !== this.STATE.NONE ? this._keyState : this._state;
+
       if (state === this.STATE.ROTATE && !this.noRotate) {
         this._movePrev.copy(this._moveCurr);
+
         this._moveCurr.copy(this.getMouseOnCircle(event.pageX, event.pageY));
       } else if (state === this.STATE.ZOOM && !this.noZoom) {
         this._zoomEnd.copy(this.getMouseOnScreen(event.pageX, event.pageY));
       } else if (state === this.STATE.PAN && !this.noPan) {
         this._panEnd.copy(this.getMouseOnScreen(event.pageX, event.pageY));
       }
-    };
-    this.onMouseUp = () => {
-      if (!this.domElement)
-        return;
-      if (this.enabled === false)
-        return;
+    });
+
+    _defineProperty(this, "onMouseUp", () => {
+      if (!this.domElement) return;
+      if (this.enabled === false) return;
       this._state = this.STATE.NONE;
-      this.domElement.ownerDocument.removeEventListener("pointermove", this.onPointerMove);
-      this.domElement.ownerDocument.removeEventListener("pointerup", this.onPointerUp);
+      this.domElement.ownerDocument.removeEventListener('pointermove', this.onPointerMove);
+      this.domElement.ownerDocument.removeEventListener('pointerup', this.onPointerUp);
       this.dispatchEvent(this.endEvent);
-    };
-    this.mousewheel = (event) => {
-      if (this.enabled === false)
-        return;
-      if (this.noZoom === true)
-        return;
+    });
+
+    _defineProperty(this, "mousewheel", event => {
+      if (this.enabled === false) return;
+      if (this.noZoom === true) return;
       event.preventDefault();
+
       switch (event.deltaMode) {
         case 2:
+          // Zoom in pages
           this._zoomStart.y -= event.deltaY * 0.025;
           break;
+
         case 1:
+          // Zoom in lines
           this._zoomStart.y -= event.deltaY * 0.01;
           break;
+
         default:
-          this._zoomStart.y -= event.deltaY * 25e-5;
+          // undefined, 0, assume pixels
+          this._zoomStart.y -= event.deltaY * 0.00025;
           break;
       }
+
       this.mousePosition.x = event.offsetX / this.screen.width * 2 - 1;
       this.mousePosition.y = -(event.offsetY / this.screen.height) * 2 + 1;
       this.dispatchEvent(this.startEvent);
       this.dispatchEvent(this.endEvent);
-    };
-    this.touchstart = (event) => {
-      if (this.enabled === false)
-        return;
+    });
+
+    _defineProperty(this, "touchstart", event => {
+      if (this.enabled === false) return;
       event.preventDefault();
+
       switch (event.touches.length) {
         case 1:
           this._state = this.STATE.TOUCH_ROTATE;
+
           this._moveCurr.copy(this.getMouseOnCircle(event.touches[0].pageX, event.touches[0].pageY));
+
           this._movePrev.copy(this._moveCurr);
+
           break;
+
         default:
+          // 2 or more
           this._state = this.STATE.TOUCH_ZOOM_PAN;
           const dx = event.touches[0].pageX - event.touches[1].pageX;
           const dy = event.touches[0].pageY - event.touches[1].pageY;
           this._touchZoomDistanceEnd = this._touchZoomDistanceStart = Math.sqrt(dx * dx + dy * dy);
           const x = (event.touches[0].pageX + event.touches[1].pageX) / 2;
           const y = (event.touches[0].pageY + event.touches[1].pageY) / 2;
+
           this._panStart.copy(this.getMouseOnScreen(x, y));
+
           this._panEnd.copy(this._panStart);
+
           break;
       }
+
       this.dispatchEvent(this.startEvent);
-    };
-    this.touchmove = (event) => {
-      if (this.enabled === false)
-        return;
+    });
+
+    _defineProperty(this, "touchmove", event => {
+      if (this.enabled === false) return;
       event.preventDefault();
+
       switch (event.touches.length) {
         case 1:
           this._movePrev.copy(this._moveCurr);
+
           this._moveCurr.copy(this.getMouseOnCircle(event.touches[0].pageX, event.touches[0].pageY));
+
           break;
+
         default:
+          // 2 or more
           const dx = event.touches[0].pageX - event.touches[1].pageX;
           const dy = event.touches[0].pageY - event.touches[1].pageY;
           this._touchZoomDistanceEnd = Math.sqrt(dx * dx + dy * dy);
           const x = (event.touches[0].pageX + event.touches[1].pageX) / 2;
           const y = (event.touches[0].pageY + event.touches[1].pageY) / 2;
+
           this._panEnd.copy(this.getMouseOnScreen(x, y));
+
           break;
       }
-    };
-    this.touchend = (event) => {
-      if (this.enabled === false)
-        return;
+    });
+
+    _defineProperty(this, "touchend", event => {
+      if (this.enabled === false) return;
+
       switch (event.touches.length) {
         case 0:
           this._state = this.STATE.NONE;
           break;
+
         case 1:
           this._state = this.STATE.TOUCH_ROTATE;
+
           this._moveCurr.copy(this.getMouseOnCircle(event.touches[0].pageX, event.touches[0].pageY));
+
           this._movePrev.copy(this._moveCurr);
+
           break;
       }
+
       this.dispatchEvent(this.endEvent);
-    };
-    this.contextmenu = (event) => {
-      if (this.enabled === false)
-        return;
+    });
+
+    _defineProperty(this, "contextmenu", event => {
+      if (this.enabled === false) return;
       event.preventDefault();
-    };
-    this.connect = (domElement2) => {
-      if (domElement2 === document) {
-        console.error(
-          'THREE.OrbitControls: "document" should not be used as the target "domElement". Please use "renderer.domElement" instead.'
-        );
+    });
+
+    _defineProperty(this, "connect", domElement => {
+      if (domElement === document) {
+        console.error('THREE.OrbitControls: "document" should not be used as the target "domElement". Please use "renderer.domElement" instead.');
       }
-      this.domElement = domElement2;
-      this.domElement.addEventListener("contextmenu", this.contextmenu);
-      this.domElement.addEventListener("pointerdown", this.onPointerDown);
-      this.domElement.addEventListener("wheel", this.mousewheel);
-      this.domElement.addEventListener("touchstart", this.touchstart);
-      this.domElement.addEventListener("touchend", this.touchend);
-      this.domElement.addEventListener("touchmove", this.touchmove);
-      this.domElement.ownerDocument.addEventListener("pointermove", this.onPointerMove);
-      this.domElement.ownerDocument.addEventListener("pointerup", this.onPointerUp);
-      window.addEventListener("keydown", this.keydown);
-      window.addEventListener("keyup", this.keyup);
+
+      this.domElement = domElement;
+      this.domElement.addEventListener('contextmenu', this.contextmenu);
+      this.domElement.addEventListener('pointerdown', this.onPointerDown);
+      this.domElement.addEventListener('wheel', this.mousewheel);
+      this.domElement.addEventListener('touchstart', this.touchstart);
+      this.domElement.addEventListener('touchend', this.touchend);
+      this.domElement.addEventListener('touchmove', this.touchmove);
+      this.domElement.ownerDocument.addEventListener('pointermove', this.onPointerMove);
+      this.domElement.ownerDocument.addEventListener('pointerup', this.onPointerUp);
+      window.addEventListener('keydown', this.keydown);
+      window.addEventListener('keyup', this.keyup);
       this.handleResize();
-    };
-    this.dispose = () => {
-      if (!this.domElement)
-        return;
-      this.domElement.removeEventListener("contextmenu", this.contextmenu);
-      this.domElement.removeEventListener("pointerdown", this.onPointerDown);
-      this.domElement.removeEventListener("wheel", this.mousewheel);
-      this.domElement.removeEventListener("touchstart", this.touchstart);
-      this.domElement.removeEventListener("touchend", this.touchend);
-      this.domElement.removeEventListener("touchmove", this.touchmove);
-      this.domElement.ownerDocument.removeEventListener("pointermove", this.onPointerMove);
-      this.domElement.ownerDocument.removeEventListener("pointerup", this.onPointerUp);
-      window.removeEventListener("keydown", this.keydown);
-      window.removeEventListener("keyup", this.keyup);
-    };
-    this.object = object;
+    });
+
+    _defineProperty(this, "dispose", () => {
+      if (!this.domElement) return;
+      this.domElement.removeEventListener('contextmenu', this.contextmenu);
+      this.domElement.removeEventListener('pointerdown', this.onPointerDown);
+      this.domElement.removeEventListener('wheel', this.mousewheel);
+      this.domElement.removeEventListener('touchstart', this.touchstart);
+      this.domElement.removeEventListener('touchend', this.touchend);
+      this.domElement.removeEventListener('touchmove', this.touchmove);
+      this.domElement.ownerDocument.removeEventListener('pointermove', this.onPointerMove);
+      this.domElement.ownerDocument.removeEventListener('pointerup', this.onPointerUp);
+      window.removeEventListener('keydown', this.keydown);
+      window.removeEventListener('keyup', this.keyup);
+    });
+
+    this.object = object; // for reset
+
     this.target0 = this.target.clone();
     this.position0 = this.object.position.clone();
     this.up0 = this.object.up.clone();
-    this.zoom0 = this.object.zoom;
-    if (domElement !== void 0)
-      this.connect(domElement);
+    this.zoom0 = this.object.zoom; // connect events
+
+    if (_domElement !== undefined) this.connect(_domElement); // force an update at start
+
     this.update();
   }
+
 }
-exports.TrackballControls = TrackballControls;
+
+export { TrackballControls };