nitro-patcher 0.2.0 → 0.2.1

package/src/nitro/twl.ts

@@ -1,9 +1,10 @@
-import { hashDigest, hmacSha1, verifyRsaSha1, readFileSync } from '#nitro-runtime';
-import type { BinaryWriter } from './binary';
-import type { ModcryptHeader } from './crypto';
-import type { Arm9Header } from './blz';
-import { aes128CtrCrypt, encryptSecureArea, modcryptKey } from './crypto';
-import { compressArm9, decompressArm9 } from './blz';
+import { hashDigest, hmacSha1, readFileSync, verifyRsaSha1 } from "#nitro-runtime";
+
+import type { BinaryWriter } from "./binary";
+import type { Arm9Header } from "./blz";
+import { compressArm9, decompressArm9 } from "./blz";
+import type { ModcryptHeader } from "./crypto";
+import { aes128CtrCrypt, encryptSecureArea, modcryptKey } from "./crypto";
 
 export interface TwlHeader extends ModcryptHeader {
   digest_sector_size: number;
@@ -43,8 +44,8 @@ export interface OverlayRange {
 }
 
 export const HMAC_SHA1_KEY = Buffer.from(
-  '2106c0deba98ce3fa692e39d46f2ed0176e3cc08562363facad4ecdf9a6278348f6d633cfe22ca9220889723d2cfaec232678dfeca836498acfd3e3787465824',
-  'hex',
+  "2106c0deba98ce3fa692e39d46f2ed0176e3cc08562363facad4ecdf9a6278348f6d633cfe22ca9220889723d2cfaec232678dfeca836498acfd3e3787465824",
+  "hex",
 );
 const hash = (data: Buffer): Buffer => hmacSha1(HMAC_SHA1_KEY, data);
 function slice(data: Buffer, start: number, size: number, label: string): Buffer {
@@ -60,46 +61,44 @@ function slice(data: Buffer, start: number, size: number, label: string): Buffer
 }
 function validate(h: TwlHeader): void {
   for (const field of [
-    'digest_ntr_start',
-    'digest_ntr_size',
-    'digest_twl_start',
-    'digest_twl_size',
-    'sector_hashtable_start',
-    'sector_hashtable_size',
-    'block_hashtable_start',
-    'block_hashtable_size',
-    'dsi9_rom_offset',
-    'dsi9_size',
-    'dsi7_rom_offset',
-    'dsi7_size',
-    'modcrypt1_start',
-    'modcrypt1_size',
-    'modcrypt2_start',
-    'modcrypt2_size',
-    'total_rom_size',
+    "digest_ntr_start",
+    "digest_ntr_size",
+    "digest_twl_start",
+    "digest_twl_size",
+    "sector_hashtable_start",
+    "sector_hashtable_size",
+    "block_hashtable_start",
+    "block_hashtable_size",
+    "dsi9_rom_offset",
+    "dsi9_size",
+    "dsi7_rom_offset",
+    "dsi7_size",
+    "modcrypt1_start",
+    "modcrypt1_size",
+    "modcrypt2_start",
+    "modcrypt2_size",
+    "total_rom_size",
   ] as const) {
     if (!Number.isSafeInteger(h[field]) || h[field] < 0 || h[field] > 0xffffffff) {
       throw new Error(`Invalid TWL ${field}`);
     }
   }
   const s = h.digest_sector_size;
-  if (!Number.isSafeInteger(s) || s <= 0 || s > 0x4000 || 0x4000 % s)
-    throw new Error('Invalid TWL digest sector size');
+  if (!Number.isSafeInteger(s) || s <= 0 || s > 0x4000 || 0x4000 % s) throw new Error("Invalid TWL digest sector size");
   if (
     !Number.isSafeInteger(h.digest_block_sectorcount) ||
     h.digest_block_sectorcount <= 0 ||
     h.digest_block_sectorcount > 0x100000
   )
-    throw new Error('Invalid TWL digest block sector count');
+    throw new Error("Invalid TWL digest block sector count");
   if (h.digest_ntr_size < 0x4000 || h.digest_ntr_size % s || h.digest_twl_size % s)
-    throw new Error('Invalid TWL digest region size');
+    throw new Error("Invalid TWL digest region size");
   const hashes = (h.digest_ntr_size + h.digest_twl_size) / s;
   if (
     hashes * 20 > h.sector_hashtable_size ||
-    Math.ceil(h.sector_hashtable_size / (h.digest_block_sectorcount * 20)) * 20 >
-      h.block_hashtable_size
+    Math.ceil(h.sector_hashtable_size / (h.digest_block_sectorcount * 20)) * 20 > h.block_hashtable_size
   )
-    throw new Error('TWL hash tables are too small');
+    throw new Error("TWL hash tables are too small");
 }
 export class TWL {
   readonly firstDSiHashOffset: number;
@@ -117,51 +116,31 @@ export class TWL {
     this.firstDSiHashOffset = (h.digest_ntr_size / h.digest_sector_size) * 20;
     this.dsiHashSize = (h.digest_twl_size / h.digest_sector_size) * 20;
     this.Hashtable1Data = Buffer.from(
-      slice(original, h.sector_hashtable_start, h.sector_hashtable_size, 'Sector hash table'),
+      slice(original, h.sector_hashtable_start, h.sector_hashtable_size, "Sector hash table"),
     );
     this.Hashtable2Data = Buffer.from(
-      slice(original, h.block_hashtable_start, h.block_hashtable_size, 'Block hash table'),
-    );
-    this.DSi9Data = Buffer.from(
-      slice(original, h.dsi9_rom_offset, Math.max(h.modcrypt1_size, h.dsi9_size), 'ARM9i'),
-    );
-    this.DSi7Data = Buffer.from(
-      slice(original, h.dsi7_rom_offset, Math.max(h.modcrypt2_size, h.dsi7_size), 'ARM7i'),
+      slice(original, h.block_hashtable_start, h.block_hashtable_size, "Block hash table"),
     );
+    this.DSi9Data = Buffer.from(slice(original, h.dsi9_rom_offset, Math.max(h.modcrypt1_size, h.dsi9_size), "ARM9i"));
+    this.DSi7Data = Buffer.from(slice(original, h.dsi7_rom_offset, Math.max(h.modcrypt2_size, h.dsi7_size), "ARM7i"));
     this.Header2Data = h.trimmedRom
       ? null
       : Array.from({ length: 3 }, (_, i) =>
-          Buffer.from(
-            slice(original, h.digest_twl_start - 0x3000 + 0x1000 * i, 0x1000, 'Secondary header'),
-          ),
+          Buffer.from(slice(original, h.digest_twl_start - 0x3000 + 0x1000 * i, 0x1000, "Secondary header")),
         );
-    this.Overlays9Sha1Hmac = overlays.map((o) =>
-      hash(slice(original, o.offset, o.size, 'ARM9 overlay')),
-    );
+    this.Overlays9Sha1Hmac = overlays.map((o) => hash(slice(original, o.offset, o.size, "ARM9 overlay")));
     let encrypted = false;
     const modcryptStart = [
       { start: h.modcrypt1_start, size: h.modcrypt1_size },
       { start: h.modcrypt2_start, size: h.modcrypt2_size },
-    ].find(
-      ({ start, size }) => size > 0 && start >= h.digest_twl_start && start < 0xffffffff,
-    )?.start;
+    ].find(({ start, size }) => size > 0 && start >= h.digest_twl_start && start < 0xffffffff)?.start;
     if (modcryptStart !== undefined) {
       const index = Math.floor((modcryptStart - h.digest_twl_start) / h.digest_sector_size);
       const actual = hash(
-        slice(
-          original,
-          h.digest_twl_start + index * h.digest_sector_size,
-          h.digest_sector_size,
-          'Modcrypt sector',
-        ),
+        slice(original, h.digest_twl_start + index * h.digest_sector_size, h.digest_sector_size, "Modcrypt sector"),
       );
       encrypted = !actual.equals(
-        slice(
-          this.Hashtable1Data,
-          this.firstDSiHashOffset + index * 20,
-          20,
-          'Modcrypt sector hash',
-        ),
+        slice(this.Hashtable1Data, this.firstDSiHashOffset + index * 20, 20, "Modcrypt sector hash"),
       );
     }
     if (encrypted) this.cryptSections(h);
@@ -178,8 +157,8 @@ export class TWL {
       const off = h[`modcrypt${id}_start`] - start;
       const result = aes128CtrCrypt(
         key,
-        slice(counter, 0, 16, 'Modcrypt counter'),
-        slice(data, off, size, 'Modcrypt payload'),
+        slice(counter, 0, 16, "Modcrypt counter"),
+        slice(data, off, size, "Modcrypt payload"),
       );
       if (writer) {
         writer.position = start + off;
@@ -194,20 +173,16 @@ export class TWL {
     this.DSi7Data = this.importData(data, offset, size);
   }
   private importData(data: Buffer | string, offset: number, size?: number): Buffer {
-    if (typeof data === 'string') data = readFileSync(data);
+    if (typeof data === "string") data = readFileSync(data);
     size ??= data.length - offset;
-    const src = slice(data, offset, size, 'DSi import');
+    const src = slice(data, offset, size, "DSi import");
     const out = Buffer.alloc(Math.ceil(size / 16) * 16, 255);
     src.copy(out);
     return out;
   }
-  updateOverlays9Sha1Hmac(
-    arm9Data: Buffer,
-    header: Arm9Header,
-    overlays: readonly Buffer[],
-  ): Buffer {
+  updateOverlays9Sha1Hmac(arm9Data: Buffer, header: Arm9Header, overlays: readonly Buffer[]): Buffer {
     if (overlays.length !== this.Overlays9Sha1Hmac.length)
-      throw new Error('Changing ARM9 overlay count is unsupported');
+      throw new Error("Changing ARM9 overlay count is unsupported");
     const hashes = overlays.map(hash);
     if (hashes.every((h, i) => h.equals(this.Overlays9Sha1Hmac[i]))) return Buffer.from(arm9Data);
     const init = header.reserved2.readUInt32LE(0) & 0x3fff;
@@ -215,30 +190,23 @@ export class TWL {
     const unpacked = decompressArm9(arm9Data, header);
     const end = unpacked.data.readUInt32LE(init + 8) - header.ARM9ramAddress;
     let found = -1;
-    for (
-      let p = Math.min(end - hashes.length * 20, unpacked.data.length - hashes.length * 20);
-      p >= 0;
-      p--
-    ) {
+    for (let p = Math.min(end - hashes.length * 20, unpacked.data.length - hashes.length * 20); p >= 0; p--) {
       if (unpacked.data.subarray(p, p + 20).equals(this.Overlays9Sha1Hmac[0])) {
         found = p;
         break;
       }
     }
-    if (found < 0)
-      throw new Error('ARM9 overlay hashes changed but original hash table was not found');
+    if (found < 0) throw new Error("ARM9 overlay hashes changed but original hash table was not found");
     hashes.forEach((h, i) => h.copy(unpacked.data, found + i * 20));
     // Original C# inverted this check and tried to compress uncompressed data.
     // Preserve the original storage format: recompress only a compressed ARM9.
-    return unpacked.compressed
-      ? compressArm9(unpacked.data, header, arm9Data.length - hdrptr)
-      : unpacked.data;
+    return unpacked.compressed ? compressArm9(unpacked.data, header, arm9Data.length - hdrptr) : unpacked.data;
   }
   writeTo(writer: BinaryWriter, h: TwlHeader): Buffer {
     validate(h);
     // Fixed DSi regions cannot be shifted safely without rewriting the header.
     if (writer.position > h.sector_hashtable_start) {
-      throw new Error('NTR output overlaps the fixed DSi sector hash table');
+      throw new Error("NTR output overlaps the fixed DSi sector hash table");
     }
     if (
       h.sector_hashtable_start + h.sector_hashtable_size > h.block_hashtable_start ||
@@ -246,7 +214,7 @@ export class TWL {
       h.dsi9_rom_offset + this.DSi9Data.length > h.dsi7_rom_offset ||
       h.dsi7_rom_offset + this.DSi7Data.length > h.total_rom_size
     ) {
-      throw new Error('DSi sections overlap or exceed the ROM size');
+      throw new Error("DSi sections overlap or exceed the ROM size");
     }
     const fill = (end: number): void => {
       if (writer.position < end) writer.fillTo(end, 255);
@@ -268,7 +236,7 @@ export class TWL {
     fill(h.total_rom_size);
     const finalPosition = writer.position;
     const read = (p: number, n: number): Buffer =>
-      slice(writer.buffer.subarray(0, writer.length), p, n, 'TWL output digest');
+      slice(writer.buffer.subarray(0, writer.length), p, n, "TWL output digest");
     let secure: Buffer = Buffer.from(read(h.digest_ntr_start, 0x4000));
     if (h.decrypted) secure = encryptSecureArea(h.gameCode, secure);
     let index = 0;
@@ -276,19 +244,10 @@ export class TWL {
       writer.position = h.sector_hashtable_start + index++ * 20;
       writer.write(hash(b));
     };
-    for (let p = 0; p < 0x4000; p += h.digest_sector_size)
-      put(secure.subarray(p, p + h.digest_sector_size));
-    for (
-      let p = h.digest_ntr_start + 0x4000;
-      p < h.digest_ntr_start + h.digest_ntr_size;
-      p += h.digest_sector_size
-    )
+    for (let p = 0; p < 0x4000; p += h.digest_sector_size) put(secure.subarray(p, p + h.digest_sector_size));
+    for (let p = h.digest_ntr_start + 0x4000; p < h.digest_ntr_start + h.digest_ntr_size; p += h.digest_sector_size)
       put(read(p, h.digest_sector_size));
-    for (
-      let p = h.digest_twl_start;
-      p < h.digest_twl_start + h.digest_twl_size;
-      p += h.digest_sector_size
-    )
+    for (let p = h.digest_twl_start; p < h.digest_twl_start + h.digest_twl_size; p += h.digest_sector_size)
       put(read(p, h.digest_sector_size));
     index = 0;
     for (
@@ -314,9 +273,9 @@ export const updateHeaderSignatures = (
   originalHeader: Buffer,
   keepOriginal: boolean,
 ): void => {
-  const signedData = Buffer.from(slice(originalHeader, 0, 0xe00, 'Signed header'));
-  const digest = slice(header.hmac_digest_master, 0, 20, 'Master digest');
-  const signature = slice(header.rsa_signature, 0, 128, 'RSA signature');
+  const signedData = Buffer.from(slice(originalHeader, 0, 0xe00, "Signed header"));
+  const digest = slice(header.hmac_digest_master, 0, 20, "Master digest");
+  const signature = slice(header.rsa_signature, 0, 128, "RSA signature");
   digest.copy(signedData, 0x328);
   const valid = verifyRsaSha1(signedData, signature);
   const position = writer.position;
@@ -328,7 +287,7 @@ export const updateHeaderSignatures = (
       mask[0] = 0;
       mask[1] = 1;
       mask[107] = 0;
-      hashDigest('sha1', signedData).copy(mask, 108);
+      hashDigest("sha1", signedData).copy(mask, 108);
       header.rsa_signature = mask;
     }
     writer.position = 0xf80;

package/src/nitro-helper.ts

@@ -1,14 +1,14 @@
-export { NDSFile } from './nitro/nds-file';
-export type { RomOptions, RomFileInfo } from './nitro/nds-file';
-export { Header, UnitCode } from './nitro/header';
-export { Banner } from './nitro/banner';
-export { FileAllocationTable, FileNameTable, OverlayTable } from './nitro/filesystem';
-export type { NitroFile, NitroFolder, FatEntry, OverlayItem } from './nitro/filesystem';
-export { BinaryWriter } from './nitro/binary';
-export { crc16, crc32 } from './nitro/crc';
-export { encryptSecureArea, aes128CtrCrypt, modcryptKey } from './nitro/crypto';
-export type { ModcryptHeader } from './nitro/crypto';
-export { compressBLZ, decompressBLZ, compressArm9, decompressArm9 } from './nitro/blz';
-export type { Arm9Header } from './nitro/blz';
-export { TWL, updateHeaderSignatures } from './nitro/twl';
-export type { TwlHeader, SignedTwlHeader, OverlayRange } from './nitro/twl';
+export { NDSFile } from "./nitro/nds-file";
+export type { RomFileInfo, RomOptions } from "./nitro/nds-file";
+export { Header, UnitCode } from "./nitro/header";
+export { Banner } from "./nitro/banner";
+export { FileAllocationTable, FileNameTable, OverlayTable } from "./nitro/filesystem";
+export type { FatEntry, NitroFile, NitroFolder, OverlayItem } from "./nitro/filesystem";
+export { BinaryWriter } from "./nitro/binary";
+export { crc16, crc32 } from "./nitro/crc";
+export { aes128CtrCrypt, encryptSecureArea, modcryptKey } from "./nitro/crypto";
+export type { ModcryptHeader } from "./nitro/crypto";
+export { compressArm9, compressBLZ, decompressArm9, decompressBLZ } from "./nitro/blz";
+export type { Arm9Header } from "./nitro/blz";
+export { TWL, updateHeaderSignatures } from "./nitro/twl";
+export type { OverlayRange, SignedTwlHeader, TwlHeader } from "./nitro/twl";

package/src/nitro-patch-helper.ts

@@ -1,13 +1,14 @@
 // Native TypeScript port of NitroPatchHelper/PatchHelper.cs, GPL-3.0.
-import { hashDigest, readFile } from '#nitro-runtime';
-import { bytes } from './nitro/binary';
-import { NDSFile } from './nitro/nds-file';
-import { readZip } from './patch/zip';
-import { decodeXdelta } from './patch/xdelta';
+import { hashDigest, readFile } from "#nitro-runtime";
+
+import { bytes } from "./nitro/binary";
+import { NDSFile } from "./nitro/nds-file";
+import { decodeXdelta } from "./patch/xdelta";
+import { extractZipEntry as extractEntry, readZip } from "./patch/zip";
 
 export const PatchReturnValue = Object.freeze({
-  SUCCESS: 'SUCCESS',
-  MD5_MISMATCH: 'MD5_MISMATCH',
+  SUCCESS: "SUCCESS",
+  MD5_MISMATCH: "MD5_MISMATCH",
 } as const);
 export type PatchReturnValue = (typeof PatchReturnValue)[keyof typeof PatchReturnValue];
 
@@ -41,7 +42,7 @@ export interface PatchMetadata {
 }
 
 export interface PatchReadme {
-  format: 'markdown' | 'plaintext';
+  format: "markdown" | "plaintext";
   content: string;
 }
 
@@ -50,7 +51,7 @@ export interface PatchInfo {
   readme: PatchReadme | null;
 }
 
-const md5 = (data: Uint8Array): string => hashDigest('md5', data).toString('hex');
+const md5 = (data: Uint8Array): string => hashDigest("md5", data).toString("hex");
 const invalidMetadata = (message: string): null => {
   console.warn(`忽略 metadata.json：${message}`);
   return null;
@@ -60,43 +61,46 @@ const invalidMetadataField = (field: keyof PatchMetadata, message: string): void
 };
 
 const readMetadata = (files: Map<string, Buffer>): PatchMetadata | null => {
-  const file = files.get('metadata.json');
+  const file = files.get("metadata.json");
   if (!file) return null;
 
   let metadata: unknown;
   try {
-    metadata = JSON.parse(new TextDecoder('utf-8', { fatal: true }).decode(file));
+    metadata = JSON.parse(new TextDecoder("utf-8", { fatal: true }).decode(file));
   } catch (error) {
     return invalidMetadata(
       `格式错误，可能是因为补丁包已损坏：${error instanceof Error ? error.message : String(error)}`,
     );
   }
-  if (!metadata || typeof metadata !== 'object' || Array.isArray(metadata))
-    return invalidMetadata('根节点必须是对象。');
+  if (!metadata || typeof metadata !== "object" || Array.isArray(metadata))
+    return invalidMetadata("根节点必须是对象。");
 
   const value = metadata as Record<string, unknown>;
   const result: PatchMetadata = {};
-  for (const field of ['id', 'author', 'name', 'homepage', 'version'] as const) {
-    if (typeof value[field] === 'string') result[field] = value[field];
-    else invalidMetadataField(field, '必须是字符串。');
+  for (const field of ["id", "author", "name", "homepage", "version"] as const) {
+    const fieldValue = value[field];
+    if (fieldValue === undefined) continue;
+    if (typeof fieldValue === "string") result[field] = fieldValue;
+    else invalidMetadataField(field, "必须是字符串。");
   }
-  if (typeof value.isBeta === 'boolean') result.isBeta = value.isBeta;
-  else invalidMetadataField('isBeta', '必须是布尔值。');
+  if (value.isBeta === undefined) return result;
+  if (typeof value.isBeta === "boolean") result.isBeta = value.isBeta;
+  else invalidMetadataField("isBeta", "必须是布尔值。");
 
   return result;
 };
 
 const readReadme = (files: Map<string, Buffer>): PatchReadme | null => {
   for (const [filename, format] of [
-    ['README.md', 'markdown'],
-    ['README.txt', 'plaintext'],
+    ["README.md", "markdown"],
+    ["README.txt", "plaintext"],
   ] as const) {
     const file = files.get(filename.toLowerCase());
     if (!file) continue;
     try {
       return {
         format,
-        content: new TextDecoder('utf-8', { fatal: true }).decode(file),
+        content: new TextDecoder("utf-8", { fatal: true }).decode(file),
       };
     } catch (error) {
       console.warn(
@@ -108,16 +112,12 @@ const readReadme = (files: Map<string, Buffer>): PatchReadme | null => {
 };
 
 /** Read and validate metadata.json from a NitroPatcher ZIP package. */
-export const readPatchMetadata = (
-  patch: Uint8Array,
-  options: PatchOptions = {},
-): PatchMetadata | null => readMetadata(readZip(patch, options));
+export const readPatchMetadata = (patch: Uint8Array, options: PatchOptions = {}): PatchMetadata | null =>
+  readMetadata(readZip(patch, options));
 
 /** Read a root README.md or README.txt from a NitroPatcher ZIP package. */
-export const readPatchReadme = (
-  patch: Uint8Array,
-  options: PatchOptions = {},
-): PatchReadme | null => readReadme(readZip(patch, options));
+export const readPatchReadme = (patch: Uint8Array, options: PatchOptions = {}): PatchReadme | null =>
+  readReadme(readZip(patch, options));
 
 /** Read metadata and README content while parsing the patch package only once. */
 export const readPatchInfo = (patch: Uint8Array, options: PatchOptions = {}): PatchInfo => {
@@ -125,6 +125,10 @@ export const readPatchInfo = (patch: Uint8Array, options: PatchOptions = {}): Pa
   return { metadata: readMetadata(files), readme: readReadme(files) };
 };
 
+/** Extract one file from a ZIP archive entirely in memory. */
+export const extractZipEntry = (archive: Uint8Array, entryName: string, options: PatchOptions = {}): Buffer =>
+  extractEntry(archive, entryName, options);
+
 /** Read metadata.json from a NitroPatcher ZIP package on disk. */
 export const readPatchMetadataFile = async (
   patchPath: string,
@@ -132,40 +136,29 @@ export const readPatchMetadataFile = async (
 ): Promise<PatchMetadata | null> => readPatchMetadata(await readFile(patchPath), options);
 
 /** Read a patch README from disk. */
-export const readPatchReadmeFile = async (
-  patchPath: string,
-  options: PatchOptions = {},
-): Promise<PatchReadme | null> => readPatchReadme(await readFile(patchPath), options);
+export const readPatchReadmeFile = async (patchPath: string, options: PatchOptions = {}): Promise<PatchReadme | null> =>
+  readPatchReadme(await readFile(patchPath), options);
 
 /** Read patch metadata and README content from disk. */
-export const readPatchInfoFile = async (
-  patchPath: string,
-  options: PatchOptions = {},
-): Promise<PatchInfo> => readPatchInfo(await readFile(patchPath), options);
+export const readPatchInfoFile = async (patchPath: string, options: PatchOptions = {}): Promise<PatchInfo> =>
+  readPatchInfo(await readFile(patchPath), options);
 
 /** Apply an existing NitroPatcher ZIP package entirely in memory. */
-export const patchBuffer = (
-  original: Uint8Array,
-  patch: Uint8Array,
-  options: PatchOptions = {},
-): PatchResult => {
-  const input = bytes(original, 'original ROM');
+export const patchBuffer = (original: Uint8Array, patch: Uint8Array, options: PatchOptions = {}): PatchResult => {
+  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');
+  const md5File = patches.get("md5.txt");
   if (md5File) {
     matched = false;
-    for (const line of md5File.toString('utf8').split('\n')) {
+    for (const line of md5File.toString("utf8").split("\n")) {
       const expected = line.trim();
-      if (!expected || expected.startsWith('#')) continue;
+      if (!expected || expected.startsWith("#")) continue;
       // Keep the original format contract: exactly 32 characters, case-insensitive comparison.
-      if (expected.length !== 32) throw new Error('md5.txt 格式错误，可能是因为补丁包已损坏。');
+      if (expected.length !== 32) throw new Error("md5.txt 格式错误，可能是因为补丁包已损坏。");
       if (expected.toLowerCase() === inputMd5) {
         matched = true;
         break;
@@ -173,11 +166,9 @@ export const patchBuffer = (
     }
   }
   for (const { path } of rom.listFiles()) {
-    const normalized = path.replaceAll('\\', '/').toLowerCase();
+    const normalized = path.replaceAll("\\", "/").toLowerCase();
     const delta = patches.get(`xdelta/${normalized}`);
-    const replacement = delta
-      ? decodeXdelta(rom.getFile(path), delta, options)
-      : patches.get(normalized);
+    const replacement = delta ? decodeXdelta(rom.getFile(path), delta, options) : patches.get(normalized);
     if (replacement) rom.replaceFile(path, replacement);
   }
   const buffer = rom.toBuffer();
@@ -201,6 +192,7 @@ export const patchIt = async (
 
 /** Namespaced counterpart of the original C# helper, sharing the same typed functions. */
 export const PatchHelper = Object.freeze({
+  extractZipEntry,
   patchBuffer,
   patchIt,
   readPatchInfo,
@@ -210,5 +202,5 @@ export const PatchHelper = Object.freeze({
   readPatchReadme,
   readPatchReadmeFile,
 });
-export { decodeXdelta } from './patch/xdelta';
-export type { XdeltaOptions } from './patch/xdelta';
+export { decodeXdelta } from "./patch/xdelta";
+export type { XdeltaOptions } from "./patch/xdelta";