@shopware-ag/dive 2.3.8 → 3.0.0-beta.0

package/build/chunks/DIVEShaderMaterial-Bt0d8oJB.mjs

@@ -1,3468 +0,0 @@
-import { Color as O, ShaderMaterial as ie } from "three";
-const ne = (
-  /* glsl */
-  `
-varying vec2 vUv;
-uniform mat3 uvTransform;
-
-void main() {
-
-	vUv = ( uvTransform * vec3( uv, 1 ) ).xy;
-
-	gl_Position = vec4( position.xy, 1.0, 1.0 );
-
-}
-`
-), re = (
-  /* glsl */
-  `
-uniform sampler2D t2D;
-uniform float backgroundIntensity;
-
-varying vec2 vUv;
-
-void main() {
-
-	vec4 texColor = texture2D( t2D, vUv );
-
-	#ifdef DECODE_VIDEO_TEXTURE
-
-		// use inline sRGB decode until browsers properly support SRGB8_APLHA8 with video textures
-
-		texColor = vec4( mix( pow( texColor.rgb * 0.9478672986 + vec3( 0.0521327014 ), vec3( 2.4 ) ), texColor.rgb * 0.0773993808, vec3( lessThanEqual( texColor.rgb, vec3( 0.04045 ) ) ) ), texColor.w );
-
-	#endif
-
-	texColor.rgb *= backgroundIntensity;
-
-	gl_FragColor = texColor;
-
-	#include <tonemapping_fragment>
-	#include <colorspace_fragment>
-
-}
-`
-), ae = (
-  /* glsl */
-  `
-varying vec3 vWorldDirection;
-
-#include <common>
-
-void main() {
-
-	vWorldDirection = transformDirection( position, modelMatrix );
-
-	#include <begin_vertex>
-	#include <project_vertex>
-
-	gl_Position.z = gl_Position.w; // set z to camera.far
-
-}
-`
-), se = (
-  /* glsl */
-  `
-
-#ifdef ENVMAP_TYPE_CUBE
-
-	uniform samplerCube envMap;
-
-#elif defined( ENVMAP_TYPE_CUBE_UV )
-
-	uniform sampler2D envMap;
-
-#endif
-
-uniform float flipEnvMap;
-uniform float backgroundBlurriness;
-uniform float backgroundIntensity;
-uniform mat3 backgroundRotation;
-
-varying vec3 vWorldDirection;
-
-#include <cube_uv_reflection_fragment>
-
-void main() {
-
-	#ifdef ENVMAP_TYPE_CUBE
-
-		vec4 texColor = textureCube( envMap, backgroundRotation * vec3( flipEnvMap * vWorldDirection.x, vWorldDirection.yz ) );
-
-	#elif defined( ENVMAP_TYPE_CUBE_UV )
-
-		vec4 texColor = textureCubeUV( envMap, backgroundRotation * vWorldDirection, backgroundBlurriness );
-
-	#else
-
-		vec4 texColor = vec4( 0.0, 0.0, 0.0, 1.0 );
-
-	#endif
-
-	texColor.rgb *= backgroundIntensity;
-
-	gl_FragColor = texColor;
-
-	#include <tonemapping_fragment>
-	#include <colorspace_fragment>
-
-}
-`
-), le = (
-  /* glsl */
-  `
-varying vec3 vWorldDirection;
-
-#include <common>
-
-void main() {
-
-	vWorldDirection = transformDirection( position, modelMatrix );
-
-	#include <begin_vertex>
-	#include <project_vertex>
-
-	gl_Position.z = gl_Position.w; // set z to camera.far
-
-}
-`
-), oe = (
-  /* glsl */
-  `
-uniform samplerCube tCube;
-uniform float tFlip;
-uniform float opacity;
-
-varying vec3 vWorldDirection;
-
-void main() {
-
-	vec4 texColor = textureCube( tCube, vec3( tFlip * vWorldDirection.x, vWorldDirection.yz ) );
-
-	gl_FragColor = texColor;
-	gl_FragColor.a *= opacity;
-
-	#include <tonemapping_fragment>
-	#include <colorspace_fragment>
-
-}
-`
-), ce = (
-  /* glsl */
-  `
-#include <common>
-#include <batching_pars_vertex>
-#include <uv_pars_vertex>
-#include <displacementmap_pars_vertex>
-#include <morphtarget_pars_vertex>
-#include <skinning_pars_vertex>
-#include <logdepthbuf_pars_vertex>
-#include <clipping_planes_pars_vertex>
-
-// This is used for computing an equivalent of gl_FragCoord.z that is as high precision as possible.
-// Some platforms compute gl_FragCoord at a lower precision which makes the manually computed value better for
-// depth-based postprocessing effects. Reproduced on iPad with A10 processor / iPadOS 13.3.1.
-varying vec2 vHighPrecisionZW;
-
-void main() {
-
-	#include <uv_vertex>
-
-	#include <batching_vertex>
-	#include <skinbase_vertex>
-
-	#include <morphinstance_vertex>
-
-	#ifdef USE_DISPLACEMENTMAP
-
-		#include <beginnormal_vertex>
-		#include <morphnormal_vertex>
-		#include <skinnormal_vertex>
-
-	#endif
-
-	#include <begin_vertex>
-	#include <morphtarget_vertex>
-	#include <skinning_vertex>
-	#include <displacementmap_vertex>
-	#include <project_vertex>
-	#include <logdepthbuf_vertex>
-	#include <clipping_planes_vertex>
-
-	vHighPrecisionZW = gl_Position.zw;
-
-}
-`
-), ue = (
-  /* glsl */
-  `
-#if DEPTH_PACKING == 3200
-
-	uniform float opacity;
-
-#endif
-
-#include <common>
-#include <packing>
-#include <uv_pars_fragment>
-#include <map_pars_fragment>
-#include <alphamap_pars_fragment>
-#include <alphatest_pars_fragment>
-#include <alphahash_pars_fragment>
-#include <logdepthbuf_pars_fragment>
-#include <clipping_planes_pars_fragment>
-
-varying vec2 vHighPrecisionZW;
-
-void main() {
-
-	vec4 diffuseColor = vec4( 1.0 );
-	#include <clipping_planes_fragment>
-
-	#if DEPTH_PACKING == 3200
-
-		diffuseColor.a = opacity;
-
-	#endif
-
-	#include <map_fragment>
-	#include <alphamap_fragment>
-	#include <alphatest_fragment>
-	#include <alphahash_fragment>
-
-	#include <logdepthbuf_fragment>
-
-	// Higher precision equivalent of gl_FragCoord.z. This assumes depthRange has been left to its default values.
-	float fragCoordZ = 0.5 * vHighPrecisionZW[0] / vHighPrecisionZW[1] + 0.5;
-
-	#if DEPTH_PACKING == 3200
-
-		gl_FragColor = vec4( vec3( 1.0 - fragCoordZ ), opacity );
-
-	#elif DEPTH_PACKING == 3201
-
-		gl_FragColor = packDepthToRGBA( fragCoordZ );
-
-	#endif
-
-}
-`
-), he = (
-  /* glsl */
-  `
-#define DISTANCE
-
-varying vec3 vWorldPosition;
-
-#include <common>
-#include <batching_pars_vertex>
-#include <uv_pars_vertex>
-#include <displacementmap_pars_vertex>
-#include <morphtarget_pars_vertex>
-#include <skinning_pars_vertex>
-#include <clipping_planes_pars_vertex>
-
-void main() {
-
-	#include <uv_vertex>
-
-	#include <batching_vertex>
-	#include <skinbase_vertex>
-
-	#include <morphinstance_vertex>
-
-	#ifdef USE_DISPLACEMENTMAP
-
-		#include <beginnormal_vertex>
-		#include <morphnormal_vertex>
-		#include <skinnormal_vertex>
-
-	#endif
-
-	#include <begin_vertex>
-	#include <morphtarget_vertex>
-	#include <skinning_vertex>
-	#include <displacementmap_vertex>
-	#include <project_vertex>
-	#include <worldpos_vertex>
-	#include <clipping_planes_vertex>
-
-	vWorldPosition = worldPosition.xyz;
-
-}
-`
-), de = (
-  /* glsl */
-  `
-#define DISTANCE
-
-uniform vec3 referencePosition;
-uniform float nearDistance;
-uniform float farDistance;
-varying vec3 vWorldPosition;
-
-#include <common>
-#include <packing>
-#include <uv_pars_fragment>
-#include <map_pars_fragment>
-#include <alphamap_pars_fragment>
-#include <alphatest_pars_fragment>
-#include <alphahash_pars_fragment>
-#include <clipping_planes_pars_fragment>
-
-void main () {
-
-	vec4 diffuseColor = vec4( 1.0 );
-	#include <clipping_planes_fragment>
-
-	#include <map_fragment>
-	#include <alphamap_fragment>
-	#include <alphatest_fragment>
-	#include <alphahash_fragment>
-
-	float dist = length( vWorldPosition - referencePosition );
-	dist = ( dist - nearDistance ) / ( farDistance - nearDistance );
-	dist = saturate( dist ); // clamp to [ 0, 1 ]
-
-	gl_FragColor = packDepthToRGBA( dist );
-
-}
-`
-), me = (
-  /* glsl */
-  `
-varying vec3 vWorldDirection;
-
-#include <common>
-
-void main() {
-
-	vWorldDirection = transformDirection( position, modelMatrix );
-
-	#include <begin_vertex>
-	#include <project_vertex>
-
-}
-`
-), pe = (
-  /* glsl */
-  `
-uniform sampler2D tEquirect;
-
-varying vec3 vWorldDirection;
-
-#include <common>
-
-void main() {
-
-	vec3 direction = normalize( vWorldDirection );
-
-	vec2 sampleUV = equirectUv( direction );
-
-	gl_FragColor = texture2D( tEquirect, sampleUV );
-
-	#include <tonemapping_fragment>
-	#include <colorspace_fragment>
-
-}
-`
-), _e = (
-  /* glsl */
-  `
-uniform float scale;
-attribute float lineDistance;
-
-varying float vLineDistance;
-
-#include <common>
-#include <uv_pars_vertex>
-#include <color_pars_vertex>
-#include <fog_pars_vertex>
-#include <morphtarget_pars_vertex>
-#include <logdepthbuf_pars_vertex>
-#include <clipping_planes_pars_vertex>
-
-void main() {
-
-	vLineDistance = scale * lineDistance;
-
-	#include <uv_vertex>
-	#include <color_vertex>
-	#include <morphinstance_vertex>
-	#include <morphcolor_vertex>
-	#include <begin_vertex>
-	#include <morphtarget_vertex>
-	#include <project_vertex>
-	#include <logdepthbuf_vertex>
-	#include <clipping_planes_vertex>
-	#include <fog_vertex>
-
-}
-`
-), ge = (
-  /* glsl */
-  `
-uniform vec3 diffuse;
-uniform float opacity;
-
-uniform float dashSize;
-uniform float totalSize;
-
-varying float vLineDistance;
-
-#include <common>
-#include <color_pars_fragment>
-#include <uv_pars_fragment>
-#include <map_pars_fragment>
-#include <fog_pars_fragment>
-#include <logdepthbuf_pars_fragment>
-#include <clipping_planes_pars_fragment>
-
-void main() {
-
-	vec4 diffuseColor = vec4( diffuse, opacity );
-	#include <clipping_planes_fragment>
-
-	if ( mod( vLineDistance, totalSize ) > dashSize ) {
-
-		discard;
-
-	}
-
-	vec3 outgoingLight = vec3( 0.0 );
-
-	#include <logdepthbuf_fragment>
-	#include <map_fragment>
-	#include <color_fragment>
-
-	outgoingLight = diffuseColor.rgb; // simple shader
-
-	#include <opaque_fragment>
-	#include <tonemapping_fragment>
-	#include <colorspace_fragment>
-	#include <fog_fragment>
-	#include <premultiplied_alpha_fragment>
-
-}
-`
-), fe = (
-  /* glsl */
-  `
-#include <common>
-#include <batching_pars_vertex>
-#include <uv_pars_vertex>
-#include <envmap_pars_vertex>
-#include <color_pars_vertex>
-#include <fog_pars_vertex>
-#include <morphtarget_pars_vertex>
-#include <skinning_pars_vertex>
-#include <logdepthbuf_pars_vertex>
-#include <clipping_planes_pars_vertex>
-
-void main() {
-
-	#include <uv_vertex>
-	#include <color_vertex>
-	#include <morphinstance_vertex>
-	#include <morphcolor_vertex>
-	#include <batching_vertex>
-
-	#if defined ( USE_ENVMAP ) || defined ( USE_SKINNING )
-
-		#include <beginnormal_vertex>
-		#include <morphnormal_vertex>
-		#include <skinbase_vertex>
-		#include <skinnormal_vertex>
-		#include <defaultnormal_vertex>
-
-	#endif
-
-	#include <begin_vertex>
-	#include <morphtarget_vertex>
-	#include <skinning_vertex>
-	#include <project_vertex>
-	#include <logdepthbuf_vertex>
-	#include <clipping_planes_vertex>
-
-	#include <worldpos_vertex>
-	#include <envmap_vertex>
-	#include <fog_vertex>
-
-}
-`
-), ve = (
-  /* glsl */
-  `
-uniform vec3 diffuse;
-uniform float opacity;
-
-#ifndef FLAT_SHADED
-
-	varying vec3 vNormal;
-
-#endif
-
-#include <common>
-#include <dithering_pars_fragment>
-#include <color_pars_fragment>
-#include <uv_pars_fragment>
-#include <map_pars_fragment>
-#include <alphamap_pars_fragment>
-#include <alphatest_pars_fragment>
-#include <alphahash_pars_fragment>
-#include <aomap_pars_fragment>
-#include <lightmap_pars_fragment>
-#include <envmap_common_pars_fragment>
-#include <envmap_pars_fragment>
-#include <fog_pars_fragment>
-#include <specularmap_pars_fragment>
-#include <logdepthbuf_pars_fragment>
-#include <clipping_planes_pars_fragment>
-
-void main() {
-
-	vec4 diffuseColor = vec4( diffuse, opacity );
-	#include <clipping_planes_fragment>
-
-	#include <logdepthbuf_fragment>
-	#include <map_fragment>
-	#include <color_fragment>
-	#include <alphamap_fragment>
-	#include <alphatest_fragment>
-	#include <alphahash_fragment>
-	#include <specularmap_fragment>
-
-	ReflectedLight reflectedLight = ReflectedLight( vec3( 0.0 ), vec3( 0.0 ), vec3( 0.0 ), vec3( 0.0 ) );
-
-	// accumulation (baked indirect lighting only)
-	#ifdef USE_LIGHTMAP
-
-		vec4 lightMapTexel = texture2D( lightMap, vLightMapUv );
-		reflectedLight.indirectDiffuse += lightMapTexel.rgb * lightMapIntensity * RECIPROCAL_PI;
-
-	#else
-
-		reflectedLight.indirectDiffuse += vec3( 1.0 );
-
-	#endif
-
-	// modulation
-	#include <aomap_fragment>
-
-	reflectedLight.indirectDiffuse *= diffuseColor.rgb;
-
-	vec3 outgoingLight = reflectedLight.indirectDiffuse;
-
-	#include <envmap_fragment>
-
-	#include <opaque_fragment>
-	#include <tonemapping_fragment>
-	#include <colorspace_fragment>
-	#include <fog_fragment>
-	#include <premultiplied_alpha_fragment>
-	#include <dithering_fragment>
-
-}
-`
-), xe = (
-  /* glsl */
-  `
-#define LAMBERT
-
-varying vec3 vViewPosition;
-
-#include <common>
-#include <batching_pars_vertex>
-#include <uv_pars_vertex>
-#include <displacementmap_pars_vertex>
-#include <envmap_pars_vertex>
-#include <color_pars_vertex>
-#include <fog_pars_vertex>
-#include <normal_pars_vertex>
-#include <morphtarget_pars_vertex>
-#include <skinning_pars_vertex>
-#include <shadowmap_pars_vertex>
-#include <logdepthbuf_pars_vertex>
-#include <clipping_planes_pars_vertex>
-
-void main() {
-
-	#include <uv_vertex>
-	#include <color_vertex>
-	#include <morphinstance_vertex>
-	#include <morphcolor_vertex>
-	#include <batching_vertex>
-
-	#include <beginnormal_vertex>
-	#include <morphnormal_vertex>
-	#include <skinbase_vertex>
-	#include <skinnormal_vertex>
-	#include <defaultnormal_vertex>
-	#include <normal_vertex>
-
-	#include <begin_vertex>
-	#include <morphtarget_vertex>
-	#include <skinning_vertex>
-	#include <displacementmap_vertex>
-	#include <project_vertex>
-	#include <logdepthbuf_vertex>
-	#include <clipping_planes_vertex>
-
-	vViewPosition = - mvPosition.xyz;
-
-	#include <worldpos_vertex>
-	#include <envmap_vertex>
-	#include <shadowmap_vertex>
-	#include <fog_vertex>
-
-}
-`
-), ye = (
-  /* glsl */
-  `
-#define LAMBERT
-
-uniform vec3 diffuse;
-uniform vec3 emissive;
-uniform float opacity;
-
-#include <common>
-#include <packing>
-#include <dithering_pars_fragment>
-#include <color_pars_fragment>
-#include <uv_pars_fragment>
-#include <map_pars_fragment>
-#include <alphamap_pars_fragment>
-#include <alphatest_pars_fragment>
-#include <alphahash_pars_fragment>
-#include <aomap_pars_fragment>
-#include <lightmap_pars_fragment>
-#include <emissivemap_pars_fragment>
-#include <envmap_common_pars_fragment>
-#include <envmap_pars_fragment>
-#include <fog_pars_fragment>
-#include <bsdfs>
-#include <lights_pars_begin>
-#include <normal_pars_fragment>
-#include <lights_lambert_pars_fragment>
-#include <shadowmap_pars_fragment>
-#include <bumpmap_pars_fragment>
-#include <normalmap_pars_fragment>
-#include <specularmap_pars_fragment>
-#include <logdepthbuf_pars_fragment>
-#include <clipping_planes_pars_fragment>
-
-void main() {
-
-	vec4 diffuseColor = vec4( diffuse, opacity );
-	#include <clipping_planes_fragment>
-
-	ReflectedLight reflectedLight = ReflectedLight( vec3( 0.0 ), vec3( 0.0 ), vec3( 0.0 ), vec3( 0.0 ) );
-	vec3 totalEmissiveRadiance = emissive;
-
-	#include <logdepthbuf_fragment>
-	#include <map_fragment>
-	#include <color_fragment>
-	#include <alphamap_fragment>
-	#include <alphatest_fragment>
-	#include <alphahash_fragment>
-	#include <specularmap_fragment>
-	#include <normal_fragment_begin>
-	#include <normal_fragment_maps>
-	#include <emissivemap_fragment>
-
-	// accumulation
-	#include <lights_lambert_fragment>
-	#include <lights_fragment_begin>
-	#include <lights_fragment_maps>
-	#include <lights_fragment_end>
-
-	// modulation
-	#include <aomap_fragment>
-
-	vec3 outgoingLight = reflectedLight.directDiffuse + reflectedLight.indirectDiffuse + totalEmissiveRadiance;
-
-	#include <envmap_fragment>
-	#include <opaque_fragment>
-	#include <tonemapping_fragment>
-	#include <colorspace_fragment>
-	#include <fog_fragment>
-	#include <premultiplied_alpha_fragment>
-	#include <dithering_fragment>
-
-}
-`
-), be = (
-  /* glsl */
-  `
-#define MATCAP
-
-varying vec3 vViewPosition;
-
-#include <common>
-#include <batching_pars_vertex>
-#include <uv_pars_vertex>
-#include <color_pars_vertex>
-#include <displacementmap_pars_vertex>
-#include <fog_pars_vertex>
-#include <normal_pars_vertex>
-#include <morphtarget_pars_vertex>
-#include <skinning_pars_vertex>
-
-#include <logdepthbuf_pars_vertex>
-#include <clipping_planes_pars_vertex>
-
-void main() {
-
-	#include <uv_vertex>
-	#include <color_vertex>
-	#include <morphinstance_vertex>
-	#include <morphcolor_vertex>
-	#include <batching_vertex>
-
-	#include <beginnormal_vertex>
-	#include <morphnormal_vertex>
-	#include <skinbase_vertex>
-	#include <skinnormal_vertex>
-	#include <defaultnormal_vertex>
-	#include <normal_vertex>
-
-	#include <begin_vertex>
-	#include <morphtarget_vertex>
-	#include <skinning_vertex>
-	#include <displacementmap_vertex>
-	#include <project_vertex>
-
-	#include <logdepthbuf_vertex>
-	#include <clipping_planes_vertex>
-	#include <fog_vertex>
-
-	vViewPosition = - mvPosition.xyz;
-
-}
-`
-), Me = (
-  /* glsl */
-  `
-#define MATCAP
-
-uniform vec3 diffuse;
-uniform float opacity;
-uniform sampler2D matcap;
-
-varying vec3 vViewPosition;
-
-#include <common>
-#include <dithering_pars_fragment>
-#include <color_pars_fragment>
-#include <uv_pars_fragment>
-#include <map_pars_fragment>
-#include <alphamap_pars_fragment>
-#include <alphatest_pars_fragment>
-#include <alphahash_pars_fragment>
-#include <fog_pars_fragment>
-#include <normal_pars_fragment>
-#include <bumpmap_pars_fragment>
-#include <normalmap_pars_fragment>
-#include <logdepthbuf_pars_fragment>
-#include <clipping_planes_pars_fragment>
-
-void main() {
-
-	vec4 diffuseColor = vec4( diffuse, opacity );
-	#include <clipping_planes_fragment>
-
-	#include <logdepthbuf_fragment>
-	#include <map_fragment>
-	#include <color_fragment>
-	#include <alphamap_fragment>
-	#include <alphatest_fragment>
-	#include <alphahash_fragment>
-	#include <normal_fragment_begin>
-	#include <normal_fragment_maps>
-
-	vec3 viewDir = normalize( vViewPosition );
-	vec3 x = normalize( vec3( viewDir.z, 0.0, - viewDir.x ) );
-	vec3 y = cross( viewDir, x );
-	vec2 uv = vec2( dot( x, normal ), dot( y, normal ) ) * 0.495 + 0.5; // 0.495 to remove artifacts caused by undersized matcap disks
-
-	#ifdef USE_MATCAP
-
-		vec4 matcapColor = texture2D( matcap, uv );
-
-	#else
-
-		vec4 matcapColor = vec4( vec3( mix( 0.2, 0.8, uv.y ) ), 1.0 ); // default if matcap is missing
-
-	#endif
-
-	vec3 outgoingLight = diffuseColor.rgb * matcapColor.rgb;
-
-	#include <opaque_fragment>
-	#include <tonemapping_fragment>
-	#include <colorspace_fragment>
-	#include <fog_fragment>
-	#include <premultiplied_alpha_fragment>
-	#include <dithering_fragment>
-
-}
-`
-), we = (
-  /* glsl */
-  `
-#define NORMAL
-
-#if defined( FLAT_SHADED ) || defined( USE_BUMPMAP ) || defined( USE_NORMALMAP_TANGENTSPACE )
-
-	varying vec3 vViewPosition;
-
-#endif
-
-#include <common>
-#include <batching_pars_vertex>
-#include <uv_pars_vertex>
-#include <displacementmap_pars_vertex>
-#include <normal_pars_vertex>
-#include <morphtarget_pars_vertex>
-#include <skinning_pars_vertex>
-#include <logdepthbuf_pars_vertex>
-#include <clipping_planes_pars_vertex>
-
-void main() {
-
-	#include <uv_vertex>
-	#include <batching_vertex>
-
-	#include <beginnormal_vertex>
-	#include <morphinstance_vertex>
-	#include <morphnormal_vertex>
-	#include <skinbase_vertex>
-	#include <skinnormal_vertex>
-	#include <defaultnormal_vertex>
-	#include <normal_vertex>
-
-	#include <begin_vertex>
-	#include <morphtarget_vertex>
-	#include <skinning_vertex>
-	#include <displacementmap_vertex>
-	#include <project_vertex>
-	#include <logdepthbuf_vertex>
-	#include <clipping_planes_vertex>
-
-#if defined( FLAT_SHADED ) || defined( USE_BUMPMAP ) || defined( USE_NORMALMAP_TANGENTSPACE )
-
-	vViewPosition = - mvPosition.xyz;
-
-#endif
-
-}
-`
-), Ce = (
-  /* glsl */
-  `
-#define NORMAL
-
-uniform float opacity;
-
-#if defined( FLAT_SHADED ) || defined( USE_BUMPMAP ) || defined( USE_NORMALMAP_TANGENTSPACE )
-
-	varying vec3 vViewPosition;
-
-#endif
-
-#include <packing>
-#include <uv_pars_fragment>
-#include <normal_pars_fragment>
-#include <bumpmap_pars_fragment>
-#include <normalmap_pars_fragment>
-#include <logdepthbuf_pars_fragment>
-#include <clipping_planes_pars_fragment>
-
-void main() {
-
-	vec4 diffuseColor = vec4( 0.0, 0.0, 0.0, opacity );
-
-	#include <clipping_planes_fragment>
-	#include <logdepthbuf_fragment>
-	#include <normal_fragment_begin>
-	#include <normal_fragment_maps>
-
-	gl_FragColor = vec4( packNormalToRGB( normal ), diffuseColor.a );
-
-	#ifdef OPAQUE
-
-		gl_FragColor.a = 1.0;
-
-	#endif
-
-}
-`
-), Se = (
-  /* glsl */
-  `
-#define PHONG
-
-varying vec3 vViewPosition;
-
-#include <common>
-#include <batching_pars_vertex>
-#include <uv_pars_vertex>
-#include <displacementmap_pars_vertex>
-#include <envmap_pars_vertex>
-#include <color_pars_vertex>
-#include <fog_pars_vertex>
-#include <normal_pars_vertex>
-#include <morphtarget_pars_vertex>
-#include <skinning_pars_vertex>
-#include <shadowmap_pars_vertex>
-#include <logdepthbuf_pars_vertex>
-#include <clipping_planes_pars_vertex>
-
-void main() {
-
-	#include <uv_vertex>
-	#include <color_vertex>
-	#include <morphcolor_vertex>
-	#include <batching_vertex>
-
-	#include <beginnormal_vertex>
-	#include <morphinstance_vertex>
-	#include <morphnormal_vertex>
-	#include <skinbase_vertex>
-	#include <skinnormal_vertex>
-	#include <defaultnormal_vertex>
-	#include <normal_vertex>
-
-	#include <begin_vertex>
-	#include <morphtarget_vertex>
-	#include <skinning_vertex>
-	#include <displacementmap_vertex>
-	#include <project_vertex>
-	#include <logdepthbuf_vertex>
-	#include <clipping_planes_vertex>
-
-	vViewPosition = - mvPosition.xyz;
-
-	#include <worldpos_vertex>
-	#include <envmap_vertex>
-	#include <shadowmap_vertex>
-	#include <fog_vertex>
-
-}
-`
-), Fe = (
-  /* glsl */
-  `
-#define PHONG
-
-uniform vec3 diffuse;
-uniform vec3 emissive;
-uniform vec3 specular;
-uniform float shininess;
-uniform float opacity;
-
-#include <common>
-#include <packing>
-#include <dithering_pars_fragment>
-#include <color_pars_fragment>
-#include <uv_pars_fragment>
-#include <map_pars_fragment>
-#include <alphamap_pars_fragment>
-#include <alphatest_pars_fragment>
-#include <alphahash_pars_fragment>
-#include <aomap_pars_fragment>
-#include <lightmap_pars_fragment>
-#include <emissivemap_pars_fragment>
-#include <envmap_common_pars_fragment>
-#include <envmap_pars_fragment>
-#include <fog_pars_fragment>
-#include <bsdfs>
-#include <lights_pars_begin>
-#include <normal_pars_fragment>
-#include <lights_phong_pars_fragment>
-#include <shadowmap_pars_fragment>
-#include <bumpmap_pars_fragment>
-#include <normalmap_pars_fragment>
-#include <specularmap_pars_fragment>
-#include <logdepthbuf_pars_fragment>
-#include <clipping_planes_pars_fragment>
-
-void main() {
-
-	vec4 diffuseColor = vec4( diffuse, opacity );
-	#include <clipping_planes_fragment>
-
-	ReflectedLight reflectedLight = ReflectedLight( vec3( 0.0 ), vec3( 0.0 ), vec3( 0.0 ), vec3( 0.0 ) );
-	vec3 totalEmissiveRadiance = emissive;
-
-	#include <logdepthbuf_fragment>
-	#include <map_fragment>
-	#include <color_fragment>
-	#include <alphamap_fragment>
-	#include <alphatest_fragment>
-	#include <alphahash_fragment>
-	#include <specularmap_fragment>
-	#include <normal_fragment_begin>
-	#include <normal_fragment_maps>
-	#include <emissivemap_fragment>
-
-	// accumulation
-	#include <lights_phong_fragment>
-	#include <lights_fragment_begin>
-	#include <lights_fragment_maps>
-	#include <lights_fragment_end>
-
-	// modulation
-	#include <aomap_fragment>
-
-	vec3 outgoingLight = reflectedLight.directDiffuse + reflectedLight.indirectDiffuse + reflectedLight.directSpecular + reflectedLight.indirectSpecular + totalEmissiveRadiance;
-
-	#include <envmap_fragment>
-	#include <opaque_fragment>
-	#include <tonemapping_fragment>
-	#include <colorspace_fragment>
-	#include <fog_fragment>
-	#include <premultiplied_alpha_fragment>
-	#include <dithering_fragment>
-
-}
-`
-), ze = (
-  /* glsl */
-  `
-#define STANDARD
-
-varying vec3 vViewPosition;
-
-#ifdef USE_TRANSMISSION
-
-	varying vec3 vWorldPosition;
-
-#endif
-
-#include <common>
-#include <batching_pars_vertex>
-#include <uv_pars_vertex>
-#include <displacementmap_pars_vertex>
-#include <color_pars_vertex>
-#include <fog_pars_vertex>
-#include <normal_pars_vertex>
-#include <morphtarget_pars_vertex>
-#include <skinning_pars_vertex>
-#include <shadowmap_pars_vertex>
-#include <logdepthbuf_pars_vertex>
-#include <clipping_planes_pars_vertex>
-
-void main() {
-
-	#include <uv_vertex>
-	#include <color_vertex>
-	#include <morphinstance_vertex>
-	#include <morphcolor_vertex>
-	#include <batching_vertex>
-
-	#include <beginnormal_vertex>
-	#include <morphnormal_vertex>
-	#include <skinbase_vertex>
-	#include <skinnormal_vertex>
-	#include <defaultnormal_vertex>
-	#include <normal_vertex>
-
-	#include <begin_vertex>
-	#include <morphtarget_vertex>
-	#include <skinning_vertex>
-	#include <displacementmap_vertex>
-	#include <project_vertex>
-	#include <logdepthbuf_vertex>
-	#include <clipping_planes_vertex>
-
-	vViewPosition = - mvPosition.xyz;
-
-	#include <worldpos_vertex>
-	#include <shadowmap_vertex>
-	#include <fog_vertex>
-
-#ifdef USE_TRANSMISSION
-
-	vWorldPosition = worldPosition.xyz;
-
-#endif
-}
-`
-), Ee = (
-  /* glsl */
-  `
-#define STANDARD
-
-#ifdef PHYSICAL
-	#define IOR
-	#define USE_SPECULAR
-#endif
-
-uniform vec3 diffuse;
-uniform vec3 emissive;
-uniform float roughness;
-uniform float metalness;
-uniform float opacity;
-
-#ifdef IOR
-	uniform float ior;
-#endif
-
-#ifdef USE_SPECULAR
-	uniform float specularIntensity;
-	uniform vec3 specularColor;
-
-	#ifdef USE_SPECULAR_COLORMAP
-		uniform sampler2D specularColorMap;
-	#endif
-
-	#ifdef USE_SPECULAR_INTENSITYMAP
-		uniform sampler2D specularIntensityMap;
-	#endif
-#endif
-
-#ifdef USE_CLEARCOAT
-	uniform float clearcoat;
-	uniform float clearcoatRoughness;
-#endif
-
-#ifdef USE_IRIDESCENCE
-	uniform float iridescence;
-	uniform float iridescenceIOR;
-	uniform float iridescenceThicknessMinimum;
-	uniform float iridescenceThicknessMaximum;
-#endif
-
-#ifdef USE_SHEEN
-	uniform vec3 sheenColor;
-	uniform float sheenRoughness;
-
-	#ifdef USE_SHEEN_COLORMAP
-		uniform sampler2D sheenColorMap;
-	#endif
-
-	#ifdef USE_SHEEN_ROUGHNESSMAP
-		uniform sampler2D sheenRoughnessMap;
-	#endif
-#endif
-
-#ifdef USE_ANISOTROPY
-	uniform vec2 anisotropyVector;
-
-	#ifdef USE_ANISOTROPYMAP
-		uniform sampler2D anisotropyMap;
-	#endif
-#endif
-
-varying vec3 vViewPosition;
-
-#include <common>
-#include <packing>
-#include <dithering_pars_fragment>
-#include <color_pars_fragment>
-#include <uv_pars_fragment>
-#include <map_pars_fragment>
-#include <alphamap_pars_fragment>
-#include <alphatest_pars_fragment>
-#include <alphahash_pars_fragment>
-#include <aomap_pars_fragment>
-#include <lightmap_pars_fragment>
-#include <emissivemap_pars_fragment>
-#include <iridescence_fragment>
-#include <cube_uv_reflection_fragment>
-#include <envmap_common_pars_fragment>
-#include <envmap_physical_pars_fragment>
-#include <fog_pars_fragment>
-#include <lights_pars_begin>
-#include <normal_pars_fragment>
-#include <lights_physical_pars_fragment>
-#include <transmission_pars_fragment>
-#include <shadowmap_pars_fragment>
-#include <bumpmap_pars_fragment>
-#include <normalmap_pars_fragment>
-#include <clearcoat_pars_fragment>
-#include <iridescence_pars_fragment>
-#include <roughnessmap_pars_fragment>
-#include <metalnessmap_pars_fragment>
-#include <logdepthbuf_pars_fragment>
-#include <clipping_planes_pars_fragment>
-
-void main() {
-
-	vec4 diffuseColor = vec4( diffuse, opacity );
-	#include <clipping_planes_fragment>
-
-	ReflectedLight reflectedLight = ReflectedLight( vec3( 0.0 ), vec3( 0.0 ), vec3( 0.0 ), vec3( 0.0 ) );
-	vec3 totalEmissiveRadiance = emissive;
-
-	#include <logdepthbuf_fragment>
-	#include <map_fragment>
-	#include <color_fragment>
-	#include <alphamap_fragment>
-	#include <alphatest_fragment>
-	#include <alphahash_fragment>
-	#include <roughnessmap_fragment>
-	#include <metalnessmap_fragment>
-	#include <normal_fragment_begin>
-	#include <normal_fragment_maps>
-	#include <clearcoat_normal_fragment_begin>
-	#include <clearcoat_normal_fragment_maps>
-	#include <emissivemap_fragment>
-
-	// accumulation
-	#include <lights_physical_fragment>
-	#include <lights_fragment_begin>
-	#include <lights_fragment_maps>
-	#include <lights_fragment_end>
-
-	// modulation
-	#include <aomap_fragment>
-
-	vec3 totalDiffuse = reflectedLight.directDiffuse + reflectedLight.indirectDiffuse;
-	vec3 totalSpecular = reflectedLight.directSpecular + reflectedLight.indirectSpecular;
-
-	#include <transmission_fragment>
-
-	vec3 outgoingLight = totalDiffuse + totalSpecular + totalEmissiveRadiance;
-
-	#ifdef USE_SHEEN
-
-		// Sheen energy compensation approximation calculation can be found at the end of
-		// https://drive.google.com/file/d/1T0D1VSyR4AllqIJTQAraEIzjlb5h4FKH/view?usp=sharing
-		float sheenEnergyComp = 1.0 - 0.157 * max3( material.sheenColor );
-
-		outgoingLight = outgoingLight * sheenEnergyComp + sheenSpecularDirect + sheenSpecularIndirect;
-
-	#endif
-
-	#ifdef USE_CLEARCOAT
-
-		float dotNVcc = saturate( dot( geometryClearcoatNormal, geometryViewDir ) );
-
-		vec3 Fcc = F_Schlick( material.clearcoatF0, material.clearcoatF90, dotNVcc );
-
-		outgoingLight = outgoingLight * ( 1.0 - material.clearcoat * Fcc ) + ( clearcoatSpecularDirect + clearcoatSpecularIndirect ) * material.clearcoat;
-
-	#endif
-
-	#include <opaque_fragment>
-	#include <tonemapping_fragment>
-	#include <colorspace_fragment>
-	#include <fog_fragment>
-	#include <premultiplied_alpha_fragment>
-	#include <dithering_fragment>
-
-}
-`
-), Ae = (
-  /* glsl */
-  `
-#define TOON
-
-varying vec3 vViewPosition;
-
-#include <common>
-#include <batching_pars_vertex>
-#include <uv_pars_vertex>
-#include <displacementmap_pars_vertex>
-#include <color_pars_vertex>
-#include <fog_pars_vertex>
-#include <normal_pars_vertex>
-#include <morphtarget_pars_vertex>
-#include <skinning_pars_vertex>
-#include <shadowmap_pars_vertex>
-#include <logdepthbuf_pars_vertex>
-#include <clipping_planes_pars_vertex>
-
-void main() {
-
-	#include <uv_vertex>
-	#include <color_vertex>
-	#include <morphinstance_vertex>
-	#include <morphcolor_vertex>
-	#include <batching_vertex>
-
-	#include <beginnormal_vertex>
-	#include <morphnormal_vertex>
-	#include <skinbase_vertex>
-	#include <skinnormal_vertex>
-	#include <defaultnormal_vertex>
-	#include <normal_vertex>
-
-	#include <begin_vertex>
-	#include <morphtarget_vertex>
-	#include <skinning_vertex>
-	#include <displacementmap_vertex>
-	#include <project_vertex>
-	#include <logdepthbuf_vertex>
-	#include <clipping_planes_vertex>
-
-	vViewPosition = - mvPosition.xyz;
-
-	#include <worldpos_vertex>
-	#include <shadowmap_vertex>
-	#include <fog_vertex>
-
-}
-`
-), ke = (
-  /* glsl */
-  `
-#define TOON
-
-uniform vec3 diffuse;
-uniform vec3 emissive;
-uniform float opacity;
-
-#include <common>
-#include <packing>
-#include <dithering_pars_fragment>
-#include <color_pars_fragment>
-#include <uv_pars_fragment>
-#include <map_pars_fragment>
-#include <alphamap_pars_fragment>
-#include <alphatest_pars_fragment>
-#include <alphahash_pars_fragment>
-#include <aomap_pars_fragment>
-#include <lightmap_pars_fragment>
-#include <emissivemap_pars_fragment>
-#include <gradientmap_pars_fragment>
-#include <fog_pars_fragment>
-#include <bsdfs>
-#include <lights_pars_begin>
-#include <normal_pars_fragment>
-#include <lights_toon_pars_fragment>
-#include <shadowmap_pars_fragment>
-#include <bumpmap_pars_fragment>
-#include <normalmap_pars_fragment>
-#include <logdepthbuf_pars_fragment>
-#include <clipping_planes_pars_fragment>
-
-void main() {
-
-	vec4 diffuseColor = vec4( diffuse, opacity );
-	#include <clipping_planes_fragment>
-
-	ReflectedLight reflectedLight = ReflectedLight( vec3( 0.0 ), vec3( 0.0 ), vec3( 0.0 ), vec3( 0.0 ) );
-	vec3 totalEmissiveRadiance = emissive;
-
-	#include <logdepthbuf_fragment>
-	#include <map_fragment>
-	#include <color_fragment>
-	#include <alphamap_fragment>
-	#include <alphatest_fragment>
-	#include <alphahash_fragment>
-	#include <normal_fragment_begin>
-	#include <normal_fragment_maps>
-	#include <emissivemap_fragment>
-
-	// accumulation
-	#include <lights_toon_fragment>
-	#include <lights_fragment_begin>
-	#include <lights_fragment_maps>
-	#include <lights_fragment_end>
-
-	// modulation
-	#include <aomap_fragment>
-
-	vec3 outgoingLight = reflectedLight.directDiffuse + reflectedLight.indirectDiffuse + totalEmissiveRadiance;
-
-	#include <opaque_fragment>
-	#include <tonemapping_fragment>
-	#include <colorspace_fragment>
-	#include <fog_fragment>
-	#include <premultiplied_alpha_fragment>
-	#include <dithering_fragment>
-
-}
-`
-), De = (
-  /* glsl */
-  `
-uniform float size;
-uniform float scale;
-
-#include <common>
-#include <color_pars_vertex>
-#include <fog_pars_vertex>
-#include <morphtarget_pars_vertex>
-#include <logdepthbuf_pars_vertex>
-#include <clipping_planes_pars_vertex>
-
-#ifdef USE_POINTS_UV
-
-	varying vec2 vUv;
-	uniform mat3 uvTransform;
-
-#endif
-
-void main() {
-
-	#ifdef USE_POINTS_UV
-
-		vUv = ( uvTransform * vec3( uv, 1 ) ).xy;
-
-	#endif
-
-	#include <color_vertex>
-	#include <morphinstance_vertex>
-	#include <morphcolor_vertex>
-	#include <begin_vertex>
-	#include <morphtarget_vertex>
-	#include <project_vertex>
-
-	gl_PointSize = size;
-
-	#ifdef USE_SIZEATTENUATION
-
-		bool isPerspective = isPerspectiveMatrix( projectionMatrix );
-
-		if ( isPerspective ) gl_PointSize *= ( scale / - mvPosition.z );
-
-	#endif
-
-	#include <logdepthbuf_vertex>
-	#include <clipping_planes_vertex>
-	#include <worldpos_vertex>
-	#include <fog_vertex>
-
-}
-`
-), Pe = (
-  /* glsl */
-  `
-uniform vec3 diffuse;
-uniform float opacity;
-
-#include <common>
-#include <color_pars_fragment>
-#include <map_particle_pars_fragment>
-#include <alphatest_pars_fragment>
-#include <alphahash_pars_fragment>
-#include <fog_pars_fragment>
-#include <logdepthbuf_pars_fragment>
-#include <clipping_planes_pars_fragment>
-
-void main() {
-
-	vec4 diffuseColor = vec4( diffuse, opacity );
-	#include <clipping_planes_fragment>
-
-	vec3 outgoingLight = vec3( 0.0 );
-
-	#include <logdepthbuf_fragment>
-	#include <map_particle_fragment>
-	#include <color_fragment>
-	#include <alphatest_fragment>
-	#include <alphahash_fragment>
-
-	outgoingLight = diffuseColor.rgb;
-
-	#include <opaque_fragment>
-	#include <tonemapping_fragment>
-	#include <colorspace_fragment>
-	#include <fog_fragment>
-	#include <premultiplied_alpha_fragment>
-
-}
-`
-), Te = (
-  /* glsl */
-  `
-#include <common>
-#include <batching_pars_vertex>
-#include <fog_pars_vertex>
-#include <morphtarget_pars_vertex>
-#include <skinning_pars_vertex>
-#include <logdepthbuf_pars_vertex>
-#include <shadowmap_pars_vertex>
-
-void main() {
-
-	#include <batching_vertex>
-
-	#include <beginnormal_vertex>
-	#include <morphinstance_vertex>
-	#include <morphnormal_vertex>
-	#include <skinbase_vertex>
-	#include <skinnormal_vertex>
-	#include <defaultnormal_vertex>
-
-	#include <begin_vertex>
-	#include <morphtarget_vertex>
-	#include <skinning_vertex>
-	#include <project_vertex>
-	#include <logdepthbuf_vertex>
-
-	#include <worldpos_vertex>
-	#include <shadowmap_vertex>
-	#include <fog_vertex>
-
-}
-`
-), Le = (
-  /* glsl */
-  `
-uniform vec3 color;
-uniform float opacity;
-
-#include <common>
-#include <packing>
-#include <fog_pars_fragment>
-#include <bsdfs>
-#include <lights_pars_begin>
-#include <logdepthbuf_pars_fragment>
-#include <shadowmap_pars_fragment>
-#include <shadowmask_pars_fragment>
-
-void main() {
-
-	#include <logdepthbuf_fragment>
-
-	gl_FragColor = vec4( color, opacity * ( 1.0 - getShadowMask() ) );
-
-	#include <tonemapping_fragment>
-	#include <colorspace_fragment>
-	#include <fog_fragment>
-
-}
-`
-), Re = (
-  /* glsl */
-  `
-uniform float rotation;
-uniform vec2 center;
-
-#include <common>
-#include <uv_pars_vertex>
-#include <fog_pars_vertex>
-#include <logdepthbuf_pars_vertex>
-#include <clipping_planes_pars_vertex>
-
-void main() {
-
-	#include <uv_vertex>
-
-	vec4 mvPosition = modelViewMatrix * vec4( 0.0, 0.0, 0.0, 1.0 );
-
-	vec2 scale;
-	scale.x = length( vec3( modelMatrix[ 0 ].x, modelMatrix[ 0 ].y, modelMatrix[ 0 ].z ) );
-	scale.y = length( vec3( modelMatrix[ 1 ].x, modelMatrix[ 1 ].y, modelMatrix[ 1 ].z ) );
-
-	#ifndef USE_SIZEATTENUATION
-
-		bool isPerspective = isPerspectiveMatrix( projectionMatrix );
-
-		if ( isPerspective ) scale *= - mvPosition.z;
-
-	#endif
-
-	vec2 alignedPosition = ( position.xy - ( center - vec2( 0.5 ) ) ) * scale;
-
-	vec2 rotatedPosition;
-	rotatedPosition.x = cos( rotation ) * alignedPosition.x - sin( rotation ) * alignedPosition.y;
-	rotatedPosition.y = sin( rotation ) * alignedPosition.x + cos( rotation ) * alignedPosition.y;
-
-	mvPosition.xy += rotatedPosition;
-
-	gl_Position = projectionMatrix * mvPosition;
-
-	#include <logdepthbuf_vertex>
-	#include <clipping_planes_vertex>
-	#include <fog_vertex>
-
-}
-`
-), Be = (
-  /* glsl */
-  `
-uniform vec3 diffuse;
-uniform float opacity;
-
-#include <common>
-#include <uv_pars_fragment>
-#include <map_pars_fragment>
-#include <alphamap_pars_fragment>
-#include <alphatest_pars_fragment>
-#include <alphahash_pars_fragment>
-#include <fog_pars_fragment>
-#include <logdepthbuf_pars_fragment>
-#include <clipping_planes_pars_fragment>
-
-void main() {
-
-	vec4 diffuseColor = vec4( diffuse, opacity );
-	#include <clipping_planes_fragment>
-
-	vec3 outgoingLight = vec3( 0.0 );
-
-	#include <logdepthbuf_fragment>
-	#include <map_fragment>
-	#include <alphamap_fragment>
-	#include <alphatest_fragment>
-	#include <alphahash_fragment>
-
-	outgoingLight = diffuseColor.rgb;
-
-	#include <opaque_fragment>
-	#include <tonemapping_fragment>
-	#include <colorspace_fragment>
-	#include <fog_fragment>
-
-}
-`
-), g = {
-  background_vert: ne,
-  background_frag: re,
-  backgroundCube_vert: ae,
-  backgroundCube_frag: se,
-  cube_vert: le,
-  cube_frag: oe,
-  depth_vert: ce,
-  depth_frag: ue,
-  distanceRGBA_vert: he,
-  distanceRGBA_frag: de,
-  equirect_vert: me,
-  equirect_frag: pe,
-  linedashed_vert: _e,
-  linedashed_frag: ge,
-  meshbasic_vert: fe,
-  meshbasic_frag: ve,
-  meshlambert_vert: xe,
-  meshlambert_frag: ye,
-  meshmatcap_vert: be,
-  meshmatcap_frag: Me,
-  meshnormal_vert: we,
-  meshnormal_frag: Ce,
-  meshphong_vert: Se,
-  meshphong_frag: Fe,
-  meshphysical_vert: ze,
-  meshphysical_frag: Ee,
-  meshtoon_vert: Ae,
-  meshtoon_frag: ke,
-  points_vert: De,
-  points_frag: Pe,
-  shadow_vert: Te,
-  shadow_frag: Le,
-  sprite_vert: Re,
-  sprite_frag: Be
-}, Ie = "", E = "srgb", W = "srgb-linear", Ne = "display-p3", ee = "display-p3-linear", H = "linear", Y = "srgb", Z = "rec709", Q = "p3";
-class f {
-  constructor(e, t, i, n, r, l, o, h, a) {
-    f.prototype.isMatrix3 = !0, this.elements = [
-      1,
-      0,
-      0,
-      0,
-      1,
-      0,
-      0,
-      0,
-      1
-    ], e !== void 0 && this.set(e, t, i, n, r, l, o, h, a);
-  }
-  set(e, t, i, n, r, l, o, h, a) {
-    const s = this.elements;
-    return s[0] = e, s[1] = n, s[2] = o, s[3] = t, s[4] = r, s[5] = h, s[6] = i, s[7] = l, s[8] = a, this;
-  }
-  identity() {
-    return this.set(
-      1,
-      0,
-      0,
-      0,
-      1,
-      0,
-      0,
-      0,
-      1
-    ), this;
-  }
-  copy(e) {
-    const t = this.elements, i = e.elements;
-    return t[0] = i[0], t[1] = i[1], t[2] = i[2], t[3] = i[3], t[4] = i[4], t[5] = i[5], t[6] = i[6], t[7] = i[7], t[8] = i[8], this;
-  }
-  extractBasis(e, t, i) {
-    return e.setFromMatrix3Column(this, 0), t.setFromMatrix3Column(this, 1), i.setFromMatrix3Column(this, 2), this;
-  }
-  setFromMatrix4(e) {
-    const t = e.elements;
-    return this.set(
-      t[0],
-      t[4],
-      t[8],
-      t[1],
-      t[5],
-      t[9],
-      t[2],
-      t[6],
-      t[10]
-    ), this;
-  }
-  multiply(e) {
-    return this.multiplyMatrices(this, e);
-  }
-  premultiply(e) {
-    return this.multiplyMatrices(e, this);
-  }
-  multiplyMatrices(e, t) {
-    const i = e.elements, n = t.elements, r = this.elements, l = i[0], o = i[3], h = i[6], a = i[1], s = i[4], u = i[7], p = i[2], d = i[5], _ = i[8], v = n[0], w = n[3], S = n[6], D = n[1], P = n[4], F = n[7], M = n[2], T = n[5], I = n[8];
-    return r[0] = l * v + o * D + h * M, r[3] = l * w + o * P + h * T, r[6] = l * S + o * F + h * I, r[1] = a * v + s * D + u * M, r[4] = a * w + s * P + u * T, r[7] = a * S + s * F + u * I, r[2] = p * v + d * D + _ * M, r[5] = p * w + d * P + _ * T, r[8] = p * S + d * F + _ * I, this;
-  }
-  multiplyScalar(e) {
-    const t = this.elements;
-    return t[0] *= e, t[3] *= e, t[6] *= e, t[1] *= e, t[4] *= e, t[7] *= e, t[2] *= e, t[5] *= e, t[8] *= e, this;
-  }
-  determinant() {
-    const e = this.elements, t = e[0], i = e[1], n = e[2], r = e[3], l = e[4], o = e[5], h = e[6], a = e[7], s = e[8];
-    return t * l * s - t * o * a - i * r * s + i * o * h + n * r * a - n * l * h;
-  }
-  invert() {
-    const e = this.elements, t = e[0], i = e[1], n = e[2], r = e[3], l = e[4], o = e[5], h = e[6], a = e[7], s = e[8], u = s * l - o * a, p = o * h - s * r, d = a * r - l * h, _ = t * u + i * p + n * d;
-    if (_ === 0) return this.set(0, 0, 0, 0, 0, 0, 0, 0, 0);
-    const v = 1 / _;
-    return e[0] = u * v, e[1] = (n * a - s * i) * v, e[2] = (o * i - n * l) * v, e[3] = p * v, e[4] = (s * t - n * h) * v, e[5] = (n * r - o * t) * v, e[6] = d * v, e[7] = (i * h - a * t) * v, e[8] = (l * t - i * r) * v, this;
-  }
-  transpose() {
-    let e;
-    const t = this.elements;
-    return e = t[1], t[1] = t[3], t[3] = e, e = t[2], t[2] = t[6], t[6] = e, e = t[5], t[5] = t[7], t[7] = e, this;
-  }
-  getNormalMatrix(e) {
-    return this.setFromMatrix4(e).invert().transpose();
-  }
-  transposeIntoArray(e) {
-    const t = this.elements;
-    return e[0] = t[0], e[1] = t[3], e[2] = t[6], e[3] = t[1], e[4] = t[4], e[5] = t[7], e[6] = t[2], e[7] = t[5], e[8] = t[8], this;
-  }
-  setUvTransform(e, t, i, n, r, l, o) {
-    const h = Math.cos(r), a = Math.sin(r);
-    return this.set(
-      i * h,
-      i * a,
-      -i * (h * l + a * o) + l + e,
-      -n * a,
-      n * h,
-      -n * (-a * l + h * o) + o + t,
-      0,
-      0,
-      1
-    ), this;
-  }
-  //
-  scale(e, t) {
-    return this.premultiply(N.makeScale(e, t)), this;
-  }
-  rotate(e) {
-    return this.premultiply(N.makeRotation(-e)), this;
-  }
-  translate(e, t) {
-    return this.premultiply(N.makeTranslation(e, t)), this;
-  }
-  // for 2D Transforms
-  makeTranslation(e, t) {
-    return e.isVector2 ? this.set(
-      1,
-      0,
-      e.x,
-      0,
-      1,
-      e.y,
-      0,
-      0,
-      1
-    ) : this.set(
-      1,
-      0,
-      e,
-      0,
-      1,
-      t,
-      0,
-      0,
-      1
-    ), this;
-  }
-  makeRotation(e) {
-    const t = Math.cos(e), i = Math.sin(e);
-    return this.set(
-      t,
-      -i,
-      0,
-      i,
-      t,
-      0,
-      0,
-      0,
-      1
-    ), this;
-  }
-  makeScale(e, t) {
-    return this.set(
-      e,
-      0,
-      0,
-      0,
-      t,
-      0,
-      0,
-      0,
-      1
-    ), this;
-  }
-  //
-  equals(e) {
-    const t = this.elements, i = e.elements;
-    for (let n = 0; n < 9; n++)
-      if (t[n] !== i[n]) return !1;
-    return !0;
-  }
-  fromArray(e, t = 0) {
-    for (let i = 0; i < 9; i++)
-      this.elements[i] = e[i + t];
-    return this;
-  }
-  toArray(e = [], t = 0) {
-    const i = this.elements;
-    return e[t] = i[0], e[t + 1] = i[1], e[t + 2] = i[2], e[t + 3] = i[3], e[t + 4] = i[4], e[t + 5] = i[5], e[t + 6] = i[6], e[t + 7] = i[7], e[t + 8] = i[8], e;
-  }
-  clone() {
-    return new this.constructor().fromArray(this.elements);
-  }
-}
-const N = /* @__PURE__ */ new f(), X = /* @__PURE__ */ new f().set(
-  0.8224621,
-  0.177538,
-  0,
-  0.0331941,
-  0.9668058,
-  0,
-  0.0170827,
-  0.0723974,
-  0.9105199
-), K = /* @__PURE__ */ new f().set(
-  1.2249401,
-  -0.2249404,
-  0,
-  -0.0420569,
-  1.0420571,
-  0,
-  -0.0196376,
-  -0.0786361,
-  1.0982735
-), L = {
-  [W]: {
-    transfer: H,
-    primaries: Z,
-    toReference: (m) => m,
-    fromReference: (m) => m
-  },
-  [E]: {
-    transfer: Y,
-    primaries: Z,
-    toReference: (m) => m.convertSRGBToLinear(),
-    fromReference: (m) => m.convertLinearToSRGB()
-  },
-  [ee]: {
-    transfer: H,
-    primaries: Q,
-    toReference: (m) => m.applyMatrix3(K),
-    fromReference: (m) => m.applyMatrix3(X)
-  },
-  [Ne]: {
-    transfer: Y,
-    primaries: Q,
-    toReference: (m) => m.convertSRGBToLinear().applyMatrix3(K),
-    fromReference: (m) => m.applyMatrix3(X).convertLinearToSRGB()
-  }
-}, Ue = /* @__PURE__ */ new Set([W, ee]), C = {
-  enabled: !0,
-  _workingColorSpace: W,
-  get workingColorSpace() {
-    return this._workingColorSpace;
-  },
-  set workingColorSpace(m) {
-    if (!Ue.has(m))
-      throw new Error(`Unsupported working color space, "${m}".`);
-    this._workingColorSpace = m;
-  },
-  convert: function(m, e, t) {
-    if (this.enabled === !1 || e === t || !e || !t)
-      return m;
-    const i = L[e].toReference, n = L[t].fromReference;
-    return n(i(m));
-  },
-  fromWorkingColorSpace: function(m, e) {
-    return this.convert(m, this._workingColorSpace, e);
-  },
-  toWorkingColorSpace: function(m, e) {
-    return this.convert(m, e, this._workingColorSpace);
-  },
-  getPrimaries: function(m) {
-    return L[m].primaries;
-  },
-  getTransfer: function(m) {
-    return m === Ie ? H : L[m].transfer;
-  }
-};
-function U(m) {
-  return m < 0.04045 ? m * 0.0773993808 : Math.pow(m * 0.9478672986 + 0.0521327014, 2.4);
-}
-function q(m) {
-  return m < 31308e-7 ? m * 12.92 : 1.055 * Math.pow(m, 0.41666) - 0.055;
-}
-function qe(m) {
-  const e = {};
-  for (const t in m) {
-    e[t] = {};
-    for (const i in m[t]) {
-      const n = m[t][i];
-      n && (n.isColor || n.isMatrix3 || n.isMatrix4 || n.isVector2 || n.isVector3 || n.isVector4 || n.isTexture || n.isQuaternion) ? n.isRenderTargetTexture ? (console.warn("UniformsUtils: Textures of render targets cannot be cloned via cloneUniforms() or mergeUniforms()."), e[t][i] = null) : e[t][i] = n.clone() : Array.isArray(n) ? e[t][i] = n.slice() : e[t][i] = n;
-    }
-  }
-  return e;
-}
-function b(m) {
-  const e = {};
-  for (let t = 0; t < m.length; t++) {
-    const i = qe(m[t]);
-    for (const n in i)
-      e[n] = i[n];
-  }
-  return e;
-}
-function A(m, e, t) {
-  return Math.max(e, Math.min(t, m));
-}
-function Ge(m, e) {
-  return (m % e + e) % e;
-}
-function G(m, e, t) {
-  return (1 - t) * m + t * e;
-}
-class k {
-  constructor(e = 0, t = 0) {
-    k.prototype.isVector2 = !0, this.x = e, this.y = t;
-  }
-  get width() {
-    return this.x;
-  }
-  set width(e) {
-    this.x = e;
-  }
-  get height() {
-    return this.y;
-  }
-  set height(e) {
-    this.y = e;
-  }
-  set(e, t) {
-    return this.x = e, this.y = t, this;
-  }
-  setScalar(e) {
-    return this.x = e, this.y = e, this;
-  }
-  setX(e) {
-    return this.x = e, this;
-  }
-  setY(e) {
-    return this.y = e, this;
-  }
-  setComponent(e, t) {
-    switch (e) {
-      case 0:
-        this.x = t;
-        break;
-      case 1:
-        this.y = t;
-        break;
-      default:
-        throw new Error("index is out of range: " + e);
-    }
-    return this;
-  }
-  getComponent(e) {
-    switch (e) {
-      case 0:
-        return this.x;
-      case 1:
-        return this.y;
-      default:
-        throw new Error("index is out of range: " + e);
-    }
-  }
-  clone() {
-    return new this.constructor(this.x, this.y);
-  }
-  copy(e) {
-    return this.x = e.x, this.y = e.y, this;
-  }
-  add(e) {
-    return this.x += e.x, this.y += e.y, this;
-  }
-  addScalar(e) {
-    return this.x += e, this.y += e, this;
-  }
-  addVectors(e, t) {
-    return this.x = e.x + t.x, this.y = e.y + t.y, this;
-  }
-  addScaledVector(e, t) {
-    return this.x += e.x * t, this.y += e.y * t, this;
-  }
-  sub(e) {
-    return this.x -= e.x, this.y -= e.y, this;
-  }
-  subScalar(e) {
-    return this.x -= e, this.y -= e, this;
-  }
-  subVectors(e, t) {
-    return this.x = e.x - t.x, this.y = e.y - t.y, this;
-  }
-  multiply(e) {
-    return this.x *= e.x, this.y *= e.y, this;
-  }
-  multiplyScalar(e) {
-    return this.x *= e, this.y *= e, this;
-  }
-  divide(e) {
-    return this.x /= e.x, this.y /= e.y, this;
-  }
-  divideScalar(e) {
-    return this.multiplyScalar(1 / e);
-  }
-  applyMatrix3(e) {
-    const t = this.x, i = this.y, n = e.elements;
-    return this.x = n[0] * t + n[3] * i + n[6], this.y = n[1] * t + n[4] * i + n[7], this;
-  }
-  min(e) {
-    return this.x = Math.min(this.x, e.x), this.y = Math.min(this.y, e.y), this;
-  }
-  max(e) {
-    return this.x = Math.max(this.x, e.x), this.y = Math.max(this.y, e.y), this;
-  }
-  clamp(e, t) {
-    return this.x = Math.max(e.x, Math.min(t.x, this.x)), this.y = Math.max(e.y, Math.min(t.y, this.y)), this;
-  }
-  clampScalar(e, t) {
-    return this.x = Math.max(e, Math.min(t, this.x)), this.y = Math.max(e, Math.min(t, this.y)), this;
-  }
-  clampLength(e, t) {
-    const i = this.length();
-    return this.divideScalar(i || 1).multiplyScalar(Math.max(e, Math.min(t, i)));
-  }
-  floor() {
-    return this.x = Math.floor(this.x), this.y = Math.floor(this.y), this;
-  }
-  ceil() {
-    return this.x = Math.ceil(this.x), this.y = Math.ceil(this.y), this;
-  }
-  round() {
-    return this.x = Math.round(this.x), this.y = Math.round(this.y), this;
-  }
-  roundToZero() {
-    return this.x = Math.trunc(this.x), this.y = Math.trunc(this.y), this;
-  }
-  negate() {
-    return this.x = -this.x, this.y = -this.y, this;
-  }
-  dot(e) {
-    return this.x * e.x + this.y * e.y;
-  }
-  cross(e) {
-    return this.x * e.y - this.y * e.x;
-  }
-  lengthSq() {
-    return this.x * this.x + this.y * this.y;
-  }
-  length() {
-    return Math.sqrt(this.x * this.x + this.y * this.y);
-  }
-  manhattanLength() {
-    return Math.abs(this.x) + Math.abs(this.y);
-  }
-  normalize() {
-    return this.divideScalar(this.length() || 1);
-  }
-  angle() {
-    return Math.atan2(-this.y, -this.x) + Math.PI;
-  }
-  angleTo(e) {
-    const t = Math.sqrt(this.lengthSq() * e.lengthSq());
-    if (t === 0) return Math.PI / 2;
-    const i = this.dot(e) / t;
-    return Math.acos(A(i, -1, 1));
-  }
-  distanceTo(e) {
-    return Math.sqrt(this.distanceToSquared(e));
-  }
-  distanceToSquared(e) {
-    const t = this.x - e.x, i = this.y - e.y;
-    return t * t + i * i;
-  }
-  manhattanDistanceTo(e) {
-    return Math.abs(this.x - e.x) + Math.abs(this.y - e.y);
-  }
-  setLength(e) {
-    return this.normalize().multiplyScalar(e);
-  }
-  lerp(e, t) {
-    return this.x += (e.x - this.x) * t, this.y += (e.y - this.y) * t, this;
-  }
-  lerpVectors(e, t, i) {
-    return this.x = e.x + (t.x - e.x) * i, this.y = e.y + (t.y - e.y) * i, this;
-  }
-  equals(e) {
-    return e.x === this.x && e.y === this.y;
-  }
-  fromArray(e, t = 0) {
-    return this.x = e[t], this.y = e[t + 1], this;
-  }
-  toArray(e = [], t = 0) {
-    return e[t] = this.x, e[t + 1] = this.y, e;
-  }
-  fromBufferAttribute(e, t) {
-    return this.x = e.getX(t), this.y = e.getY(t), this;
-  }
-  rotateAround(e, t) {
-    const i = Math.cos(t), n = Math.sin(t), r = this.x - e.x, l = this.y - e.y;
-    return this.x = r * i - l * n + e.x, this.y = r * n + l * i + e.y, this;
-  }
-  random() {
-    return this.x = Math.random(), this.y = Math.random(), this;
-  }
-  *[Symbol.iterator]() {
-    yield this.x, yield this.y;
-  }
-}
-class Ve {
-  constructor(e = 0, t = 0, i = 0, n = 1) {
-    this.isQuaternion = !0, this._x = e, this._y = t, this._z = i, this._w = n;
-  }
-  static slerpFlat(e, t, i, n, r, l, o) {
-    let h = i[n + 0], a = i[n + 1], s = i[n + 2], u = i[n + 3];
-    const p = r[l + 0], d = r[l + 1], _ = r[l + 2], v = r[l + 3];
-    if (o === 0) {
-      e[t + 0] = h, e[t + 1] = a, e[t + 2] = s, e[t + 3] = u;
-      return;
-    }
-    if (o === 1) {
-      e[t + 0] = p, e[t + 1] = d, e[t + 2] = _, e[t + 3] = v;
-      return;
-    }
-    if (u !== v || h !== p || a !== d || s !== _) {
-      let w = 1 - o;
-      const S = h * p + a * d + s * _ + u * v, D = S >= 0 ? 1 : -1, P = 1 - S * S;
-      if (P > Number.EPSILON) {
-        const M = Math.sqrt(P), T = Math.atan2(M, S * D);
-        w = Math.sin(w * T) / M, o = Math.sin(o * T) / M;
-      }
-      const F = o * D;
-      if (h = h * w + p * F, a = a * w + d * F, s = s * w + _ * F, u = u * w + v * F, w === 1 - o) {
-        const M = 1 / Math.sqrt(h * h + a * a + s * s + u * u);
-        h *= M, a *= M, s *= M, u *= M;
-      }
-    }
-    e[t] = h, e[t + 1] = a, e[t + 2] = s, e[t + 3] = u;
-  }
-  static multiplyQuaternionsFlat(e, t, i, n, r, l) {
-    const o = i[n], h = i[n + 1], a = i[n + 2], s = i[n + 3], u = r[l], p = r[l + 1], d = r[l + 2], _ = r[l + 3];
-    return e[t] = o * _ + s * u + h * d - a * p, e[t + 1] = h * _ + s * p + a * u - o * d, e[t + 2] = a * _ + s * d + o * p - h * u, e[t + 3] = s * _ - o * u - h * p - a * d, e;
-  }
-  get x() {
-    return this._x;
-  }
-  set x(e) {
-    this._x = e, this._onChangeCallback();
-  }
-  get y() {
-    return this._y;
-  }
-  set y(e) {
-    this._y = e, this._onChangeCallback();
-  }
-  get z() {
-    return this._z;
-  }
-  set z(e) {
-    this._z = e, this._onChangeCallback();
-  }
-  get w() {
-    return this._w;
-  }
-  set w(e) {
-    this._w = e, this._onChangeCallback();
-  }
-  set(e, t, i, n) {
-    return this._x = e, this._y = t, this._z = i, this._w = n, this._onChangeCallback(), this;
-  }
-  clone() {
-    return new this.constructor(this._x, this._y, this._z, this._w);
-  }
-  copy(e) {
-    return this._x = e.x, this._y = e.y, this._z = e.z, this._w = e.w, this._onChangeCallback(), this;
-  }
-  setFromEuler(e, t = !0) {
-    const i = e._x, n = e._y, r = e._z, l = e._order, o = Math.cos, h = Math.sin, a = o(i / 2), s = o(n / 2), u = o(r / 2), p = h(i / 2), d = h(n / 2), _ = h(r / 2);
-    switch (l) {
-      case "XYZ":
-        this._x = p * s * u + a * d * _, this._y = a * d * u - p * s * _, this._z = a * s * _ + p * d * u, this._w = a * s * u - p * d * _;
-        break;
-      case "YXZ":
-        this._x = p * s * u + a * d * _, this._y = a * d * u - p * s * _, this._z = a * s * _ - p * d * u, this._w = a * s * u + p * d * _;
-        break;
-      case "ZXY":
-        this._x = p * s * u - a * d * _, this._y = a * d * u + p * s * _, this._z = a * s * _ + p * d * u, this._w = a * s * u - p * d * _;
-        break;
-      case "ZYX":
-        this._x = p * s * u - a * d * _, this._y = a * d * u + p * s * _, this._z = a * s * _ - p * d * u, this._w = a * s * u + p * d * _;
-        break;
-      case "YZX":
-        this._x = p * s * u + a * d * _, this._y = a * d * u + p * s * _, this._z = a * s * _ - p * d * u, this._w = a * s * u - p * d * _;
-        break;
-      case "XZY":
-        this._x = p * s * u - a * d * _, this._y = a * d * u - p * s * _, this._z = a * s * _ + p * d * u, this._w = a * s * u + p * d * _;
-        break;
-      default:
-        console.warn("THREE.Quaternion: .setFromEuler() encountered an unknown order: " + l);
-    }
-    return t === !0 && this._onChangeCallback(), this;
-  }
-  setFromAxisAngle(e, t) {
-    const i = t / 2, n = Math.sin(i);
-    return this._x = e.x * n, this._y = e.y * n, this._z = e.z * n, this._w = Math.cos(i), this._onChangeCallback(), this;
-  }
-  setFromRotationMatrix(e) {
-    const t = e.elements, i = t[0], n = t[4], r = t[8], l = t[1], o = t[5], h = t[9], a = t[2], s = t[6], u = t[10], p = i + o + u;
-    if (p > 0) {
-      const d = 0.5 / Math.sqrt(p + 1);
-      this._w = 0.25 / d, this._x = (s - h) * d, this._y = (r - a) * d, this._z = (l - n) * d;
-    } else if (i > o && i > u) {
-      const d = 2 * Math.sqrt(1 + i - o - u);
-      this._w = (s - h) / d, this._x = 0.25 * d, this._y = (n + l) / d, this._z = (r + a) / d;
-    } else if (o > u) {
-      const d = 2 * Math.sqrt(1 + o - i - u);
-      this._w = (r - a) / d, this._x = (n + l) / d, this._y = 0.25 * d, this._z = (h + s) / d;
-    } else {
-      const d = 2 * Math.sqrt(1 + u - i - o);
-      this._w = (l - n) / d, this._x = (r + a) / d, this._y = (h + s) / d, this._z = 0.25 * d;
-    }
-    return this._onChangeCallback(), this;
-  }
-  setFromUnitVectors(e, t) {
-    let i = e.dot(t) + 1;
-    return i < Number.EPSILON ? (i = 0, Math.abs(e.x) > Math.abs(e.z) ? (this._x = -e.y, this._y = e.x, this._z = 0, this._w = i) : (this._x = 0, this._y = -e.z, this._z = e.y, this._w = i)) : (this._x = e.y * t.z - e.z * t.y, this._y = e.z * t.x - e.x * t.z, this._z = e.x * t.y - e.y * t.x, this._w = i), this.normalize();
-  }
-  angleTo(e) {
-    return 2 * Math.acos(Math.abs(A(this.dot(e), -1, 1)));
-  }
-  rotateTowards(e, t) {
-    const i = this.angleTo(e);
-    if (i === 0) return this;
-    const n = Math.min(1, t / i);
-    return this.slerp(e, n), this;
-  }
-  identity() {
-    return this.set(0, 0, 0, 1);
-  }
-  invert() {
-    return this.conjugate();
-  }
-  conjugate() {
-    return this._x *= -1, this._y *= -1, this._z *= -1, this._onChangeCallback(), this;
-  }
-  dot(e) {
-    return this._x * e._x + this._y * e._y + this._z * e._z + this._w * e._w;
-  }
-  lengthSq() {
-    return this._x * this._x + this._y * this._y + this._z * this._z + this._w * this._w;
-  }
-  length() {
-    return Math.sqrt(this._x * this._x + this._y * this._y + this._z * this._z + this._w * this._w);
-  }
-  normalize() {
-    let e = this.length();
-    return e === 0 ? (this._x = 0, this._y = 0, this._z = 0, this._w = 1) : (e = 1 / e, this._x = this._x * e, this._y = this._y * e, this._z = this._z * e, this._w = this._w * e), this._onChangeCallback(), this;
-  }
-  multiply(e) {
-    return this.multiplyQuaternions(this, e);
-  }
-  premultiply(e) {
-    return this.multiplyQuaternions(e, this);
-  }
-  multiplyQuaternions(e, t) {
-    const i = e._x, n = e._y, r = e._z, l = e._w, o = t._x, h = t._y, a = t._z, s = t._w;
-    return this._x = i * s + l * o + n * a - r * h, this._y = n * s + l * h + r * o - i * a, this._z = r * s + l * a + i * h - n * o, this._w = l * s - i * o - n * h - r * a, this._onChangeCallback(), this;
-  }
-  slerp(e, t) {
-    if (t === 0) return this;
-    if (t === 1) return this.copy(e);
-    const i = this._x, n = this._y, r = this._z, l = this._w;
-    let o = l * e._w + i * e._x + n * e._y + r * e._z;
-    if (o < 0 ? (this._w = -e._w, this._x = -e._x, this._y = -e._y, this._z = -e._z, o = -o) : this.copy(e), o >= 1)
-      return this._w = l, this._x = i, this._y = n, this._z = r, this;
-    const h = 1 - o * o;
-    if (h <= Number.EPSILON) {
-      const d = 1 - t;
-      return this._w = d * l + t * this._w, this._x = d * i + t * this._x, this._y = d * n + t * this._y, this._z = d * r + t * this._z, this.normalize(), this;
-    }
-    const a = Math.sqrt(h), s = Math.atan2(a, o), u = Math.sin((1 - t) * s) / a, p = Math.sin(t * s) / a;
-    return this._w = l * u + this._w * p, this._x = i * u + this._x * p, this._y = n * u + this._y * p, this._z = r * u + this._z * p, this._onChangeCallback(), this;
-  }
-  slerpQuaternions(e, t, i) {
-    return this.copy(e).slerp(t, i);
-  }
-  random() {
-    const e = 2 * Math.PI * Math.random(), t = 2 * Math.PI * Math.random(), i = Math.random(), n = Math.sqrt(1 - i), r = Math.sqrt(i);
-    return this.set(
-      n * Math.sin(e),
-      n * Math.cos(e),
-      r * Math.sin(t),
-      r * Math.cos(t)
-    );
-  }
-  equals(e) {
-    return e._x === this._x && e._y === this._y && e._z === this._z && e._w === this._w;
-  }
-  fromArray(e, t = 0) {
-    return this._x = e[t], this._y = e[t + 1], this._z = e[t + 2], this._w = e[t + 3], this._onChangeCallback(), this;
-  }
-  toArray(e = [], t = 0) {
-    return e[t] = this._x, e[t + 1] = this._y, e[t + 2] = this._z, e[t + 3] = this._w, e;
-  }
-  fromBufferAttribute(e, t) {
-    return this._x = e.getX(t), this._y = e.getY(t), this._z = e.getZ(t), this._w = e.getW(t), this._onChangeCallback(), this;
-  }
-  toJSON() {
-    return this.toArray();
-  }
-  _onChange(e) {
-    return this._onChangeCallback = e, this;
-  }
-  _onChangeCallback() {
-  }
-  *[Symbol.iterator]() {
-    yield this._x, yield this._y, yield this._z, yield this._w;
-  }
-}
-class B {
-  constructor(e = 0, t = 0, i = 0) {
-    B.prototype.isVector3 = !0, this.x = e, this.y = t, this.z = i;
-  }
-  set(e, t, i) {
-    return i === void 0 && (i = this.z), this.x = e, this.y = t, this.z = i, this;
-  }
-  setScalar(e) {
-    return this.x = e, this.y = e, this.z = e, this;
-  }
-  setX(e) {
-    return this.x = e, this;
-  }
-  setY(e) {
-    return this.y = e, this;
-  }
-  setZ(e) {
-    return this.z = e, this;
-  }
-  setComponent(e, t) {
-    switch (e) {
-      case 0:
-        this.x = t;
-        break;
-      case 1:
-        this.y = t;
-        break;
-      case 2:
-        this.z = t;
-        break;
-      default:
-        throw new Error("index is out of range: " + e);
-    }
-    return this;
-  }
-  getComponent(e) {
-    switch (e) {
-      case 0:
-        return this.x;
-      case 1:
-        return this.y;
-      case 2:
-        return this.z;
-      default:
-        throw new Error("index is out of range: " + e);
-    }
-  }
-  clone() {
-    return new this.constructor(this.x, this.y, this.z);
-  }
-  copy(e) {
-    return this.x = e.x, this.y = e.y, this.z = e.z, this;
-  }
-  add(e) {
-    return this.x += e.x, this.y += e.y, this.z += e.z, this;
-  }
-  addScalar(e) {
-    return this.x += e, this.y += e, this.z += e, this;
-  }
-  addVectors(e, t) {
-    return this.x = e.x + t.x, this.y = e.y + t.y, this.z = e.z + t.z, this;
-  }
-  addScaledVector(e, t) {
-    return this.x += e.x * t, this.y += e.y * t, this.z += e.z * t, this;
-  }
-  sub(e) {
-    return this.x -= e.x, this.y -= e.y, this.z -= e.z, this;
-  }
-  subScalar(e) {
-    return this.x -= e, this.y -= e, this.z -= e, this;
-  }
-  subVectors(e, t) {
-    return this.x = e.x - t.x, this.y = e.y - t.y, this.z = e.z - t.z, this;
-  }
-  multiply(e) {
-    return this.x *= e.x, this.y *= e.y, this.z *= e.z, this;
-  }
-  multiplyScalar(e) {
-    return this.x *= e, this.y *= e, this.z *= e, this;
-  }
-  multiplyVectors(e, t) {
-    return this.x = e.x * t.x, this.y = e.y * t.y, this.z = e.z * t.z, this;
-  }
-  applyEuler(e) {
-    return this.applyQuaternion(J.setFromEuler(e));
-  }
-  applyAxisAngle(e, t) {
-    return this.applyQuaternion(J.setFromAxisAngle(e, t));
-  }
-  applyMatrix3(e) {
-    const t = this.x, i = this.y, n = this.z, r = e.elements;
-    return this.x = r[0] * t + r[3] * i + r[6] * n, this.y = r[1] * t + r[4] * i + r[7] * n, this.z = r[2] * t + r[5] * i + r[8] * n, this;
-  }
-  applyNormalMatrix(e) {
-    return this.applyMatrix3(e).normalize();
-  }
-  applyMatrix4(e) {
-    const t = this.x, i = this.y, n = this.z, r = e.elements, l = 1 / (r[3] * t + r[7] * i + r[11] * n + r[15]);
-    return this.x = (r[0] * t + r[4] * i + r[8] * n + r[12]) * l, this.y = (r[1] * t + r[5] * i + r[9] * n + r[13]) * l, this.z = (r[2] * t + r[6] * i + r[10] * n + r[14]) * l, this;
-  }
-  applyQuaternion(e) {
-    const t = this.x, i = this.y, n = this.z, r = e.x, l = e.y, o = e.z, h = e.w, a = 2 * (l * n - o * i), s = 2 * (o * t - r * n), u = 2 * (r * i - l * t);
-    return this.x = t + h * a + l * u - o * s, this.y = i + h * s + o * a - r * u, this.z = n + h * u + r * s - l * a, this;
-  }
-  project(e) {
-    return this.applyMatrix4(e.matrixWorldInverse).applyMatrix4(e.projectionMatrix);
-  }
-  unproject(e) {
-    return this.applyMatrix4(e.projectionMatrixInverse).applyMatrix4(e.matrixWorld);
-  }
-  transformDirection(e) {
-    const t = this.x, i = this.y, n = this.z, r = e.elements;
-    return this.x = r[0] * t + r[4] * i + r[8] * n, this.y = r[1] * t + r[5] * i + r[9] * n, this.z = r[2] * t + r[6] * i + r[10] * n, this.normalize();
-  }
-  divide(e) {
-    return this.x /= e.x, this.y /= e.y, this.z /= e.z, this;
-  }
-  divideScalar(e) {
-    return this.multiplyScalar(1 / e);
-  }
-  min(e) {
-    return this.x = Math.min(this.x, e.x), this.y = Math.min(this.y, e.y), this.z = Math.min(this.z, e.z), this;
-  }
-  max(e) {
-    return this.x = Math.max(this.x, e.x), this.y = Math.max(this.y, e.y), this.z = Math.max(this.z, e.z), this;
-  }
-  clamp(e, t) {
-    return this.x = Math.max(e.x, Math.min(t.x, this.x)), this.y = Math.max(e.y, Math.min(t.y, this.y)), this.z = Math.max(e.z, Math.min(t.z, this.z)), this;
-  }
-  clampScalar(e, t) {
-    return this.x = Math.max(e, Math.min(t, this.x)), this.y = Math.max(e, Math.min(t, this.y)), this.z = Math.max(e, Math.min(t, this.z)), this;
-  }
-  clampLength(e, t) {
-    const i = this.length();
-    return this.divideScalar(i || 1).multiplyScalar(Math.max(e, Math.min(t, i)));
-  }
-  floor() {
-    return this.x = Math.floor(this.x), this.y = Math.floor(this.y), this.z = Math.floor(this.z), this;
-  }
-  ceil() {
-    return this.x = Math.ceil(this.x), this.y = Math.ceil(this.y), this.z = Math.ceil(this.z), this;
-  }
-  round() {
-    return this.x = Math.round(this.x), this.y = Math.round(this.y), this.z = Math.round(this.z), this;
-  }
-  roundToZero() {
-    return this.x = Math.trunc(this.x), this.y = Math.trunc(this.y), this.z = Math.trunc(this.z), this;
-  }
-  negate() {
-    return this.x = -this.x, this.y = -this.y, this.z = -this.z, this;
-  }
-  dot(e) {
-    return this.x * e.x + this.y * e.y + this.z * e.z;
-  }
-  // TODO lengthSquared?
-  lengthSq() {
-    return this.x * this.x + this.y * this.y + this.z * this.z;
-  }
-  length() {
-    return Math.sqrt(this.x * this.x + this.y * this.y + this.z * this.z);
-  }
-  manhattanLength() {
-    return Math.abs(this.x) + Math.abs(this.y) + Math.abs(this.z);
-  }
-  normalize() {
-    return this.divideScalar(this.length() || 1);
-  }
-  setLength(e) {
-    return this.normalize().multiplyScalar(e);
-  }
-  lerp(e, t) {
-    return this.x += (e.x - this.x) * t, this.y += (e.y - this.y) * t, this.z += (e.z - this.z) * t, this;
-  }
-  lerpVectors(e, t, i) {
-    return this.x = e.x + (t.x - e.x) * i, this.y = e.y + (t.y - e.y) * i, this.z = e.z + (t.z - e.z) * i, this;
-  }
-  cross(e) {
-    return this.crossVectors(this, e);
-  }
-  crossVectors(e, t) {
-    const i = e.x, n = e.y, r = e.z, l = t.x, o = t.y, h = t.z;
-    return this.x = n * h - r * o, this.y = r * l - i * h, this.z = i * o - n * l, this;
-  }
-  projectOnVector(e) {
-    const t = e.lengthSq();
-    if (t === 0) return this.set(0, 0, 0);
-    const i = e.dot(this) / t;
-    return this.copy(e).multiplyScalar(i);
-  }
-  projectOnPlane(e) {
-    return V.copy(this).projectOnVector(e), this.sub(V);
-  }
-  reflect(e) {
-    return this.sub(V.copy(e).multiplyScalar(2 * this.dot(e)));
-  }
-  angleTo(e) {
-    const t = Math.sqrt(this.lengthSq() * e.lengthSq());
-    if (t === 0) return Math.PI / 2;
-    const i = this.dot(e) / t;
-    return Math.acos(A(i, -1, 1));
-  }
-  distanceTo(e) {
-    return Math.sqrt(this.distanceToSquared(e));
-  }
-  distanceToSquared(e) {
-    const t = this.x - e.x, i = this.y - e.y, n = this.z - e.z;
-    return t * t + i * i + n * n;
-  }
-  manhattanDistanceTo(e) {
-    return Math.abs(this.x - e.x) + Math.abs(this.y - e.y) + Math.abs(this.z - e.z);
-  }
-  setFromSpherical(e) {
-    return this.setFromSphericalCoords(e.radius, e.phi, e.theta);
-  }
-  setFromSphericalCoords(e, t, i) {
-    const n = Math.sin(t) * e;
-    return this.x = n * Math.sin(i), this.y = Math.cos(t) * e, this.z = n * Math.cos(i), this;
-  }
-  setFromCylindrical(e) {
-    return this.setFromCylindricalCoords(e.radius, e.theta, e.y);
-  }
-  setFromCylindricalCoords(e, t, i) {
-    return this.x = e * Math.sin(t), this.y = i, this.z = e * Math.cos(t), this;
-  }
-  setFromMatrixPosition(e) {
-    const t = e.elements;
-    return this.x = t[12], this.y = t[13], this.z = t[14], this;
-  }
-  setFromMatrixScale(e) {
-    const t = this.setFromMatrixColumn(e, 0).length(), i = this.setFromMatrixColumn(e, 1).length(), n = this.setFromMatrixColumn(e, 2).length();
-    return this.x = t, this.y = i, this.z = n, this;
-  }
-  setFromMatrixColumn(e, t) {
-    return this.fromArray(e.elements, t * 4);
-  }
-  setFromMatrix3Column(e, t) {
-    return this.fromArray(e.elements, t * 3);
-  }
-  setFromEuler(e) {
-    return this.x = e._x, this.y = e._y, this.z = e._z, this;
-  }
-  setFromColor(e) {
-    return this.x = e.r, this.y = e.g, this.z = e.b, this;
-  }
-  equals(e) {
-    return e.x === this.x && e.y === this.y && e.z === this.z;
-  }
-  fromArray(e, t = 0) {
-    return this.x = e[t], this.y = e[t + 1], this.z = e[t + 2], this;
-  }
-  toArray(e = [], t = 0) {
-    return e[t] = this.x, e[t + 1] = this.y, e[t + 2] = this.z, e;
-  }
-  fromBufferAttribute(e, t) {
-    return this.x = e.getX(t), this.y = e.getY(t), this.z = e.getZ(t), this;
-  }
-  random() {
-    return this.x = Math.random(), this.y = Math.random(), this.z = Math.random(), this;
-  }
-  randomDirection() {
-    const e = Math.random() * Math.PI * 2, t = Math.random() * 2 - 1, i = Math.sqrt(1 - t * t);
-    return this.x = i * Math.cos(e), this.y = t, this.z = i * Math.sin(e), this;
-  }
-  *[Symbol.iterator]() {
-    yield this.x, yield this.y, yield this.z;
-  }
-}
-const V = /* @__PURE__ */ new B(), J = /* @__PURE__ */ new Ve(), te = {
-  aliceblue: 15792383,
-  antiquewhite: 16444375,
-  aqua: 65535,
-  aquamarine: 8388564,
-  azure: 15794175,
-  beige: 16119260,
-  bisque: 16770244,
-  black: 0,
-  blanchedalmond: 16772045,
-  blue: 255,
-  blueviolet: 9055202,
-  brown: 10824234,
-  burlywood: 14596231,
-  cadetblue: 6266528,
-  chartreuse: 8388352,
-  chocolate: 13789470,
-  coral: 16744272,
-  cornflowerblue: 6591981,
-  cornsilk: 16775388,
-  crimson: 14423100,
-  cyan: 65535,
-  darkblue: 139,
-  darkcyan: 35723,
-  darkgoldenrod: 12092939,
-  darkgray: 11119017,
-  darkgreen: 25600,
-  darkgrey: 11119017,
-  darkkhaki: 12433259,
-  darkmagenta: 9109643,
-  darkolivegreen: 5597999,
-  darkorange: 16747520,
-  darkorchid: 10040012,
-  darkred: 9109504,
-  darksalmon: 15308410,
-  darkseagreen: 9419919,
-  darkslateblue: 4734347,
-  darkslategray: 3100495,
-  darkslategrey: 3100495,
-  darkturquoise: 52945,
-  darkviolet: 9699539,
-  deeppink: 16716947,
-  deepskyblue: 49151,
-  dimgray: 6908265,
-  dimgrey: 6908265,
-  dodgerblue: 2003199,
-  firebrick: 11674146,
-  floralwhite: 16775920,
-  forestgreen: 2263842,
-  fuchsia: 16711935,
-  gainsboro: 14474460,
-  ghostwhite: 16316671,
-  gold: 16766720,
-  goldenrod: 14329120,
-  gray: 8421504,
-  green: 32768,
-  greenyellow: 11403055,
-  grey: 8421504,
-  honeydew: 15794160,
-  hotpink: 16738740,
-  indianred: 13458524,
-  indigo: 4915330,
-  ivory: 16777200,
-  khaki: 15787660,
-  lavender: 15132410,
-  lavenderblush: 16773365,
-  lawngreen: 8190976,
-  lemonchiffon: 16775885,
-  lightblue: 11393254,
-  lightcoral: 15761536,
-  lightcyan: 14745599,
-  lightgoldenrodyellow: 16448210,
-  lightgray: 13882323,
-  lightgreen: 9498256,
-  lightgrey: 13882323,
-  lightpink: 16758465,
-  lightsalmon: 16752762,
-  lightseagreen: 2142890,
-  lightskyblue: 8900346,
-  lightslategray: 7833753,
-  lightslategrey: 7833753,
-  lightsteelblue: 11584734,
-  lightyellow: 16777184,
-  lime: 65280,
-  limegreen: 3329330,
-  linen: 16445670,
-  magenta: 16711935,
-  maroon: 8388608,
-  mediumaquamarine: 6737322,
-  mediumblue: 205,
-  mediumorchid: 12211667,
-  mediumpurple: 9662683,
-  mediumseagreen: 3978097,
-  mediumslateblue: 8087790,
-  mediumspringgreen: 64154,
-  mediumturquoise: 4772300,
-  mediumvioletred: 13047173,
-  midnightblue: 1644912,
-  mintcream: 16121850,
-  mistyrose: 16770273,
-  moccasin: 16770229,
-  navajowhite: 16768685,
-  navy: 128,
-  oldlace: 16643558,
-  olive: 8421376,
-  olivedrab: 7048739,
-  orange: 16753920,
-  orangered: 16729344,
-  orchid: 14315734,
-  palegoldenrod: 15657130,
-  palegreen: 10025880,
-  paleturquoise: 11529966,
-  palevioletred: 14381203,
-  papayawhip: 16773077,
-  peachpuff: 16767673,
-  peru: 13468991,
-  pink: 16761035,
-  plum: 14524637,
-  powderblue: 11591910,
-  purple: 8388736,
-  rebeccapurple: 6697881,
-  red: 16711680,
-  rosybrown: 12357519,
-  royalblue: 4286945,
-  saddlebrown: 9127187,
-  salmon: 16416882,
-  sandybrown: 16032864,
-  seagreen: 3050327,
-  seashell: 16774638,
-  sienna: 10506797,
-  silver: 12632256,
-  skyblue: 8900331,
-  slateblue: 6970061,
-  slategray: 7372944,
-  slategrey: 7372944,
-  snow: 16775930,
-  springgreen: 65407,
-  steelblue: 4620980,
-  tan: 13808780,
-  teal: 32896,
-  thistle: 14204888,
-  tomato: 16737095,
-  turquoise: 4251856,
-  violet: 15631086,
-  wheat: 16113331,
-  white: 16777215,
-  whitesmoke: 16119285,
-  yellow: 16776960,
-  yellowgreen: 10145074
-}, z = { h: 0, s: 0, l: 0 }, R = { h: 0, s: 0, l: 0 };
-function j(m, e, t) {
-  return t < 0 && (t += 1), t > 1 && (t -= 1), t < 1 / 6 ? m + (e - m) * 6 * t : t < 1 / 2 ? e : t < 2 / 3 ? m + (e - m) * 6 * (2 / 3 - t) : m;
-}
-class y {
-  constructor(e, t, i) {
-    return this.isColor = !0, this.r = 1, this.g = 1, this.b = 1, this.set(e, t, i);
-  }
-  set(e, t, i) {
-    if (t === void 0 && i === void 0) {
-      const n = e;
-      n && n.isColor ? this.copy(n) : typeof n == "number" ? this.setHex(n) : typeof n == "string" && this.setStyle(n);
-    } else
-      this.setRGB(e, t, i);
-    return this;
-  }
-  setScalar(e) {
-    return this.r = e, this.g = e, this.b = e, this;
-  }
-  setHex(e, t = E) {
-    return e = Math.floor(e), this.r = (e >> 16 & 255) / 255, this.g = (e >> 8 & 255) / 255, this.b = (e & 255) / 255, C.toWorkingColorSpace(this, t), this;
-  }
-  setRGB(e, t, i, n = C.workingColorSpace) {
-    return this.r = e, this.g = t, this.b = i, C.toWorkingColorSpace(this, n), this;
-  }
-  setHSL(e, t, i, n = C.workingColorSpace) {
-    if (e = Ge(e, 1), t = A(t, 0, 1), i = A(i, 0, 1), t === 0)
-      this.r = this.g = this.b = i;
-    else {
-      const r = i <= 0.5 ? i * (1 + t) : i + t - i * t, l = 2 * i - r;
-      this.r = j(l, r, e + 1 / 3), this.g = j(l, r, e), this.b = j(l, r, e - 1 / 3);
-    }
-    return C.toWorkingColorSpace(this, n), this;
-  }
-  setStyle(e, t = E) {
-    function i(r) {
-      r !== void 0 && parseFloat(r) < 1 && console.warn("THREE.Color: Alpha component of " + e + " will be ignored.");
-    }
-    let n;
-    if (n = /^(\w+)\(([^\)]*)\)/.exec(e)) {
-      let r;
-      const l = n[1], o = n[2];
-      switch (l) {
-        case "rgb":
-        case "rgba":
-          if (r = /^\s*(\d+)\s*,\s*(\d+)\s*,\s*(\d+)\s*(?:,\s*(\d*\.?\d+)\s*)?$/.exec(o))
-            return i(r[4]), this.setRGB(
-              Math.min(255, parseInt(r[1], 10)) / 255,
-              Math.min(255, parseInt(r[2], 10)) / 255,
-              Math.min(255, parseInt(r[3], 10)) / 255,
-              t
-            );
-          if (r = /^\s*(\d+)\%\s*,\s*(\d+)\%\s*,\s*(\d+)\%\s*(?:,\s*(\d*\.?\d+)\s*)?$/.exec(o))
-            return i(r[4]), this.setRGB(
-              Math.min(100, parseInt(r[1], 10)) / 100,
-              Math.min(100, parseInt(r[2], 10)) / 100,
-              Math.min(100, parseInt(r[3], 10)) / 100,
-              t
-            );
-          break;
-        case "hsl":
-        case "hsla":
-          if (r = /^\s*(\d*\.?\d+)\s*,\s*(\d*\.?\d+)\%\s*,\s*(\d*\.?\d+)\%\s*(?:,\s*(\d*\.?\d+)\s*)?$/.exec(o))
-            return i(r[4]), this.setHSL(
-              parseFloat(r[1]) / 360,
-              parseFloat(r[2]) / 100,
-              parseFloat(r[3]) / 100,
-              t
-            );
-          break;
-        default:
-          console.warn("THREE.Color: Unknown color model " + e);
-      }
-    } else if (n = /^\#([A-Fa-f\d]+)$/.exec(e)) {
-      const r = n[1], l = r.length;
-      if (l === 3)
-        return this.setRGB(
-          parseInt(r.charAt(0), 16) / 15,
-          parseInt(r.charAt(1), 16) / 15,
-          parseInt(r.charAt(2), 16) / 15,
-          t
-        );
-      if (l === 6)
-        return this.setHex(parseInt(r, 16), t);
-      console.warn("THREE.Color: Invalid hex color " + e);
-    } else if (e && e.length > 0)
-      return this.setColorName(e, t);
-    return this;
-  }
-  setColorName(e, t = E) {
-    const i = te[e.toLowerCase()];
-    return i !== void 0 ? this.setHex(i, t) : console.warn("THREE.Color: Unknown color " + e), this;
-  }
-  clone() {
-    return new this.constructor(this.r, this.g, this.b);
-  }
-  copy(e) {
-    return this.r = e.r, this.g = e.g, this.b = e.b, this;
-  }
-  copySRGBToLinear(e) {
-    return this.r = U(e.r), this.g = U(e.g), this.b = U(e.b), this;
-  }
-  copyLinearToSRGB(e) {
-    return this.r = q(e.r), this.g = q(e.g), this.b = q(e.b), this;
-  }
-  convertSRGBToLinear() {
-    return this.copySRGBToLinear(this), this;
-  }
-  convertLinearToSRGB() {
-    return this.copyLinearToSRGB(this), this;
-  }
-  getHex(e = E) {
-    return C.fromWorkingColorSpace(x.copy(this), e), Math.round(A(x.r * 255, 0, 255)) * 65536 + Math.round(A(x.g * 255, 0, 255)) * 256 + Math.round(A(x.b * 255, 0, 255));
-  }
-  getHexString(e = E) {
-    return ("000000" + this.getHex(e).toString(16)).slice(-6);
-  }
-  getHSL(e, t = C.workingColorSpace) {
-    C.fromWorkingColorSpace(x.copy(this), t);
-    const i = x.r, n = x.g, r = x.b, l = Math.max(i, n, r), o = Math.min(i, n, r);
-    let h, a;
-    const s = (o + l) / 2;
-    if (o === l)
-      h = 0, a = 0;
-    else {
-      const u = l - o;
-      switch (a = s <= 0.5 ? u / (l + o) : u / (2 - l - o), l) {
-        case i:
-          h = (n - r) / u + (n < r ? 6 : 0);
-          break;
-        case n:
-          h = (r - i) / u + 2;
-          break;
-        case r:
-          h = (i - n) / u + 4;
-          break;
-      }
-      h /= 6;
-    }
-    return e.h = h, e.s = a, e.l = s, e;
-  }
-  getRGB(e, t = C.workingColorSpace) {
-    return C.fromWorkingColorSpace(x.copy(this), t), e.r = x.r, e.g = x.g, e.b = x.b, e;
-  }
-  getStyle(e = E) {
-    C.fromWorkingColorSpace(x.copy(this), e);
-    const t = x.r, i = x.g, n = x.b;
-    return e !== E ? `color(${e} ${t.toFixed(3)} ${i.toFixed(3)} ${n.toFixed(3)})` : `rgb(${Math.round(t * 255)},${Math.round(i * 255)},${Math.round(n * 255)})`;
-  }
-  offsetHSL(e, t, i) {
-    return this.getHSL(z), this.setHSL(z.h + e, z.s + t, z.l + i);
-  }
-  add(e) {
-    return this.r += e.r, this.g += e.g, this.b += e.b, this;
-  }
-  addColors(e, t) {
-    return this.r = e.r + t.r, this.g = e.g + t.g, this.b = e.b + t.b, this;
-  }
-  addScalar(e) {
-    return this.r += e, this.g += e, this.b += e, this;
-  }
-  sub(e) {
-    return this.r = Math.max(0, this.r - e.r), this.g = Math.max(0, this.g - e.g), this.b = Math.max(0, this.b - e.b), this;
-  }
-  multiply(e) {
-    return this.r *= e.r, this.g *= e.g, this.b *= e.b, this;
-  }
-  multiplyScalar(e) {
-    return this.r *= e, this.g *= e, this.b *= e, this;
-  }
-  lerp(e, t) {
-    return this.r += (e.r - this.r) * t, this.g += (e.g - this.g) * t, this.b += (e.b - this.b) * t, this;
-  }
-  lerpColors(e, t, i) {
-    return this.r = e.r + (t.r - e.r) * i, this.g = e.g + (t.g - e.g) * i, this.b = e.b + (t.b - e.b) * i, this;
-  }
-  lerpHSL(e, t) {
-    this.getHSL(z), e.getHSL(R);
-    const i = G(z.h, R.h, t), n = G(z.s, R.s, t), r = G(z.l, R.l, t);
-    return this.setHSL(i, n, r), this;
-  }
-  setFromVector3(e) {
-    return this.r = e.x, this.g = e.y, this.b = e.z, this;
-  }
-  applyMatrix3(e) {
-    const t = this.r, i = this.g, n = this.b, r = e.elements;
-    return this.r = r[0] * t + r[3] * i + r[6] * n, this.g = r[1] * t + r[4] * i + r[7] * n, this.b = r[2] * t + r[5] * i + r[8] * n, this;
-  }
-  equals(e) {
-    return e.r === this.r && e.g === this.g && e.b === this.b;
-  }
-  fromArray(e, t = 0) {
-    return this.r = e[t], this.g = e[t + 1], this.b = e[t + 2], this;
-  }
-  toArray(e = [], t = 0) {
-    return e[t] = this.r, e[t + 1] = this.g, e[t + 2] = this.b, e;
-  }
-  fromBufferAttribute(e, t) {
-    return this.r = e.getX(t), this.g = e.getY(t), this.b = e.getZ(t), this;
-  }
-  toJSON() {
-    return this.getHex();
-  }
-  *[Symbol.iterator]() {
-    yield this.r, yield this.g, yield this.b;
-  }
-}
-const x = /* @__PURE__ */ new y();
-y.NAMES = te;
-const c = {
-  common: {
-    diffuse: { value: /* @__PURE__ */ new y(16777215) },
-    opacity: { value: 1 },
-    map: { value: null },
-    mapTransform: { value: /* @__PURE__ */ new f() },
-    alphaMap: { value: null },
-    alphaMapTransform: { value: /* @__PURE__ */ new f() },
-    alphaTest: { value: 0 }
-  },
-  specularmap: {
-    specularMap: { value: null },
-    specularMapTransform: { value: /* @__PURE__ */ new f() }
-  },
-  envmap: {
-    envMap: { value: null },
-    envMapRotation: { value: /* @__PURE__ */ new f() },
-    flipEnvMap: { value: -1 },
-    reflectivity: { value: 1 },
-    // basic, lambert, phong
-    ior: { value: 1.5 },
-    // physical
-    refractionRatio: { value: 0.98 }
-    // basic, lambert, phong
-  },
-  aomap: {
-    aoMap: { value: null },
-    aoMapIntensity: { value: 1 },
-    aoMapTransform: { value: /* @__PURE__ */ new f() }
-  },
-  lightmap: {
-    lightMap: { value: null },
-    lightMapIntensity: { value: 1 },
-    lightMapTransform: { value: /* @__PURE__ */ new f() }
-  },
-  bumpmap: {
-    bumpMap: { value: null },
-    bumpMapTransform: { value: /* @__PURE__ */ new f() },
-    bumpScale: { value: 1 }
-  },
-  normalmap: {
-    normalMap: { value: null },
-    normalMapTransform: { value: /* @__PURE__ */ new f() },
-    normalScale: { value: /* @__PURE__ */ new k(1, 1) }
-  },
-  displacementmap: {
-    displacementMap: { value: null },
-    displacementMapTransform: { value: /* @__PURE__ */ new f() },
-    displacementScale: { value: 1 },
-    displacementBias: { value: 0 }
-  },
-  emissivemap: {
-    emissiveMap: { value: null },
-    emissiveMapTransform: { value: /* @__PURE__ */ new f() }
-  },
-  metalnessmap: {
-    metalnessMap: { value: null },
-    metalnessMapTransform: { value: /* @__PURE__ */ new f() }
-  },
-  roughnessmap: {
-    roughnessMap: { value: null },
-    roughnessMapTransform: { value: /* @__PURE__ */ new f() }
-  },
-  gradientmap: {
-    gradientMap: { value: null }
-  },
-  fog: {
-    fogDensity: { value: 25e-5 },
-    fogNear: { value: 1 },
-    fogFar: { value: 2e3 },
-    fogColor: { value: /* @__PURE__ */ new y(16777215) }
-  },
-  lights: {
-    ambientLightColor: { value: [] },
-    lightProbe: { value: [] },
-    directionalLights: { value: [], properties: {
-      direction: {},
-      color: {}
-    } },
-    directionalLightShadows: { value: [], properties: {
-      shadowBias: {},
-      shadowNormalBias: {},
-      shadowRadius: {},
-      shadowMapSize: {}
-    } },
-    directionalShadowMap: { value: [] },
-    directionalShadowMatrix: { value: [] },
-    spotLights: { value: [], properties: {
-      color: {},
-      position: {},
-      direction: {},
-      distance: {},
-      coneCos: {},
-      penumbraCos: {},
-      decay: {}
-    } },
-    spotLightShadows: { value: [], properties: {
-      shadowBias: {},
-      shadowNormalBias: {},
-      shadowRadius: {},
-      shadowMapSize: {}
-    } },
-    spotLightMap: { value: [] },
-    spotShadowMap: { value: [] },
-    spotLightMatrix: { value: [] },
-    pointLights: { value: [], properties: {
-      color: {},
-      position: {},
-      decay: {},
-      distance: {}
-    } },
-    pointLightShadows: { value: [], properties: {
-      shadowBias: {},
-      shadowNormalBias: {},
-      shadowRadius: {},
-      shadowMapSize: {},
-      shadowCameraNear: {},
-      shadowCameraFar: {}
-    } },
-    pointShadowMap: { value: [] },
-    pointShadowMatrix: { value: [] },
-    hemisphereLights: { value: [], properties: {
-      direction: {},
-      skyColor: {},
-      groundColor: {}
-    } },
-    // TODO (abelnation): RectAreaLight BRDF data needs to be moved from example to main src
-    rectAreaLights: { value: [], properties: {
-      color: {},
-      position: {},
-      width: {},
-      height: {}
-    } },
-    ltc_1: { value: null },
-    ltc_2: { value: null }
-  },
-  points: {
-    diffuse: { value: /* @__PURE__ */ new y(16777215) },
-    opacity: { value: 1 },
-    size: { value: 1 },
-    scale: { value: 1 },
-    map: { value: null },
-    alphaMap: { value: null },
-    alphaMapTransform: { value: /* @__PURE__ */ new f() },
-    alphaTest: { value: 0 },
-    uvTransform: { value: /* @__PURE__ */ new f() }
-  },
-  sprite: {
-    diffuse: { value: /* @__PURE__ */ new y(16777215) },
-    opacity: { value: 1 },
-    center: { value: /* @__PURE__ */ new k(0.5, 0.5) },
-    rotation: { value: 0 },
-    map: { value: null },
-    mapTransform: { value: /* @__PURE__ */ new f() },
-    alphaMap: { value: null },
-    alphaMapTransform: { value: /* @__PURE__ */ new f() },
-    alphaTest: { value: 0 }
-  }
-}, $ = {
-  basic: {
-    uniforms: /* @__PURE__ */ b([
-      c.common,
-      c.specularmap,
-      c.envmap,
-      c.aomap,
-      c.lightmap,
-      c.fog
-    ]),
-    vertexShader: g.meshbasic_vert,
-    fragmentShader: g.meshbasic_frag
-  },
-  lambert: {
-    uniforms: /* @__PURE__ */ b([
-      c.common,
-      c.specularmap,
-      c.envmap,
-      c.aomap,
-      c.lightmap,
-      c.emissivemap,
-      c.bumpmap,
-      c.normalmap,
-      c.displacementmap,
-      c.fog,
-      c.lights,
-      {
-        emissive: { value: /* @__PURE__ */ new y(0) }
-      }
-    ]),
-    vertexShader: g.meshlambert_vert,
-    fragmentShader: g.meshlambert_frag
-  },
-  phong: {
-    uniforms: /* @__PURE__ */ b([
-      c.common,
-      c.specularmap,
-      c.envmap,
-      c.aomap,
-      c.lightmap,
-      c.emissivemap,
-      c.bumpmap,
-      c.normalmap,
-      c.displacementmap,
-      c.fog,
-      c.lights,
-      {
-        emissive: { value: /* @__PURE__ */ new y(0) },
-        specular: { value: /* @__PURE__ */ new y(1118481) },
-        shininess: { value: 30 }
-      }
-    ]),
-    vertexShader: g.meshphong_vert,
-    fragmentShader: g.meshphong_frag
-  },
-  standard: {
-    uniforms: /* @__PURE__ */ b([
-      c.common,
-      c.envmap,
-      c.aomap,
-      c.lightmap,
-      c.emissivemap,
-      c.bumpmap,
-      c.normalmap,
-      c.displacementmap,
-      c.roughnessmap,
-      c.metalnessmap,
-      c.fog,
-      c.lights,
-      {
-        emissive: { value: /* @__PURE__ */ new y(0) },
-        roughness: { value: 1 },
-        metalness: { value: 0 },
-        envMapIntensity: { value: 1 }
-      }
-    ]),
-    vertexShader: g.meshphysical_vert,
-    fragmentShader: g.meshphysical_frag
-  },
-  toon: {
-    uniforms: /* @__PURE__ */ b([
-      c.common,
-      c.aomap,
-      c.lightmap,
-      c.emissivemap,
-      c.bumpmap,
-      c.normalmap,
-      c.displacementmap,
-      c.gradientmap,
-      c.fog,
-      c.lights,
-      {
-        emissive: { value: /* @__PURE__ */ new y(0) }
-      }
-    ]),
-    vertexShader: g.meshtoon_vert,
-    fragmentShader: g.meshtoon_frag
-  },
-  matcap: {
-    uniforms: /* @__PURE__ */ b([
-      c.common,
-      c.bumpmap,
-      c.normalmap,
-      c.displacementmap,
-      c.fog,
-      {
-        matcap: { value: null }
-      }
-    ]),
-    vertexShader: g.meshmatcap_vert,
-    fragmentShader: g.meshmatcap_frag
-  },
-  points: {
-    uniforms: /* @__PURE__ */ b([
-      c.points,
-      c.fog
-    ]),
-    vertexShader: g.points_vert,
-    fragmentShader: g.points_frag
-  },
-  dashed: {
-    uniforms: /* @__PURE__ */ b([
-      c.common,
-      c.fog,
-      {
-        scale: { value: 1 },
-        dashSize: { value: 1 },
-        totalSize: { value: 2 }
-      }
-    ]),
-    vertexShader: g.linedashed_vert,
-    fragmentShader: g.linedashed_frag
-  },
-  depth: {
-    uniforms: /* @__PURE__ */ b([
-      c.common,
-      c.displacementmap
-    ]),
-    vertexShader: g.depth_vert,
-    fragmentShader: g.depth_frag
-  },
-  normal: {
-    uniforms: /* @__PURE__ */ b([
-      c.common,
-      c.bumpmap,
-      c.normalmap,
-      c.displacementmap,
-      {
-        opacity: { value: 1 }
-      }
-    ]),
-    vertexShader: g.meshnormal_vert,
-    fragmentShader: g.meshnormal_frag
-  },
-  sprite: {
-    uniforms: /* @__PURE__ */ b([
-      c.sprite,
-      c.fog
-    ]),
-    vertexShader: g.sprite_vert,
-    fragmentShader: g.sprite_frag
-  },
-  background: {
-    uniforms: {
-      uvTransform: { value: /* @__PURE__ */ new f() },
-      t2D: { value: null },
-      backgroundIntensity: { value: 1 }
-    },
-    vertexShader: g.background_vert,
-    fragmentShader: g.background_frag
-  },
-  backgroundCube: {
-    uniforms: {
-      envMap: { value: null },
-      flipEnvMap: { value: -1 },
-      backgroundBlurriness: { value: 0 },
-      backgroundIntensity: { value: 1 },
-      backgroundRotation: { value: /* @__PURE__ */ new f() }
-    },
-    vertexShader: g.backgroundCube_vert,
-    fragmentShader: g.backgroundCube_frag
-  },
-  cube: {
-    uniforms: {
-      tCube: { value: null },
-      tFlip: { value: -1 },
-      opacity: { value: 1 }
-    },
-    vertexShader: g.cube_vert,
-    fragmentShader: g.cube_frag
-  },
-  equirect: {
-    uniforms: {
-      tEquirect: { value: null }
-    },
-    vertexShader: g.equirect_vert,
-    fragmentShader: g.equirect_frag
-  },
-  distanceRGBA: {
-    uniforms: /* @__PURE__ */ b([
-      c.common,
-      c.displacementmap,
-      {
-        referencePosition: { value: /* @__PURE__ */ new B() },
-        nearDistance: { value: 1 },
-        farDistance: { value: 1e3 }
-      }
-    ]),
-    vertexShader: g.distanceRGBA_vert,
-    fragmentShader: g.distanceRGBA_frag
-  },
-  shadow: {
-    uniforms: /* @__PURE__ */ b([
-      c.lights,
-      c.fog,
-      {
-        color: { value: /* @__PURE__ */ new y(0) },
-        opacity: { value: 1 }
-      }
-    ]),
-    vertexShader: g.shadow_vert,
-    fragmentShader: g.shadow_frag
-  }
-};
-$.physical = {
-  uniforms: /* @__PURE__ */ b([
-    $.standard.uniforms,
-    {
-      clearcoat: { value: 0 },
-      clearcoatMap: { value: null },
-      clearcoatMapTransform: { value: /* @__PURE__ */ new f() },
-      clearcoatNormalMap: { value: null },
-      clearcoatNormalMapTransform: { value: /* @__PURE__ */ new f() },
-      clearcoatNormalScale: { value: /* @__PURE__ */ new k(1, 1) },
-      clearcoatRoughness: { value: 0 },
-      clearcoatRoughnessMap: { value: null },
-      clearcoatRoughnessMapTransform: { value: /* @__PURE__ */ new f() },
-      iridescence: { value: 0 },
-      iridescenceMap: { value: null },
-      iridescenceMapTransform: { value: /* @__PURE__ */ new f() },
-      iridescenceIOR: { value: 1.3 },
-      iridescenceThicknessMinimum: { value: 100 },
-      iridescenceThicknessMaximum: { value: 400 },
-      iridescenceThicknessMap: { value: null },
-      iridescenceThicknessMapTransform: { value: /* @__PURE__ */ new f() },
-      sheen: { value: 0 },
-      sheenColor: { value: /* @__PURE__ */ new y(0) },
-      sheenColorMap: { value: null },
-      sheenColorMapTransform: { value: /* @__PURE__ */ new f() },
-      sheenRoughness: { value: 1 },
-      sheenRoughnessMap: { value: null },
-      sheenRoughnessMapTransform: { value: /* @__PURE__ */ new f() },
-      transmission: { value: 0 },
-      transmissionMap: { value: null },
-      transmissionMapTransform: { value: /* @__PURE__ */ new f() },
-      transmissionSamplerSize: { value: /* @__PURE__ */ new k() },
-      transmissionSamplerMap: { value: null },
-      thickness: { value: 0 },
-      thicknessMap: { value: null },
-      thicknessMapTransform: { value: /* @__PURE__ */ new f() },
-      attenuationDistance: { value: 0 },
-      attenuationColor: { value: /* @__PURE__ */ new y(0) },
-      specularColor: { value: /* @__PURE__ */ new y(1, 1, 1) },
-      specularColorMap: { value: null },
-      specularColorMapTransform: { value: /* @__PURE__ */ new f() },
-      specularIntensity: { value: 1 },
-      specularIntensityMap: { value: null },
-      specularIntensityMapTransform: { value: /* @__PURE__ */ new f() },
-      anisotropyVector: { value: /* @__PURE__ */ new k() },
-      anisotropyMap: { value: null },
-      anisotropyMapTransform: { value: /* @__PURE__ */ new f() }
-    }
-  ]),
-  vertexShader: g.meshphysical_vert,
-  fragmentShader: g.meshphysical_frag
-};
-const je = `varying vec3 vWorldPosition;
-
-void main() {
-    vec4 worldPos = modelMatrix * vec4(position, 1.0);
-    vWorldPosition = worldPos.xyz;
-    gl_Position = projectionMatrix * viewMatrix * worldPos;
-}`, He = `uniform float uGridSize;
-uniform float uMajorLineEvery;
-uniform vec3 uMinorLineColor;
-uniform vec3 uMajorLineColor;
-uniform float uFadeDistance;
-
-varying vec3 vWorldPosition;
-
-void main() {
-    vec2 coord = vWorldPosition.xz;
-
-    // Minor grid
-    vec2 minorCoord = coord / uGridSize;
-    vec2 minorGrid = abs(fract(minorCoord - 0.5) - 0.5) / fwidth(minorCoord);
-    float lineMinor = min(minorGrid.x, minorGrid.y);
-
-    // Major grid
-    float majorSize = uGridSize * uMajorLineEvery;
-    vec2 majorCoord = coord / majorSize;
-    vec2 majorGrid = abs(fract(majorCoord - 0.5) - 0.5) / fwidth(majorCoord);
-    float lineMajor = min(majorGrid.x, majorGrid.y);
-
-    // Line alpha: minor = 1px, major = 2px wide
-    float minorAlpha = 1.0 - min(lineMinor, 1.0);
-    float majorAlpha = 1.0 - min(lineMajor / 2.0, 1.0);
-
-    float alpha = max(minorAlpha, majorAlpha);
-    vec3 color = mix(uMinorLineColor, uMajorLineColor, step(minorAlpha, majorAlpha));
-
-    // Radial fade from camera
-    float dist = length(vWorldPosition.xz - cameraPosition.xz);
-    alpha *= 1.0 - smoothstep(uFadeDistance * 0.5, uFadeDistance, dist);
-
-    if (alpha < 0.001) discard;
-
-    gl_FragColor = vec4(color, alpha);
-}`, $e = {
-  uniforms: {
-    uGridSize: { value: 1 },
-    uMajorLineEvery: { value: 10 },
-    uMinorLineColor: { value: new O("#dddddd") },
-    uMajorLineColor: { value: new O("#888888") },
-    uFadeDistance: { value: 10 }
-  },
-  vertexShader: je,
-  fragmentShader: He
-}, Oe = {
-  ...$,
-  grid: $e
-};
-class Ye extends ie {
-}
-export {
-  Oe as D,
-  Ye as a
-};