minerender 2.1.0-alpha.90 → 2.1.0-alpha.92

package/dist/bundle.js

@@ -119191,17 +119191,141 @@ gl_FragDepth=readDepth(vUv);
     }
   };
 
+  // src/world/_compression/Lz4.ts
+  init_dirname();
+  init_buffer2();
+  init_process2();
+  init_MineRenderError();
+  function decodeAnvilLz4(data) {
+    const view = new DataView(data.buffer, data.byteOffset, data.byteLength);
+    const blocks = [];
+    let cursor = 0, totalSize = 0;
+    while (true) {
+      if (cursor + 21 > data.length) throw invalid("truncated block header or missing terminator");
+      if (view.getUint32(cursor) !== 1280980034 || view.getUint32(cursor + 4) !== 1819239275) {
+        throw invalid("invalid block signature");
+      }
+      const token = data[cursor + 8];
+      const method = token & 240;
+      const size = view.getInt32(cursor + 9, true);
+      const decodedSize = view.getInt32(cursor + 13, true);
+      const checksum = view.getUint32(cursor + 17, true);
+      cursor += 21;
+      if (method !== 16 && method !== 32) throw invalid("unsupported block method");
+      if (size < 0 || decodedSize < 0 || decodedSize > 2 ** (10 + (token & 15)) || size === 0 !== (decodedSize === 0) || method === 16 && size !== decodedSize) {
+        throw invalid("invalid block lengths");
+      }
+      if (size === 0) {
+        if (checksum !== 0 || cursor !== data.length) throw invalid("invalid terminator or trailing bytes");
+        break;
+      }
+      if (cursor + size > data.length || decodedSize > size * 255) throw invalid("invalid block lengths");
+      blocks.push({ start: cursor, size, decodedSize, raw: method === 16, checksum });
+      totalSize += decodedSize;
+      cursor += size;
+    }
+    const output = new Uint8Array(totalSize);
+    let offset = 0;
+    for (const block of blocks) {
+      const source = data.subarray(block.start, block.start + block.size);
+      const target = output.subarray(offset, offset + block.decodedSize);
+      if (block.raw) target.set(source);
+      else decodeBlock(source, target);
+      if (checksum32(target) !== block.checksum) throw invalid("block checksum mismatch");
+      offset += block.decodedSize;
+    }
+    return output;
+  }
+  function decodeBlock(source, target) {
+    let input = 0, output = 0, matched = false;
+    const length = (nibble) => {
+      let value = nibble;
+      if (value === 15) {
+        let extension;
+        do {
+          if (input === source.length) throw invalid("truncated sequence length");
+          extension = source[input++];
+          value += extension;
+        } while (extension === 255);
+      }
+      return value;
+    };
+    while (input < source.length) {
+      const token = source[input++];
+      const literals = length(token >>> 4);
+      if (input + literals > source.length || output + literals > target.length) {
+        throw invalid("literal sequence exceeds block bounds");
+      }
+      target.set(source.subarray(input, input + literals), output);
+      input += literals;
+      output += literals;
+      if (input === source.length) {
+        if (output !== target.length || matched && literals < 5) throw invalid("invalid final literal sequence");
+        return;
+      }
+      if (input + 2 > source.length) throw invalid("truncated match offset");
+      const distance = source[input] | source[input + 1] << 8;
+      input += 2;
+      if (distance === 0 || distance > output) throw invalid("match offset exceeds block history");
+      const count = length(token & 15) + 4;
+      if (output > target.length - 12 || output + count > target.length - 5) {
+        throw invalid("match exceeds block bounds");
+      }
+      for (let end = output + count; output < end; output++) target[output] = target[output - distance];
+      matched = true;
+    }
+    throw invalid("missing final literal sequence");
+  }
+  function checksum32(data) {
+    const prime1 = 2654435761, prime2 = 2246822519, prime3 = 3266489917, prime4 = 668265263, prime5 = 374761393;
+    const seed = 2538058380;
+    const rotate = (value, bits2) => value << bits2 | value >>> 32 - bits2;
+    const round = (value, word) => Math.imul(rotate(value + Math.imul(word, prime2), 13), prime1);
+    const view = new DataView(data.buffer, data.byteOffset, data.byteLength);
+    let cursor = 0, hash2;
+    if (data.length >= 16) {
+      let a4 = seed + prime1 + prime2, b4 = seed + prime2, c4 = seed, d4 = seed - prime1;
+      while (cursor + 16 <= data.length) {
+        a4 = round(a4, view.getUint32(cursor, true));
+        b4 = round(b4, view.getUint32(cursor + 4, true));
+        c4 = round(c4, view.getUint32(cursor + 8, true));
+        d4 = round(d4, view.getUint32(cursor + 12, true));
+        cursor += 16;
+      }
+      hash2 = rotate(a4, 1) + rotate(b4, 7) + rotate(c4, 12) + rotate(d4, 18);
+    } else {
+      hash2 = seed + prime5;
+    }
+    hash2 += data.length;
+    while (cursor + 4 <= data.length) {
+      hash2 = Math.imul(rotate(hash2 + Math.imul(view.getUint32(cursor, true), prime3), 17), prime4);
+      cursor += 4;
+    }
+    while (cursor < data.length) {
+      hash2 = Math.imul(rotate(hash2 + Math.imul(data[cursor++], prime5), 11), prime1);
+    }
+    hash2 = Math.imul(hash2 ^ hash2 >>> 15, prime2);
+    hash2 = Math.imul(hash2 ^ hash2 >>> 13, prime3);
+    return (hash2 ^ hash2 >>> 16) & 268435455;
+  }
+  function invalid(detail) {
+    return new MineRenderError(`Invalid Anvil LZ4 stream: ${detail}`);
+  }
+
   // src/world/AnvilParser.ts
   var AnvilParser = class {
     /** Lists occupied chunk positions within the region, using local coordinates from 0 to 31. */
     static getChunkList(data) {
       return this.locations(this.bytes(data)).map(({ x: x4, z: z4 }) => ({ x: x4, z: z4 }));
     }
-    /** Decodes all stored chunks. Gzip, zlib, and uncompressed payloads are supported. */
-    static async parse(data) {
+    /** Decodes all stored chunks. Gzip, zlib, LZ4, and uncompressed payloads are supported. */
+    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 };
     }
     /**
@@ -119210,13 +119334,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);
@@ -119242,18 +119381,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");
-      if (compression !== 1 && compression !== 2 && compression !== 3) {
-        throw new MineRenderError(`Unsupported Anvil compression ${compression}${compression === 4 ? " (LZ4)" : ""}`);
+    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);
-      if (compression !== 3) {
+      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;
@@ -119266,6 +119428,9 @@ 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`);
+      }
       for (const section of this.compounds(level.sections ?? level.Sections, "sections")) {
         const y5 = this.integer(section.Y, "section Y");
         if (section.Blocks || section.Data || section.Add) {
@@ -119400,6 +119565,7 @@ gl_FragDepth=readDepth(vUv);
       this.cachedBytes = 0;
       this.maxCachedRegions = options.maxCachedRegions ?? 4;
       this.maxCachedBytes = options.maxCachedBytes ?? 64 * 1024 * 1024;
+      this.readExternalChunk = options.readExternalChunk;
       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`);
       }
@@ -119413,7 +119579,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, {
+        region: { x: regionX, z: regionZ },
+        readExternalChunk: this.readExternalChunk,
+        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}`);
@@ -119444,7 +119614,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);