@pixerate/editor 0.73.0 → 0.74.0

package/dist/chunk-33AHNSEB.js

@@ -0,0 +1,323 @@
+// src/import/zip.ts
+var ZipError = class extends Error {
+  code;
+  entryName;
+  constructor(code, message, details = {}) {
+    super(message, details.cause !== void 0 ? { cause: details.cause } : void 0);
+    this.name = "ZipError";
+    this.code = code;
+    this.entryName = details.entryName;
+  }
+};
+var DEFAULT_ZIP_MAX_ENTRIES = 1e4;
+var DEFAULT_ZIP_MAX_TOTAL_SIZE = 256 * 1024 * 1024;
+var SIG_EOCD = 101010256;
+var SIG_ZIP64_EOCD = 101075792;
+var SIG_ZIP64_LOCATOR = 117853008;
+var SIG_CENTRAL = 33639248;
+var SIG_LOCAL = 67324752;
+var EOCD_SIZE = 22;
+var MAX_COMMENT = 65535;
+var crcTable = null;
+function zipCrc32(data) {
+  if (!crcTable) {
+    crcTable = new Uint32Array(256);
+    for (let n = 0; n < 256; n++) {
+      let c = n;
+      for (let k = 0; k < 8; k++) c = c & 1 ? 3988292384 ^ c >>> 1 : c >>> 1;
+      crcTable[n] = c >>> 0;
+    }
+  }
+  let crc = 4294967295;
+  for (let i = 0; i < data.length; i++) crc = crcTable[(crc ^ data[i]) & 255] ^ crc >>> 8;
+  return (crc ^ 4294967295) >>> 0;
+}
+function toBytes(data) {
+  if (ArrayBuffer.isView(data)) return new Uint8Array(data.buffer, data.byteOffset, data.byteLength);
+  return new Uint8Array(data);
+}
+function isUnsafeZipPath(name) {
+  if (!name || name.includes("\0")) return true;
+  const normalized = name.replace(/\\/g, "/");
+  if (normalized.startsWith("/") || /^[a-zA-Z]:/.test(normalized)) return true;
+  return normalized.split("/").some((segment) => segment === "..");
+}
+var utf8 = new TextDecoder("utf-8");
+var CP437_HIGH = "\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 decodeName(bytes, isUtf8) {
+  if (isUtf8 || bytes.every((b) => b < 128)) return utf8.decode(bytes);
+  let out = "";
+  for (const b of bytes) out += b < 128 ? String.fromCharCode(b) : CP437_HIGH[b - 128];
+  return out;
+}
+var ZipArchive = class {
+  constructor(bytes, entries, maxTotalSize) {
+    this.bytes = bytes;
+    this.maxTotalSize = maxTotalSize;
+    this.entries = entries;
+    entries.forEach((entry) => {
+      if (!this.byName.has(entry.name)) this.byName.set(entry.name, entry);
+    });
+  }
+  bytes;
+  maxTotalSize;
+  /** Entries in central-directory order. */
+  entries;
+  byName = /* @__PURE__ */ new Map();
+  extracted = 0;
+  /** Looks up an entry by exact name (a leading `/` is ignored). */
+  get(name) {
+    return this.byName.get(name.replace(/^\/+/, ""));
+  }
+  has(name) {
+    return !!this.get(name);
+  }
+  /** Uncompressed bytes extracted so far (counted against `maxTotalSize`). */
+  get extractedSize() {
+    return this.extracted;
+  }
+  /** Extracts an entry's data, verifying its size and CRC-32. */
+  async read(entryOrName) {
+    const entry = typeof entryOrName === "string" ? this.get(entryOrName) : entryOrName;
+    if (!entry) {
+      throw new ZipError("entry_not_found", `ZIP entry "${String(entryOrName)}" not found.`, {
+        entryName: String(entryOrName)
+      });
+    }
+    const name = entry.name;
+    if (entry.encrypted) {
+      throw new ZipError("encrypted", `ZIP entry "${name}" is encrypted; encrypted archives are not supported.`, {
+        entryName: name
+      });
+    }
+    if (entry.isDirectory) return new Uint8Array(0);
+    const remaining = this.maxTotalSize - this.extracted;
+    if (entry.size > remaining) {
+      throw new ZipError(
+        "too_large",
+        `Extracting "${name}" (${entry.size} bytes) would exceed the ${this.maxTotalSize}-byte limit.`,
+        { entryName: name }
+      );
+    }
+    const { bytes } = this;
+    const offset = entry.localHeaderOffset;
+    if (offset + 30 > bytes.length || readU32(bytes, offset) !== SIG_LOCAL) {
+      throw new ZipError("corrupt_entry", `ZIP entry "${name}" has no valid local header.`, { entryName: name });
+    }
+    const dataStart = offset + 30 + readU16(bytes, offset + 26) + readU16(bytes, offset + 28);
+    const dataEnd = dataStart + entry.compressedSize;
+    if (dataEnd > bytes.length) {
+      throw new ZipError("corrupt_entry", `ZIP entry "${name}" is truncated.`, { entryName: name });
+    }
+    const raw = bytes.subarray(dataStart, dataEnd);
+    let data;
+    if (entry.method === 0) {
+      if (entry.compressedSize !== entry.size) {
+        throw new ZipError("corrupt_entry", `Stored ZIP entry "${name}" has inconsistent sizes.`, { entryName: name });
+      }
+      data = raw.slice();
+    } else if (entry.method === 8) {
+      data = await inflateRaw(raw, entry.size, name);
+    } else {
+      throw new ZipError(
+        "unsupported_feature",
+        `ZIP entry "${name}" uses unsupported compression method ${entry.method}; only stored and deflate are supported.`,
+        { entryName: name }
+      );
+    }
+    if (data.length !== entry.size) {
+      throw new ZipError("corrupt_entry", `ZIP entry "${name}" size does not match the directory.`, { entryName: name });
+    }
+    this.extracted += data.length;
+    if (zipCrc32(data) !== entry.crc32) {
+      throw new ZipError("corrupt_entry", `ZIP entry "${name}" failed its CRC-32 check.`, { entryName: name });
+    }
+    return data;
+  }
+  /** Extracts an entry and decodes it as UTF-8 (a leading BOM is removed). */
+  async readText(entryOrName) {
+    const text = utf8.decode(await this.read(entryOrName));
+    return text.charCodeAt(0) === 65279 ? text.slice(1) : text;
+  }
+};
+function readU16(bytes, offset) {
+  return bytes[offset] | bytes[offset + 1] << 8;
+}
+function readU32(bytes, offset) {
+  return (bytes[offset] | bytes[offset + 1] << 8 | bytes[offset + 2] << 16 | bytes[offset + 3] << 24) >>> 0;
+}
+function readU64(bytes, offset) {
+  const value = readU32(bytes, offset) + readU32(bytes, offset + 4) * 4294967296;
+  if (!Number.isSafeInteger(value)) {
+    throw new ZipError("unsupported_feature", "ZIP64 value exceeds the supported range.");
+  }
+  return value;
+}
+async function inflateRaw(raw, limit, entryName) {
+  const Stream = globalThis.DecompressionStream;
+  if (typeof Stream !== "function") {
+    throw new ZipError(
+      "unsupported_environment",
+      "Inflating ZIP entries needs DecompressionStream (modern browsers, Node 18+).",
+      { entryName }
+    );
+  }
+  const stream = new Stream("deflate-raw");
+  const writer = stream.writable.getWriter();
+  const reader = stream.readable.getReader();
+  const CHUNK = 64 * 1024;
+  const feeding = (async () => {
+    for (let i = 0; i < raw.length; i += CHUNK) await writer.write(raw.subarray(i, i + CHUNK));
+    await writer.close();
+  })();
+  feeding.catch(() => {
+  });
+  const chunks = [];
+  let total = 0;
+  try {
+    for (; ; ) {
+      const { done, value } = await reader.read();
+      if (done) break;
+      total += value.length;
+      if (total > limit) {
+        throw new ZipError(
+          "corrupt_entry",
+          `ZIP entry "${entryName}" inflates beyond its declared size of ${limit} bytes.`,
+          { entryName }
+        );
+      }
+      chunks.push(value);
+    }
+  } catch (error) {
+    reader.cancel().catch(() => {
+    });
+    writer.abort().catch(() => {
+    });
+    if (error instanceof ZipError) throw error;
+    throw new ZipError("corrupt_entry", `ZIP entry "${entryName}" has an invalid deflate stream.`, {
+      entryName,
+      cause: error
+    });
+  }
+  await feeding.catch(() => {
+  });
+  const out = new Uint8Array(total);
+  let pos = 0;
+  for (const chunk of chunks) {
+    out.set(chunk, pos);
+    pos += chunk.length;
+  }
+  return out;
+}
+function findEndOfCentralDirectory(bytes) {
+  const min = Math.max(0, bytes.length - EOCD_SIZE - MAX_COMMENT);
+  for (let i = bytes.length - EOCD_SIZE; i >= min; i--) {
+    if (readU32(bytes, i) === SIG_EOCD && i + EOCD_SIZE + readU16(bytes, i + 20) <= bytes.length) return i;
+  }
+  return -1;
+}
+async function readZip(data, options = {}) {
+  const bytes = toBytes(data);
+  const maxEntries = options.maxEntries ?? DEFAULT_ZIP_MAX_ENTRIES;
+  const maxTotalSize = options.maxTotalSize ?? DEFAULT_ZIP_MAX_TOTAL_SIZE;
+  const eocd = findEndOfCentralDirectory(bytes);
+  if (eocd < 0) throw new ZipError("invalid_archive", "Not a ZIP archive (no end of central directory record).");
+  let diskNumber = readU16(bytes, eocd + 4);
+  let cdDisk = readU16(bytes, eocd + 6);
+  let count = readU16(bytes, eocd + 10);
+  let cdSize = readU32(bytes, eocd + 12);
+  let cdOffset = readU32(bytes, eocd + 16);
+  if (count === 65535 || cdSize === 4294967295 || cdOffset === 4294967295) {
+    const locator = eocd - 20;
+    if (locator < 0 || readU32(bytes, locator) !== SIG_ZIP64_LOCATOR) {
+      throw new ZipError("invalid_archive", "ZIP64 archive is missing its end of central directory locator.");
+    }
+    const record = readU64(bytes, locator + 8);
+    if (record + 56 > bytes.length || readU32(bytes, record) !== SIG_ZIP64_EOCD) {
+      throw new ZipError("invalid_archive", "ZIP64 end of central directory record not found.");
+    }
+    diskNumber = readU32(bytes, record + 16);
+    cdDisk = readU32(bytes, record + 20);
+    count = readU64(bytes, record + 32);
+    cdSize = readU64(bytes, record + 40);
+    cdOffset = readU64(bytes, record + 48);
+  }
+  if (diskNumber !== 0 || cdDisk !== 0) {
+    throw new ZipError("unsupported_feature", "Multi-disk (spanned) ZIP archives are not supported.");
+  }
+  if (count > maxEntries) {
+    throw new ZipError("too_many_entries", `ZIP archive has ${count} entries; the limit is ${maxEntries}.`);
+  }
+  if (cdOffset + cdSize > bytes.length) {
+    throw new ZipError("invalid_archive", "ZIP central directory lies outside the file.");
+  }
+  const entries = [];
+  let p = cdOffset;
+  for (let i = 0; i < count; i++) {
+    if (p + 46 > bytes.length || readU32(bytes, p) !== SIG_CENTRAL) {
+      throw new ZipError("invalid_archive", "ZIP central directory is corrupt.");
+    }
+    const flags = readU16(bytes, p + 8);
+    const method = readU16(bytes, p + 10);
+    const crc32 = readU32(bytes, p + 16);
+    let compressedSize = readU32(bytes, p + 20);
+    let size = readU32(bytes, p + 24);
+    const nameLength = readU16(bytes, p + 28);
+    const extraLength = readU16(bytes, p + 30);
+    const commentLength = readU16(bytes, p + 32);
+    let localHeaderOffset = readU32(bytes, p + 42);
+    const nameStart = p + 46;
+    const extraStart = nameStart + nameLength;
+    const next = extraStart + extraLength + commentLength;
+    if (next > bytes.length) throw new ZipError("invalid_archive", "ZIP central directory is truncated.");
+    for (let e = extraStart; e + 4 <= extraStart + extraLength; ) {
+      const id = readU16(bytes, e);
+      const len = readU16(bytes, e + 2);
+      if (id === 1) {
+        let f = e + 4;
+        const end = f + len;
+        if (size === 4294967295 && f + 8 <= end) {
+          size = readU64(bytes, f);
+          f += 8;
+        }
+        if (compressedSize === 4294967295 && f + 8 <= end) {
+          compressedSize = readU64(bytes, f);
+          f += 8;
+        }
+        if (localHeaderOffset === 4294967295 && f + 8 <= end) localHeaderOffset = readU64(bytes, f);
+      }
+      e += 4 + len;
+    }
+    const rawName = decodeName(bytes.subarray(nameStart, extraStart), (flags & 2048) !== 0);
+    const name = rawName.replace(/\\/g, "/");
+    p = next;
+    if (isUnsafeZipPath(rawName)) {
+      if (options.unsafePaths === "skip") continue;
+      throw new ZipError("unsafe_path", `ZIP entry name "${rawName}" is absolute or escapes the archive root.`, {
+        entryName: rawName
+      });
+    }
+    entries.push({
+      name,
+      isDirectory: name.endsWith("/"),
+      encrypted: (flags & 1) !== 0,
+      method,
+      compressedSize,
+      size,
+      crc32,
+      localHeaderOffset
+    });
+  }
+  return new ZipArchive(bytes, entries, maxTotalSize);
+}
+
+export {
+  ZipError,
+  DEFAULT_ZIP_MAX_ENTRIES,
+  DEFAULT_ZIP_MAX_TOTAL_SIZE,
+  zipCrc32,
+  isUnsafeZipPath,
+  ZipArchive,
+  readZip
+};
+//# sourceMappingURL=chunk-33AHNSEB.js.map

package/dist/chunk-33AHNSEB.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/import/zip.ts"],"sourcesContent":["/**\n * Minimal, dependency-free ZIP reader used by the DOCX and zipped-export\n * import adapters.\n *\n * - Reads the central directory (including ZIP64 end records and extra\n *   fields), so sizes come from the authoritative directory rather than local\n *   headers or data descriptors.\n * - Supports stored (method 0) and deflate (method 8) entries; deflate is\n *   inflated with the platform `DecompressionStream(\"deflate-raw\")` (modern\n *   browsers, Node ≥ 18).\n * - Guards against zip bombs (entry-count and total-uncompressed-size caps,\n *   enforced on the bytes actually inflated, not only the declared sizes),\n *   path traversal in entry names and encrypted entries.\n * - Verifies CRC-32 checksums of extracted entries.\n */\n\nexport type ZipErrorCode =\n  /** Not a ZIP archive, or its directory is truncated / inconsistent. */\n  | \"invalid_archive\"\n  /** Compression method other than stored/deflate, multi-disk archives, … */\n  | \"unsupported_feature\"\n  /** The entry is encrypted (general-purpose flag bit 0). */\n  | \"encrypted\"\n  /** An entry name is absolute or contains `..` segments. */\n  | \"unsafe_path\"\n  /** More entries than `maxEntries`. */\n  | \"too_many_entries\"\n  /** Extracting would exceed `maxTotalSize` uncompressed bytes. */\n  | \"too_large\"\n  /** The entry data is corrupt (bad header, size or CRC mismatch, bad deflate stream). */\n  | \"corrupt_entry\"\n  /** No entry with the requested name. */\n  | \"entry_not_found\"\n  /** `DecompressionStream` is unavailable in this environment. */\n  | \"unsupported_environment\";\n\nexport class ZipError extends Error {\n  readonly code: ZipErrorCode;\n  readonly entryName?: string;\n\n  constructor(code: ZipErrorCode, message: string, details: { entryName?: string; cause?: unknown } = {}) {\n    super(message, details.cause !== undefined ? { cause: details.cause } : undefined);\n    this.name = \"ZipError\";\n    this.code = code;\n    this.entryName = details.entryName;\n  }\n}\n\nexport interface ZipEntry {\n  /** Entry path with `/` separators (backslashes are normalized). */\n  name: string;\n  /** Whether the entry is a directory (name ends with `/`). */\n  isDirectory: boolean;\n  /** Whether the entry is encrypted; reading it throws `ZipError(\"encrypted\")`. */\n  encrypted: boolean;\n  /** Compression method (0 = stored, 8 = deflate). */\n  method: number;\n  /** Declared compressed size in bytes. */\n  compressedSize: number;\n  /** Declared uncompressed size in bytes. */\n  size: number;\n  /** CRC-32 of the uncompressed data. */\n  crc32: number;\n  /** Offset of the entry's local file header. */\n  localHeaderOffset: number;\n}\n\nexport interface ZipReadOptions {\n  /** Maximum number of entries in the central directory (default 10 000). */\n  maxEntries?: number;\n  /**\n   * Maximum number of uncompressed bytes extracted from the archive, summed\n   * over every `read` call (default 256 MiB). Enforced while inflating.\n   */\n  maxTotalSize?: number;\n  /**\n   * What to do with entries whose names are absolute or contain `..`\n   * segments: `\"error\"` (default) rejects the archive, `\"skip\"` leaves them\n   * out of `entries`.\n   */\n  unsafePaths?: \"error\" | \"skip\";\n}\n\nexport const DEFAULT_ZIP_MAX_ENTRIES = 10_000;\nexport const DEFAULT_ZIP_MAX_TOTAL_SIZE = 256 * 1024 * 1024;\n\nconst SIG_EOCD = 0x06054b50;\nconst SIG_ZIP64_EOCD = 0x06064b50;\nconst SIG_ZIP64_LOCATOR = 0x07064b50;\nconst SIG_CENTRAL = 0x02014b50;\nconst SIG_LOCAL = 0x04034b50;\nconst EOCD_SIZE = 22;\nconst MAX_COMMENT = 0xffff;\n\nlet crcTable: Uint32Array | null = null;\n\n/** CRC-32 (IEEE 802.3), as used by ZIP. */\nexport function zipCrc32(data: Uint8Array): number {\n  if (!crcTable) {\n    crcTable = new Uint32Array(256);\n    for (let n = 0; n < 256; n++) {\n      let c = n;\n      for (let k = 0; k < 8; k++) c = c & 1 ? 0xedb88320 ^ (c >>> 1) : c >>> 1;\n      crcTable[n] = c >>> 0;\n    }\n  }\n  let crc = 0xffffffff;\n  for (let i = 0; i < data.length; i++) crc = crcTable[(crc ^ data[i]) & 0xff] ^ (crc >>> 8);\n  return (crc ^ 0xffffffff) >>> 0;\n}\n\nfunction toBytes(data: ArrayBuffer | ArrayBufferView): Uint8Array {\n  // Duck-typed so ArrayBuffers from other realms (iframes, jsdom) work too.\n  if (ArrayBuffer.isView(data)) return new Uint8Array(data.buffer, data.byteOffset, data.byteLength);\n  return new Uint8Array(data as ArrayBuffer);\n}\n\n/** Whether `name` is absolute, has a drive letter, or contains `..` / NUL. */\nexport function isUnsafeZipPath(name: string): boolean {\n  if (!name || name.includes(\"\\0\")) return true;\n  const normalized = name.replace(/\\\\/g, \"/\");\n  if (normalized.startsWith(\"/\") || /^[a-zA-Z]:/.test(normalized)) return true;\n  return normalized.split(\"/\").some((segment) => segment === \"..\");\n}\n\nconst utf8 = new TextDecoder(\"utf-8\");\n\n/** CP437 high half, used for names without the UTF-8 flag. */\nconst CP437_HIGH =\n  \"ÇüéâäàåçêëèïîìÄÅÉæÆôöòûùÿÖÜ¢£¥₧ƒáíóúñѪº¿⌐¬½¼¡«»░▒▓│┤╡╢╖╕╣║╗╝╜╛┐└┴┬├─┼╞╟╚╔╩╦╠═╬╧╨╤╥╙╘╒╓╫╪┘┌█▄▌▐▀αßΓπΣσµτΦΘΩδ∞φε∩≡±≥≤⌠⌡÷≈°∙·√ⁿ²■ \";\n\nfunction decodeName(bytes: Uint8Array, isUtf8: boolean): string {\n  if (isUtf8 || bytes.every((b) => b < 0x80)) return utf8.decode(bytes);\n  let out = \"\";\n  for (const b of bytes) out += b < 0x80 ? String.fromCharCode(b) : CP437_HIGH[b - 0x80];\n  return out;\n}\n\n/**\n * A parsed ZIP archive. Entry data is extracted lazily with {@link read}.\n * Create it with {@link readZip}.\n */\nexport class ZipArchive {\n  /** Entries in central-directory order. */\n  readonly entries: readonly ZipEntry[];\n  private readonly byName = new Map<string, ZipEntry>();\n  private extracted = 0;\n\n  constructor(\n    private readonly bytes: Uint8Array,\n    entries: ZipEntry[],\n    private readonly maxTotalSize: number,\n  ) {\n    this.entries = entries;\n    entries.forEach((entry) => {\n      if (!this.byName.has(entry.name)) this.byName.set(entry.name, entry);\n    });\n  }\n\n  /** Looks up an entry by exact name (a leading `/` is ignored). */\n  get(name: string): ZipEntry | undefined {\n    return this.byName.get(name.replace(/^\\/+/, \"\"));\n  }\n\n  has(name: string): boolean {\n    return !!this.get(name);\n  }\n\n  /** Uncompressed bytes extracted so far (counted against `maxTotalSize`). */\n  get extractedSize(): number {\n    return this.extracted;\n  }\n\n  /** Extracts an entry's data, verifying its size and CRC-32. */\n  async read(entryOrName: ZipEntry | string): Promise<Uint8Array> {\n    const entry = typeof entryOrName === \"string\" ? this.get(entryOrName) : entryOrName;\n    if (!entry) {\n      throw new ZipError(\"entry_not_found\", `ZIP entry \"${String(entryOrName)}\" not found.`, {\n        entryName: String(entryOrName),\n      });\n    }\n    const name = entry.name;\n    if (entry.encrypted) {\n      throw new ZipError(\"encrypted\", `ZIP entry \"${name}\" is encrypted; encrypted archives are not supported.`, {\n        entryName: name,\n      });\n    }\n    if (entry.isDirectory) return new Uint8Array(0);\n    const remaining = this.maxTotalSize - this.extracted;\n    if (entry.size > remaining) {\n      throw new ZipError(\n        \"too_large\",\n        `Extracting \"${name}\" (${entry.size} bytes) would exceed the ${this.maxTotalSize}-byte limit.`,\n        { entryName: name },\n      );\n    }\n\n    const { bytes } = this;\n    const offset = entry.localHeaderOffset;\n    if (offset + 30 > bytes.length || readU32(bytes, offset) !== SIG_LOCAL) {\n      throw new ZipError(\"corrupt_entry\", `ZIP entry \"${name}\" has no valid local header.`, { entryName: name });\n    }\n    const dataStart = offset + 30 + readU16(bytes, offset + 26) + readU16(bytes, offset + 28);\n    const dataEnd = dataStart + entry.compressedSize;\n    if (dataEnd > bytes.length) {\n      throw new ZipError(\"corrupt_entry\", `ZIP entry \"${name}\" is truncated.`, { entryName: name });\n    }\n    const raw = bytes.subarray(dataStart, dataEnd);\n\n    let data: Uint8Array;\n    if (entry.method === 0) {\n      if (entry.compressedSize !== entry.size) {\n        throw new ZipError(\"corrupt_entry\", `Stored ZIP entry \"${name}\" has inconsistent sizes.`, { entryName: name });\n      }\n      data = raw.slice();\n    } else if (entry.method === 8) {\n      // Cap at the declared size: more output means a lying header (or a bomb).\n      data = await inflateRaw(raw, entry.size, name);\n    } else {\n      throw new ZipError(\n        \"unsupported_feature\",\n        `ZIP entry \"${name}\" uses unsupported compression method ${entry.method}; only stored and deflate are supported.`,\n        { entryName: name },\n      );\n    }\n    if (data.length !== entry.size) {\n      throw new ZipError(\"corrupt_entry\", `ZIP entry \"${name}\" size does not match the directory.`, { entryName: name });\n    }\n    this.extracted += data.length;\n    if (zipCrc32(data) !== entry.crc32) {\n      throw new ZipError(\"corrupt_entry\", `ZIP entry \"${name}\" failed its CRC-32 check.`, { entryName: name });\n    }\n    return data;\n  }\n\n  /** Extracts an entry and decodes it as UTF-8 (a leading BOM is removed). */\n  async readText(entryOrName: ZipEntry | string): Promise<string> {\n    const text = utf8.decode(await this.read(entryOrName));\n    return text.charCodeAt(0) === 0xfeff ? text.slice(1) : text;\n  }\n}\n\nfunction readU16(bytes: Uint8Array, offset: number): number {\n  return bytes[offset] | (bytes[offset + 1] << 8);\n}\n\nfunction readU32(bytes: Uint8Array, offset: number): number {\n  return (bytes[offset] | (bytes[offset + 1] << 8) | (bytes[offset + 2] << 16) | (bytes[offset + 3] << 24)) >>> 0;\n}\n\nfunction readU64(bytes: Uint8Array, offset: number): number {\n  const value = readU32(bytes, offset) + readU32(bytes, offset + 4) * 0x100000000;\n  if (!Number.isSafeInteger(value)) {\n    throw new ZipError(\"unsupported_feature\", \"ZIP64 value exceeds the supported range.\");\n  }\n  return value;\n}\n\n/** Inflates a raw deflate stream, failing as soon as output exceeds `limit` bytes. */\nasync function inflateRaw(raw: Uint8Array, limit: number, entryName: string): Promise<Uint8Array> {\n  const Stream: typeof DecompressionStream | undefined = (globalThis as any).DecompressionStream;\n  if (typeof Stream !== \"function\") {\n    throw new ZipError(\n      \"unsupported_environment\",\n      \"Inflating ZIP entries needs DecompressionStream (modern browsers, Node 18+).\",\n      { entryName },\n    );\n  }\n  const stream = new Stream(\"deflate-raw\");\n  const writer = stream.writable.getWriter();\n  const reader = stream.readable.getReader();\n  // Feed the input in slices so output is pulled (and checked) incrementally.\n  const CHUNK = 64 * 1024;\n  const feeding = (async () => {\n    for (let i = 0; i < raw.length; i += CHUNK) await writer.write(raw.subarray(i, i + CHUNK) as unknown as BufferSource);\n    await writer.close();\n  })();\n  feeding.catch(() => {});\n\n  const chunks: Uint8Array[] = [];\n  let total = 0;\n  try {\n    for (;;) {\n      const { done, value } = await reader.read();\n      if (done) break;\n      total += value.length;\n      if (total > limit) {\n        throw new ZipError(\n          \"corrupt_entry\",\n          `ZIP entry \"${entryName}\" inflates beyond its declared size of ${limit} bytes.`,\n          { entryName },\n        );\n      }\n      chunks.push(value);\n    }\n  } catch (error) {\n    reader.cancel().catch(() => {});\n    writer.abort().catch(() => {});\n    if (error instanceof ZipError) throw error;\n    throw new ZipError(\"corrupt_entry\", `ZIP entry \"${entryName}\" has an invalid deflate stream.`, {\n      entryName,\n      cause: error,\n    });\n  }\n  await feeding.catch(() => {});\n  const out = new Uint8Array(total);\n  let pos = 0;\n  for (const chunk of chunks) {\n    out.set(chunk, pos);\n    pos += chunk.length;\n  }\n  return out;\n}\n\nfunction findEndOfCentralDirectory(bytes: Uint8Array): number {\n  const min = Math.max(0, bytes.length - EOCD_SIZE - MAX_COMMENT);\n  for (let i = bytes.length - EOCD_SIZE; i >= min; i--) {\n    if (readU32(bytes, i) === SIG_EOCD && i + EOCD_SIZE + readU16(bytes, i + 20) <= bytes.length) return i;\n  }\n  return -1;\n}\n\n/**\n * Parses a ZIP archive's central directory. Entry data is not extracted until\n * {@link ZipArchive.read} is called. Throws {@link ZipError}.\n */\nexport async function readZip(data: ArrayBuffer | ArrayBufferView, options: ZipReadOptions = {}): Promise<ZipArchive> {\n  const bytes = toBytes(data);\n  const maxEntries = options.maxEntries ?? DEFAULT_ZIP_MAX_ENTRIES;\n  const maxTotalSize = options.maxTotalSize ?? DEFAULT_ZIP_MAX_TOTAL_SIZE;\n\n  const eocd = findEndOfCentralDirectory(bytes);\n  if (eocd < 0) throw new ZipError(\"invalid_archive\", \"Not a ZIP archive (no end of central directory record).\");\n\n  let diskNumber = readU16(bytes, eocd + 4);\n  let cdDisk = readU16(bytes, eocd + 6);\n  let count = readU16(bytes, eocd + 10);\n  let cdSize = readU32(bytes, eocd + 12);\n  let cdOffset = readU32(bytes, eocd + 16);\n\n  if (count === 0xffff || cdSize === 0xffffffff || cdOffset === 0xffffffff) {\n    const locator = eocd - 20;\n    if (locator < 0 || readU32(bytes, locator) !== SIG_ZIP64_LOCATOR) {\n      throw new ZipError(\"invalid_archive\", \"ZIP64 archive is missing its end of central directory locator.\");\n    }\n    const record = readU64(bytes, locator + 8);\n    if (record + 56 > bytes.length || readU32(bytes, record) !== SIG_ZIP64_EOCD) {\n      throw new ZipError(\"invalid_archive\", \"ZIP64 end of central directory record not found.\");\n    }\n    diskNumber = readU32(bytes, record + 16);\n    cdDisk = readU32(bytes, record + 20);\n    count = readU64(bytes, record + 32);\n    cdSize = readU64(bytes, record + 40);\n    cdOffset = readU64(bytes, record + 48);\n  }\n  if (diskNumber !== 0 || cdDisk !== 0) {\n    throw new ZipError(\"unsupported_feature\", \"Multi-disk (spanned) ZIP archives are not supported.\");\n  }\n  if (count > maxEntries) {\n    throw new ZipError(\"too_many_entries\", `ZIP archive has ${count} entries; the limit is ${maxEntries}.`);\n  }\n  if (cdOffset + cdSize > bytes.length) {\n    throw new ZipError(\"invalid_archive\", \"ZIP central directory lies outside the file.\");\n  }\n\n  const entries: ZipEntry[] = [];\n  let p = cdOffset;\n  for (let i = 0; i < count; i++) {\n    if (p + 46 > bytes.length || readU32(bytes, p) !== SIG_CENTRAL) {\n      throw new ZipError(\"invalid_archive\", \"ZIP central directory is corrupt.\");\n    }\n    const flags = readU16(bytes, p + 8);\n    const method = readU16(bytes, p + 10);\n    const crc32 = readU32(bytes, p + 16);\n    let compressedSize = readU32(bytes, p + 20);\n    let size = readU32(bytes, p + 24);\n    const nameLength = readU16(bytes, p + 28);\n    const extraLength = readU16(bytes, p + 30);\n    const commentLength = readU16(bytes, p + 32);\n    let localHeaderOffset = readU32(bytes, p + 42);\n    const nameStart = p + 46;\n    const extraStart = nameStart + nameLength;\n    const next = extraStart + extraLength + commentLength;\n    if (next > bytes.length) throw new ZipError(\"invalid_archive\", \"ZIP central directory is truncated.\");\n\n    // ZIP64 extended information: only the fields that overflowed are present, in order.\n    for (let e = extraStart; e + 4 <= extraStart + extraLength; ) {\n      const id = readU16(bytes, e);\n      const len = readU16(bytes, e + 2);\n      if (id === 0x0001) {\n        let f = e + 4;\n        const end = f + len;\n        if (size === 0xffffffff && f + 8 <= end) {\n          size = readU64(bytes, f);\n          f += 8;\n        }\n        if (compressedSize === 0xffffffff && f + 8 <= end) {\n          compressedSize = readU64(bytes, f);\n          f += 8;\n        }\n        if (localHeaderOffset === 0xffffffff && f + 8 <= end) localHeaderOffset = readU64(bytes, f);\n      }\n      e += 4 + len;\n    }\n\n    const rawName = decodeName(bytes.subarray(nameStart, extraStart), (flags & 0x0800) !== 0);\n    const name = rawName.replace(/\\\\/g, \"/\");\n    p = next;\n    if (isUnsafeZipPath(rawName)) {\n      if (options.unsafePaths === \"skip\") continue;\n      throw new ZipError(\"unsafe_path\", `ZIP entry name \"${rawName}\" is absolute or escapes the archive root.`, {\n        entryName: rawName,\n      });\n    }\n    entries.push({\n      name,\n      isDirectory: name.endsWith(\"/\"),\n      encrypted: (flags & 0x0001) !== 0,\n      method,\n      compressedSize,\n      size,\n      crc32,\n      localHeaderOffset,\n    });\n  }\n  return new ZipArchive(bytes, entries, maxTotalSize);\n}\n"],"mappings":"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","names":[]}