minerender 2.1.0-alpha.91 → 2.1.0-alpha.92

package/dist/browser/index.mjs

@@ -29048,10 +29048,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 };
   }
   /**
@@ -29060,13 +29063,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);
@@ -29092,20 +29110,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;
@@ -29118,6 +29157,9 @@ 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`);
+    }
     for (const section of this.compounds(level.sections ?? level.Sections, "sections")) {
       const y = this.integer(section.Y, "section Y");
       if (section.Blocks || section.Data || section.Add) {
@@ -29249,6 +29291,7 @@ var AnvilWorldSource = class {
     this.cachedBytes = 0;
     this.maxCachedRegions = options.maxCachedRegions ?? 4;
     this.maxCachedBytes = options.maxCachedBytes ?? 64 * 1024 * 1024;
+    this.readExternalChunk = options.readExternalChunk;
     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`);
     }
@@ -29262,7 +29305,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, {
+      region: { x: regionX, z: regionZ },
+      readExternalChunk: this.readExternalChunk,
+      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}`);
@@ -29293,7 +29340,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);