three-render-objects 1.29.4 → 1.29.5

package/dist/three-render-objects.js

@@ -1,4 +1,4 @@
-// Version 1.29.4 three-render-objects - https://github.com/vasturiano/three-render-objects
+// Version 1.29.5 three-render-objects - https://github.com/vasturiano/three-render-objects
 (function (global, factory) {
   typeof exports === 'object' && typeof module !== 'undefined' ? module.exports = factory(require('three')) :
   typeof define === 'function' && define.amd ? define(['three'], factory) :
@@ -6,8 +6,8 @@
 })(this, (function (three$1) { 'use strict';
 
   function styleInject(css, ref) {
-    ref = {};
-    ref.insertAt;
+    if ( ref === void 0 ) ref = {};
+    var insertAt = ref.insertAt;
 
     if (typeof document === 'undefined') { return; }
 
@@ -15,7 +15,13 @@
     var style = document.createElement('style');
     style.type = 'text/css';
 
-    {
+    if (insertAt === 'top') {
+      if (head.firstChild) {
+        head.insertBefore(style, head.firstChild);
+      } else {
+        head.appendChild(style);
+      }
+    } else {
       head.appendChild(style);
     }
 
@@ -29,6 +35,28 @@
   var css_248z = ".scene-nav-info {\n  bottom: 5px;\n  width: 100%;\n  text-align: center;\n  color: slategrey;\n  opacity: 0.7;\n  font-size: 10px;\n}\n\n.scene-tooltip {\n  top: 0;\n  color: lavender;\n  font-size: 15px;\n}\n\n.scene-nav-info, .scene-tooltip {\n  position: absolute;\n  font-family: sans-serif;\n  pointer-events: none;\n  user-select: none;\n}\n\n.scene-container canvas:focus {\n  outline: none;\n}";
   styleInject(css_248z);
 
+  function _arrayLikeToArray$1(r, a) {
+    (null == a || a > r.length) && (a = r.length);
+    for (var e = 0, n = Array(a); e < a; e++) n[e] = r[e];
+    return n;
+  }
+  function _arrayWithHoles$1(r) {
+    if (Array.isArray(r)) return r;
+  }
+  function _arrayWithoutHoles(r) {
+    if (Array.isArray(r)) return _arrayLikeToArray$1(r);
+  }
+  function _defineProperty(e, r, t) {
+    return (r = _toPropertyKey(r)) in e ? Object.defineProperty(e, r, {
+      value: t,
+      enumerable: !0,
+      configurable: !0,
+      writable: !0
+    }) : e[r] = t, e;
+  }
+  function _iterableToArray(r) {
+    if ("undefined" != typeof Symbol && null != r[Symbol.iterator] || null != r["@@iterator"]) return Array.from(r);
+  }
   function _iterableToArrayLimit$1(r, l) {
     var t = null == r ? null : "undefined" != typeof Symbol && r[Symbol.iterator] || r["@@iterator"];
     if (null != t) {
@@ -53,85 +81,63 @@
       return a;
     }
   }
+  function _nonIterableRest$1() {
+    throw new TypeError("Invalid attempt to destructure non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
+  }
+  function _nonIterableSpread() {
+    throw new TypeError("Invalid attempt to spread non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
+  }
+  function _slicedToArray$1(r, e) {
+    return _arrayWithHoles$1(r) || _iterableToArrayLimit$1(r, e) || _unsupportedIterableToArray$1(r, e) || _nonIterableRest$1();
+  }
+  function _toConsumableArray(r) {
+    return _arrayWithoutHoles(r) || _iterableToArray(r) || _unsupportedIterableToArray$1(r) || _nonIterableSpread();
+  }
   function _toPrimitive(t, r) {
     if ("object" != typeof t || !t) return t;
     var e = t[Symbol.toPrimitive];
     if (void 0 !== e) {
-      var i = e.call(t, r );
+      var i = e.call(t, r || "default");
       if ("object" != typeof i) return i;
       throw new TypeError("@@toPrimitive must return a primitive value.");
     }
-    return (String )(t);
+    return ("string" === r ? String : Number)(t);
   }
   function _toPropertyKey(t) {
     var i = _toPrimitive(t, "string");
     return "symbol" == typeof i ? i : i + "";
   }
-  function _defineProperty(obj, key, value) {
-    key = _toPropertyKey(key);
-    if (key in obj) {
-      Object.defineProperty(obj, key, {
-        value: value,
-        enumerable: true,
-        configurable: true,
-        writable: true
-      });
-    } else {
-      obj[key] = value;
+  function _unsupportedIterableToArray$1(r, a) {
+    if (r) {
+      if ("string" == typeof r) return _arrayLikeToArray$1(r, a);
+      var t = {}.toString.call(r).slice(8, -1);
+      return "Object" === t && r.constructor && (t = r.constructor.name), "Map" === t || "Set" === t ? Array.from(r) : "Arguments" === t || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(t) ? _arrayLikeToArray$1(r, a) : void 0;
     }
-    return obj;
-  }
-  function _slicedToArray$1(arr, i) {
-    return _arrayWithHoles$1(arr) || _iterableToArrayLimit$1(arr, i) || _unsupportedIterableToArray$1(arr, i) || _nonIterableRest$1();
-  }
-  function _toConsumableArray(arr) {
-    return _arrayWithoutHoles(arr) || _iterableToArray(arr) || _unsupportedIterableToArray$1(arr) || _nonIterableSpread();
-  }
-  function _arrayWithoutHoles(arr) {
-    if (Array.isArray(arr)) return _arrayLikeToArray$1(arr);
-  }
-  function _arrayWithHoles$1(arr) {
-    if (Array.isArray(arr)) return arr;
-  }
-  function _iterableToArray(iter) {
-    if (typeof Symbol !== "undefined" && iter[Symbol.iterator] != null || iter["@@iterator"] != null) return Array.from(iter);
-  }
-  function _unsupportedIterableToArray$1(o, minLen) {
-    if (!o) return;
-    if (typeof o === "string") return _arrayLikeToArray$1(o, minLen);
-    var n = Object.prototype.toString.call(o).slice(8, -1);
-    if (n === "Object" && o.constructor) n = o.constructor.name;
-    if (n === "Map" || n === "Set") return Array.from(o);
-    if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray$1(o, minLen);
-  }
-  function _arrayLikeToArray$1(arr, len) {
-    if (len == null || len > arr.length) len = arr.length;
-    for (var i = 0, arr2 = new Array(len); i < len; i++) arr2[i] = arr[i];
-    return arr2;
-  }
-  function _nonIterableSpread() {
-    throw new TypeError("Invalid attempt to spread non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
-  }
-  function _nonIterableRest$1() {
-    throw new TypeError("Invalid attempt to destructure non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
   }
 
   const _changeEvent$2 = { type: 'change' };
   const _startEvent$1 = { type: 'start' };
   const _endEvent$1 = { type: 'end' };
 
-  class TrackballControls extends three$1.EventDispatcher {
+  const _EPS$2 = 0.000001;
+  const _STATE$1 = { NONE: - 1, ROTATE: 0, ZOOM: 1, PAN: 2, TOUCH_ROTATE: 3, TOUCH_ZOOM_PAN: 4 };
 
-  	constructor( object, domElement ) {
+  const _v2 = new three$1.Vector2();
+  const _mouseChange = new three$1.Vector2();
+  const _objectUp = new three$1.Vector3();
+  const _pan = new three$1.Vector3();
+  const _axis = new three$1.Vector3();
+  const _quaternion = new three$1.Quaternion();
+  const _eyeDirection = new three$1.Vector3();
+  const _objectUpDirection = new three$1.Vector3();
+  const _objectSidewaysDirection = new three$1.Vector3();
+  const _moveDirection = new three$1.Vector3();
 
-  		super();
+  class TrackballControls extends three$1.Controls {
 
-  		const scope = this;
-  		const STATE = { NONE: - 1, ROTATE: 0, ZOOM: 1, PAN: 2, TOUCH_ROTATE: 3, TOUCH_ZOOM_PAN: 4 };
+  	constructor( object, domElement = null ) {
 
-  		this.object = object;
-  		this.domElement = domElement;
-  		this.domElement.style.touchAction = 'none'; // disable touch scroll
+  		super( object, domElement );
 
   		// API
 
@@ -159,779 +165,773 @@
   		this.keys = [ 'KeyA' /*A*/, 'KeyS' /*S*/, 'KeyD' /*D*/ ];
 
   		this.mouseButtons = { LEFT: three$1.MOUSE.ROTATE, MIDDLE: three$1.MOUSE.DOLLY, RIGHT: three$1.MOUSE.PAN };
-
-  		// internals
+  		this.state = _STATE$1.NONE;
+  		this.keyState = _STATE$1.NONE;
 
   		this.target = new three$1.Vector3();
 
-  		const EPS = 0.000001;
+  		// internals
 
-  		const lastPosition = new three$1.Vector3();
-  		let lastZoom = 1;
+  		this._lastPosition = new three$1.Vector3();
+  		this._lastZoom = 1;
+  		this._touchZoomDistanceStart = 0;
+  		this._touchZoomDistanceEnd = 0;
+  		this._lastAngle = 0;
 
-  		let _state = STATE.NONE,
-  			_keyState = STATE.NONE,
+  		this._eye = new three$1.Vector3();
 
-  			_touchZoomDistanceStart = 0,
-  			_touchZoomDistanceEnd = 0,
+  		this._movePrev = new three$1.Vector2();
+  		this._moveCurr = new three$1.Vector2();
 
-  			_lastAngle = 0;
+  		this._lastAxis = new three$1.Vector3();
 
-  		const _eye = new three$1.Vector3(),
+  		this._zoomStart = new three$1.Vector2();
+  		this._zoomEnd = new three$1.Vector2();
 
-  			_movePrev = new three$1.Vector2(),
-  			_moveCurr = new three$1.Vector2(),
+  		this._panStart = new three$1.Vector2();
+  		this._panEnd = new three$1.Vector2();
 
-  			_lastAxis = new three$1.Vector3(),
+  		this._pointers = [];
+  		this._pointerPositions = {};
 
-  			_zoomStart = new three$1.Vector2(),
-  			_zoomEnd = new three$1.Vector2(),
+  		// event listeners
 
-  			_panStart = new three$1.Vector2(),
-  			_panEnd = new three$1.Vector2(),
+  		this._onPointerMove = onPointerMove$2.bind( this );
+  		this._onPointerDown = onPointerDown$2.bind( this );
+  		this._onPointerUp = onPointerUp$2.bind( this );
+  		this._onPointerCancel = onPointerCancel$1.bind( this );
+  		this._onContextMenu = onContextMenu$2.bind( this );
+  		this._onMouseWheel = onMouseWheel$1.bind( this );
+  		this._onKeyDown = onKeyDown$2.bind( this );
+  		this._onKeyUp = onKeyUp$1.bind( this );
 
-  			_pointers = [],
-  			_pointerPositions = {};
+  		this._onTouchStart = onTouchStart$1.bind( this );
+  		this._onTouchMove = onTouchMove$1.bind( this );
+  		this._onTouchEnd = onTouchEnd.bind( this );
 
-  		// for reset
+  		this._onMouseDown = onMouseDown$1.bind( this );
+  		this._onMouseMove = onMouseMove$1.bind( this );
+  		this._onMouseUp = onMouseUp.bind( this );
 
-  		this.target0 = this.target.clone();
-  		this.position0 = this.object.position.clone();
-  		this.up0 = this.object.up.clone();
-  		this.zoom0 = this.object.zoom;
-
-  		// methods
-
-  		this.handleResize = function () {
-
-  			const box = scope.domElement.getBoundingClientRect();
-  			// adjustments come from similar code in the jquery offset() function
-  			const d = scope.domElement.ownerDocument.documentElement;
-  			scope.screen.left = box.left + window.pageXOffset - d.clientLeft;
-  			scope.screen.top = box.top + window.pageYOffset - d.clientTop;
-  			scope.screen.width = box.width;
-  			scope.screen.height = box.height;
+  		// for reset
 
-  		};
+  		this._target0 = this.target.clone();
+  		this._position0 = this.object.position.clone();
+  		this._up0 = this.object.up.clone();
+  		this._zoom0 = this.object.zoom;
 
-  		const getMouseOnScreen = ( function () {
+  		if ( domElement !== null ) {
 
-  			const vector = new three$1.Vector2();
+  			this.connect();
 
-  			return function getMouseOnScreen( pageX, pageY ) {
+  			this.handleResize();
 
-  				vector.set(
-  					( pageX - scope.screen.left ) / scope.screen.width,
-  					( pageY - scope.screen.top ) / scope.screen.height
-  				);
+  		}
 
-  				return vector;
+  		// force an update at start
+  		this.update();
 
-  			};
+  	}
 
-  		}() );
+  	connect() {
 
-  		const getMouseOnCircle = ( function () {
+  		window.addEventListener( 'keydown', this._onKeyDown );
+  		window.addEventListener( 'keyup', this._onKeyUp );
 
-  			const vector = new three$1.Vector2();
+  		this.domElement.addEventListener( 'pointerdown', this._onPointerDown );
+  		this.domElement.addEventListener( 'pointercancel', this._onPointerCancel );
+  		this.domElement.addEventListener( 'wheel', this._onMouseWheel, { passive: false } );
+  		this.domElement.addEventListener( 'contextmenu', this._onContextMenu );
 
-  			return function getMouseOnCircle( pageX, pageY ) {
+  		this.domElement.style.touchAction = 'none'; // disable touch scroll
 
-  				vector.set(
-  					( ( pageX - scope.screen.width * 0.5 - scope.screen.left ) / ( scope.screen.width * 0.5 ) ),
-  					( ( scope.screen.height + 2 * ( scope.screen.top - pageY ) ) / scope.screen.width ) // screen.width intentional
-  				);
+  	}
 
-  				return vector;
+  	disconnect() {
 
-  			};
+  		window.removeEventListener( 'keydown', this._onKeyDown );
+  		window.removeEventListener( 'keyup', this._onKeyUp );
 
-  		}() );
+  		this.domElement.removeEventListener( 'pointerdown', this._onPointerDown );
+  		this.domElement.removeEventListener( 'pointermove', this._onPointerMove );
+  		this.domElement.removeEventListener( 'pointerup', this._onPointerUp );
+  		this.domElement.removeEventListener( 'pointercancel', this._onPointerCancel );
+  		this.domElement.removeEventListener( 'wheel', this._onMouseWheel );
+  		this.domElement.removeEventListener( 'contextmenu', this._onContextMenu );
 
-  		this.rotateCamera = ( function () {
+  		this.domElement.style.touchAction = 'auto'; // disable touch scroll
 
-  			const axis = new three$1.Vector3(),
-  				quaternion = new three$1.Quaternion(),
-  				eyeDirection = new three$1.Vector3(),
-  				objectUpDirection = new three$1.Vector3(),
-  				objectSidewaysDirection = new three$1.Vector3(),
-  				moveDirection = new three$1.Vector3();
+  	}
 
-  			return function rotateCamera() {
+  	dispose() {
 
-  				moveDirection.set( _moveCurr.x - _movePrev.x, _moveCurr.y - _movePrev.y, 0 );
-  				let angle = moveDirection.length();
+  		this.disconnect();
 
-  				if ( angle ) {
+  	}
 
-  					_eye.copy( scope.object.position ).sub( scope.target );
+  	handleResize() {
 
-  					eyeDirection.copy( _eye ).normalize();
-  					objectUpDirection.copy( scope.object.up ).normalize();
-  					objectSidewaysDirection.crossVectors( objectUpDirection, eyeDirection ).normalize();
+  		const box = this.domElement.getBoundingClientRect();
+  		// adjustments come from similar code in the jquery offset() function
+  		const d = this.domElement.ownerDocument.documentElement;
 
-  					objectUpDirection.setLength( _moveCurr.y - _movePrev.y );
-  					objectSidewaysDirection.setLength( _moveCurr.x - _movePrev.x );
+  		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;
 
-  					moveDirection.copy( objectUpDirection.add( objectSidewaysDirection ) );
+  	}
 
-  					axis.crossVectors( moveDirection, _eye ).normalize();
+  	update() {
 
-  					angle *= scope.rotateSpeed;
-  					quaternion.setFromAxisAngle( axis, angle );
+  		this._eye.subVectors( this.object.position, this.target );
 
-  					_eye.applyQuaternion( quaternion );
-  					scope.object.up.applyQuaternion( quaternion );
+  		if ( ! this.noRotate ) {
 
-  					_lastAxis.copy( axis );
-  					_lastAngle = angle;
+  			this._rotateCamera();
 
-  				} else if ( ! scope.staticMoving && _lastAngle ) {
+  		}
 
-  					_lastAngle *= Math.sqrt( 1.0 - scope.dynamicDampingFactor );
-  					_eye.copy( scope.object.position ).sub( scope.target );
-  					quaternion.setFromAxisAngle( _lastAxis, _lastAngle );
-  					_eye.applyQuaternion( quaternion );
-  					scope.object.up.applyQuaternion( quaternion );
+  		if ( ! this.noZoom ) {
 
-  				}
+  			this._zoomCamera();
 
-  				_movePrev.copy( _moveCurr );
+  		}
 
-  			};
+  		if ( ! this.noPan ) {
 
-  		}() );
+  			this._panCamera();
 
+  		}
 
-  		this.zoomCamera = function () {
+  		this.object.position.addVectors( this.target, this._eye );
 
-  			let factor;
+  		if ( this.object.isPerspectiveCamera ) {
 
-  			if ( _state === STATE.TOUCH_ZOOM_PAN ) {
+  			this._checkDistances();
 
-  				factor = _touchZoomDistanceStart / _touchZoomDistanceEnd;
-  				_touchZoomDistanceStart = _touchZoomDistanceEnd;
+  			this.object.lookAt( this.target );
 
-  				if ( scope.object.isPerspectiveCamera ) {
+  			if ( this._lastPosition.distanceToSquared( this.object.position ) > _EPS$2 ) {
 
-  					_eye.multiplyScalar( factor );
+  				this.dispatchEvent( _changeEvent$2 );
 
-  				} else if ( scope.object.isOrthographicCamera ) {
+  				this._lastPosition.copy( this.object.position );
 
-  					scope.object.zoom = three$1.MathUtils.clamp( scope.object.zoom / factor, scope.minZoom, scope.maxZoom );
+  			}
 
-  					if ( lastZoom !== scope.object.zoom ) {
+  		} else if ( this.object.isOrthographicCamera ) {
 
-  						scope.object.updateProjectionMatrix();
+  			this.object.lookAt( this.target );
 
-  					}
+  			if ( this._lastPosition.distanceToSquared( this.object.position ) > _EPS$2 || this._lastZoom !== this.object.zoom ) {
 
-  				} else {
+  				this.dispatchEvent( _changeEvent$2 );
 
-  					console.warn( 'THREE.TrackballControls: Unsupported camera type' );
+  				this._lastPosition.copy( this.object.position );
+  				this._lastZoom = this.object.zoom;
 
-  				}
+  			}
 
-  			} else {
+  		} else {
 
-  				factor = 1.0 + ( _zoomEnd.y - _zoomStart.y ) * scope.zoomSpeed;
+  			console.warn( 'THREE.TrackballControls: Unsupported camera type.' );
 
-  				if ( factor !== 1.0 && factor > 0.0 ) {
+  		}
 
-  					if ( scope.object.isPerspectiveCamera ) {
+  	}
 
-  						_eye.multiplyScalar( factor );
+  	reset() {
 
-  					} else if ( scope.object.isOrthographicCamera ) {
+  		this.state = _STATE$1.NONE;
+  		this.keyState = _STATE$1.NONE;
 
-  						scope.object.zoom = three$1.MathUtils.clamp( scope.object.zoom / factor, scope.minZoom, scope.maxZoom );
+  		this.target.copy( this._target0 );
+  		this.object.position.copy( this._position0 );
+  		this.object.up.copy( this._up0 );
+  		this.object.zoom = this._zoom0;
 
-  						if ( lastZoom !== scope.object.zoom ) {
+  		this.object.updateProjectionMatrix();
 
-  							scope.object.updateProjectionMatrix();
+  		this._eye.subVectors( this.object.position, this.target );
 
-  						}
+  		this.object.lookAt( this.target );
 
-  					} else {
+  		this.dispatchEvent( _changeEvent$2 );
 
-  						console.warn( 'THREE.TrackballControls: Unsupported camera type' );
+  		this._lastPosition.copy( this.object.position );
+  		this._lastZoom = this.object.zoom;
 
-  					}
+  	}
 
-  				}
+  	_panCamera() {
 
-  				if ( scope.staticMoving ) {
+  		_mouseChange.copy( this._panEnd ).sub( this._panStart );
 
-  					_zoomStart.copy( _zoomEnd );
+  		if ( _mouseChange.lengthSq() ) {
 
-  				} else {
+  			if ( this.object.isOrthographicCamera ) {
 
-  					_zoomStart.y += ( _zoomEnd.y - _zoomStart.y ) * this.dynamicDampingFactor;
+  				const scale_x = ( this.object.right - this.object.left ) / this.object.zoom / this.domElement.clientWidth;
+  				const scale_y = ( this.object.top - this.object.bottom ) / this.object.zoom / this.domElement.clientWidth;
 
-  				}
+  				_mouseChange.x *= scale_x;
+  				_mouseChange.y *= scale_y;
 
   			}
 
-  		};
+  			_mouseChange.multiplyScalar( this._eye.length() * this.panSpeed );
 
-  		this.panCamera = ( function () {
+  			_pan.copy( this._eye ).cross( this.object.up ).setLength( _mouseChange.x );
+  			_pan.add( _objectUp.copy( this.object.up ).setLength( _mouseChange.y ) );
 
-  			const mouseChange = new three$1.Vector2(),
-  				objectUp = new three$1.Vector3(),
-  				pan = new three$1.Vector3();
+  			this.object.position.add( _pan );
+  			this.target.add( _pan );
 
-  			return function panCamera() {
+  			if ( this.staticMoving ) {
 
-  				mouseChange.copy( _panEnd ).sub( _panStart );
+  				this._panStart.copy( this._panEnd );
 
-  				if ( mouseChange.lengthSq() ) {
-
-  					if ( scope.object.isOrthographicCamera ) {
-
-  						const scale_x = ( scope.object.right - scope.object.left ) / scope.object.zoom / scope.domElement.clientWidth;
-  						const scale_y = ( scope.object.top - scope.object.bottom ) / scope.object.zoom / scope.domElement.clientWidth;
+  			} else {
 
-  						mouseChange.x *= scale_x;
-  						mouseChange.y *= scale_y;
+  				this._panStart.add( _mouseChange.subVectors( this._panEnd, this._panStart ).multiplyScalar( this.dynamicDampingFactor ) );
 
-  					}
+  			}
 
-  					mouseChange.multiplyScalar( _eye.length() * scope.panSpeed );
+  		}
 
-  					pan.copy( _eye ).cross( scope.object.up ).setLength( mouseChange.x );
-  					pan.add( objectUp.copy( scope.object.up ).setLength( mouseChange.y ) );
+  	}
 
-  					scope.object.position.add( pan );
-  					scope.target.add( pan );
+  	_rotateCamera() {
 
-  					if ( scope.staticMoving ) {
+  		_moveDirection.set( this._moveCurr.x - this._movePrev.x, this._moveCurr.y - this._movePrev.y, 0 );
+  		let angle = _moveDirection.length();
 
-  						_panStart.copy( _panEnd );
+  		if ( angle ) {
 
-  					} else {
+  			this._eye.copy( this.object.position ).sub( this.target );
 
-  						_panStart.add( mouseChange.subVectors( _panEnd, _panStart ).multiplyScalar( scope.dynamicDampingFactor ) );
+  			_eyeDirection.copy( this._eye ).normalize();
+  			_objectUpDirection.copy( this.object.up ).normalize();
+  			_objectSidewaysDirection.crossVectors( _objectUpDirection, _eyeDirection ).normalize();
 
-  					}
+  			_objectUpDirection.setLength( this._moveCurr.y - this._movePrev.y );
+  			_objectSidewaysDirection.setLength( this._moveCurr.x - this._movePrev.x );
 
-  				}
+  			_moveDirection.copy( _objectUpDirection.add( _objectSidewaysDirection ) );
 
-  			};
+  			_axis.crossVectors( _moveDirection, this._eye ).normalize();
 
-  		}() );
+  			angle *= this.rotateSpeed;
+  			_quaternion.setFromAxisAngle( _axis, angle );
 
-  		this.checkDistances = function () {
+  			this._eye.applyQuaternion( _quaternion );
+  			this.object.up.applyQuaternion( _quaternion );
 
-  			if ( ! scope.noZoom || ! scope.noPan ) {
+  			this._lastAxis.copy( _axis );
+  			this._lastAngle = angle;
 
-  				if ( _eye.lengthSq() > scope.maxDistance * scope.maxDistance ) {
+  		} else if ( ! this.staticMoving && this._lastAngle ) {
 
-  					scope.object.position.addVectors( scope.target, _eye.setLength( scope.maxDistance ) );
-  					_zoomStart.copy( _zoomEnd );
+  			this._lastAngle *= Math.sqrt( 1.0 - this.dynamicDampingFactor );
+  			this._eye.copy( this.object.position ).sub( this.target );
+  			_quaternion.setFromAxisAngle( this._lastAxis, this._lastAngle );
+  			this._eye.applyQuaternion( _quaternion );
+  			this.object.up.applyQuaternion( _quaternion );
 
-  				}
+  		}
 
-  				if ( _eye.lengthSq() < scope.minDistance * scope.minDistance ) {
+  		this._movePrev.copy( this._moveCurr );
 
-  					scope.object.position.addVectors( scope.target, _eye.setLength( scope.minDistance ) );
-  					_zoomStart.copy( _zoomEnd );
+  	}
 
-  				}
+  	_zoomCamera() {
 
-  			}
+  		let factor;
 
-  		};
+  		if ( this.state === _STATE$1.TOUCH_ZOOM_PAN ) {
 
-  		this.update = function () {
+  			factor = this._touchZoomDistanceStart / this._touchZoomDistanceEnd;
+  			this._touchZoomDistanceStart = this._touchZoomDistanceEnd;
 
-  			_eye.subVectors( scope.object.position, scope.target );
+  			if ( this.object.isPerspectiveCamera ) {
 
-  			if ( ! scope.noRotate ) {
+  				this._eye.multiplyScalar( factor );
 
-  				scope.rotateCamera();
+  			} else if ( this.object.isOrthographicCamera ) {
 
-  			}
+  				this.object.zoom = three$1.MathUtils.clamp( this.object.zoom / factor, this.minZoom, this.maxZoom );
 
-  			if ( ! scope.noZoom ) {
+  				if ( this._lastZoom !== this.object.zoom ) {
 
-  				scope.zoomCamera();
+  					this.object.updateProjectionMatrix();
 
-  			}
+  				}
 
-  			if ( ! scope.noPan ) {
+  			} else {
 
-  				scope.panCamera();
+  				console.warn( 'THREE.TrackballControls: Unsupported camera type' );
 
   			}
 
-  			scope.object.position.addVectors( scope.target, _eye );
-
-  			if ( scope.object.isPerspectiveCamera ) {
+  		} else {
 
-  				scope.checkDistances();
+  			factor = 1.0 + ( this._zoomEnd.y - this._zoomStart.y ) * this.zoomSpeed;
 
-  				scope.object.lookAt( scope.target );
+  			if ( factor !== 1.0 && factor > 0.0 ) {
 
-  				if ( lastPosition.distanceToSquared( scope.object.position ) > EPS ) {
+  				if ( this.object.isPerspectiveCamera ) {
 
-  					scope.dispatchEvent( _changeEvent$2 );
+  					this._eye.multiplyScalar( factor );
 
-  					lastPosition.copy( scope.object.position );
+  				} else if ( this.object.isOrthographicCamera ) {
 
-  				}
+  					this.object.zoom = three$1.MathUtils.clamp( this.object.zoom / factor, this.minZoom, this.maxZoom );
 
-  			} else if ( scope.object.isOrthographicCamera ) {
+  					if ( this._lastZoom !== this.object.zoom ) {
 
-  				scope.object.lookAt( scope.target );
+  						this.object.updateProjectionMatrix();
 
-  				if ( lastPosition.distanceToSquared( scope.object.position ) > EPS || lastZoom !== scope.object.zoom ) {
+  					}
 
-  					scope.dispatchEvent( _changeEvent$2 );
+  				} else {
 
-  					lastPosition.copy( scope.object.position );
-  					lastZoom = scope.object.zoom;
+  					console.warn( 'THREE.TrackballControls: Unsupported camera type' );
 
   				}
 
-  			} else {
-
-  				console.warn( 'THREE.TrackballControls: Unsupported camera type' );
-
   			}
 
-  		};
+  			if ( this.staticMoving ) {
 
-  		this.reset = function () {
+  				this._zoomStart.copy( this._zoomEnd );
 
-  			_state = STATE.NONE;
-  			_keyState = STATE.NONE;
+  			} else {
 
-  			scope.target.copy( scope.target0 );
-  			scope.object.position.copy( scope.position0 );
-  			scope.object.up.copy( scope.up0 );
-  			scope.object.zoom = scope.zoom0;
+  				this._zoomStart.y += ( this._zoomEnd.y - this._zoomStart.y ) * this.dynamicDampingFactor;
 
-  			scope.object.updateProjectionMatrix();
+  			}
 
-  			_eye.subVectors( scope.object.position, scope.target );
+  		}
 
-  			scope.object.lookAt( scope.target );
+  	}
 
-  			scope.dispatchEvent( _changeEvent$2 );
+  	_getMouseOnScreen( pageX, pageY ) {
 
-  			lastPosition.copy( scope.object.position );
-  			lastZoom = scope.object.zoom;
+  		_v2.set(
+  			( pageX - this.screen.left ) / this.screen.width,
+  			( pageY - this.screen.top ) / this.screen.height
+  		);
 
-  		};
+  		return _v2;
 
-  		// listeners
+  	}
 
-  		function onPointerDown( event ) {
+  	_getMouseOnCircle( pageX, pageY ) {
 
-  			if ( scope.enabled === false ) return;
+  		_v2.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
+  		);
 
-  			if ( _pointers.length === 0 ) {
+  		return _v2;
 
-  				scope.domElement.setPointerCapture( event.pointerId );
+  	}
 
-  				scope.domElement.addEventListener( 'pointermove', onPointerMove );
-  				scope.domElement.addEventListener( 'pointerup', onPointerUp );
+  	_addPointer( event ) {
 
-  			}
+  		this._pointers.push( event );
 
-  			//
+  	}
 
-  			addPointer( event );
+  	_removePointer( event ) {
 
-  			if ( event.pointerType === 'touch' ) {
+  		delete this._pointerPositions[ event.pointerId ];
 
-  				onTouchStart( event );
+  		for ( let i = 0; i < this._pointers.length; i ++ ) {
 
-  			} else {
+  			if ( this._pointers[ i ].pointerId == event.pointerId ) {
 
-  				onMouseDown( event );
+  				this._pointers.splice( i, 1 );
+  				return;
 
   			}
 
   		}
 
-  		function onPointerMove( event ) {
-
-  			if ( scope.enabled === false ) return;
-
-  			if ( event.pointerType === 'touch' ) {
+  	}
 
-  				onTouchMove( event );
+  	_trackPointer( event ) {
 
-  			} else {
+  		let position = this._pointerPositions[ event.pointerId ];
 
-  				onMouseMove( event );
+  		if ( position === undefined ) {
 
-  			}
+  			position = new three$1.Vector2();
+  			this._pointerPositions[ event.pointerId ] = position;
 
   		}
 
-  		function onPointerUp( event ) {
+  		position.set( event.pageX, event.pageY );
 
-  			if ( scope.enabled === false ) return;
+  	}
 
-  			if ( event.pointerType === 'touch' ) {
+  	_getSecondPointerPosition( event ) {
 
-  				onTouchEnd( event );
+  		const pointer = ( event.pointerId === this._pointers[ 0 ].pointerId ) ? this._pointers[ 1 ] : this._pointers[ 0 ];
 
-  			} else {
+  		return this._pointerPositions[ pointer.pointerId ];
 
-  				onMouseUp();
+  	}
 
-  			}
+  	_checkDistances() {
 
-  			//
+  		if ( ! this.noZoom || ! this.noPan ) {
 
-  			removePointer( event );
+  			if ( this._eye.lengthSq() > this.maxDistance * this.maxDistance ) {
 
-  			if ( _pointers.length === 0 ) {
+  				this.object.position.addVectors( this.target, this._eye.setLength( this.maxDistance ) );
+  				this._zoomStart.copy( this._zoomEnd );
 
-  				scope.domElement.releasePointerCapture( event.pointerId );
+  			}
 
-  				scope.domElement.removeEventListener( 'pointermove', onPointerMove );
-  				scope.domElement.removeEventListener( 'pointerup', onPointerUp );
+  			if ( this._eye.lengthSq() < this.minDistance * this.minDistance ) {
 
-  			}
+  				this.object.position.addVectors( this.target, this._eye.setLength( this.minDistance ) );
+  				this._zoomStart.copy( this._zoomEnd );
 
+  			}
 
   		}
 
-  		function onPointerCancel( event ) {
+  	}
 
-  			removePointer( event );
+  }
 
-  		}
+  function onPointerDown$2( event ) {
 
-  		function keydown( event ) {
+  	if ( this.enabled === false ) return;
 
-  			if ( scope.enabled === false ) return;
+  	if ( this._pointers.length === 0 ) {
 
-  			window.removeEventListener( 'keydown', keydown );
+  		this.domElement.setPointerCapture( event.pointerId );
 
-  			if ( _keyState !== STATE.NONE ) {
+  		this.domElement.addEventListener( 'pointermove', this._onPointerMove );
+  		this.domElement.addEventListener( 'pointerup', this._onPointerUp );
 
-  				return;
+  	}
 
-  			} else if ( event.code === scope.keys[ STATE.ROTATE ] && ! scope.noRotate ) {
+  	//
 
-  				_keyState = STATE.ROTATE;
+  	this._addPointer( event );
 
-  			} else if ( event.code === scope.keys[ STATE.ZOOM ] && ! scope.noZoom ) {
+  	if ( event.pointerType === 'touch' ) {
 
-  				_keyState = STATE.ZOOM;
+  		this._onTouchStart( event );
 
-  			} else if ( event.code === scope.keys[ STATE.PAN ] && ! scope.noPan ) {
+  	} else {
 
-  				_keyState = STATE.PAN;
+  		this._onMouseDown( event );
 
-  			}
+  	}
 
-  		}
+  }
 
-  		function keyup() {
+  function onPointerMove$2( event ) {
 
-  			if ( scope.enabled === false ) return;
+  	if ( this.enabled === false ) return;
 
-  			_keyState = STATE.NONE;
+  	if ( event.pointerType === 'touch' ) {
 
-  			window.addEventListener( 'keydown', keydown );
+  		this._onTouchMove( event );
 
-  		}
+  	} else {
 
-  		function onMouseDown( event ) {
+  		this._onMouseMove( event );
 
-  			if ( _state === STATE.NONE ) {
+  	}
 
-  				switch ( event.button ) {
+  }
 
-  					case scope.mouseButtons.LEFT:
-  						_state = STATE.ROTATE;
-  						break;
+  function onPointerUp$2( event ) {
 
-  					case scope.mouseButtons.MIDDLE:
-  						_state = STATE.ZOOM;
-  						break;
+  	if ( this.enabled === false ) return;
 
-  					case scope.mouseButtons.RIGHT:
-  						_state = STATE.PAN;
-  						break;
+  	if ( event.pointerType === 'touch' ) {
 
-  				}
+  		this._onTouchEnd( event );
 
-  			}
+  	} else {
 
-  			const state = ( _keyState !== STATE.NONE ) ? _keyState : _state;
+  		this._onMouseUp();
 
-  			if ( state === STATE.ROTATE && ! scope.noRotate ) {
+  	}
 
-  				_moveCurr.copy( getMouseOnCircle( event.pageX, event.pageY ) );
-  				_movePrev.copy( _moveCurr );
+  	//
 
-  			} else if ( state === STATE.ZOOM && ! scope.noZoom ) {
+  	this._removePointer( event );
 
-  				_zoomStart.copy( getMouseOnScreen( event.pageX, event.pageY ) );
-  				_zoomEnd.copy( _zoomStart );
+  	if ( this._pointers.length === 0 ) {
 
-  			} else if ( state === STATE.PAN && ! scope.noPan ) {
+  		this.domElement.releasePointerCapture( event.pointerId );
 
-  				_panStart.copy( getMouseOnScreen( event.pageX, event.pageY ) );
-  				_panEnd.copy( _panStart );
+  		this.domElement.removeEventListener( 'pointermove', this._onPointerMove );
+  		this.domElement.removeEventListener( 'pointerup', this._onPointerUp );
 
-  			}
+  	}
 
-  			scope.dispatchEvent( _startEvent$1 );
+  }
 
-  		}
+  function onPointerCancel$1( event ) {
 
-  		function onMouseMove( event ) {
+  	this._removePointer( event );
 
-  			const state = ( _keyState !== STATE.NONE ) ? _keyState : _state;
+  }
 
-  			if ( state === STATE.ROTATE && ! scope.noRotate ) {
+  function onKeyUp$1() {
 
-  				_movePrev.copy( _moveCurr );
-  				_moveCurr.copy( getMouseOnCircle( event.pageX, event.pageY ) );
+  	if ( this.enabled === false ) return;
 
-  			} else if ( state === STATE.ZOOM && ! scope.noZoom ) {
+  	this.keyState = _STATE$1.NONE;
 
-  				_zoomEnd.copy( getMouseOnScreen( event.pageX, event.pageY ) );
+  	window.addEventListener( 'keydown', this._onKeyDown );
 
-  			} else if ( state === STATE.PAN && ! scope.noPan ) {
+  }
 
-  				_panEnd.copy( getMouseOnScreen( event.pageX, event.pageY ) );
+  function onKeyDown$2( event ) {
 
-  			}
+  	if ( this.enabled === false ) return;
 
-  		}
+  	window.removeEventListener( 'keydown', this._onKeyDown );
 
-  		function onMouseUp() {
+  	if ( this.keyState !== _STATE$1.NONE ) {
 
-  			_state = STATE.NONE;
+  		return;
 
-  			scope.dispatchEvent( _endEvent$1 );
+  	} else if ( event.code === this.keys[ _STATE$1.ROTATE ] && ! this.noRotate ) {
 
-  		}
+  		this.keyState = _STATE$1.ROTATE;
 
-  		function onMouseWheel( event ) {
+  	} else if ( event.code === this.keys[ _STATE$1.ZOOM ] && ! this.noZoom ) {
 
-  			if ( scope.enabled === false ) return;
+  		this.keyState = _STATE$1.ZOOM;
 
-  			if ( scope.noZoom === true ) return;
+  	} else if ( event.code === this.keys[ _STATE$1.PAN ] && ! this.noPan ) {
 
-  			event.preventDefault();
+  		this.keyState = _STATE$1.PAN;
 
-  			switch ( event.deltaMode ) {
+  	}
 
-  				case 2:
-  					// Zoom in pages
-  					_zoomStart.y -= event.deltaY * 0.025;
-  					break;
+  }
 
-  				case 1:
-  					// Zoom in lines
-  					_zoomStart.y -= event.deltaY * 0.01;
-  					break;
+  function onMouseDown$1( event ) {
 
-  				default:
-  					// undefined, 0, assume pixels
-  					_zoomStart.y -= event.deltaY * 0.00025;
-  					break;
+  	if ( this.state === _STATE$1.NONE ) {
 
-  			}
+  		switch ( event.button ) {
 
-  			scope.dispatchEvent( _startEvent$1 );
-  			scope.dispatchEvent( _endEvent$1 );
+  			case this.mouseButtons.LEFT:
+  				this.state = _STATE$1.ROTATE;
+  				break;
 
-  		}
+  			case this.mouseButtons.MIDDLE:
+  				this.state = _STATE$1.ZOOM;
+  				break;
 
-  		function onTouchStart( event ) {
+  			case this.mouseButtons.RIGHT:
+  				this.state = _STATE$1.PAN;
+  				break;
 
-  			trackPointer( event );
+  		}
 
-  			switch ( _pointers.length ) {
+  	}
 
-  				case 1:
-  					_state = STATE.TOUCH_ROTATE;
-  					_moveCurr.copy( getMouseOnCircle( _pointers[ 0 ].pageX, _pointers[ 0 ].pageY ) );
-  					_movePrev.copy( _moveCurr );
-  					break;
+  	const state = ( this.keyState !== _STATE$1.NONE ) ? this.keyState : this.state;
 
-  				default: // 2 or more
-  					_state = STATE.TOUCH_ZOOM_PAN;
-  					const dx = _pointers[ 0 ].pageX - _pointers[ 1 ].pageX;
-  					const dy = _pointers[ 0 ].pageY - _pointers[ 1 ].pageY;
-  					_touchZoomDistanceEnd = _touchZoomDistanceStart = Math.sqrt( dx * dx + dy * dy );
+  	if ( state === _STATE$1.ROTATE && ! this.noRotate ) {
 
-  					const x = ( _pointers[ 0 ].pageX + _pointers[ 1 ].pageX ) / 2;
-  					const y = ( _pointers[ 0 ].pageY + _pointers[ 1 ].pageY ) / 2;
-  					_panStart.copy( getMouseOnScreen( x, y ) );
-  					_panEnd.copy( _panStart );
-  					break;
+  		this._moveCurr.copy( this._getMouseOnCircle( event.pageX, event.pageY ) );
+  		this._movePrev.copy( this._moveCurr );
 
-  			}
+  	} else if ( state === _STATE$1.ZOOM && ! this.noZoom ) {
 
-  			scope.dispatchEvent( _startEvent$1 );
+  		this._zoomStart.copy( this._getMouseOnScreen( event.pageX, event.pageY ) );
+  		this._zoomEnd.copy( this._zoomStart );
 
-  		}
+  	} else if ( state === _STATE$1.PAN && ! this.noPan ) {
 
-  		function onTouchMove( event ) {
+  		this._panStart.copy( this._getMouseOnScreen( event.pageX, event.pageY ) );
+  		this._panEnd.copy( this._panStart );
 
-  			trackPointer( event );
+  	}
 
-  			switch ( _pointers.length ) {
+  	this.dispatchEvent( _startEvent$1 );
 
-  				case 1:
-  					_movePrev.copy( _moveCurr );
-  					_moveCurr.copy( getMouseOnCircle( event.pageX, event.pageY ) );
-  					break;
+  }
 
-  				default: // 2 or more
+  function onMouseMove$1( event ) {
 
-  					const position = getSecondPointerPosition( event );
+  	const state = ( this.keyState !== _STATE$1.NONE ) ? this.keyState : this.state;
 
-  					const dx = event.pageX - position.x;
-  					const dy = event.pageY - position.y;
-  					_touchZoomDistanceEnd = Math.sqrt( dx * dx + dy * dy );
+  	if ( state === _STATE$1.ROTATE && ! this.noRotate ) {
 
-  					const x = ( event.pageX + position.x ) / 2;
-  					const y = ( event.pageY + position.y ) / 2;
-  					_panEnd.copy( getMouseOnScreen( x, y ) );
-  					break;
+  		this._movePrev.copy( this._moveCurr );
+  		this._moveCurr.copy( this._getMouseOnCircle( event.pageX, event.pageY ) );
 
-  			}
+  	} else if ( state === _STATE$1.ZOOM && ! this.noZoom ) {
 
-  		}
+  		this._zoomEnd.copy( this._getMouseOnScreen( event.pageX, event.pageY ) );
 
-  		function onTouchEnd( event ) {
+  	} else if ( state === _STATE$1.PAN && ! this.noPan ) {
 
-  			switch ( _pointers.length ) {
+  		this._panEnd.copy( this._getMouseOnScreen( event.pageX, event.pageY ) );
 
-  				case 0:
-  					_state = STATE.NONE;
-  					break;
+  	}
 
-  				case 1:
-  					_state = STATE.TOUCH_ROTATE;
-  					_moveCurr.copy( getMouseOnCircle( event.pageX, event.pageY ) );
-  					_movePrev.copy( _moveCurr );
-  					break;
+  }
 
-  				case 2:
-  					_state = STATE.TOUCH_ZOOM_PAN;
+  function onMouseUp() {
 
-  					for ( let i = 0; i < _pointers.length; i ++ ) {
+  	this.state = _STATE$1.NONE;
 
-  						if ( _pointers[ i ].pointerId !== event.pointerId ) {
+  	this.dispatchEvent( _endEvent$1 );
 
-  							const position = _pointerPositions[ _pointers[ i ].pointerId ];
-  							_moveCurr.copy( getMouseOnCircle( position.x, position.y ) );
-  							_movePrev.copy( _moveCurr );
-  							break;
+  }
 
-  						}
+  function onMouseWheel$1( event ) {
 
-  					}
+  	if ( this.enabled === false ) return;
 
-  					break;
+  	if ( this.noZoom === true ) return;
 
-  			}
+  	event.preventDefault();
 
-  			scope.dispatchEvent( _endEvent$1 );
+  	switch ( event.deltaMode ) {
 
-  		}
+  		case 2:
+  			// Zoom in pages
+  			this._zoomStart.y -= event.deltaY * 0.025;
+  			break;
 
-  		function contextmenu( event ) {
+  		case 1:
+  			// Zoom in lines
+  			this._zoomStart.y -= event.deltaY * 0.01;
+  			break;
 
-  			if ( scope.enabled === false ) return;
+  		default:
+  			// undefined, 0, assume pixels
+  			this._zoomStart.y -= event.deltaY * 0.00025;
+  			break;
 
-  			event.preventDefault();
+  	}
 
-  		}
+  	this.dispatchEvent( _startEvent$1 );
+  	this.dispatchEvent( _endEvent$1 );
 
-  		function addPointer( event ) {
+  }
 
-  			_pointers.push( event );
+  function onContextMenu$2( event ) {
 
-  		}
+  	if ( this.enabled === false ) return;
 
-  		function removePointer( event ) {
+  	event.preventDefault();
 
-  			delete _pointerPositions[ event.pointerId ];
+  }
 
-  			for ( let i = 0; i < _pointers.length; i ++ ) {
+  function onTouchStart$1( event ) {
 
-  				if ( _pointers[ i ].pointerId == event.pointerId ) {
+  	this._trackPointer( event );
 
-  					_pointers.splice( i, 1 );
-  					return;
+  	switch ( this._pointers.length ) {
 
-  				}
+  		case 1:
+  			this.state = _STATE$1.TOUCH_ROTATE;
+  			this._moveCurr.copy( this._getMouseOnCircle( this._pointers[ 0 ].pageX, this._pointers[ 0 ].pageY ) );
+  			this._movePrev.copy( this._moveCurr );
+  			break;
 
-  			}
+  		default: // 2 or more
+  			this.state = _STATE$1.TOUCH_ZOOM_PAN;
+  			const dx = this._pointers[ 0 ].pageX - this._pointers[ 1 ].pageX;
+  			const dy = this._pointers[ 0 ].pageY - this._pointers[ 1 ].pageY;
+  			this._touchZoomDistanceEnd = this._touchZoomDistanceStart = Math.sqrt( dx * dx + dy * dy );
 
-  		}
+  			const x = ( this._pointers[ 0 ].pageX + this._pointers[ 1 ].pageX ) / 2;
+  			const y = ( this._pointers[ 0 ].pageY + this._pointers[ 1 ].pageY ) / 2;
+  			this._panStart.copy( this._getMouseOnScreen( x, y ) );
+  			this._panEnd.copy( this._panStart );
+  			break;
 
-  		function trackPointer( event ) {
+  	}
 
-  			let position = _pointerPositions[ event.pointerId ];
+  	this.dispatchEvent( _startEvent$1 );
 
-  			if ( position === undefined ) {
+  }
 
-  				position = new three$1.Vector2();
-  				_pointerPositions[ event.pointerId ] = position;
+  function onTouchMove$1( event ) {
 
-  			}
+  	this._trackPointer( event );
 
-  			position.set( event.pageX, event.pageY );
+  	switch ( this._pointers.length ) {
 
-  		}
+  		case 1:
+  			this._movePrev.copy( this._moveCurr );
+  			this._moveCurr.copy( this._getMouseOnCircle( event.pageX, event.pageY ) );
+  			break;
 
-  		function getSecondPointerPosition( event ) {
+  		default: // 2 or more
 
-  			const pointer = ( event.pointerId === _pointers[ 0 ].pointerId ) ? _pointers[ 1 ] : _pointers[ 0 ];
+  			const position = this._getSecondPointerPosition( event );
 
-  			return _pointerPositions[ pointer.pointerId ];
+  			const dx = event.pageX - position.x;
+  			const dy = event.pageY - position.y;
+  			this._touchZoomDistanceEnd = Math.sqrt( dx * dx + dy * dy );
 
-  		}
+  			const x = ( event.pageX + position.x ) / 2;
+  			const y = ( event.pageY + position.y ) / 2;
+  			this._panEnd.copy( this._getMouseOnScreen( x, y ) );
+  			break;
 
-  		this.dispose = function () {
+  	}
 
-  			scope.domElement.removeEventListener( 'contextmenu', contextmenu );
+  }
 
-  			scope.domElement.removeEventListener( 'pointerdown', onPointerDown );
-  			scope.domElement.removeEventListener( 'pointercancel', onPointerCancel );
-  			scope.domElement.removeEventListener( 'wheel', onMouseWheel );
+  function onTouchEnd( event ) {
 
-  			scope.domElement.removeEventListener( 'pointermove', onPointerMove );
-  			scope.domElement.removeEventListener( 'pointerup', onPointerUp );
+  	switch ( this._pointers.length ) {
 
-  			window.removeEventListener( 'keydown', keydown );
-  			window.removeEventListener( 'keyup', keyup );
+  		case 0:
+  			this.state = _STATE$1.NONE;
+  			break;
 
-  		};
+  		case 1:
+  			this.state = _STATE$1.TOUCH_ROTATE;
+  			this._moveCurr.copy( this._getMouseOnCircle( event.pageX, event.pageY ) );
+  			this._movePrev.copy( this._moveCurr );
+  			break;
+
+  		case 2:
+  			this.state = _STATE$1.TOUCH_ZOOM_PAN;
 
-  		this.domElement.addEventListener( 'contextmenu', contextmenu );
+  			for ( let i = 0; i < this._pointers.length; i ++ ) {
 
-  		this.domElement.addEventListener( 'pointerdown', onPointerDown );
-  		this.domElement.addEventListener( 'pointercancel', onPointerCancel );
-  		this.domElement.addEventListener( 'wheel', onMouseWheel, { passive: false } );
+  				if ( this._pointers[ i ].pointerId !== event.pointerId ) {
 
+  					const position = this._pointerPositions[ this._pointers[ i ].pointerId ];
+  					this._moveCurr.copy( this._getMouseOnCircle( position.x, position.y ) );
+  					this._movePrev.copy( this._moveCurr );
+  					break;
 
-  		window.addEventListener( 'keydown', keydown );
-  		window.addEventListener( 'keyup', keyup );
+  				}
 
-  		this.handleResize();
+  			}
 
-  		// force an update at start
-  		this.update();
+  			break;
 
   	}
 
+  	this.dispatchEvent( _endEvent$1 );
+
   }
 
   // OrbitControls performs orbiting, dollying (zooming), and panning.
@@ -946,17 +946,30 @@
   const _endEvent = { type: 'end' };
   const _ray = new three$1.Ray();
   const _plane = new three$1.Plane();
-  const TILT_LIMIT = Math.cos( 70 * three$1.MathUtils.DEG2RAD );
+  const _TILT_LIMIT = Math.cos( 70 * three$1.MathUtils.DEG2RAD );
+
+  const _v = new three$1.Vector3();
+  const _twoPI = 2 * Math.PI;
+
+  const _STATE = {
+  	NONE: - 1,
+  	ROTATE: 0,
+  	DOLLY: 1,
+  	PAN: 2,
+  	TOUCH_ROTATE: 3,
+  	TOUCH_PAN: 4,
+  	TOUCH_DOLLY_PAN: 5,
+  	TOUCH_DOLLY_ROTATE: 6
+  };
+  const _EPS$1 = 0.000001;
 
-  class OrbitControls extends three$1.EventDispatcher {
+  class OrbitControls extends three$1.Controls {
 
-  	constructor( object, domElement ) {
+  	constructor( object, domElement = null ) {
 
-  		super();
+  		super( object, domElement );
 
-  		this.object = object;
-  		this.domElement = domElement;
-  		this.domElement.style.touchAction = 'none'; // disable touch scroll
+  		this.state = _STATE.NONE;
 
   		// Set to false to disable this control
   		this.enabled = true;
@@ -1032,1421 +1045,1399 @@
   		// the target DOM element for key events
   		this._domElementKeyEvents = null;
 
-  		//
-  		// public methods
-  		//
+  		// internals
 
-  		this.getPolarAngle = function () {
+  		this._lastPosition = new three$1.Vector3();
+  		this._lastQuaternion = new three$1.Quaternion();
+  		this._lastTargetPosition = new three$1.Vector3();
 
-  			return spherical.phi;
+  		// so camera.up is the orbit axis
+  		this._quat = new three$1.Quaternion().setFromUnitVectors( object.up, new three$1.Vector3( 0, 1, 0 ) );
+  		this._quatInverse = this._quat.clone().invert();
 
-  		};
+  		// current position in spherical coordinates
+  		this._spherical = new three$1.Spherical();
+  		this._sphericalDelta = new three$1.Spherical();
 
-  		this.getAzimuthalAngle = function () {
+  		this._scale = 1;
+  		this._panOffset = new three$1.Vector3();
 
-  			return spherical.theta;
+  		this._rotateStart = new three$1.Vector2();
+  		this._rotateEnd = new three$1.Vector2();
+  		this._rotateDelta = new three$1.Vector2();
 
-  		};
+  		this._panStart = new three$1.Vector2();
+  		this._panEnd = new three$1.Vector2();
+  		this._panDelta = new three$1.Vector2();
 
-  		this.getDistance = function () {
+  		this._dollyStart = new three$1.Vector2();
+  		this._dollyEnd = new three$1.Vector2();
+  		this._dollyDelta = new three$1.Vector2();
 
-  			return this.object.position.distanceTo( this.target );
+  		this._dollyDirection = new three$1.Vector3();
+  		this._mouse = new three$1.Vector2();
+  		this._performCursorZoom = false;
 
-  		};
+  		this._pointers = [];
+  		this._pointerPositions = {};
 
-  		this.listenToKeyEvents = function ( domElement ) {
+  		this._controlActive = false;
 
-  			domElement.addEventListener( 'keydown', onKeyDown );
-  			this._domElementKeyEvents = domElement;
+  		// event listeners
 
-  		};
+  		this._onPointerMove = onPointerMove$1.bind( this );
+  		this._onPointerDown = onPointerDown$1.bind( this );
+  		this._onPointerUp = onPointerUp$1.bind( this );
+  		this._onContextMenu = onContextMenu$1.bind( this );
+  		this._onMouseWheel = onMouseWheel.bind( this );
+  		this._onKeyDown = onKeyDown$1.bind( this );
 
-  		this.stopListenToKeyEvents = function () {
+  		this._onTouchStart = onTouchStart.bind( this );
+  		this._onTouchMove = onTouchMove.bind( this );
 
-  			this._domElementKeyEvents.removeEventListener( 'keydown', onKeyDown );
-  			this._domElementKeyEvents = null;
+  		this._onMouseDown = onMouseDown.bind( this );
+  		this._onMouseMove = onMouseMove.bind( this );
 
-  		};
+  		this._interceptControlDown = interceptControlDown.bind( this );
+  		this._interceptControlUp = interceptControlUp.bind( this );
 
-  		this.saveState = function () {
+  		//
 
-  			scope.target0.copy( scope.target );
-  			scope.position0.copy( scope.object.position );
-  			scope.zoom0 = scope.object.zoom;
+  		if ( this.domElement !== null ) {
 
-  		};
+  			this.connect();
 
-  		this.reset = function () {
+  		}
 
-  			scope.target.copy( scope.target0 );
-  			scope.object.position.copy( scope.position0 );
-  			scope.object.zoom = scope.zoom0;
+  		this.update();
 
-  			scope.object.updateProjectionMatrix();
-  			scope.dispatchEvent( _changeEvent$1 );
+  	}
 
-  			scope.update();
+  	connect() {
 
-  			state = STATE.NONE;
+  		this.domElement.addEventListener( 'pointerdown', this._onPointerDown );
+  		this.domElement.addEventListener( 'pointercancel', this._onPointerUp );
 
-  		};
+  		this.domElement.addEventListener( 'contextmenu', this._onContextMenu );
+  		this.domElement.addEventListener( 'wheel', this._onMouseWheel, { passive: false } );
 
-  		// this method is exposed, but perhaps it would be better if we can make it private...
-  		this.update = function () {
+  		const document = this.domElement.getRootNode(); // offscreen canvas compatibility
+  		document.addEventListener( 'keydown', this._interceptControlDown, { passive: true, capture: true } );
 
-  			const offset = new three$1.Vector3();
+  		this.domElement.style.touchAction = 'none'; // disable touch scroll
 
-  			// so camera.up is the orbit axis
-  			const quat = new three$1.Quaternion().setFromUnitVectors( object.up, new three$1.Vector3( 0, 1, 0 ) );
-  			const quatInverse = quat.clone().invert();
+  	}
 
-  			const lastPosition = new three$1.Vector3();
-  			const lastQuaternion = new three$1.Quaternion();
-  			const lastTargetPosition = new three$1.Vector3();
+  	disconnect() {
 
-  			const twoPI = 2 * Math.PI;
+  		this.domElement.removeEventListener( 'pointerdown', this._onPointerDown );
+  		this.domElement.removeEventListener( 'pointermove', this._onPointerMove );
+  		this.domElement.removeEventListener( 'pointerup', this._onPointerUp );
+  		this.domElement.removeEventListener( 'pointercancel', this._onPointerUp );
 
-  			return function update( deltaTime = null ) {
+  		this.domElement.removeEventListener( 'wheel', this._onMouseWheel );
+  		this.domElement.removeEventListener( 'contextmenu', this._onContextMenu );
 
-  				const position = scope.object.position;
+  		this.stopListenToKeyEvents();
 
-  				offset.copy( position ).sub( scope.target );
+  		const document = this.domElement.getRootNode(); // offscreen canvas compatibility
+  		document.removeEventListener( 'keydown', this._interceptControlDown, { capture: true } );
 
-  				// rotate offset to "y-axis-is-up" space
-  				offset.applyQuaternion( quat );
+  		this.domElement.style.touchAction = 'auto';
 
-  				// angle from z-axis around y-axis
-  				spherical.setFromVector3( offset );
+  	}
 
-  				if ( scope.autoRotate && state === STATE.NONE ) {
+  	dispose() {
 
-  					rotateLeft( getAutoRotationAngle( deltaTime ) );
+  		this.disconnect();
 
-  				}
+  	}
 
-  				if ( scope.enableDamping ) {
+  	getPolarAngle() {
 
-  					spherical.theta += sphericalDelta.theta * scope.dampingFactor;
-  					spherical.phi += sphericalDelta.phi * scope.dampingFactor;
+  		return this._spherical.phi;
 
-  				} else {
+  	}
 
-  					spherical.theta += sphericalDelta.theta;
-  					spherical.phi += sphericalDelta.phi;
+  	getAzimuthalAngle() {
 
-  				}
+  		return this._spherical.theta;
 
-  				// restrict theta to be between desired limits
+  	}
 
-  				let min = scope.minAzimuthAngle;
-  				let max = scope.maxAzimuthAngle;
+  	getDistance() {
 
-  				if ( isFinite( min ) && isFinite( max ) ) {
+  		return this.object.position.distanceTo( this.target );
 
-  					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;
+  	listenToKeyEvents( domElement ) {
 
-  					if ( min <= max ) {
+  		domElement.addEventListener( 'keydown', this._onKeyDown );
+  		this._domElementKeyEvents = domElement;
 
-  						spherical.theta = Math.max( min, Math.min( max, spherical.theta ) );
+  	}
 
-  					} else {
+  	stopListenToKeyEvents() {
 
-  						spherical.theta = ( spherical.theta > ( min + max ) / 2 ) ?
-  							Math.max( min, spherical.theta ) :
-  							Math.min( max, spherical.theta );
+  		if ( this._domElementKeyEvents !== null ) {
 
-  					}
+  			this._domElementKeyEvents.removeEventListener( 'keydown', this._onKeyDown );
+  			this._domElementKeyEvents = null;
 
-  				}
+  		}
 
-  				// restrict phi to be between desired limits
-  				spherical.phi = Math.max( scope.minPolarAngle, Math.min( scope.maxPolarAngle, spherical.phi ) );
+  	}
 
-  				spherical.makeSafe();
+  	saveState() {
 
+  		this.target0.copy( this.target );
+  		this.position0.copy( this.object.position );
+  		this.zoom0 = this.object.zoom;
 
-  				// move target to panned location
+  	}
 
-  				if ( scope.enableDamping === true ) {
+  	reset() {
 
-  					scope.target.addScaledVector( panOffset, scope.dampingFactor );
+  		this.target.copy( this.target0 );
+  		this.object.position.copy( this.position0 );
+  		this.object.zoom = this.zoom0;
 
-  				} else {
+  		this.object.updateProjectionMatrix();
+  		this.dispatchEvent( _changeEvent$1 );
 
-  					scope.target.add( panOffset );
+  		this.update();
 
-  				}
+  		this.state = _STATE.NONE;
 
-  				// Limit the target distance from the cursor to create a sphere around the center of interest
-  				scope.target.sub( scope.cursor );
-  				scope.target.clampLength( scope.minTargetRadius, scope.maxTargetRadius );
-  				scope.target.add( scope.cursor );
+  	}
 
-  				let zoomChanged = false;
-  				// adjust the camera position based on zoom only if we're not zooming to the cursor or if it's an ortho camera
-  				// we adjust zoom later in these cases
-  				if ( scope.zoomToCursor && performCursorZoom || scope.object.isOrthographicCamera ) {
+  	update( deltaTime = null ) {
 
-  					spherical.radius = clampDistance( spherical.radius );
+  		const position = this.object.position;
 
-  				} else {
+  		_v.copy( position ).sub( this.target );
 
-  					const prevRadius = spherical.radius;
-  					spherical.radius = clampDistance( spherical.radius * scale );
-  					zoomChanged = prevRadius != spherical.radius;
+  		// rotate offset to "y-axis-is-up" space
+  		_v.applyQuaternion( this._quat );
 
-  				}
+  		// angle from z-axis around y-axis
+  		this._spherical.setFromVector3( _v );
 
-  				offset.setFromSpherical( spherical );
+  		if ( this.autoRotate && this.state === _STATE.NONE ) {
 
-  				// rotate offset back to "camera-up-vector-is-up" space
-  				offset.applyQuaternion( quatInverse );
+  			this._rotateLeft( this._getAutoRotationAngle( deltaTime ) );
 
-  				position.copy( scope.target ).add( offset );
+  		}
 
-  				scope.object.lookAt( scope.target );
+  		if ( this.enableDamping ) {
 
-  				if ( scope.enableDamping === true ) {
+  			this._spherical.theta += this._sphericalDelta.theta * this.dampingFactor;
+  			this._spherical.phi += this._sphericalDelta.phi * this.dampingFactor;
 
-  					sphericalDelta.theta *= ( 1 - scope.dampingFactor );
-  					sphericalDelta.phi *= ( 1 - scope.dampingFactor );
+  		} else {
 
-  					panOffset.multiplyScalar( 1 - scope.dampingFactor );
+  			this._spherical.theta += this._sphericalDelta.theta;
+  			this._spherical.phi += this._sphericalDelta.phi;
 
-  				} else {
+  		}
 
-  					sphericalDelta.set( 0, 0, 0 );
+  		// restrict theta to be between desired limits
 
-  					panOffset.set( 0, 0, 0 );
+  		let min = this.minAzimuthAngle;
+  		let max = this.maxAzimuthAngle;
 
-  				}
+  		if ( isFinite( min ) && isFinite( max ) ) {
 
-  				// adjust camera position
-  				if ( scope.zoomToCursor && performCursorZoom ) {
+  			if ( min < - Math.PI ) min += _twoPI; else if ( min > Math.PI ) min -= _twoPI;
 
-  					let newRadius = null;
-  					if ( scope.object.isPerspectiveCamera ) {
+  			if ( max < - Math.PI ) max += _twoPI; else if ( max > Math.PI ) max -= _twoPI;
 
-  						// move the camera down the pointer ray
-  						// this method avoids floating point error
-  						const prevRadius = offset.length();
-  						newRadius = clampDistance( prevRadius * scale );
+  			if ( min <= max ) {
 
-  						const radiusDelta = prevRadius - newRadius;
-  						scope.object.position.addScaledVector( dollyDirection, radiusDelta );
-  						scope.object.updateMatrixWorld();
+  				this._spherical.theta = Math.max( min, Math.min( max, this._spherical.theta ) );
 
-  						zoomChanged = !! radiusDelta;
+  			} else {
 
-  					} else if ( scope.object.isOrthographicCamera ) {
+  				this._spherical.theta = ( this._spherical.theta > ( min + max ) / 2 ) ?
+  					Math.max( min, this._spherical.theta ) :
+  					Math.min( max, this._spherical.theta );
 
-  						// adjust the ortho camera position based on zoom changes
-  						const mouseBefore = new three$1.Vector3( mouse.x, mouse.y, 0 );
-  						mouseBefore.unproject( scope.object );
+  			}
 
-  						const prevZoom = scope.object.zoom;
-  						scope.object.zoom = Math.max( scope.minZoom, Math.min( scope.maxZoom, scope.object.zoom / scale ) );
-  						scope.object.updateProjectionMatrix();
+  		}
 
-  						zoomChanged = prevZoom !== scope.object.zoom;
+  		// restrict phi to be between desired limits
+  		this._spherical.phi = Math.max( this.minPolarAngle, Math.min( this.maxPolarAngle, this._spherical.phi ) );
 
-  						const mouseAfter = new three$1.Vector3( mouse.x, mouse.y, 0 );
-  						mouseAfter.unproject( scope.object );
+  		this._spherical.makeSafe();
 
-  						scope.object.position.sub( mouseAfter ).add( mouseBefore );
-  						scope.object.updateMatrixWorld();
 
-  						newRadius = offset.length();
+  		// move target to panned location
 
-  					} else {
+  		if ( this.enableDamping === true ) {
 
-  						console.warn( 'WARNING: OrbitControls.js encountered an unknown camera type - zoom to cursor disabled.' );
-  						scope.zoomToCursor = false;
+  			this.target.addScaledVector( this._panOffset, this.dampingFactor );
 
-  					}
+  		} else {
+
+  			this.target.add( this._panOffset );
 
-  					// handle the placement of the target
-  					if ( newRadius !== null ) {
+  		}
 
-  						if ( this.screenSpacePanning ) {
+  		// Limit the target distance from the cursor to create a sphere around the center of interest
+  		this.target.sub( this.cursor );
+  		this.target.clampLength( this.minTargetRadius, this.maxTargetRadius );
+  		this.target.add( this.cursor );
 
-  							// position the orbit target in front of the new camera position
-  							scope.target.set( 0, 0, - 1 )
-  								.transformDirection( scope.object.matrix )
-  								.multiplyScalar( newRadius )
-  								.add( scope.object.position );
+  		let zoomChanged = false;
+  		// adjust the camera position based on zoom only if we're not zooming to the cursor or if it's an ortho camera
+  		// we adjust zoom later in these cases
+  		if ( this.zoomToCursor && this._performCursorZoom || this.object.isOrthographicCamera ) {
 
-  						} else {
+  			this._spherical.radius = this._clampDistance( this._spherical.radius );
 
-  							// get the ray and translation plane to compute target
-  							_ray.origin.copy( scope.object.position );
-  							_ray.direction.set( 0, 0, - 1 ).transformDirection( scope.object.matrix );
+  		} else {
 
-  							// if the camera is 20 degrees above the horizon then don't adjust the focus target to avoid
-  							// extremely large values
-  							if ( Math.abs( scope.object.up.dot( _ray.direction ) ) < TILT_LIMIT ) {
+  			const prevRadius = this._spherical.radius;
+  			this._spherical.radius = this._clampDistance( this._spherical.radius * this._scale );
+  			zoomChanged = prevRadius != this._spherical.radius;
 
-  								object.lookAt( scope.target );
+  		}
 
-  							} else {
+  		_v.setFromSpherical( this._spherical );
 
-  								_plane.setFromNormalAndCoplanarPoint( scope.object.up, scope.target );
-  								_ray.intersectPlane( _plane, scope.target );
+  		// rotate offset back to "camera-up-vector-is-up" space
+  		_v.applyQuaternion( this._quatInverse );
 
-  							}
+  		position.copy( this.target ).add( _v );
 
-  						}
+  		this.object.lookAt( this.target );
 
-  					}
+  		if ( this.enableDamping === true ) {
 
-  				} else if ( scope.object.isOrthographicCamera ) {
+  			this._sphericalDelta.theta *= ( 1 - this.dampingFactor );
+  			this._sphericalDelta.phi *= ( 1 - this.dampingFactor );
 
-  					const prevZoom = scope.object.zoom;
-  					scope.object.zoom = Math.max( scope.minZoom, Math.min( scope.maxZoom, scope.object.zoom / scale ) );
+  			this._panOffset.multiplyScalar( 1 - this.dampingFactor );
 
-  					if ( prevZoom !== scope.object.zoom ) {
+  		} else {
 
-  						scope.object.updateProjectionMatrix();
-  						zoomChanged = true;
+  			this._sphericalDelta.set( 0, 0, 0 );
 
-  					}
+  			this._panOffset.set( 0, 0, 0 );
 
-  				}
+  		}
 
-  				scale = 1;
-  				performCursorZoom = false;
+  		// adjust camera position
+  		if ( this.zoomToCursor && this._performCursorZoom ) {
 
-  				// update condition is:
-  				// min(camera displacement, camera rotation in radians)^2 > EPS
-  				// using small-angle approximation cos(x/2) = 1 - x^2 / 8
+  			let newRadius = null;
+  			if ( this.object.isPerspectiveCamera ) {
 
-  				if ( zoomChanged ||
-  					lastPosition.distanceToSquared( scope.object.position ) > EPS ||
-  					8 * ( 1 - lastQuaternion.dot( scope.object.quaternion ) ) > EPS ||
-  					lastTargetPosition.distanceToSquared( scope.target ) > EPS ) {
+  				// move the camera down the pointer ray
+  				// this method avoids floating point error
+  				const prevRadius = _v.length();
+  				newRadius = this._clampDistance( prevRadius * this._scale );
 
-  					scope.dispatchEvent( _changeEvent$1 );
+  				const radiusDelta = prevRadius - newRadius;
+  				this.object.position.addScaledVector( this._dollyDirection, radiusDelta );
+  				this.object.updateMatrixWorld();
 
-  					lastPosition.copy( scope.object.position );
-  					lastQuaternion.copy( scope.object.quaternion );
-  					lastTargetPosition.copy( scope.target );
+  				zoomChanged = !! radiusDelta;
 
-  					return true;
+  			} else if ( this.object.isOrthographicCamera ) {
 
-  				}
+  				// adjust the ortho camera position based on zoom changes
+  				const mouseBefore = new three$1.Vector3( this._mouse.x, this._mouse.y, 0 );
+  				mouseBefore.unproject( this.object );
 
-  				return false;
+  				const prevZoom = this.object.zoom;
+  				this.object.zoom = Math.max( this.minZoom, Math.min( this.maxZoom, this.object.zoom / this._scale ) );
+  				this.object.updateProjectionMatrix();
 
-  			};
+  				zoomChanged = prevZoom !== this.object.zoom;
 
-  		}();
+  				const mouseAfter = new three$1.Vector3( this._mouse.x, this._mouse.y, 0 );
+  				mouseAfter.unproject( this.object );
 
-  		this.dispose = function () {
+  				this.object.position.sub( mouseAfter ).add( mouseBefore );
+  				this.object.updateMatrixWorld();
 
-  			scope.domElement.removeEventListener( 'contextmenu', onContextMenu );
+  				newRadius = _v.length();
 
-  			scope.domElement.removeEventListener( 'pointerdown', onPointerDown );
-  			scope.domElement.removeEventListener( 'pointercancel', onPointerUp );
-  			scope.domElement.removeEventListener( 'wheel', onMouseWheel );
+  			} else {
 
-  			scope.domElement.removeEventListener( 'pointermove', onPointerMove );
-  			scope.domElement.removeEventListener( 'pointerup', onPointerUp );
+  				console.warn( 'WARNING: OrbitControls.js encountered an unknown camera type - zoom to cursor disabled.' );
+  				this.zoomToCursor = false;
 
-  			const document = scope.domElement.getRootNode(); // offscreen canvas compatibility
+  			}
 
-  			document.removeEventListener( 'keydown', interceptControlDown, { capture: true } );
+  			// handle the placement of the target
+  			if ( newRadius !== null ) {
 
-  			if ( scope._domElementKeyEvents !== null ) {
+  				if ( this.screenSpacePanning ) {
 
-  				scope._domElementKeyEvents.removeEventListener( 'keydown', onKeyDown );
-  				scope._domElementKeyEvents = null;
+  					// position the orbit target in front of the new camera position
+  					this.target.set( 0, 0, - 1 )
+  						.transformDirection( this.object.matrix )
+  						.multiplyScalar( newRadius )
+  						.add( this.object.position );
 
-  			}
+  				} else {
 
-  			//scope.dispatchEvent( { type: 'dispose' } ); // should this be added here?
+  					// get the ray and translation plane to compute target
+  					_ray.origin.copy( this.object.position );
+  					_ray.direction.set( 0, 0, - 1 ).transformDirection( this.object.matrix );
 
-  		};
+  					// if the camera is 20 degrees above the horizon then don't adjust the focus target to avoid
+  					// extremely large values
+  					if ( Math.abs( this.object.up.dot( _ray.direction ) ) < _TILT_LIMIT ) {
 
-  		//
-  		// internals
-  		//
+  						this.object.lookAt( this.target );
 
-  		const scope = this;
-
-  		const STATE = {
-  			NONE: - 1,
-  			ROTATE: 0,
-  			DOLLY: 1,
-  			PAN: 2,
-  			TOUCH_ROTATE: 3,
-  			TOUCH_PAN: 4,
-  			TOUCH_DOLLY_PAN: 5,
-  			TOUCH_DOLLY_ROTATE: 6
-  		};
+  					} else {
 
-  		let state = STATE.NONE;
+  						_plane.setFromNormalAndCoplanarPoint( this.object.up, this.target );
+  						_ray.intersectPlane( _plane, this.target );
 
-  		const EPS = 0.000001;
+  					}
 
-  		// current position in spherical coordinates
-  		const spherical = new three$1.Spherical();
-  		const sphericalDelta = new three$1.Spherical();
+  				}
 
-  		let scale = 1;
-  		const panOffset = new three$1.Vector3();
+  			}
 
-  		const rotateStart = new three$1.Vector2();
-  		const rotateEnd = new three$1.Vector2();
-  		const rotateDelta = new three$1.Vector2();
+  		} else if ( this.object.isOrthographicCamera ) {
 
-  		const panStart = new three$1.Vector2();
-  		const panEnd = new three$1.Vector2();
-  		const panDelta = new three$1.Vector2();
+  			const prevZoom = this.object.zoom;
+  			this.object.zoom = Math.max( this.minZoom, Math.min( this.maxZoom, this.object.zoom / this._scale ) );
 
-  		const dollyStart = new three$1.Vector2();
-  		const dollyEnd = new three$1.Vector2();
-  		const dollyDelta = new three$1.Vector2();
+  			if ( prevZoom !== this.object.zoom ) {
 
-  		const dollyDirection = new three$1.Vector3();
-  		const mouse = new three$1.Vector2();
-  		let performCursorZoom = false;
+  				this.object.updateProjectionMatrix();
+  				zoomChanged = true;
 
-  		const pointers = [];
-  		const pointerPositions = {};
+  			}
 
-  		let controlActive = false;
+  		}
 
-  		function getAutoRotationAngle( deltaTime ) {
+  		this._scale = 1;
+  		this._performCursorZoom = false;
 
-  			if ( deltaTime !== null ) {
+  		// update condition is:
+  		// min(camera displacement, camera rotation in radians)^2 > EPS
+  		// using small-angle approximation cos(x/2) = 1 - x^2 / 8
 
-  				return ( 2 * Math.PI / 60 * scope.autoRotateSpeed ) * deltaTime;
+  		if ( zoomChanged ||
+  			this._lastPosition.distanceToSquared( this.object.position ) > _EPS$1 ||
+  			8 * ( 1 - this._lastQuaternion.dot( this.object.quaternion ) ) > _EPS$1 ||
+  			this._lastTargetPosition.distanceToSquared( this.target ) > _EPS$1 ) {
 
-  			} else {
+  			this.dispatchEvent( _changeEvent$1 );
 
-  				return 2 * Math.PI / 60 / 60 * scope.autoRotateSpeed;
+  			this._lastPosition.copy( this.object.position );
+  			this._lastQuaternion.copy( this.object.quaternion );
+  			this._lastTargetPosition.copy( this.target );
 
-  			}
+  			return true;
 
   		}
 
-  		function getZoomScale( delta ) {
-
-  			const normalizedDelta = Math.abs( delta * 0.01 );
-  			return Math.pow( 0.95, scope.zoomSpeed * normalizedDelta );
+  		return false;
 
-  		}
+  	}
 
-  		function rotateLeft( angle ) {
+  	_getAutoRotationAngle( deltaTime ) {
 
-  			sphericalDelta.theta -= angle;
+  		if ( deltaTime !== null ) {
 
-  		}
+  			return ( _twoPI / 60 * this.autoRotateSpeed ) * deltaTime;
 
-  		function rotateUp( angle ) {
+  		} else {
 
-  			sphericalDelta.phi -= angle;
+  			return _twoPI / 60 / 60 * this.autoRotateSpeed;
 
   		}
 
-  		const panLeft = function () {
+  	}
 
-  			const v = new three$1.Vector3();
+  	_getZoomScale( delta ) {
 
-  			return function panLeft( distance, objectMatrix ) {
+  		const normalizedDelta = Math.abs( delta * 0.01 );
+  		return Math.pow( 0.95, this.zoomSpeed * normalizedDelta );
 
-  				v.setFromMatrixColumn( objectMatrix, 0 ); // get X column of objectMatrix
-  				v.multiplyScalar( - distance );
+  	}
 
-  				panOffset.add( v );
+  	_rotateLeft( angle ) {
 
-  			};
+  		this._sphericalDelta.theta -= angle;
 
-  		}();
+  	}
 
-  		const panUp = function () {
+  	_rotateUp( angle ) {
 
-  			const v = new three$1.Vector3();
+  		this._sphericalDelta.phi -= angle;
 
-  			return function panUp( distance, objectMatrix ) {
+  	}
 
-  				if ( scope.screenSpacePanning === true ) {
+  	_panLeft( distance, objectMatrix ) {
 
-  					v.setFromMatrixColumn( objectMatrix, 1 );
+  		_v.setFromMatrixColumn( objectMatrix, 0 ); // get X column of objectMatrix
+  		_v.multiplyScalar( - distance );
 
-  				} else {
+  		this._panOffset.add( _v );
 
-  					v.setFromMatrixColumn( objectMatrix, 0 );
-  					v.crossVectors( scope.object.up, v );
+  	}
 
-  				}
+  	_panUp( distance, objectMatrix ) {
 
-  				v.multiplyScalar( distance );
+  		if ( this.screenSpacePanning === true ) {
 
-  				panOffset.add( v );
+  			_v.setFromMatrixColumn( objectMatrix, 1 );
 
-  			};
+  		} else {
 
-  		}();
+  			_v.setFromMatrixColumn( objectMatrix, 0 );
+  			_v.crossVectors( this.object.up, _v );
 
-  		// deltaX and deltaY are in pixels; right and down are positive
-  		const pan = function () {
+  		}
 
-  			const offset = new three$1.Vector3();
+  		_v.multiplyScalar( distance );
 
-  			return function pan( deltaX, deltaY ) {
+  		this._panOffset.add( _v );
 
-  				const element = scope.domElement;
+  	}
 
-  				if ( scope.object.isPerspectiveCamera ) {
+  	// deltaX and deltaY are in pixels; right and down are positive
+  	_pan( deltaX, deltaY ) {
 
-  					// perspective
-  					const position = scope.object.position;
-  					offset.copy( position ).sub( scope.target );
-  					let targetDistance = offset.length();
+  		const element = this.domElement;
 
-  					// half of the fov is center to top of screen
-  					targetDistance *= Math.tan( ( scope.object.fov / 2 ) * Math.PI / 180.0 );
+  		if ( this.object.isPerspectiveCamera ) {
 
-  					// 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 );
+  			// perspective
+  			const position = this.object.position;
+  			_v.copy( position ).sub( this.target );
+  			let targetDistance = _v.length();
 
-  				} else if ( scope.object.isOrthographicCamera ) {
+  			// half of the fov is center to top of screen
+  			targetDistance *= Math.tan( ( this.object.fov / 2 ) * Math.PI / 180.0 );
 
-  					// 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 );
+  			// we use only clientHeight here so aspect ratio does not distort speed
+  			this._panLeft( 2 * deltaX * targetDistance / element.clientHeight, this.object.matrix );
+  			this._panUp( 2 * deltaY * targetDistance / element.clientHeight, this.object.matrix );
 
-  				} else {
+  		} else if ( this.object.isOrthographicCamera ) {
 
-  					// camera neither orthographic nor perspective
-  					console.warn( 'WARNING: OrbitControls.js encountered an unknown camera type - pan disabled.' );
-  					scope.enablePan = false;
+  			// orthographic
+  			this._panLeft( deltaX * ( this.object.right - this.object.left ) / this.object.zoom / element.clientWidth, this.object.matrix );
+  			this._panUp( deltaY * ( this.object.top - this.object.bottom ) / this.object.zoom / element.clientHeight, this.object.matrix );
 
-  				}
+  		} else {
 
-  			};
+  			// camera neither orthographic nor perspective
+  			console.warn( 'WARNING: OrbitControls.js encountered an unknown camera type - pan disabled.' );
+  			this.enablePan = false;
 
-  		}();
+  		}
 
-  		function dollyOut( dollyScale ) {
+  	}
 
-  			if ( scope.object.isPerspectiveCamera || scope.object.isOrthographicCamera ) {
+  	_dollyOut( dollyScale ) {
 
-  				scale /= dollyScale;
+  		if ( this.object.isPerspectiveCamera || this.object.isOrthographicCamera ) {
 
-  			} else {
+  			this._scale /= dollyScale;
 
-  				console.warn( 'WARNING: OrbitControls.js encountered an unknown camera type - dolly/zoom disabled.' );
-  				scope.enableZoom = false;
+  		} else {
 
-  			}
+  			console.warn( 'WARNING: OrbitControls.js encountered an unknown camera type - dolly/zoom disabled.' );
+  			this.enableZoom = false;
 
   		}
 
-  		function dollyIn( dollyScale ) {
+  	}
 
-  			if ( scope.object.isPerspectiveCamera || scope.object.isOrthographicCamera ) {
+  	_dollyIn( dollyScale ) {
 
-  				scale *= dollyScale;
+  		if ( this.object.isPerspectiveCamera || this.object.isOrthographicCamera ) {
 
-  			} else {
+  			this._scale *= dollyScale;
 
-  				console.warn( 'WARNING: OrbitControls.js encountered an unknown camera type - dolly/zoom disabled.' );
-  				scope.enableZoom = false;
+  		} else {
 
-  			}
+  			console.warn( 'WARNING: OrbitControls.js encountered an unknown camera type - dolly/zoom disabled.' );
+  			this.enableZoom = false;
 
   		}
 
-  		function updateZoomParameters( x, y ) {
-
-  			if ( ! scope.zoomToCursor ) {
-
-  				return;
+  	}
 
-  			}
+  	_updateZoomParameters( x, y ) {
 
-  			performCursorZoom = true;
+  		if ( ! this.zoomToCursor ) {
 
-  			const rect = scope.domElement.getBoundingClientRect();
-  			const dx = x - rect.left;
-  			const dy = y - rect.top;
-  			const w = rect.width;
-  			const h = rect.height;
+  			return;
 
-  			mouse.x = ( dx / w ) * 2 - 1;
-  			mouse.y = - ( dy / h ) * 2 + 1;
+  		}
 
-  			dollyDirection.set( mouse.x, mouse.y, 1 ).unproject( scope.object ).sub( scope.object.position ).normalize();
+  		this._performCursorZoom = true;
 
-  		}
+  		const rect = this.domElement.getBoundingClientRect();
+  		const dx = x - rect.left;
+  		const dy = y - rect.top;
+  		const w = rect.width;
+  		const h = rect.height;
 
-  		function clampDistance( dist ) {
+  		this._mouse.x = ( dx / w ) * 2 - 1;
+  		this._mouse.y = - ( dy / h ) * 2 + 1;
 
-  			return Math.max( scope.minDistance, Math.min( scope.maxDistance, dist ) );
+  		this._dollyDirection.set( this._mouse.x, this._mouse.y, 1 ).unproject( this.object ).sub( this.object.position ).normalize();
 
-  		}
+  	}
 
-  		//
-  		// event callbacks - update the object state
-  		//
+  	_clampDistance( dist ) {
 
-  		function handleMouseDownRotate( event ) {
+  		return Math.max( this.minDistance, Math.min( this.maxDistance, dist ) );
 
-  			rotateStart.set( event.clientX, event.clientY );
+  	}
 
-  		}
+  	//
+  	// event callbacks - update the object state
+  	//
 
-  		function handleMouseDownDolly( event ) {
+  	_handleMouseDownRotate( event ) {
 
-  			updateZoomParameters( event.clientX, event.clientX );
-  			dollyStart.set( event.clientX, event.clientY );
+  		this._rotateStart.set( event.clientX, event.clientY );
 
-  		}
+  	}
 
-  		function handleMouseDownPan( event ) {
+  	_handleMouseDownDolly( event ) {
 
-  			panStart.set( event.clientX, event.clientY );
+  		this._updateZoomParameters( event.clientX, event.clientX );
+  		this._dollyStart.set( event.clientX, event.clientY );
 
-  		}
+  	}
 
-  		function handleMouseMoveRotate( event ) {
+  	_handleMouseDownPan( event ) {
 
-  			rotateEnd.set( event.clientX, event.clientY );
+  		this._panStart.set( event.clientX, event.clientY );
 
-  			rotateDelta.subVectors( rotateEnd, rotateStart ).multiplyScalar( scope.rotateSpeed );
+  	}
 
-  			const element = scope.domElement;
+  	_handleMouseMoveRotate( event ) {
 
-  			rotateLeft( 2 * Math.PI * rotateDelta.x / element.clientHeight ); // yes, height
+  		this._rotateEnd.set( event.clientX, event.clientY );
 
-  			rotateUp( 2 * Math.PI * rotateDelta.y / element.clientHeight );
+  		this._rotateDelta.subVectors( this._rotateEnd, this._rotateStart ).multiplyScalar( this.rotateSpeed );
 
-  			rotateStart.copy( rotateEnd );
+  		const element = this.domElement;
 
-  			scope.update();
+  		this._rotateLeft( _twoPI * this._rotateDelta.x / element.clientHeight ); // yes, height
 
-  		}
+  		this._rotateUp( _twoPI * this._rotateDelta.y / element.clientHeight );
 
-  		function handleMouseMoveDolly( event ) {
+  		this._rotateStart.copy( this._rotateEnd );
 
-  			dollyEnd.set( event.clientX, event.clientY );
+  		this.update();
 
-  			dollyDelta.subVectors( dollyEnd, dollyStart );
+  	}
 
-  			if ( dollyDelta.y > 0 ) {
+  	_handleMouseMoveDolly( event ) {
 
-  				dollyOut( getZoomScale( dollyDelta.y ) );
+  		this._dollyEnd.set( event.clientX, event.clientY );
 
-  			} else if ( dollyDelta.y < 0 ) {
+  		this._dollyDelta.subVectors( this._dollyEnd, this._dollyStart );
 
-  				dollyIn( getZoomScale( dollyDelta.y ) );
+  		if ( this._dollyDelta.y > 0 ) {
 
-  			}
+  			this._dollyOut( this._getZoomScale( this._dollyDelta.y ) );
 
-  			dollyStart.copy( dollyEnd );
+  		} else if ( this._dollyDelta.y < 0 ) {
 
-  			scope.update();
+  			this._dollyIn( this._getZoomScale( this._dollyDelta.y ) );
 
   		}
 
-  		function handleMouseMovePan( event ) {
+  		this._dollyStart.copy( this._dollyEnd );
 
-  			panEnd.set( event.clientX, event.clientY );
+  		this.update();
 
-  			panDelta.subVectors( panEnd, panStart ).multiplyScalar( scope.panSpeed );
+  	}
 
-  			pan( panDelta.x, panDelta.y );
+  	_handleMouseMovePan( event ) {
 
-  			panStart.copy( panEnd );
+  		this._panEnd.set( event.clientX, event.clientY );
 
-  			scope.update();
+  		this._panDelta.subVectors( this._panEnd, this._panStart ).multiplyScalar( this.panSpeed );
 
-  		}
+  		this._pan( this._panDelta.x, this._panDelta.y );
 
-  		function handleMouseWheel( event ) {
+  		this._panStart.copy( this._panEnd );
 
-  			updateZoomParameters( event.clientX, event.clientY );
+  		this.update();
 
-  			if ( event.deltaY < 0 ) {
+  	}
 
-  				dollyIn( getZoomScale( event.deltaY ) );
+  	_handleMouseWheel( event ) {
 
-  			} else if ( event.deltaY > 0 ) {
+  		this._updateZoomParameters( event.clientX, event.clientY );
 
-  				dollyOut( getZoomScale( event.deltaY ) );
+  		if ( event.deltaY < 0 ) {
 
-  			}
+  			this._dollyIn( this._getZoomScale( event.deltaY ) );
+
+  		} else if ( event.deltaY > 0 ) {
 
-  			scope.update();
+  			this._dollyOut( this._getZoomScale( event.deltaY ) );
 
   		}
 
-  		function handleKeyDown( event ) {
+  		this.update();
 
-  			let needsUpdate = false;
+  	}
 
-  			switch ( event.code ) {
+  	_handleKeyDown( event ) {
 
-  				case scope.keys.UP:
+  		let needsUpdate = false;
 
-  					if ( event.ctrlKey || event.metaKey || event.shiftKey ) {
+  		switch ( event.code ) {
 
-  						rotateUp( 2 * Math.PI * scope.rotateSpeed / scope.domElement.clientHeight );
+  			case this.keys.UP:
 
-  					} else {
+  				if ( event.ctrlKey || event.metaKey || event.shiftKey ) {
 
-  						pan( 0, scope.keyPanSpeed );
+  					this._rotateUp( _twoPI * this.rotateSpeed / this.domElement.clientHeight );
 
-  					}
+  				} else {
 
-  					needsUpdate = true;
-  					break;
+  					this._pan( 0, this.keyPanSpeed );
 
-  				case scope.keys.BOTTOM:
+  				}
 
-  					if ( event.ctrlKey || event.metaKey || event.shiftKey ) {
+  				needsUpdate = true;
+  				break;
 
-  						rotateUp( - 2 * Math.PI * scope.rotateSpeed / scope.domElement.clientHeight );
+  			case this.keys.BOTTOM:
 
-  					} else {
+  				if ( event.ctrlKey || event.metaKey || event.shiftKey ) {
 
-  						pan( 0, - scope.keyPanSpeed );
+  					this._rotateUp( - _twoPI * this.rotateSpeed / this.domElement.clientHeight );
 
-  					}
+  				} else {
 
-  					needsUpdate = true;
-  					break;
+  					this._pan( 0, - this.keyPanSpeed );
 
-  				case scope.keys.LEFT:
+  				}
 
-  					if ( event.ctrlKey || event.metaKey || event.shiftKey ) {
+  				needsUpdate = true;
+  				break;
 
-  						rotateLeft( 2 * Math.PI * scope.rotateSpeed / scope.domElement.clientHeight );
+  			case this.keys.LEFT:
 
-  					} else {
+  				if ( event.ctrlKey || event.metaKey || event.shiftKey ) {
 
-  						pan( scope.keyPanSpeed, 0 );
+  					this._rotateLeft( _twoPI * this.rotateSpeed / this.domElement.clientHeight );
 
-  					}
+  				} else {
 
-  					needsUpdate = true;
-  					break;
+  					this._pan( this.keyPanSpeed, 0 );
 
-  				case scope.keys.RIGHT:
+  				}
 
-  					if ( event.ctrlKey || event.metaKey || event.shiftKey ) {
+  				needsUpdate = true;
+  				break;
 
-  						rotateLeft( - 2 * Math.PI * scope.rotateSpeed / scope.domElement.clientHeight );
+  			case this.keys.RIGHT:
 
-  					} else {
+  				if ( event.ctrlKey || event.metaKey || event.shiftKey ) {
 
-  						pan( - scope.keyPanSpeed, 0 );
+  					this._rotateLeft( - _twoPI * this.rotateSpeed / this.domElement.clientHeight );
 
-  					}
+  				} else {
 
-  					needsUpdate = true;
-  					break;
+  					this._pan( - this.keyPanSpeed, 0 );
 
-  			}
+  				}
 
-  			if ( needsUpdate ) {
+  				needsUpdate = true;
+  				break;
 
-  				// prevent the browser from scrolling on cursor keys
-  				event.preventDefault();
+  		}
 
-  				scope.update();
+  		if ( needsUpdate ) {
 
-  			}
+  			// prevent the browser from scrolling on cursor keys
+  			event.preventDefault();
 
+  			this.update();
 
   		}
 
-  		function handleTouchStartRotate( event ) {
 
-  			if ( pointers.length === 1 ) {
+  	}
 
-  				rotateStart.set( event.pageX, event.pageY );
+  	_handleTouchStartRotate( event ) {
 
-  			} else {
+  		if ( this._pointers.length === 1 ) {
 
-  				const position = getSecondPointerPosition( event );
+  			this._rotateStart.set( event.pageX, event.pageY );
 
-  				const x = 0.5 * ( event.pageX + position.x );
-  				const y = 0.5 * ( event.pageY + position.y );
+  		} else {
 
-  				rotateStart.set( x, y );
+  			const position = this._getSecondPointerPosition( event );
 
-  			}
+  			const x = 0.5 * ( event.pageX + position.x );
+  			const y = 0.5 * ( event.pageY + position.y );
+
+  			this._rotateStart.set( x, y );
 
   		}
 
-  		function handleTouchStartPan( event ) {
+  	}
 
-  			if ( pointers.length === 1 ) {
+  	_handleTouchStartPan( event ) {
 
-  				panStart.set( event.pageX, event.pageY );
+  		if ( this._pointers.length === 1 ) {
 
-  			} else {
+  			this._panStart.set( event.pageX, event.pageY );
 
-  				const position = getSecondPointerPosition( event );
+  		} else {
 
-  				const x = 0.5 * ( event.pageX + position.x );
-  				const y = 0.5 * ( event.pageY + position.y );
+  			const position = this._getSecondPointerPosition( event );
 
-  				panStart.set( x, y );
+  			const x = 0.5 * ( event.pageX + position.x );
+  			const y = 0.5 * ( event.pageY + position.y );
 
-  			}
+  			this._panStart.set( x, y );
 
   		}
 
-  		function handleTouchStartDolly( event ) {
-
-  			const position = getSecondPointerPosition( event );
-
-  			const dx = event.pageX - position.x;
-  			const dy = event.pageY - position.y;
-
-  			const distance = Math.sqrt( dx * dx + dy * dy );
-
-  			dollyStart.set( 0, distance );
-
-  		}
+  	}
 
-  		function handleTouchStartDollyPan( event ) {
+  	_handleTouchStartDolly( event ) {
 
-  			if ( scope.enableZoom ) handleTouchStartDolly( event );
+  		const position = this._getSecondPointerPosition( event );
 
-  			if ( scope.enablePan ) handleTouchStartPan( event );
+  		const dx = event.pageX - position.x;
+  		const dy = event.pageY - position.y;
 
-  		}
+  		const distance = Math.sqrt( dx * dx + dy * dy );
 
-  		function handleTouchStartDollyRotate( event ) {
+  		this._dollyStart.set( 0, distance );
 
-  			if ( scope.enableZoom ) handleTouchStartDolly( event );
+  	}
 
-  			if ( scope.enableRotate ) handleTouchStartRotate( event );
+  	_handleTouchStartDollyPan( event ) {
 
-  		}
+  		if ( this.enableZoom ) this._handleTouchStartDolly( event );
 
-  		function handleTouchMoveRotate( event ) {
+  		if ( this.enablePan ) this._handleTouchStartPan( event );
 
-  			if ( pointers.length == 1 ) {
+  	}
 
-  				rotateEnd.set( event.pageX, event.pageY );
+  	_handleTouchStartDollyRotate( event ) {
 
-  			} else {
+  		if ( this.enableZoom ) this._handleTouchStartDolly( event );
 
-  				const position = getSecondPointerPosition( event );
+  		if ( this.enableRotate ) this._handleTouchStartRotate( event );
 
-  				const x = 0.5 * ( event.pageX + position.x );
-  				const y = 0.5 * ( event.pageY + position.y );
+  	}
 
-  				rotateEnd.set( x, y );
+  	_handleTouchMoveRotate( event ) {
 
-  			}
+  		if ( this._pointers.length == 1 ) {
 
-  			rotateDelta.subVectors( rotateEnd, rotateStart ).multiplyScalar( scope.rotateSpeed );
+  			this._rotateEnd.set( event.pageX, event.pageY );
 
-  			const element = scope.domElement;
+  		} else {
 
-  			rotateLeft( 2 * Math.PI * rotateDelta.x / element.clientHeight ); // yes, height
+  			const position = this._getSecondPointerPosition( event );
 
-  			rotateUp( 2 * Math.PI * rotateDelta.y / element.clientHeight );
+  			const x = 0.5 * ( event.pageX + position.x );
+  			const y = 0.5 * ( event.pageY + position.y );
 
-  			rotateStart.copy( rotateEnd );
+  			this._rotateEnd.set( x, y );
 
   		}
 
-  		function handleTouchMovePan( event ) {
+  		this._rotateDelta.subVectors( this._rotateEnd, this._rotateStart ).multiplyScalar( this.rotateSpeed );
 
-  			if ( pointers.length === 1 ) {
+  		const element = this.domElement;
 
-  				panEnd.set( event.pageX, event.pageY );
+  		this._rotateLeft( _twoPI * this._rotateDelta.x / element.clientHeight ); // yes, height
 
-  			} else {
+  		this._rotateUp( _twoPI * this._rotateDelta.y / element.clientHeight );
 
-  				const position = getSecondPointerPosition( event );
+  		this._rotateStart.copy( this._rotateEnd );
 
-  				const x = 0.5 * ( event.pageX + position.x );
-  				const y = 0.5 * ( event.pageY + position.y );
+  	}
 
-  				panEnd.set( x, y );
+  	_handleTouchMovePan( event ) {
 
-  			}
+  		if ( this._pointers.length === 1 ) {
 
-  			panDelta.subVectors( panEnd, panStart ).multiplyScalar( scope.panSpeed );
+  			this._panEnd.set( event.pageX, event.pageY );
 
-  			pan( panDelta.x, panDelta.y );
+  		} else {
 
-  			panStart.copy( panEnd );
+  			const position = this._getSecondPointerPosition( event );
 
-  		}
+  			const x = 0.5 * ( event.pageX + position.x );
+  			const y = 0.5 * ( event.pageY + position.y );
 
-  		function handleTouchMoveDolly( event ) {
+  			this._panEnd.set( x, y );
 
-  			const position = getSecondPointerPosition( event );
+  		}
 
-  			const dx = event.pageX - position.x;
-  			const dy = event.pageY - position.y;
+  		this._panDelta.subVectors( this._panEnd, this._panStart ).multiplyScalar( this.panSpeed );
 
-  			const distance = Math.sqrt( dx * dx + dy * dy );
+  		this._pan( this._panDelta.x, this._panDelta.y );
 
-  			dollyEnd.set( 0, distance );
+  		this._panStart.copy( this._panEnd );
 
-  			dollyDelta.set( 0, Math.pow( dollyEnd.y / dollyStart.y, scope.zoomSpeed ) );
+  	}
 
-  			dollyOut( dollyDelta.y );
+  	_handleTouchMoveDolly( event ) {
 
-  			dollyStart.copy( dollyEnd );
+  		const position = this._getSecondPointerPosition( event );
 
-  			const centerX = ( event.pageX + position.x ) * 0.5;
-  			const centerY = ( event.pageY + position.y ) * 0.5;
+  		const dx = event.pageX - position.x;
+  		const dy = event.pageY - position.y;
 
-  			updateZoomParameters( centerX, centerY );
+  		const distance = Math.sqrt( dx * dx + dy * dy );
 
-  		}
+  		this._dollyEnd.set( 0, distance );
 
-  		function handleTouchMoveDollyPan( event ) {
+  		this._dollyDelta.set( 0, Math.pow( this._dollyEnd.y / this._dollyStart.y, this.zoomSpeed ) );
 
-  			if ( scope.enableZoom ) handleTouchMoveDolly( event );
+  		this._dollyOut( this._dollyDelta.y );
 
-  			if ( scope.enablePan ) handleTouchMovePan( event );
+  		this._dollyStart.copy( this._dollyEnd );
 
-  		}
+  		const centerX = ( event.pageX + position.x ) * 0.5;
+  		const centerY = ( event.pageY + position.y ) * 0.5;
 
-  		function handleTouchMoveDollyRotate( event ) {
+  		this._updateZoomParameters( centerX, centerY );
 
-  			if ( scope.enableZoom ) handleTouchMoveDolly( event );
+  	}
 
-  			if ( scope.enableRotate ) handleTouchMoveRotate( event );
+  	_handleTouchMoveDollyPan( event ) {
 
-  		}
+  		if ( this.enableZoom ) this._handleTouchMoveDolly( event );
 
-  		//
-  		// event handlers - FSM: listen for events and reset state
-  		//
+  		if ( this.enablePan ) this._handleTouchMovePan( event );
 
-  		function onPointerDown( event ) {
+  	}
 
-  			if ( scope.enabled === false ) return;
+  	_handleTouchMoveDollyRotate( event ) {
 
-  			if ( pointers.length === 0 ) {
+  		if ( this.enableZoom ) this._handleTouchMoveDolly( event );
 
-  				scope.domElement.setPointerCapture( event.pointerId );
+  		if ( this.enableRotate ) this._handleTouchMoveRotate( event );
 
-  				scope.domElement.addEventListener( 'pointermove', onPointerMove );
-  				scope.domElement.addEventListener( 'pointerup', onPointerUp );
+  	}
 
-  			}
+  	// pointers
 
-  			//
+  	_addPointer( event ) {
 
-  			if ( isTrackingPointer( event ) ) return;
+  		this._pointers.push( event.pointerId );
 
-  			//
+  	}
 
-  			addPointer( event );
+  	_removePointer( event ) {
 
-  			if ( event.pointerType === 'touch' ) {
+  		delete this._pointerPositions[ event.pointerId ];
 
-  				onTouchStart( event );
+  		for ( let i = 0; i < this._pointers.length; i ++ ) {
 
-  			} else {
+  			if ( this._pointers[ i ] == event.pointerId ) {
 
-  				onMouseDown( event );
+  				this._pointers.splice( i, 1 );
+  				return;
 
   			}
 
   		}
 
-  		function onPointerMove( event ) {
-
-  			if ( scope.enabled === false ) return;
+  	}
 
-  			if ( event.pointerType === 'touch' ) {
+  	_isTrackingPointer( event ) {
 
-  				onTouchMove( event );
+  		for ( let i = 0; i < this._pointers.length; i ++ ) {
 
-  			} else {
+  			if ( this._pointers[ i ] == event.pointerId ) return true;
 
-  				onMouseMove( event );
+  		}
 
-  			}
+  		return false;
 
-  		}
+  	}
 
-  		function onPointerUp( event ) {
+  	_trackPointer( event ) {
 
-  			removePointer( event );
+  		let position = this._pointerPositions[ event.pointerId ];
 
-  			switch ( pointers.length ) {
+  		if ( position === undefined ) {
 
-  				case 0:
+  			position = new three$1.Vector2();
+  			this._pointerPositions[ event.pointerId ] = position;
 
-  					scope.domElement.releasePointerCapture( event.pointerId );
+  		}
 
-  					scope.domElement.removeEventListener( 'pointermove', onPointerMove );
-  					scope.domElement.removeEventListener( 'pointerup', onPointerUp );
+  		position.set( event.pageX, event.pageY );
 
-  					scope.dispatchEvent( _endEvent );
+  	}
 
-  					state = STATE.NONE;
+  	_getSecondPointerPosition( event ) {
 
-  					break;
+  		const pointerId = ( event.pointerId === this._pointers[ 0 ] ) ? this._pointers[ 1 ] : this._pointers[ 0 ];
 
-  				case 1:
+  		return this._pointerPositions[ pointerId ];
 
-  					const pointerId = pointers[ 0 ];
-  					const position = pointerPositions[ pointerId ];
+  	}
 
-  					// minimal placeholder event - allows state correction on pointer-up
-  					onTouchStart( { pointerId: pointerId, pageX: position.x, pageY: position.y } );
+  	//
 
-  					break;
+  	_customWheelEvent( event ) {
 
-  			}
+  		const mode = event.deltaMode;
 
-  		}
+  		// minimal wheel event altered to meet delta-zoom demand
+  		const newEvent = {
+  			clientX: event.clientX,
+  			clientY: event.clientY,
+  			deltaY: event.deltaY,
+  		};
 
-  		function onMouseDown( event ) {
+  		switch ( mode ) {
 
-  			let mouseAction;
+  			case 1: // LINE_MODE
+  				newEvent.deltaY *= 16;
+  				break;
 
-  			switch ( event.button ) {
+  			case 2: // PAGE_MODE
+  				newEvent.deltaY *= 100;
+  				break;
 
-  				case 0:
+  		}
 
-  					mouseAction = scope.mouseButtons.LEFT;
-  					break;
+  		// detect if event was triggered by pinching
+  		if ( event.ctrlKey && ! this._controlActive ) {
 
-  				case 1:
+  			newEvent.deltaY *= 10;
 
-  					mouseAction = scope.mouseButtons.MIDDLE;
-  					break;
+  		}
 
-  				case 2:
+  		return newEvent;
 
-  					mouseAction = scope.mouseButtons.RIGHT;
-  					break;
+  	}
 
-  				default:
+  }
 
-  					mouseAction = - 1;
+  function onPointerDown$1( event ) {
 
-  			}
+  	if ( this.enabled === false ) return;
 
-  			switch ( mouseAction ) {
+  	if ( this._pointers.length === 0 ) {
 
-  				case three$1.MOUSE.DOLLY:
+  		this.domElement.setPointerCapture( event.pointerId );
 
-  					if ( scope.enableZoom === false ) return;
+  		this.domElement.addEventListener( 'pointermove', this._onPointerMove );
+  		this.domElement.addEventListener( 'pointerup', this._onPointerUp );
 
-  					handleMouseDownDolly( event );
+  	}
 
-  					state = STATE.DOLLY;
+  	//
 
-  					break;
+  	if ( this._isTrackingPointer( event ) ) return;
 
-  				case three$1.MOUSE.ROTATE:
+  	//
 
-  					if ( event.ctrlKey || event.metaKey || event.shiftKey ) {
+  	this._addPointer( event );
 
-  						if ( scope.enablePan === false ) return;
+  	if ( event.pointerType === 'touch' ) {
 
-  						handleMouseDownPan( event );
+  		this._onTouchStart( event );
 
-  						state = STATE.PAN;
+  	} else {
 
-  					} else {
+  		this._onMouseDown( event );
 
-  						if ( scope.enableRotate === false ) return;
+  	}
 
-  						handleMouseDownRotate( event );
+  }
 
-  						state = STATE.ROTATE;
+  function onPointerMove$1( event ) {
 
-  					}
+  	if ( this.enabled === false ) return;
 
-  					break;
+  	if ( event.pointerType === 'touch' ) {
 
-  				case three$1.MOUSE.PAN:
+  		this._onTouchMove( event );
 
-  					if ( event.ctrlKey || event.metaKey || event.shiftKey ) {
+  	} else {
 
-  						if ( scope.enableRotate === false ) return;
+  		this._onMouseMove( event );
 
-  						handleMouseDownRotate( event );
+  	}
 
-  						state = STATE.ROTATE;
+  }
 
-  					} else {
+  function onPointerUp$1( event ) {
 
-  						if ( scope.enablePan === false ) return;
+  	this._removePointer( event );
 
-  						handleMouseDownPan( event );
+  	switch ( this._pointers.length ) {
 
-  						state = STATE.PAN;
+  		case 0:
 
-  					}
+  			this.domElement.releasePointerCapture( event.pointerId );
 
-  					break;
+  			this.domElement.removeEventListener( 'pointermove', this._onPointerMove );
+  			this.domElement.removeEventListener( 'pointerup', this._onPointerUp );
 
-  				default:
+  			this.dispatchEvent( _endEvent );
 
-  					state = STATE.NONE;
+  			this.state = _STATE.NONE;
 
-  			}
+  			break;
 
-  			if ( state !== STATE.NONE ) {
+  		case 1:
 
-  				scope.dispatchEvent( _startEvent );
+  			const pointerId = this._pointers[ 0 ];
+  			const position = this._pointerPositions[ pointerId ];
 
-  			}
+  			// minimal placeholder event - allows state correction on pointer-up
+  			this._onTouchStart( { pointerId: pointerId, pageX: position.x, pageY: position.y } );
 
-  		}
+  			break;
 
-  		function onMouseMove( event ) {
+  	}
 
-  			switch ( state ) {
+  }
 
-  				case STATE.ROTATE:
+  function onMouseDown( event ) {
 
-  					if ( scope.enableRotate === false ) return;
+  	let mouseAction;
 
-  					handleMouseMoveRotate( event );
+  	switch ( event.button ) {
 
-  					break;
+  		case 0:
 
-  				case STATE.DOLLY:
+  			mouseAction = this.mouseButtons.LEFT;
+  			break;
 
-  					if ( scope.enableZoom === false ) return;
+  		case 1:
 
-  					handleMouseMoveDolly( event );
+  			mouseAction = this.mouseButtons.MIDDLE;
+  			break;
 
-  					break;
+  		case 2:
 
-  				case STATE.PAN:
+  			mouseAction = this.mouseButtons.RIGHT;
+  			break;
 
-  					if ( scope.enablePan === false ) return;
+  		default:
 
-  					handleMouseMovePan( event );
+  			mouseAction = - 1;
 
-  					break;
+  	}
 
-  			}
+  	switch ( mouseAction ) {
 
-  		}
+  		case three$1.MOUSE.DOLLY:
 
-  		function onMouseWheel( event ) {
+  			if ( this.enableZoom === false ) return;
 
-  			if ( scope.enabled === false || scope.enableZoom === false || state !== STATE.NONE ) return;
+  			this._handleMouseDownDolly( event );
 
-  			event.preventDefault();
+  			this.state = _STATE.DOLLY;
 
-  			scope.dispatchEvent( _startEvent );
+  			break;
 
-  			handleMouseWheel( customWheelEvent( event ) );
+  		case three$1.MOUSE.ROTATE:
 
-  			scope.dispatchEvent( _endEvent );
+  			if ( event.ctrlKey || event.metaKey || event.shiftKey ) {
 
-  		}
+  				if ( this.enablePan === false ) return;
 
-  		function customWheelEvent( event ) {
+  				this._handleMouseDownPan( event );
 
-  			const mode = event.deltaMode;
+  				this.state = _STATE.PAN;
 
-  			// minimal wheel event altered to meet delta-zoom demand
-  			const newEvent = {
-  				clientX: event.clientX,
-  				clientY: event.clientY,
-  				deltaY: event.deltaY,
-  			};
+  			} else {
 
-  			switch ( mode ) {
+  				if ( this.enableRotate === false ) return;
 
-  				case 1: // LINE_MODE
-  					newEvent.deltaY *= 16;
-  					break;
+  				this._handleMouseDownRotate( event );
 
-  				case 2: // PAGE_MODE
-  					newEvent.deltaY *= 100;
-  					break;
+  				this.state = _STATE.ROTATE;
 
   			}
 
-  			// detect if event was triggered by pinching
-  			if ( event.ctrlKey && ! controlActive ) {
-
-  				newEvent.deltaY *= 10;
+  			break;
 
-  			}
+  		case three$1.MOUSE.PAN:
 
-  			return newEvent;
+  			if ( event.ctrlKey || event.metaKey || event.shiftKey ) {
 
-  		}
+  				if ( this.enableRotate === false ) return;
 
-  		function interceptControlDown( event ) {
+  				this._handleMouseDownRotate( event );
 
-  			if ( event.key === 'Control' ) {
+  				this.state = _STATE.ROTATE;
 
-  				controlActive = true;
+  			} else {
 
+  				if ( this.enablePan === false ) return;
 
-  				const document = scope.domElement.getRootNode(); // offscreen canvas compatibility
+  				this._handleMouseDownPan( event );
 
-  				document.addEventListener( 'keyup', interceptControlUp, { passive: true, capture: true } );
+  				this.state = _STATE.PAN;
 
   			}
 
-  		}
-
-  		function interceptControlUp( event ) {
+  			break;
 
-  			if ( event.key === 'Control' ) {
+  		default:
 
-  				controlActive = false;
+  			this.state = _STATE.NONE;
 
+  	}
 
-  				const document = scope.domElement.getRootNode(); // offscreen canvas compatibility
+  	if ( this.state !== _STATE.NONE ) {
 
-  				document.removeEventListener( 'keyup', interceptControlUp, { passive: true, capture: true } );
+  		this.dispatchEvent( _startEvent );
 
-  			}
+  	}
 
-  		}
+  }
 
-  		function onKeyDown( event ) {
+  function onMouseMove( event ) {
 
-  			if ( scope.enabled === false || scope.enablePan === false ) return;
+  	switch ( this.state ) {
 
-  			handleKeyDown( event );
+  		case _STATE.ROTATE:
 
-  		}
+  			if ( this.enableRotate === false ) return;
 
-  		function onTouchStart( event ) {
+  			this._handleMouseMoveRotate( event );
 
-  			trackPointer( event );
+  			break;
 
-  			switch ( pointers.length ) {
+  		case _STATE.DOLLY:
 
-  				case 1:
+  			if ( this.enableZoom === false ) return;
 
-  					switch ( scope.touches.ONE ) {
+  			this._handleMouseMoveDolly( event );
 
-  						case three$1.TOUCH.ROTATE:
+  			break;
 
-  							if ( scope.enableRotate === false ) return;
+  		case _STATE.PAN:
 
-  							handleTouchStartRotate( event );
+  			if ( this.enablePan === false ) return;
 
-  							state = STATE.TOUCH_ROTATE;
+  			this._handleMouseMovePan( event );
 
-  							break;
+  			break;
 
-  						case three$1.TOUCH.PAN:
+  	}
 
-  							if ( scope.enablePan === false ) return;
+  }
 
-  							handleTouchStartPan( event );
+  function onMouseWheel( event ) {
 
-  							state = STATE.TOUCH_PAN;
+  	if ( this.enabled === false || this.enableZoom === false || this.state !== _STATE.NONE ) return;
 
-  							break;
+  	event.preventDefault();
 
-  						default:
+  	this.dispatchEvent( _startEvent );
 
-  							state = STATE.NONE;
+  	this._handleMouseWheel( this._customWheelEvent( event ) );
 
-  					}
+  	this.dispatchEvent( _endEvent );
 
-  					break;
+  }
 
-  				case 2:
+  function onKeyDown$1( event ) {
 
-  					switch ( scope.touches.TWO ) {
+  	if ( this.enabled === false || this.enablePan === false ) return;
 
-  						case three$1.TOUCH.DOLLY_PAN:
+  	this._handleKeyDown( event );
 
-  							if ( scope.enableZoom === false && scope.enablePan === false ) return;
+  }
 
-  							handleTouchStartDollyPan( event );
+  function onTouchStart( event ) {
 
-  							state = STATE.TOUCH_DOLLY_PAN;
+  	this._trackPointer( event );
 
-  							break;
+  	switch ( this._pointers.length ) {
 
-  						case three$1.TOUCH.DOLLY_ROTATE:
+  		case 1:
 
-  							if ( scope.enableZoom === false && scope.enableRotate === false ) return;
+  			switch ( this.touches.ONE ) {
 
-  							handleTouchStartDollyRotate( event );
+  				case three$1.TOUCH.ROTATE:
 
-  							state = STATE.TOUCH_DOLLY_ROTATE;
+  					if ( this.enableRotate === false ) return;
 
-  							break;
+  					this._handleTouchStartRotate( event );
 
-  						default:
+  					this.state = _STATE.TOUCH_ROTATE;
 
-  							state = STATE.NONE;
+  					break;
 
-  					}
+  				case three$1.TOUCH.PAN:
 
-  					break;
+  					if ( this.enablePan === false ) return;
 
-  				default:
+  					this._handleTouchStartPan( event );
 
-  					state = STATE.NONE;
+  					this.state = _STATE.TOUCH_PAN;
 
-  			}
+  					break;
 
-  			if ( state !== STATE.NONE ) {
+  				default:
 
-  				scope.dispatchEvent( _startEvent );
+  					this.state = _STATE.NONE;
 
   			}
 
-  		}
-
-  		function onTouchMove( event ) {
+  			break;
 
-  			trackPointer( event );
+  		case 2:
 
-  			switch ( state ) {
+  			switch ( this.touches.TWO ) {
 
-  				case STATE.TOUCH_ROTATE:
+  				case three$1.TOUCH.DOLLY_PAN:
 
-  					if ( scope.enableRotate === false ) return;
+  					if ( this.enableZoom === false && this.enablePan === false ) return;
 
-  					handleTouchMoveRotate( event );
+  					this._handleTouchStartDollyPan( event );
 
-  					scope.update();
+  					this.state = _STATE.TOUCH_DOLLY_PAN;
 
   					break;
 
-  				case STATE.TOUCH_PAN:
+  				case three$1.TOUCH.DOLLY_ROTATE:
 
-  					if ( scope.enablePan === false ) return;
+  					if ( this.enableZoom === false && this.enableRotate === false ) return;
 
-  					handleTouchMovePan( event );
+  					this._handleTouchStartDollyRotate( event );
 
-  					scope.update();
+  					this.state = _STATE.TOUCH_DOLLY_ROTATE;
 
   					break;
 
-  				case STATE.TOUCH_DOLLY_PAN:
+  				default:
 
-  					if ( scope.enableZoom === false && scope.enablePan === false ) return;
+  					this.state = _STATE.NONE;
 
-  					handleTouchMoveDollyPan( event );
+  			}
 
-  					scope.update();
+  			break;
 
-  					break;
+  		default:
 
-  				case STATE.TOUCH_DOLLY_ROTATE:
+  			this.state = _STATE.NONE;
 
-  					if ( scope.enableZoom === false && scope.enableRotate === false ) return;
+  	}
 
-  					handleTouchMoveDollyRotate( event );
+  	if ( this.state !== _STATE.NONE ) {
 
-  					scope.update();
+  		this.dispatchEvent( _startEvent );
 
-  					break;
+  	}
 
-  				default:
+  }
 
-  					state = STATE.NONE;
+  function onTouchMove( event ) {
 
-  			}
+  	this._trackPointer( event );
 
-  		}
+  	switch ( this.state ) {
 
-  		function onContextMenu( event ) {
+  		case _STATE.TOUCH_ROTATE:
 
-  			if ( scope.enabled === false ) return;
+  			if ( this.enableRotate === false ) return;
 
-  			event.preventDefault();
+  			this._handleTouchMoveRotate( event );
 
-  		}
+  			this.update();
 
-  		function addPointer( event ) {
+  			break;
 
-  			pointers.push( event.pointerId );
+  		case _STATE.TOUCH_PAN:
 
-  		}
+  			if ( this.enablePan === false ) return;
 
-  		function removePointer( event ) {
+  			this._handleTouchMovePan( event );
 
-  			delete pointerPositions[ event.pointerId ];
+  			this.update();
 
-  			for ( let i = 0; i < pointers.length; i ++ ) {
+  			break;
 
-  				if ( pointers[ i ] == event.pointerId ) {
+  		case _STATE.TOUCH_DOLLY_PAN:
 
-  					pointers.splice( i, 1 );
-  					return;
+  			if ( this.enableZoom === false && this.enablePan === false ) return;
 
-  				}
+  			this._handleTouchMoveDollyPan( event );
 
-  			}
+  			this.update();
 
-  		}
+  			break;
 
-  		function isTrackingPointer( event ) {
+  		case _STATE.TOUCH_DOLLY_ROTATE:
 
-  			for ( let i = 0; i < pointers.length; i ++ ) {
+  			if ( this.enableZoom === false && this.enableRotate === false ) return;
 
-  				if ( pointers[ i ] == event.pointerId ) return true;
+  			this._handleTouchMoveDollyRotate( event );
 
-  			}
+  			this.update();
 
-  			return false;
+  			break;
 
-  		}
+  		default:
 
-  		function trackPointer( event ) {
+  			this.state = _STATE.NONE;
 
-  			let position = pointerPositions[ event.pointerId ];
+  	}
 
-  			if ( position === undefined ) {
+  }
 
-  				position = new three$1.Vector2();
-  				pointerPositions[ event.pointerId ] = position;
+  function onContextMenu$1( event ) {
 
-  			}
+  	if ( this.enabled === false ) return;
 
-  			position.set( event.pageX, event.pageY );
+  	event.preventDefault();
 
-  		}
+  }
 
-  		function getSecondPointerPosition( event ) {
+  function interceptControlDown( event ) {
 
-  			const pointerId = ( event.pointerId === pointers[ 0 ] ) ? pointers[ 1 ] : pointers[ 0 ];
+  	if ( event.key === 'Control' ) {
 
-  			return pointerPositions[ pointerId ];
+  		this._controlActive = true;
 
-  		}
+  		const document = this.domElement.getRootNode(); // offscreen canvas compatibility
 
-  		//
+  		document.addEventListener( 'keyup', this._interceptControlUp, { passive: true, capture: true } );
+
+  	}
 
-  		scope.domElement.addEventListener( 'contextmenu', onContextMenu );
+  }
 
-  		scope.domElement.addEventListener( 'pointerdown', onPointerDown );
-  		scope.domElement.addEventListener( 'pointercancel', onPointerUp );
-  		scope.domElement.addEventListener( 'wheel', onMouseWheel, { passive: false } );
+  function interceptControlUp( event ) {
 
-  		const document = scope.domElement.getRootNode(); // offscreen canvas compatibility
+  	if ( event.key === 'Control' ) {
 
-  		document.addEventListener( 'keydown', interceptControlDown, { passive: true, capture: true } );
+  		this._controlActive = false;
 
-  		// force an update at start
+  		const document = this.domElement.getRootNode(); // offscreen canvas compatibility
 
-  		this.update();
+  		document.removeEventListener( 'keyup', this._interceptControlUp, { passive: true, capture: true } );
 
   	}
 
@@ -2454,19 +2445,14 @@
 
   const _changeEvent = { type: 'change' };
 
-  class FlyControls extends three$1.EventDispatcher {
-
-  	constructor( object, domElement ) {
+  const _EPS = 0.000001;
+  const _tmpQuaternion = new three$1.Quaternion();
 
-  		super();
-
-  		this.object = object;
-  		this.domElement = domElement;
+  class FlyControls extends three$1.Controls {
 
-  		// API
+  	constructor( object, domElement = null ) {
 
-  		// Set to false to disable this control
-  		this.enabled = true;
+  		super( object, domElement );
 
   		this.movementSpeed = 1.0;
   		this.rollSpeed = 0.005;
@@ -2474,301 +2460,312 @@
   		this.dragToLook = false;
   		this.autoForward = false;
 
-  		// disable default target object behavior
-
   		// internals
 
-  		const scope = this;
+  		this._moveState = { up: 0, down: 0, left: 0, right: 0, forward: 0, back: 0, pitchUp: 0, pitchDown: 0, yawLeft: 0, yawRight: 0, rollLeft: 0, rollRight: 0 };
+  		this._moveVector = new three$1.Vector3( 0, 0, 0 );
+  		this._rotationVector = new three$1.Vector3( 0, 0, 0 );
+  		this._lastQuaternion = new three$1.Quaternion();
+  		this._lastPosition = new three$1.Vector3();
+  		this._status = 0;
 
-  		const EPS = 0.000001;
+  		// event listeners
 
-  		const lastQuaternion = new three$1.Quaternion();
-  		const lastPosition = new three$1.Vector3();
+  		this._onKeyDown = onKeyDown.bind( this );
+  		this._onKeyUp = onKeyUp.bind( this );
+  		this._onPointerMove = onPointerMove.bind( this );
+  		this._onPointerDown = onPointerDown.bind( this );
+  		this._onPointerUp = onPointerUp.bind( this );
+  		this._onPointerCancel = onPointerCancel.bind( this );
+  		this._onContextMenu = onContextMenu.bind( this );
+
+  		//
 
-  		this.tmpQuaternion = new three$1.Quaternion();
+  		if ( domElement !== null ) {
 
-  		this.status = 0;
+  			this.connect();
 
-  		this.moveState = { up: 0, down: 0, left: 0, right: 0, forward: 0, back: 0, pitchUp: 0, pitchDown: 0, yawLeft: 0, yawRight: 0, rollLeft: 0, rollRight: 0 };
-  		this.moveVector = new three$1.Vector3( 0, 0, 0 );
-  		this.rotationVector = new three$1.Vector3( 0, 0, 0 );
+  		}
 
-  		this.keydown = function ( event ) {
+  	}
 
-  			if ( event.altKey || this.enabled === false ) {
+  	connect() {
 
-  				return;
+  		window.addEventListener( 'keydown', this._onKeyDown );
+  		window.addEventListener( 'keyup', this._onKeyUp );
 
-  			}
+  		this.domElement.addEventListener( 'pointermove', this._onPointerMove );
+  		this.domElement.addEventListener( 'pointerdown', this._onPointerDown );
+  		this.domElement.addEventListener( 'pointerup', this._onPointerUp );
+  		this.domElement.addEventListener( 'pointercancel', this._onPointerCancel );
+  		this.domElement.addEventListener( 'contextmenu', this._onContextMenu );
 
-  			switch ( event.code ) {
+  	}
 
-  				case 'ShiftLeft':
-  				case 'ShiftRight': this.movementSpeedMultiplier = .1; break;
+  	disconnect() {
 
-  				case 'KeyW': this.moveState.forward = 1; break;
-  				case 'KeyS': this.moveState.back = 1; break;
+  		window.removeEventListener( 'keydown', this._onKeyDown );
+  		window.removeEventListener( 'keyup', this._onKeyUp );
 
-  				case 'KeyA': this.moveState.left = 1; break;
-  				case 'KeyD': this.moveState.right = 1; break;
+  		this.domElement.removeEventListener( 'pointermove', this._onPointerMove );
+  		this.domElement.removeEventListener( 'pointerdown', this._onPointerDown );
+  		this.domElement.removeEventListener( 'pointerup', this._onPointerUp );
+  		this.domElement.removeEventListener( 'pointercancel', this._onPointerCancel );
+  		this.domElement.removeEventListener( 'contextmenu', this._onContextMenu );
 
-  				case 'KeyR': this.moveState.up = 1; break;
-  				case 'KeyF': this.moveState.down = 1; break;
+  	}
 
-  				case 'ArrowUp': this.moveState.pitchUp = 1; break;
-  				case 'ArrowDown': this.moveState.pitchDown = 1; break;
+  	dispose() {
 
-  				case 'ArrowLeft': this.moveState.yawLeft = 1; break;
-  				case 'ArrowRight': this.moveState.yawRight = 1; break;
+  		this.disconnect();
 
-  				case 'KeyQ': this.moveState.rollLeft = 1; break;
-  				case 'KeyE': this.moveState.rollRight = 1; break;
+  	}
 
-  			}
+  	update( delta ) {
 
-  			this.updateMovementVector();
-  			this.updateRotationVector();
+  		if ( this.enabled === false ) return;
 
-  		};
+  		const object = this.object;
 
-  		this.keyup = function ( event ) {
+  		const moveMult = delta * this.movementSpeed;
+  		const rotMult = delta * this.rollSpeed;
 
-  			if ( this.enabled === false ) return;
+  		object.translateX( this._moveVector.x * moveMult );
+  		object.translateY( this._moveVector.y * moveMult );
+  		object.translateZ( this._moveVector.z * moveMult );
 
-  			switch ( event.code ) {
+  		_tmpQuaternion.set( this._rotationVector.x * rotMult, this._rotationVector.y * rotMult, this._rotationVector.z * rotMult, 1 ).normalize();
+  		object.quaternion.multiply( _tmpQuaternion );
 
-  				case 'ShiftLeft':
-  				case 'ShiftRight': this.movementSpeedMultiplier = 1; break;
+  		if (
+  			this._lastPosition.distanceToSquared( object.position ) > _EPS ||
+  			8 * ( 1 - this._lastQuaternion.dot( object.quaternion ) ) > _EPS
+  		) {
 
-  				case 'KeyW': this.moveState.forward = 0; break;
-  				case 'KeyS': this.moveState.back = 0; break;
+  			this.dispatchEvent( _changeEvent );
+  			this._lastQuaternion.copy( object.quaternion );
+  			this._lastPosition.copy( object.position );
 
-  				case 'KeyA': this.moveState.left = 0; break;
-  				case 'KeyD': this.moveState.right = 0; break;
+  		}
 
-  				case 'KeyR': this.moveState.up = 0; break;
-  				case 'KeyF': this.moveState.down = 0; break;
+  	}
 
-  				case 'ArrowUp': this.moveState.pitchUp = 0; break;
-  				case 'ArrowDown': this.moveState.pitchDown = 0; break;
+  	// private
 
-  				case 'ArrowLeft': this.moveState.yawLeft = 0; break;
-  				case 'ArrowRight': this.moveState.yawRight = 0; break;
+  	_updateMovementVector() {
 
-  				case 'KeyQ': this.moveState.rollLeft = 0; break;
-  				case 'KeyE': this.moveState.rollRight = 0; break;
+  		const forward = ( this._moveState.forward || ( this.autoForward && ! this._moveState.back ) ) ? 1 : 0;
 
-  			}
+  		this._moveVector.x = ( - this._moveState.left + this._moveState.right );
+  		this._moveVector.y = ( - this._moveState.down + this._moveState.up );
+  		this._moveVector.z = ( - forward + this._moveState.back );
 
-  			this.updateMovementVector();
-  			this.updateRotationVector();
+  		//console.log( 'move:', [ this._moveVector.x, this._moveVector.y, this._moveVector.z ] );
 
-  		};
+  	}
 
-  		this.pointerdown = function ( event ) {
+  	_updateRotationVector() {
 
-  			if ( this.enabled === false ) return;
+  		this._rotationVector.x = ( - this._moveState.pitchDown + this._moveState.pitchUp );
+  		this._rotationVector.y = ( - this._moveState.yawRight + this._moveState.yawLeft );
+  		this._rotationVector.z = ( - this._moveState.rollRight + this._moveState.rollLeft );
 
-  			if ( this.dragToLook ) {
+  		//console.log( 'rotate:', [ this._rotationVector.x, this._rotationVector.y, this._rotationVector.z ] );
 
-  				this.status ++;
+  	}
 
-  			} else {
+  	_getContainerDimensions() {
 
-  				switch ( event.button ) {
+  		if ( this.domElement != document ) {
 
-  					case 0: this.moveState.forward = 1; break;
-  					case 2: this.moveState.back = 1; break;
+  			return {
+  				size: [ this.domElement.offsetWidth, this.domElement.offsetHeight ],
+  				offset: [ this.domElement.offsetLeft, this.domElement.offsetTop ]
+  			};
 
-  				}
+  		} else {
 
-  				this.updateMovementVector();
+  			return {
+  				size: [ window.innerWidth, window.innerHeight ],
+  				offset: [ 0, 0 ]
+  			};
 
-  			}
+  		}
 
-  		};
+  	}
 
-  		this.pointermove = function ( event ) {
+  }
 
-  			if ( this.enabled === false ) return;
+  function onKeyDown( event ) {
 
-  			if ( ! this.dragToLook || this.status > 0 ) {
+  	if ( event.altKey || this.enabled === false ) {
 
-  				const container = this.getContainerDimensions();
-  				const halfWidth = container.size[ 0 ] / 2;
-  				const halfHeight = container.size[ 1 ] / 2;
+  		return;
 
-  				this.moveState.yawLeft = - ( ( event.pageX - container.offset[ 0 ] ) - halfWidth ) / halfWidth;
-  				this.moveState.pitchDown = ( ( event.pageY - container.offset[ 1 ] ) - halfHeight ) / halfHeight;
+  	}
 
-  				this.updateRotationVector();
+  	switch ( event.code ) {
 
-  			}
+  		case 'ShiftLeft':
+  		case 'ShiftRight': this.movementSpeedMultiplier = .1; break;
 
-  		};
+  		case 'KeyW': this._moveState.forward = 1; break;
+  		case 'KeyS': this._moveState.back = 1; break;
 
-  		this.pointerup = function ( event ) {
+  		case 'KeyA': this._moveState.left = 1; break;
+  		case 'KeyD': this._moveState.right = 1; break;
 
-  			if ( this.enabled === false ) return;
+  		case 'KeyR': this._moveState.up = 1; break;
+  		case 'KeyF': this._moveState.down = 1; break;
 
-  			if ( this.dragToLook ) {
+  		case 'ArrowUp': this._moveState.pitchUp = 1; break;
+  		case 'ArrowDown': this._moveState.pitchDown = 1; break;
 
-  				this.status --;
+  		case 'ArrowLeft': this._moveState.yawLeft = 1; break;
+  		case 'ArrowRight': this._moveState.yawRight = 1; break;
 
-  				this.moveState.yawLeft = this.moveState.pitchDown = 0;
+  		case 'KeyQ': this._moveState.rollLeft = 1; break;
+  		case 'KeyE': this._moveState.rollRight = 1; break;
 
-  			} else {
+  	}
 
-  				switch ( event.button ) {
+  	this._updateMovementVector();
+  	this._updateRotationVector();
 
-  					case 0: this.moveState.forward = 0; break;
-  					case 2: this.moveState.back = 0; break;
+  }
 
-  				}
+  function onKeyUp( event ) {
 
-  				this.updateMovementVector();
+  	if ( this.enabled === false ) return;
 
-  			}
+  	switch ( event.code ) {
 
-  			this.updateRotationVector();
+  		case 'ShiftLeft':
+  		case 'ShiftRight': this.movementSpeedMultiplier = 1; break;
 
-  		};
+  		case 'KeyW': this._moveState.forward = 0; break;
+  		case 'KeyS': this._moveState.back = 0; break;
 
-  		this.pointercancel = function () {
+  		case 'KeyA': this._moveState.left = 0; break;
+  		case 'KeyD': this._moveState.right = 0; break;
 
-  			if ( this.enabled === false ) return;
+  		case 'KeyR': this._moveState.up = 0; break;
+  		case 'KeyF': this._moveState.down = 0; break;
 
-  			if ( this.dragToLook ) {
+  		case 'ArrowUp': this._moveState.pitchUp = 0; break;
+  		case 'ArrowDown': this._moveState.pitchDown = 0; break;
 
-  				this.status = 0;
+  		case 'ArrowLeft': this._moveState.yawLeft = 0; break;
+  		case 'ArrowRight': this._moveState.yawRight = 0; break;
 
-  				this.moveState.yawLeft = this.moveState.pitchDown = 0;
+  		case 'KeyQ': this._moveState.rollLeft = 0; break;
+  		case 'KeyE': this._moveState.rollRight = 0; break;
 
-  			} else {
+  	}
 
-  				this.moveState.forward = 0;
-  				this.moveState.back = 0;
+  	this._updateMovementVector();
+  	this._updateRotationVector();
 
-  				this.updateMovementVector();
+  }
 
-  			}
+  function onPointerDown( event ) {
 
-  			this.updateRotationVector();
+  	if ( this.enabled === false ) return;
 
-  		};
+  	if ( this.dragToLook ) {
 
-  		this.contextMenu = function ( event ) {
+  		this._status ++;
 
-  			if ( this.enabled === false ) return;
+  	} else {
 
-  			event.preventDefault();
+  		switch ( event.button ) {
 
-  		};
+  			case 0: this._moveState.forward = 1; break;
+  			case 2: this._moveState.back = 1; break;
 
-  		this.update = function ( delta ) {
+  		}
 
-  			if ( this.enabled === false ) return;
+  		this._updateMovementVector();
 
-  			const moveMult = delta * scope.movementSpeed;
-  			const rotMult = delta * scope.rollSpeed;
+  	}
 
-  			scope.object.translateX( scope.moveVector.x * moveMult );
-  			scope.object.translateY( scope.moveVector.y * moveMult );
-  			scope.object.translateZ( scope.moveVector.z * moveMult );
+  }
 
-  			scope.tmpQuaternion.set( scope.rotationVector.x * rotMult, scope.rotationVector.y * rotMult, scope.rotationVector.z * rotMult, 1 ).normalize();
-  			scope.object.quaternion.multiply( scope.tmpQuaternion );
+  function onPointerMove( event ) {
 
-  			if (
-  				lastPosition.distanceToSquared( scope.object.position ) > EPS ||
-  				8 * ( 1 - lastQuaternion.dot( scope.object.quaternion ) ) > EPS
-  			) {
+  	if ( this.enabled === false ) return;
 
-  				scope.dispatchEvent( _changeEvent );
-  				lastQuaternion.copy( scope.object.quaternion );
-  				lastPosition.copy( scope.object.position );
+  	if ( ! this.dragToLook || this._status > 0 ) {
 
-  			}
+  		const container = this._getContainerDimensions();
+  		const halfWidth = container.size[ 0 ] / 2;
+  		const halfHeight = container.size[ 1 ] / 2;
 
-  		};
+  		this._moveState.yawLeft = - ( ( event.pageX - container.offset[ 0 ] ) - halfWidth ) / halfWidth;
+  		this._moveState.pitchDown = ( ( event.pageY - container.offset[ 1 ] ) - halfHeight ) / halfHeight;
 
-  		this.updateMovementVector = function () {
+  		this._updateRotationVector();
 
-  			const forward = ( this.moveState.forward || ( this.autoForward && ! this.moveState.back ) ) ? 1 : 0;
+  	}
 
-  			this.moveVector.x = ( - this.moveState.left + this.moveState.right );
-  			this.moveVector.y = ( - this.moveState.down + this.moveState.up );
-  			this.moveVector.z = ( - forward + this.moveState.back );
+  }
 
-  			//console.log( 'move:', [ this.moveVector.x, this.moveVector.y, this.moveVector.z ] );
+  function onPointerUp( event ) {
 
-  		};
+  	if ( this.enabled === false ) return;
 
-  		this.updateRotationVector = function () {
+  	if ( this.dragToLook ) {
 
-  			this.rotationVector.x = ( - this.moveState.pitchDown + this.moveState.pitchUp );
-  			this.rotationVector.y = ( - this.moveState.yawRight + this.moveState.yawLeft );
-  			this.rotationVector.z = ( - this.moveState.rollRight + this.moveState.rollLeft );
+  		this._status --;
 
-  			//console.log( 'rotate:', [ this.rotationVector.x, this.rotationVector.y, this.rotationVector.z ] );
+  		this._moveState.yawLeft = this._moveState.pitchDown = 0;
 
-  		};
+  	} else {
 
-  		this.getContainerDimensions = function () {
+  		switch ( event.button ) {
 
-  			if ( this.domElement != document ) {
+  			case 0: this._moveState.forward = 0; break;
+  			case 2: this._moveState.back = 0; break;
 
-  				return {
-  					size: [ this.domElement.offsetWidth, this.domElement.offsetHeight ],
-  					offset: [ this.domElement.offsetLeft, this.domElement.offsetTop ]
-  				};
+  		}
 
-  			} else {
+  		this._updateMovementVector();
 
-  				return {
-  					size: [ window.innerWidth, window.innerHeight ],
-  					offset: [ 0, 0 ]
-  				};
+  	}
 
-  			}
+  	this._updateRotationVector();
 
-  		};
+  }
 
-  		this.dispose = function () {
+  function onPointerCancel() {
 
-  			this.domElement.removeEventListener( 'contextmenu', _contextmenu );
-  			this.domElement.removeEventListener( 'pointerdown', _pointerdown );
-  			this.domElement.removeEventListener( 'pointermove', _pointermove );
-  			this.domElement.removeEventListener( 'pointerup', _pointerup );
-  			this.domElement.removeEventListener( 'pointercancel', _pointercancel );
+  	if ( this.enabled === false ) return;
 
-  			window.removeEventListener( 'keydown', _keydown );
-  			window.removeEventListener( 'keyup', _keyup );
+  	if ( this.dragToLook ) {
 
-  		};
+  		this._status = 0;
 
-  		const _contextmenu = this.contextMenu.bind( this );
-  		const _pointermove = this.pointermove.bind( this );
-  		const _pointerdown = this.pointerdown.bind( this );
-  		const _pointerup = this.pointerup.bind( this );
-  		const _pointercancel = this.pointercancel.bind( this );
-  		const _keydown = this.keydown.bind( this );
-  		const _keyup = this.keyup.bind( this );
+  		this._moveState.yawLeft = this._moveState.pitchDown = 0;
 
-  		this.domElement.addEventListener( 'contextmenu', _contextmenu );
-  		this.domElement.addEventListener( 'pointerdown', _pointerdown );
-  		this.domElement.addEventListener( 'pointermove', _pointermove );
-  		this.domElement.addEventListener( 'pointerup', _pointerup );
-  		this.domElement.addEventListener( 'pointercancel', _pointercancel );
+  	} else {
 
-  		window.addEventListener( 'keydown', _keydown );
-  		window.addEventListener( 'keyup', _keyup );
+  		this._moveState.forward = 0;
+  		this._moveState.back = 0;
 
-  		this.updateMovementVector();
-  		this.updateRotationVector();
+  		this._updateMovementVector();
 
   	}
 
+  	this._updateRotationVector();
+
+  }
+
+  function onContextMenu( event ) {
+
+  	if ( this.enabled === false ) return;
+
+  	event.preventDefault();
+
   }
 
   /**
@@ -3330,7 +3327,7 @@
   		if ( this.clearColor !== null ) {
 
   			renderer.getClearColor( this._oldClearColor );
-  			renderer.setClearColor( this.clearColor );
+  			renderer.setClearColor( this.clearColor, renderer.getClearAlpha() );
 
   		}
 
@@ -3385,53 +3382,41 @@
   }
 
   function _extends() {
-    _extends = Object.assign ? Object.assign.bind() : function (target) {
-      for (var i = 1; i < arguments.length; i++) {
-        var source = arguments[i];
-        for (var key in source) {
-          if (Object.prototype.hasOwnProperty.call(source, key)) {
-            target[key] = source[key];
-          }
-        }
+    return _extends = Object.assign ? Object.assign.bind() : function (n) {
+      for (var e = 1; e < arguments.length; e++) {
+        var t = arguments[e];
+        for (var r in t) ({}).hasOwnProperty.call(t, r) && (n[r] = t[r]);
       }
-      return target;
-    };
-    return _extends.apply(this, arguments);
+      return n;
+    }, _extends.apply(null, arguments);
   }
 
-  function _assertThisInitialized(self) {
-    if (self === void 0) {
-      throw new ReferenceError("this hasn't been initialised - super() hasn't been called");
-    }
-    return self;
+  function _assertThisInitialized(e) {
+    if (void 0 === e) throw new ReferenceError("this hasn't been initialised - super() hasn't been called");
+    return e;
   }
 
-  function _setPrototypeOf(o, p) {
-    _setPrototypeOf = Object.setPrototypeOf ? Object.setPrototypeOf.bind() : function _setPrototypeOf(o, p) {
-      o.__proto__ = p;
-      return o;
-    };
-    return _setPrototypeOf(o, p);
+  function _setPrototypeOf(t, e) {
+    return _setPrototypeOf = Object.setPrototypeOf ? Object.setPrototypeOf.bind() : function (t, e) {
+      return t.__proto__ = e, t;
+    }, _setPrototypeOf(t, e);
   }
 
-  function _inheritsLoose(subClass, superClass) {
-    subClass.prototype = Object.create(superClass.prototype);
-    subClass.prototype.constructor = subClass;
-    _setPrototypeOf(subClass, superClass);
+  function _inheritsLoose(t, o) {
+    t.prototype = Object.create(o.prototype), t.prototype.constructor = t, _setPrototypeOf(t, o);
   }
 
-  function _getPrototypeOf(o) {
-    _getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf.bind() : function _getPrototypeOf(o) {
-      return o.__proto__ || Object.getPrototypeOf(o);
-    };
-    return _getPrototypeOf(o);
+  function _getPrototypeOf(t) {
+    return _getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf.bind() : function (t) {
+      return t.__proto__ || Object.getPrototypeOf(t);
+    }, _getPrototypeOf(t);
   }
 
-  function _isNativeFunction(fn) {
+  function _isNativeFunction(t) {
     try {
-      return Function.toString.call(fn).indexOf("[native code]") !== -1;
-    } catch (e) {
-      return typeof fn === "function";
+      return -1 !== Function.toString.call(t).indexOf("[native code]");
+    } catch (n) {
+      return "function" == typeof t;
     }
   }
 
@@ -3452,31 +3437,27 @@
     return r && _setPrototypeOf(p, r.prototype), p;
   }
 
-  function _wrapNativeSuper(Class) {
-    var _cache = typeof Map === "function" ? new Map() : undefined;
-    _wrapNativeSuper = function _wrapNativeSuper(Class) {
-      if (Class === null || !_isNativeFunction(Class)) return Class;
-      if (typeof Class !== "function") {
-        throw new TypeError("Super expression must either be null or a function");
-      }
-      if (typeof _cache !== "undefined") {
-        if (_cache.has(Class)) return _cache.get(Class);
-        _cache.set(Class, Wrapper);
+  function _wrapNativeSuper(t) {
+    var r = "function" == typeof Map ? new Map() : void 0;
+    return _wrapNativeSuper = function _wrapNativeSuper(t) {
+      if (null === t || !_isNativeFunction(t)) return t;
+      if ("function" != typeof t) throw new TypeError("Super expression must either be null or a function");
+      if (void 0 !== r) {
+        if (r.has(t)) return r.get(t);
+        r.set(t, Wrapper);
       }
       function Wrapper() {
-        return _construct(Class, arguments, _getPrototypeOf(this).constructor);
+        return _construct(t, arguments, _getPrototypeOf(this).constructor);
       }
-      Wrapper.prototype = Object.create(Class.prototype, {
+      return Wrapper.prototype = Object.create(t.prototype, {
         constructor: {
           value: Wrapper,
-          enumerable: false,
-          writable: true,
-          configurable: true
+          enumerable: !1,
+          writable: !0,
+          configurable: !0
         }
-      });
-      return _setPrototypeOf(Wrapper, Class);
-    };
-    return _wrapNativeSuper(Class);
+      }), _setPrototypeOf(Wrapper, t);
+    }, _wrapNativeSuper(t);
   }
 
   // based on https://github.com/styled-components/styled-components/blob/fcf6f3804c57a14dd7984dfab7bc06ee2edca044/src/utils/error.js
@@ -4086,7 +4067,7 @@
    */
   function hsla(value, saturation, lightness, alpha) {
     if (typeof value === 'number' && typeof saturation === 'number' && typeof lightness === 'number' && typeof alpha === 'number') {
-      return "rgba(" + hslToRgb(value, saturation, lightness) + "," + alpha + ")";
+      return alpha >= 1 ? hslToHex(value, saturation, lightness) : "rgba(" + hslToRgb(value, saturation, lightness) + "," + alpha + ")";
     } else if (typeof value === 'object' && saturation === undefined && lightness === undefined && alpha === undefined) {
       return value.alpha >= 1 ? hslToHex(value.hue, value.saturation, value.lightness) : "rgba(" + hslToRgb(value.hue, value.saturation, value.lightness) + "," + value.alpha + ")";
     }
@@ -4164,7 +4145,7 @@
       var rgbValue = parseToRgb(firstValue);
       return "rgba(" + rgbValue.red + "," + rgbValue.green + "," + rgbValue.blue + "," + secondValue + ")";
     } else if (typeof firstValue === 'number' && typeof secondValue === 'number' && typeof thirdValue === 'number' && typeof fourthValue === 'number') {
-      return "rgba(" + firstValue + "," + secondValue + "," + thirdValue + "," + fourthValue + ")";
+      return fourthValue >= 1 ? rgb(firstValue, secondValue, thirdValue) : "rgba(" + firstValue + "," + secondValue + "," + thirdValue + "," + fourthValue + ")";
     } else if (typeof firstValue === 'object' && secondValue === undefined && thirdValue === undefined && fourthValue === undefined) {
       return firstValue.alpha >= 1 ? rgb(firstValue.red, firstValue.green, firstValue.blue) : "rgba(" + firstValue.red + "," + firstValue.green + "," + firstValue.blue + "," + firstValue.alpha + ")";
     }
@@ -4731,13 +4712,13 @@
               return amount;
           },
           In: function (amount) {
-              return this.None(amount);
+              return amount;
           },
           Out: function (amount) {
-              return this.None(amount);
+              return amount;
           },
           InOut: function (amount) {
-              return this.None(amount);
+              return amount;
           },
       }),
       Quadratic: Object.freeze({
@@ -4947,33 +4928,61 @@
    */
   var Group = /** @class */ (function () {
       function Group() {
+          var tweens = [];
+          for (var _i = 0; _i < arguments.length; _i++) {
+              tweens[_i] = arguments[_i];
+          }
           this._tweens = {};
           this._tweensAddedDuringUpdate = {};
+          this.add.apply(this, tweens);
       }
       Group.prototype.getAll = function () {
           var _this = this;
-          return Object.keys(this._tweens).map(function (tweenId) {
-              return _this._tweens[tweenId];
-          });
+          return Object.keys(this._tweens).map(function (tweenId) { return _this._tweens[tweenId]; });
       };
       Group.prototype.removeAll = function () {
           this._tweens = {};
       };
-      Group.prototype.add = function (tween) {
-          this._tweens[tween.getId()] = tween;
-          this._tweensAddedDuringUpdate[tween.getId()] = tween;
+      Group.prototype.add = function () {
+          var _a;
+          var tweens = [];
+          for (var _i = 0; _i < arguments.length; _i++) {
+              tweens[_i] = arguments[_i];
+          }
+          for (var _b = 0, tweens_1 = tweens; _b < tweens_1.length; _b++) {
+              var tween = tweens_1[_b];
+              // Remove from any other group first, a tween can only be in one group at a time.
+              // @ts-expect-error library internal access
+              (_a = tween._group) === null || _a === void 0 ? void 0 : _a.remove(tween);
+              // @ts-expect-error library internal access
+              tween._group = this;
+              this._tweens[tween.getId()] = tween;
+              this._tweensAddedDuringUpdate[tween.getId()] = tween;
+          }
+      };
+      Group.prototype.remove = function () {
+          var tweens = [];
+          for (var _i = 0; _i < arguments.length; _i++) {
+              tweens[_i] = arguments[_i];
+          }
+          for (var _a = 0, tweens_2 = tweens; _a < tweens_2.length; _a++) {
+              var tween = tweens_2[_a];
+              // @ts-expect-error library internal access
+              tween._group = undefined;
+              delete this._tweens[tween.getId()];
+              delete this._tweensAddedDuringUpdate[tween.getId()];
+          }
       };
-      Group.prototype.remove = function (tween) {
-          delete this._tweens[tween.getId()];
-          delete this._tweensAddedDuringUpdate[tween.getId()];
+      /** Return true if all tweens in the group are not paused or playing. */
+      Group.prototype.allStopped = function () {
+          return this.getAll().every(function (tween) { return !tween.isPlaying(); });
       };
       Group.prototype.update = function (time, preserve) {
           if (time === void 0) { time = now$1(); }
-          if (preserve === void 0) { preserve = false; }
+          if (preserve === void 0) { preserve = true; }
           var tweenIds = Object.keys(this._tweens);
-          if (tweenIds.length === 0) {
-              return false;
-          }
+          if (tweenIds.length === 0)
+              return;
           // Tweens are updated in "batches". If you add a new tween during an
           // update, then the new tween will be updated in the next batch.
           // If you remove a tween during an update, it may or may not be updated.
@@ -4984,13 +4993,11 @@
               for (var i = 0; i < tweenIds.length; i++) {
                   var tween = this._tweens[tweenIds[i]];
                   var autoStart = !preserve;
-                  if (tween && tween.update(time, autoStart) === false && !preserve) {
-                      delete this._tweens[tweenIds[i]];
-                  }
+                  if (tween && tween.update(time, autoStart) === false && !preserve)
+                      this.remove(tween);
               }
               tweenIds = Object.keys(this._tweensAddedDuringUpdate);
           }
-          return true;
       };
       return Group;
   }());
@@ -5099,10 +5106,7 @@
    * Thank you all, you're awesome!
    */
   var Tween = /** @class */ (function () {
-      function Tween(_object, _group) {
-          if (_group === void 0) { _group = mainGroup; }
-          this._object = _object;
-          this._group = _group;
+      function Tween(object, group) {
           this._isPaused = false;
           this._pauseStart = 0;
           this._valuesStart = {};
@@ -5127,6 +5131,16 @@
           this._isChainStopped = false;
           this._propertiesAreSetUp = false;
           this._goToEnd = false;
+          this._object = object;
+          if (typeof group === 'object') {
+              this._group = group;
+              group.add(this);
+          }
+          // Use "true" to restore old behavior (will be removed in future release).
+          else if (group === true) {
+              this._group = mainGroup;
+              mainGroup.add(this);
+          }
       }
       Tween.prototype.getId = function () {
           return this._id;
@@ -5165,8 +5179,6 @@
           if (this._isPlaying) {
               return this;
           }
-          // eslint-disable-next-line
-          this._group && this._group.add(this);
           this._repeat = this._initialRepeat;
           if (this._reversed) {
               // If we were reversed (f.e. using the yoyo feature) then we need to
@@ -5283,8 +5295,6 @@
           if (!this._isPlaying) {
               return this;
           }
-          // eslint-disable-next-line
-          this._group && this._group.remove(this);
           this._isPlaying = false;
           this._isPaused = false;
           if (this._onStopCallback) {
@@ -5294,7 +5304,7 @@
       };
       Tween.prototype.end = function () {
           this._goToEnd = true;
-          this.update(Infinity);
+          this.update(this._startTime + this._duration);
           return this;
       };
       Tween.prototype.pause = function (time) {
@@ -5304,8 +5314,6 @@
           }
           this._isPaused = true;
           this._pauseStart = time;
-          // eslint-disable-next-line
-          this._group && this._group.remove(this);
           return this;
       };
       Tween.prototype.resume = function (time) {
@@ -5316,8 +5324,6 @@
           this._isPaused = false;
           this._startTime += time - this._pauseStart;
           this._pauseStart = 0;
-          // eslint-disable-next-line
-          this._group && this._group.add(this);
           return this;
       };
       Tween.prototype.stopChainedTweens = function () {
@@ -5327,8 +5333,19 @@
           return this;
       };
       Tween.prototype.group = function (group) {
-          if (group === void 0) { group = mainGroup; }
-          this._group = group;
+          if (!group) {
+              console.warn('tween.group() without args has been removed, use group.add(tween) instead.');
+              return this;
+          }
+          group.add(this);
+          return this;
+      };
+      /**
+       * Removes the tween from whichever group it is in.
+       */
+      Tween.prototype.remove = function () {
+          var _a;
+          (_a = this._group) === null || _a === void 0 ? void 0 : _a.remove(this);
           return this;
       };
       Tween.prototype.delay = function (amount) {
@@ -5398,21 +5415,24 @@
        * @returns true if the tween is still playing after the update, false
        * otherwise (calling update on a paused tween still returns true because
        * it is still playing, just paused).
+       *
+       * @param autoStart - When true, calling update will implicitly call start()
+       * as well. Note, if you stop() or end() the tween, but are still calling
+       * update(), it will start again!
        */
       Tween.prototype.update = function (time, autoStart) {
           var _this = this;
           var _a;
           if (time === void 0) { time = now$1(); }
-          if (autoStart === void 0) { autoStart = true; }
+          if (autoStart === void 0) { autoStart = Tween.autoStartOnUpdate; }
           if (this._isPaused)
               return true;
           var property;
-          var endTime = this._startTime + this._duration;
           if (!this._goToEnd && !this._isPlaying) {
-              if (time > endTime)
-                  return false;
               if (autoStart)
                   this.start(time, true);
+              else
+                  return false;
           }
           this._goToEnd = false;
           if (time < this._startTime) {
@@ -5551,6 +5571,7 @@
           }
           this._valuesEnd[property] = tmp;
       };
+      Tween.autoStartOnUpdate = false;
       return Tween;
   }());
   /**
@@ -5564,11 +5585,246 @@
   // Modules and CommonJS, without build hacks, and so as not to break the
   // existing API.
   // https://github.com/rollup/rollup/issues/1961#issuecomment-423037881
+  /**
+   * @deprecated The global TWEEN Group will be removed in a following major
+   * release. To migrate, create a `new Group()` instead of using `TWEEN` as a
+   * group.
+   *
+   * Old code:
+   *
+   * ```js
+   * import * as TWEEN from '@tweenjs/tween.js'
+   *
+   * //...
+   *
+   * const tween = new TWEEN.Tween(obj)
+   * const tween2 = new TWEEN.Tween(obj2)
+   *
+   * //...
+   *
+   * requestAnimationFrame(function loop(time) {
+   *   TWEEN.update(time)
+   *   requestAnimationFrame(loop)
+   * })
+   * ```
+   *
+   * New code:
+   *
+   * ```js
+   * import {Tween, Group} from '@tweenjs/tween.js'
+   *
+   * //...
+   *
+   * const tween = new Tween(obj)
+   * const tween2 = new TWEEN.Tween(obj2)
+   *
+   * //...
+   *
+   * const group = new Group()
+   * group.add(tween)
+   * group.add(tween2)
+   *
+   * //...
+   *
+   * requestAnimationFrame(function loop(time) {
+   *   group.update(time)
+   *   requestAnimationFrame(loop)
+   * })
+   * ```
+   */
   TWEEN.getAll.bind(TWEEN);
+  /**
+   * @deprecated The global TWEEN Group will be removed in a following major
+   * release. To migrate, create a `new Group()` instead of using `TWEEN` as a
+   * group.
+   *
+   * Old code:
+   *
+   * ```js
+   * import * as TWEEN from '@tweenjs/tween.js'
+   *
+   * //...
+   *
+   * const tween = new TWEEN.Tween(obj)
+   * const tween2 = new TWEEN.Tween(obj2)
+   *
+   * //...
+   *
+   * requestAnimationFrame(function loop(time) {
+   *   TWEEN.update(time)
+   *   requestAnimationFrame(loop)
+   * })
+   * ```
+   *
+   * New code:
+   *
+   * ```js
+   * import {Tween, Group} from '@tweenjs/tween.js'
+   *
+   * //...
+   *
+   * const tween = new Tween(obj)
+   * const tween2 = new TWEEN.Tween(obj2)
+   *
+   * //...
+   *
+   * const group = new Group()
+   * group.add(tween)
+   * group.add(tween2)
+   *
+   * //...
+   *
+   * requestAnimationFrame(function loop(time) {
+   *   group.update(time)
+   *   requestAnimationFrame(loop)
+   * })
+   * ```
+   */
   TWEEN.removeAll.bind(TWEEN);
+  /**
+   * @deprecated The global TWEEN Group will be removed in a following major
+   * release. To migrate, create a `new Group()` instead of using `TWEEN` as a
+   * group.
+   *
+   * Old code:
+   *
+   * ```js
+   * import * as TWEEN from '@tweenjs/tween.js'
+   *
+   * //...
+   *
+   * const tween = new TWEEN.Tween(obj)
+   * const tween2 = new TWEEN.Tween(obj2)
+   *
+   * //...
+   *
+   * requestAnimationFrame(function loop(time) {
+   *   TWEEN.update(time)
+   *   requestAnimationFrame(loop)
+   * })
+   * ```
+   *
+   * New code:
+   *
+   * ```js
+   * import {Tween, Group} from '@tweenjs/tween.js'
+   *
+   * //...
+   *
+   * const tween = new Tween(obj)
+   * const tween2 = new TWEEN.Tween(obj2)
+   *
+   * //...
+   *
+   * const group = new Group()
+   * group.add(tween)
+   * group.add(tween2)
+   *
+   * //...
+   *
+   * requestAnimationFrame(function loop(time) {
+   *   group.update(time)
+   *   requestAnimationFrame(loop)
+   * })
+   * ```
+   */
   TWEEN.add.bind(TWEEN);
+  /**
+   * @deprecated The global TWEEN Group will be removed in a following major
+   * release. To migrate, create a `new Group()` instead of using `TWEEN` as a
+   * group.
+   *
+   * Old code:
+   *
+   * ```js
+   * import * as TWEEN from '@tweenjs/tween.js'
+   *
+   * //...
+   *
+   * const tween = new TWEEN.Tween(obj)
+   * const tween2 = new TWEEN.Tween(obj2)
+   *
+   * //...
+   *
+   * requestAnimationFrame(function loop(time) {
+   *   TWEEN.update(time)
+   *   requestAnimationFrame(loop)
+   * })
+   * ```
+   *
+   * New code:
+   *
+   * ```js
+   * import {Tween, Group} from '@tweenjs/tween.js'
+   *
+   * //...
+   *
+   * const tween = new Tween(obj)
+   * const tween2 = new TWEEN.Tween(obj2)
+   *
+   * //...
+   *
+   * const group = new Group()
+   * group.add(tween)
+   * group.add(tween2)
+   *
+   * //...
+   *
+   * requestAnimationFrame(function loop(time) {
+   *   group.update(time)
+   *   requestAnimationFrame(loop)
+   * })
+   * ```
+   */
   TWEEN.remove.bind(TWEEN);
-  var update = TWEEN.update.bind(TWEEN);
+  /**
+   * @deprecated The global TWEEN Group will be removed in a following major
+   * release. To migrate, create a `new Group()` instead of using `TWEEN` as a
+   * group.
+   *
+   * Old code:
+   *
+   * ```js
+   * import * as TWEEN from '@tweenjs/tween.js'
+   *
+   * //...
+   *
+   * const tween = new TWEEN.Tween(obj)
+   * const tween2 = new TWEEN.Tween(obj2)
+   *
+   * //...
+   *
+   * requestAnimationFrame(function loop(time) {
+   *   TWEEN.update(time)
+   *   requestAnimationFrame(loop)
+   * })
+   * ```
+   *
+   * New code:
+   *
+   * ```js
+   * import {Tween, Group} from '@tweenjs/tween.js'
+   *
+   * //...
+   *
+   * const tween = new Tween(obj)
+   * const tween2 = new TWEEN.Tween(obj2)
+   *
+   * //...
+   *
+   * const group = new Group()
+   * group.add(tween)
+   * group.add(tween2)
+   *
+   * //...
+   *
+   * requestAnimationFrame(function loop(time) {
+   *   group.update(time)
+   *   requestAnimationFrame(loop)
+   * })
+   * ```
+   */
+  TWEEN.update.bind(TWEEN);
 
   var index$1 = (function (p) {
     return typeof p === 'function' ? p // fn
@@ -6111,7 +6367,7 @@
     if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen);
   }
   function _arrayLikeToArray(arr, len) {
-    if (len > arr.length) len = arr.length;
+    if (len == null || len > arr.length) len = arr.length;
     for (var i = 0, arr2 = new Array(len); i < len; i++) arr2[i] = arr[i];
     return arr2;
   }
@@ -6380,7 +6636,7 @@
               state.hoverObj = topObject;
             }
           }
-          update(); // update camera animation tweens
+          state.tweenGroup.update(); // update camera animation tweens
         }
         return this;
       },
@@ -6411,10 +6667,10 @@
           } else {
             var camPos = Object.assign({}, camera.position);
             var camLookAt = getLookAt();
-            new Tween(camPos).to(finalPos, transitionDuration).easing(Easing.Quadratic.Out).onUpdate(setCameraPos).start();
+            state.tweenGroup.add(new Tween(camPos).to(finalPos, transitionDuration).easing(Easing.Quadratic.Out).onUpdate(setCameraPos).start());
 
             // Face direction in 1/3rd of time
-            new Tween(camLookAt).to(finalLookAt, transitionDuration / 3).easing(Easing.Quadratic.Out).onUpdate(setLookAt).start();
+            state.tweenGroup.add(new Tween(camLookAt).to(finalLookAt, transitionDuration / 3).easing(Easing.Quadratic.Out).onUpdate(setLookAt).start());
           }
           return this;
         }
@@ -6545,7 +6801,8 @@
       return {
         scene: new three.Scene(),
         camera: new three.PerspectiveCamera(),
-        clock: new three.Clock()
+        clock: new three.Clock(),
+        tweenGroup: new Group()
       };
     },
     init: function init(domNode, state) {