globe.gl 2.32.6 → 2.33.0

package/dist/globe.gl.js

@@ -1,4 +1,4 @@
-// Version 2.32.6 globe.gl - https://github.com/vasturiano/globe.gl
+// Version 2.33.0 globe.gl - https://github.com/vasturiano/globe.gl
 (function (global, factory) {
   typeof exports === 'object' && typeof module !== 'undefined' ? module.exports = factory() :
   typeof define === 'function' && define.amd ? define(factory) :
@@ -128,7 +128,7 @@
    * Copyright 2010-2024 Three.js Authors
    * SPDX-License-Identifier: MIT
    */
-  const REVISION = '168';
+  const REVISION = '169';
 
   const MOUSE = { LEFT: 0, MIDDLE: 1, RIGHT: 2, ROTATE: 0, DOLLY: 1, PAN: 2 };
   const TOUCH = { ROTATE: 0, PAN: 1, DOLLY_PAN: 2, DOLLY_ROTATE: 3 };
@@ -1651,6 +1651,38 @@
 
   }
 
+  function toNormalizedProjectionMatrix( projectionMatrix ) {
+
+  	const m = projectionMatrix.elements;
+
+  	// Convert [-1, 1] to [0, 1] projection matrix
+  	m[ 2 ] = 0.5 * m[ 2 ] + 0.5 * m[ 3 ];
+  	m[ 6 ] = 0.5 * m[ 6 ] + 0.5 * m[ 7 ];
+  	m[ 10 ] = 0.5 * m[ 10 ] + 0.5 * m[ 11 ];
+  	m[ 14 ] = 0.5 * m[ 14 ] + 0.5 * m[ 15 ];
+
+  }
+
+  function toReversedProjectionMatrix( projectionMatrix ) {
+
+  	const m = projectionMatrix.elements;
+  	const isPerspectiveMatrix = m[ 11 ] === - 1;
+
+  	// Reverse [0, 1] projection matrix
+  	if ( isPerspectiveMatrix ) {
+
+  		m[ 10 ] = - m[ 10 ] - 1;
+  		m[ 14 ] = - m[ 14 ];
+
+  	} else {
+
+  		m[ 10 ] = - m[ 10 ];
+  		m[ 14 ] = - m[ 14 ] + 1;
+
+  	}
+
+  }
+
   /**
    * Matrices converting P3 <-> Rec. 709 primaries, without gamut mapping
    * or clipping. Based on W3C specifications for sRGB and Display P3,
@@ -8210,6 +8242,10 @@
   const _vbp = /*@__PURE__*/ new Vector3();
   const _vcp = /*@__PURE__*/ new Vector3();
 
+  const _v40 = /*@__PURE__*/ new Vector4();
+  const _v41 = /*@__PURE__*/ new Vector4();
+  const _v42 = /*@__PURE__*/ new Vector4();
+
   class Triangle {
 
   	constructor( a = new Vector3(), b = new Vector3(), c = new Vector3() ) {
@@ -8304,6 +8340,25 @@
 
   	}
 
+  	static getInterpolatedAttribute( attr, i1, i2, i3, barycoord, target ) {
+
+  		_v40.setScalar( 0 );
+  		_v41.setScalar( 0 );
+  		_v42.setScalar( 0 );
+
+  		_v40.fromBufferAttribute( attr, i1 );
+  		_v41.fromBufferAttribute( attr, i2 );
+  		_v42.fromBufferAttribute( attr, i3 );
+
+  		target.setScalar( 0 );
+  		target.addScaledVector( _v40, barycoord.x );
+  		target.addScaledVector( _v41, barycoord.y );
+  		target.addScaledVector( _v42, barycoord.z );
+
+  		return target;
+
+  	}
+
   	static isFrontFacing( a, b, c, direction ) {
 
   		_v0$2.subVectors( c, b );
@@ -9750,7 +9805,6 @@
   		this.normalized = normalized;
 
   		this.usage = StaticDrawUsage;
-  		this._updateRange = { offset: 0, count: - 1 };
   		this.updateRanges = [];
   		this.gpuType = FloatType;
 
@@ -9766,13 +9820,6 @@
 
   	}
 
-  	get updateRange() {
-
-  		warnOnce( 'THREE.BufferAttribute: updateRange() is deprecated and will be removed in r169. Use addUpdateRange() instead.' ); // @deprecated, r159
-  		return this._updateRange;
-
-  	}
-
   	setUsage( value ) {
 
   		this.usage = value;
@@ -11213,14 +11260,6 @@
   const _tempA = /*@__PURE__*/ new Vector3();
   const _morphA = /*@__PURE__*/ new Vector3();
 
-  const _uvA$1 = /*@__PURE__*/ new Vector2();
-  const _uvB$1 = /*@__PURE__*/ new Vector2();
-  const _uvC$1 = /*@__PURE__*/ new Vector2();
-
-  const _normalA = /*@__PURE__*/ new Vector3();
-  const _normalB = /*@__PURE__*/ new Vector3();
-  const _normalC = /*@__PURE__*/ new Vector3();
-
   const _intersectionPoint = /*@__PURE__*/ new Vector3();
   const _intersectionPointWorld = /*@__PURE__*/ new Vector3();
 
@@ -11563,33 +11602,24 @@
 
   	if ( intersection ) {
 
-  		if ( uv ) {
+  		const barycoord = new Vector3();
+  		Triangle.getBarycoord( _intersectionPoint, _vA$1, _vB$1, _vC$1, barycoord );
 
-  			_uvA$1.fromBufferAttribute( uv, a );
-  			_uvB$1.fromBufferAttribute( uv, b );
-  			_uvC$1.fromBufferAttribute( uv, c );
+  		if ( uv ) {
 
-  			intersection.uv = Triangle.getInterpolation( _intersectionPoint, _vA$1, _vB$1, _vC$1, _uvA$1, _uvB$1, _uvC$1, new Vector2() );
+  			intersection.uv = Triangle.getInterpolatedAttribute( uv, a, b, c, barycoord, new Vector2() );
 
   		}
 
   		if ( uv1 ) {
 
-  			_uvA$1.fromBufferAttribute( uv1, a );
-  			_uvB$1.fromBufferAttribute( uv1, b );
-  			_uvC$1.fromBufferAttribute( uv1, c );
-
-  			intersection.uv1 = Triangle.getInterpolation( _intersectionPoint, _vA$1, _vB$1, _vC$1, _uvA$1, _uvB$1, _uvC$1, new Vector2() );
+  			intersection.uv1 = Triangle.getInterpolatedAttribute( uv1, a, b, c, barycoord, new Vector2() );
 
   		}
 
   		if ( normal ) {
 
-  			_normalA.fromBufferAttribute( normal, a );
-  			_normalB.fromBufferAttribute( normal, b );
-  			_normalC.fromBufferAttribute( normal, c );
-
-  			intersection.normal = Triangle.getInterpolation( _intersectionPoint, _vA$1, _vB$1, _vC$1, _normalA, _normalB, _normalC, new Vector3() );
+  			intersection.normal = Triangle.getInterpolatedAttribute( normal, a, b, c, barycoord, new Vector3() );
 
   			if ( intersection.normal.dot( ray.direction ) > 0 ) {
 
@@ -11610,6 +11640,7 @@
   		Triangle.getNormal( _vA$1, _vB$1, _vC$1, face.normal );
 
   		intersection.face = face;
+  		intersection.barycoord = barycoord;
 
   	}
 
@@ -13253,40 +13284,71 @@
   	function updateBuffer( buffer, attribute, bufferType ) {
 
   		const array = attribute.array;
-  		const updateRange = attribute._updateRange; // @deprecated, r159
   		const updateRanges = attribute.updateRanges;
 
   		gl.bindBuffer( bufferType, buffer );
 
-  		if ( updateRange.count === - 1 && updateRanges.length === 0 ) {
+  		if ( updateRanges.length === 0 ) {
 
   			// Not using update ranges
   			gl.bufferSubData( bufferType, 0, array );
 
-  		}
+  		} else {
 
-  		if ( updateRanges.length !== 0 ) {
+  			// Before applying update ranges, we merge any adjacent / overlapping
+  			// ranges to reduce load on `gl.bufferSubData`. Empirically, this has led
+  			// to performance improvements for applications which make heavy use of
+  			// update ranges. Likely due to GPU command overhead.
+  			//
+  			// Note that to reduce garbage collection between frames, we merge the
+  			// update ranges in-place. This is safe because this method will clear the
+  			// update ranges once updated.
 
-  			for ( let i = 0, l = updateRanges.length; i < l; i ++ ) {
+  			updateRanges.sort( ( a, b ) => a.start - b.start );
+
+  			// To merge the update ranges in-place, we work from left to right in the
+  			// existing updateRanges array, merging ranges. This may result in a final
+  			// array which is smaller than the original. This index tracks the last
+  			// index representing a merged range, any data after this index can be
+  			// trimmed once the merge algorithm is completed.
+  			let mergeIndex = 0;
+
+  			for ( let i = 1; i < updateRanges.length; i ++ ) {
 
+  				const previousRange = updateRanges[ mergeIndex ];
   				const range = updateRanges[ i ];
 
-  				gl.bufferSubData( bufferType, range.start * array.BYTES_PER_ELEMENT,
-  					array, range.start, range.count );
+  				// We add one here to merge adjacent ranges. This is safe because ranges
+  				// operate over positive integers.
+  				if ( range.start <= previousRange.start + previousRange.count + 1 ) {
+
+  					previousRange.count = Math.max(
+  						previousRange.count,
+  						range.start + range.count - previousRange.start
+  					);
+
+  				} else {
+
+  					++ mergeIndex;
+  					updateRanges[ mergeIndex ] = range;
+
+  				}
 
   			}
 
-  			attribute.clearUpdateRanges();
+  			// Trim the array to only contain the merged ranges.
+  			updateRanges.length = mergeIndex + 1;
 
-  		}
+  			for ( let i = 0, l = updateRanges.length; i < l; i ++ ) {
 
-  		// @deprecated, r159
-  		if ( updateRange.count !== - 1 ) {
+  				const range = updateRanges[ i ];
 
-  			gl.bufferSubData( bufferType, updateRange.offset * array.BYTES_PER_ELEMENT,
-  				array, updateRange.offset, updateRange.count );
+  				gl.bufferSubData( bufferType, range.start * array.BYTES_PER_ELEMENT,
+  					array, range.start, range.count );
 
-  			updateRange.count = - 1; // reset range
+  			}
+
+  			attribute.clearUpdateRanges();
 
   		}
 
@@ -13747,7 +13809,7 @@
 
   const fragment$2 = "uniform vec3 color;\nuniform float opacity;\n#include <common>\n#include <packing>\n#include <fog_pars_fragment>\n#include <bsdfs>\n#include <lights_pars_begin>\n#include <logdepthbuf_pars_fragment>\n#include <shadowmap_pars_fragment>\n#include <shadowmask_pars_fragment>\nvoid main() {\n\t#include <logdepthbuf_fragment>\n\tgl_FragColor = vec4( color, opacity * ( 1.0 - getShadowMask() ) );\n\t#include <tonemapping_fragment>\n\t#include <colorspace_fragment>\n\t#include <fog_fragment>\n}";
 
-  const vertex$1 = "uniform float rotation;\nuniform vec2 center;\n#include <common>\n#include <uv_pars_vertex>\n#include <fog_pars_vertex>\n#include <logdepthbuf_pars_vertex>\n#include <clipping_planes_pars_vertex>\nvoid main() {\n\t#include <uv_vertex>\n\tvec4 mvPosition = modelViewMatrix * vec4( 0.0, 0.0, 0.0, 1.0 );\n\tvec2 scale;\n\tscale.x = length( vec3( modelMatrix[ 0 ].x, modelMatrix[ 0 ].y, modelMatrix[ 0 ].z ) );\n\tscale.y = length( vec3( modelMatrix[ 1 ].x, modelMatrix[ 1 ].y, modelMatrix[ 1 ].z ) );\n\t#ifndef USE_SIZEATTENUATION\n\t\tbool isPerspective = isPerspectiveMatrix( projectionMatrix );\n\t\tif ( isPerspective ) scale *= - mvPosition.z;\n\t#endif\n\tvec2 alignedPosition = ( position.xy - ( center - vec2( 0.5 ) ) ) * scale;\n\tvec2 rotatedPosition;\n\trotatedPosition.x = cos( rotation ) * alignedPosition.x - sin( rotation ) * alignedPosition.y;\n\trotatedPosition.y = sin( rotation ) * alignedPosition.x + cos( rotation ) * alignedPosition.y;\n\tmvPosition.xy += rotatedPosition;\n\tgl_Position = projectionMatrix * mvPosition;\n\t#include <logdepthbuf_vertex>\n\t#include <clipping_planes_vertex>\n\t#include <fog_vertex>\n}";
+  const vertex$1 = "uniform float rotation;\nuniform vec2 center;\n#include <common>\n#include <uv_pars_vertex>\n#include <fog_pars_vertex>\n#include <logdepthbuf_pars_vertex>\n#include <clipping_planes_pars_vertex>\nvoid main() {\n\t#include <uv_vertex>\n\tvec4 mvPosition = modelViewMatrix[ 3 ];\n\tvec2 scale = vec2( length( modelMatrix[ 0 ].xyz ), length( modelMatrix[ 1 ].xyz ) );\n\t#ifndef USE_SIZEATTENUATION\n\t\tbool isPerspective = isPerspectiveMatrix( projectionMatrix );\n\t\tif ( isPerspective ) scale *= - mvPosition.z;\n\t#endif\n\tvec2 alignedPosition = ( position.xy - ( center - vec2( 0.5 ) ) ) * scale;\n\tvec2 rotatedPosition;\n\trotatedPosition.x = cos( rotation ) * alignedPosition.x - sin( rotation ) * alignedPosition.y;\n\trotatedPosition.y = sin( rotation ) * alignedPosition.x + cos( rotation ) * alignedPosition.y;\n\tmvPosition.xy += rotatedPosition;\n\tgl_Position = projectionMatrix * mvPosition;\n\t#include <logdepthbuf_vertex>\n\t#include <clipping_planes_vertex>\n\t#include <fog_vertex>\n}";
 
   const fragment$1 = "uniform vec3 diffuse;\nuniform float opacity;\n#include <common>\n#include <uv_pars_fragment>\n#include <map_pars_fragment>\n#include <alphamap_pars_fragment>\n#include <alphatest_pars_fragment>\n#include <alphahash_pars_fragment>\n#include <fog_pars_fragment>\n#include <logdepthbuf_pars_fragment>\n#include <clipping_planes_pars_fragment>\nvoid main() {\n\tvec4 diffuseColor = vec4( diffuse, opacity );\n\t#include <clipping_planes_fragment>\n\tvec3 outgoingLight = vec3( 0.0 );\n\t#include <logdepthbuf_fragment>\n\t#include <map_fragment>\n\t#include <alphamap_fragment>\n\t#include <alphatest_fragment>\n\t#include <alphahash_fragment>\n\toutgoingLight = diffuseColor.rgb;\n\t#include <opaque_fragment>\n\t#include <tonemapping_fragment>\n\t#include <colorspace_fragment>\n\t#include <fog_fragment>\n}";
 
@@ -15513,6 +15575,14 @@
   	}
 
   	const logarithmicDepthBuffer = parameters.logarithmicDepthBuffer === true;
+  	const reverseDepthBuffer = parameters.reverseDepthBuffer === true && extensions.has( 'EXT_clip_control' );
+
+  	if ( reverseDepthBuffer === true ) {
+
+  		const ext = extensions.get( 'EXT_clip_control' );
+  		ext.clipControlEXT( ext.LOWER_LEFT_EXT, ext.ZERO_TO_ONE_EXT );
+
+  	}
 
   	const maxTextures = gl.getParameter( gl.MAX_TEXTURE_IMAGE_UNITS );
   	const maxVertexTextures = gl.getParameter( gl.MAX_VERTEX_TEXTURE_IMAGE_UNITS );
@@ -15540,6 +15610,7 @@
 
   		precision: precision,
   		logarithmicDepthBuffer: logarithmicDepthBuffer,
+  		reverseDepthBuffer: reverseDepthBuffer,
 
   		maxTextures: maxTextures,
   		maxVertexTextures: maxVertexTextures,
@@ -19557,6 +19628,7 @@
   			parameters.numLightProbes > 0 ? '#define USE_LIGHT_PROBES' : '',
 
   			parameters.logarithmicDepthBuffer ? '#define USE_LOGDEPTHBUF' : '',
+  			parameters.reverseDepthBuffer ? '#define USE_REVERSEDEPTHBUF' : '',
 
   			'uniform mat4 modelMatrix;',
   			'uniform mat4 modelViewMatrix;',
@@ -19722,6 +19794,7 @@
   			parameters.decodeVideoTexture ? '#define DECODE_VIDEO_TEXTURE' : '',
 
   			parameters.logarithmicDepthBuffer ? '#define USE_LOGDEPTHBUF' : '',
+  			parameters.reverseDepthBuffer ? '#define USE_REVERSEDEPTHBUF' : '',
 
   			'uniform mat4 viewMatrix;',
   			'uniform vec3 cameraPosition;',
@@ -20114,6 +20187,7 @@
   	const programs = [];
 
   	const logarithmicDepthBuffer = capabilities.logarithmicDepthBuffer;
+  	const reverseDepthBuffer = capabilities.reverseDepthBuffer;
   	const SUPPORTS_VERTEX_TEXTURES = capabilities.vertexTextures;
 
   	let precision = capabilities.precision;
@@ -20405,6 +20479,7 @@
 
   			sizeAttenuation: material.sizeAttenuation === true,
   			logarithmicDepthBuffer: logarithmicDepthBuffer,
+  			reverseDepthBuffer: reverseDepthBuffer,
 
   			skinning: object.isSkinnedMesh === true,
 
@@ -20624,38 +20699,40 @@
   			_programLayers.enable( 2 );
   		if ( parameters.logarithmicDepthBuffer )
   			_programLayers.enable( 3 );
-  		if ( parameters.skinning )
+  		if ( parameters.reverseDepthBuffer )
   			_programLayers.enable( 4 );
-  		if ( parameters.morphTargets )
+  		if ( parameters.skinning )
   			_programLayers.enable( 5 );
-  		if ( parameters.morphNormals )
+  		if ( parameters.morphTargets )
   			_programLayers.enable( 6 );
-  		if ( parameters.morphColors )
+  		if ( parameters.morphNormals )
   			_programLayers.enable( 7 );
-  		if ( parameters.premultipliedAlpha )
+  		if ( parameters.morphColors )
   			_programLayers.enable( 8 );
-  		if ( parameters.shadowMapEnabled )
+  		if ( parameters.premultipliedAlpha )
   			_programLayers.enable( 9 );
-  		if ( parameters.doubleSided )
+  		if ( parameters.shadowMapEnabled )
   			_programLayers.enable( 10 );
-  		if ( parameters.flipSided )
+  		if ( parameters.doubleSided )
   			_programLayers.enable( 11 );
-  		if ( parameters.useDepthPacking )
+  		if ( parameters.flipSided )
   			_programLayers.enable( 12 );
-  		if ( parameters.dithering )
+  		if ( parameters.useDepthPacking )
   			_programLayers.enable( 13 );
-  		if ( parameters.transmission )
+  		if ( parameters.dithering )
   			_programLayers.enable( 14 );
-  		if ( parameters.sheen )
+  		if ( parameters.transmission )
   			_programLayers.enable( 15 );
-  		if ( parameters.opaque )
+  		if ( parameters.sheen )
   			_programLayers.enable( 16 );
-  		if ( parameters.pointsUvs )
+  		if ( parameters.opaque )
   			_programLayers.enable( 17 );
-  		if ( parameters.decodeVideoTexture )
+  		if ( parameters.pointsUvs )
   			_programLayers.enable( 18 );
-  		if ( parameters.alphaToCoverage )
+  		if ( parameters.decodeVideoTexture )
   			_programLayers.enable( 19 );
+  		if ( parameters.alphaToCoverage )
+  			_programLayers.enable( 20 );
 
   		array.push( _programLayers.mask );
 
@@ -22213,6 +22290,18 @@
 
   }
 
+  const reversedFuncs = {
+  	[ NeverDepth ]: AlwaysDepth,
+  	[ LessDepth ]: GreaterDepth,
+  	[ EqualDepth ]: NotEqualDepth,
+  	[ LessEqualDepth ]: GreaterEqualDepth,
+
+  	[ AlwaysDepth ]: NeverDepth,
+  	[ GreaterDepth ]: LessDepth,
+  	[ NotEqualDepth ]: EqualDepth,
+  	[ GreaterEqualDepth ]: LessEqualDepth,
+  };
+
   function WebGLState( gl ) {
 
   	function ColorBuffer() {
@@ -22277,6 +22366,7 @@
   	function DepthBuffer() {
 
   		let locked = false;
+  		let reversed = false;
 
   		let currentDepthMask = null;
   		let currentDepthFunc = null;
@@ -22284,6 +22374,12 @@
 
   		return {
 
+  			setReversed: function ( value ) {
+
+  				reversed = value;
+
+  			},
+
   			setTest: function ( depthTest ) {
 
   				if ( depthTest ) {
@@ -22311,6 +22407,8 @@
 
   			setFunc: function ( depthFunc ) {
 
+  				if ( reversed ) depthFunc = reversedFuncs[ depthFunc ];
+
   				if ( currentDepthFunc !== depthFunc ) {
 
   					switch ( depthFunc ) {
@@ -23781,6 +23879,28 @@
 
   		}
 
+  		if ( glFormat === _gl.RGB_INTEGER ) {
+
+  			if ( glType === _gl.UNSIGNED_BYTE ) internalFormat = _gl.RGB8UI;
+  			if ( glType === _gl.UNSIGNED_SHORT ) internalFormat = _gl.RGB16UI;
+  			if ( glType === _gl.UNSIGNED_INT ) internalFormat = _gl.RGB32UI;
+  			if ( glType === _gl.BYTE ) internalFormat = _gl.RGB8I;
+  			if ( glType === _gl.SHORT ) internalFormat = _gl.RGB16I;
+  			if ( glType === _gl.INT ) internalFormat = _gl.RGB32I;
+
+  		}
+
+  		if ( glFormat === _gl.RGBA_INTEGER ) {
+
+  			if ( glType === _gl.UNSIGNED_BYTE ) internalFormat = _gl.RGBA8UI;
+  			if ( glType === _gl.UNSIGNED_SHORT ) internalFormat = _gl.RGBA16UI;
+  			if ( glType === _gl.UNSIGNED_INT ) internalFormat = _gl.RGBA32UI;
+  			if ( glType === _gl.BYTE ) internalFormat = _gl.RGBA8I;
+  			if ( glType === _gl.SHORT ) internalFormat = _gl.RGBA16I;
+  			if ( glType === _gl.INT ) internalFormat = _gl.RGBA32I;
+
+  		}
+
   		if ( glFormat === _gl.RGB ) {
 
   			if ( glType === _gl.UNSIGNED_INT_5_9_9_9_REV ) internalFormat = _gl.RGB9_E5;
@@ -28374,6 +28494,7 @@ void main() {
 
   		// camera matrices cache
 
+  		const _currentProjectionMatrix = new Matrix4();
   		const _projScreenMatrix = new Matrix4();
 
   		const _vector3 = new Vector3();
@@ -28469,6 +28590,8 @@ void main() {
 
   			state = new WebGLState( _gl );
 
+  			if ( capabilities.reverseDepthBuffer ) state.buffers.depth.setReversed( true );
+
   			info = new WebGLInfo( _gl );
   			properties = new WebGLProperties();
   			textures = new WebGLTextures( _gl, extensions, state, properties, capabilities, utils, info );
@@ -28768,7 +28891,13 @@ void main() {
 
   			}
 
-  			if ( depth ) bits |= _gl.DEPTH_BUFFER_BIT;
+  			if ( depth ) {
+
+  				bits |= _gl.DEPTH_BUFFER_BIT;
+  				_gl.clearDepth( this.capabilities.reverseDepthBuffer ? 0 : 1 );
+
+  			}
+
   			if ( stencil ) {
 
   				bits |= _gl.STENCIL_BUFFER_BIT;
@@ -29157,6 +29286,12 @@ void main() {
 
   			scene.traverse( function ( object ) {
 
+  				if ( ! ( object.isMesh || object.isPoints || object.isLine || object.isSprite ) ) {
+
+  					return;
+
+  				}
+
   				const material = object.material;
 
   				if ( material ) {
@@ -30143,7 +30278,21 @@ void main() {
 
   				// common camera uniforms
 
-  				p_uniforms.setValue( _gl, 'projectionMatrix', camera.projectionMatrix );
+  				if ( capabilities.reverseDepthBuffer ) {
+
+  					_currentProjectionMatrix.copy( camera.projectionMatrix );
+
+  					toNormalizedProjectionMatrix( _currentProjectionMatrix );
+  					toReversedProjectionMatrix( _currentProjectionMatrix );
+
+  					p_uniforms.setValue( _gl, 'projectionMatrix', _currentProjectionMatrix );
+
+  				} else {
+
+  					p_uniforms.setValue( _gl, 'projectionMatrix', camera.projectionMatrix );
+
+  				}
+
   				p_uniforms.setValue( _gl, 'viewMatrix', camera.matrixWorldInverse );
 
   				const uCamPos = p_uniforms.map.cameraPosition;
@@ -30624,61 +30773,55 @@ void main() {
 
   			if ( framebuffer ) {
 
-  				state.bindFramebuffer( _gl.FRAMEBUFFER, framebuffer );
-
-  				try {
-
-  					const texture = renderTarget.texture;
-  					const textureFormat = texture.format;
-  					const textureType = texture.type;
-
-  					if ( ! capabilities.textureFormatReadable( textureFormat ) ) {
-
-  						throw new Error( 'THREE.WebGLRenderer.readRenderTargetPixelsAsync: renderTarget is not in RGBA or implementation defined format.' );
+  				const texture = renderTarget.texture;
+  				const textureFormat = texture.format;
+  				const textureType = texture.type;
 
-  					}
+  				if ( ! capabilities.textureFormatReadable( textureFormat ) ) {
 
-  					if ( ! capabilities.textureTypeReadable( textureType ) ) {
+  					throw new Error( 'THREE.WebGLRenderer.readRenderTargetPixelsAsync: renderTarget is not in RGBA or implementation defined format.' );
 
-  						throw new Error( 'THREE.WebGLRenderer.readRenderTargetPixelsAsync: renderTarget is not in UnsignedByteType or implementation defined type.' );
+  				}
 
-  					}
+  				if ( ! capabilities.textureTypeReadable( textureType ) ) {
 
-  					// the following if statement ensures valid read requests (no out-of-bounds pixels, see #8604)
-  					if ( ( x >= 0 && x <= ( renderTarget.width - width ) ) && ( y >= 0 && y <= ( renderTarget.height - height ) ) ) {
+  					throw new Error( 'THREE.WebGLRenderer.readRenderTargetPixelsAsync: renderTarget is not in UnsignedByteType or implementation defined type.' );
 
-  						const glBuffer = _gl.createBuffer();
-  						_gl.bindBuffer( _gl.PIXEL_PACK_BUFFER, glBuffer );
-  						_gl.bufferData( _gl.PIXEL_PACK_BUFFER, buffer.byteLength, _gl.STREAM_READ );
-  						_gl.readPixels( x, y, width, height, utils.convert( textureFormat ), utils.convert( textureType ), 0 );
-  						_gl.flush();
+  				}
 
-  						// check if the commands have finished every 8 ms
-  						const sync = _gl.fenceSync( _gl.SYNC_GPU_COMMANDS_COMPLETE, 0 );
-  						await probeAsync( _gl, sync, 4 );
+  				// the following if statement ensures valid read requests (no out-of-bounds pixels, see #8604)
+  				if ( ( x >= 0 && x <= ( renderTarget.width - width ) ) && ( y >= 0 && y <= ( renderTarget.height - height ) ) ) {
 
-  						try {
+  					// set the active frame buffer to the one we want to read
+  					state.bindFramebuffer( _gl.FRAMEBUFFER, framebuffer );
 
-  							_gl.bindBuffer( _gl.PIXEL_PACK_BUFFER, glBuffer );
-  							_gl.getBufferSubData( _gl.PIXEL_PACK_BUFFER, 0, buffer );
+  					const glBuffer = _gl.createBuffer();
+  					_gl.bindBuffer( _gl.PIXEL_PACK_BUFFER, glBuffer );
+  					_gl.bufferData( _gl.PIXEL_PACK_BUFFER, buffer.byteLength, _gl.STREAM_READ );
+  					_gl.readPixels( x, y, width, height, utils.convert( textureFormat ), utils.convert( textureType ), 0 );
 
-  						} finally {
+  					// reset the frame buffer to the currently set buffer before waiting
+  					const currFramebuffer = _currentRenderTarget !== null ? properties.get( _currentRenderTarget ).__webglFramebuffer : null;
+  					state.bindFramebuffer( _gl.FRAMEBUFFER, currFramebuffer );
 
-  							_gl.deleteBuffer( glBuffer );
-  							_gl.deleteSync( sync );
+  					// check if the commands have finished every 8 ms
+  					const sync = _gl.fenceSync( _gl.SYNC_GPU_COMMANDS_COMPLETE, 0 );
 
-  						}
+  					_gl.flush();
 
-  						return buffer;
+  					await probeAsync( _gl, sync, 4 );
 
-  					}
+  					// read the data and delete the buffer
+  					_gl.bindBuffer( _gl.PIXEL_PACK_BUFFER, glBuffer );
+  					_gl.getBufferSubData( _gl.PIXEL_PACK_BUFFER, 0, buffer );
+  					_gl.deleteBuffer( glBuffer );
+  					_gl.deleteSync( sync );
 
-  				} finally {
+  					return buffer;
 
-  					// restore framebuffer of current render target if necessary
+  				} else {
 
-  					const framebuffer = ( _currentRenderTarget !== null ) ? properties.get( _currentRenderTarget ).__webglFramebuffer : null;
-  					state.bindFramebuffer( _gl.FRAMEBUFFER, framebuffer );
+  					throw new Error( 'THREE.WebGLRenderer.readRenderTargetPixelsAsync: requested read bounds are out of range.' );
 
   				}
 
@@ -31097,7 +31240,6 @@ void main() {
   		this.count = array !== undefined ? array.length / stride : 0;
 
   		this.usage = StaticDrawUsage;
-  		this._updateRange = { offset: 0, count: - 1 };
   		this.updateRanges = [];
 
   		this.version = 0;
@@ -31114,13 +31256,6 @@ void main() {
 
   	}
 
-  	get updateRange() {
-
-  		warnOnce( 'THREE.InterleavedBuffer: updateRange() is deprecated and will be removed in r169. Use addUpdateRange() instead.' ); // @deprecated, r159
-  		return this._updateRange;
-
-  	}
-
   	setUsage( value ) {
 
   		this.usage = value;
@@ -31677,7 +31812,7 @@ void main() {
   const _vEnd = /*@__PURE__*/ new Vector3();
 
   const _inverseMatrix$1 = /*@__PURE__*/ new Matrix4();
-  const _ray$1 = /*@__PURE__*/ new Ray();
+  const _ray$1$1 = /*@__PURE__*/ new Ray();
   const _sphere$1 = /*@__PURE__*/ new Sphere();
 
   const _intersectPointOnRay = /*@__PURE__*/ new Vector3();
@@ -31764,7 +31899,7 @@ void main() {
   		//
 
   		_inverseMatrix$1.copy( matrixWorld ).invert();
-  		_ray$1.copy( raycaster.ray ).applyMatrix4( _inverseMatrix$1 );
+  		_ray$1$1.copy( raycaster.ray ).applyMatrix4( _inverseMatrix$1 );
 
   		const localThreshold = threshold / ( ( this.scale.x + this.scale.y + this.scale.z ) / 3 );
   		const localThresholdSq = localThreshold * localThreshold;
@@ -31785,7 +31920,7 @@ void main() {
   				const a = index.getX( i );
   				const b = index.getX( i + 1 );
 
-  				const intersect = checkIntersection( this, raycaster, _ray$1, localThresholdSq, a, b );
+  				const intersect = checkIntersection( this, raycaster, _ray$1$1, localThresholdSq, a, b );
 
   				if ( intersect ) {
 
@@ -31800,7 +31935,7 @@ void main() {
   				const a = index.getX( end - 1 );
   				const b = index.getX( start );
 
-  				const intersect = checkIntersection( this, raycaster, _ray$1, localThresholdSq, a, b );
+  				const intersect = checkIntersection( this, raycaster, _ray$1$1, localThresholdSq, a, b );
 
   				if ( intersect ) {
 
@@ -31817,7 +31952,7 @@ void main() {
 
   			for ( let i = start, l = end - 1; i < l; i += step ) {
 
-  				const intersect = checkIntersection( this, raycaster, _ray$1, localThresholdSq, i, i + 1 );
+  				const intersect = checkIntersection( this, raycaster, _ray$1$1, localThresholdSq, i, i + 1 );
 
   				if ( intersect ) {
 
@@ -31829,7 +31964,7 @@ void main() {
 
   			if ( this.isLineLoop ) {
 
-  				const intersect = checkIntersection( this, raycaster, _ray$1, localThresholdSq, end - 1, start );
+  				const intersect = checkIntersection( this, raycaster, _ray$1$1, localThresholdSq, end - 1, start );
 
   				if ( intersect ) {
 
@@ -31902,6 +32037,7 @@ void main() {
   		index: a,
   		face: null,
   		faceIndex: null,
+  		barycoord: null,
   		object: object
 
   	};
@@ -34090,12 +34226,19 @@ void main() {
 
   					// faces
 
-  					indices.push( a, b, d );
-  					indices.push( b, c, d );
+  					if ( radiusTop > 0 ) {
 
-  					// update group counter
+  						indices.push( a, b, d );
+  						groupCount += 3;
 
-  					groupCount += 6;
+  					}
+
+  					if ( radiusBottom > 0 ) {
+
+  						indices.push( b, c, d );
+  						groupCount += 3;
+
+  					}
 
   				}
 
@@ -34346,14 +34489,14 @@ void main() {
 
   		const hasHoles = holeIndices && holeIndices.length;
   		const outerLen = hasHoles ? holeIndices[ 0 ] * dim : data.length;
-  		let outerNode = linkedList( data, 0, outerLen, dim, true );
+  		let outerNode = linkedList$1( data, 0, outerLen, dim, true );
   		const triangles = [];
 
   		if ( ! outerNode || outerNode.next === outerNode.prev ) return triangles;
 
   		let minX, minY, maxX, maxY, x, y, invSize;
 
-  		if ( hasHoles ) outerNode = eliminateHoles( data, holeIndices, outerNode, dim );
+  		if ( hasHoles ) outerNode = eliminateHoles$1( data, holeIndices, outerNode, dim );
 
   		// if the shape is not too simple, we'll use z-order curve hash later; calculate polygon bbox
   		if ( data.length > 80 * dim ) {
@@ -34378,7 +34521,7 @@ void main() {
 
   		}
 
-  		earcutLinked( outerNode, triangles, dim, minX, minY, invSize, 0 );
+  		earcutLinked$1( outerNode, triangles, dim, minX, minY, invSize, 0 );
 
   		return triangles;
 
@@ -34387,23 +34530,23 @@ void main() {
   };
 
   // create a circular doubly linked list from polygon points in the specified winding order
-  function linkedList( data, start, end, dim, clockwise ) {
+  function linkedList$1( data, start, end, dim, clockwise ) {
 
   	let i, last;
 
-  	if ( clockwise === ( signedArea( data, start, end, dim ) > 0 ) ) {
+  	if ( clockwise === ( signedArea$1( data, start, end, dim ) > 0 ) ) {
 
-  		for ( i = start; i < end; i += dim ) last = insertNode( i, data[ i ], data[ i + 1 ], last );
+  		for ( i = start; i < end; i += dim ) last = insertNode$1( i, data[ i ], data[ i + 1 ], last );
 
   	} else {
 
-  		for ( i = end - dim; i >= start; i -= dim ) last = insertNode( i, data[ i ], data[ i + 1 ], last );
+  		for ( i = end - dim; i >= start; i -= dim ) last = insertNode$1( i, data[ i ], data[ i + 1 ], last );
 
   	}
 
-  	if ( last && equals( last, last.next ) ) {
+  	if ( last && equals$1( last, last.next ) ) {
 
-  		removeNode( last );
+  		removeNode$1( last );
   		last = last.next;
 
   	}
@@ -34413,7 +34556,7 @@ void main() {
   }
 
   // eliminate colinear or duplicate points
-  function filterPoints( start, end ) {
+  function filterPoints$1( start, end ) {
 
   	if ( ! start ) return start;
   	if ( ! end ) end = start;
@@ -34424,9 +34567,9 @@ void main() {
 
   		again = false;
 
-  		if ( ! p.steiner && ( equals( p, p.next ) || area( p.prev, p, p.next ) === 0 ) ) {
+  		if ( ! p.steiner && ( equals$1( p, p.next ) || area$1( p.prev, p, p.next ) === 0 ) ) {
 
-  			removeNode( p );
+  			removeNode$1( p );
   			p = end = p.prev;
   			if ( p === p.next ) break;
   			again = true;
@@ -34444,12 +34587,12 @@ void main() {
   }
 
   // main ear slicing loop which triangulates a polygon (given as a linked list)
-  function earcutLinked( ear, triangles, dim, minX, minY, invSize, pass ) {
+  function earcutLinked$1( ear, triangles, dim, minX, minY, invSize, pass ) {
 
   	if ( ! ear ) return;
 
   	// interlink polygon nodes in z-order
-  	if ( ! pass && invSize ) indexCurve( ear, minX, minY, invSize );
+  	if ( ! pass && invSize ) indexCurve$1( ear, minX, minY, invSize );
 
   	let stop = ear,
   		prev, next;
@@ -34460,14 +34603,14 @@ void main() {
   		prev = ear.prev;
   		next = ear.next;
 
-  		if ( invSize ? isEarHashed( ear, minX, minY, invSize ) : isEar( ear ) ) {
+  		if ( invSize ? isEarHashed$1( ear, minX, minY, invSize ) : isEar$1( ear ) ) {
 
   			// cut off the triangle
   			triangles.push( prev.i / dim | 0 );
   			triangles.push( ear.i / dim | 0 );
   			triangles.push( next.i / dim | 0 );
 
-  			removeNode( ear );
+  			removeNode$1( ear );
 
   			// skipping the next vertex leads to less sliver triangles
   			ear = next.next;
@@ -34485,20 +34628,20 @@ void main() {
   			// try filtering points and slicing again
   			if ( ! pass ) {
 
-  				earcutLinked( filterPoints( ear ), triangles, dim, minX, minY, invSize, 1 );
+  				earcutLinked$1( filterPoints$1( ear ), triangles, dim, minX, minY, invSize, 1 );
 
   				// if this didn't work, try curing all small self-intersections locally
 
   			} else if ( pass === 1 ) {
 
-  				ear = cureLocalIntersections( filterPoints( ear ), triangles, dim );
-  				earcutLinked( ear, triangles, dim, minX, minY, invSize, 2 );
+  				ear = cureLocalIntersections$1( filterPoints$1( ear ), triangles, dim );
+  				earcutLinked$1( ear, triangles, dim, minX, minY, invSize, 2 );
 
   				// as a last resort, try splitting the remaining polygon into two
 
   			} else if ( pass === 2 ) {
 
-  				splitEarcut( ear, triangles, dim, minX, minY, invSize );
+  				splitEarcut$1( ear, triangles, dim, minX, minY, invSize );
 
   			}
 
@@ -34511,13 +34654,13 @@ void main() {
   }
 
   // check whether a polygon node forms a valid ear with adjacent nodes
-  function isEar( ear ) {
+  function isEar$1( ear ) {
 
   	const a = ear.prev,
   		b = ear,
   		c = ear.next;
 
-  	if ( area( a, b, c ) >= 0 ) return false; // reflex, can't be an ear
+  	if ( area$1( a, b, c ) >= 0 ) return false; // reflex, can't be an ear
 
   	// now make sure we don't have other points inside the potential ear
   	const ax = a.x, bx = b.x, cx = c.x, ay = a.y, by = b.y, cy = c.y;
@@ -34532,8 +34675,8 @@ void main() {
   	while ( p !== a ) {
 
   		if ( p.x >= x0 && p.x <= x1 && p.y >= y0 && p.y <= y1 &&
-  			pointInTriangle( ax, ay, bx, by, cx, cy, p.x, p.y ) &&
-  			area( p.prev, p, p.next ) >= 0 ) return false;
+  			pointInTriangle$1( ax, ay, bx, by, cx, cy, p.x, p.y ) &&
+  			area$1( p.prev, p, p.next ) >= 0 ) return false;
   		p = p.next;
 
   	}
@@ -34542,13 +34685,13 @@ void main() {
 
   }
 
-  function isEarHashed( ear, minX, minY, invSize ) {
+  function isEarHashed$1( ear, minX, minY, invSize ) {
 
   	const a = ear.prev,
   		b = ear,
   		c = ear.next;
 
-  	if ( area( a, b, c ) >= 0 ) return false; // reflex, can't be an ear
+  	if ( area$1( a, b, c ) >= 0 ) return false; // reflex, can't be an ear
 
   	const ax = a.x, bx = b.x, cx = c.x, ay = a.y, by = b.y, cy = c.y;
 
@@ -34559,8 +34702,8 @@ void main() {
   		y1 = ay > by ? ( ay > cy ? ay : cy ) : ( by > cy ? by : cy );
 
   	// z-order range for the current triangle bbox;
-  	const minZ = zOrder( x0, y0, minX, minY, invSize ),
-  		maxZ = zOrder( x1, y1, minX, minY, invSize );
+  	const minZ = zOrder$1( x0, y0, minX, minY, invSize ),
+  		maxZ = zOrder$1( x1, y1, minX, minY, invSize );
 
   	let p = ear.prevZ,
   		n = ear.nextZ;
@@ -34569,11 +34712,11 @@ void main() {
   	while ( p && p.z >= minZ && n && n.z <= maxZ ) {
 
   		if ( p.x >= x0 && p.x <= x1 && p.y >= y0 && p.y <= y1 && p !== a && p !== c &&
-  			pointInTriangle( ax, ay, bx, by, cx, cy, p.x, p.y ) && area( p.prev, p, p.next ) >= 0 ) return false;
+  			pointInTriangle$1( ax, ay, bx, by, cx, cy, p.x, p.y ) && area$1( p.prev, p, p.next ) >= 0 ) return false;
   		p = p.prevZ;
 
   		if ( n.x >= x0 && n.x <= x1 && n.y >= y0 && n.y <= y1 && n !== a && n !== c &&
-  			pointInTriangle( ax, ay, bx, by, cx, cy, n.x, n.y ) && area( n.prev, n, n.next ) >= 0 ) return false;
+  			pointInTriangle$1( ax, ay, bx, by, cx, cy, n.x, n.y ) && area$1( n.prev, n, n.next ) >= 0 ) return false;
   		n = n.nextZ;
 
   	}
@@ -34582,7 +34725,7 @@ void main() {
   	while ( p && p.z >= minZ ) {
 
   		if ( p.x >= x0 && p.x <= x1 && p.y >= y0 && p.y <= y1 && p !== a && p !== c &&
-  			pointInTriangle( ax, ay, bx, by, cx, cy, p.x, p.y ) && area( p.prev, p, p.next ) >= 0 ) return false;
+  			pointInTriangle$1( ax, ay, bx, by, cx, cy, p.x, p.y ) && area$1( p.prev, p, p.next ) >= 0 ) return false;
   		p = p.prevZ;
 
   	}
@@ -34591,7 +34734,7 @@ void main() {
   	while ( n && n.z <= maxZ ) {
 
   		if ( n.x >= x0 && n.x <= x1 && n.y >= y0 && n.y <= y1 && n !== a && n !== c &&
-  			pointInTriangle( ax, ay, bx, by, cx, cy, n.x, n.y ) && area( n.prev, n, n.next ) >= 0 ) return false;
+  			pointInTriangle$1( ax, ay, bx, by, cx, cy, n.x, n.y ) && area$1( n.prev, n, n.next ) >= 0 ) return false;
   		n = n.nextZ;
 
   	}
@@ -34601,7 +34744,7 @@ void main() {
   }
 
   // go through all polygon nodes and cure small local self-intersections
-  function cureLocalIntersections( start, triangles, dim ) {
+  function cureLocalIntersections$1( start, triangles, dim ) {
 
   	let p = start;
   	do {
@@ -34609,15 +34752,15 @@ void main() {
   		const a = p.prev,
   			b = p.next.next;
 
-  		if ( ! equals( a, b ) && intersects( a, p, p.next, b ) && locallyInside( a, b ) && locallyInside( b, a ) ) {
+  		if ( ! equals$1( a, b ) && intersects$1( a, p, p.next, b ) && locallyInside$1( a, b ) && locallyInside$1( b, a ) ) {
 
   			triangles.push( a.i / dim | 0 );
   			triangles.push( p.i / dim | 0 );
   			triangles.push( b.i / dim | 0 );
 
   			// remove two nodes involved
-  			removeNode( p );
-  			removeNode( p.next );
+  			removeNode$1( p );
+  			removeNode$1( p.next );
 
   			p = start = b;
 
@@ -34627,12 +34770,12 @@ void main() {
 
   	} while ( p !== start );
 
-  	return filterPoints( p );
+  	return filterPoints$1( p );
 
   }
 
   // try splitting polygon into two and triangulate them independently
-  function splitEarcut( start, triangles, dim, minX, minY, invSize ) {
+  function splitEarcut$1( start, triangles, dim, minX, minY, invSize ) {
 
   	// look for a valid diagonal that divides the polygon into two
   	let a = start;
@@ -34641,18 +34784,18 @@ void main() {
   		let b = a.next.next;
   		while ( b !== a.prev ) {
 
-  			if ( a.i !== b.i && isValidDiagonal( a, b ) ) {
+  			if ( a.i !== b.i && isValidDiagonal$1( a, b ) ) {
 
   				// split the polygon in two by the diagonal
-  				let c = splitPolygon( a, b );
+  				let c = splitPolygon$1( a, b );
 
   				// filter colinear points around the cuts
-  				a = filterPoints( a, a.next );
-  				c = filterPoints( c, c.next );
+  				a = filterPoints$1( a, a.next );
+  				c = filterPoints$1( c, c.next );
 
   				// run earcut on each half
-  				earcutLinked( a, triangles, dim, minX, minY, invSize, 0 );
-  				earcutLinked( c, triangles, dim, minX, minY, invSize, 0 );
+  				earcutLinked$1( a, triangles, dim, minX, minY, invSize, 0 );
+  				earcutLinked$1( c, triangles, dim, minX, minY, invSize, 0 );
   				return;
 
   			}
@@ -34668,7 +34811,7 @@ void main() {
   }
 
   // link every hole into the outer loop, producing a single-ring polygon without holes
-  function eliminateHoles( data, holeIndices, outerNode, dim ) {
+  function eliminateHoles$1( data, holeIndices, outerNode, dim ) {
 
   	const queue = [];
   	let i, len, start, end, list;
@@ -34677,18 +34820,18 @@ void main() {
 
   		start = holeIndices[ i ] * dim;
   		end = i < len - 1 ? holeIndices[ i + 1 ] * dim : data.length;
-  		list = linkedList( data, start, end, dim, false );
+  		list = linkedList$1( data, start, end, dim, false );
   		if ( list === list.next ) list.steiner = true;
-  		queue.push( getLeftmost( list ) );
+  		queue.push( getLeftmost$1( list ) );
 
   	}
 
-  	queue.sort( compareX );
+  	queue.sort( compareX$1 );
 
   	// process holes from left to right
   	for ( i = 0; i < queue.length; i ++ ) {
 
-  		outerNode = eliminateHole( queue[ i ], outerNode );
+  		outerNode = eliminateHole$1( queue[ i ], outerNode );
 
   	}
 
@@ -34696,32 +34839,32 @@ void main() {
 
   }
 
-  function compareX( a, b ) {
+  function compareX$1( a, b ) {
 
   	return a.x - b.x;
 
   }
 
   // find a bridge between vertices that connects hole with an outer ring and link it
-  function eliminateHole( hole, outerNode ) {
+  function eliminateHole$1( hole, outerNode ) {
 
-  	const bridge = findHoleBridge( hole, outerNode );
+  	const bridge = findHoleBridge$1( hole, outerNode );
   	if ( ! bridge ) {
 
   		return outerNode;
 
   	}
 
-  	const bridgeReverse = splitPolygon( bridge, hole );
+  	const bridgeReverse = splitPolygon$1( bridge, hole );
 
   	// filter collinear points around the cuts
-  	filterPoints( bridgeReverse, bridgeReverse.next );
-  	return filterPoints( bridge, bridge.next );
+  	filterPoints$1( bridgeReverse, bridgeReverse.next );
+  	return filterPoints$1( bridge, bridge.next );
 
   }
 
   // David Eberly's algorithm for finding a bridge between hole and outer polygon
-  function findHoleBridge( hole, outerNode ) {
+  function findHoleBridge$1( hole, outerNode ) {
 
   	let p = outerNode,
   		qx = - Infinity,
@@ -34766,11 +34909,11 @@ void main() {
   	do {
 
   		if ( hx >= p.x && p.x >= mx && hx !== p.x &&
-  				pointInTriangle( hy < my ? hx : qx, hy, mx, my, hy < my ? qx : hx, hy, p.x, p.y ) ) {
+  				pointInTriangle$1( hy < my ? hx : qx, hy, mx, my, hy < my ? qx : hx, hy, p.x, p.y ) ) {
 
   			tan = Math.abs( hy - p.y ) / ( hx - p.x ); // tangential
 
-  			if ( locallyInside( p, hole ) && ( tan < tanMin || ( tan === tanMin && ( p.x > m.x || ( p.x === m.x && sectorContainsSector( m, p ) ) ) ) ) ) {
+  			if ( locallyInside$1( p, hole ) && ( tan < tanMin || ( tan === tanMin && ( p.x > m.x || ( p.x === m.x && sectorContainsSector$1( m, p ) ) ) ) ) ) {
 
   				m = p;
   				tanMin = tan;
@@ -34788,19 +34931,19 @@ void main() {
   }
 
   // whether sector in vertex m contains sector in vertex p in the same coordinates
-  function sectorContainsSector( m, p ) {
+  function sectorContainsSector$1( m, p ) {
 
-  	return area( m.prev, m, p.prev ) < 0 && area( p.next, m, m.next ) < 0;
+  	return area$1( m.prev, m, p.prev ) < 0 && area$1( p.next, m, m.next ) < 0;
 
   }
 
   // interlink polygon nodes in z-order
-  function indexCurve( start, minX, minY, invSize ) {
+  function indexCurve$1( start, minX, minY, invSize ) {
 
   	let p = start;
   	do {
 
-  		if ( p.z === 0 ) p.z = zOrder( p.x, p.y, minX, minY, invSize );
+  		if ( p.z === 0 ) p.z = zOrder$1( p.x, p.y, minX, minY, invSize );
   		p.prevZ = p.prev;
   		p.nextZ = p.next;
   		p = p.next;
@@ -34810,13 +34953,13 @@ void main() {
   	p.prevZ.nextZ = null;
   	p.prevZ = null;
 
-  	sortLinked( p );
+  	sortLinked$1( p );
 
   }
 
   // Simon Tatham's linked list merge sort algorithm
   // http://www.chiark.greenend.org.uk/~sgtatham/algorithms/listsort.html
-  function sortLinked( list ) {
+  function sortLinked$1( list ) {
 
   	let i, p, q, e, tail, numMerges, pSize, qSize,
   		inSize = 1;
@@ -34881,7 +35024,7 @@ void main() {
   }
 
   // z-order of a point given coords and inverse of the longer side of data bbox
-  function zOrder( x, y, minX, minY, invSize ) {
+  function zOrder$1( x, y, minX, minY, invSize ) {
 
   	// coords are transformed into non-negative 15-bit integer range
   	x = ( x - minX ) * invSize | 0;
@@ -34902,7 +35045,7 @@ void main() {
   }
 
   // find the leftmost node of a polygon ring
-  function getLeftmost( start ) {
+  function getLeftmost$1( start ) {
 
   	let p = start,
   		leftmost = start;
@@ -34918,7 +35061,7 @@ void main() {
   }
 
   // check if a point lies within a convex triangle
-  function pointInTriangle( ax, ay, bx, by, cx, cy, px, py ) {
+  function pointInTriangle$1( ax, ay, bx, by, cx, cy, px, py ) {
 
   	return ( cx - px ) * ( ay - py ) >= ( ax - px ) * ( cy - py ) &&
              ( ax - px ) * ( by - py ) >= ( bx - px ) * ( ay - py ) &&
@@ -34927,69 +35070,69 @@ void main() {
   }
 
   // check if a diagonal between two polygon nodes is valid (lies in polygon interior)
-  function isValidDiagonal( a, b ) {
+  function isValidDiagonal$1( a, b ) {
 
-  	return a.next.i !== b.i && a.prev.i !== b.i && ! intersectsPolygon( a, b ) && // dones't intersect other edges
-             ( locallyInside( a, b ) && locallyInside( b, a ) && middleInside( a, b ) && // locally visible
-              ( area( a.prev, a, b.prev ) || area( a, b.prev, b ) ) || // does not create opposite-facing sectors
-              equals( a, b ) && area( a.prev, a, a.next ) > 0 && area( b.prev, b, b.next ) > 0 ); // special zero-length case
+  	return a.next.i !== b.i && a.prev.i !== b.i && ! intersectsPolygon$1( a, b ) && // dones't intersect other edges
+             ( locallyInside$1( a, b ) && locallyInside$1( b, a ) && middleInside$1( a, b ) && // locally visible
+              ( area$1( a.prev, a, b.prev ) || area$1( a, b.prev, b ) ) || // does not create opposite-facing sectors
+              equals$1( a, b ) && area$1( a.prev, a, a.next ) > 0 && area$1( b.prev, b, b.next ) > 0 ); // special zero-length case
 
   }
 
   // signed area of a triangle
-  function area( p, q, r ) {
+  function area$1( p, q, r ) {
 
   	return ( q.y - p.y ) * ( r.x - q.x ) - ( q.x - p.x ) * ( r.y - q.y );
 
   }
 
   // check if two points are equal
-  function equals( p1, p2 ) {
+  function equals$1( p1, p2 ) {
 
   	return p1.x === p2.x && p1.y === p2.y;
 
   }
 
   // check if two segments intersect
-  function intersects( p1, q1, p2, q2 ) {
+  function intersects$1( p1, q1, p2, q2 ) {
 
-  	const o1 = sign$2( area( p1, q1, p2 ) );
-  	const o2 = sign$2( area( p1, q1, q2 ) );
-  	const o3 = sign$2( area( p2, q2, p1 ) );
-  	const o4 = sign$2( area( p2, q2, q1 ) );
+  	const o1 = sign$3( area$1( p1, q1, p2 ) );
+  	const o2 = sign$3( area$1( p1, q1, q2 ) );
+  	const o3 = sign$3( area$1( p2, q2, p1 ) );
+  	const o4 = sign$3( area$1( p2, q2, q1 ) );
 
   	if ( o1 !== o2 && o3 !== o4 ) return true; // general case
 
-  	if ( o1 === 0 && onSegment( p1, p2, q1 ) ) return true; // p1, q1 and p2 are collinear and p2 lies on p1q1
-  	if ( o2 === 0 && onSegment( p1, q2, q1 ) ) return true; // p1, q1 and q2 are collinear and q2 lies on p1q1
-  	if ( o3 === 0 && onSegment( p2, p1, q2 ) ) return true; // p2, q2 and p1 are collinear and p1 lies on p2q2
-  	if ( o4 === 0 && onSegment( p2, q1, q2 ) ) return true; // p2, q2 and q1 are collinear and q1 lies on p2q2
+  	if ( o1 === 0 && onSegment$1( p1, p2, q1 ) ) return true; // p1, q1 and p2 are collinear and p2 lies on p1q1
+  	if ( o2 === 0 && onSegment$1( p1, q2, q1 ) ) return true; // p1, q1 and q2 are collinear and q2 lies on p1q1
+  	if ( o3 === 0 && onSegment$1( p2, p1, q2 ) ) return true; // p2, q2 and p1 are collinear and p1 lies on p2q2
+  	if ( o4 === 0 && onSegment$1( p2, q1, q2 ) ) return true; // p2, q2 and q1 are collinear and q1 lies on p2q2
 
   	return false;
 
   }
 
   // for collinear points p, q, r, check if point q lies on segment pr
-  function onSegment( p, q, r ) {
+  function onSegment$1( p, q, r ) {
 
   	return q.x <= Math.max( p.x, r.x ) && q.x >= Math.min( p.x, r.x ) && q.y <= Math.max( p.y, r.y ) && q.y >= Math.min( p.y, r.y );
 
   }
 
-  function sign$2( num ) {
+  function sign$3( num ) {
 
   	return num > 0 ? 1 : num < 0 ? - 1 : 0;
 
   }
 
   // check if a polygon diagonal intersects any polygon segments
-  function intersectsPolygon( a, b ) {
+  function intersectsPolygon$1( a, b ) {
 
   	let p = a;
   	do {
 
   		if ( p.i !== a.i && p.next.i !== a.i && p.i !== b.i && p.next.i !== b.i &&
-  			intersects( p, p.next, a, b ) ) return true;
+  			intersects$1( p, p.next, a, b ) ) return true;
   		p = p.next;
 
   	} while ( p !== a );
@@ -34999,16 +35142,16 @@ void main() {
   }
 
   // check if a polygon diagonal is locally inside the polygon
-  function locallyInside( a, b ) {
+  function locallyInside$1( a, b ) {
 
-  	return area( a.prev, a, a.next ) < 0 ?
-  		area( a, b, a.next ) >= 0 && area( a, a.prev, b ) >= 0 :
-  		area( a, b, a.prev ) < 0 || area( a, a.next, b ) < 0;
+  	return area$1( a.prev, a, a.next ) < 0 ?
+  		area$1( a, b, a.next ) >= 0 && area$1( a, a.prev, b ) >= 0 :
+  		area$1( a, b, a.prev ) < 0 || area$1( a, a.next, b ) < 0;
 
   }
 
   // check if the middle point of a polygon diagonal is inside the polygon
-  function middleInside( a, b ) {
+  function middleInside$1( a, b ) {
 
   	let p = a,
   		inside = false;
@@ -35029,7 +35172,7 @@ void main() {
 
   // link two polygon vertices with a bridge; if the vertices belong to the same ring, it splits polygon into two;
   // if one belongs to the outer ring and another to a hole, it merges it into a single ring
-  function splitPolygon( a, b ) {
+  function splitPolygon$1( a, b ) {
 
   	const a2 = new Node( a.i, a.x, a.y ),
   		b2 = new Node( b.i, b.x, b.y ),
@@ -35053,7 +35196,7 @@ void main() {
   }
 
   // create a node and optionally link it with previous one (in a circular doubly linked list)
-  function insertNode( i, x, y, last ) {
+  function insertNode$1( i, x, y, last ) {
 
   	const p = new Node( i, x, y );
 
@@ -35075,7 +35218,7 @@ void main() {
 
   }
 
-  function removeNode( p ) {
+  function removeNode$1( p ) {
 
   	p.next.prev = p.prev;
   	p.prev.next = p.next;
@@ -35110,7 +35253,7 @@ void main() {
 
   }
 
-  function signedArea( data, start, end, dim ) {
+  function signedArea$1( data, start, end, dim ) {
 
   	let sum = 0;
   	for ( let i = start, j = end - dim; i < end; i += dim ) {
@@ -37454,7 +37597,7 @@ void main() {
 
   function now$2() {
 
-  	return ( typeof performance === 'undefined' ? Date : performance ).now(); // see #10732
+  	return performance.now();
 
   }
 
@@ -38105,7 +38248,7 @@ void main() {
 
   class Controls extends EventDispatcher {
 
-  	constructor( object, domElement ) {
+  	constructor( object, domElement = null ) {
 
   		super();
 
@@ -40172,6 +40315,619 @@ void main() {
    */
   TWEEN.update.bind(TWEEN);
 
+  function earcut(data, holeIndices, dim = 2) {
+
+      const hasHoles = holeIndices && holeIndices.length;
+      const outerLen = hasHoles ? holeIndices[0] * dim : data.length;
+      let outerNode = linkedList(data, 0, outerLen, dim, true);
+      const triangles = [];
+
+      if (!outerNode || outerNode.next === outerNode.prev) return triangles;
+
+      let minX, minY, invSize;
+
+      if (hasHoles) outerNode = eliminateHoles(data, holeIndices, outerNode, dim);
+
+      // if the shape is not too simple, we'll use z-order curve hash later; calculate polygon bbox
+      if (data.length > 80 * dim) {
+          minX = Infinity;
+          minY = Infinity;
+          let maxX = -Infinity;
+          let maxY = -Infinity;
+
+          for (let i = dim; i < outerLen; i += dim) {
+              const x = data[i];
+              const y = data[i + 1];
+              if (x < minX) minX = x;
+              if (y < minY) minY = y;
+              if (x > maxX) maxX = x;
+              if (y > maxY) maxY = y;
+          }
+
+          // minX, minY and invSize are later used to transform coords into integers for z-order calculation
+          invSize = Math.max(maxX - minX, maxY - minY);
+          invSize = invSize !== 0 ? 32767 / invSize : 0;
+      }
+
+      earcutLinked(outerNode, triangles, dim, minX, minY, invSize, 0);
+
+      return triangles;
+  }
+
+  // create a circular doubly linked list from polygon points in the specified winding order
+  function linkedList(data, start, end, dim, clockwise) {
+      let last;
+
+      if (clockwise === (signedArea(data, start, end, dim) > 0)) {
+          for (let i = start; i < end; i += dim) last = insertNode(i / dim | 0, data[i], data[i + 1], last);
+      } else {
+          for (let i = end - dim; i >= start; i -= dim) last = insertNode(i / dim | 0, data[i], data[i + 1], last);
+      }
+
+      if (last && equals(last, last.next)) {
+          removeNode(last);
+          last = last.next;
+      }
+
+      return last;
+  }
+
+  // eliminate colinear or duplicate points
+  function filterPoints(start, end) {
+      if (!start) return start;
+      if (!end) end = start;
+
+      let p = start,
+          again;
+      do {
+          again = false;
+
+          if (!p.steiner && (equals(p, p.next) || area(p.prev, p, p.next) === 0)) {
+              removeNode(p);
+              p = end = p.prev;
+              if (p === p.next) break;
+              again = true;
+
+          } else {
+              p = p.next;
+          }
+      } while (again || p !== end);
+
+      return end;
+  }
+
+  // main ear slicing loop which triangulates a polygon (given as a linked list)
+  function earcutLinked(ear, triangles, dim, minX, minY, invSize, pass) {
+      if (!ear) return;
+
+      // interlink polygon nodes in z-order
+      if (!pass && invSize) indexCurve(ear, minX, minY, invSize);
+
+      let stop = ear;
+
+      // iterate through ears, slicing them one by one
+      while (ear.prev !== ear.next) {
+          const prev = ear.prev;
+          const next = ear.next;
+
+          if (invSize ? isEarHashed(ear, minX, minY, invSize) : isEar(ear)) {
+              triangles.push(prev.i, ear.i, next.i); // cut off the triangle
+
+              removeNode(ear);
+
+              // skipping the next vertex leads to less sliver triangles
+              ear = next.next;
+              stop = next.next;
+
+              continue;
+          }
+
+          ear = next;
+
+          // if we looped through the whole remaining polygon and can't find any more ears
+          if (ear === stop) {
+              // try filtering points and slicing again
+              if (!pass) {
+                  earcutLinked(filterPoints(ear), triangles, dim, minX, minY, invSize, 1);
+
+              // if this didn't work, try curing all small self-intersections locally
+              } else if (pass === 1) {
+                  ear = cureLocalIntersections(filterPoints(ear), triangles);
+                  earcutLinked(ear, triangles, dim, minX, minY, invSize, 2);
+
+              // as a last resort, try splitting the remaining polygon into two
+              } else if (pass === 2) {
+                  splitEarcut(ear, triangles, dim, minX, minY, invSize);
+              }
+
+              break;
+          }
+      }
+  }
+
+  // check whether a polygon node forms a valid ear with adjacent nodes
+  function isEar(ear) {
+      const a = ear.prev,
+          b = ear,
+          c = ear.next;
+
+      if (area(a, b, c) >= 0) return false; // reflex, can't be an ear
+
+      // now make sure we don't have other points inside the potential ear
+      const ax = a.x, bx = b.x, cx = c.x, ay = a.y, by = b.y, cy = c.y;
+
+      // triangle bbox; min & max are calculated like this for speed
+      const x0 = ax < bx ? (ax < cx ? ax : cx) : (bx < cx ? bx : cx),
+          y0 = ay < by ? (ay < cy ? ay : cy) : (by < cy ? by : cy),
+          x1 = ax > bx ? (ax > cx ? ax : cx) : (bx > cx ? bx : cx),
+          y1 = ay > by ? (ay > cy ? ay : cy) : (by > cy ? by : cy);
+
+      let p = c.next;
+      while (p !== a) {
+          if (p.x >= x0 && p.x <= x1 && p.y >= y0 && p.y <= y1 &&
+              pointInTriangle(ax, ay, bx, by, cx, cy, p.x, p.y) &&
+              area(p.prev, p, p.next) >= 0) return false;
+          p = p.next;
+      }
+
+      return true;
+  }
+
+  function isEarHashed(ear, minX, minY, invSize) {
+      const a = ear.prev,
+          b = ear,
+          c = ear.next;
+
+      if (area(a, b, c) >= 0) return false; // reflex, can't be an ear
+
+      const ax = a.x, bx = b.x, cx = c.x, ay = a.y, by = b.y, cy = c.y;
+
+      // triangle bbox; min & max are calculated like this for speed
+      const x0 = ax < bx ? (ax < cx ? ax : cx) : (bx < cx ? bx : cx),
+          y0 = ay < by ? (ay < cy ? ay : cy) : (by < cy ? by : cy),
+          x1 = ax > bx ? (ax > cx ? ax : cx) : (bx > cx ? bx : cx),
+          y1 = ay > by ? (ay > cy ? ay : cy) : (by > cy ? by : cy);
+
+      // z-order range for the current triangle bbox;
+      const minZ = zOrder(x0, y0, minX, minY, invSize),
+          maxZ = zOrder(x1, y1, minX, minY, invSize);
+
+      let p = ear.prevZ,
+          n = ear.nextZ;
+
+      // look for points inside the triangle in both directions
+      while (p && p.z >= minZ && n && n.z <= maxZ) {
+          if (p.x >= x0 && p.x <= x1 && p.y >= y0 && p.y <= y1 && p !== a && p !== c &&
+              pointInTriangle(ax, ay, bx, by, cx, cy, p.x, p.y) && area(p.prev, p, p.next) >= 0) return false;
+          p = p.prevZ;
+
+          if (n.x >= x0 && n.x <= x1 && n.y >= y0 && n.y <= y1 && n !== a && n !== c &&
+              pointInTriangle(ax, ay, bx, by, cx, cy, n.x, n.y) && area(n.prev, n, n.next) >= 0) return false;
+          n = n.nextZ;
+      }
+
+      // look for remaining points in decreasing z-order
+      while (p && p.z >= minZ) {
+          if (p.x >= x0 && p.x <= x1 && p.y >= y0 && p.y <= y1 && p !== a && p !== c &&
+              pointInTriangle(ax, ay, bx, by, cx, cy, p.x, p.y) && area(p.prev, p, p.next) >= 0) return false;
+          p = p.prevZ;
+      }
+
+      // look for remaining points in increasing z-order
+      while (n && n.z <= maxZ) {
+          if (n.x >= x0 && n.x <= x1 && n.y >= y0 && n.y <= y1 && n !== a && n !== c &&
+              pointInTriangle(ax, ay, bx, by, cx, cy, n.x, n.y) && area(n.prev, n, n.next) >= 0) return false;
+          n = n.nextZ;
+      }
+
+      return true;
+  }
+
+  // go through all polygon nodes and cure small local self-intersections
+  function cureLocalIntersections(start, triangles) {
+      let p = start;
+      do {
+          const a = p.prev,
+              b = p.next.next;
+
+          if (!equals(a, b) && intersects(a, p, p.next, b) && locallyInside(a, b) && locallyInside(b, a)) {
+
+              triangles.push(a.i, p.i, b.i);
+
+              // remove two nodes involved
+              removeNode(p);
+              removeNode(p.next);
+
+              p = start = b;
+          }
+          p = p.next;
+      } while (p !== start);
+
+      return filterPoints(p);
+  }
+
+  // try splitting polygon into two and triangulate them independently
+  function splitEarcut(start, triangles, dim, minX, minY, invSize) {
+      // look for a valid diagonal that divides the polygon into two
+      let a = start;
+      do {
+          let b = a.next.next;
+          while (b !== a.prev) {
+              if (a.i !== b.i && isValidDiagonal(a, b)) {
+                  // split the polygon in two by the diagonal
+                  let c = splitPolygon(a, b);
+
+                  // filter colinear points around the cuts
+                  a = filterPoints(a, a.next);
+                  c = filterPoints(c, c.next);
+
+                  // run earcut on each half
+                  earcutLinked(a, triangles, dim, minX, minY, invSize, 0);
+                  earcutLinked(c, triangles, dim, minX, minY, invSize, 0);
+                  return;
+              }
+              b = b.next;
+          }
+          a = a.next;
+      } while (a !== start);
+  }
+
+  // link every hole into the outer loop, producing a single-ring polygon without holes
+  function eliminateHoles(data, holeIndices, outerNode, dim) {
+      const queue = [];
+
+      for (let i = 0, len = holeIndices.length; i < len; i++) {
+          const start = holeIndices[i] * dim;
+          const end = i < len - 1 ? holeIndices[i + 1] * dim : data.length;
+          const list = linkedList(data, start, end, dim, false);
+          if (list === list.next) list.steiner = true;
+          queue.push(getLeftmost(list));
+      }
+
+      queue.sort(compareX);
+
+      // process holes from left to right
+      for (let i = 0; i < queue.length; i++) {
+          outerNode = eliminateHole(queue[i], outerNode);
+      }
+
+      return outerNode;
+  }
+
+  function compareX(a, b) {
+      return a.x - b.x;
+  }
+
+  // find a bridge between vertices that connects hole with an outer ring and and link it
+  function eliminateHole(hole, outerNode) {
+      const bridge = findHoleBridge(hole, outerNode);
+      if (!bridge) {
+          return outerNode;
+      }
+
+      const bridgeReverse = splitPolygon(bridge, hole);
+
+      // filter collinear points around the cuts
+      filterPoints(bridgeReverse, bridgeReverse.next);
+      return filterPoints(bridge, bridge.next);
+  }
+
+  // David Eberly's algorithm for finding a bridge between hole and outer polygon
+  function findHoleBridge(hole, outerNode) {
+      let p = outerNode;
+      const hx = hole.x;
+      const hy = hole.y;
+      let qx = -Infinity;
+      let m;
+
+      // find a segment intersected by a ray from the hole's leftmost point to the left;
+      // segment's endpoint with lesser x will be potential connection point
+      do {
+          if (hy <= p.y && hy >= p.next.y && p.next.y !== p.y) {
+              const x = p.x + (hy - p.y) * (p.next.x - p.x) / (p.next.y - p.y);
+              if (x <= hx && x > qx) {
+                  qx = x;
+                  m = p.x < p.next.x ? p : p.next;
+                  if (x === hx) return m; // hole touches outer segment; pick leftmost endpoint
+              }
+          }
+          p = p.next;
+      } while (p !== outerNode);
+
+      if (!m) return null;
+
+      // look for points inside the triangle of hole point, segment intersection and endpoint;
+      // if there are no points found, we have a valid connection;
+      // otherwise choose the point of the minimum angle with the ray as connection point
+
+      const stop = m;
+      const mx = m.x;
+      const my = m.y;
+      let tanMin = Infinity;
+
+      p = m;
+
+      do {
+          if (hx >= p.x && p.x >= mx && hx !== p.x &&
+                  pointInTriangle(hy < my ? hx : qx, hy, mx, my, hy < my ? qx : hx, hy, p.x, p.y)) {
+
+              const tan = Math.abs(hy - p.y) / (hx - p.x); // tangential
+
+              if (locallyInside(p, hole) &&
+                  (tan < tanMin || (tan === tanMin && (p.x > m.x || (p.x === m.x && sectorContainsSector(m, p)))))) {
+                  m = p;
+                  tanMin = tan;
+              }
+          }
+
+          p = p.next;
+      } while (p !== stop);
+
+      return m;
+  }
+
+  // whether sector in vertex m contains sector in vertex p in the same coordinates
+  function sectorContainsSector(m, p) {
+      return area(m.prev, m, p.prev) < 0 && area(p.next, m, m.next) < 0;
+  }
+
+  // interlink polygon nodes in z-order
+  function indexCurve(start, minX, minY, invSize) {
+      let p = start;
+      do {
+          if (p.z === 0) p.z = zOrder(p.x, p.y, minX, minY, invSize);
+          p.prevZ = p.prev;
+          p.nextZ = p.next;
+          p = p.next;
+      } while (p !== start);
+
+      p.prevZ.nextZ = null;
+      p.prevZ = null;
+
+      sortLinked(p);
+  }
+
+  // Simon Tatham's linked list merge sort algorithm
+  // http://www.chiark.greenend.org.uk/~sgtatham/algorithms/listsort.html
+  function sortLinked(list) {
+      let numMerges;
+      let inSize = 1;
+
+      do {
+          let p = list;
+          let e;
+          list = null;
+          let tail = null;
+          numMerges = 0;
+
+          while (p) {
+              numMerges++;
+              let q = p;
+              let pSize = 0;
+              for (let i = 0; i < inSize; i++) {
+                  pSize++;
+                  q = q.nextZ;
+                  if (!q) break;
+              }
+              let qSize = inSize;
+
+              while (pSize > 0 || (qSize > 0 && q)) {
+
+                  if (pSize !== 0 && (qSize === 0 || !q || p.z <= q.z)) {
+                      e = p;
+                      p = p.nextZ;
+                      pSize--;
+                  } else {
+                      e = q;
+                      q = q.nextZ;
+                      qSize--;
+                  }
+
+                  if (tail) tail.nextZ = e;
+                  else list = e;
+
+                  e.prevZ = tail;
+                  tail = e;
+              }
+
+              p = q;
+          }
+
+          tail.nextZ = null;
+          inSize *= 2;
+
+      } while (numMerges > 1);
+
+      return list;
+  }
+
+  // z-order of a point given coords and inverse of the longer side of data bbox
+  function zOrder(x, y, minX, minY, invSize) {
+      // coords are transformed into non-negative 15-bit integer range
+      x = (x - minX) * invSize | 0;
+      y = (y - minY) * invSize | 0;
+
+      x = (x | (x << 8)) & 0x00FF00FF;
+      x = (x | (x << 4)) & 0x0F0F0F0F;
+      x = (x | (x << 2)) & 0x33333333;
+      x = (x | (x << 1)) & 0x55555555;
+
+      y = (y | (y << 8)) & 0x00FF00FF;
+      y = (y | (y << 4)) & 0x0F0F0F0F;
+      y = (y | (y << 2)) & 0x33333333;
+      y = (y | (y << 1)) & 0x55555555;
+
+      return x | (y << 1);
+  }
+
+  // find the leftmost node of a polygon ring
+  function getLeftmost(start) {
+      let p = start,
+          leftmost = start;
+      do {
+          if (p.x < leftmost.x || (p.x === leftmost.x && p.y < leftmost.y)) leftmost = p;
+          p = p.next;
+      } while (p !== start);
+
+      return leftmost;
+  }
+
+  // check if a point lies within a convex triangle
+  function pointInTriangle(ax, ay, bx, by, cx, cy, px, py) {
+      return (cx - px) * (ay - py) >= (ax - px) * (cy - py) &&
+             (ax - px) * (by - py) >= (bx - px) * (ay - py) &&
+             (bx - px) * (cy - py) >= (cx - px) * (by - py);
+  }
+
+  // check if a diagonal between two polygon nodes is valid (lies in polygon interior)
+  function isValidDiagonal(a, b) {
+      return a.next.i !== b.i && a.prev.i !== b.i && !intersectsPolygon(a, b) && // dones't intersect other edges
+             (locallyInside(a, b) && locallyInside(b, a) && middleInside(a, b) && // locally visible
+              (area(a.prev, a, b.prev) || area(a, b.prev, b)) || // does not create opposite-facing sectors
+              equals(a, b) && area(a.prev, a, a.next) > 0 && area(b.prev, b, b.next) > 0); // special zero-length case
+  }
+
+  // signed area of a triangle
+  function area(p, q, r) {
+      return (q.y - p.y) * (r.x - q.x) - (q.x - p.x) * (r.y - q.y);
+  }
+
+  // check if two points are equal
+  function equals(p1, p2) {
+      return p1.x === p2.x && p1.y === p2.y;
+  }
+
+  // check if two segments intersect
+  function intersects(p1, q1, p2, q2) {
+      const o1 = sign$2(area(p1, q1, p2));
+      const o2 = sign$2(area(p1, q1, q2));
+      const o3 = sign$2(area(p2, q2, p1));
+      const o4 = sign$2(area(p2, q2, q1));
+
+      if (o1 !== o2 && o3 !== o4) return true; // general case
+
+      if (o1 === 0 && onSegment(p1, p2, q1)) return true; // p1, q1 and p2 are collinear and p2 lies on p1q1
+      if (o2 === 0 && onSegment(p1, q2, q1)) return true; // p1, q1 and q2 are collinear and q2 lies on p1q1
+      if (o3 === 0 && onSegment(p2, p1, q2)) return true; // p2, q2 and p1 are collinear and p1 lies on p2q2
+      if (o4 === 0 && onSegment(p2, q1, q2)) return true; // p2, q2 and q1 are collinear and q1 lies on p2q2
+
+      return false;
+  }
+
+  // for collinear points p, q, r, check if point q lies on segment pr
+  function onSegment(p, q, r) {
+      return q.x <= Math.max(p.x, r.x) && q.x >= Math.min(p.x, r.x) && q.y <= Math.max(p.y, r.y) && q.y >= Math.min(p.y, r.y);
+  }
+
+  function sign$2(num) {
+      return num > 0 ? 1 : num < 0 ? -1 : 0;
+  }
+
+  // check if a polygon diagonal intersects any polygon segments
+  function intersectsPolygon(a, b) {
+      let p = a;
+      do {
+          if (p.i !== a.i && p.next.i !== a.i && p.i !== b.i && p.next.i !== b.i &&
+                  intersects(p, p.next, a, b)) return true;
+          p = p.next;
+      } while (p !== a);
+
+      return false;
+  }
+
+  // check if a polygon diagonal is locally inside the polygon
+  function locallyInside(a, b) {
+      return area(a.prev, a, a.next) < 0 ?
+          area(a, b, a.next) >= 0 && area(a, a.prev, b) >= 0 :
+          area(a, b, a.prev) < 0 || area(a, a.next, b) < 0;
+  }
+
+  // check if the middle point of a polygon diagonal is inside the polygon
+  function middleInside(a, b) {
+      let p = a;
+      let inside = false;
+      const px = (a.x + b.x) / 2;
+      const py = (a.y + b.y) / 2;
+      do {
+          if (((p.y > py) !== (p.next.y > py)) && p.next.y !== p.y &&
+                  (px < (p.next.x - p.x) * (py - p.y) / (p.next.y - p.y) + p.x))
+              inside = !inside;
+          p = p.next;
+      } while (p !== a);
+
+      return inside;
+  }
+
+  // link two polygon vertices with a bridge; if the vertices belong to the same ring, it splits polygon into two;
+  // if one belongs to the outer ring and another to a hole, it merges it into a single ring
+  function splitPolygon(a, b) {
+      const a2 = createNode(a.i, a.x, a.y),
+          b2 = createNode(b.i, b.x, b.y),
+          an = a.next,
+          bp = b.prev;
+
+      a.next = b;
+      b.prev = a;
+
+      a2.next = an;
+      an.prev = a2;
+
+      b2.next = a2;
+      a2.prev = b2;
+
+      bp.next = b2;
+      b2.prev = bp;
+
+      return b2;
+  }
+
+  // create a node and optionally link it with previous one (in a circular doubly linked list)
+  function insertNode(i, x, y, last) {
+      const p = createNode(i, x, y);
+
+      if (!last) {
+          p.prev = p;
+          p.next = p;
+
+      } else {
+          p.next = last.next;
+          p.prev = last;
+          last.next.prev = p;
+          last.next = p;
+      }
+      return p;
+  }
+
+  function removeNode(p) {
+      p.next.prev = p.prev;
+      p.prev.next = p.next;
+
+      if (p.prevZ) p.prevZ.nextZ = p.nextZ;
+      if (p.nextZ) p.nextZ.prevZ = p.prevZ;
+  }
+
+  function createNode(i, x, y) {
+      return {
+          i, // vertex index in coordinates array
+          x, y, // vertex coordinates
+          prev: null, // previous and next vertex nodes in a polygon ring
+          next: null,
+          z: 0, // z-order curve value
+          prevZ: null, // previous and next nodes in z-order
+          nextZ: null,
+          steiner: false // indicates whether this is a steiner point
+      };
+  }
+
+  function signedArea(data, start, end, dim) {
+      let sum = 0;
+      for (let i = start, j = end - dim; i < end; i += dim) {
+          sum += (data[j] - data[i]) * (data[i + 1] + data[j + 1]);
+          j = i;
+      }
+      return sum;
+  }
+
   // turn a polygon in a multi-dimensional array form (e.g. as in GeoJSON) into a form Earcut accepts
   function flatten$1(data) {
       const vertices = [];
@@ -42754,14 +43510,14 @@ void main() {
     return result;
   };
 
-  var THREE$l = typeof window !== 'undefined' && window.THREE ? window.THREE // Prefer consumption from global THREE, if exists
+  var THREE$k = typeof window !== 'undefined' && window.THREE ? window.THREE // Prefer consumption from global THREE, if exists
   : {
     BufferGeometry: BufferGeometry,
     Float32BufferAttribute: Float32BufferAttribute
   };
 
   // support both modes for backwards threejs compatibility
-  var setAttributeFn$3 = new THREE$l.BufferGeometry().setAttribute ? 'setAttribute' : 'addAttribute';
+  var setAttributeFn$1 = new THREE$k.BufferGeometry().setAttribute ? 'setAttribute' : 'addAttribute';
   var GeoJsonGeometry = /*#__PURE__*/function (_THREE$BufferGeometry) {
     function GeoJsonGeometry(geoJson) {
       var _this;
@@ -42803,7 +43559,7 @@ void main() {
 
       // build geometry
       indices.length && _this.setIndex(indices);
-      vertices.length && _this[setAttributeFn$3]('position', new THREE$l.Float32BufferAttribute(vertices, 3));
+      vertices.length && _this[setAttributeFn$1]('position', new THREE$k.Float32BufferAttribute(vertices, 3));
 
       //
 
@@ -42930,7 +43686,7 @@ void main() {
     }
     _inherits$2(GeoJsonGeometry, _THREE$BufferGeometry);
     return _createClass$2(GeoJsonGeometry);
-  }(THREE$l.BufferGeometry); //
+  }(THREE$k.BufferGeometry); //
   function concatGroup(main, extra) {
     var prevVertCnt = Math.round(main.vertices.length / 3);
     concatArr(main.vertices, extra.vertices);
@@ -47159,699 +47915,6 @@ void main() {
     return linearish(scale);
   }
 
-  var earcut$1 = {exports: {}};
-
-  var hasRequiredEarcut;
-
-  function requireEarcut () {
-  	if (hasRequiredEarcut) return earcut$1.exports;
-  	hasRequiredEarcut = 1;
-
-  	earcut$1.exports = earcut;
-  	earcut$1.exports.default = earcut;
-
-  	function earcut(data, holeIndices, dim) {
-
-  	    dim = dim || 2;
-
-  	    var hasHoles = holeIndices && holeIndices.length,
-  	        outerLen = hasHoles ? holeIndices[0] * dim : data.length,
-  	        outerNode = linkedList(data, 0, outerLen, dim, true),
-  	        triangles = [];
-
-  	    if (!outerNode || outerNode.next === outerNode.prev) return triangles;
-
-  	    var minX, minY, maxX, maxY, x, y, invSize;
-
-  	    if (hasHoles) outerNode = eliminateHoles(data, holeIndices, outerNode, dim);
-
-  	    // if the shape is not too simple, we'll use z-order curve hash later; calculate polygon bbox
-  	    if (data.length > 80 * dim) {
-  	        minX = maxX = data[0];
-  	        minY = maxY = data[1];
-
-  	        for (var i = dim; i < outerLen; i += dim) {
-  	            x = data[i];
-  	            y = data[i + 1];
-  	            if (x < minX) minX = x;
-  	            if (y < minY) minY = y;
-  	            if (x > maxX) maxX = x;
-  	            if (y > maxY) maxY = y;
-  	        }
-
-  	        // minX, minY and invSize are later used to transform coords into integers for z-order calculation
-  	        invSize = Math.max(maxX - minX, maxY - minY);
-  	        invSize = invSize !== 0 ? 32767 / invSize : 0;
-  	    }
-
-  	    earcutLinked(outerNode, triangles, dim, minX, minY, invSize, 0);
-
-  	    return triangles;
-  	}
-
-  	// create a circular doubly linked list from polygon points in the specified winding order
-  	function linkedList(data, start, end, dim, clockwise) {
-  	    var i, last;
-
-  	    if (clockwise === (signedArea(data, start, end, dim) > 0)) {
-  	        for (i = start; i < end; i += dim) last = insertNode(i, data[i], data[i + 1], last);
-  	    } else {
-  	        for (i = end - dim; i >= start; i -= dim) last = insertNode(i, data[i], data[i + 1], last);
-  	    }
-
-  	    if (last && equals(last, last.next)) {
-  	        removeNode(last);
-  	        last = last.next;
-  	    }
-
-  	    return last;
-  	}
-
-  	// eliminate colinear or duplicate points
-  	function filterPoints(start, end) {
-  	    if (!start) return start;
-  	    if (!end) end = start;
-
-  	    var p = start,
-  	        again;
-  	    do {
-  	        again = false;
-
-  	        if (!p.steiner && (equals(p, p.next) || area(p.prev, p, p.next) === 0)) {
-  	            removeNode(p);
-  	            p = end = p.prev;
-  	            if (p === p.next) break;
-  	            again = true;
-
-  	        } else {
-  	            p = p.next;
-  	        }
-  	    } while (again || p !== end);
-
-  	    return end;
-  	}
-
-  	// main ear slicing loop which triangulates a polygon (given as a linked list)
-  	function earcutLinked(ear, triangles, dim, minX, minY, invSize, pass) {
-  	    if (!ear) return;
-
-  	    // interlink polygon nodes in z-order
-  	    if (!pass && invSize) indexCurve(ear, minX, minY, invSize);
-
-  	    var stop = ear,
-  	        prev, next;
-
-  	    // iterate through ears, slicing them one by one
-  	    while (ear.prev !== ear.next) {
-  	        prev = ear.prev;
-  	        next = ear.next;
-
-  	        if (invSize ? isEarHashed(ear, minX, minY, invSize) : isEar(ear)) {
-  	            // cut off the triangle
-  	            triangles.push(prev.i / dim | 0);
-  	            triangles.push(ear.i / dim | 0);
-  	            triangles.push(next.i / dim | 0);
-
-  	            removeNode(ear);
-
-  	            // skipping the next vertex leads to less sliver triangles
-  	            ear = next.next;
-  	            stop = next.next;
-
-  	            continue;
-  	        }
-
-  	        ear = next;
-
-  	        // if we looped through the whole remaining polygon and can't find any more ears
-  	        if (ear === stop) {
-  	            // try filtering points and slicing again
-  	            if (!pass) {
-  	                earcutLinked(filterPoints(ear), triangles, dim, minX, minY, invSize, 1);
-
-  	            // if this didn't work, try curing all small self-intersections locally
-  	            } else if (pass === 1) {
-  	                ear = cureLocalIntersections(filterPoints(ear), triangles, dim);
-  	                earcutLinked(ear, triangles, dim, minX, minY, invSize, 2);
-
-  	            // as a last resort, try splitting the remaining polygon into two
-  	            } else if (pass === 2) {
-  	                splitEarcut(ear, triangles, dim, minX, minY, invSize);
-  	            }
-
-  	            break;
-  	        }
-  	    }
-  	}
-
-  	// check whether a polygon node forms a valid ear with adjacent nodes
-  	function isEar(ear) {
-  	    var a = ear.prev,
-  	        b = ear,
-  	        c = ear.next;
-
-  	    if (area(a, b, c) >= 0) return false; // reflex, can't be an ear
-
-  	    // now make sure we don't have other points inside the potential ear
-  	    var ax = a.x, bx = b.x, cx = c.x, ay = a.y, by = b.y, cy = c.y;
-
-  	    // triangle bbox; min & max are calculated like this for speed
-  	    var x0 = ax < bx ? (ax < cx ? ax : cx) : (bx < cx ? bx : cx),
-  	        y0 = ay < by ? (ay < cy ? ay : cy) : (by < cy ? by : cy),
-  	        x1 = ax > bx ? (ax > cx ? ax : cx) : (bx > cx ? bx : cx),
-  	        y1 = ay > by ? (ay > cy ? ay : cy) : (by > cy ? by : cy);
-
-  	    var p = c.next;
-  	    while (p !== a) {
-  	        if (p.x >= x0 && p.x <= x1 && p.y >= y0 && p.y <= y1 &&
-  	            pointInTriangle(ax, ay, bx, by, cx, cy, p.x, p.y) &&
-  	            area(p.prev, p, p.next) >= 0) return false;
-  	        p = p.next;
-  	    }
-
-  	    return true;
-  	}
-
-  	function isEarHashed(ear, minX, minY, invSize) {
-  	    var a = ear.prev,
-  	        b = ear,
-  	        c = ear.next;
-
-  	    if (area(a, b, c) >= 0) return false; // reflex, can't be an ear
-
-  	    var ax = a.x, bx = b.x, cx = c.x, ay = a.y, by = b.y, cy = c.y;
-
-  	    // triangle bbox; min & max are calculated like this for speed
-  	    var x0 = ax < bx ? (ax < cx ? ax : cx) : (bx < cx ? bx : cx),
-  	        y0 = ay < by ? (ay < cy ? ay : cy) : (by < cy ? by : cy),
-  	        x1 = ax > bx ? (ax > cx ? ax : cx) : (bx > cx ? bx : cx),
-  	        y1 = ay > by ? (ay > cy ? ay : cy) : (by > cy ? by : cy);
-
-  	    // z-order range for the current triangle bbox;
-  	    var minZ = zOrder(x0, y0, minX, minY, invSize),
-  	        maxZ = zOrder(x1, y1, minX, minY, invSize);
-
-  	    var p = ear.prevZ,
-  	        n = ear.nextZ;
-
-  	    // look for points inside the triangle in both directions
-  	    while (p && p.z >= minZ && n && n.z <= maxZ) {
-  	        if (p.x >= x0 && p.x <= x1 && p.y >= y0 && p.y <= y1 && p !== a && p !== c &&
-  	            pointInTriangle(ax, ay, bx, by, cx, cy, p.x, p.y) && area(p.prev, p, p.next) >= 0) return false;
-  	        p = p.prevZ;
-
-  	        if (n.x >= x0 && n.x <= x1 && n.y >= y0 && n.y <= y1 && n !== a && n !== c &&
-  	            pointInTriangle(ax, ay, bx, by, cx, cy, n.x, n.y) && area(n.prev, n, n.next) >= 0) return false;
-  	        n = n.nextZ;
-  	    }
-
-  	    // look for remaining points in decreasing z-order
-  	    while (p && p.z >= minZ) {
-  	        if (p.x >= x0 && p.x <= x1 && p.y >= y0 && p.y <= y1 && p !== a && p !== c &&
-  	            pointInTriangle(ax, ay, bx, by, cx, cy, p.x, p.y) && area(p.prev, p, p.next) >= 0) return false;
-  	        p = p.prevZ;
-  	    }
-
-  	    // look for remaining points in increasing z-order
-  	    while (n && n.z <= maxZ) {
-  	        if (n.x >= x0 && n.x <= x1 && n.y >= y0 && n.y <= y1 && n !== a && n !== c &&
-  	            pointInTriangle(ax, ay, bx, by, cx, cy, n.x, n.y) && area(n.prev, n, n.next) >= 0) return false;
-  	        n = n.nextZ;
-  	    }
-
-  	    return true;
-  	}
-
-  	// go through all polygon nodes and cure small local self-intersections
-  	function cureLocalIntersections(start, triangles, dim) {
-  	    var p = start;
-  	    do {
-  	        var a = p.prev,
-  	            b = p.next.next;
-
-  	        if (!equals(a, b) && intersects(a, p, p.next, b) && locallyInside(a, b) && locallyInside(b, a)) {
-
-  	            triangles.push(a.i / dim | 0);
-  	            triangles.push(p.i / dim | 0);
-  	            triangles.push(b.i / dim | 0);
-
-  	            // remove two nodes involved
-  	            removeNode(p);
-  	            removeNode(p.next);
-
-  	            p = start = b;
-  	        }
-  	        p = p.next;
-  	    } while (p !== start);
-
-  	    return filterPoints(p);
-  	}
-
-  	// try splitting polygon into two and triangulate them independently
-  	function splitEarcut(start, triangles, dim, minX, minY, invSize) {
-  	    // look for a valid diagonal that divides the polygon into two
-  	    var a = start;
-  	    do {
-  	        var b = a.next.next;
-  	        while (b !== a.prev) {
-  	            if (a.i !== b.i && isValidDiagonal(a, b)) {
-  	                // split the polygon in two by the diagonal
-  	                var c = splitPolygon(a, b);
-
-  	                // filter colinear points around the cuts
-  	                a = filterPoints(a, a.next);
-  	                c = filterPoints(c, c.next);
-
-  	                // run earcut on each half
-  	                earcutLinked(a, triangles, dim, minX, minY, invSize, 0);
-  	                earcutLinked(c, triangles, dim, minX, minY, invSize, 0);
-  	                return;
-  	            }
-  	            b = b.next;
-  	        }
-  	        a = a.next;
-  	    } while (a !== start);
-  	}
-
-  	// link every hole into the outer loop, producing a single-ring polygon without holes
-  	function eliminateHoles(data, holeIndices, outerNode, dim) {
-  	    var queue = [],
-  	        i, len, start, end, list;
-
-  	    for (i = 0, len = holeIndices.length; i < len; i++) {
-  	        start = holeIndices[i] * dim;
-  	        end = i < len - 1 ? holeIndices[i + 1] * dim : data.length;
-  	        list = linkedList(data, start, end, dim, false);
-  	        if (list === list.next) list.steiner = true;
-  	        queue.push(getLeftmost(list));
-  	    }
-
-  	    queue.sort(compareX);
-
-  	    // process holes from left to right
-  	    for (i = 0; i < queue.length; i++) {
-  	        outerNode = eliminateHole(queue[i], outerNode);
-  	    }
-
-  	    return outerNode;
-  	}
-
-  	function compareX(a, b) {
-  	    return a.x - b.x;
-  	}
-
-  	// find a bridge between vertices that connects hole with an outer ring and and link it
-  	function eliminateHole(hole, outerNode) {
-  	    var bridge = findHoleBridge(hole, outerNode);
-  	    if (!bridge) {
-  	        return outerNode;
-  	    }
-
-  	    var bridgeReverse = splitPolygon(bridge, hole);
-
-  	    // filter collinear points around the cuts
-  	    filterPoints(bridgeReverse, bridgeReverse.next);
-  	    return filterPoints(bridge, bridge.next);
-  	}
-
-  	// David Eberly's algorithm for finding a bridge between hole and outer polygon
-  	function findHoleBridge(hole, outerNode) {
-  	    var p = outerNode,
-  	        hx = hole.x,
-  	        hy = hole.y,
-  	        qx = -Infinity,
-  	        m;
-
-  	    // find a segment intersected by a ray from the hole's leftmost point to the left;
-  	    // segment's endpoint with lesser x will be potential connection point
-  	    do {
-  	        if (hy <= p.y && hy >= p.next.y && p.next.y !== p.y) {
-  	            var x = p.x + (hy - p.y) * (p.next.x - p.x) / (p.next.y - p.y);
-  	            if (x <= hx && x > qx) {
-  	                qx = x;
-  	                m = p.x < p.next.x ? p : p.next;
-  	                if (x === hx) return m; // hole touches outer segment; pick leftmost endpoint
-  	            }
-  	        }
-  	        p = p.next;
-  	    } while (p !== outerNode);
-
-  	    if (!m) return null;
-
-  	    // look for points inside the triangle of hole point, segment intersection and endpoint;
-  	    // if there are no points found, we have a valid connection;
-  	    // otherwise choose the point of the minimum angle with the ray as connection point
-
-  	    var stop = m,
-  	        mx = m.x,
-  	        my = m.y,
-  	        tanMin = Infinity,
-  	        tan;
-
-  	    p = m;
-
-  	    do {
-  	        if (hx >= p.x && p.x >= mx && hx !== p.x &&
-  	                pointInTriangle(hy < my ? hx : qx, hy, mx, my, hy < my ? qx : hx, hy, p.x, p.y)) {
-
-  	            tan = Math.abs(hy - p.y) / (hx - p.x); // tangential
-
-  	            if (locallyInside(p, hole) &&
-  	                (tan < tanMin || (tan === tanMin && (p.x > m.x || (p.x === m.x && sectorContainsSector(m, p)))))) {
-  	                m = p;
-  	                tanMin = tan;
-  	            }
-  	        }
-
-  	        p = p.next;
-  	    } while (p !== stop);
-
-  	    return m;
-  	}
-
-  	// whether sector in vertex m contains sector in vertex p in the same coordinates
-  	function sectorContainsSector(m, p) {
-  	    return area(m.prev, m, p.prev) < 0 && area(p.next, m, m.next) < 0;
-  	}
-
-  	// interlink polygon nodes in z-order
-  	function indexCurve(start, minX, minY, invSize) {
-  	    var p = start;
-  	    do {
-  	        if (p.z === 0) p.z = zOrder(p.x, p.y, minX, minY, invSize);
-  	        p.prevZ = p.prev;
-  	        p.nextZ = p.next;
-  	        p = p.next;
-  	    } while (p !== start);
-
-  	    p.prevZ.nextZ = null;
-  	    p.prevZ = null;
-
-  	    sortLinked(p);
-  	}
-
-  	// Simon Tatham's linked list merge sort algorithm
-  	// http://www.chiark.greenend.org.uk/~sgtatham/algorithms/listsort.html
-  	function sortLinked(list) {
-  	    var i, p, q, e, tail, numMerges, pSize, qSize,
-  	        inSize = 1;
-
-  	    do {
-  	        p = list;
-  	        list = null;
-  	        tail = null;
-  	        numMerges = 0;
-
-  	        while (p) {
-  	            numMerges++;
-  	            q = p;
-  	            pSize = 0;
-  	            for (i = 0; i < inSize; i++) {
-  	                pSize++;
-  	                q = q.nextZ;
-  	                if (!q) break;
-  	            }
-  	            qSize = inSize;
-
-  	            while (pSize > 0 || (qSize > 0 && q)) {
-
-  	                if (pSize !== 0 && (qSize === 0 || !q || p.z <= q.z)) {
-  	                    e = p;
-  	                    p = p.nextZ;
-  	                    pSize--;
-  	                } else {
-  	                    e = q;
-  	                    q = q.nextZ;
-  	                    qSize--;
-  	                }
-
-  	                if (tail) tail.nextZ = e;
-  	                else list = e;
-
-  	                e.prevZ = tail;
-  	                tail = e;
-  	            }
-
-  	            p = q;
-  	        }
-
-  	        tail.nextZ = null;
-  	        inSize *= 2;
-
-  	    } while (numMerges > 1);
-
-  	    return list;
-  	}
-
-  	// z-order of a point given coords and inverse of the longer side of data bbox
-  	function zOrder(x, y, minX, minY, invSize) {
-  	    // coords are transformed into non-negative 15-bit integer range
-  	    x = (x - minX) * invSize | 0;
-  	    y = (y - minY) * invSize | 0;
-
-  	    x = (x | (x << 8)) & 0x00FF00FF;
-  	    x = (x | (x << 4)) & 0x0F0F0F0F;
-  	    x = (x | (x << 2)) & 0x33333333;
-  	    x = (x | (x << 1)) & 0x55555555;
-
-  	    y = (y | (y << 8)) & 0x00FF00FF;
-  	    y = (y | (y << 4)) & 0x0F0F0F0F;
-  	    y = (y | (y << 2)) & 0x33333333;
-  	    y = (y | (y << 1)) & 0x55555555;
-
-  	    return x | (y << 1);
-  	}
-
-  	// find the leftmost node of a polygon ring
-  	function getLeftmost(start) {
-  	    var p = start,
-  	        leftmost = start;
-  	    do {
-  	        if (p.x < leftmost.x || (p.x === leftmost.x && p.y < leftmost.y)) leftmost = p;
-  	        p = p.next;
-  	    } while (p !== start);
-
-  	    return leftmost;
-  	}
-
-  	// check if a point lies within a convex triangle
-  	function pointInTriangle(ax, ay, bx, by, cx, cy, px, py) {
-  	    return (cx - px) * (ay - py) >= (ax - px) * (cy - py) &&
-  	           (ax - px) * (by - py) >= (bx - px) * (ay - py) &&
-  	           (bx - px) * (cy - py) >= (cx - px) * (by - py);
-  	}
-
-  	// check if a diagonal between two polygon nodes is valid (lies in polygon interior)
-  	function isValidDiagonal(a, b) {
-  	    return a.next.i !== b.i && a.prev.i !== b.i && !intersectsPolygon(a, b) && // dones't intersect other edges
-  	           (locallyInside(a, b) && locallyInside(b, a) && middleInside(a, b) && // locally visible
-  	            (area(a.prev, a, b.prev) || area(a, b.prev, b)) || // does not create opposite-facing sectors
-  	            equals(a, b) && area(a.prev, a, a.next) > 0 && area(b.prev, b, b.next) > 0); // special zero-length case
-  	}
-
-  	// signed area of a triangle
-  	function area(p, q, r) {
-  	    return (q.y - p.y) * (r.x - q.x) - (q.x - p.x) * (r.y - q.y);
-  	}
-
-  	// check if two points are equal
-  	function equals(p1, p2) {
-  	    return p1.x === p2.x && p1.y === p2.y;
-  	}
-
-  	// check if two segments intersect
-  	function intersects(p1, q1, p2, q2) {
-  	    var o1 = sign(area(p1, q1, p2));
-  	    var o2 = sign(area(p1, q1, q2));
-  	    var o3 = sign(area(p2, q2, p1));
-  	    var o4 = sign(area(p2, q2, q1));
-
-  	    if (o1 !== o2 && o3 !== o4) return true; // general case
-
-  	    if (o1 === 0 && onSegment(p1, p2, q1)) return true; // p1, q1 and p2 are collinear and p2 lies on p1q1
-  	    if (o2 === 0 && onSegment(p1, q2, q1)) return true; // p1, q1 and q2 are collinear and q2 lies on p1q1
-  	    if (o3 === 0 && onSegment(p2, p1, q2)) return true; // p2, q2 and p1 are collinear and p1 lies on p2q2
-  	    if (o4 === 0 && onSegment(p2, q1, q2)) return true; // p2, q2 and q1 are collinear and q1 lies on p2q2
-
-  	    return false;
-  	}
-
-  	// for collinear points p, q, r, check if point q lies on segment pr
-  	function onSegment(p, q, r) {
-  	    return q.x <= Math.max(p.x, r.x) && q.x >= Math.min(p.x, r.x) && q.y <= Math.max(p.y, r.y) && q.y >= Math.min(p.y, r.y);
-  	}
-
-  	function sign(num) {
-  	    return num > 0 ? 1 : num < 0 ? -1 : 0;
-  	}
-
-  	// check if a polygon diagonal intersects any polygon segments
-  	function intersectsPolygon(a, b) {
-  	    var p = a;
-  	    do {
-  	        if (p.i !== a.i && p.next.i !== a.i && p.i !== b.i && p.next.i !== b.i &&
-  	                intersects(p, p.next, a, b)) return true;
-  	        p = p.next;
-  	    } while (p !== a);
-
-  	    return false;
-  	}
-
-  	// check if a polygon diagonal is locally inside the polygon
-  	function locallyInside(a, b) {
-  	    return area(a.prev, a, a.next) < 0 ?
-  	        area(a, b, a.next) >= 0 && area(a, a.prev, b) >= 0 :
-  	        area(a, b, a.prev) < 0 || area(a, a.next, b) < 0;
-  	}
-
-  	// check if the middle point of a polygon diagonal is inside the polygon
-  	function middleInside(a, b) {
-  	    var p = a,
-  	        inside = false,
-  	        px = (a.x + b.x) / 2,
-  	        py = (a.y + b.y) / 2;
-  	    do {
-  	        if (((p.y > py) !== (p.next.y > py)) && p.next.y !== p.y &&
-  	                (px < (p.next.x - p.x) * (py - p.y) / (p.next.y - p.y) + p.x))
-  	            inside = !inside;
-  	        p = p.next;
-  	    } while (p !== a);
-
-  	    return inside;
-  	}
-
-  	// link two polygon vertices with a bridge; if the vertices belong to the same ring, it splits polygon into two;
-  	// if one belongs to the outer ring and another to a hole, it merges it into a single ring
-  	function splitPolygon(a, b) {
-  	    var a2 = new Node(a.i, a.x, a.y),
-  	        b2 = new Node(b.i, b.x, b.y),
-  	        an = a.next,
-  	        bp = b.prev;
-
-  	    a.next = b;
-  	    b.prev = a;
-
-  	    a2.next = an;
-  	    an.prev = a2;
-
-  	    b2.next = a2;
-  	    a2.prev = b2;
-
-  	    bp.next = b2;
-  	    b2.prev = bp;
-
-  	    return b2;
-  	}
-
-  	// create a node and optionally link it with previous one (in a circular doubly linked list)
-  	function insertNode(i, x, y, last) {
-  	    var p = new Node(i, x, y);
-
-  	    if (!last) {
-  	        p.prev = p;
-  	        p.next = p;
-
-  	    } else {
-  	        p.next = last.next;
-  	        p.prev = last;
-  	        last.next.prev = p;
-  	        last.next = p;
-  	    }
-  	    return p;
-  	}
-
-  	function removeNode(p) {
-  	    p.next.prev = p.prev;
-  	    p.prev.next = p.next;
-
-  	    if (p.prevZ) p.prevZ.nextZ = p.nextZ;
-  	    if (p.nextZ) p.nextZ.prevZ = p.prevZ;
-  	}
-
-  	function Node(i, x, y) {
-  	    // vertex index in coordinates array
-  	    this.i = i;
-
-  	    // vertex coordinates
-  	    this.x = x;
-  	    this.y = y;
-
-  	    // previous and next vertex nodes in a polygon ring
-  	    this.prev = null;
-  	    this.next = null;
-
-  	    // z-order curve value
-  	    this.z = 0;
-
-  	    // previous and next nodes in z-order
-  	    this.prevZ = null;
-  	    this.nextZ = null;
-
-  	    // indicates whether this is a steiner point
-  	    this.steiner = false;
-  	}
-
-  	// return a percentage difference between the polygon area and its triangulation area;
-  	// used to verify correctness of triangulation
-  	earcut.deviation = function (data, holeIndices, dim, triangles) {
-  	    var hasHoles = holeIndices && holeIndices.length;
-  	    var outerLen = hasHoles ? holeIndices[0] * dim : data.length;
-
-  	    var polygonArea = Math.abs(signedArea(data, 0, outerLen, dim));
-  	    if (hasHoles) {
-  	        for (var i = 0, len = holeIndices.length; i < len; i++) {
-  	            var start = holeIndices[i] * dim;
-  	            var end = i < len - 1 ? holeIndices[i + 1] * dim : data.length;
-  	            polygonArea -= Math.abs(signedArea(data, start, end, dim));
-  	        }
-  	    }
-
-  	    var trianglesArea = 0;
-  	    for (i = 0; i < triangles.length; i += 3) {
-  	        var a = triangles[i] * dim;
-  	        var b = triangles[i + 1] * dim;
-  	        var c = triangles[i + 2] * dim;
-  	        trianglesArea += Math.abs(
-  	            (data[a] - data[c]) * (data[b + 1] - data[a + 1]) -
-  	            (data[a] - data[b]) * (data[c + 1] - data[a + 1]));
-  	    }
-
-  	    return polygonArea === 0 && trianglesArea === 0 ? 0 :
-  	        Math.abs((trianglesArea - polygonArea) / polygonArea);
-  	};
-
-  	function signedArea(data, start, end, dim) {
-  	    var sum = 0;
-  	    for (var i = start, j = end - dim; i < end; i += dim) {
-  	        sum += (data[j] - data[i]) * (data[i + 1] + data[j + 1]);
-  	        j = i;
-  	    }
-  	    return sum;
-  	}
-
-  	// turn a polygon in a multi-dimensional array form (e.g. as in GeoJSON) into a form Earcut accepts
-  	earcut.flatten = function (data) {
-  	    var dim = data[0][0].length,
-  	        result = {vertices: [], holes: [], dimensions: dim},
-  	        holeIndex = 0;
-
-  	    for (var i = 0; i < data.length; i++) {
-  	        for (var j = 0; j < data[i].length; j++) {
-  	            for (var d = 0; d < dim; d++) result.vertices.push(data[i][j][d]);
-  	        }
-  	        if (i > 0) {
-  	            holeIndex += data[i - 1].length;
-  	            result.holes.push(holeIndex);
-  	        }
-  	    }
-  	    return result;
-  	};
-  	return earcut$1.exports;
-  }
-
-  var earcutExports = requireEarcut();
-  var earcut = /*@__PURE__*/getDefaultExportFromCjs(earcutExports);
-
   const epsilon$1 = 1.1102230246251565e-16;
   const splitter = 134217729;
   const resulterrbound = (3 + 8 * epsilon$1) * epsilon$1;
@@ -48596,179 +48659,139 @@ void main() {
       return p[1];
   }
 
-  /**
-   * Unwrap a coordinate from a Point Feature, Geometry or a single coordinate.
-   *
-   * @name getCoord
-   * @param {Array<number>|Geometry<Point>|Feature<Point>} coord GeoJSON Point or an Array of numbers
-   * @returns {Array<number>} coordinates
-   * @example
-   * var pt = turf.point([10, 10]);
-   *
-   * var coord = turf.getCoord(pt);
-   * //= [10, 10]
-   */
-  function getCoord(coord) {
-      if (!coord) {
-          throw new Error("coord is required");
-      }
-      if (!Array.isArray(coord)) {
-          if (coord.type === "Feature" &&
-              coord.geometry !== null &&
-              coord.geometry.type === "Point") {
-              return coord.geometry.coordinates;
-          }
-          if (coord.type === "Point") {
-              return coord.coordinates;
+  function pointInPolygon(p, polygon) {
+      var i = 0;
+      var ii = 0;
+      var k = 0;
+      var f = 0;
+      var u1 = 0;
+      var v1 = 0;
+      var u2 = 0;
+      var v2 = 0;
+      var currentP = null;
+      var nextP = null;
+
+      var x = p[0];
+      var y = p[1];
+
+      var numContours = polygon.length;
+      for (i; i < numContours; i++) {
+          ii = 0;
+          var contourLen = polygon[i].length - 1;
+          var contour = polygon[i];
+
+          currentP = contour[0];
+          if (currentP[0] !== contour[contourLen][0] &&
+              currentP[1] !== contour[contourLen][1]) {
+              throw new Error('First and last coordinates in a ring must be the same')
           }
-      }
-      if (Array.isArray(coord) &&
-          coord.length >= 2 &&
-          !Array.isArray(coord[0]) &&
-          !Array.isArray(coord[1])) {
-          return coord;
-      }
-      throw new Error("coord must be GeoJSON Point or an Array of numbers");
-  }
-  /**
-   * Get Geometry from Feature or Geometry Object
-   *
-   * @param {Feature|Geometry} geojson GeoJSON Feature or Geometry Object
-   * @returns {Geometry|null} GeoJSON Geometry Object
-   * @throws {Error} if geojson is not a Feature or Geometry Object
-   * @example
-   * var point = {
-   *   "type": "Feature",
-   *   "properties": {},
-   *   "geometry": {
-   *     "type": "Point",
-   *     "coordinates": [110, 40]
-   *   }
-   * }
-   * var geom = turf.getGeom(point)
-   * //={"type": "Point", "coordinates": [110, 40]}
-   */
-  function getGeom(geojson) {
-      if (geojson.type === "Feature") {
-          return geojson.geometry;
-      }
-      return geojson;
-  }
 
-  // http://en.wikipedia.org/wiki/Even%E2%80%93odd_rule
-  // modified from: https://github.com/substack/point-in-polygon/blob/master/index.js
-  // which was modified from http://www.ecse.rpi.edu/Homepages/wrf/Research/Short_Notes/pnpoly.html
-  /**
-   * Takes a {@link Point} and a {@link Polygon} or {@link MultiPolygon} and determines if the point
-   * resides inside the polygon. The polygon can be convex or concave. The function accounts for holes.
-   *
-   * @name booleanPointInPolygon
-   * @param {Coord} point input point
-   * @param {Feature<Polygon|MultiPolygon>} polygon input polygon or multipolygon
-   * @param {Object} [options={}] Optional parameters
-   * @param {boolean} [options.ignoreBoundary=false] True if polygon boundary should be ignored when determining if
-   * the point is inside the polygon otherwise false.
-   * @returns {boolean} `true` if the Point is inside the Polygon; `false` if the Point is not inside the Polygon
-   * @example
-   * var pt = turf.point([-77, 44]);
-   * var poly = turf.polygon([[
-   *   [-81, 41],
-   *   [-81, 47],
-   *   [-72, 47],
-   *   [-72, 41],
-   *   [-81, 41]
-   * ]]);
-   *
-   * turf.booleanPointInPolygon(pt, poly);
-   * //= true
-   */
-  function booleanPointInPolygon(point, polygon, options) {
-      if (options === void 0) { options = {}; }
-      // validation
-      if (!point) {
-          throw new Error("point is required");
-      }
-      if (!polygon) {
-          throw new Error("polygon is required");
-      }
-      var pt = getCoord(point);
-      var geom = getGeom(polygon);
-      var type = geom.type;
-      var bbox = polygon.bbox;
-      var polys = geom.coordinates;
-      // Quick elimination if point is not inside bbox
-      if (bbox && inBBox(pt, bbox) === false) {
-          return false;
-      }
-      // normalize to multipolygon
-      if (type === "Polygon") {
-          polys = [polys];
-      }
-      var insidePoly = false;
-      for (var i = 0; i < polys.length && !insidePoly; i++) {
-          // check if it is in the outer ring first
-          if (inRing(pt, polys[i][0], options.ignoreBoundary)) {
-              var inHole = false;
-              var k = 1;
-              // check for the point in any of the holes
-              while (k < polys[i].length && !inHole) {
-                  if (inRing(pt, polys[i][k], !options.ignoreBoundary)) {
-                      inHole = true;
-                  }
-                  k++;
+          u1 = currentP[0] - x;
+          v1 = currentP[1] - y;
+
+          for (ii; ii < contourLen; ii++) {
+              nextP = contour[ii + 1];
+
+              v2 = nextP[1] - y;
+
+              if ((v1 < 0 && v2 < 0) || (v1 > 0 && v2 > 0)) {
+                  currentP = nextP;
+                  v1 = v2;
+                  u1 = currentP[0] - x;
+                  continue
               }
-              if (!inHole) {
-                  insidePoly = true;
+
+              u2 = nextP[0] - p[0];
+
+              if (v2 > 0 && v1 <= 0) {
+                  f = (u1 * v2) - (u2 * v1);
+                  if (f > 0) { k = k + 1; }
+                  else if (f === 0) { return 0 }
+              } else if (v1 > 0 && v2 <= 0) {
+                  f = (u1 * v2) - (u2 * v1);
+                  if (f < 0) { k = k + 1; }
+                  else if (f === 0) { return 0 }
+              } else if (v2 === 0 && v1 < 0) {
+                  f = (u1 * v2) - (u2 * v1);
+                  if (f === 0) { return 0 }
+              } else if (v1 === 0 && v2 < 0) {
+                  f = u1 * v2 - u2 * v1;
+                  if (f === 0) { return 0 }
+              } else if (v1 === 0 && v2 === 0) {
+                  if (u2 <= 0 && u1 >= 0) {
+                      return 0
+                  } else if (u1 <= 0 && u2 >= 0) {
+                      return 0
+                  }
               }
+              currentP = nextP;
+              v1 = v2;
+              u1 = u2;
           }
       }
-      return insidePoly;
+
+      if (k % 2 === 0) { return false }
+      return true
   }
-  /**
-   * inRing
-   *
-   * @private
-   * @param {Array<number>} pt [x,y]
-   * @param {Array<Array<number>>} ring [[x,y], [x,y],..]
-   * @param {boolean} ignoreBoundary ignoreBoundary
-   * @returns {boolean} inRing
-   */
-  function inRing(pt, ring, ignoreBoundary) {
-      var isInside = false;
-      if (ring[0][0] === ring[ring.length - 1][0] &&
-          ring[0][1] === ring[ring.length - 1][1]) {
-          ring = ring.slice(0, ring.length - 1);
+
+  // index.ts
+  function getCoord(coord) {
+    if (!coord) {
+      throw new Error("coord is required");
+    }
+    if (!Array.isArray(coord)) {
+      if (coord.type === "Feature" && coord.geometry !== null && coord.geometry.type === "Point") {
+        return [...coord.geometry.coordinates];
       }
-      for (var i = 0, j = ring.length - 1; i < ring.length; j = i++) {
-          var xi = ring[i][0];
-          var yi = ring[i][1];
-          var xj = ring[j][0];
-          var yj = ring[j][1];
-          var onBoundary = pt[1] * (xi - xj) + yi * (xj - pt[0]) + yj * (pt[0] - xi) === 0 &&
-              (xi - pt[0]) * (xj - pt[0]) <= 0 &&
-              (yi - pt[1]) * (yj - pt[1]) <= 0;
-          if (onBoundary) {
-              return !ignoreBoundary;
-          }
-          var intersect = yi > pt[1] !== yj > pt[1] &&
-              pt[0] < ((xj - xi) * (pt[1] - yi)) / (yj - yi) + xi;
-          if (intersect) {
-              isInside = !isInside;
-          }
+      if (coord.type === "Point") {
+        return [...coord.coordinates];
       }
-      return isInside;
+    }
+    if (Array.isArray(coord) && coord.length >= 2 && !Array.isArray(coord[0]) && !Array.isArray(coord[1])) {
+      return [...coord];
+    }
+    throw new Error("coord must be GeoJSON Point or an Array of numbers");
+  }
+  function getGeom(geojson) {
+    if (geojson.type === "Feature") {
+      return geojson.geometry;
+    }
+    return geojson;
+  }
+
+  // index.ts
+  function booleanPointInPolygon(point, polygon, options = {}) {
+    if (!point) {
+      throw new Error("point is required");
+    }
+    if (!polygon) {
+      throw new Error("polygon is required");
+    }
+    const pt = getCoord(point);
+    const geom = getGeom(polygon);
+    const type = geom.type;
+    const bbox = polygon.bbox;
+    let polys = geom.coordinates;
+    if (bbox && inBBox(pt, bbox) === false) {
+      return false;
+    }
+    if (type === "Polygon") {
+      polys = [polys];
+    }
+    let result = false;
+    for (var i = 0; i < polys.length; ++i) {
+      const polyResult = pointInPolygon(pt, polys[i]);
+      if (polyResult === 0)
+        return options.ignoreBoundary ? false : true;
+      else if (polyResult)
+        result = true;
+    }
+    return result;
   }
-  /**
-   * inBBox
-   *
-   * @private
-   * @param {Position} pt point [x,y]
-   * @param {BBox} bbox BBox [west, south, east, north]
-   * @returns {boolean} true/false if point is inside BBox
-   */
   function inBBox(pt, bbox) {
-      return (bbox[0] <= pt[0] && bbox[1] <= pt[1] && bbox[2] >= pt[0] && bbox[3] >= pt[1]);
+    return bbox[0] <= pt[0] && bbox[1] <= pt[1] && bbox[2] >= pt[0] && bbox[3] >= pt[1];
   }
+  var turf_boolean_point_in_polygon_default = booleanPointInPolygon;
 
   const epsilon = 1e-6;
 
@@ -50026,9 +50049,49 @@ void main() {
     return data ? v(data) : v;
   }
 
+  function _arrayLikeToArray$2(r, a) {
+    (null == a || a > r.length) && (a = r.length);
+    for (var e = 0, n = Array(a); e < a; e++) n[e] = r[e];
+    return n;
+  }
+  function _arrayWithHoles$2(r) {
+    if (Array.isArray(r)) return r;
+  }
+  function _arrayWithoutHoles$2(r) {
+    if (Array.isArray(r)) return _arrayLikeToArray$2(r);
+  }
+  function _assertThisInitialized$2(e) {
+    if (void 0 === e) throw new ReferenceError("this hasn't been initialised - super() hasn't been called");
+    return e;
+  }
   function _callSuper$1(t, o, e) {
     return o = _getPrototypeOf$2(o), _possibleConstructorReturn$1(t, _isNativeReflectConstruct$2() ? Reflect.construct(o, [], _getPrototypeOf$2(t).constructor) : o.apply(t, e));
   }
+  function _classCallCheck$1(a, n) {
+    if (!(a instanceof n)) throw new TypeError("Cannot call a class as a function");
+  }
+  function _createClass$1(e, r, t) {
+    return Object.defineProperty(e, "prototype", {
+      writable: !1
+    }), e;
+  }
+  function _getPrototypeOf$2(t) {
+    return _getPrototypeOf$2 = Object.setPrototypeOf ? Object.getPrototypeOf.bind() : function (t) {
+      return t.__proto__ || Object.getPrototypeOf(t);
+    }, _getPrototypeOf$2(t);
+  }
+  function _inherits$1(t, e) {
+    if ("function" != typeof e && null !== e) throw new TypeError("Super expression must either be null or a function");
+    t.prototype = Object.create(e && e.prototype, {
+      constructor: {
+        value: t,
+        writable: !0,
+        configurable: !0
+      }
+    }), Object.defineProperty(t, "prototype", {
+      writable: !1
+    }), e && _setPrototypeOf$2(t, e);
+  }
   function _isNativeReflectConstruct$2() {
     try {
       var t = !Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {}));
@@ -50037,6 +50100,9 @@ void main() {
       return !!t;
     })();
   }
+  function _iterableToArray$2(r) {
+    if ("undefined" != typeof Symbol && null != r[Symbol.iterator] || null != r["@@iterator"]) return Array.from(r);
+  }
   function _iterableToArrayLimit$2(r, l) {
     var t = null == r ? null : "undefined" != typeof Symbol && r[Symbol.iterator] || r["@@iterator"];
     if (null != t) {
@@ -50061,93 +50127,34 @@ void main() {
       return a;
     }
   }
-  function _classCallCheck$1(instance, Constructor) {
-    if (!(instance instanceof Constructor)) {
-      throw new TypeError("Cannot call a class as a function");
-    }
+  function _nonIterableRest$2() {
+    throw new TypeError("Invalid attempt to destructure non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
   }
-  function _createClass$1(Constructor, protoProps, staticProps) {
-    Object.defineProperty(Constructor, "prototype", {
-      writable: false
-    });
-    return Constructor;
+  function _nonIterableSpread$2() {
+    throw new TypeError("Invalid attempt to spread non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
   }
-  function _inherits$1(subClass, superClass) {
-    if (typeof superClass !== "function" && superClass !== null) {
-      throw new TypeError("Super expression must either be null or a function");
-    }
-    subClass.prototype = Object.create(superClass && superClass.prototype, {
-      constructor: {
-        value: subClass,
-        writable: true,
-        configurable: true
-      }
-    });
-    Object.defineProperty(subClass, "prototype", {
-      writable: false
-    });
-    if (superClass) _setPrototypeOf$2(subClass, superClass);
+  function _possibleConstructorReturn$1(t, e) {
+    if (e && ("object" == typeof e || "function" == typeof e)) return e;
+    if (void 0 !== e) throw new TypeError("Derived constructors may only return object or undefined");
+    return _assertThisInitialized$2(t);
   }
-  function _getPrototypeOf$2(o) {
-    _getPrototypeOf$2 = Object.setPrototypeOf ? Object.getPrototypeOf.bind() : function _getPrototypeOf(o) {
-      return o.__proto__ || Object.getPrototypeOf(o);
-    };
-    return _getPrototypeOf$2(o);
+  function _setPrototypeOf$2(t, e) {
+    return _setPrototypeOf$2 = Object.setPrototypeOf ? Object.setPrototypeOf.bind() : function (t, e) {
+      return t.__proto__ = e, t;
+    }, _setPrototypeOf$2(t, e);
   }
-  function _setPrototypeOf$2(o, p) {
-    _setPrototypeOf$2 = Object.setPrototypeOf ? Object.setPrototypeOf.bind() : function _setPrototypeOf(o, p) {
-      o.__proto__ = p;
-      return o;
-    };
-    return _setPrototypeOf$2(o, p);
+  function _slicedToArray$2(r, e) {
+    return _arrayWithHoles$2(r) || _iterableToArrayLimit$2(r, e) || _unsupportedIterableToArray$2(r, e) || _nonIterableRest$2();
   }
-  function _assertThisInitialized$2(self) {
-    if (self === void 0) {
-      throw new ReferenceError("this hasn't been initialised - super() hasn't been called");
-    }
-    return self;
+  function _toConsumableArray$2(r) {
+    return _arrayWithoutHoles$2(r) || _iterableToArray$2(r) || _unsupportedIterableToArray$2(r) || _nonIterableSpread$2();
   }
-  function _possibleConstructorReturn$1(self, call) {
-    if (call && (typeof call === "object" || typeof call === "function")) {
-      return call;
-    } else if (call !== void 0) {
-      throw new TypeError("Derived constructors may only return object or undefined");
+  function _unsupportedIterableToArray$2(r, a) {
+    if (r) {
+      if ("string" == typeof r) return _arrayLikeToArray$2(r, a);
+      var t = {}.toString.call(r).slice(8, -1);
+      return "Object" === t && r.constructor && (t = r.constructor.name), "Map" === t || "Set" === t ? Array.from(r) : "Arguments" === t || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(t) ? _arrayLikeToArray$2(r, a) : void 0;
     }
-    return _assertThisInitialized$2(self);
-  }
-  function _slicedToArray$2(arr, i) {
-    return _arrayWithHoles$2(arr) || _iterableToArrayLimit$2(arr, i) || _unsupportedIterableToArray$2(arr, i) || _nonIterableRest$2();
-  }
-  function _toConsumableArray$2(arr) {
-    return _arrayWithoutHoles$2(arr) || _iterableToArray$2(arr) || _unsupportedIterableToArray$2(arr) || _nonIterableSpread$2();
-  }
-  function _arrayWithoutHoles$2(arr) {
-    if (Array.isArray(arr)) return _arrayLikeToArray$2(arr);
-  }
-  function _arrayWithHoles$2(arr) {
-    if (Array.isArray(arr)) return arr;
-  }
-  function _iterableToArray$2(iter) {
-    if (typeof Symbol !== "undefined" && iter[Symbol.iterator] != null || iter["@@iterator"] != null) return Array.from(iter);
-  }
-  function _unsupportedIterableToArray$2(o, minLen) {
-    if (!o) return;
-    if (typeof o === "string") return _arrayLikeToArray$2(o, minLen);
-    var n = Object.prototype.toString.call(o).slice(8, -1);
-    if (n === "Object" && o.constructor) n = o.constructor.name;
-    if (n === "Map" || n === "Set") return Array.from(o);
-    if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray$2(o, minLen);
-  }
-  function _arrayLikeToArray$2(arr, len) {
-    if (len == null || len > arr.length) len = arr.length;
-    for (var i = 0, arr2 = new Array(len); i < len; i++) arr2[i] = arr[i];
-    return arr2;
-  }
-  function _nonIterableSpread$2() {
-    throw new TypeError("Invalid attempt to spread non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
-  }
-  function _nonIterableRest$2() {
-    throw new TypeError("Invalid attempt to destructure non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
   }
 
   function geoPolygonTriangulate(polygon) {
@@ -50209,10 +50216,10 @@ void main() {
       });
     } else if (!innerPoints.length) {
       // earcut triangulation slightly more performing if it's only using the polygon perimeter
-      var _earcut$flatten = earcut.flatten(contour),
-        vertices = _earcut$flatten.vertices,
-        _earcut$flatten$holes = _earcut$flatten.holes,
-        holes = _earcut$flatten$holes === void 0 ? [] : _earcut$flatten$holes;
+      var _earcutFlatten = flatten$1(contour),
+        vertices = _earcutFlatten.vertices,
+        _earcutFlatten$holes = _earcutFlatten.holes,
+        holes = _earcutFlatten$holes === void 0 ? [] : _earcutFlatten$holes;
       indices = earcut(vertices, holes, 2);
     } else {
       // use delaunator
@@ -50359,19 +50366,18 @@ void main() {
   function pointInside(pnt, polygon) {
     var crossesPoleOrAntimeridian = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : false;
     // turf method is more performing but malfunctions if polygon includes a pole (lat = 90 | -90) or crosses the antimeridian (lng = 180 | -180)
-    return crossesPoleOrAntimeridian ? geoContains(polygon, pnt) : booleanPointInPolygon(pnt, polygon);
+    return crossesPoleOrAntimeridian ? geoContains(polygon, pnt) : turf_boolean_point_in_polygon_default(pnt, polygon);
   }
 
-  var THREE$k = window.THREE ? window.THREE // Prefer consumption from global THREE, if exists
+  var THREE$j = window.THREE ? window.THREE // Prefer consumption from global THREE, if exists
   : {
     BufferGeometry: BufferGeometry,
     Float32BufferAttribute: Float32BufferAttribute
   };
 
   // support both modes for backwards threejs compatibility
-  var setAttributeFn$2 = new THREE$k.BufferGeometry().setAttribute ? 'setAttribute' : 'addAttribute';
+  var setAttributeFn = new THREE$j.BufferGeometry().setAttribute ? 'setAttribute' : 'addAttribute';
   var ConicPolygonBufferGeometry = /*#__PURE__*/function (_THREE$BufferGeometry) {
-    _inherits$1(ConicPolygonBufferGeometry, _THREE$BufferGeometry);
     function ConicPolygonBufferGeometry(polygonGeoJson, startHeight, endHeight, closedBottom, closedTop, includeSides, curvatureResolution) {
       var _this;
       _classCallCheck$1(this, ConicPolygonBufferGeometry);
@@ -50423,8 +50429,8 @@ void main() {
 
       // build geometry
       _this.setIndex(indices);
-      _this[setAttributeFn$2]('position', new THREE$k.Float32BufferAttribute(vertices, 3));
-      _this[setAttributeFn$2]('uv', new THREE$k.Float32BufferAttribute(uvs, 2));
+      _this[setAttributeFn]('position', new THREE$j.Float32BufferAttribute(vertices, 3));
+      _this[setAttributeFn]('uv', new THREE$j.Float32BufferAttribute(uvs, 2));
 
       // auto-calculate normals
       _this.computeVertexNormals();
@@ -50441,7 +50447,7 @@ void main() {
           });
         });
         // returns { vertices, holes, coordinates }. Each point generates 3 vertice items (x,y,z).
-        return earcut.flatten(coords3d);
+        return flatten$1(coords3d);
       }
       function generateTorso() {
         var _generateVertices = generateVertices(contour, startHeight),
@@ -50487,8 +50493,9 @@ void main() {
       }
       return _this;
     }
+    _inherits$1(ConicPolygonBufferGeometry, _THREE$BufferGeometry);
     return _createClass$1(ConicPolygonBufferGeometry);
-  }(THREE$k.BufferGeometry); //
+  }(THREE$j.BufferGeometry); //
   function polar2Cartesian$1(lat, lng) {
     var r = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : 0;
     var phi = (90 - lat) * Math.PI / 180;
@@ -65923,201 +65930,257 @@ void main() {
   var yaotExports = requireYaot();
   var yaOctree = /*@__PURE__*/getDefaultExportFromCjs(yaotExports);
 
-  const THREE$2$1 = window.THREE ? window.THREE // Prefer consumption from global THREE, if exists
-  : {
-    Box3,
-    BufferGeometry,
-    Float32BufferAttribute,
-    InstancedBufferGeometry,
-    InstancedInterleavedBuffer,
-    InterleavedBufferAttribute,
-    Sphere,
-    Vector3,
-    WireframeGeometry
-  };
+  const _box$1 = new Box3();
+  const _vector = new Vector3();
 
-  // support multiple method names for backwards threejs compatibility
-  var setAttributeFn$1 = new THREE$2$1.BufferGeometry().setAttribute ? 'setAttribute' : 'addAttribute';
-  const _box$1 = new THREE$2$1.Box3();
-  const _vector = new THREE$2$1.Vector3();
-  class LineSegmentsGeometry extends THREE$2$1.InstancedBufferGeometry {
-    constructor() {
-      super();
-      this.type = 'LineSegmentsGeometry';
-      const positions = [-1, 2, 0, 1, 2, 0, -1, 1, 0, 1, 1, 0, -1, 0, 0, 1, 0, 0, -1, -1, 0, 1, -1, 0];
-      const uvs = [-1, 2, 1, 2, -1, 1, 1, 1, -1, -1, 1, -1, -1, -2, 1, -2];
-      const index = [0, 2, 1, 2, 3, 1, 2, 4, 3, 4, 5, 3, 4, 6, 5, 6, 7, 5];
-      this.setIndex(index);
-      this[setAttributeFn$1]('position', new THREE$2$1.Float32BufferAttribute(positions, 3));
-      this[setAttributeFn$1]('uv', new THREE$2$1.Float32BufferAttribute(uvs, 2));
-    }
-    applyMatrix4(matrix) {
-      const start = this.attributes.instanceStart;
-      const end = this.attributes.instanceEnd;
-      if (start !== undefined) {
-        start.applyMatrix4(matrix);
-        end.applyMatrix4(matrix);
-        start.needsUpdate = true;
-      }
-      if (this.boundingBox !== null) {
-        this.computeBoundingBox();
-      }
-      if (this.boundingSphere !== null) {
-        this.computeBoundingSphere();
-      }
-      return this;
-    }
-    setPositions(array) {
-      let lineSegments;
-      if (array instanceof Float32Array) {
-        lineSegments = array;
-      } else if (Array.isArray(array)) {
-        lineSegments = new Float32Array(array);
-      }
-      const instanceBuffer = new THREE$2$1.InstancedInterleavedBuffer(lineSegments, 6, 1); // xyz, xyz
+  class LineSegmentsGeometry extends InstancedBufferGeometry {
 
-      this[setAttributeFn$1]('instanceStart', new THREE$2$1.InterleavedBufferAttribute(instanceBuffer, 3, 0)); // xyz
+  	constructor() {
 
-      this[setAttributeFn$1]('instanceEnd', new THREE$2$1.InterleavedBufferAttribute(instanceBuffer, 3, 3)); // xyz
-      //
+  		super();
 
-      this.computeBoundingBox();
-      this.computeBoundingSphere();
-      return this;
-    }
-    setColors(array) {
-      let colors;
-      if (array instanceof Float32Array) {
-        colors = array;
-      } else if (Array.isArray(array)) {
-        colors = new Float32Array(array);
-      }
-      const instanceColorBuffer = new THREE$2$1.InstancedInterleavedBuffer(colors, 6, 1); // rgb, rgb
+  		this.isLineSegmentsGeometry = true;
 
-      this[setAttributeFn$1]('instanceColorStart', new THREE$2$1.InterleavedBufferAttribute(instanceColorBuffer, 3, 0)); // rgb
+  		this.type = 'LineSegmentsGeometry';
 
-      this[setAttributeFn$1]('instanceColorEnd', new THREE$2$1.InterleavedBufferAttribute(instanceColorBuffer, 3, 3)); // rgb
+  		const positions = [ - 1, 2, 0, 1, 2, 0, - 1, 1, 0, 1, 1, 0, - 1, 0, 0, 1, 0, 0, - 1, - 1, 0, 1, - 1, 0 ];
+  		const uvs = [ - 1, 2, 1, 2, - 1, 1, 1, 1, - 1, - 1, 1, - 1, - 1, - 2, 1, - 2 ];
+  		const index = [ 0, 2, 1, 2, 3, 1, 2, 4, 3, 4, 5, 3, 4, 6, 5, 6, 7, 5 ];
 
-      return this;
-    }
-    fromWireframeGeometry(geometry) {
-      this.setPositions(geometry.attributes.position.array);
-      return this;
-    }
-    fromEdgesGeometry(geometry) {
-      this.setPositions(geometry.attributes.position.array);
-      return this;
-    }
-    fromMesh(mesh) {
-      this.fromWireframeGeometry(new THREE$2$1.WireframeGeometry(mesh.geometry)); // set colors, maybe
+  		this.setIndex( index );
+  		this.setAttribute( 'position', new Float32BufferAttribute( positions, 3 ) );
+  		this.setAttribute( 'uv', new Float32BufferAttribute( uvs, 2 ) );
 
-      return this;
-    }
-    fromLineSegments(lineSegments) {
-      const geometry = lineSegments.geometry;
-      if (geometry.isGeometry) {
-        console.error('LineSegmentsGeometry no longer supports Geometry. Use THREE.BufferGeometry instead.');
-        return;
-      } else if (geometry.isBufferGeometry) {
-        this.setPositions(geometry.attributes.position.array); // assumes non-indexed
-      } // set colors, maybe
+  	}
+
+  	applyMatrix4( matrix ) {
+
+  		const start = this.attributes.instanceStart;
+  		const end = this.attributes.instanceEnd;
+
+  		if ( start !== undefined ) {
+
+  			start.applyMatrix4( matrix );
+
+  			end.applyMatrix4( matrix );
+
+  			start.needsUpdate = true;
+
+  		}
+
+  		if ( this.boundingBox !== null ) {
+
+  			this.computeBoundingBox();
+
+  		}
+
+  		if ( this.boundingSphere !== null ) {
+
+  			this.computeBoundingSphere();
+
+  		}
+
+  		return this;
+
+  	}
+
+  	setPositions( array ) {
+
+  		let lineSegments;
+
+  		if ( array instanceof Float32Array ) {
+
+  			lineSegments = array;
+
+  		} else if ( Array.isArray( array ) ) {
+
+  			lineSegments = new Float32Array( array );
+
+  		}
+
+  		const instanceBuffer = new InstancedInterleavedBuffer( lineSegments, 6, 1 ); // xyz, xyz
+
+  		this.setAttribute( 'instanceStart', new InterleavedBufferAttribute( instanceBuffer, 3, 0 ) ); // xyz
+  		this.setAttribute( 'instanceEnd', new InterleavedBufferAttribute( instanceBuffer, 3, 3 ) ); // xyz
+
+  		//
+
+  		this.computeBoundingBox();
+  		this.computeBoundingSphere();
+
+  		return this;
+
+  	}
+
+  	setColors( array ) {
+
+  		let colors;
+
+  		if ( array instanceof Float32Array ) {
+
+  			colors = array;
+
+  		} else if ( Array.isArray( array ) ) {
+
+  			colors = new Float32Array( array );
+
+  		}
+
+  		const instanceColorBuffer = new InstancedInterleavedBuffer( colors, 6, 1 ); // rgb, rgb
+
+  		this.setAttribute( 'instanceColorStart', new InterleavedBufferAttribute( instanceColorBuffer, 3, 0 ) ); // rgb
+  		this.setAttribute( 'instanceColorEnd', new InterleavedBufferAttribute( instanceColorBuffer, 3, 3 ) ); // rgb
+
+  		return this;
+
+  	}
+
+  	fromWireframeGeometry( geometry ) {
+
+  		this.setPositions( geometry.attributes.position.array );
+
+  		return this;
+
+  	}
+
+  	fromEdgesGeometry( geometry ) {
+
+  		this.setPositions( geometry.attributes.position.array );
+
+  		return this;
+
+  	}
+
+  	fromMesh( mesh ) {
+
+  		this.fromWireframeGeometry( new WireframeGeometry( mesh.geometry ) );
+
+  		// set colors, maybe
+
+  		return this;
+
+  	}
+
+  	fromLineSegments( lineSegments ) {
+
+  		const geometry = lineSegments.geometry;
+
+  		this.setPositions( geometry.attributes.position.array ); // assumes non-indexed
+
+  		// set colors, maybe
+
+  		return this;
+
+  	}
+
+  	computeBoundingBox() {
+
+  		if ( this.boundingBox === null ) {
+
+  			this.boundingBox = new Box3();
+
+  		}
+
+  		const start = this.attributes.instanceStart;
+  		const end = this.attributes.instanceEnd;
+
+  		if ( start !== undefined && end !== undefined ) {
+
+  			this.boundingBox.setFromBufferAttribute( start );
+
+  			_box$1.setFromBufferAttribute( end );
+
+  			this.boundingBox.union( _box$1 );
+
+  		}
+
+  	}
+
+  	computeBoundingSphere() {
+
+  		if ( this.boundingSphere === null ) {
+
+  			this.boundingSphere = new Sphere();
+
+  		}
+
+  		if ( this.boundingBox === null ) {
+
+  			this.computeBoundingBox();
+
+  		}
+
+  		const start = this.attributes.instanceStart;
+  		const end = this.attributes.instanceEnd;
+
+  		if ( start !== undefined && end !== undefined ) {
+
+  			const center = this.boundingSphere.center;
+
+  			this.boundingBox.getCenter( center );
+
+  			let maxRadiusSq = 0;
+
+  			for ( let i = 0, il = start.count; i < il; i ++ ) {
+
+  				_vector.fromBufferAttribute( start, i );
+  				maxRadiusSq = Math.max( maxRadiusSq, center.distanceToSquared( _vector ) );
+
+  				_vector.fromBufferAttribute( end, i );
+  				maxRadiusSq = Math.max( maxRadiusSq, center.distanceToSquared( _vector ) );
+
+  			}
+
+  			this.boundingSphere.radius = Math.sqrt( maxRadiusSq );
+
+  			if ( isNaN( this.boundingSphere.radius ) ) {
+
+  				console.error( 'THREE.LineSegmentsGeometry.computeBoundingSphere(): Computed radius is NaN. The instanced position data is likely to have NaN values.', this );
+
+  			}
+
+  		}
+
+  	}
+
+  	toJSON() {
+
+  		// todo
+
+  	}
+
+  	applyMatrix( matrix ) {
+
+  		console.warn( 'THREE.LineSegmentsGeometry: applyMatrix() has been renamed to applyMatrix4().' );
+
+  		return this.applyMatrix4( matrix );
+
+  	}
 
-      return this;
-    }
-    computeBoundingBox() {
-      if (this.boundingBox === null) {
-        this.boundingBox = new THREE$2$1.Box3();
-      }
-      const start = this.attributes.instanceStart;
-      const end = this.attributes.instanceEnd;
-      if (start !== undefined && end !== undefined) {
-        this.boundingBox.setFromBufferAttribute(start);
-        _box$1.setFromBufferAttribute(end);
-        this.boundingBox.union(_box$1);
-      }
-    }
-    computeBoundingSphere() {
-      if (this.boundingSphere === null) {
-        this.boundingSphere = new THREE$2$1.Sphere();
-      }
-      if (this.boundingBox === null) {
-        this.computeBoundingBox();
-      }
-      const start = this.attributes.instanceStart;
-      const end = this.attributes.instanceEnd;
-      if (start !== undefined && end !== undefined) {
-        const center = this.boundingSphere.center;
-        this.boundingBox.getCenter(center);
-        let maxRadiusSq = 0;
-        for (let i = 0, il = start.count; i < il; i++) {
-          _vector.fromBufferAttribute(start, i);
-          maxRadiusSq = Math.max(maxRadiusSq, center.distanceToSquared(_vector));
-          _vector.fromBufferAttribute(end, i);
-          maxRadiusSq = Math.max(maxRadiusSq, center.distanceToSquared(_vector));
-        }
-        this.boundingSphere.radius = Math.sqrt(maxRadiusSq);
-        if (isNaN(this.boundingSphere.radius)) {
-          console.error('THREE.LineSegmentsGeometry.computeBoundingSphere(): Computed radius is NaN. The instanced position data is likely to have NaN values.', this);
-        }
-      }
-    }
-    toJSON() {// todo
-    }
-    applyMatrix(matrix) {
-      console.warn('THREE.LineSegmentsGeometry: applyMatrix() has been renamed to applyMatrix4().');
-      return this.applyMatrix4(matrix);
-    }
   }
-  LineSegmentsGeometry.prototype.isLineSegmentsGeometry = true;
 
-  /**
-   * parameters = {
-   *  color: <hex>,
-   *  linewidth: <float>,
-   *  dashed: <boolean>,
-   *  dashScale: <float>,
-   *  dashSize: <float>,
-   *  dashOffset: <float>,
-   *  gapSize: <float>,
-   *  resolution: <Vector2>, // to be set by renderer
-   * }
-   */
+  UniformsLib.line = {
+
+  	worldUnits: { value: 1 },
+  	linewidth: { value: 1 },
+  	resolution: { value: new Vector2( 1, 1 ) },
+  	dashOffset: { value: 0 },
+  	dashScale: { value: 1 },
+  	dashSize: { value: 1 },
+  	gapSize: { value: 1 } // todo FIX - maybe change to totalSize
 
-  const THREE$1$1 = window.THREE ? window.THREE // Prefer consumption from global THREE, if exists
-  : {
-    ShaderLib,
-    ShaderMaterial,
-    UniformsLib,
-    UniformsUtils,
-    Vector2
-  };
-  THREE$1$1.UniformsLib.line = {
-    worldUnits: {
-      value: 1
-    },
-    linewidth: {
-      value: 1
-    },
-    resolution: {
-      value: new THREE$1$1.Vector2(1, 1)
-    },
-    dashScale: {
-      value: 1
-    },
-    dashSize: {
-      value: 1
-    },
-    dashOffset: {
-      value: 0
-    },
-    gapSize: {
-      value: 1
-    } // todo FIX - maybe change to totalSize
   };
-  THREE$1$1.ShaderLib['line'] = {
-    uniforms: THREE$1$1.UniformsUtils.merge([THREE$1$1.UniformsLib.common, THREE$1$1.UniformsLib.fog, THREE$1$1.UniformsLib.line]),
-    vertexShader: /* glsl */
-    `
+
+  ShaderLib[ 'line' ] = {
+
+  	uniforms: UniformsUtils.merge( [
+  		UniformsLib.common,
+  		UniformsLib.fog,
+  		UniformsLib.line
+  	] ),
+
+  	vertexShader:
+  	/* glsl */`
 		#include <common>
 		#include <color_pars_vertex>
 		#include <fog_pars_vertex>
@@ -66133,10 +66196,23 @@ void main() {
 		attribute vec3 instanceColorStart;
 		attribute vec3 instanceColorEnd;
 
-		varying vec2 vUv;
-		varying vec4 worldPos;
-		varying vec3 worldStart;
-		varying vec3 worldEnd;
+		#ifdef WORLD_UNITS
+
+			varying vec4 worldPos;
+			varying vec3 worldStart;
+			varying vec3 worldEnd;
+
+			#ifdef USE_DASH
+
+				varying vec2 vUv;
+
+			#endif
+
+		#else
+
+			varying vec2 vUv;
+
+		#endif
 
 		#ifdef USE_DASH
 
@@ -66173,19 +66249,26 @@ void main() {
 			#ifdef USE_DASH
 
 				vLineDistance = ( position.y < 0.5 ) ? dashScale * instanceDistanceStart : dashScale * instanceDistanceEnd;
+				vUv = uv;
 
 			#endif
 
 			float aspect = resolution.x / resolution.y;
 
-			vUv = uv;
-
 			// camera space
 			vec4 start = modelViewMatrix * vec4( instanceStart, 1.0 );
 			vec4 end = modelViewMatrix * vec4( instanceEnd, 1.0 );
 
-			worldStart = start.xyz;
-			worldEnd = end.xyz;
+			#ifdef WORLD_UNITS
+
+				worldStart = start.xyz;
+				worldEnd = end.xyz;
+
+			#else
+
+				vUv = uv;
+
+			#endif
 
 			// special case for perspective projection, and segments that terminate either in, or behind, the camera plane
 			// clearly the gpu firmware has a way of addressing this issue when projecting into ndc space
@@ -66225,94 +66308,77 @@ void main() {
 
 			#ifdef WORLD_UNITS
 
-				// get the offset direction as perpendicular to the view vector
 				vec3 worldDir = normalize( end.xyz - start.xyz );
-				vec3 offset;
-				if ( position.y < 0.5 ) {
-
-					offset = normalize( cross( start.xyz, worldDir ) );
-
-				} else {
-
-					offset = normalize( cross( end.xyz, worldDir ) );
-
-				}
-
-				// sign flip
-				if ( position.x < 0.0 ) offset *= - 1.0;
+				vec3 tmpFwd = normalize( mix( start.xyz, end.xyz, 0.5 ) );
+				vec3 worldUp = normalize( cross( worldDir, tmpFwd ) );
+				vec3 worldFwd = cross( worldDir, worldUp );
+				worldPos = position.y < 0.5 ? start: end;
 
-				float forwardOffset = dot( worldDir, vec3( 0.0, 0.0, 1.0 ) );
+				// height offset
+				float hw = linewidth * 0.5;
+				worldPos.xyz += position.x < 0.0 ? hw * worldUp : - hw * worldUp;
 
 				// don't extend the line if we're rendering dashes because we
 				// won't be rendering the endcaps
 				#ifndef USE_DASH
 
-					// extend the line bounds to encompass  endcaps
-					start.xyz += - worldDir * linewidth * 0.5;
-					end.xyz += worldDir * linewidth * 0.5;
-
-					// shift the position of the quad so it hugs the forward edge of the line
-					offset.xy -= dir * forwardOffset;
-					offset.z += 0.5;
-
-				#endif
+					// cap extension
+					worldPos.xyz += position.y < 0.5 ? - hw * worldDir : hw * worldDir;
 
-				// endcaps
-				if ( position.y > 1.0 || position.y < 0.0 ) {
+					// add width to the box
+					worldPos.xyz += worldFwd * hw;
 
-					offset.xy += dir * 2.0 * forwardOffset;
+					// endcaps
+					if ( position.y > 1.0 || position.y < 0.0 ) {
 
-				}
+						worldPos.xyz -= worldFwd * 2.0 * hw;
 
-				// adjust for linewidth
-				offset *= linewidth * 0.5;
+					}
 
-				// set the world position
-				worldPos = ( position.y < 0.5 ) ? start : end;
-				worldPos.xyz += offset;
+				#endif
 
 				// project the worldpos
 				vec4 clip = projectionMatrix * worldPos;
 
 				// shift the depth of the projected points so the line
-				// segements overlap neatly
+				// segments overlap neatly
 				vec3 clipPose = ( position.y < 0.5 ) ? ndcStart : ndcEnd;
 				clip.z = clipPose.z * clip.w;
 
 			#else
 
-			vec2 offset = vec2( dir.y, - dir.x );
-			// undo aspect ratio adjustment
-			dir.x /= aspect;
-			offset.x /= aspect;
+				vec2 offset = vec2( dir.y, - dir.x );
+				// undo aspect ratio adjustment
+				dir.x /= aspect;
+				offset.x /= aspect;
 
-			// sign flip
-			if ( position.x < 0.0 ) offset *= - 1.0;
+				// sign flip
+				if ( position.x < 0.0 ) offset *= - 1.0;
 
-			// endcaps
-			if ( position.y < 0.0 ) {
+				// endcaps
+				if ( position.y < 0.0 ) {
 
-				offset += - dir;
+					offset += - dir;
 
-			} else if ( position.y > 1.0 ) {
+				} else if ( position.y > 1.0 ) {
 
-				offset += dir;
+					offset += dir;
 
-			}
+				}
 
-			// adjust for linewidth
-			offset *= linewidth;
+				// adjust for linewidth
+				offset *= linewidth;
 
-			// adjust for clip-space to screen-space conversion // maybe resolution should be based on viewport ...
-			offset /= resolution.y;
+				// adjust for clip-space to screen-space conversion // maybe resolution should be based on viewport ...
+				offset /= resolution.y;
 
-			// select end
-			vec4 clip = ( position.y < 0.5 ) ? clipStart : clipEnd;
+				// select end
+				vec4 clip = ( position.y < 0.5 ) ? clipStart : clipEnd;
 
-			// back to clip space
-			offset *= clip.w;
+				// back to clip space
+				offset *= clip.w;
 
-			clip.xy += offset;
+				clip.xy += offset;
 
 			#endif
 
@@ -66326,8 +66392,9 @@ void main() {
 
 		}
 		`,
-    fragmentShader: /* glsl */
-    `
+
+  	fragmentShader:
+  	/* glsl */`
 		uniform vec3 diffuse;
 		uniform float opacity;
 		uniform float linewidth;
@@ -66341,9 +66408,24 @@ void main() {
 		#endif
 
 		varying float vLineDistance;
-		varying vec4 worldPos;
-		varying vec3 worldStart;
-		varying vec3 worldEnd;
+
+		#ifdef WORLD_UNITS
+
+			varying vec4 worldPos;
+			varying vec3 worldStart;
+			varying vec3 worldEnd;
+
+			#ifdef USE_DASH
+
+				varying vec2 vUv;
+
+			#endif
+
+		#else
+
+			varying vec2 vUv;
+
+		#endif
 
 		#include <common>
 		#include <color_pars_fragment>
@@ -66351,8 +66433,6 @@ void main() {
 		#include <logdepthbuf_pars_fragment>
 		#include <clipping_planes_pars_fragment>
 
-		varying vec2 vUv;
-
 		vec2 closestLineToLine(vec3 p1, vec3 p2, vec3 p3, vec3 p4) {
 
 			float mua;
@@ -66411,7 +66491,7 @@ void main() {
 
 				#ifndef USE_DASH
 
-					#ifdef ALPHA_TO_COVERAGE
+					#ifdef USE_ALPHA_TO_COVERAGE
 
 						float dnorm = fwidth( norm );
 						alpha = 1.0 - smoothstep( 0.5 - dnorm, 0.5 + dnorm, norm );
@@ -66426,11 +66506,11 @@ void main() {
 
 					#endif
 
-			#endif
+				#endif
 
 			#else
 
-				#ifdef ALPHA_TO_COVERAGE
+				#ifdef USE_ALPHA_TO_COVERAGE
 
 					// artifacts appear on some hardware if a derivative is taken within a conditional
 					float a = vUv.x;
@@ -66446,15 +66526,15 @@ void main() {
 
 				#else
 
-			if ( abs( vUv.y ) > 1.0 ) {
+					if ( abs( vUv.y ) > 1.0 ) {
 
-				float a = vUv.x;
-				float b = ( vUv.y > 0.0 ) ? vUv.y - 1.0 : vUv.y + 1.0;
-				float len2 = a * a + b * b;
+						float a = vUv.x;
+						float b = ( vUv.y > 0.0 ) ? vUv.y - 1.0 : vUv.y + 1.0;
+						float len2 = a * a + b * b;
 
-				if ( len2 > 1.0 ) discard;
+						if ( len2 > 1.0 ) discard;
 
-			}
+					}
 
 				#endif
 
@@ -66475,400 +66555,653 @@ void main() {
 		}
 		`
   };
-  class LineMaterial extends THREE$1$1.ShaderMaterial {
-    constructor(parameters) {
-      super({
-        type: 'LineMaterial',
-        uniforms: THREE$1$1.UniformsUtils.clone(THREE$1$1.ShaderLib['line'].uniforms),
-        vertexShader: THREE$1$1.ShaderLib['line'].vertexShader,
-        fragmentShader: THREE$1$1.ShaderLib['line'].fragmentShader,
-        clipping: true // required for clipping support
-      });
-      Object.defineProperties(this, {
-        color: {
-          enumerable: true,
-          get: function () {
-            return this.uniforms.diffuse.value;
-          },
-          set: function (value) {
-            this.uniforms.diffuse.value = value;
-          }
-        },
-        worldUnits: {
-          enumerable: true,
-          get: function () {
-            return 'WORLD_UNITS' in this.defines;
-          },
-          set: function (value) {
-            if (value === true) {
-              this.defines.WORLD_UNITS = '';
-            } else {
-              delete this.defines.WORLD_UNITS;
-            }
-          }
-        },
-        linewidth: {
-          enumerable: true,
-          get: function () {
-            return this.uniforms.linewidth.value;
-          },
-          set: function (value) {
-            this.uniforms.linewidth.value = value;
-          }
-        },
-        dashed: {
-          enumerable: true,
-          get: function () {
-            return Boolean('USE_DASH' in this.defines);
-          },
-          set(value) {
-            if (Boolean(value) !== Boolean('USE_DASH' in this.defines)) {
-              this.needsUpdate = true;
-            }
-            if (value === true) {
-              this.defines.USE_DASH = '';
-            } else {
-              delete this.defines.USE_DASH;
-            }
-          }
-        },
-        dashScale: {
-          enumerable: true,
-          get: function () {
-            return this.uniforms.dashScale.value;
-          },
-          set: function (value) {
-            this.uniforms.dashScale.value = value;
-          }
-        },
-        dashSize: {
-          enumerable: true,
-          get: function () {
-            return this.uniforms.dashSize.value;
-          },
-          set: function (value) {
-            this.uniforms.dashSize.value = value;
-          }
-        },
-        dashOffset: {
-          enumerable: true,
-          get: function () {
-            return this.uniforms.dashOffset.value;
-          },
-          set: function (value) {
-            this.uniforms.dashOffset.value = value;
-          }
-        },
-        gapSize: {
-          enumerable: true,
-          get: function () {
-            return this.uniforms.gapSize.value;
-          },
-          set: function (value) {
-            this.uniforms.gapSize.value = value;
-          }
-        },
-        opacity: {
-          enumerable: true,
-          get: function () {
-            return this.uniforms.opacity.value;
-          },
-          set: function (value) {
-            this.uniforms.opacity.value = value;
-          }
-        },
-        resolution: {
-          enumerable: true,
-          get: function () {
-            return this.uniforms.resolution.value;
-          },
-          set: function (value) {
-            this.uniforms.resolution.value.copy(value);
-          }
-        },
-        alphaToCoverage: {
-          enumerable: true,
-          get: function () {
-            return Boolean('ALPHA_TO_COVERAGE' in this.defines);
-          },
-          set: function (value) {
-            if (Boolean(value) !== Boolean('ALPHA_TO_COVERAGE' in this.defines)) {
-              this.needsUpdate = true;
-            }
-            if (value === true) {
-              this.defines.ALPHA_TO_COVERAGE = '';
-              this.extensions.derivatives = true;
-            } else {
-              delete this.defines.ALPHA_TO_COVERAGE;
-              this.extensions.derivatives = false;
-            }
-          }
-        }
-      });
-      this.setValues(parameters);
-    }
+
+  class LineMaterial extends ShaderMaterial {
+
+  	constructor( parameters ) {
+
+  		super( {
+
+  			type: 'LineMaterial',
+
+  			uniforms: UniformsUtils.clone( ShaderLib[ 'line' ].uniforms ),
+
+  			vertexShader: ShaderLib[ 'line' ].vertexShader,
+  			fragmentShader: ShaderLib[ 'line' ].fragmentShader,
+
+  			clipping: true // required for clipping support
+
+  		} );
+
+  		this.isLineMaterial = true;
+
+  		this.setValues( parameters );
+
+  	}
+
+  	get color() {
+
+  		return this.uniforms.diffuse.value;
+
+  	}
+
+  	set color( value ) {
+
+  		this.uniforms.diffuse.value = value;
+
+  	}
+
+  	get worldUnits() {
+
+  		return 'WORLD_UNITS' in this.defines;
+
+  	}
+
+  	set worldUnits( value ) {
+
+  		if ( value === true ) {
+
+  			this.defines.WORLD_UNITS = '';
+
+  		} else {
+
+  			delete this.defines.WORLD_UNITS;
+
+  		}
+
+  	}
+
+  	get linewidth() {
+
+  		return this.uniforms.linewidth.value;
+
+  	}
+
+  	set linewidth( value ) {
+
+  		if ( ! this.uniforms.linewidth ) return;
+  		this.uniforms.linewidth.value = value;
+
+  	}
+
+  	get dashed() {
+
+  		return 'USE_DASH' in this.defines;
+
+  	}
+
+  	set dashed( value ) {
+
+  		if ( ( value === true ) !== this.dashed ) {
+
+  			this.needsUpdate = true;
+
+  		}
+
+  		if ( value === true ) {
+
+  			this.defines.USE_DASH = '';
+
+  		} else {
+
+  			delete this.defines.USE_DASH;
+
+  		}
+
+  	}
+
+  	get dashScale() {
+
+  		return this.uniforms.dashScale.value;
+
+  	}
+
+  	set dashScale( value ) {
+
+  		this.uniforms.dashScale.value = value;
+
+  	}
+
+  	get dashSize() {
+
+  		return this.uniforms.dashSize.value;
+
+  	}
+
+  	set dashSize( value ) {
+
+  		this.uniforms.dashSize.value = value;
+
+  	}
+
+  	get dashOffset() {
+
+  		return this.uniforms.dashOffset.value;
+
+  	}
+
+  	set dashOffset( value ) {
+
+  		this.uniforms.dashOffset.value = value;
+
+  	}
+
+  	get gapSize() {
+
+  		return this.uniforms.gapSize.value;
+
+  	}
+
+  	set gapSize( value ) {
+
+  		this.uniforms.gapSize.value = value;
+
+  	}
+
+  	get opacity() {
+
+  		return this.uniforms.opacity.value;
+
+  	}
+
+  	set opacity( value ) {
+
+  		if ( ! this.uniforms ) return;
+  		this.uniforms.opacity.value = value;
+
+  	}
+
+  	get resolution() {
+
+  		return this.uniforms.resolution.value;
+
+  	}
+
+  	set resolution( value ) {
+
+  		this.uniforms.resolution.value.copy( value );
+
+  	}
+
+  	get alphaToCoverage() {
+
+  		return 'USE_ALPHA_TO_COVERAGE' in this.defines;
+
+  	}
+
+  	set alphaToCoverage( value ) {
+
+  		if ( ! this.defines ) return;
+
+  		if ( ( value === true ) !== this.alphaToCoverage ) {
+
+  			this.needsUpdate = true;
+
+  		}
+
+  		if ( value === true ) {
+
+  			this.defines.USE_ALPHA_TO_COVERAGE = '';
+
+  		} else {
+
+  			delete this.defines.USE_ALPHA_TO_COVERAGE;
+
+  		}
+
+  	}
+
   }
-  LineMaterial.prototype.isLineMaterial = true;
 
-  const THREE$j = window.THREE ? window.THREE // Prefer consumption from global THREE, if exists
-  : {
-    Box3,
-    BufferGeometry,
-    InstancedInterleavedBuffer,
-    InterleavedBufferAttribute,
-    Line3,
-    MathUtils,
-    Matrix4,
-    Mesh,
-    Sphere,
-    Vector3,
-    Vector4
-  };
+  const _viewport = new Vector4();
 
-  // support both modes for backwards threejs compatibility
-  var setAttributeFn = new THREE$j.BufferGeometry().setAttribute ? 'setAttribute' : 'addAttribute';
-  const _start = new THREE$j.Vector3();
-  const _end = new THREE$j.Vector3();
-  const _start4 = new THREE$j.Vector4();
-  const _end4 = new THREE$j.Vector4();
-  const _ssOrigin = new THREE$j.Vector4();
-  const _ssOrigin3 = new THREE$j.Vector3();
-  const _mvMatrix = new THREE$j.Matrix4();
-  const _line = new THREE$j.Line3();
-  const _closestPoint = new THREE$j.Vector3();
-  const _box = new THREE$j.Box3();
-  const _sphere = new THREE$j.Sphere();
-  const _clipToWorldVector = new THREE$j.Vector4();
-  class LineSegments2 extends THREE$j.Mesh {
-    constructor(geometry = new LineSegmentsGeometry(), material = new LineMaterial({
-      color: Math.random() * 0xffffff
-    })) {
-      super(geometry, material);
-      this.type = 'LineSegments2';
-    } // for backwards-compatability, but could be a method of LineSegmentsGeometry...
-
-    computeLineDistances() {
-      const geometry = this.geometry;
-      const instanceStart = geometry.attributes.instanceStart;
-      const instanceEnd = geometry.attributes.instanceEnd;
-      const lineDistances = new Float32Array(2 * instanceStart.count);
-      for (let i = 0, j = 0, l = instanceStart.count; i < l; i++, j += 2) {
-        _start.fromBufferAttribute(instanceStart, i);
-        _end.fromBufferAttribute(instanceEnd, i);
-        lineDistances[j] = j === 0 ? 0 : lineDistances[j - 1];
-        lineDistances[j + 1] = lineDistances[j] + _start.distanceTo(_end);
-      }
-      const instanceDistanceBuffer = new THREE$j.InstancedInterleavedBuffer(lineDistances, 2, 1); // d0, d1
+  const _start = new Vector3();
+  const _end = new Vector3();
 
-      geometry[setAttributeFn]('instanceDistanceStart', new THREE$j.InterleavedBufferAttribute(instanceDistanceBuffer, 1, 0)); // d0
+  const _start4 = new Vector4();
+  const _end4 = new Vector4();
 
-      geometry[setAttributeFn]('instanceDistanceEnd', new THREE$j.InterleavedBufferAttribute(instanceDistanceBuffer, 1, 1)); // d1
+  const _ssOrigin = new Vector4();
+  const _ssOrigin3 = new Vector3();
+  const _mvMatrix = new Matrix4();
+  const _line = new Line3();
+  const _closestPoint = new Vector3();
 
-      return this;
-    }
-    raycast(raycaster, intersects) {
-      if (raycaster.camera === null) {
-        console.error('LineSegments2: "Raycaster.camera" needs to be set in order to raycast against LineSegments2.');
-      }
-      const threshold = raycaster.params.Line2 !== undefined ? raycaster.params.Line2.threshold || 0 : 0;
-      const ray = raycaster.ray;
-      const camera = raycaster.camera;
-      const projectionMatrix = camera.projectionMatrix;
-      const matrixWorld = this.matrixWorld;
-      const geometry = this.geometry;
-      const material = this.material;
-      const resolution = material.resolution;
-      const lineWidth = material.linewidth + threshold;
-      const instanceStart = geometry.attributes.instanceStart;
-      const instanceEnd = geometry.attributes.instanceEnd; // camera forward is negative
-
-      const near = -camera.near; // clip space is [ - 1, 1 ] so multiply by two to get the full
-      // width in clip space
-
-      const ssMaxWidth = 2.0 * Math.max(lineWidth / resolution.width, lineWidth / resolution.height); //
-      // check if we intersect the sphere bounds
-
-      if (geometry.boundingSphere === null) {
-        geometry.computeBoundingSphere();
-      }
-      _sphere.copy(geometry.boundingSphere).applyMatrix4(matrixWorld);
-      const distanceToSphere = Math.max(camera.near, _sphere.distanceToPoint(ray.origin)); // get the w component to scale the world space line width
+  const _box = new Box3();
+  const _sphere = new Sphere();
+  const _clipToWorldVector = new Vector4();
 
-      _clipToWorldVector.set(0, 0, -distanceToSphere, 1.0).applyMatrix4(camera.projectionMatrix);
-      _clipToWorldVector.multiplyScalar(1.0 / _clipToWorldVector.w);
-      _clipToWorldVector.applyMatrix4(camera.projectionMatrixInverse); // increase the sphere bounds by the worst case line screen space width
+  let _ray$1, _lineWidth;
 
-      const sphereMargin = Math.abs(ssMaxWidth / _clipToWorldVector.w) * 0.5;
-      _sphere.radius += sphereMargin;
-      if (raycaster.ray.intersectsSphere(_sphere) === false) {
-        return;
-      } //
-      // check if we intersect the box bounds
+  // Returns the margin required to expand by in world space given the distance from the camera,
+  // line width, resolution, and camera projection
+  function getWorldSpaceHalfWidth( camera, distance, resolution ) {
+
+  	// transform into clip space, adjust the x and y values by the pixel width offset, then
+  	// transform back into world space to get world offset. Note clip space is [-1, 1] so full
+  	// width does not need to be halved.
+  	_clipToWorldVector.set( 0, 0, - distance, 1.0 ).applyMatrix4( camera.projectionMatrix );
+  	_clipToWorldVector.multiplyScalar( 1.0 / _clipToWorldVector.w );
+  	_clipToWorldVector.x = _lineWidth / resolution.width;
+  	_clipToWorldVector.y = _lineWidth / resolution.height;
+  	_clipToWorldVector.applyMatrix4( camera.projectionMatrixInverse );
+  	_clipToWorldVector.multiplyScalar( 1.0 / _clipToWorldVector.w );
+
+  	return Math.abs( Math.max( _clipToWorldVector.x, _clipToWorldVector.y ) );
+
+  }
+
+  function raycastWorldUnits( lineSegments, intersects ) {
+
+  	const matrixWorld = lineSegments.matrixWorld;
+  	const geometry = lineSegments.geometry;
+  	const instanceStart = geometry.attributes.instanceStart;
+  	const instanceEnd = geometry.attributes.instanceEnd;
+  	const segmentCount = Math.min( geometry.instanceCount, instanceStart.count );
+
+  	for ( let i = 0, l = segmentCount; i < l; i ++ ) {
+
+  		_line.start.fromBufferAttribute( instanceStart, i );
+  		_line.end.fromBufferAttribute( instanceEnd, i );
+
+  		_line.applyMatrix4( matrixWorld );
+
+  		const pointOnLine = new Vector3();
+  		const point = new Vector3();
+
+  		_ray$1.distanceSqToSegment( _line.start, _line.end, point, pointOnLine );
+  		const isInside = point.distanceTo( pointOnLine ) < _lineWidth * 0.5;
+
+  		if ( isInside ) {
+
+  			intersects.push( {
+  				point,
+  				pointOnLine,
+  				distance: _ray$1.origin.distanceTo( point ),
+  				object: lineSegments,
+  				face: null,
+  				faceIndex: i,
+  				uv: null,
+  				uv1: null,
+  			} );
+
+  		}
+
+  	}
+
+  }
+
+  function raycastScreenSpace( lineSegments, camera, intersects ) {
+
+  	const projectionMatrix = camera.projectionMatrix;
+  	const material = lineSegments.material;
+  	const resolution = material.resolution;
+  	const matrixWorld = lineSegments.matrixWorld;
+
+  	const geometry = lineSegments.geometry;
+  	const instanceStart = geometry.attributes.instanceStart;
+  	const instanceEnd = geometry.attributes.instanceEnd;
+  	const segmentCount = Math.min( geometry.instanceCount, instanceStart.count );
+
+  	const near = - camera.near;
+
+  	//
+
+  	// pick a point 1 unit out along the ray to avoid the ray origin
+  	// sitting at the camera origin which will cause "w" to be 0 when
+  	// applying the projection matrix.
+  	_ray$1.at( 1, _ssOrigin );
+
+  	// ndc space [ - 1.0, 1.0 ]
+  	_ssOrigin.w = 1;
+  	_ssOrigin.applyMatrix4( camera.matrixWorldInverse );
+  	_ssOrigin.applyMatrix4( projectionMatrix );
+  	_ssOrigin.multiplyScalar( 1 / _ssOrigin.w );
+
+  	// screen space
+  	_ssOrigin.x *= resolution.x / 2;
+  	_ssOrigin.y *= resolution.y / 2;
+  	_ssOrigin.z = 0;
+
+  	_ssOrigin3.copy( _ssOrigin );
+
+  	_mvMatrix.multiplyMatrices( camera.matrixWorldInverse, matrixWorld );
+
+  	for ( let i = 0, l = segmentCount; i < l; i ++ ) {
+
+  		_start4.fromBufferAttribute( instanceStart, i );
+  		_end4.fromBufferAttribute( instanceEnd, i );
+
+  		_start4.w = 1;
+  		_end4.w = 1;
+
+  		// camera space
+  		_start4.applyMatrix4( _mvMatrix );
+  		_end4.applyMatrix4( _mvMatrix );
+
+  		// skip the segment if it's entirely behind the camera
+  		const isBehindCameraNear = _start4.z > near && _end4.z > near;
+  		if ( isBehindCameraNear ) {
+
+  			continue;
+
+  		}
+
+  		// trim the segment if it extends behind camera near
+  		if ( _start4.z > near ) {
+
+  			const deltaDist = _start4.z - _end4.z;
+  			const t = ( _start4.z - near ) / deltaDist;
+  			_start4.lerp( _end4, t );
+
+  		} else if ( _end4.z > near ) {
+
+  			const deltaDist = _end4.z - _start4.z;
+  			const t = ( _end4.z - near ) / deltaDist;
+  			_end4.lerp( _start4, t );
+
+  		}
+
+  		// clip space
+  		_start4.applyMatrix4( projectionMatrix );
+  		_end4.applyMatrix4( projectionMatrix );
+
+  		// ndc space [ - 1.0, 1.0 ]
+  		_start4.multiplyScalar( 1 / _start4.w );
+  		_end4.multiplyScalar( 1 / _end4.w );
+
+  		// screen space
+  		_start4.x *= resolution.x / 2;
+  		_start4.y *= resolution.y / 2;
+
+  		_end4.x *= resolution.x / 2;
+  		_end4.y *= resolution.y / 2;
+
+  		// create 2d segment
+  		_line.start.copy( _start4 );
+  		_line.start.z = 0;
+
+  		_line.end.copy( _end4 );
+  		_line.end.z = 0;
+
+  		// get closest point on ray to segment
+  		const param = _line.closestPointToPointParameter( _ssOrigin3, true );
+  		_line.at( param, _closestPoint );
+
+  		// check if the intersection point is within clip space
+  		const zPos = MathUtils.lerp( _start4.z, _end4.z, param );
+  		const isInClipSpace = zPos >= - 1 && zPos <= 1;
+
+  		const isInside = _ssOrigin3.distanceTo( _closestPoint ) < _lineWidth * 0.5;
+
+  		if ( isInClipSpace && isInside ) {
+
+  			_line.start.fromBufferAttribute( instanceStart, i );
+  			_line.end.fromBufferAttribute( instanceEnd, i );
+
+  			_line.start.applyMatrix4( matrixWorld );
+  			_line.end.applyMatrix4( matrixWorld );
+
+  			const pointOnLine = new Vector3();
+  			const point = new Vector3();
+
+  			_ray$1.distanceSqToSegment( _line.start, _line.end, point, pointOnLine );
+
+  			intersects.push( {
+  				point: point,
+  				pointOnLine: pointOnLine,
+  				distance: _ray$1.origin.distanceTo( point ),
+  				object: lineSegments,
+  				face: null,
+  				faceIndex: i,
+  				uv: null,
+  				uv1: null,
+  			} );
+
+  		}
+
+  	}
+
+  }
+
+  class LineSegments2 extends Mesh {
+
+  	constructor( geometry = new LineSegmentsGeometry(), material = new LineMaterial( { color: Math.random() * 0xffffff } ) ) {
+
+  		super( geometry, material );
+
+  		this.isLineSegments2 = true;
+
+  		this.type = 'LineSegments2';
+
+  	}
+
+  	// for backwards-compatibility, but could be a method of LineSegmentsGeometry...
+
+  	computeLineDistances() {
+
+  		const geometry = this.geometry;
+
+  		const instanceStart = geometry.attributes.instanceStart;
+  		const instanceEnd = geometry.attributes.instanceEnd;
+  		const lineDistances = new Float32Array( 2 * instanceStart.count );
+
+  		for ( let i = 0, j = 0, l = instanceStart.count; i < l; i ++, j += 2 ) {
+
+  			_start.fromBufferAttribute( instanceStart, i );
+  			_end.fromBufferAttribute( instanceEnd, i );
+
+  			lineDistances[ j ] = ( j === 0 ) ? 0 : lineDistances[ j - 1 ];
+  			lineDistances[ j + 1 ] = lineDistances[ j ] + _start.distanceTo( _end );
+
+  		}
+
+  		const instanceDistanceBuffer = new InstancedInterleavedBuffer( lineDistances, 2, 1 ); // d0, d1
+
+  		geometry.setAttribute( 'instanceDistanceStart', new InterleavedBufferAttribute( instanceDistanceBuffer, 1, 0 ) ); // d0
+  		geometry.setAttribute( 'instanceDistanceEnd', new InterleavedBufferAttribute( instanceDistanceBuffer, 1, 1 ) ); // d1
+
+  		return this;
+
+  	}
+
+  	raycast( raycaster, intersects ) {
+
+  		const worldUnits = this.material.worldUnits;
+  		const camera = raycaster.camera;
+
+  		if ( camera === null && ! worldUnits ) {
+
+  			console.error( 'LineSegments2: "Raycaster.camera" needs to be set in order to raycast against LineSegments2 while worldUnits is set to false.' );
+
+  		}
+
+  		const threshold = ( raycaster.params.Line2 !== undefined ) ? raycaster.params.Line2.threshold || 0 : 0;
+
+  		_ray$1 = raycaster.ray;
+
+  		const matrixWorld = this.matrixWorld;
+  		const geometry = this.geometry;
+  		const material = this.material;
+
+  		_lineWidth = material.linewidth + threshold;
+
+  		// check if we intersect the sphere bounds
+  		if ( geometry.boundingSphere === null ) {
+
+  			geometry.computeBoundingSphere();
+
+  		}
+
+  		_sphere.copy( geometry.boundingSphere ).applyMatrix4( matrixWorld );
+
+  		// increase the sphere bounds by the worst case line screen space width
+  		let sphereMargin;
+  		if ( worldUnits ) {
+
+  			sphereMargin = _lineWidth * 0.5;
+
+  		} else {
+
+  			const distanceToSphere = Math.max( camera.near, _sphere.distanceToPoint( _ray$1.origin ) );
+  			sphereMargin = getWorldSpaceHalfWidth( camera, distanceToSphere, material.resolution );
+
+  		}
+
+  		_sphere.radius += sphereMargin;
+
+  		if ( _ray$1.intersectsSphere( _sphere ) === false ) {
+
+  			return;
+
+  		}
+
+  		// check if we intersect the box bounds
+  		if ( geometry.boundingBox === null ) {
+
+  			geometry.computeBoundingBox();
+
+  		}
+
+  		_box.copy( geometry.boundingBox ).applyMatrix4( matrixWorld );
+
+  		// increase the box bounds by the worst case line width
+  		let boxMargin;
+  		if ( worldUnits ) {
+
+  			boxMargin = _lineWidth * 0.5;
+
+  		} else {
+
+  			const distanceToBox = Math.max( camera.near, _box.distanceToPoint( _ray$1.origin ) );
+  			boxMargin = getWorldSpaceHalfWidth( camera, distanceToBox, material.resolution );
+
+  		}
+
+  		_box.expandByScalar( boxMargin );
+
+  		if ( _ray$1.intersectsBox( _box ) === false ) {
+
+  			return;
+
+  		}
+
+  		if ( worldUnits ) {
+
+  			raycastWorldUnits( this, intersects );
+
+  		} else {
+
+  			raycastScreenSpace( this, camera, intersects );
+
+  		}
+
+  	}
+
+  	onBeforeRender( renderer ) {
+
+  		const uniforms = this.material.uniforms;
+
+  		if ( uniforms && uniforms.resolution ) {
+
+  			renderer.getViewport( _viewport );
+  			this.material.uniforms.resolution.value.set( _viewport.z, _viewport.w );
+
+  		}
+
+  	}
 
-      if (geometry.boundingBox === null) {
-        geometry.computeBoundingBox();
-      }
-      _box.copy(geometry.boundingBox).applyMatrix4(matrixWorld);
-      const distanceToBox = Math.max(camera.near, _box.distanceToPoint(ray.origin)); // get the w component to scale the world space line width
-
-      _clipToWorldVector.set(0, 0, -distanceToBox, 1.0).applyMatrix4(camera.projectionMatrix);
-      _clipToWorldVector.multiplyScalar(1.0 / _clipToWorldVector.w);
-      _clipToWorldVector.applyMatrix4(camera.projectionMatrixInverse); // increase the sphere bounds by the worst case line screen space width
-
-      const boxMargin = Math.abs(ssMaxWidth / _clipToWorldVector.w) * 0.5;
-      _box.max.x += boxMargin;
-      _box.max.y += boxMargin;
-      _box.max.z += boxMargin;
-      _box.min.x -= boxMargin;
-      _box.min.y -= boxMargin;
-      _box.min.z -= boxMargin;
-      if (raycaster.ray.intersectsBox(_box) === false) {
-        return;
-      } //
-      // pick a point 1 unit out along the ray to avoid the ray origin
-      // sitting at the camera origin which will cause "w" to be 0 when
-      // applying the projection matrix.
-
-      ray.at(1, _ssOrigin); // ndc space [ - 1.0, 1.0 ]
-
-      _ssOrigin.w = 1;
-      _ssOrigin.applyMatrix4(camera.matrixWorldInverse);
-      _ssOrigin.applyMatrix4(projectionMatrix);
-      _ssOrigin.multiplyScalar(1 / _ssOrigin.w); // screen space
-
-      _ssOrigin.x *= resolution.x / 2;
-      _ssOrigin.y *= resolution.y / 2;
-      _ssOrigin.z = 0;
-      _ssOrigin3.copy(_ssOrigin);
-      _mvMatrix.multiplyMatrices(camera.matrixWorldInverse, matrixWorld);
-      for (let i = 0, l = instanceStart.count; i < l; i++) {
-        _start4.fromBufferAttribute(instanceStart, i);
-        _end4.fromBufferAttribute(instanceEnd, i);
-        _start4.w = 1;
-        _end4.w = 1; // camera space
-
-        _start4.applyMatrix4(_mvMatrix);
-        _end4.applyMatrix4(_mvMatrix); // skip the segment if it's entirely behind the camera
-
-        var isBehindCameraNear = _start4.z > near && _end4.z > near;
-        if (isBehindCameraNear) {
-          continue;
-        } // trim the segment if it extends behind camera near
-
-        if (_start4.z > near) {
-          const deltaDist = _start4.z - _end4.z;
-          const t = (_start4.z - near) / deltaDist;
-          _start4.lerp(_end4, t);
-        } else if (_end4.z > near) {
-          const deltaDist = _end4.z - _start4.z;
-          const t = (_end4.z - near) / deltaDist;
-          _end4.lerp(_start4, t);
-        } // clip space
-
-        _start4.applyMatrix4(projectionMatrix);
-        _end4.applyMatrix4(projectionMatrix); // ndc space [ - 1.0, 1.0 ]
-
-        _start4.multiplyScalar(1 / _start4.w);
-        _end4.multiplyScalar(1 / _end4.w); // screen space
-
-        _start4.x *= resolution.x / 2;
-        _start4.y *= resolution.y / 2;
-        _end4.x *= resolution.x / 2;
-        _end4.y *= resolution.y / 2; // create 2d segment
-
-        _line.start.copy(_start4);
-        _line.start.z = 0;
-        _line.end.copy(_end4);
-        _line.end.z = 0; // get closest point on ray to segment
-
-        const param = _line.closestPointToPointParameter(_ssOrigin3, true);
-        _line.at(param, _closestPoint); // check if the intersection point is within clip space
-
-        const zPos = THREE$j.MathUtils.lerp(_start4.z, _end4.z, param);
-        const isInClipSpace = zPos >= -1 && zPos <= 1;
-        const isInside = _ssOrigin3.distanceTo(_closestPoint) < lineWidth * 0.5;
-        if (isInClipSpace && isInside) {
-          _line.start.fromBufferAttribute(instanceStart, i);
-          _line.end.fromBufferAttribute(instanceEnd, i);
-          _line.start.applyMatrix4(matrixWorld);
-          _line.end.applyMatrix4(matrixWorld);
-          const pointOnLine = new THREE$j.Vector3();
-          const point = new THREE$j.Vector3();
-          ray.distanceSqToSegment(_line.start, _line.end, point, pointOnLine);
-          intersects.push({
-            point: point,
-            pointOnLine: pointOnLine,
-            distance: ray.origin.distanceTo(point),
-            object: this,
-            face: null,
-            faceIndex: i,
-            uv: null,
-            uv2: null
-          });
-        }
-      }
-    }
   }
-  LineSegments2.prototype.LineSegments2 = true;
 
   class LineGeometry extends LineSegmentsGeometry {
-    constructor() {
-      super();
-      this.type = 'LineGeometry';
-    }
-    setPositions(array) {
-      // converts [ x1, y1, z1,  x2, y2, z2, ... ] to pairs format
-      var length = array.length - 3;
-      var points = new Float32Array(2 * length);
-      for (var i = 0; i < length; i += 3) {
-        points[2 * i] = array[i];
-        points[2 * i + 1] = array[i + 1];
-        points[2 * i + 2] = array[i + 2];
-        points[2 * i + 3] = array[i + 3];
-        points[2 * i + 4] = array[i + 4];
-        points[2 * i + 5] = array[i + 5];
-      }
-      super.setPositions(points);
-      return this;
-    }
-    setColors(array) {
-      // converts [ r1, g1, b1,  r2, g2, b2, ... ] to pairs format
-      var length = array.length - 3;
-      var colors = new Float32Array(2 * length);
-      for (var i = 0; i < length; i += 3) {
-        colors[2 * i] = array[i];
-        colors[2 * i + 1] = array[i + 1];
-        colors[2 * i + 2] = array[i + 2];
-        colors[2 * i + 3] = array[i + 3];
-        colors[2 * i + 4] = array[i + 4];
-        colors[2 * i + 5] = array[i + 5];
-      }
-      super.setColors(colors);
-      return this;
-    }
-    fromLine(line) {
-      var geometry = line.geometry;
-      if (geometry.isGeometry) {
-        console.error('THREE.LineGeometry no longer supports Geometry. Use THREE.BufferGeometry instead.');
-        return;
-      } else if (geometry.isBufferGeometry) {
-        this.setPositions(geometry.attributes.position.array); // assumes non-indexed
-      } // set colors, maybe
 
-      return this;
-    }
+  	constructor() {
+
+  		super();
+
+  		this.isLineGeometry = true;
+
+  		this.type = 'LineGeometry';
+
+  	}
+
+  	setPositions( array ) {
+
+  		// converts [ x1, y1, z1,  x2, y2, z2, ... ] to pairs format
+
+  		const length = array.length - 3;
+  		const points = new Float32Array( 2 * length );
+
+  		for ( let i = 0; i < length; i += 3 ) {
+
+  			points[ 2 * i ] = array[ i ];
+  			points[ 2 * i + 1 ] = array[ i + 1 ];
+  			points[ 2 * i + 2 ] = array[ i + 2 ];
+
+  			points[ 2 * i + 3 ] = array[ i + 3 ];
+  			points[ 2 * i + 4 ] = array[ i + 4 ];
+  			points[ 2 * i + 5 ] = array[ i + 5 ];
+
+  		}
+
+  		super.setPositions( points );
+
+  		return this;
+
+  	}
+
+  	setColors( array ) {
+
+  		// converts [ r1, g1, b1,  r2, g2, b2, ... ] to pairs format
+
+  		const length = array.length - 3;
+  		const colors = new Float32Array( 2 * length );
+
+  		for ( let i = 0; i < length; i += 3 ) {
+
+  			colors[ 2 * i ] = array[ i ];
+  			colors[ 2 * i + 1 ] = array[ i + 1 ];
+  			colors[ 2 * i + 2 ] = array[ i + 2 ];
+
+  			colors[ 2 * i + 3 ] = array[ i + 3 ];
+  			colors[ 2 * i + 4 ] = array[ i + 4 ];
+  			colors[ 2 * i + 5 ] = array[ i + 5 ];
+
+  		}
+
+  		super.setColors( colors );
+
+  		return this;
+
+  	}
+
+  	fromLine( line ) {
+
+  		const geometry = line.geometry;
+
+  		this.setPositions( geometry.attributes.position.array ); // assumes non-indexed
+
+  		// set colors, maybe
+
+  		return this;
+
+  	}
+
   }
-  LineGeometry.prototype.isLineGeometry = true;
 
   class Line2 extends LineSegments2 {
-    constructor(geometry = new LineGeometry(), material = new LineMaterial({
-      color: Math.random() * 0xffffff
-    })) {
-      super(geometry, material);
-      this.type = 'Line2';
-    }
+
+  	constructor( geometry = new LineGeometry(), material = new LineMaterial( { color: Math.random() * 0xffffff } ) ) {
+
+  		super( geometry, material );
+
+  		this.isLine2 = true;
+
+  		this.type = 'Line2';
+
+  	}
+
   }
-  Line2.prototype.isLine2 = true;
 
   /**
    * Text = 3D Text
@@ -71290,23 +71623,43 @@ void main() {
 
   function onMouseDown$1( event ) {
 
-  	if ( this.state === _STATE$1.NONE ) {
+  	let mouseAction;
 
-  		switch ( event.button ) {
+  	switch ( event.button ) {
 
-  			case this.mouseButtons.LEFT:
-  				this.state = _STATE$1.ROTATE;
-  				break;
+  		case 0:
+  			mouseAction = this.mouseButtons.LEFT;
+  			break;
 
-  			case this.mouseButtons.MIDDLE:
-  				this.state = _STATE$1.ZOOM;
-  				break;
+  		case 1:
+  			mouseAction = this.mouseButtons.MIDDLE;
+  			break;
 
-  			case this.mouseButtons.RIGHT:
-  				this.state = _STATE$1.PAN;
-  				break;
+  		case 2:
+  			mouseAction = this.mouseButtons.RIGHT;
+  			break;
 
-  		}
+  		default:
+  			mouseAction = - 1;
+
+  	}
+
+  	switch ( mouseAction ) {
+
+  		case MOUSE.DOLLY:
+  			this.state = _STATE$1.ZOOM;
+  			break;
+
+  		case MOUSE.ROTATE:
+  			this.state = _STATE$1.ROTATE;
+  			break;
+
+  		case MOUSE.PAN:
+  			this.state = _STATE$1.PAN;
+  			break;
+
+  		default:
+  			this.state = _STATE$1.NONE;
 
   	}