minerender 2.1.0-alpha.49 → 2.1.0-alpha.50

package/dist/bundle.js

@@ -8271,7 +8271,7 @@ var MineRender = (() => {
       dispose
     };
   }
-  function WebGLShadowMap(_renderer, _objects, _capabilities) {
+  function WebGLShadowMap(_renderer2, _objects, _capabilities) {
     let _frustum = new Frustum();
     const _shadowMapSize = new Vector2(), _viewportSize = new Vector2(), _viewport = new Vector4(), _depthMaterial = new MeshDepthMaterial({ depthPacking: RGBADepthPacking }), _distanceMaterial = new MeshDistanceMaterial(), _materialCache = {}, _maxTextureSize = _capabilities.maxTextureSize;
     const shadowSide = { [FrontSide]: BackSide, [BackSide]: FrontSide, [DoubleSide]: DoubleSide };
@@ -8308,10 +8308,10 @@ var MineRender = (() => {
       if (scope.enabled === false) return;
       if (scope.autoUpdate === false && scope.needsUpdate === false) return;
       if (lights.length === 0) return;
-      const currentRenderTarget = _renderer.getRenderTarget();
-      const activeCubeFace = _renderer.getActiveCubeFace();
-      const activeMipmapLevel = _renderer.getActiveMipmapLevel();
-      const _state = _renderer.state;
+      const currentRenderTarget = _renderer2.getRenderTarget();
+      const activeCubeFace = _renderer2.getActiveCubeFace();
+      const activeMipmapLevel = _renderer2.getActiveMipmapLevel();
+      const _state = _renderer2.state;
       _state.setBlending(NoBlending);
       _state.buffers.color.setClear(1, 1, 1, 1);
       _state.buffers.depth.setTest(true);
@@ -8351,8 +8351,8 @@ var MineRender = (() => {
           shadow.map.texture.name = light.name + ".shadowMap";
           shadow.camera.updateProjectionMatrix();
         }
-        _renderer.setRenderTarget(shadow.map);
-        _renderer.clear();
+        _renderer2.setRenderTarget(shadow.map);
+        _renderer2.clear();
         const viewportCount = shadow.getViewportCount();
         for (let vp = 0; vp < viewportCount; vp++) {
           const viewport = shadow.getViewport(vp);
@@ -8374,7 +8374,7 @@ var MineRender = (() => {
       }
       _previousType = this.type;
       scope.needsUpdate = false;
-      _renderer.setRenderTarget(currentRenderTarget, activeCubeFace, activeMipmapLevel);
+      _renderer2.setRenderTarget(currentRenderTarget, activeCubeFace, activeMipmapLevel);
     };
     function VSMPass(shadow, camera) {
       const geometry = _objects.update(fullScreenMesh);
@@ -8390,15 +8390,15 @@ var MineRender = (() => {
       shadowMaterialVertical.uniforms.shadow_pass.value = shadow.map.texture;
       shadowMaterialVertical.uniforms.resolution.value = shadow.mapSize;
       shadowMaterialVertical.uniforms.radius.value = shadow.radius;
-      _renderer.setRenderTarget(shadow.mapPass);
-      _renderer.clear();
-      _renderer.renderBufferDirect(camera, null, geometry, shadowMaterialVertical, fullScreenMesh, null);
+      _renderer2.setRenderTarget(shadow.mapPass);
+      _renderer2.clear();
+      _renderer2.renderBufferDirect(camera, null, geometry, shadowMaterialVertical, fullScreenMesh, null);
       shadowMaterialHorizontal.uniforms.shadow_pass.value = shadow.mapPass.texture;
       shadowMaterialHorizontal.uniforms.resolution.value = shadow.mapSize;
       shadowMaterialHorizontal.uniforms.radius.value = shadow.radius;
-      _renderer.setRenderTarget(shadow.map);
-      _renderer.clear();
-      _renderer.renderBufferDirect(camera, null, geometry, shadowMaterialHorizontal, fullScreenMesh, null);
+      _renderer2.setRenderTarget(shadow.map);
+      _renderer2.clear();
+      _renderer2.renderBufferDirect(camera, null, geometry, shadowMaterialHorizontal, fullScreenMesh, null);
     }
     function getDepthMaterial(object, material, light, type) {
       let result = null;
@@ -8407,7 +8407,7 @@ var MineRender = (() => {
         result = customMaterial;
       } else {
         result = light.isPointLight === true ? _distanceMaterial : _depthMaterial;
-        if (_renderer.localClippingEnabled && material.clipShadows === true && Array.isArray(material.clippingPlanes) && material.clippingPlanes.length !== 0 || material.displacementMap && material.displacementScale !== 0 || material.alphaMap && material.alphaTest > 0 || material.map && material.alphaTest > 0) {
+        if (_renderer2.localClippingEnabled && material.clipShadows === true && Array.isArray(material.clippingPlanes) && material.clippingPlanes.length !== 0 || material.displacementMap && material.displacementScale !== 0 || material.alphaMap && material.alphaTest > 0 || material.map && material.alphaTest > 0) {
           const keyA = result.uuid, keyB = material.uuid;
           let materialsForVariant = _materialCache[keyA];
           if (materialsForVariant === void 0) {
@@ -8441,7 +8441,7 @@ var MineRender = (() => {
       result.wireframeLinewidth = material.wireframeLinewidth;
       result.linewidth = material.linewidth;
       if (light.isPointLight === true && result.isMeshDistanceMaterial === true) {
-        const materialProperties = _renderer.properties.get(result);
+        const materialProperties = _renderer2.properties.get(result);
         materialProperties.light = light;
       }
       return result;
@@ -8461,12 +8461,12 @@ var MineRender = (() => {
               const groupMaterial = material[group.materialIndex];
               if (groupMaterial && groupMaterial.visible) {
                 const depthMaterial = getDepthMaterial(object, groupMaterial, light, type);
-                _renderer.renderBufferDirect(shadowCamera, null, geometry, depthMaterial, object, group);
+                _renderer2.renderBufferDirect(shadowCamera, null, geometry, depthMaterial, object, group);
               }
             }
           } else if (material.visible) {
             const depthMaterial = getDepthMaterial(object, material, light, type);
-            _renderer.renderBufferDirect(shadowCamera, null, geometry, depthMaterial, object, null);
+            _renderer2.renderBufferDirect(shadowCamera, null, geometry, depthMaterial, object, null);
           }
         }
       }
@@ -10988,7 +10988,7 @@ var MineRender = (() => {
       }
     }
   }
-  var REVISION, MOUSE, TOUCH, CullFaceNone, CullFaceBack, CullFaceFront, PCFShadowMap, PCFSoftShadowMap, VSMShadowMap, FrontSide, BackSide, DoubleSide, NoBlending, NormalBlending, AdditiveBlending, SubtractiveBlending, MultiplyBlending, CustomBlending, AddEquation, SubtractEquation, ReverseSubtractEquation, MinEquation, MaxEquation, ZeroFactor, OneFactor, SrcColorFactor, OneMinusSrcColorFactor, SrcAlphaFactor, OneMinusSrcAlphaFactor, DstAlphaFactor, OneMinusDstAlphaFactor, DstColorFactor, OneMinusDstColorFactor, SrcAlphaSaturateFactor, ConstantColorFactor, OneMinusConstantColorFactor, ConstantAlphaFactor, OneMinusConstantAlphaFactor, NeverDepth, AlwaysDepth, LessDepth, LessEqualDepth, EqualDepth, GreaterEqualDepth, GreaterDepth, NotEqualDepth, MultiplyOperation, MixOperation, AddOperation, NoToneMapping, LinearToneMapping, ReinhardToneMapping, CineonToneMapping, ACESFilmicToneMapping, CustomToneMapping, UVMapping, CubeReflectionMapping, CubeRefractionMapping, EquirectangularReflectionMapping, EquirectangularRefractionMapping, CubeUVReflectionMapping, RepeatWrapping, ClampToEdgeWrapping, MirroredRepeatWrapping, NearestFilter, NearestMipmapNearestFilter, NearestMipmapLinearFilter, LinearFilter, LinearMipmapNearestFilter, LinearMipmapLinearFilter, UnsignedByteType, ByteType, ShortType, UnsignedShortType, IntType, UnsignedIntType, FloatType, HalfFloatType, UnsignedShort4444Type, UnsignedShort5551Type, UnsignedInt248Type, AlphaFormat, RGBAFormat, LuminanceFormat, LuminanceAlphaFormat, DepthFormat, DepthStencilFormat, RedFormat, RedIntegerFormat, RGFormat, RGIntegerFormat, RGBAIntegerFormat, RGB_S3TC_DXT1_Format, RGBA_S3TC_DXT1_Format, RGBA_S3TC_DXT3_Format, RGBA_S3TC_DXT5_Format, RGB_PVRTC_4BPPV1_Format, RGB_PVRTC_2BPPV1_Format, RGBA_PVRTC_4BPPV1_Format, RGBA_PVRTC_2BPPV1_Format, RGB_ETC1_Format, RGB_ETC2_Format, RGBA_ETC2_EAC_Format, RGBA_ASTC_4x4_Format, RGBA_ASTC_5x4_Format, RGBA_ASTC_5x5_Format, RGBA_ASTC_6x5_Format, RGBA_ASTC_6x6_Format, RGBA_ASTC_8x5_Format, RGBA_ASTC_8x6_Format, RGBA_ASTC_8x8_Format, RGBA_ASTC_10x5_Format, RGBA_ASTC_10x6_Format, RGBA_ASTC_10x8_Format, RGBA_ASTC_10x10_Format, RGBA_ASTC_12x10_Format, RGBA_ASTC_12x12_Format, RGBA_BPTC_Format, RGB_BPTC_SIGNED_Format, RGB_BPTC_UNSIGNED_Format, RED_RGTC1_Format, SIGNED_RED_RGTC1_Format, RED_GREEN_RGTC2_Format, SIGNED_RED_GREEN_RGTC2_Format, InterpolateDiscrete, InterpolateLinear, InterpolateSmooth, ZeroCurvatureEnding, ZeroSlopeEnding, WrapAroundEnding, TrianglesDrawMode, TriangleStripDrawMode, TriangleFanDrawMode, LinearEncoding, sRGBEncoding, BasicDepthPacking, RGBADepthPacking, TangentSpaceNormalMap, ObjectSpaceNormalMap, NoColorSpace, SRGBColorSpace, LinearSRGBColorSpace, DisplayP3ColorSpace, LinearDisplayP3ColorSpace, LinearTransfer, SRGBTransfer, Rec709Primaries, P3Primaries, KeepStencilOp, AlwaysStencilFunc, NeverCompare, LessCompare, EqualCompare, LessEqualCompare, GreaterCompare, NotEqualCompare, GreaterEqualCompare, AlwaysCompare, StaticDrawUsage, GLSL3, _SRGBAFormat, WebGLCoordinateSystem, WebGPUCoordinateSystem, EventDispatcher, _lut, _seed, DEG2RAD, RAD2DEG, MathUtils, Vector2, Matrix3, _m3, _cache, LINEAR_SRGB_TO_LINEAR_DISPLAY_P3, LINEAR_DISPLAY_P3_TO_LINEAR_SRGB, COLOR_SPACES, SUPPORTED_WORKING_COLOR_SPACES, ColorManagement, _canvas, ImageUtils, _sourceId, Source, _textureId, Texture, Vector4, RenderTarget, WebGLRenderTarget, DataArrayTexture, Data3DTexture, Quaternion, Vector3, _vector$b, _quaternion$4, Box3, _points, _vector$a, _box$3, _v0$2, _v1$7, _v2$4, _f0, _f1, _f2, _center, _extents, _triangleNormal, _testAxis, _box$2, _v1$6, _v2$3, Sphere, _vector$9, _segCenter, _segDir, _diff, _edge1, _edge2, _normal$1, Ray, Matrix4, _v1$5, _m1$2, _zero, _one, _x, _y, _z, _matrix, _quaternion$3, Euler, Layers, _object3DId, _v1$4, _q1, _m1$1, _target, _position$3, _scale$2, _quaternion$2, _xAxis, _yAxis, _zAxis, _addedEvent, _removedEvent, Object3D, _v0$1, _v1$3, _v2$2, _v3$1, _vab, _vac, _vbc, _vap, _vbp, _vcp, warnedGetUV, Triangle, _colorKeywords, _hslA, _hslB, Color, _color, _materialId, Material, MeshBasicMaterial, _vector$8, _vector2$1, BufferAttribute, Uint16BufferAttribute, Uint32BufferAttribute, Float32BufferAttribute, _id$2, _m1, _obj, _offset, _box$1, _boxMorphTargets, _vector$7, BufferGeometry, _inverseMatrix$3, _ray$3, _sphere$5, _sphereHitAt, _vA$1, _vB$1, _vC$1, _tempA, _morphA, _uvA$1, _uvB$1, _uvC$1, _normalA, _normalB, _normalC, _intersectionPoint, _intersectionPointWorld, Mesh, BoxGeometry, UniformsUtils, default_vertex, default_fragment, ShaderMaterial, Camera, PerspectiveCamera, fov, aspect, CubeCamera, CubeTexture, WebGLCubeRenderTarget, _vector1, _vector2, _normalMatrix, Plane, _sphere$4, _vector$6, Frustum, PlaneGeometry, alphahash_fragment, alphahash_pars_fragment, alphamap_fragment, alphamap_pars_fragment, alphatest_fragment, alphatest_pars_fragment, aomap_fragment, aomap_pars_fragment, begin_vertex, beginnormal_vertex, bsdfs, iridescence_fragment, bumpmap_pars_fragment, clipping_planes_fragment, clipping_planes_pars_fragment, clipping_planes_pars_vertex, clipping_planes_vertex, color_fragment, color_pars_fragment, color_pars_vertex, color_vertex, common, cube_uv_reflection_fragment, defaultnormal_vertex, displacementmap_pars_vertex, displacementmap_vertex, emissivemap_fragment, emissivemap_pars_fragment, colorspace_fragment, colorspace_pars_fragment, envmap_fragment, envmap_common_pars_fragment, envmap_pars_fragment, envmap_pars_vertex, envmap_vertex, fog_vertex, fog_pars_vertex, fog_fragment, fog_pars_fragment, gradientmap_pars_fragment, lightmap_fragment, lightmap_pars_fragment, lights_lambert_fragment, lights_lambert_pars_fragment, lights_pars_begin, envmap_physical_pars_fragment, lights_toon_fragment, lights_toon_pars_fragment, lights_phong_fragment, lights_phong_pars_fragment, lights_physical_fragment, lights_physical_pars_fragment, lights_fragment_begin, lights_fragment_maps, lights_fragment_end, logdepthbuf_fragment, logdepthbuf_pars_fragment, logdepthbuf_pars_vertex, logdepthbuf_vertex, map_fragment, map_pars_fragment, map_particle_fragment, map_particle_pars_fragment, metalnessmap_fragment, metalnessmap_pars_fragment, morphcolor_vertex, morphnormal_vertex, morphtarget_pars_vertex, morphtarget_vertex, normal_fragment_begin, normal_fragment_maps, normal_pars_fragment, normal_pars_vertex, normal_vertex, normalmap_pars_fragment, clearcoat_normal_fragment_begin, clearcoat_normal_fragment_maps, clearcoat_pars_fragment, iridescence_pars_fragment, opaque_fragment, packing, premultiplied_alpha_fragment, project_vertex, dithering_fragment, dithering_pars_fragment, roughnessmap_fragment, roughnessmap_pars_fragment, shadowmap_pars_fragment, shadowmap_pars_vertex, shadowmap_vertex, shadowmask_pars_fragment, skinbase_vertex, skinning_pars_vertex, skinning_vertex, skinnormal_vertex, specularmap_fragment, specularmap_pars_fragment, tonemapping_fragment, tonemapping_pars_fragment, transmission_fragment, transmission_pars_fragment, uv_pars_fragment, uv_pars_vertex, uv_vertex, worldpos_vertex, vertex$h, fragment$h, vertex$g, fragment$g, vertex$f, fragment$f, vertex$e, fragment$e, vertex$d, fragment$d, vertex$c, fragment$c, vertex$b, fragment$b, vertex$a, fragment$a, vertex$9, fragment$9, vertex$8, fragment$8, vertex$7, fragment$7, vertex$6, fragment$6, vertex$5, fragment$5, vertex$4, fragment$4, vertex$3, fragment$3, vertex$2, fragment$2, vertex$1, fragment$1, ShaderChunk, UniformsLib, ShaderLib, _rgb, OrthographicCamera, LOD_MIN, EXTRA_LOD_SIGMA, MAX_SAMPLES, _flatCamera, _clearColor, _oldTarget, _oldActiveCubeFace, _oldActiveMipmapLevel, PHI, INV_PHI, _axisDirections, PMREMGenerator, emptyTexture, emptyArrayTexture, empty3dTexture, emptyCubeTexture, arrayCacheF32, arrayCacheI32, mat4array, mat3array, mat2array, SingleUniform, PureArrayUniform, StructuredUniform, RePathPart, WebGLUniforms, COMPLETION_STATUS_KHR, programIdCount, includePattern, shaderChunkMap, unrollLoopPattern, _id$1, WebGLShaderCache, WebGLShaderStage, nextVersion, MeshDepthMaterial, MeshDistanceMaterial, vertex, fragment, ArrayCamera, Group, _moveEvent, WebXRController, DepthTexture, WebXRManager, WebGLRenderer, WebGL1Renderer, Scene, InterleavedBuffer, _vector$5, InterleavedBufferAttribute, DataTexture, InstancedBufferAttribute, _instanceLocalMatrix, _instanceWorldMatrix, _instanceIntersects, _box3, _identity, _mesh, _sphere$2, InstancedMesh, LineBasicMaterial, _start$1, _end$1, _inverseMatrix$1, _ray$1, _sphere$1, Line, _start, _end, LineSegments, CanvasTexture, _v0, _v1$1, _normal, _triangle, EdgesGeometry, MeshStandardMaterial, Interpolant, CubicInterpolant, LinearInterpolant, DiscreteInterpolant, KeyframeTrack, BooleanKeyframeTrack, ColorKeyframeTrack, NumberKeyframeTrack, QuaternionLinearInterpolant, QuaternionKeyframeTrack, StringKeyframeTrack, VectorKeyframeTrack, LoadingManager, DefaultLoadingManager, Loader, _RESERVED_CHARS_RE, _reservedRe, _wordChar, _wordCharOrDot, _directoryRe, _nodeRe, _objectRe, _propertyRe, _trackRe, _supportedObjectNames, Composite, PropertyBinding, _controlInterpolantsResultBuffer, Uniform, Raycaster, Spherical, _vector$4, Box2, GridHelper, AxesHelper;
+  var REVISION, MOUSE, TOUCH, CullFaceNone, CullFaceBack, CullFaceFront, PCFShadowMap, PCFSoftShadowMap, VSMShadowMap, FrontSide, BackSide, DoubleSide, NoBlending, NormalBlending, AdditiveBlending, SubtractiveBlending, MultiplyBlending, CustomBlending, AddEquation, SubtractEquation, ReverseSubtractEquation, MinEquation, MaxEquation, ZeroFactor, OneFactor, SrcColorFactor, OneMinusSrcColorFactor, SrcAlphaFactor, OneMinusSrcAlphaFactor, DstAlphaFactor, OneMinusDstAlphaFactor, DstColorFactor, OneMinusDstColorFactor, SrcAlphaSaturateFactor, ConstantColorFactor, OneMinusConstantColorFactor, ConstantAlphaFactor, OneMinusConstantAlphaFactor, NeverDepth, AlwaysDepth, LessDepth, LessEqualDepth, EqualDepth, GreaterEqualDepth, GreaterDepth, NotEqualDepth, MultiplyOperation, MixOperation, AddOperation, NoToneMapping, LinearToneMapping, ReinhardToneMapping, CineonToneMapping, ACESFilmicToneMapping, CustomToneMapping, UVMapping, CubeReflectionMapping, CubeRefractionMapping, EquirectangularReflectionMapping, EquirectangularRefractionMapping, CubeUVReflectionMapping, RepeatWrapping, ClampToEdgeWrapping, MirroredRepeatWrapping, NearestFilter, NearestMipmapNearestFilter, NearestMipmapLinearFilter, LinearFilter, LinearMipmapNearestFilter, LinearMipmapLinearFilter, UnsignedByteType, ByteType, ShortType, UnsignedShortType, IntType, UnsignedIntType, FloatType, HalfFloatType, UnsignedShort4444Type, UnsignedShort5551Type, UnsignedInt248Type, AlphaFormat, RGBAFormat, LuminanceFormat, LuminanceAlphaFormat, DepthFormat, DepthStencilFormat, RedFormat, RedIntegerFormat, RGFormat, RGIntegerFormat, RGBAIntegerFormat, RGB_S3TC_DXT1_Format, RGBA_S3TC_DXT1_Format, RGBA_S3TC_DXT3_Format, RGBA_S3TC_DXT5_Format, RGB_PVRTC_4BPPV1_Format, RGB_PVRTC_2BPPV1_Format, RGBA_PVRTC_4BPPV1_Format, RGBA_PVRTC_2BPPV1_Format, RGB_ETC1_Format, RGB_ETC2_Format, RGBA_ETC2_EAC_Format, RGBA_ASTC_4x4_Format, RGBA_ASTC_5x4_Format, RGBA_ASTC_5x5_Format, RGBA_ASTC_6x5_Format, RGBA_ASTC_6x6_Format, RGBA_ASTC_8x5_Format, RGBA_ASTC_8x6_Format, RGBA_ASTC_8x8_Format, RGBA_ASTC_10x5_Format, RGBA_ASTC_10x6_Format, RGBA_ASTC_10x8_Format, RGBA_ASTC_10x10_Format, RGBA_ASTC_12x10_Format, RGBA_ASTC_12x12_Format, RGBA_BPTC_Format, RGB_BPTC_SIGNED_Format, RGB_BPTC_UNSIGNED_Format, RED_RGTC1_Format, SIGNED_RED_RGTC1_Format, RED_GREEN_RGTC2_Format, SIGNED_RED_GREEN_RGTC2_Format, InterpolateDiscrete, InterpolateLinear, InterpolateSmooth, ZeroCurvatureEnding, ZeroSlopeEnding, WrapAroundEnding, TrianglesDrawMode, TriangleStripDrawMode, TriangleFanDrawMode, LinearEncoding, sRGBEncoding, BasicDepthPacking, RGBADepthPacking, TangentSpaceNormalMap, ObjectSpaceNormalMap, NoColorSpace, SRGBColorSpace, LinearSRGBColorSpace, DisplayP3ColorSpace, LinearDisplayP3ColorSpace, LinearTransfer, SRGBTransfer, Rec709Primaries, P3Primaries, KeepStencilOp, AlwaysStencilFunc, NeverCompare, LessCompare, EqualCompare, LessEqualCompare, GreaterCompare, NotEqualCompare, GreaterEqualCompare, AlwaysCompare, StaticDrawUsage, GLSL3, _SRGBAFormat, WebGLCoordinateSystem, WebGPUCoordinateSystem, EventDispatcher, _lut, _seed, DEG2RAD, RAD2DEG, MathUtils, Vector2, Matrix3, _m3, _cache, LINEAR_SRGB_TO_LINEAR_DISPLAY_P3, LINEAR_DISPLAY_P3_TO_LINEAR_SRGB, COLOR_SPACES, SUPPORTED_WORKING_COLOR_SPACES, ColorManagement, _canvas, ImageUtils, _sourceId, Source, _textureId, Texture, Vector4, RenderTarget, WebGLRenderTarget, DataArrayTexture, Data3DTexture, Quaternion, Vector3, _vector$b, _quaternion$4, Box3, _points, _vector$a, _box$3, _v0$2, _v1$7, _v2$4, _f0, _f1, _f2, _center, _extents, _triangleNormal, _testAxis, _box$2, _v1$6, _v2$3, Sphere, _vector$9, _segCenter, _segDir, _diff, _edge1, _edge2, _normal$1, Ray, Matrix4, _v1$5, _m1$2, _zero, _one, _x, _y, _z, _matrix, _quaternion$3, Euler, Layers, _object3DId, _v1$4, _q1, _m1$1, _target, _position$3, _scale$2, _quaternion$2, _xAxis, _yAxis, _zAxis, _addedEvent, _removedEvent, Object3D, _v0$1, _v1$3, _v2$2, _v3$1, _vab, _vac, _vbc, _vap, _vbp, _vcp, warnedGetUV, Triangle, _colorKeywords, _hslA, _hslB, Color, _color, _materialId, Material, MeshBasicMaterial, _vector$8, _vector2$1, BufferAttribute, Uint16BufferAttribute, Uint32BufferAttribute, Float32BufferAttribute, _id$2, _m1, _obj, _offset, _box$1, _boxMorphTargets, _vector$7, BufferGeometry, _inverseMatrix$3, _ray$3, _sphere$5, _sphereHitAt, _vA$1, _vB$1, _vC$1, _tempA, _morphA, _uvA$1, _uvB$1, _uvC$1, _normalA, _normalB, _normalC, _intersectionPoint, _intersectionPointWorld, Mesh, BoxGeometry, UniformsUtils, default_vertex, default_fragment, ShaderMaterial, Camera, PerspectiveCamera, fov, aspect, CubeCamera, CubeTexture, WebGLCubeRenderTarget, _vector1, _vector2, _normalMatrix, Plane, _sphere$4, _vector$6, Frustum, PlaneGeometry, alphahash_fragment, alphahash_pars_fragment, alphamap_fragment, alphamap_pars_fragment, alphatest_fragment, alphatest_pars_fragment, aomap_fragment, aomap_pars_fragment, begin_vertex, beginnormal_vertex, bsdfs, iridescence_fragment, bumpmap_pars_fragment, clipping_planes_fragment, clipping_planes_pars_fragment, clipping_planes_pars_vertex, clipping_planes_vertex, color_fragment, color_pars_fragment, color_pars_vertex, color_vertex, common, cube_uv_reflection_fragment, defaultnormal_vertex, displacementmap_pars_vertex, displacementmap_vertex, emissivemap_fragment, emissivemap_pars_fragment, colorspace_fragment, colorspace_pars_fragment, envmap_fragment, envmap_common_pars_fragment, envmap_pars_fragment, envmap_pars_vertex, envmap_vertex, fog_vertex, fog_pars_vertex, fog_fragment, fog_pars_fragment, gradientmap_pars_fragment, lightmap_fragment, lightmap_pars_fragment, lights_lambert_fragment, lights_lambert_pars_fragment, lights_pars_begin, envmap_physical_pars_fragment, lights_toon_fragment, lights_toon_pars_fragment, lights_phong_fragment, lights_phong_pars_fragment, lights_physical_fragment, lights_physical_pars_fragment, lights_fragment_begin, lights_fragment_maps, lights_fragment_end, logdepthbuf_fragment, logdepthbuf_pars_fragment, logdepthbuf_pars_vertex, logdepthbuf_vertex, map_fragment, map_pars_fragment, map_particle_fragment, map_particle_pars_fragment, metalnessmap_fragment, metalnessmap_pars_fragment, morphcolor_vertex, morphnormal_vertex, morphtarget_pars_vertex, morphtarget_vertex, normal_fragment_begin, normal_fragment_maps, normal_pars_fragment, normal_pars_vertex, normal_vertex, normalmap_pars_fragment, clearcoat_normal_fragment_begin, clearcoat_normal_fragment_maps, clearcoat_pars_fragment, iridescence_pars_fragment, opaque_fragment, packing, premultiplied_alpha_fragment, project_vertex, dithering_fragment, dithering_pars_fragment, roughnessmap_fragment, roughnessmap_pars_fragment, shadowmap_pars_fragment, shadowmap_pars_vertex, shadowmap_vertex, shadowmask_pars_fragment, skinbase_vertex, skinning_pars_vertex, skinning_vertex, skinnormal_vertex, specularmap_fragment, specularmap_pars_fragment, tonemapping_fragment, tonemapping_pars_fragment, transmission_fragment, transmission_pars_fragment, uv_pars_fragment, uv_pars_vertex, uv_vertex, worldpos_vertex, vertex$h, fragment$h, vertex$g, fragment$g, vertex$f, fragment$f, vertex$e, fragment$e, vertex$d, fragment$d, vertex$c, fragment$c, vertex$b, fragment$b, vertex$a, fragment$a, vertex$9, fragment$9, vertex$8, fragment$8, vertex$7, fragment$7, vertex$6, fragment$6, vertex$5, fragment$5, vertex$4, fragment$4, vertex$3, fragment$3, vertex$2, fragment$2, vertex$1, fragment$1, ShaderChunk, UniformsLib, ShaderLib, _rgb, OrthographicCamera, LOD_MIN, EXTRA_LOD_SIGMA, MAX_SAMPLES, _flatCamera, _clearColor, _oldTarget, _oldActiveCubeFace, _oldActiveMipmapLevel, PHI, INV_PHI, _axisDirections, PMREMGenerator, emptyTexture, emptyArrayTexture, empty3dTexture, emptyCubeTexture, arrayCacheF32, arrayCacheI32, mat4array, mat3array, mat2array, SingleUniform, PureArrayUniform, StructuredUniform, RePathPart, WebGLUniforms, COMPLETION_STATUS_KHR, programIdCount, includePattern, shaderChunkMap, unrollLoopPattern, _id$1, WebGLShaderCache, WebGLShaderStage, nextVersion, MeshDepthMaterial, MeshDistanceMaterial, vertex, fragment, ArrayCamera, Group, _moveEvent, WebXRController, DepthTexture, WebXRManager, WebGLRenderer, WebGL1Renderer, Scene, InterleavedBuffer, _vector$5, InterleavedBufferAttribute, DataTexture, InstancedBufferAttribute, _instanceLocalMatrix, _instanceWorldMatrix, _instanceIntersects, _box3, _identity, _mesh, _sphere$2, InstancedMesh, LineBasicMaterial, _start$1, _end$1, _inverseMatrix$1, _ray$1, _sphere$1, Line, _start, _end, LineSegments, CompressedTexture, CanvasTexture, _v0, _v1$1, _normal, _triangle, EdgesGeometry, MeshStandardMaterial, Interpolant, CubicInterpolant, LinearInterpolant, DiscreteInterpolant, KeyframeTrack, BooleanKeyframeTrack, ColorKeyframeTrack, NumberKeyframeTrack, QuaternionLinearInterpolant, QuaternionKeyframeTrack, StringKeyframeTrack, VectorKeyframeTrack, LoadingManager, DefaultLoadingManager, Loader, _RESERVED_CHARS_RE, _reservedRe, _wordChar, _wordCharOrDot, _directoryRe, _nodeRe, _objectRe, _propertyRe, _trackRe, _supportedObjectNames, Composite, PropertyBinding, _controlInterpolantsResultBuffer, Uniform, Raycaster, Spherical, _vector$4, Box2, GridHelper, AxesHelper;
   var init_three_module = __esm({
     "../../node_modules/three/build/three.module.js"() {
       init_dirname();
@@ -22340,6 +22340,16 @@ var MineRender = (() => {
           return this;
         }
       };
+      CompressedTexture = class extends Texture {
+        constructor(mipmaps, width, height, format2, type, mapping, wrapS, wrapT, magFilter, minFilter, anisotropy, colorSpace) {
+          super(null, mapping, wrapS, wrapT, magFilter, minFilter, format2, type, anisotropy, colorSpace);
+          this.isCompressedTexture = true;
+          this.image = { width, height };
+          this.mipmaps = mipmaps;
+          this.flipY = false;
+          this.generateMipmaps = false;
+        }
+      };
       CanvasTexture = class extends Texture {
         constructor(canvas, mapping, wrapS, wrapT, magFilter, minFilter, format2, type, anisotropy) {
           super(canvas, mapping, wrapS, wrapT, magFilter, minFilter, format2, type, anisotropy);
@@ -82978,6 +82988,7 @@ ${key}` : key;
     RequestError: () => RequestError,
     Requests: () => Requests,
     SKIN_PARTS: () => SKIN_PARTS,
+    SceneExporter: () => SceneExporter,
     SceneInspector: () => SceneInspector,
     SceneObject: () => SceneObject,
     SceneStats: () => SceneStats,
@@ -83067,7 +83078,8 @@ ${key}` : key;
     timingStart: () => timingStart,
     toDegrees: () => toDegrees,
     toRadians: () => toRadians,
-    toTrianglesDrawMode: () => toTrianglesDrawMode
+    toTrianglesDrawMode: () => toTrianglesDrawMode,
+    trimCanvas: () => trimCanvas
   });
   init_dirname();
   init_buffer2();
@@ -83557,6 +83569,40 @@ ${key}` : key;
   init_CanvasCompat();
   init_CanvasImage();
 
+  // src/canvas/trimCanvas.ts
+  init_dirname();
+  init_buffer2();
+  init_process2();
+  init_CanvasCompat();
+  function trimCanvas(source) {
+    if (source.width === 0 || source.height === 0) return createCanvas(1, 1);
+    const canvas = createCanvas(source.width, source.height);
+    const context = canvas.getContext("2d");
+    if (!context) throw new Error("Image export requires a 2D canvas context");
+    context.drawImage(source, 0, 0);
+    const pixels = context.getImageData(0, 0, canvas.width, canvas.height).data;
+    let left = canvas.width, top = canvas.height, right = -1, bottom = -1;
+    for (let y5 = 0; y5 < canvas.height; y5++) {
+      for (let x4 = 0; x4 < canvas.width; x4++) {
+        if (pixels[(y5 * canvas.width + x4) * 4 + 3] === 0) continue;
+        left = Math.min(left, x4);
+        top = Math.min(top, y5);
+        right = Math.max(right, x4);
+        bottom = Math.max(bottom, y5);
+      }
+    }
+    if (right < left) {
+      canvas.width = canvas.height = 1;
+      return canvas;
+    }
+    const width = right - left + 1, height = bottom - top + 1;
+    const cropped = context.getImageData(left, top, width, height);
+    canvas.width = width;
+    canvas.height = height;
+    context.putImageData(cropped, 0, 0);
+    return canvas;
+  }
+
   // src/entity/index.ts
   init_dirname();
   init_buffer2();
@@ -83699,6 +83745,2530 @@ ${key}` : key;
   init_process2();
   init_MineRenderError();
 
+  // src/export/index.ts
+  init_dirname();
+  init_buffer2();
+  init_process2();
+
+  // src/export/SceneExporter.ts
+  init_dirname();
+  init_buffer2();
+  init_process2();
+  init_three_module();
+
+  // ../../node_modules/three/examples/jsm/exporters/OBJExporter.js
+  init_dirname();
+  init_buffer2();
+  init_process2();
+  init_three_module();
+  var OBJExporter = class {
+    parse(object) {
+      let output = "";
+      let indexVertex = 0;
+      let indexVertexUvs = 0;
+      let indexNormals = 0;
+      const vertex2 = new Vector3();
+      const color2 = new Color();
+      const normal = new Vector3();
+      const uv = new Vector2();
+      const face = [];
+      function parseMesh(mesh) {
+        let nbVertex = 0;
+        let nbNormals = 0;
+        let nbVertexUvs = 0;
+        const geometry = mesh.geometry;
+        const normalMatrixWorld = new Matrix3();
+        const vertices = geometry.getAttribute("position");
+        const normals = geometry.getAttribute("normal");
+        const uvs = geometry.getAttribute("uv");
+        const indices = geometry.getIndex();
+        output += "o " + mesh.name + "\n";
+        if (mesh.material && mesh.material.name) {
+          output += "usemtl " + mesh.material.name + "\n";
+        }
+        if (vertices !== void 0) {
+          for (let i4 = 0, l4 = vertices.count; i4 < l4; i4++, nbVertex++) {
+            vertex2.fromBufferAttribute(vertices, i4);
+            vertex2.applyMatrix4(mesh.matrixWorld);
+            output += "v " + vertex2.x + " " + vertex2.y + " " + vertex2.z + "\n";
+          }
+        }
+        if (uvs !== void 0) {
+          for (let i4 = 0, l4 = uvs.count; i4 < l4; i4++, nbVertexUvs++) {
+            uv.fromBufferAttribute(uvs, i4);
+            output += "vt " + uv.x + " " + uv.y + "\n";
+          }
+        }
+        if (normals !== void 0) {
+          normalMatrixWorld.getNormalMatrix(mesh.matrixWorld);
+          for (let i4 = 0, l4 = normals.count; i4 < l4; i4++, nbNormals++) {
+            normal.fromBufferAttribute(normals, i4);
+            normal.applyMatrix3(normalMatrixWorld).normalize();
+            output += "vn " + normal.x + " " + normal.y + " " + normal.z + "\n";
+          }
+        }
+        if (indices !== null) {
+          for (let i4 = 0, l4 = indices.count; i4 < l4; i4 += 3) {
+            for (let m4 = 0; m4 < 3; m4++) {
+              const j4 = indices.getX(i4 + m4) + 1;
+              face[m4] = indexVertex + j4 + (normals || uvs ? "/" + (uvs ? indexVertexUvs + j4 : "") + (normals ? "/" + (indexNormals + j4) : "") : "");
+            }
+            output += "f " + face.join(" ") + "\n";
+          }
+        } else {
+          for (let i4 = 0, l4 = vertices.count; i4 < l4; i4 += 3) {
+            for (let m4 = 0; m4 < 3; m4++) {
+              const j4 = i4 + m4 + 1;
+              face[m4] = indexVertex + j4 + (normals || uvs ? "/" + (uvs ? indexVertexUvs + j4 : "") + (normals ? "/" + (indexNormals + j4) : "") : "");
+            }
+            output += "f " + face.join(" ") + "\n";
+          }
+        }
+        indexVertex += nbVertex;
+        indexVertexUvs += nbVertexUvs;
+        indexNormals += nbNormals;
+      }
+      function parseLine(line) {
+        let nbVertex = 0;
+        const geometry = line.geometry;
+        const type = line.type;
+        const vertices = geometry.getAttribute("position");
+        output += "o " + line.name + "\n";
+        if (vertices !== void 0) {
+          for (let i4 = 0, l4 = vertices.count; i4 < l4; i4++, nbVertex++) {
+            vertex2.fromBufferAttribute(vertices, i4);
+            vertex2.applyMatrix4(line.matrixWorld);
+            output += "v " + vertex2.x + " " + vertex2.y + " " + vertex2.z + "\n";
+          }
+        }
+        if (type === "Line") {
+          output += "l ";
+          for (let j4 = 1, l4 = vertices.count; j4 <= l4; j4++) {
+            output += indexVertex + j4 + " ";
+          }
+          output += "\n";
+        }
+        if (type === "LineSegments") {
+          for (let j4 = 1, k4 = j4 + 1, l4 = vertices.count; j4 < l4; j4 += 2, k4 = j4 + 1) {
+            output += "l " + (indexVertex + j4) + " " + (indexVertex + k4) + "\n";
+          }
+        }
+        indexVertex += nbVertex;
+      }
+      function parsePoints(points) {
+        let nbVertex = 0;
+        const geometry = points.geometry;
+        const vertices = geometry.getAttribute("position");
+        const colors = geometry.getAttribute("color");
+        output += "o " + points.name + "\n";
+        if (vertices !== void 0) {
+          for (let i4 = 0, l4 = vertices.count; i4 < l4; i4++, nbVertex++) {
+            vertex2.fromBufferAttribute(vertices, i4);
+            vertex2.applyMatrix4(points.matrixWorld);
+            output += "v " + vertex2.x + " " + vertex2.y + " " + vertex2.z;
+            if (colors !== void 0) {
+              color2.fromBufferAttribute(colors, i4).convertLinearToSRGB();
+              output += " " + color2.r + " " + color2.g + " " + color2.b;
+            }
+            output += "\n";
+          }
+          output += "p ";
+          for (let j4 = 1, l4 = vertices.count; j4 <= l4; j4++) {
+            output += indexVertex + j4 + " ";
+          }
+          output += "\n";
+        }
+        indexVertex += nbVertex;
+      }
+      object.traverse(function(child) {
+        if (child.isMesh === true) {
+          parseMesh(child);
+        }
+        if (child.isLine === true) {
+          parseLine(child);
+        }
+        if (child.isPoints === true) {
+          parsePoints(child);
+        }
+      });
+      return output;
+    }
+  };
+
+  // ../../node_modules/three/examples/jsm/exporters/PLYExporter.js
+  init_dirname();
+  init_buffer2();
+  init_process2();
+  init_three_module();
+  var PLYExporter = class {
+    parse(object, onDone, options = {}) {
+      function traverseMeshes(cb) {
+        object.traverse(function(child) {
+          if (child.isMesh === true || child.isPoints) {
+            const mesh = child;
+            const geometry = mesh.geometry;
+            if (geometry.hasAttribute("position") === true) {
+              cb(mesh, geometry);
+            }
+          }
+        });
+      }
+      const defaultOptions = {
+        binary: false,
+        excludeAttributes: [],
+        // normal, uv, color, index
+        littleEndian: false
+      };
+      options = Object.assign(defaultOptions, options);
+      const excludeAttributes = options.excludeAttributes;
+      let includeIndices = true;
+      let includeNormals = false;
+      let includeColors = false;
+      let includeUVs = false;
+      let vertexCount = 0;
+      let faceCount = 0;
+      object.traverse(function(child) {
+        if (child.isMesh === true) {
+          const mesh = child;
+          const geometry = mesh.geometry;
+          const vertices = geometry.getAttribute("position");
+          const normals = geometry.getAttribute("normal");
+          const uvs = geometry.getAttribute("uv");
+          const colors = geometry.getAttribute("color");
+          const indices = geometry.getIndex();
+          if (vertices === void 0) {
+            return;
+          }
+          vertexCount += vertices.count;
+          faceCount += indices ? indices.count / 3 : vertices.count / 3;
+          if (normals !== void 0) includeNormals = true;
+          if (uvs !== void 0) includeUVs = true;
+          if (colors !== void 0) includeColors = true;
+        } else if (child.isPoints) {
+          const mesh = child;
+          const geometry = mesh.geometry;
+          const vertices = geometry.getAttribute("position");
+          const normals = geometry.getAttribute("normal");
+          const colors = geometry.getAttribute("color");
+          vertexCount += vertices.count;
+          if (normals !== void 0) includeNormals = true;
+          if (colors !== void 0) includeColors = true;
+          includeIndices = false;
+        }
+      });
+      const tempColor = new Color();
+      includeIndices = includeIndices && excludeAttributes.indexOf("index") === -1;
+      includeNormals = includeNormals && excludeAttributes.indexOf("normal") === -1;
+      includeColors = includeColors && excludeAttributes.indexOf("color") === -1;
+      includeUVs = includeUVs && excludeAttributes.indexOf("uv") === -1;
+      if (includeIndices && faceCount !== Math.floor(faceCount)) {
+        console.error(
+          "PLYExporter: Failed to generate a valid PLY file with triangle indices because the number of indices is not divisible by 3."
+        );
+        return null;
+      }
+      const indexByteCount = 4;
+      let header = `ply
+format ${options.binary ? options.littleEndian ? "binary_little_endian" : "binary_big_endian" : "ascii"} 1.0
+element vertex ${vertexCount}
+property float x
+property float y
+property float z
+`;
+      if (includeNormals === true) {
+        header += "property float nx\nproperty float ny\nproperty float nz\n";
+      }
+      if (includeUVs === true) {
+        header += "property float s\nproperty float t\n";
+      }
+      if (includeColors === true) {
+        header += "property uchar red\nproperty uchar green\nproperty uchar blue\n";
+      }
+      if (includeIndices === true) {
+        header += `element face ${faceCount}
+property list uchar int vertex_index
+`;
+      }
+      header += "end_header\n";
+      const vertex2 = new Vector3();
+      const normalMatrixWorld = new Matrix3();
+      let result = null;
+      if (options.binary === true) {
+        const headerBin = new TextEncoder().encode(header);
+        const vertexListLength = vertexCount * (4 * 3 + (includeNormals ? 4 * 3 : 0) + (includeColors ? 3 : 0) + (includeUVs ? 4 * 2 : 0));
+        const faceListLength = includeIndices ? faceCount * (indexByteCount * 3 + 1) : 0;
+        const output = new DataView(new ArrayBuffer(headerBin.length + vertexListLength + faceListLength));
+        new Uint8Array(output.buffer).set(headerBin, 0);
+        let vOffset = headerBin.length;
+        let fOffset = headerBin.length + vertexListLength;
+        let writtenVertices = 0;
+        traverseMeshes(function(mesh, geometry) {
+          const vertices = geometry.getAttribute("position");
+          const normals = geometry.getAttribute("normal");
+          const uvs = geometry.getAttribute("uv");
+          const colors = geometry.getAttribute("color");
+          const indices = geometry.getIndex();
+          normalMatrixWorld.getNormalMatrix(mesh.matrixWorld);
+          for (let i4 = 0, l4 = vertices.count; i4 < l4; i4++) {
+            vertex2.fromBufferAttribute(vertices, i4);
+            vertex2.applyMatrix4(mesh.matrixWorld);
+            output.setFloat32(vOffset, vertex2.x, options.littleEndian);
+            vOffset += 4;
+            output.setFloat32(vOffset, vertex2.y, options.littleEndian);
+            vOffset += 4;
+            output.setFloat32(vOffset, vertex2.z, options.littleEndian);
+            vOffset += 4;
+            if (includeNormals === true) {
+              if (normals != null) {
+                vertex2.fromBufferAttribute(normals, i4);
+                vertex2.applyMatrix3(normalMatrixWorld).normalize();
+                output.setFloat32(vOffset, vertex2.x, options.littleEndian);
+                vOffset += 4;
+                output.setFloat32(vOffset, vertex2.y, options.littleEndian);
+                vOffset += 4;
+                output.setFloat32(vOffset, vertex2.z, options.littleEndian);
+                vOffset += 4;
+              } else {
+                output.setFloat32(vOffset, 0, options.littleEndian);
+                vOffset += 4;
+                output.setFloat32(vOffset, 0, options.littleEndian);
+                vOffset += 4;
+                output.setFloat32(vOffset, 0, options.littleEndian);
+                vOffset += 4;
+              }
+            }
+            if (includeUVs === true) {
+              if (uvs != null) {
+                output.setFloat32(vOffset, uvs.getX(i4), options.littleEndian);
+                vOffset += 4;
+                output.setFloat32(vOffset, uvs.getY(i4), options.littleEndian);
+                vOffset += 4;
+              } else {
+                output.setFloat32(vOffset, 0, options.littleEndian);
+                vOffset += 4;
+                output.setFloat32(vOffset, 0, options.littleEndian);
+                vOffset += 4;
+              }
+            }
+            if (includeColors === true) {
+              if (colors != null) {
+                tempColor.fromBufferAttribute(colors, i4).convertLinearToSRGB();
+                output.setUint8(vOffset, Math.floor(tempColor.r * 255));
+                vOffset += 1;
+                output.setUint8(vOffset, Math.floor(tempColor.g * 255));
+                vOffset += 1;
+                output.setUint8(vOffset, Math.floor(tempColor.b * 255));
+                vOffset += 1;
+              } else {
+                output.setUint8(vOffset, 255);
+                vOffset += 1;
+                output.setUint8(vOffset, 255);
+                vOffset += 1;
+                output.setUint8(vOffset, 255);
+                vOffset += 1;
+              }
+            }
+          }
+          if (includeIndices === true) {
+            if (indices !== null) {
+              for (let i4 = 0, l4 = indices.count; i4 < l4; i4 += 3) {
+                output.setUint8(fOffset, 3);
+                fOffset += 1;
+                output.setUint32(fOffset, indices.getX(i4 + 0) + writtenVertices, options.littleEndian);
+                fOffset += indexByteCount;
+                output.setUint32(fOffset, indices.getX(i4 + 1) + writtenVertices, options.littleEndian);
+                fOffset += indexByteCount;
+                output.setUint32(fOffset, indices.getX(i4 + 2) + writtenVertices, options.littleEndian);
+                fOffset += indexByteCount;
+              }
+            } else {
+              for (let i4 = 0, l4 = vertices.count; i4 < l4; i4 += 3) {
+                output.setUint8(fOffset, 3);
+                fOffset += 1;
+                output.setUint32(fOffset, writtenVertices + i4, options.littleEndian);
+                fOffset += indexByteCount;
+                output.setUint32(fOffset, writtenVertices + i4 + 1, options.littleEndian);
+                fOffset += indexByteCount;
+                output.setUint32(fOffset, writtenVertices + i4 + 2, options.littleEndian);
+                fOffset += indexByteCount;
+              }
+            }
+          }
+          writtenVertices += vertices.count;
+        });
+        result = output.buffer;
+      } else {
+        let writtenVertices = 0;
+        let vertexList = "";
+        let faceList = "";
+        traverseMeshes(function(mesh, geometry) {
+          const vertices = geometry.getAttribute("position");
+          const normals = geometry.getAttribute("normal");
+          const uvs = geometry.getAttribute("uv");
+          const colors = geometry.getAttribute("color");
+          const indices = geometry.getIndex();
+          normalMatrixWorld.getNormalMatrix(mesh.matrixWorld);
+          for (let i4 = 0, l4 = vertices.count; i4 < l4; i4++) {
+            vertex2.fromBufferAttribute(vertices, i4);
+            vertex2.applyMatrix4(mesh.matrixWorld);
+            let line = vertex2.x + " " + vertex2.y + " " + vertex2.z;
+            if (includeNormals === true) {
+              if (normals != null) {
+                vertex2.fromBufferAttribute(normals, i4);
+                vertex2.applyMatrix3(normalMatrixWorld).normalize();
+                line += " " + vertex2.x + " " + vertex2.y + " " + vertex2.z;
+              } else {
+                line += " 0 0 0";
+              }
+            }
+            if (includeUVs === true) {
+              if (uvs != null) {
+                line += " " + uvs.getX(i4) + " " + uvs.getY(i4);
+              } else {
+                line += " 0 0";
+              }
+            }
+            if (includeColors === true) {
+              if (colors != null) {
+                tempColor.fromBufferAttribute(colors, i4).convertLinearToSRGB();
+                line += " " + Math.floor(tempColor.r * 255) + " " + Math.floor(tempColor.g * 255) + " " + Math.floor(tempColor.b * 255);
+              } else {
+                line += " 255 255 255";
+              }
+            }
+            vertexList += line + "\n";
+          }
+          if (includeIndices === true) {
+            if (indices !== null) {
+              for (let i4 = 0, l4 = indices.count; i4 < l4; i4 += 3) {
+                faceList += `3 ${indices.getX(i4 + 0) + writtenVertices}`;
+                faceList += ` ${indices.getX(i4 + 1) + writtenVertices}`;
+                faceList += ` ${indices.getX(i4 + 2) + writtenVertices}
+`;
+              }
+            } else {
+              for (let i4 = 0, l4 = vertices.count; i4 < l4; i4 += 3) {
+                faceList += `3 ${writtenVertices + i4} ${writtenVertices + i4 + 1} ${writtenVertices + i4 + 2}
+`;
+              }
+            }
+            faceCount += indices ? indices.count / 3 : vertices.count / 3;
+          }
+          writtenVertices += vertices.count;
+        });
+        result = `${header}${vertexList}${includeIndices ? `${faceList}
+` : "\n"}`;
+      }
+      if (typeof onDone === "function") requestAnimationFrame(() => onDone(result));
+      return result;
+    }
+  };
+
+  // ../../node_modules/three/examples/jsm/exporters/GLTFExporter.js
+  init_dirname();
+  init_buffer2();
+  init_process2();
+  init_three_module();
+
+  // ../../node_modules/three/examples/jsm/utils/TextureUtils.js
+  init_dirname();
+  init_buffer2();
+  init_process2();
+  init_three_module();
+  var _renderer;
+  var fullscreenQuadGeometry;
+  var fullscreenQuadMaterial;
+  var fullscreenQuad;
+  function decompress(texture, maxTextureSize = Infinity, renderer = null) {
+    if (!fullscreenQuadGeometry) fullscreenQuadGeometry = new PlaneGeometry(2, 2, 1, 1);
+    if (!fullscreenQuadMaterial) fullscreenQuadMaterial = new ShaderMaterial({
+      uniforms: { blitTexture: new Uniform(texture) },
+      vertexShader: `
+            varying vec2 vUv;
+            void main(){
+                vUv = uv;
+                gl_Position = vec4(position.xy * 1.0,0.,.999999);
+            }`,
+      fragmentShader: `
+            uniform sampler2D blitTexture; 
+            varying vec2 vUv;
+
+            void main(){ 
+                gl_FragColor = vec4(vUv.xy, 0, 1);
+                
+                #ifdef IS_SRGB
+                gl_FragColor = LinearTosRGB( texture2D( blitTexture, vUv) );
+                #else
+                gl_FragColor = texture2D( blitTexture, vUv);
+                #endif
+            }`
+    });
+    fullscreenQuadMaterial.uniforms.blitTexture.value = texture;
+    fullscreenQuadMaterial.defines.IS_SRGB = texture.colorSpace == SRGBColorSpace;
+    fullscreenQuadMaterial.needsUpdate = true;
+    if (!fullscreenQuad) {
+      fullscreenQuad = new Mesh(fullscreenQuadGeometry, fullscreenQuadMaterial);
+      fullscreenQuad.frustrumCulled = false;
+    }
+    const _camera = new PerspectiveCamera();
+    const _scene = new Scene();
+    _scene.add(fullscreenQuad);
+    if (!renderer) {
+      renderer = _renderer = new WebGLRenderer({ antialias: false });
+    }
+    renderer.setSize(Math.min(texture.image.width, maxTextureSize), Math.min(texture.image.height, maxTextureSize));
+    renderer.clear();
+    renderer.render(_scene, _camera);
+    const readableTexture = new Texture(renderer.domElement);
+    readableTexture.minFilter = texture.minFilter;
+    readableTexture.magFilter = texture.magFilter;
+    readableTexture.wrapS = texture.wrapS;
+    readableTexture.wrapT = texture.wrapT;
+    readableTexture.name = texture.name;
+    if (_renderer) {
+      _renderer.dispose();
+      _renderer = null;
+    }
+    return readableTexture;
+  }
+
+  // ../../node_modules/three/examples/jsm/exporters/GLTFExporter.js
+  var KHR_mesh_quantization_ExtraAttrTypes = {
+    POSITION: [
+      "byte",
+      "byte normalized",
+      "unsigned byte",
+      "unsigned byte normalized",
+      "short",
+      "short normalized",
+      "unsigned short",
+      "unsigned short normalized"
+    ],
+    NORMAL: [
+      "byte normalized",
+      "short normalized"
+    ],
+    TANGENT: [
+      "byte normalized",
+      "short normalized"
+    ],
+    TEXCOORD: [
+      "byte",
+      "byte normalized",
+      "unsigned byte",
+      "short",
+      "short normalized",
+      "unsigned short"
+    ]
+  };
+  var GLTFExporter = class {
+    constructor() {
+      this.pluginCallbacks = [];
+      this.register(function(writer) {
+        return new GLTFLightExtension(writer);
+      });
+      this.register(function(writer) {
+        return new GLTFMaterialsUnlitExtension(writer);
+      });
+      this.register(function(writer) {
+        return new GLTFMaterialsTransmissionExtension(writer);
+      });
+      this.register(function(writer) {
+        return new GLTFMaterialsVolumeExtension(writer);
+      });
+      this.register(function(writer) {
+        return new GLTFMaterialsIorExtension(writer);
+      });
+      this.register(function(writer) {
+        return new GLTFMaterialsSpecularExtension(writer);
+      });
+      this.register(function(writer) {
+        return new GLTFMaterialsClearcoatExtension(writer);
+      });
+      this.register(function(writer) {
+        return new GLTFMaterialsIridescenceExtension(writer);
+      });
+      this.register(function(writer) {
+        return new GLTFMaterialsSheenExtension(writer);
+      });
+      this.register(function(writer) {
+        return new GLTFMaterialsAnisotropyExtension(writer);
+      });
+      this.register(function(writer) {
+        return new GLTFMaterialsEmissiveStrengthExtension(writer);
+      });
+      this.register(function(writer) {
+        return new GLTFMeshGpuInstancing(writer);
+      });
+    }
+    register(callback) {
+      if (this.pluginCallbacks.indexOf(callback) === -1) {
+        this.pluginCallbacks.push(callback);
+      }
+      return this;
+    }
+    unregister(callback) {
+      if (this.pluginCallbacks.indexOf(callback) !== -1) {
+        this.pluginCallbacks.splice(this.pluginCallbacks.indexOf(callback), 1);
+      }
+      return this;
+    }
+    /**
+     * Parse scenes and generate GLTF output
+     * @param  {Scene or [THREE.Scenes]} input   Scene or Array of THREE.Scenes
+     * @param  {Function} onDone  Callback on completed
+     * @param  {Function} onError  Callback on errors
+     * @param  {Object} options options
+     */
+    parse(input, onDone, onError, options) {
+      const writer = new GLTFWriter();
+      const plugins = [];
+      for (let i4 = 0, il = this.pluginCallbacks.length; i4 < il; i4++) {
+        plugins.push(this.pluginCallbacks[i4](writer));
+      }
+      writer.setPlugins(plugins);
+      writer.write(input, onDone, options).catch(onError);
+    }
+    parseAsync(input, options) {
+      const scope = this;
+      return new Promise(function(resolve, reject) {
+        scope.parse(input, resolve, reject, options);
+      });
+    }
+  };
+  var WEBGL_CONSTANTS = {
+    POINTS: 0,
+    LINES: 1,
+    LINE_LOOP: 2,
+    LINE_STRIP: 3,
+    TRIANGLES: 4,
+    TRIANGLE_STRIP: 5,
+    TRIANGLE_FAN: 6,
+    BYTE: 5120,
+    UNSIGNED_BYTE: 5121,
+    SHORT: 5122,
+    UNSIGNED_SHORT: 5123,
+    INT: 5124,
+    UNSIGNED_INT: 5125,
+    FLOAT: 5126,
+    ARRAY_BUFFER: 34962,
+    ELEMENT_ARRAY_BUFFER: 34963,
+    NEAREST: 9728,
+    LINEAR: 9729,
+    NEAREST_MIPMAP_NEAREST: 9984,
+    LINEAR_MIPMAP_NEAREST: 9985,
+    NEAREST_MIPMAP_LINEAR: 9986,
+    LINEAR_MIPMAP_LINEAR: 9987,
+    CLAMP_TO_EDGE: 33071,
+    MIRRORED_REPEAT: 33648,
+    REPEAT: 10497
+  };
+  var KHR_MESH_QUANTIZATION = "KHR_mesh_quantization";
+  var THREE_TO_WEBGL = {};
+  THREE_TO_WEBGL[NearestFilter] = WEBGL_CONSTANTS.NEAREST;
+  THREE_TO_WEBGL[NearestMipmapNearestFilter] = WEBGL_CONSTANTS.NEAREST_MIPMAP_NEAREST;
+  THREE_TO_WEBGL[NearestMipmapLinearFilter] = WEBGL_CONSTANTS.NEAREST_MIPMAP_LINEAR;
+  THREE_TO_WEBGL[LinearFilter] = WEBGL_CONSTANTS.LINEAR;
+  THREE_TO_WEBGL[LinearMipmapNearestFilter] = WEBGL_CONSTANTS.LINEAR_MIPMAP_NEAREST;
+  THREE_TO_WEBGL[LinearMipmapLinearFilter] = WEBGL_CONSTANTS.LINEAR_MIPMAP_LINEAR;
+  THREE_TO_WEBGL[ClampToEdgeWrapping] = WEBGL_CONSTANTS.CLAMP_TO_EDGE;
+  THREE_TO_WEBGL[RepeatWrapping] = WEBGL_CONSTANTS.REPEAT;
+  THREE_TO_WEBGL[MirroredRepeatWrapping] = WEBGL_CONSTANTS.MIRRORED_REPEAT;
+  var PATH_PROPERTIES = {
+    scale: "scale",
+    position: "translation",
+    quaternion: "rotation",
+    morphTargetInfluences: "weights"
+  };
+  var DEFAULT_SPECULAR_COLOR = new Color();
+  var GLB_HEADER_BYTES = 12;
+  var GLB_HEADER_MAGIC = 1179937895;
+  var GLB_VERSION = 2;
+  var GLB_CHUNK_PREFIX_BYTES = 8;
+  var GLB_CHUNK_TYPE_JSON = 1313821514;
+  var GLB_CHUNK_TYPE_BIN = 5130562;
+  function equalArray(array1, array2) {
+    return array1.length === array2.length && array1.every(function(element, index) {
+      return element === array2[index];
+    });
+  }
+  function stringToArrayBuffer(text) {
+    return new TextEncoder().encode(text).buffer;
+  }
+  function isIdentityMatrix(matrix) {
+    return equalArray(matrix.elements, [1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1]);
+  }
+  function getMinMax(attribute, start, count) {
+    const output = {
+      min: new Array(attribute.itemSize).fill(Number.POSITIVE_INFINITY),
+      max: new Array(attribute.itemSize).fill(Number.NEGATIVE_INFINITY)
+    };
+    for (let i4 = start; i4 < start + count; i4++) {
+      for (let a4 = 0; a4 < attribute.itemSize; a4++) {
+        let value;
+        if (attribute.itemSize > 4) {
+          value = attribute.array[i4 * attribute.itemSize + a4];
+        } else {
+          if (a4 === 0) value = attribute.getX(i4);
+          else if (a4 === 1) value = attribute.getY(i4);
+          else if (a4 === 2) value = attribute.getZ(i4);
+          else if (a4 === 3) value = attribute.getW(i4);
+          if (attribute.normalized === true) {
+            value = MathUtils.normalize(value, attribute.array);
+          }
+        }
+        output.min[a4] = Math.min(output.min[a4], value);
+        output.max[a4] = Math.max(output.max[a4], value);
+      }
+    }
+    return output;
+  }
+  function getPaddedBufferSize(bufferSize) {
+    return Math.ceil(bufferSize / 4) * 4;
+  }
+  function getPaddedArrayBuffer(arrayBuffer, paddingByte = 0) {
+    const paddedLength = getPaddedBufferSize(arrayBuffer.byteLength);
+    if (paddedLength !== arrayBuffer.byteLength) {
+      const array = new Uint8Array(paddedLength);
+      array.set(new Uint8Array(arrayBuffer));
+      if (paddingByte !== 0) {
+        for (let i4 = arrayBuffer.byteLength; i4 < paddedLength; i4++) {
+          array[i4] = paddingByte;
+        }
+      }
+      return array.buffer;
+    }
+    return arrayBuffer;
+  }
+  function getCanvas() {
+    if (typeof document === "undefined" && typeof OffscreenCanvas !== "undefined") {
+      return new OffscreenCanvas(1, 1);
+    }
+    return document.createElement("canvas");
+  }
+  function getToBlobPromise(canvas, mimeType) {
+    if (canvas.toBlob !== void 0) {
+      return new Promise((resolve) => canvas.toBlob(resolve, mimeType));
+    }
+    let quality;
+    if (mimeType === "image/jpeg") {
+      quality = 0.92;
+    } else if (mimeType === "image/webp") {
+      quality = 0.8;
+    }
+    return canvas.convertToBlob({
+      type: mimeType,
+      quality
+    });
+  }
+  var GLTFWriter = class {
+    constructor() {
+      this.plugins = [];
+      this.options = {};
+      this.pending = [];
+      this.buffers = [];
+      this.byteOffset = 0;
+      this.buffers = [];
+      this.nodeMap = /* @__PURE__ */ new Map();
+      this.skins = [];
+      this.extensionsUsed = {};
+      this.extensionsRequired = {};
+      this.uids = /* @__PURE__ */ new Map();
+      this.uid = 0;
+      this.json = {
+        asset: {
+          version: "2.0",
+          generator: "THREE.GLTFExporter"
+        }
+      };
+      this.cache = {
+        meshes: /* @__PURE__ */ new Map(),
+        attributes: /* @__PURE__ */ new Map(),
+        attributesNormalized: /* @__PURE__ */ new Map(),
+        materials: /* @__PURE__ */ new Map(),
+        textures: /* @__PURE__ */ new Map(),
+        images: /* @__PURE__ */ new Map()
+      };
+    }
+    setPlugins(plugins) {
+      this.plugins = plugins;
+    }
+    /**
+     * Parse scenes and generate GLTF output
+     * @param  {Scene or [THREE.Scenes]} input   Scene or Array of THREE.Scenes
+     * @param  {Function} onDone  Callback on completed
+     * @param  {Object} options options
+     */
+    async write(input, onDone, options = {}) {
+      this.options = Object.assign({
+        // default options
+        binary: false,
+        trs: false,
+        onlyVisible: true,
+        maxTextureSize: Infinity,
+        animations: [],
+        includeCustomExtensions: false
+      }, options);
+      if (this.options.animations.length > 0) {
+        this.options.trs = true;
+      }
+      this.processInput(input);
+      await Promise.all(this.pending);
+      const writer = this;
+      const buffers = writer.buffers;
+      const json = writer.json;
+      options = writer.options;
+      const extensionsUsed = writer.extensionsUsed;
+      const extensionsRequired = writer.extensionsRequired;
+      const blob = new Blob(buffers, { type: "application/octet-stream" });
+      const extensionsUsedList = Object.keys(extensionsUsed);
+      const extensionsRequiredList = Object.keys(extensionsRequired);
+      if (extensionsUsedList.length > 0) json.extensionsUsed = extensionsUsedList;
+      if (extensionsRequiredList.length > 0) json.extensionsRequired = extensionsRequiredList;
+      if (json.buffers && json.buffers.length > 0) json.buffers[0].byteLength = blob.size;
+      if (options.binary === true) {
+        const reader = new FileReader();
+        reader.readAsArrayBuffer(blob);
+        reader.onloadend = function() {
+          const binaryChunk = getPaddedArrayBuffer(reader.result);
+          const binaryChunkPrefix = new DataView(new ArrayBuffer(GLB_CHUNK_PREFIX_BYTES));
+          binaryChunkPrefix.setUint32(0, binaryChunk.byteLength, true);
+          binaryChunkPrefix.setUint32(4, GLB_CHUNK_TYPE_BIN, true);
+          const jsonChunk = getPaddedArrayBuffer(stringToArrayBuffer(JSON.stringify(json)), 32);
+          const jsonChunkPrefix = new DataView(new ArrayBuffer(GLB_CHUNK_PREFIX_BYTES));
+          jsonChunkPrefix.setUint32(0, jsonChunk.byteLength, true);
+          jsonChunkPrefix.setUint32(4, GLB_CHUNK_TYPE_JSON, true);
+          const header = new ArrayBuffer(GLB_HEADER_BYTES);
+          const headerView = new DataView(header);
+          headerView.setUint32(0, GLB_HEADER_MAGIC, true);
+          headerView.setUint32(4, GLB_VERSION, true);
+          const totalByteLength = GLB_HEADER_BYTES + jsonChunkPrefix.byteLength + jsonChunk.byteLength + binaryChunkPrefix.byteLength + binaryChunk.byteLength;
+          headerView.setUint32(8, totalByteLength, true);
+          const glbBlob = new Blob([
+            header,
+            jsonChunkPrefix,
+            jsonChunk,
+            binaryChunkPrefix,
+            binaryChunk
+          ], { type: "application/octet-stream" });
+          const glbReader = new FileReader();
+          glbReader.readAsArrayBuffer(glbBlob);
+          glbReader.onloadend = function() {
+            onDone(glbReader.result);
+          };
+        };
+      } else {
+        if (json.buffers && json.buffers.length > 0) {
+          const reader = new FileReader();
+          reader.readAsDataURL(blob);
+          reader.onloadend = function() {
+            const base64data = reader.result;
+            json.buffers[0].uri = base64data;
+            onDone(json);
+          };
+        } else {
+          onDone(json);
+        }
+      }
+    }
+    /**
+     * Serializes a userData.
+     *
+     * @param {THREE.Object3D|THREE.Material} object
+     * @param {Object} objectDef
+     */
+    serializeUserData(object, objectDef) {
+      if (Object.keys(object.userData).length === 0) return;
+      const options = this.options;
+      const extensionsUsed = this.extensionsUsed;
+      try {
+        const json = JSON.parse(JSON.stringify(object.userData));
+        if (options.includeCustomExtensions && json.gltfExtensions) {
+          if (objectDef.extensions === void 0) objectDef.extensions = {};
+          for (const extensionName in json.gltfExtensions) {
+            objectDef.extensions[extensionName] = json.gltfExtensions[extensionName];
+            extensionsUsed[extensionName] = true;
+          }
+          delete json.gltfExtensions;
+        }
+        if (Object.keys(json).length > 0) objectDef.extras = json;
+      } catch (error) {
+        console.warn("THREE.GLTFExporter: userData of '" + object.name + "' won't be serialized because of JSON.stringify error - " + error.message);
+      }
+    }
+    /**
+     * Returns ids for buffer attributes.
+     * @param  {Object} object
+     * @return {Integer}
+     */
+    getUID(attribute, isRelativeCopy = false) {
+      if (this.uids.has(attribute) === false) {
+        const uids2 = /* @__PURE__ */ new Map();
+        uids2.set(true, this.uid++);
+        uids2.set(false, this.uid++);
+        this.uids.set(attribute, uids2);
+      }
+      const uids = this.uids.get(attribute);
+      return uids.get(isRelativeCopy);
+    }
+    /**
+     * Checks if normal attribute values are normalized.
+     *
+     * @param {BufferAttribute} normal
+     * @returns {Boolean}
+     */
+    isNormalizedNormalAttribute(normal) {
+      const cache = this.cache;
+      if (cache.attributesNormalized.has(normal)) return false;
+      const v5 = new Vector3();
+      for (let i4 = 0, il = normal.count; i4 < il; i4++) {
+        if (Math.abs(v5.fromBufferAttribute(normal, i4).length() - 1) > 5e-4) return false;
+      }
+      return true;
+    }
+    /**
+     * Creates normalized normal buffer attribute.
+     *
+     * @param {BufferAttribute} normal
+     * @returns {BufferAttribute}
+     *
+     */
+    createNormalizedNormalAttribute(normal) {
+      const cache = this.cache;
+      if (cache.attributesNormalized.has(normal)) return cache.attributesNormalized.get(normal);
+      const attribute = normal.clone();
+      const v5 = new Vector3();
+      for (let i4 = 0, il = attribute.count; i4 < il; i4++) {
+        v5.fromBufferAttribute(attribute, i4);
+        if (v5.x === 0 && v5.y === 0 && v5.z === 0) {
+          v5.setX(1);
+        } else {
+          v5.normalize();
+        }
+        attribute.setXYZ(i4, v5.x, v5.y, v5.z);
+      }
+      cache.attributesNormalized.set(normal, attribute);
+      return attribute;
+    }
+    /**
+     * Applies a texture transform, if present, to the map definition. Requires
+     * the KHR_texture_transform extension.
+     *
+     * @param {Object} mapDef
+     * @param {THREE.Texture} texture
+     */
+    applyTextureTransform(mapDef, texture) {
+      let didTransform = false;
+      const transformDef = {};
+      if (texture.offset.x !== 0 || texture.offset.y !== 0) {
+        transformDef.offset = texture.offset.toArray();
+        didTransform = true;
+      }
+      if (texture.rotation !== 0) {
+        transformDef.rotation = texture.rotation;
+        didTransform = true;
+      }
+      if (texture.repeat.x !== 1 || texture.repeat.y !== 1) {
+        transformDef.scale = texture.repeat.toArray();
+        didTransform = true;
+      }
+      if (didTransform) {
+        mapDef.extensions = mapDef.extensions || {};
+        mapDef.extensions["KHR_texture_transform"] = transformDef;
+        this.extensionsUsed["KHR_texture_transform"] = true;
+      }
+    }
+    buildMetalRoughTexture(metalnessMap, roughnessMap) {
+      if (metalnessMap === roughnessMap) return metalnessMap;
+      function getEncodingConversion(map) {
+        if (map.colorSpace === SRGBColorSpace) {
+          return function SRGBToLinear2(c4) {
+            return c4 < 0.04045 ? c4 * 0.0773993808 : Math.pow(c4 * 0.9478672986 + 0.0521327014, 2.4);
+          };
+        }
+        return function LinearToLinear(c4) {
+          return c4;
+        };
+      }
+      console.warn("THREE.GLTFExporter: Merged metalnessMap and roughnessMap textures.");
+      if (metalnessMap instanceof CompressedTexture) {
+        metalnessMap = decompress(metalnessMap);
+      }
+      if (roughnessMap instanceof CompressedTexture) {
+        roughnessMap = decompress(roughnessMap);
+      }
+      const metalness = metalnessMap ? metalnessMap.image : null;
+      const roughness = roughnessMap ? roughnessMap.image : null;
+      const width = Math.max(metalness ? metalness.width : 0, roughness ? roughness.width : 0);
+      const height = Math.max(metalness ? metalness.height : 0, roughness ? roughness.height : 0);
+      const canvas = getCanvas();
+      canvas.width = width;
+      canvas.height = height;
+      const context = canvas.getContext("2d");
+      context.fillStyle = "#00ffff";
+      context.fillRect(0, 0, width, height);
+      const composite = context.getImageData(0, 0, width, height);
+      if (metalness) {
+        context.drawImage(metalness, 0, 0, width, height);
+        const convert = getEncodingConversion(metalnessMap);
+        const data = context.getImageData(0, 0, width, height).data;
+        for (let i4 = 2; i4 < data.length; i4 += 4) {
+          composite.data[i4] = convert(data[i4] / 256) * 256;
+        }
+      }
+      if (roughness) {
+        context.drawImage(roughness, 0, 0, width, height);
+        const convert = getEncodingConversion(roughnessMap);
+        const data = context.getImageData(0, 0, width, height).data;
+        for (let i4 = 1; i4 < data.length; i4 += 4) {
+          composite.data[i4] = convert(data[i4] / 256) * 256;
+        }
+      }
+      context.putImageData(composite, 0, 0);
+      const reference = metalnessMap || roughnessMap;
+      const texture = reference.clone();
+      texture.source = new Source(canvas);
+      texture.colorSpace = NoColorSpace;
+      texture.channel = (metalnessMap || roughnessMap).channel;
+      if (metalnessMap && roughnessMap && metalnessMap.channel !== roughnessMap.channel) {
+        console.warn("THREE.GLTFExporter: UV channels for metalnessMap and roughnessMap textures must match.");
+      }
+      return texture;
+    }
+    /**
+     * Process a buffer to append to the default one.
+     * @param  {ArrayBuffer} buffer
+     * @return {Integer}
+     */
+    processBuffer(buffer2) {
+      const json = this.json;
+      const buffers = this.buffers;
+      if (!json.buffers) json.buffers = [{ byteLength: 0 }];
+      buffers.push(buffer2);
+      return 0;
+    }
+    /**
+     * Process and generate a BufferView
+     * @param  {BufferAttribute} attribute
+     * @param  {number} componentType
+     * @param  {number} start
+     * @param  {number} count
+     * @param  {number} target (Optional) Target usage of the BufferView
+     * @return {Object}
+     */
+    processBufferView(attribute, componentType, start, count, target) {
+      const json = this.json;
+      if (!json.bufferViews) json.bufferViews = [];
+      let componentSize;
+      switch (componentType) {
+        case WEBGL_CONSTANTS.BYTE:
+        case WEBGL_CONSTANTS.UNSIGNED_BYTE:
+          componentSize = 1;
+          break;
+        case WEBGL_CONSTANTS.SHORT:
+        case WEBGL_CONSTANTS.UNSIGNED_SHORT:
+          componentSize = 2;
+          break;
+        default:
+          componentSize = 4;
+      }
+      const byteLength = getPaddedBufferSize(count * attribute.itemSize * componentSize);
+      const dataView = new DataView(new ArrayBuffer(byteLength));
+      let offset = 0;
+      for (let i4 = start; i4 < start + count; i4++) {
+        for (let a4 = 0; a4 < attribute.itemSize; a4++) {
+          let value;
+          if (attribute.itemSize > 4) {
+            value = attribute.array[i4 * attribute.itemSize + a4];
+          } else {
+            if (a4 === 0) value = attribute.getX(i4);
+            else if (a4 === 1) value = attribute.getY(i4);
+            else if (a4 === 2) value = attribute.getZ(i4);
+            else if (a4 === 3) value = attribute.getW(i4);
+            if (attribute.normalized === true) {
+              value = MathUtils.normalize(value, attribute.array);
+            }
+          }
+          if (componentType === WEBGL_CONSTANTS.FLOAT) {
+            dataView.setFloat32(offset, value, true);
+          } else if (componentType === WEBGL_CONSTANTS.INT) {
+            dataView.setInt32(offset, value, true);
+          } else if (componentType === WEBGL_CONSTANTS.UNSIGNED_INT) {
+            dataView.setUint32(offset, value, true);
+          } else if (componentType === WEBGL_CONSTANTS.SHORT) {
+            dataView.setInt16(offset, value, true);
+          } else if (componentType === WEBGL_CONSTANTS.UNSIGNED_SHORT) {
+            dataView.setUint16(offset, value, true);
+          } else if (componentType === WEBGL_CONSTANTS.BYTE) {
+            dataView.setInt8(offset, value);
+          } else if (componentType === WEBGL_CONSTANTS.UNSIGNED_BYTE) {
+            dataView.setUint8(offset, value);
+          }
+          offset += componentSize;
+        }
+      }
+      const bufferViewDef = {
+        buffer: this.processBuffer(dataView.buffer),
+        byteOffset: this.byteOffset,
+        byteLength
+      };
+      if (target !== void 0) bufferViewDef.target = target;
+      if (target === WEBGL_CONSTANTS.ARRAY_BUFFER) {
+        bufferViewDef.byteStride = attribute.itemSize * componentSize;
+      }
+      this.byteOffset += byteLength;
+      json.bufferViews.push(bufferViewDef);
+      const output = {
+        id: json.bufferViews.length - 1,
+        byteLength: 0
+      };
+      return output;
+    }
+    /**
+     * Process and generate a BufferView from an image Blob.
+     * @param {Blob} blob
+     * @return {Promise<Integer>}
+     */
+    processBufferViewImage(blob) {
+      const writer = this;
+      const json = writer.json;
+      if (!json.bufferViews) json.bufferViews = [];
+      return new Promise(function(resolve) {
+        const reader = new FileReader();
+        reader.readAsArrayBuffer(blob);
+        reader.onloadend = function() {
+          const buffer2 = getPaddedArrayBuffer(reader.result);
+          const bufferViewDef = {
+            buffer: writer.processBuffer(buffer2),
+            byteOffset: writer.byteOffset,
+            byteLength: buffer2.byteLength
+          };
+          writer.byteOffset += buffer2.byteLength;
+          resolve(json.bufferViews.push(bufferViewDef) - 1);
+        };
+      });
+    }
+    /**
+     * Process attribute to generate an accessor
+     * @param  {BufferAttribute} attribute Attribute to process
+     * @param  {THREE.BufferGeometry} geometry (Optional) Geometry used for truncated draw range
+     * @param  {Integer} start (Optional)
+     * @param  {Integer} count (Optional)
+     * @return {Integer|null} Index of the processed accessor on the "accessors" array
+     */
+    processAccessor(attribute, geometry, start, count) {
+      const json = this.json;
+      const types2 = {
+        1: "SCALAR",
+        2: "VEC2",
+        3: "VEC3",
+        4: "VEC4",
+        9: "MAT3",
+        16: "MAT4"
+      };
+      let componentType;
+      if (attribute.array.constructor === Float32Array) {
+        componentType = WEBGL_CONSTANTS.FLOAT;
+      } else if (attribute.array.constructor === Int32Array) {
+        componentType = WEBGL_CONSTANTS.INT;
+      } else if (attribute.array.constructor === Uint32Array) {
+        componentType = WEBGL_CONSTANTS.UNSIGNED_INT;
+      } else if (attribute.array.constructor === Int16Array) {
+        componentType = WEBGL_CONSTANTS.SHORT;
+      } else if (attribute.array.constructor === Uint16Array) {
+        componentType = WEBGL_CONSTANTS.UNSIGNED_SHORT;
+      } else if (attribute.array.constructor === Int8Array) {
+        componentType = WEBGL_CONSTANTS.BYTE;
+      } else if (attribute.array.constructor === Uint8Array) {
+        componentType = WEBGL_CONSTANTS.UNSIGNED_BYTE;
+      } else {
+        throw new Error("THREE.GLTFExporter: Unsupported bufferAttribute component type: " + attribute.array.constructor.name);
+      }
+      if (start === void 0) start = 0;
+      if (count === void 0 || count === Infinity) count = attribute.count;
+      if (count === 0) return null;
+      const minMax = getMinMax(attribute, start, count);
+      let bufferViewTarget;
+      if (geometry !== void 0) {
+        bufferViewTarget = attribute === geometry.index ? WEBGL_CONSTANTS.ELEMENT_ARRAY_BUFFER : WEBGL_CONSTANTS.ARRAY_BUFFER;
+      }
+      const bufferView = this.processBufferView(attribute, componentType, start, count, bufferViewTarget);
+      const accessorDef = {
+        bufferView: bufferView.id,
+        byteOffset: bufferView.byteOffset,
+        componentType,
+        count,
+        max: minMax.max,
+        min: minMax.min,
+        type: types2[attribute.itemSize]
+      };
+      if (attribute.normalized === true) accessorDef.normalized = true;
+      if (!json.accessors) json.accessors = [];
+      return json.accessors.push(accessorDef) - 1;
+    }
+    /**
+     * Process image
+     * @param  {Image} image to process
+     * @param  {Integer} format of the image (RGBAFormat)
+     * @param  {Boolean} flipY before writing out the image
+     * @param  {String} mimeType export format
+     * @return {Integer}     Index of the processed texture in the "images" array
+     */
+    processImage(image, format2, flipY, mimeType = "image/png") {
+      if (image !== null) {
+        const writer = this;
+        const cache = writer.cache;
+        const json = writer.json;
+        const options = writer.options;
+        const pending = writer.pending;
+        if (!cache.images.has(image)) cache.images.set(image, {});
+        const cachedImages = cache.images.get(image);
+        const key = mimeType + ":flipY/" + flipY.toString();
+        if (cachedImages[key] !== void 0) return cachedImages[key];
+        if (!json.images) json.images = [];
+        const imageDef = { mimeType };
+        const canvas = getCanvas();
+        canvas.width = Math.min(image.width, options.maxTextureSize);
+        canvas.height = Math.min(image.height, options.maxTextureSize);
+        const ctx2 = canvas.getContext("2d");
+        if (flipY === true) {
+          ctx2.translate(0, canvas.height);
+          ctx2.scale(1, -1);
+        }
+        if (image.data !== void 0) {
+          if (format2 !== RGBAFormat) {
+            console.error("GLTFExporter: Only RGBAFormat is supported.", format2);
+          }
+          if (image.width > options.maxTextureSize || image.height > options.maxTextureSize) {
+            console.warn("GLTFExporter: Image size is bigger than maxTextureSize", image);
+          }
+          const data = new Uint8ClampedArray(image.height * image.width * 4);
+          for (let i4 = 0; i4 < data.length; i4 += 4) {
+            data[i4 + 0] = image.data[i4 + 0];
+            data[i4 + 1] = image.data[i4 + 1];
+            data[i4 + 2] = image.data[i4 + 2];
+            data[i4 + 3] = image.data[i4 + 3];
+          }
+          ctx2.putImageData(new ImageData(data, image.width, image.height), 0, 0);
+        } else {
+          ctx2.drawImage(image, 0, 0, canvas.width, canvas.height);
+        }
+        if (options.binary === true) {
+          pending.push(
+            getToBlobPromise(canvas, mimeType).then((blob) => writer.processBufferViewImage(blob)).then((bufferViewIndex) => {
+              imageDef.bufferView = bufferViewIndex;
+            })
+          );
+        } else {
+          if (canvas.toDataURL !== void 0) {
+            imageDef.uri = canvas.toDataURL(mimeType);
+          } else {
+            pending.push(
+              getToBlobPromise(canvas, mimeType).then((blob) => new FileReader().readAsDataURL(blob)).then((dataURL) => {
+                imageDef.uri = dataURL;
+              })
+            );
+          }
+        }
+        const index = json.images.push(imageDef) - 1;
+        cachedImages[key] = index;
+        return index;
+      } else {
+        throw new Error("THREE.GLTFExporter: No valid image data found. Unable to process texture.");
+      }
+    }
+    /**
+     * Process sampler
+     * @param  {Texture} map Texture to process
+     * @return {Integer}     Index of the processed texture in the "samplers" array
+     */
+    processSampler(map) {
+      const json = this.json;
+      if (!json.samplers) json.samplers = [];
+      const samplerDef = {
+        magFilter: THREE_TO_WEBGL[map.magFilter],
+        minFilter: THREE_TO_WEBGL[map.minFilter],
+        wrapS: THREE_TO_WEBGL[map.wrapS],
+        wrapT: THREE_TO_WEBGL[map.wrapT]
+      };
+      return json.samplers.push(samplerDef) - 1;
+    }
+    /**
+     * Process texture
+     * @param  {Texture} map Map to process
+     * @return {Integer} Index of the processed texture in the "textures" array
+     */
+    processTexture(map) {
+      const writer = this;
+      const options = writer.options;
+      const cache = this.cache;
+      const json = this.json;
+      if (cache.textures.has(map)) return cache.textures.get(map);
+      if (!json.textures) json.textures = [];
+      if (map instanceof CompressedTexture) {
+        map = decompress(map, options.maxTextureSize);
+      }
+      let mimeType = map.userData.mimeType;
+      if (mimeType === "image/webp") mimeType = "image/png";
+      const textureDef = {
+        sampler: this.processSampler(map),
+        source: this.processImage(map.image, map.format, map.flipY, mimeType)
+      };
+      if (map.name) textureDef.name = map.name;
+      this._invokeAll(function(ext) {
+        ext.writeTexture && ext.writeTexture(map, textureDef);
+      });
+      const index = json.textures.push(textureDef) - 1;
+      cache.textures.set(map, index);
+      return index;
+    }
+    /**
+     * Process material
+     * @param  {THREE.Material} material Material to process
+     * @return {Integer|null} Index of the processed material in the "materials" array
+     */
+    processMaterial(material) {
+      const cache = this.cache;
+      const json = this.json;
+      if (cache.materials.has(material)) return cache.materials.get(material);
+      if (material.isShaderMaterial) {
+        console.warn("GLTFExporter: THREE.ShaderMaterial not supported.");
+        return null;
+      }
+      if (!json.materials) json.materials = [];
+      const materialDef = { pbrMetallicRoughness: {} };
+      if (material.isMeshStandardMaterial !== true && material.isMeshBasicMaterial !== true) {
+        console.warn("GLTFExporter: Use MeshStandardMaterial or MeshBasicMaterial for best results.");
+      }
+      const color2 = material.color.toArray().concat([material.opacity]);
+      if (!equalArray(color2, [1, 1, 1, 1])) {
+        materialDef.pbrMetallicRoughness.baseColorFactor = color2;
+      }
+      if (material.isMeshStandardMaterial) {
+        materialDef.pbrMetallicRoughness.metallicFactor = material.metalness;
+        materialDef.pbrMetallicRoughness.roughnessFactor = material.roughness;
+      } else {
+        materialDef.pbrMetallicRoughness.metallicFactor = 0.5;
+        materialDef.pbrMetallicRoughness.roughnessFactor = 0.5;
+      }
+      if (material.metalnessMap || material.roughnessMap) {
+        const metalRoughTexture = this.buildMetalRoughTexture(material.metalnessMap, material.roughnessMap);
+        const metalRoughMapDef = {
+          index: this.processTexture(metalRoughTexture),
+          channel: metalRoughTexture.channel
+        };
+        this.applyTextureTransform(metalRoughMapDef, metalRoughTexture);
+        materialDef.pbrMetallicRoughness.metallicRoughnessTexture = metalRoughMapDef;
+      }
+      if (material.map) {
+        const baseColorMapDef = {
+          index: this.processTexture(material.map),
+          texCoord: material.map.channel
+        };
+        this.applyTextureTransform(baseColorMapDef, material.map);
+        materialDef.pbrMetallicRoughness.baseColorTexture = baseColorMapDef;
+      }
+      if (material.emissive) {
+        const emissive = material.emissive;
+        const maxEmissiveComponent = Math.max(emissive.r, emissive.g, emissive.b);
+        if (maxEmissiveComponent > 0) {
+          materialDef.emissiveFactor = material.emissive.toArray();
+        }
+        if (material.emissiveMap) {
+          const emissiveMapDef = {
+            index: this.processTexture(material.emissiveMap),
+            texCoord: material.emissiveMap.channel
+          };
+          this.applyTextureTransform(emissiveMapDef, material.emissiveMap);
+          materialDef.emissiveTexture = emissiveMapDef;
+        }
+      }
+      if (material.normalMap) {
+        const normalMapDef = {
+          index: this.processTexture(material.normalMap),
+          texCoord: material.normalMap.channel
+        };
+        if (material.normalScale && material.normalScale.x !== 1) {
+          normalMapDef.scale = material.normalScale.x;
+        }
+        this.applyTextureTransform(normalMapDef, material.normalMap);
+        materialDef.normalTexture = normalMapDef;
+      }
+      if (material.aoMap) {
+        const occlusionMapDef = {
+          index: this.processTexture(material.aoMap),
+          texCoord: material.aoMap.channel
+        };
+        if (material.aoMapIntensity !== 1) {
+          occlusionMapDef.strength = material.aoMapIntensity;
+        }
+        this.applyTextureTransform(occlusionMapDef, material.aoMap);
+        materialDef.occlusionTexture = occlusionMapDef;
+      }
+      if (material.transparent) {
+        materialDef.alphaMode = "BLEND";
+      } else {
+        if (material.alphaTest > 0) {
+          materialDef.alphaMode = "MASK";
+          materialDef.alphaCutoff = material.alphaTest;
+        }
+      }
+      if (material.side === DoubleSide) materialDef.doubleSided = true;
+      if (material.name !== "") materialDef.name = material.name;
+      this.serializeUserData(material, materialDef);
+      this._invokeAll(function(ext) {
+        ext.writeMaterial && ext.writeMaterial(material, materialDef);
+      });
+      const index = json.materials.push(materialDef) - 1;
+      cache.materials.set(material, index);
+      return index;
+    }
+    /**
+     * Process mesh
+     * @param  {THREE.Mesh} mesh Mesh to process
+     * @return {Integer|null} Index of the processed mesh in the "meshes" array
+     */
+    processMesh(mesh) {
+      const cache = this.cache;
+      const json = this.json;
+      const meshCacheKeyParts = [mesh.geometry.uuid];
+      if (Array.isArray(mesh.material)) {
+        for (let i4 = 0, l4 = mesh.material.length; i4 < l4; i4++) {
+          meshCacheKeyParts.push(mesh.material[i4].uuid);
+        }
+      } else {
+        meshCacheKeyParts.push(mesh.material.uuid);
+      }
+      const meshCacheKey = meshCacheKeyParts.join(":");
+      if (cache.meshes.has(meshCacheKey)) return cache.meshes.get(meshCacheKey);
+      const geometry = mesh.geometry;
+      let mode2;
+      if (mesh.isLineSegments) {
+        mode2 = WEBGL_CONSTANTS.LINES;
+      } else if (mesh.isLineLoop) {
+        mode2 = WEBGL_CONSTANTS.LINE_LOOP;
+      } else if (mesh.isLine) {
+        mode2 = WEBGL_CONSTANTS.LINE_STRIP;
+      } else if (mesh.isPoints) {
+        mode2 = WEBGL_CONSTANTS.POINTS;
+      } else {
+        mode2 = mesh.material.wireframe ? WEBGL_CONSTANTS.LINES : WEBGL_CONSTANTS.TRIANGLES;
+      }
+      const meshDef = {};
+      const attributes = {};
+      const primitives = [];
+      const targets = [];
+      const nameConversion = {
+        uv: "TEXCOORD_0",
+        uv1: "TEXCOORD_1",
+        uv2: "TEXCOORD_2",
+        uv3: "TEXCOORD_3",
+        color: "COLOR_0",
+        skinWeight: "WEIGHTS_0",
+        skinIndex: "JOINTS_0"
+      };
+      const originalNormal = geometry.getAttribute("normal");
+      if (originalNormal !== void 0 && !this.isNormalizedNormalAttribute(originalNormal)) {
+        console.warn("THREE.GLTFExporter: Creating normalized normal attribute from the non-normalized one.");
+        geometry.setAttribute("normal", this.createNormalizedNormalAttribute(originalNormal));
+      }
+      let modifiedAttribute = null;
+      for (let attributeName in geometry.attributes) {
+        if (attributeName.slice(0, 5) === "morph") continue;
+        const attribute = geometry.attributes[attributeName];
+        attributeName = nameConversion[attributeName] || attributeName.toUpperCase();
+        const validVertexAttributes = /^(POSITION|NORMAL|TANGENT|TEXCOORD_\d+|COLOR_\d+|JOINTS_\d+|WEIGHTS_\d+)$/;
+        if (!validVertexAttributes.test(attributeName)) attributeName = "_" + attributeName;
+        if (cache.attributes.has(this.getUID(attribute))) {
+          attributes[attributeName] = cache.attributes.get(this.getUID(attribute));
+          continue;
+        }
+        modifiedAttribute = null;
+        const array = attribute.array;
+        if (attributeName === "JOINTS_0" && !(array instanceof Uint16Array) && !(array instanceof Uint8Array)) {
+          console.warn('GLTFExporter: Attribute "skinIndex" converted to type UNSIGNED_SHORT.');
+          modifiedAttribute = new BufferAttribute(new Uint16Array(array), attribute.itemSize, attribute.normalized);
+        }
+        const accessor = this.processAccessor(modifiedAttribute || attribute, geometry);
+        if (accessor !== null) {
+          if (!attributeName.startsWith("_")) {
+            this.detectMeshQuantization(attributeName, attribute);
+          }
+          attributes[attributeName] = accessor;
+          cache.attributes.set(this.getUID(attribute), accessor);
+        }
+      }
+      if (originalNormal !== void 0) geometry.setAttribute("normal", originalNormal);
+      if (Object.keys(attributes).length === 0) return null;
+      if (mesh.morphTargetInfluences !== void 0 && mesh.morphTargetInfluences.length > 0) {
+        const weights = [];
+        const targetNames = [];
+        const reverseDictionary = {};
+        if (mesh.morphTargetDictionary !== void 0) {
+          for (const key in mesh.morphTargetDictionary) {
+            reverseDictionary[mesh.morphTargetDictionary[key]] = key;
+          }
+        }
+        for (let i4 = 0; i4 < mesh.morphTargetInfluences.length; ++i4) {
+          const target = {};
+          let warned = false;
+          for (const attributeName in geometry.morphAttributes) {
+            if (attributeName !== "position" && attributeName !== "normal") {
+              if (!warned) {
+                console.warn("GLTFExporter: Only POSITION and NORMAL morph are supported.");
+                warned = true;
+              }
+              continue;
+            }
+            const attribute = geometry.morphAttributes[attributeName][i4];
+            const gltfAttributeName = attributeName.toUpperCase();
+            const baseAttribute = geometry.attributes[attributeName];
+            if (cache.attributes.has(this.getUID(attribute, true))) {
+              target[gltfAttributeName] = cache.attributes.get(this.getUID(attribute, true));
+              continue;
+            }
+            const relativeAttribute = attribute.clone();
+            if (!geometry.morphTargetsRelative) {
+              for (let j4 = 0, jl = attribute.count; j4 < jl; j4++) {
+                for (let a4 = 0; a4 < attribute.itemSize; a4++) {
+                  if (a4 === 0) relativeAttribute.setX(j4, attribute.getX(j4) - baseAttribute.getX(j4));
+                  if (a4 === 1) relativeAttribute.setY(j4, attribute.getY(j4) - baseAttribute.getY(j4));
+                  if (a4 === 2) relativeAttribute.setZ(j4, attribute.getZ(j4) - baseAttribute.getZ(j4));
+                  if (a4 === 3) relativeAttribute.setW(j4, attribute.getW(j4) - baseAttribute.getW(j4));
+                }
+              }
+            }
+            target[gltfAttributeName] = this.processAccessor(relativeAttribute, geometry);
+            cache.attributes.set(this.getUID(baseAttribute, true), target[gltfAttributeName]);
+          }
+          targets.push(target);
+          weights.push(mesh.morphTargetInfluences[i4]);
+          if (mesh.morphTargetDictionary !== void 0) targetNames.push(reverseDictionary[i4]);
+        }
+        meshDef.weights = weights;
+        if (targetNames.length > 0) {
+          meshDef.extras = {};
+          meshDef.extras.targetNames = targetNames;
+        }
+      }
+      const isMultiMaterial = Array.isArray(mesh.material);
+      if (isMultiMaterial && geometry.groups.length === 0) return null;
+      const materials = isMultiMaterial ? mesh.material : [mesh.material];
+      const groups = isMultiMaterial ? geometry.groups : [{ materialIndex: 0, start: void 0, count: void 0 }];
+      for (let i4 = 0, il = groups.length; i4 < il; i4++) {
+        const primitive = {
+          mode: mode2,
+          attributes
+        };
+        this.serializeUserData(geometry, primitive);
+        if (targets.length > 0) primitive.targets = targets;
+        if (geometry.index !== null) {
+          let cacheKey = this.getUID(geometry.index);
+          if (groups[i4].start !== void 0 || groups[i4].count !== void 0) {
+            cacheKey += ":" + groups[i4].start + ":" + groups[i4].count;
+          }
+          if (cache.attributes.has(cacheKey)) {
+            primitive.indices = cache.attributes.get(cacheKey);
+          } else {
+            primitive.indices = this.processAccessor(geometry.index, geometry, groups[i4].start, groups[i4].count);
+            cache.attributes.set(cacheKey, primitive.indices);
+          }
+          if (primitive.indices === null) delete primitive.indices;
+        }
+        const material = this.processMaterial(materials[groups[i4].materialIndex]);
+        if (material !== null) primitive.material = material;
+        primitives.push(primitive);
+      }
+      meshDef.primitives = primitives;
+      if (!json.meshes) json.meshes = [];
+      this._invokeAll(function(ext) {
+        ext.writeMesh && ext.writeMesh(mesh, meshDef);
+      });
+      const index = json.meshes.push(meshDef) - 1;
+      cache.meshes.set(meshCacheKey, index);
+      return index;
+    }
+    /**
+     * If a vertex attribute with a
+     * [non-standard data type](https://registry.khronos.org/glTF/specs/2.0/glTF-2.0.html#meshes-overview)
+     * is used, it is checked whether it is a valid data type according to the
+     * [KHR_mesh_quantization](https://github.com/KhronosGroup/glTF/blob/main/extensions/2.0/Khronos/KHR_mesh_quantization/README.md)
+     * extension.
+     * In this case the extension is automatically added to the list of used extensions.
+     *
+     * @param {string} attributeName
+     * @param {THREE.BufferAttribute} attribute
+     */
+    detectMeshQuantization(attributeName, attribute) {
+      if (this.extensionsUsed[KHR_MESH_QUANTIZATION]) return;
+      let attrType = void 0;
+      switch (attribute.array.constructor) {
+        case Int8Array:
+          attrType = "byte";
+          break;
+        case Uint8Array:
+          attrType = "unsigned byte";
+          break;
+        case Int16Array:
+          attrType = "short";
+          break;
+        case Uint16Array:
+          attrType = "unsigned short";
+          break;
+        default:
+          return;
+      }
+      if (attribute.normalized) attrType += " normalized";
+      const attrNamePrefix = attributeName.split("_", 1)[0];
+      if (KHR_mesh_quantization_ExtraAttrTypes[attrNamePrefix] && KHR_mesh_quantization_ExtraAttrTypes[attrNamePrefix].includes(attrType)) {
+        this.extensionsUsed[KHR_MESH_QUANTIZATION] = true;
+        this.extensionsRequired[KHR_MESH_QUANTIZATION] = true;
+      }
+    }
+    /**
+     * Process camera
+     * @param  {THREE.Camera} camera Camera to process
+     * @return {Integer}      Index of the processed mesh in the "camera" array
+     */
+    processCamera(camera) {
+      const json = this.json;
+      if (!json.cameras) json.cameras = [];
+      const isOrtho = camera.isOrthographicCamera;
+      const cameraDef = {
+        type: isOrtho ? "orthographic" : "perspective"
+      };
+      if (isOrtho) {
+        cameraDef.orthographic = {
+          xmag: camera.right * 2,
+          ymag: camera.top * 2,
+          zfar: camera.far <= 0 ? 1e-3 : camera.far,
+          znear: camera.near < 0 ? 0 : camera.near
+        };
+      } else {
+        cameraDef.perspective = {
+          aspectRatio: camera.aspect,
+          yfov: MathUtils.degToRad(camera.fov),
+          zfar: camera.far <= 0 ? 1e-3 : camera.far,
+          znear: camera.near < 0 ? 0 : camera.near
+        };
+      }
+      if (camera.name !== "") cameraDef.name = camera.type;
+      return json.cameras.push(cameraDef) - 1;
+    }
+    /**
+     * Creates glTF animation entry from AnimationClip object.
+     *
+     * Status:
+     * - Only properties listed in PATH_PROPERTIES may be animated.
+     *
+     * @param {THREE.AnimationClip} clip
+     * @param {THREE.Object3D} root
+     * @return {number|null}
+     */
+    processAnimation(clip, root) {
+      const json = this.json;
+      const nodeMap = this.nodeMap;
+      if (!json.animations) json.animations = [];
+      clip = GLTFExporter.Utils.mergeMorphTargetTracks(clip.clone(), root);
+      const tracks = clip.tracks;
+      const channels = [];
+      const samplers = [];
+      for (let i4 = 0; i4 < tracks.length; ++i4) {
+        const track = tracks[i4];
+        const trackBinding = PropertyBinding.parseTrackName(track.name);
+        let trackNode = PropertyBinding.findNode(root, trackBinding.nodeName);
+        const trackProperty = PATH_PROPERTIES[trackBinding.propertyName];
+        if (trackBinding.objectName === "bones") {
+          if (trackNode.isSkinnedMesh === true) {
+            trackNode = trackNode.skeleton.getBoneByName(trackBinding.objectIndex);
+          } else {
+            trackNode = void 0;
+          }
+        }
+        if (!trackNode || !trackProperty) {
+          console.warn('THREE.GLTFExporter: Could not export animation track "%s".', track.name);
+          return null;
+        }
+        const inputItemSize = 1;
+        let outputItemSize = track.values.length / track.times.length;
+        if (trackProperty === PATH_PROPERTIES.morphTargetInfluences) {
+          outputItemSize /= trackNode.morphTargetInfluences.length;
+        }
+        let interpolation;
+        if (track.createInterpolant.isInterpolantFactoryMethodGLTFCubicSpline === true) {
+          interpolation = "CUBICSPLINE";
+          outputItemSize /= 3;
+        } else if (track.getInterpolation() === InterpolateDiscrete) {
+          interpolation = "STEP";
+        } else {
+          interpolation = "LINEAR";
+        }
+        samplers.push({
+          input: this.processAccessor(new BufferAttribute(track.times, inputItemSize)),
+          output: this.processAccessor(new BufferAttribute(track.values, outputItemSize)),
+          interpolation
+        });
+        channels.push({
+          sampler: samplers.length - 1,
+          target: {
+            node: nodeMap.get(trackNode),
+            path: trackProperty
+          }
+        });
+      }
+      json.animations.push({
+        name: clip.name || "clip_" + json.animations.length,
+        samplers,
+        channels
+      });
+      return json.animations.length - 1;
+    }
+    /**
+     * @param {THREE.Object3D} object
+     * @return {number|null}
+     */
+    processSkin(object) {
+      const json = this.json;
+      const nodeMap = this.nodeMap;
+      const node = json.nodes[nodeMap.get(object)];
+      const skeleton = object.skeleton;
+      if (skeleton === void 0) return null;
+      const rootJoint = object.skeleton.bones[0];
+      if (rootJoint === void 0) return null;
+      const joints = [];
+      const inverseBindMatrices = new Float32Array(skeleton.bones.length * 16);
+      const temporaryBoneInverse = new Matrix4();
+      for (let i4 = 0; i4 < skeleton.bones.length; ++i4) {
+        joints.push(nodeMap.get(skeleton.bones[i4]));
+        temporaryBoneInverse.copy(skeleton.boneInverses[i4]);
+        temporaryBoneInverse.multiply(object.bindMatrix).toArray(inverseBindMatrices, i4 * 16);
+      }
+      if (json.skins === void 0) json.skins = [];
+      json.skins.push({
+        inverseBindMatrices: this.processAccessor(new BufferAttribute(inverseBindMatrices, 16)),
+        joints,
+        skeleton: nodeMap.get(rootJoint)
+      });
+      const skinIndex = node.skin = json.skins.length - 1;
+      return skinIndex;
+    }
+    /**
+     * Process Object3D node
+     * @param  {THREE.Object3D} node Object3D to processNode
+     * @return {Integer} Index of the node in the nodes list
+     */
+    processNode(object) {
+      const json = this.json;
+      const options = this.options;
+      const nodeMap = this.nodeMap;
+      if (!json.nodes) json.nodes = [];
+      const nodeDef = {};
+      if (options.trs) {
+        const rotation = object.quaternion.toArray();
+        const position = object.position.toArray();
+        const scale = object.scale.toArray();
+        if (!equalArray(rotation, [0, 0, 0, 1])) {
+          nodeDef.rotation = rotation;
+        }
+        if (!equalArray(position, [0, 0, 0])) {
+          nodeDef.translation = position;
+        }
+        if (!equalArray(scale, [1, 1, 1])) {
+          nodeDef.scale = scale;
+        }
+      } else {
+        if (object.matrixAutoUpdate) {
+          object.updateMatrix();
+        }
+        if (isIdentityMatrix(object.matrix) === false) {
+          nodeDef.matrix = object.matrix.elements;
+        }
+      }
+      if (object.name !== "") nodeDef.name = String(object.name);
+      this.serializeUserData(object, nodeDef);
+      if (object.isMesh || object.isLine || object.isPoints) {
+        const meshIndex = this.processMesh(object);
+        if (meshIndex !== null) nodeDef.mesh = meshIndex;
+      } else if (object.isCamera) {
+        nodeDef.camera = this.processCamera(object);
+      }
+      if (object.isSkinnedMesh) this.skins.push(object);
+      if (object.children.length > 0) {
+        const children = [];
+        for (let i4 = 0, l4 = object.children.length; i4 < l4; i4++) {
+          const child = object.children[i4];
+          if (child.visible || options.onlyVisible === false) {
+            const nodeIndex2 = this.processNode(child);
+            if (nodeIndex2 !== null) children.push(nodeIndex2);
+          }
+        }
+        if (children.length > 0) nodeDef.children = children;
+      }
+      this._invokeAll(function(ext) {
+        ext.writeNode && ext.writeNode(object, nodeDef);
+      });
+      const nodeIndex = json.nodes.push(nodeDef) - 1;
+      nodeMap.set(object, nodeIndex);
+      return nodeIndex;
+    }
+    /**
+     * Process Scene
+     * @param  {Scene} node Scene to process
+     */
+    processScene(scene) {
+      const json = this.json;
+      const options = this.options;
+      if (!json.scenes) {
+        json.scenes = [];
+        json.scene = 0;
+      }
+      const sceneDef = {};
+      if (scene.name !== "") sceneDef.name = scene.name;
+      json.scenes.push(sceneDef);
+      const nodes = [];
+      for (let i4 = 0, l4 = scene.children.length; i4 < l4; i4++) {
+        const child = scene.children[i4];
+        if (child.visible || options.onlyVisible === false) {
+          const nodeIndex = this.processNode(child);
+          if (nodeIndex !== null) nodes.push(nodeIndex);
+        }
+      }
+      if (nodes.length > 0) sceneDef.nodes = nodes;
+      this.serializeUserData(scene, sceneDef);
+    }
+    /**
+     * Creates a Scene to hold a list of objects and parse it
+     * @param  {Array} objects List of objects to process
+     */
+    processObjects(objects) {
+      const scene = new Scene();
+      scene.name = "AuxScene";
+      for (let i4 = 0; i4 < objects.length; i4++) {
+        scene.children.push(objects[i4]);
+      }
+      this.processScene(scene);
+    }
+    /**
+     * @param {THREE.Object3D|Array<THREE.Object3D>} input
+     */
+    processInput(input) {
+      const options = this.options;
+      input = input instanceof Array ? input : [input];
+      this._invokeAll(function(ext) {
+        ext.beforeParse && ext.beforeParse(input);
+      });
+      const objectsWithoutScene = [];
+      for (let i4 = 0; i4 < input.length; i4++) {
+        if (input[i4] instanceof Scene) {
+          this.processScene(input[i4]);
+        } else {
+          objectsWithoutScene.push(input[i4]);
+        }
+      }
+      if (objectsWithoutScene.length > 0) this.processObjects(objectsWithoutScene);
+      for (let i4 = 0; i4 < this.skins.length; ++i4) {
+        this.processSkin(this.skins[i4]);
+      }
+      for (let i4 = 0; i4 < options.animations.length; ++i4) {
+        this.processAnimation(options.animations[i4], input[0]);
+      }
+      this._invokeAll(function(ext) {
+        ext.afterParse && ext.afterParse(input);
+      });
+    }
+    _invokeAll(func) {
+      for (let i4 = 0, il = this.plugins.length; i4 < il; i4++) {
+        func(this.plugins[i4]);
+      }
+    }
+  };
+  var GLTFLightExtension = class {
+    constructor(writer) {
+      this.writer = writer;
+      this.name = "KHR_lights_punctual";
+    }
+    writeNode(light, nodeDef) {
+      if (!light.isLight) return;
+      if (!light.isDirectionalLight && !light.isPointLight && !light.isSpotLight) {
+        console.warn("THREE.GLTFExporter: Only directional, point, and spot lights are supported.", light);
+        return;
+      }
+      const writer = this.writer;
+      const json = writer.json;
+      const extensionsUsed = writer.extensionsUsed;
+      const lightDef = {};
+      if (light.name) lightDef.name = light.name;
+      lightDef.color = light.color.toArray();
+      lightDef.intensity = light.intensity;
+      if (light.isDirectionalLight) {
+        lightDef.type = "directional";
+      } else if (light.isPointLight) {
+        lightDef.type = "point";
+        if (light.distance > 0) lightDef.range = light.distance;
+      } else if (light.isSpotLight) {
+        lightDef.type = "spot";
+        if (light.distance > 0) lightDef.range = light.distance;
+        lightDef.spot = {};
+        lightDef.spot.innerConeAngle = (1 - light.penumbra) * light.angle;
+        lightDef.spot.outerConeAngle = light.angle;
+      }
+      if (light.decay !== void 0 && light.decay !== 2) {
+        console.warn("THREE.GLTFExporter: Light decay may be lost. glTF is physically-based, and expects light.decay=2.");
+      }
+      if (light.target && (light.target.parent !== light || light.target.position.x !== 0 || light.target.position.y !== 0 || light.target.position.z !== -1)) {
+        console.warn("THREE.GLTFExporter: Light direction may be lost. For best results, make light.target a child of the light with position 0,0,-1.");
+      }
+      if (!extensionsUsed[this.name]) {
+        json.extensions = json.extensions || {};
+        json.extensions[this.name] = { lights: [] };
+        extensionsUsed[this.name] = true;
+      }
+      const lights = json.extensions[this.name].lights;
+      lights.push(lightDef);
+      nodeDef.extensions = nodeDef.extensions || {};
+      nodeDef.extensions[this.name] = { light: lights.length - 1 };
+    }
+  };
+  var GLTFMaterialsUnlitExtension = class {
+    constructor(writer) {
+      this.writer = writer;
+      this.name = "KHR_materials_unlit";
+    }
+    writeMaterial(material, materialDef) {
+      if (!material.isMeshBasicMaterial) return;
+      const writer = this.writer;
+      const extensionsUsed = writer.extensionsUsed;
+      materialDef.extensions = materialDef.extensions || {};
+      materialDef.extensions[this.name] = {};
+      extensionsUsed[this.name] = true;
+      materialDef.pbrMetallicRoughness.metallicFactor = 0;
+      materialDef.pbrMetallicRoughness.roughnessFactor = 0.9;
+    }
+  };
+  var GLTFMaterialsClearcoatExtension = class {
+    constructor(writer) {
+      this.writer = writer;
+      this.name = "KHR_materials_clearcoat";
+    }
+    writeMaterial(material, materialDef) {
+      if (!material.isMeshPhysicalMaterial || material.clearcoat === 0) return;
+      const writer = this.writer;
+      const extensionsUsed = writer.extensionsUsed;
+      const extensionDef = {};
+      extensionDef.clearcoatFactor = material.clearcoat;
+      if (material.clearcoatMap) {
+        const clearcoatMapDef = {
+          index: writer.processTexture(material.clearcoatMap),
+          texCoord: material.clearcoatMap.channel
+        };
+        writer.applyTextureTransform(clearcoatMapDef, material.clearcoatMap);
+        extensionDef.clearcoatTexture = clearcoatMapDef;
+      }
+      extensionDef.clearcoatRoughnessFactor = material.clearcoatRoughness;
+      if (material.clearcoatRoughnessMap) {
+        const clearcoatRoughnessMapDef = {
+          index: writer.processTexture(material.clearcoatRoughnessMap),
+          texCoord: material.clearcoatRoughnessMap.channel
+        };
+        writer.applyTextureTransform(clearcoatRoughnessMapDef, material.clearcoatRoughnessMap);
+        extensionDef.clearcoatRoughnessTexture = clearcoatRoughnessMapDef;
+      }
+      if (material.clearcoatNormalMap) {
+        const clearcoatNormalMapDef = {
+          index: writer.processTexture(material.clearcoatNormalMap),
+          texCoord: material.clearcoatNormalMap.channel
+        };
+        writer.applyTextureTransform(clearcoatNormalMapDef, material.clearcoatNormalMap);
+        extensionDef.clearcoatNormalTexture = clearcoatNormalMapDef;
+      }
+      materialDef.extensions = materialDef.extensions || {};
+      materialDef.extensions[this.name] = extensionDef;
+      extensionsUsed[this.name] = true;
+    }
+  };
+  var GLTFMaterialsIridescenceExtension = class {
+    constructor(writer) {
+      this.writer = writer;
+      this.name = "KHR_materials_iridescence";
+    }
+    writeMaterial(material, materialDef) {
+      if (!material.isMeshPhysicalMaterial || material.iridescence === 0) return;
+      const writer = this.writer;
+      const extensionsUsed = writer.extensionsUsed;
+      const extensionDef = {};
+      extensionDef.iridescenceFactor = material.iridescence;
+      if (material.iridescenceMap) {
+        const iridescenceMapDef = {
+          index: writer.processTexture(material.iridescenceMap),
+          texCoord: material.iridescenceMap.channel
+        };
+        writer.applyTextureTransform(iridescenceMapDef, material.iridescenceMap);
+        extensionDef.iridescenceTexture = iridescenceMapDef;
+      }
+      extensionDef.iridescenceIor = material.iridescenceIOR;
+      extensionDef.iridescenceThicknessMinimum = material.iridescenceThicknessRange[0];
+      extensionDef.iridescenceThicknessMaximum = material.iridescenceThicknessRange[1];
+      if (material.iridescenceThicknessMap) {
+        const iridescenceThicknessMapDef = {
+          index: writer.processTexture(material.iridescenceThicknessMap),
+          texCoord: material.iridescenceThicknessMap.channel
+        };
+        writer.applyTextureTransform(iridescenceThicknessMapDef, material.iridescenceThicknessMap);
+        extensionDef.iridescenceThicknessTexture = iridescenceThicknessMapDef;
+      }
+      materialDef.extensions = materialDef.extensions || {};
+      materialDef.extensions[this.name] = extensionDef;
+      extensionsUsed[this.name] = true;
+    }
+  };
+  var GLTFMaterialsTransmissionExtension = class {
+    constructor(writer) {
+      this.writer = writer;
+      this.name = "KHR_materials_transmission";
+    }
+    writeMaterial(material, materialDef) {
+      if (!material.isMeshPhysicalMaterial || material.transmission === 0) return;
+      const writer = this.writer;
+      const extensionsUsed = writer.extensionsUsed;
+      const extensionDef = {};
+      extensionDef.transmissionFactor = material.transmission;
+      if (material.transmissionMap) {
+        const transmissionMapDef = {
+          index: writer.processTexture(material.transmissionMap),
+          texCoord: material.transmissionMap.channel
+        };
+        writer.applyTextureTransform(transmissionMapDef, material.transmissionMap);
+        extensionDef.transmissionTexture = transmissionMapDef;
+      }
+      materialDef.extensions = materialDef.extensions || {};
+      materialDef.extensions[this.name] = extensionDef;
+      extensionsUsed[this.name] = true;
+    }
+  };
+  var GLTFMaterialsVolumeExtension = class {
+    constructor(writer) {
+      this.writer = writer;
+      this.name = "KHR_materials_volume";
+    }
+    writeMaterial(material, materialDef) {
+      if (!material.isMeshPhysicalMaterial || material.transmission === 0) return;
+      const writer = this.writer;
+      const extensionsUsed = writer.extensionsUsed;
+      const extensionDef = {};
+      extensionDef.thicknessFactor = material.thickness;
+      if (material.thicknessMap) {
+        const thicknessMapDef = {
+          index: writer.processTexture(material.thicknessMap),
+          texCoord: material.thicknessMap.channel
+        };
+        writer.applyTextureTransform(thicknessMapDef, material.thicknessMap);
+        extensionDef.thicknessTexture = thicknessMapDef;
+      }
+      extensionDef.attenuationDistance = material.attenuationDistance;
+      extensionDef.attenuationColor = material.attenuationColor.toArray();
+      materialDef.extensions = materialDef.extensions || {};
+      materialDef.extensions[this.name] = extensionDef;
+      extensionsUsed[this.name] = true;
+    }
+  };
+  var GLTFMaterialsIorExtension = class {
+    constructor(writer) {
+      this.writer = writer;
+      this.name = "KHR_materials_ior";
+    }
+    writeMaterial(material, materialDef) {
+      if (!material.isMeshPhysicalMaterial || material.ior === 1.5) return;
+      const writer = this.writer;
+      const extensionsUsed = writer.extensionsUsed;
+      const extensionDef = {};
+      extensionDef.ior = material.ior;
+      materialDef.extensions = materialDef.extensions || {};
+      materialDef.extensions[this.name] = extensionDef;
+      extensionsUsed[this.name] = true;
+    }
+  };
+  var GLTFMaterialsSpecularExtension = class {
+    constructor(writer) {
+      this.writer = writer;
+      this.name = "KHR_materials_specular";
+    }
+    writeMaterial(material, materialDef) {
+      if (!material.isMeshPhysicalMaterial || material.specularIntensity === 1 && material.specularColor.equals(DEFAULT_SPECULAR_COLOR) && !material.specularIntensityMap && !material.specularColorTexture) return;
+      const writer = this.writer;
+      const extensionsUsed = writer.extensionsUsed;
+      const extensionDef = {};
+      if (material.specularIntensityMap) {
+        const specularIntensityMapDef = {
+          index: writer.processTexture(material.specularIntensityMap),
+          texCoord: material.specularIntensityMap.channel
+        };
+        writer.applyTextureTransform(specularIntensityMapDef, material.specularIntensityMap);
+        extensionDef.specularTexture = specularIntensityMapDef;
+      }
+      if (material.specularColorMap) {
+        const specularColorMapDef = {
+          index: writer.processTexture(material.specularColorMap),
+          texCoord: material.specularColorMap.channel
+        };
+        writer.applyTextureTransform(specularColorMapDef, material.specularColorMap);
+        extensionDef.specularColorTexture = specularColorMapDef;
+      }
+      extensionDef.specularFactor = material.specularIntensity;
+      extensionDef.specularColorFactor = material.specularColor.toArray();
+      materialDef.extensions = materialDef.extensions || {};
+      materialDef.extensions[this.name] = extensionDef;
+      extensionsUsed[this.name] = true;
+    }
+  };
+  var GLTFMaterialsSheenExtension = class {
+    constructor(writer) {
+      this.writer = writer;
+      this.name = "KHR_materials_sheen";
+    }
+    writeMaterial(material, materialDef) {
+      if (!material.isMeshPhysicalMaterial || material.sheen == 0) return;
+      const writer = this.writer;
+      const extensionsUsed = writer.extensionsUsed;
+      const extensionDef = {};
+      if (material.sheenRoughnessMap) {
+        const sheenRoughnessMapDef = {
+          index: writer.processTexture(material.sheenRoughnessMap),
+          texCoord: material.sheenRoughnessMap.channel
+        };
+        writer.applyTextureTransform(sheenRoughnessMapDef, material.sheenRoughnessMap);
+        extensionDef.sheenRoughnessTexture = sheenRoughnessMapDef;
+      }
+      if (material.sheenColorMap) {
+        const sheenColorMapDef = {
+          index: writer.processTexture(material.sheenColorMap),
+          texCoord: material.sheenColorMap.channel
+        };
+        writer.applyTextureTransform(sheenColorMapDef, material.sheenColorMap);
+        extensionDef.sheenColorTexture = sheenColorMapDef;
+      }
+      extensionDef.sheenRoughnessFactor = material.sheenRoughness;
+      extensionDef.sheenColorFactor = material.sheenColor.toArray();
+      materialDef.extensions = materialDef.extensions || {};
+      materialDef.extensions[this.name] = extensionDef;
+      extensionsUsed[this.name] = true;
+    }
+  };
+  var GLTFMaterialsAnisotropyExtension = class {
+    constructor(writer) {
+      this.writer = writer;
+      this.name = "KHR_materials_anisotropy";
+    }
+    writeMaterial(material, materialDef) {
+      if (!material.isMeshPhysicalMaterial || material.anisotropy == 0) return;
+      const writer = this.writer;
+      const extensionsUsed = writer.extensionsUsed;
+      const extensionDef = {};
+      if (material.anisotropyMap) {
+        const anisotropyMapDef = { index: writer.processTexture(material.anisotropyMap) };
+        writer.applyTextureTransform(anisotropyMapDef, material.anisotropyMap);
+        extensionDef.anisotropyTexture = anisotropyMapDef;
+      }
+      extensionDef.anisotropyStrength = material.anisotropy;
+      extensionDef.anisotropyRotation = material.anisotropyRotation;
+      materialDef.extensions = materialDef.extensions || {};
+      materialDef.extensions[this.name] = extensionDef;
+      extensionsUsed[this.name] = true;
+    }
+  };
+  var GLTFMaterialsEmissiveStrengthExtension = class {
+    constructor(writer) {
+      this.writer = writer;
+      this.name = "KHR_materials_emissive_strength";
+    }
+    writeMaterial(material, materialDef) {
+      if (!material.isMeshStandardMaterial || material.emissiveIntensity === 1) return;
+      const writer = this.writer;
+      const extensionsUsed = writer.extensionsUsed;
+      const extensionDef = {};
+      extensionDef.emissiveStrength = material.emissiveIntensity;
+      materialDef.extensions = materialDef.extensions || {};
+      materialDef.extensions[this.name] = extensionDef;
+      extensionsUsed[this.name] = true;
+    }
+  };
+  var GLTFMeshGpuInstancing = class {
+    constructor(writer) {
+      this.writer = writer;
+      this.name = "EXT_mesh_gpu_instancing";
+    }
+    writeNode(object, nodeDef) {
+      if (!object.isInstancedMesh) return;
+      const writer = this.writer;
+      const mesh = object;
+      const translationAttr = new Float32Array(mesh.count * 3);
+      const rotationAttr = new Float32Array(mesh.count * 4);
+      const scaleAttr = new Float32Array(mesh.count * 3);
+      const matrix = new Matrix4();
+      const position = new Vector3();
+      const quaternion = new Quaternion();
+      const scale = new Vector3();
+      for (let i4 = 0; i4 < mesh.count; i4++) {
+        mesh.getMatrixAt(i4, matrix);
+        matrix.decompose(position, quaternion, scale);
+        position.toArray(translationAttr, i4 * 3);
+        quaternion.toArray(rotationAttr, i4 * 4);
+        scale.toArray(scaleAttr, i4 * 3);
+      }
+      const attributes = {
+        TRANSLATION: writer.processAccessor(new BufferAttribute(translationAttr, 3)),
+        ROTATION: writer.processAccessor(new BufferAttribute(rotationAttr, 4)),
+        SCALE: writer.processAccessor(new BufferAttribute(scaleAttr, 3))
+      };
+      if (mesh.instanceColor)
+        attributes._COLOR_0 = writer.processAccessor(mesh.instanceColor);
+      nodeDef.extensions = nodeDef.extensions || {};
+      nodeDef.extensions[this.name] = { attributes };
+      writer.extensionsUsed[this.name] = true;
+      writer.extensionsRequired[this.name] = true;
+    }
+  };
+  GLTFExporter.Utils = {
+    insertKeyframe: function(track, time) {
+      const tolerance = 1e-3;
+      const valueSize = track.getValueSize();
+      const times = new track.TimeBufferType(track.times.length + 1);
+      const values = new track.ValueBufferType(track.values.length + valueSize);
+      const interpolant = track.createInterpolant(new track.ValueBufferType(valueSize));
+      let index;
+      if (track.times.length === 0) {
+        times[0] = time;
+        for (let i4 = 0; i4 < valueSize; i4++) {
+          values[i4] = 0;
+        }
+        index = 0;
+      } else if (time < track.times[0]) {
+        if (Math.abs(track.times[0] - time) < tolerance) return 0;
+        times[0] = time;
+        times.set(track.times, 1);
+        values.set(interpolant.evaluate(time), 0);
+        values.set(track.values, valueSize);
+        index = 0;
+      } else if (time > track.times[track.times.length - 1]) {
+        if (Math.abs(track.times[track.times.length - 1] - time) < tolerance) {
+          return track.times.length - 1;
+        }
+        times[times.length - 1] = time;
+        times.set(track.times, 0);
+        values.set(track.values, 0);
+        values.set(interpolant.evaluate(time), track.values.length);
+        index = times.length - 1;
+      } else {
+        for (let i4 = 0; i4 < track.times.length; i4++) {
+          if (Math.abs(track.times[i4] - time) < tolerance) return i4;
+          if (track.times[i4] < time && track.times[i4 + 1] > time) {
+            times.set(track.times.slice(0, i4 + 1), 0);
+            times[i4 + 1] = time;
+            times.set(track.times.slice(i4 + 1), i4 + 2);
+            values.set(track.values.slice(0, (i4 + 1) * valueSize), 0);
+            values.set(interpolant.evaluate(time), (i4 + 1) * valueSize);
+            values.set(track.values.slice((i4 + 1) * valueSize), (i4 + 2) * valueSize);
+            index = i4 + 1;
+            break;
+          }
+        }
+      }
+      track.times = times;
+      track.values = values;
+      return index;
+    },
+    mergeMorphTargetTracks: function(clip, root) {
+      const tracks = [];
+      const mergedTracks = {};
+      const sourceTracks = clip.tracks;
+      for (let i4 = 0; i4 < sourceTracks.length; ++i4) {
+        let sourceTrack = sourceTracks[i4];
+        const sourceTrackBinding = PropertyBinding.parseTrackName(sourceTrack.name);
+        const sourceTrackNode = PropertyBinding.findNode(root, sourceTrackBinding.nodeName);
+        if (sourceTrackBinding.propertyName !== "morphTargetInfluences" || sourceTrackBinding.propertyIndex === void 0) {
+          tracks.push(sourceTrack);
+          continue;
+        }
+        if (sourceTrack.createInterpolant !== sourceTrack.InterpolantFactoryMethodDiscrete && sourceTrack.createInterpolant !== sourceTrack.InterpolantFactoryMethodLinear) {
+          if (sourceTrack.createInterpolant.isInterpolantFactoryMethodGLTFCubicSpline) {
+            throw new Error("THREE.GLTFExporter: Cannot merge tracks with glTF CUBICSPLINE interpolation.");
+          }
+          console.warn("THREE.GLTFExporter: Morph target interpolation mode not yet supported. Using LINEAR instead.");
+          sourceTrack = sourceTrack.clone();
+          sourceTrack.setInterpolation(InterpolateLinear);
+        }
+        const targetCount = sourceTrackNode.morphTargetInfluences.length;
+        const targetIndex = sourceTrackNode.morphTargetDictionary[sourceTrackBinding.propertyIndex];
+        if (targetIndex === void 0) {
+          throw new Error("THREE.GLTFExporter: Morph target name not found: " + sourceTrackBinding.propertyIndex);
+        }
+        let mergedTrack;
+        if (mergedTracks[sourceTrackNode.uuid] === void 0) {
+          mergedTrack = sourceTrack.clone();
+          const values = new mergedTrack.ValueBufferType(targetCount * mergedTrack.times.length);
+          for (let j4 = 0; j4 < mergedTrack.times.length; j4++) {
+            values[j4 * targetCount + targetIndex] = mergedTrack.values[j4];
+          }
+          mergedTrack.name = (sourceTrackBinding.nodeName || "") + ".morphTargetInfluences";
+          mergedTrack.values = values;
+          mergedTracks[sourceTrackNode.uuid] = mergedTrack;
+          tracks.push(mergedTrack);
+          continue;
+        }
+        const sourceInterpolant = sourceTrack.createInterpolant(new sourceTrack.ValueBufferType(1));
+        mergedTrack = mergedTracks[sourceTrackNode.uuid];
+        for (let j4 = 0; j4 < mergedTrack.times.length; j4++) {
+          mergedTrack.values[j4 * targetCount + targetIndex] = sourceInterpolant.evaluate(mergedTrack.times[j4]);
+        }
+        for (let j4 = 0; j4 < sourceTrack.times.length; j4++) {
+          const keyframeIndex = this.insertKeyframe(mergedTrack, sourceTrack.times[j4]);
+          mergedTrack.values[keyframeIndex * targetCount + targetIndex] = sourceTrack.values[j4];
+        }
+      }
+      clip.tracks = tracks;
+      return clip;
+    }
+  };
+
+  // src/export/SceneExporter.ts
+  init_MineRenderError();
+  init_DisplayTransforms();
+  init_CanvasCompat();
+  var SceneExporter = class {
+    /** Returns OBJ geometry with normals and UVs; material files and textures are not included. */
+    static toObj(root) {
+      const snapshot = createSnapshot(root, false);
+      try {
+        return new OBJExporter().parse(snapshot.scene);
+      } finally {
+        snapshot.dispose();
+      }
+    }
+    /** Returns PLY geometry with vertex colors and UVs; texture images are not included. */
+    static toPLY(root, options) {
+      const snapshot = createSnapshot(root, false, true);
+      try {
+        const result = new PLYExporter().parse(snapshot.scene, void 0, options);
+        if (result === null) throw new MineRenderError("The scene could not be exported as PLY");
+        return result;
+      } finally {
+        snapshot.dispose();
+      }
+    }
+    /**
+     * Exports a static glTF/GLB snapshot in a browser. Atlas textures and vertex tints are retained;
+     * MineRender's custom directional lighting is not baked into the exported materials.
+     */
+    static async toGLTF(root, options = {}) {
+      if (typeof document === "undefined" || typeof FileReader === "undefined") {
+        throw new MineRenderError("glTF export requires a browser with canvas and FileReader support");
+      }
+      if (options.maxTextureSize !== void 0 && !(options.maxTextureSize >= 1)) {
+        throw new MineRenderError("maxTextureSize must be at least 1 pixel");
+      }
+      const snapshot = createSnapshot(root, true);
+      try {
+        return await new GLTFExporter().parseAsync(snapshot.scene, {
+          binary: options.binary ?? false,
+          maxTextureSize: options.maxTextureSize ?? Infinity
+        });
+      } finally {
+        snapshot.dispose();
+      }
+    }
+  };
+  function localMatrix(object) {
+    return object.matrixAutoUpdate ? new Matrix4().compose(object.position, object.quaternion, object.scale) : object.matrix.clone();
+  }
+  function createSnapshot(root, gltf, bakeColors = false) {
+    const scene = new Scene();
+    const geometries = [];
+    const materials = [];
+    const textures = [];
+    const textureCopies = /* @__PURE__ */ new Map();
+    const dispose = () => {
+      for (const geometry of geometries) geometry.dispose();
+      for (const material of materials) material.dispose();
+      for (const texture of textures) texture.dispose();
+    };
+    const copyMaterial = (source, geometry) => {
+      let material;
+      const shader = source;
+      if (shader.isShaderMaterial && gltf) {
+        const uniforms = shader.uniforms;
+        if (!uniforms.map?.value?.isTexture || !uniforms.SHADE || !uniforms.BRIGHTNESS || !uniforms.EMISSIVE) {
+          throw new MineRenderError("glTF export does not support this custom ShaderMaterial");
+        }
+        material = new MeshBasicMaterial({
+          map: uniforms.map.value,
+          vertexColors: source.vertexColors,
+          transparent: source.transparent,
+          side: source.side,
+          alphaTest: 0.01,
+          depthWrite: source.depthWrite
+        });
+        material.name = source.name;
+      } else if (shader.isShaderMaterial) {
+        material = new MeshBasicMaterial({ vertexColors: source.vertexColors });
+        material.name = source.name;
+      } else {
+        const copySource = Object.create(source);
+        copySource.userData = {};
+        material = source.clone.call(copySource);
+      }
+      materials.push(material);
+      if (gltf) {
+        selectAlphaMode(material, geometry);
+        for (const [key, value] of Object.entries(material)) {
+          if (value?.isDataTexture) {
+            let texture = textureCopies.get(value);
+            if (!texture) {
+              texture = copyDataTexture(value);
+              textureCopies.set(value, texture);
+              textures.push(texture);
+            }
+            material[key] = texture;
+          }
+        }
+      }
+      return material;
+    };
+    const addMesh = (mesh, world, instanceColor) => {
+      if (world.determinant() === 0 || !mesh.geometry.getAttribute("position")) return;
+      const source = mesh.geometry;
+      const count = source.index?.count ?? source.getAttribute("position").count;
+      const groups = Array.isArray(mesh.material) ? source.groups : [{ start: 0, count, materialIndex: 0 }];
+      for (const group of groups) {
+        const sourceMaterial = Array.isArray(mesh.material) ? mesh.material[group.materialIndex ?? 0] : mesh.material;
+        if (!sourceMaterial?.visible) continue;
+        const start = Math.max(group.start, source.drawRange.start);
+        const end = Math.min(count, group.start + group.count, source.drawRange.start + source.drawRange.count);
+        const indices = [];
+        for (let i4 = start; i4 + 2 < end; i4 += 3) {
+          for (let corner = 0; corner < 3; corner++) indices.push(source.index?.getX(i4 + corner) ?? i4 + corner);
+        }
+        if (!indices.length) continue;
+        let geometry = source.clone();
+        geometry.setIndex(indices);
+        if (new Set(indices).size < geometry.getAttribute("position").count) {
+          const compact = geometry.toNonIndexed();
+          geometry.dispose();
+          geometry = compact;
+        }
+        geometries.push(geometry);
+        geometry.userData = {};
+        geometry.clearGroups();
+        geometry.setDrawRange(0, Infinity);
+        DisplayTransforms.apply(geometry, world);
+        const material = copyMaterial(sourceMaterial, geometry);
+        if (!sourceMaterial.vertexColors) geometry.deleteAttribute("color");
+        if (bakeColors || instanceColor) {
+          const tint = (material.color ?? new Color()).clone();
+          if (instanceColor) tint.multiply(instanceColor);
+          if (bakeColors) {
+            const original = geometry.getAttribute("color");
+            const colors = new Float32BufferAttribute(new Float32Array(geometry.getAttribute("position").count * 3), 3);
+            for (let i4 = 0; i4 < colors.count; i4++) {
+              colors.setXYZ(i4, (original?.getX(i4) ?? 1) * tint.r, (original?.getY(i4) ?? 1) * tint.g, (original?.getZ(i4) ?? 1) * tint.b);
+            }
+            geometry.setAttribute("color", colors);
+          } else if (material.color) {
+            material.color.copy(tint);
+          }
+        }
+        const copy = new Mesh(geometry, material);
+        copy.name = mesh.name;
+        copy.renderOrder = mesh.renderOrder;
+        scene.add(copy);
+      }
+    };
+    const visit = (object, parentWorld) => {
+      if (!object.visible) return;
+      const world = parentWorld.clone().multiply(localMatrix(object));
+      const mesh = object;
+      if (mesh.isMesh) {
+        const instanced = mesh;
+        if (instanced.isInstancedMesh) {
+          for (let i4 = 0; i4 < instanced.count; i4++) {
+            const matrix = new Matrix4();
+            instanced.getMatrixAt(i4, matrix);
+            const color2 = instanced.instanceColor ? new Color().fromBufferAttribute(instanced.instanceColor, i4) : void 0;
+            addMesh(mesh, world.clone().multiply(matrix), color2);
+          }
+        } else {
+          addMesh(mesh, world);
+        }
+      }
+      for (const child of object.children) visit(child, world);
+    };
+    try {
+      const ancestors = [];
+      for (let parent = root.parent; parent; parent = parent.parent) ancestors.unshift(parent);
+      const world = new Matrix4();
+      for (const ancestor of ancestors) {
+        if (!ancestor.visible) return { scene, dispose };
+        world.multiply(localMatrix(ancestor));
+      }
+      visit(root, world);
+      return { scene, dispose };
+    } catch (error) {
+      dispose();
+      throw error;
+    }
+  }
+  function selectAlphaMode(material, geometry) {
+    const texture = material.map;
+    if (material.type !== "MeshBasicMaterial" || !material.transparent || !material.depthWrite || material.opacity !== 1 || material.alphaMap || !texture?.isDataTexture || texture.format !== RGBAFormat || texture.type !== UnsignedByteType || texture.wrapS !== ClampToEdgeWrapping || texture.wrapT !== ClampToEdgeWrapping || texture.magFilter !== NearestFilter || texture.minFilter !== NearestFilter || texture.anisotropy > 1 || texture.offset.x !== 0 || texture.offset.y !== 0 || texture.repeat.x !== 1 || texture.repeat.y !== 1 || texture.rotation !== 0 || !texture.matrixAutoUpdate && !texture.matrix.elements.every((value, i4) => value === (i4 % 4 === 0 ? 1 : 0))) return;
+    const uv = geometry.getAttribute(texture.channel === 0 ? "uv" : `uv${texture.channel}`);
+    const colors = geometry.getAttribute("color");
+    if (!uv || material.vertexColors && colors?.itemSize === 4) return;
+    const { data, width, height } = texture.image;
+    if (!data || width < 1 || height < 1 || data.length < width * height * 4) return;
+    const count = geometry.index?.count ?? uv.count;
+    let holes = false;
+    for (let i4 = 0; i4 + 2 < count; i4 += 3) {
+      let minU = Infinity, maxU = -Infinity, minV = Infinity, maxV = -Infinity;
+      for (let corner = 0; corner < 3; corner++) {
+        const index = geometry.index?.getX(i4 + corner) ?? i4 + corner;
+        const u4 = uv.getX(index), v5 = texture.flipY ? 1 - uv.getY(index) : uv.getY(index);
+        if (!Number.isFinite(u4) || !Number.isFinite(v5)) return;
+        minU = Math.min(minU, u4);
+        maxU = Math.max(maxU, u4);
+        minV = Math.min(minV, v5);
+        maxV = Math.max(maxV, v5);
+      }
+      const minX = Math.max(0, Math.min(width - 1, Math.floor(minU * width)));
+      const maxX = Math.max(minX, Math.min(width - 1, Math.ceil(maxU * width) - 1));
+      const minY = Math.max(0, Math.min(height - 1, Math.floor(minV * height)));
+      const maxY = Math.max(minY, Math.min(height - 1, Math.ceil(maxV * height) - 1));
+      for (let y5 = minY; y5 <= maxY; y5++) {
+        for (let x4 = minX; x4 <= maxX; x4++) {
+          const alpha = data[(y5 * width + x4) * 4 + 3];
+          if (alpha === 255) continue;
+          if (alpha !== 0 && alpha / 255 >= material.alphaTest) return;
+          holes = true;
+        }
+      }
+    }
+    material.transparent = false;
+    if (holes && material.alphaTest === 0) material.alphaTest = 1 / 255;
+  }
+  function copyDataTexture(source) {
+    const image = source.image;
+    if (source.format !== RGBAFormat || source.type !== UnsignedByteType) {
+      throw new MineRenderError("glTF export requires RGBA unsigned-byte data textures");
+    }
+    const canvas = createCanvas(image.width, image.height);
+    const context = canvas.getContext("2d");
+    if (!context) throw new MineRenderError("glTF export could not create a 2D canvas context");
+    const pixels = context.createImageData(image.width, image.height);
+    pixels.data.set(image.data);
+    context.putImageData(pixels, 0, 0);
+    const copySource = Object.create(source);
+    copySource.userData = {};
+    copySource.source = new Source(canvas);
+    return new Texture().copy(copySource);
+  }
+
   // src/gui/index.ts
   init_dirname();
   init_buffer2();
@@ -90556,6 +93126,9 @@ uniform float opacity;varying vec2 vUv;void main(){vec4 texel=texture2D(inputBuf
         if (next !== void 0 && t5 + 0.1 < next) return;
         this._nextFrameTime = next !== void 0 && t5 - next < interval ? next + interval : t5 + interval;
       }
+      this.drawFrame();
+    }
+    drawFrame() {
       if (this._stats) {
         this._stats.begin();
       }
@@ -90570,8 +93143,28 @@ uniform float opacity;varying vec2 vUv;void main(){vec4 texel=texture2D(inputBuf
       }
     }
     //</editor-fold>
-    toImage() {
-      return this.renderer.domElement.toDataURL();
+    /**
+     * Renders a fresh frame and returns an image data URL, including while the animation loop is stopped.
+     * Trimming removes transparent borders; an empty image becomes one transparent pixel.
+     * MIME type support and lossy quality (0–1) follow the canvas encoder.
+     */
+    toImage(trim = false, mime = "image/png", quality) {
+      if (this._disposed) throw new Error("Cannot export an image from a disposed renderer");
+      if (this._controls?.enabled) {
+        this._controls.update();
+      }
+      this.drawFrame();
+      const canvas = trim ? trimCanvas(this.renderer.domElement) : this.renderer.domElement;
+      return canvas.toDataURL(mime, quality);
+    }
+    toObj() {
+      return SceneExporter.toObj(this.scene);
+    }
+    toPLY(options) {
+      return SceneExporter.toPLY(this.scene, options);
+    }
+    toGLTF(options) {
+      return SceneExporter.toGLTF(this.scene, options);
     }
     ///
     get attachedToBody() {