minerender 2.1.0-alpha.90 → 2.1.0-alpha.91

package/dist/browser/index.mjs

@@ -28923,13 +28923,131 @@ var ChunkData = class _ChunkData {
   }
 };
 
+// src/world/_compression/Lz4.ts
+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, bits) => value << bits | value >>> 32 - bits;
+  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, hash;
+  if (data.length >= 16) {
+    let a = seed + prime1 + prime2, b = seed + prime2, c = seed, d = seed - prime1;
+    while (cursor + 16 <= data.length) {
+      a = round(a, view.getUint32(cursor, true));
+      b = round(b, view.getUint32(cursor + 4, true));
+      c = round(c, view.getUint32(cursor + 8, true));
+      d = round(d, view.getUint32(cursor + 12, true));
+      cursor += 16;
+    }
+    hash = rotate(a, 1) + rotate(b, 7) + rotate(c, 12) + rotate(d, 18);
+  } else {
+    hash = seed + prime5;
+  }
+  hash += data.length;
+  while (cursor + 4 <= data.length) {
+    hash = Math.imul(rotate(hash + Math.imul(view.getUint32(cursor, true), prime3), 17), prime4);
+    cursor += 4;
+  }
+  while (cursor < data.length) {
+    hash = Math.imul(rotate(hash + Math.imul(data[cursor++], prime5), 11), prime1);
+  }
+  hash = Math.imul(hash ^ hash >>> 15, prime2);
+  hash = Math.imul(hash ^ hash >>> 13, prime3);
+  return (hash ^ hash >>> 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, z }) => ({ x, z }));
   }
-  /** Decodes all stored chunks. Gzip, zlib, and uncompressed payloads are supported. */
+  /** Decodes all stored chunks. Gzip, zlib, LZ4, and uncompressed payloads are supported. */
   static async parse(data) {
     const bytes = this.bytes(data);
     const chunks = [];
@@ -28977,11 +29095,13 @@ var AnvilParser = class {
   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)" : ""}`);
+    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) {
+    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());
     }