minerender 2.1.0-alpha.91 → 2.1.0-alpha.93

package/dist/bundle.js

@@ -106662,6 +106662,7 @@ ${shader.fragmentShader}`.replace(
     prefix: () => prefix,
     probeImageSize: () => probeImageSize,
     registerBrowserEnv: () => registerBrowserEnv,
+    resolveLegacyBlock: () => resolveLegacyBlock,
     sampleEntityAnimation: () => sampleEntityAnimation,
     sampleEntityKeyframes: () => sampleEntityKeyframes,
     sampleFluid: () => sampleFluid,
@@ -111945,168 +111946,10 @@ property list uchar int vertex_index
   init_buffer2();
   init_process2();
 
-  // src/model/multiblock/LitematicaParser.ts
+  // src/model/multiblock/LegacyBlocks.ts
   init_dirname();
   init_buffer2();
   init_process2();
-  init_MineRenderError();
-  var LitematicaParser = class {
-    /**
-     * Parses decoded NBT, preserving subregion placement and omitting air.
-     * Later entries in regions replace earlier cells, including with air.
-     * Size encloses all region bounds; positions retain the schematic origin.
-     * Metadata and scheduled ticks are not imported. Named regions can be placed individually.
-     */
-    static async parse(nbt) {
-      const tags = nbt.value;
-      const version3 = integer2(tags.Version, "Version");
-      if (version3 < 5 || version3 > 7) throw new MineRenderError(`Unsupported Litematica version ${version3}; expected 5, 6, or 7`);
-      const dataVersion = tags.MinecraftDataVersion === void 0 ? void 0 : integer2(tags.MinecraftDataVersion, "MinecraftDataVersion");
-      const blocks = /* @__PURE__ */ new Map();
-      const regions = [];
-      const min = [Infinity, Infinity, Infinity];
-      const max2 = [-Infinity, -Infinity, -Infinity];
-      for (const [name2, tag] of Object.entries(compound(tags.Regions, "Regions"))) {
-        const region = readRegion(compound(tag, `region ${name2}`), name2, dataVersion, blocks);
-        regions.push(region);
-        for (let axis = 0; axis < 3; axis++) {
-          const start = minimum(region.position[axis], region.signedSize[axis]);
-          min[axis] = Math.min(min[axis], start);
-          max2[axis] = Math.max(max2[axis], start + region.size[axis]);
-        }
-      }
-      return {
-        size: regions.length ? min.map((value, axis) => max2[axis] - value) : [0, 0, 0],
-        blocks: [...blocks.values()],
-        entities: regions.flatMap((region) => region.entities ?? []),
-        dataVersion,
-        regions
-      };
-    }
-  };
-  function readRegion(tags, name2, dataVersion, combined) {
-    const position = blockPosition(compound(tags.Position, `region ${name2} Position`));
-    const signedSize = blockPosition(compound(tags.Size, `region ${name2} Size`));
-    if (signedSize.some((value) => value === 0)) throw new MineRenderError(`Litematica region ${name2} dimensions must be nonzero`);
-    const size = signedSize.map(Math.abs);
-    const min = position.map((value, axis) => minimum(value, signedSize[axis]));
-    const [width, height, length] = size;
-    const volume = width * height * length;
-    const palette = compounds(tags.BlockStatePalette, "BlockStatePalette").map(blockState);
-    if (!palette.length) throw new MineRenderError(`Litematica region ${name2} has no block palette`);
-    const bits2 = Math.max(2, Math.ceil(Math.log2(palette.length)));
-    if (!Number.isSafeInteger(volume * bits2)) throw new MineRenderError(`Litematica region ${name2} volume is too large`);
-    const packed = tags.BlockStates;
-    const expected = Math.ceil(volume * bits2 / 64);
-    if (packed?.type !== "longArray" || !Array.isArray(packed.value) || packed.value.length !== expected) {
-      throw new MineRenderError(`Litematica region ${name2} BlockStates must contain ${expected} longs`);
-    }
-    const words = packed.value.map((pair) => {
-      if (!Array.isArray(pair) || pair.length !== 2 || !pair.every((value) => Number.isInteger(value) && value >= -2147483648 && value <= 4294967295)) {
-        throw new MineRenderError(`Litematica region ${name2} has an invalid BlockStates long`);
-      }
-      return [pair[0] >>> 0, pair[1] >>> 0];
-    });
-    const blockEntities = /* @__PURE__ */ new Map();
-    for (const tile of compounds(tags.TileEntities, "TileEntities")) {
-      const pos = blockPosition(tile);
-      if (pos.some((value2, axis) => value2 < 0 || value2 >= size[axis])) {
-        throw new MineRenderError(`Litematica region ${name2} block entity is outside its dimensions`);
-      }
-      const index = pos[0] + pos[2] * width + pos[1] * width * length;
-      if (blockEntities.has(index)) throw new MineRenderError(`Duplicate Litematica block entity at index ${index}`);
-      const value = { ...tile };
-      for (const [axis, key] of ["x", "y", "z"].entries()) value[key] = { type: "int", value: pos[axis] + min[axis] };
-      blockEntities.set(index, { type: "compound", value });
-    }
-    const blocks = [];
-    const mask = 2 ** bits2 - 1;
-    for (let index = 0; index < volume; index++) {
-      const word = Math.floor(index * bits2 / 64);
-      const shift = index * bits2 % 64;
-      const [high, low] = words[word];
-      let value = shift < 32 ? low >>> shift : high >>> shift - 32;
-      if (shift < 32 && shift + bits2 > 32) value |= high << 32 - shift;
-      if (shift + bits2 > 64) value |= words[word + 1][1] << 64 - shift;
-      const id = (value & mask) >>> 0;
-      const state = palette[id];
-      if (!state) throw new MineRenderError(`Litematica region ${name2} palette index ${id} does not exist`);
-      const pos = [
-        index % width + min[0],
-        Math.floor(index / (width * length)) + min[1],
-        Math.floor(index / width) % length + min[2]
-      ];
-      const key = pos.join(",");
-      if (["minecraft:air", "minecraft:cave_air", "minecraft:void_air"].includes(state.type)) {
-        combined.delete(key);
-        continue;
-      }
-      const block = { type: state.type, properties: { ...state.properties }, position: pos, nbt: blockEntities.get(index) };
-      blocks.push(block);
-      combined.set(key, block);
-    }
-    const entities = compounds(tags.Entities, "Entities").map((entity) => {
-      const pos = entity.Pos;
-      if (pos?.type !== "list" || pos.value.type !== "double" || pos.value.value.length !== 3 || !pos.value.value.every(Number.isFinite)) {
-        throw new MineRenderError(`Litematica region ${name2} entity Pos must contain three doubles`);
-      }
-      const absolute = pos.value.value.map((value2, axis) => value2 + position[axis]);
-      const value = { ...entity, Pos: { type: "list", value: { type: "double", value: [...absolute] } } };
-      return { position: absolute, nbt: { type: "compound", value } };
-    });
-    return { name: name2, position, signedSize, size, blocks, entities, dataVersion };
-  }
-  function minimum(position, size) {
-    return position + Math.min(0, size + 1);
-  }
-  function integer2(tag, name2) {
-    if (tag?.type !== "int" || !Number.isInteger(tag.value) || tag.value < -2147483648 || tag.value > 2147483647) {
-      throw new MineRenderError(`Litematica ${name2} must be an int`);
-    }
-    return tag.value;
-  }
-  function compound(tag, name2) {
-    if (tag?.type !== "compound" || !tag.value || typeof tag.value !== "object" || Array.isArray(tag.value)) {
-      throw new MineRenderError(`Litematica ${name2} must be a compound`);
-    }
-    return tag.value;
-  }
-  function blockPosition(tags) {
-    return ["x", "y", "z"].map((axis) => integer2(tags[axis], axis));
-  }
-  function compounds(tag, name2) {
-    if (tag === void 0) return [];
-    if (tag.type === "list" && Array.isArray(tag.value.value)) {
-      if (tag.value.value.length === 0) return [];
-      if (tag.value.type === "compound") return tag.value.value;
-    }
-    throw new MineRenderError(`Litematica ${name2} must be a compound list`);
-  }
-  function blockState(tags) {
-    const name2 = tags.Name;
-    if (name2?.type !== "string" || !/^(?:[a-z0-9_.-]+:)?[a-z0-9_./-]+$/.test(name2.value)) {
-      throw new MineRenderError("Litematica palette entry must have a block Name");
-    }
-    const properties = {};
-    if (tags.Properties !== void 0) {
-      for (const [key, tag] of Object.entries(compound(tags.Properties, "block Properties"))) {
-        if (tag?.type !== "string") throw new MineRenderError("Litematica block properties must be strings");
-        Object.defineProperty(properties, key, { value: tag.value, enumerable: true, writable: true, configurable: true });
-      }
-    }
-    return { type: name2.value.includes(":") ? name2.value : `minecraft:${name2.value}`, properties };
-  }
-
-  // src/model/multiblock/MultiBlockStructure.ts
-  init_dirname();
-  init_buffer2();
-  init_process2();
-
-  // src/model/multiblock/SchematicParser.ts
-  init_dirname();
-  init_buffer2();
-  init_process2();
-  init_MineRenderError();
 
   // src/model/multiblock/legacyBlocks.json
   var legacyBlocks_default = {
@@ -112951,12 +112794,20 @@ property list uchar int vertex_index
       "131:15": "minecraft:tripwire_hook[powered=true,attached=true,facing=east]",
       "132:0": "minecraft:tripwire[disarmed=false,east=false,powered=false,south=false,north=false,west=false,attached=false]",
       "132:1": "minecraft:tripwire[disarmed=false,east=false,powered=true,south=false,north=false,west=false,attached=false]",
+      "132:2": "minecraft:tripwire[disarmed=false,east=false,powered=false,south=false,north=false,west=false,attached=false]",
+      "132:3": "minecraft:tripwire[disarmed=false,east=false,powered=true,south=false,north=false,west=false,attached=false]",
       "132:4": "minecraft:tripwire[disarmed=false,east=false,powered=false,south=false,north=false,west=false,attached=true]",
       "132:5": "minecraft:tripwire[disarmed=false,east=false,powered=true,south=false,north=false,west=false,attached=true]",
+      "132:6": "minecraft:tripwire[disarmed=false,east=false,powered=false,south=false,north=false,west=false,attached=true]",
+      "132:7": "minecraft:tripwire[disarmed=false,east=false,powered=true,south=false,north=false,west=false,attached=true]",
       "132:8": "minecraft:tripwire[disarmed=true,east=false,powered=false,south=false,north=false,west=false,attached=false]",
       "132:9": "minecraft:tripwire[disarmed=true,east=false,powered=true,south=false,north=false,west=false,attached=false]",
+      "132:10": "minecraft:tripwire[disarmed=true,east=false,powered=false,south=false,north=false,west=false,attached=false]",
+      "132:11": "minecraft:tripwire[disarmed=true,east=false,powered=true,south=false,north=false,west=false,attached=false]",
       "132:12": "minecraft:tripwire[disarmed=true,east=false,powered=false,south=false,north=false,west=false,attached=true]",
       "132:13": "minecraft:tripwire[disarmed=true,east=false,powered=true,south=false,north=false,west=false,attached=true]",
+      "132:14": "minecraft:tripwire[disarmed=true,east=false,powered=false,south=false,north=false,west=false,attached=true]",
+      "132:15": "minecraft:tripwire[disarmed=true,east=false,powered=true,south=false,north=false,west=false,attached=true]",
       "133:0": "minecraft:emerald_block",
       "134:0": "minecraft:spruce_stairs[half=bottom,shape=outer_right,facing=east]",
       "134:1": "minecraft:spruce_stairs[half=bottom,shape=outer_right,facing=west]",
@@ -113797,7 +113648,186 @@ property list uchar int vertex_index
     }
   };
 
+  // src/model/multiblock/LegacyBlocks.ts
+  function resolveLegacyBlock(id, metadata, customMappings = {}, lenient = false) {
+    const mapping = legacyBlocks_default.blocks;
+    const key = `${id}:${metadata}`;
+    let mapped = customMappings[key] ?? mapping[key];
+    if (!mapped && lenient) mapped = customMappings[`${id}:0`] ?? mapping[`${id}:0`];
+    if (!mapped) return void 0;
+    const [type, state] = mapped.split("[");
+    const properties = {};
+    if (state) {
+      for (const property of state.slice(0, -1).split(",")) {
+        const [key2, value] = property.split("=");
+        properties[key2] = value;
+      }
+    }
+    return { type, properties };
+  }
+
+  // src/model/multiblock/LitematicaParser.ts
+  init_dirname();
+  init_buffer2();
+  init_process2();
+  init_MineRenderError();
+  var LitematicaParser = class {
+    /**
+     * Parses decoded NBT, preserving subregion placement and omitting air.
+     * Later entries in regions replace earlier cells, including with air.
+     * Size encloses all region bounds; positions retain the schematic origin.
+     * Metadata and scheduled ticks are not imported. Named regions can be placed individually.
+     */
+    static async parse(nbt) {
+      const tags = nbt.value;
+      const version3 = integer2(tags.Version, "Version");
+      if (version3 < 5 || version3 > 7) throw new MineRenderError(`Unsupported Litematica version ${version3}; expected 5, 6, or 7`);
+      const dataVersion = tags.MinecraftDataVersion === void 0 ? void 0 : integer2(tags.MinecraftDataVersion, "MinecraftDataVersion");
+      const blocks = /* @__PURE__ */ new Map();
+      const regions = [];
+      const min = [Infinity, Infinity, Infinity];
+      const max2 = [-Infinity, -Infinity, -Infinity];
+      for (const [name2, tag] of Object.entries(compound(tags.Regions, "Regions"))) {
+        const region = readRegion(compound(tag, `region ${name2}`), name2, dataVersion, blocks);
+        regions.push(region);
+        for (let axis = 0; axis < 3; axis++) {
+          const start = minimum(region.position[axis], region.signedSize[axis]);
+          min[axis] = Math.min(min[axis], start);
+          max2[axis] = Math.max(max2[axis], start + region.size[axis]);
+        }
+      }
+      return {
+        size: regions.length ? min.map((value, axis) => max2[axis] - value) : [0, 0, 0],
+        blocks: [...blocks.values()],
+        entities: regions.flatMap((region) => region.entities ?? []),
+        dataVersion,
+        regions
+      };
+    }
+  };
+  function readRegion(tags, name2, dataVersion, combined) {
+    const position = blockPosition(compound(tags.Position, `region ${name2} Position`));
+    const signedSize = blockPosition(compound(tags.Size, `region ${name2} Size`));
+    if (signedSize.some((value) => value === 0)) throw new MineRenderError(`Litematica region ${name2} dimensions must be nonzero`);
+    const size = signedSize.map(Math.abs);
+    const min = position.map((value, axis) => minimum(value, signedSize[axis]));
+    const [width, height, length] = size;
+    const volume = width * height * length;
+    const palette = compounds(tags.BlockStatePalette, "BlockStatePalette").map(blockState);
+    if (!palette.length) throw new MineRenderError(`Litematica region ${name2} has no block palette`);
+    const bits2 = Math.max(2, Math.ceil(Math.log2(palette.length)));
+    if (!Number.isSafeInteger(volume * bits2)) throw new MineRenderError(`Litematica region ${name2} volume is too large`);
+    const packed = tags.BlockStates;
+    const expected = Math.ceil(volume * bits2 / 64);
+    if (packed?.type !== "longArray" || !Array.isArray(packed.value) || packed.value.length !== expected) {
+      throw new MineRenderError(`Litematica region ${name2} BlockStates must contain ${expected} longs`);
+    }
+    const words = packed.value.map((pair) => {
+      if (!Array.isArray(pair) || pair.length !== 2 || !pair.every((value) => Number.isInteger(value) && value >= -2147483648 && value <= 4294967295)) {
+        throw new MineRenderError(`Litematica region ${name2} has an invalid BlockStates long`);
+      }
+      return [pair[0] >>> 0, pair[1] >>> 0];
+    });
+    const blockEntities = /* @__PURE__ */ new Map();
+    for (const tile of compounds(tags.TileEntities, "TileEntities")) {
+      const pos = blockPosition(tile);
+      if (pos.some((value2, axis) => value2 < 0 || value2 >= size[axis])) {
+        throw new MineRenderError(`Litematica region ${name2} block entity is outside its dimensions`);
+      }
+      const index = pos[0] + pos[2] * width + pos[1] * width * length;
+      if (blockEntities.has(index)) throw new MineRenderError(`Duplicate Litematica block entity at index ${index}`);
+      const value = { ...tile };
+      for (const [axis, key] of ["x", "y", "z"].entries()) value[key] = { type: "int", value: pos[axis] + min[axis] };
+      blockEntities.set(index, { type: "compound", value });
+    }
+    const blocks = [];
+    const mask = 2 ** bits2 - 1;
+    for (let index = 0; index < volume; index++) {
+      const word = Math.floor(index * bits2 / 64);
+      const shift = index * bits2 % 64;
+      const [high, low] = words[word];
+      let value = shift < 32 ? low >>> shift : high >>> shift - 32;
+      if (shift < 32 && shift + bits2 > 32) value |= high << 32 - shift;
+      if (shift + bits2 > 64) value |= words[word + 1][1] << 64 - shift;
+      const id = (value & mask) >>> 0;
+      const state = palette[id];
+      if (!state) throw new MineRenderError(`Litematica region ${name2} palette index ${id} does not exist`);
+      const pos = [
+        index % width + min[0],
+        Math.floor(index / (width * length)) + min[1],
+        Math.floor(index / width) % length + min[2]
+      ];
+      const key = pos.join(",");
+      if (["minecraft:air", "minecraft:cave_air", "minecraft:void_air"].includes(state.type)) {
+        combined.delete(key);
+        continue;
+      }
+      const block = { type: state.type, properties: { ...state.properties }, position: pos, nbt: blockEntities.get(index) };
+      blocks.push(block);
+      combined.set(key, block);
+    }
+    const entities = compounds(tags.Entities, "Entities").map((entity) => {
+      const pos = entity.Pos;
+      if (pos?.type !== "list" || pos.value.type !== "double" || pos.value.value.length !== 3 || !pos.value.value.every(Number.isFinite)) {
+        throw new MineRenderError(`Litematica region ${name2} entity Pos must contain three doubles`);
+      }
+      const absolute = pos.value.value.map((value2, axis) => value2 + position[axis]);
+      const value = { ...entity, Pos: { type: "list", value: { type: "double", value: [...absolute] } } };
+      return { position: absolute, nbt: { type: "compound", value } };
+    });
+    return { name: name2, position, signedSize, size, blocks, entities, dataVersion };
+  }
+  function minimum(position, size) {
+    return position + Math.min(0, size + 1);
+  }
+  function integer2(tag, name2) {
+    if (tag?.type !== "int" || !Number.isInteger(tag.value) || tag.value < -2147483648 || tag.value > 2147483647) {
+      throw new MineRenderError(`Litematica ${name2} must be an int`);
+    }
+    return tag.value;
+  }
+  function compound(tag, name2) {
+    if (tag?.type !== "compound" || !tag.value || typeof tag.value !== "object" || Array.isArray(tag.value)) {
+      throw new MineRenderError(`Litematica ${name2} must be a compound`);
+    }
+    return tag.value;
+  }
+  function blockPosition(tags) {
+    return ["x", "y", "z"].map((axis) => integer2(tags[axis], axis));
+  }
+  function compounds(tag, name2) {
+    if (tag === void 0) return [];
+    if (tag.type === "list" && Array.isArray(tag.value.value)) {
+      if (tag.value.value.length === 0) return [];
+      if (tag.value.type === "compound") return tag.value.value;
+    }
+    throw new MineRenderError(`Litematica ${name2} must be a compound list`);
+  }
+  function blockState(tags) {
+    const name2 = tags.Name;
+    if (name2?.type !== "string" || !/^(?:[a-z0-9_.-]+:)?[a-z0-9_./-]+$/.test(name2.value)) {
+      throw new MineRenderError("Litematica palette entry must have a block Name");
+    }
+    const properties = {};
+    if (tags.Properties !== void 0) {
+      for (const [key, tag] of Object.entries(compound(tags.Properties, "block Properties"))) {
+        if (tag?.type !== "string") throw new MineRenderError("Litematica block properties must be strings");
+        Object.defineProperty(properties, key, { value: tag.value, enumerable: true, writable: true, configurable: true });
+      }
+    }
+    return { type: name2.value.includes(":") ? name2.value : `minecraft:${name2.value}`, properties };
+  }
+
+  // src/model/multiblock/MultiBlockStructure.ts
+  init_dirname();
+  init_buffer2();
+  init_process2();
+
   // src/model/multiblock/SchematicParser.ts
+  init_dirname();
+  init_buffer2();
+  init_process2();
+  init_MineRenderError();
   var SchematicParser = class {
     /**
      * Parses a legacy schematic using custom mappings before the bundled defaults.
@@ -113839,35 +113869,21 @@ property list uchar int vertex_index
         tileEntities.set((y5 * length + z4) * width + x4, { type: "compound", value: tile });
       }
       const blocks = [];
-      const mapping = legacyBlocks_default.blocks;
       for (let index = 0; index < volume; index++) {
         const packed = addBlocks?.value[index >> 1] ?? 0;
         const high = packed >> (index & 1) * 4 & 15;
         const id = high << 8 | ids.value[index] & 255;
         const metadata = data.value[index] & 255;
-        const key = `${id}:${metadata}`;
-        let mapped = customMappings[key] ?? mapping[key];
-        if (!mapped && options.lenient) {
-          mapped = customMappings[`${id}:0`] ?? mapping[`${id}:0`];
-        }
-        if (!mapped) {
+        const block = resolveLegacyBlock(id, metadata, customMappings, options.lenient);
+        if (!block) {
           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 = {};
-        if (state) {
-          for (const property of state.slice(0, -1).split(",")) {
-            const [key2, value] = property.split("=");
-            properties[key2] = value;
-          }
-        }
+        if (block.type === "minecraft:air") continue;
         blocks.push({
-          type,
-          properties,
+          ...block,
           position: [index % width, Math.floor(index / (width * length)), Math.floor(index / width) % length],
           nbt: tileEntities.get(index)
         });
@@ -119319,10 +119335,13 @@ gl_FragDepth=readDepth(vUv);
       return this.locations(this.bytes(data)).map(({ x: x4, z: z4 }) => ({ x: x4, z: z4 }));
     }
     /** Decodes all stored chunks. Gzip, zlib, LZ4, and uncompressed payloads are supported. */
-    static async parse(data) {
+    static async parse(data, options = {}) {
+      options.signal?.throwIfAborted();
       const bytes = this.bytes(data);
       const chunks = [];
-      for (const location of this.locations(bytes)) chunks.push(await this.readChunk(bytes, location));
+      for (const location of this.locations(bytes)) {
+        chunks.push(await this.abortable(this.readChunk(bytes, location, options), options.signal));
+      }
       return { chunks };
     }
     /**
@@ -119331,13 +119350,28 @@ gl_FragDepth=readDepth(vUv);
      * @param localZ - Chunk z within the region, from 0 to 31.
      * @returns The chunk with absolute coordinates, or `undefined` if the region has no chunk there.
      */
-    static async parseChunk(data, localX, localZ) {
+    static async parseChunk(data, localX, localZ, options = {}) {
+      options.signal?.throwIfAborted();
       if (![localX, localZ].every((value) => Number.isInteger(value) && value >= 0 && value < 32)) {
         throw new RangeError("Region-local chunk coordinates must be integers from 0 to 31");
       }
       const bytes = this.bytes(data);
       const location = this.locations(bytes).find(({ x: x4, z: z4 }) => x4 === localX && z4 === localZ);
-      return location ? this.readChunk(bytes, location) : void 0;
+      return location ? this.abortable(this.readChunk(bytes, location, options), options.signal) : void 0;
+    }
+    static async abortable(promise, signal) {
+      if (!signal) return promise;
+      let abort2;
+      const cancelled = new Promise((_4, reject) => {
+        abort2 = () => reject(signal.reason);
+        signal.addEventListener("abort", abort2, { once: true });
+        if (signal.aborted) abort2();
+      });
+      try {
+        return await Promise.race([promise, cancelled]);
+      } finally {
+        signal.removeEventListener("abort", abort2);
+      }
     }
     static bytes(data) {
       return data instanceof Uint8Array ? data : new Uint8Array(data);
@@ -119363,20 +119397,41 @@ gl_FragDepth=readDepth(vUv);
       }
       return locations;
     }
-    static async readChunk(data, location) {
-      const compression = data[location.offset + 4];
-      if (compression & 128) throw new MineRenderError("External Anvil .mcc chunks are not supported");
+    static async readChunk(data, location, options) {
+      options.signal?.throwIfAborted();
+      const format3 = data[location.offset + 4];
+      const external = (format3 & 128) !== 0;
+      const compression = format3 & 127;
       if (compression !== 1 && compression !== 2 && compression !== 3 && compression !== 4) {
         throw new MineRenderError(`Unsupported Anvil compression ${compression}`);
       }
       let payload = data.subarray(location.offset + 5, location.offset + 4 + location.length);
+      let expected;
+      if (external) {
+        if (!options.region || !options.readExternalChunk) {
+          throw new MineRenderError("External Anvil .mcc chunks require region coordinates and readExternalChunk");
+        }
+        if (![options.region.x, options.region.z].every(Number.isSafeInteger)) {
+          throw new RangeError("Anvil region coordinates must be safe integers");
+        }
+        expected = { x: options.region.x * 32 + location.x, z: options.region.z * 32 + location.z };
+        if (![expected.x, expected.z].every(Number.isSafeInteger)) {
+          throw new RangeError("External Anvil chunk coordinates must be safe integers");
+        }
+        const externalData = await options.readExternalChunk(expected.x, expected.z, options.signal);
+        options.signal?.throwIfAborted();
+        if (externalData === void 0) throw new MineRenderError(`External Anvil chunk c.${expected.x}.${expected.z}.mcc is missing`);
+        payload = this.bytes(externalData);
+      }
       if (compression === 4) {
         payload = decodeAnvilLz4(payload);
       } else if (compression !== 3) {
         const stream = new Blob([payload]).stream().pipeThrough(new DecompressionStream(compression === 1 ? "gzip" : "deflate"));
         payload = new Uint8Array(await new Response(stream).arrayBuffer());
       }
+      options.signal?.throwIfAborted();
       const nbt = await NBTHelper.fromBuffer(payload, "big");
+      options.signal?.throwIfAborted();
       const root = nbt.value;
       const level = root.Level?.type === "compound" ? root.Level.value : root;
       const dataVersion = root.DataVersion?.type === "int" ? root.DataVersion.value : void 0;
@@ -119389,28 +119444,37 @@ gl_FragDepth=readDepth(vUv);
       if ((chunk.x % 32 + 32) % 32 !== location.x || (chunk.z % 32 + 32) % 32 !== location.z) {
         throw new MineRenderError("Anvil chunk coordinates do not match its region location");
       }
+      if (expected && (chunk.x !== expected.x || chunk.z !== expected.z)) {
+        throw new MineRenderError(`Anvil chunk coordinates do not match external file c.${expected.x}.${expected.z}.mcc`);
+      }
+      const numericStates = /* @__PURE__ */ new Map();
       for (const section of this.compounds(level.sections ?? level.Sections, "sections")) {
         const y5 = this.integer(section.Y, "section Y");
+        let data2;
         if (section.Blocks || section.Data || section.Add) {
-          throw new MineRenderError("Numeric Anvil block IDs before Minecraft 1.13 are not supported");
-        }
-        if (section.block_states && section.block_states.type !== "compound") {
-          throw new MineRenderError("Anvil block_states must be a compound");
-        }
-        const modern = section.block_states?.type === "compound" ? section.block_states.value : void 0;
-        const paletteTag = modern ? modern.palette : section.Palette;
-        const palette = paletteTag?.type === "list" && paletteTag.value.type === "string" ? paletteTag.value.value : this.compounds(paletteTag, "block palette");
-        const data2 = new ChunkData();
-        if (palette.length) {
-          const states = palette.map((entry) => this.block(entry));
-          const indices = this.unpack(modern ? modern.data : section.BlockStates, states.length, !!modern, dataVersion);
-          for (let index = 0; index < 4096; index++) {
-            const state = states[indices[index]];
-            if (!state) throw new MineRenderError(`Anvil palette index ${indices[index]} is out of range`);
-            if (!ChunkData.isAir(state)) data2.set(index, state);
+          if (section.Palette || section.BlockStates || section.block_states) {
+            throw new MineRenderError(`Anvil section ${y5} mixes numeric and paletted block states`);
+          }
+          data2 = this.numericSection(section, y5, options, numericStates);
+        } else {
+          if (section.block_states && section.block_states.type !== "compound") {
+            throw new MineRenderError("Anvil block_states must be a compound");
+          }
+          const modern = section.block_states?.type === "compound" ? section.block_states.value : void 0;
+          const paletteTag = modern ? modern.palette : section.Palette;
+          const palette = paletteTag?.type === "list" && paletteTag.value.type === "string" ? paletteTag.value.value : this.compounds(paletteTag, "block palette");
+          data2 = new ChunkData();
+          if (palette.length) {
+            const states = palette.map((entry) => this.block(entry));
+            const indices = this.unpack(modern ? modern.data : section.BlockStates, states.length, !!modern, dataVersion);
+            for (let index = 0; index < 4096; index++) {
+              const state = states[indices[index]];
+              if (!state) throw new MineRenderError(`Anvil palette index ${indices[index]} is out of range`);
+              if (!ChunkData.isAir(state)) data2.set(index, state);
+            }
+          } else if (modern || section.Palette || section.BlockStates) {
+            throw new MineRenderError("Anvil section has block states without a palette");
           }
-        } else if (modern || section.Palette || section.BlockStates) {
-          throw new MineRenderError("Anvil section has block states without a palette");
         }
         if (chunk.sections.some((section2) => section2.y === y5)) throw new MineRenderError(`Duplicate Anvil section Y ${y5}`);
         chunk.sections.push({ y: y5, data: data2 });
@@ -119438,6 +119502,33 @@ gl_FragDepth=readDepth(vUv);
       }
       return chunk;
     }
+    static numericSection(section, y5, options, states) {
+      const bytes = (name2, length, optional = false) => {
+        const tag = section[name2];
+        if (!tag && optional) return void 0;
+        if (tag?.type !== "byteArray" || !Array.isArray(tag.value) || tag.value.length !== length) {
+          throw new MineRenderError(`Anvil section ${y5} ${name2} must contain ${length} bytes`);
+        }
+        return tag.value;
+      };
+      const ids = bytes("Blocks", 4096);
+      const metadata = bytes("Data", 2048, true);
+      const extra = bytes("Add", 2048, true);
+      const data = new ChunkData();
+      for (let index = 0; index < 4096; index++) {
+        const shift = (index & 1) * 4;
+        const id = ids[index] & 255 | ((extra?.[index >> 1] ?? 0) >> shift & 15) << 8;
+        const value = (metadata?.[index >> 1] ?? 0) >> shift & 15;
+        const key = id * 16 + value;
+        if (!states.has(key)) states.set(key, resolveLegacyBlock(id, value, options.legacyMappings, options.lenient));
+        const block = states.get(key);
+        if (!block && !options.lenient) {
+          throw new MineRenderError(`Unsupported legacy block ${id}:${value} at Anvil section ${y5} index ${index}`);
+        }
+        if (block && !ChunkData.isAir(block)) data.set(index, block);
+      }
+      return data;
+    }
     static compounds(tag, name2) {
       if (!tag) return [];
       if (tag.type !== "list" || tag.value.type !== "compound" && tag.value.value.length !== 0) {
@@ -119523,6 +119614,7 @@ gl_FragDepth=readDepth(vUv);
       this.cachedBytes = 0;
       this.maxCachedRegions = options.maxCachedRegions ?? 4;
       this.maxCachedBytes = options.maxCachedBytes ?? 64 * 1024 * 1024;
+      this.parseOptions = { readExternalChunk: options.readExternalChunk, legacyMappings: options.legacyMappings, lenient: options.lenient };
       for (const [name2, value] of Object.entries({ maxCachedRegions: this.maxCachedRegions, maxCachedBytes: this.maxCachedBytes })) {
         if (!Number.isSafeInteger(value) || value < 0) throw new RangeError(`${name2} must be a nonnegative safe integer`);
       }
@@ -119536,7 +119628,11 @@ gl_FragDepth=readDepth(vUv);
       const data = await this.getRegion(regionX, regionZ, signal);
       signal?.throwIfAborted();
       if (!data) return void 0;
-      const chunk = await abortable2(AnvilParser.parseChunk(data, x4 - regionX * 32, z4 - regionZ * 32), signal);
+      const chunk = await AnvilParser.parseChunk(data, x4 - regionX * 32, z4 - regionZ * 32, {
+        ...this.parseOptions,
+        region: { x: regionX, z: regionZ },
+        signal
+      });
       signal?.throwIfAborted();
       if (chunk && (chunk.x !== x4 || chunk.z !== z4)) {
         throw new MineRenderError(`Anvil chunk coordinates ${chunk.x},${chunk.z} do not match requested column ${x4},${z4}`);
@@ -119567,7 +119663,7 @@ gl_FragDepth=readDepth(vUv);
           settled: false,
           promise: Promise.resolve().then(() => {
             controller.signal.throwIfAborted();
-            return this.readRegion(x4, z4, controller.signal);
+            return abortable2(this.readRegion(x4, z4, controller.signal), controller.signal);
           }).then((data) => {
             controller.signal.throwIfAborted();
             let bytes = data instanceof Uint8Array ? data : data === void 0 ? void 0 : new Uint8Array(data);