nitro-patcher 0.1.0 → 0.2.1

package/dist/{chunk-L7ZM4LLP.js → chunk-IGURDH5L.js}

@@ -5,158 +5,11 @@ import {
   hashDigest,
   inflateRawSync,
   readFile
-} from "./chunk-GFF67HX4.js";
-
-// src/patch/zip.ts
-var fail = (message) => {
-  throw new Error(`ZIP: ${message}`);
-};
-var utf8 = new TextDecoder("utf-8", { fatal: true });
-var cp437 = "\xC7\xFC\xE9\xE2\xE4\xE0\xE5\xE7\xEA\xEB\xE8\xEF\xEE\xEC\xC4\xC5\xC9\xE6\xC6\xF4\xF6\xF2\xFB\xF9\xFF\xD6\xDC\xA2\xA3\xA5\u20A7\u0192\xE1\xED\xF3\xFA\xF1\xD1\xAA\xBA\xBF\u2310\xAC\xBD\xBC\xA1\xAB\xBB\u2591\u2592\u2593\u2502\u2524\u2561\u2562\u2556\u2555\u2563\u2551\u2557\u255D\u255C\u255B\u2510\u2514\u2534\u252C\u251C\u2500\u253C\u255E\u255F\u255A\u2554\u2569\u2566\u2560\u2550\u256C\u2567\u2568\u2564\u2565\u2559\u2558\u2552\u2553\u256B\u256A\u2518\u250C\u2588\u2584\u258C\u2590\u2580\u03B1\xDF\u0393\u03C0\u03A3\u03C3\xB5\u03C4\u03A6\u0398\u03A9\u03B4\u221E\u03C6\u03B5\u2229\u2261\xB1\u2265\u2264\u2320\u2321\xF7\u2248\xB0\u2219\xB7\u221A\u207F\xB2\u25A0\xA0";
-function decodeUtf8(bytes2) {
-  try {
-    return utf8.decode(bytes2);
-  } catch {
-    return fail("invalid UTF-8 filename");
-  }
-}
-function boundOption(value, fallback, label) {
-  value ??= fallback;
-  if (!Number.isSafeInteger(value) || value < 0)
-    throw new RangeError(`${label} must be a non-negative safe integer`);
-  return value;
-}
-function checkRange(bytes2, offset, length, end = bytes2.length) {
-  if (offset < 0 || offset > end || length > end - offset)
-    fail(`truncated or out-of-bounds record at ${offset} (length ${length})`);
-}
-function extras(bytes2) {
-  const fields = /* @__PURE__ */ new Map();
-  let offset = 0;
-  while (offset < bytes2.length) {
-    checkRange(bytes2, offset, 4);
-    const id = bytes2.readUInt16LE(offset), length = bytes2.readUInt16LE(offset + 2);
-    offset += 4;
-    checkRange(bytes2, offset, length);
-    if (id === 1) fail("ZIP64 archives are unsupported");
-    fields.set(id, bytes2.subarray(offset, offset + length));
-    offset += length;
-  }
-  return fields;
-}
-function filename(raw, flags, fields) {
-  if (flags & 2048) return decodeUtf8(raw);
-  const unicode = fields.get(28789);
-  if (unicode && unicode.length >= 5 && unicode[0] === 1 && unicode.readUInt32LE(1) === crc32(raw))
-    return decodeUtf8(unicode.subarray(5));
-  let result = "";
-  for (const byte of raw) result += byte < 128 ? String.fromCharCode(byte) : cp437[byte - 128];
-  return result;
-}
-var readZip = (input, options = {}) => {
-  if (!(input instanceof Uint8Array))
-    throw new TypeError("ZIP input must be a Buffer or Uint8Array");
-  const bytes2 = Buffer.from(input.buffer, input.byteOffset, input.byteLength);
-  const maxSize = boundOption(
-    options.maxUncompressedSize,
-    1024 * 1024 * 1024,
-    "maxUncompressedSize"
-  );
-  const maxEntries = boundOption(options.maxEntries, 1e5, "maxEntries");
-  let eocd = -1;
-  for (let offset2 = bytes2.length - 22; offset2 >= Math.max(0, bytes2.length - 65557); offset2--) {
-    if (bytes2.readUInt32LE(offset2) === 101010256 && offset2 + 22 + bytes2.readUInt16LE(offset2 + 20) === bytes2.length) {
-      eocd = offset2;
-      break;
-    }
-  }
-  if (eocd < 0) fail("end of central directory not found or truncated");
-  const disk = bytes2.readUInt16LE(eocd + 4), centralDisk = bytes2.readUInt16LE(eocd + 6);
-  const diskEntries = bytes2.readUInt16LE(eocd + 8), count = bytes2.readUInt16LE(eocd + 10);
-  const centralSize = bytes2.readUInt32LE(eocd + 12), centralOffset = bytes2.readUInt32LE(eocd + 16);
-  if (count === 65535 || diskEntries === 65535 || centralSize === 4294967295 || centralOffset === 4294967295 || eocd >= 20 && bytes2.readUInt32LE(eocd - 20) === 117853008)
-    fail("ZIP64 archives are unsupported");
-  if (disk || centralDisk || diskEntries !== count)
-    fail("split or multiple-disk archives are unsupported");
-  if (count > maxEntries) fail(`entry count exceeds limit ${maxEntries}`);
-  checkRange(bytes2, centralOffset, centralSize, eocd);
-  if (centralOffset + centralSize !== eocd) fail("central directory size/offset mismatch");
-  if (count > Math.floor(centralSize / 46)) fail("entry count exceeds central directory size");
-  const result = /* @__PURE__ */ new Map();
-  const ranges = [];
-  let offset = centralOffset, totalSize = 0;
-  for (let index = 0; index < count; index++) {
-    checkRange(bytes2, offset, 46, eocd);
-    if (bytes2.readUInt32LE(offset) !== 33639248) fail("invalid central directory signature");
-    const flags = bytes2.readUInt16LE(offset + 8), method = bytes2.readUInt16LE(offset + 10);
-    const checksum = bytes2.readUInt32LE(offset + 16), compressedSize = bytes2.readUInt32LE(offset + 20), size = bytes2.readUInt32LE(offset + 24);
-    const nameLength = bytes2.readUInt16LE(offset + 28), extraLength = bytes2.readUInt16LE(offset + 30), commentLength = bytes2.readUInt16LE(offset + 32);
-    const startDisk = bytes2.readUInt16LE(offset + 34), localOffset = bytes2.readUInt32LE(offset + 42);
-    if (size === 4294967295 || compressedSize === 4294967295 || localOffset === 4294967295 || startDisk === 65535)
-      fail("ZIP64 entry is unsupported");
-    if (startDisk) fail("split or multiple-disk entry is unsupported");
-    if (flags & 8257) fail("encrypted entries are unsupported");
-    if (flags & ~2062) fail("unsupported general purpose flags");
-    if (method !== 0 && method !== 8) fail(`unsupported compression method ${method}`);
-    if (size > maxSize - totalSize) fail(`uncompressed size exceeds limit ${maxSize}`);
-    totalSize += size;
-    checkRange(bytes2, offset + 46, nameLength + extraLength + commentLength, eocd);
-    const rawName = bytes2.subarray(offset + 46, offset + 46 + nameLength);
-    const fields = extras(
-      bytes2.subarray(offset + 46 + nameLength, offset + 46 + nameLength + extraLength)
-    );
-    const name = filename(rawName, flags, fields).replaceAll("\\", "/").toLowerCase();
-    offset += 46 + nameLength + extraLength + commentLength;
-    checkRange(bytes2, localOffset, 30, centralOffset);
-    if (bytes2.readUInt32LE(localOffset) !== 67324752) fail("invalid local header signature");
-    if (bytes2.readUInt16LE(localOffset + 6) !== flags || bytes2.readUInt16LE(localOffset + 8) !== method)
-      fail("local header flags/compression method mismatch");
-    const localNameLength = bytes2.readUInt16LE(localOffset + 26), localExtraLength = bytes2.readUInt16LE(localOffset + 28);
-    const dataOffset = localOffset + 30 + localNameLength + localExtraLength;
-    checkRange(bytes2, localOffset + 30, localNameLength + localExtraLength, centralOffset);
-    if (!rawName.equals(bytes2.subarray(localOffset + 30, localOffset + 30 + localNameLength)))
-      fail("local filename differs from central directory");
-    extras(bytes2.subarray(localOffset + 30 + localNameLength, dataOffset));
-    if (!(flags & 8) && (bytes2.readUInt32LE(localOffset + 14) !== checksum || bytes2.readUInt32LE(localOffset + 18) !== compressedSize || bytes2.readUInt32LE(localOffset + 22) !== size))
-      fail("local header CRC/size mismatch");
-    checkRange(bytes2, dataOffset, compressedSize, centralOffset);
-    let dataEnd = dataOffset + compressedSize;
-    if (flags & 8) {
-      checkRange(bytes2, dataEnd, 12, centralOffset);
-      const matches = (at) => at + 12 <= centralOffset && bytes2.readUInt32LE(at) === checksum && bytes2.readUInt32LE(at + 4) === compressedSize && bytes2.readUInt32LE(at + 8) === size;
-      if (matches(dataEnd)) dataEnd += 12;
-      else if (bytes2.readUInt32LE(dataEnd) === 134695760 && matches(dataEnd + 4)) dataEnd += 16;
-      else fail("data descriptor CRC/size mismatch");
-    }
-    ranges.push({ start: localOffset, end: dataEnd });
-    const compressed = bytes2.subarray(dataOffset, dataOffset + compressedSize);
-    let data;
-    if (method === 0) {
-      if (compressedSize !== size) fail("stored entry compressed/uncompressed size mismatch");
-      data = Buffer.from(compressed);
-    } else {
-      try {
-        data = inflateRawSync(compressed, { maxOutputLength: Math.max(1, size) });
-      } catch (error) {
-        return fail(
-          `cannot inflate entry ${JSON.stringify(name)} within declared size: ${error instanceof Error ? error.message : String(error)}`
-        );
-      }
-    }
-    if (data.length !== size) fail(`uncompressed size mismatch for ${JSON.stringify(name)}`);
-    if (crc32(data) !== checksum) fail(`CRC32 mismatch for ${JSON.stringify(name)}`);
-    if (name && !name.endsWith("/")) result.set(name, data);
-  }
-  if (offset !== eocd) fail("central directory entry count/length mismatch");
-  ranges.sort((a, b) => a.start - b.start);
-  for (let i = 1; i < ranges.length; i++)
-    if (ranges[i].start < ranges[i - 1].end) fail("overlapping local entry ranges");
-  return result;
-};
+} from "./chunk-GLK3K2HY.js";
 
 // src/patch/xdelta.ts
 var UINT32_MAX = 4294967295;
-var fail2 = (message) => {
+var fail = (message) => {
   throw new Error(`VCDIFF: ${message}`);
 };
 var Reader = class {
@@ -164,14 +17,12 @@ var Reader = class {
     this.bytes = bytes2;
     this.label = label;
   }
-  bytes;
-  label;
   pos = 0;
   get remaining() {
     return this.bytes.length - this.pos;
   }
   byte() {
-    if (!this.remaining) fail2(`truncated ${this.label}`);
+    if (!this.remaining) fail(`truncated ${this.label}`);
     return this.bytes[this.pos++];
   }
   integer() {
@@ -179,14 +30,13 @@ var Reader = class {
     for (let count = 0; count < 5; count++) {
       const byte = this.byte();
       value = value * 128 + (byte & 127);
-      if (value > UINT32_MAX) fail2(`integer exceeds 32-bit limit in ${this.label}`);
+      if (value > UINT32_MAX) fail(`integer exceeds 32-bit limit in ${this.label}`);
       if (!(byte & 128)) return value;
     }
-    return fail2(`invalid variable-length integer in ${this.label}`);
+    return fail(`invalid variable-length integer in ${this.label}`);
   }
   take(size) {
-    if (size > this.remaining)
-      fail2(`truncated ${this.label}: requested ${size} bytes, ${this.remaining} remain`);
+    if (size > this.remaining) fail(`truncated ${this.label}: requested ${size} bytes, ${this.remaining} remain`);
     const result = this.bytes.subarray(this.pos, this.pos + size);
     this.pos += size;
     return result;
@@ -237,27 +87,26 @@ var decodeXdelta = (source, patch, options = {}) => {
   const reader = new Reader(asBuffer(patch, "patch"));
   const maxOutput = limit(options.maxOutputSize, 1024 * 1024 * 1024, "maxOutputSize");
   const maxWindow = limit(options.maxWindowSize, 16 * 1024 * 1024, "maxWindowSize");
-  if (!reader.take(3).equals(Buffer.from([214, 195, 196]))) fail2("invalid file signature");
-  if (reader.byte() !== 0) fail2("unsupported version (expected 0)");
+  if (!reader.take(3).equals(Buffer.from([214, 195, 196]))) fail("invalid file signature");
+  if (reader.byte() !== 0) fail("unsupported version (expected 0)");
   const header = reader.byte();
-  if (header & ~7) fail2("unrecognized header indicator bits");
-  if (header & 1)
-    fail2("secondary compression is unsupported; recreate the patch using xdelta3 -S none");
-  if (header & 2) fail2("custom code table is unsupported");
+  if (header & ~7) fail("unrecognized header indicator bits");
+  if (header & 1) fail("secondary compression is unsupported; recreate the patch using xdelta3 -S none");
+  if (header & 2) fail("custom code table is unsupported");
   if (header & 4) reader.take(reader.integer());
   const windows = [];
   let total = 0;
   while (reader.remaining) {
     const indicator = reader.byte();
     if (indicator & ~7 || (indicator & 3) === 3)
-      fail2("invalid window indicator: source and target are mutually exclusive");
+      fail("invalid window indicator: source and target are mutually exclusive");
     let dictionary = Buffer.alloc(0);
     if (indicator & 3) {
       const length = reader.integer();
       const offset = reader.integer();
       const available = indicator & 1 ? sourceBytes.length : total;
       if (offset > available || length > available - offset)
-        fail2("source segment exceeds available source/target bounds");
+        fail("source segment exceeds available source/target bounds");
       if (indicator & 1) dictionary = sourceBytes.subarray(offset, offset + length);
       else {
         dictionary = Buffer.allocUnsafe(length);
@@ -273,20 +122,18 @@ var decodeXdelta = (source, patch, options = {}) => {
     const deltaLength = reader.integer();
     const delta = new Reader(reader.take(deltaLength), "delta window");
     const targetLength = delta.integer();
-    if (targetLength > maxWindow)
-      fail2(`window size ${targetLength} exceeds maximum limit ${maxWindow}`);
-    if (targetLength > maxOutput - total) fail2(`output size exceeds maximum limit ${maxOutput}`);
-    if (dictionary.length + targetLength > UINT32_MAX)
-      fail2("window address space exceeds 32-bit limit");
+    if (targetLength > maxWindow) fail(`window size ${targetLength} exceeds maximum limit ${maxWindow}`);
+    if (targetLength > maxOutput - total) fail(`output size exceeds maximum limit ${maxOutput}`);
+    if (dictionary.length + targetLength > UINT32_MAX) fail("window address space exceeds 32-bit limit");
     const compressed = delta.byte();
-    if (compressed & ~7) fail2("unrecognized delta indicator bits");
-    if (compressed) fail2("secondary compression in delta sections is unsupported");
+    if (compressed & ~7) fail("unrecognized delta indicator bits");
+    if (compressed) fail("secondary compression in delta sections is unsupported");
     const dataLength = delta.integer(), instructionLength = delta.integer(), addressLength = delta.integer();
     const checksum = indicator & 4 ? delta.take(4).readUInt32BE() : null;
     const data = new Reader(delta.take(dataLength), "data section");
     const instructions = new Reader(delta.take(instructionLength), "instruction section");
     const addresses = new Reader(delta.take(addressLength), "address section");
-    if (delta.remaining) fail2("delta encoding length does not match section lengths");
+    if (delta.remaining) fail("delta encoding length does not match section lengths");
     const target = Buffer.allocUnsafe(targetLength);
     const near = new Uint32Array(4), same = new Uint32Array(768);
     let nearIndex = 0, position = 0;
@@ -294,7 +141,7 @@ var decodeXdelta = (source, patch, options = {}) => {
       const operations = table[instructions.byte()];
       for (const { type, size: fixedSize, mode } of operations) {
         const size = fixedSize || instructions.integer();
-        if (size > targetLength - position) fail2(`${type} size exceeds target window length`);
+        if (size > targetLength - position) fail(`${type} size exceeds target window length`);
         if (type === "ADD") {
           data.take(size).copy(target, position);
         } else if (type === "RUN") {
@@ -306,8 +153,7 @@ var decodeXdelta = (source, patch, options = {}) => {
           else if (mode === 1) address = here - addresses.integer();
           else if (mode < 6) address = near[mode - 2] + addresses.integer();
           else address = same[(mode - 6) * 256 + addresses.byte()];
-          if (address < 0 || address >= here)
-            fail2(`COPY address ${address} is outside decoded address space ${here}`);
+          if (address < 0 || address >= here) fail(`COPY address ${address} is outside decoded address space ${here}`);
           near[nearIndex] = address;
           nearIndex = (nearIndex + 1) % near.length;
           same[address % same.length] = address;
@@ -319,7 +165,7 @@ var decodeXdelta = (source, patch, options = {}) => {
           const from = Math.max(0, address - dictionary.length);
           while (copied < size) {
             const count = Math.min(size - copied, position + copied - from);
-            if (count <= 0) fail2("COPY references unavailable target bytes");
+            if (count <= 0) fail("COPY references unavailable target bytes");
             target.copy(target, position + copied, from, from + count);
             copied += count;
           }
@@ -327,31 +173,236 @@ var decodeXdelta = (source, patch, options = {}) => {
         position += size;
       }
     }
-    if (position !== targetLength)
-      fail2(`target window length mismatch: decoded ${position}, expected ${targetLength}`);
-    if (data.remaining || addresses.remaining) fail2("unused bytes in data/address section");
-    if (checksum !== null && adler32(target) !== checksum) fail2("Adler32 checksum mismatch");
+    if (position !== targetLength) fail(`target window length mismatch: decoded ${position}, expected ${targetLength}`);
+    if (data.remaining || addresses.remaining) fail("unused bytes in data/address section");
+    if (checksum !== null && adler32(target) !== checksum) fail("Adler32 checksum mismatch");
     windows.push(target);
     total += targetLength;
   }
   return Buffer.concat(windows, total);
 };
 
+// src/patch/zip.ts
+var fail2 = (message) => {
+  throw new Error(`ZIP: ${message}`);
+};
+var utf8 = new TextDecoder("utf-8", { fatal: true });
+var cp437 = "\xC7\xFC\xE9\xE2\xE4\xE0\xE5\xE7\xEA\xEB\xE8\xEF\xEE\xEC\xC4\xC5\xC9\xE6\xC6\xF4\xF6\xF2\xFB\xF9\xFF\xD6\xDC\xA2\xA3\xA5\u20A7\u0192\xE1\xED\xF3\xFA\xF1\xD1\xAA\xBA\xBF\u2310\xAC\xBD\xBC\xA1\xAB\xBB\u2591\u2592\u2593\u2502\u2524\u2561\u2562\u2556\u2555\u2563\u2551\u2557\u255D\u255C\u255B\u2510\u2514\u2534\u252C\u251C\u2500\u253C\u255E\u255F\u255A\u2554\u2569\u2566\u2560\u2550\u256C\u2567\u2568\u2564\u2565\u2559\u2558\u2552\u2553\u256B\u256A\u2518\u250C\u2588\u2584\u258C\u2590\u2580\u03B1\xDF\u0393\u03C0\u03A3\u03C3\xB5\u03C4\u03A6\u0398\u03A9\u03B4\u221E\u03C6\u03B5\u2229\u2261\xB1\u2265\u2264\u2320\u2321\xF7\u2248\xB0\u2219\xB7\u221A\u207F\xB2\u25A0\xA0";
+function decodeUtf8(bytes2) {
+  try {
+    return utf8.decode(bytes2);
+  } catch {
+    return fail2("invalid UTF-8 filename");
+  }
+}
+function boundOption(value, fallback, label) {
+  value ??= fallback;
+  if (!Number.isSafeInteger(value) || value < 0) throw new RangeError(`${label} must be a non-negative safe integer`);
+  return value;
+}
+function checkRange(bytes2, offset, length, end = bytes2.length) {
+  if (offset < 0 || offset > end || length > end - offset)
+    fail2(`truncated or out-of-bounds record at ${offset} (length ${length})`);
+}
+function extras(bytes2) {
+  const fields = /* @__PURE__ */ new Map();
+  let offset = 0;
+  while (offset < bytes2.length) {
+    checkRange(bytes2, offset, 4);
+    const id = bytes2.readUInt16LE(offset), length = bytes2.readUInt16LE(offset + 2);
+    offset += 4;
+    checkRange(bytes2, offset, length);
+    if (id === 1) fail2("ZIP64 archives are unsupported");
+    fields.set(id, bytes2.subarray(offset, offset + length));
+    offset += length;
+  }
+  return fields;
+}
+function filename(raw, flags, fields) {
+  if (flags & 2048) return decodeUtf8(raw);
+  const unicode = fields.get(28789);
+  if (unicode && unicode.length >= 5 && unicode[0] === 1 && unicode.readUInt32LE(1) === crc32(raw))
+    return decodeUtf8(unicode.subarray(5));
+  let result = "";
+  for (const byte of raw) result += byte < 128 ? String.fromCharCode(byte) : cp437[byte - 128];
+  return result;
+}
+var readZip = (input, options = {}) => {
+  if (!(input instanceof Uint8Array)) throw new TypeError("ZIP input must be a Buffer or Uint8Array");
+  const bytes2 = Buffer.from(input.buffer, input.byteOffset, input.byteLength);
+  const maxSize = boundOption(options.maxUncompressedSize, 1024 * 1024 * 1024, "maxUncompressedSize");
+  const maxEntries = boundOption(options.maxEntries, 1e5, "maxEntries");
+  let eocd = -1;
+  for (let offset2 = bytes2.length - 22; offset2 >= Math.max(0, bytes2.length - 65557); offset2--) {
+    if (bytes2.readUInt32LE(offset2) === 101010256 && offset2 + 22 + bytes2.readUInt16LE(offset2 + 20) === bytes2.length) {
+      eocd = offset2;
+      break;
+    }
+  }
+  if (eocd < 0) fail2("end of central directory not found or truncated");
+  const disk = bytes2.readUInt16LE(eocd + 4), centralDisk = bytes2.readUInt16LE(eocd + 6);
+  const diskEntries = bytes2.readUInt16LE(eocd + 8), count = bytes2.readUInt16LE(eocd + 10);
+  const centralSize = bytes2.readUInt32LE(eocd + 12), centralOffset = bytes2.readUInt32LE(eocd + 16);
+  if (count === 65535 || diskEntries === 65535 || centralSize === 4294967295 || centralOffset === 4294967295 || eocd >= 20 && bytes2.readUInt32LE(eocd - 20) === 117853008)
+    fail2("ZIP64 archives are unsupported");
+  if (disk || centralDisk || diskEntries !== count) fail2("split or multiple-disk archives are unsupported");
+  if (count > maxEntries) fail2(`entry count exceeds limit ${maxEntries}`);
+  checkRange(bytes2, centralOffset, centralSize, eocd);
+  if (centralOffset + centralSize !== eocd) fail2("central directory size/offset mismatch");
+  if (count > Math.floor(centralSize / 46)) fail2("entry count exceeds central directory size");
+  const result = /* @__PURE__ */ new Map();
+  const ranges = [];
+  let offset = centralOffset, totalSize = 0;
+  for (let index = 0; index < count; index++) {
+    checkRange(bytes2, offset, 46, eocd);
+    if (bytes2.readUInt32LE(offset) !== 33639248) fail2("invalid central directory signature");
+    const flags = bytes2.readUInt16LE(offset + 8), method = bytes2.readUInt16LE(offset + 10);
+    const checksum = bytes2.readUInt32LE(offset + 16), compressedSize = bytes2.readUInt32LE(offset + 20), size = bytes2.readUInt32LE(offset + 24);
+    const nameLength = bytes2.readUInt16LE(offset + 28), extraLength = bytes2.readUInt16LE(offset + 30), commentLength = bytes2.readUInt16LE(offset + 32);
+    const startDisk = bytes2.readUInt16LE(offset + 34), localOffset = bytes2.readUInt32LE(offset + 42);
+    if (size === 4294967295 || compressedSize === 4294967295 || localOffset === 4294967295 || startDisk === 65535)
+      fail2("ZIP64 entry is unsupported");
+    if (startDisk) fail2("split or multiple-disk entry is unsupported");
+    if (flags & 8257) fail2("encrypted entries are unsupported");
+    if (flags & ~2062) fail2("unsupported general purpose flags");
+    if (method !== 0 && method !== 8) fail2(`unsupported compression method ${method}`);
+    if (size > maxSize - totalSize) fail2(`uncompressed size exceeds limit ${maxSize}`);
+    totalSize += size;
+    checkRange(bytes2, offset + 46, nameLength + extraLength + commentLength, eocd);
+    const rawName = bytes2.subarray(offset + 46, offset + 46 + nameLength);
+    const fields = extras(bytes2.subarray(offset + 46 + nameLength, offset + 46 + nameLength + extraLength));
+    const name = filename(rawName, flags, fields).replaceAll("\\", "/").toLowerCase();
+    offset += 46 + nameLength + extraLength + commentLength;
+    checkRange(bytes2, localOffset, 30, centralOffset);
+    if (bytes2.readUInt32LE(localOffset) !== 67324752) fail2("invalid local header signature");
+    if (bytes2.readUInt16LE(localOffset + 6) !== flags || bytes2.readUInt16LE(localOffset + 8) !== method)
+      fail2("local header flags/compression method mismatch");
+    const localNameLength = bytes2.readUInt16LE(localOffset + 26), localExtraLength = bytes2.readUInt16LE(localOffset + 28);
+    const dataOffset = localOffset + 30 + localNameLength + localExtraLength;
+    checkRange(bytes2, localOffset + 30, localNameLength + localExtraLength, centralOffset);
+    if (!rawName.equals(bytes2.subarray(localOffset + 30, localOffset + 30 + localNameLength)))
+      fail2("local filename differs from central directory");
+    extras(bytes2.subarray(localOffset + 30 + localNameLength, dataOffset));
+    if (!(flags & 8) && (bytes2.readUInt32LE(localOffset + 14) !== checksum || bytes2.readUInt32LE(localOffset + 18) !== compressedSize || bytes2.readUInt32LE(localOffset + 22) !== size))
+      fail2("local header CRC/size mismatch");
+    checkRange(bytes2, dataOffset, compressedSize, centralOffset);
+    let dataEnd = dataOffset + compressedSize;
+    if (flags & 8) {
+      checkRange(bytes2, dataEnd, 12, centralOffset);
+      const matches = (at) => at + 12 <= centralOffset && bytes2.readUInt32LE(at) === checksum && bytes2.readUInt32LE(at + 4) === compressedSize && bytes2.readUInt32LE(at + 8) === size;
+      if (matches(dataEnd)) dataEnd += 12;
+      else if (bytes2.readUInt32LE(dataEnd) === 134695760 && matches(dataEnd + 4)) dataEnd += 16;
+      else fail2("data descriptor CRC/size mismatch");
+    }
+    ranges.push({ start: localOffset, end: dataEnd });
+    const compressed = bytes2.subarray(dataOffset, dataOffset + compressedSize);
+    let data;
+    if (method === 0) {
+      if (compressedSize !== size) fail2("stored entry compressed/uncompressed size mismatch");
+      data = Buffer.from(compressed);
+    } else {
+      try {
+        data = inflateRawSync(compressed, { maxOutputLength: Math.max(1, size) });
+      } catch (error) {
+        return fail2(
+          `cannot inflate entry ${JSON.stringify(name)} within declared size: ${error instanceof Error ? error.message : String(error)}`
+        );
+      }
+    }
+    if (data.length !== size) fail2(`uncompressed size mismatch for ${JSON.stringify(name)}`);
+    if (crc32(data) !== checksum) fail2(`CRC32 mismatch for ${JSON.stringify(name)}`);
+    if (name && !name.endsWith("/")) result.set(name, data);
+  }
+  if (offset !== eocd) fail2("central directory entry count/length mismatch");
+  ranges.sort((a, b) => a.start - b.start);
+  for (let i = 1; i < ranges.length; i++)
+    if (ranges[i].start < ranges[i - 1].end) fail2("overlapping local entry ranges");
+  return result;
+};
+var extractZipEntry = (input, entryName, options = {}) => {
+  if (typeof entryName !== "string" || !entryName) throw new TypeError("ZIP entry name must be a non-empty string");
+  const normalized = entryName.replaceAll("\\", "/").toLowerCase();
+  if (normalized.endsWith("/")) fail2(`entry ${JSON.stringify(entryName)} is a directory`);
+  const entry = readZip(input, options).get(normalized);
+  if (entry === void 0) return fail2(`entry ${JSON.stringify(entryName)} not found`);
+  return entry;
+};
+
 // src/nitro-patch-helper.ts
 var PatchReturnValue = Object.freeze({
   SUCCESS: "SUCCESS",
   MD5_MISMATCH: "MD5_MISMATCH"
 });
 var md5 = (data) => hashDigest("md5", data).toString("hex");
+var invalidMetadata = (message) => {
+  console.warn(`\u5FFD\u7565 metadata.json\uFF1A${message}`);
+  return null;
+};
+var invalidMetadataField = (field, message) => {
+  console.warn(`\u5FFD\u7565 metadata.json \u7684 ${field}\uFF1A${message}`);
+};
+var readMetadata = (files) => {
+  const file = files.get("metadata.json");
+  if (!file) return null;
+  let metadata;
+  try {
+    metadata = JSON.parse(new TextDecoder("utf-8", { fatal: true }).decode(file));
+  } catch (error) {
+    return invalidMetadata(
+      `\u683C\u5F0F\u9519\u8BEF\uFF0C\u53EF\u80FD\u662F\u56E0\u4E3A\u8865\u4E01\u5305\u5DF2\u635F\u574F\uFF1A${error instanceof Error ? error.message : String(error)}`
+    );
+  }
+  if (!metadata || typeof metadata !== "object" || Array.isArray(metadata))
+    return invalidMetadata("\u6839\u8282\u70B9\u5FC5\u987B\u662F\u5BF9\u8C61\u3002");
+  const value = metadata;
+  const result = {};
+  for (const field of ["id", "author", "name", "homepage", "version"]) {
+    const fieldValue = value[field];
+    if (fieldValue === void 0) continue;
+    if (typeof fieldValue === "string") result[field] = fieldValue;
+    else invalidMetadataField(field, "\u5FC5\u987B\u662F\u5B57\u7B26\u4E32\u3002");
+  }
+  if (value.isBeta === void 0) return result;
+  if (typeof value.isBeta === "boolean") result.isBeta = value.isBeta;
+  else invalidMetadataField("isBeta", "\u5FC5\u987B\u662F\u5E03\u5C14\u503C\u3002");
+  return result;
+};
+var readReadme = (files) => {
+  for (const [filename2, format] of [
+    ["README.md", "markdown"],
+    ["README.txt", "plaintext"]
+  ]) {
+    const file = files.get(filename2.toLowerCase());
+    if (!file) continue;
+    try {
+      return {
+        format,
+        content: new TextDecoder("utf-8", { fatal: true }).decode(file)
+      };
+    } catch (error) {
+      console.warn(
+        `\u5FFD\u7565 ${filename2}\uFF1A\u4E0D\u662F\u6709\u6548\u7684 UTF-8 \u6587\u672C\uFF1A${error instanceof Error ? error.message : String(error)}`
+      );
+    }
+  }
+  return null;
+};
+var readPatchMetadata = (patch, options = {}) => readMetadata(readZip(patch, options));
+var readPatchReadme = (patch, options = {}) => readReadme(readZip(patch, options));
+var readPatchInfo = (patch, options = {}) => {
+  const files = readZip(patch, options);
+  return { metadata: readMetadata(files), readme: readReadme(files) };
+};
+var extractZipEntry2 = (archive, entryName, options = {}) => extractZipEntry(archive, entryName, options);
+var readPatchMetadataFile = async (patchPath, options = {}) => readPatchMetadata(await readFile(patchPath), options);
+var readPatchReadmeFile = async (patchPath, options = {}) => readPatchReadme(await readFile(patchPath), options);
+var readPatchInfoFile = async (patchPath, options = {}) => readPatchInfo(await readFile(patchPath), options);
 var patchBuffer = (original, patch, options = {}) => {
   const input = bytes(original, "original ROM");
   const patches = readZip(patch, options);
   const inputMd5 = md5(input);
   const preprocessing = patches.get(`preprocessing/${inputMd5}.xdelta`);
-  const rom = new NDSFile(
-    preprocessing ? decodeXdelta(input, preprocessing, options) : input,
-    options
-  );
+  const rom = new NDSFile(preprocessing ? decodeXdelta(input, preprocessing, options) : input, options);
   let matched = true;
   const md5File = patches.get("md5.txt");
   if (md5File) {
@@ -384,13 +435,30 @@ var patchIt = async (originalPath, patchPath, options = {}) => {
   const [original, patch] = await Promise.all([readFile(originalPath), readFile(patchPath)]);
   return patchBuffer(original, patch, options);
 };
-var PatchHelper = Object.freeze({ patchBuffer, patchIt });
+var PatchHelper = Object.freeze({
+  extractZipEntry: extractZipEntry2,
+  patchBuffer,
+  patchIt,
+  readPatchInfo,
+  readPatchInfoFile,
+  readPatchMetadata,
+  readPatchMetadataFile,
+  readPatchReadme,
+  readPatchReadmeFile
+});
 
 export {
   decodeXdelta,
   PatchReturnValue,
+  readPatchMetadata,
+  readPatchReadme,
+  readPatchInfo,
+  extractZipEntry2 as extractZipEntry,
+  readPatchMetadataFile,
+  readPatchReadmeFile,
+  readPatchInfoFile,
   patchBuffer,
   patchIt,
   PatchHelper
 };
-//# sourceMappingURL=chunk-L7ZM4LLP.js.map
+//# sourceMappingURL=chunk-IGURDH5L.js.map