three-stdlib 2.16.0 → 2.16.2

package/controls/OrbitControls.js

@@ -1,56 +1,166 @@
-"use strict";
-Object.defineProperties(exports, { __esModule: { value: true }, [Symbol.toStringTag]: { value: "Module" } });
-const THREE = require("three");
+import _defineProperty from '@babel/runtime/helpers/esm/defineProperty';
+import { EventDispatcher, Vector3, MOUSE, TOUCH, PerspectiveCamera, Quaternion, Spherical, Vector2, OrthographicCamera } from 'three';
+
+// Unlike TrackballControls, it maintains the "up" direction object.up (+Y by default).
+//
+//    Orbit - left mouse / touch: one-finger move
+//    Zoom - middle mouse, or mousewheel / touch: two-finger spread or squish
+//    Pan - right mouse, or left mouse + ctrl/meta/shiftKey, or arrow keys / touch: two-finger move
+
 const moduloWrapAround = (offset, capacity) => (offset % capacity + capacity) % capacity;
-class OrbitControls extends THREE.EventDispatcher {
+
+class OrbitControls extends EventDispatcher {
+  // Set to false to disable this control
+  // "target" sets the location of focus, where the object orbits around
+  // How far you can dolly in and out ( PerspectiveCamera only )
+  // How far you can zoom in and out ( OrthographicCamera only )
+  // How far you can orbit vertically, upper and lower limits.
+  // Range is 0 to Math.PI radians.
+  // radians
+  // radians
+  // How far you can orbit horizontally, upper and lower limits.
+  // If set, the interval [ min, max ] must be a sub-interval of [ - 2 PI, 2 PI ], with ( max - min < 2 PI )
+  // radians
+  // radians
+  // Set to true to enable damping (inertia)
+  // If damping is enabled, you must call controls.update() in your animation loop
+  // This option actually enables dollying in and out; left as "zoom" for backwards compatibility.
+  // Set to false to disable zooming
+  // Set to false to disable rotating
+  // Set to false to disable panning
+  // if false, pan orthogonal to world-space direction camera.up
+  // pixels moved per arrow key push
+  // Set to true to automatically rotate around the target
+  // If auto-rotate is enabled, you must call controls.update() in your animation loop
+  // 30 seconds per orbit when fps is 60
+  // true if you want to reverse the orbit to mouse drag from left to right = orbits left
+  // The four arrow keys
+  // Mouse buttons
+  // Touch fingers
+  // the target DOM element for key events
   constructor(object, domElement) {
     super();
-    this.enabled = true;
-    this.target = new THREE.Vector3();
-    this.minDistance = 0;
-    this.maxDistance = Infinity;
-    this.minZoom = 0;
-    this.maxZoom = Infinity;
-    this.minPolarAngle = 0;
-    this.maxPolarAngle = Math.PI;
-    this.minAzimuthAngle = -Infinity;
-    this.maxAzimuthAngle = Infinity;
-    this.enableDamping = false;
-    this.dampingFactor = 0.05;
-    this.enableZoom = true;
-    this.zoomSpeed = 1;
-    this.enableRotate = true;
-    this.rotateSpeed = 1;
-    this.enablePan = true;
-    this.panSpeed = 1;
-    this.screenSpacePanning = true;
-    this.keyPanSpeed = 7;
-    this.autoRotate = false;
-    this.autoRotateSpeed = 2;
-    this.reverseOrbit = false;
-    this.keys = { LEFT: "ArrowLeft", UP: "ArrowUp", RIGHT: "ArrowRight", BOTTOM: "ArrowDown" };
-    this.mouseButtons = {
-      LEFT: THREE.MOUSE.ROTATE,
-      MIDDLE: THREE.MOUSE.DOLLY,
-      RIGHT: THREE.MOUSE.PAN
-    };
-    this.touches = { ONE: THREE.TOUCH.ROTATE, TWO: THREE.TOUCH.DOLLY_PAN };
-    this._domElementKeyEvents = null;
+
+    _defineProperty(this, "object", void 0);
+
+    _defineProperty(this, "domElement", void 0);
+
+    _defineProperty(this, "enabled", true);
+
+    _defineProperty(this, "target", new Vector3());
+
+    _defineProperty(this, "minDistance", 0);
+
+    _defineProperty(this, "maxDistance", Infinity);
+
+    _defineProperty(this, "minZoom", 0);
+
+    _defineProperty(this, "maxZoom", Infinity);
+
+    _defineProperty(this, "minPolarAngle", 0);
+
+    _defineProperty(this, "maxPolarAngle", Math.PI);
+
+    _defineProperty(this, "minAzimuthAngle", -Infinity);
+
+    _defineProperty(this, "maxAzimuthAngle", Infinity);
+
+    _defineProperty(this, "enableDamping", false);
+
+    _defineProperty(this, "dampingFactor", 0.05);
+
+    _defineProperty(this, "enableZoom", true);
+
+    _defineProperty(this, "zoomSpeed", 1.0);
+
+    _defineProperty(this, "enableRotate", true);
+
+    _defineProperty(this, "rotateSpeed", 1.0);
+
+    _defineProperty(this, "enablePan", true);
+
+    _defineProperty(this, "panSpeed", 1.0);
+
+    _defineProperty(this, "screenSpacePanning", true);
+
+    _defineProperty(this, "keyPanSpeed", 7.0);
+
+    _defineProperty(this, "autoRotate", false);
+
+    _defineProperty(this, "autoRotateSpeed", 2.0);
+
+    _defineProperty(this, "reverseOrbit", false);
+
+    _defineProperty(this, "keys", {
+      LEFT: 'ArrowLeft',
+      UP: 'ArrowUp',
+      RIGHT: 'ArrowRight',
+      BOTTOM: 'ArrowDown'
+    });
+
+    _defineProperty(this, "mouseButtons", {
+      LEFT: MOUSE.ROTATE,
+      MIDDLE: MOUSE.DOLLY,
+      RIGHT: MOUSE.PAN
+    });
+
+    _defineProperty(this, "touches", {
+      ONE: TOUCH.ROTATE,
+      TWO: TOUCH.DOLLY_PAN
+    });
+
+    _defineProperty(this, "target0", void 0);
+
+    _defineProperty(this, "position0", void 0);
+
+    _defineProperty(this, "zoom0", void 0);
+
+    _defineProperty(this, "_domElementKeyEvents", null);
+
+    _defineProperty(this, "getPolarAngle", void 0);
+
+    _defineProperty(this, "getAzimuthalAngle", void 0);
+
+    _defineProperty(this, "setPolarAngle", void 0);
+
+    _defineProperty(this, "setAzimuthalAngle", void 0);
+
+    _defineProperty(this, "getDistance", void 0);
+
+    _defineProperty(this, "listenToKeyEvents", void 0);
+
+    _defineProperty(this, "saveState", void 0);
+
+    _defineProperty(this, "reset", void 0);
+
+    _defineProperty(this, "update", void 0);
+
+    _defineProperty(this, "connect", void 0);
+
+    _defineProperty(this, "dispose", void 0);
+
     this.object = object;
-    this.domElement = domElement;
+    this.domElement = domElement; // for reset
+
     this.target0 = this.target.clone();
     this.position0 = this.object.position.clone();
-    this.zoom0 = this.object instanceof THREE.PerspectiveCamera ? this.object.zoom : 1;
+    this.zoom0 = this.object instanceof PerspectiveCamera ? this.object.zoom : 1; //
+    // public methods
+    //
+
     this.getPolarAngle = () => spherical.phi;
+
     this.getAzimuthalAngle = () => spherical.theta;
-    this.setPolarAngle = (value) => {
+
+    this.setPolarAngle = value => {
+      // use modulo wrapping to safeguard value
       let phi = moduloWrapAround(value, 2 * Math.PI);
-      let currentPhi = spherical.phi;
-      if (currentPhi < 0)
-        currentPhi += 2 * Math.PI;
-      if (phi < 0)
-        phi += 2 * Math.PI;
+      let currentPhi = spherical.phi; // convert to the equivalent shortest angle
+
+      if (currentPhi < 0) currentPhi += 2 * Math.PI;
+      if (phi < 0) phi += 2 * Math.PI;
       let phiDist = Math.abs(phi - currentPhi);
+
       if (2 * Math.PI - phiDist < phiDist) {
         if (phi < currentPhi) {
           phi += 2 * Math.PI;
@@ -58,17 +168,20 @@ class OrbitControls extends THREE.EventDispatcher {
           currentPhi += 2 * Math.PI;
         }
       }
+
       sphericalDelta.phi = phi - currentPhi;
       scope.update();
     };
-    this.setAzimuthalAngle = (value) => {
+
+    this.setAzimuthalAngle = value => {
+      // use modulo wrapping to safeguard value
       let theta = moduloWrapAround(value, 2 * Math.PI);
-      let currentTheta = spherical.theta;
-      if (currentTheta < 0)
-        currentTheta += 2 * Math.PI;
-      if (theta < 0)
-        theta += 2 * Math.PI;
+      let currentTheta = spherical.theta; // convert to the equivalent shortest angle
+
+      if (currentTheta < 0) currentTheta += 2 * Math.PI;
+      if (theta < 0) theta += 2 * Math.PI;
       let thetaDist = Math.abs(theta - currentTheta);
+
       if (2 * Math.PI - thetaDist < thetaDist) {
         if (theta < currentTheta) {
           theta += 2 * Math.PI;
@@ -76,82 +189,101 @@ class OrbitControls extends THREE.EventDispatcher {
           currentTheta += 2 * Math.PI;
         }
       }
+
       sphericalDelta.theta = theta - currentTheta;
       scope.update();
     };
+
     this.getDistance = () => scope.object.position.distanceTo(scope.target);
-    this.listenToKeyEvents = (domElement2) => {
-      domElement2.addEventListener("keydown", onKeyDown);
-      this._domElementKeyEvents = domElement2;
+
+    this.listenToKeyEvents = domElement => {
+      domElement.addEventListener('keydown', onKeyDown);
+      this._domElementKeyEvents = domElement;
     };
+
     this.saveState = () => {
       scope.target0.copy(scope.target);
       scope.position0.copy(scope.object.position);
-      scope.zoom0 = scope.object instanceof THREE.PerspectiveCamera ? scope.object.zoom : 1;
+      scope.zoom0 = scope.object instanceof PerspectiveCamera ? scope.object.zoom : 1;
     };
+
     this.reset = () => {
       scope.target.copy(scope.target0);
       scope.object.position.copy(scope.position0);
-      if (scope.object instanceof THREE.PerspectiveCamera) {
+
+      if (scope.object instanceof PerspectiveCamera) {
         scope.object.zoom = scope.zoom0;
         scope.object.updateProjectionMatrix();
       }
+
       scope.dispatchEvent(changeEvent);
       scope.update();
       state = STATE.NONE;
-    };
+    }; // this method is exposed, but perhaps it would be better if we can make it private...
+
+
     this.update = (() => {
-      const offset = new THREE.Vector3();
-      const quat = new THREE.Quaternion().setFromUnitVectors(object.up, new THREE.Vector3(0, 1, 0));
+      const offset = new Vector3(); // so camera.up is the orbit axis
+
+      const quat = new Quaternion().setFromUnitVectors(object.up, new Vector3(0, 1, 0));
       const quatInverse = quat.clone().invert();
-      const lastPosition = new THREE.Vector3();
-      const lastQuaternion = new THREE.Quaternion();
+      const lastPosition = new Vector3();
+      const lastQuaternion = new Quaternion();
       const twoPI = 2 * Math.PI;
       return function update() {
         const position = scope.object.position;
-        offset.copy(position).sub(scope.target);
-        offset.applyQuaternion(quat);
+        offset.copy(position).sub(scope.target); // rotate offset to "y-axis-is-up" space
+
+        offset.applyQuaternion(quat); // angle from z-axis around y-axis
+
         spherical.setFromVector3(offset);
+
         if (scope.autoRotate && state === STATE.NONE) {
           rotateLeft(getAutoRotationAngle());
         }
+
         if (scope.enableDamping) {
           spherical.theta += sphericalDelta.theta * scope.dampingFactor;
           spherical.phi += sphericalDelta.phi * scope.dampingFactor;
         } else {
           spherical.theta += sphericalDelta.theta;
           spherical.phi += sphericalDelta.phi;
-        }
+        } // restrict theta to be between desired limits
+
+
         let min = scope.minAzimuthAngle;
         let max = scope.maxAzimuthAngle;
+
         if (isFinite(min) && isFinite(max)) {
-          if (min < -Math.PI)
-            min += twoPI;
-          else if (min > Math.PI)
-            min -= twoPI;
-          if (max < -Math.PI)
-            max += twoPI;
-          else if (max > Math.PI)
-            max -= twoPI;
+          if (min < -Math.PI) min += twoPI;else if (min > Math.PI) min -= twoPI;
+          if (max < -Math.PI) max += twoPI;else if (max > Math.PI) max -= twoPI;
+
           if (min <= max) {
             spherical.theta = Math.max(min, Math.min(max, spherical.theta));
           } else {
             spherical.theta = spherical.theta > (min + max) / 2 ? Math.max(min, spherical.theta) : Math.min(max, spherical.theta);
           }
-        }
+        } // restrict phi to be between desired limits
+
+
         spherical.phi = Math.max(scope.minPolarAngle, Math.min(scope.maxPolarAngle, spherical.phi));
         spherical.makeSafe();
-        spherical.radius *= scale;
-        spherical.radius = Math.max(scope.minDistance, Math.min(scope.maxDistance, spherical.radius));
+        spherical.radius *= scale; // restrict radius to be between desired limits
+
+        spherical.radius = Math.max(scope.minDistance, Math.min(scope.maxDistance, spherical.radius)); // move target to panned location
+
         if (scope.enableDamping === true) {
           scope.target.addScaledVector(panOffset, scope.dampingFactor);
         } else {
           scope.target.add(panOffset);
         }
-        offset.setFromSpherical(spherical);
+
+        offset.setFromSpherical(spherical); // rotate offset back to "camera-up-vector-is-up" space
+
         offset.applyQuaternion(quatInverse);
         position.copy(scope.target).add(offset);
         scope.object.lookAt(scope.target);
+
         if (scope.enableDamping === true) {
           sphericalDelta.theta *= 1 - scope.dampingFactor;
           sphericalDelta.phi *= 1 - scope.dampingFactor;
@@ -160,7 +292,11 @@ class OrbitControls extends THREE.EventDispatcher {
           sphericalDelta.set(0, 0, 0);
           panOffset.set(0, 0, 0);
         }
-        scale = 1;
+
+        scale = 1; // update condition is:
+        // min(camera displacement, camera rotation in radians)^2 > EPS
+        // using small-angle approximation cos(x/2) = 1 - x^2 / 8
+
         if (zoomChanged || lastPosition.distanceToSquared(scope.object.position) > EPS || 8 * (1 - lastQuaternion.dot(scope.object.quaternion)) > EPS) {
           scope.dispatchEvent(changeEvent);
           lastPosition.copy(scope.object.position);
@@ -168,38 +304,57 @@ class OrbitControls extends THREE.EventDispatcher {
           zoomChanged = false;
           return true;
         }
+
         return false;
       };
-    })();
-    this.connect = (domElement2) => {
-      if (domElement2 === document) {
-        console.error(
-          'THREE.OrbitControls: "document" should not be used as the target "domElement". Please use "renderer.domElement" instead.'
-        );
-      }
-      scope.domElement = domElement2;
-      scope.domElement.style.touchAction = "none";
-      scope.domElement.addEventListener("contextmenu", onContextMenu);
-      scope.domElement.addEventListener("pointerdown", onPointerDown);
-      scope.domElement.addEventListener("pointercancel", onPointerCancel);
-      scope.domElement.addEventListener("wheel", onMouseWheel);
+    })(); // https://github.com/mrdoob/three.js/issues/20575
+
+
+    this.connect = domElement => {
+      if (domElement === document) {
+        console.error('THREE.OrbitControls: "document" should not be used as the target "domElement". Please use "renderer.domElement" instead.');
+      }
+
+      scope.domElement = domElement; // disables touch scroll
+      // touch-action needs to be defined for pointer events to work on mobile
+      // https://stackoverflow.com/a/48254578
+
+      scope.domElement.style.touchAction = 'none';
+      scope.domElement.addEventListener('contextmenu', onContextMenu);
+      scope.domElement.addEventListener('pointerdown', onPointerDown);
+      scope.domElement.addEventListener('pointercancel', onPointerCancel);
+      scope.domElement.addEventListener('wheel', onMouseWheel);
     };
+
     this.dispose = () => {
-      var _a, _b, _c, _d, _e, _f;
-      (_a = scope.domElement) == null ? void 0 : _a.removeEventListener("contextmenu", onContextMenu);
-      (_b = scope.domElement) == null ? void 0 : _b.removeEventListener("pointerdown", onPointerDown);
-      (_c = scope.domElement) == null ? void 0 : _c.removeEventListener("pointercancel", onPointerCancel);
-      (_d = scope.domElement) == null ? void 0 : _d.removeEventListener("wheel", onMouseWheel);
-      (_e = scope.domElement) == null ? void 0 : _e.ownerDocument.removeEventListener("pointermove", onPointerMove);
-      (_f = scope.domElement) == null ? void 0 : _f.ownerDocument.removeEventListener("pointerup", onPointerUp);
+      var _scope$domElement, _scope$domElement2, _scope$domElement3, _scope$domElement4, _scope$domElement5, _scope$domElement6;
+
+      (_scope$domElement = scope.domElement) === null || _scope$domElement === void 0 ? void 0 : _scope$domElement.removeEventListener('contextmenu', onContextMenu);
+      (_scope$domElement2 = scope.domElement) === null || _scope$domElement2 === void 0 ? void 0 : _scope$domElement2.removeEventListener('pointerdown', onPointerDown);
+      (_scope$domElement3 = scope.domElement) === null || _scope$domElement3 === void 0 ? void 0 : _scope$domElement3.removeEventListener('pointercancel', onPointerCancel);
+      (_scope$domElement4 = scope.domElement) === null || _scope$domElement4 === void 0 ? void 0 : _scope$domElement4.removeEventListener('wheel', onMouseWheel);
+      (_scope$domElement5 = scope.domElement) === null || _scope$domElement5 === void 0 ? void 0 : _scope$domElement5.ownerDocument.removeEventListener('pointermove', onPointerMove);
+      (_scope$domElement6 = scope.domElement) === null || _scope$domElement6 === void 0 ? void 0 : _scope$domElement6.ownerDocument.removeEventListener('pointerup', onPointerUp);
+
       if (scope._domElementKeyEvents !== null) {
-        scope._domElementKeyEvents.removeEventListener("keydown", onKeyDown);
-      }
-    };
+        scope._domElementKeyEvents.removeEventListener('keydown', onKeyDown);
+      } //scope.dispatchEvent( { type: 'dispose' } ); // should this be added here?
+
+    }; //
+    // internals
+    //
+
+
     const scope = this;
-    const changeEvent = { type: "change" };
-    const startEvent = { type: "start" };
-    const endEvent = { type: "end" };
+    const changeEvent = {
+      type: 'change'
+    };
+    const startEvent = {
+      type: 'start'
+    };
+    const endEvent = {
+      type: 'end'
+    };
     const STATE = {
       NONE: -1,
       ROTATE: 0,
@@ -211,29 +366,33 @@ class OrbitControls extends THREE.EventDispatcher {
       TOUCH_DOLLY_ROTATE: 6
     };
     let state = STATE.NONE;
-    const EPS = 1e-6;
-    const spherical = new THREE.Spherical();
-    const sphericalDelta = new THREE.Spherical();
+    const EPS = 0.000001; // current position in spherical coordinates
+
+    const spherical = new Spherical();
+    const sphericalDelta = new Spherical();
     let scale = 1;
-    const panOffset = new THREE.Vector3();
+    const panOffset = new Vector3();
     let zoomChanged = false;
-    const rotateStart = new THREE.Vector2();
-    const rotateEnd = new THREE.Vector2();
-    const rotateDelta = new THREE.Vector2();
-    const panStart = new THREE.Vector2();
-    const panEnd = new THREE.Vector2();
-    const panDelta = new THREE.Vector2();
-    const dollyStart = new THREE.Vector2();
-    const dollyEnd = new THREE.Vector2();
-    const dollyDelta = new THREE.Vector2();
+    const rotateStart = new Vector2();
+    const rotateEnd = new Vector2();
+    const rotateDelta = new Vector2();
+    const panStart = new Vector2();
+    const panEnd = new Vector2();
+    const panDelta = new Vector2();
+    const dollyStart = new Vector2();
+    const dollyEnd = new Vector2();
+    const dollyDelta = new Vector2();
     const pointers = [];
     const pointerPositions = {};
+
     function getAutoRotationAngle() {
       return 2 * Math.PI / 60 / 60 * scope.autoRotateSpeed;
     }
+
     function getZoomScale() {
       return Math.pow(0.95, scope.zoomSpeed);
     }
+
     function rotateLeft(angle) {
       if (scope.reverseOrbit) {
         sphericalDelta.theta += angle;
@@ -241,6 +400,7 @@ class OrbitControls extends THREE.EventDispatcher {
         sphericalDelta.theta -= angle;
       }
     }
+
     function rotateUp(angle) {
       if (scope.reverseOrbit) {
         sphericalDelta.phi += angle;
@@ -248,108 +408,130 @@ class OrbitControls extends THREE.EventDispatcher {
         sphericalDelta.phi -= angle;
       }
     }
+
     const panLeft = (() => {
-      const v = new THREE.Vector3();
-      return function panLeft2(distance, objectMatrix) {
-        v.setFromMatrixColumn(objectMatrix, 0);
+      const v = new Vector3();
+      return function panLeft(distance, objectMatrix) {
+        v.setFromMatrixColumn(objectMatrix, 0); // get X column of objectMatrix
+
         v.multiplyScalar(-distance);
         panOffset.add(v);
       };
     })();
+
     const panUp = (() => {
-      const v = new THREE.Vector3();
-      return function panUp2(distance, objectMatrix) {
+      const v = new Vector3();
+      return function panUp(distance, objectMatrix) {
         if (scope.screenSpacePanning === true) {
           v.setFromMatrixColumn(objectMatrix, 1);
         } else {
           v.setFromMatrixColumn(objectMatrix, 0);
           v.crossVectors(scope.object.up, v);
         }
+
         v.multiplyScalar(distance);
         panOffset.add(v);
       };
-    })();
+    })(); // deltaX and deltaY are in pixels; right and down are positive
+
+
     const pan = (() => {
-      const offset = new THREE.Vector3();
-      return function pan2(deltaX, deltaY) {
+      const offset = new Vector3();
+      return function pan(deltaX, deltaY) {
         const element = scope.domElement;
-        if (element && scope.object instanceof THREE.PerspectiveCamera && scope.object.isPerspectiveCamera) {
+
+        if (element && scope.object instanceof PerspectiveCamera && scope.object.isPerspectiveCamera) {
+          // perspective
           const position = scope.object.position;
           offset.copy(position).sub(scope.target);
-          let targetDistance = offset.length();
-          targetDistance *= Math.tan(scope.object.fov / 2 * Math.PI / 180);
+          let targetDistance = offset.length(); // half of the fov is center to top of screen
+
+          targetDistance *= Math.tan(scope.object.fov / 2 * Math.PI / 180.0); // we use only clientHeight here so aspect ratio does not distort speed
+
           panLeft(2 * deltaX * targetDistance / element.clientHeight, scope.object.matrix);
           panUp(2 * deltaY * targetDistance / element.clientHeight, scope.object.matrix);
-        } else if (element && scope.object instanceof THREE.OrthographicCamera && scope.object.isOrthographicCamera) {
-          panLeft(
-            deltaX * (scope.object.right - scope.object.left) / scope.object.zoom / element.clientWidth,
-            scope.object.matrix
-          );
-          panUp(
-            deltaY * (scope.object.top - scope.object.bottom) / scope.object.zoom / element.clientHeight,
-            scope.object.matrix
-          );
+        } else if (element && scope.object instanceof OrthographicCamera && scope.object.isOrthographicCamera) {
+          // orthographic
+          panLeft(deltaX * (scope.object.right - scope.object.left) / scope.object.zoom / element.clientWidth, scope.object.matrix);
+          panUp(deltaY * (scope.object.top - scope.object.bottom) / scope.object.zoom / element.clientHeight, scope.object.matrix);
         } else {
-          console.warn("WARNING: OrbitControls.js encountered an unknown camera type - pan disabled.");
+          // camera neither orthographic nor perspective
+          console.warn('WARNING: OrbitControls.js encountered an unknown camera type - pan disabled.');
           scope.enablePan = false;
         }
       };
     })();
+
     function dollyOut(dollyScale) {
-      if (scope.object instanceof THREE.PerspectiveCamera && scope.object.isPerspectiveCamera) {
+      if (scope.object instanceof PerspectiveCamera && scope.object.isPerspectiveCamera) {
         scale /= dollyScale;
-      } else if (scope.object instanceof THREE.OrthographicCamera && scope.object.isOrthographicCamera) {
+      } else if (scope.object instanceof OrthographicCamera && scope.object.isOrthographicCamera) {
         scope.object.zoom = Math.max(scope.minZoom, Math.min(scope.maxZoom, scope.object.zoom * dollyScale));
         scope.object.updateProjectionMatrix();
         zoomChanged = true;
       } else {
-        console.warn("WARNING: OrbitControls.js encountered an unknown camera type - dolly/zoom disabled.");
+        console.warn('WARNING: OrbitControls.js encountered an unknown camera type - dolly/zoom disabled.');
         scope.enableZoom = false;
       }
     }
+
     function dollyIn(dollyScale) {
-      if (scope.object instanceof THREE.PerspectiveCamera && scope.object.isPerspectiveCamera) {
+      if (scope.object instanceof PerspectiveCamera && scope.object.isPerspectiveCamera) {
         scale *= dollyScale;
-      } else if (scope.object instanceof THREE.OrthographicCamera && scope.object.isOrthographicCamera) {
+      } else if (scope.object instanceof OrthographicCamera && scope.object.isOrthographicCamera) {
         scope.object.zoom = Math.max(scope.minZoom, Math.min(scope.maxZoom, scope.object.zoom / dollyScale));
         scope.object.updateProjectionMatrix();
         zoomChanged = true;
       } else {
-        console.warn("WARNING: OrbitControls.js encountered an unknown camera type - dolly/zoom disabled.");
+        console.warn('WARNING: OrbitControls.js encountered an unknown camera type - dolly/zoom disabled.');
         scope.enableZoom = false;
       }
-    }
+    } //
+    // event callbacks - update the object state
+    //
+
+
     function handleMouseDownRotate(event) {
       rotateStart.set(event.clientX, event.clientY);
     }
+
     function handleMouseDownDolly(event) {
       dollyStart.set(event.clientX, event.clientY);
     }
+
     function handleMouseDownPan(event) {
       panStart.set(event.clientX, event.clientY);
     }
+
     function handleMouseMoveRotate(event) {
       rotateEnd.set(event.clientX, event.clientY);
       rotateDelta.subVectors(rotateEnd, rotateStart).multiplyScalar(scope.rotateSpeed);
       const element = scope.domElement;
+
       if (element) {
-        rotateLeft(2 * Math.PI * rotateDelta.x / element.clientHeight);
+        rotateLeft(2 * Math.PI * rotateDelta.x / element.clientHeight); // yes, height
+
         rotateUp(2 * Math.PI * rotateDelta.y / element.clientHeight);
       }
+
       rotateStart.copy(rotateEnd);
       scope.update();
     }
+
     function handleMouseMoveDolly(event) {
       dollyEnd.set(event.clientX, event.clientY);
       dollyDelta.subVectors(dollyEnd, dollyStart);
+
       if (dollyDelta.y > 0) {
         dollyOut(getZoomScale());
       } else if (dollyDelta.y < 0) {
         dollyIn(getZoomScale());
       }
+
       dollyStart.copy(dollyEnd);
       scope.update();
     }
+
     function handleMouseMovePan(event) {
       panEnd.set(event.clientX, event.clientY);
       panDelta.subVectors(panEnd, panStart).multiplyScalar(scope.panSpeed);
@@ -357,39 +539,49 @@ class OrbitControls extends THREE.EventDispatcher {
       panStart.copy(panEnd);
       scope.update();
     }
+
     function handleMouseWheel(event) {
       if (event.deltaY < 0) {
         dollyIn(getZoomScale());
       } else if (event.deltaY > 0) {
         dollyOut(getZoomScale());
       }
+
       scope.update();
     }
+
     function handleKeyDown(event) {
       let needsUpdate = false;
+
       switch (event.code) {
         case scope.keys.UP:
           pan(0, scope.keyPanSpeed);
           needsUpdate = true;
           break;
+
         case scope.keys.BOTTOM:
           pan(0, -scope.keyPanSpeed);
           needsUpdate = true;
           break;
+
         case scope.keys.LEFT:
           pan(scope.keyPanSpeed, 0);
           needsUpdate = true;
           break;
+
         case scope.keys.RIGHT:
           pan(-scope.keyPanSpeed, 0);
           needsUpdate = true;
           break;
       }
+
       if (needsUpdate) {
+        // prevent the browser from scrolling on cursor keys
         event.preventDefault();
         scope.update();
       }
     }
+
     function handleTouchStartRotate() {
       if (pointers.length == 1) {
         rotateStart.set(pointers[0].pageX, pointers[0].pageY);
@@ -399,6 +591,7 @@ class OrbitControls extends THREE.EventDispatcher {
         rotateStart.set(x, y);
       }
     }
+
     function handleTouchStartPan() {
       if (pointers.length == 1) {
         panStart.set(pointers[0].pageX, pointers[0].pageY);
@@ -408,24 +601,24 @@ class OrbitControls extends THREE.EventDispatcher {
         panStart.set(x, y);
       }
     }
+
     function handleTouchStartDolly() {
       const dx = pointers[0].pageX - pointers[1].pageX;
       const dy = pointers[0].pageY - pointers[1].pageY;
       const distance = Math.sqrt(dx * dx + dy * dy);
       dollyStart.set(0, distance);
     }
+
     function handleTouchStartDollyPan() {
-      if (scope.enableZoom)
-        handleTouchStartDolly();
-      if (scope.enablePan)
-        handleTouchStartPan();
+      if (scope.enableZoom) handleTouchStartDolly();
+      if (scope.enablePan) handleTouchStartPan();
     }
+
     function handleTouchStartDollyRotate() {
-      if (scope.enableZoom)
-        handleTouchStartDolly();
-      if (scope.enableRotate)
-        handleTouchStartRotate();
+      if (scope.enableZoom) handleTouchStartDolly();
+      if (scope.enableRotate) handleTouchStartRotate();
     }
+
     function handleTouchMoveRotate(event) {
       if (pointers.length == 1) {
         rotateEnd.set(event.pageX, event.pageY);
@@ -435,14 +628,19 @@ class OrbitControls extends THREE.EventDispatcher {
         const y = 0.5 * (event.pageY + position.y);
         rotateEnd.set(x, y);
       }
+
       rotateDelta.subVectors(rotateEnd, rotateStart).multiplyScalar(scope.rotateSpeed);
       const element = scope.domElement;
+
       if (element) {
-        rotateLeft(2 * Math.PI * rotateDelta.x / element.clientHeight);
+        rotateLeft(2 * Math.PI * rotateDelta.x / element.clientHeight); // yes, height
+
         rotateUp(2 * Math.PI * rotateDelta.y / element.clientHeight);
       }
+
       rotateStart.copy(rotateEnd);
     }
+
     function handleTouchMovePan(event) {
       if (pointers.length == 1) {
         panEnd.set(event.pageX, event.pageY);
@@ -452,10 +650,12 @@ class OrbitControls extends THREE.EventDispatcher {
         const y = 0.5 * (event.pageY + position.y);
         panEnd.set(x, y);
       }
+
       panDelta.subVectors(panEnd, panStart).multiplyScalar(scope.panSpeed);
       pan(panDelta.x, panDelta.y);
       panStart.copy(panEnd);
     }
+
     function handleTouchMoveDolly(event) {
       const position = getSecondPointerPosition(event);
       const dx = event.pageX - position.x;
@@ -466,233 +666,265 @@ class OrbitControls extends THREE.EventDispatcher {
       dollyOut(dollyDelta.y);
       dollyStart.copy(dollyEnd);
     }
+
     function handleTouchMoveDollyPan(event) {
-      if (scope.enableZoom)
-        handleTouchMoveDolly(event);
-      if (scope.enablePan)
-        handleTouchMovePan(event);
+      if (scope.enableZoom) handleTouchMoveDolly(event);
+      if (scope.enablePan) handleTouchMovePan(event);
     }
+
     function handleTouchMoveDollyRotate(event) {
-      if (scope.enableZoom)
-        handleTouchMoveDolly(event);
-      if (scope.enableRotate)
-        handleTouchMoveRotate(event);
-    }
+      if (scope.enableZoom) handleTouchMoveDolly(event);
+      if (scope.enableRotate) handleTouchMoveRotate(event);
+    } //
+    // event handlers - FSM: listen for events and reset state
+    //
+
+
     function onPointerDown(event) {
-      var _a, _b;
-      if (scope.enabled === false)
-        return;
+      if (scope.enabled === false) return;
+
       if (pointers.length === 0) {
-        (_a = scope.domElement) == null ? void 0 : _a.ownerDocument.addEventListener("pointermove", onPointerMove);
-        (_b = scope.domElement) == null ? void 0 : _b.ownerDocument.addEventListener("pointerup", onPointerUp);
+        var _scope$domElement7, _scope$domElement8;
+
+        (_scope$domElement7 = scope.domElement) === null || _scope$domElement7 === void 0 ? void 0 : _scope$domElement7.ownerDocument.addEventListener('pointermove', onPointerMove);
+        (_scope$domElement8 = scope.domElement) === null || _scope$domElement8 === void 0 ? void 0 : _scope$domElement8.ownerDocument.addEventListener('pointerup', onPointerUp);
       }
+
       addPointer(event);
-      if (event.pointerType === "touch") {
+
+      if (event.pointerType === 'touch') {
         onTouchStart(event);
       } else {
         onMouseDown(event);
       }
     }
+
     function onPointerMove(event) {
-      if (scope.enabled === false)
-        return;
-      if (event.pointerType === "touch") {
+      if (scope.enabled === false) return;
+
+      if (event.pointerType === 'touch') {
         onTouchMove(event);
       } else {
         onMouseMove(event);
       }
     }
+
     function onPointerUp(event) {
-      var _a, _b, _c;
       removePointer(event);
+
       if (pointers.length === 0) {
-        (_a = scope.domElement) == null ? void 0 : _a.releasePointerCapture(event.pointerId);
-        (_b = scope.domElement) == null ? void 0 : _b.ownerDocument.removeEventListener("pointermove", onPointerMove);
-        (_c = scope.domElement) == null ? void 0 : _c.ownerDocument.removeEventListener("pointerup", onPointerUp);
+        var _scope$domElement9, _scope$domElement10, _scope$domElement11;
+
+        (_scope$domElement9 = scope.domElement) === null || _scope$domElement9 === void 0 ? void 0 : _scope$domElement9.releasePointerCapture(event.pointerId);
+        (_scope$domElement10 = scope.domElement) === null || _scope$domElement10 === void 0 ? void 0 : _scope$domElement10.ownerDocument.removeEventListener('pointermove', onPointerMove);
+        (_scope$domElement11 = scope.domElement) === null || _scope$domElement11 === void 0 ? void 0 : _scope$domElement11.ownerDocument.removeEventListener('pointerup', onPointerUp);
       }
+
       scope.dispatchEvent(endEvent);
       state = STATE.NONE;
     }
+
     function onPointerCancel(event) {
       removePointer(event);
     }
+
     function onMouseDown(event) {
       let mouseAction;
+
       switch (event.button) {
         case 0:
           mouseAction = scope.mouseButtons.LEFT;
           break;
+
         case 1:
           mouseAction = scope.mouseButtons.MIDDLE;
           break;
+
         case 2:
           mouseAction = scope.mouseButtons.RIGHT;
           break;
+
         default:
           mouseAction = -1;
       }
+
       switch (mouseAction) {
-        case THREE.MOUSE.DOLLY:
-          if (scope.enableZoom === false)
-            return;
+        case MOUSE.DOLLY:
+          if (scope.enableZoom === false) return;
           handleMouseDownDolly(event);
           state = STATE.DOLLY;
           break;
-        case THREE.MOUSE.ROTATE:
+
+        case MOUSE.ROTATE:
           if (event.ctrlKey || event.metaKey || event.shiftKey) {
-            if (scope.enablePan === false)
-              return;
+            if (scope.enablePan === false) return;
             handleMouseDownPan(event);
             state = STATE.PAN;
           } else {
-            if (scope.enableRotate === false)
-              return;
+            if (scope.enableRotate === false) return;
             handleMouseDownRotate(event);
             state = STATE.ROTATE;
           }
+
           break;
-        case THREE.MOUSE.PAN:
+
+        case MOUSE.PAN:
           if (event.ctrlKey || event.metaKey || event.shiftKey) {
-            if (scope.enableRotate === false)
-              return;
+            if (scope.enableRotate === false) return;
             handleMouseDownRotate(event);
             state = STATE.ROTATE;
           } else {
-            if (scope.enablePan === false)
-              return;
+            if (scope.enablePan === false) return;
             handleMouseDownPan(event);
             state = STATE.PAN;
           }
+
           break;
+
         default:
           state = STATE.NONE;
       }
+
       if (state !== STATE.NONE) {
         scope.dispatchEvent(startEvent);
       }
     }
+
     function onMouseMove(event) {
-      if (scope.enabled === false)
-        return;
+      if (scope.enabled === false) return;
+
       switch (state) {
         case STATE.ROTATE:
-          if (scope.enableRotate === false)
-            return;
+          if (scope.enableRotate === false) return;
           handleMouseMoveRotate(event);
           break;
+
         case STATE.DOLLY:
-          if (scope.enableZoom === false)
-            return;
+          if (scope.enableZoom === false) return;
           handleMouseMoveDolly(event);
           break;
+
         case STATE.PAN:
-          if (scope.enablePan === false)
-            return;
+          if (scope.enablePan === false) return;
           handleMouseMovePan(event);
           break;
       }
     }
+
     function onMouseWheel(event) {
       if (scope.enabled === false || scope.enableZoom === false || state !== STATE.NONE && state !== STATE.ROTATE) {
         return;
       }
+
       event.preventDefault();
       scope.dispatchEvent(startEvent);
       handleMouseWheel(event);
       scope.dispatchEvent(endEvent);
     }
+
     function onKeyDown(event) {
-      if (scope.enabled === false || scope.enablePan === false)
-        return;
+      if (scope.enabled === false || scope.enablePan === false) return;
       handleKeyDown(event);
     }
+
     function onTouchStart(event) {
       trackPointer(event);
+
       switch (pointers.length) {
         case 1:
           switch (scope.touches.ONE) {
-            case THREE.TOUCH.ROTATE:
-              if (scope.enableRotate === false)
-                return;
+            case TOUCH.ROTATE:
+              if (scope.enableRotate === false) return;
               handleTouchStartRotate();
               state = STATE.TOUCH_ROTATE;
               break;
-            case THREE.TOUCH.PAN:
-              if (scope.enablePan === false)
-                return;
+
+            case TOUCH.PAN:
+              if (scope.enablePan === false) return;
               handleTouchStartPan();
               state = STATE.TOUCH_PAN;
               break;
+
             default:
               state = STATE.NONE;
           }
+
           break;
+
         case 2:
           switch (scope.touches.TWO) {
-            case THREE.TOUCH.DOLLY_PAN:
-              if (scope.enableZoom === false && scope.enablePan === false)
-                return;
+            case TOUCH.DOLLY_PAN:
+              if (scope.enableZoom === false && scope.enablePan === false) return;
               handleTouchStartDollyPan();
               state = STATE.TOUCH_DOLLY_PAN;
               break;
-            case THREE.TOUCH.DOLLY_ROTATE:
-              if (scope.enableZoom === false && scope.enableRotate === false)
-                return;
+
+            case TOUCH.DOLLY_ROTATE:
+              if (scope.enableZoom === false && scope.enableRotate === false) return;
               handleTouchStartDollyRotate();
               state = STATE.TOUCH_DOLLY_ROTATE;
               break;
+
             default:
               state = STATE.NONE;
           }
+
           break;
+
         default:
           state = STATE.NONE;
       }
+
       if (state !== STATE.NONE) {
         scope.dispatchEvent(startEvent);
       }
     }
+
     function onTouchMove(event) {
       trackPointer(event);
+
       switch (state) {
         case STATE.TOUCH_ROTATE:
-          if (scope.enableRotate === false)
-            return;
+          if (scope.enableRotate === false) return;
           handleTouchMoveRotate(event);
           scope.update();
           break;
+
         case STATE.TOUCH_PAN:
-          if (scope.enablePan === false)
-            return;
+          if (scope.enablePan === false) return;
           handleTouchMovePan(event);
           scope.update();
           break;
+
         case STATE.TOUCH_DOLLY_PAN:
-          if (scope.enableZoom === false && scope.enablePan === false)
-            return;
+          if (scope.enableZoom === false && scope.enablePan === false) return;
           handleTouchMoveDollyPan(event);
           scope.update();
           break;
+
         case STATE.TOUCH_DOLLY_ROTATE:
-          if (scope.enableZoom === false && scope.enableRotate === false)
-            return;
+          if (scope.enableZoom === false && scope.enableRotate === false) return;
           handleTouchMoveDollyRotate(event);
           scope.update();
           break;
+
         default:
           state = STATE.NONE;
       }
     }
+
     function onContextMenu(event) {
-      if (scope.enabled === false)
-        return;
+      if (scope.enabled === false) return;
       event.preventDefault();
     }
+
     function addPointer(event) {
       pointers.push(event);
     }
+
     function removePointer(event) {
       delete pointerPositions[event.pointerId];
+
       for (let i = 0; i < pointers.length; i++) {
         if (pointers[i].pointerId == event.pointerId) {
           pointers.splice(i, 1);
@@ -700,32 +932,49 @@ class OrbitControls extends THREE.EventDispatcher {
         }
       }
     }
+
     function trackPointer(event) {
       let position = pointerPositions[event.pointerId];
-      if (position === void 0) {
-        position = new THREE.Vector2();
+
+      if (position === undefined) {
+        position = new Vector2();
         pointerPositions[event.pointerId] = position;
       }
+
       position.set(event.pageX, event.pageY);
     }
+
     function getSecondPointerPosition(event) {
       const pointer = event.pointerId === pointers[0].pointerId ? pointers[1] : pointers[0];
       return pointerPositions[pointer.pointerId];
-    }
-    if (domElement !== void 0)
-      this.connect(domElement);
+    } // connect events
+
+
+    if (domElement !== undefined) this.connect(domElement); // force an update at start
+
     this.update();
   }
-}
+
+} // This set of controls performs orbiting, dollying (zooming), and panning.
+// Unlike TrackballControls, it maintains the "up" direction object.up (+Y by default).
+// This is very similar to OrbitControls, another set of touch behavior
+//
+//    Orbit - right mouse, or left mouse + ctrl/meta/shiftKey / touch: two-finger rotate
+//    Zoom - middle mouse, or mousewheel / touch: two-finger spread or squish
+//    Pan - left mouse, or arrow keys / touch: one-finger move
+
+
 class MapControls extends OrbitControls {
   constructor(object, domElement) {
     super(object, domElement);
-    this.screenSpacePanning = false;
-    this.mouseButtons.LEFT = THREE.MOUSE.PAN;
-    this.mouseButtons.RIGHT = THREE.MOUSE.ROTATE;
-    this.touches.ONE = THREE.TOUCH.PAN;
-    this.touches.TWO = THREE.TOUCH.DOLLY_ROTATE;
+    this.screenSpacePanning = false; // pan orthogonal to world-space direction camera.up
+
+    this.mouseButtons.LEFT = MOUSE.PAN;
+    this.mouseButtons.RIGHT = MOUSE.ROTATE;
+    this.touches.ONE = TOUCH.PAN;
+    this.touches.TWO = TOUCH.DOLLY_ROTATE;
   }
+
 }
-exports.MapControls = MapControls;
-exports.OrbitControls = OrbitControls;
+
+export { MapControls, OrbitControls };