@tarsis/toolkit 0.1.0 → 0.1.2

package/dist/gl-B0ALaRuW.cjs

@@ -0,0 +1,3256 @@
+'use strict';
+
+Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+
+const index = require('./index-CsdKS34u.cjs');
+
+var commonjsGlobal = typeof globalThis !== 'undefined' ? globalThis : typeof window !== 'undefined' ? window : typeof global !== 'undefined' ? global : typeof self !== 'undefined' ? self : {};
+
+function getDefaultExportFromCjs (x) {
+	return x && x.__esModule && Object.prototype.hasOwnProperty.call(x, 'default') ? x['default'] : x;
+}
+
+function getAugmentedNamespace(n) {
+  if (n.__esModule) return n;
+  var f = n.default;
+	if (typeof f == "function") {
+		var a = function a () {
+			if (this instanceof a) {
+        return Reflect.construct(f, arguments, this.constructor);
+			}
+			return f.apply(this, arguments);
+		};
+		a.prototype = f.prototype;
+  } else a = {};
+  Object.defineProperty(a, '__esModule', {value: true});
+	Object.keys(n).forEach(function (k) {
+		var d = Object.getOwnPropertyDescriptor(n, k);
+		Object.defineProperty(a, k, d.get ? d : {
+			enumerable: true,
+			get: function () {
+				return n[k];
+			}
+		});
+	});
+	return a;
+}
+
+var threeOrbitControls;
+var hasRequiredThreeOrbitControls;
+
+function requireThreeOrbitControls () {
+	if (hasRequiredThreeOrbitControls) return threeOrbitControls;
+	hasRequiredThreeOrbitControls = 1;
+	threeOrbitControls = function( THREE ) {
+		/**
+		 * @author qiao / https://github.com/qiao
+		 * @author mrdoob / http://mrdoob.com
+		 * @author alteredq / http://alteredqualia.com/
+		 * @author WestLangley / http://github.com/WestLangley
+		 * @author erich666 / http://erichaines.com
+		 */
+
+	// This set of controls performs orbiting, dollying (zooming), and panning.
+	// Unlike TrackballControls, it maintains the "up" direction object.up (+Y by default).
+	//
+	//    Orbit - left mouse / touch: one finger move
+	//    Zoom - middle mouse, or mousewheel / touch: two finger spread or squish
+	//    Pan - right mouse, or arrow keys / touch: three finter swipe
+
+		function OrbitControls( object, domElement ) {
+
+			this.object = object;
+
+			this.domElement = ( domElement !== undefined ) ? domElement : document;
+
+			// Set to false to disable this control
+			this.enabled = true;
+
+			// "target" sets the location of focus, where the object orbits around
+			this.target = new THREE.Vector3();
+
+			// How far you can dolly in and out ( PerspectiveCamera only )
+			this.minDistance = 0;
+			this.maxDistance = Infinity;
+
+			// How far you can zoom in and out ( OrthographicCamera only )
+			this.minZoom = 0;
+			this.maxZoom = Infinity;
+
+			// How far you can orbit vertically, upper and lower limits.
+			// Range is 0 to Math.PI radians.
+			this.minPolarAngle = 0; // radians
+			this.maxPolarAngle = Math.PI; // radians
+
+			// How far you can orbit horizontally, upper and lower limits.
+			// If set, must be a sub-interval of the interval [ - Math.PI, Math.PI ].
+			this.minAzimuthAngle = - Infinity; // radians
+			this.maxAzimuthAngle = Infinity; // radians
+
+			// Set to true to enable damping (inertia)
+			// If damping is enabled, you must call controls.update() in your animation loop
+			this.enableDamping = false;
+			this.dampingFactor = 0.25;
+
+			// This option actually enables dollying in and out; left as "zoom" for backwards compatibility.
+			// Set to false to disable zooming
+			this.enableZoom = true;
+			this.zoomSpeed = 1.0;
+
+			// Set to false to disable rotating
+			this.enableRotate = true;
+			this.rotateSpeed = 1.0;
+
+			// Set to false to disable panning
+			this.enablePan = true;
+			this.keyPanSpeed = 7.0;	// pixels moved per arrow key push
+
+			// Set to true to automatically rotate around the target
+			// If auto-rotate is enabled, you must call controls.update() in your animation loop
+			this.autoRotate = false;
+			this.autoRotateSpeed = 2.0; // 30 seconds per round when fps is 60
+
+			// Set to false to disable use of the keys
+			this.enableKeys = true;
+
+			// The four arrow keys
+			this.keys = { LEFT: 37, UP: 38, RIGHT: 39, BOTTOM: 40 };
+
+			// Mouse buttons
+			this.mouseButtons = { ORBIT: THREE.MOUSE.LEFT, ZOOM: THREE.MOUSE.MIDDLE, PAN: THREE.MOUSE.RIGHT };
+
+			// for reset
+			this.target0 = this.target.clone();
+			this.position0 = this.object.position.clone();
+			this.zoom0 = this.object.zoom;
+
+			//
+			// public methods
+			//
+
+			this.getPolarAngle = function () {
+
+				return spherical.phi;
+
+			};
+
+			this.getAzimuthalAngle = function () {
+
+				return spherical.theta;
+
+			};
+
+			this.reset = function () {
+
+				scope.target.copy( scope.target0 );
+				scope.object.position.copy( scope.position0 );
+				scope.object.zoom = scope.zoom0;
+
+				scope.object.updateProjectionMatrix();
+				scope.dispatchEvent( changeEvent );
+
+				scope.update();
+
+				state = STATE.NONE;
+
+			};
+
+			// this method is exposed, but perhaps it would be better if we can make it private...
+			this.update = function() {
+
+				var offset = new THREE.Vector3();
+
+				// so camera.up is the orbit axis
+				var quat = new THREE.Quaternion().setFromUnitVectors( object.up, new THREE.Vector3( 0, 1, 0 ) );
+				var quatInverse = quat.clone().inverse();
+
+				var lastPosition = new THREE.Vector3();
+				var lastQuaternion = new THREE.Quaternion();
+
+				return function update () {
+
+					var position = scope.object.position;
+
+					offset.copy( position ).sub( scope.target );
+
+					// rotate offset to "y-axis-is-up" space
+					offset.applyQuaternion( quat );
+
+					// angle from z-axis around y-axis
+					spherical.setFromVector3( offset );
+
+					if ( scope.autoRotate && state === STATE.NONE ) {
+
+						rotateLeft( getAutoRotationAngle() );
+
+					}
+
+					spherical.theta += sphericalDelta.theta;
+					spherical.phi += sphericalDelta.phi;
+
+					// restrict theta to be between desired limits
+					spherical.theta = Math.max( scope.minAzimuthAngle, Math.min( scope.maxAzimuthAngle, spherical.theta ) );
+
+					// restrict phi to be between desired limits
+					spherical.phi = Math.max( scope.minPolarAngle, Math.min( scope.maxPolarAngle, spherical.phi ) );
+
+					spherical.makeSafe();
+
+
+					spherical.radius *= scale;
+
+					// restrict radius to be between desired limits
+					spherical.radius = Math.max( scope.minDistance, Math.min( scope.maxDistance, spherical.radius ) );
+
+					// move target to panned location
+					scope.target.add( panOffset );
+
+					offset.setFromSpherical( spherical );
+
+					// rotate offset back to "camera-up-vector-is-up" space
+					offset.applyQuaternion( quatInverse );
+
+					position.copy( scope.target ).add( offset );
+
+					scope.object.lookAt( scope.target );
+
+					if ( scope.enableDamping === true ) {
+
+						sphericalDelta.theta *= ( 1 - scope.dampingFactor );
+						sphericalDelta.phi *= ( 1 - scope.dampingFactor );
+
+					} else {
+
+						sphericalDelta.set( 0, 0, 0 );
+
+					}
+
+					scale = 1;
+					panOffset.set( 0, 0, 0 );
+
+					// update condition is:
+					// min(camera displacement, camera rotation in radians)^2 > EPS
+					// using small-angle approximation cos(x/2) = 1 - x^2 / 8
+
+					if ( zoomChanged ||
+						lastPosition.distanceToSquared( scope.object.position ) > EPS ||
+						8 * ( 1 - lastQuaternion.dot( scope.object.quaternion ) ) > EPS ) {
+
+						scope.dispatchEvent( changeEvent );
+
+						lastPosition.copy( scope.object.position );
+						lastQuaternion.copy( scope.object.quaternion );
+						zoomChanged = false;
+
+						return true;
+
+					}
+
+					return false;
+
+				};
+
+			}();
+
+			this.dispose = function() {
+
+				scope.domElement.removeEventListener( 'contextmenu', onContextMenu, false );
+				scope.domElement.removeEventListener( 'mousedown', onMouseDown, false );
+				scope.domElement.removeEventListener( 'wheel', onMouseWheel, false );
+
+				scope.domElement.removeEventListener( 'touchstart', onTouchStart, false );
+				scope.domElement.removeEventListener( 'touchend', onTouchEnd, false );
+				scope.domElement.removeEventListener( 'touchmove', onTouchMove, false );
+
+				document.removeEventListener( 'mousemove', onMouseMove, false );
+				document.removeEventListener( 'mouseup', onMouseUp, false );
+
+				window.removeEventListener( 'keydown', onKeyDown, false );
+
+				//scope.dispatchEvent( { type: 'dispose' } ); // should this be added here?
+
+			};
+
+			//
+			// internals
+			//
+
+			var scope = this;
+
+			var changeEvent = { type: 'change' };
+			var startEvent = { type: 'start' };
+			var endEvent = { type: 'end' };
+
+			var STATE = { NONE : - 1, ROTATE : 0, DOLLY : 1, PAN : 2, TOUCH_ROTATE : 3, TOUCH_DOLLY : 4, TOUCH_PAN : 5 };
+
+			var state = STATE.NONE;
+
+			var EPS = 0.000001;
+
+			// current position in spherical coordinates
+			var spherical = new THREE.Spherical();
+			var sphericalDelta = new THREE.Spherical();
+
+			var scale = 1;
+			var panOffset = new THREE.Vector3();
+			var zoomChanged = false;
+
+			var rotateStart = new THREE.Vector2();
+			var rotateEnd = new THREE.Vector2();
+			var rotateDelta = new THREE.Vector2();
+
+			var panStart = new THREE.Vector2();
+			var panEnd = new THREE.Vector2();
+			var panDelta = new THREE.Vector2();
+
+			var dollyStart = new THREE.Vector2();
+			var dollyEnd = new THREE.Vector2();
+			var dollyDelta = new THREE.Vector2();
+
+			function getAutoRotationAngle() {
+
+				return 2 * Math.PI / 60 / 60 * scope.autoRotateSpeed;
+
+			}
+
+			function getZoomScale() {
+
+				return Math.pow( 0.95, scope.zoomSpeed );
+
+			}
+
+			function rotateLeft( angle ) {
+
+				sphericalDelta.theta -= angle;
+
+			}
+
+			function rotateUp( angle ) {
+
+				sphericalDelta.phi -= angle;
+
+			}
+
+			var panLeft = function() {
+
+				var v = new THREE.Vector3();
+
+				return function panLeft( distance, objectMatrix ) {
+
+					v.setFromMatrixColumn( objectMatrix, 0 ); // get X column of objectMatrix
+					v.multiplyScalar( - distance );
+
+					panOffset.add( v );
+
+				};
+
+			}();
+
+			var panUp = function() {
+
+				var v = new THREE.Vector3();
+
+				return function panUp( distance, objectMatrix ) {
+
+					v.setFromMatrixColumn( objectMatrix, 1 ); // get Y column of objectMatrix
+					v.multiplyScalar( distance );
+
+					panOffset.add( v );
+
+				};
+
+			}();
+
+			// deltaX and deltaY are in pixels; right and down are positive
+			var pan = function() {
+
+				var offset = new THREE.Vector3();
+
+				return function pan ( deltaX, deltaY ) {
+
+					var element = scope.domElement === document ? scope.domElement.body : scope.domElement;
+
+					if ( scope.object instanceof THREE.PerspectiveCamera ) {
+
+						// perspective
+						var position = scope.object.position;
+						offset.copy( position ).sub( scope.target );
+						var targetDistance = offset.length();
+
+						// half of the fov is center to top of screen
+						targetDistance *= Math.tan( ( scope.object.fov / 2 ) * Math.PI / 180.0 );
+
+						// we actually don't use screenWidth, since perspective camera is fixed to screen height
+						panLeft( 2 * deltaX * targetDistance / element.clientHeight, scope.object.matrix );
+						panUp( 2 * deltaY * targetDistance / element.clientHeight, scope.object.matrix );
+
+					} else if ( scope.object instanceof THREE.OrthographicCamera ) {
+
+						// orthographic
+						panLeft( deltaX * ( scope.object.right - scope.object.left ) / scope.object.zoom / element.clientWidth, scope.object.matrix );
+						panUp( deltaY * ( scope.object.top - scope.object.bottom ) / scope.object.zoom / element.clientHeight, scope.object.matrix );
+
+					} else {
+
+						// camera neither orthographic nor perspective
+						console.warn( 'WARNING: OrbitControls.js encountered an unknown camera type - pan disabled.' );
+						scope.enablePan = false;
+
+					}
+
+				};
+
+			}();
+
+			function dollyIn( dollyScale ) {
+
+				if ( scope.object instanceof THREE.PerspectiveCamera ) {
+
+					scale /= dollyScale;
+
+				} else if ( scope.object instanceof THREE.OrthographicCamera ) {
+
+					scope.object.zoom = Math.max( scope.minZoom, Math.min( scope.maxZoom, scope.object.zoom * dollyScale ) );
+					scope.object.updateProjectionMatrix();
+					zoomChanged = true;
+
+				} else {
+
+					console.warn( 'WARNING: OrbitControls.js encountered an unknown camera type - dolly/zoom disabled.' );
+					scope.enableZoom = false;
+
+				}
+
+			}
+
+			function dollyOut( dollyScale ) {
+
+				if ( scope.object instanceof THREE.PerspectiveCamera ) {
+
+					scale *= dollyScale;
+
+				} else if ( scope.object instanceof THREE.OrthographicCamera ) {
+
+					scope.object.zoom = Math.max( scope.minZoom, Math.min( scope.maxZoom, scope.object.zoom / dollyScale ) );
+					scope.object.updateProjectionMatrix();
+					zoomChanged = true;
+
+				} else {
+
+					console.warn( 'WARNING: OrbitControls.js encountered an unknown camera type - dolly/zoom disabled.' );
+					scope.enableZoom = false;
+
+				}
+
+			}
+
+			//
+			// event callbacks - update the object state
+			//
+
+			function handleMouseDownRotate( event ) {
+
+				//console.log( 'handleMouseDownRotate' );
+
+				rotateStart.set( event.clientX, event.clientY );
+
+			}
+
+			function handleMouseDownDolly( event ) {
+
+				//console.log( 'handleMouseDownDolly' );
+
+				dollyStart.set( event.clientX, event.clientY );
+
+			}
+
+			function handleMouseDownPan( event ) {
+
+				//console.log( 'handleMouseDownPan' );
+
+				panStart.set( event.clientX, event.clientY );
+
+			}
+
+			function handleMouseMoveRotate( event ) {
+
+				//console.log( 'handleMouseMoveRotate' );
+
+				rotateEnd.set( event.clientX, event.clientY );
+				rotateDelta.subVectors( rotateEnd, rotateStart );
+
+				var element = scope.domElement === document ? scope.domElement.body : scope.domElement;
+
+				// rotating across whole screen goes 360 degrees around
+				rotateLeft( 2 * Math.PI * rotateDelta.x / element.clientWidth * scope.rotateSpeed );
+
+				// rotating up and down along whole screen attempts to go 360, but limited to 180
+				rotateUp( 2 * Math.PI * rotateDelta.y / element.clientHeight * scope.rotateSpeed );
+
+				rotateStart.copy( rotateEnd );
+
+				scope.update();
+
+			}
+
+			function handleMouseMoveDolly( event ) {
+
+				//console.log( 'handleMouseMoveDolly' );
+
+				dollyEnd.set( event.clientX, event.clientY );
+
+				dollyDelta.subVectors( dollyEnd, dollyStart );
+
+				if ( dollyDelta.y > 0 ) {
+
+					dollyIn( getZoomScale() );
+
+				} else if ( dollyDelta.y < 0 ) {
+
+					dollyOut( getZoomScale() );
+
+				}
+
+				dollyStart.copy( dollyEnd );
+
+				scope.update();
+
+			}
+
+			function handleMouseMovePan( event ) {
+
+				//console.log( 'handleMouseMovePan' );
+
+				panEnd.set( event.clientX, event.clientY );
+
+				panDelta.subVectors( panEnd, panStart );
+
+				pan( panDelta.x, panDelta.y );
+
+				panStart.copy( panEnd );
+
+				scope.update();
+
+			}
+
+			function handleMouseWheel( event ) {
+
+				//console.log( 'handleMouseWheel' );
+
+				if ( event.deltaY < 0 ) {
+
+					dollyOut( getZoomScale() );
+
+				} else if ( event.deltaY > 0 ) {
+
+					dollyIn( getZoomScale() );
+
+				}
+
+				scope.update();
+
+			}
+
+			function handleKeyDown( event ) {
+
+				//console.log( 'handleKeyDown' );
+
+				switch ( event.keyCode ) {
+
+					case scope.keys.UP:
+						pan( 0, scope.keyPanSpeed );
+						scope.update();
+						break;
+
+					case scope.keys.BOTTOM:
+						pan( 0, - scope.keyPanSpeed );
+						scope.update();
+						break;
+
+					case scope.keys.LEFT:
+						pan( scope.keyPanSpeed, 0 );
+						scope.update();
+						break;
+
+					case scope.keys.RIGHT:
+						pan( - scope.keyPanSpeed, 0 );
+						scope.update();
+						break;
+
+				}
+
+			}
+
+			function handleTouchStartRotate( event ) {
+
+				//console.log( 'handleTouchStartRotate' );
+
+				rotateStart.set( event.touches[ 0 ].pageX, event.touches[ 0 ].pageY );
+
+			}
+
+			function handleTouchStartDolly( event ) {
+
+				//console.log( 'handleTouchStartDolly' );
+
+				var dx = event.touches[ 0 ].pageX - event.touches[ 1 ].pageX;
+				var dy = event.touches[ 0 ].pageY - event.touches[ 1 ].pageY;
+
+				var distance = Math.sqrt( dx * dx + dy * dy );
+
+				dollyStart.set( 0, distance );
+
+			}
+
+			function handleTouchStartPan( event ) {
+
+				//console.log( 'handleTouchStartPan' );
+
+				panStart.set( event.touches[ 0 ].pageX, event.touches[ 0 ].pageY );
+
+			}
+
+			function handleTouchMoveRotate( event ) {
+
+				//console.log( 'handleTouchMoveRotate' );
+
+				rotateEnd.set( event.touches[ 0 ].pageX, event.touches[ 0 ].pageY );
+				rotateDelta.subVectors( rotateEnd, rotateStart );
+
+				var element = scope.domElement === document ? scope.domElement.body : scope.domElement;
+
+				// rotating across whole screen goes 360 degrees around
+				rotateLeft( 2 * Math.PI * rotateDelta.x / element.clientWidth * scope.rotateSpeed );
+
+				// rotating up and down along whole screen attempts to go 360, but limited to 180
+				rotateUp( 2 * Math.PI * rotateDelta.y / element.clientHeight * scope.rotateSpeed );
+
+				rotateStart.copy( rotateEnd );
+
+				scope.update();
+
+			}
+
+			function handleTouchMoveDolly( event ) {
+
+				//console.log( 'handleTouchMoveDolly' );
+
+				var dx = event.touches[ 0 ].pageX - event.touches[ 1 ].pageX;
+				var dy = event.touches[ 0 ].pageY - event.touches[ 1 ].pageY;
+
+				var distance = Math.sqrt( dx * dx + dy * dy );
+
+				dollyEnd.set( 0, distance );
+
+				dollyDelta.subVectors( dollyEnd, dollyStart );
+
+				if ( dollyDelta.y > 0 ) {
+
+					dollyOut( getZoomScale() );
+
+				} else if ( dollyDelta.y < 0 ) {
+
+					dollyIn( getZoomScale() );
+
+				}
+
+				dollyStart.copy( dollyEnd );
+
+				scope.update();
+
+			}
+
+			function handleTouchMovePan( event ) {
+
+				//console.log( 'handleTouchMovePan' );
+
+				panEnd.set( event.touches[ 0 ].pageX, event.touches[ 0 ].pageY );
+
+				panDelta.subVectors( panEnd, panStart );
+
+				pan( panDelta.x, panDelta.y );
+
+				panStart.copy( panEnd );
+
+				scope.update();
+
+			}
+
+			//
+			// event handlers - FSM: listen for events and reset state
+			//
+
+			function onMouseDown( event ) {
+
+				if ( scope.enabled === false ) return;
+
+				event.preventDefault();
+
+				if ( event.button === scope.mouseButtons.ORBIT ) {
+
+					if ( scope.enableRotate === false ) return;
+
+					handleMouseDownRotate( event );
+
+					state = STATE.ROTATE;
+
+				} else if ( event.button === scope.mouseButtons.ZOOM ) {
+
+					if ( scope.enableZoom === false ) return;
+
+					handleMouseDownDolly( event );
+
+					state = STATE.DOLLY;
+
+				} else if ( event.button === scope.mouseButtons.PAN ) {
+
+					if ( scope.enablePan === false ) return;
+
+					handleMouseDownPan( event );
+
+					state = STATE.PAN;
+
+				}
+
+				if ( state !== STATE.NONE ) {
+
+					document.addEventListener( 'mousemove', onMouseMove, false );
+					document.addEventListener( 'mouseup', onMouseUp, false );
+
+					scope.dispatchEvent( startEvent );
+
+				}
+
+			}
+
+			function onMouseMove( event ) {
+
+				if ( scope.enabled === false ) return;
+
+				event.preventDefault();
+
+				if ( state === STATE.ROTATE ) {
+
+					if ( scope.enableRotate === false ) return;
+
+					handleMouseMoveRotate( event );
+
+				} else if ( state === STATE.DOLLY ) {
+
+					if ( scope.enableZoom === false ) return;
+
+					handleMouseMoveDolly( event );
+
+				} else if ( state === STATE.PAN ) {
+
+					if ( scope.enablePan === false ) return;
+
+					handleMouseMovePan( event );
+
+				}
+
+			}
+
+			function onMouseUp( event ) {
+
+				if ( scope.enabled === false ) return;
+
+				document.removeEventListener( 'mousemove', onMouseMove, false );
+				document.removeEventListener( 'mouseup', onMouseUp, false );
+
+				scope.dispatchEvent( endEvent );
+
+				state = STATE.NONE;
+
+			}
+
+			function onMouseWheel( event ) {
+
+				if ( scope.enabled === false || scope.enableZoom === false || ( state !== STATE.NONE && state !== STATE.ROTATE ) ) return;
+
+				event.preventDefault();
+				event.stopPropagation();
+
+				handleMouseWheel( event );
+
+				scope.dispatchEvent( startEvent ); // not sure why these are here...
+				scope.dispatchEvent( endEvent );
+
+			}
+
+			function onKeyDown( event ) {
+
+				if ( scope.enabled === false || scope.enableKeys === false || scope.enablePan === false ) return;
+
+				handleKeyDown( event );
+
+			}
+
+			function onTouchStart( event ) {
+
+				if ( scope.enabled === false ) return;
+
+				switch ( event.touches.length ) {
+
+					case 1:	// one-fingered touch: rotate
+
+						if ( scope.enableRotate === false ) return;
+
+						handleTouchStartRotate( event );
+
+						state = STATE.TOUCH_ROTATE;
+
+						break;
+
+					case 2:	// two-fingered touch: dolly
+
+						if ( scope.enableZoom === false ) return;
+
+						handleTouchStartDolly( event );
+
+						state = STATE.TOUCH_DOLLY;
+
+						break;
+
+					case 3: // three-fingered touch: pan
+
+						if ( scope.enablePan === false ) return;
+
+						handleTouchStartPan( event );
+
+						state = STATE.TOUCH_PAN;
+
+						break;
+
+					default:
+
+						state = STATE.NONE;
+
+				}
+
+				if ( state !== STATE.NONE ) {
+
+					scope.dispatchEvent( startEvent );
+
+				}
+
+			}
+
+			function onTouchMove( event ) {
+
+				if ( scope.enabled === false ) return;
+
+				event.preventDefault();
+				event.stopPropagation();
+
+				switch ( event.touches.length ) {
+
+					case 1: // one-fingered touch: rotate
+
+						if ( scope.enableRotate === false ) return;
+						if ( state !== STATE.TOUCH_ROTATE ) return; // is this needed?...
+
+						handleTouchMoveRotate( event );
+
+						break;
+
+					case 2: // two-fingered touch: dolly
+
+						if ( scope.enableZoom === false ) return;
+						if ( state !== STATE.TOUCH_DOLLY ) return; // is this needed?...
+
+						handleTouchMoveDolly( event );
+
+						break;
+
+					case 3: // three-fingered touch: pan
+
+						if ( scope.enablePan === false ) return;
+						if ( state !== STATE.TOUCH_PAN ) return; // is this needed?...
+
+						handleTouchMovePan( event );
+
+						break;
+
+					default:
+
+						state = STATE.NONE;
+
+				}
+
+			}
+
+			function onTouchEnd( event ) {
+
+				if ( scope.enabled === false ) return;
+
+				scope.dispatchEvent( endEvent );
+
+				state = STATE.NONE;
+
+			}
+
+			function onContextMenu( event ) {
+
+				event.preventDefault();
+
+			}
+
+			//
+
+			scope.domElement.addEventListener( 'contextmenu', onContextMenu, false );
+
+			scope.domElement.addEventListener( 'mousedown', onMouseDown, false );
+			scope.domElement.addEventListener( 'wheel', onMouseWheel, false );
+
+			scope.domElement.addEventListener( 'touchstart', onTouchStart, false );
+			scope.domElement.addEventListener( 'touchend', onTouchEnd, false );
+			scope.domElement.addEventListener( 'touchmove', onTouchMove, false );
+
+			window.addEventListener( 'keydown', onKeyDown, false );
+
+			// force an update at start
+
+			this.update();
+
+		}
+		OrbitControls.prototype = Object.create( THREE.EventDispatcher.prototype );
+		OrbitControls.prototype.constructor = OrbitControls;
+
+		Object.defineProperties( OrbitControls.prototype, {
+
+			center: {
+
+				get: function () {
+
+					console.warn( 'THREE.OrbitControls: .center has been renamed to .target' );
+					return this.target;
+
+				}
+
+			},
+
+			// backward compatibility
+
+			noZoom: {
+
+				get: function () {
+
+					console.warn( 'THREE.OrbitControls: .noZoom has been deprecated. Use .enableZoom instead.' );
+					return ! this.enableZoom;
+
+				},
+
+				set: function ( value ) {
+
+					console.warn( 'THREE.OrbitControls: .noZoom has been deprecated. Use .enableZoom instead.' );
+					this.enableZoom = ! value;
+
+				}
+
+			},
+
+			noRotate: {
+
+				get: function () {
+
+					console.warn( 'THREE.OrbitControls: .noRotate has been deprecated. Use .enableRotate instead.' );
+					return ! this.enableRotate;
+
+				},
+
+				set: function ( value ) {
+
+					console.warn( 'THREE.OrbitControls: .noRotate has been deprecated. Use .enableRotate instead.' );
+					this.enableRotate = ! value;
+
+				}
+
+			},
+
+			noPan: {
+
+				get: function () {
+
+					console.warn( 'THREE.OrbitControls: .noPan has been deprecated. Use .enablePan instead.' );
+					return ! this.enablePan;
+
+				},
+
+				set: function ( value ) {
+
+					console.warn( 'THREE.OrbitControls: .noPan has been deprecated. Use .enablePan instead.' );
+					this.enablePan = ! value;
+
+				}
+
+			},
+
+			noKeys: {
+
+				get: function () {
+
+					console.warn( 'THREE.OrbitControls: .noKeys has been deprecated. Use .enableKeys instead.' );
+					return ! this.enableKeys;
+
+				},
+
+				set: function ( value ) {
+
+					console.warn( 'THREE.OrbitControls: .noKeys has been deprecated. Use .enableKeys instead.' );
+					this.enableKeys = ! value;
+
+				}
+
+			},
+
+			staticMoving : {
+
+				get: function () {
+
+					console.warn( 'THREE.OrbitControls: .staticMoving has been deprecated. Use .enableDamping instead.' );
+					return ! this.enableDamping;
+
+				},
+
+				set: function ( value ) {
+
+					console.warn( 'THREE.OrbitControls: .staticMoving has been deprecated. Use .enableDamping instead.' );
+					this.enableDamping = ! value;
+
+				}
+
+			},
+
+			dynamicDampingFactor : {
+
+				get: function () {
+
+					console.warn( 'THREE.OrbitControls: .dynamicDampingFactor has been renamed. Use .dampingFactor instead.' );
+					return this.dampingFactor;
+
+				},
+
+				set: function ( value ) {
+
+					console.warn( 'THREE.OrbitControls: .dynamicDampingFactor has been renamed. Use .dampingFactor instead.' );
+					this.dampingFactor = value;
+
+				}
+
+			}
+
+		} );
+
+		return OrbitControls;
+	};
+	return threeOrbitControls;
+}
+
+var threeOrbitControlsExports = requireThreeOrbitControls();
+const OrbitControls = /*@__PURE__*/getDefaultExportFromCjs(threeOrbitControlsExports);
+
+var xhr = {exports: {}};
+
+var window_1;
+var hasRequiredWindow;
+
+function requireWindow () {
+	if (hasRequiredWindow) return window_1;
+	hasRequiredWindow = 1;
+	var win;
+
+	if (typeof window !== "undefined") {
+	    win = window;
+	} else if (typeof commonjsGlobal !== "undefined") {
+	    win = commonjsGlobal;
+	} else if (typeof self !== "undefined"){
+	    win = self;
+	} else {
+	    win = {};
+	}
+
+	window_1 = win;
+	return window_1;
+}
+
+var isFunction_1;
+var hasRequiredIsFunction;
+
+function requireIsFunction () {
+	if (hasRequiredIsFunction) return isFunction_1;
+	hasRequiredIsFunction = 1;
+	isFunction_1 = isFunction;
+
+	var toString = Object.prototype.toString;
+
+	function isFunction (fn) {
+	  if (!fn) {
+	    return false
+	  }
+	  var string = toString.call(fn);
+	  return string === '[object Function]' ||
+	    (typeof fn === 'function' && string !== '[object RegExp]') ||
+	    (typeof window !== 'undefined' &&
+	     // IE8 and below
+	     (fn === window.setTimeout ||
+	      fn === window.alert ||
+	      fn === window.confirm ||
+	      fn === window.prompt))
+	}	return isFunction_1;
+}
+
+var parseHeaders;
+var hasRequiredParseHeaders;
+
+function requireParseHeaders () {
+	if (hasRequiredParseHeaders) return parseHeaders;
+	hasRequiredParseHeaders = 1;
+	var trim = function(string) {
+	  return string.replace(/^\s+|\s+$/g, '');
+	}
+	  , isArray = function(arg) {
+	      return Object.prototype.toString.call(arg) === '[object Array]';
+	    };
+
+	parseHeaders = function (headers) {
+	  if (!headers)
+	    return {}
+
+	  var result = {};
+
+	  var headersArr = trim(headers).split('\n');
+
+	  for (var i = 0; i < headersArr.length; i++) {
+	    var row = headersArr[i];
+	    var index = row.indexOf(':')
+	    , key = trim(row.slice(0, index)).toLowerCase()
+	    , value = trim(row.slice(index + 1));
+
+	    if (typeof(result[key]) === 'undefined') {
+	      result[key] = value;
+	    } else if (isArray(result[key])) {
+	      result[key].push(value);
+	    } else {
+	      result[key] = [ result[key], value ];
+	    }
+	  }
+
+	  return result
+	};
+	return parseHeaders;
+}
+
+var immutable;
+var hasRequiredImmutable;
+
+function requireImmutable () {
+	if (hasRequiredImmutable) return immutable;
+	hasRequiredImmutable = 1;
+	immutable = extend;
+
+	var hasOwnProperty = Object.prototype.hasOwnProperty;
+
+	function extend() {
+	    var target = {};
+
+	    for (var i = 0; i < arguments.length; i++) {
+	        var source = arguments[i];
+
+	        for (var key in source) {
+	            if (hasOwnProperty.call(source, key)) {
+	                target[key] = source[key];
+	            }
+	        }
+	    }
+
+	    return target
+	}
+	return immutable;
+}
+
+var hasRequiredXhr;
+
+function requireXhr () {
+	if (hasRequiredXhr) return xhr.exports;
+	hasRequiredXhr = 1;
+	var window = requireWindow();
+	var isFunction = requireIsFunction();
+	var parseHeaders = requireParseHeaders();
+	var xtend = requireImmutable();
+
+	xhr.exports = createXHR;
+	// Allow use of default import syntax in TypeScript
+	xhr.exports.default = createXHR;
+	createXHR.XMLHttpRequest = window.XMLHttpRequest || noop;
+	createXHR.XDomainRequest = "withCredentials" in (new createXHR.XMLHttpRequest()) ? createXHR.XMLHttpRequest : window.XDomainRequest;
+
+	forEachArray(["get", "put", "post", "patch", "head", "delete"], function(method) {
+	    createXHR[method === "delete" ? "del" : method] = function(uri, options, callback) {
+	        options = initParams(uri, options, callback);
+	        options.method = method.toUpperCase();
+	        return _createXHR(options)
+	    };
+	});
+
+	function forEachArray(array, iterator) {
+	    for (var i = 0; i < array.length; i++) {
+	        iterator(array[i]);
+	    }
+	}
+
+	function isEmpty(obj){
+	    for(var i in obj){
+	        if(obj.hasOwnProperty(i)) return false
+	    }
+	    return true
+	}
+
+	function initParams(uri, options, callback) {
+	    var params = uri;
+
+	    if (isFunction(options)) {
+	        callback = options;
+	        if (typeof uri === "string") {
+	            params = {uri:uri};
+	        }
+	    } else {
+	        params = xtend(options, {uri: uri});
+	    }
+
+	    params.callback = callback;
+	    return params
+	}
+
+	function createXHR(uri, options, callback) {
+	    options = initParams(uri, options, callback);
+	    return _createXHR(options)
+	}
+
+	function _createXHR(options) {
+	    if(typeof options.callback === "undefined"){
+	        throw new Error("callback argument missing")
+	    }
+
+	    var called = false;
+	    var callback = function cbOnce(err, response, body){
+	        if(!called){
+	            called = true;
+	            options.callback(err, response, body);
+	        }
+	    };
+
+	    function readystatechange() {
+	        if (xhr.readyState === 4) {
+	            setTimeout(loadFunc, 0);
+	        }
+	    }
+
+	    function getBody() {
+	        // Chrome with requestType=blob throws errors arround when even testing access to responseText
+	        var body = undefined;
+
+	        if (xhr.response) {
+	            body = xhr.response;
+	        } else {
+	            body = xhr.responseText || getXml(xhr);
+	        }
+
+	        if (isJson) {
+	            try {
+	                body = JSON.parse(body);
+	            } catch (e) {}
+	        }
+
+	        return body
+	    }
+
+	    function errorFunc(evt) {
+	        clearTimeout(timeoutTimer);
+	        if(!(evt instanceof Error)){
+	            evt = new Error("" + (evt || "Unknown XMLHttpRequest Error") );
+	        }
+	        evt.statusCode = 0;
+	        return callback(evt, failureResponse)
+	    }
+
+	    // will load the data & process the response in a special response object
+	    function loadFunc() {
+	        if (aborted) return
+	        var status;
+	        clearTimeout(timeoutTimer);
+	        if(options.useXDR && xhr.status===undefined) {
+	            //IE8 CORS GET successful response doesn't have a status field, but body is fine
+	            status = 200;
+	        } else {
+	            status = (xhr.status === 1223 ? 204 : xhr.status);
+	        }
+	        var response = failureResponse;
+	        var err = null;
+
+	        if (status !== 0){
+	            response = {
+	                body: getBody(),
+	                statusCode: status,
+	                method: method,
+	                headers: {},
+	                url: uri,
+	                rawRequest: xhr
+	            };
+	            if(xhr.getAllResponseHeaders){ //remember xhr can in fact be XDR for CORS in IE
+	                response.headers = parseHeaders(xhr.getAllResponseHeaders());
+	            }
+	        } else {
+	            err = new Error("Internal XMLHttpRequest Error");
+	        }
+	        return callback(err, response, response.body)
+	    }
+
+	    var xhr = options.xhr || null;
+
+	    if (!xhr) {
+	        if (options.cors || options.useXDR) {
+	            xhr = new createXHR.XDomainRequest();
+	        }else {
+	            xhr = new createXHR.XMLHttpRequest();
+	        }
+	    }
+
+	    var key;
+	    var aborted;
+	    var uri = xhr.url = options.uri || options.url;
+	    var method = xhr.method = options.method || "GET";
+	    var body = options.body || options.data;
+	    var headers = xhr.headers = options.headers || {};
+	    var sync = !!options.sync;
+	    var isJson = false;
+	    var timeoutTimer;
+	    var failureResponse = {
+	        body: undefined,
+	        headers: {},
+	        statusCode: 0,
+	        method: method,
+	        url: uri,
+	        rawRequest: xhr
+	    };
+
+	    if ("json" in options && options.json !== false) {
+	        isJson = true;
+	        headers["accept"] || headers["Accept"] || (headers["Accept"] = "application/json"); //Don't override existing accept header declared by user
+	        if (method !== "GET" && method !== "HEAD") {
+	            headers["content-type"] || headers["Content-Type"] || (headers["Content-Type"] = "application/json"); //Don't override existing accept header declared by user
+	            body = JSON.stringify(options.json === true ? body : options.json);
+	        }
+	    }
+
+	    xhr.onreadystatechange = readystatechange;
+	    xhr.onload = loadFunc;
+	    xhr.onerror = errorFunc;
+	    // IE9 must have onprogress be set to a unique function.
+	    xhr.onprogress = function () {
+	        // IE must die
+	    };
+	    xhr.onabort = function(){
+	        aborted = true;
+	    };
+	    xhr.ontimeout = errorFunc;
+	    xhr.open(method, uri, !sync, options.username, options.password);
+	    //has to be after open
+	    if(!sync) {
+	        xhr.withCredentials = !!options.withCredentials;
+	    }
+	    // Cannot set timeout with sync request
+	    // not setting timeout on the xhr object, because of old webkits etc. not handling that correctly
+	    // both npm's request and jquery 1.x use this kind of timeout, so this is being consistent
+	    if (!sync && options.timeout > 0 ) {
+	        timeoutTimer = setTimeout(function(){
+	            if (aborted) return
+	            aborted = true;//IE9 may still call readystatechange
+	            xhr.abort("timeout");
+	            var e = new Error("XMLHttpRequest timeout");
+	            e.code = "ETIMEDOUT";
+	            errorFunc(e);
+	        }, options.timeout );
+	    }
+
+	    if (xhr.setRequestHeader) {
+	        for(key in headers){
+	            if(headers.hasOwnProperty(key)){
+	                xhr.setRequestHeader(key, headers[key]);
+	            }
+	        }
+	    } else if (options.headers && !isEmpty(options.headers)) {
+	        throw new Error("Headers cannot be set on an XDomainRequest object")
+	    }
+
+	    if ("responseType" in options) {
+	        xhr.responseType = options.responseType;
+	    }
+
+	    if ("beforeSend" in options &&
+	        typeof options.beforeSend === "function"
+	    ) {
+	        options.beforeSend(xhr);
+	    }
+
+	    // Microsoft Edge browser sends "undefined" when send is called with undefined value.
+	    // XMLHttpRequest spec says to pass null as body to indicate no body
+	    // See https://github.com/naugtur/xhr/issues/100.
+	    xhr.send(body || null);
+
+	    return xhr
+
+
+	}
+
+	function getXml(xhr) {
+	    // xhr.responseXML will throw Exception "InvalidStateError" or "DOMException"
+	    // See https://developer.mozilla.org/en-US/docs/Web/API/XMLHttpRequest/responseXML.
+	    try {
+	        if (xhr.responseType === "document") {
+	            return xhr.responseXML
+	        }
+	        var firefoxBugTakenEffect = xhr.responseXML && xhr.responseXML.documentElement.nodeName === "parsererror";
+	        if (xhr.responseType === "" && !firefoxBugTakenEffect) {
+	            return xhr.responseXML
+	        }
+	    } catch (e) {}
+
+	    return null
+	}
+
+	function noop() {}
+	return xhr.exports;
+}
+
+var parseBmfontAscii;
+var hasRequiredParseBmfontAscii;
+
+function requireParseBmfontAscii () {
+	if (hasRequiredParseBmfontAscii) return parseBmfontAscii;
+	hasRequiredParseBmfontAscii = 1;
+	parseBmfontAscii = function parseBMFontAscii(data) {
+	  if (!data)
+	    throw new Error('no data provided')
+	  data = data.toString().trim();
+
+	  var output = {
+	    pages: [],
+	    chars: [],
+	    kernings: []
+	  };
+
+	  var lines = data.split(/\r\n?|\n/g);
+
+	  if (lines.length === 0)
+	    throw new Error('no data in BMFont file')
+
+	  for (var i = 0; i < lines.length; i++) {
+	    var lineData = splitLine(lines[i], i);
+	    if (!lineData) //skip empty lines
+	      continue
+
+	    if (lineData.key === 'page') {
+	      if (typeof lineData.data.id !== 'number')
+	        throw new Error('malformed file at line ' + i + ' -- needs page id=N')
+	      if (typeof lineData.data.file !== 'string')
+	        throw new Error('malformed file at line ' + i + ' -- needs page file="path"')
+	      output.pages[lineData.data.id] = lineData.data.file;
+	    } else if (lineData.key === 'chars' || lineData.key === 'kernings') ; else if (lineData.key === 'char') {
+	      output.chars.push(lineData.data);
+	    } else if (lineData.key === 'kerning') {
+	      output.kernings.push(lineData.data);
+	    } else {
+	      output[lineData.key] = lineData.data;
+	    }
+	  }
+
+	  return output
+	};
+
+	function splitLine(line, idx) {
+	  line = line.replace(/\t+/g, ' ').trim();
+	  if (!line)
+	    return null
+
+	  var space = line.indexOf(' ');
+	  if (space === -1) 
+	    throw new Error("no named row at line " + idx)
+
+	  var key = line.substring(0, space);
+
+	  line = line.substring(space + 1);
+	  //clear "letter" field as it is non-standard and
+	  //requires additional complexity to parse " / = symbols
+	  line = line.replace(/letter=[\'\"]\S+[\'\"]/gi, '');  
+	  line = line.split("=");
+	  line = line.map(function(str) {
+	    return str.trim().match((/(".*?"|[^"\s]+)+(?=\s*|\s*$)/g))
+	  });
+
+	  var data = [];
+	  for (var i = 0; i < line.length; i++) {
+	    var dt = line[i];
+	    if (i === 0) {
+	      data.push({
+	        key: dt[0],
+	        data: ""
+	      });
+	    } else if (i === line.length - 1) {
+	      data[data.length - 1].data = parseData(dt[0]);
+	    } else {
+	      data[data.length - 1].data = parseData(dt[0]);
+	      data.push({
+	        key: dt[1],
+	        data: ""
+	      });
+	    }
+	  }
+
+	  var out = {
+	    key: key,
+	    data: {}
+	  };
+
+	  data.forEach(function(v) {
+	    out.data[v.key] = v.data;
+	  });
+
+	  return out
+	}
+
+	function parseData(data) {
+	  if (!data || data.length === 0)
+	    return ""
+
+	  if (data.indexOf('"') === 0 || data.indexOf("'") === 0)
+	    return data.substring(1, data.length - 1)
+	  if (data.indexOf(',') !== -1)
+	    return parseIntList(data)
+	  return parseInt(data, 10)
+	}
+
+	function parseIntList(data) {
+	  return data.split(',').map(function(val) {
+	    return parseInt(val, 10)
+	  })
+	}
+	return parseBmfontAscii;
+}
+
+var parseAttribs;
+var hasRequiredParseAttribs;
+
+function requireParseAttribs () {
+	if (hasRequiredParseAttribs) return parseAttribs;
+	hasRequiredParseAttribs = 1;
+	//Some versions of GlyphDesigner have a typo
+	//that causes some bugs with parsing. 
+	//Need to confirm with recent version of the software
+	//to see whether this is still an issue or not.
+	var GLYPH_DESIGNER_ERROR = 'chasrset';
+
+	parseAttribs = function parseAttributes(obj) {
+	  obj = Object.assign({}, obj);
+	  if (GLYPH_DESIGNER_ERROR in obj) {
+	    obj['charset'] = obj[GLYPH_DESIGNER_ERROR];
+	    delete obj[GLYPH_DESIGNER_ERROR];
+	  }
+
+	  for (var k in obj) {
+	    if (k === 'face' || k === 'charset') 
+	      continue
+	    else if (k === 'padding' || k === 'spacing')
+	      obj[k] = parseIntList(obj[k]);
+	    else
+	      obj[k] = parseInt(obj[k], 10); 
+	  }
+	  return obj
+	};
+
+	function parseIntList(data) {
+	  return data.split(',').map(function(val) {
+	    return parseInt(val, 10)
+	  })
+	}
+	return parseAttribs;
+}
+
+var xmlParseFromString;
+var hasRequiredXmlParseFromString;
+
+function requireXmlParseFromString () {
+	if (hasRequiredXmlParseFromString) return xmlParseFromString;
+	hasRequiredXmlParseFromString = 1;
+	xmlParseFromString = (function xmlparser() {
+	  //common browsers
+	  if (typeof self.DOMParser !== 'undefined') {
+	    return function(str) {
+	      var parser = new self.DOMParser();
+	      return parser.parseFromString(str, 'application/xml')
+	    }
+	  } 
+
+	  //IE8 fallback
+	  if (typeof self.ActiveXObject !== 'undefined'
+	      && new self.ActiveXObject('Microsoft.XMLDOM')) {
+	    return function(str) {
+	      var xmlDoc = new self.ActiveXObject("Microsoft.XMLDOM");
+	      xmlDoc.async = "false";
+	      xmlDoc.loadXML(str);
+	      return xmlDoc
+	    }
+	  }
+
+	  //last resort fallback
+	  return function(str) {
+	    var div = document.createElement('div');
+	    div.innerHTML = str;
+	    return div
+	  }
+	})();
+	return xmlParseFromString;
+}
+
+var browser$1;
+var hasRequiredBrowser$1;
+
+function requireBrowser$1 () {
+	if (hasRequiredBrowser$1) return browser$1;
+	hasRequiredBrowser$1 = 1;
+	var parseAttributes = requireParseAttribs();
+	var parseFromString = requireXmlParseFromString();
+
+	//In some cases element.attribute.nodeName can return
+	//all lowercase values.. so we need to map them to the correct 
+	//case
+	var NAME_MAP = {
+	  scaleh: 'scaleH',
+	  scalew: 'scaleW',
+	  stretchh: 'stretchH',
+	  lineheight: 'lineHeight',
+	  alphachnl: 'alphaChnl',
+	  redchnl: 'redChnl',
+	  greenchnl: 'greenChnl',
+	  bluechnl: 'blueChnl'
+	};
+
+	browser$1 = function parse(data) {
+	  data = data.toString();
+	  
+	  var xmlRoot = parseFromString(data);
+	  var output = {
+	    pages: [],
+	    chars: [],
+	    kernings: []
+	  }
+
+	  //get config settings
+	  ;['info', 'common'].forEach(function(key) {
+	    var element = xmlRoot.getElementsByTagName(key)[0];
+	    if (element)
+	      output[key] = parseAttributes(getAttribs(element));
+	  });
+
+	  //get page info
+	  var pageRoot = xmlRoot.getElementsByTagName('pages')[0];
+	  if (!pageRoot)
+	    throw new Error('malformed file -- no <pages> element')
+	  var pages = pageRoot.getElementsByTagName('page');
+	  for (var i=0; i<pages.length; i++) {
+	    var p = pages[i];
+	    var id = parseInt(p.getAttribute('id'), 10);
+	    var file = p.getAttribute('file');
+	    if (isNaN(id))
+	      throw new Error('malformed file -- page "id" attribute is NaN')
+	    if (!file)
+	      throw new Error('malformed file -- needs page "file" attribute')
+	    output.pages[parseInt(id, 10)] = file;
+	  }
+['chars', 'kernings'].forEach(function(key) {
+	    var element = xmlRoot.getElementsByTagName(key)[0];
+	    if (!element)
+	      return
+	    var childTag = key.substring(0, key.length-1);
+	    var children = element.getElementsByTagName(childTag);
+	    for (var i=0; i<children.length; i++) {      
+	      var child = children[i];
+	      output[key].push(parseAttributes(getAttribs(child)));
+	    }
+	  });
+	  return output
+	};
+
+	function getAttribs(element) {
+	  var attribs = getAttribList(element);
+	  return attribs.reduce(function(dict, attrib) {
+	    var key = mapName(attrib.nodeName);
+	    dict[key] = attrib.nodeValue;
+	    return dict
+	  }, {})
+	}
+
+	function getAttribList(element) {
+	  //IE8+ and modern browsers
+	  var attribs = [];
+	  for (var i=0; i<element.attributes.length; i++)
+	    attribs.push(element.attributes[i]);
+	  return attribs
+	}
+
+	function mapName(nodeName) {
+	  return NAME_MAP[nodeName.toLowerCase()] || nodeName
+	}
+	return browser$1;
+}
+
+var parseBmfontBinary;
+var hasRequiredParseBmfontBinary;
+
+function requireParseBmfontBinary () {
+	if (hasRequiredParseBmfontBinary) return parseBmfontBinary;
+	hasRequiredParseBmfontBinary = 1;
+	var HEADER = [66, 77, 70];
+
+	parseBmfontBinary = function readBMFontBinary(buf) {
+	  if (buf.length < 6)
+	    throw new Error('invalid buffer length for BMFont')
+
+	  var header = HEADER.every(function(byte, i) {
+	    return buf.readUInt8(i) === byte
+	  });
+
+	  if (!header)
+	    throw new Error('BMFont missing BMF byte header')
+
+	  var i = 3;
+	  var vers = buf.readUInt8(i++);
+	  if (vers > 3)
+	    throw new Error('Only supports BMFont Binary v3 (BMFont App v1.10)')
+	  
+	  var target = { kernings: [], chars: [] };
+	  for (var b=0; b<5; b++)
+	    i += readBlock(target, buf, i);
+	  return target
+	};
+
+	function readBlock(target, buf, i) {
+	  if (i > buf.length-1)
+	    return 0
+
+	  var blockID = buf.readUInt8(i++);
+	  var blockSize = buf.readInt32LE(i);
+	  i += 4;
+
+	  switch(blockID) {
+	    case 1: 
+	      target.info = readInfo(buf, i);
+	      break
+	    case 2:
+	      target.common = readCommon(buf, i);
+	      break
+	    case 3:
+	      target.pages = readPages(buf, i, blockSize);
+	      break
+	    case 4:
+	      target.chars = readChars(buf, i, blockSize);
+	      break
+	    case 5:
+	      target.kernings = readKernings(buf, i, blockSize);
+	      break
+	  }
+	  return 5 + blockSize
+	}
+
+	function readInfo(buf, i) {
+	  var info = {};
+	  info.size = buf.readInt16LE(i);
+
+	  var bitField = buf.readUInt8(i+2);
+	  info.smooth = (bitField >> 7) & 1;
+	  info.unicode = (bitField >> 6) & 1;
+	  info.italic = (bitField >> 5) & 1;
+	  info.bold = (bitField >> 4) & 1;
+	  
+	  //fixedHeight is only mentioned in binary spec 
+	  if ((bitField >> 3) & 1)
+	    info.fixedHeight = 1;
+	  
+	  info.charset = buf.readUInt8(i+3) || '';
+	  info.stretchH = buf.readUInt16LE(i+4);
+	  info.aa = buf.readUInt8(i+6);
+	  info.padding = [
+	    buf.readInt8(i+7),
+	    buf.readInt8(i+8),
+	    buf.readInt8(i+9),
+	    buf.readInt8(i+10)
+	  ];
+	  info.spacing = [
+	    buf.readInt8(i+11),
+	    buf.readInt8(i+12)
+	  ];
+	  info.outline = buf.readUInt8(i+13);
+	  info.face = readStringNT(buf, i+14);
+	  return info
+	}
+
+	function readCommon(buf, i) {
+	  var common = {};
+	  common.lineHeight = buf.readUInt16LE(i);
+	  common.base = buf.readUInt16LE(i+2);
+	  common.scaleW = buf.readUInt16LE(i+4);
+	  common.scaleH = buf.readUInt16LE(i+6);
+	  common.pages = buf.readUInt16LE(i+8);
+	  buf.readUInt8(i+10);
+	  common.packed = 0;
+	  common.alphaChnl = buf.readUInt8(i+11);
+	  common.redChnl = buf.readUInt8(i+12);
+	  common.greenChnl = buf.readUInt8(i+13);
+	  common.blueChnl = buf.readUInt8(i+14);
+	  return common
+	}
+
+	function readPages(buf, i, size) {
+	  var pages = [];
+	  var text = readNameNT(buf, i);
+	  var len = text.length+1;
+	  var count = size / len;
+	  for (var c=0; c<count; c++) {
+	    pages[c] = buf.slice(i, i+text.length).toString('utf8');
+	    i += len;
+	  }
+	  return pages
+	}
+
+	function readChars(buf, i, blockSize) {
+	  var chars = [];
+
+	  var count = blockSize / 20;
+	  for (var c=0; c<count; c++) {
+	    var char = {};
+	    var off = c*20;
+	    char.id = buf.readUInt32LE(i + 0 + off);
+	    char.x = buf.readUInt16LE(i + 4 + off);
+	    char.y = buf.readUInt16LE(i + 6 + off);
+	    char.width = buf.readUInt16LE(i + 8 + off);
+	    char.height = buf.readUInt16LE(i + 10 + off);
+	    char.xoffset = buf.readInt16LE(i + 12 + off);
+	    char.yoffset = buf.readInt16LE(i + 14 + off);
+	    char.xadvance = buf.readInt16LE(i + 16 + off);
+	    char.page = buf.readUInt8(i + 18 + off);
+	    char.chnl = buf.readUInt8(i + 19 + off);
+	    chars[c] = char;
+	  }
+	  return chars
+	}
+
+	function readKernings(buf, i, blockSize) {
+	  var kernings = [];
+	  var count = blockSize / 10;
+	  for (var c=0; c<count; c++) {
+	    var kern = {};
+	    var off = c*10;
+	    kern.first = buf.readUInt32LE(i + 0 + off);
+	    kern.second = buf.readUInt32LE(i + 4 + off);
+	    kern.amount = buf.readInt16LE(i + 8 + off);
+	    kernings[c] = kern;
+	  }
+	  return kernings
+	}
+
+	function readNameNT(buf, offset) {
+	  var pos=offset;
+	  for (; pos<buf.length; pos++) {
+	    if (buf[pos] === 0x00) 
+	      break
+	  }
+	  return buf.slice(offset, pos)
+	}
+
+	function readStringNT(buf, offset) {
+	  return readNameNT(buf, offset).toString('utf8')
+	}
+	return parseBmfontBinary;
+}
+
+const __viteBrowserExternal = {};
+
+const __viteBrowserExternal$1 = /*#__PURE__*/Object.freeze(/*#__PURE__*/Object.defineProperty({
+	__proto__: null,
+	default: __viteBrowserExternal
+}, Symbol.toStringTag, { value: 'Module' }));
+
+const require$$0 = /*@__PURE__*/getAugmentedNamespace(__viteBrowserExternal$1);
+
+var bufferEqual;
+var hasRequiredBufferEqual;
+
+function requireBufferEqual () {
+	if (hasRequiredBufferEqual) return bufferEqual;
+	hasRequiredBufferEqual = 1;
+	var Buffer = require$$0.Buffer; // for use with browserify
+
+	bufferEqual = function (a, b) {
+	    if (!Buffer.isBuffer(a)) return undefined;
+	    if (!Buffer.isBuffer(b)) return undefined;
+	    if (typeof a.equals === 'function') return a.equals(b);
+	    if (a.length !== b.length) return false;
+	    
+	    for (var i = 0; i < a.length; i++) {
+	        if (a[i] !== b[i]) return false;
+	    }
+	    
+	    return true;
+	};
+	return bufferEqual;
+}
+
+var isBinary;
+var hasRequiredIsBinary;
+
+function requireIsBinary () {
+	if (hasRequiredIsBinary) return isBinary;
+	hasRequiredIsBinary = 1;
+	var equal = requireBufferEqual();
+	var HEADER = Buffer.from([66, 77, 70, 3]);
+
+	isBinary = function(buf) {
+	  if (typeof buf === 'string')
+	    return buf.substring(0, 3) === 'BMF'
+	  return buf.length > 4 && equal(buf.slice(0, 4), HEADER)
+	};
+	return isBinary;
+}
+
+var browser;
+var hasRequiredBrowser;
+
+function requireBrowser () {
+	if (hasRequiredBrowser) return browser;
+	hasRequiredBrowser = 1;
+	var xhr = requireXhr();
+	var noop = function(){};
+	var parseASCII = requireParseBmfontAscii();
+	var parseXML = requireBrowser$1();
+	var readBinary = requireParseBmfontBinary();
+	var isBinaryFormat = requireIsBinary();
+	var xtend = requireImmutable();
+
+	var xml2 = (function hasXML2() {
+	  return self.XMLHttpRequest && "withCredentials" in new XMLHttpRequest
+	})();
+
+	browser = function(opt, cb) {
+	  cb = typeof cb === 'function' ? cb : noop;
+
+	  if (typeof opt === 'string')
+	    opt = { uri: opt };
+	  else if (!opt)
+	    opt = {};
+
+	  var expectBinary = opt.binary;
+	  if (expectBinary)
+	    opt = getBinaryOpts(opt);
+
+	  xhr(opt, function(err, res, body) {
+	    if (err)
+	      return cb(err)
+	    if (!/^2/.test(res.statusCode))
+	      return cb(new Error('http status code: '+res.statusCode))
+	    if (!body)
+	      return cb(new Error('no body result'))
+
+	    var binary = false; 
+
+	    //if the response type is an array buffer,
+	    //we need to convert it into a regular Buffer object
+	    if (isArrayBuffer(body)) {
+	      var array = new Uint8Array(body);
+	      body = Buffer.from(array, 'binary');
+	    }
+
+	    //now check the string/Buffer response
+	    //and see if it has a binary BMF header
+	    if (isBinaryFormat(body)) {
+	      binary = true;
+	      //if we have a string, turn it into a Buffer
+	      if (typeof body === 'string') 
+	        body = Buffer.from(body, 'binary');
+	    } 
+
+	    //we are not parsing a binary format, just ASCII/XML/etc
+	    if (!binary) {
+	      //might still be a buffer if responseType is 'arraybuffer'
+	      if (Buffer.isBuffer(body))
+	        body = body.toString(opt.encoding);
+	      body = body.trim();
+	    }
+
+	    var result;
+	    try {
+	      var type = res.headers['content-type'];
+	      if (binary)
+	        result = readBinary(body);
+	      else if (/json/.test(type) || body.charAt(0) === '{')
+	        result = JSON.parse(body);
+	      else if (/xml/.test(type)  || body.charAt(0) === '<')
+	        result = parseXML(body);
+	      else
+	        result = parseASCII(body);
+	    } catch (e) {
+	      cb(new Error('error parsing font '+e.message));
+	      cb = noop;
+	    }
+	    cb(null, result);
+	  });
+	};
+
+	function isArrayBuffer(arr) {
+	  var str = Object.prototype.toString;
+	  return str.call(arr) === '[object ArrayBuffer]'
+	}
+
+	function getBinaryOpts(opt) {
+	  //IE10+ and other modern browsers support array buffers
+	  if (xml2)
+	    return xtend(opt, { responseType: 'arraybuffer' })
+	  
+	  if (typeof self.XMLHttpRequest === 'undefined')
+	    throw new Error('your browser does not support XHR loading')
+
+	  //IE9 and XML1 browsers could still use an override
+	  var req = new self.XMLHttpRequest();
+	  req.overrideMimeType('text/plain; charset=x-user-defined');
+	  return xtend({
+	    xhr: req
+	  }, opt)
+	}
+	return browser;
+}
+
+var browserExports = requireBrowser();
+const loadFont = /*@__PURE__*/getDefaultExportFromCjs(browserExports);
+
+var wordWrapper = {exports: {}};
+
+var hasRequiredWordWrapper;
+
+function requireWordWrapper () {
+	if (hasRequiredWordWrapper) return wordWrapper.exports;
+	hasRequiredWordWrapper = 1;
+	(function (module) {
+		var newline = /\n/;
+		var newlineChar = '\n';
+		var whitespace = /\s/;
+
+		module.exports = function(text, opt) {
+		    var lines = module.exports.lines(text, opt);
+		    return lines.map(function(line) {
+		        return text.substring(line.start, line.end)
+		    }).join('\n')
+		};
+
+		module.exports.lines = function wordwrap(text, opt) {
+		    opt = opt||{};
+
+		    //zero width results in nothing visible
+		    if (opt.width === 0 && opt.mode !== 'nowrap') 
+		        return []
+
+		    text = text||'';
+		    var width = typeof opt.width === 'number' ? opt.width : Number.MAX_VALUE;
+		    var start = Math.max(0, opt.start||0);
+		    var end = typeof opt.end === 'number' ? opt.end : text.length;
+		    var mode = opt.mode;
+
+		    var measure = opt.measure || monospace;
+		    if (mode === 'pre')
+		        return pre(measure, text, start, end, width)
+		    else
+		        return greedy(measure, text, start, end, width, mode)
+		};
+
+		function idxOf(text, chr, start, end) {
+		    var idx = text.indexOf(chr, start);
+		    if (idx === -1 || idx > end)
+		        return end
+		    return idx
+		}
+
+		function isWhitespace(chr) {
+		    return whitespace.test(chr)
+		}
+
+		function pre(measure, text, start, end, width) {
+		    var lines = [];
+		    var lineStart = start;
+		    for (var i=start; i<end && i<text.length; i++) {
+		        var chr = text.charAt(i);
+		        var isNewline = newline.test(chr);
+
+		        //If we've reached a newline, then step down a line
+		        //Or if we've reached the EOF
+		        if (isNewline || i===end-1) {
+		            var lineEnd = isNewline ? i : i+1;
+		            var measured = measure(text, lineStart, lineEnd, width);
+		            lines.push(measured);
+		            
+		            lineStart = i+1;
+		        }
+		    }
+		    return lines
+		}
+
+		function greedy(measure, text, start, end, width, mode) {
+		    //A greedy word wrapper based on LibGDX algorithm
+		    //https://github.com/libgdx/libgdx/blob/master/gdx/src/com/badlogic/gdx/graphics/g2d/BitmapFontCache.java
+		    var lines = [];
+
+		    var testWidth = width;
+		    //if 'nowrap' is specified, we only wrap on newline chars
+		    if (mode === 'nowrap')
+		        testWidth = Number.MAX_VALUE;
+
+		    while (start < end && start < text.length) {
+		        //get next newline position
+		        var newLine = idxOf(text, newlineChar, start, end);
+
+		        //eat whitespace at start of line
+		        while (start < newLine) {
+		            if (!isWhitespace( text.charAt(start) ))
+		                break
+		            start++;
+		        }
+
+		        //determine visible # of glyphs for the available width
+		        var measured = measure(text, start, newLine, testWidth);
+
+		        var lineEnd = start + (measured.end-measured.start);
+		        var nextStart = lineEnd + newlineChar.length;
+
+		        //if we had to cut the line before the next newline...
+		        if (lineEnd < newLine) {
+		            //find char to break on
+		            while (lineEnd > start) {
+		                if (isWhitespace(text.charAt(lineEnd)))
+		                    break
+		                lineEnd--;
+		            }
+		            if (lineEnd === start) {
+		                if (nextStart > start + newlineChar.length) nextStart--;
+		                lineEnd = nextStart; // If no characters to break, show all.
+		            } else {
+		                nextStart = lineEnd;
+		                //eat whitespace at end of line
+		                while (lineEnd > start) {
+		                    if (!isWhitespace(text.charAt(lineEnd - newlineChar.length)))
+		                        break
+		                    lineEnd--;
+		                }
+		            }
+		        }
+		        if (lineEnd >= start) {
+		            var result = measure(text, start, lineEnd, testWidth);
+		            lines.push(result);
+		        }
+		        start = nextStart;
+		    }
+		    return lines
+		}
+
+		//determines the visible number of glyphs within a given width
+		function monospace(text, start, end, width) {
+		    var glyphs = Math.min(width, end-start);
+		    return {
+		        start: start,
+		        end: start+glyphs
+		    }
+		} 
+	} (wordWrapper));
+	return wordWrapper.exports;
+}
+
+var asNumber;
+var hasRequiredAsNumber;
+
+function requireAsNumber () {
+	if (hasRequiredAsNumber) return asNumber;
+	hasRequiredAsNumber = 1;
+	asNumber = function numtype(num, def) {
+		return typeof num === 'number'
+			? num 
+			: (typeof def === 'number' ? def : 0)
+	};
+	return asNumber;
+}
+
+var layoutBmfontText;
+var hasRequiredLayoutBmfontText;
+
+function requireLayoutBmfontText () {
+	if (hasRequiredLayoutBmfontText) return layoutBmfontText;
+	hasRequiredLayoutBmfontText = 1;
+	var wordWrap = requireWordWrapper();
+	var xtend = requireImmutable();
+	var number = requireAsNumber();
+
+	var X_HEIGHTS = ['x', 'e', 'a', 'o', 'n', 's', 'r', 'c', 'u', 'm', 'v', 'w', 'z'];
+	var M_WIDTHS = ['m', 'w'];
+	var CAP_HEIGHTS = ['H', 'I', 'N', 'E', 'F', 'K', 'L', 'T', 'U', 'V', 'W', 'X', 'Y', 'Z'];
+
+
+	var TAB_ID = '\t'.charCodeAt(0);
+	var SPACE_ID = ' '.charCodeAt(0);
+	var ALIGN_LEFT = 0, 
+	    ALIGN_CENTER = 1, 
+	    ALIGN_RIGHT = 2;
+
+	layoutBmfontText = function createLayout(opt) {
+	  return new TextLayout(opt)
+	};
+
+	function TextLayout(opt) {
+	  this.glyphs = [];
+	  this._measure = this.computeMetrics.bind(this);
+	  this.update(opt);
+	}
+
+	TextLayout.prototype.update = function(opt) {
+	  opt = xtend({
+	    measure: this._measure
+	  }, opt);
+	  this._opt = opt;
+	  this._opt.tabSize = number(this._opt.tabSize, 4);
+
+	  if (!opt.font)
+	    throw new Error('must provide a valid bitmap font')
+
+	  var glyphs = this.glyphs;
+	  var text = opt.text||''; 
+	  var font = opt.font;
+	  this._setupSpaceGlyphs(font);
+	  
+	  var lines = wordWrap.lines(text, opt);
+	  var minWidth = opt.width || 0;
+
+	  //clear glyphs
+	  glyphs.length = 0;
+
+	  //get max line width
+	  var maxLineWidth = lines.reduce(function(prev, line) {
+	    return Math.max(prev, line.width, minWidth)
+	  }, 0);
+
+	  //the pen position
+	  var x = 0;
+	  var y = 0;
+	  var lineHeight = number(opt.lineHeight, font.common.lineHeight);
+	  var baseline = font.common.base;
+	  var descender = lineHeight-baseline;
+	  var letterSpacing = opt.letterSpacing || 0;
+	  var height = lineHeight * lines.length - descender;
+	  var align = getAlignType(this._opt.align);
+
+	  //draw text along baseline
+	  y -= height;
+	  
+	  //the metrics for this text layout
+	  this._width = maxLineWidth;
+	  this._height = height;
+	  this._descender = lineHeight - baseline;
+	  this._baseline = baseline;
+	  this._xHeight = getXHeight(font);
+	  this._capHeight = getCapHeight(font);
+	  this._lineHeight = lineHeight;
+	  this._ascender = lineHeight - descender - this._xHeight;
+	    
+	  //layout each glyph
+	  var self = this;
+	  lines.forEach(function(line, lineIndex) {
+	    var start = line.start;
+	    var end = line.end;
+	    var lineWidth = line.width;
+	    var lastGlyph;
+	    
+	    //for each glyph in that line...
+	    for (var i=start; i<end; i++) {
+	      var id = text.charCodeAt(i);
+	      var glyph = self.getGlyph(font, id);
+	      if (glyph) {
+	        if (lastGlyph) 
+	          x += getKerning(font, lastGlyph.id, glyph.id);
+
+	        var tx = x;
+	        if (align === ALIGN_CENTER) 
+	          tx += (maxLineWidth-lineWidth)/2;
+	        else if (align === ALIGN_RIGHT)
+	          tx += (maxLineWidth-lineWidth);
+
+	        glyphs.push({
+	          position: [tx, y],
+	          data: glyph,
+	          index: i,
+	          line: lineIndex
+	        });  
+
+	        //move pen forward
+	        x += glyph.xadvance + letterSpacing;
+	        lastGlyph = glyph;
+	      }
+	    }
+
+	    //next line down
+	    y += lineHeight;
+	    x = 0;
+	  });
+	  this._linesTotal = lines.length;
+	};
+
+	TextLayout.prototype._setupSpaceGlyphs = function(font) {
+	  //These are fallbacks, when the font doesn't include
+	  //' ' or '\t' glyphs
+	  this._fallbackSpaceGlyph = null;
+	  this._fallbackTabGlyph = null;
+
+	  if (!font.chars || font.chars.length === 0)
+	    return
+
+	  //try to get space glyph
+	  //then fall back to the 'm' or 'w' glyphs
+	  //then fall back to the first glyph available
+	  var space = getGlyphById(font, SPACE_ID) 
+	          || getMGlyph(font) 
+	          || font.chars[0];
+
+	  //and create a fallback for tab
+	  var tabWidth = this._opt.tabSize * space.xadvance;
+	  this._fallbackSpaceGlyph = space;
+	  this._fallbackTabGlyph = xtend(space, {
+	    x: 0, y: 0, xadvance: tabWidth, id: TAB_ID, 
+	    xoffset: 0, yoffset: 0, width: 0, height: 0
+	  });
+	};
+
+	TextLayout.prototype.getGlyph = function(font, id) {
+	  var glyph = getGlyphById(font, id);
+	  if (glyph)
+	    return glyph
+	  else if (id === TAB_ID) 
+	    return this._fallbackTabGlyph
+	  else if (id === SPACE_ID) 
+	    return this._fallbackSpaceGlyph
+	  return null
+	};
+
+	TextLayout.prototype.computeMetrics = function(text, start, end, width) {
+	  var letterSpacing = this._opt.letterSpacing || 0;
+	  var font = this._opt.font;
+	  var curPen = 0;
+	  var curWidth = 0;
+	  var count = 0;
+	  var glyph;
+	  var lastGlyph;
+
+	  if (!font.chars || font.chars.length === 0) {
+	    return {
+	      start: start,
+	      end: start,
+	      width: 0
+	    }
+	  }
+
+	  end = Math.min(text.length, end);
+	  for (var i=start; i < end; i++) {
+	    var id = text.charCodeAt(i);
+	    var glyph = this.getGlyph(font, id);
+
+	    if (glyph) {
+	      //move pen forward
+	      glyph.xoffset;
+	      var kern = lastGlyph ? getKerning(font, lastGlyph.id, glyph.id) : 0;
+	      curPen += kern;
+
+	      var nextPen = curPen + glyph.xadvance + letterSpacing;
+	      var nextWidth = curPen + glyph.width;
+
+	      //we've hit our limit; we can't move onto the next glyph
+	      if (nextWidth >= width || nextPen >= width)
+	        break
+
+	      //otherwise continue along our line
+	      curPen = nextPen;
+	      curWidth = nextWidth;
+	      lastGlyph = glyph;
+	    }
+	    count++;
+	  }
+	  
+	  //make sure rightmost edge lines up with rendered glyphs
+	  if (lastGlyph)
+	    curWidth += lastGlyph.xoffset;
+
+	  return {
+	    start: start,
+	    end: start + count,
+	    width: curWidth
+	  }
+	}
+
+	//getters for the private vars
+	;['width', 'height', 
+	  'descender', 'ascender',
+	  'xHeight', 'baseline',
+	  'capHeight',
+	  'lineHeight' ].forEach(addGetter);
+
+	function addGetter(name) {
+	  Object.defineProperty(TextLayout.prototype, name, {
+	    get: wrapper(name),
+	    configurable: true
+	  });
+	}
+
+	//create lookups for private vars
+	function wrapper(name) {
+	  return (new Function([
+	    'return function '+name+'() {',
+	    '  return this._'+name,
+	    '}'
+	  ].join('\n')))()
+	}
+
+	function getGlyphById(font, id) {
+	  if (!font.chars || font.chars.length === 0)
+	    return null
+
+	  var glyphIdx = findChar(font.chars, id);
+	  if (glyphIdx >= 0)
+	    return font.chars[glyphIdx]
+	  return null
+	}
+
+	function getXHeight(font) {
+	  for (var i=0; i<X_HEIGHTS.length; i++) {
+	    var id = X_HEIGHTS[i].charCodeAt(0);
+	    var idx = findChar(font.chars, id);
+	    if (idx >= 0) 
+	      return font.chars[idx].height
+	  }
+	  return 0
+	}
+
+	function getMGlyph(font) {
+	  for (var i=0; i<M_WIDTHS.length; i++) {
+	    var id = M_WIDTHS[i].charCodeAt(0);
+	    var idx = findChar(font.chars, id);
+	    if (idx >= 0) 
+	      return font.chars[idx]
+	  }
+	  return 0
+	}
+
+	function getCapHeight(font) {
+	  for (var i=0; i<CAP_HEIGHTS.length; i++) {
+	    var id = CAP_HEIGHTS[i].charCodeAt(0);
+	    var idx = findChar(font.chars, id);
+	    if (idx >= 0) 
+	      return font.chars[idx].height
+	  }
+	  return 0
+	}
+
+	function getKerning(font, left, right) {
+	  if (!font.kernings || font.kernings.length === 0)
+	    return 0
+
+	  var table = font.kernings;
+	  for (var i=0; i<table.length; i++) {
+	    var kern = table[i];
+	    if (kern.first === left && kern.second === right)
+	      return kern.amount
+	  }
+	  return 0
+	}
+
+	function getAlignType(align) {
+	  if (align === 'center')
+	    return ALIGN_CENTER
+	  else if (align === 'right')
+	    return ALIGN_RIGHT
+	  return ALIGN_LEFT
+	}
+
+	function findChar (array, value, start) {
+	  start = start || 0;
+	  for (var i = start; i < array.length; i++) {
+	    if (array[i].id === value) {
+	      return i
+	    }
+	  }
+	  return -1
+	}
+	return layoutBmfontText;
+}
+
+var inherits_browser = {exports: {}};
+
+var hasRequiredInherits_browser;
+
+function requireInherits_browser () {
+	if (hasRequiredInherits_browser) return inherits_browser.exports;
+	hasRequiredInherits_browser = 1;
+	if (typeof Object.create === 'function') {
+	  // implementation from standard node.js 'util' module
+	  inherits_browser.exports = function inherits(ctor, superCtor) {
+	    if (superCtor) {
+	      ctor.super_ = superCtor;
+	      ctor.prototype = Object.create(superCtor.prototype, {
+	        constructor: {
+	          value: ctor,
+	          enumerable: false,
+	          writable: true,
+	          configurable: true
+	        }
+	      });
+	    }
+	  };
+	} else {
+	  // old school shim for old browsers
+	  inherits_browser.exports = function inherits(ctor, superCtor) {
+	    if (superCtor) {
+	      ctor.super_ = superCtor;
+	      var TempCtor = function () {};
+	      TempCtor.prototype = superCtor.prototype;
+	      ctor.prototype = new TempCtor();
+	      ctor.prototype.constructor = ctor;
+	    }
+	  };
+	}
+	return inherits_browser.exports;
+}
+
+var dtype;
+var hasRequiredDtype;
+
+function requireDtype () {
+	if (hasRequiredDtype) return dtype;
+	hasRequiredDtype = 1;
+	dtype = function(dtype) {
+	  switch (dtype) {
+	    case 'int8':
+	      return Int8Array
+	    case 'int16':
+	      return Int16Array
+	    case 'int32':
+	      return Int32Array
+	    case 'uint8':
+	      return Uint8Array
+	    case 'uint16':
+	      return Uint16Array
+	    case 'uint32':
+	      return Uint32Array
+	    case 'float32':
+	      return Float32Array
+	    case 'float64':
+	      return Float64Array
+	    case 'array':
+	      return Array
+	    case 'uint8_clamped':
+	      return Uint8ClampedArray
+	  }
+	};
+	return dtype;
+}
+
+var anArray_1;
+var hasRequiredAnArray;
+
+function requireAnArray () {
+	if (hasRequiredAnArray) return anArray_1;
+	hasRequiredAnArray = 1;
+	var str = Object.prototype.toString;
+
+	anArray_1 = anArray;
+
+	function anArray(arr) {
+	  return (
+	       arr.BYTES_PER_ELEMENT
+	    && str.call(arr.buffer) === '[object ArrayBuffer]'
+	    || Array.isArray(arr)
+	  )
+	}
+	return anArray_1;
+}
+
+/*!
+ * Determine if an object is a Buffer
+ *
+ * @author   Feross Aboukhadijeh <https://feross.org>
+ * @license  MIT
+ */
+
+var isBuffer_1;
+var hasRequiredIsBuffer;
+
+function requireIsBuffer () {
+	if (hasRequiredIsBuffer) return isBuffer_1;
+	hasRequiredIsBuffer = 1;
+	// The _isBuffer check is for Safari 5-7 support, because it's missing
+	// Object.prototype.constructor. Remove this eventually
+	isBuffer_1 = function (obj) {
+	  return obj != null && (isBuffer(obj) || isSlowBuffer(obj) || !!obj._isBuffer)
+	};
+
+	function isBuffer (obj) {
+	  return !!obj.constructor && typeof obj.constructor.isBuffer === 'function' && obj.constructor.isBuffer(obj)
+	}
+
+	// For Node v0.10 support. Remove this eventually.
+	function isSlowBuffer (obj) {
+	  return typeof obj.readFloatLE === 'function' && typeof obj.slice === 'function' && isBuffer(obj.slice(0, 0))
+	}
+	return isBuffer_1;
+}
+
+var quadIndices;
+var hasRequiredQuadIndices;
+
+function requireQuadIndices () {
+	if (hasRequiredQuadIndices) return quadIndices;
+	hasRequiredQuadIndices = 1;
+	var dtype = requireDtype();
+	var anArray = requireAnArray();
+	var isBuffer = requireIsBuffer();
+
+	var CW = [0, 2, 3];
+	var CCW = [2, 1, 3];
+
+	quadIndices = function createQuadElements(array, opt) {
+	    //if user didn't specify an output array
+	    if (!array || !(anArray(array) || isBuffer(array))) {
+	        opt = array || {};
+	        array = null;
+	    }
+
+	    if (typeof opt === 'number') //backwards-compatible
+	        opt = { count: opt };
+	    else
+	        opt = opt || {};
+
+	    var type = typeof opt.type === 'string' ? opt.type : 'uint16';
+	    var count = typeof opt.count === 'number' ? opt.count : 1;
+	    var start = (opt.start || 0); 
+
+	    var dir = opt.clockwise !== false ? CW : CCW,
+	        a = dir[0], 
+	        b = dir[1],
+	        c = dir[2];
+
+	    var numIndices = count * 6;
+
+	    var indices = array || new (dtype(type))(numIndices);
+	    for (var i = 0, j = 0; i < numIndices; i += 6, j += 4) {
+	        var x = i + start;
+	        indices[x + 0] = j + 0;
+	        indices[x + 1] = j + 1;
+	        indices[x + 2] = j + 2;
+	        indices[x + 3] = j + a;
+	        indices[x + 4] = j + b;
+	        indices[x + 5] = j + c;
+	    }
+	    return indices
+	};
+	return quadIndices;
+}
+
+var vertices = {};
+
+var hasRequiredVertices;
+
+function requireVertices () {
+	if (hasRequiredVertices) return vertices;
+	hasRequiredVertices = 1;
+	vertices.pages = function pages (glyphs) {
+	  var pages = new Float32Array(glyphs.length * 4 * 1);
+	  var i = 0;
+	  glyphs.forEach(function (glyph) {
+	    var id = glyph.data.page || 0;
+	    pages[i++] = id;
+	    pages[i++] = id;
+	    pages[i++] = id;
+	    pages[i++] = id;
+	  });
+	  return pages
+	};
+
+	vertices.uvs = function uvs (glyphs, texWidth, texHeight, flipY) {
+	  var uvs = new Float32Array(glyphs.length * 4 * 2);
+	  var i = 0;
+	  glyphs.forEach(function (glyph) {
+	    var bitmap = glyph.data;
+	    var bw = (bitmap.x + bitmap.width);
+	    var bh = (bitmap.y + bitmap.height);
+
+	    // top left position
+	    var u0 = bitmap.x / texWidth;
+	    var v1 = bitmap.y / texHeight;
+	    var u1 = bw / texWidth;
+	    var v0 = bh / texHeight;
+
+	    if (flipY) {
+	      v1 = (texHeight - bitmap.y) / texHeight;
+	      v0 = (texHeight - bh) / texHeight;
+	    }
+
+	    // BL
+	    uvs[i++] = u0;
+	    uvs[i++] = v1;
+	    // TL
+	    uvs[i++] = u0;
+	    uvs[i++] = v0;
+	    // TR
+	    uvs[i++] = u1;
+	    uvs[i++] = v0;
+	    // BR
+	    uvs[i++] = u1;
+	    uvs[i++] = v1;
+	  });
+	  return uvs
+	};
+
+	vertices.positions = function positions (glyphs) {
+	  var positions = new Float32Array(glyphs.length * 4 * 2);
+	  var i = 0;
+	  glyphs.forEach(function (glyph) {
+	    var bitmap = glyph.data;
+
+	    // bottom left position
+	    var x = glyph.position[0] + bitmap.xoffset;
+	    var y = glyph.position[1] + bitmap.yoffset;
+
+	    // quad size
+	    var w = bitmap.width;
+	    var h = bitmap.height;
+
+	    // BL
+	    positions[i++] = x;
+	    positions[i++] = y;
+	    // TL
+	    positions[i++] = x;
+	    positions[i++] = y + h;
+	    // TR
+	    positions[i++] = x + w;
+	    positions[i++] = y + h;
+	    // BR
+	    positions[i++] = x + w;
+	    positions[i++] = y;
+	  });
+	  return positions
+	};
+	return vertices;
+}
+
+var utils = {};
+
+var hasRequiredUtils;
+
+function requireUtils () {
+	if (hasRequiredUtils) return utils;
+	hasRequiredUtils = 1;
+	var itemSize = 2;
+	var box = { min: [0, 0], max: [0, 0] };
+
+	function bounds (positions) {
+	  var count = positions.length / itemSize;
+	  box.min[0] = positions[0];
+	  box.min[1] = positions[1];
+	  box.max[0] = positions[0];
+	  box.max[1] = positions[1];
+
+	  for (var i = 0; i < count; i++) {
+	    var x = positions[i * itemSize + 0];
+	    var y = positions[i * itemSize + 1];
+	    box.min[0] = Math.min(x, box.min[0]);
+	    box.min[1] = Math.min(y, box.min[1]);
+	    box.max[0] = Math.max(x, box.max[0]);
+	    box.max[1] = Math.max(y, box.max[1]);
+	  }
+	}
+
+	utils.computeBox = function (positions, output) {
+	  bounds(positions);
+	  output.min.set(box.min[0], box.min[1], 0);
+	  output.max.set(box.max[0], box.max[1], 0);
+	};
+
+	utils.computeSphere = function (positions, output) {
+	  bounds(positions);
+	  var minX = box.min[0];
+	  var minY = box.min[1];
+	  var maxX = box.max[0];
+	  var maxY = box.max[1];
+	  var width = maxX - minX;
+	  var height = maxY - minY;
+	  var length = Math.sqrt(width * width + height * height);
+	  output.center.set(minX + width / 2, minY + height / 2, 0);
+	  output.radius = length / 2;
+	};
+	return utils;
+}
+
+var threeBmfontText;
+var hasRequiredThreeBmfontText;
+
+function requireThreeBmfontText () {
+	if (hasRequiredThreeBmfontText) return threeBmfontText;
+	hasRequiredThreeBmfontText = 1;
+	var createLayout = requireLayoutBmfontText();
+	var inherits = requireInherits_browser();
+	var createIndices = requireQuadIndices();
+
+	var vertices = requireVertices();
+	var utils = requireUtils();
+
+	var Base = THREE.BufferGeometry;
+
+	threeBmfontText = function createTextGeometry (opt) {
+	  return new TextGeometry(opt)
+	};
+
+	function TextGeometry (opt) {
+	  Base.call(this);
+
+	  if (typeof opt === 'string') {
+	    opt = { text: opt };
+	  }
+
+	  // use these as default values for any subsequent
+	  // calls to update()
+	  this._opt = Object.assign({}, opt);
+
+	  // also do an initial setup...
+	  if (opt) this.update(opt);
+	}
+
+	inherits(TextGeometry, Base);
+
+	TextGeometry.prototype.update = function (opt) {
+	  if (typeof opt === 'string') {
+	    opt = { text: opt };
+	  }
+
+	  // use constructor defaults
+	  opt = Object.assign({}, this._opt, opt);
+
+	  if (!opt.font) {
+	    throw new TypeError('must specify a { font } in options')
+	  }
+
+	  this.layout = createLayout(opt);
+
+	  // get vec2 texcoords
+	  var flipY = opt.flipY !== false;
+
+	  // the desired BMFont data
+	  var font = opt.font;
+
+	  // determine texture size from font file
+	  var texWidth = font.common.scaleW;
+	  var texHeight = font.common.scaleH;
+
+	  // get visible glyphs
+	  var glyphs = this.layout.glyphs.filter(function (glyph) {
+	    var bitmap = glyph.data;
+	    return bitmap.width * bitmap.height > 0
+	  });
+
+	  // provide visible glyphs for convenience
+	  this.visibleGlyphs = glyphs;
+
+	  // get common vertex data
+	  var positions = vertices.positions(glyphs);
+	  var uvs = vertices.uvs(glyphs, texWidth, texHeight, flipY);
+	  var indices = createIndices([], {
+	    clockwise: true,
+	    type: 'uint16',
+	    count: glyphs.length
+	  });
+
+	  // update vertex data
+	  this.setIndex(indices);
+	  this.setAttribute('position', new THREE.BufferAttribute(positions, 2));
+	  this.setAttribute('uv', new THREE.BufferAttribute(uvs, 2));
+
+	  // update multipage data
+	  if (!opt.multipage && 'page' in this.attributes) {
+	    // disable multipage rendering
+	    this.removeAttribute('page');
+	  } else if (opt.multipage) {
+	    // enable multipage rendering
+	    var pages = vertices.pages(glyphs);
+	    this.setAttribute('page', new THREE.BufferAttribute(pages, 1));
+	  }
+	};
+
+	TextGeometry.prototype.computeBoundingSphere = function () {
+	  if (this.boundingSphere === null) {
+	    this.boundingSphere = new THREE.Sphere();
+	  }
+
+	  var positions = this.attributes.position.array;
+	  var itemSize = this.attributes.position.itemSize;
+	  if (!positions || !itemSize || positions.length < 2) {
+	    this.boundingSphere.radius = 0;
+	    this.boundingSphere.center.set(0, 0, 0);
+	    return
+	  }
+	  utils.computeSphere(positions, this.boundingSphere);
+	  if (isNaN(this.boundingSphere.radius)) {
+	    console.error('THREE.BufferGeometry.computeBoundingSphere(): ' +
+	      'Computed radius is NaN. The ' +
+	      '"position" attribute is likely to have NaN values.');
+	  }
+	};
+
+	TextGeometry.prototype.computeBoundingBox = function () {
+	  if (this.boundingBox === null) {
+	    this.boundingBox = new THREE.Box3();
+	  }
+
+	  var bbox = this.boundingBox;
+	  var positions = this.attributes.position.array;
+	  var itemSize = this.attributes.position.itemSize;
+	  if (!positions || !itemSize || positions.length < 2) {
+	    bbox.makeEmpty();
+	    return
+	  }
+	  utils.computeBox(positions, bbox);
+	};
+	return threeBmfontText;
+}
+
+var threeBmfontTextExports = requireThreeBmfontText();
+const createGeometry = /*@__PURE__*/getDefaultExportFromCjs(threeBmfontTextExports);
+
+/*
+object-assign
+(c) Sindre Sorhus
+@license MIT
+*/
+
+var objectAssign;
+var hasRequiredObjectAssign;
+
+function requireObjectAssign () {
+	if (hasRequiredObjectAssign) return objectAssign;
+	hasRequiredObjectAssign = 1;
+	/* eslint-disable no-unused-vars */
+	var getOwnPropertySymbols = Object.getOwnPropertySymbols;
+	var hasOwnProperty = Object.prototype.hasOwnProperty;
+	var propIsEnumerable = Object.prototype.propertyIsEnumerable;
+
+	function toObject(val) {
+		if (val === null || val === undefined) {
+			throw new TypeError('Object.assign cannot be called with null or undefined');
+		}
+
+		return Object(val);
+	}
+
+	function shouldUseNative() {
+		try {
+			if (!Object.assign) {
+				return false;
+			}
+
+			// Detect buggy property enumeration order in older V8 versions.
+
+			// https://bugs.chromium.org/p/v8/issues/detail?id=4118
+			var test1 = new String('abc');  // eslint-disable-line no-new-wrappers
+			test1[5] = 'de';
+			if (Object.getOwnPropertyNames(test1)[0] === '5') {
+				return false;
+			}
+
+			// https://bugs.chromium.org/p/v8/issues/detail?id=3056
+			var test2 = {};
+			for (var i = 0; i < 10; i++) {
+				test2['_' + String.fromCharCode(i)] = i;
+			}
+			var order2 = Object.getOwnPropertyNames(test2).map(function (n) {
+				return test2[n];
+			});
+			if (order2.join('') !== '0123456789') {
+				return false;
+			}
+
+			// https://bugs.chromium.org/p/v8/issues/detail?id=3056
+			var test3 = {};
+			'abcdefghijklmnopqrst'.split('').forEach(function (letter) {
+				test3[letter] = letter;
+			});
+			if (Object.keys(Object.assign({}, test3)).join('') !==
+					'abcdefghijklmnopqrst') {
+				return false;
+			}
+
+			return true;
+		} catch (err) {
+			// We don't expect any of the above to throw, but better to be safe.
+			return false;
+		}
+	}
+
+	objectAssign = shouldUseNative() ? Object.assign : function (target, source) {
+		var from;
+		var to = toObject(target);
+		var symbols;
+
+		for (var s = 1; s < arguments.length; s++) {
+			from = Object(arguments[s]);
+
+			for (var key in from) {
+				if (hasOwnProperty.call(from, key)) {
+					to[key] = from[key];
+				}
+			}
+
+			if (getOwnPropertySymbols) {
+				symbols = getOwnPropertySymbols(from);
+				for (var i = 0; i < symbols.length; i++) {
+					if (propIsEnumerable.call(from, symbols[i])) {
+						to[symbols[i]] = from[symbols[i]];
+					}
+				}
+			}
+		}
+
+		return to;
+	};
+	return objectAssign;
+}
+
+var msdf;
+var hasRequiredMsdf;
+
+function requireMsdf () {
+	if (hasRequiredMsdf) return msdf;
+	hasRequiredMsdf = 1;
+	var assign = requireObjectAssign();
+
+	msdf = function createMSDFShader (opt) {
+	  opt = opt || {};
+	  var opacity = typeof opt.opacity === 'number' ? opt.opacity : 1;
+	  var alphaTest = typeof opt.alphaTest === 'number' ? opt.alphaTest : 0.0001;
+	  var precision = opt.precision || 'highp';
+	  var color = opt.color;
+	  var map = opt.map;
+	  var negate = typeof opt.negate === 'boolean' ? opt.negate : true;
+
+	  // remove to satisfy r73
+	  delete opt.map;
+	  delete opt.color;
+	  delete opt.precision;
+	  delete opt.opacity;
+	  delete opt.negate;
+
+	  return assign({
+	    uniforms: {
+	      opacity: { type: 'f', value: opacity },
+	      map: { type: 't', value: map || new THREE.Texture() },
+	      color: { type: 'c', value: new THREE.Color(color) }
+	    },
+	    vertexShader: [
+	      'attribute vec2 uv;',
+	      'attribute vec4 position;',
+	      'uniform mat4 projectionMatrix;',
+	      'uniform mat4 modelViewMatrix;',
+	      'varying vec2 vUv;',
+	      'void main() {',
+	      'vUv = uv;',
+	      'gl_Position = projectionMatrix * modelViewMatrix * position;',
+	      '}'
+	    ].join('\n'),
+	    fragmentShader: [
+	      '#ifdef GL_OES_standard_derivatives',
+	      '#extension GL_OES_standard_derivatives : enable',
+	      '#endif',
+	      'precision ' + precision + ' float;',
+	      'uniform float opacity;',
+	      'uniform vec3 color;',
+	      'uniform sampler2D map;',
+	      'varying vec2 vUv;',
+
+	      'float median(float r, float g, float b) {',
+	      '  return max(min(r, g), min(max(r, g), b));',
+	      '}',
+
+	      'void main() {',
+	      '  vec3 sample = ' + (negate ? '1.0 - ' : '') + 'texture2D(map, vUv).rgb;',
+	      '  float sigDist = median(sample.r, sample.g, sample.b) - 0.5;',
+	      '  float alpha = clamp(sigDist/fwidth(sigDist) + 0.5, 0.0, 1.0);',
+	      '  gl_FragColor = vec4(color.xyz, alpha * opacity);',
+	      alphaTest === 0
+	        ? ''
+	        : '  if (gl_FragColor.a < ' + alphaTest + ') discard;',
+	      '}'
+	    ].join('\n')
+	  }, opt);
+	};
+	return msdf;
+}
+
+var msdfExports = requireMsdf();
+const MSDFShader = /*@__PURE__*/getDefaultExportFromCjs(msdfExports);
+
+const vertexShader = `
+  varying vec2 vUv;
+  varying vec3 vPos;
+
+  void main() {
+    vUv = uv;
+    vPos = position;
+
+    gl_Position = projectionMatrix * modelViewMatrix * vec4(position, 1.);
+  }
+`;
+const fragmentShader = `
+  varying vec2 vUv;
+  varying vec3 vPos;
+
+  uniform sampler2D uTexture;
+  uniform float uTime;
+
+  void main() {
+    float time = uTime * 0.5;
+    vec2 repeat = -vec2(12., 3.);
+    // To repeat the uvs we need to multiply them by a scalar
+    // and then get the fractional part of it so they from 0 to 1
+    // To move them continuously we have to add time
+    // to the x or y component, to change the direction
+    vec2 uv = fract(vUv * repeat - vec2(time, 0.)); // The sign of time change direction of movement
+
+    // Fake shadow
+    float shadow = clamp(vPos.z / 5., 0., 1.);
+
+    vec3 texture = texture2D(uTexture, uv).rgb;
+    // texture *= vec3(uv.x, uv.y, 1.); // To help visualize the repeated uvs
+
+    gl_FragColor = vec4(texture * shadow, 1.);
+  }
+`;
+
+class GL {
+  renderer;
+  camera;
+  scene;
+  controls;
+  clock;
+  rt;
+  rtCamera;
+  rtScene;
+  text;
+  mesh;
+  geometry;
+  material;
+  fontGeometry;
+  fontMaterial;
+  loader;
+  constructor() {
+    this.renderer = new index.WebGLRenderer({
+      alpha: true
+    });
+    this.renderer.setPixelRatio(Math.min(window.devicePixelRatio, 1.5));
+    this.renderer.setSize(window.innerWidth, window.innerHeight);
+    this.renderer.setClearColor(0, 1);
+    document.body.appendChild(this.renderer.domElement);
+    this.camera = new index.PerspectiveCamera(
+      45,
+      window.innerWidth / window.innerHeight,
+      1,
+      1e3
+    );
+    this.camera.position.z = 60;
+    this.scene = new index.Scene();
+    this.controls = new (OrbitControls(index.THREE))(
+      this.camera,
+      this.renderer.domElement
+    );
+    this.clock = new index.Clock();
+  }
+  init() {
+    loadFont("/fonts/orbitron/orbitron-black.fnt", (_, font) => {
+      this.fontGeometry = createGeometry({
+        font,
+        text: "ENDLESS"
+      });
+      this.loader = new index.TextureLoader();
+      this.loader.load("/fonts/orbitron/orbitron-black.png", (texture) => {
+        this.fontMaterial = new index.RawShaderMaterial(
+          MSDFShader({
+            map: texture,
+            side: index.DoubleSide,
+            transparent: true,
+            negate: false,
+            color: 16777215
+          })
+        );
+        this.createRenderTarget();
+        this.createMesh();
+        this.animate();
+        this.addEvents();
+      });
+    });
+  }
+  createRenderTarget() {
+    this.rt = new index.WebGLRenderTarget(window.innerWidth, window.innerHeight);
+    this.rtCamera = new index.PerspectiveCamera(45, 1, 0.1, 1e3);
+    this.rtCamera.position.z = 2.5;
+    this.rtScene = new index.Scene();
+    this.rtScene.background = new index.Color("#000000");
+    this.text = new index.Mesh(this.fontGeometry, this.fontMaterial);
+    this.text.position.set(-0.965, -0.525, 0);
+    this.text.rotation.set(Math.PI, 0, 0);
+    this.text.scale.set(8e-3, 0.04, 1);
+    this.rtScene.add(this.text);
+  }
+  createMesh() {
+    if (!this.rt) return;
+    this.geometry = new index.TorusKnotGeometry(9, 3, 768, 3, 4, 3);
+    this.material = new index.ShaderMaterial({
+      vertexShader,
+      fragmentShader,
+      uniforms: {
+        uTime: { value: 0 },
+        uTexture: { value: this.rt.texture }
+      }
+    });
+    this.mesh = new index.Mesh(this.geometry, this.material);
+    this.scene.add(this.mesh);
+  }
+  animate() {
+    requestAnimationFrame(this.animate.bind(this));
+    this.render();
+  }
+  render() {
+    if (!this.material || !this.rt || !this.rtScene || !this.rtCamera) return;
+    this.controls.update();
+    this.material.uniforms.uTime.value = this.clock.getElapsedTime();
+    this.renderer.setRenderTarget(this.rt);
+    this.renderer.render(this.rtScene, this.rtCamera);
+    this.renderer.setRenderTarget(null);
+    this.renderer.render(this.scene, this.camera);
+  }
+  addEvents() {
+    window.addEventListener("resize", this.resize.bind(this));
+  }
+  resize() {
+    const width = window.innerWidth;
+    const height = window.innerHeight;
+    this.camera.aspect = width / height;
+    this.camera.updateProjectionMatrix();
+    this.renderer.setSize(width, height);
+  }
+}
+
+exports.GL = GL;