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

package/dist/browser/index.js

@@ -18872,6 +18872,7 @@ __export(index_browser_exports, {
   prefix: () => prefix,
   probeImageSize: () => probeImageSize,
   registerBrowserEnv: () => registerBrowserEnv,
+  resolveLegacyBlock: () => resolveLegacyBlock,
   sampleEntityAnimation: () => sampleEntityAnimation,
   sampleEntityKeyframes: () => sampleEntityKeyframes,
   sampleFluid: () => sampleFluid,
@@ -23900,158 +23901,6 @@ function isBlockObject(obj) {
 init_FluidGeometry();
 init_FluidModelObject();
 
-// src/model/multiblock/LitematicaParser.ts
-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 version2 = integer2(tags.Version, "Version");
-    if (version2 < 5 || version2 > 7) throw new MineRenderError(`Unsupported Litematica version ${version2}; 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 max = [-Infinity, -Infinity, -Infinity];
-    for (const [name, tag] of Object.entries(compound(tags.Regions, "Regions"))) {
-      const region = readRegion(compound(tag, `region ${name}`), name, 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);
-        max[axis] = Math.max(max[axis], start + region.size[axis]);
-      }
-    }
-    return {
-      size: regions.length ? min.map((value, axis) => max[axis] - value) : [0, 0, 0],
-      blocks: [...blocks.values()],
-      entities: regions.flatMap((region) => region.entities ?? []),
-      dataVersion,
-      regions
-    };
-  }
-};
-function readRegion(tags, name, dataVersion, combined) {
-  const position = blockPosition(compound(tags.Position, `region ${name} Position`));
-  const signedSize = blockPosition(compound(tags.Size, `region ${name} Size`));
-  if (signedSize.some((value) => value === 0)) throw new MineRenderError(`Litematica region ${name} 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 ${name} has no block palette`);
-  const bits = Math.max(2, Math.ceil(Math.log2(palette.length)));
-  if (!Number.isSafeInteger(volume * bits)) throw new MineRenderError(`Litematica region ${name} volume is too large`);
-  const packed = tags.BlockStates;
-  const expected = Math.ceil(volume * bits / 64);
-  if (packed?.type !== "longArray" || !Array.isArray(packed.value) || packed.value.length !== expected) {
-    throw new MineRenderError(`Litematica region ${name} 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 ${name} 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 ${name} 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 ** bits - 1;
-  for (let index = 0; index < volume; index++) {
-    const word = Math.floor(index * bits / 64);
-    const shift = index * bits % 64;
-    const [high, low] = words[word];
-    let value = shift < 32 ? low >>> shift : high >>> shift - 32;
-    if (shift < 32 && shift + bits > 32) value |= high << 32 - shift;
-    if (shift + bits > 64) value |= words[word + 1][1] << 64 - shift;
-    const id = (value & mask) >>> 0;
-    const state = palette[id];
-    if (!state) throw new MineRenderError(`Litematica region ${name} 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 ${name} 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, position, signedSize, size, blocks, entities, dataVersion };
-}
-function minimum(position, size) {
-  return position + Math.min(0, size + 1);
-}
-function integer2(tag, name) {
-  if (tag?.type !== "int" || !Number.isInteger(tag.value) || tag.value < -2147483648 || tag.value > 2147483647) {
-    throw new MineRenderError(`Litematica ${name} must be an int`);
-  }
-  return tag.value;
-}
-function compound(tag, name) {
-  if (tag?.type !== "compound" || !tag.value || typeof tag.value !== "object" || Array.isArray(tag.value)) {
-    throw new MineRenderError(`Litematica ${name} must be a compound`);
-  }
-  return tag.value;
-}
-function blockPosition(tags) {
-  return ["x", "y", "z"].map((axis) => integer2(tags[axis], axis));
-}
-function compounds(tag, name) {
-  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 ${name} must be a compound list`);
-}
-function blockState(tags) {
-  const name = tags.Name;
-  if (name?.type !== "string" || !/^(?:[a-z0-9_.-]+:)?[a-z0-9_./-]+$/.test(name.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: name.value.includes(":") ? name.value : `minecraft:${name.value}`, properties };
-}
-
-// src/model/multiblock/SchematicParser.ts
-init_MineRenderError();
-
 // src/model/multiblock/legacyBlocks.json
 var legacyBlocks_default = {
   __comment: "Block mappings from res/idsToNames.json (WorldEdit legacy.json); block names and cauldrons updated for Minecraft 1.21.11. Source: https://github.com/sk89q/WorldEdit/blob/master/worldedit-core/src/main/resources/com/sk89q/worldedit/world/registry/legacy.json",
@@ -24895,12 +24744,20 @@ var legacyBlocks_default = {
     "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]",
@@ -25741,7 +25598,175 @@ var legacyBlocks_default = {
   }
 };
 
+// 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_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 version2 = integer2(tags.Version, "Version");
+    if (version2 < 5 || version2 > 7) throw new MineRenderError(`Unsupported Litematica version ${version2}; 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 max = [-Infinity, -Infinity, -Infinity];
+    for (const [name, tag] of Object.entries(compound(tags.Regions, "Regions"))) {
+      const region = readRegion(compound(tag, `region ${name}`), name, 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);
+        max[axis] = Math.max(max[axis], start + region.size[axis]);
+      }
+    }
+    return {
+      size: regions.length ? min.map((value, axis) => max[axis] - value) : [0, 0, 0],
+      blocks: [...blocks.values()],
+      entities: regions.flatMap((region) => region.entities ?? []),
+      dataVersion,
+      regions
+    };
+  }
+};
+function readRegion(tags, name, dataVersion, combined) {
+  const position = blockPosition(compound(tags.Position, `region ${name} Position`));
+  const signedSize = blockPosition(compound(tags.Size, `region ${name} Size`));
+  if (signedSize.some((value) => value === 0)) throw new MineRenderError(`Litematica region ${name} 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 ${name} has no block palette`);
+  const bits = Math.max(2, Math.ceil(Math.log2(palette.length)));
+  if (!Number.isSafeInteger(volume * bits)) throw new MineRenderError(`Litematica region ${name} volume is too large`);
+  const packed = tags.BlockStates;
+  const expected = Math.ceil(volume * bits / 64);
+  if (packed?.type !== "longArray" || !Array.isArray(packed.value) || packed.value.length !== expected) {
+    throw new MineRenderError(`Litematica region ${name} 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 ${name} 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 ${name} 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 ** bits - 1;
+  for (let index = 0; index < volume; index++) {
+    const word = Math.floor(index * bits / 64);
+    const shift = index * bits % 64;
+    const [high, low] = words[word];
+    let value = shift < 32 ? low >>> shift : high >>> shift - 32;
+    if (shift < 32 && shift + bits > 32) value |= high << 32 - shift;
+    if (shift + bits > 64) value |= words[word + 1][1] << 64 - shift;
+    const id = (value & mask) >>> 0;
+    const state = palette[id];
+    if (!state) throw new MineRenderError(`Litematica region ${name} 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 ${name} 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, position, signedSize, size, blocks, entities, dataVersion };
+}
+function minimum(position, size) {
+  return position + Math.min(0, size + 1);
+}
+function integer2(tag, name) {
+  if (tag?.type !== "int" || !Number.isInteger(tag.value) || tag.value < -2147483648 || tag.value > 2147483647) {
+    throw new MineRenderError(`Litematica ${name} must be an int`);
+  }
+  return tag.value;
+}
+function compound(tag, name) {
+  if (tag?.type !== "compound" || !tag.value || typeof tag.value !== "object" || Array.isArray(tag.value)) {
+    throw new MineRenderError(`Litematica ${name} must be a compound`);
+  }
+  return tag.value;
+}
+function blockPosition(tags) {
+  return ["x", "y", "z"].map((axis) => integer2(tags[axis], axis));
+}
+function compounds(tag, name) {
+  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 ${name} must be a compound list`);
+}
+function blockState(tags) {
+  const name = tags.Name;
+  if (name?.type !== "string" || !/^(?:[a-z0-9_.-]+:)?[a-z0-9_./-]+$/.test(name.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: name.value.includes(":") ? name.value : `minecraft:${name.value}`, properties };
+}
+
 // src/model/multiblock/SchematicParser.ts
+init_MineRenderError();
 var SchematicParser = class {
   /**
    * Parses a legacy schematic using custom mappings before the bundled defaults.
@@ -25783,35 +25808,21 @@ var SchematicParser = class {
       tileEntities.set((y * length + z) * width + x, { 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)
       });
@@ -29191,10 +29202,13 @@ var AnvilParser = class {
     return this.locations(this.bytes(data)).map(({ x, z }) => ({ x, z }));
   }
   /** 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 };
   }
   /**
@@ -29203,13 +29217,28 @@ var AnvilParser = class {
    * @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, z }) => x === localX && z === 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 abort;
+    const cancelled = new Promise((_, reject) => {
+      abort = () => reject(signal.reason);
+      signal.addEventListener("abort", abort, { once: true });
+      if (signal.aborted) abort();
+    });
+    try {
+      return await Promise.race([promise, cancelled]);
+    } finally {
+      signal.removeEventListener("abort", abort);
+    }
   }
   static bytes(data) {
     return data instanceof Uint8Array ? data : new Uint8Array(data);
@@ -29235,20 +29264,41 @@ var AnvilParser = class {
     }
     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 format2 = data[location.offset + 4];
+    const external = (format2 & 128) !== 0;
+    const compression = format2 & 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;
@@ -29261,28 +29311,37 @@ var AnvilParser = class {
     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 y = 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 ${y} mixes numeric and paletted block states`);
+        }
+        data2 = this.numericSection(section, y, 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 === y)) throw new MineRenderError(`Duplicate Anvil section Y ${y}`);
       chunk.sections.push({ y, data: data2 });
@@ -29310,6 +29369,33 @@ var AnvilParser = class {
     }
     return chunk;
   }
+  static numericSection(section, y, options, states) {
+    const bytes = (name, length, optional = false) => {
+      const tag = section[name];
+      if (!tag && optional) return void 0;
+      if (tag?.type !== "byteArray" || !Array.isArray(tag.value) || tag.value.length !== length) {
+        throw new MineRenderError(`Anvil section ${y} ${name} 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 ${y} index ${index}`);
+      }
+      if (block && !ChunkData.isAir(block)) data.set(index, block);
+    }
+    return data;
+  }
   static compounds(tag, name) {
     if (!tag) return [];
     if (tag.type !== "list" || tag.value.type !== "compound" && tag.value.value.length !== 0) {
@@ -29392,6 +29478,7 @@ var AnvilWorldSource = class {
     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 [name, value] of Object.entries({ maxCachedRegions: this.maxCachedRegions, maxCachedBytes: this.maxCachedBytes })) {
       if (!Number.isSafeInteger(value) || value < 0) throw new RangeError(`${name} must be a nonnegative safe integer`);
     }
@@ -29405,7 +29492,11 @@ var AnvilWorldSource = class {
     const data = await this.getRegion(regionX, regionZ, signal);
     signal?.throwIfAborted();
     if (!data) return void 0;
-    const chunk = await abortable2(AnvilParser.parseChunk(data, x - regionX * 32, z - regionZ * 32), signal);
+    const chunk = await AnvilParser.parseChunk(data, x - regionX * 32, z - regionZ * 32, {
+      ...this.parseOptions,
+      region: { x: regionX, z: regionZ },
+      signal
+    });
     signal?.throwIfAborted();
     if (chunk && (chunk.x !== x || chunk.z !== z)) {
       throw new MineRenderError(`Anvil chunk coordinates ${chunk.x},${chunk.z} do not match requested column ${x},${z}`);
@@ -29436,7 +29527,7 @@ var AnvilWorldSource = class {
         settled: false,
         promise: Promise.resolve().then(() => {
           controller.signal.throwIfAborted();
-          return this.readRegion(x, z, controller.signal);
+          return abortable2(this.readRegion(x, z, controller.signal), controller.signal);
         }).then((data) => {
           controller.signal.throwIfAborted();
           let bytes = data instanceof Uint8Array ? data : data === void 0 ? void 0 : new Uint8Array(data);