@shopware-ag/dive 2.3.3 → 2.3.5

package/build/chunks/DIVEShaderMaterial-Bt0d8oJB.mjs

@@ -0,0 +1,3468 @@
+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
+};