minerender 2.1.0-alpha.53 → 2.1.0-alpha.55

package/dist/node/index.js

@@ -291,6 +291,12 @@ var init_Caching = __esm({
       static {
         this.entityTextureCache = _Caching.createAssetCache();
       }
+      static {
+        this.entityAnimationCache = _Caching.createAssetCache();
+      }
+      static {
+        this.blockEntityIndexCache = _Caching.createAssetCache();
+      }
       static createAssetCache() {
         return import_loading_cache.Caches.builder().expireAfterWrite(import_time.Time.minutes(10)).expireAfterAccess(import_time.Time.minutes(5)).expirationInterval(import_time.Time.seconds(30)).buildAsync();
       }
@@ -315,7 +321,9 @@ var init_Caching = __esm({
           this.defaultBlockStatesCache,
           this.blockTintCache,
           this.entityModelCache,
-          this.entityTextureCache
+          this.entityTextureCache,
+          this.entityAnimationCache,
+          this.blockEntityIndexCache
         ];
       }
       static clear() {
@@ -886,6 +894,71 @@ var init_Materials = __esm({
           alphaTest: 0.5
         });
       }
+      /** Whether vanilla's render type for the mode culls back faces. */
+      static entityModeCulls(mode = "cutout") {
+        return mode === "cutout_cull" || mode === "solid" || mode === "eyes" || mode === "water_mask";
+      }
+      /** UV offset per tick of entity age for the scrolling modes, as vanilla's texture matrix applies it. */
+      static entityModeScroll(mode = "cutout") {
+        if (mode === "energy_swirl") return [0.01, 0.01];
+        if (mode === "breeze_wind") return [0.02, 0];
+        return void 0;
+      }
+      /**
+       * Entity material for one of vanilla's render types. Entities are unlit here, so the lit and full-bright modes
+       * differ only in blending and depth state. Culling is not a material property: {@link entityModeCulls} decides
+       * whether the geometry gets inward faces.
+       */
+      static createEntityCanvasMaterial(canvas, mode = "cutout", tint) {
+        const material = _Materials.createBasicCanvasMaterial(canvas);
+        switch (mode) {
+          case "cutout":
+          case "cutout_cull":
+            break;
+          case "cutout_z_offset":
+            material.polygonOffset = true;
+            material.polygonOffsetFactor = -1;
+            material.polygonOffsetUnits = -10;
+            break;
+          case "solid":
+            material.alphaTest = 0;
+            break;
+          case "translucent":
+          case "breeze_wind":
+            material.transparent = true;
+            material.alphaTest = 0.1;
+            break;
+          case "translucent_emissive":
+            material.transparent = true;
+            material.alphaTest = 0.1;
+            material.depthWrite = false;
+            break;
+          case "eyes":
+            material.transparent = true;
+            material.alphaTest = 0;
+            material.depthWrite = false;
+            break;
+          case "energy_swirl":
+            material.transparent = true;
+            material.alphaTest = 0.1;
+            material.blending = import_three5.CustomBlending;
+            material.blendSrc = import_three5.OneFactor;
+            material.blendDst = import_three5.OneFactor;
+            material.blendSrcAlpha = import_three5.ZeroFactor;
+            material.blendDstAlpha = import_three5.OneFactor;
+            material.color.set(8421504);
+            break;
+          case "water_mask":
+            material.alphaTest = 0;
+            material.colorWrite = false;
+            break;
+        }
+        if (_Materials.entityModeScroll(mode)) {
+          material.map.wrapS = material.map.wrapT = import_three5.RepeatWrapping;
+        }
+        if (tint !== void 0) material.color.multiply(new import_three5.Color(tint));
+        return material;
+      }
       static createGuiCanvasMaterial(canvas) {
         const material = new import_three5.MeshBasicMaterial({
           map: Textures.createCanvasTexture(canvas),
@@ -3101,10 +3174,10 @@ var init_InstanceReference = __esm({
 function isSceneObject(obj) {
   return obj.isSceneObject;
 }
-var import_three10, import_ts_deepmerge3, p6, SceneObject;
+var import_three11, import_ts_deepmerge3, p6, SceneObject;
 var init_SceneObject = __esm({
   "src/renderer/SceneObject.ts"() {
-    import_three10 = require("three");
+    import_three11 = require("three");
     init_Geometries();
     init_UVMapper();
     init_Axis();
@@ -3116,7 +3189,7 @@ var init_SceneObject = __esm({
     import_ts_deepmerge3 = __toESM(require_dist());
     init_log();
     p6 = prefix("SceneObject");
-    SceneObject = class _SceneObject extends import_three10.Object3D {
+    SceneObject = class _SceneObject extends import_three11.Object3D {
       constructor(options) {
         super();
         this.isSceneObject = true;
@@ -3168,7 +3241,7 @@ var init_SceneObject = __esm({
         return group;
       }
       createGroup(name, x = 0, y = 0, z = 0, offsetAxis, offset = 0) {
-        const obj = new import_three10.Object3D();
+        const obj = new import_three11.Object3D();
         if (name) {
           obj.name = `group:${name}`;
         }
@@ -3218,7 +3291,7 @@ var init_SceneObject = __esm({
         return mesh;
       }
       createMesh(name, geometry, material, offsetAxis, offset = 0) {
-        const mesh = new import_three10.Mesh(geometry, material);
+        const mesh = new import_three11.Mesh(geometry, material);
         if (name) {
           mesh.name = `mesh:${name}`;
         }
@@ -3230,7 +3303,7 @@ var init_SceneObject = __esm({
         return mesh;
       }
       createInstancedMesh(name, geometry, material, count) {
-        const mesh = new import_three10.InstancedMesh(geometry, material, count);
+        const mesh = new import_three11.InstancedMesh(geometry, material, count);
         mesh.count = 0;
         this.instanceMesh = mesh;
         this._isInstanced = true;
@@ -3310,11 +3383,11 @@ var init_SceneObject = __esm({
         this._instanceCounter = this.instanceReferences.size;
         mesh.count = Math.max(mesh.count, index + 1);
         if (mesh.instanceColor) {
-          mesh.setColorAt(index, new import_three10.Color(16777215));
+          mesh.setColorAt(index, new import_three11.Color(16777215));
           mesh.instanceColor.needsUpdate = true;
         }
         if (this._scene) this._scene.stats.instanceCount++;
-        this.setMatrixAt(index, new import_three10.Matrix4());
+        this.setMatrixAt(index, new import_three11.Matrix4());
         return reference;
       }
       /** Returns the live reference for a raycast hit on this object's instance mesh. */
@@ -3327,7 +3400,7 @@ var init_SceneObject = __esm({
       removeInstanceAt(index) {
         if (!this.instanceReferences.has(index)) return;
         const mesh = this.instanceMesh;
-        this.setMatrixAt(index, new import_three10.Matrix4().makeScale(0, 0, 0));
+        this.setMatrixAt(index, new import_three11.Matrix4().makeScale(0, 0, 0));
         this.instanceReferences.delete(index);
         this.freeInstanceIndices.push(index);
         this._instanceCounter = this.instanceReferences.size;
@@ -3340,7 +3413,7 @@ var init_SceneObject = __esm({
         const grow = (attribute, fill) => {
           const array = new Float32Array(capacity * attribute.itemSize).fill(fill);
           array.set(attribute.array);
-          return new import_three10.InstancedBufferAttribute(array, attribute.itemSize, attribute.normalized, attribute.meshPerAttribute).setUsage(attribute.usage);
+          return new import_three11.InstancedBufferAttribute(array, attribute.itemSize, attribute.normalized, attribute.meshPerAttribute).setUsage(attribute.usage);
         };
         const matrix = grow(mesh.instanceMatrix, 0);
         const color = mesh.instanceColor ? grow(mesh.instanceColor, 1) : null;
@@ -3357,7 +3430,7 @@ var init_SceneObject = __esm({
       }
       //</editor-fold>
       //<editor-fold desc="TRANSFORMATION">
-      getMatrixAt(index, matrix = new import_three10.Matrix4()) {
+      getMatrixAt(index, matrix = new import_three11.Matrix4()) {
         if (!this.instanceReferences.has(index)) throw new MineRenderError("Instance is not active");
         this.instanceMesh.getMatrixAt(index, matrix);
         return matrix;
@@ -3373,16 +3446,16 @@ var init_SceneObject = __esm({
       }
       setPositionRotationScaleAt(index, position, rotation, scale) {
         if (!this.isInstanced) throw new MineRenderError("Object is not instanced");
-        const oldPosition = new import_three10.Vector3();
-        const oldRotation = new import_three10.Quaternion();
-        const oldScale = new import_three10.Vector3();
-        const matrix = new import_three10.Matrix4();
+        const oldPosition = new import_three11.Vector3();
+        const oldRotation = new import_three11.Quaternion();
+        const oldScale = new import_three11.Vector3();
+        const matrix = new import_three11.Matrix4();
         if (!scale || !rotation || !position) {
           this.getMatrixAt(index, matrix).decompose(oldPosition, oldRotation, oldScale);
         }
         matrix.compose(
           position ? position : oldPosition,
-          rotation ? new import_three10.Quaternion().setFromEuler(rotation) : oldRotation,
+          rotation ? new import_three11.Quaternion().setFromEuler(rotation) : oldRotation,
           scale ? scale : oldScale
         );
         this.setMatrixAt(index, matrix);
@@ -3391,7 +3464,7 @@ var init_SceneObject = __esm({
         if (!this.isInstanced) throw new MineRenderError("Object is not instanced");
         this.setPositionRotationScaleAt(index, position);
       }
-      getPositionAt(index, vector = new import_three10.Vector3()) {
+      getPositionAt(index, vector = new import_three11.Vector3()) {
         if (!this.isInstanced) throw new MineRenderError("Object is not instanced");
         const matrix = this.getMatrixAt(index);
         vector.setFromMatrixPosition(matrix);
@@ -3401,17 +3474,17 @@ var init_SceneObject = __esm({
         if (!this.isInstanced) throw new MineRenderError("Object is not instanced");
         this.setPositionRotationScaleAt(index, void 0, rotation, void 0);
       }
-      getRotationAt(index, euler = new import_three10.Euler()) {
+      getRotationAt(index, euler = new import_three11.Euler()) {
         if (!this.isInstanced) throw new MineRenderError("Object is not instanced");
-        const rotation = new import_three10.Quaternion();
-        this.getMatrixAt(index).decompose(new import_three10.Vector3(), rotation, new import_three10.Vector3());
+        const rotation = new import_three11.Quaternion();
+        this.getMatrixAt(index).decompose(new import_three11.Vector3(), rotation, new import_three11.Vector3());
         return euler.setFromQuaternion(rotation);
       }
       setScaleAt(index, scale) {
         if (!this.isInstanced) throw new MineRenderError("Object is not instanced");
         this.setPositionRotationScaleAt(index, void 0, void 0, scale);
       }
-      getScaleAt(index, vector = new import_three10.Vector3()) {
+      getScaleAt(index, vector = new import_three11.Vector3()) {
         if (!this.isInstanced) throw new MineRenderError("Object is not instanced");
         const matrix = this.getMatrixAt(index);
         vector.setFromMatrixScale(matrix);
@@ -3547,7 +3620,7 @@ function mergeBufferGeometries(geometries, useGroups = false) {
   const attributes = {};
   const morphAttributes = {};
   const morphTargetsRelative = geometries[0].morphTargetsRelative;
-  const mergedGeometry = new import_three19.BufferGeometry();
+  const mergedGeometry = new import_three20.BufferGeometry();
   let offset = 0;
   for (let i = 0; i < geometries.length; ++i) {
     const geometry = geometries[i];
@@ -3671,7 +3744,7 @@ function mergeBufferAttributes(attributes) {
     array.set(attributes[i].array, offset);
     offset += attributes[i].array.length;
   }
-  return new import_three19.BufferAttribute(array, itemSize, normalized);
+  return new import_three20.BufferAttribute(array, itemSize, normalized);
 }
 function interleaveAttributes(attributes) {
   let TypedArray;
@@ -3687,7 +3760,7 @@ function interleaveAttributes(attributes) {
     arrayLength += attribute.array.length;
     stride += attribute.itemSize;
   }
-  const interleavedBuffer = new import_three19.InterleavedBuffer(new TypedArray(arrayLength), stride);
+  const interleavedBuffer = new import_three20.InterleavedBuffer(new TypedArray(arrayLength), stride);
   let offset = 0;
   const res = [];
   const getters = ["getX", "getY", "getZ", "getW"];
@@ -3696,7 +3769,7 @@ function interleaveAttributes(attributes) {
     const attribute = attributes[j];
     const itemSize = attribute.itemSize;
     const count = attribute.count;
-    const iba = new import_three19.InterleavedBufferAttribute(interleavedBuffer, itemSize, offset, attribute.normalized);
+    const iba = new import_three20.InterleavedBufferAttribute(interleavedBuffer, itemSize, offset, attribute.normalized);
     res.push(iba);
     offset += itemSize;
     for (let c = 0; c < count; c++) {
@@ -3780,13 +3853,13 @@ function mergeVertices(geometry, tolerance = 1e-4) {
     const name = attributeNames[i];
     const oldAttribute = geometry.getAttribute(name);
     const buffer = new oldAttribute.array.constructor(attrArrays[name]);
-    const attribute = new import_three19.BufferAttribute(buffer, oldAttribute.itemSize, oldAttribute.normalized);
+    const attribute = new import_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_three19.BufferAttribute(buffer2, oldMorphAttribute.itemSize, oldMorphAttribute.normalized);
+        const morphAttribute = new import_three20.BufferAttribute(buffer2, oldMorphAttribute.itemSize, oldMorphAttribute.normalized);
         result.morphAttributes[name][j] = morphAttribute;
       }
     }
@@ -3795,11 +3868,11 @@ function mergeVertices(geometry, tolerance = 1e-4) {
   return result;
 }
 function toTrianglesDrawMode(geometry, drawMode) {
-  if (drawMode === import_three19.TrianglesDrawMode) {
+  if (drawMode === import_three20.TrianglesDrawMode) {
     console.warn("THREE.BufferGeometryUtils.toTrianglesDrawMode(): Geometry already defined as triangles.");
     return geometry;
   }
-  if (drawMode === import_three19.TriangleFanDrawMode || drawMode === import_three19.TriangleStripDrawMode) {
+  if (drawMode === import_three20.TriangleFanDrawMode || drawMode === import_three20.TriangleStripDrawMode) {
     let index = geometry.getIndex();
     if (index === null) {
       const indices = [];
@@ -3817,7 +3890,7 @@ function toTrianglesDrawMode(geometry, drawMode) {
     }
     const numberOfTriangles = index.count - 2;
     const newIndices = [];
-    if (drawMode === import_three19.TriangleFanDrawMode) {
+    if (drawMode === import_three20.TriangleFanDrawMode) {
       for (let i = 1; i <= numberOfTriangles; i++) {
         newIndices.push(index.getX(0));
         newIndices.push(index.getX(i));
@@ -3853,15 +3926,15 @@ function computeMorphedAttributes(object) {
     console.error("THREE.BufferGeometryUtils: Geometry is not of type BufferGeometry.");
     return null;
   }
-  const _vA = new import_three19.Vector3();
-  const _vB = new import_three19.Vector3();
-  const _vC = new import_three19.Vector3();
-  const _tempA = new import_three19.Vector3();
-  const _tempB = new import_three19.Vector3();
-  const _tempC = new import_three19.Vector3();
-  const _morphA = new import_three19.Vector3();
-  const _morphB = new import_three19.Vector3();
-  const _morphC = new import_three19.Vector3();
+  const _vA = new import_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);
@@ -4056,8 +4129,8 @@ function computeMorphedAttributes(object) {
       }
     }
   }
-  const morphedPositionAttribute = new import_three19.Float32BufferAttribute(modifiedPosition, 3);
-  const morphedNormalAttribute = new import_three19.Float32BufferAttribute(modifiedNormal, 3);
+  const morphedPositionAttribute = new import_three20.Float32BufferAttribute(modifiedPosition, 3);
+  const morphedNormalAttribute = new import_three20.Float32BufferAttribute(modifiedNormal, 3);
   return {
     positionAttribute,
     normalAttribute,
@@ -4065,24 +4138,24 @@ function computeMorphedAttributes(object) {
     morphedNormalAttribute
   };
 }
-var import_three19;
+var import_three20;
 var init_BufferGeometryUtils = __esm({
   "src/three/BufferGeometryUtils.js"() {
-    import_three19 = require("three");
+    import_three20 = require("three");
   }
 });
 
 // src/model/ModelCulling.ts
-var import_three20, ModelCulling;
+var import_three21, ModelCulling;
 var init_ModelCulling = __esm({
   "src/model/ModelCulling.ts"() {
-    import_three20 = 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_three20.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;
@@ -4118,13 +4191,13 @@ var init_ModelCulling = __esm({
 function isModelObject(obj) {
   return obj.isModelObject;
 }
-var import_three21, import_ts_deepmerge5, p7, ModelObject;
+var import_three22, import_ts_deepmerge5, p7, ModelObject;
 var init_ModelObject = __esm({
   "src/model/scene/ModelObject.ts"() {
     init_SceneObject();
     init_Materials();
     init_UVMapper();
-    import_three21 = require("three");
+    import_three22 = require("three");
     init_BufferGeometryUtils();
     init_model();
     import_ts_deepmerge5 = __toESM(require_dist());
@@ -4181,7 +4254,7 @@ var init_ModelObject = __esm({
                 elGeo.clearGroups();
               }
               if (this.options.uvLockRotation) {
-                UVMapper.lockUvs(elGeo, el.faces, this.atlas, new import_three21.Euler(...this.options.uvLockRotation));
+                UVMapper.lockUvs(elGeo, el.faces, this.atlas, new import_three22.Euler(...this.options.uvLockRotation));
               }
               if (this.options.tints) {
                 const colors = new Float32Array(elGeo.getAttribute("position").count * 3).fill(1);
@@ -4190,19 +4263,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_three21.Color(tint);
+                  const color = new import_three22.Color(tint);
                   for (let vertex = 0; vertex < 4; vertex++) {
                     color.toArray(colors, (faceIndex * 4 + vertex) * 3);
                   }
                 }
-                elGeo.setAttribute("color", new import_three21.BufferAttribute(colors, 3));
+                elGeo.setAttribute("color", new import_three22.BufferAttribute(colors, 3));
               }
-              elGeo.applyMatrix4(new import_three21.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_three21.Matrix4().makeTranslation(el.from[0], el.from[1], el.from[2]));
+              elGeo.applyMatrix4(new import_three22.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_three22.Matrix4().makeTranslation(el.from[0], el.from[1], el.from[2]));
               if (el.rotation) {
                 applyElementRotation(el.rotation, elGeo);
               }
-              elGeo.applyMatrix4(new import_three21.Matrix4().makeTranslation(-8, -8, -8));
+              elGeo.applyMatrix4(new import_three22.Matrix4().makeTranslation(-8, -8, -8));
               if (displayTransform) DisplayTransforms.apply(elGeo, displayTransform);
               if (this.options.mergeMeshes) {
                 allGeos.push(elGeo);
@@ -4224,7 +4297,7 @@ var init_ModelObject = __esm({
           if (allGeos.length > 0) {
             combinedGeo = mergeBufferGeometries(allGeos);
           } else {
-            combinedGeo = new import_three21.BoxGeometry(16, 16, 16);
+            combinedGeo = new import_three22.BoxGeometry(16, 16, 16);
             if (displayTransform) DisplayTransforms.apply(combinedGeo, displayTransform);
           }
           combinedGeo.computeBoundingBox();
@@ -4332,7 +4405,7 @@ function ownHeight(sample) {
   return (level === 0 || level >= 8 ? 8 : 8 - level) / 9;
 }
 function createFluidGeometry(kind, sample) {
-  const geometry = new import_three26.BufferGeometry();
+  const geometry = new import_three27.BufferGeometry();
   const positions = [], normals = [], uvs = [], indices = [];
   const self = sample(0, 0, 0);
   const height = (x, z) => {
@@ -4431,16 +4504,16 @@ function createFluidGeometry(kind, sample) {
       1
     );
   }
-  geometry.setAttribute("position", new import_three26.Float32BufferAttribute(positions, 3));
-  geometry.setAttribute("normal", new import_three26.Float32BufferAttribute(normals, 3));
-  geometry.setAttribute("uv", new import_three26.Float32BufferAttribute(uvs, 2));
+  geometry.setAttribute("position", new import_three27.Float32BufferAttribute(positions, 3));
+  geometry.setAttribute("normal", new import_three27.Float32BufferAttribute(normals, 3));
+  geometry.setAttribute("uv", new import_three27.Float32BufferAttribute(uvs, 2));
   geometry.setIndex(indices);
   return geometry;
 }
-var import_three26, fluidRules, HORIZONTAL, EPSILON;
+var import_three27, fluidRules, HORIZONTAL, EPSILON;
 var init_FluidGeometry = __esm({
   "src/model/fluid/FluidGeometry.ts"() {
-    import_three26 = require("three");
+    import_three27 = require("three");
     init_fluidBlocks();
     fluidRules = fluidBlocks_default;
     HORIZONTAL = [[0, -1], [0, 1], [-1, 0], [1, 0]];
@@ -4469,10 +4542,10 @@ function sampleFluid(kind, sample) {
   }
   return { key: key.join(""), sample: (x, y, z) => cells[(y + 1) * 9 + (z + 1) * 3 + x + 1] };
 }
-var import_three27, FluidModelObject;
+var import_three28, FluidModelObject;
 var init_FluidModelObject = __esm({
   "src/model/fluid/FluidModelObject.ts"() {
-    import_three27 = require("three");
+    import_three28 = require("three");
     init_AssetKey();
     init_Materials();
     init_ModelObject();
@@ -4505,10 +4578,10 @@ var init_FluidModelObject = __esm({
           }
         }
         geometry.clearGroups();
-        const color = new import_three27.Color(this.options.tints?.[0] ?? (this.kind === "water" ? 4159204 : 16777215));
+        const color = new import_three28.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_three27.BufferAttribute(colors, 3));
+        geometry.setAttribute("color", new import_three28.BufferAttribute(colors, 3));
         geometry.computeBoundingBox();
         geometry.computeBoundingSphere();
         if (this.options.instanceMeshes) {
@@ -4522,7 +4595,7 @@ var init_FluidModelObject = __esm({
         super.applyTextures();
         this.iterateAllMeshes((mesh) => {
           const material = mesh.material;
-          material.side = import_three27.DoubleSide;
+          material.side = import_three28.DoubleSide;
           material.forceSinglePass = true;
           material.depthWrite = !material.transparent;
         });
@@ -4553,6 +4626,7 @@ __export(index_node_exports, {
   BUILTIN_GENERATED: () => BUILTIN_GENERATED,
   BasicAssetKey: () => BasicAssetKey,
   BatchedExecutor: () => BatchedExecutor,
+  BlockEntities: () => BlockEntities,
   BlockObject: () => BlockObject,
   BlockStateResolver: () => BlockStateResolver,
   BlockStates: () => BlockStates,
@@ -4574,7 +4648,9 @@ __export(index_node_exports, {
   DefaultBlockStates: () => DefaultBlockStates,
   DisplayPosition: () => DisplayPosition,
   DisplayTransforms: () => DisplayTransforms,
+  ENTITY_ANIMATION_CHANNELS: () => ENTITY_ANIMATION_CHANNELS,
   Entities: () => Entities,
+  EntityAnimationPlayer: () => EntityAnimationPlayer,
   EntityObject: () => EntityObject,
   Env: () => Env,
   FluidModelObject: () => FluidModelObject,
@@ -4650,6 +4726,7 @@ __export(index_node_exports, {
   createCanvas: () => createCanvas2,
   createFluidGeometry: () => createFluidGeometry,
   createImage: () => createImage,
+  entityAnimationTime: () => entityAnimationTime,
   estimateBytesUsed: () => estimateBytesUsed,
   getBlockFluidState: () => getBlockFluidState,
   getFluidKind: () => getFluidKind,
@@ -4682,6 +4759,8 @@ __export(index_node_exports, {
   mergeVertices: () => mergeVertices,
   prefix: () => prefix,
   registerNodeEnv: () => registerNodeEnv,
+  sampleEntityAnimation: () => sampleEntityAnimation,
+  sampleEntityKeyframes: () => sampleEntityKeyframes,
   sampleFluid: () => sampleFluid,
   serializeBoxGeometryKey: () => serializeBoxGeometryKey,
   serializeImageKey: () => serializeImageKey,
@@ -4939,6 +5018,59 @@ function shutdown() {
 init_AssetKey();
 init_AssetLoader();
 init_Assets();
+
+// src/assets/BlockEntities.ts
+var import_three10 = require("three");
+init_AssetKey();
+init_AssetLoader();
+init_source();
+init_Caching();
+var BlockEntities = class {
+  /**
+   * Loads the block index of a version. Versions and sources without one yield an empty index, and so does
+   * a failed load: the index is optional, and blocks must not retry or fail with it one by one. The empty
+   * result is cached like any other; `Caching.clear()` or `AssetLoader.setVersion()` forces a new attempt.
+   */
+  static async getIndex(root) {
+    const key = new AssetKey("entity-models", "blocks", void 0, void 0, void 0, ".json", root);
+    key.rootType = void 0;
+    const index = await Caching.blockEntityIndexCache.get(key.serialize(), async () => {
+      try {
+        return await AssetLoader.get(key, "json" /* JSON */) ?? {};
+      } catch (error) {
+        console.warn("Could not load the block entity index; block entities are drawn as plain block models", error);
+        return {};
+      }
+    });
+    return index ?? {};
+  }
+  /** The index entry of a block ID such as `minecraft:chest`. */
+  static entry(index, block) {
+    const entry = Object.prototype.hasOwnProperty.call(index, block) ? index[block] : void 0;
+    return Array.isArray(entry?.parts) ? entry : void 0;
+  }
+  /** Selects the parts and placement for a block ID such as `minecraft:chest`; undefined when nothing is drawn. */
+  static resolve(index, block, state = {}) {
+    const entry = this.entry(index, block);
+    if (!entry) return void 0;
+    const value = (property) => String(state[property]).toLowerCase();
+    const parts = entry.parts.filter((part) => Object.entries(part.when ?? {}).every(([property, values]) => String(values).split("|").includes(value(property))));
+    if (!parts.length) return void 0;
+    let rotation = 0;
+    if (entry.rotation) {
+      const selected = value(entry.rotation.property);
+      rotation = "degrees" in entry.rotation ? entry.rotation.degrees[selected] : Number(selected) * entry.rotation.step;
+      if (!Number.isFinite(rotation)) rotation = 0;
+    }
+    return { parts, rotation, translation: entry.translation ?? [0, 0, 0] };
+  }
+  /** Placement in block space (0..16 per axis), applied on top of the model's own transform. */
+  static matrix(resolved, matrix = new import_three10.Matrix4()) {
+    return matrix.makeTranslation(8, 0, 8).multiply(new import_three10.Matrix4().makeRotationY(resolved.rotation * Math.PI / 180)).multiply(new import_three10.Matrix4().makeTranslation(resolved.translation[0] - 8, resolved.translation[1], resolved.translation[2] - 8));
+  }
+};
+
+// src/assets/index.ts
 init_BlockStates();
 
 // src/assets/Entities.ts
@@ -4970,32 +5102,53 @@ var Entities = class {
   static async getLayerList(modelKey) {
     return Object.keys((await this.getModelFile(modelKey))?.layers ?? {});
   }
+  /** The dataset's extra draws on top of `main`; their `when` labels are the states `EntityModelOptions.when` can enable. */
+  static async getPassList(modelKey) {
+    return (await this.getModelFile(modelKey))?.passes ?? [];
+  }
   static async getEntity(modelKey, textureKey, options) {
     const model = await this.getModelFile(modelKey);
     if (!model) return void 0;
-    const names = [...new Set(options?.layers ?? [options?.layer ?? "main"])];
-    if (names.length === 0) throw new MineRenderError(`Entity ${model.id} requires at least one layer`);
-    const selected = names.map((name) => {
-      const layer = model.layers[name];
+    const passes = options?.layers || options?.layer !== void 0 ? [] : (model.passes ?? []).filter((pass) => pass.when === void 0 || options?.when?.includes(pass.when));
+    const draws = [...new Set(options?.layers ?? [options?.layer ?? "main"])].map((layer) => ({ layer }));
+    if (draws.length === 0) throw new MineRenderError(`Entity ${model.id} requires at least one layer`);
+    draws.push(...passes);
+    const names = [];
+    const selected = draws.map((pass) => {
+      const layer = model.layers[pass.layer];
       if (!layer) {
-        throw new MineRenderError(`Entity ${model.id} has no layer "${name}". Available layers: ${Object.keys(model.layers).join(", ")}`);
+        throw new MineRenderError(`Entity ${model.id} has no layer "${pass.layer}". Available layers: ${Object.keys(model.layers).join(", ")}`);
       }
-      return { name, layer };
+      let name = pass.layer;
+      for (let n = 2; names.includes(name); n++) name = `${pass.layer}#${n}`;
+      names.push(name);
+      return { name, layer, pass };
     });
-    const layers = Object.fromEntries(await Promise.all(selected.map(async ({ name, layer }, index) => {
+    const layers = Object.fromEntries(await Promise.all(selected.map(async ({ name, layer, pass }, index) => {
       const override = options?.textures?.[name] ?? (index === 0 ? textureKey : void 0);
+      const textureLocation = pass.textureLocation ?? layer.textureLocation;
       let texture;
       if (override) {
         const path = isAssetKey(override) ? override.getFullPath() : override.path;
         texture = isAssetKey(override) && override.assetType === "textures" && path.startsWith("entity/") ? override : new AssetKey(override.namespace, path, "textures", "entity", "assets", ".png", isAssetKey(override) ? override.root : void 0);
-      } else if (layer.textureLocation !== void 0) {
-        texture = AssetKey.parse("textures", layer.textureLocation.replace(/^([^:]+:)?textures\//, "$1"));
+      } else if (textureLocation !== void 0) {
+        texture = AssetKey.parse("textures", textureLocation.replace(/^([^:]+:)?textures\//, "$1"));
       } else {
         texture = await this.resolveTexture(modelKey);
       }
-      return [name, { key: override ?? modelKey, texture, layer }];
+      const render = pass.render ?? layer.render;
+      return [name, { key: override ?? modelKey, texture, layer, ...render && { render }, ...pass.tint && { tint: pass.tint } }];
     })));
-    return { ...layers[names[0]], id: model.id, layers };
+    return { ...layers[names[0]], id: model.id, layers, ...model.transform && { transform: model.transform } };
+  }
+  /**
+   * Vanilla's keyframe animations of a model by name, or undefined when the model or the selected version has none.
+   */
+  static async getAnimations(modelKey) {
+    const path = isAssetKey(modelKey) ? modelKey.getFullPath() : modelKey.path;
+    const key = new AssetKey(modelKey.namespace, path, void 0, void 0, "entity-models/animations", ".json");
+    const file = await Caching.entityAnimationCache.get(key.serialize(), () => AssetLoader.get(key, "json" /* JSON */));
+    return file?.animations;
   }
   static async resolveTexture(modelKey) {
     const path = isAssetKey(modelKey) ? modelKey.getFullPath() : modelKey.path;
@@ -5073,11 +5226,125 @@ function trimCanvas(source) {
   return canvas;
 }
 
+// src/entity/EntityAnimation.ts
+var ENTITY_ANIMATION_CHANNELS = ["position", "rotation", "scale"];
+function catmullRom(delta, p0, p1, p22, p32) {
+  return 0.5 * (2 * p1 + (p22 - p0) * delta + (2 * p0 - 5 * p1 + 4 * p22 - p32) * delta * delta + (3 * p1 - p0 - 3 * p22 + p32) * delta * delta * delta);
+}
+function sampleEntityKeyframes(keyframes, time) {
+  if (keyframes.length === 0) return [0, 0, 0];
+  let low = 0, high = keyframes.length;
+  while (low < high) {
+    const middle = low + high >>> 1;
+    if (time <= keyframes[middle].time) high = middle;
+    else low = middle + 1;
+  }
+  const a = Math.max(0, low - 1);
+  const b = Math.min(keyframes.length - 1, a + 1);
+  const from = keyframes[a];
+  const to = keyframes[b];
+  const delta = a === b ? 0 : Math.min(1, Math.max(0, (time - from.time) / (to.time - from.time)));
+  if (to.interpolation === "catmullrom") {
+    const before = keyframes[Math.max(0, a - 1)].value;
+    const after = keyframes[Math.min(keyframes.length - 1, b + 1)].value;
+    return [0, 1, 2].map((i) => catmullRom(delta, before[i], from.value[i], to.value[i], after[i]));
+  }
+  const target = to.pre ?? to.value;
+  return [0, 1, 2].map((i) => from.value[i] + (target[i] - from.value[i]) * delta);
+}
+function entityAnimationTime(animation, time, loop = animation.loop) {
+  return loop && animation.length > 0 ? time % animation.length : time;
+}
+function sampleEntityAnimation(animation, time, loop = animation.loop) {
+  const elapsed = entityAnimationTime(animation, time, loop);
+  const pose = {};
+  for (const [name, bone] of Object.entries(animation.bones)) {
+    const sampled = pose[name] = {};
+    for (const channel of ENTITY_ANIMATION_CHANNELS) {
+      const keyframes = bone[channel];
+      if (keyframes?.length) sampled[channel] = sampleEntityKeyframes(keyframes, elapsed);
+    }
+  }
+  return pose;
+}
+
+// src/entity/scene/EntityAnimationPlayer.ts
+var ZERO = [0, 0, 0];
+var EntityAnimationPlayer = class {
+  constructor() {
+    this.parts = [];
+    this._time = 0;
+    this.loop = false;
+    this.speed = 1;
+  }
+  get animation() {
+    return this._animation;
+  }
+  get time() {
+    return this._time;
+  }
+  /**
+   * Starts an animation on the named parts below each layer root. The current pose of a part becomes its default;
+   * bones without a matching part are skipped.
+   */
+  play(layers, animation, options = {}) {
+    this.stop();
+    this._animation = animation;
+    this._time = options.time ?? 0;
+    this.loop = options.loop ?? animation.loop;
+    this.speed = options.speed ?? 1;
+    for (const layer of layers) {
+      for (const bone of Object.keys(animation.bones)) {
+        const object = layer.getObjectByName(`group:${bone}`);
+        if (!object) continue;
+        this.parts.push({ bone, object, position: object.position.clone(), rotation: object.rotation.clone(), scale: object.scale.clone() });
+      }
+    }
+    this.apply();
+  }
+  /** Restores the default poses. Returns whether an animation was active. */
+  stop() {
+    if (!this._animation) return false;
+    for (const part of this.parts) {
+      part.object.position.copy(part.position);
+      part.object.rotation.copy(part.rotation);
+      part.object.scale.copy(part.scale);
+    }
+    this.clear();
+    return true;
+  }
+  /** Forgets the animation without touching the parts, for parts that no longer exist. */
+  clear() {
+    this.parts = [];
+    this._animation = void 0;
+    this._time = 0;
+  }
+  setTime(seconds) {
+    if (!this._animation) return false;
+    this._time = seconds;
+    this.apply();
+    return true;
+  }
+  advance(deltaSeconds) {
+    return this.setTime(this._time + deltaSeconds * this.speed);
+  }
+  apply() {
+    const pose = sampleEntityAnimation(this._animation, this._time, this.loop);
+    for (const part of this.parts) {
+      const { position = ZERO, rotation = ZERO, scale = ZERO } = pose[part.bone];
+      part.object.position.set(part.position.x + position[0], part.position.y + position[1], part.position.z + position[2]);
+      part.object.rotation.set(part.rotation.x + rotation[0], part.rotation.y + rotation[1], part.rotation.z + rotation[2], part.rotation.order);
+      part.object.scale.set(part.scale.x + scale[0], part.scale.y + scale[1], part.scale.z + scale[2]);
+    }
+  }
+};
+
 // src/entity/scene/EntityObject.ts
 init_SceneObject();
 init_Caching();
 var import_ts_deepmerge4 = __toESM(require_dist());
-var import_three12 = require("three");
+var import_three13 = require("three");
+init_Ticker();
 init_model();
 init_ModelTextures();
 init_AssetKey();
@@ -5089,10 +5356,15 @@ var EntityObject = class _EntityObject extends SceneObject {
     this.entity = entity;
     this.isEntityObject = true;
     this.meshesCreated = false;
+    /** Scrolling materials are owned: their texture offset follows this entity's age. */
+    this.scrollMaterials = [];
+    /** Entity age in ticks, as vanilla's `ageInTicks`; drives the scrolling render modes. */
+    this.age = 0;
+    this.animationPlayer = new EntityAnimationPlayer();
     this.options = (0, import_ts_deepmerge4.default)({}, _EntityObject.DEFAULT_OPTIONS, options ?? {});
   }
   static {
-    this.DEFAULT_OPTIONS = (0, import_ts_deepmerge4.default)({}, SceneObject.DEFAULT_OPTIONS, { flip: true });
+    this.DEFAULT_OPTIONS = (0, import_ts_deepmerge4.default)({}, SceneObject.DEFAULT_OPTIONS);
   }
   async init() {
     this.createMeshes();
@@ -5101,6 +5373,59 @@ var EntityObject = class _EntityObject extends SceneObject {
   dispose() {
     super.dispose();
   }
+  disposeAndRemoveAllChildren() {
+    this.clearScrollMaterials();
+    this.animationPlayer.clear();
+    super.disposeAndRemoveAllChildren();
+  }
+  clearScrollMaterials() {
+    Ticker.remove(this.scrollTicker);
+    this.scrollTicker = void 0;
+    for (const { material } of this.scrollMaterials.splice(0)) {
+      material.map?.dispose();
+      material.dispose();
+    }
+  }
+  /** Applies the entity age to the scrolling materials; the ticker calls this 20 times per second. */
+  updateScroll() {
+    for (const { offset, speed } of this.scrollMaterials) {
+      offset.set(this.age * speed[0] % 1, 0 - this.age * speed[1] % 1);
+    }
+    this.notifyDirty();
+  }
+  //<editor-fold desc="ANIMATION">
+  /** The animation started by {@link playAnimation}, until {@link stopAnimation} or disposal. */
+  get animation() {
+    return this.animationPlayer.animation;
+  }
+  /** Seconds since the animation started, before looping. */
+  get animationTime() {
+    return this.animationPlayer.time;
+  }
+  /**
+   * Poses the object from a keyframe animation of {@link Entities.getAnimations}, replacing the current one.
+   * Parts of every layer are matched by name and their current pose is the default the offsets add to.
+   * The object owns no clock: call {@link advanceAnimation} per frame, or {@link setAnimationTime}.
+   */
+  playAnimation(animation, options) {
+    this.createMeshes();
+    const layers = Object.keys(this.entityLayers).map((name) => this.getLayerGroup(name)).filter((layer) => !!layer);
+    this.animationPlayer.play(layers, animation, options);
+    this.notifyDirty();
+  }
+  /** Stops the animation and restores the default pose. */
+  stopAnimation() {
+    if (this.animationPlayer.stop()) this.notifyDirty();
+  }
+  /** Poses the object at an explicit time in seconds. Has no effect without an animation. */
+  setAnimationTime(seconds) {
+    if (this.animationPlayer.setTime(seconds)) this.notifyDirty();
+  }
+  /** Advances the animation by a frame delta in seconds, scaled by its speed. Has no effect without an animation. */
+  advanceAnimation(deltaSeconds) {
+    if (this.animationPlayer.advance(deltaSeconds)) this.notifyDirty();
+  }
+  //</editor-fold>
   getLayerGroup(name) {
     return super.getGroupByName(`layer:${name}`);
   }
@@ -5130,17 +5455,30 @@ var EntityObject = class _EntityObject extends SceneObject {
   }
   createMeshes(force = false) {
     if (this.meshesCreated && !force) return;
-    const modelRoot = new import_three12.Object3D();
-    if (this.options.flip) modelRoot.scale.set(-1, -1, 1);
+    const modelRoot = new import_three13.Object3D();
+    const transform = this.options.flip === void 0 ? this.entity.transform : void 0;
+    if (transform) {
+      for (const op of transform) {
+        const matrix = new import_three13.Matrix4();
+        if ("scale" in op) matrix.makeScale(...op.scale);
+        else if ("translate" in op) matrix.makeTranslation(...op.translate);
+        else matrix.makeRotationFromEuler(new import_three13.Euler(...op.rotate, "ZYX"));
+        modelRoot.matrix.multiply(matrix);
+      }
+      modelRoot.matrixAutoUpdate = false;
+    } else if (this.options.flip ?? true) {
+      modelRoot.scale.set(-1, -1, 1);
+    }
     this.add(modelRoot);
     Object.entries(this.entityLayers).forEach(([name, layer], index) => {
       const group = this.createGroup(`layer:${name}`);
       modelRoot.add(group);
-      this.createPart("root", layer.layer.root, group, layer.layer.texture, Materials.MISSING_TEXTURE, index);
+      const inward = !Materials.entityModeCulls(layer.render ?? layer.layer.render);
+      this.createPart("root", layer.layer.root, group, layer.layer.texture, Materials.MISSING_TEXTURE, index, inward);
     });
     this.meshesCreated = true;
   }
-  createPart(name, part, parent, textureSize, material, renderOrder) {
+  createPart(name, part, parent, textureSize, material, renderOrder, inward = true) {
     const anchor = this.createGroup(name);
     anchor.position.fromArray(part.pose.offset);
     anchor.rotation.set(...part.pose.rotation, "ZYX");
@@ -5159,7 +5497,7 @@ var EntityObject = class _EntityObject extends SceneObject {
         uv
       ).clone();
       geometry.translate(cube.origin[0] + width / 2, cube.origin[1] + height / 2, cube.origin[2] + depth / 2);
-      if (Math.min(width + growX * 2, height + growY * 2, depth + growZ * 2) > 0) {
+      if (inward && Math.min(width + growX * 2, height + growY * 2, depth + growZ * 2) > 0) {
         const index = Array.from(geometry.getIndex().array);
         geometry.setIndex(index.concat(index.slice().reverse()));
       }
@@ -5169,26 +5507,42 @@ var EntityObject = class _EntityObject extends SceneObject {
       if (this.options.wireframe) addWireframeToMesh(geometry, mesh);
     }
     for (const [childName, child] of Object.entries(part.children)) {
-      this.createPart(childName, child, anchor, size, material, renderOrder);
+      this.createPart(childName, child, anchor, size, material, renderOrder, inward);
     }
   }
   async applyTextures() {
+    this.clearScrollMaterials();
     await Promise.all(Object.entries(this.entityLayers).map(async ([name, layer]) => {
+      const mode = layer.render ?? layer.layer.render ?? "cutout";
+      const tint = layer.tint === void 0 ? void 0 : this.options.tints?.[layer.tint];
+      const scroll = Materials.entityModeScroll(mode);
       const assetKeyStr = this.getTextureKey(layer).serialize();
-      const keyStr = `entity:${assetKeyStr}`;
-      let mat = Caching.materialCache.getIfPresent(keyStr);
+      const keyStr = `entity:${mode}:${tint === void 0 ? "" : new import_three13.Color(tint).getHexString()}:${assetKeyStr}`;
+      let mat = scroll ? void 0 : Caching.materialCache.getIfPresent(keyStr);
       if (!mat) {
         const cachedAsset = Caching.textureAssetCache.getIfPresent(assetKeyStr);
         const imageData = await this.loadTextures(layer);
         if (!imageData) return;
         const canvas = imageData.data.canvas;
-        const createMaterial = () => Materials.createBasicCanvasMaterial(canvas);
-        mat = cachedAsset && Caching.textureAssetCache.getIfPresent(assetKeyStr) === cachedAsset ? Caching.materialCache.get(keyStr, createMaterial) : createMaterial();
+        const createMaterial = () => Materials.createEntityCanvasMaterial(canvas, mode, tint);
+        mat = !scroll && cachedAsset && Caching.textureAssetCache.getIfPresent(assetKeyStr) === cachedAsset ? Caching.materialCache.get(keyStr, createMaterial) : createMaterial();
+        if (scroll) {
+          this.scrollMaterials.push({ material: mat, offset: mat.map.offset, speed: scroll });
+        }
       }
       this.getLayerGroup(name)?.traverse((object) => {
         if (isMesh(object)) object.material = mat;
       });
     }));
+    if (!this.children.length) {
+      this.clearScrollMaterials();
+    } else if (this.scrollMaterials.length) {
+      this.updateScroll();
+      this.scrollTicker = Ticker.add(() => {
+        this.age++;
+        this.updateScroll();
+      });
+    }
     this.notifyDirty();
   }
 };
@@ -5200,27 +5554,27 @@ function isEntityObject(obj) {
 init_MineRenderError();
 
 // src/export/SceneExporter.ts
-var import_three18 = require("three");
+var import_three19 = require("three");
 
 // ../../node_modules/three/examples/jsm/exporters/OBJExporter.js
-var import_three14 = require("three");
+var import_three15 = require("three");
 var OBJExporter = class {
   parse(object) {
     let output = "";
     let indexVertex = 0;
     let indexVertexUvs = 0;
     let indexNormals = 0;
-    const vertex = new import_three14.Vector3();
-    const color = new import_three14.Color();
-    const normal = new import_three14.Vector3();
-    const uv = new import_three14.Vector2();
+    const vertex = new import_three15.Vector3();
+    const color = new import_three15.Color();
+    const normal = new import_three15.Vector3();
+    const uv = new import_three15.Vector2();
     const face = [];
     function parseMesh(mesh) {
       let nbVertex = 0;
       let nbNormals = 0;
       let nbVertexUvs = 0;
       const geometry = mesh.geometry;
-      const normalMatrixWorld = new import_three14.Matrix3();
+      const normalMatrixWorld = new import_three15.Matrix3();
       const vertices = geometry.getAttribute("position");
       const normals = geometry.getAttribute("normal");
       const uvs = geometry.getAttribute("uv");
@@ -5339,7 +5693,7 @@ var OBJExporter = class {
 };
 
 // ../../node_modules/three/examples/jsm/exporters/PLYExporter.js
-var import_three15 = require("three");
+var import_three16 = require("three");
 var PLYExporter = class {
   parse(object, onDone, options = {}) {
     function traverseMeshes(cb) {
@@ -5396,7 +5750,7 @@ var PLYExporter = class {
         includeIndices = false;
       }
     });
-    const tempColor = new import_three15.Color();
+    const tempColor = new import_three16.Color();
     includeIndices = includeIndices && excludeAttributes.indexOf("index") === -1;
     includeNormals = includeNormals && excludeAttributes.indexOf("normal") === -1;
     includeColors = includeColors && excludeAttributes.indexOf("color") === -1;
@@ -5430,8 +5784,8 @@ property list uchar int vertex_index
 `;
     }
     header += "end_header\n";
-    const vertex = new import_three15.Vector3();
-    const normalMatrixWorld = new import_three15.Matrix3();
+    const vertex = new import_three16.Vector3();
+    const normalMatrixWorld = new import_three16.Matrix3();
     let result = null;
     if (options.binary === true) {
       const headerBin = new TextEncoder().encode(header);
@@ -5605,18 +5959,18 @@ property list uchar int vertex_index
 };
 
 // ../../node_modules/three/examples/jsm/exporters/GLTFExporter.js
-var import_three17 = require("three");
+var import_three18 = require("three");
 
 // ../../node_modules/three/examples/jsm/utils/TextureUtils.js
-var import_three16 = require("three");
+var import_three17 = require("three");
 var _renderer;
 var fullscreenQuadGeometry;
 var fullscreenQuadMaterial;
 var fullscreenQuad;
 function decompress(texture, maxTextureSize = Infinity, renderer = null) {
-  if (!fullscreenQuadGeometry) fullscreenQuadGeometry = new import_three16.PlaneGeometry(2, 2, 1, 1);
-  if (!fullscreenQuadMaterial) fullscreenQuadMaterial = new import_three16.ShaderMaterial({
-    uniforms: { blitTexture: new import_three16.Uniform(texture) },
+  if (!fullscreenQuadGeometry) fullscreenQuadGeometry = new import_three17.PlaneGeometry(2, 2, 1, 1);
+  if (!fullscreenQuadMaterial) fullscreenQuadMaterial = new import_three17.ShaderMaterial({
+    uniforms: { blitTexture: new import_three17.Uniform(texture) },
     vertexShader: `
             varying vec2 vUv;
             void main(){
@@ -5638,22 +5992,22 @@ function decompress(texture, maxTextureSize = Infinity, renderer = null) {
             }`
   });
   fullscreenQuadMaterial.uniforms.blitTexture.value = texture;
-  fullscreenQuadMaterial.defines.IS_SRGB = texture.colorSpace == import_three16.SRGBColorSpace;
+  fullscreenQuadMaterial.defines.IS_SRGB = texture.colorSpace == import_three17.SRGBColorSpace;
   fullscreenQuadMaterial.needsUpdate = true;
   if (!fullscreenQuad) {
-    fullscreenQuad = new import_three16.Mesh(fullscreenQuadGeometry, fullscreenQuadMaterial);
+    fullscreenQuad = new import_three17.Mesh(fullscreenQuadGeometry, fullscreenQuadMaterial);
     fullscreenQuad.frustrumCulled = false;
   }
-  const _camera = new import_three16.PerspectiveCamera();
-  const _scene = new import_three16.Scene();
+  const _camera = new import_three17.PerspectiveCamera();
+  const _scene = new import_three17.Scene();
   _scene.add(fullscreenQuad);
   if (!renderer) {
-    renderer = _renderer = new import_three16.WebGLRenderer({ antialias: false });
+    renderer = _renderer = new import_three17.WebGLRenderer({ antialias: false });
   }
   renderer.setSize(Math.min(texture.image.width, maxTextureSize), Math.min(texture.image.height, maxTextureSize));
   renderer.clear();
   renderer.render(_scene, _camera);
-  const readableTexture = new import_three16.Texture(renderer.domElement);
+  const readableTexture = new import_three17.Texture(renderer.domElement);
   readableTexture.minFilter = texture.minFilter;
   readableTexture.magFilter = texture.magFilter;
   readableTexture.wrapS = texture.wrapS;
@@ -5799,22 +6153,22 @@ var WEBGL_CONSTANTS = {
 };
 var KHR_MESH_QUANTIZATION = "KHR_mesh_quantization";
 var THREE_TO_WEBGL = {};
-THREE_TO_WEBGL[import_three17.NearestFilter] = WEBGL_CONSTANTS.NEAREST;
-THREE_TO_WEBGL[import_three17.NearestMipmapNearestFilter] = WEBGL_CONSTANTS.NEAREST_MIPMAP_NEAREST;
-THREE_TO_WEBGL[import_three17.NearestMipmapLinearFilter] = WEBGL_CONSTANTS.NEAREST_MIPMAP_LINEAR;
-THREE_TO_WEBGL[import_three17.LinearFilter] = WEBGL_CONSTANTS.LINEAR;
-THREE_TO_WEBGL[import_three17.LinearMipmapNearestFilter] = WEBGL_CONSTANTS.LINEAR_MIPMAP_NEAREST;
-THREE_TO_WEBGL[import_three17.LinearMipmapLinearFilter] = WEBGL_CONSTANTS.LINEAR_MIPMAP_LINEAR;
-THREE_TO_WEBGL[import_three17.ClampToEdgeWrapping] = WEBGL_CONSTANTS.CLAMP_TO_EDGE;
-THREE_TO_WEBGL[import_three17.RepeatWrapping] = WEBGL_CONSTANTS.REPEAT;
-THREE_TO_WEBGL[import_three17.MirroredRepeatWrapping] = WEBGL_CONSTANTS.MIRRORED_REPEAT;
+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_three17.Color();
+var DEFAULT_SPECULAR_COLOR = new import_three18.Color();
 var GLB_HEADER_BYTES = 12;
 var GLB_HEADER_MAGIC = 1179937895;
 var GLB_VERSION = 2;
@@ -5848,7 +6202,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_three17.MathUtils.normalize(value, attribute.array);
+          value = import_three18.MathUtils.normalize(value, attribute.array);
         }
       }
       output.min[a] = Math.min(output.min[a], value);
@@ -6054,7 +6408,7 @@ var GLTFWriter = class {
   isNormalizedNormalAttribute(normal) {
     const cache = this.cache;
     if (cache.attributesNormalized.has(normal)) return false;
-    const v = new import_three17.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;
     }
@@ -6071,7 +6425,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_three17.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) {
@@ -6115,7 +6469,7 @@ var GLTFWriter = class {
   buildMetalRoughTexture(metalnessMap, roughnessMap) {
     if (metalnessMap === roughnessMap) return metalnessMap;
     function getEncodingConversion(map) {
-      if (map.colorSpace === import_three17.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);
         };
@@ -6125,10 +6479,10 @@ var GLTFWriter = class {
       };
     }
     console.warn("THREE.GLTFExporter: Merged metalnessMap and roughnessMap textures.");
-    if (metalnessMap instanceof import_three17.CompressedTexture) {
+    if (metalnessMap instanceof import_three18.CompressedTexture) {
       metalnessMap = decompress(metalnessMap);
     }
-    if (roughnessMap instanceof import_three17.CompressedTexture) {
+    if (roughnessMap instanceof import_three18.CompressedTexture) {
       roughnessMap = decompress(roughnessMap);
     }
     const metalness = metalnessMap ? metalnessMap.image : null;
@@ -6161,8 +6515,8 @@ var GLTFWriter = class {
     context.putImageData(composite, 0, 0);
     const reference = metalnessMap || roughnessMap;
     const texture = reference.clone();
-    texture.source = new import_three17.Source(canvas);
-    texture.colorSpace = import_three17.NoColorSpace;
+    texture.source = new import_three18.Source(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.");
@@ -6220,7 +6574,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_three17.MathUtils.normalize(value, attribute.array);
+            value = import_three18.MathUtils.normalize(value, attribute.array);
           }
         }
         if (componentType === WEBGL_CONSTANTS.FLOAT) {
@@ -6370,7 +6724,7 @@ var GLTFWriter = class {
         ctx.scale(1, -1);
       }
       if (image.data !== void 0) {
-        if (format !== import_three17.RGBAFormat) {
+        if (format !== import_three18.RGBAFormat) {
           console.error("GLTFExporter: Only RGBAFormat is supported.", format);
         }
         if (image.width > options.maxTextureSize || image.height > options.maxTextureSize) {
@@ -6439,7 +6793,7 @@ var GLTFWriter = class {
     const json = this.json;
     if (cache.textures.has(map)) return cache.textures.get(map);
     if (!json.textures) json.textures = [];
-    if (map instanceof import_three17.CompressedTexture) {
+    if (map instanceof import_three18.CompressedTexture) {
       map = decompress(map, options.maxTextureSize);
     }
     let mimeType = map.userData.mimeType;
@@ -6547,7 +6901,7 @@ var GLTFWriter = class {
         materialDef.alphaCutoff = material.alphaTest;
       }
     }
-    if (material.side === import_three17.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) {
@@ -6621,7 +6975,7 @@ 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_three17.BufferAttribute(new Uint16Array(array), attribute.itemSize, attribute.normalized);
+        modifiedAttribute = new import_three18.BufferAttribute(new Uint16Array(array), attribute.itemSize, attribute.normalized);
       }
       const accessor = this.processAccessor(modifiedAttribute || attribute, geometry);
       if (accessor !== null) {
@@ -6781,7 +7135,7 @@ var GLTFWriter = class {
     } else {
       cameraDef.perspective = {
         aspectRatio: camera.aspect,
-        yfov: import_three17.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
       };
@@ -6809,8 +7163,8 @@ var GLTFWriter = class {
     const samplers = [];
     for (let i = 0; i < tracks.length; ++i) {
       const track = tracks[i];
-      const trackBinding = import_three17.PropertyBinding.parseTrackName(track.name);
-      let trackNode = import_three17.PropertyBinding.findNode(root, trackBinding.nodeName);
+      const 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) {
@@ -6832,14 +7186,14 @@ var GLTFWriter = class {
       if (track.createInterpolant.isInterpolantFactoryMethodGLTFCubicSpline === true) {
         interpolation = "CUBICSPLINE";
         outputItemSize /= 3;
-      } else if (track.getInterpolation() === import_three17.InterpolateDiscrete) {
+      } else if (track.getInterpolation() === import_three18.InterpolateDiscrete) {
         interpolation = "STEP";
       } else {
         interpolation = "LINEAR";
       }
       samplers.push({
-        input: this.processAccessor(new import_three17.BufferAttribute(track.times, inputItemSize)),
-        output: this.processAccessor(new import_three17.BufferAttribute(track.values, outputItemSize)),
+        input: this.processAccessor(new import_three18.BufferAttribute(track.times, inputItemSize)),
+        output: this.processAccessor(new import_three18.BufferAttribute(track.values, outputItemSize)),
         interpolation
       });
       channels.push({
@@ -6871,7 +7225,7 @@ var GLTFWriter = class {
     if (rootJoint === void 0) return null;
     const joints = [];
     const inverseBindMatrices = new Float32Array(skeleton.bones.length * 16);
-    const temporaryBoneInverse = new import_three17.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]);
@@ -6879,7 +7233,7 @@ var GLTFWriter = class {
     }
     if (json.skins === void 0) json.skins = [];
     json.skins.push({
-      inverseBindMatrices: this.processAccessor(new import_three17.BufferAttribute(inverseBindMatrices, 16)),
+      inverseBindMatrices: this.processAccessor(new import_three18.BufferAttribute(inverseBindMatrices, 16)),
       joints,
       skeleton: nodeMap.get(rootJoint)
     });
@@ -6975,7 +7329,7 @@ var GLTFWriter = class {
    * @param  {Array} objects List of objects to process
    */
   processObjects(objects) {
-    const scene = new import_three17.Scene();
+    const scene = new import_three18.Scene();
     scene.name = "AuxScene";
     for (let i = 0; i < objects.length; i++) {
       scene.children.push(objects[i]);
@@ -6993,7 +7347,7 @@ var GLTFWriter = class {
     });
     const objectsWithoutScene = [];
     for (let i = 0; i < input.length; i++) {
-      if (input[i] instanceof import_three17.Scene) {
+      if (input[i] instanceof import_three18.Scene) {
         this.processScene(input[i]);
       } else {
         objectsWithoutScene.push(input[i]);
@@ -7337,10 +7691,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_three17.Matrix4();
-    const position = new import_three17.Vector3();
-    const quaternion = new import_three17.Quaternion();
-    const scale = new import_three17.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);
@@ -7349,9 +7703,9 @@ var GLTFMeshGpuInstancing = class {
       scale.toArray(scaleAttr, i * 3);
     }
     const attributes = {
-      TRANSLATION: writer.processAccessor(new import_three17.BufferAttribute(translationAttr, 3)),
-      ROTATION: writer.processAccessor(new import_three17.BufferAttribute(rotationAttr, 4)),
-      SCALE: writer.processAccessor(new import_three17.BufferAttribute(scaleAttr, 3))
+      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);
@@ -7416,8 +7770,8 @@ GLTFExporter.Utils = {
     const sourceTracks = clip.tracks;
     for (let i = 0; i < sourceTracks.length; ++i) {
       let sourceTrack = sourceTracks[i];
-      const sourceTrackBinding = import_three17.PropertyBinding.parseTrackName(sourceTrack.name);
-      const sourceTrackNode = import_three17.PropertyBinding.findNode(root, sourceTrackBinding.nodeName);
+      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;
@@ -7428,7 +7782,7 @@ GLTFExporter.Utils = {
         }
         console.warn("THREE.GLTFExporter: Morph target interpolation mode not yet supported. Using LINEAR instead.");
         sourceTrack = sourceTrack.clone();
-        sourceTrack.setInterpolation(import_three17.InterpolateLinear);
+        sourceTrack.setInterpolation(import_three18.InterpolateLinear);
       }
       const targetCount = sourceTrackNode.morphTargetInfluences.length;
       const targetIndex = sourceTrackNode.morphTargetDictionary[sourceTrackBinding.propertyIndex];
@@ -7511,10 +7865,10 @@ var SceneExporter = class {
   }
 };
 function localMatrix(object) {
-  return object.matrixAutoUpdate ? new import_three18.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_three18.Scene();
+  const scene = new import_three19.Scene();
   const geometries = [];
   const materials = [];
   const textures = [];
@@ -7532,7 +7886,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_three18.MeshBasicMaterial({
+      material = new import_three19.MeshBasicMaterial({
         map: uniforms.map.value,
         vertexColors: source.vertexColors,
         transparent: source.transparent,
@@ -7542,7 +7896,7 @@ function createSnapshot(root, gltf, bakeColors = false) {
       });
       material.name = source.name;
     } else if (shader.isShaderMaterial) {
-      material = new import_three18.MeshBasicMaterial({ vertexColors: source.vertexColors });
+      material = new import_three19.MeshBasicMaterial({ vertexColors: source.vertexColors });
       material.name = source.name;
     } else {
       const copySource = Object.create(source);
@@ -7596,11 +7950,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_three18.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_three18.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);
           }
@@ -7609,7 +7963,7 @@ function createSnapshot(root, gltf, bakeColors = false) {
           material.color.copy(tint);
         }
       }
-      const copy = new import_three18.Mesh(geometry, material);
+      const copy = new import_three19.Mesh(geometry, material);
       copy.name = mesh.name;
       copy.renderOrder = mesh.renderOrder;
       scene.add(copy);
@@ -7623,9 +7977,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_three18.Matrix4();
+          const matrix = new import_three19.Matrix4();
           instanced.getMatrixAt(i, matrix);
-          const color = instanced.instanceColor ? new import_three18.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 {
@@ -7637,7 +7991,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_three18.Matrix4();
+    const world = new import_three19.Matrix4();
     for (const ancestor of ancestors) {
       if (!ancestor.visible) return { scene, dispose };
       world.multiply(localMatrix(ancestor));
@@ -7651,7 +8005,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_three18.RGBAFormat || texture.type !== import_three18.UnsignedByteType || texture.wrapS !== import_three18.ClampToEdgeWrapping || texture.wrapT !== import_three18.ClampToEdgeWrapping || texture.magFilter !== import_three18.NearestFilter || texture.minFilter !== import_three18.NearestFilter || texture.anisotropy > 1 || texture.offset.x !== 0 || texture.offset.y !== 0 || texture.repeat.x !== 1 || texture.repeat.y !== 1 || texture.rotation !== 0 || !texture.matrixAutoUpdate && !texture.matrix.elements.every((value, i) => value === (i % 4 === 0 ? 1 : 0))) return;
+  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;
@@ -7688,7 +8042,7 @@ function selectAlphaMode(material, geometry) {
 }
 function copyDataTexture(source) {
   const image = source.image;
-  if (source.format !== import_three18.RGBAFormat || source.type !== import_three18.UnsignedByteType) {
+  if (source.format !== import_three19.RGBAFormat || source.type !== import_three19.UnsignedByteType) {
     throw new MineRenderError("glTF export requires RGBA unsigned-byte data textures");
   }
   const canvas = createCanvas2(image.width, image.height);
@@ -7699,20 +8053,78 @@ function copyDataTexture(source) {
   context.putImageData(pixels, 0, 0);
   const copySource = Object.create(source);
   copySource.userData = {};
-  copySource.source = new import_three18.Source(canvas);
-  return new import_three18.Texture().copy(copySource);
+  copySource.source = new import_three19.Source(canvas);
+  return new import_three19.Texture().copy(copySource);
 }
 
 // src/gui/GuiHelper.ts
+init_AssetKey();
 var GuiHelper = class {
   static inventorySlot(slot, origin = [0, 0], offset = [18, 18], rowSize = 9) {
     const [column, row] = typeof slot === "number" ? [slot % rowSize, Math.floor(slot / rowSize)] : slot;
     return [origin[0] + column * offset[0], origin[1] + row * offset[1]];
   }
+  /** Creates crafting-table layers for ingredients and the result; stack counts are not drawn. */
+  static recipe(recipe, options = {}) {
+    const layers = [
+      { name: "background", texture: "minecraft:gui/container/crafting_table", crop: [0, 0, 176, 166] }
+    ];
+    const itemKey = (ingredient) => {
+      const item = typeof ingredient === "string" && !ingredient.startsWith("#") ? ingredient : typeof ingredient === "object" && "item" in ingredient ? ingredient.item : options.resolveIngredient?.(ingredient);
+      if (isAssetKey(item)) return item;
+      if (!item || item.startsWith("#")) {
+        throw new Error(`Select a concrete item for recipe ingredient ${JSON.stringify(ingredient)}`);
+      }
+      const key = AssetKey.parse("models", item);
+      return new AssetKey(key.namespace, key.getFullPath(), "models", "item");
+    };
+    const addIngredient = (ingredient, slot) => {
+      layers.push({
+        name: `ingredient-${slot}`,
+        item: itemKey(ingredient),
+        position: this.inventorySlot(slot, [30, 17], [18, 18], 3)
+      });
+    };
+    switch (recipe.type) {
+      case "minecraft:crafting_shaped":
+      case "crafting_shaped": {
+        const pattern = recipe.pattern;
+        if (!pattern.length || pattern.length > 3 || !pattern[0].length || pattern[0].length > 3 || pattern.some((row) => row.length !== pattern[0].length)) {
+          throw new Error("Crafting patterns must be rectangular, with 1\u20133 rows and columns");
+        }
+        const cells = pattern.flatMap((row, y) => row.split("").map((symbol, x) => ({ symbol, x, y }))).filter((cell) => cell.symbol !== " ");
+        if (!cells.length) throw new Error("Crafting patterns must contain an ingredient");
+        const minX = Math.min(...cells.map((cell) => cell.x)), maxX = Math.max(...cells.map((cell) => cell.x));
+        const minY = Math.min(...cells.map((cell) => cell.y)), maxY = Math.max(...cells.map((cell) => cell.y));
+        const offsetX = minX === maxX ? 1 : 0, offsetY = minY === maxY ? 1 : 0;
+        for (const { symbol, x, y } of cells) {
+          const ingredient = recipe.key[symbol];
+          if (!ingredient) throw new Error(`Missing recipe ingredient for symbol ${JSON.stringify(symbol)}`);
+          addIngredient(ingredient, (y - minY + offsetY) * 3 + x - minX + offsetX);
+        }
+        break;
+      }
+      case "minecraft:crafting_shapeless":
+      case "crafting_shapeless":
+        if (!recipe.ingredients.length || recipe.ingredients.length > 9) {
+          throw new Error("Shapeless crafting recipes require 1\u20139 ingredients");
+        }
+        recipe.ingredients.forEach(addIngredient);
+        break;
+      default:
+        throw new Error(`Unsupported crafting recipe type: ${recipe.type}`);
+    }
+    layers.push({
+      name: "result",
+      item: itemKey("id" in recipe.result ? recipe.result.id : recipe.result.item),
+      position: [124, 35]
+    });
+    return layers;
+  }
 };
 
 // src/gui/scene/GuiObject.ts
-var import_three22 = require("three");
+var import_three23 = require("three");
 init_AssetKey();
 init_ModelTextures();
 init_Models();
@@ -7736,7 +8148,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_three22.Box2();
+    this.bounds = new import_three23.Box2();
     this.geometries = /* @__PURE__ */ new Set();
     this.ownedMaterials = /* @__PURE__ */ new Set();
     this.initialized = false;
@@ -7753,7 +8165,7 @@ var GuiObject = class extends SceneObject {
           item.position.set(x + width2 / 2, -y - height2 / 2, 0);
           item.scale.set(width2 / 16, height2 / 16, width2 / 16);
           item.updateMatrix();
-          const bounds = new import_three22.Box3();
+          const bounds = new import_three23.Box3();
           item.iterateAllMeshes((mesh2) => {
             mesh2.geometry.computeBoundingBox();
             bounds.union(mesh2.geometry.boundingBox);
@@ -7761,10 +8173,10 @@ var GuiObject = class extends SceneObject {
           bounds.applyMatrix4(item.matrix);
           item.position.z = depth - bounds.min.z;
           depth += bounds.max.z - bounds.min.z + 0.01;
-          this.bounds.expandByPoint(new import_three22.Vector2(x, y));
-          this.bounds.expandByPoint(new import_three22.Vector2(x + width2, y + height2));
-          this.bounds.expandByPoint(new import_three22.Vector2(bounds.min.x, -bounds.max.y));
-          this.bounds.expandByPoint(new import_three22.Vector2(bounds.max.x, -bounds.min.y));
+          this.bounds.expandByPoint(new import_three23.Vector2(x, y));
+          this.bounds.expandByPoint(new import_three23.Vector2(x + width2, y + height2));
+          this.bounds.expandByPoint(new import_three23.Vector2(bounds.min.x, -bounds.max.y));
+          this.bounds.expandByPoint(new import_three23.Vector2(bounds.max.x, -bounds.min.y));
           continue;
         }
         const key = typeof layer.texture === "string" ? AssetKey.parse("textures", layer.texture) : layer.texture;
@@ -7772,7 +8184,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_three22.PlaneGeometry(width, height);
+        const geometry = new import_three23.PlaneGeometry(width, height);
         this.geometries.add(geometry);
         const uv = geometry.getAttribute("uv");
         for (let i = 0; i < uv.count; i++) {
@@ -7782,13 +8194,13 @@ var GuiObject = class extends SceneObject {
             1 - (cropY + (1 - uv.getY(i)) * cropHeight) / image.height
           );
         }
-        const mesh = new import_three22.Mesh(geometry, material);
+        const mesh = new import_three23.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_three22.Vector2(x, y));
-        this.bounds.expandByPoint(new import_three22.Vector2(x + width, y + height));
+        this.bounds.expandByPoint(new import_three23.Vector2(x, y));
+        this.bounds.expandByPoint(new import_three23.Vector2(x + width, y + height));
         depth += 0.01;
       }
       for (const child of this.children) child.position.z -= depth - 0.01;
@@ -7863,7 +8275,7 @@ function isGuiObject(obj) {
 init_image();
 
 // src/inspector/SceneInspector.ts
-var import_three23 = require("three");
+var import_three24 = require("three");
 init_SceneObject();
 init_util();
 init_log();
@@ -7873,11 +8285,11 @@ var help = "<span>Ctrl/Cmd+Click to Select<br/></span><br/>";
 var SceneInspector = class {
   constructor(renderer) {
     this.renderer = renderer;
-    this.mouse = new import_three23.Vector2();
+    this.mouse = new import_three24.Vector2();
     this.listeners = new AbortController();
     this.objectInfoContainer = document.createElement("div");
     this.objectControlsContainer = document.createElement("div");
-    this.raycaster = new import_three23.Raycaster();
+    this.raycaster = new import_three24.Raycaster();
     this.init();
   }
   init() {
@@ -8293,7 +8705,7 @@ init_ModelGenerator();
 init_ModelMerger();
 
 // src/model/block/BlockStateResolver.ts
-var import_three25 = require("three");
+var import_three26 = require("three");
 init_BlockStates();
 init_MineRenderError();
 init_util();
@@ -8371,7 +8783,7 @@ var BlockStateResolver = class {
     return variants[variants.length - 1];
   }
   static rotation(variant) {
-    const rotation = new import_three25.Euler();
+    const rotation = new import_three26.Euler();
     if (typeof variant.x !== "undefined") {
       rotation.x = toRadians(clampRotationDegrees(variant.x));
     }
@@ -8478,7 +8890,7 @@ init_SceneObject();
 init_ModelObject();
 init_Models();
 var import_ts_deepmerge6 = __toESM(require_dist());
-var import_three28 = require("three");
+var import_three29 = require("three");
 init_MineRenderError();
 init_InstanceReference();
 init_AssetKey();
@@ -8498,6 +8910,9 @@ var BlockObject = class _BlockObject extends SceneObject {
     this._variants = [];
     this._models = [];
     this._cullMask = 0;
+    this._entities = [];
+    this._entityPlacement = new import_three29.Matrix4();
+    this._entityGeneration = 0;
     this.options = (0, import_ts_deepmerge6.default)({}, _BlockObject.DEFAULT_OPTIONS, options ?? {});
   }
   static {
@@ -8522,6 +8937,8 @@ var BlockObject = class _BlockObject extends SceneObject {
   }
   clearModels() {
     this.removeModels(this._models.splice(0));
+    this._entityGeneration++;
+    this.removeEntities(this._entities.splice(0));
     this._fluidKey = void 0;
     this._fluidModel = void 0;
     this._isInstanced = false;
@@ -8533,6 +8950,57 @@ var BlockObject = class _BlockObject extends SceneObject {
       if (!isInstanceReference(model)) model.dispose();
     }
   }
+  removeEntities(entities) {
+    for (const entity of entities) {
+      entity.removeFromScene();
+      entity.dispose();
+    }
+  }
+  /** Entity models drawn for this block instead of its block model; they are scene children, unlike the block. */
+  get blockEntities() {
+    return this._entities;
+  }
+  /**
+   * Draws the block through the dataset's block-entity index. Returns false, leaving nothing behind,
+   * when the block is not listed or one of its models cannot be loaded.
+   */
+  async createBlockEntities() {
+    const key = this.blockState.key;
+    if (!key || this.options.displayPosition) return false;
+    const generation = this._entityGeneration;
+    const created = [];
+    let resolved;
+    try {
+      resolved = BlockEntities.resolve(await BlockEntities.getIndex(key.root), key.toNamespacedString(), this.state);
+      if (!resolved) return false;
+      for (const part of resolved.parts) {
+        const [namespace, path] = part.model.includes(":") ? part.model.split(":") : [key.namespace, part.model];
+        const texture = part.textureLocation === void 0 ? void 0 : AssetKey.parse("textures", part.textureLocation.replace(/^([^:]+:)?textures\//, "$1"));
+        if (texture) texture.root = key.root;
+        const entity = await Entities.getEntity(new BasicAssetKey(namespace, path), texture, { layer: part.layer });
+        if (!entity) throw new MineRenderError(`Missing entity model ${part.model}`);
+        created.push(await this.scene.addEntity(entity, { wireframe: this.options.wireframe }));
+      }
+    } catch (error) {
+      console.warn(`Could not draw block entity ${key.toNamespacedString()}, using its block model`, error);
+      this.removeEntities(created);
+      return false;
+    }
+    if (generation !== this._entityGeneration) {
+      this.removeEntities(created);
+      return true;
+    }
+    BlockEntities.matrix(resolved, this._entityPlacement);
+    this._entities = created;
+    this.placeEntities();
+    return true;
+  }
+  placeEntities() {
+    const matrix = new import_three29.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);
+    }
+  }
   get isOccluding() {
     return this._models.some((model) => {
       const object = isInstanceReference(model) ? model.instanceable : model;
@@ -8547,12 +9015,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_three28.Vector3();
-    const rotation = new import_three28.Quaternion();
-    const scale = new import_three28.Vector3();
+    const position = new import_three29.Vector3();
+    const rotation = new import_three29.Quaternion();
+    const scale = new import_three29.Vector3();
     this.getModelMatrix(model).decompose(position, rotation, scale);
-    if (position.distanceToSquared(this.position) > 1e-10 || scale.distanceToSquared(new import_three28.Vector3(1, 1, 1)) > 1e-10) return 0;
-    return ModelCulling.toLocalMask(worldMask, new import_three28.Euler().setFromQuaternion(rotation));
+    if (position.distanceToSquared(this.position) > 1e-10 || scale.distanceToSquared(new import_three29.Vector3(1, 1, 1)) > 1e-10) return 0;
+    return ModelCulling.toLocalMask(worldMask, new import_three29.Euler().setFromQuaternion(rotation));
   }
   async setCullMask(worldMask) {
     worldMask &= 63;
@@ -8614,7 +9082,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_three28.Matrix4().makeTranslation(...this.position.toArray());
+    const matrix = previous ? this.getModelMatrix(previous) : new import_three29.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);
@@ -8644,13 +9112,20 @@ var BlockObject = class _BlockObject extends SceneObject {
       await this.updateFluid(this._fluidSampler);
       return;
     }
+    const hasEntities = await this.createBlockEntities();
     const variantsToCreate = await this.mapStateToVariant(this.state);
     this._variants = variantsToCreate;
     for (let blockStateVariant of variantsToCreate) {
+      if (hasEntities && !await this.hasGeometry(blockStateVariant)) continue;
       this._models.push(await this.createVariant(blockStateVariant));
     }
     await this.updateFluid(this._fluidSampler);
   }
+  async hasGeometry(variant) {
+    const modelKey = AssetKey.parse("models", variant.model);
+    modelKey.root = this.blockState.key?.root;
+    return !!(await Models.getMerged(modelKey))?.elements?.length;
+  }
   getSingleVariant(variants) {
     return BlockStateResolver.choose(variants);
   }
@@ -8745,7 +9220,7 @@ var BlockObject = class _BlockObject extends SceneObject {
   setPositionRotationScaleAt(index, position, rotation, scale) {
     super.setPositionRotationScaleAt(index, position, rotation, scale);
   }
-  getMatrixAt(index, matrix = new import_three28.Matrix4()) {
+  getMatrixAt(index, matrix = new import_three29.Matrix4()) {
     if (!this.isInstanced) throw new MineRenderError("Object is not instanced");
     const child = this._models[0];
     if (child && isModelObject(child)) {
@@ -8770,6 +9245,7 @@ var BlockObject = class _BlockObject extends SceneObject {
     for (let model of this._models) {
       model.setPosition(position);
     }
+    this.placeEntities();
     this.notifyDirty();
   }
   //TODO: should override rotation + scale methods
@@ -10611,7 +11087,7 @@ init_ModelObject();
 init_nbt();
 
 // src/renderer/MineRenderScene.ts
-var import_three30 = require("three");
+var import_three31 = require("three");
 init_SceneObject();
 var import_ts_deepmerge8 = __toESM(require_dist());
 init_ModelObject();
@@ -11344,7 +11820,7 @@ var import_ts_deepmerge7 = __toESM(require_dist());
 init_util();
 
 // src/skin/SkinTextures.ts
-var import_three29 = require("three");
+var import_three30 = require("three");
 init_Caching();
 init_CacheKey();
 init_MineRenderError();
@@ -11428,11 +11904,11 @@ var SkinTextures = class {
     });
   }
   static createMaterial(pixels, width, height, transparent = true) {
-    const texture = Textures.initTextureProps(new import_three29.DataTexture(pixels, width, height));
-    texture.colorSpace = import_three29.SRGBColorSpace;
+    const texture = Textures.initTextureProps(new import_three30.DataTexture(pixels, width, height));
+    texture.colorSpace = import_three30.SRGBColorSpace;
     texture.flipY = true;
     texture.needsUpdate = true;
-    return new import_three29.MeshBasicMaterial({ map: texture, transparent, side: transparent ? import_three29.DoubleSide : import_three29.FrontSide, alphaTest: transparent ? 0.1 : 0 });
+    return new import_three30.MeshBasicMaterial({ map: texture, transparent, side: transparent ? import_three30.DoubleSide : import_three30.FrontSide, alphaTest: transparent ? 0.1 : 0 });
   }
   static isSlim(image, scale) {
     for (const [x, y] of [[46, 52], [54, 20]]) {
@@ -11660,7 +12136,7 @@ var SkinObject = class extends SceneObject {
 };
 
 // src/renderer/MineRenderScene.ts
-var MineRenderScene = class _MineRenderScene extends import_three30.Scene {
+var MineRenderScene = class _MineRenderScene extends import_three31.Scene {
   constructor(options) {
     super();
     this.isMineRenderScene = true;
@@ -11788,7 +12264,7 @@ function isMineRenderScene(obj) {
 }
 
 // src/renderer/Renderer.ts
-var import_three32 = require("three");
+var import_three33 = require("three");
 var import_ts_deepmerge9 = __toESM(require_dist());
 var import_stats = __toESM(require("stats.js"));
 var import_postprocessing = require("postprocessing");
@@ -11796,11 +12272,11 @@ init_util();
 init_three();
 
 // src/three/OrbitControls.js
-var import_three31 = require("three");
+var import_three32 = require("three");
 var _changeEvent = { type: "change" };
 var _startEvent = { type: "start" };
 var _endEvent = { type: "end" };
-var OrbitControls = class extends import_three31.EventDispatcher {
+var OrbitControls = class extends import_three32.EventDispatcher {
   constructor(object, domElement) {
     super();
     if (domElement === void 0) console.warn('THREE.OrbitControls: The second parameter "domElement" is now mandatory.');
@@ -11809,7 +12285,7 @@ var OrbitControls = class extends import_three31.EventDispatcher {
     this.domElement = domElement;
     this.domElement.style.touchAction = "none";
     this.enabled = true;
-    this.target = new import_three31.Vector3();
+    this.target = new import_three32.Vector3();
     this.minDistance = 0;
     this.maxDistance = Infinity;
     this.minZoom = 0;
@@ -11831,8 +12307,8 @@ var OrbitControls = class extends import_three31.EventDispatcher {
     this.autoRotate = false;
     this.autoRotateSpeed = 2;
     this.keys = { LEFT: "ArrowLeft", UP: "ArrowUp", RIGHT: "ArrowRight", BOTTOM: "ArrowDown" };
-    this.mouseButtons = { LEFT: import_three31.MOUSE.ROTATE, MIDDLE: import_three31.MOUSE.DOLLY, RIGHT: import_three31.MOUSE.PAN };
-    this.touches = { ONE: import_three31.TOUCH.ROTATE, TWO: import_three31.TOUCH.DOLLY_PAN };
+    this.mouseButtons = { LEFT: import_three32.MOUSE.ROTATE, MIDDLE: import_three32.MOUSE.DOLLY, RIGHT: import_three32.MOUSE.PAN };
+    this.touches = { ONE: import_three32.TOUCH.ROTATE, TWO: import_three32.TOUCH.DOLLY_PAN };
     this.target0 = this.target.clone();
     this.position0 = this.object.position.clone();
     this.zoom0 = this.object.zoom;
@@ -11861,11 +12337,11 @@ var OrbitControls = class extends import_three31.EventDispatcher {
       state = STATE.NONE;
     };
     this.update = function() {
-      const offset = new import_three31.Vector3();
-      const quat = new import_three31.Quaternion().setFromUnitVectors(object.up, new import_three31.Vector3(0, 1, 0));
+      const offset = new import_three32.Vector3();
+      const quat = new import_three32.Quaternion().setFromUnitVectors(object.up, new import_three32.Vector3(0, 1, 0));
       const quatInverse = quat.clone().invert();
-      const lastPosition = new import_three31.Vector3();
-      const lastQuaternion = new import_three31.Quaternion();
+      const lastPosition = new import_three32.Vector3();
+      const lastQuaternion = new import_three32.Quaternion();
       const twoPI = 2 * Math.PI;
       return function update() {
         const position = scope.object.position;
@@ -11951,20 +12427,20 @@ var OrbitControls = class extends import_three31.EventDispatcher {
     };
     let state = STATE.NONE;
     const EPS = 1e-6;
-    const spherical = new import_three31.Spherical();
-    const sphericalDelta = new import_three31.Spherical();
+    const spherical = new import_three32.Spherical();
+    const sphericalDelta = new import_three32.Spherical();
     let scale = 1;
-    const panOffset = new import_three31.Vector3();
+    const panOffset = new import_three32.Vector3();
     let zoomChanged = false;
-    const rotateStart = new import_three31.Vector2();
-    const rotateEnd = new import_three31.Vector2();
-    const rotateDelta = new import_three31.Vector2();
-    const panStart = new import_three31.Vector2();
-    const panEnd = new import_three31.Vector2();
-    const panDelta = new import_three31.Vector2();
-    const dollyStart = new import_three31.Vector2();
-    const dollyEnd = new import_three31.Vector2();
-    const dollyDelta = new import_three31.Vector2();
+    const rotateStart = new import_three32.Vector2();
+    const rotateEnd = new import_three32.Vector2();
+    const rotateDelta = new import_three32.Vector2();
+    const panStart = new import_three32.Vector2();
+    const panEnd = new import_three32.Vector2();
+    const panDelta = new import_three32.Vector2();
+    const dollyStart = new import_three32.Vector2();
+    const dollyEnd = new import_three32.Vector2();
+    const dollyDelta = new import_three32.Vector2();
     const pointers = [];
     const pointerPositions = {};
     function getAutoRotationAngle() {
@@ -11980,7 +12456,7 @@ var OrbitControls = class extends import_three31.EventDispatcher {
       sphericalDelta.phi -= angle;
     }
     const panLeft = function() {
-      const v = new import_three31.Vector3();
+      const v = new import_three32.Vector3();
       return function panLeft2(distance, objectMatrix) {
         v.setFromMatrixColumn(objectMatrix, 0);
         v.multiplyScalar(-distance);
@@ -11988,7 +12464,7 @@ var OrbitControls = class extends import_three31.EventDispatcher {
       };
     }();
     const panUp = function() {
-      const v = new import_three31.Vector3();
+      const v = new import_three32.Vector3();
       return function panUp2(distance, objectMatrix) {
         if (scope.screenSpacePanning === true) {
           v.setFromMatrixColumn(objectMatrix, 1);
@@ -12001,7 +12477,7 @@ var OrbitControls = class extends import_three31.EventDispatcher {
       };
     }();
     const pan = function() {
-      const offset = new import_three31.Vector3();
+      const offset = new import_three32.Vector3();
       return function pan2(deltaX, deltaY) {
         const element = scope.domElement;
         if (scope.object.isPerspectiveCamera) {
@@ -12250,12 +12726,12 @@ var OrbitControls = class extends import_three31.EventDispatcher {
           mouseAction = -1;
       }
       switch (mouseAction) {
-        case import_three31.MOUSE.DOLLY:
+        case import_three32.MOUSE.DOLLY:
           if (scope.enableZoom === false) return;
           handleMouseDownDolly(event);
           state = STATE.DOLLY;
           break;
-        case import_three31.MOUSE.ROTATE:
+        case import_three32.MOUSE.ROTATE:
           if (event.ctrlKey || event.metaKey || event.shiftKey) {
             if (scope.enablePan === false) return;
             handleMouseDownPan(event);
@@ -12266,7 +12742,7 @@ var OrbitControls = class extends import_three31.EventDispatcher {
             state = STATE.ROTATE;
           }
           break;
-        case import_three31.MOUSE.PAN:
+        case import_three32.MOUSE.PAN:
           if (event.ctrlKey || event.metaKey || event.shiftKey) {
             if (scope.enableRotate === false) return;
             handleMouseDownRotate(event);
@@ -12322,12 +12798,12 @@ var OrbitControls = class extends import_three31.EventDispatcher {
       switch (pointers.length) {
         case 1:
           switch (scope.touches.ONE) {
-            case import_three31.TOUCH.ROTATE:
+            case import_three32.TOUCH.ROTATE:
               if (scope.enableRotate === false) return;
               handleTouchStartRotate();
               state = STATE.TOUCH_ROTATE;
               break;
-            case import_three31.TOUCH.PAN:
+            case import_three32.TOUCH.PAN:
               if (scope.enablePan === false) return;
               handleTouchStartPan();
               state = STATE.TOUCH_PAN;
@@ -12338,12 +12814,12 @@ var OrbitControls = class extends import_three31.EventDispatcher {
           break;
         case 2:
           switch (scope.touches.TWO) {
-            case import_three31.TOUCH.DOLLY_PAN:
+            case import_three32.TOUCH.DOLLY_PAN:
               if (scope.enableZoom === false && scope.enablePan === false) return;
               handleTouchStartDollyPan();
               state = STATE.TOUCH_DOLLY_PAN;
               break;
-            case import_three31.TOUCH.DOLLY_ROTATE:
+            case import_three32.TOUCH.DOLLY_ROTATE:
               if (scope.enableZoom === false && scope.enableRotate === false) return;
               handleTouchStartDollyRotate();
               state = STATE.TOUCH_DOLLY_ROTATE;
@@ -12410,7 +12886,7 @@ var OrbitControls = class extends import_three31.EventDispatcher {
     function trackPointer(event) {
       let position = pointerPositions[event.pointerId];
       if (position === void 0) {
-        position = new import_three31.Vector2();
+        position = new import_three32.Vector2();
         pointerPositions[event.pointerId] = position;
       }
       position.set(event.pageX, event.pageY);
@@ -12430,10 +12906,10 @@ var MapControls = class extends OrbitControls {
   constructor(object, domElement) {
     super(object, domElement);
     this.screenSpacePanning = false;
-    this.mouseButtons.LEFT = import_three31.MOUSE.PAN;
-    this.mouseButtons.RIGHT = import_three31.MOUSE.ROTATE;
-    this.touches.ONE = import_three31.TOUCH.PAN;
-    this.touches.TWO = import_three31.TOUCH.DOLLY_ROTATE;
+    this.mouseButtons.LEFT = import_three32.MOUSE.PAN;
+    this.mouseButtons.RIGHT = import_three32.MOUSE.ROTATE;
+    this.touches.ONE = import_three32.TOUCH.PAN;
+    this.touches.TWO = import_three32.TOUCH.DOLLY_ROTATE;
   }
 };
 
@@ -12492,8 +12968,8 @@ var Renderer = class _Renderer {
           top: void 0,
           bottom: void 0
         },
-        position: new import_three32.Vector3(50, 50, 50),
-        lookingAt: new import_three32.Vector3(0, 0, 0)
+        position: new import_three33.Vector3(50, 50, 50),
+        lookingAt: new import_three33.Vector3(0, 0, 0)
       },
       render: {
         fpsLimit: 60,
@@ -12524,14 +13000,14 @@ var Renderer = class _Renderer {
     switch (this.options.camera.type) {
       case "perspective":
       default:
-        return new import_three32.PerspectiveCamera(
+        return new import_three33.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_three32.OrthographicCamera(
+        return new import_three33.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,
@@ -12542,7 +13018,7 @@ var Renderer = class _Renderer {
     }
   }
   createRenderer() {
-    const renderer = new import_three32.WebGLRenderer({
+    const renderer = new import_three33.WebGLRenderer({
       antialias: this.options.render.antialias,
       alpha: true,
       powerPreference: "high-performance",
@@ -12550,8 +13026,8 @@ var Renderer = class _Renderer {
     });
     renderer.setClearColor(0, 0);
     renderer.shadowMap.enabled = true;
-    renderer.shadowMap.type = import_three32.PCFSoftShadowMap;
-    renderer.outputColorSpace = import_three32.SRGBColorSpace;
+    renderer.shadowMap.type = import_three33.PCFSoftShadowMap;
+    renderer.outputColorSpace = import_three33.SRGBColorSpace;
     renderer.setPixelRatio(this.options.render.pixelRatio ?? 1);
     renderer.setSize(this.viewWidth, this.viewHeight);
     return renderer;
@@ -12586,20 +13062,20 @@ var Renderer = class _Renderer {
       window["__THREE_DEVTOOLS__"].dispatchEvent(new CustomEvent("observe", { detail: this.scene }));
     }
     if (this.options.debug.grid) {
-      const gridHelper = new import_three32.GridHelper(128, 16);
+      const gridHelper = new import_three33.GridHelper(128, 16);
       this._debugHelpers.push(gridHelper);
       this.scene.add(gridHelper);
-      const gridHelper2 = new import_three32.GridHelper(128, 16);
+      const gridHelper2 = new import_three33.GridHelper(128, 16);
       this._debugHelpers.push(gridHelper2);
       gridHelper2.rotation.x = 90 * (Math.PI / 180);
       this.scene.add(gridHelper2);
-      const gridHelper3 = new import_three32.GridHelper(128, 16);
+      const gridHelper3 = new import_three33.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_three32.AxesHelper(64);
+      const axesHelper = new import_three33.AxesHelper(64);
       this._debugHelpers.push(axesHelper);
       this.scene.add(axesHelper);
     }
@@ -13284,19 +13760,19 @@ var AnvilParser = class {
 };
 
 // src/world/Chunk.ts
-var import_three37 = require("three");
+var import_three38 = require("three");
 init_BlockStates();
 init_AssetKey();
 
 // src/world/MineRenderWorld.ts
-var import_three35 = require("three");
+var import_three36 = require("three");
 init_BatchedExecutor();
 init_AssetKey();
 init_BlockStates();
 init_CubeFace();
 
 // src/world/SectionModels.ts
-var import_three34 = require("three");
+var import_three35 = require("three");
 init_AssetKey();
 init_Models();
 init_CubeFace();
@@ -13362,12 +13838,12 @@ var SectionModels = class {
         });
         await object.init();
         const geometry = object.children[0].geometry;
-        geometry.applyMatrix4(new import_three34.Matrix4().makeRotationFromEuler(rotation));
+        geometry.applyMatrix4(new import_three35.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_three34.Vector3(...CUBE_FACE_OFFSETS[local]).applyEuler(rotation);
+          const normal = new import_three35.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;
         });
@@ -13397,20 +13873,20 @@ var MineRenderWorld = class {
   }
   getBlockAt(posOrX, y, z) {
     if (typeof posOrX == "number") {
-      return this.getBlockAt(new import_three35.Vector3(posOrX, y, z));
+      return this.getBlockAt(new import_three36.Vector3(posOrX, y, z));
     }
     if (isTripleArray(posOrX)) {
-      return this.getBlockAt(new import_three35.Vector3(posOrX[0], posOrX[1], posOrX[2]));
+      return this.getBlockAt(new import_three36.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_three35.Vector3(posOrX, yOrBlock, z), block);
+      return this.setBlockAt(new import_three36.Vector3(posOrX, yOrBlock, z), block);
     }
     if (isTripleArray(posOrX)) {
-      return this.setBlockAt(new import_three35.Vector3(posOrX[0], posOrX[1], posOrX[2]), yOrBlock);
+      return this.setBlockAt(new import_three36.Vector3(posOrX[0], posOrX[1], posOrX[2]), yOrBlock);
     }
     return this.placeBlock(posOrX, yOrBlock);
   }
@@ -13431,7 +13907,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_three35.Vector3(...block.position), block, collect);
+    const place = (block) => this.placeBlock(new import_three36.Vector3(...block.position), block, collect);
     const keys = /* @__PURE__ */ new Map();
     for (const block of multiblock.blocks) {
       if (Chunk.isAir(block)) continue;
@@ -13509,13 +13985,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_three35.Vector3(...offset));
+        const neighbor = pos.clone().add(new import_three36.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_three35.Vector3(x, y, z));
+            const neighbor = pos.clone().add(new import_three36.Vector3(x, y, z));
             if (this.getBlockAt(neighbor)?.object?.fluidKind) {
               this.pendingCulling.set(neighbor.toArray().join(","), neighbor);
             }
@@ -13537,7 +14013,7 @@ var MineRenderWorld = class {
             if (!block) continue;
             if (block.object?.fluidKind) {
               await block.object.updateFluid((x, y, z) => {
-                const neighbor = pos.clone().add(new import_three35.Vector3(x, y, z));
+                const neighbor = pos.clone().add(new import_three36.Vector3(x, y, z));
                 const section = this.getChunkAt(neighbor);
                 const object = section?.getBlockAt(neighbor)?.object;
                 return {
@@ -13549,7 +14025,7 @@ var MineRenderWorld = class {
             }
             let mask = 0;
             for (const [face, offset] of CUBE_FACE_OFFSETS.entries()) {
-              const neighbor = pos.clone().add(new import_three35.Vector3(...offset));
+              const neighbor = pos.clone().add(new import_three36.Vector3(...offset));
               if (this.getChunkAt(neighbor)?.isOccludingAt(neighbor)) {
                 mask |= 1 << face;
               }
@@ -13583,14 +14059,14 @@ var MineRenderWorld = class {
     return this._chunks.get(this.worldPosToChunkKey(pos));
   }
   static worldToScenePosition(pos) {
-    return new import_three35.Vector3(
+    return new import_three36.Vector3(
       pos.x * 16,
       pos.y * 16,
       pos.z * 16
     );
   }
   static sceneToWorldPosition(pos) {
-    return new import_three35.Vector3(
+    return new import_three36.Vector3(
       pos.x / 16,
       pos.y / 16,
       pos.z / 16
@@ -13610,10 +14086,10 @@ var MineRenderWorld = class {
 };
 
 // src/world/SectionMesh.ts
-var import_three36 = require("three");
+var import_three37 = require("three");
 init_CanvasCompat();
 init_Materials();
-var SectionMesh = class _SectionMesh extends import_three36.Group {
+var SectionMesh = class _SectionMesh extends import_three37.Group {
   constructor() {
     super(...arguments);
     this.ownedMeshes = [];
@@ -13686,18 +14162,18 @@ var SectionMesh = class _SectionMesh extends import_three36.Group {
           for (let corner = 0; corner < 6; corner++) indices.push(start + sourceIndices.getX(face * 6 + corner) - face * 4);
         }
       }
-      const geometry = new import_three36.BufferGeometry();
-      geometry.setAttribute("position", new import_three36.Float32BufferAttribute(positions, 3));
-      geometry.setAttribute("normal", new import_three36.Float32BufferAttribute(normals, 3));
-      geometry.setAttribute("uv", new import_three36.Float32BufferAttribute(uvs, 2));
-      geometry.setAttribute("color", new import_three36.Float32BufferAttribute(colors, 3));
+      const geometry = new import_three37.BufferGeometry();
+      geometry.setAttribute("position", new import_three37.Float32BufferAttribute(positions, 3));
+      geometry.setAttribute("normal", new import_three37.Float32BufferAttribute(normals, 3));
+      geometry.setAttribute("uv", new import_three37.Float32BufferAttribute(uvs, 2));
+      geometry.setAttribute("color", new import_three37.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_three36.Mesh(geometry, material);
+      const mesh = new import_three37.Mesh(geometry, material);
       section.add(mesh);
       section.ownedMeshes.push({ mesh, texture });
     }
@@ -13731,10 +14207,10 @@ var Chunk = class _Chunk {
   }
   getBlockAt(posOrX, y, z) {
     if (typeof posOrX == "number") {
-      return this.getBlockAt(new import_three37.Vector3(posOrX, y, z));
+      return this.getBlockAt(new import_three38.Vector3(posOrX, y, z));
     }
     if (isTripleArray(posOrX)) {
-      return this.getBlockAt(new import_three37.Vector3(posOrX[0], posOrX[1], posOrX[2]));
+      return this.getBlockAt(new import_three38.Vector3(posOrX[0], posOrX[1], posOrX[2]));
     }
     const pos = this.worldPosToChunkPos(posOrX);
     const index = _Chunk.chunkPosToBlockIndex(pos);
@@ -13742,10 +14218,10 @@ var Chunk = class _Chunk {
   }
   async setBlockAt(posOrX, yOrBlock, z, block) {
     if (typeof posOrX == "number") {
-      return this.setBlockAt(new import_three37.Vector3(posOrX, yOrBlock, z), block);
+      return this.setBlockAt(new import_three38.Vector3(posOrX, yOrBlock, z), block);
     }
     if (isTripleArray(posOrX)) {
-      return this.setBlockAt(new import_three37.Vector3(posOrX[0], posOrX[1], posOrX[2]), yOrBlock);
+      return this.setBlockAt(new import_three38.Vector3(posOrX[0], posOrX[1], posOrX[2]), yOrBlock);
     }
     const worldPos = posOrX;
     const pos = this.worldPosToChunkPos(worldPos);
@@ -13774,7 +14250,8 @@ var Chunk = class _Chunk {
         this.data.set(index, void 0);
         return void 0;
       }
-      const template = getFluidKind(blockState.key, stored.properties) ? void 0 : await this.sectionModels?.get(blockState, stored.properties);
+      const perBlock = !this.sectionModels || getFluidKind(blockState.key, stored.properties) || blockState.key && BlockEntities.entry(await BlockEntities.getIndex(blockState.key.root), blockState.key.toNamespacedString());
+      const template = perBlock ? void 0 : await this.sectionModels.get(blockState, stored.properties);
       if (template) {
         this.sectionBlocks.set(index, { index, template, cullMask: 0 });
         this.meshDirty = true;
@@ -13830,7 +14307,7 @@ var Chunk = class _Chunk {
   }
   async clear(onBlocksChanged = this.onBlocksChanged) {
     const positions = [...this.renderedBlocks.keys()].map((index) => this.chunkPosToWorldPos(
-      new import_three37.Vector3(index % 16, Math.floor(index / 256), Math.floor(index / 16) % 16)
+      new import_three38.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();
@@ -13854,14 +14331,14 @@ var Chunk = class _Chunk {
     return pos.y * 16 * 16 + pos.z * 16 + pos.x;
   }
   worldPosToChunkPos(pos) {
-    return new import_three37.Vector3(
+    return new import_three38.Vector3(
       pos.x - this.x * 16,
       pos.y - this.y * 16,
       pos.z - this.z * 16
     );
   }
   chunkPosToWorldPos(pos) {
-    return new import_three37.Vector3(
+    return new import_three38.Vector3(
       this.x * 16 + pos.x,
       this.y * 16 + pos.y,
       this.z * 16 + pos.z
@@ -13884,6 +14361,7 @@ var Chunk = class _Chunk {
   BUILTIN_GENERATED,
   BasicAssetKey,
   BatchedExecutor,
+  BlockEntities,
   BlockObject,
   BlockStateResolver,
   BlockStates,
@@ -13905,7 +14383,9 @@ var Chunk = class _Chunk {
   DefaultBlockStates,
   DisplayPosition,
   DisplayTransforms,
+  ENTITY_ANIMATION_CHANNELS,
   Entities,
+  EntityAnimationPlayer,
   EntityObject,
   Env,
   FluidModelObject,
@@ -13981,6 +14461,7 @@ var Chunk = class _Chunk {
   createCanvas,
   createFluidGeometry,
   createImage,
+  entityAnimationTime,
   estimateBytesUsed,
   getBlockFluidState,
   getFluidKind,
@@ -14013,6 +14494,8 @@ var Chunk = class _Chunk {
   mergeVertices,
   prefix,
   registerNodeEnv,
+  sampleEntityAnimation,
+  sampleEntityKeyframes,
   sampleFluid,
   serializeBoxGeometryKey,
   serializeImageKey,