minerender 2.1.0-alpha.65 → 2.1.0-alpha.67

package/dist/browser/index.js

@@ -2922,16 +2922,17 @@ var init_UVMapper = __esm({
               positions[textureKey] = [x, y];
               const [width, height] = sizes[textureKey];
               const sequence = frames[textureKey];
-              const drawFrame = (index) => {
+              const getFrameData = (index) => {
                 const columns = texture.width / width;
-                image.putData(texture.getSectionData(
+                return texture.getSectionData(
                   index % columns * width,
                   Math.floor(index / columns) * height,
                   width,
                   height
-                ), x, y);
+                );
               };
-              drawFrame(sequence?.[0].index ?? 0);
+              const firstFrame = getFrameData(sequence?.[0].index ?? 0);
+              image.putData(firstFrame, x, y);
               if (texture.hasTransparency) {
                 hasTransparency = true;
               }
@@ -2939,13 +2940,28 @@ var init_UVMapper = __esm({
                 hasAnimation = true;
                 let t = 0;
                 let f = 0;
+                const interpolated = metaMap[textureKey]?.animation?.interpolate ? image.context.createImageData(width, height) : void 0;
+                let currentFrame = firstFrame;
+                let nextFrame = interpolated ? getFrameData(sequence[1].index) : firstFrame;
                 animatorFunctions[textureKey] = () => {
-                  if (++t < sequence[f].time) return false;
-                  t = 0;
-                  const previous = sequence[f].index;
-                  f = (f + 1) % sequence.length;
-                  if (sequence[f].index === previous) return false;
-                  drawFrame(sequence[f].index);
+                  if (++t >= sequence[f].time) {
+                    t = 0;
+                    const previous = sequence[f].index;
+                    f = (f + 1) % sequence.length;
+                    if (interpolated) {
+                      currentFrame = nextFrame;
+                      nextFrame = getFrameData(sequence[(f + 1) % sequence.length].index);
+                    }
+                    if (sequence[f].index === previous) return false;
+                    image.putData(interpolated ? currentFrame : getFrameData(sequence[f].index), x, y);
+                    return true;
+                  }
+                  if (!interpolated || sequence[f].index === sequence[(f + 1) % sequence.length].index) return false;
+                  const progress = Math.floor(Math.fround(Math.fround(t / sequence[f].time) * 1e3)) / 1e3;
+                  for (let i = 0; i < interpolated.data.length; i++) {
+                    interpolated.data[i] = currentFrame.data[i] + (nextFrame.data[i] - currentFrame.data[i]) * progress;
+                  }
+                  image.putData(interpolated, x, y);
                   return true;
                 };
               }
@@ -3926,6 +3942,7 @@ var init_SceneObject = __esm({
       dispose() {
         this.disposeAndRemoveAllChildren();
         this.notifyDirty();
+        super.dispose();
       }
       disposeAndRemoveAllChildren() {
         if (this.instanceMesh) {
@@ -4143,6 +4160,7 @@ var init_EntityObject = __esm({
             else matrix.makeRotationFromEuler(new import_three14.Euler(...op.rotate, "ZYX"));
             modelRoot.matrix.multiply(matrix);
           }
+          modelRoot.matrixWorldNeedsUpdate = true;
           modelRoot.matrixAutoUpdate = false;
         } else if (this.options.flip ?? true) {
           modelRoot.scale.set(-1, -1, 1);
@@ -4240,7 +4258,7 @@ function mergeBufferGeometries(geometries, useGroups = false) {
   const attributes = {};
   const morphAttributes = {};
   const morphTargetsRelative = geometries[0].morphTargetsRelative;
-  const mergedGeometry = new import_three21.BufferGeometry();
+  const mergedGeometry = new import_three20.BufferGeometry();
   let offset = 0;
   for (let i = 0; i < geometries.length; ++i) {
     const geometry = geometries[i];
@@ -4364,7 +4382,7 @@ function mergeBufferAttributes(attributes) {
     array.set(attributes[i].array, offset);
     offset += attributes[i].array.length;
   }
-  return new import_three21.BufferAttribute(array, itemSize, normalized);
+  return new import_three20.BufferAttribute(array, itemSize, normalized);
 }
 function interleaveAttributes(attributes) {
   let TypedArray;
@@ -4380,7 +4398,7 @@ function interleaveAttributes(attributes) {
     arrayLength += attribute.array.length;
     stride += attribute.itemSize;
   }
-  const interleavedBuffer = new import_three21.InterleavedBuffer(new TypedArray(arrayLength), stride);
+  const interleavedBuffer = new import_three20.InterleavedBuffer(new TypedArray(arrayLength), stride);
   let offset = 0;
   const res = [];
   const getters = ["getX", "getY", "getZ", "getW"];
@@ -4389,7 +4407,7 @@ function interleaveAttributes(attributes) {
     const attribute = attributes[j];
     const itemSize = attribute.itemSize;
     const count = attribute.count;
-    const iba = new import_three21.InterleavedBufferAttribute(interleavedBuffer, itemSize, offset, attribute.normalized);
+    const iba = new import_three20.InterleavedBufferAttribute(interleavedBuffer, itemSize, offset, attribute.normalized);
     res.push(iba);
     offset += itemSize;
     for (let c = 0; c < count; c++) {
@@ -4473,13 +4491,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_three21.BufferAttribute(buffer, oldAttribute.itemSize, oldAttribute.normalized);
+    const attribute = new import_three20.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_three21.BufferAttribute(buffer2, oldMorphAttribute.itemSize, oldMorphAttribute.normalized);
+        const morphAttribute = new import_three20.BufferAttribute(buffer2, oldMorphAttribute.itemSize, oldMorphAttribute.normalized);
         result.morphAttributes[name][j] = morphAttribute;
       }
     }
@@ -4488,11 +4506,11 @@ function mergeVertices(geometry, tolerance = 1e-4) {
   return result;
 }
 function toTrianglesDrawMode(geometry, drawMode) {
-  if (drawMode === import_three21.TrianglesDrawMode) {
+  if (drawMode === import_three20.TrianglesDrawMode) {
     console.warn("THREE.BufferGeometryUtils.toTrianglesDrawMode(): Geometry already defined as triangles.");
     return geometry;
   }
-  if (drawMode === import_three21.TriangleFanDrawMode || drawMode === import_three21.TriangleStripDrawMode) {
+  if (drawMode === import_three20.TriangleFanDrawMode || drawMode === import_three20.TriangleStripDrawMode) {
     let index = geometry.getIndex();
     if (index === null) {
       const indices = [];
@@ -4510,7 +4528,7 @@ function toTrianglesDrawMode(geometry, drawMode) {
     }
     const numberOfTriangles = index.count - 2;
     const newIndices = [];
-    if (drawMode === import_three21.TriangleFanDrawMode) {
+    if (drawMode === import_three20.TriangleFanDrawMode) {
       for (let i = 1; i <= numberOfTriangles; i++) {
         newIndices.push(index.getX(0));
         newIndices.push(index.getX(i));
@@ -4546,15 +4564,15 @@ function computeMorphedAttributes(object) {
     console.error("THREE.BufferGeometryUtils: Geometry is not of type BufferGeometry.");
     return null;
   }
-  const _vA = new import_three21.Vector3();
-  const _vB = new import_three21.Vector3();
-  const _vC = new import_three21.Vector3();
-  const _tempA = new import_three21.Vector3();
-  const _tempB = new import_three21.Vector3();
-  const _tempC = new import_three21.Vector3();
-  const _morphA = new import_three21.Vector3();
-  const _morphB = new import_three21.Vector3();
-  const _morphC = new import_three21.Vector3();
+  const _vA = new import_three20.Vector3();
+  const _vB = new import_three20.Vector3();
+  const _vC = new import_three20.Vector3();
+  const _tempA = new import_three20.Vector3();
+  const _tempB = new import_three20.Vector3();
+  const _tempC = new import_three20.Vector3();
+  const _morphA = new import_three20.Vector3();
+  const _morphB = new import_three20.Vector3();
+  const _morphC = new import_three20.Vector3();
   function _calculateMorphedAttributeData(object2, material2, attribute, morphAttribute, morphTargetsRelative2, a2, b2, c2, modifiedAttributeArray) {
     _vA.fromBufferAttribute(attribute, a2);
     _vB.fromBufferAttribute(attribute, b2);
@@ -4749,8 +4767,8 @@ function computeMorphedAttributes(object) {
       }
     }
   }
-  const morphedPositionAttribute = new import_three21.Float32BufferAttribute(modifiedPosition, 3);
-  const morphedNormalAttribute = new import_three21.Float32BufferAttribute(modifiedNormal, 3);
+  const morphedPositionAttribute = new import_three20.Float32BufferAttribute(modifiedPosition, 3);
+  const morphedNormalAttribute = new import_three20.Float32BufferAttribute(modifiedNormal, 3);
   return {
     positionAttribute,
     normalAttribute,
@@ -4758,24 +4776,24 @@ function computeMorphedAttributes(object) {
     morphedNormalAttribute
   };
 }
-var import_three21;
+var import_three20;
 var init_BufferGeometryUtils = __esm({
   "src/three/BufferGeometryUtils.js"() {
-    import_three21 = require("three");
+    import_three20 = require("three");
   }
 });
 
 // src/model/ModelCulling.ts
-var import_three22, ModelCulling;
+var import_three21, ModelCulling;
 var init_ModelCulling = __esm({
   "src/model/ModelCulling.ts"() {
-    import_three22 = require("three");
+    import_three21 = 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_three22.Vector3(...offset).applyEuler(rotation);
+          const normal = new import_three21.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;
@@ -4808,10 +4826,10 @@ var init_ModelCulling = __esm({
 });
 
 // src/model/SpecialItems.ts
-var import_three23, SpecialItems;
+var import_three22, SpecialItems;
 var init_SpecialItems = __esm({
   "src/model/SpecialItems.ts"() {
-    import_three23 = require("three");
+    import_three22 = require("three");
     init_AssetKey();
     init_Entities();
     SpecialItems = class {
@@ -4839,7 +4857,7 @@ var init_SpecialItems = __esm({
           case "minecraft:chest":
           case "chest": {
             const angle = -(special.openness ?? 0) * Math.PI / 2;
-            const chest = await load("chest", texture(special.texture, "chest"), new import_three23.Matrix4(), {
+            const chest = await load("chest", texture(special.texture, "chest"), new import_three22.Matrix4(), {
               lid: [angle, 0, 0],
               lock: [angle, 0, 0]
             });
@@ -4848,11 +4866,11 @@ var init_SpecialItems = __esm({
           }
           case "minecraft:bed":
           case "bed": {
-            const transform = new import_three23.Matrix4().makeTranslation(0, 9, 0).multiply(new import_three23.Matrix4().makeRotationX(Math.PI / 2)).multiply(new import_three23.Matrix4().makeTranslation(8, 8, 8)).multiply(new import_three23.Matrix4().makeRotationZ(Math.PI)).multiply(new import_three23.Matrix4().makeTranslation(-8, -8, -8));
+            const transform = new import_three22.Matrix4().makeTranslation(0, 9, 0).multiply(new import_three22.Matrix4().makeRotationX(Math.PI / 2)).multiply(new import_three22.Matrix4().makeTranslation(8, 8, 8)).multiply(new import_three22.Matrix4().makeRotationZ(Math.PI)).multiply(new import_three22.Matrix4().makeTranslation(-8, -8, -8));
             const key = texture(special.texture, "bed");
             return Promise.all([
               load("bed_head", key, transform),
-              load("bed_foot", key, new import_three23.Matrix4().makeTranslation(0, 0, -16).multiply(transform))
+              load("bed_foot", key, new import_three22.Matrix4().makeTranslation(0, 0, -16).multiply(transform))
             ]);
           }
           case "minecraft:head":
@@ -4877,7 +4895,7 @@ var init_SpecialItems = __esm({
             return [await load(
               id,
               special.texture ? texture(special.texture, "") : void 0,
-              new import_three23.Matrix4().makeTranslation(8, 0, 8).multiply(new import_three23.Matrix4().makeScale(-1, -1, 1)),
+              new import_three22.Matrix4().makeTranslation(8, 0, 8).multiply(new import_three22.Matrix4().makeScale(-1, -1, 1)),
               rotations
             )];
           }
@@ -5005,13 +5023,13 @@ var init_ItemTints = __esm({
 function isModelObject(obj) {
   return obj.isModelObject;
 }
-var import_three24, import_ts_deepmerge5, p7, _ModelObject, ModelObject;
+var import_three23, import_ts_deepmerge5, p7, _ModelObject, ModelObject;
 var init_ModelObject = __esm({
   "src/model/scene/ModelObject.ts"() {
     init_SceneObject();
     init_Materials();
     init_UVMapper();
-    import_three24 = require("three");
+    import_three23 = require("three");
     init_BufferGeometryUtils();
     init_model();
     import_ts_deepmerge5 = __toESM(require_dist());
@@ -5043,12 +5061,13 @@ var init_ModelObject = __esm({
         const special = this.originalModel.special;
         if (special) {
           const parts = await SpecialItems.getParts(special, this.originalModel.key?.root);
-          const transform = this.options.displayPosition ? DisplayTransforms.getMatrix(this.originalModel.display, this.options.displayPosition) : new import_three24.Matrix4();
-          transform.multiply(new import_three24.Matrix4().makeTranslation(-8, -8, -8));
+          const transform = this.options.displayPosition ? DisplayTransforms.getMatrix(this.originalModel.display, this.options.displayPosition) : new import_three23.Matrix4();
+          transform.multiply(new import_three23.Matrix4().makeTranslation(-8, -8, -8));
           try {
             for (const part of parts) {
               const object = new EntityObject(part.model, { flip: false, wireframe: this.options.wireframe });
               object.matrix.copy(transform).multiply(part.transform);
+              object.matrixWorldNeedsUpdate = true;
               object.matrixAutoUpdate = false;
               this.add(object);
               await object.init();
@@ -5106,7 +5125,7 @@ var init_ModelObject = __esm({
                 elGeo.clearGroups();
               }
               if (this.options.uvLockRotation) {
-                UVMapper.lockUvs(elGeo, el.faces, this.atlas, new import_three24.Euler(...this.options.uvLockRotation));
+                UVMapper.lockUvs(elGeo, el.faces, this.atlas, new import_three23.Euler(...this.options.uvLockRotation));
               }
               if (this.options.tints) {
                 const colors = new Float32Array(elGeo.getAttribute("position").count * 3).fill(1);
@@ -5115,19 +5134,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_three24.Color(tint);
+                  const color = new import_three23.Color(tint);
                   for (let vertex = 0; vertex < 4; vertex++) {
                     color.toArray(colors, (faceIndex * 4 + vertex) * 3);
                   }
                 }
-                elGeo.setAttribute("color", new import_three24.BufferAttribute(colors, 3));
+                elGeo.setAttribute("color", new import_three23.BufferAttribute(colors, 3));
               }
-              elGeo.applyMatrix4(new import_three24.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_three24.Matrix4().makeTranslation(el.from[0], el.from[1], el.from[2]));
+              elGeo.applyMatrix4(new import_three23.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_three23.Matrix4().makeTranslation(el.from[0], el.from[1], el.from[2]));
               if (el.rotation) {
                 applyElementRotation(el.rotation, elGeo);
               }
-              elGeo.applyMatrix4(new import_three24.Matrix4().makeTranslation(-8, -8, -8));
+              elGeo.applyMatrix4(new import_three23.Matrix4().makeTranslation(-8, -8, -8));
               if (displayTransform) DisplayTransforms.apply(elGeo, displayTransform);
               if (this.options.mergeMeshes) {
                 allGeos.push(elGeo);
@@ -5149,7 +5168,7 @@ var init_ModelObject = __esm({
           if (allGeos.length > 0) {
             combinedGeo = mergeBufferGeometries(allGeos);
           } else {
-            combinedGeo = new import_three24.BoxGeometry(16, 16, 16);
+            combinedGeo = new import_three23.BoxGeometry(16, 16, 16);
             if (displayTransform) DisplayTransforms.apply(combinedGeo, displayTransform);
           }
           combinedGeo.computeBoundingBox();
@@ -5261,7 +5280,7 @@ function ownHeight(sample) {
   return (level === 0 || level >= 8 ? 8 : 8 - level) / 9;
 }
 function createFluidGeometry(kind, sample) {
-  const geometry = new import_three29.BufferGeometry();
+  const geometry = new import_three28.BufferGeometry();
   const positions = [], normals = [], uvs = [], indices = [];
   const self = sample(0, 0, 0);
   const height = (x, z) => {
@@ -5360,16 +5379,16 @@ function createFluidGeometry(kind, sample) {
       1
     );
   }
-  geometry.setAttribute("position", new import_three29.Float32BufferAttribute(positions, 3));
-  geometry.setAttribute("normal", new import_three29.Float32BufferAttribute(normals, 3));
-  geometry.setAttribute("uv", new import_three29.Float32BufferAttribute(uvs, 2));
+  geometry.setAttribute("position", new import_three28.Float32BufferAttribute(positions, 3));
+  geometry.setAttribute("normal", new import_three28.Float32BufferAttribute(normals, 3));
+  geometry.setAttribute("uv", new import_three28.Float32BufferAttribute(uvs, 2));
   geometry.setIndex(indices);
   return geometry;
 }
-var import_three29, fluidRules, HORIZONTAL, EPSILON;
+var import_three28, fluidRules, HORIZONTAL, EPSILON;
 var init_FluidGeometry = __esm({
   "src/model/fluid/FluidGeometry.ts"() {
-    import_three29 = require("three");
+    import_three28 = require("three");
     init_fluidBlocks();
     fluidRules = fluidBlocks_default;
     HORIZONTAL = [[0, -1], [0, 1], [-1, 0], [1, 0]];
@@ -5398,10 +5417,10 @@ function sampleFluid(kind, sample) {
   }
   return { key: key.join(""), sample: (x, y, z) => cells[(y + 1) * 9 + (z + 1) * 3 + x + 1] };
 }
-var import_three30, FluidModelObject;
+var import_three29, FluidModelObject;
 var init_FluidModelObject = __esm({
   "src/model/fluid/FluidModelObject.ts"() {
-    import_three30 = require("three");
+    import_three29 = require("three");
     init_AssetKey();
     init_Materials();
     init_ModelObject();
@@ -5434,10 +5453,10 @@ var init_FluidModelObject = __esm({
           }
         }
         geometry.clearGroups();
-        const color = new import_three30.Color(this.options.tints?.[0] ?? (this.kind === "water" ? 4159204 : 16777215));
+        const color = new import_three29.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_three30.BufferAttribute(colors, 3));
+        geometry.setAttribute("color", new import_three29.BufferAttribute(colors, 3));
         geometry.computeBoundingBox();
         geometry.computeBoundingSphere();
         if (this.options.instanceMeshes) {
@@ -5451,7 +5470,7 @@ var init_FluidModelObject = __esm({
         super.applyTextures();
         this.iterateAllMeshes((mesh) => {
           const material = mesh.material;
-          material.side = import_three30.DoubleSide;
+          material.side = import_three29.DoubleSide;
           material.forceSinglePass = true;
           material.depthWrite = !material.transparent;
         });
@@ -5938,11 +5957,19 @@ init_EntityObject();
 init_MineRenderError();
 
 // src/export/SceneExporter.ts
-var import_three20 = require("three");
+var import_three19 = require("three");
 
 // ../../node_modules/three/examples/jsm/exporters/OBJExporter.js
 var import_three16 = require("three");
 var OBJExporter = class {
+  /**
+   * Parses the given 3D object and generates the OBJ output.
+   *
+   * If the 3D object is composed of multiple children and geometry, they are merged into a single mesh in the file.
+   *
+   * @param {Object3D} object - The 3D object to export.
+   * @return {string} The exported OBJ.
+   */
   parse(object) {
     let output = "";
     let indexVertex = 0;
@@ -6048,7 +6075,8 @@ var OBJExporter = class {
           vertex.applyMatrix4(points.matrixWorld);
           output += "v " + vertex.x + " " + vertex.y + " " + vertex.z;
           if (colors !== void 0) {
-            color.fromBufferAttribute(colors, i).convertLinearToSRGB();
+            color.fromBufferAttribute(colors, i);
+            import_three16.ColorManagement.workingToColorSpace(color, import_three16.SRGBColorSpace);
             output += " " + color.r + " " + color.g + " " + color.b;
           }
           output += "\n";
@@ -6079,6 +6107,16 @@ var OBJExporter = class {
 // ../../node_modules/three/examples/jsm/exporters/PLYExporter.js
 var import_three17 = require("three");
 var PLYExporter = class {
+  /**
+   * Parses the given 3D object and generates the PLY output.
+   *
+   * If the 3D object is composed of multiple children and geometry, they are merged into a single mesh in the file.
+   *
+   * @param {Object3D} object - The 3D object to export.
+   * @param {PLYExporter~OnDone} onDone - A callback function that is executed when the export has finished.
+   * @param {PLYExporter~Options} options - The export options.
+   * @return {?(string|ArrayBuffer)} The exported PLY.
+   */
   parse(object, onDone, options = {}) {
     function traverseMeshes(cb) {
       object.traverse(function(child) {
@@ -6095,14 +6133,23 @@ var PLYExporter = class {
       binary: false,
       excludeAttributes: [],
       // normal, uv, color, index
-      littleEndian: false
+      littleEndian: false,
+      customPropertyMapping: {}
     };
     options = Object.assign(defaultOptions, options);
     const excludeAttributes = options.excludeAttributes;
+    const customPropertyMapping = options.customPropertyMapping;
+    const customAttributeNames = Object.keys(customPropertyMapping);
     let includeIndices = true;
     let includeNormals = false;
     let includeColors = false;
     let includeUVs = false;
+    let positionType = "float";
+    let normalType = "float";
+    let uvType = "float";
+    let colorType = "uchar";
+    const customTypes = {};
+    for (const name of customAttributeNames) customTypes[name] = "float";
     let vertexCount = 0;
     let faceCount = 0;
     object.traverse(function(child) {
@@ -6119,9 +6166,23 @@ var PLYExporter = class {
         }
         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;
+        positionType = getPlyType(vertices.array);
+        if (normals !== void 0) {
+          includeNormals = true;
+          normalType = getPlyType(normals.array);
+        }
+        if (uvs !== void 0) {
+          includeUVs = true;
+          uvType = getPlyType(uvs.array);
+        }
+        if (colors !== void 0) {
+          includeColors = true;
+          colorType = getPlyType(colors.array);
+        }
+        for (const name of customAttributeNames) {
+          const attr = geometry.getAttribute(name);
+          if (attr !== void 0) customTypes[name] = getPlyType(attr.array);
+        }
       } else if (child.isPoints) {
         const mesh = child;
         const geometry = mesh.geometry;
@@ -6129,8 +6190,19 @@ var PLYExporter = class {
         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;
+        positionType = getPlyType(vertices.array);
+        if (normals !== void 0) {
+          includeNormals = true;
+          normalType = getPlyType(normals.array);
+        }
+        if (colors !== void 0) {
+          includeColors = true;
+          colorType = getPlyType(colors.array);
+        }
+        for (const name of customAttributeNames) {
+          const attr = geometry.getAttribute(name);
+          if (attr !== void 0) customTypes[name] = getPlyType(attr.array);
+        }
         includeIndices = false;
       }
     });
@@ -6149,18 +6221,33 @@ var PLYExporter = class {
     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
+property ${positionType} x
+property ${positionType} y
+property ${positionType} z
 `;
     if (includeNormals === true) {
-      header += "property float nx\nproperty float ny\nproperty float nz\n";
+      header += `property ${normalType} nx
+property ${normalType} ny
+property ${normalType} nz
+`;
     }
     if (includeUVs === true) {
-      header += "property float s\nproperty float t\n";
+      header += `property ${uvType} s
+property ${uvType} t
+`;
     }
     if (includeColors === true) {
-      header += "property uchar red\nproperty uchar green\nproperty uchar blue\n";
+      header += `property ${colorType} red
+property ${colorType} green
+property ${colorType} blue
+`;
+    }
+    for (const name of customAttributeNames) {
+      const type = customTypes[name];
+      for (const propName of customPropertyMapping[name]) {
+        header += `property ${type} ${propName}
+`;
+      }
     }
     if (includeIndices === true) {
       header += `element face ${faceCount}
@@ -6173,7 +6260,23 @@ property list uchar int vertex_index
     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 posWriter = getBinaryWriter(positionType);
+      const normalWriter = includeNormals ? getBinaryWriter(normalType) : null;
+      const uvWriter = includeUVs ? getBinaryWriter(uvType) : null;
+      const colorWriter = includeColors ? getBinaryWriter(colorType) : null;
+      const colorIsFloat = isFloatType(colorType);
+      const colorScale = getColorScale(colorType);
+      const customWriters = {};
+      const customIsFloat = {};
+      let customStride = 0;
+      for (const name of customAttributeNames) {
+        const type = customTypes[name];
+        const writer = getBinaryWriter(type);
+        customWriters[name] = writer;
+        customIsFloat[name] = isFloatType(type);
+        customStride += customPropertyMapping[name].length * writer.size;
+      }
+      const vertexListLength = vertexCount * (3 * posWriter.size + (includeNormals ? 3 * normalWriter.size : 0) + (includeUVs ? 2 * uvWriter.size : 0) + (includeColors ? 3 * colorWriter.size : 0) + customStride);
       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);
@@ -6190,60 +6293,76 @@ property list uchar int vertex_index
         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;
+          posWriter.write(output, vOffset, vertex.x, options.littleEndian);
+          vOffset += posWriter.size;
+          posWriter.write(output, vOffset, vertex.y, options.littleEndian);
+          vOffset += posWriter.size;
+          posWriter.write(output, vOffset, vertex.z, options.littleEndian);
+          vOffset += posWriter.size;
           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;
+              normalWriter.write(output, vOffset, vertex.x, options.littleEndian);
+              vOffset += normalWriter.size;
+              normalWriter.write(output, vOffset, vertex.y, options.littleEndian);
+              vOffset += normalWriter.size;
+              normalWriter.write(output, vOffset, vertex.z, options.littleEndian);
+              vOffset += normalWriter.size;
             } 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;
+              normalWriter.write(output, vOffset, 0, options.littleEndian);
+              vOffset += normalWriter.size;
+              normalWriter.write(output, vOffset, 0, options.littleEndian);
+              vOffset += normalWriter.size;
+              normalWriter.write(output, vOffset, 0, options.littleEndian);
+              vOffset += normalWriter.size;
             }
           }
           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;
+              uvWriter.write(output, vOffset, uvs.getX(i), options.littleEndian);
+              vOffset += uvWriter.size;
+              uvWriter.write(output, vOffset, uvs.getY(i), options.littleEndian);
+              vOffset += uvWriter.size;
             } else {
-              output.setFloat32(vOffset, 0, options.littleEndian);
-              vOffset += 4;
-              output.setFloat32(vOffset, 0, options.littleEndian);
-              vOffset += 4;
+              uvWriter.write(output, vOffset, 0, options.littleEndian);
+              vOffset += uvWriter.size;
+              uvWriter.write(output, vOffset, 0, options.littleEndian);
+              vOffset += uvWriter.size;
             }
           }
           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;
+              tempColor.fromBufferAttribute(colors, i);
+              import_three17.ColorManagement.workingToColorSpace(tempColor, import_three17.SRGBColorSpace);
+              const r = colorIsFloat ? tempColor.r : Math.round(tempColor.r * colorScale);
+              const g = colorIsFloat ? tempColor.g : Math.round(tempColor.g * colorScale);
+              const b = colorIsFloat ? tempColor.b : Math.round(tempColor.b * colorScale);
+              colorWriter.write(output, vOffset, r, options.littleEndian);
+              vOffset += colorWriter.size;
+              colorWriter.write(output, vOffset, g, options.littleEndian);
+              vOffset += colorWriter.size;
+              colorWriter.write(output, vOffset, b, options.littleEndian);
+              vOffset += colorWriter.size;
             } else {
-              output.setUint8(vOffset, 255);
-              vOffset += 1;
-              output.setUint8(vOffset, 255);
-              vOffset += 1;
-              output.setUint8(vOffset, 255);
-              vOffset += 1;
+              const white = colorIsFloat ? 1 : colorScale;
+              colorWriter.write(output, vOffset, white, options.littleEndian);
+              vOffset += colorWriter.size;
+              colorWriter.write(output, vOffset, white, options.littleEndian);
+              vOffset += colorWriter.size;
+              colorWriter.write(output, vOffset, white, options.littleEndian);
+              vOffset += colorWriter.size;
+            }
+          }
+          for (const name of customAttributeNames) {
+            const writer = customWriters[name];
+            const propCount = customPropertyMapping[name].length;
+            const attr = geometry.getAttribute(name);
+            const isFloat = customIsFloat[name];
+            for (let c = 0; c < propCount; c++) {
+              const raw = attr != null ? getAttributeComponent(attr, i, c) : 0;
+              writer.write(output, vOffset, isFloat ? raw : Math.round(raw), options.littleEndian);
+              vOffset += writer.size;
             }
           }
         }
@@ -6279,6 +6398,14 @@ property list uchar int vertex_index
       let writtenVertices = 0;
       let vertexList = "";
       let faceList = "";
+      const positionIsFloat = isFloatType(positionType);
+      const normalIsFloat = isFloatType(normalType);
+      const uvIsFloat = isFloatType(uvType);
+      const colorIsFloat = isFloatType(colorType);
+      const colorScale = getColorScale(colorType);
+      const customIsFloat = {};
+      for (const name of customAttributeNames) customIsFloat[name] = isFloatType(customTypes[name]);
+      const encode = (v, isFloat) => isFloat ? v : Math.round(v);
       traverseMeshes(function(mesh, geometry) {
         const vertices = geometry.getAttribute("position");
         const normals = geometry.getAttribute("normal");
@@ -6289,29 +6416,43 @@ property list uchar int vertex_index
         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;
+          let line = encode(vertex.x, positionIsFloat) + " " + encode(vertex.y, positionIsFloat) + " " + encode(vertex.z, positionIsFloat);
           if (includeNormals === true) {
             if (normals != null) {
               vertex.fromBufferAttribute(normals, i);
               vertex.applyMatrix3(normalMatrixWorld).normalize();
-              line += " " + vertex.x + " " + vertex.y + " " + vertex.z;
+              line += " " + encode(vertex.x, normalIsFloat) + " " + encode(vertex.y, normalIsFloat) + " " + encode(vertex.z, normalIsFloat);
             } else {
               line += " 0 0 0";
             }
           }
           if (includeUVs === true) {
             if (uvs != null) {
-              line += " " + uvs.getX(i) + " " + uvs.getY(i);
+              line += " " + encode(uvs.getX(i), uvIsFloat) + " " + encode(uvs.getY(i), uvIsFloat);
             } 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);
+              tempColor.fromBufferAttribute(colors, i);
+              import_three17.ColorManagement.workingToColorSpace(tempColor, import_three17.SRGBColorSpace);
+              const r = colorIsFloat ? tempColor.r : Math.round(tempColor.r * colorScale);
+              const g = colorIsFloat ? tempColor.g : Math.round(tempColor.g * colorScale);
+              const b = colorIsFloat ? tempColor.b : Math.round(tempColor.b * colorScale);
+              line += ` ${r} ${g} ${b}`;
             } else {
-              line += " 255 255 255";
+              const white = colorIsFloat ? 1 : colorScale;
+              line += ` ${white} ${white} ${white}`;
+            }
+          }
+          for (const name of customAttributeNames) {
+            const propCount = customPropertyMapping[name].length;
+            const attr = geometry.getAttribute(name);
+            const isFloat = customIsFloat[name];
+            for (let c = 0; c < propCount; c++) {
+              const raw = attr != null ? getAttributeComponent(attr, i, c) : 0;
+              line += " " + encode(raw, isFloat);
             }
           }
           vertexList += line + "\n";
@@ -6341,70 +6482,65 @@ property list uchar int vertex_index
     return result;
   }
 };
-
-// ../../node_modules/three/examples/jsm/exporters/GLTFExporter.js
-var import_three19 = require("three");
-
-// ../../node_modules/three/examples/jsm/utils/TextureUtils.js
-var import_three18 = require("three");
-var _renderer;
-var fullscreenQuadGeometry;
-var fullscreenQuadMaterial;
-var fullscreenQuad;
-function decompress(texture, maxTextureSize = Infinity, renderer = null) {
-  if (!fullscreenQuadGeometry) fullscreenQuadGeometry = new import_three18.PlaneGeometry(2, 2, 1, 1);
-  if (!fullscreenQuadMaterial) fullscreenQuadMaterial = new import_three18.ShaderMaterial({
-    uniforms: { blitTexture: new import_three18.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_three18.SRGBColorSpace;
-  fullscreenQuadMaterial.needsUpdate = true;
-  if (!fullscreenQuad) {
-    fullscreenQuad = new import_three18.Mesh(fullscreenQuadGeometry, fullscreenQuadMaterial);
-    fullscreenQuad.frustrumCulled = false;
-  }
-  const _camera = new import_three18.PerspectiveCamera();
-  const _scene = new import_three18.Scene();
-  _scene.add(fullscreenQuad);
-  if (!renderer) {
-    renderer = _renderer = new import_three18.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_three18.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;
+function getPlyType(array) {
+  if (array instanceof Int8Array) return "char";
+  if (array instanceof Uint8Array || array instanceof Uint8ClampedArray) return "uchar";
+  if (array instanceof Int16Array) return "short";
+  if (array instanceof Uint16Array) return "ushort";
+  if (array instanceof Int32Array) return "int";
+  if (array instanceof Uint32Array) return "uint";
+  if (array instanceof Float32Array) return "float";
+  if (array instanceof Float64Array) return "double";
+  return "float";
+}
+function getBinaryWriter(type) {
+  switch (type) {
+    case "char":
+      return { write: (dv, at, v) => dv.setInt8(at, v), size: 1 };
+    case "uchar":
+      return { write: (dv, at, v) => dv.setUint8(at, v), size: 1 };
+    case "short":
+      return { write: (dv, at, v, le) => dv.setInt16(at, v, le), size: 2 };
+    case "ushort":
+      return { write: (dv, at, v, le) => dv.setUint16(at, v, le), size: 2 };
+    case "int":
+      return { write: (dv, at, v, le) => dv.setInt32(at, v, le), size: 4 };
+    case "uint":
+      return { write: (dv, at, v, le) => dv.setUint32(at, v, le), size: 4 };
+    case "float":
+      return { write: (dv, at, v, le) => dv.setFloat32(at, v, le), size: 4 };
+    case "double":
+      return { write: (dv, at, v, le) => dv.setFloat64(at, v, le), size: 8 };
+  }
+}
+function isFloatType(type) {
+  return type === "float" || type === "double";
+}
+function getAttributeComponent(attr, i, c) {
+  switch (c) {
+    case 0:
+      return attr.getX(i);
+    case 1:
+      return attr.getY(i);
+    case 2:
+      return attr.getZ(i);
+    case 3:
+      return attr.getW(i);
+  }
+}
+function getColorScale(type) {
+  switch (type) {
+    case "uchar":
+      return 255;
+    case "ushort":
+      return 65535;
+    default:
+      return 1;
+  }
 }
 
 // ../../node_modules/three/examples/jsm/exporters/GLTFExporter.js
+var import_three18 = require("three");
 var KHR_mesh_quantization_ExtraAttrTypes = {
   POSITION: [
     "byte",
@@ -6434,7 +6570,11 @@ var KHR_mesh_quantization_ExtraAttrTypes = {
   ]
 };
 var GLTFExporter = class {
+  /**
+   * Constructs a new glTF exporter.
+   */
   constructor() {
+    this.textureUtils = null;
     this.pluginCallbacks = [];
     this.register(function(writer) {
       return new GLTFLightExtension(writer);
@@ -6457,6 +6597,9 @@ var GLTFExporter = class {
     this.register(function(writer) {
       return new GLTFMaterialsClearcoatExtension(writer);
     });
+    this.register(function(writer) {
+      return new GLTFMaterialsDispersionExtension(writer);
+    });
     this.register(function(writer) {
       return new GLTFMaterialsIridescenceExtension(writer);
     });
@@ -6469,16 +6612,33 @@ var GLTFExporter = class {
     this.register(function(writer) {
       return new GLTFMaterialsEmissiveStrengthExtension(writer);
     });
+    this.register(function(writer) {
+      return new GLTFMaterialsBumpExtension(writer);
+    });
     this.register(function(writer) {
       return new GLTFMeshGpuInstancing(writer);
     });
   }
+  /**
+   * Registers a plugin callback. This API is internally used to implement the various
+   * glTF extensions but can also used by third-party code to add additional logic
+   * to the exporter.
+   *
+   * @param {function(writer:GLTFWriter)} callback - The callback function to register.
+   * @return {GLTFExporter} A reference to this exporter.
+   */
   register(callback) {
     if (this.pluginCallbacks.indexOf(callback) === -1) {
       this.pluginCallbacks.push(callback);
     }
     return this;
   }
+  /**
+   * Unregisters a plugin callback.
+   *
+   * @param {Function} callback - The callback function to unregister.
+   * @return {GLTFExporter} A reference to this exporter.
+   */
   unregister(callback) {
     if (this.pluginCallbacks.indexOf(callback) !== -1) {
       this.pluginCallbacks.splice(this.pluginCallbacks.indexOf(callback), 1);
@@ -6486,11 +6646,25 @@ var GLTFExporter = class {
     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
+   * Sets the texture utils for this exporter. Only relevant when compressed textures have to be exported.
+   *
+   * Depending on whether you use {@link WebGLRenderer} or {@link WebGPURenderer}, you must inject the
+   * corresponding texture utils {@link module:WebGLTextureUtils} or {@link module:WebGPUTextureUtils}.
+   *
+   * @param {WebGLTextureUtils|WebGPUTextureUtils} utils - The texture utils.
+   * @return {GLTFExporter} A reference to this exporter.
+   */
+  setTextureUtils(utils) {
+    this.textureUtils = utils;
+    return this;
+  }
+  /**
+   * Parses the given scenes and generates the glTF output.
+   *
+   * @param {Scene|Array<Scene>} input - A scene or an array of scenes.
+   * @param {GLTFExporter~OnDone} onDone - A callback function that is executed when the export has finished.
+   * @param {GLTFExporter~OnError} onError - A callback function that is executed when an error happens.
+   * @param {GLTFExporter~Options} options - options
    */
   parse(input, onDone, onError, options) {
     const writer = new GLTFWriter();
@@ -6499,8 +6673,16 @@ var GLTFExporter = class {
       plugins.push(this.pluginCallbacks[i](writer));
     }
     writer.setPlugins(plugins);
-    writer.write(input, onDone, options).catch(onError);
+    writer.setTextureUtils(this.textureUtils);
+    writer.writeAsync(input, onDone, options).catch(onError);
   }
+  /**
+   * Async version of {@link GLTFExporter#parse}.
+   *
+   * @param {Scene|Array<Scene>} input - A scene or an array of scenes.
+   * @param {GLTFExporter~Options} options - options.
+   * @return {Promise<ArrayBuffer|string>} A Promise that resolved with the exported glTF data.
+   */
   parseAsync(input, options) {
     const scope = this;
     return new Promise(function(resolve, reject) {
@@ -6537,22 +6719,22 @@ var WEBGL_CONSTANTS = {
 };
 var KHR_MESH_QUANTIZATION = "KHR_mesh_quantization";
 var THREE_TO_WEBGL = {};
-THREE_TO_WEBGL[import_three19.NearestFilter] = WEBGL_CONSTANTS.NEAREST;
-THREE_TO_WEBGL[import_three19.NearestMipmapNearestFilter] = WEBGL_CONSTANTS.NEAREST_MIPMAP_NEAREST;
-THREE_TO_WEBGL[import_three19.NearestMipmapLinearFilter] = WEBGL_CONSTANTS.NEAREST_MIPMAP_LINEAR;
-THREE_TO_WEBGL[import_three19.LinearFilter] = WEBGL_CONSTANTS.LINEAR;
-THREE_TO_WEBGL[import_three19.LinearMipmapNearestFilter] = WEBGL_CONSTANTS.LINEAR_MIPMAP_NEAREST;
-THREE_TO_WEBGL[import_three19.LinearMipmapLinearFilter] = WEBGL_CONSTANTS.LINEAR_MIPMAP_LINEAR;
-THREE_TO_WEBGL[import_three19.ClampToEdgeWrapping] = WEBGL_CONSTANTS.CLAMP_TO_EDGE;
-THREE_TO_WEBGL[import_three19.RepeatWrapping] = WEBGL_CONSTANTS.REPEAT;
-THREE_TO_WEBGL[import_three19.MirroredRepeatWrapping] = WEBGL_CONSTANTS.MIRRORED_REPEAT;
+THREE_TO_WEBGL[import_three18.NearestFilter] = WEBGL_CONSTANTS.NEAREST;
+THREE_TO_WEBGL[import_three18.NearestMipmapNearestFilter] = WEBGL_CONSTANTS.NEAREST_MIPMAP_NEAREST;
+THREE_TO_WEBGL[import_three18.NearestMipmapLinearFilter] = WEBGL_CONSTANTS.NEAREST_MIPMAP_LINEAR;
+THREE_TO_WEBGL[import_three18.LinearFilter] = WEBGL_CONSTANTS.LINEAR;
+THREE_TO_WEBGL[import_three18.LinearMipmapNearestFilter] = WEBGL_CONSTANTS.LINEAR_MIPMAP_NEAREST;
+THREE_TO_WEBGL[import_three18.LinearMipmapLinearFilter] = WEBGL_CONSTANTS.LINEAR_MIPMAP_LINEAR;
+THREE_TO_WEBGL[import_three18.ClampToEdgeWrapping] = WEBGL_CONSTANTS.CLAMP_TO_EDGE;
+THREE_TO_WEBGL[import_three18.RepeatWrapping] = WEBGL_CONSTANTS.REPEAT;
+THREE_TO_WEBGL[import_three18.MirroredRepeatWrapping] = WEBGL_CONSTANTS.MIRRORED_REPEAT;
 var PATH_PROPERTIES = {
   scale: "scale",
   position: "translation",
   quaternion: "rotation",
   morphTargetInfluences: "weights"
 };
-var DEFAULT_SPECULAR_COLOR = new import_three19.Color();
+var DEFAULT_SPECULAR_COLOR = new import_three18.Color();
 var GLB_HEADER_BYTES = 12;
 var GLB_HEADER_MAGIC = 1179937895;
 var GLB_VERSION = 2;
@@ -6586,7 +6768,7 @@ function getMinMax(attribute, start, count) {
         else if (a === 2) value = attribute.getZ(i);
         else if (a === 3) value = attribute.getW(i);
         if (attribute.normalized === true) {
-          value = import_three19.MathUtils.normalize(value, attribute.array);
+          value = import_three18.MathUtils.normalize(value, attribute.array);
         }
       }
       output.min[a] = Math.min(output.min[a], value);
@@ -6619,19 +6801,20 @@ function getCanvas() {
   return document.createElement("canvas");
 }
 function getToBlobPromise(canvas, mimeType) {
-  if (canvas.toBlob !== void 0) {
+  if (typeof OffscreenCanvas !== "undefined" && canvas instanceof OffscreenCanvas) {
+    let quality;
+    if (mimeType === "image/jpeg") {
+      quality = 0.92;
+    } else if (mimeType === "image/webp") {
+      quality = 0.8;
+    }
+    return canvas.convertToBlob({
+      type: mimeType,
+      quality
+    });
+  } else {
     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() {
@@ -6650,7 +6833,7 @@ var GLTFWriter = class {
     this.json = {
       asset: {
         version: "2.0",
-        generator: "THREE.GLTFExporter"
+        generator: "THREE.GLTFExporter r" + import_three18.REVISION
       }
     };
     this.cache = {
@@ -6659,19 +6842,25 @@ var GLTFWriter = class {
       attributesNormalized: /* @__PURE__ */ new Map(),
       materials: /* @__PURE__ */ new Map(),
       textures: /* @__PURE__ */ new Map(),
-      images: /* @__PURE__ */ new Map()
+      images: /* @__PURE__ */ new Map(),
+      normalMaps: /* @__PURE__ */ new Map()
     };
+    this.textureUtils = null;
   }
   setPlugins(plugins) {
     this.plugins = plugins;
   }
+  setTextureUtils(utils) {
+    this.textureUtils = utils;
+  }
   /**
    * 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
+   *
+   * @param {Scene|Array<Scene>} input Scene or Array of THREE.Scenes
+   * @param {Function} onDone Callback on completed
+   * @param {Object} options options
    */
-  async write(input, onDone, options = {}) {
+  async writeAsync(input, onDone, options = {}) {
     this.options = Object.assign({
       // default options
       binary: false,
@@ -6679,12 +6868,13 @@ var GLTFWriter = class {
       onlyVisible: true,
       maxTextureSize: Infinity,
       animations: [],
-      includeCustomExtensions: false
+      includeCustomExtensions: false,
+      copyright: null
     }, options);
     if (this.options.animations.length > 0) {
       this.options.trs = true;
     }
-    this.processInput(input);
+    await this.processInputAsync(input);
     await Promise.all(this.pending);
     const writer = this;
     const buffers = writer.buffers;
@@ -6698,6 +6888,7 @@ var GLTFWriter = class {
     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.copyright) json.asset.copyright = options.copyright;
     if (options.binary === true) {
       const reader = new FileReader();
       reader.readAsArrayBuffer(blob);
@@ -6746,7 +6937,7 @@ var GLTFWriter = class {
   /**
    * Serializes a userData.
    *
-   * @param {THREE.Object3D|THREE.Material} object
+   * @param {THREE.Object3D|THREE.Material|THREE.BufferGeometry|THREE.AnimationClip} object
    * @param {Object} objectDef
    */
   serializeUserData(object, objectDef) {
@@ -6770,8 +6961,10 @@ var GLTFWriter = class {
   }
   /**
    * Returns ids for buffer attributes.
-   * @param  {Object} object
-   * @return {Integer}
+   *
+   * @param {Object} attribute
+   * @param {boolean} [isRelativeCopy=false]
+   * @return {number} An integer
    */
   getUID(attribute, isRelativeCopy = false) {
     if (this.uids.has(attribute) === false) {
@@ -6787,12 +6980,12 @@ var GLTFWriter = class {
    * Checks if normal attribute values are normalized.
    *
    * @param {BufferAttribute} normal
-   * @returns {Boolean}
+   * @returns {boolean}
    */
   isNormalizedNormalAttribute(normal) {
     const cache = this.cache;
     if (cache.attributesNormalized.has(normal)) return false;
-    const v = new import_three19.Vector3();
+    const v = new import_three18.Vector3();
     for (let i = 0, il = normal.count; i < il; i++) {
       if (Math.abs(v.fromBufferAttribute(normal, i).length() - 1) > 5e-4) return false;
     }
@@ -6809,7 +7002,7 @@ var GLTFWriter = class {
     const cache = this.cache;
     if (cache.attributesNormalized.has(normal)) return cache.attributesNormalized.get(normal);
     const attribute = normal.clone();
-    const v = new import_three19.Vector3();
+    const v = new import_three18.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) {
@@ -6850,10 +7043,10 @@ var GLTFWriter = class {
       this.extensionsUsed["KHR_texture_transform"] = true;
     }
   }
-  buildMetalRoughTexture(metalnessMap, roughnessMap) {
+  async buildMetalRoughTextureAsync(metalnessMap, roughnessMap) {
     if (metalnessMap === roughnessMap) return metalnessMap;
     function getEncodingConversion(map) {
-      if (map.colorSpace === import_three19.SRGBColorSpace) {
+      if (map.colorSpace === import_three18.SRGBColorSpace) {
         return function SRGBToLinear(c) {
           return c < 0.04045 ? c * 0.0773993808 : Math.pow(c * 0.9478672986 + 0.0521327014, 2.4);
         };
@@ -6862,12 +7055,11 @@ var GLTFWriter = class {
         return c;
       };
     }
-    console.warn("THREE.GLTFExporter: Merged metalnessMap and roughnessMap textures.");
-    if (metalnessMap instanceof import_three19.CompressedTexture) {
-      metalnessMap = decompress(metalnessMap);
+    if (metalnessMap instanceof import_three18.CompressedTexture) {
+      metalnessMap = await this.decompressTextureAsync(metalnessMap);
     }
-    if (roughnessMap instanceof import_three19.CompressedTexture) {
-      roughnessMap = decompress(roughnessMap);
+    if (roughnessMap instanceof import_three18.CompressedTexture) {
+      roughnessMap = await this.decompressTextureAsync(roughnessMap);
     }
     const metalness = metalnessMap ? metalnessMap.image : null;
     const roughness = roughnessMap ? roughnessMap.image : null;
@@ -6876,7 +7068,9 @@ var GLTFWriter = class {
     const canvas = getCanvas();
     canvas.width = width;
     canvas.height = height;
-    const context = canvas.getContext("2d");
+    const context = canvas.getContext("2d", {
+      willReadFrequently: true
+    });
     context.fillStyle = "#00ffff";
     context.fillRect(0, 0, width, height);
     const composite = context.getImageData(0, 0, width, height);
@@ -6899,18 +7093,60 @@ var GLTFWriter = class {
     context.putImageData(composite, 0, 0);
     const reference = metalnessMap || roughnessMap;
     const texture = reference.clone();
-    texture.source = new import_three19.Source(canvas);
-    texture.colorSpace = import_three19.NoColorSpace;
+    texture.source = new import_three18.TextureSource(canvas);
+    texture.colorSpace = import_three18.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.");
     }
+    console.warn("THREE.GLTFExporter: Merged metalnessMap and roughnessMap textures.");
     return texture;
   }
+  /**
+   * Builds a copy of the given normal map with the red and/or green channels
+   * inverted (`color = 255 - color`). This is used to bake the sign of
+   * `material.normalScale` and the tangent-space convention into the texture,
+   * since glTF only supports OpenGL-style normal maps with a univariate,
+   * positive scale.
+   *
+   * @param {THREE.Texture} normalMap The source normal map.
+   * @param {boolean} flipX Whether to invert the red channel (normal X).
+   * @param {boolean} flipY Whether to invert the green channel (normal Y).
+   * @return {Promise<THREE.Texture>} The derived normal map texture.
+   */
+  async buildNormalMapTextureAsync(normalMap, flipX, flipY) {
+    if (normalMap instanceof import_three18.CompressedTexture) {
+      normalMap = await this.decompressTextureAsync(normalMap);
+    }
+    const image = normalMap.image;
+    const canvas = getCanvas();
+    canvas.width = image.width;
+    canvas.height = image.height;
+    const context = canvas.getContext("2d", {
+      willReadFrequently: true
+    });
+    context.drawImage(image, 0, 0, canvas.width, canvas.height);
+    const imageData = context.getImageData(0, 0, canvas.width, canvas.height);
+    const data = imageData.data;
+    for (let i = 0; i < data.length; i += 4) {
+      if (flipX) data[i + 0] = 255 - data[i + 0];
+      if (flipY) data[i + 1] = 255 - data[i + 1];
+    }
+    context.putImageData(imageData, 0, 0);
+    const texture = normalMap.clone();
+    texture.source = new import_three18.TextureSource(canvas);
+    return texture;
+  }
+  async decompressTextureAsync(texture, maxTextureSize = Infinity) {
+    if (this.textureUtils === null) {
+      throw new Error("THREE.GLTFExporter: setTextureUtils() must be called to process compressed textures.");
+    }
+    return await this.textureUtils.decompress(texture, maxTextureSize);
+  }
   /**
    * Process a buffer to append to the default one.
-   * @param  {ArrayBuffer} buffer
-   * @return {Integer}
+   * @param {ArrayBuffer} buffer
+   * @return {0}
    */
   processBuffer(buffer) {
     const json = this.json;
@@ -6921,11 +7157,11 @@ var GLTFWriter = class {
   }
   /**
    * 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
+   * @param {BufferAttribute} attribute
+   * @param {number} componentType
+   * @param {number} start
+   * @param {number} count
+   * @param {number} [target] Target usage of the BufferView
    * @return {Object}
    */
   processBufferView(attribute, componentType, start, count, target) {
@@ -6944,7 +7180,11 @@ var GLTFWriter = class {
       default:
         componentSize = 4;
     }
-    const byteLength = getPaddedBufferSize(count * attribute.itemSize * componentSize);
+    let byteStride = attribute.itemSize * componentSize;
+    if (target === WEBGL_CONSTANTS.ARRAY_BUFFER) {
+      byteStride = Math.ceil(byteStride / 4) * 4;
+    }
+    const byteLength = getPaddedBufferSize(count * byteStride);
     const dataView = new DataView(new ArrayBuffer(byteLength));
     let offset = 0;
     for (let i = start; i < start + count; i++) {
@@ -6958,7 +7198,7 @@ var GLTFWriter = class {
           else if (a === 2) value = attribute.getZ(i);
           else if (a === 3) value = attribute.getW(i);
           if (attribute.normalized === true) {
-            value = import_three19.MathUtils.normalize(value, attribute.array);
+            value = import_three18.MathUtils.normalize(value, attribute.array);
           }
         }
         if (componentType === WEBGL_CONSTANTS.FLOAT) {
@@ -6978,6 +7218,9 @@ var GLTFWriter = class {
         }
         offset += componentSize;
       }
+      if (offset % byteStride !== 0) {
+        offset += byteStride - offset % byteStride;
+      }
     }
     const bufferViewDef = {
       buffer: this.processBuffer(dataView.buffer),
@@ -6986,7 +7229,7 @@ var GLTFWriter = class {
     };
     if (target !== void 0) bufferViewDef.target = target;
     if (target === WEBGL_CONSTANTS.ARRAY_BUFFER) {
-      bufferViewDef.byteStride = attribute.itemSize * componentSize;
+      bufferViewDef.byteStride = byteStride;
     }
     this.byteOffset += byteLength;
     json.bufferViews.push(bufferViewDef);
@@ -6999,7 +7242,7 @@ var GLTFWriter = class {
   /**
    * Process and generate a BufferView from an image Blob.
    * @param {Blob} blob
-   * @return {Promise<Integer>}
+   * @return {Promise<number>} An integer
    */
   processBufferViewImage(blob) {
     const writer = this;
@@ -7022,11 +7265,11 @@ var GLTFWriter = class {
   }
   /**
    * 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
+   * @param {BufferAttribute} attribute Attribute to process
+   * @param {?BufferGeometry} [geometry] Geometry used for truncated draw range
+   * @param {number} [start=0]
+   * @param {number} [count=Infinity]
+   * @return {?number} Index of the processed accessor on the "accessors" array
    */
   processAccessor(attribute, geometry, start, count) {
     const json = this.json;
@@ -7080,11 +7323,11 @@ var GLTFWriter = class {
   }
   /**
    * 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
+   * @param {Image} image to process
+   * @param {number} format Identifier of the format (RGBAFormat)
+   * @param {boolean} flipY before writing out the image
+   * @param {string} mimeType export format
+   * @return {number}     Index of the processed texture in the "images" array
    */
   processImage(image, format, flipY, mimeType = "image/png") {
     if (image !== null) {
@@ -7102,13 +7345,15 @@ var GLTFWriter = class {
       const canvas = getCanvas();
       canvas.width = Math.min(image.width, options.maxTextureSize);
       canvas.height = Math.min(image.height, options.maxTextureSize);
-      const ctx = canvas.getContext("2d");
+      const ctx = canvas.getContext("2d", {
+        willReadFrequently: true
+      });
       if (flipY === true) {
         ctx.translate(0, canvas.height);
         ctx.scale(1, -1);
       }
       if (image.data !== void 0) {
-        if (format !== import_three19.RGBAFormat) {
+        if (format !== import_three18.RGBAFormat) {
           console.error("GLTFExporter: Only RGBAFormat is supported.", format);
         }
         if (image.width > options.maxTextureSize || image.height > options.maxTextureSize) {
@@ -7123,7 +7368,11 @@ var GLTFWriter = class {
         }
         ctx.putImageData(new ImageData(data, image.width, image.height), 0, 0);
       } else {
-        ctx.drawImage(image, 0, 0, canvas.width, canvas.height);
+        if (typeof HTMLImageElement !== "undefined" && image instanceof HTMLImageElement || typeof HTMLCanvasElement !== "undefined" && image instanceof HTMLCanvasElement || typeof ImageBitmap !== "undefined" && image instanceof ImageBitmap || typeof OffscreenCanvas !== "undefined" && image instanceof OffscreenCanvas) {
+          ctx.drawImage(image, 0, 0, canvas.width, canvas.height);
+        } else {
+          throw new Error("THREE.GLTFExporter: Invalid image type. Use HTMLImageElement, HTMLCanvasElement, ImageBitmap or OffscreenCanvas.");
+        }
       }
       if (options.binary === true) {
         pending.push(
@@ -7132,15 +7381,7 @@ var GLTFWriter = class {
           })
         );
       } 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;
-            })
-          );
-        }
+        imageDef.uri = import_three18.ImageUtils.getDataURL(canvas, mimeType);
       }
       const index = json.images.push(imageDef) - 1;
       cachedImages[key] = index;
@@ -7151,8 +7392,8 @@ var GLTFWriter = class {
   }
   /**
    * Process sampler
-   * @param  {Texture} map Texture to process
-   * @return {Integer}     Index of the processed texture in the "samplers" array
+   * @param {Texture} map Texture to process
+   * @return {number}      Index of the processed texture in the "samplers" array
    */
   processSampler(map) {
     const json = this.json;
@@ -7167,28 +7408,37 @@ var GLTFWriter = class {
   }
   /**
    * Process texture
-   * @param  {Texture} map Map to process
-   * @return {Integer} Index of the processed texture in the "textures" array
+   * @param {Texture} map Map to process
+   * @return {Promise<number>} Index of the processed texture in the "textures" array
    */
-  processTexture(map) {
+  async processTextureAsync(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_three19.CompressedTexture) {
-      map = decompress(map, options.maxTextureSize);
+    if (map instanceof import_three18.CompressedTexture) {
+      map = await this.decompressTextureAsync(map, options.maxTextureSize);
     }
-    let mimeType = map.userData.mimeType;
-    if (mimeType === "image/webp") mimeType = "image/png";
+    const mimeType = map.userData.mimeType;
+    const imageIndex = this.processImage(map.image, map.format, map.flipY, mimeType);
     const textureDef = {
-      sampler: this.processSampler(map),
-      source: this.processImage(map.image, map.format, map.flipY, mimeType)
+      sampler: this.processSampler(map)
     };
+    if (mimeType === "image/webp") {
+      textureDef.extensions = textureDef.extensions || {};
+      textureDef.extensions["EXT_texture_webp"] = {
+        source: imageIndex
+      };
+      this.extensionsUsed["EXT_texture_webp"] = true;
+      this.extensionsRequired["EXT_texture_webp"] = true;
+    } else {
+      textureDef.source = imageIndex;
+    }
     if (map.name) textureDef.name = map.name;
-    this._invokeAll(function(ext) {
-      ext.writeTexture && ext.writeTexture(map, textureDef);
+    await this._invokeAllAsync(async function(ext) {
+      ext.writeTexture && await ext.writeTexture(map, textureDef);
     });
     const index = json.textures.push(textureDef) - 1;
     cache.textures.set(map, index);
@@ -7196,13 +7446,16 @@ var GLTFWriter = class {
   }
   /**
    * Process material
-   * @param  {THREE.Material} material Material to process
-   * @return {Integer|null} Index of the processed material in the "materials" array
+   * @param {THREE.Material} material Material to process
+   * @param {THREE.BufferGeometry} [geometry] Geometry the material is used with.
+   * @return {Promise<?number>} Index of the processed material in the "materials" array
    */
-  processMaterial(material) {
+  async processMaterialAsync(material, geometry) {
     const cache = this.cache;
     const json = this.json;
-    if (cache.materials.has(material)) return cache.materials.get(material);
+    const hasTangent = geometry !== void 0 && geometry.hasAttribute("tangent");
+    const cacheKey = material.normalMap ? material.uuid + ":" + hasTangent : material.uuid;
+    if (cache.materials.has(cacheKey)) return cache.materials.get(cacheKey);
     if (material.isShaderMaterial) {
       console.warn("GLTFExporter: THREE.ShaderMaterial not supported.");
       return null;
@@ -7220,21 +7473,21 @@ var GLTFWriter = class {
       materialDef.pbrMetallicRoughness.metallicFactor = material.metalness;
       materialDef.pbrMetallicRoughness.roughnessFactor = material.roughness;
     } else {
-      materialDef.pbrMetallicRoughness.metallicFactor = 0.5;
-      materialDef.pbrMetallicRoughness.roughnessFactor = 0.5;
+      materialDef.pbrMetallicRoughness.metallicFactor = 0;
+      materialDef.pbrMetallicRoughness.roughnessFactor = 1;
     }
     if (material.metalnessMap || material.roughnessMap) {
-      const metalRoughTexture = this.buildMetalRoughTexture(material.metalnessMap, material.roughnessMap);
+      const metalRoughTexture = await this.buildMetalRoughTextureAsync(material.metalnessMap, material.roughnessMap);
       const metalRoughMapDef = {
-        index: this.processTexture(metalRoughTexture),
-        channel: metalRoughTexture.channel
+        index: await this.processTextureAsync(metalRoughTexture),
+        texCoord: metalRoughTexture.channel
       };
       this.applyTextureTransform(metalRoughMapDef, metalRoughTexture);
       materialDef.pbrMetallicRoughness.metallicRoughnessTexture = metalRoughMapDef;
     }
     if (material.map) {
       const baseColorMapDef = {
-        index: this.processTexture(material.map),
+        index: await this.processTextureAsync(material.map),
         texCoord: material.map.channel
       };
       this.applyTextureTransform(baseColorMapDef, material.map);
@@ -7248,7 +7501,7 @@ var GLTFWriter = class {
       }
       if (material.emissiveMap) {
         const emissiveMapDef = {
-          index: this.processTexture(material.emissiveMap),
+          index: await this.processTextureAsync(material.emissiveMap),
           texCoord: material.emissiveMap.channel
         };
         this.applyTextureTransform(emissiveMapDef, material.emissiveMap);
@@ -7256,19 +7509,32 @@ var GLTFWriter = class {
       }
     }
     if (material.normalMap) {
+      const normalScale = material.normalScale;
+      const flipX = normalScale.x < 0;
+      const flipY = hasTangent ? normalScale.y < 0 : normalScale.y > 0;
+      let normalMap = material.normalMap;
+      if (flipX || flipY) {
+        if (cache.normalMaps.has(material.normalMap) === false) cache.normalMaps.set(material.normalMap, {});
+        const cachedVariants = cache.normalMaps.get(material.normalMap);
+        const cacheKey2 = `${flipX}:${flipY}`;
+        if (cachedVariants[cacheKey2] === void 0) {
+          cachedVariants[cacheKey2] = await this.buildNormalMapTextureAsync(material.normalMap, flipX, flipY);
+        }
+        normalMap = cachedVariants[cacheKey2];
+      }
       const normalMapDef = {
-        index: this.processTexture(material.normalMap),
+        index: await this.processTextureAsync(normalMap),
         texCoord: material.normalMap.channel
       };
-      if (material.normalScale && material.normalScale.x !== 1) {
-        normalMapDef.scale = material.normalScale.x;
+      if (Math.abs(normalScale.x) !== 1) {
+        normalMapDef.scale = Math.abs(normalScale.x);
       }
       this.applyTextureTransform(normalMapDef, material.normalMap);
       materialDef.normalTexture = normalMapDef;
     }
     if (material.aoMap) {
       const occlusionMapDef = {
-        index: this.processTexture(material.aoMap),
+        index: await this.processTextureAsync(material.aoMap),
         texCoord: material.aoMap.channel
       };
       if (material.aoMapIntensity !== 1) {
@@ -7285,22 +7551,22 @@ var GLTFWriter = class {
         materialDef.alphaCutoff = material.alphaTest;
       }
     }
-    if (material.side === import_three19.DoubleSide) materialDef.doubleSided = true;
+    if (material.side === import_three18.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);
+    await this._invokeAllAsync(async function(ext) {
+      ext.writeMaterialAsync && await ext.writeMaterialAsync(material, materialDef);
     });
     const index = json.materials.push(materialDef) - 1;
-    cache.materials.set(material, index);
+    cache.materials.set(cacheKey, index);
     return index;
   }
   /**
    * Process mesh
-   * @param  {THREE.Mesh} mesh Mesh to process
-   * @return {Integer|null} Index of the processed mesh in the "meshes" array
+   * @param {THREE.Mesh} mesh Mesh to process
+   * @return {Promise<?number>} Index of the processed mesh in the "meshes" array
    */
-  processMesh(mesh) {
+  async processMeshAsync(mesh) {
     const cache = this.cache;
     const json = this.json;
     const meshCacheKeyParts = [mesh.geometry.uuid];
@@ -7350,7 +7616,7 @@ var GLTFWriter = class {
       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 (!validVertexAttributes.test(attributeName) && !attributeName.startsWith("_")) attributeName = "_" + attributeName;
       if (cache.attributes.has(this.getUID(attribute))) {
         attributes[attributeName] = cache.attributes.get(this.getUID(attribute));
         continue;
@@ -7359,7 +7625,10 @@ var GLTFWriter = class {
       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_three19.BufferAttribute(new Uint16Array(array), attribute.itemSize, attribute.normalized);
+        modifiedAttribute = GLTFExporter.Utils.toTypedBufferAttribute(attribute, Uint16Array);
+      } else if ((array instanceof Uint32Array || array instanceof Int32Array) && !attributeName.startsWith("_")) {
+        console.warn(`GLTFExporter: Attribute "${attributeName}" converted to type FLOAT.`);
+        modifiedAttribute = GLTFExporter.Utils.toTypedBufferAttribute(attribute, Float32Array);
       }
       const accessor = this.processAccessor(modifiedAttribute || attribute, geometry);
       if (accessor !== null) {
@@ -7425,6 +7694,15 @@ var GLTFWriter = class {
     }
     const isMultiMaterial = Array.isArray(mesh.material);
     if (isMultiMaterial && geometry.groups.length === 0) return null;
+    let didForceIndices = false;
+    if (isMultiMaterial && geometry.index === null) {
+      const indices = [];
+      for (let i = 0, il = geometry.attributes.position.count; i < il; i++) {
+        indices[i] = i;
+      }
+      geometry.setIndex(indices);
+      didForceIndices = true;
+    }
     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++) {
@@ -7447,13 +7725,16 @@ var GLTFWriter = class {
         }
         if (primitive.indices === null) delete primitive.indices;
       }
-      const material = this.processMaterial(materials[groups[i].materialIndex]);
+      const material = await this.processMaterialAsync(materials[groups[i].materialIndex], geometry);
       if (material !== null) primitive.material = material;
       primitives.push(primitive);
     }
+    if (didForceIndices === true) {
+      geometry.setIndex(null);
+    }
     meshDef.primitives = primitives;
     if (!json.meshes) json.meshes = [];
-    this._invokeAll(function(ext) {
+    await this._invokeAllAsync(function(ext) {
       ext.writeMesh && ext.writeMesh(mesh, meshDef);
     });
     const index = json.meshes.push(meshDef) - 1;
@@ -7499,8 +7780,8 @@ var GLTFWriter = class {
   }
   /**
    * Process camera
-   * @param  {THREE.Camera} camera Camera to process
-   * @return {Integer}      Index of the processed mesh in the "camera" array
+   * @param {THREE.Camera} camera Camera to process
+   * @return {number} Index of the processed mesh in the "camera" array
    */
   processCamera(camera) {
     const json = this.json;
@@ -7519,7 +7800,7 @@ var GLTFWriter = class {
     } else {
       cameraDef.perspective = {
         aspectRatio: camera.aspect,
-        yfov: import_three19.MathUtils.degToRad(camera.fov),
+        yfov: import_three18.MathUtils.degToRad(camera.fov),
         zfar: camera.far <= 0 ? 1e-3 : camera.far,
         znear: camera.near < 0 ? 0 : camera.near
       };
@@ -7535,7 +7816,7 @@ var GLTFWriter = class {
    *
    * @param {THREE.AnimationClip} clip
    * @param {THREE.Object3D} root
-   * @return {number|null}
+   * @return {?number}
    */
   processAnimation(clip, root) {
     const json = this.json;
@@ -7547,8 +7828,8 @@ var GLTFWriter = class {
     const samplers = [];
     for (let i = 0; i < tracks.length; ++i) {
       const track = tracks[i];
-      const trackBinding = import_three19.PropertyBinding.parseTrackName(track.name);
-      let trackNode = import_three19.PropertyBinding.findNode(root, trackBinding.nodeName);
+      const trackBinding = import_three18.PropertyBinding.parseTrackName(track.name);
+      let trackNode = import_three18.PropertyBinding.findNode(root, trackBinding.nodeName);
       const trackProperty = PATH_PROPERTIES[trackBinding.propertyName];
       if (trackBinding.objectName === "bones") {
         if (trackNode.isSkinnedMesh === true) {
@@ -7559,7 +7840,7 @@ var GLTFWriter = class {
       }
       if (!trackNode || !trackProperty) {
         console.warn('THREE.GLTFExporter: Could not export animation track "%s".', track.name);
-        return null;
+        continue;
       }
       const inputItemSize = 1;
       let outputItemSize = track.values.length / track.times.length;
@@ -7570,14 +7851,14 @@ var GLTFWriter = class {
       if (track.createInterpolant.isInterpolantFactoryMethodGLTFCubicSpline === true) {
         interpolation = "CUBICSPLINE";
         outputItemSize /= 3;
-      } else if (track.getInterpolation() === import_three19.InterpolateDiscrete) {
+      } else if (track.getInterpolation() === import_three18.InterpolateDiscrete) {
         interpolation = "STEP";
       } else {
         interpolation = "LINEAR";
       }
       samplers.push({
-        input: this.processAccessor(new import_three19.BufferAttribute(track.times, inputItemSize)),
-        output: this.processAccessor(new import_three19.BufferAttribute(track.values, outputItemSize)),
+        input: this.processAccessor(new import_three18.BufferAttribute(track.times, inputItemSize)),
+        output: this.processAccessor(new import_three18.BufferAttribute(track.values, outputItemSize)),
         interpolation
       });
       channels.push({
@@ -7588,16 +7869,18 @@ var GLTFWriter = class {
         }
       });
     }
-    json.animations.push({
+    const animationDef = {
       name: clip.name || "clip_" + json.animations.length,
       samplers,
       channels
-    });
+    };
+    this.serializeUserData(clip, animationDef);
+    json.animations.push(animationDef);
     return json.animations.length - 1;
   }
   /**
    * @param {THREE.Object3D} object
-   * @return {number|null}
+   * @return {?number}
    */
   processSkin(object) {
     const json = this.json;
@@ -7609,7 +7892,7 @@ var GLTFWriter = class {
     if (rootJoint === void 0) return null;
     const joints = [];
     const inverseBindMatrices = new Float32Array(skeleton.bones.length * 16);
-    const temporaryBoneInverse = new import_three19.Matrix4();
+    const temporaryBoneInverse = new import_three18.Matrix4();
     for (let i = 0; i < skeleton.bones.length; ++i) {
       joints.push(nodeMap.get(skeleton.bones[i]));
       temporaryBoneInverse.copy(skeleton.boneInverses[i]);
@@ -7617,7 +7900,7 @@ var GLTFWriter = class {
     }
     if (json.skins === void 0) json.skins = [];
     json.skins.push({
-      inverseBindMatrices: this.processAccessor(new import_three19.BufferAttribute(inverseBindMatrices, 16)),
+      inverseBindMatrices: this.processAccessor(new import_three18.BufferAttribute(inverseBindMatrices, 16)),
       joints,
       skeleton: nodeMap.get(rootJoint)
     });
@@ -7626,14 +7909,17 @@ var GLTFWriter = class {
   }
   /**
    * Process Object3D node
-   * @param  {THREE.Object3D} node Object3D to processNode
-   * @return {Integer} Index of the node in the nodes list
+   * @param {THREE.Object3D} object Object3D to processNodeAsync
+   * @return {Promise<number>} Index of the node in the nodes list
    */
-  processNode(object) {
+  async processNodeAsync(object) {
     const json = this.json;
     const options = this.options;
     const nodeMap = this.nodeMap;
     if (!json.nodes) json.nodes = [];
+    if (object.pivot !== null) {
+      return await this._processNodeWithPivotAsync(object);
+    }
     const nodeDef = {};
     if (options.trs) {
       const rotation = object.quaternion.toArray();
@@ -7659,35 +7945,98 @@ var GLTFWriter = class {
     if (object.name !== "") nodeDef.name = String(object.name);
     this.serializeUserData(object, nodeDef);
     if (object.isMesh || object.isLine || object.isPoints) {
-      const meshIndex = this.processMesh(object);
+      const meshIndex = await this.processMeshAsync(object);
       if (meshIndex !== null) nodeDef.mesh = meshIndex;
     } else if (object.isCamera) {
       nodeDef.camera = this.processCamera(object);
     }
     if (object.isSkinnedMesh) this.skins.push(object);
+    const nodeIndex = json.nodes.push(nodeDef) - 1;
+    nodeMap.set(object, nodeIndex);
     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);
+          const childNodeIndex = await this.processNodeAsync(child);
+          if (childNodeIndex !== null) children.push(childNodeIndex);
         }
       }
       if (children.length > 0) nodeDef.children = children;
     }
-    this._invokeAll(function(ext) {
+    await this._invokeAllAsync(function(ext) {
       ext.writeNode && ext.writeNode(object, nodeDef);
     });
-    const nodeIndex = json.nodes.push(nodeDef) - 1;
-    nodeMap.set(object, nodeIndex);
     return nodeIndex;
   }
+  /**
+   * Process Object3D node with pivot using container approach
+   * @param {THREE.Object3D} object Object3D with pivot
+   * @return {Promise<number>} Index of the container node
+   */
+  async _processNodeWithPivotAsync(object) {
+    const json = this.json;
+    const options = this.options;
+    const nodeMap = this.nodeMap;
+    const pivot = object.pivot;
+    const containerDef = {};
+    const rotation = object.quaternion.toArray();
+    const position = [
+      object.position.x + pivot.x,
+      object.position.y + pivot.y,
+      object.position.z + pivot.z
+    ];
+    const scale = object.scale.toArray();
+    if (!equalArray(rotation, [0, 0, 0, 1])) {
+      containerDef.rotation = rotation;
+    }
+    if (!equalArray(position, [0, 0, 0])) {
+      containerDef.translation = position;
+    }
+    if (!equalArray(scale, [1, 1, 1])) {
+      containerDef.scale = scale;
+    }
+    containerDef.extras = { pivot: pivot.toArray() };
+    if (object.name !== "") containerDef.name = String(object.name);
+    this.serializeUserData(object, containerDef);
+    const containerIndex = json.nodes.push(containerDef) - 1;
+    nodeMap.set(object, containerIndex);
+    const childDef = {};
+    const childPosition = [-pivot.x, -pivot.y, -pivot.z];
+    if (!equalArray(childPosition, [0, 0, 0])) {
+      childDef.translation = childPosition;
+    }
+    if (object.isMesh || object.isLine || object.isPoints) {
+      const meshIndex = await this.processMeshAsync(object);
+      if (meshIndex !== null) childDef.mesh = meshIndex;
+    } else if (object.isCamera) {
+      childDef.camera = this.processCamera(object);
+    }
+    if (object.isSkinnedMesh) this.skins.push(object);
+    const childIndex = json.nodes.push(childDef) - 1;
+    const containerChildren = [childIndex];
+    if (object.children.length > 0) {
+      const grandchildren = [];
+      for (let i = 0, l = object.children.length; i < l; i++) {
+        const child = object.children[i];
+        if (child.visible || options.onlyVisible === false) {
+          const childNodeIndex = await this.processNodeAsync(child);
+          if (childNodeIndex !== null) grandchildren.push(childNodeIndex);
+        }
+      }
+      if (grandchildren.length > 0) childDef.children = grandchildren;
+    }
+    containerDef.children = containerChildren;
+    await this._invokeAllAsync(function(ext) {
+      ext.writeNode && ext.writeNode(object, containerDef);
+    });
+    return containerIndex;
+  }
   /**
    * Process Scene
-   * @param  {Scene} node Scene to process
+   * @param {Scene} scene Scene to process
    */
-  processScene(scene) {
+  async processSceneAsync(scene) {
     const json = this.json;
     const options = this.options;
     if (!json.scenes) {
@@ -7701,7 +8050,7 @@ var GLTFWriter = class {
     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);
+        const nodeIndex = await this.processNodeAsync(child);
         if (nodeIndex !== null) nodes.push(nodeIndex);
       }
     }
@@ -7710,47 +8059,58 @@ var GLTFWriter = class {
   }
   /**
    * Creates a Scene to hold a list of objects and parse it
-   * @param  {Array} objects List of objects to process
+   * @param {Array<THREE.Object3D>} objects List of objects to process
    */
-  processObjects(objects) {
-    const scene = new import_three19.Scene();
+  async processObjectsAsync(objects) {
+    const scene = new import_three18.Scene();
     scene.name = "AuxScene";
     for (let i = 0; i < objects.length; i++) {
       scene.children.push(objects[i]);
     }
-    this.processScene(scene);
+    await this.processSceneAsync(scene);
   }
   /**
    * @param {THREE.Object3D|Array<THREE.Object3D>} input
    */
-  processInput(input) {
+  async processInputAsync(input) {
     const options = this.options;
     input = input instanceof Array ? input : [input];
-    this._invokeAll(function(ext) {
+    await this._invokeAllAsync(function(ext) {
       ext.beforeParse && ext.beforeParse(input);
     });
     const objectsWithoutScene = [];
     for (let i = 0; i < input.length; i++) {
-      if (input[i] instanceof import_three19.Scene) {
-        this.processScene(input[i]);
+      if (input[i] instanceof import_three18.Scene) {
+        await this.processSceneAsync(input[i]);
       } else {
         objectsWithoutScene.push(input[i]);
       }
     }
-    if (objectsWithoutScene.length > 0) this.processObjects(objectsWithoutScene);
+    if (objectsWithoutScene.length > 0) {
+      await this.processObjectsAsync(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]);
+    if (input.length === 1) {
+      for (let i = 0; i < options.animations.length; ++i) {
+        this.processAnimation(options.animations[i], input[0]);
+      }
+    } else {
+      for (let i = 0; i < input.length; i++) {
+        const animations = options.animations[i] || [];
+        for (let j = 0; j < animations.length; ++j) {
+          this.processAnimation(animations[j], input[i]);
+        }
+      }
     }
-    this._invokeAll(function(ext) {
+    await this._invokeAllAsync(function(ext) {
       ext.afterParse && ext.afterParse(input);
     });
   }
-  _invokeAll(func) {
+  async _invokeAllAsync(func) {
     for (let i = 0, il = this.plugins.length; i < il; i++) {
-      func(this.plugins[i]);
+      await func(this.plugins[i]);
     }
   }
 };
@@ -7806,7 +8166,7 @@ var GLTFMaterialsUnlitExtension = class {
     this.writer = writer;
     this.name = "KHR_materials_unlit";
   }
-  writeMaterial(material, materialDef) {
+  async writeMaterialAsync(material, materialDef) {
     if (!material.isMeshBasicMaterial) return;
     const writer = this.writer;
     const extensionsUsed = writer.extensionsUsed;
@@ -7822,7 +8182,7 @@ var GLTFMaterialsClearcoatExtension = class {
     this.writer = writer;
     this.name = "KHR_materials_clearcoat";
   }
-  writeMaterial(material, materialDef) {
+  async writeMaterialAsync(material, materialDef) {
     if (!material.isMeshPhysicalMaterial || material.clearcoat === 0) return;
     const writer = this.writer;
     const extensionsUsed = writer.extensionsUsed;
@@ -7830,7 +8190,7 @@ var GLTFMaterialsClearcoatExtension = class {
     extensionDef.clearcoatFactor = material.clearcoat;
     if (material.clearcoatMap) {
       const clearcoatMapDef = {
-        index: writer.processTexture(material.clearcoatMap),
+        index: await writer.processTextureAsync(material.clearcoatMap),
         texCoord: material.clearcoatMap.channel
       };
       writer.applyTextureTransform(clearcoatMapDef, material.clearcoatMap);
@@ -7839,7 +8199,7 @@ var GLTFMaterialsClearcoatExtension = class {
     extensionDef.clearcoatRoughnessFactor = material.clearcoatRoughness;
     if (material.clearcoatRoughnessMap) {
       const clearcoatRoughnessMapDef = {
-        index: writer.processTexture(material.clearcoatRoughnessMap),
+        index: await writer.processTextureAsync(material.clearcoatRoughnessMap),
         texCoord: material.clearcoatRoughnessMap.channel
       };
       writer.applyTextureTransform(clearcoatRoughnessMapDef, material.clearcoatRoughnessMap);
@@ -7847,9 +8207,10 @@ var GLTFMaterialsClearcoatExtension = class {
     }
     if (material.clearcoatNormalMap) {
       const clearcoatNormalMapDef = {
-        index: writer.processTexture(material.clearcoatNormalMap),
+        index: await writer.processTextureAsync(material.clearcoatNormalMap),
         texCoord: material.clearcoatNormalMap.channel
       };
+      if (material.clearcoatNormalScale.x !== 1) clearcoatNormalMapDef.scale = material.clearcoatNormalScale.x;
       writer.applyTextureTransform(clearcoatNormalMapDef, material.clearcoatNormalMap);
       extensionDef.clearcoatNormalTexture = clearcoatNormalMapDef;
     }
@@ -7858,12 +8219,28 @@ var GLTFMaterialsClearcoatExtension = class {
     extensionsUsed[this.name] = true;
   }
 };
+var GLTFMaterialsDispersionExtension = class {
+  constructor(writer) {
+    this.writer = writer;
+    this.name = "KHR_materials_dispersion";
+  }
+  async writeMaterialAsync(material, materialDef) {
+    if (!material.isMeshPhysicalMaterial || material.dispersion === 0) return;
+    const writer = this.writer;
+    const extensionsUsed = writer.extensionsUsed;
+    const extensionDef = {};
+    extensionDef.dispersion = material.dispersion;
+    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) {
+  async writeMaterialAsync(material, materialDef) {
     if (!material.isMeshPhysicalMaterial || material.iridescence === 0) return;
     const writer = this.writer;
     const extensionsUsed = writer.extensionsUsed;
@@ -7871,7 +8248,7 @@ var GLTFMaterialsIridescenceExtension = class {
     extensionDef.iridescenceFactor = material.iridescence;
     if (material.iridescenceMap) {
       const iridescenceMapDef = {
-        index: writer.processTexture(material.iridescenceMap),
+        index: await writer.processTextureAsync(material.iridescenceMap),
         texCoord: material.iridescenceMap.channel
       };
       writer.applyTextureTransform(iridescenceMapDef, material.iridescenceMap);
@@ -7882,7 +8259,7 @@ var GLTFMaterialsIridescenceExtension = class {
     extensionDef.iridescenceThicknessMaximum = material.iridescenceThicknessRange[1];
     if (material.iridescenceThicknessMap) {
       const iridescenceThicknessMapDef = {
-        index: writer.processTexture(material.iridescenceThicknessMap),
+        index: await writer.processTextureAsync(material.iridescenceThicknessMap),
         texCoord: material.iridescenceThicknessMap.channel
       };
       writer.applyTextureTransform(iridescenceThicknessMapDef, material.iridescenceThicknessMap);
@@ -7898,7 +8275,7 @@ var GLTFMaterialsTransmissionExtension = class {
     this.writer = writer;
     this.name = "KHR_materials_transmission";
   }
-  writeMaterial(material, materialDef) {
+  async writeMaterialAsync(material, materialDef) {
     if (!material.isMeshPhysicalMaterial || material.transmission === 0) return;
     const writer = this.writer;
     const extensionsUsed = writer.extensionsUsed;
@@ -7906,7 +8283,7 @@ var GLTFMaterialsTransmissionExtension = class {
     extensionDef.transmissionFactor = material.transmission;
     if (material.transmissionMap) {
       const transmissionMapDef = {
-        index: writer.processTexture(material.transmissionMap),
+        index: await writer.processTextureAsync(material.transmissionMap),
         texCoord: material.transmissionMap.channel
       };
       writer.applyTextureTransform(transmissionMapDef, material.transmissionMap);
@@ -7922,7 +8299,7 @@ var GLTFMaterialsVolumeExtension = class {
     this.writer = writer;
     this.name = "KHR_materials_volume";
   }
-  writeMaterial(material, materialDef) {
+  async writeMaterialAsync(material, materialDef) {
     if (!material.isMeshPhysicalMaterial || material.transmission === 0) return;
     const writer = this.writer;
     const extensionsUsed = writer.extensionsUsed;
@@ -7930,13 +8307,15 @@ var GLTFMaterialsVolumeExtension = class {
     extensionDef.thicknessFactor = material.thickness;
     if (material.thicknessMap) {
       const thicknessMapDef = {
-        index: writer.processTexture(material.thicknessMap),
+        index: await writer.processTextureAsync(material.thicknessMap),
         texCoord: material.thicknessMap.channel
       };
       writer.applyTextureTransform(thicknessMapDef, material.thicknessMap);
       extensionDef.thicknessTexture = thicknessMapDef;
     }
-    extensionDef.attenuationDistance = material.attenuationDistance;
+    if (material.attenuationDistance !== Infinity) {
+      extensionDef.attenuationDistance = material.attenuationDistance;
+    }
     extensionDef.attenuationColor = material.attenuationColor.toArray();
     materialDef.extensions = materialDef.extensions || {};
     materialDef.extensions[this.name] = extensionDef;
@@ -7948,7 +8327,7 @@ var GLTFMaterialsIorExtension = class {
     this.writer = writer;
     this.name = "KHR_materials_ior";
   }
-  writeMaterial(material, materialDef) {
+  async writeMaterialAsync(material, materialDef) {
     if (!material.isMeshPhysicalMaterial || material.ior === 1.5) return;
     const writer = this.writer;
     const extensionsUsed = writer.extensionsUsed;
@@ -7964,14 +8343,14 @@ var GLTFMaterialsSpecularExtension = class {
     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;
+  async writeMaterialAsync(material, materialDef) {
+    if (!material.isMeshPhysicalMaterial || material.specularIntensity === 1 && material.specularColor.equals(DEFAULT_SPECULAR_COLOR) && !material.specularIntensityMap && !material.specularColorMap) return;
     const writer = this.writer;
     const extensionsUsed = writer.extensionsUsed;
     const extensionDef = {};
     if (material.specularIntensityMap) {
       const specularIntensityMapDef = {
-        index: writer.processTexture(material.specularIntensityMap),
+        index: await writer.processTextureAsync(material.specularIntensityMap),
         texCoord: material.specularIntensityMap.channel
       };
       writer.applyTextureTransform(specularIntensityMapDef, material.specularIntensityMap);
@@ -7979,7 +8358,7 @@ var GLTFMaterialsSpecularExtension = class {
     }
     if (material.specularColorMap) {
       const specularColorMapDef = {
-        index: writer.processTexture(material.specularColorMap),
+        index: await writer.processTextureAsync(material.specularColorMap),
         texCoord: material.specularColorMap.channel
       };
       writer.applyTextureTransform(specularColorMapDef, material.specularColorMap);
@@ -7997,14 +8376,14 @@ var GLTFMaterialsSheenExtension = class {
     this.writer = writer;
     this.name = "KHR_materials_sheen";
   }
-  writeMaterial(material, materialDef) {
+  async writeMaterialAsync(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),
+        index: await writer.processTextureAsync(material.sheenRoughnessMap),
         texCoord: material.sheenRoughnessMap.channel
       };
       writer.applyTextureTransform(sheenRoughnessMapDef, material.sheenRoughnessMap);
@@ -8012,7 +8391,7 @@ var GLTFMaterialsSheenExtension = class {
     }
     if (material.sheenColorMap) {
       const sheenColorMapDef = {
-        index: writer.processTexture(material.sheenColorMap),
+        index: await writer.processTextureAsync(material.sheenColorMap),
         texCoord: material.sheenColorMap.channel
       };
       writer.applyTextureTransform(sheenColorMapDef, material.sheenColorMap);
@@ -8030,13 +8409,13 @@ var GLTFMaterialsAnisotropyExtension = class {
     this.writer = writer;
     this.name = "KHR_materials_anisotropy";
   }
-  writeMaterial(material, materialDef) {
+  async writeMaterialAsync(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) };
+      const anisotropyMapDef = { index: await writer.processTextureAsync(material.anisotropyMap) };
       writer.applyTextureTransform(anisotropyMapDef, material.anisotropyMap);
       extensionDef.anisotropyTexture = anisotropyMapDef;
     }
@@ -8052,7 +8431,7 @@ var GLTFMaterialsEmissiveStrengthExtension = class {
     this.writer = writer;
     this.name = "KHR_materials_emissive_strength";
   }
-  writeMaterial(material, materialDef) {
+  async writeMaterialAsync(material, materialDef) {
     if (!material.isMeshStandardMaterial || material.emissiveIntensity === 1) return;
     const writer = this.writer;
     const extensionsUsed = writer.extensionsUsed;
@@ -8063,6 +8442,30 @@ var GLTFMaterialsEmissiveStrengthExtension = class {
     extensionsUsed[this.name] = true;
   }
 };
+var GLTFMaterialsBumpExtension = class {
+  constructor(writer) {
+    this.writer = writer;
+    this.name = "EXT_materials_bump";
+  }
+  async writeMaterialAsync(material, materialDef) {
+    if (!material.isMeshStandardMaterial || material.bumpScale === 1 && !material.bumpMap) return;
+    const writer = this.writer;
+    const extensionsUsed = writer.extensionsUsed;
+    const extensionDef = {};
+    if (material.bumpMap) {
+      const bumpMapDef = {
+        index: await writer.processTextureAsync(material.bumpMap),
+        texCoord: material.bumpMap.channel
+      };
+      writer.applyTextureTransform(bumpMapDef, material.bumpMap);
+      extensionDef.bumpTexture = bumpMapDef;
+    }
+    extensionDef.bumpFactor = material.bumpScale;
+    materialDef.extensions = materialDef.extensions || {};
+    materialDef.extensions[this.name] = extensionDef;
+    extensionsUsed[this.name] = true;
+  }
+};
 var GLTFMeshGpuInstancing = class {
   constructor(writer) {
     this.writer = writer;
@@ -8075,10 +8478,10 @@ var GLTFMeshGpuInstancing = class {
     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_three19.Matrix4();
-    const position = new import_three19.Vector3();
-    const quaternion = new import_three19.Quaternion();
-    const scale = new import_three19.Vector3();
+    const matrix = new import_three18.Matrix4();
+    const position = new import_three18.Vector3();
+    const quaternion = new import_three18.Quaternion();
+    const scale = new import_three18.Vector3();
     for (let i = 0; i < mesh.count; i++) {
       mesh.getMatrixAt(i, matrix);
       matrix.decompose(position, quaternion, scale);
@@ -8087,9 +8490,9 @@ var GLTFMeshGpuInstancing = class {
       scale.toArray(scaleAttr, i * 3);
     }
     const attributes = {
-      TRANSLATION: writer.processAccessor(new import_three19.BufferAttribute(translationAttr, 3)),
-      ROTATION: writer.processAccessor(new import_three19.BufferAttribute(rotationAttr, 4)),
-      SCALE: writer.processAccessor(new import_three19.BufferAttribute(scaleAttr, 3))
+      TRANSLATION: writer.processAccessor(new import_three18.BufferAttribute(translationAttr, 3)),
+      ROTATION: writer.processAccessor(new import_three18.BufferAttribute(rotationAttr, 4)),
+      SCALE: writer.processAccessor(new import_three18.BufferAttribute(scaleAttr, 3))
     };
     if (mesh.instanceColor)
       attributes._COLOR_0 = writer.processAccessor(mesh.instanceColor);
@@ -8154,8 +8557,8 @@ GLTFExporter.Utils = {
     const sourceTracks = clip.tracks;
     for (let i = 0; i < sourceTracks.length; ++i) {
       let sourceTrack = sourceTracks[i];
-      const sourceTrackBinding = import_three19.PropertyBinding.parseTrackName(sourceTrack.name);
-      const sourceTrackNode = import_three19.PropertyBinding.findNode(root, sourceTrackBinding.nodeName);
+      const sourceTrackBinding = import_three18.PropertyBinding.parseTrackName(sourceTrack.name);
+      const sourceTrackNode = import_three18.PropertyBinding.findNode(root, sourceTrackBinding.nodeName);
       if (sourceTrackBinding.propertyName !== "morphTargetInfluences" || sourceTrackBinding.propertyIndex === void 0) {
         tracks.push(sourceTrack);
         continue;
@@ -8166,7 +8569,7 @@ GLTFExporter.Utils = {
         }
         console.warn("THREE.GLTFExporter: Morph target interpolation mode not yet supported. Using LINEAR instead.");
         sourceTrack = sourceTrack.clone();
-        sourceTrack.setInterpolation(import_three19.InterpolateLinear);
+        sourceTrack.setInterpolation(import_three18.InterpolateLinear);
       }
       const targetCount = sourceTrackNode.morphTargetInfluences.length;
       const targetIndex = sourceTrackNode.morphTargetDictionary[sourceTrackBinding.propertyIndex];
@@ -8198,6 +8601,19 @@ GLTFExporter.Utils = {
     }
     clip.tracks = tracks;
     return clip;
+  },
+  toTypedBufferAttribute: function(srcAttribute, TypedArray) {
+    const dstAttribute = new import_three18.BufferAttribute(new TypedArray(srcAttribute.count * srcAttribute.itemSize), srcAttribute.itemSize, false);
+    if (!srcAttribute.normalized && !srcAttribute.isInterleavedBufferAttribute) {
+      dstAttribute.array.set(srcAttribute.array);
+      return dstAttribute;
+    }
+    for (let i = 0, il = srcAttribute.count; i < il; i++) {
+      for (let j = 0; j < srcAttribute.itemSize; j++) {
+        dstAttribute.setComponent(i, j, srcAttribute.getComponent(i, j));
+      }
+    }
+    return dstAttribute;
   }
 };
 
@@ -8249,10 +8665,10 @@ var SceneExporter = class {
   }
 };
 function localMatrix(object) {
-  return object.matrixAutoUpdate ? new import_three20.Matrix4().compose(object.position, object.quaternion, object.scale) : object.matrix.clone();
+  return object.matrixAutoUpdate ? new import_three19.Matrix4().compose(object.position, object.quaternion, object.scale) : object.matrix.clone();
 }
 function createSnapshot(root, gltf, bakeColors = false) {
-  const scene = new import_three20.Scene();
+  const scene = new import_three19.Scene();
   const geometries = [];
   const materials = [];
   const textures = [];
@@ -8270,7 +8686,7 @@ function createSnapshot(root, gltf, bakeColors = false) {
       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_three20.MeshBasicMaterial({
+      material = new import_three19.MeshBasicMaterial({
         map: uniforms.map.value,
         vertexColors: source.vertexColors,
         transparent: source.transparent,
@@ -8280,7 +8696,7 @@ function createSnapshot(root, gltf, bakeColors = false) {
       });
       material.name = source.name;
     } else if (shader.isShaderMaterial) {
-      material = new import_three20.MeshBasicMaterial({ vertexColors: source.vertexColors });
+      material = new import_three19.MeshBasicMaterial({ vertexColors: source.vertexColors });
       material.name = source.name;
     } else {
       const copySource = Object.create(source);
@@ -8334,11 +8750,11 @@ function createSnapshot(root, gltf, bakeColors = false) {
       const material = copyMaterial(sourceMaterial, geometry);
       if (!sourceMaterial.vertexColors) geometry.deleteAttribute("color");
       if (bakeColors || instanceColor) {
-        const tint = (material.color ?? new import_three20.Color()).clone();
+        const tint = (material.color ?? new import_three19.Color()).clone();
         if (instanceColor) tint.multiply(instanceColor);
         if (bakeColors) {
           const original = geometry.getAttribute("color");
-          const colors = new import_three20.Float32BufferAttribute(new Float32Array(geometry.getAttribute("position").count * 3), 3);
+          const colors = new import_three19.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);
           }
@@ -8347,7 +8763,7 @@ function createSnapshot(root, gltf, bakeColors = false) {
           material.color.copy(tint);
         }
       }
-      const copy = new import_three20.Mesh(geometry, material);
+      const copy = new import_three19.Mesh(geometry, material);
       copy.name = mesh.name;
       copy.renderOrder = mesh.renderOrder;
       scene.add(copy);
@@ -8361,9 +8777,9 @@ function createSnapshot(root, gltf, bakeColors = false) {
       const instanced = mesh;
       if (instanced.isInstancedMesh) {
         for (let i = 0; i < instanced.count; i++) {
-          const matrix = new import_three20.Matrix4();
+          const matrix = new import_three19.Matrix4();
           instanced.getMatrixAt(i, matrix);
-          const color = instanced.instanceColor ? new import_three20.Color().fromBufferAttribute(instanced.instanceColor, i) : void 0;
+          const color = instanced.instanceColor ? new import_three19.Color().fromBufferAttribute(instanced.instanceColor, i) : void 0;
           addMesh(mesh, world.clone().multiply(matrix), color);
         }
       } else {
@@ -8375,7 +8791,7 @@ function createSnapshot(root, gltf, bakeColors = false) {
   try {
     const ancestors = [];
     for (let parent = root.parent; parent; parent = parent.parent) ancestors.unshift(parent);
-    const world = new import_three20.Matrix4();
+    const world = new import_three19.Matrix4();
     for (const ancestor of ancestors) {
       if (!ancestor.visible) return { scene, dispose };
       world.multiply(localMatrix(ancestor));
@@ -8389,7 +8805,7 @@ function createSnapshot(root, gltf, bakeColors = false) {
 }
 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_three20.RGBAFormat || texture.type !== import_three20.UnsignedByteType || texture.wrapS !== import_three20.ClampToEdgeWrapping || texture.wrapT !== import_three20.ClampToEdgeWrapping || texture.magFilter !== import_three20.NearestFilter || texture.minFilter !== import_three20.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;
+  if (material.type !== "MeshBasicMaterial" || !material.transparent || !material.depthWrite || material.opacity !== 1 || material.alphaMap || !texture?.isDataTexture || texture.format !== import_three19.RGBAFormat || texture.type !== import_three19.UnsignedByteType || texture.wrapS !== import_three19.ClampToEdgeWrapping || texture.wrapT !== import_three19.ClampToEdgeWrapping || texture.magFilter !== import_three19.NearestFilter || texture.minFilter !== import_three19.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;
@@ -8426,7 +8842,7 @@ function selectAlphaMode(material, geometry) {
 }
 function copyDataTexture(source) {
   const image = source.image;
-  if (source.format !== import_three20.RGBAFormat || source.type !== import_three20.UnsignedByteType) {
+  if (!image.data || source.format !== import_three19.RGBAFormat || source.type !== import_three19.UnsignedByteType) {
     throw new MineRenderError("glTF export requires RGBA unsigned-byte data textures");
   }
   const canvas = createCanvas(image.width, image.height);
@@ -8437,8 +8853,8 @@ function copyDataTexture(source) {
   context.putImageData(pixels, 0, 0);
   const copySource = Object.create(source);
   copySource.userData = {};
-  copySource.source = new import_three20.Source(canvas);
-  return new import_three20.Texture().copy(copySource);
+  copySource.source = new import_three19.TextureSource(canvas);
+  return new import_three19.Texture().copy(copySource);
 }
 
 // src/gui/GuiHelper.ts
@@ -8508,7 +8924,7 @@ var GuiHelper = class {
 };
 
 // src/gui/scene/GuiObject.ts
-var import_three25 = require("three");
+var import_three24 = require("three");
 init_AssetKey();
 init_ModelTextures();
 init_Models();
@@ -8524,7 +8940,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_three25.Box2();
+    this.bounds = new import_three24.Box2();
     this.geometries = /* @__PURE__ */ new Set();
     this.ownedMaterials = /* @__PURE__ */ new Set();
     this.initialized = false;
@@ -8542,17 +8958,17 @@ var GuiObject = class extends SceneObject {
           item.scale.set(width2 / 16, height2 / 16, width2 / 16);
           item.updateWorldMatrix(true, true);
           const inverse = this.matrixWorld.clone().invert();
-          const bounds = new import_three25.Box3();
+          const bounds = new import_three24.Box3();
           item.iterateAllMeshes((mesh2) => {
             mesh2.geometry.computeBoundingBox();
-            bounds.union(mesh2.geometry.boundingBox.clone().applyMatrix4(new import_three25.Matrix4().multiplyMatrices(inverse, mesh2.matrixWorld)));
+            bounds.union(mesh2.geometry.boundingBox.clone().applyMatrix4(new import_three24.Matrix4().multiplyMatrices(inverse, mesh2.matrixWorld)));
           });
           item.position.z = depth - bounds.min.z;
           depth += bounds.max.z - bounds.min.z + 0.01;
-          this.bounds.expandByPoint(new import_three25.Vector2(x, y));
-          this.bounds.expandByPoint(new import_three25.Vector2(x + width2, y + height2));
-          this.bounds.expandByPoint(new import_three25.Vector2(bounds.min.x, -bounds.max.y));
-          this.bounds.expandByPoint(new import_three25.Vector2(bounds.max.x, -bounds.min.y));
+          this.bounds.expandByPoint(new import_three24.Vector2(x, y));
+          this.bounds.expandByPoint(new import_three24.Vector2(x + width2, y + height2));
+          this.bounds.expandByPoint(new import_three24.Vector2(bounds.min.x, -bounds.max.y));
+          this.bounds.expandByPoint(new import_three24.Vector2(bounds.max.x, -bounds.min.y));
           continue;
         }
         const key = typeof layer.texture === "string" ? AssetKey.parse("textures", layer.texture) : layer.texture;
@@ -8560,7 +8976,7 @@ var GuiObject = class extends SceneObject {
         const image = material.map.image;
         const [cropX, cropY, cropWidth, cropHeight] = layer.crop ?? [0, 0, image.width, image.height];
         const [width, height] = layer.size ?? [cropWidth, cropHeight];
-        const geometry = new import_three25.PlaneGeometry(width, height);
+        const geometry = new import_three24.PlaneGeometry(width, height);
         this.geometries.add(geometry);
         const uv = geometry.getAttribute("uv");
         for (let i = 0; i < uv.count; i++) {
@@ -8570,13 +8986,13 @@ var GuiObject = class extends SceneObject {
             1 - (cropY + (1 - uv.getY(i)) * cropHeight) / image.height
           );
         }
-        const mesh = new import_three25.Mesh(geometry, material);
+        const mesh = new import_three24.Mesh(geometry, material);
         mesh.name = `mesh:${layer.name ?? index}`;
         mesh.position.set(x + width / 2, -y - height / 2, depth);
         mesh.renderOrder = index;
         this.add(mesh);
-        this.bounds.expandByPoint(new import_three25.Vector2(x, y));
-        this.bounds.expandByPoint(new import_three25.Vector2(x + width, y + height));
+        this.bounds.expandByPoint(new import_three24.Vector2(x, y));
+        this.bounds.expandByPoint(new import_three24.Vector2(x + width, y + height));
         depth += 0.01;
       }
       for (const child of this.children) child.position.z -= depth - 0.01;
@@ -8651,7 +9067,7 @@ function isGuiObject(obj) {
 init_image();
 
 // src/inspector/SceneInspector.ts
-var import_three26 = require("three");
+var import_three25 = require("three");
 init_SceneObject();
 init_util();
 init_log();
@@ -8661,11 +9077,11 @@ var help = "<span>Ctrl/Cmd+Click to Select<br/></span><br/>";
 var SceneInspector = class {
   constructor(renderer) {
     this.renderer = renderer;
-    this.mouse = new import_three26.Vector2();
+    this.mouse = new import_three25.Vector2();
     this.listeners = new AbortController();
     this.objectInfoContainer = document.createElement("div");
     this.objectControlsContainer = document.createElement("div");
-    this.raycaster = new import_three26.Raycaster();
+    this.raycaster = new import_three25.Raycaster();
     this.init();
   }
   init() {
@@ -9068,7 +9484,7 @@ init_ModelMerger();
 init_SpecialItems();
 
 // src/model/block/BlockStateResolver.ts
-var import_three28 = require("three");
+var import_three27 = require("three");
 init_BlockStates();
 init_MineRenderError();
 init_util();
@@ -9146,7 +9562,7 @@ var BlockStateResolver = class {
     return variants[variants.length - 1];
   }
   static rotation(variant) {
-    const rotation = new import_three28.Euler();
+    const rotation = new import_three27.Euler();
     if (typeof variant.x !== "undefined") {
       rotation.x = toRadians(clampRotationDegrees(variant.x));
     }
@@ -9238,7 +9654,7 @@ init_SceneObject();
 init_ModelObject();
 init_Models();
 var import_ts_deepmerge6 = __toESM(require_dist());
-var import_three31 = require("three");
+var import_three30 = require("three");
 init_MineRenderError();
 init_InstanceReference();
 init_AssetKey();
@@ -9260,7 +9676,7 @@ var _BlockObject = class _BlockObject extends SceneObject {
     this._models = [];
     this._cullMask = 0;
     this._entities = [];
-    this._entityPlacement = new import_three31.Matrix4();
+    this._entityPlacement = new import_three30.Matrix4();
     this._entityGeneration = 0;
     this.options = (0, import_ts_deepmerge6.default)({}, _BlockObject.DEFAULT_OPTIONS, options ?? {});
   }
@@ -9356,7 +9772,7 @@ var _BlockObject = class _BlockObject extends SceneObject {
     return true;
   }
   placeEntities() {
-    const matrix = new import_three31.Matrix4().makeTranslation(this.position.x - 8, this.position.y - 8, this.position.z - 8).multiply(this._entityPlacement);
+    const matrix = new import_three30.Matrix4().makeTranslation(this.position.x - 8, this.position.y - 8, this.position.z - 8).multiply(this._entityPlacement);
     for (const entity of this._entities) {
       matrix.decompose(entity.position, entity.quaternion, entity.scale);
     }
@@ -9378,12 +9794,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_three31.Vector3();
-    const rotation = new import_three31.Quaternion();
-    const scale = new import_three31.Vector3();
+    const position = new import_three30.Vector3();
+    const rotation = new import_three30.Quaternion();
+    const scale = new import_three30.Vector3();
     this.getModelMatrix(model).decompose(position, rotation, scale);
-    if (position.distanceToSquared(this.position) > 1e-10 || scale.distanceToSquared(new import_three31.Vector3(1, 1, 1)) > 1e-10) return 0;
-    return ModelCulling.toLocalMask(worldMask, new import_three31.Euler().setFromQuaternion(rotation));
+    if (position.distanceToSquared(this.position) > 1e-10 || scale.distanceToSquared(new import_three30.Vector3(1, 1, 1)) > 1e-10) return 0;
+    return ModelCulling.toLocalMask(worldMask, new import_three30.Euler().setFromQuaternion(rotation));
   }
   async setCullMask(worldMask) {
     worldMask &= 63;
@@ -9407,6 +9823,7 @@ var _BlockObject = class _BlockObject extends SceneObject {
           replacement.setMatrix(matrix);
         } else {
           replacement.matrix.copy(matrix);
+          replacement.matrixWorldNeedsUpdate = true;
           matrix.decompose(replacement.position, replacement.quaternion, replacement.scale);
           replacement.matrixAutoUpdate = object.matrixAutoUpdate;
           replacement.visible = object.visible;
@@ -9448,7 +9865,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_three31.Matrix4().makeTranslation(...this.position.toArray());
+    const matrix = previous ? this.getModelMatrix(previous) : new import_three30.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);
@@ -9590,7 +10007,7 @@ var _BlockObject = class _BlockObject extends SceneObject {
   setPositionRotationScaleAt(index, position, rotation, scale) {
     super.setPositionRotationScaleAt(index, position, rotation, scale);
   }
-  getMatrixAt(index, matrix = new import_three31.Matrix4()) {
+  getMatrixAt(index, matrix = new import_three30.Matrix4()) {
     if (!this.isInstanced) throw new MineRenderError("Object is not instanced");
     const child = this._models[0];
     if (child && isModelObject(child)) {
@@ -11466,7 +11883,7 @@ init_ModelObject();
 init_nbt();
 
 // src/renderer/MineRenderScene.ts
-var import_three33 = require("three");
+var import_three32 = require("three");
 init_SceneObject();
 var import_ts_deepmerge8 = __toESM(require_dist());
 init_ModelObject();
@@ -12199,7 +12616,7 @@ var import_ts_deepmerge7 = __toESM(require_dist());
 init_util();
 
 // src/skin/SkinTextures.ts
-var import_three32 = require("three");
+var import_three31 = require("three");
 init_Caching();
 init_CacheKey();
 init_MineRenderError();
@@ -12283,11 +12700,11 @@ var SkinTextures = class {
     });
   }
   static createMaterial(pixels, width, height, transparent = true) {
-    const texture = Textures.initTextureProps(new import_three32.DataTexture(pixels, width, height));
-    texture.colorSpace = import_three32.SRGBColorSpace;
+    const texture = Textures.initTextureProps(new import_three31.DataTexture(pixels, width, height));
+    texture.colorSpace = import_three31.SRGBColorSpace;
     texture.flipY = true;
     texture.needsUpdate = true;
-    return new import_three32.MeshBasicMaterial({ map: texture, transparent, side: transparent ? import_three32.DoubleSide : import_three32.FrontSide, alphaTest: transparent ? 0.1 : 0 });
+    return new import_three31.MeshBasicMaterial({ map: texture, transparent, side: transparent ? import_three31.DoubleSide : import_three31.FrontSide, alphaTest: transparent ? 0.1 : 0 });
   }
   static isSlim(image, scale) {
     for (const [x, y] of [[46, 52], [54, 20]]) {
@@ -12517,7 +12934,7 @@ var SkinObject = class extends SceneObject {
 // src/renderer/MineRenderScene.ts
 init_EntityObject();
 init_ItemTints();
-var _MineRenderScene = class _MineRenderScene extends import_three33.Scene {
+var _MineRenderScene = class _MineRenderScene extends import_three32.Scene {
   constructor(options) {
     super();
     this.isMineRenderScene = true;
@@ -12560,12 +12977,13 @@ var _MineRenderScene = class _MineRenderScene extends import_three33.Scene {
   }
   updateObjectRegistration(object, attached) {
     if (this.observedObjects.has(object) === attached) return;
+    const observable = object;
     if (attached) {
       this.observedObjects.add(object);
-      object.addEventListener("change", this.onObjectChange);
+      observable.addEventListener("change", this.onObjectChange);
     } else {
       this.observedObjects.delete(object);
-      object.removeEventListener("change", this.onObjectChange);
+      observable.removeEventListener("change", this.onObjectChange);
     }
     const change = attached ? 1 : -1;
     this.stats.objectCount += change;
@@ -12645,7 +13063,7 @@ function isMineRenderScene(obj) {
 }
 
 // src/renderer/Renderer.ts
-var import_three35 = require("three");
+var import_three34 = require("three");
 var import_ts_deepmerge9 = __toESM(require_dist());
 var import_stats = __toESM(require("stats.js"));
 var import_postprocessing = require("postprocessing");
@@ -12654,11 +13072,11 @@ init_Model();
 init_three();
 
 // src/three/OrbitControls.js
-var import_three34 = require("three");
+var import_three33 = require("three");
 var _changeEvent = { type: "change" };
 var _startEvent = { type: "start" };
 var _endEvent = { type: "end" };
-var OrbitControls = class extends import_three34.EventDispatcher {
+var OrbitControls = class extends import_three33.EventDispatcher {
   constructor(object, domElement) {
     super();
     if (domElement === void 0) console.warn('THREE.OrbitControls: The second parameter "domElement" is now mandatory.');
@@ -12667,7 +13085,7 @@ var OrbitControls = class extends import_three34.EventDispatcher {
     this.domElement = domElement;
     this.domElement.style.touchAction = "none";
     this.enabled = true;
-    this.target = new import_three34.Vector3();
+    this.target = new import_three33.Vector3();
     this.minDistance = 0;
     this.maxDistance = Infinity;
     this.minZoom = 0;
@@ -12689,8 +13107,8 @@ var OrbitControls = class extends import_three34.EventDispatcher {
     this.autoRotate = false;
     this.autoRotateSpeed = 2;
     this.keys = { LEFT: "ArrowLeft", UP: "ArrowUp", RIGHT: "ArrowRight", BOTTOM: "ArrowDown" };
-    this.mouseButtons = { LEFT: import_three34.MOUSE.ROTATE, MIDDLE: import_three34.MOUSE.DOLLY, RIGHT: import_three34.MOUSE.PAN };
-    this.touches = { ONE: import_three34.TOUCH.ROTATE, TWO: import_three34.TOUCH.DOLLY_PAN };
+    this.mouseButtons = { LEFT: import_three33.MOUSE.ROTATE, MIDDLE: import_three33.MOUSE.DOLLY, RIGHT: import_three33.MOUSE.PAN };
+    this.touches = { ONE: import_three33.TOUCH.ROTATE, TWO: import_three33.TOUCH.DOLLY_PAN };
     this.target0 = this.target.clone();
     this.position0 = this.object.position.clone();
     this.zoom0 = this.object.zoom;
@@ -12719,11 +13137,11 @@ var OrbitControls = class extends import_three34.EventDispatcher {
       state = STATE.NONE;
     };
     this.update = function() {
-      const offset = new import_three34.Vector3();
-      const quat = new import_three34.Quaternion().setFromUnitVectors(object.up, new import_three34.Vector3(0, 1, 0));
+      const offset = new import_three33.Vector3();
+      const quat = new import_three33.Quaternion().setFromUnitVectors(object.up, new import_three33.Vector3(0, 1, 0));
       const quatInverse = quat.clone().invert();
-      const lastPosition = new import_three34.Vector3();
-      const lastQuaternion = new import_three34.Quaternion();
+      const lastPosition = new import_three33.Vector3();
+      const lastQuaternion = new import_three33.Quaternion();
       const twoPI = 2 * Math.PI;
       return function update() {
         const position = scope.object.position;
@@ -12809,20 +13227,20 @@ var OrbitControls = class extends import_three34.EventDispatcher {
     };
     let state = STATE.NONE;
     const EPS = 1e-6;
-    const spherical = new import_three34.Spherical();
-    const sphericalDelta = new import_three34.Spherical();
+    const spherical = new import_three33.Spherical();
+    const sphericalDelta = new import_three33.Spherical();
     let scale = 1;
-    const panOffset = new import_three34.Vector3();
+    const panOffset = new import_three33.Vector3();
     let zoomChanged = false;
-    const rotateStart = new import_three34.Vector2();
-    const rotateEnd = new import_three34.Vector2();
-    const rotateDelta = new import_three34.Vector2();
-    const panStart = new import_three34.Vector2();
-    const panEnd = new import_three34.Vector2();
-    const panDelta = new import_three34.Vector2();
-    const dollyStart = new import_three34.Vector2();
-    const dollyEnd = new import_three34.Vector2();
-    const dollyDelta = new import_three34.Vector2();
+    const rotateStart = new import_three33.Vector2();
+    const rotateEnd = new import_three33.Vector2();
+    const rotateDelta = new import_three33.Vector2();
+    const panStart = new import_three33.Vector2();
+    const panEnd = new import_three33.Vector2();
+    const panDelta = new import_three33.Vector2();
+    const dollyStart = new import_three33.Vector2();
+    const dollyEnd = new import_three33.Vector2();
+    const dollyDelta = new import_three33.Vector2();
     const pointers = [];
     const pointerPositions = {};
     function getAutoRotationAngle() {
@@ -12838,7 +13256,7 @@ var OrbitControls = class extends import_three34.EventDispatcher {
       sphericalDelta.phi -= angle;
     }
     const panLeft = function() {
-      const v = new import_three34.Vector3();
+      const v = new import_three33.Vector3();
       return function panLeft2(distance, objectMatrix) {
         v.setFromMatrixColumn(objectMatrix, 0);
         v.multiplyScalar(-distance);
@@ -12846,7 +13264,7 @@ var OrbitControls = class extends import_three34.EventDispatcher {
       };
     }();
     const panUp = function() {
-      const v = new import_three34.Vector3();
+      const v = new import_three33.Vector3();
       return function panUp2(distance, objectMatrix) {
         if (scope.screenSpacePanning === true) {
           v.setFromMatrixColumn(objectMatrix, 1);
@@ -12859,7 +13277,7 @@ var OrbitControls = class extends import_three34.EventDispatcher {
       };
     }();
     const pan = function() {
-      const offset = new import_three34.Vector3();
+      const offset = new import_three33.Vector3();
       return function pan2(deltaX, deltaY) {
         const element = scope.domElement;
         if (scope.object.isPerspectiveCamera) {
@@ -13108,12 +13526,12 @@ var OrbitControls = class extends import_three34.EventDispatcher {
           mouseAction = -1;
       }
       switch (mouseAction) {
-        case import_three34.MOUSE.DOLLY:
+        case import_three33.MOUSE.DOLLY:
           if (scope.enableZoom === false) return;
           handleMouseDownDolly(event);
           state = STATE.DOLLY;
           break;
-        case import_three34.MOUSE.ROTATE:
+        case import_three33.MOUSE.ROTATE:
           if (event.ctrlKey || event.metaKey || event.shiftKey) {
             if (scope.enablePan === false) return;
             handleMouseDownPan(event);
@@ -13124,7 +13542,7 @@ var OrbitControls = class extends import_three34.EventDispatcher {
             state = STATE.ROTATE;
           }
           break;
-        case import_three34.MOUSE.PAN:
+        case import_three33.MOUSE.PAN:
           if (event.ctrlKey || event.metaKey || event.shiftKey) {
             if (scope.enableRotate === false) return;
             handleMouseDownRotate(event);
@@ -13180,12 +13598,12 @@ var OrbitControls = class extends import_three34.EventDispatcher {
       switch (pointers.length) {
         case 1:
           switch (scope.touches.ONE) {
-            case import_three34.TOUCH.ROTATE:
+            case import_three33.TOUCH.ROTATE:
               if (scope.enableRotate === false) return;
               handleTouchStartRotate();
               state = STATE.TOUCH_ROTATE;
               break;
-            case import_three34.TOUCH.PAN:
+            case import_three33.TOUCH.PAN:
               if (scope.enablePan === false) return;
               handleTouchStartPan();
               state = STATE.TOUCH_PAN;
@@ -13196,12 +13614,12 @@ var OrbitControls = class extends import_three34.EventDispatcher {
           break;
         case 2:
           switch (scope.touches.TWO) {
-            case import_three34.TOUCH.DOLLY_PAN:
+            case import_three33.TOUCH.DOLLY_PAN:
               if (scope.enableZoom === false && scope.enablePan === false) return;
               handleTouchStartDollyPan();
               state = STATE.TOUCH_DOLLY_PAN;
               break;
-            case import_three34.TOUCH.DOLLY_ROTATE:
+            case import_three33.TOUCH.DOLLY_ROTATE:
               if (scope.enableZoom === false && scope.enableRotate === false) return;
               handleTouchStartDollyRotate();
               state = STATE.TOUCH_DOLLY_ROTATE;
@@ -13268,7 +13686,7 @@ var OrbitControls = class extends import_three34.EventDispatcher {
     function trackPointer(event) {
       let position = pointerPositions[event.pointerId];
       if (position === void 0) {
-        position = new import_three34.Vector2();
+        position = new import_three33.Vector2();
         pointerPositions[event.pointerId] = position;
       }
       position.set(event.pageX, event.pageY);
@@ -13288,10 +13706,10 @@ var MapControls = class extends OrbitControls {
   constructor(object, domElement) {
     super(object, domElement);
     this.screenSpacePanning = false;
-    this.mouseButtons.LEFT = import_three34.MOUSE.PAN;
-    this.mouseButtons.RIGHT = import_three34.MOUSE.ROTATE;
-    this.touches.ONE = import_three34.TOUCH.PAN;
-    this.touches.TWO = import_three34.TOUCH.DOLLY_ROTATE;
+    this.mouseButtons.LEFT = import_three33.MOUSE.PAN;
+    this.mouseButtons.RIGHT = import_three33.MOUSE.ROTATE;
+    this.touches.ONE = import_three33.TOUCH.PAN;
+    this.touches.TWO = import_three33.TOUCH.DOLLY_ROTATE;
   }
 };
 
@@ -13342,14 +13760,14 @@ var _Renderer = class _Renderer {
     switch (this.options.camera.type) {
       case "perspective":
       default:
-        return new import_three35.PerspectiveCamera(
+        return new import_three34.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_three35.OrthographicCamera(
+        return new import_three34.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,
@@ -13360,7 +13778,7 @@ var _Renderer = class _Renderer {
     }
   }
   createRenderer() {
-    const renderer = new import_three35.WebGLRenderer({
+    const renderer = new import_three34.WebGLRenderer({
       antialias: this.options.render.antialias,
       alpha: true,
       powerPreference: "high-performance",
@@ -13368,8 +13786,8 @@ var _Renderer = class _Renderer {
     });
     renderer.setClearColor(0, 0);
     renderer.shadowMap.enabled = true;
-    renderer.shadowMap.type = import_three35.PCFSoftShadowMap;
-    renderer.outputColorSpace = import_three35.SRGBColorSpace;
+    renderer.shadowMap.type = import_three34.PCFShadowMap;
+    renderer.outputColorSpace = import_three34.SRGBColorSpace;
     renderer.setPixelRatio(this.options.render.pixelRatio ?? 1);
     renderer.setSize(this.viewWidth, this.viewHeight);
     return renderer;
@@ -13404,20 +13822,20 @@ var _Renderer = class _Renderer {
       window["__THREE_DEVTOOLS__"].dispatchEvent(new CustomEvent("observe", { detail: this.scene }));
     }
     if (this.options.debug.grid) {
-      const gridHelper = new import_three35.GridHelper(128, 16);
+      const gridHelper = new import_three34.GridHelper(128, 16);
       this._debugHelpers.push(gridHelper);
       this.scene.add(gridHelper);
-      const gridHelper2 = new import_three35.GridHelper(128, 16);
+      const gridHelper2 = new import_three34.GridHelper(128, 16);
       this._debugHelpers.push(gridHelper2);
       gridHelper2.rotation.x = 90 * (Math.PI / 180);
       this.scene.add(gridHelper2);
-      const gridHelper3 = new import_three35.GridHelper(128, 16);
+      const gridHelper3 = new import_three34.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_three35.AxesHelper(64);
+      const axesHelper = new import_three34.AxesHelper(64);
       this._debugHelpers.push(axesHelper);
       this.scene.add(axesHelper);
     }
@@ -13676,8 +14094,8 @@ _Renderer.DEFAULT_OPTIONS = (0, import_ts_deepmerge9.default)({}, {
       top: void 0,
       bottom: void 0
     },
-    position: new import_three35.Vector3(50, 50, 50),
-    lookingAt: new import_three35.Vector3(0, 0, 0)
+    position: new import_three34.Vector3(50, 50, 50),
+    lookingAt: new import_three34.Vector3(0, 0, 0)
   },
   render: {
     fpsLimit: 60,
@@ -14142,12 +14560,12 @@ var AnvilParser = class {
 };
 
 // src/world/Chunk.ts
-var import_three40 = require("three");
+var import_three39 = require("three");
 init_BlockStates();
 init_AssetKey();
 
 // src/world/MineRenderWorld.ts
-var import_three38 = require("three");
+var import_three37 = require("three");
 init_Model();
 init_BatchedExecutor();
 init_AssetKey();
@@ -14155,7 +14573,7 @@ init_BlockStates();
 init_CubeFace();
 
 // src/world/SectionModels.ts
-var import_three37 = require("three");
+var import_three36 = require("three");
 init_AssetKey();
 init_Models();
 init_CubeFace();
@@ -14221,12 +14639,12 @@ var SectionModels = class {
         });
         await object.init();
         const geometry = object.children[0].geometry;
-        geometry.applyMatrix4(new import_three37.Matrix4().makeRotationFromEuler(rotation));
+        geometry.applyMatrix4(new import_three36.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_three37.Vector3(...CUBE_FACE_OFFSETS[local]).applyEuler(rotation);
+          const normal = new import_three36.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;
         });
@@ -14256,20 +14674,20 @@ var MineRenderWorld = class {
   }
   getBlockAt(posOrX, y, z) {
     if (typeof posOrX == "number") {
-      return this.getBlockAt(new import_three38.Vector3(posOrX, y, z));
+      return this.getBlockAt(new import_three37.Vector3(posOrX, y, z));
     }
     if (isTripleArray(posOrX)) {
-      return this.getBlockAt(new import_three38.Vector3(posOrX[0], posOrX[1], posOrX[2]));
+      return this.getBlockAt(new import_three37.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_three38.Vector3(posOrX, yOrBlock, z), block);
+      return this.setBlockAt(new import_three37.Vector3(posOrX, yOrBlock, z), block);
     }
     if (isTripleArray(posOrX)) {
-      return this.setBlockAt(new import_three38.Vector3(posOrX[0], posOrX[1], posOrX[2]), yOrBlock);
+      return this.setBlockAt(new import_three37.Vector3(posOrX[0], posOrX[1], posOrX[2]), yOrBlock);
     }
     return this.placeBlock(posOrX, yOrBlock);
   }
@@ -14280,10 +14698,10 @@ var MineRenderWorld = class {
   }
   async setBlockVisibleAt(posOrX, yOrVisible, z, visible) {
     if (typeof posOrX === "number") {
-      return this.setBlockVisibleAt(new import_three38.Vector3(posOrX, yOrVisible, z), visible);
+      return this.setBlockVisibleAt(new import_three37.Vector3(posOrX, yOrVisible, z), visible);
     }
     if (isTripleArray(posOrX)) {
-      return this.setBlockVisibleAt(new import_three38.Vector3(...posOrX), yOrVisible);
+      return this.setBlockVisibleAt(new import_three37.Vector3(...posOrX), yOrVisible);
     }
     this.validatePosBounds(posOrX);
     await this.getChunkAt(posOrX)?.setBlockVisibleAt(posOrX, yOrVisible);
@@ -14300,7 +14718,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_three38.Vector3(...block.position), block, collect);
+    const place = (block) => this.placeBlock(new import_three37.Vector3(...block.position), block, collect);
     const keys = /* @__PURE__ */ new Map();
     for (const block of multiblock.blocks) {
       if (Chunk.isAir(block)) continue;
@@ -14378,13 +14796,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_three38.Vector3(...offset));
+        const neighbor = pos.clone().add(new import_three37.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_three38.Vector3(x, y, z));
+            const neighbor = pos.clone().add(new import_three37.Vector3(x, y, z));
             if (this.getBlockAt(neighbor)?.object?.fluidKind) {
               this.pendingCulling.set(neighbor.toArray().join(","), neighbor);
             }
@@ -14408,7 +14826,7 @@ var MineRenderWorld = class {
             }
             if (block.object?.fluidKind) {
               await block.object.updateFluid((x, y, z) => {
-                const neighbor = pos.clone().add(new import_three38.Vector3(x, y, z));
+                const neighbor = pos.clone().add(new import_three37.Vector3(x, y, z));
                 const section = this.getChunkAt(neighbor);
                 const object = section?.isBlockVisibleAt(neighbor) ? section.getBlockAt(neighbor)?.object : void 0;
                 return {
@@ -14420,7 +14838,7 @@ var MineRenderWorld = class {
             }
             let mask = 0;
             for (const [face, offset] of CUBE_FACE_OFFSETS.entries()) {
-              const neighbor = pos.clone().add(new import_three38.Vector3(...offset));
+              const neighbor = pos.clone().add(new import_three37.Vector3(...offset));
               if (this.getChunkAt(neighbor)?.isOccludingAt(neighbor)) {
                 mask |= 1 << face;
               }
@@ -14454,14 +14872,14 @@ var MineRenderWorld = class {
     return this._chunks.get(this.worldPosToChunkKey(pos));
   }
   static worldToScenePosition(pos) {
-    return new import_three38.Vector3(
+    return new import_three37.Vector3(
       pos.x * 16,
       pos.y * 16,
       pos.z * 16
     );
   }
   static sceneToWorldPosition(pos) {
-    return new import_three38.Vector3(
+    return new import_three37.Vector3(
       pos.x / 16,
       pos.y / 16,
       pos.z / 16
@@ -14484,10 +14902,10 @@ var MineRenderWorld = class {
 init_Model();
 
 // src/world/SectionMesh.ts
-var import_three39 = require("three");
+var import_three38 = require("three");
 init_CanvasCompat();
 init_Materials();
-var SectionMesh = class _SectionMesh extends import_three39.Group {
+var SectionMesh = class _SectionMesh extends import_three38.Group {
   constructor() {
     super(...arguments);
     this.ownedMeshes = [];
@@ -14560,18 +14978,18 @@ var SectionMesh = class _SectionMesh extends import_three39.Group {
           for (let corner = 0; corner < 6; corner++) indices.push(start + sourceIndices.getX(face * 6 + corner) - face * 4);
         }
       }
-      const geometry = new import_three39.BufferGeometry();
-      geometry.setAttribute("position", new import_three39.Float32BufferAttribute(positions, 3));
-      geometry.setAttribute("normal", new import_three39.Float32BufferAttribute(normals, 3));
-      geometry.setAttribute("uv", new import_three39.Float32BufferAttribute(uvs, 2));
-      geometry.setAttribute("color", new import_three39.Float32BufferAttribute(colors, 3));
+      const geometry = new import_three38.BufferGeometry();
+      geometry.setAttribute("position", new import_three38.Float32BufferAttribute(positions, 3));
+      geometry.setAttribute("normal", new import_three38.Float32BufferAttribute(normals, 3));
+      geometry.setAttribute("uv", new import_three38.Float32BufferAttribute(uvs, 2));
+      geometry.setAttribute("color", new import_three38.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_three39.Mesh(geometry, material);
+      const mesh = new import_three38.Mesh(geometry, material);
       section.add(mesh);
       section.ownedMeshes.push({ mesh, texture });
     }
@@ -14585,6 +15003,7 @@ var SectionMesh = class _SectionMesh extends import_three39.Group {
       texture?.dispose();
     }
     this.removeFromParent();
+    super.dispose();
   }
 };
 
@@ -14606,10 +15025,10 @@ var Chunk = class _Chunk {
   }
   getBlockAt(posOrX, y, z) {
     if (typeof posOrX == "number") {
-      return this.getBlockAt(new import_three40.Vector3(posOrX, y, z));
+      return this.getBlockAt(new import_three39.Vector3(posOrX, y, z));
     }
     if (isTripleArray(posOrX)) {
-      return this.getBlockAt(new import_three40.Vector3(posOrX[0], posOrX[1], posOrX[2]));
+      return this.getBlockAt(new import_three39.Vector3(posOrX[0], posOrX[1], posOrX[2]));
     }
     const pos = this.worldPosToChunkPos(posOrX);
     const index = _Chunk.chunkPosToBlockIndex(pos);
@@ -14617,10 +15036,10 @@ var Chunk = class _Chunk {
   }
   async setBlockAt(posOrX, yOrBlock, z, block) {
     if (typeof posOrX == "number") {
-      return this.setBlockAt(new import_three40.Vector3(posOrX, yOrBlock, z), block);
+      return this.setBlockAt(new import_three39.Vector3(posOrX, yOrBlock, z), block);
     }
     if (isTripleArray(posOrX)) {
-      return this.setBlockAt(new import_three40.Vector3(posOrX[0], posOrX[1], posOrX[2]), yOrBlock);
+      return this.setBlockAt(new import_three39.Vector3(posOrX[0], posOrX[1], posOrX[2]), yOrBlock);
     }
     const worldPos = posOrX;
     const pos = this.worldPosToChunkPos(worldPos);
@@ -14732,7 +15151,7 @@ var Chunk = class _Chunk {
   }
   async clear(onBlocksChanged = this.onBlocksChanged) {
     const positions = [...this.renderedBlocks.keys()].map((index) => this.chunkPosToWorldPos(
-      new import_three40.Vector3(index % 16, Math.floor(index / 256), Math.floor(index / 16) % 16)
+      new import_three39.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();
@@ -14757,14 +15176,14 @@ var Chunk = class _Chunk {
     return pos.y * 16 * 16 + pos.z * 16 + pos.x;
   }
   worldPosToChunkPos(pos) {
-    return new import_three40.Vector3(
+    return new import_three39.Vector3(
       pos.x - this.x * 16,
       pos.y - this.y * 16,
       pos.z - this.z * 16
     );
   }
   chunkPosToWorldPos(pos) {
-    return new import_three40.Vector3(
+    return new import_three39.Vector3(
       this.x * 16 + pos.x,
       this.y * 16 + pos.y,
       this.z * 16 + pos.z