minerender 2.1.0-alpha.70 → 2.1.0-alpha.74

package/dist/node/index.js

@@ -801,7 +801,7 @@ var init_TextureLoader = __esm({
       static createTexture() {
         return new import_three3.Texture();
       }
-      static loadInBackground(src, format = import_three3.RGBAFormat, rotation = 0) {
+      static loadInBackground(src, format2 = import_three3.RGBAFormat, rotation = 0) {
         const texture = this.createTexture();
         texture.colorSpace = THREE.SRGBColorSpace;
         const image = ImageLoader.loadElement(src, () => {
@@ -811,11 +811,11 @@ var init_TextureLoader = __esm({
           console.warn("Failed to load texture", src, error);
         });
         texture.image = image;
-        texture.format = format;
+        texture.format = format2;
         texture.rotation = rotation;
         return Textures.initTextureProps(texture);
       }
-      static load(src, format = import_three3.RGBAFormat, rotation = 0) {
+      static load(src, format2 = import_three3.RGBAFormat, rotation = 0) {
         const texture = new import_three3.Texture();
         texture.colorSpace = THREE.SRGBColorSpace;
         ImageLoader.getData(src).then((image) => {
@@ -825,7 +825,7 @@ var init_TextureLoader = __esm({
           this.failedTextures.add(texture);
           console.warn("Failed to load texture", src, error);
         });
-        texture.format = format;
+        texture.format = format2;
         texture.rotation = rotation;
         return Textures.initTextureProps(texture);
       }
@@ -1032,7 +1032,7 @@ var init_Materials = __esm({
         };
         return material;
       }
-      static createShadedCanvasMaterial(canvas, transparent = false, shade = false) {
+      static createShadedCanvasMaterial(canvas, transparent = false, shade = false, boundUvs = false) {
         const vertShader = `
             uniform bool SHADE;
             
@@ -1042,6 +1042,10 @@ var init_Materials = __esm({
             #else
             varying vec2 vUv;
             #endif
+            #ifdef BOUND_UVS
+            attribute vec4 uvBounds;
+            flat out vec4 vUvBounds;
+            #endif
             varying vec3 vTint;
             varying float light;
             varying float lift;
@@ -1077,13 +1081,17 @@ var init_Materials = __esm({
                 }
                 
                 vUv = uv;
+                #ifdef BOUND_UVS
+                vUvBounds = uvBounds;
+                #endif
                 vTint = color;
                
+                vec4 mvPosition = vec4(position, 1.0);
                 #ifdef USE_INSTANCING
-                    gl_Position = projectionMatrix * viewMatrix * modelMatrix * instanceMatrix * vec4(position, 1.0);
-                #else
-                    gl_Position = projectionMatrix * modelViewMatrix * vec4( position, 1.0 );
+                    mvPosition = instanceMatrix * mvPosition;
                 #endif
+                mvPosition = modelViewMatrix * mvPosition;
+                gl_Position = projectionMatrix * mvPosition;
                 
             }
         `;
@@ -1103,13 +1111,22 @@ var init_Materials = __esm({
             #else
             varying vec2 vUv;
             #endif
+            #ifdef BOUND_UVS
+            flat in vec4 vUvBounds;
+            #endif
             varying vec3 vTint;
             varying float light;
             varying float lift;
 
             void main(void)
             {
-                vec4 color = texture2D(map, vUv);
+                #ifdef BOUND_UVS
+                // Keep edge samples inside their texture even without centroid interpolation.
+                vec2 mapUv = clamp(vUv, vUvBounds.xy, vUvBounds.zw);
+                #else
+                vec2 mapUv = vUv;
+                #endif
+                vec4 color = texture2D(map, mapUv);
                 color.rgb *= vTint;
                 
                 if (color.a < 0.01) discard;
@@ -1130,7 +1147,8 @@ var init_Materials = __esm({
             }
         `;
         try {
-          return new import_three5.ShaderMaterial({
+          const material = new import_three5.ShaderMaterial({
+            defines: boundUvs ? { BOUND_UVS: true } : {},
             uniforms: {
               SHADE: { value: true },
               BRIGHTNESS: { value: 1 },
@@ -1148,6 +1166,8 @@ var init_Materials = __esm({
             side: transparent ? import_three5.DoubleSide : import_three5.FrontSide,
             alphaTest: 0.5
           });
+          Object.assign(material.defaultAttributeValues, { uvBounds: [0, 0, 1, 1] });
+          return material;
         } catch (e) {
           console.warn(e);
         }
@@ -1754,6 +1774,10 @@ var init_AssetSource = __esm({
     AssetSource = class {
       constructor() {
       }
+      /** Whether this source prevents lower-priority sources from supplying the key. Its own assets remain available. */
+      blocks(key) {
+        return false;
+      }
       /**
        * Identifies this source's content across sessions for persistent caching. Sources that
        * cannot tell whether their content changed (an unnamed archive, for example) return
@@ -1934,10 +1958,10 @@ var init_NBTHelper = __esm({
   "src/nbt/NBTHelper.ts"() {
     import_buffer2 = require("buffer");
     NBTHelper = class {
-      static async fromBuffer(data, format) {
+      static async fromBuffer(data, format2) {
         const buffer = import_buffer2.Buffer.from(data instanceof Uint8Array ? data : new Uint8Array(data));
         const prismarineNbt = await import("prismarine-nbt");
-        const { parsed, type, metadata } = await prismarineNbt.parse(buffer, format);
+        const { parsed, type, metadata } = await prismarineNbt.parse(buffer, format2);
         return Object.assign(parsed, {
           format: type,
           metadata,
@@ -2186,6 +2210,164 @@ var init_BrowserArchiveProxy = __esm({
   }
 });
 
+// src/assets/source/archive/PackMetadata.ts
+function object(value, field) {
+  if (value === null || typeof value !== "object" || Array.isArray(value)) {
+    throw new Error(`Invalid ${field}: expected an object`);
+  }
+  return value;
+}
+function integer(value, field) {
+  if (typeof value !== "number" || !Number.isSafeInteger(value) || value < 0) {
+    throw new Error(`Invalid ${field}: expected a nonnegative integer`);
+  }
+  return value;
+}
+function format(value, field, upper = false) {
+  const parts = Array.isArray(value) ? value : [value];
+  if (parts.length < 1 || parts.length > 2) {
+    throw new Error(`Invalid ${field}: expected a major version or [major, minor]`);
+  }
+  return [integer(parts[0], field), parts.length === 2 ? integer(parts[1], field) : upper ? Infinity : 0];
+}
+function compare(a, b) {
+  return a[0] === b[0] ? a[1] - b[1] : a[0] - b[0];
+}
+function overlay(value, field) {
+  const entry = object(value, field);
+  const directory = entry.directory;
+  if (typeof directory !== "string" || !directory || /[^-_a-zA-Z0-9.]/.test(directory) || directory === "." || directory === "..") {
+    throw new Error(`Invalid ${field}.directory: expected a directory name without path separators`);
+  }
+  let min, max;
+  if ("min_format" in entry || "max_format" in entry) {
+    min = format(entry.min_format, `${field}.min_format`);
+    max = format(entry.max_format, `${field}.max_format`, true);
+  } else {
+    const range = entry.formats;
+    let lower, upper;
+    if (typeof range === "number") {
+      lower = upper = range;
+    } else if (Array.isArray(range)) {
+      if (range.length !== 2) throw new Error(`Invalid ${field}.formats: expected [min, max]`);
+      [lower, upper] = range;
+    } else {
+      const bounds = object(range, `${field}.formats`);
+      lower = bounds.min_inclusive;
+      upper = bounds.max_inclusive;
+    }
+    min = [integer(lower, `${field}.formats.min_inclusive`), 0];
+    max = [integer(upper, `${field}.formats.max_inclusive`), Infinity];
+  }
+  if (compare(min, max) > 0) throw new Error(`Invalid ${field}: minimum format exceeds maximum format`);
+  return { directory, min, max };
+}
+function pattern(value, field) {
+  if (value === void 0) return void 0;
+  if (typeof value !== "string") throw new Error(`Invalid ${field}: expected a regular expression string`);
+  try {
+    return new RegExp(value);
+  } catch (cause) {
+    throw new Error(`Invalid ${field}: ${String(cause)}`);
+  }
+}
+var PackMetadata;
+var init_PackMetadata = __esm({
+  "src/assets/source/archive/PackMetadata.ts"() {
+    PackMetadata = class _PackMetadata {
+      constructor(overlays, filters) {
+        this.overlays = overlays;
+        this.filters = filters;
+        this.hasOverlays = overlays.length > 0;
+      }
+      static parse(value) {
+        const metadata = object(value, "pack.mcmeta");
+        let overlays = [];
+        if ("overlays" in metadata) {
+          const entries = object(metadata.overlays, "overlays").entries;
+          if (!Array.isArray(entries)) throw new Error("Invalid overlays.entries: expected an array");
+          overlays = entries.map((entry, index) => overlay(entry, `overlays.entries[${index}]`));
+        }
+        let filters = [];
+        if ("filter" in metadata) {
+          const entries = object(metadata.filter, "filter").block;
+          if (!Array.isArray(entries)) throw new Error("Invalid filter.block: expected an array");
+          filters = entries.map((value2, index) => {
+            const field = `filter.block[${index}]`;
+            const entry = object(value2, field);
+            return { namespace: pattern(entry.namespace, `${field}.namespace`), path: pattern(entry.path, `${field}.path`) };
+          });
+        }
+        return new _PackMetadata(overlays, filters);
+      }
+      /** Returns applicable directories in lookup order, with the last declared overlay first. */
+      overlayDirectories(target) {
+        const selected = format(target, "target format");
+        return this.overlays.filter((entry) => compare(selected, entry.min) >= 0 && compare(selected, entry.max) <= 0).map((entry) => entry.directory).reverse();
+      }
+      blocks(namespace, path) {
+        return this.filters.some((entry) => entry.namespace?.test(namespace) ?? true) && this.filters.some((entry) => entry.path?.test(path) ?? true);
+      }
+    };
+  }
+});
+
+// src/assets/source/archive/PackFormats.ts
+var PackFormats;
+var init_PackFormats = __esm({
+  "src/assets/source/archive/PackFormats.ts"() {
+    init_Requests();
+    PackFormats = class {
+      static {
+        this.versions = /* @__PURE__ */ new Map();
+      }
+      /** Resolves pack formats from Mojang's client metadata hosted on assets.mcasset.cloud. */
+      static async get(version, type) {
+        let pending = this.versions.get(version);
+        if (!pending || pending.expires <= Date.now()) {
+          pending = {
+            formats: this.load(version),
+            expires: ["latest", "release", "snapshot"].includes(version) ? Date.now() + 3e5 : Infinity
+          };
+          this.versions.set(version, pending);
+        }
+        try {
+          return (await pending.formats)[type];
+        } catch (cause) {
+          if (this.versions.get(version) === pending) this.versions.delete(version);
+          const option = type === "assets" ? "resourcePackFormat" : "dataPackFormat";
+          const reason = cause instanceof Error ? cause.message : String(cause);
+          throw new Error(`Could not resolve the pack format for Minecraft ${version}. Set ArchiveAssetSource ${option} explicitly. ${reason}`);
+        }
+      }
+      static async load(version) {
+        const response = await Requests.genericRequest({
+          url: `https://assets.mcasset.cloud/${encodeURIComponent(version)}/game-version.json`,
+          responseType: "json"
+        });
+        const data = response.data;
+        if (!data || typeof data !== "object" || Array.isArray(data)) {
+          throw new Error("Expected version metadata to be an object");
+        }
+        const packs = data.pack_version;
+        if (typeof packs !== "number" && (!packs || typeof packs !== "object" || Array.isArray(packs))) {
+          throw new Error("Expected pack_version to be a number or an object");
+        }
+        const format2 = (type) => {
+          const modern = typeof packs === "object" && ["resource_major", "resource_minor", "data_major", "data_minor"].some((key) => key in packs);
+          const major = typeof packs === "number" ? packs : packs[modern ? `${type}_major` : type];
+          const minor = modern ? packs[`${type}_minor`] : 0;
+          if (typeof major !== "number" || !Number.isSafeInteger(major) || major < 0 || typeof minor !== "number" || !Number.isSafeInteger(minor) || minor < 0) {
+            throw new Error(`Invalid ${type} pack format in version metadata`);
+          }
+          return Object.freeze([major, minor]);
+        };
+        return { assets: format2("resource"), data: format2("data") };
+      }
+    };
+  }
+});
+
 // src/assets/source/archive/ArchiveAssetSource.ts
 var ArchiveAssetSource;
 var init_ArchiveAssetSource = __esm({
@@ -2194,35 +2376,77 @@ var init_ArchiveAssetSource = __esm({
     init_request();
     init_HostedAssetSource();
     init_BrowserArchiveProxy();
+    init_AssetLoader();
+    init_PackMetadata();
+    init_PackFormats();
     ArchiveAssetSource = class _ArchiveAssetSource extends AssetSource {
-      constructor(archiveProxy) {
+      constructor(archiveProxy, options = {}) {
         super();
-        console.log(archiveProxy);
         this._archiveProxy = archiveProxy;
+        const copyFormat = (format2) => typeof format2 === "object" ? [format2[0], format2[1]] : format2;
+        this.options = {
+          resourcePackFormat: copyFormat(options.resourcePackFormat),
+          dataPackFormat: copyFormat(options.dataPackFormat)
+        };
       }
-      static blob(blob) {
-        return new _ArchiveAssetSource(new BrowserArchiveProxy(blob));
+      static blob(blob, options) {
+        return new _ArchiveAssetSource(new BrowserArchiveProxy(blob), options);
       }
       get cacheId() {
         const id = this._archiveProxy.id;
-        return id === void 0 ? void 0 : `archive:${id}`;
+        const formats = [this.options.resourcePackFormat ?? AssetLoader.version, this.options.dataPackFormat ?? AssetLoader.version];
+        return id === void 0 ? void 0 : `archive-metadata:1:${id}:${JSON.stringify(formats)}`;
       }
       async getEntries() {
-        return this._archiveProxy.getEntries();
+        return this.entries ??= this._archiveProxy.getEntries().catch((error) => {
+          this.entries = void 0;
+          throw error;
+        });
       }
       async getEntry(path) {
         const entries = await this.getEntries();
         return entries.find((e) => e.filename === path);
       }
+      async getMetadata(key) {
+        try {
+          return await (this.metadata ??= this.getEntry("pack.mcmeta").then(async (entry) => PackMetadata.parse(entry ? JSON.parse(await (await entry.getData()).text()) : {})).catch((error) => {
+            this.metadata = void 0;
+            throw error;
+          }));
+        } catch (cause) {
+          throw new AssetLoadError(this, key, "pack.mcmeta", cause);
+        }
+      }
+      async blocks(key) {
+        if (key.rootType !== "assets" && key.rootType !== "data") return false;
+        const metadata = await this.getMetadata(key);
+        const path = `${key.assetType !== void 0 ? key.assetType + "/" : ""}${key.getFullPath()}${key.extension}`;
+        return metadata.blocks(key.namespace, path);
+      }
       async get(key, parser) {
         const responseParser = HostedAssetSource.PARSER_MAP.get(parser);
         return this.load(key, responseParser);
       }
       async load(key, parser) {
         const path = `${this.assetBasePath(key)}${key.type !== void 0 ? key.type + "/" : ""}${key.path}${key.extension}`;
+        const version = AssetLoader.version;
+        let selectedPath = path;
         let url;
         try {
-          const entry = await this.getEntry(path);
+          let directories = [];
+          if (key.rootType === "assets" || key.rootType === "data") {
+            const metadata = await this.getMetadata(key);
+            if (metadata.hasOverlays) {
+              const format2 = (key.rootType === "assets" ? this.options.resourcePackFormat : this.options.dataPackFormat) ?? await PackFormats.get(version, key.rootType);
+              directories = metadata.overlayDirectories(format2);
+            }
+          }
+          let entry;
+          for (const directory of [...directories, ""]) {
+            selectedPath = directory ? `${directory}/${path}` : path;
+            entry = await this.getEntry(selectedPath);
+            if (entry) break;
+          }
           if (!entry) {
             return void 0;
           }
@@ -2235,7 +2459,8 @@ var init_ArchiveAssetSource = __esm({
           }
           return await parser.parse(response);
         } catch (cause) {
-          throw new AssetLoadError(this, key, path, cause);
+          if (cause instanceof AssetLoadError) throw cause;
+          throw new AssetLoadError(this, key, selectedPath, cause);
         } finally {
           if (url !== void 0) {
             URL.revokeObjectURL(url);
@@ -2268,6 +2493,8 @@ var init_archive = __esm({
     init_ArchiveEntry();
     init_ArchiveProxy();
     init_BrowserArchiveProxy();
+    init_PackFormats();
+    init_PackMetadata();
   }
 });
 
@@ -2364,13 +2591,14 @@ ${key}` : key;
         this.addSource("mcassets", new HostedAssetSource(this.ROOT, { retryDefaults: false }));
       }
       static async getAll(key, parser) {
-        let promises = [];
-        for (const source of this._SOURCES) {
-          promises.push(source.source.get(key, parser));
+        const sources = [...this._SOURCES];
+        const results = [];
+        for (const { source } of sources) {
+          const asset = await source.get(key, parser);
+          if (asset != void 0) results.push(asset);
+          if (await source.blocks(key)) break;
         }
-        return Promise.all(promises).then((results) => {
-          return results.filter((r) => r != void 0);
-        });
+        return results;
       }
       /** Returns the first defined result in source-priority order, without merging assets. */
       static async get(key, parser) {
@@ -2391,13 +2619,17 @@ ${key}` : key;
       /** Tries each path within a source before considering lower-priority sources. */
       static async getFirst(keys, parser) {
         const sources = [...this._SOURCES];
+        let remaining = [...keys];
         for (const source of sources) {
-          for (const key of keys) {
+          for (const key of remaining) {
             const result = await source.source.get(key, parser);
             if (result !== void 0) {
               return { key, asset: result };
             }
           }
+          const blocked = await Promise.all(remaining.map((key) => source.source.blocks(key)));
+          remaining = remaining.filter((_, index) => !blocked[index]);
+          if (!remaining.length) break;
         }
         return void 0;
       }
@@ -2856,6 +3088,37 @@ var init_UVMapper = __esm({
       static facesToUv(faces, originalTextureSize, actualTextureSize) {
         return new import_three9.Float32BufferAttribute(this.facesToUvArray(faces, originalTextureSize, actualTextureSize), 2);
       }
+      /** Bounds texture sampling to texel centres without changing cropped face UVs. */
+      static setAtlasUvBounds(geometry, faces, atlas) {
+        const uv = geometry.getAttribute("uv");
+        const bounds = new Float32Array(uv.count * 4);
+        for (const [faceIndex, faceName] of CUBE_FACES.entries()) {
+          const texture = faces[faceName]?.texture?.substring(1);
+          const position = texture && atlas.positions[texture];
+          const size = texture && atlas.sizes[texture];
+          let minU = Infinity, minV = Infinity, maxU = -Infinity, maxV = -Infinity;
+          if (position && size) {
+            minU = position[0] / atlas.image.width;
+            maxU = (position[0] + size[0]) / atlas.image.width;
+            minV = 1 - (position[1] + size[1]) / atlas.image.height;
+            maxV = 1 - position[1] / atlas.image.height;
+          } else {
+            for (let corner = 0; corner < 4; corner++) {
+              const index = faceIndex * 4 + corner;
+              minU = Math.min(minU, uv.getX(index));
+              minV = Math.min(minV, uv.getY(index));
+              maxU = Math.max(maxU, uv.getX(index));
+              maxV = Math.max(maxV, uv.getY(index));
+            }
+          }
+          const insetU = Math.min(0.5 / atlas.image.width, (maxU - minU) / 2);
+          const insetV = Math.min(0.5 / atlas.image.height, (maxV - minV) / 2);
+          for (let corner = 0; corner < 4; corner++) {
+            bounds.set([minU + insetU, minV + insetV, maxU - insetU, maxV - insetV], (faceIndex * 4 + corner) * 4);
+          }
+        }
+        geometry.setAttribute("uvBounds", new import_three9.Float32BufferAttribute(bounds, 4));
+      }
       static lockUvs(geometry, faces, atlas, rotation) {
         const uv = geometry.getAttribute("uv");
         for (let faceIndex = 0; faceIndex < CUBE_FACES.length; faceIndex++) {
@@ -3512,27 +3775,27 @@ var init_EntityAnimationPlayer = __esm({
         for (const layer of layers) {
           const objects = [];
           if (poses) {
-            layer.traverse((object) => {
-              if (poses.has(object)) objects.push(object);
+            layer.traverse((object2) => {
+              if (poses.has(object2)) objects.push(object2);
             });
           } else {
             for (const bone of Object.keys(animation.bones)) {
-              const object = layer.getObjectByName(`group:${bone}`);
-              if (object) objects.push(object);
+              const object2 = layer.getObjectByName(`group:${bone}`);
+              if (object2) objects.push(object2);
             }
           }
-          for (const object of objects) {
-            const bone = object.name.slice("group:".length);
-            const pose = poses?.get(object);
+          for (const object2 of objects) {
+            const bone = object2.name.slice("group:".length);
+            const pose = poses?.get(object2);
             this.parts.push({
               bone,
-              object,
-              position: object.position.clone(),
-              rotation: object.rotation.clone(),
-              scale: object.scale.clone(),
-              basePosition: pose ? new import_three11.Vector3(...pose.offset) : object.position.clone(),
-              baseRotation: pose ? new import_three11.Euler(...pose.rotation, "ZYX") : object.rotation.clone(),
-              baseScale: pose ? new import_three11.Vector3(...pose.scale ?? [1, 1, 1]) : object.scale.clone()
+              object: object2,
+              position: object2.position.clone(),
+              rotation: object2.rotation.clone(),
+              scale: object2.scale.clone(),
+              basePosition: pose ? new import_three11.Vector3(...pose.offset) : object2.position.clone(),
+              baseRotation: pose ? new import_three11.Euler(...pose.rotation, "ZYX") : object2.rotation.clone(),
+              baseScale: pose ? new import_three11.Vector3(...pose.scale ?? [1, 1, 1]) : object2.scale.clone()
             });
           }
         }
@@ -4059,15 +4322,15 @@ var init_SceneObject = __esm({
         }
       }
       //</editor-fold>
-      toggleObjectVisibility(object, visible) {
-        if (object) {
+      toggleObjectVisibility(object2, visible) {
+        if (object2) {
           if (typeof visible !== "undefined") {
-            object.visible = visible;
+            object2.visible = visible;
           } else {
-            object.visible = !object.visible;
+            object2.visible = !object2.visible;
           }
           this.notifyDirty();
-          return object.visible;
+          return object2.visible;
         }
         this.notifyDirty();
         return false;
@@ -4358,8 +4621,8 @@ var init_EntityObject = __esm({
               this.scrollMaterials.push({ material: mat, offset: mat.map.offset, speed: scroll });
             }
           }
-          this.getLayerGroup(name)?.traverse((object) => {
-            if (isMesh(object)) object.material = mat;
+          this.getLayerGroup(name)?.traverse((object2) => {
+            if (isMesh(object2)) object2.material = mat;
           });
         }));
         if (!this.children.length) {
@@ -4687,8 +4950,8 @@ function toTrianglesDrawMode(geometry, drawMode) {
     return geometry;
   }
 }
-function computeMorphedAttributes(object) {
-  if (object.geometry.isBufferGeometry !== true) {
+function computeMorphedAttributes(object2) {
+  if (object2.geometry.isBufferGeometry !== true) {
     console.error("THREE.BufferGeometryUtils: Geometry is not of type BufferGeometry.");
     return null;
   }
@@ -4701,11 +4964,11 @@ function computeMorphedAttributes(object) {
   const _morphA = new import_three22.Vector3();
   const _morphB = new import_three22.Vector3();
   const _morphC = new import_three22.Vector3();
-  function _calculateMorphedAttributeData(object2, material2, attribute, morphAttribute, morphTargetsRelative2, a2, b2, c2, modifiedAttributeArray) {
+  function _calculateMorphedAttributeData(object3, material2, attribute, morphAttribute, morphTargetsRelative2, a2, b2, c2, modifiedAttributeArray) {
     _vA.fromBufferAttribute(attribute, a2);
     _vB.fromBufferAttribute(attribute, b2);
     _vC.fromBufferAttribute(attribute, c2);
-    const morphInfluences = object2.morphTargetInfluences;
+    const morphInfluences = object3.morphTargetInfluences;
     if (material2.morphTargets && morphAttribute && morphInfluences) {
       _morphA.set(0, 0, 0);
       _morphB.set(0, 0, 0);
@@ -4731,10 +4994,10 @@ function computeMorphedAttributes(object) {
       _vB.add(_morphB);
       _vC.add(_morphC);
     }
-    if (object2.isSkinnedMesh) {
-      object2.boneTransform(a2, _vA);
-      object2.boneTransform(b2, _vB);
-      object2.boneTransform(c2, _vC);
+    if (object3.isSkinnedMesh) {
+      object3.boneTransform(a2, _vA);
+      object3.boneTransform(b2, _vB);
+      object3.boneTransform(c2, _vC);
     }
     modifiedAttributeArray[a2 * 3 + 0] = _vA.x;
     modifiedAttributeArray[a2 * 3 + 1] = _vA.y;
@@ -4746,8 +5009,8 @@ function computeMorphedAttributes(object) {
     modifiedAttributeArray[c2 * 3 + 1] = _vC.y;
     modifiedAttributeArray[c2 * 3 + 2] = _vC.z;
   }
-  const geometry = object.geometry;
-  const material = object.material;
+  const geometry = object2.geometry;
+  const material = object2.material;
   let a, b, c;
   const index = geometry.index;
   const positionAttribute = geometry.attributes.position;
@@ -4774,7 +5037,7 @@ function computeMorphedAttributes(object) {
           b = index.getX(j + 1);
           c = index.getX(j + 2);
           _calculateMorphedAttributeData(
-            object,
+            object2,
             groupMaterial,
             positionAttribute,
             morphPosition,
@@ -4785,7 +5048,7 @@ function computeMorphedAttributes(object) {
             modifiedPosition
           );
           _calculateMorphedAttributeData(
-            object,
+            object2,
             groupMaterial,
             normalAttribute,
             morphNormal,
@@ -4805,7 +5068,7 @@ function computeMorphedAttributes(object) {
         b = index.getX(i + 1);
         c = index.getX(i + 2);
         _calculateMorphedAttributeData(
-          object,
+          object2,
           material,
           positionAttribute,
           morphPosition,
@@ -4816,7 +5079,7 @@ function computeMorphedAttributes(object) {
           modifiedPosition
         );
         _calculateMorphedAttributeData(
-          object,
+          object2,
           material,
           normalAttribute,
           morphNormal,
@@ -4840,7 +5103,7 @@ function computeMorphedAttributes(object) {
           b = j + 1;
           c = j + 2;
           _calculateMorphedAttributeData(
-            object,
+            object2,
             groupMaterial,
             positionAttribute,
             morphPosition,
@@ -4851,7 +5114,7 @@ function computeMorphedAttributes(object) {
             modifiedPosition
           );
           _calculateMorphedAttributeData(
-            object,
+            object2,
             groupMaterial,
             normalAttribute,
             morphNormal,
@@ -4871,7 +5134,7 @@ function computeMorphedAttributes(object) {
         b = i + 1;
         c = i + 2;
         _calculateMorphedAttributeData(
-          object,
+          object2,
           material,
           positionAttribute,
           morphPosition,
@@ -4882,7 +5145,7 @@ function computeMorphedAttributes(object) {
           modifiedPosition
         );
         _calculateMorphedAttributeData(
-          object,
+          object2,
           material,
           normalAttribute,
           morphNormal,
@@ -5196,13 +5459,13 @@ var init_ModelObject = __esm({
           transform.multiply(new import_three25.Matrix4().makeTranslation(-8, -8, -8));
           try {
             for (const part of parts) {
-              const object = new EntityObject(part.model, { flip: false, wireframe: this.options.wireframe });
-              object.matrix.copy(transform).multiply(part.transform);
-              object.matrixWorldNeedsUpdate = true;
-              object.matrixAutoUpdate = false;
-              this.add(object);
-              await object.init();
-              object.iterateAllMeshes((mesh) => {
+              const object2 = new EntityObject(part.model, { flip: false, wireframe: this.options.wireframe });
+              object2.matrix.copy(transform).multiply(part.transform);
+              object2.matrixWorldNeedsUpdate = true;
+              object2.matrixAutoUpdate = false;
+              this.add(object2);
+              await object2.init();
+              object2.iterateAllMeshes((mesh) => {
                 const source = mesh.material;
                 let material = this.specialMaterials.get(source);
                 if (!material) {
@@ -5213,7 +5476,7 @@ var init_ModelObject = __esm({
                 mesh.material = material;
               });
               for (const [name, rotation] of Object.entries(part.rotations)) {
-                object.getGroupByName(name)?.rotation.set(...rotation, "ZYX");
+                object2.getGroupByName(name)?.rotation.set(...rotation, "ZYX");
               }
             }
           } catch (error) {
@@ -5258,6 +5521,7 @@ var init_ModelObject = __esm({
               if (this.options.uvLockRotation) {
                 UVMapper.lockUvs(elGeo, el.faces, this.atlas, new import_three25.Euler(...this.options.uvLockRotation));
               }
+              UVMapper.setAtlasUvBounds(elGeo, el.faces, this.atlas);
               if (this.options.tints) {
                 const colors = new Float32Array(elGeo.getAttribute("position").count * 3).fill(1);
                 for (const [faceIndex, faceName] of CUBE_FACES.entries()) {
@@ -5323,7 +5587,7 @@ var init_ModelObject = __esm({
       }
       applyTextures() {
         if (this.atlas) {
-          const mat = Materials.createShadedCanvasMaterial(this.atlas.image.canvas, this.atlas.hasTransparency, false);
+          const mat = Materials.createShadedCanvasMaterial(this.atlas.image.canvas, this.atlas.hasTransparency, false, true);
           this.atlasMaterial = mat;
           this.atlasTexture = mat.uniforms?.map?.value ?? mat.map;
           this.iterateAllMeshes((mesh) => {
@@ -5688,6 +5952,8 @@ __export(index_node_exports, {
   NodeCache: () => NodeCache,
   NodeEnv: () => NodeEnv,
   OrbitControls: () => OrbitControls,
+  PackFormats: () => PackFormats,
+  PackMetadata: () => PackMetadata,
   PersistentCache: () => PersistentCache,
   Renderer: () => Renderer,
   RequestError: () => RequestError,
@@ -6159,7 +6425,7 @@ var OBJExporter = class {
    * @param {Object3D} object - The 3D object to export.
    * @return {string} The exported OBJ.
    */
-  parse(object) {
+  parse(object2) {
     let output = "";
     let indexVertex = 0;
     let indexVertexUvs = 0;
@@ -6278,7 +6544,7 @@ var OBJExporter = class {
       }
       indexVertex += nbVertex;
     }
-    object.traverse(function(child) {
+    object2.traverse(function(child) {
       if (child.isMesh === true) {
         parseMesh(child);
       }
@@ -6306,9 +6572,9 @@ var PLYExporter = class {
    * @param {PLYExporter~Options} options - The export options.
    * @return {?(string|ArrayBuffer)} The exported PLY.
    */
-  parse(object, onDone, options = {}) {
+  parse(object2, onDone, options = {}) {
     function traverseMeshes(cb) {
-      object.traverse(function(child) {
+      object2.traverse(function(child) {
         if (child.isMesh === true || child.isPoints) {
           const mesh = child;
           const geometry = mesh.geometry;
@@ -6341,7 +6607,7 @@ var PLYExporter = class {
     for (const name of customAttributeNames) customTypes[name] = "float";
     let vertexCount = 0;
     let faceCount = 0;
-    object.traverse(function(child) {
+    object2.traverse(function(child) {
       if (child.isMesh === true) {
         const mesh = child;
         const geometry = mesh.geometry;
@@ -7129,12 +7395,12 @@ var GLTFWriter = class {
    * @param {THREE.Object3D|THREE.Material|THREE.BufferGeometry|THREE.AnimationClip} object
    * @param {Object} objectDef
    */
-  serializeUserData(object, objectDef) {
-    if (Object.keys(object.userData).length === 0) return;
+  serializeUserData(object2, objectDef) {
+    if (Object.keys(object2.userData).length === 0) return;
     const options = this.options;
     const extensionsUsed = this.extensionsUsed;
     try {
-      const json = JSON.parse(JSON.stringify(object.userData));
+      const json = JSON.parse(JSON.stringify(object2.userData));
       if (options.includeCustomExtensions && json.gltfExtensions) {
         if (objectDef.extensions === void 0) objectDef.extensions = {};
         for (const extensionName in json.gltfExtensions) {
@@ -7145,7 +7411,7 @@ var GLTFWriter = class {
       }
       if (Object.keys(json).length > 0) objectDef.extras = json;
     } catch (error) {
-      console.warn("THREE.GLTFExporter: userData of '" + object.name + "' won't be serialized because of JSON.stringify error - " + error.message);
+      console.warn("THREE.GLTFExporter: userData of '" + object2.name + "' won't be serialized because of JSON.stringify error - " + error.message);
     }
   }
   /**
@@ -7518,7 +7784,7 @@ var GLTFWriter = class {
    * @param {string} mimeType export format
    * @return {number}     Index of the processed texture in the "images" array
    */
-  processImage(image, format, flipY, mimeType = "image/png") {
+  processImage(image, format2, flipY, mimeType = "image/png") {
     if (image !== null) {
       const writer = this;
       const cache = writer.cache;
@@ -7542,8 +7808,8 @@ var GLTFWriter = class {
         ctx.scale(1, -1);
       }
       if (image.data !== void 0) {
-        if (format !== import_three18.RGBAFormat) {
-          console.error("GLTFExporter: Only RGBAFormat is supported.", format);
+        if (format2 !== import_three18.RGBAFormat) {
+          console.error("GLTFExporter: Only RGBAFormat is supported.", format2);
         }
         if (image.width > options.maxTextureSize || image.height > options.maxTextureSize) {
           console.warn("GLTFExporter: Image size is bigger than maxTextureSize", image);
@@ -8071,13 +8337,13 @@ var GLTFWriter = class {
    * @param {THREE.Object3D} object
    * @return {?number}
    */
-  processSkin(object) {
+  processSkin(object2) {
     const json = this.json;
     const nodeMap = this.nodeMap;
-    const node = json.nodes[nodeMap.get(object)];
-    const skeleton = object.skeleton;
+    const node = json.nodes[nodeMap.get(object2)];
+    const skeleton = object2.skeleton;
     if (skeleton === void 0) return null;
-    const rootJoint = object.skeleton.bones[0];
+    const rootJoint = object2.skeleton.bones[0];
     if (rootJoint === void 0) return null;
     const joints = [];
     const inverseBindMatrices = new Float32Array(skeleton.bones.length * 16);
@@ -8085,7 +8351,7 @@ var GLTFWriter = class {
     for (let i = 0; i < skeleton.bones.length; ++i) {
       joints.push(nodeMap.get(skeleton.bones[i]));
       temporaryBoneInverse.copy(skeleton.boneInverses[i]);
-      temporaryBoneInverse.multiply(object.bindMatrix).toArray(inverseBindMatrices, i * 16);
+      temporaryBoneInverse.multiply(object2.bindMatrix).toArray(inverseBindMatrices, i * 16);
     }
     if (json.skins === void 0) json.skins = [];
     json.skins.push({
@@ -8101,19 +8367,19 @@ var GLTFWriter = class {
    * @param {THREE.Object3D} object Object3D to processNodeAsync
    * @return {Promise<number>} Index of the node in the nodes list
    */
-  async processNodeAsync(object) {
+  async processNodeAsync(object2) {
     const json = this.json;
     const options = this.options;
     const nodeMap = this.nodeMap;
     if (!json.nodes) json.nodes = [];
-    if (object.pivot !== null) {
-      return await this._processNodeWithPivotAsync(object);
+    if (object2.pivot !== null) {
+      return await this._processNodeWithPivotAsync(object2);
     }
     const nodeDef = {};
     if (options.trs) {
-      const rotation = object.quaternion.toArray();
-      const position = object.position.toArray();
-      const scale = object.scale.toArray();
+      const rotation = object2.quaternion.toArray();
+      const position = object2.position.toArray();
+      const scale = object2.scale.toArray();
       if (!equalArray(rotation, [0, 0, 0, 1])) {
         nodeDef.rotation = rotation;
       }
@@ -8124,28 +8390,28 @@ var GLTFWriter = class {
         nodeDef.scale = scale;
       }
     } else {
-      if (object.matrixAutoUpdate) {
-        object.updateMatrix();
+      if (object2.matrixAutoUpdate) {
+        object2.updateMatrix();
       }
-      if (isIdentityMatrix(object.matrix) === false) {
-        nodeDef.matrix = object.matrix.elements;
+      if (isIdentityMatrix(object2.matrix) === false) {
+        nodeDef.matrix = object2.matrix.elements;
       }
     }
-    if (object.name !== "") nodeDef.name = String(object.name);
-    this.serializeUserData(object, nodeDef);
-    if (object.isMesh || object.isLine || object.isPoints) {
-      const meshIndex = await this.processMeshAsync(object);
+    if (object2.name !== "") nodeDef.name = String(object2.name);
+    this.serializeUserData(object2, nodeDef);
+    if (object2.isMesh || object2.isLine || object2.isPoints) {
+      const meshIndex = await this.processMeshAsync(object2);
       if (meshIndex !== null) nodeDef.mesh = meshIndex;
-    } else if (object.isCamera) {
-      nodeDef.camera = this.processCamera(object);
+    } else if (object2.isCamera) {
+      nodeDef.camera = this.processCamera(object2);
     }
-    if (object.isSkinnedMesh) this.skins.push(object);
+    if (object2.isSkinnedMesh) this.skins.push(object2);
     const nodeIndex = json.nodes.push(nodeDef) - 1;
-    nodeMap.set(object, nodeIndex);
-    if (object.children.length > 0) {
+    nodeMap.set(object2, nodeIndex);
+    if (object2.children.length > 0) {
       const children = [];
-      for (let i = 0, l = object.children.length; i < l; i++) {
-        const child = object.children[i];
+      for (let i = 0, l = object2.children.length; i < l; i++) {
+        const child = object2.children[i];
         if (child.visible || options.onlyVisible === false) {
           const childNodeIndex = await this.processNodeAsync(child);
           if (childNodeIndex !== null) children.push(childNodeIndex);
@@ -8154,7 +8420,7 @@ var GLTFWriter = class {
       if (children.length > 0) nodeDef.children = children;
     }
     await this._invokeAllAsync(function(ext) {
-      ext.writeNode && ext.writeNode(object, nodeDef);
+      ext.writeNode && ext.writeNode(object2, nodeDef);
     });
     return nodeIndex;
   }
@@ -8163,19 +8429,19 @@ var GLTFWriter = class {
    * @param {THREE.Object3D} object Object3D with pivot
    * @return {Promise<number>} Index of the container node
    */
-  async _processNodeWithPivotAsync(object) {
+  async _processNodeWithPivotAsync(object2) {
     const json = this.json;
     const options = this.options;
     const nodeMap = this.nodeMap;
-    const pivot = object.pivot;
+    const pivot = object2.pivot;
     const containerDef = {};
-    const rotation = object.quaternion.toArray();
+    const rotation = object2.quaternion.toArray();
     const position = [
-      object.position.x + pivot.x,
-      object.position.y + pivot.y,
-      object.position.z + pivot.z
+      object2.position.x + pivot.x,
+      object2.position.y + pivot.y,
+      object2.position.z + pivot.z
     ];
-    const scale = object.scale.toArray();
+    const scale = object2.scale.toArray();
     if (!equalArray(rotation, [0, 0, 0, 1])) {
       containerDef.rotation = rotation;
     }
@@ -8186,28 +8452,28 @@ var GLTFWriter = class {
       containerDef.scale = scale;
     }
     containerDef.extras = { pivot: pivot.toArray() };
-    if (object.name !== "") containerDef.name = String(object.name);
-    this.serializeUserData(object, containerDef);
+    if (object2.name !== "") containerDef.name = String(object2.name);
+    this.serializeUserData(object2, containerDef);
     const containerIndex = json.nodes.push(containerDef) - 1;
-    nodeMap.set(object, containerIndex);
+    nodeMap.set(object2, containerIndex);
     const childDef = {};
     const childPosition = [-pivot.x, -pivot.y, -pivot.z];
     if (!equalArray(childPosition, [0, 0, 0])) {
       childDef.translation = childPosition;
     }
-    if (object.isMesh || object.isLine || object.isPoints) {
-      const meshIndex = await this.processMeshAsync(object);
+    if (object2.isMesh || object2.isLine || object2.isPoints) {
+      const meshIndex = await this.processMeshAsync(object2);
       if (meshIndex !== null) childDef.mesh = meshIndex;
-    } else if (object.isCamera) {
-      childDef.camera = this.processCamera(object);
+    } else if (object2.isCamera) {
+      childDef.camera = this.processCamera(object2);
     }
-    if (object.isSkinnedMesh) this.skins.push(object);
+    if (object2.isSkinnedMesh) this.skins.push(object2);
     const childIndex = json.nodes.push(childDef) - 1;
     const containerChildren = [childIndex];
-    if (object.children.length > 0) {
+    if (object2.children.length > 0) {
       const grandchildren = [];
-      for (let i = 0, l = object.children.length; i < l; i++) {
-        const child = object.children[i];
+      for (let i = 0, l = object2.children.length; i < l; i++) {
+        const child = object2.children[i];
         if (child.visible || options.onlyVisible === false) {
           const childNodeIndex = await this.processNodeAsync(child);
           if (childNodeIndex !== null) grandchildren.push(childNodeIndex);
@@ -8217,7 +8483,7 @@ var GLTFWriter = class {
     }
     containerDef.children = containerChildren;
     await this._invokeAllAsync(function(ext) {
-      ext.writeNode && ext.writeNode(object, containerDef);
+      ext.writeNode && ext.writeNode(object2, containerDef);
     });
     return containerIndex;
   }
@@ -8660,10 +8926,10 @@ var GLTFMeshGpuInstancing = class {
     this.writer = writer;
     this.name = "EXT_mesh_gpu_instancing";
   }
-  writeNode(object, nodeDef) {
-    if (!object.isInstancedMesh) return;
+  writeNode(object2, nodeDef) {
+    if (!object2.isInstancedMesh) return;
     const writer = this.writer;
-    const mesh = object;
+    const mesh = object2;
     const translationAttr = new Float32Array(mesh.count * 3);
     const rotationAttr = new Float32Array(mesh.count * 4);
     const scaleAttr = new Float32Array(mesh.count * 3);
@@ -8853,8 +9119,8 @@ var SceneExporter = class {
     }
   }
 };
-function localMatrix(object) {
-  return object.matrixAutoUpdate ? new import_three19.Matrix4().compose(object.position, object.quaternion, object.scale) : object.matrix.clone();
+function localMatrix(object2) {
+  return object2.matrixAutoUpdate ? new import_three19.Matrix4().compose(object2.position, object2.quaternion, object2.scale) : object2.matrix.clone();
 }
 function createSnapshot(root, gltf, bakeColors = false) {
   const scene = new import_three19.Scene();
@@ -8958,10 +9224,10 @@ function createSnapshot(root, gltf, bakeColors = false) {
       scene.add(copy);
     }
   };
-  const visit = (object, parentWorld) => {
-    if (!object.visible) return;
-    const world = parentWorld.clone().multiply(localMatrix(object));
-    const mesh = object;
+  const visit = (object2, parentWorld) => {
+    if (!object2.visible) return;
+    const world = parentWorld.clone().multiply(localMatrix(object2));
+    const mesh = object2;
     if (mesh.isMesh) {
       const instanced = mesh;
       if (instanced.isInstancedMesh) {
@@ -8975,7 +9241,7 @@ function createSnapshot(root, gltf, bakeColors = false) {
         addMesh(mesh, world);
       }
     }
-    for (const child of object.children) visit(child, world);
+    for (const child of object2.children) visit(child, world);
   };
   try {
     const ancestors = [];
@@ -9207,11 +9473,11 @@ var GuiHelper = class {
     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)) {
+        const pattern2 = recipe.pattern;
+        if (!pattern2.length || pattern2.length > 3 || !pattern2[0].length || pattern2[0].length > 3 || pattern2.some((row) => row.length !== pattern2[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 !== " ");
+        const cells = pattern2.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));
@@ -9623,29 +9889,29 @@ var SceneInspector = class {
     this.objectControlsContainer.innerHTML = "";
     this.addControls(targetObject, targetIntersection, instance);
   }
-  addControls(object, intersection, instance) {
+  addControls(object2, intersection, instance) {
     const container = document.createElement("div");
     container.append(this.separator("Select Parent/Child"));
-    if (object.parent) {
-      container.append(this.buttonControl("Select Parent " + object.parent.constructor.name + " " + object.parent.name, "P", () => {
-        this.selectObject(object.parent, intersection, instance);
+    if (object2.parent) {
+      container.append(this.buttonControl("Select Parent " + object2.parent.constructor.name + " " + object2.parent.name, "P", () => {
+        this.selectObject(object2.parent, intersection, instance);
       }));
     }
-    if (object.children.length > 0) {
+    if (object2.children.length > 0) {
       let i = 1;
-      for (let child of object.children) {
+      for (let child of object2.children) {
         container.append(this.buttonControl("Select Child " + child.constructor.name + " " + child.name, "C" + i++, () => {
           this.selectObject(child, intersection, instance);
         }));
       }
     }
     container.append(this.separator());
-    const selectedInstance = instance && (object === instance.instanceable || object === intersection?.object) ? instance : void 0;
+    const selectedInstance = instance && (object2 === instance.instanceable || object2 === intersection?.object) ? instance : void 0;
     if (!selectedInstance) {
-      container.append(this.toggleControl("Visibility", "V", object.visible, (v) => object.visible = v));
+      container.append(this.toggleControl("Visibility", "V", object2.visible, (v) => object2.visible = v));
     }
     container.append(this.separator("Mesh"));
-    this.addObjectControls(object, intersection, container, selectedInstance);
+    this.addObjectControls(object2, intersection, container, selectedInstance);
     container.append(this.separator());
     this.objectControlsContainer.append(container);
   }
@@ -10216,8 +10482,8 @@ var BlockObject = class _BlockObject extends SceneObject {
       return false;
     }
     return this._models.some((model) => {
-      const object = isInstanceReference(model) ? model.instanceable : model;
-      return object.isOpaqueFullCube && this.getModelCullMask(model, 63) === 63;
+      const object2 = isInstanceReference(model) ? model.instanceable : model;
+      return object2.isOpaqueFullCube && this.getModelCullMask(model, 63) === 63;
     });
   }
   getModelMatrix(model) {
@@ -10226,8 +10492,8 @@ var BlockObject = class _BlockObject extends SceneObject {
     return model.matrix.clone();
   }
   getModelCullMask(model, worldMask) {
-    const object = isInstanceReference(model) ? model.instanceable : model;
-    if (object.options.displayPosition) return 0;
+    const object2 = isInstanceReference(model) ? model.instanceable : model;
+    if (object2.options.displayPosition) return 0;
     const position = new import_three32.Vector3();
     const rotation = new import_three32.Quaternion();
     const scale = new import_three32.Vector3();
@@ -10244,14 +10510,14 @@ var BlockObject = class _BlockObject extends SceneObject {
           replacements.push(model);
           continue;
         }
-        const object = isInstanceReference(model) ? model.instanceable : model;
+        const object2 = isInstanceReference(model) ? model.instanceable : model;
         const cullMask = this.getModelCullMask(model, worldMask);
-        if (cullMask === (object.options.cullMask ?? 0)) {
+        if (cullMask === (object2.options.cullMask ?? 0)) {
           replacements.push(model);
           continue;
         }
         const matrix = this.getModelMatrix(model);
-        const replacement = await this.scene.addModel(object.originalModel, { ...object.options, cullMask });
+        const replacement = await this.scene.addModel(object2.originalModel, { ...object2.options, cullMask });
         replacements.push(replacement);
         if (isInstanceReference(replacement)) {
           replacement.setMatrix(matrix);
@@ -10259,8 +10525,8 @@ var BlockObject = class _BlockObject extends SceneObject {
           replacement.matrix.copy(matrix);
           replacement.matrixWorldNeedsUpdate = true;
           matrix.decompose(replacement.position, replacement.quaternion, replacement.scale);
-          replacement.matrixAutoUpdate = object.matrixAutoUpdate;
-          replacement.visible = object.visible;
+          replacement.matrixAutoUpdate = object2.matrixAutoUpdate;
+          replacement.visible = object2.visible;
         }
       }
     } catch (error) {
@@ -12178,9 +12444,9 @@ var SchematicParser = class {
    * Parses a legacy schematic using custom mappings before the bundled defaults.
    * Keys are `id:metadata`; values are block states such as `minecraft:oak_log[axis=x]`.
    */
-  static async parse(nbt, customMappings = {}) {
+  static async parse(nbt, customMappings = {}, options = {}) {
     const tags = nbt.value;
-    if (tags.Materials?.type !== "string" || tags.Materials.value !== "Alpha") {
+    if (!options.lenient && (tags.Materials?.type !== "string" || tags.Materials.value !== "Alpha")) {
       throw new MineRenderError("Schematic Materials must be Alpha");
     }
     const size = ["Width", "Height", "Length"].map((name) => {
@@ -12221,8 +12487,16 @@ var SchematicParser = class {
       const id = high << 8 | ids.value[index] & 255;
       const metadata = data.value[index] & 255;
       const key = `${id}:${metadata}`;
-      const mapped = customMappings[key] ?? mapping[key];
-      if (!mapped) throw new MineRenderError(`Unsupported legacy block ${id}:${metadata} at schematic index ${index}`);
+      let mapped = customMappings[key] ?? mapping[key];
+      if (!mapped && options.lenient) {
+        mapped = customMappings[`${id}:0`] ?? mapping[`${id}:0`];
+      }
+      if (!mapped) {
+        if (options.lenient) {
+          continue;
+        }
+        throw new MineRenderError(`Unsupported legacy block ${id}:${metadata} at schematic index ${index}`);
+      }
       const [type, state] = mapped.split("[");
       if (type === "minecraft:air") continue;
       const properties = {};
@@ -13383,53 +13657,53 @@ var MineRenderScene = class _MineRenderScene extends import_three34.Scene {
     this.DEFAULT_OPTIONS = (0, import_ts_deepmerge8.default)({}, {});
   }
   add(...objects) {
-    for (const object of objects) {
+    for (const object2 of objects) {
       this.dirty = true;
       try {
-        super.add(object);
+        super.add(object2);
       } finally {
-        if (object?.isObject3D && object !== this) {
-          this.updateObjectRegistration(object, object.parent === this);
+        if (object2?.isObject3D && object2 !== this) {
+          this.updateObjectRegistration(object2, object2.parent === this);
         }
       }
     }
     return this;
   }
   remove(...objects) {
-    for (const object of objects) {
-      if (!this.children.includes(object)) continue;
+    for (const object2 of objects) {
+      if (!this.children.includes(object2)) continue;
       this.dirty = true;
-      this.updateObjectRegistration(object, false);
+      this.updateObjectRegistration(object2, false);
       try {
-        super.remove(object);
+        super.remove(object2);
       } finally {
-        this.updateObjectRegistration(object, object.parent === this);
+        this.updateObjectRegistration(object2, object2.parent === this);
       }
     }
     return this;
   }
-  updateObjectRegistration(object, attached) {
-    if (this.observedObjects.has(object) === attached) return;
-    const observable = object;
+  updateObjectRegistration(object2, attached) {
+    if (this.observedObjects.has(object2) === attached) return;
+    const observable = object2;
     if (attached) {
-      this.observedObjects.add(object);
+      this.observedObjects.add(object2);
       observable.addEventListener("change", this.onObjectChange);
     } else {
-      this.observedObjects.delete(object);
+      this.observedObjects.delete(object2);
       observable.removeEventListener("change", this.onObjectChange);
     }
     const change = attached ? 1 : -1;
     this.stats.objectCount += change;
-    if (isSceneObject(object)) {
+    if (isSceneObject(object2)) {
       this.stats.sceneObjectCount += change;
     }
   }
-  async initAndAdd(...object) {
+  async initAndAdd(...object2) {
     this.dirty = true;
-    for (let obj of object) {
+    for (let obj of object2) {
       await obj.init();
     }
-    return this.add(...object);
+    return this.add(...object2);
   }
   async addSceneObject(asset, objectSupplier, _options, parent = this) {
     this.dirty = true;
@@ -13508,11 +13782,11 @@ var _changeEvent = { type: "change" };
 var _startEvent = { type: "start" };
 var _endEvent = { type: "end" };
 var OrbitControls = class extends import_three35.EventDispatcher {
-  constructor(object, domElement) {
+  constructor(object2, domElement) {
     super();
     if (domElement === void 0) console.warn('THREE.OrbitControls: The second parameter "domElement" is now mandatory.');
     if (domElement === document) console.error('THREE.OrbitControls: "document" should not be used as the target "domElement". Please use "renderer.domElement" instead.');
-    this.object = object;
+    this.object = object2;
     this.domElement = domElement;
     this.domElement.style.touchAction = "none";
     this.enabled = true;
@@ -13569,7 +13843,7 @@ var OrbitControls = class extends import_three35.EventDispatcher {
     };
     this.update = function() {
       const offset = new import_three35.Vector3();
-      const quat = new import_three35.Quaternion().setFromUnitVectors(object.up, new import_three35.Vector3(0, 1, 0));
+      const quat = new import_three35.Quaternion().setFromUnitVectors(object2.up, new import_three35.Vector3(0, 1, 0));
       const quatInverse = quat.clone().invert();
       const lastPosition = new import_three35.Vector3();
       const lastQuaternion = new import_three35.Quaternion();
@@ -14134,8 +14408,8 @@ var OrbitControls = class extends import_three35.EventDispatcher {
   }
 };
 var MapControls = class extends OrbitControls {
-  constructor(object, domElement) {
-    super(object, domElement);
+  constructor(object2, domElement) {
+    super(object2, domElement);
     this.screenSpacePanning = false;
     this.mouseButtons.LEFT = import_three35.MOUSE.PAN;
     this.mouseButtons.RIGHT = import_three35.MOUSE.ROTATE;
@@ -15063,16 +15337,16 @@ var SectionModels = class {
       if (!models) this.models.set(model, models = /* @__PURE__ */ new Map());
       const key = JSON.stringify([rotation.x, rotation.y, rotation.z, variant.uvlock, tints]);
       const template = await cached(models, key, async () => {
-        const object = new SectionModel(model, {
+        const object2 = new SectionModel(model, {
           instanceMeshes: false,
           mergeMeshes: false,
           tints,
           uvLockRotation: variant.uvlock && (rotation.x !== 0 || rotation.y !== 0) ? [rotation.x, rotation.y, rotation.z] : void 0
         });
-        await object.init();
-        const geometry = object.children[0].geometry;
+        await object2.init();
+        const geometry = object2.children[0].geometry;
         geometry.applyMatrix4(new import_three38.Matrix4().makeRotationFromEuler(rotation));
-        object.clear();
+        object2.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;
@@ -15260,10 +15534,10 @@ var MineRenderWorld = class {
               await block.object.updateFluid((x, y, z) => {
                 const neighbor = pos.clone().add(new import_three39.Vector3(x, y, z));
                 const section = this.getChunkAt(neighbor);
-                const object = section?.isBlockVisibleAt(neighbor) ? section.getBlockAt(neighbor)?.object : void 0;
+                const object2 = section?.isBlockVisibleAt(neighbor) ? section.getBlockAt(neighbor)?.object : void 0;
                 return {
-                  fluid: object?.fluidKind,
-                  level: object?.fluidLevel,
+                  fluid: object2?.fluidKind,
+                  level: object2?.fluidLevel,
                   solid: section?.isOccludingAt(neighbor) ?? false
                 };
               });
@@ -15383,14 +15657,17 @@ var SectionMesh = class _SectionMesh extends import_three40.Group {
       for (const { atlas, x, y } of page.placements) {
         context.drawImage(atlas.image.canvas, x, y);
       }
-      const positions = [], normals = [], uvs = [], colors = [], indices = [];
+      const positions = [], normals = [], uvs = [], uvBounds = [], colors = [], indices = [];
       for (const { index, template, cullMask } of page.entries) {
         const position = template.geometry.getAttribute("position");
         const normal = template.geometry.getAttribute("normal");
         const uv = template.geometry.getAttribute("uv");
+        const bounds = template.geometry.getAttribute("uvBounds");
         const color = template.geometry.getAttribute("color");
         const sourceIndices = template.geometry.getIndex();
         const placement = locations.get(template.atlas).placement;
+        const mapU = (u) => (placement.x + u * template.atlas.image.width) / page.width;
+        const mapV = (v) => 1 - (placement.y + (1 - v) * template.atlas.image.height) / page.height;
         const offsetX = index % 16 * 16;
         const offsetY = Math.floor(index / 256) * 16;
         const offsetZ = Math.floor(index / 16) % 16 * 16;
@@ -15401,9 +15678,12 @@ var SectionMesh = class _SectionMesh extends import_three40.Group {
             const vertex = face * 4 + corner;
             positions.push(position.getX(vertex) + offsetX, position.getY(vertex) + offsetY, position.getZ(vertex) + offsetZ);
             normals.push(normal.getX(vertex), normal.getY(vertex), normal.getZ(vertex));
-            uvs.push(
-              (placement.x + uv.getX(vertex) * template.atlas.image.width) / page.width,
-              1 - (placement.y + (1 - uv.getY(vertex)) * template.atlas.image.height) / page.height
+            uvs.push(mapU(uv.getX(vertex)), mapV(uv.getY(vertex)));
+            uvBounds.push(
+              mapU(bounds?.getX(vertex) ?? 0),
+              mapV(bounds?.getY(vertex) ?? 0),
+              mapU(bounds?.getZ(vertex) ?? 1),
+              mapV(bounds?.getW(vertex) ?? 1)
             );
             colors.push(color?.getX(vertex) ?? 1, color?.getY(vertex) ?? 1, color?.getZ(vertex) ?? 1);
           }
@@ -15414,11 +15694,12 @@ var SectionMesh = class _SectionMesh extends import_three40.Group {
       geometry.setAttribute("position", new import_three40.Float32BufferAttribute(positions, 3));
       geometry.setAttribute("normal", new import_three40.Float32BufferAttribute(normals, 3));
       geometry.setAttribute("uv", new import_three40.Float32BufferAttribute(uvs, 2));
+      geometry.setAttribute("uvBounds", new import_three40.Float32BufferAttribute(uvBounds, 4));
       geometry.setAttribute("color", new import_three40.Float32BufferAttribute(colors, 3));
       geometry.setIndex(indices);
       geometry.computeBoundingBox();
       geometry.computeBoundingSphere();
-      const material = Materials.createShadedCanvasMaterial(canvas, false);
+      const material = Materials.createShadedCanvasMaterial(canvas, false, false, true);
       material.vertexColors = true;
       const texture = material.uniforms?.map?.value ?? material.map;
       const mesh = new import_three40.Mesh(geometry, material);
@@ -15492,7 +15773,7 @@ var Chunk = class _Chunk {
     this.renderedBlocks.get(index)?.object?.removeFromScene();
     if (this.sectionBlocks.delete(index)) this.meshDirty = true;
     this.renderedBlocks.delete(index);
-    let object;
+    let object2;
     try {
       if (!readBlock) return void 0;
       const stored = readBlock();
@@ -15507,22 +15788,22 @@ var Chunk = class _Chunk {
         this.sectionBlocks.set(index, { index, template, cullMask: 0 });
         this.meshDirty = true;
       } else {
-        object = await this.scene.addBlock(blockState, {
+        object2 = await this.scene.addBlock(blockState, {
           mergeMeshes: true,
           instanceMeshes: true,
           maxInstanceCount: 2e3,
           initialState: stored.properties
         });
-        object.setPosition(MineRenderWorld.worldToScenePosition(worldPos));
+        object2.setPosition(MineRenderWorld.worldToScenePosition(worldPos));
       }
       const info = { get block() {
         return readBlock();
-      }, object };
+      }, object: object2 };
       this.renderedBlocks.set(index, info);
       return info;
     } catch (error) {
       this.data.set(index, void 0);
-      object?.removeFromScene();
+      object2?.removeFromScene();
       throw error;
     } finally {
       await onBlocksChanged?.([worldPos]);
@@ -15696,6 +15977,8 @@ var Chunk = class _Chunk {
   NodeCache,
   NodeEnv,
   OrbitControls,
+  PackFormats,
+  PackMetadata,
   PersistentCache,
   Renderer,
   RequestError,