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

package/dist/browser/index.js

@@ -3406,16 +3406,16 @@ var init_SceneObject = __esm({
 });
 
 // src/model/ModelCulling.ts
-var import_three17, ModelCulling;
+var import_three22, ModelCulling;
 var init_ModelCulling = __esm({
   "src/model/ModelCulling.ts"() {
-    import_three17 = require("three");
+    import_three22 = require("three");
     init_CubeFace();
     ModelCulling = class {
       static toLocalMask(worldMask, rotation) {
         let localMask = 0;
         for (const [localFace, offset] of CUBE_FACE_OFFSETS.entries()) {
-          const normal = new import_three17.Vector3(...offset).applyEuler(rotation);
+          const normal = new import_three22.Vector3(...offset).applyEuler(rotation);
           const worldFace = CUBE_FACE_OFFSETS.findIndex(([x, y, z]) => Math.abs(normal.x - x) < 1e-6 && Math.abs(normal.y - y) < 1e-6 && Math.abs(normal.z - z) < 1e-6);
           if (worldFace < 0) return 0;
           if (worldMask & 1 << worldFace) localMask |= 1 << localFace;
@@ -3459,7 +3459,7 @@ function mergeBufferGeometries(geometries, useGroups = false) {
   const attributes = {};
   const morphAttributes = {};
   const morphTargetsRelative = geometries[0].morphTargetsRelative;
-  const mergedGeometry = new import_three19.BufferGeometry();
+  const mergedGeometry = new import_three24.BufferGeometry();
   let offset = 0;
   for (let i = 0; i < geometries.length; ++i) {
     const geometry = geometries[i];
@@ -3583,7 +3583,7 @@ function mergeBufferAttributes(attributes) {
     array.set(attributes[i].array, offset);
     offset += attributes[i].array.length;
   }
-  return new import_three19.BufferAttribute(array, itemSize, normalized);
+  return new import_three24.BufferAttribute(array, itemSize, normalized);
 }
 function interleaveAttributes(attributes) {
   let TypedArray;
@@ -3599,7 +3599,7 @@ function interleaveAttributes(attributes) {
     arrayLength += attribute.array.length;
     stride += attribute.itemSize;
   }
-  const interleavedBuffer = new import_three19.InterleavedBuffer(new TypedArray(arrayLength), stride);
+  const interleavedBuffer = new import_three24.InterleavedBuffer(new TypedArray(arrayLength), stride);
   let offset = 0;
   const res = [];
   const getters = ["getX", "getY", "getZ", "getW"];
@@ -3608,7 +3608,7 @@ function interleaveAttributes(attributes) {
     const attribute = attributes[j];
     const itemSize = attribute.itemSize;
     const count = attribute.count;
-    const iba = new import_three19.InterleavedBufferAttribute(interleavedBuffer, itemSize, offset, attribute.normalized);
+    const iba = new import_three24.InterleavedBufferAttribute(interleavedBuffer, itemSize, offset, attribute.normalized);
     res.push(iba);
     offset += itemSize;
     for (let c = 0; c < count; c++) {
@@ -3692,13 +3692,13 @@ function mergeVertices(geometry, tolerance = 1e-4) {
     const name = attributeNames[i];
     const oldAttribute = geometry.getAttribute(name);
     const buffer = new oldAttribute.array.constructor(attrArrays[name]);
-    const attribute = new import_three19.BufferAttribute(buffer, oldAttribute.itemSize, oldAttribute.normalized);
+    const attribute = new import_three24.BufferAttribute(buffer, oldAttribute.itemSize, oldAttribute.normalized);
     result.setAttribute(name, attribute);
     if (name in morphAttrsArrays) {
       for (let j = 0; j < morphAttrsArrays[name].length; j++) {
         const oldMorphAttribute = geometry.morphAttributes[name][j];
         const buffer2 = new oldMorphAttribute.array.constructor(morphAttrsArrays[name][j]);
-        const morphAttribute = new import_three19.BufferAttribute(buffer2, oldMorphAttribute.itemSize, oldMorphAttribute.normalized);
+        const morphAttribute = new import_three24.BufferAttribute(buffer2, oldMorphAttribute.itemSize, oldMorphAttribute.normalized);
         result.morphAttributes[name][j] = morphAttribute;
       }
     }
@@ -3707,11 +3707,11 @@ function mergeVertices(geometry, tolerance = 1e-4) {
   return result;
 }
 function toTrianglesDrawMode(geometry, drawMode) {
-  if (drawMode === import_three19.TrianglesDrawMode) {
+  if (drawMode === import_three24.TrianglesDrawMode) {
     console.warn("THREE.BufferGeometryUtils.toTrianglesDrawMode(): Geometry already defined as triangles.");
     return geometry;
   }
-  if (drawMode === import_three19.TriangleFanDrawMode || drawMode === import_three19.TriangleStripDrawMode) {
+  if (drawMode === import_three24.TriangleFanDrawMode || drawMode === import_three24.TriangleStripDrawMode) {
     let index = geometry.getIndex();
     if (index === null) {
       const indices = [];
@@ -3729,7 +3729,7 @@ function toTrianglesDrawMode(geometry, drawMode) {
     }
     const numberOfTriangles = index.count - 2;
     const newIndices = [];
-    if (drawMode === import_three19.TriangleFanDrawMode) {
+    if (drawMode === import_three24.TriangleFanDrawMode) {
       for (let i = 1; i <= numberOfTriangles; i++) {
         newIndices.push(index.getX(0));
         newIndices.push(index.getX(i));
@@ -3765,15 +3765,15 @@ function computeMorphedAttributes(object) {
     console.error("THREE.BufferGeometryUtils: Geometry is not of type BufferGeometry.");
     return null;
   }
-  const _vA = new import_three19.Vector3();
-  const _vB = new import_three19.Vector3();
-  const _vC = new import_three19.Vector3();
-  const _tempA = new import_three19.Vector3();
-  const _tempB = new import_three19.Vector3();
-  const _tempC = new import_three19.Vector3();
-  const _morphA = new import_three19.Vector3();
-  const _morphB = new import_three19.Vector3();
-  const _morphC = new import_three19.Vector3();
+  const _vA = new import_three24.Vector3();
+  const _vB = new import_three24.Vector3();
+  const _vC = new import_three24.Vector3();
+  const _tempA = new import_three24.Vector3();
+  const _tempB = new import_three24.Vector3();
+  const _tempC = new import_three24.Vector3();
+  const _morphA = new import_three24.Vector3();
+  const _morphB = new import_three24.Vector3();
+  const _morphC = new import_three24.Vector3();
   function _calculateMorphedAttributeData(object2, material2, attribute, morphAttribute, morphTargetsRelative2, a2, b2, c2, modifiedAttributeArray) {
     _vA.fromBufferAttribute(attribute, a2);
     _vB.fromBufferAttribute(attribute, b2);
@@ -3968,8 +3968,8 @@ function computeMorphedAttributes(object) {
       }
     }
   }
-  const morphedPositionAttribute = new import_three19.Float32BufferAttribute(modifiedPosition, 3);
-  const morphedNormalAttribute = new import_three19.Float32BufferAttribute(modifiedNormal, 3);
+  const morphedPositionAttribute = new import_three24.Float32BufferAttribute(modifiedPosition, 3);
+  const morphedNormalAttribute = new import_three24.Float32BufferAttribute(modifiedNormal, 3);
   return {
     positionAttribute,
     normalAttribute,
@@ -3977,10 +3977,10 @@ function computeMorphedAttributes(object) {
     morphedNormalAttribute
   };
 }
-var import_three19;
+var import_three24;
 var init_BufferGeometryUtils = __esm({
   "src/three/BufferGeometryUtils.js"() {
-    import_three19 = require("three");
+    import_three24 = require("three");
   }
 });
 
@@ -3988,13 +3988,13 @@ var init_BufferGeometryUtils = __esm({
 function isModelObject(obj) {
   return obj.isModelObject;
 }
-var import_three20, import_ts_deepmerge5, p9, _ModelObject, ModelObject;
+var import_three25, import_ts_deepmerge5, p9, _ModelObject, ModelObject;
 var init_ModelObject = __esm({
   "src/model/scene/ModelObject.ts"() {
     init_SceneObject();
     init_Materials();
     init_UVMapper();
-    import_three20 = require("three");
+    import_three25 = require("three");
     init_BufferGeometryUtils();
     init_model();
     import_ts_deepmerge5 = __toESM(require_dist());
@@ -4049,7 +4049,7 @@ var init_ModelObject = __esm({
                 elGeo.clearGroups();
               }
               if (this.options.uvLockRotation) {
-                UVMapper.lockUvs(elGeo, el.faces, this.atlas, new import_three20.Euler(...this.options.uvLockRotation));
+                UVMapper.lockUvs(elGeo, el.faces, this.atlas, new import_three25.Euler(...this.options.uvLockRotation));
               }
               if (this.options.tints) {
                 const colors = new Float32Array(elGeo.getAttribute("position").count * 3).fill(1);
@@ -4058,19 +4058,19 @@ var init_ModelObject = __esm({
                   if (tintIndex === void 0 || tintIndex < 0) continue;
                   const tint = this.options.tints[tintIndex];
                   if (tint === void 0) continue;
-                  const color = new import_three20.Color(tint);
+                  const color = new import_three25.Color(tint);
                   for (let vertex = 0; vertex < 4; vertex++) {
                     color.toArray(colors, (faceIndex * 4 + vertex) * 3);
                   }
                 }
-                elGeo.setAttribute("color", new import_three20.BufferAttribute(colors, 3));
+                elGeo.setAttribute("color", new import_three25.BufferAttribute(colors, 3));
               }
-              elGeo.applyMatrix4(new import_three20.Matrix4().makeTranslation((el.to[0] - el.from[0]) / 2, (el.to[1] - el.from[1]) / 2, (el.to[2] - el.from[2]) / 2));
-              elGeo.applyMatrix4(new import_three20.Matrix4().makeTranslation(el.from[0], el.from[1], el.from[2]));
+              elGeo.applyMatrix4(new import_three25.Matrix4().makeTranslation((el.to[0] - el.from[0]) / 2, (el.to[1] - el.from[1]) / 2, (el.to[2] - el.from[2]) / 2));
+              elGeo.applyMatrix4(new import_three25.Matrix4().makeTranslation(el.from[0], el.from[1], el.from[2]));
               if (el.rotation) {
                 applyElementRotation(el.rotation, elGeo);
               }
-              elGeo.applyMatrix4(new import_three20.Matrix4().makeTranslation(-8, -8, -8));
+              elGeo.applyMatrix4(new import_three25.Matrix4().makeTranslation(-8, -8, -8));
               if (displayTransform) DisplayTransforms.apply(elGeo, displayTransform);
               if (this.options.mergeMeshes) {
                 allGeos.push(elGeo);
@@ -4092,7 +4092,7 @@ var init_ModelObject = __esm({
           if (allGeos.length > 0) {
             combinedGeo = mergeBufferGeometries(allGeos);
           } else {
-            combinedGeo = new import_three20.BoxGeometry(16, 16, 16);
+            combinedGeo = new import_three25.BoxGeometry(16, 16, 16);
             if (displayTransform) DisplayTransforms.apply(combinedGeo, displayTransform);
           }
           combinedGeo.computeBoundingBox();
@@ -4202,7 +4202,7 @@ function ownHeight(sample) {
   return (level === 0 || level >= 8 ? 8 : 8 - level) / 9;
 }
 function createFluidGeometry(kind, sample) {
-  const geometry = new import_three21.BufferGeometry();
+  const geometry = new import_three26.BufferGeometry();
   const positions = [], normals = [], uvs = [], indices = [];
   const self = sample(0, 0, 0);
   const height = (x, z) => {
@@ -4301,16 +4301,16 @@ function createFluidGeometry(kind, sample) {
       1
     );
   }
-  geometry.setAttribute("position", new import_three21.Float32BufferAttribute(positions, 3));
-  geometry.setAttribute("normal", new import_three21.Float32BufferAttribute(normals, 3));
-  geometry.setAttribute("uv", new import_three21.Float32BufferAttribute(uvs, 2));
+  geometry.setAttribute("position", new import_three26.Float32BufferAttribute(positions, 3));
+  geometry.setAttribute("normal", new import_three26.Float32BufferAttribute(normals, 3));
+  geometry.setAttribute("uv", new import_three26.Float32BufferAttribute(uvs, 2));
   geometry.setIndex(indices);
   return geometry;
 }
-var import_three21, fluidRules, HORIZONTAL, EPSILON;
+var import_three26, fluidRules, HORIZONTAL, EPSILON;
 var init_FluidGeometry = __esm({
   "src/model/fluid/FluidGeometry.ts"() {
-    import_three21 = require("three");
+    import_three26 = require("three");
     init_fluidBlocks();
     fluidRules = fluidBlocks_default;
     HORIZONTAL = [[0, -1], [0, 1], [-1, 0], [1, 0]];
@@ -4339,10 +4339,10 @@ function sampleFluid(kind, sample) {
   }
   return { key: key.join(""), sample: (x, y, z) => cells[(y + 1) * 9 + (z + 1) * 3 + x + 1] };
 }
-var import_three22, FluidModelObject;
+var import_three27, FluidModelObject;
 var init_FluidModelObject = __esm({
   "src/model/fluid/FluidModelObject.ts"() {
-    import_three22 = require("three");
+    import_three27 = require("three");
     init_AssetKey();
     init_Materials();
     init_ModelObject();
@@ -4375,10 +4375,10 @@ var init_FluidModelObject = __esm({
           }
         }
         geometry.clearGroups();
-        const color = new import_three22.Color(this.options.tints?.[0] ?? (this.kind === "water" ? 4159204 : 16777215));
+        const color = new import_three27.Color(this.options.tints?.[0] ?? (this.kind === "water" ? 4159204 : 16777215));
         const colors = new Float32Array(geometry.getAttribute("position").count * 3);
         for (let i = 0; i < colors.length; i += 3) color.toArray(colors, i);
-        geometry.setAttribute("color", new import_three22.BufferAttribute(colors, 3));
+        geometry.setAttribute("color", new import_three27.BufferAttribute(colors, 3));
         geometry.computeBoundingBox();
         geometry.computeBoundingSphere();
         if (this.options.instanceMeshes) {
@@ -4392,7 +4392,7 @@ var init_FluidModelObject = __esm({
         super.applyTextures();
         this.iterateAllMeshes((mesh) => {
           const material = mesh.material;
-          material.side = import_three22.DoubleSide;
+          material.side = import_three27.DoubleSide;
           material.forceSinglePass = true;
           material.depthWrite = !material.transparent;
         });
@@ -4480,6 +4480,7 @@ __export(index_browser_exports, {
   RequestError: () => RequestError,
   Requests: () => Requests,
   SKIN_PARTS: () => SKIN_PARTS,
+  SceneExporter: () => SceneExporter,
   SceneInspector: () => SceneInspector,
   SceneObject: () => SceneObject,
   SceneStats: () => SceneStats,
@@ -4569,7 +4570,8 @@ __export(index_browser_exports, {
   timingStart: () => timingStart,
   toDegrees: () => toDegrees,
   toRadians: () => toRadians,
-  toTrianglesDrawMode: () => toTrianglesDrawMode
+  toTrianglesDrawMode: () => toTrianglesDrawMode,
+  trimCanvas: () => trimCanvas
 });
 module.exports = __toCommonJS(index_browser_exports);
 
@@ -4949,6 +4951,37 @@ init_PersistentCache();
 init_CanvasCompat();
 init_CanvasImage();
 
+// src/canvas/trimCanvas.ts
+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 y = 0; y < canvas.height; y++) {
+    for (let x = 0; x < canvas.width; x++) {
+      if (pixels[(y * canvas.width + x) * 4 + 3] === 0) continue;
+      left = Math.min(left, x);
+      top = Math.min(top, y);
+      right = Math.max(right, x);
+      bottom = Math.max(bottom, y);
+    }
+  }
+  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/scene/EntityObject.ts
 init_SceneObject();
 init_Caching();
@@ -5070,6 +5103,2510 @@ function isEntityObject(obj) {
 // src/error/index.ts
 init_MineRenderError();
 
+// src/export/SceneExporter.ts
+var import_three18 = require("three");
+
+// ../../node_modules/three/examples/jsm/exporters/OBJExporter.js
+var import_three14 = require("three");
+var OBJExporter = class {
+  parse(object) {
+    let output = "";
+    let indexVertex = 0;
+    let indexVertexUvs = 0;
+    let indexNormals = 0;
+    const vertex = new import_three14.Vector3();
+    const color = new import_three14.Color();
+    const normal = new import_three14.Vector3();
+    const uv = new import_three14.Vector2();
+    const face = [];
+    function parseMesh(mesh) {
+      let nbVertex = 0;
+      let nbNormals = 0;
+      let nbVertexUvs = 0;
+      const geometry = mesh.geometry;
+      const normalMatrixWorld = new import_three14.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 i = 0, l = vertices.count; i < l; i++, nbVertex++) {
+          vertex.fromBufferAttribute(vertices, i);
+          vertex.applyMatrix4(mesh.matrixWorld);
+          output += "v " + vertex.x + " " + vertex.y + " " + vertex.z + "\n";
+        }
+      }
+      if (uvs !== void 0) {
+        for (let i = 0, l = uvs.count; i < l; i++, nbVertexUvs++) {
+          uv.fromBufferAttribute(uvs, i);
+          output += "vt " + uv.x + " " + uv.y + "\n";
+        }
+      }
+      if (normals !== void 0) {
+        normalMatrixWorld.getNormalMatrix(mesh.matrixWorld);
+        for (let i = 0, l = normals.count; i < l; i++, nbNormals++) {
+          normal.fromBufferAttribute(normals, i);
+          normal.applyMatrix3(normalMatrixWorld).normalize();
+          output += "vn " + normal.x + " " + normal.y + " " + normal.z + "\n";
+        }
+      }
+      if (indices !== null) {
+        for (let i = 0, l = indices.count; i < l; i += 3) {
+          for (let m = 0; m < 3; m++) {
+            const j = indices.getX(i + m) + 1;
+            face[m] = indexVertex + j + (normals || uvs ? "/" + (uvs ? indexVertexUvs + j : "") + (normals ? "/" + (indexNormals + j) : "") : "");
+          }
+          output += "f " + face.join(" ") + "\n";
+        }
+      } else {
+        for (let i = 0, l = vertices.count; i < l; i += 3) {
+          for (let m = 0; m < 3; m++) {
+            const j = i + m + 1;
+            face[m] = indexVertex + j + (normals || uvs ? "/" + (uvs ? indexVertexUvs + j : "") + (normals ? "/" + (indexNormals + j) : "") : "");
+          }
+          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 i = 0, l = vertices.count; i < l; i++, nbVertex++) {
+          vertex.fromBufferAttribute(vertices, i);
+          vertex.applyMatrix4(line.matrixWorld);
+          output += "v " + vertex.x + " " + vertex.y + " " + vertex.z + "\n";
+        }
+      }
+      if (type === "Line") {
+        output += "l ";
+        for (let j = 1, l = vertices.count; j <= l; j++) {
+          output += indexVertex + j + " ";
+        }
+        output += "\n";
+      }
+      if (type === "LineSegments") {
+        for (let j = 1, k = j + 1, l = vertices.count; j < l; j += 2, k = j + 1) {
+          output += "l " + (indexVertex + j) + " " + (indexVertex + k) + "\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 i = 0, l = vertices.count; i < l; i++, nbVertex++) {
+          vertex.fromBufferAttribute(vertices, i);
+          vertex.applyMatrix4(points.matrixWorld);
+          output += "v " + vertex.x + " " + vertex.y + " " + vertex.z;
+          if (colors !== void 0) {
+            color.fromBufferAttribute(colors, i).convertLinearToSRGB();
+            output += " " + color.r + " " + color.g + " " + color.b;
+          }
+          output += "\n";
+        }
+        output += "p ";
+        for (let j = 1, l = vertices.count; j <= l; j++) {
+          output += indexVertex + j + " ";
+        }
+        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
+var import_three15 = require("three");
+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 import_three15.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 vertex = new import_three15.Vector3();
+    const normalMatrixWorld = new import_three15.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 i = 0, l = vertices.count; i < l; i++) {
+          vertex.fromBufferAttribute(vertices, i);
+          vertex.applyMatrix4(mesh.matrixWorld);
+          output.setFloat32(vOffset, vertex.x, options.littleEndian);
+          vOffset += 4;
+          output.setFloat32(vOffset, vertex.y, options.littleEndian);
+          vOffset += 4;
+          output.setFloat32(vOffset, vertex.z, options.littleEndian);
+          vOffset += 4;
+          if (includeNormals === true) {
+            if (normals != null) {
+              vertex.fromBufferAttribute(normals, i);
+              vertex.applyMatrix3(normalMatrixWorld).normalize();
+              output.setFloat32(vOffset, vertex.x, options.littleEndian);
+              vOffset += 4;
+              output.setFloat32(vOffset, vertex.y, options.littleEndian);
+              vOffset += 4;
+              output.setFloat32(vOffset, vertex.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(i), options.littleEndian);
+              vOffset += 4;
+              output.setFloat32(vOffset, uvs.getY(i), 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, i).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 i = 0, l = indices.count; i < l; i += 3) {
+              output.setUint8(fOffset, 3);
+              fOffset += 1;
+              output.setUint32(fOffset, indices.getX(i + 0) + writtenVertices, options.littleEndian);
+              fOffset += indexByteCount;
+              output.setUint32(fOffset, indices.getX(i + 1) + writtenVertices, options.littleEndian);
+              fOffset += indexByteCount;
+              output.setUint32(fOffset, indices.getX(i + 2) + writtenVertices, options.littleEndian);
+              fOffset += indexByteCount;
+            }
+          } else {
+            for (let i = 0, l = vertices.count; i < l; i += 3) {
+              output.setUint8(fOffset, 3);
+              fOffset += 1;
+              output.setUint32(fOffset, writtenVertices + i, options.littleEndian);
+              fOffset += indexByteCount;
+              output.setUint32(fOffset, writtenVertices + i + 1, options.littleEndian);
+              fOffset += indexByteCount;
+              output.setUint32(fOffset, writtenVertices + i + 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 i = 0, l = vertices.count; i < l; i++) {
+          vertex.fromBufferAttribute(vertices, i);
+          vertex.applyMatrix4(mesh.matrixWorld);
+          let line = vertex.x + " " + vertex.y + " " + vertex.z;
+          if (includeNormals === true) {
+            if (normals != null) {
+              vertex.fromBufferAttribute(normals, i);
+              vertex.applyMatrix3(normalMatrixWorld).normalize();
+              line += " " + vertex.x + " " + vertex.y + " " + vertex.z;
+            } else {
+              line += " 0 0 0";
+            }
+          }
+          if (includeUVs === true) {
+            if (uvs != null) {
+              line += " " + uvs.getX(i) + " " + uvs.getY(i);
+            } else {
+              line += " 0 0";
+            }
+          }
+          if (includeColors === true) {
+            if (colors != null) {
+              tempColor.fromBufferAttribute(colors, i).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 i = 0, l = indices.count; i < l; i += 3) {
+              faceList += `3 ${indices.getX(i + 0) + writtenVertices}`;
+              faceList += ` ${indices.getX(i + 1) + writtenVertices}`;
+              faceList += ` ${indices.getX(i + 2) + writtenVertices}
+`;
+            }
+          } else {
+            for (let i = 0, l = vertices.count; i < l; i += 3) {
+              faceList += `3 ${writtenVertices + i} ${writtenVertices + i + 1} ${writtenVertices + i + 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
+var import_three17 = require("three");
+
+// ../../node_modules/three/examples/jsm/utils/TextureUtils.js
+var import_three16 = require("three");
+var _renderer;
+var fullscreenQuadGeometry;
+var fullscreenQuadMaterial;
+var fullscreenQuad;
+function decompress(texture, maxTextureSize = Infinity, renderer = null) {
+  if (!fullscreenQuadGeometry) fullscreenQuadGeometry = new import_three16.PlaneGeometry(2, 2, 1, 1);
+  if (!fullscreenQuadMaterial) fullscreenQuadMaterial = new import_three16.ShaderMaterial({
+    uniforms: { blitTexture: new import_three16.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 == import_three16.SRGBColorSpace;
+  fullscreenQuadMaterial.needsUpdate = true;
+  if (!fullscreenQuad) {
+    fullscreenQuad = new import_three16.Mesh(fullscreenQuadGeometry, fullscreenQuadMaterial);
+    fullscreenQuad.frustrumCulled = false;
+  }
+  const _camera = new import_three16.PerspectiveCamera();
+  const _scene = new import_three16.Scene();
+  _scene.add(fullscreenQuad);
+  if (!renderer) {
+    renderer = _renderer = new import_three16.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 import_three16.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 i = 0, il = this.pluginCallbacks.length; i < il; i++) {
+      plugins.push(this.pluginCallbacks[i](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[import_three17.NearestFilter] = WEBGL_CONSTANTS.NEAREST;
+THREE_TO_WEBGL[import_three17.NearestMipmapNearestFilter] = WEBGL_CONSTANTS.NEAREST_MIPMAP_NEAREST;
+THREE_TO_WEBGL[import_three17.NearestMipmapLinearFilter] = WEBGL_CONSTANTS.NEAREST_MIPMAP_LINEAR;
+THREE_TO_WEBGL[import_three17.LinearFilter] = WEBGL_CONSTANTS.LINEAR;
+THREE_TO_WEBGL[import_three17.LinearMipmapNearestFilter] = WEBGL_CONSTANTS.LINEAR_MIPMAP_NEAREST;
+THREE_TO_WEBGL[import_three17.LinearMipmapLinearFilter] = WEBGL_CONSTANTS.LINEAR_MIPMAP_LINEAR;
+THREE_TO_WEBGL[import_three17.ClampToEdgeWrapping] = WEBGL_CONSTANTS.CLAMP_TO_EDGE;
+THREE_TO_WEBGL[import_three17.RepeatWrapping] = WEBGL_CONSTANTS.REPEAT;
+THREE_TO_WEBGL[import_three17.MirroredRepeatWrapping] = WEBGL_CONSTANTS.MIRRORED_REPEAT;
+var PATH_PROPERTIES = {
+  scale: "scale",
+  position: "translation",
+  quaternion: "rotation",
+  morphTargetInfluences: "weights"
+};
+var DEFAULT_SPECULAR_COLOR = new import_three17.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 i = start; i < start + count; i++) {
+    for (let a = 0; a < attribute.itemSize; a++) {
+      let value;
+      if (attribute.itemSize > 4) {
+        value = attribute.array[i * attribute.itemSize + a];
+      } else {
+        if (a === 0) value = attribute.getX(i);
+        else if (a === 1) value = attribute.getY(i);
+        else if (a === 2) value = attribute.getZ(i);
+        else if (a === 3) value = attribute.getW(i);
+        if (attribute.normalized === true) {
+          value = import_three17.MathUtils.normalize(value, attribute.array);
+        }
+      }
+      output.min[a] = Math.min(output.min[a], value);
+      output.max[a] = Math.max(output.max[a], 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 i = arrayBuffer.byteLength; i < paddedLength; i++) {
+        array[i] = 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 v = new import_three17.Vector3();
+    for (let i = 0, il = normal.count; i < il; i++) {
+      if (Math.abs(v.fromBufferAttribute(normal, i).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 v = new import_three17.Vector3();
+    for (let i = 0, il = attribute.count; i < il; i++) {
+      v.fromBufferAttribute(attribute, i);
+      if (v.x === 0 && v.y === 0 && v.z === 0) {
+        v.setX(1);
+      } else {
+        v.normalize();
+      }
+      attribute.setXYZ(i, v.x, v.y, v.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 === import_three17.SRGBColorSpace) {
+        return function SRGBToLinear(c) {
+          return c < 0.04045 ? c * 0.0773993808 : Math.pow(c * 0.9478672986 + 0.0521327014, 2.4);
+        };
+      }
+      return function LinearToLinear(c) {
+        return c;
+      };
+    }
+    console.warn("THREE.GLTFExporter: Merged metalnessMap and roughnessMap textures.");
+    if (metalnessMap instanceof import_three17.CompressedTexture) {
+      metalnessMap = decompress(metalnessMap);
+    }
+    if (roughnessMap instanceof import_three17.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 i = 2; i < data.length; i += 4) {
+        composite.data[i] = convert(data[i] / 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 i = 1; i < data.length; i += 4) {
+        composite.data[i] = convert(data[i] / 256) * 256;
+      }
+    }
+    context.putImageData(composite, 0, 0);
+    const reference = metalnessMap || roughnessMap;
+    const texture = reference.clone();
+    texture.source = new import_three17.Source(canvas);
+    texture.colorSpace = import_three17.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(buffer) {
+    const json = this.json;
+    const buffers = this.buffers;
+    if (!json.buffers) json.buffers = [{ byteLength: 0 }];
+    buffers.push(buffer);
+    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 i = start; i < start + count; i++) {
+      for (let a = 0; a < attribute.itemSize; a++) {
+        let value;
+        if (attribute.itemSize > 4) {
+          value = attribute.array[i * attribute.itemSize + a];
+        } else {
+          if (a === 0) value = attribute.getX(i);
+          else if (a === 1) value = attribute.getY(i);
+          else if (a === 2) value = attribute.getZ(i);
+          else if (a === 3) value = attribute.getW(i);
+          if (attribute.normalized === true) {
+            value = import_three17.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 buffer = getPaddedArrayBuffer(reader.result);
+        const bufferViewDef = {
+          buffer: writer.processBuffer(buffer),
+          byteOffset: writer.byteOffset,
+          byteLength: buffer.byteLength
+        };
+        writer.byteOffset += buffer.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 types = {
+      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: types[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, format, 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 ctx = canvas.getContext("2d");
+      if (flipY === true) {
+        ctx.translate(0, canvas.height);
+        ctx.scale(1, -1);
+      }
+      if (image.data !== void 0) {
+        if (format !== import_three17.RGBAFormat) {
+          console.error("GLTFExporter: Only RGBAFormat is supported.", format);
+        }
+        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 i = 0; i < data.length; i += 4) {
+          data[i + 0] = image.data[i + 0];
+          data[i + 1] = image.data[i + 1];
+          data[i + 2] = image.data[i + 2];
+          data[i + 3] = image.data[i + 3];
+        }
+        ctx.putImageData(new ImageData(data, image.width, image.height), 0, 0);
+      } else {
+        ctx.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 import_three17.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 color = material.color.toArray().concat([material.opacity]);
+    if (!equalArray(color, [1, 1, 1, 1])) {
+      materialDef.pbrMetallicRoughness.baseColorFactor = color;
+    }
+    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 === import_three17.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 i = 0, l = mesh.material.length; i < l; i++) {
+        meshCacheKeyParts.push(mesh.material[i].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 mode;
+    if (mesh.isLineSegments) {
+      mode = WEBGL_CONSTANTS.LINES;
+    } else if (mesh.isLineLoop) {
+      mode = WEBGL_CONSTANTS.LINE_LOOP;
+    } else if (mesh.isLine) {
+      mode = WEBGL_CONSTANTS.LINE_STRIP;
+    } else if (mesh.isPoints) {
+      mode = WEBGL_CONSTANTS.POINTS;
+    } else {
+      mode = 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 import_three17.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 i = 0; i < mesh.morphTargetInfluences.length; ++i) {
+        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][i];
+          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 j = 0, jl = attribute.count; j < jl; j++) {
+              for (let a = 0; a < attribute.itemSize; a++) {
+                if (a === 0) relativeAttribute.setX(j, attribute.getX(j) - baseAttribute.getX(j));
+                if (a === 1) relativeAttribute.setY(j, attribute.getY(j) - baseAttribute.getY(j));
+                if (a === 2) relativeAttribute.setZ(j, attribute.getZ(j) - baseAttribute.getZ(j));
+                if (a === 3) relativeAttribute.setW(j, attribute.getW(j) - baseAttribute.getW(j));
+              }
+            }
+          }
+          target[gltfAttributeName] = this.processAccessor(relativeAttribute, geometry);
+          cache.attributes.set(this.getUID(baseAttribute, true), target[gltfAttributeName]);
+        }
+        targets.push(target);
+        weights.push(mesh.morphTargetInfluences[i]);
+        if (mesh.morphTargetDictionary !== void 0) targetNames.push(reverseDictionary[i]);
+      }
+      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 i = 0, il = groups.length; i < il; i++) {
+      const primitive = {
+        mode,
+        attributes
+      };
+      this.serializeUserData(geometry, primitive);
+      if (targets.length > 0) primitive.targets = targets;
+      if (geometry.index !== null) {
+        let cacheKey = this.getUID(geometry.index);
+        if (groups[i].start !== void 0 || groups[i].count !== void 0) {
+          cacheKey += ":" + groups[i].start + ":" + groups[i].count;
+        }
+        if (cache.attributes.has(cacheKey)) {
+          primitive.indices = cache.attributes.get(cacheKey);
+        } else {
+          primitive.indices = this.processAccessor(geometry.index, geometry, groups[i].start, groups[i].count);
+          cache.attributes.set(cacheKey, primitive.indices);
+        }
+        if (primitive.indices === null) delete primitive.indices;
+      }
+      const material = this.processMaterial(materials[groups[i].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: import_three17.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 i = 0; i < tracks.length; ++i) {
+      const track = tracks[i];
+      const trackBinding = import_three17.PropertyBinding.parseTrackName(track.name);
+      let trackNode = import_three17.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() === import_three17.InterpolateDiscrete) {
+        interpolation = "STEP";
+      } else {
+        interpolation = "LINEAR";
+      }
+      samplers.push({
+        input: this.processAccessor(new import_three17.BufferAttribute(track.times, inputItemSize)),
+        output: this.processAccessor(new import_three17.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 import_three17.Matrix4();
+    for (let i = 0; i < skeleton.bones.length; ++i) {
+      joints.push(nodeMap.get(skeleton.bones[i]));
+      temporaryBoneInverse.copy(skeleton.boneInverses[i]);
+      temporaryBoneInverse.multiply(object.bindMatrix).toArray(inverseBindMatrices, i * 16);
+    }
+    if (json.skins === void 0) json.skins = [];
+    json.skins.push({
+      inverseBindMatrices: this.processAccessor(new import_three17.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 i = 0, l = object.children.length; i < l; i++) {
+        const child = object.children[i];
+        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 i = 0, l = scene.children.length; i < l; i++) {
+      const child = scene.children[i];
+      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 import_three17.Scene();
+    scene.name = "AuxScene";
+    for (let i = 0; i < objects.length; i++) {
+      scene.children.push(objects[i]);
+    }
+    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 i = 0; i < input.length; i++) {
+      if (input[i] instanceof import_three17.Scene) {
+        this.processScene(input[i]);
+      } else {
+        objectsWithoutScene.push(input[i]);
+      }
+    }
+    if (objectsWithoutScene.length > 0) this.processObjects(objectsWithoutScene);
+    for (let i = 0; i < this.skins.length; ++i) {
+      this.processSkin(this.skins[i]);
+    }
+    for (let i = 0; i < options.animations.length; ++i) {
+      this.processAnimation(options.animations[i], input[0]);
+    }
+    this._invokeAll(function(ext) {
+      ext.afterParse && ext.afterParse(input);
+    });
+  }
+  _invokeAll(func) {
+    for (let i = 0, il = this.plugins.length; i < il; i++) {
+      func(this.plugins[i]);
+    }
+  }
+};
+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 import_three17.Matrix4();
+    const position = new import_three17.Vector3();
+    const quaternion = new import_three17.Quaternion();
+    const scale = new import_three17.Vector3();
+    for (let i = 0; i < mesh.count; i++) {
+      mesh.getMatrixAt(i, matrix);
+      matrix.decompose(position, quaternion, scale);
+      position.toArray(translationAttr, i * 3);
+      quaternion.toArray(rotationAttr, i * 4);
+      scale.toArray(scaleAttr, i * 3);
+    }
+    const attributes = {
+      TRANSLATION: writer.processAccessor(new import_three17.BufferAttribute(translationAttr, 3)),
+      ROTATION: writer.processAccessor(new import_three17.BufferAttribute(rotationAttr, 4)),
+      SCALE: writer.processAccessor(new import_three17.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 i = 0; i < valueSize; i++) {
+        values[i] = 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 i = 0; i < track.times.length; i++) {
+        if (Math.abs(track.times[i] - time) < tolerance) return i;
+        if (track.times[i] < time && track.times[i + 1] > time) {
+          times.set(track.times.slice(0, i + 1), 0);
+          times[i + 1] = time;
+          times.set(track.times.slice(i + 1), i + 2);
+          values.set(track.values.slice(0, (i + 1) * valueSize), 0);
+          values.set(interpolant.evaluate(time), (i + 1) * valueSize);
+          values.set(track.values.slice((i + 1) * valueSize), (i + 2) * valueSize);
+          index = i + 1;
+          break;
+        }
+      }
+    }
+    track.times = times;
+    track.values = values;
+    return index;
+  },
+  mergeMorphTargetTracks: function(clip, root) {
+    const tracks = [];
+    const mergedTracks = {};
+    const sourceTracks = clip.tracks;
+    for (let i = 0; i < sourceTracks.length; ++i) {
+      let sourceTrack = sourceTracks[i];
+      const sourceTrackBinding = import_three17.PropertyBinding.parseTrackName(sourceTrack.name);
+      const sourceTrackNode = import_three17.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(import_three17.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 j = 0; j < mergedTrack.times.length; j++) {
+          values[j * targetCount + targetIndex] = mergedTrack.values[j];
+        }
+        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 j = 0; j < mergedTrack.times.length; j++) {
+        mergedTrack.values[j * targetCount + targetIndex] = sourceInterpolant.evaluate(mergedTrack.times[j]);
+      }
+      for (let j = 0; j < sourceTrack.times.length; j++) {
+        const keyframeIndex = this.insertKeyframe(mergedTrack, sourceTrack.times[j]);
+        mergedTrack.values[keyframeIndex * targetCount + targetIndex] = sourceTrack.values[j];
+      }
+    }
+    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 import_three18.Matrix4().compose(object.position, object.quaternion, object.scale) : object.matrix.clone();
+}
+function createSnapshot(root, gltf, bakeColors = false) {
+  const scene = new import_three18.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 import_three18.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 import_three18.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 i = start; i + 2 < end; i += 3) {
+        for (let corner = 0; corner < 3; corner++) indices.push(source.index?.getX(i + corner) ?? i + 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 import_three18.Color()).clone();
+        if (instanceColor) tint.multiply(instanceColor);
+        if (bakeColors) {
+          const original = geometry.getAttribute("color");
+          const colors = new import_three18.Float32BufferAttribute(new Float32Array(geometry.getAttribute("position").count * 3), 3);
+          for (let i = 0; i < colors.count; i++) {
+            colors.setXYZ(i, (original?.getX(i) ?? 1) * tint.r, (original?.getY(i) ?? 1) * tint.g, (original?.getZ(i) ?? 1) * tint.b);
+          }
+          geometry.setAttribute("color", colors);
+        } else if (material.color) {
+          material.color.copy(tint);
+        }
+      }
+      const copy = new import_three18.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 i = 0; i < instanced.count; i++) {
+          const matrix = new import_three18.Matrix4();
+          instanced.getMatrixAt(i, matrix);
+          const color = instanced.instanceColor ? new import_three18.Color().fromBufferAttribute(instanced.instanceColor, i) : void 0;
+          addMesh(mesh, world.clone().multiply(matrix), color);
+        }
+      } 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 import_three18.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 !== import_three18.RGBAFormat || texture.type !== import_three18.UnsignedByteType || texture.wrapS !== import_three18.ClampToEdgeWrapping || texture.wrapT !== import_three18.ClampToEdgeWrapping || texture.magFilter !== import_three18.NearestFilter || texture.minFilter !== import_three18.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, i) => value === (i % 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 i = 0; i + 2 < count; i += 3) {
+    let minU = Infinity, maxU = -Infinity, minV = Infinity, maxV = -Infinity;
+    for (let corner = 0; corner < 3; corner++) {
+      const index = geometry.index?.getX(i + corner) ?? i + corner;
+      const u = uv.getX(index), v = texture.flipY ? 1 - uv.getY(index) : uv.getY(index);
+      if (!Number.isFinite(u) || !Number.isFinite(v)) return;
+      minU = Math.min(minU, u);
+      maxU = Math.max(maxU, u);
+      minV = Math.min(minV, v);
+      maxV = Math.max(maxV, v);
+    }
+    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 y = minY; y <= maxY; y++) {
+      for (let x = minX; x <= maxX; x++) {
+        const alpha = data[(y * width + x) * 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 !== import_three18.RGBAFormat || source.type !== import_three18.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 import_three18.Source(canvas);
+  return new import_three18.Texture().copy(copySource);
+}
+
 // src/gui/GuiHelper.ts
 var GuiHelper = class {
   static inventorySlot(slot, origin = [0, 0], offset = [18, 18], rowSize = 9) {
@@ -5079,7 +7616,7 @@ var GuiHelper = class {
 };
 
 // src/gui/scene/GuiObject.ts
-var import_three14 = require("three");
+var import_three19 = require("three");
 init_AssetKey();
 init_ModelTextures();
 init_Caching();
@@ -5091,7 +7628,7 @@ var GuiObject = class extends SceneObject {
     this.textureLayers = textureLayers;
     this.isGuiObject = true;
     /** Local bounds in GUI pixels, with y growing down from the origin. */
-    this.bounds = new import_three14.Box2();
+    this.bounds = new import_three19.Box2();
     this.geometries = /* @__PURE__ */ new Set();
     this.ownedMaterials = /* @__PURE__ */ new Set();
     this.initialized = false;
@@ -5106,7 +7643,7 @@ var GuiObject = class extends SceneObject {
         const [cropX, cropY, cropWidth, cropHeight] = layer.crop ?? [0, 0, image.width, image.height];
         const [width, height] = layer.size ?? [cropWidth, cropHeight];
         const [x, y] = layer.position ?? [0, 0];
-        const geometry = new import_three14.PlaneGeometry(width, height);
+        const geometry = new import_three19.PlaneGeometry(width, height);
         this.geometries.add(geometry);
         const uv = geometry.getAttribute("uv");
         for (let i = 0; i < uv.count; i++) {
@@ -5116,13 +7653,13 @@ var GuiObject = class extends SceneObject {
             1 - (cropY + (1 - uv.getY(i)) * cropHeight) / image.height
           );
         }
-        const mesh = new import_three14.Mesh(geometry, material);
+        const mesh = new import_three19.Mesh(geometry, material);
         mesh.name = `mesh:${layer.name ?? index}`;
         mesh.position.set(x + width / 2, -y - height / 2, 0);
         mesh.renderOrder = index;
         this.add(mesh);
-        this.bounds.expandByPoint(new import_three14.Vector2(x, y));
-        this.bounds.expandByPoint(new import_three14.Vector2(x + width, y + height));
+        this.bounds.expandByPoint(new import_three19.Vector2(x, y));
+        this.bounds.expandByPoint(new import_three19.Vector2(x + width, y + height));
       }
       this.initialized = true;
       this.notifyDirty();
@@ -5169,7 +7706,7 @@ function isGuiObject(obj) {
 init_image();
 
 // src/inspector/SceneInspector.ts
-var import_three15 = require("three");
+var import_three20 = require("three");
 init_SceneObject();
 init_util();
 init_log();
@@ -5179,11 +7716,11 @@ var help = "<span>Ctrl/Cmd+Click to Select<br/></span><br/>";
 var SceneInspector = class {
   constructor(renderer) {
     this.renderer = renderer;
-    this.mouse = new import_three15.Vector2();
+    this.mouse = new import_three20.Vector2();
     this.listeners = new AbortController();
     this.objectInfoContainer = document.createElement("div");
     this.objectControlsContainer = document.createElement("div");
-    this.raycaster = new import_three15.Raycaster();
+    this.raycaster = new import_three20.Raycaster();
     this.init();
   }
   init() {
@@ -5599,7 +8136,7 @@ init_ModelGenerator();
 init_ModelMerger();
 
 // src/model/block/BlockStateResolver.ts
-var import_three18 = require("three");
+var import_three23 = require("three");
 init_BlockStates();
 init_MineRenderError();
 init_util();
@@ -5677,7 +8214,7 @@ var BlockStateResolver = class {
     return variants[variants.length - 1];
   }
   static rotation(variant) {
-    const rotation = new import_three18.Euler();
+    const rotation = new import_three23.Euler();
     if (typeof variant.x !== "undefined") {
       rotation.x = toRadians(clampRotationDegrees(variant.x));
     }
@@ -5784,7 +8321,7 @@ init_SceneObject();
 init_ModelObject();
 init_Models();
 var import_ts_deepmerge6 = __toESM(require_dist());
-var import_three23 = require("three");
+var import_three28 = require("three");
 init_MineRenderError();
 init_InstanceReference();
 init_AssetKey();
@@ -5848,12 +8385,12 @@ var _BlockObject = class _BlockObject extends SceneObject {
   getModelCullMask(model, worldMask) {
     const object = isInstanceReference(model) ? model.instanceable : model;
     if (object.options.displayPosition) return 0;
-    const position = new import_three23.Vector3();
-    const rotation = new import_three23.Quaternion();
-    const scale = new import_three23.Vector3();
+    const position = new import_three28.Vector3();
+    const rotation = new import_three28.Quaternion();
+    const scale = new import_three28.Vector3();
     this.getModelMatrix(model).decompose(position, rotation, scale);
-    if (position.distanceToSquared(this.position) > 1e-10 || scale.distanceToSquared(new import_three23.Vector3(1, 1, 1)) > 1e-10) return 0;
-    return ModelCulling.toLocalMask(worldMask, new import_three23.Euler().setFromQuaternion(rotation));
+    if (position.distanceToSquared(this.position) > 1e-10 || scale.distanceToSquared(new import_three28.Vector3(1, 1, 1)) > 1e-10) return 0;
+    return ModelCulling.toLocalMask(worldMask, new import_three28.Euler().setFromQuaternion(rotation));
   }
   async setCullMask(worldMask) {
     worldMask &= 63;
@@ -5915,7 +8452,7 @@ var _BlockObject = class _BlockObject extends SceneObject {
       () => new FluidModelObject2(kind, surface.sample, this.blockState.key, this.options)
     );
     const previous = this._fluidModel;
-    const matrix = previous ? this.getModelMatrix(previous) : new import_three23.Matrix4().makeTranslation(...this.position.toArray());
+    const matrix = previous ? this.getModelMatrix(previous) : new import_three28.Matrix4().makeTranslation(...this.position.toArray());
     if (isInstanceReference(replacement)) replacement.setMatrix(matrix);
     else matrix.decompose(replacement.position, replacement.quaternion, replacement.scale);
     this._models = this._models.filter((model) => model !== previous);
@@ -6046,7 +8583,7 @@ var _BlockObject = class _BlockObject extends SceneObject {
   setPositionRotationScaleAt(index, position, rotation, scale) {
     super.setPositionRotationScaleAt(index, position, rotation, scale);
   }
-  getMatrixAt(index, matrix = new import_three23.Matrix4()) {
+  getMatrixAt(index, matrix = new import_three28.Matrix4()) {
     if (!this.isInstanced) throw new MineRenderError("Object is not instanced");
     const child = this._models[0];
     if (child && isModelObject(child)) {
@@ -7916,7 +10453,7 @@ init_ModelObject();
 init_nbt();
 
 // src/renderer/MineRenderScene.ts
-var import_three25 = require("three");
+var import_three30 = require("three");
 init_SceneObject();
 var import_ts_deepmerge8 = __toESM(require_dist());
 init_ModelObject();
@@ -8649,7 +11186,7 @@ var import_ts_deepmerge7 = __toESM(require_dist());
 init_util();
 
 // src/skin/SkinTextures.ts
-var import_three24 = require("three");
+var import_three29 = require("three");
 init_Caching();
 init_CacheKey();
 init_MineRenderError();
@@ -8733,11 +11270,11 @@ var SkinTextures = class {
     });
   }
   static createMaterial(pixels, width, height, transparent = true) {
-    const texture = Textures.initTextureProps(new import_three24.DataTexture(pixels, width, height));
-    texture.colorSpace = import_three24.SRGBColorSpace;
+    const texture = Textures.initTextureProps(new import_three29.DataTexture(pixels, width, height));
+    texture.colorSpace = import_three29.SRGBColorSpace;
     texture.flipY = true;
     texture.needsUpdate = true;
-    return new import_three24.MeshBasicMaterial({ map: texture, transparent, side: transparent ? import_three24.DoubleSide : import_three24.FrontSide, alphaTest: transparent ? 0.1 : 0 });
+    return new import_three29.MeshBasicMaterial({ map: texture, transparent, side: transparent ? import_three29.DoubleSide : import_three29.FrontSide, alphaTest: transparent ? 0.1 : 0 });
   }
   static isSlim(image, scale) {
     for (const [x, y] of [[46, 52], [54, 20]]) {
@@ -8964,7 +11501,7 @@ var SkinObject = class extends SceneObject {
 };
 
 // src/renderer/MineRenderScene.ts
-var _MineRenderScene = class _MineRenderScene extends import_three25.Scene {
+var _MineRenderScene = class _MineRenderScene extends import_three30.Scene {
   constructor(options) {
     super();
     this.isMineRenderScene = true;
@@ -9096,7 +11633,7 @@ function isMineRenderScene(obj) {
 }
 
 // src/renderer/Renderer.ts
-var import_three27 = require("three");
+var import_three32 = require("three");
 var import_ts_deepmerge9 = __toESM(require_dist());
 var import_stats = __toESM(require("stats.js"));
 var import_postprocessing = require("postprocessing");
@@ -9104,11 +11641,11 @@ init_util();
 init_three();
 
 // src/three/OrbitControls.js
-var import_three26 = require("three");
+var import_three31 = require("three");
 var _changeEvent = { type: "change" };
 var _startEvent = { type: "start" };
 var _endEvent = { type: "end" };
-var OrbitControls = class extends import_three26.EventDispatcher {
+var OrbitControls = class extends import_three31.EventDispatcher {
   constructor(object, domElement) {
     super();
     if (domElement === void 0) console.warn('THREE.OrbitControls: The second parameter "domElement" is now mandatory.');
@@ -9117,7 +11654,7 @@ var OrbitControls = class extends import_three26.EventDispatcher {
     this.domElement = domElement;
     this.domElement.style.touchAction = "none";
     this.enabled = true;
-    this.target = new import_three26.Vector3();
+    this.target = new import_three31.Vector3();
     this.minDistance = 0;
     this.maxDistance = Infinity;
     this.minZoom = 0;
@@ -9139,8 +11676,8 @@ var OrbitControls = class extends import_three26.EventDispatcher {
     this.autoRotate = false;
     this.autoRotateSpeed = 2;
     this.keys = { LEFT: "ArrowLeft", UP: "ArrowUp", RIGHT: "ArrowRight", BOTTOM: "ArrowDown" };
-    this.mouseButtons = { LEFT: import_three26.MOUSE.ROTATE, MIDDLE: import_three26.MOUSE.DOLLY, RIGHT: import_three26.MOUSE.PAN };
-    this.touches = { ONE: import_three26.TOUCH.ROTATE, TWO: import_three26.TOUCH.DOLLY_PAN };
+    this.mouseButtons = { LEFT: import_three31.MOUSE.ROTATE, MIDDLE: import_three31.MOUSE.DOLLY, RIGHT: import_three31.MOUSE.PAN };
+    this.touches = { ONE: import_three31.TOUCH.ROTATE, TWO: import_three31.TOUCH.DOLLY_PAN };
     this.target0 = this.target.clone();
     this.position0 = this.object.position.clone();
     this.zoom0 = this.object.zoom;
@@ -9169,11 +11706,11 @@ var OrbitControls = class extends import_three26.EventDispatcher {
       state = STATE.NONE;
     };
     this.update = function() {
-      const offset = new import_three26.Vector3();
-      const quat = new import_three26.Quaternion().setFromUnitVectors(object.up, new import_three26.Vector3(0, 1, 0));
+      const offset = new import_three31.Vector3();
+      const quat = new import_three31.Quaternion().setFromUnitVectors(object.up, new import_three31.Vector3(0, 1, 0));
       const quatInverse = quat.clone().invert();
-      const lastPosition = new import_three26.Vector3();
-      const lastQuaternion = new import_three26.Quaternion();
+      const lastPosition = new import_three31.Vector3();
+      const lastQuaternion = new import_three31.Quaternion();
       const twoPI = 2 * Math.PI;
       return function update() {
         const position = scope.object.position;
@@ -9259,20 +11796,20 @@ var OrbitControls = class extends import_three26.EventDispatcher {
     };
     let state = STATE.NONE;
     const EPS = 1e-6;
-    const spherical = new import_three26.Spherical();
-    const sphericalDelta = new import_three26.Spherical();
+    const spherical = new import_three31.Spherical();
+    const sphericalDelta = new import_three31.Spherical();
     let scale = 1;
-    const panOffset = new import_three26.Vector3();
+    const panOffset = new import_three31.Vector3();
     let zoomChanged = false;
-    const rotateStart = new import_three26.Vector2();
-    const rotateEnd = new import_three26.Vector2();
-    const rotateDelta = new import_three26.Vector2();
-    const panStart = new import_three26.Vector2();
-    const panEnd = new import_three26.Vector2();
-    const panDelta = new import_three26.Vector2();
-    const dollyStart = new import_three26.Vector2();
-    const dollyEnd = new import_three26.Vector2();
-    const dollyDelta = new import_three26.Vector2();
+    const rotateStart = new import_three31.Vector2();
+    const rotateEnd = new import_three31.Vector2();
+    const rotateDelta = new import_three31.Vector2();
+    const panStart = new import_three31.Vector2();
+    const panEnd = new import_three31.Vector2();
+    const panDelta = new import_three31.Vector2();
+    const dollyStart = new import_three31.Vector2();
+    const dollyEnd = new import_three31.Vector2();
+    const dollyDelta = new import_three31.Vector2();
     const pointers = [];
     const pointerPositions = {};
     function getAutoRotationAngle() {
@@ -9288,7 +11825,7 @@ var OrbitControls = class extends import_three26.EventDispatcher {
       sphericalDelta.phi -= angle;
     }
     const panLeft = function() {
-      const v = new import_three26.Vector3();
+      const v = new import_three31.Vector3();
       return function panLeft2(distance, objectMatrix) {
         v.setFromMatrixColumn(objectMatrix, 0);
         v.multiplyScalar(-distance);
@@ -9296,7 +11833,7 @@ var OrbitControls = class extends import_three26.EventDispatcher {
       };
     }();
     const panUp = function() {
-      const v = new import_three26.Vector3();
+      const v = new import_three31.Vector3();
       return function panUp2(distance, objectMatrix) {
         if (scope.screenSpacePanning === true) {
           v.setFromMatrixColumn(objectMatrix, 1);
@@ -9309,7 +11846,7 @@ var OrbitControls = class extends import_three26.EventDispatcher {
       };
     }();
     const pan = function() {
-      const offset = new import_three26.Vector3();
+      const offset = new import_three31.Vector3();
       return function pan2(deltaX, deltaY) {
         const element = scope.domElement;
         if (scope.object.isPerspectiveCamera) {
@@ -9558,12 +12095,12 @@ var OrbitControls = class extends import_three26.EventDispatcher {
           mouseAction = -1;
       }
       switch (mouseAction) {
-        case import_three26.MOUSE.DOLLY:
+        case import_three31.MOUSE.DOLLY:
           if (scope.enableZoom === false) return;
           handleMouseDownDolly(event);
           state = STATE.DOLLY;
           break;
-        case import_three26.MOUSE.ROTATE:
+        case import_three31.MOUSE.ROTATE:
           if (event.ctrlKey || event.metaKey || event.shiftKey) {
             if (scope.enablePan === false) return;
             handleMouseDownPan(event);
@@ -9574,7 +12111,7 @@ var OrbitControls = class extends import_three26.EventDispatcher {
             state = STATE.ROTATE;
           }
           break;
-        case import_three26.MOUSE.PAN:
+        case import_three31.MOUSE.PAN:
           if (event.ctrlKey || event.metaKey || event.shiftKey) {
             if (scope.enableRotate === false) return;
             handleMouseDownRotate(event);
@@ -9630,12 +12167,12 @@ var OrbitControls = class extends import_three26.EventDispatcher {
       switch (pointers.length) {
         case 1:
           switch (scope.touches.ONE) {
-            case import_three26.TOUCH.ROTATE:
+            case import_three31.TOUCH.ROTATE:
               if (scope.enableRotate === false) return;
               handleTouchStartRotate();
               state = STATE.TOUCH_ROTATE;
               break;
-            case import_three26.TOUCH.PAN:
+            case import_three31.TOUCH.PAN:
               if (scope.enablePan === false) return;
               handleTouchStartPan();
               state = STATE.TOUCH_PAN;
@@ -9646,12 +12183,12 @@ var OrbitControls = class extends import_three26.EventDispatcher {
           break;
         case 2:
           switch (scope.touches.TWO) {
-            case import_three26.TOUCH.DOLLY_PAN:
+            case import_three31.TOUCH.DOLLY_PAN:
               if (scope.enableZoom === false && scope.enablePan === false) return;
               handleTouchStartDollyPan();
               state = STATE.TOUCH_DOLLY_PAN;
               break;
-            case import_three26.TOUCH.DOLLY_ROTATE:
+            case import_three31.TOUCH.DOLLY_ROTATE:
               if (scope.enableZoom === false && scope.enableRotate === false) return;
               handleTouchStartDollyRotate();
               state = STATE.TOUCH_DOLLY_ROTATE;
@@ -9718,7 +12255,7 @@ var OrbitControls = class extends import_three26.EventDispatcher {
     function trackPointer(event) {
       let position = pointerPositions[event.pointerId];
       if (position === void 0) {
-        position = new import_three26.Vector2();
+        position = new import_three31.Vector2();
         pointerPositions[event.pointerId] = position;
       }
       position.set(event.pageX, event.pageY);
@@ -9738,10 +12275,10 @@ var MapControls = class extends OrbitControls {
   constructor(object, domElement) {
     super(object, domElement);
     this.screenSpacePanning = false;
-    this.mouseButtons.LEFT = import_three26.MOUSE.PAN;
-    this.mouseButtons.RIGHT = import_three26.MOUSE.ROTATE;
-    this.touches.ONE = import_three26.TOUCH.PAN;
-    this.touches.TWO = import_three26.TOUCH.DOLLY_ROTATE;
+    this.mouseButtons.LEFT = import_three31.MOUSE.PAN;
+    this.mouseButtons.RIGHT = import_three31.MOUSE.ROTATE;
+    this.touches.ONE = import_three31.TOUCH.PAN;
+    this.touches.TWO = import_three31.TOUCH.DOLLY_ROTATE;
   }
 };
 
@@ -9782,14 +12319,14 @@ var _Renderer = class _Renderer {
     switch (this.options.camera.type) {
       case "perspective":
       default:
-        return new import_three27.PerspectiveCamera(
+        return new import_three32.PerspectiveCamera(
           this.options.camera.perspective.fov,
           this.options.camera.perspective.aspect ?? this.viewWidth / this.viewHeight,
           this.options.camera.near,
           this.options.camera.far
         );
       case "orthographic":
-        return new import_three27.OrthographicCamera(
+        return new import_three32.OrthographicCamera(
           this.options.camera.orthographic.left ?? this.viewWidth / -2,
           this.options.camera.orthographic.right ?? this.viewWidth / 2,
           this.options.camera.orthographic.top ?? this.viewHeight / 2,
@@ -9800,7 +12337,7 @@ var _Renderer = class _Renderer {
     }
   }
   createRenderer() {
-    const renderer = new import_three27.WebGLRenderer({
+    const renderer = new import_three32.WebGLRenderer({
       antialias: this.options.render.antialias,
       alpha: true,
       powerPreference: "high-performance",
@@ -9808,8 +12345,8 @@ var _Renderer = class _Renderer {
     });
     renderer.setClearColor(0, 0);
     renderer.shadowMap.enabled = true;
-    renderer.shadowMap.type = import_three27.PCFSoftShadowMap;
-    renderer.outputColorSpace = import_three27.SRGBColorSpace;
+    renderer.shadowMap.type = import_three32.PCFSoftShadowMap;
+    renderer.outputColorSpace = import_three32.SRGBColorSpace;
     renderer.setPixelRatio(this.options.render.pixelRatio ?? 1);
     renderer.setSize(this.viewWidth, this.viewHeight);
     return renderer;
@@ -9844,20 +12381,20 @@ var _Renderer = class _Renderer {
       window["__THREE_DEVTOOLS__"].dispatchEvent(new CustomEvent("observe", { detail: this.scene }));
     }
     if (this.options.debug.grid) {
-      const gridHelper = new import_three27.GridHelper(128, 16);
+      const gridHelper = new import_three32.GridHelper(128, 16);
       this._debugHelpers.push(gridHelper);
       this.scene.add(gridHelper);
-      const gridHelper2 = new import_three27.GridHelper(128, 16);
+      const gridHelper2 = new import_three32.GridHelper(128, 16);
       this._debugHelpers.push(gridHelper2);
       gridHelper2.rotation.x = 90 * (Math.PI / 180);
       this.scene.add(gridHelper2);
-      const gridHelper3 = new import_three27.GridHelper(128, 16);
+      const gridHelper3 = new import_three32.GridHelper(128, 16);
       this._debugHelpers.push(gridHelper3);
       gridHelper3.rotation.z = 90 * (Math.PI / 180);
       this.scene.add(gridHelper3);
     }
     if (this.options.debug.axes) {
-      const axesHelper = new import_three27.AxesHelper(64);
+      const axesHelper = new import_three32.AxesHelper(64);
       this._debugHelpers.push(axesHelper);
       this.scene.add(axesHelper);
     }
@@ -10001,6 +12538,9 @@ var _Renderer = class _Renderer {
       if (next !== void 0 && t + 0.1 < next) return;
       this._nextFrameTime = next !== void 0 && t - next < interval ? next + interval : t + interval;
     }
+    this.drawFrame();
+  }
+  drawFrame() {
     if (this._stats) {
       this._stats.begin();
     }
@@ -10015,8 +12555,28 @@ var _Renderer = class _Renderer {
     }
   }
   //</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() {
@@ -10061,8 +12621,8 @@ _Renderer.DEFAULT_OPTIONS = (0, import_ts_deepmerge9.default)({}, {
       top: void 0,
       bottom: void 0
     },
-    position: new import_three27.Vector3(50, 50, 50),
-    lookingAt: new import_three27.Vector3(0, 0, 0)
+    position: new import_three32.Vector3(50, 50, 50),
+    lookingAt: new import_three32.Vector3(0, 0, 0)
   },
   render: {
     fpsLimit: 60,
@@ -10526,19 +13086,19 @@ var AnvilParser = class {
 };
 
 // src/world/Chunk.ts
-var import_three32 = require("three");
+var import_three37 = require("three");
 init_BlockStates();
 init_AssetKey();
 
 // src/world/MineRenderWorld.ts
-var import_three30 = require("three");
+var import_three35 = require("three");
 init_BatchedExecutor();
 init_AssetKey();
 init_BlockStates();
 init_CubeFace();
 
 // src/world/SectionModels.ts
-var import_three29 = require("three");
+var import_three34 = require("three");
 init_AssetKey();
 init_Models();
 init_CubeFace();
@@ -10604,12 +13164,12 @@ var SectionModels = class {
         });
         await object.init();
         const geometry = object.children[0].geometry;
-        geometry.applyMatrix4(new import_three29.Matrix4().makeRotationFromEuler(rotation));
+        geometry.applyMatrix4(new import_three34.Matrix4().makeRotationFromEuler(rotation));
         object.clear();
         const cullFaces = CUBE_FACES.map((face) => {
           const local = CUBE_FACES.findIndex((name) => name === atlas.model.elements[0].faces[face]?.cullface);
           if (local < 0) return 0;
-          const normal = new import_three29.Vector3(...CUBE_FACE_OFFSETS[local]).applyEuler(rotation);
+          const normal = new import_three34.Vector3(...CUBE_FACE_OFFSETS[local]).applyEuler(rotation);
           const world = CUBE_FACE_OFFSETS.findIndex(([x, y, z]) => Math.abs(normal.x - x) < 1e-6 && Math.abs(normal.y - y) < 1e-6 && Math.abs(normal.z - z) < 1e-6);
           return 1 << world;
         });
@@ -10639,20 +13199,20 @@ var MineRenderWorld = class {
   }
   getBlockAt(posOrX, y, z) {
     if (typeof posOrX == "number") {
-      return this.getBlockAt(new import_three30.Vector3(posOrX, y, z));
+      return this.getBlockAt(new import_three35.Vector3(posOrX, y, z));
     }
     if (isTripleArray(posOrX)) {
-      return this.getBlockAt(new import_three30.Vector3(posOrX[0], posOrX[1], posOrX[2]));
+      return this.getBlockAt(new import_three35.Vector3(posOrX[0], posOrX[1], posOrX[2]));
     }
     this.validatePosBounds(posOrX);
     return this.getChunkAt(posOrX)?.getBlockAt(posOrX);
   }
   async setBlockAt(posOrX, yOrBlock, z, block) {
     if (typeof posOrX == "number") {
-      return this.setBlockAt(new import_three30.Vector3(posOrX, yOrBlock, z), block);
+      return this.setBlockAt(new import_three35.Vector3(posOrX, yOrBlock, z), block);
     }
     if (isTripleArray(posOrX)) {
-      return this.setBlockAt(new import_three30.Vector3(posOrX[0], posOrX[1], posOrX[2]), yOrBlock);
+      return this.setBlockAt(new import_three35.Vector3(posOrX[0], posOrX[1], posOrX[2]), yOrBlock);
     }
     return this.placeBlock(posOrX, yOrBlock);
   }
@@ -10673,7 +13233,7 @@ var MineRenderWorld = class {
     const collect = async (positions2) => {
       for (const pos of positions2) changes.set(pos.toArray().join(","), pos);
     };
-    const place = (block) => this.placeBlock(new import_three30.Vector3(...block.position), block, collect);
+    const place = (block) => this.placeBlock(new import_three35.Vector3(...block.position), block, collect);
     const keys = /* @__PURE__ */ new Map();
     for (const block of multiblock.blocks) {
       if (Chunk.isAir(block)) continue;
@@ -10751,13 +13311,13 @@ var MineRenderWorld = class {
     for (const pos of positions) {
       this.pendingCulling.set(pos.toArray().join(","), pos.clone());
       for (const offset of CUBE_FACE_OFFSETS) {
-        const neighbor = pos.clone().add(new import_three30.Vector3(...offset));
+        const neighbor = pos.clone().add(new import_three35.Vector3(...offset));
         this.pendingCulling.set(neighbor.toArray().join(","), neighbor);
       }
       for (let y = -1; y <= 1; y++) {
         for (let z = -1; z <= 1; z++) {
           for (let x = -1; x <= 1; x++) {
-            const neighbor = pos.clone().add(new import_three30.Vector3(x, y, z));
+            const neighbor = pos.clone().add(new import_three35.Vector3(x, y, z));
             if (this.getBlockAt(neighbor)?.object?.fluidKind) {
               this.pendingCulling.set(neighbor.toArray().join(","), neighbor);
             }
@@ -10779,7 +13339,7 @@ var MineRenderWorld = class {
             if (!block) continue;
             if (block.object?.fluidKind) {
               await block.object.updateFluid((x, y, z) => {
-                const neighbor = pos.clone().add(new import_three30.Vector3(x, y, z));
+                const neighbor = pos.clone().add(new import_three35.Vector3(x, y, z));
                 const section = this.getChunkAt(neighbor);
                 const object = section?.getBlockAt(neighbor)?.object;
                 return {
@@ -10791,7 +13351,7 @@ var MineRenderWorld = class {
             }
             let mask = 0;
             for (const [face, offset] of CUBE_FACE_OFFSETS.entries()) {
-              const neighbor = pos.clone().add(new import_three30.Vector3(...offset));
+              const neighbor = pos.clone().add(new import_three35.Vector3(...offset));
               if (this.getChunkAt(neighbor)?.isOccludingAt(neighbor)) {
                 mask |= 1 << face;
               }
@@ -10825,14 +13385,14 @@ var MineRenderWorld = class {
     return this._chunks.get(this.worldPosToChunkKey(pos));
   }
   static worldToScenePosition(pos) {
-    return new import_three30.Vector3(
+    return new import_three35.Vector3(
       pos.x * 16,
       pos.y * 16,
       pos.z * 16
     );
   }
   static sceneToWorldPosition(pos) {
-    return new import_three30.Vector3(
+    return new import_three35.Vector3(
       pos.x / 16,
       pos.y / 16,
       pos.z / 16
@@ -10852,10 +13412,10 @@ var MineRenderWorld = class {
 };
 
 // src/world/SectionMesh.ts
-var import_three31 = require("three");
+var import_three36 = require("three");
 init_CanvasCompat();
 init_Materials();
-var SectionMesh = class _SectionMesh extends import_three31.Group {
+var SectionMesh = class _SectionMesh extends import_three36.Group {
   constructor() {
     super(...arguments);
     this.ownedMeshes = [];
@@ -10928,18 +13488,18 @@ var SectionMesh = class _SectionMesh extends import_three31.Group {
           for (let corner = 0; corner < 6; corner++) indices.push(start + sourceIndices.getX(face * 6 + corner) - face * 4);
         }
       }
-      const geometry = new import_three31.BufferGeometry();
-      geometry.setAttribute("position", new import_three31.Float32BufferAttribute(positions, 3));
-      geometry.setAttribute("normal", new import_three31.Float32BufferAttribute(normals, 3));
-      geometry.setAttribute("uv", new import_three31.Float32BufferAttribute(uvs, 2));
-      geometry.setAttribute("color", new import_three31.Float32BufferAttribute(colors, 3));
+      const geometry = new import_three36.BufferGeometry();
+      geometry.setAttribute("position", new import_three36.Float32BufferAttribute(positions, 3));
+      geometry.setAttribute("normal", new import_three36.Float32BufferAttribute(normals, 3));
+      geometry.setAttribute("uv", new import_three36.Float32BufferAttribute(uvs, 2));
+      geometry.setAttribute("color", new import_three36.Float32BufferAttribute(colors, 3));
       geometry.setIndex(indices);
       geometry.computeBoundingBox();
       geometry.computeBoundingSphere();
       const material = Materials.createShadedCanvasMaterial(canvas, false);
       material.vertexColors = true;
       const texture = material.uniforms?.map?.value ?? material.map;
-      const mesh = new import_three31.Mesh(geometry, material);
+      const mesh = new import_three36.Mesh(geometry, material);
       section.add(mesh);
       section.ownedMeshes.push({ mesh, texture });
     }
@@ -10973,10 +13533,10 @@ var Chunk = class _Chunk {
   }
   getBlockAt(posOrX, y, z) {
     if (typeof posOrX == "number") {
-      return this.getBlockAt(new import_three32.Vector3(posOrX, y, z));
+      return this.getBlockAt(new import_three37.Vector3(posOrX, y, z));
     }
     if (isTripleArray(posOrX)) {
-      return this.getBlockAt(new import_three32.Vector3(posOrX[0], posOrX[1], posOrX[2]));
+      return this.getBlockAt(new import_three37.Vector3(posOrX[0], posOrX[1], posOrX[2]));
     }
     const pos = this.worldPosToChunkPos(posOrX);
     const index = _Chunk.chunkPosToBlockIndex(pos);
@@ -10984,10 +13544,10 @@ var Chunk = class _Chunk {
   }
   async setBlockAt(posOrX, yOrBlock, z, block) {
     if (typeof posOrX == "number") {
-      return this.setBlockAt(new import_three32.Vector3(posOrX, yOrBlock, z), block);
+      return this.setBlockAt(new import_three37.Vector3(posOrX, yOrBlock, z), block);
     }
     if (isTripleArray(posOrX)) {
-      return this.setBlockAt(new import_three32.Vector3(posOrX[0], posOrX[1], posOrX[2]), yOrBlock);
+      return this.setBlockAt(new import_three37.Vector3(posOrX[0], posOrX[1], posOrX[2]), yOrBlock);
     }
     const worldPos = posOrX;
     const pos = this.worldPosToChunkPos(worldPos);
@@ -11072,7 +13632,7 @@ var Chunk = class _Chunk {
   }
   async clear(onBlocksChanged = this.onBlocksChanged) {
     const positions = [...this.renderedBlocks.keys()].map((index) => this.chunkPosToWorldPos(
-      new import_three32.Vector3(index % 16, Math.floor(index / 256), Math.floor(index / 16) % 16)
+      new import_three37.Vector3(index % 16, Math.floor(index / 256), Math.floor(index / 16) % 16)
     ));
     for (const info of this.renderedBlocks.values()) info.object?.removeFromScene();
     this.sectionBlocks.clear();
@@ -11096,14 +13656,14 @@ var Chunk = class _Chunk {
     return pos.y * 16 * 16 + pos.z * 16 + pos.x;
   }
   worldPosToChunkPos(pos) {
-    return new import_three32.Vector3(
+    return new import_three37.Vector3(
       pos.x - this.x * 16,
       pos.y - this.y * 16,
       pos.z - this.z * 16
     );
   }
   chunkPosToWorldPos(pos) {
-    return new import_three32.Vector3(
+    return new import_three37.Vector3(
       this.x * 16 + pos.x,
       this.y * 16 + pos.y,
       this.z * 16 + pos.z