nitro-patcher 0.2.0 → 0.2.1

package/src/patch/xdelta.ts

@@ -11,7 +11,7 @@ class Reader {
   pos = 0;
   constructor(
     readonly bytes: Buffer,
-    readonly label = 'patch',
+    readonly label = "patch",
   ) {}
   get remaining() {
     return this.bytes.length - this.pos;
@@ -31,8 +31,7 @@ class Reader {
     return fail(`invalid variable-length integer in ${this.label}`);
   }
   take(size: number): Buffer {
-    if (size > this.remaining)
-      fail(`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;
@@ -40,24 +39,28 @@ class Reader {
 }
 
 // RFC 3284 section 5.6: (operation, size, COPY address mode), up to two per opcode.
-type Operation = { type: 'ADD' | 'RUN' | 'COPY'; size: number; mode: number };
+interface Operation {
+  type: "ADD" | "RUN" | "COPY";
+  size: number;
+  mode: number;
+}
 const table: Operation[][] = [];
-const op = (type: Operation['type'], size: number, mode = 0): Operation => ({ type, size, mode });
-table.push([op('RUN', 0)]);
-for (let size = 0; size <= 17; size++) table.push([op('ADD', size)]);
+const op = (type: Operation["type"], size: number, mode = 0): Operation => ({ type, size, mode });
+table.push([op("RUN", 0)]);
+for (let size = 0; size <= 17; size++) table.push([op("ADD", size)]);
 for (let mode = 0; mode <= 8; mode++) {
-  table.push([op('COPY', 0, mode)]);
-  for (let size = 4; size <= 18; size++) table.push([op('COPY', size, mode)]);
+  table.push([op("COPY", 0, mode)]);
+  for (let size = 4; size <= 18; size++) table.push([op("COPY", size, mode)]);
 }
 for (let mode = 0; mode <= 5; mode++) {
   for (let add = 1; add <= 4; add++) {
-    for (let copy = 4; copy <= 6; copy++) table.push([op('ADD', add), op('COPY', copy, mode)]);
+    for (let copy = 4; copy <= 6; copy++) table.push([op("ADD", add), op("COPY", copy, mode)]);
   }
 }
 for (let mode = 6; mode <= 8; mode++) {
-  for (let add = 1; add <= 4; add++) table.push([op('ADD', add), op('COPY', 4, mode)]);
+  for (let add = 1; add <= 4; add++) table.push([op("ADD", add), op("COPY", 4, mode)]);
 }
-for (let mode = 0; mode <= 8; mode++) table.push([op('COPY', 4, mode), op('ADD', 1)]);
+for (let mode = 0; mode <= 8; mode++) table.push([op("COPY", 4, mode), op("ADD", 1)]);
 
 function adler32(bytes: Uint8Array): number {
   let a = 1,
@@ -96,22 +99,17 @@ export interface XdeltaOptions {
   maxWindowSize?: number;
 }
 
-export const decodeXdelta = (
-  source: Uint8Array,
-  patch: Uint8Array,
-  options: XdeltaOptions = {},
-): Buffer => {
-  const sourceBytes = asBuffer(source, 'source');
-  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([0xd6, 0xc3, 0xc4]))) fail('invalid file signature');
-  if (reader.byte() !== 0) fail('unsupported version (expected 0)');
+export const decodeXdelta = (source: Uint8Array, patch: Uint8Array, options: XdeltaOptions = {}): Buffer => {
+  const sourceBytes = asBuffer(source, "source");
+  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([0xd6, 0xc3, 0xc4]))) fail("invalid file signature");
+  if (reader.byte() !== 0) fail("unsupported version (expected 0)");
   const header = reader.byte();
-  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 & ~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: Buffer[] = [];
   let total = 0;
@@ -119,14 +117,14 @@ export const decodeXdelta = (
   while (reader.remaining) {
     const indicator = reader.byte();
     if (indicator & ~7 || (indicator & 3) === 3)
-      fail('invalid window indicator: source and target are mutually exclusive');
+      fail("invalid window indicator: source and target are mutually exclusive");
     let dictionary: Buffer = 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)
-        fail('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);
@@ -141,24 +139,22 @@ export const decodeXdelta = (
       }
     }
     const deltaLength = reader.integer();
-    const delta = new Reader(reader.take(deltaLength), 'delta window');
+    const delta = new Reader(reader.take(deltaLength), "delta window");
     const targetLength = delta.integer();
-    if (targetLength > maxWindow)
-      fail(`window size ${targetLength} exceeds maximum limit ${maxWindow}`);
+    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');
+    if (dictionary.length + targetLength > UINT32_MAX) fail("window address space exceeds 32-bit limit");
     const compressed = delta.byte();
-    if (compressed & ~7) fail('unrecognized delta indicator bits');
-    if (compressed) fail('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) fail('delta encoding length does not match section lengths');
+    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) fail("delta encoding length does not match section lengths");
     const target = Buffer.allocUnsafe(targetLength);
     const near = new Uint32Array(4),
       same = new Uint32Array(768);
@@ -169,9 +165,9 @@ export const decodeXdelta = (
       for (const { type, size: fixedSize, mode } of operations) {
         const size = fixedSize || instructions.integer();
         if (size > targetLength - position) fail(`${type} size exceeds target window length`);
-        if (type === 'ADD') {
+        if (type === "ADD") {
           data.take(size).copy(target, position);
-        } else if (type === 'RUN') {
+        } else if (type === "RUN") {
           target.fill(data.byte(), position, position + size);
         } else {
           const here = dictionary.length + position;
@@ -180,8 +176,7 @@ export const decodeXdelta = (
           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)
-            fail(`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;
@@ -195,7 +190,7 @@ export const decodeXdelta = (
           const from = Math.max(0, address - dictionary.length);
           while (copied < size) {
             const count = Math.min(size - copied, position + copied - from);
-            if (count <= 0) fail('COPY references unavailable target bytes');
+            if (count <= 0) fail("COPY references unavailable target bytes");
             target.copy(target, position + copied, from, from + count);
             copied += count;
           }
@@ -203,10 +198,9 @@ export const decodeXdelta = (
         position += size;
       }
     }
-    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');
+    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;
   }

package/src/patch/zip.ts

@@ -1,5 +1,6 @@
-import { inflateRawSync } from '#nitro-runtime';
-import { crc32 } from '../nitro/crc';
+import { inflateRawSync } from "#nitro-runtime";
+
+import { crc32 } from "../nitro/crc";
 
 /** Resource limits apply to every central-directory entry, including duplicates. */
 export interface ZipOptions {
@@ -10,22 +11,21 @@ export interface ZipOptions {
 const fail = (message: string): never => {
   throw new Error(`ZIP: ${message}`);
 };
-const utf8 = new TextDecoder('utf-8', { fatal: true });
+const utf8 = new TextDecoder("utf-8", { fatal: true });
 // IBM code page 437, byte values 0x80..0xff. ASCII bytes retain their literal values.
 const cp437 =
-  'ÇüéâäàåçêëèïîìÄÅÉæÆôöòûùÿÖÜ¢£¥₧ƒáíóúñѪº¿⌐¬½¼¡«»░▒▓│┤╡╢╖╕╣║╗╝╜╛┐└┴┬├─┼╞╟╚╔╩╦╠═╬╧╨╤╥╙╘╒╓╫╪┘┌█▄▌▐▀αßΓπΣσµτΦΘΩδ∞φε∩≡±≥≤⌠⌡÷≈°∙·√ⁿ²■ ';
+  "ÇüéâäàåçêëèïîìÄÅÉæÆôöòûùÿÖÜ¢£¥₧ƒáíóúñѪº¿⌐¬½¼¡«»░▒▓│┤╡╢╖╕╣║╗╝╜╛┐└┴┬├─┼╞╟╚╔╩╦╠═╬╧╨╤╥╙╘╒╓╫╪┘┌█▄▌▐▀αßΓπΣσµτΦΘΩδ∞φε∩≡±≥≤⌠⌡÷≈°∙·√ⁿ²■ ";
 
 function decodeUtf8(bytes: Uint8Array): string {
   try {
     return utf8.decode(bytes);
   } catch {
-    return fail('invalid UTF-8 filename');
+    return fail("invalid UTF-8 filename");
   }
 }
 function boundOption(value: number | undefined, fallback: number, label: string): number {
   value ??= fallback;
-  if (!Number.isSafeInteger(value) || value < 0)
-    throw new RangeError(`${label} must be a non-negative safe integer`);
+  if (!Number.isSafeInteger(value) || value < 0) throw new RangeError(`${label} must be a non-negative safe integer`);
   return value;
 }
 function checkRange(bytes: Buffer, offset: number, length: number, end = bytes.length): void {
@@ -41,7 +41,7 @@ function extras(bytes: Buffer): Map<number, Buffer> {
       length = bytes.readUInt16LE(offset + 2);
     offset += 4;
     checkRange(bytes, offset, length);
-    if (id === 1) fail('ZIP64 archives are unsupported');
+    if (id === 1) fail("ZIP64 archives are unsupported");
     fields.set(id, bytes.subarray(offset, offset + length));
     offset += length;
   }
@@ -52,7 +52,7 @@ function filename(raw: Buffer, flags: number, fields: Map<number, Buffer>): stri
   const unicode = fields.get(0x7075);
   if (unicode && unicode.length >= 5 && unicode[0] === 1 && unicode.readUInt32LE(1) === crc32(raw))
     return decodeUtf8(unicode.subarray(5));
-  let result = '';
+  let result = "";
   for (const byte of raw) result += byte < 128 ? String.fromCharCode(byte) : cp437[byte - 128]!;
   return result;
 }
@@ -65,26 +65,18 @@ function filename(raw: Buffer, flags: number, fields: Map<number, Buffer>): stri
  * Format reference: https://pkware.cachefly.net/webdocs/casestudies/APPNOTE.TXT
  */
 export const readZip = (input: Uint8Array, options: ZipOptions = {}): Map<string, Buffer> => {
-  if (!(input instanceof Uint8Array))
-    throw new TypeError('ZIP input must be a Buffer or Uint8Array');
+  if (!(input instanceof Uint8Array)) throw new TypeError("ZIP input must be a Buffer or Uint8Array");
   const bytes = Buffer.from(input.buffer, input.byteOffset, input.byteLength);
-  const maxSize = boundOption(
-    options.maxUncompressedSize,
-    1024 * 1024 * 1024,
-    'maxUncompressedSize',
-  );
-  const maxEntries = boundOption(options.maxEntries, 100000, 'maxEntries');
+  const maxSize = boundOption(options.maxUncompressedSize, 1024 * 1024 * 1024, "maxUncompressedSize");
+  const maxEntries = boundOption(options.maxEntries, 100000, "maxEntries");
   let eocd = -1;
   for (let offset = bytes.length - 22; offset >= Math.max(0, bytes.length - 65557); offset--) {
-    if (
-      bytes.readUInt32LE(offset) === 0x06054b50 &&
-      offset + 22 + bytes.readUInt16LE(offset + 20) === bytes.length
-    ) {
+    if (bytes.readUInt32LE(offset) === 0x06054b50 && offset + 22 + bytes.readUInt16LE(offset + 20) === bytes.length) {
       eocd = offset;
       break;
     }
   }
-  if (eocd < 0) fail('end of central directory not found or truncated');
+  if (eocd < 0) fail("end of central directory not found or truncated");
   const disk = bytes.readUInt16LE(eocd + 4),
     centralDisk = bytes.readUInt16LE(eocd + 6);
   const diskEntries = bytes.readUInt16LE(eocd + 8),
@@ -98,20 +90,19 @@ export const readZip = (input: Uint8Array, options: ZipOptions = {}): Map<string
     centralOffset === 0xffffffff ||
     (eocd >= 20 && bytes.readUInt32LE(eocd - 20) === 0x07064b50)
   )
-    fail('ZIP64 archives are unsupported');
-  if (disk || centralDisk || diskEntries !== count)
-    fail('split or multiple-disk archives are unsupported');
+    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(bytes, 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');
+  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 = new Map<string, Buffer>();
-  const ranges: Array<{ start: number; end: number }> = [];
+  const ranges: { start: number; end: number }[] = [];
   let offset = centralOffset,
     totalSize = 0;
   for (let index = 0; index < count; index++) {
     checkRange(bytes, offset, 46, eocd);
-    if (bytes.readUInt32LE(offset) !== 0x02014b50) fail('invalid central directory signature');
+    if (bytes.readUInt32LE(offset) !== 0x02014b50) fail("invalid central directory signature");
     const flags = bytes.readUInt16LE(offset + 8),
       method = bytes.readUInt16LE(offset + 10);
     const checksum = bytes.readUInt32LE(offset + 16),
@@ -122,40 +113,30 @@ export const readZip = (input: Uint8Array, options: ZipOptions = {}): Map<string
       commentLength = bytes.readUInt16LE(offset + 32);
     const startDisk = bytes.readUInt16LE(offset + 34),
       localOffset = bytes.readUInt32LE(offset + 42);
-    if (
-      size === 0xffffffff ||
-      compressedSize === 0xffffffff ||
-      localOffset === 0xffffffff ||
-      startDisk === 0xffff
-    )
-      fail('ZIP64 entry is unsupported');
-    if (startDisk) fail('split or multiple-disk entry is unsupported');
-    if (flags & 0x2041) fail('encrypted entries are unsupported');
-    if (flags & ~0x80e) fail('unsupported general purpose flags');
+    if (size === 0xffffffff || compressedSize === 0xffffffff || localOffset === 0xffffffff || startDisk === 0xffff)
+      fail("ZIP64 entry is unsupported");
+    if (startDisk) fail("split or multiple-disk entry is unsupported");
+    if (flags & 0x2041) fail("encrypted entries are unsupported");
+    if (flags & ~0x80e) 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(bytes, offset + 46, nameLength + extraLength + commentLength, eocd);
     const rawName = bytes.subarray(offset + 46, offset + 46 + nameLength);
-    const fields = extras(
-      bytes.subarray(offset + 46 + nameLength, offset + 46 + nameLength + extraLength),
-    );
-    const name = filename(rawName, flags, fields).replaceAll('\\', '/').toLowerCase();
+    const fields = extras(bytes.subarray(offset + 46 + nameLength, offset + 46 + nameLength + extraLength));
+    const name = filename(rawName, flags, fields).replaceAll("\\", "/").toLowerCase();
     offset += 46 + nameLength + extraLength + commentLength;
 
     checkRange(bytes, localOffset, 30, centralOffset);
-    if (bytes.readUInt32LE(localOffset) !== 0x04034b50) fail('invalid local header signature');
-    if (
-      bytes.readUInt16LE(localOffset + 6) !== flags ||
-      bytes.readUInt16LE(localOffset + 8) !== method
-    )
-      fail('local header flags/compression method mismatch');
+    if (bytes.readUInt32LE(localOffset) !== 0x04034b50) fail("invalid local header signature");
+    if (bytes.readUInt16LE(localOffset + 6) !== flags || bytes.readUInt16LE(localOffset + 8) !== method)
+      fail("local header flags/compression method mismatch");
     const localNameLength = bytes.readUInt16LE(localOffset + 26),
       localExtraLength = bytes.readUInt16LE(localOffset + 28);
     const dataOffset = localOffset + 30 + localNameLength + localExtraLength;
     checkRange(bytes, localOffset + 30, localNameLength + localExtraLength, centralOffset);
     if (!rawName.equals(bytes.subarray(localOffset + 30, localOffset + 30 + localNameLength)))
-      fail('local filename differs from central directory');
+      fail("local filename differs from central directory");
     extras(bytes.subarray(localOffset + 30 + localNameLength, dataOffset));
     if (
       !(flags & 8) &&
@@ -163,7 +144,7 @@ export const readZip = (input: Uint8Array, options: ZipOptions = {}): Map<string
         bytes.readUInt32LE(localOffset + 18) !== compressedSize ||
         bytes.readUInt32LE(localOffset + 22) !== size)
     )
-      fail('local header CRC/size mismatch');
+      fail("local header CRC/size mismatch");
     checkRange(bytes, dataOffset, compressedSize, centralOffset);
     let dataEnd = dataOffset + compressedSize;
     if (flags & 8) {
@@ -177,13 +158,13 @@ export const readZip = (input: Uint8Array, options: ZipOptions = {}): Map<string
         bytes.readUInt32LE(at + 8) === size;
       if (matches(dataEnd)) dataEnd += 12;
       else if (bytes.readUInt32LE(dataEnd) === 0x08074b50 && matches(dataEnd + 4)) dataEnd += 16;
-      else fail('data descriptor CRC/size mismatch');
+      else fail("data descriptor CRC/size mismatch");
     }
     ranges.push({ start: localOffset, end: dataEnd });
     const compressed = bytes.subarray(dataOffset, dataOffset + compressedSize);
     let data: Buffer;
     if (method === 0) {
-      if (compressedSize !== size) fail('stored entry compressed/uncompressed size mismatch');
+      if (compressedSize !== size) fail("stored entry compressed/uncompressed size mismatch");
       data = Buffer.from(compressed);
     } else {
       try {
@@ -196,11 +177,21 @@ export const readZip = (input: Uint8Array, options: ZipOptions = {}): Map<string
     }
     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 (name && !name.endsWith("/")) result.set(name, data);
   }
-  if (offset !== eocd) fail('central directory entry count/length mismatch');
+  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');
+    if (ranges[i]!.start < ranges[i - 1]!.end) fail("overlapping local entry ranges");
   return result;
 };
+
+/** Extract one file using the same normalized, case-insensitive paths as readZip. */
+export const extractZipEntry = (input: Uint8Array, entryName: string, options: ZipOptions = {}): Buffer => {
+  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("/")) fail(`entry ${JSON.stringify(entryName)} is a directory`);
+  const entry = readZip(input, options).get(normalized);
+  if (entry === undefined) return fail(`entry ${JSON.stringify(entryName)} not found`);
+  return entry;
+};

package/src/runtime/browser.ts

@@ -1,12 +1,11 @@
-import { md5, sha1 } from '#browser-hashes';
-import { hmac } from '#browser-hmac';
-import { ecb } from '#browser-aes';
-import { Inflate } from 'fflate';
+import { ecb } from "#browser-aes";
+import { md5, sha1 } from "#browser-hashes";
+import { hmac } from "#browser-hmac";
+import { Inflate } from "fflate";
 
-export const hashDigest = (algorithm: 'md5' | 'sha1', data: Uint8Array): Buffer =>
-  Buffer.from((algorithm === 'md5' ? md5 : sha1)(data));
-export const hmacSha1 = (key: Uint8Array, data: Uint8Array): Buffer =>
-  Buffer.from(hmac(sha1, key, data));
+export const hashDigest = (algorithm: "md5" | "sha1", data: Uint8Array): Buffer =>
+  Buffer.from((algorithm === "md5" ? md5 : sha1)(data));
+export const hmacSha1 = (key: Uint8Array, data: Uint8Array): Buffer => Buffer.from(hmac(sha1, key, data));
 export const createAesBlockCipher =
   (key: Uint8Array): ((block: Uint8Array) => Buffer) =>
   (block) =>
@@ -17,8 +16,7 @@ export const inflateRawSync = (data: Uint8Array, options: { maxOutputLength: num
   const output = Buffer.alloc(options.maxOutputLength);
   let length = 0;
   const stream = new Inflate((chunk) => {
-    if (chunk.length > output.length - length)
-      throw new RangeError('Inflated data exceeds declared size');
+    if (chunk.length > output.length - length) throw new RangeError("Inflated data exceeds declared size");
     output.set(chunk, length);
     length += chunk.length;
   });
@@ -32,7 +30,7 @@ export const inflateRawSync = (data: Uint8Array, options: { maxOutputLength: num
 // These Node-only methods are not exposed by the browser public API. Keep a
 // clear error if a future internal call accidentally crosses that boundary.
 const nodeOnly = (): never => {
-  throw new Error('Filesystem and RSA APIs are only available in the Node entry');
+  throw new Error("Filesystem and RSA APIs are only available in the Node entry");
 };
 export const readFile = nodeOnly;
 export const writeFile = nodeOnly;

package/src/runtime/node.ts

@@ -1,28 +1,27 @@
-import { createHash, createHmac, createCipheriv, createPublicKey, verify } from 'node:crypto';
-export { readFile, writeFile } from 'node:fs/promises';
-export { readFileSync } from 'node:fs';
-export { inflateRawSync } from 'node:zlib';
+import { createCipheriv, createHash, createHmac, createPublicKey, verify } from "node:crypto";
+export { readFile, writeFile } from "node:fs/promises";
+export { readFileSync } from "node:fs";
+export { inflateRawSync } from "node:zlib";
 
-export const hashDigest = (algorithm: 'md5' | 'sha1', data: Uint8Array): Buffer =>
+export const hashDigest = (algorithm: "md5" | "sha1", data: Uint8Array): Buffer =>
   createHash(algorithm).update(data).digest();
-export const hmacSha1 = (key: Uint8Array, data: Uint8Array): Buffer =>
-  createHmac('sha1', key).update(data).digest();
+export const hmacSha1 = (key: Uint8Array, data: Uint8Array): Buffer => createHmac("sha1", key).update(data).digest();
 export const createAesBlockCipher = (key: Uint8Array): ((block: Uint8Array) => Buffer) => {
-  const cipher = createCipheriv('aes-128-ecb', key, null);
+  const cipher = createCipheriv("aes-128-ecb", key, null);
   cipher.setAutoPadding(false);
   return (block) => cipher.update(block);
 };
 export const verifyRsaSha1 = (data: Uint8Array, signature: Uint8Array): boolean => {
   const key = createPublicKey({
     key: {
-      kty: 'RSA',
+      kty: "RSA",
       n: Buffer.from(
-        '956F790DF08BB85A76AAEFA27FE874758BED9EDF9E9A670CD818BEB9B2885203B3FA11AEAA186513B5D6BB85A384D0D0EFB366CBC6051AAA86827AB74311F59C9BFC6C7079D5F17BD0819F522056738C721F40CF2361932590A3C5DC94CFD17A8CBC954A918AA858F4D804BAF7D3C1C4D7B8F077012FA170260B2C049056F3A5',
-        'hex',
-      ).toString('base64url'),
-      e: 'AQAB',
+        "956F790DF08BB85A76AAEFA27FE874758BED9EDF9E9A670CD818BEB9B2885203B3FA11AEAA186513B5D6BB85A384D0D0EFB366CBC6051AAA86827AB74311F59C9BFC6C7079D5F17BD0819F522056738C721F40CF2361932590A3C5DC94CFD17A8CBC954A918AA858F4D804BAF7D3C1C4D7B8F077012FA170260B2C049056F3A5",
+        "hex",
+      ).toString("base64url"),
+      e: "AQAB",
     },
-    format: 'jwk',
+    format: "jwk",
   });
-  return verify('RSA-SHA1', data, key, signature);
+  return verify("RSA-SHA1", data, key, signature);
 };