@tarsis/toolkit 0.1.0

package/dist/gl-5YgDuVIP.cjs

@@ -0,0 +1,3025 @@
+'use strict';
+
+Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+
+const index = require('./index-CZ4lcB3k.cjs');
+
+/*
+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 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;
+};
+
+const OrbitControls = /*@__PURE__*/index.getDefaultExportFromCjs(threeOrbitControls);
+
+var xhr$1 = {exports: {}};
+
+var win;
+
+if (typeof window !== "undefined") {
+    win = window;
+} else if (typeof index.commonjsGlobal !== "undefined") {
+    win = index.commonjsGlobal;
+} else if (typeof self !== "undefined"){
+    win = self;
+} else {
+    win = {};
+}
+
+var window_1 = win;
+
+var isFunction_1 = isFunction$1;
+
+var toString = Object.prototype.toString;
+
+function isFunction$1 (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))
+}
+
+var trim = function(string) {
+  return string.replace(/^\s+|\s+$/g, '');
+}
+  , isArray = function(arg) {
+      return Object.prototype.toString.call(arg) === '[object Array]';
+    };
+
+var parseHeaders$1 = 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
+};
+
+var 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
+}
+
+var window$1 = window_1;
+var isFunction = isFunction_1;
+var parseHeaders = parseHeaders$1;
+var xtend$2 = immutable;
+
+xhr$1.exports = createXHR;
+// Allow use of default import syntax in TypeScript
+xhr$1.exports.default = createXHR;
+createXHR.XMLHttpRequest = window$1.XMLHttpRequest || noop$1;
+createXHR.XDomainRequest = "withCredentials" in (new createXHR.XMLHttpRequest()) ? createXHR.XMLHttpRequest : window$1.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$2(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$1() {}
+
+var xhrExports = xhr$1.exports;
+
+var 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$1(data)
+  return parseInt(data, 10)
+}
+
+function parseIntList$1(data) {
+  return data.split(',').map(function(val) {
+    return parseInt(val, 10)
+  })
+}
+
+//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';
+
+var 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)
+  })
+}
+
+var 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
+  }
+})();
+
+var parseAttributes = parseAttribs;
+var parseFromString = xmlParseFromString;
+
+//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'
+};
+
+var 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
+}
+
+var HEADER$1 = [66, 77, 70];
+
+var parseBmfontBinary = function readBMFontBinary(buf) {
+  if (buf.length < 6)
+    throw new Error('invalid buffer length for BMFont')
+
+  var header = HEADER$1.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')
+}
+
+const __viteBrowserExternal = {};
+
+const __viteBrowserExternal$1 = /*#__PURE__*/Object.freeze(/*#__PURE__*/Object.defineProperty({
+	__proto__: null,
+	default: __viteBrowserExternal
+}, Symbol.toStringTag, { value: 'Module' }));
+
+const require$$0 = /*@__PURE__*/index.getAugmentedNamespace(__viteBrowserExternal$1);
+
+var Buffer$1 = require$$0.Buffer; // for use with browserify
+
+var bufferEqual = function (a, b) {
+    if (!Buffer$1.isBuffer(a)) return undefined;
+    if (!Buffer$1.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;
+};
+
+var equal = bufferEqual;
+var HEADER = Buffer.from([66, 77, 70, 3]);
+
+var isBinary = function(buf) {
+  if (typeof buf === 'string')
+    return buf.substring(0, 3) === 'BMF'
+  return buf.length > 4 && equal(buf.slice(0, 4), HEADER)
+};
+
+var xhr = xhrExports;
+var noop = function(){};
+var parseASCII = parseBmfontAscii;
+var parseXML = browser$1;
+var readBinary = parseBmfontBinary;
+var isBinaryFormat = isBinary;
+var xtend$1 = immutable;
+
+var xml2 = (function hasXML2() {
+  return self.XMLHttpRequest && "withCredentials" in new XMLHttpRequest
+})();
+
+var 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$1(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$1({
+    xhr: req
+  }, opt)
+}
+
+const loadFont = /*@__PURE__*/index.getDefaultExportFromCjs(browser);
+
+var wordWrapper = {exports: {}};
+
+(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));
+
+var wordWrapperExports = wordWrapper.exports;
+
+var asNumber = function numtype(num, def) {
+	return typeof num === 'number'
+		? num 
+		: (typeof def === 'number' ? def : 0)
+};
+
+var wordWrap = wordWrapperExports;
+var xtend = immutable;
+var number = asNumber;
+
+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;
+
+var 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
+}
+
+var inherits_browser = {exports: {}};
+
+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;
+    }
+  };
+}
+
+var inherits_browserExports = inherits_browser.exports;
+
+var dtype$1 = 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
+  }
+};
+
+var str = Object.prototype.toString;
+
+var anArray_1 = anArray$1;
+
+function anArray$1(arr) {
+  return (
+       arr.BYTES_PER_ELEMENT
+    && str.call(arr.buffer) === '[object ArrayBuffer]'
+    || Array.isArray(arr)
+  )
+}
+
+/*!
+ * Determine if an object is a Buffer
+ *
+ * @author   Feross Aboukhadijeh <https://feross.org>
+ * @license  MIT
+ */
+
+// The _isBuffer check is for Safari 5-7 support, because it's missing
+// Object.prototype.constructor. Remove this eventually
+var isBuffer_1 = function (obj) {
+  return obj != null && (isBuffer$1(obj) || isSlowBuffer(obj) || !!obj._isBuffer)
+};
+
+function isBuffer$1 (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$1(obj.slice(0, 0))
+}
+
+var dtype = dtype$1;
+var anArray = anArray_1;
+var isBuffer = isBuffer_1;
+
+var CW = [0, 2, 3];
+var CCW = [2, 1, 3];
+
+var 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
+};
+
+var vertices$1 = {};
+
+vertices$1.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$1.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$1.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
+};
+
+var utils$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$1.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$1.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;
+};
+
+var createLayout = layoutBmfontText;
+var inherits = inherits_browserExports;
+var createIndices = quadIndices;
+
+var vertices = vertices$1;
+var utils = utils$1;
+
+var Base = THREE.BufferGeometry;
+
+var 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);
+};
+
+const createGeometry = /*@__PURE__*/index.getDefaultExportFromCjs(threeBmfontText);
+
+var assign = requireObjectAssign();
+
+var 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);
+};
+
+const MSDFShader = /*@__PURE__*/index.getDefaultExportFromCjs(msdf);
+
+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;