@bendyline/squisq-formats 1.4.2 → 2.0.1

package/dist/chunk-FE6OJV6O.js

@@ -0,0 +1,560 @@
+// src/shared/zipLimits.ts
+var ZipSafetyError = class extends Error {
+  constructor(code, message, options = {}) {
+    super(message);
+    this.name = "ZipSafetyError";
+    this.code = code;
+    this.path = options.path;
+    this.limit = options.limit;
+    this.actual = options.actual;
+    if (options.cause !== void 0) {
+      this.cause = options.cause;
+    }
+  }
+};
+var DEFAULT_MAX_ZIP_ENTRIES = 1e4;
+var DEFAULT_MAX_ZIP_UNCOMPRESSED_BYTES = 512 * 1024 * 1024;
+var DEFAULT_MAX_ZIP_COMPRESSION_RATIO = 1e3;
+function validateZipArchive(zip, limits = {}) {
+  throwIfZipAborted(limits.signal);
+  const resolved = resolveZipSafetyLimits(limits);
+  const files = [];
+  let memberCount = 0;
+  let declaredTotal = 0;
+  let oversizedEntry;
+  zip.forEach((relativePath, entry) => {
+    throwIfZipAborted(limits.signal);
+    memberCount++;
+    if (entry.dir) return;
+    const originalPath = originalEntryPath(entry, relativePath);
+    if (!isSafeArchivePath(originalPath)) {
+      throw new ZipSafetyError(
+        "unsafe-path",
+        `ZIP import: archive contains an unsafe path: ${originalPath}.`,
+        { path: originalPath }
+      );
+    }
+    const metadata = compressedMetadata(entry, originalPath);
+    if (metadata.uncompressedSize !== void 0 && metadata.uncompressedSize > resolved.maxEntryUncompressedBytes) {
+      oversizedEntry ?? (oversizedEntry = {
+        path: originalPath,
+        actual: metadata.uncompressedSize,
+        limit: resolved.maxEntryUncompressedBytes
+      });
+    }
+    const ratio = metadata.uncompressedSize === void 0 || metadata.compressedSize === void 0 ? void 0 : compressionRatio(metadata.uncompressedSize, metadata.compressedSize);
+    if (ratio !== void 0 && ratio > resolved.maxCompressionRatio) {
+      throw compressionRatioError(originalPath, ratio, resolved.maxCompressionRatio);
+    }
+    declaredTotal += metadata.uncompressedSize ?? 0;
+    if (!Number.isSafeInteger(declaredTotal)) throw invalidMetadataError(originalPath);
+    files.push({
+      path: relativePath,
+      entry,
+      ...metadata.uncompressedSize !== void 0 ? { declaredSize: metadata.uncompressedSize } : {},
+      ...metadata.compressedSize !== void 0 ? { compressedSize: metadata.compressedSize } : {},
+      ...metadata.crc32 !== void 0 ? { crc32: metadata.crc32 } : {}
+    });
+  });
+  if (memberCount > resolved.maxEntries) {
+    throw tooManyEntriesError(memberCount, resolved.maxEntries);
+  }
+  if (declaredTotal > resolved.maxUncompressedBytes) {
+    throw archiveTooLargeError(declaredTotal, resolved.maxUncompressedBytes);
+  }
+  if (oversizedEntry) {
+    throw entryTooLargeError(oversizedEntry.path, oversizedEntry.actual, oversizedEntry.limit);
+  }
+  return files;
+}
+function throwIfZipAborted(signal) {
+  if (!signal?.aborted) return;
+  throw signal.reason ?? new Error("ZIP operation was cancelled");
+}
+function assertSafeZipPath(path) {
+  if (!isSafeArchivePath(path)) {
+    throw new ZipSafetyError("unsafe-path", `ZIP archive path is unsafe: ${path}.`, { path });
+  }
+}
+function resolveZipSafetyLimits(limits) {
+  const maxEntries = limits.maxEntries ?? DEFAULT_MAX_ZIP_ENTRIES;
+  const maxUncompressedBytes = limits.maxUncompressedBytes ?? DEFAULT_MAX_ZIP_UNCOMPRESSED_BYTES;
+  const maxEntryUncompressedBytes = limits.maxEntryUncompressedBytes ?? maxUncompressedBytes;
+  const maxCompressionRatio = limits.maxCompressionRatio ?? DEFAULT_MAX_ZIP_COMPRESSION_RATIO;
+  assertNonNegativeInteger("maxEntries", maxEntries);
+  assertNonNegativeFinite("maxUncompressedBytes", maxUncompressedBytes);
+  assertNonNegativeFinite("maxEntryUncompressedBytes", maxEntryUncompressedBytes);
+  if (!Number.isFinite(maxCompressionRatio) || maxCompressionRatio < 1) {
+    throw invalidLimitError(
+      "maxCompressionRatio must be a finite number greater than or equal to 1"
+    );
+  }
+  return {
+    maxEntries,
+    maxEntryUncompressedBytes,
+    maxUncompressedBytes,
+    maxCompressionRatio
+  };
+}
+function assertNonNegativeFinite(name, value) {
+  if (!Number.isFinite(value) || value < 0) {
+    throw invalidLimitError(`${name} must be a non-negative finite number`);
+  }
+}
+function entryTooLargeError(path, actual, limit) {
+  return new ZipSafetyError(
+    "entry-too-large",
+    `ZIP import: archive member ${path} exceeds ${limit} byte per-entry limit.`,
+    { path, limit, actual }
+  );
+}
+function tooManyEntriesError(actual, limit) {
+  return new ZipSafetyError(
+    "too-many-entries",
+    `ZIP import: archive has ${actual} files; limit is ${limit}.`,
+    { limit, actual }
+  );
+}
+function archiveTooLargeError(actual, limit) {
+  return new ZipSafetyError(
+    "archive-too-large",
+    `ZIP import: uncompressed content exceeds ${limit} byte limit.`,
+    { limit, actual }
+  );
+}
+function compressionRatioError(path, actual, limit) {
+  return new ZipSafetyError(
+    "compression-ratio-exceeded",
+    `ZIP import: archive member ${path} exceeds ${limit}:1 compression-ratio limit.`,
+    { path, limit, actual }
+  );
+}
+function compressionRatio(uncompressedBytes, compressedBytes) {
+  if (uncompressedBytes === 0) return 0;
+  if (compressedBytes === 0) return Number.POSITIVE_INFINITY;
+  return uncompressedBytes / compressedBytes;
+}
+function assertNonNegativeInteger(name, value) {
+  if (!Number.isInteger(value) || value < 0) {
+    throw invalidLimitError(`${name} must be a non-negative integer`);
+  }
+}
+function invalidLimitError(detail) {
+  return new ZipSafetyError("invalid-limit", `ZIP import: ${detail}.`);
+}
+function originalEntryPath(entry, relativePath) {
+  return entry.unsafeOriginalName ?? relativePath;
+}
+function compressedMetadata(entry, path) {
+  const data = entry._data;
+  const uncompressedSize = data?.uncompressedSize;
+  const compressedSize = data?.compressedSize;
+  const crc32 = data?.crc32;
+  if (uncompressedSize !== void 0 && !isValidMetadataInteger(uncompressedSize) || compressedSize !== void 0 && !isValidMetadataInteger(compressedSize) || crc32 !== void 0 && !Number.isInteger(crc32)) {
+    throw invalidMetadataError(path);
+  }
+  return {
+    ...uncompressedSize !== void 0 ? { uncompressedSize } : {},
+    ...compressedSize !== void 0 ? { compressedSize } : {},
+    ...crc32 !== void 0 ? { crc32 } : {}
+  };
+}
+function isValidMetadataInteger(value) {
+  return Number.isSafeInteger(value) && value >= 0;
+}
+function invalidMetadataError(path) {
+  return new ZipSafetyError(
+    "invalid-entry-metadata",
+    `ZIP import: archive member has invalid size or checksum metadata: ${path}.`,
+    { path }
+  );
+}
+function isSafeArchivePath(path) {
+  const segments = path.split("/");
+  return !(path.startsWith("/") || /^[a-zA-Z]:[\\/]/.test(path) || path.includes("\\") || Array.from(path).some((character) => {
+    const codePoint = character.codePointAt(0) ?? 0;
+    return codePoint < 32 || codePoint === 127;
+  }) || segments.some((segment) => segment === "" || segment === "." || segment === ".."));
+}
+
+// src/shared/boundedZipArchive.ts
+import JSZip from "jszip";
+
+// src/shared/zipEntryCount.ts
+var END_OF_CENTRAL_DIRECTORY = 101010256;
+var ZIP64_END_OF_CENTRAL_DIRECTORY = 101075792;
+var ZIP64_END_LOCATOR = 117853008;
+var UINT16_MAX = 65535;
+var MIN_EOCD_BYTES = 22;
+var MAX_ZIP_COMMENT_BYTES = 65535;
+async function prepareZipInput(data, signal) {
+  throwIfZipAborted(signal);
+  if (ArrayBuffer.isView(data)) {
+    const bytes2 = new Uint8Array(data.buffer, data.byteOffset, data.byteLength);
+    return { input: bytes2, bytes: bytes2 };
+  }
+  if (!isBlobLike(data)) {
+    const bytes2 = new Uint8Array(data);
+    return { input: bytes2, bytes: bytes2 };
+  }
+  const bytes = await readBlobBytes(data, signal);
+  throwIfZipAborted(signal);
+  return bytes ? { input: bytes, bytes } : { input: data };
+}
+function declaredZipEntryCount(bytes) {
+  const eocdOffset = findEocd(bytes);
+  if (eocdOffset === void 0) return void 0;
+  const view = new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength);
+  const count = view.getUint16(eocdOffset + 10, true);
+  if (count !== UINT16_MAX) return count;
+  return readZip64EntryCount(view, eocdOffset);
+}
+function findEocd(bytes) {
+  if (bytes.byteLength < MIN_EOCD_BYTES) return void 0;
+  const view = new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength);
+  const earliest = Math.max(0, bytes.byteLength - MIN_EOCD_BYTES - MAX_ZIP_COMMENT_BYTES);
+  for (let offset = bytes.byteLength - MIN_EOCD_BYTES; offset >= earliest; offset--) {
+    if (view.getUint32(offset, true) !== END_OF_CENTRAL_DIRECTORY) continue;
+    const commentLength = view.getUint16(offset + 20, true);
+    if (offset + MIN_EOCD_BYTES + commentLength === bytes.byteLength) return offset;
+  }
+  return void 0;
+}
+function readZip64EntryCount(view, eocdOffset) {
+  const locatorOffset = eocdOffset - 20;
+  if (locatorOffset < 0 || view.getUint32(locatorOffset, true) !== ZIP64_END_LOCATOR) {
+    return void 0;
+  }
+  const recordOffset = readSafeUint64(view, locatorOffset + 8);
+  if (recordOffset === void 0 || recordOffset < 0 || recordOffset + 40 > view.byteLength || view.getUint32(recordOffset, true) !== ZIP64_END_OF_CENTRAL_DIRECTORY) {
+    return void 0;
+  }
+  return readSafeUint64(view, recordOffset + 32);
+}
+function readSafeUint64(view, offset) {
+  if (offset < 0 || offset + 8 > view.byteLength) return void 0;
+  const low = view.getUint32(offset, true);
+  const high = view.getUint32(offset + 4, true);
+  const value = high * 4294967296 + low;
+  return Number.isSafeInteger(value) ? value : void 0;
+}
+function isBlobLike(data) {
+  const candidate = data;
+  return typeof candidate.size === "number" && typeof candidate.slice === "function";
+}
+async function readBlobBytes(blob, signal) {
+  const arrayBuffer = blob.arrayBuffer;
+  if (typeof arrayBuffer === "function") {
+    return new Uint8Array(await raceWithAbort(arrayBuffer.call(blob), signal));
+  }
+  if (typeof FileReader === "undefined") return void 0;
+  return new Promise((resolve, reject) => {
+    const reader = new FileReader();
+    let settled = false;
+    const cleanup = () => signal?.removeEventListener("abort", handleAbort);
+    const finish = (work) => {
+      if (settled) return;
+      settled = true;
+      cleanup();
+      work();
+    };
+    const handleAbort = () => {
+      if (settled) return;
+      const reason = signal?.reason ?? new Error("ZIP operation was cancelled");
+      finish(() => reject(reason));
+      try {
+        reader.abort();
+      } catch {
+      }
+    };
+    reader.onload = () => finish(() => resolve(new Uint8Array(reader.result)));
+    reader.onerror = () => finish(() => reject(reader.error ?? new Error("Could not read ZIP blob.")));
+    reader.onabort = handleAbort;
+    signal?.addEventListener("abort", handleAbort, { once: true });
+    if (signal?.aborted) {
+      handleAbort();
+      return;
+    }
+    reader.readAsArrayBuffer(blob);
+  });
+}
+function raceWithAbort(work, signal) {
+  throwIfZipAborted(signal);
+  if (!signal) return work;
+  return new Promise((resolve, reject) => {
+    let settled = false;
+    const finish = (complete) => {
+      if (settled) return;
+      settled = true;
+      signal.removeEventListener("abort", handleAbort);
+      complete();
+    };
+    const handleAbort = () => finish(() => reject(signal.reason ?? new Error("ZIP operation was cancelled")));
+    signal.addEventListener("abort", handleAbort, { once: true });
+    if (signal.aborted) handleAbort();
+    work.then(
+      (value) => finish(() => resolve(value)),
+      (error) => finish(() => reject(error))
+    );
+  });
+}
+
+// src/shared/boundedZipArchive.ts
+var JsZipBoundedArchive = class {
+  constructor(zip, entries, limits, signal) {
+    this.reads = /* @__PURE__ */ new Map();
+    this.activeReads = /* @__PURE__ */ new Set();
+    this.emittedBytes = 0;
+    this.zip = zip;
+    this.entries = entries;
+    this.limits = limits;
+    this.signal = signal;
+    this.entriesByPath = new Map(entries.map((entry) => [entry.path, entry]));
+  }
+  /** Actual uncompressed bytes accepted from JSZip streams so far. */
+  get emittedUncompressedBytes() {
+    return this.emittedBytes;
+  }
+  /** Read and cache one member, returning null when it does not exist. */
+  async read(path, maxBytes) {
+    throwIfZipAborted(this.signal);
+    this.throwIfFailed();
+    if (maxBytes !== void 0) assertNonNegativeFinite("member read limit", maxBytes);
+    const entry = this.entriesByPath.get(path);
+    if (!entry) return null;
+    let pending = this.reads.get(path);
+    if (!pending) {
+      pending = this.streamEntry(entry, maxBytes);
+      this.reads.set(path, pending);
+    }
+    let bytes;
+    try {
+      bytes = await pending;
+    } catch (error) {
+      if (this.reads.get(path) === pending && !this.terminalError) this.reads.delete(path);
+      throw error;
+    }
+    throwIfZipAborted(this.signal);
+    if (maxBytes !== void 0 && bytes.byteLength > maxBytes) {
+      const error = entryTooLargeError(path, bytes.byteLength, maxBytes);
+      this.failArchive(error);
+      throw error;
+    }
+    return bytes;
+  }
+  /** Read one UTF-8 text member, returning null when it does not exist. */
+  async readText(path, maxBytes) {
+    const bytes = await this.read(path, maxBytes);
+    return bytes ? new TextDecoder().decode(bytes) : null;
+  }
+  /** Release a cached member when a sequential consumer has taken ownership. */
+  release(path) {
+    this.reads.delete(path);
+  }
+  streamEntry(metadata, readLimit) {
+    throwIfZipAborted(this.signal);
+    const { path, entry, declaredSize, crc32: expectedCrc } = metadata;
+    const effectiveEntryLimit = Math.min(
+      this.limits.maxEntryUncompressedBytes,
+      readLimit ?? Number.POSITIVE_INFINITY
+    );
+    let output = new Uint8Array(0);
+    let stream;
+    try {
+      stream = entry.internalStream("uint8array");
+    } catch (error) {
+      const safeError = asZipSafetyError(error, path);
+      this.failArchive(safeError);
+      return Promise.reject(safeError);
+    }
+    return new Promise((resolve, reject) => {
+      let settled = false;
+      let written = 0;
+      let crc = 4294967295;
+      const removeAbortListener = () => this.signal?.removeEventListener("abort", handleAbort);
+      const handleAbort = () => controller.stop(this.signal?.reason ?? new Error("ZIP operation was cancelled"));
+      const controller = {
+        stop: (error) => {
+          if (settled) return;
+          settled = true;
+          this.activeReads.delete(controller);
+          removeAbortListener();
+          try {
+            stream.pause();
+          } catch {
+          }
+          reject(error);
+        }
+      };
+      this.activeReads.add(controller);
+      if (this.signal) {
+        this.signal.addEventListener("abort", handleAbort, { once: true });
+        if (this.signal.aborted) {
+          handleAbort();
+          return;
+        }
+      }
+      stream.on("data", (chunk) => {
+        if (settled) return;
+        const nextWritten = written + chunk.byteLength;
+        try {
+          throwIfZipAborted(this.signal);
+          this.assertChunkAllowed(metadata, nextWritten, chunk.byteLength, effectiveEntryLimit);
+          output = growOutput(output, nextWritten, declaredSize, effectiveEntryLimit);
+          output.set(chunk, written);
+          written = nextWritten;
+          crc = updateCrc32(crc, chunk);
+        } catch (error) {
+          if (this.signal?.aborted) controller.stop(error);
+          else this.failArchive(asZipSafetyError(error, path));
+        }
+      }).on("error", (error) => {
+        if (settled) return;
+        const message = error instanceof Error ? error.message : String(error);
+        const code = message.includes("uncompressed data size mismatch") ? "size-mismatch" : "decompression-failed";
+        this.failArchive(
+          new ZipSafetyError(code, `ZIP import: could not decompress ${path}: ${message}`, {
+            path,
+            cause: error
+          })
+        );
+      }).on("end", () => {
+        if (settled) return;
+        if (declaredSize !== void 0 && written !== declaredSize) {
+          this.failArchive(
+            new ZipSafetyError(
+              "size-mismatch",
+              `ZIP import: archive member size does not match its metadata: ${path}.`,
+              { path, actual: written }
+            )
+          );
+          return;
+        }
+        const actualCrc = (crc ^ 4294967295) >>> 0;
+        if (expectedCrc !== void 0 && actualCrc !== expectedCrc >>> 0) {
+          this.failArchive(
+            new ZipSafetyError("crc-mismatch", `ZIP import: CRC32 mismatch for ${path}.`, {
+              path
+            })
+          );
+          return;
+        }
+        settled = true;
+        this.activeReads.delete(controller);
+        removeAbortListener();
+        resolve(output.byteLength === written ? output : output.slice(0, written));
+      }).resume();
+    });
+  }
+  assertChunkAllowed(entry, nextEntryBytes, chunkBytes, effectiveEntryLimit) {
+    if (entry.declaredSize !== void 0 && nextEntryBytes > entry.declaredSize) {
+      throw new ZipSafetyError(
+        "size-mismatch",
+        `ZIP import: archive member size does not match its metadata: ${entry.path}.`,
+        { path: entry.path, actual: nextEntryBytes }
+      );
+    }
+    if (effectiveEntryLimit < this.limits.maxUncompressedBytes && nextEntryBytes > effectiveEntryLimit) {
+      throw entryTooLargeError(entry.path, nextEntryBytes, effectiveEntryLimit);
+    }
+    const nextTotal = this.emittedBytes + chunkBytes;
+    if (nextTotal > this.limits.maxUncompressedBytes) {
+      throw archiveTooLargeError(nextTotal, this.limits.maxUncompressedBytes);
+    }
+    if (nextEntryBytes > effectiveEntryLimit) {
+      throw entryTooLargeError(entry.path, nextEntryBytes, effectiveEntryLimit);
+    }
+    const ratio = entry.compressedSize === void 0 ? void 0 : compressionRatio(nextEntryBytes, entry.compressedSize);
+    if (ratio !== void 0 && ratio > this.limits.maxCompressionRatio) {
+      throw compressionRatioError(entry.path, ratio, this.limits.maxCompressionRatio);
+    }
+    this.emittedBytes = nextTotal;
+  }
+  failArchive(error) {
+    if (this.terminalError) return;
+    this.terminalError = error;
+    for (const active of [...this.activeReads]) active.stop(error);
+  }
+  throwIfFailed() {
+    if (this.terminalError) throw this.terminalError;
+  }
+};
+async function openBoundedZipArchive(data, limits = {}) {
+  throwIfZipAborted(limits.signal);
+  const resolved = resolveZipSafetyLimits(limits);
+  let prepared;
+  try {
+    prepared = await prepareZipInput(data, limits.signal);
+  } catch (error) {
+    if (limits.signal?.aborted) throw limits.signal.reason ?? error;
+    throw invalidArchiveError(error);
+  }
+  throwIfZipAborted(limits.signal);
+  if (prepared.bytes) {
+    const declaredEntries = declaredZipEntryCount(prepared.bytes);
+    if (declaredEntries !== void 0 && declaredEntries > resolved.maxEntries) {
+      throw tooManyEntriesError(declaredEntries, resolved.maxEntries);
+    }
+  }
+  let zip;
+  try {
+    zip = await JSZip.loadAsync(prepared.input);
+  } catch (error) {
+    if (limits.signal?.aborted) throw limits.signal.reason ?? error;
+    throw invalidArchiveError(error);
+  }
+  throwIfZipAborted(limits.signal);
+  return createBoundedZipArchive(zip, limits);
+}
+function invalidArchiveError(cause) {
+  return new ZipSafetyError("invalid-archive", "ZIP import: archive is not readable.", { cause });
+}
+function createBoundedZipArchive(zip, limits = {}) {
+  throwIfZipAborted(limits.signal);
+  const resolved = resolveZipSafetyLimits(limits);
+  const entries = validateZipArchive(zip, limits);
+  throwIfZipAborted(limits.signal);
+  return new JsZipBoundedArchive(zip, entries, resolved, limits.signal);
+}
+function asZipSafetyError(error, path) {
+  if (error instanceof ZipSafetyError) return error;
+  return new ZipSafetyError(
+    "decompression-failed",
+    `ZIP import: could not decompress ${path}: ${error instanceof Error ? error.message : String(error)}`,
+    { path, cause: error }
+  );
+}
+function growOutput(current, required, declaredSize, limit) {
+  if (required <= current.byteLength) return current;
+  const maximum = Math.min(declaredSize ?? limit, limit);
+  const grownSize = current.byteLength === 0 ? required : current.byteLength * 2;
+  const nextSize = Math.min(maximum, Math.max(required, grownSize));
+  const next = new Uint8Array(nextSize);
+  next.set(current);
+  return next;
+}
+var crcTable;
+function updateCrc32(crc, bytes) {
+  const table = crcTable ?? (crcTable = makeCrcTable());
+  let next = crc >>> 0;
+  for (const byte of bytes) next = table[(next ^ byte) & 255] ^ next >>> 8;
+  return next >>> 0;
+}
+function makeCrcTable() {
+  const table = new Uint32Array(256);
+  for (let n = 0; n < table.length; n++) {
+    let value = n;
+    for (let bit = 0; bit < 8; bit++) {
+      value = (value & 1) !== 0 ? 3988292384 ^ value >>> 1 : value >>> 1;
+    }
+    table[n] = value >>> 0;
+  }
+  return table;
+}
+
+export {
+  ZipSafetyError,
+  assertSafeZipPath,
+  openBoundedZipArchive
+};
+//# sourceMappingURL=chunk-FE6OJV6O.js.map

package/dist/chunk-FE6OJV6O.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/shared/zipLimits.ts","../src/shared/boundedZipArchive.ts","../src/shared/zipEntryCount.ts"],"sourcesContent":["/** ZIP safety policy, structured errors, path checks, and metadata validation. */\n\nimport type JSZip from 'jszip';\n\nexport interface ZipSafetyLimits {\n  /** Cooperatively cancel archive opening, validation, and member traversal. */\n  signal?: AbortSignal;\n  /** Maximum number of archive records, including directories. Default: 10,000. */\n  maxEntries?: number;\n  /** Maximum uncompressed bytes for one member. Defaults to maxUncompressedBytes. */\n  maxEntryUncompressedBytes?: number;\n  /** Maximum total uncompressed bytes across the archive. Default: 512 MiB. */\n  maxUncompressedBytes?: number;\n  /** Maximum uncompressed/compressed ratio for a member. Default: 1,000. */\n  maxCompressionRatio?: number;\n}\n\nexport type ZipSafetyErrorCode =\n  | 'invalid-limit'\n  | 'invalid-archive'\n  | 'unsafe-path'\n  | 'invalid-entry-metadata'\n  | 'too-many-entries'\n  | 'entry-too-large'\n  | 'archive-too-large'\n  | 'compression-ratio-exceeded'\n  | 'size-mismatch'\n  | 'crc-mismatch'\n  | 'decompression-failed';\n\nexport interface ZipSafetyErrorOptions {\n  path?: string;\n  limit?: number;\n  actual?: number;\n  cause?: unknown;\n}\n\n/** A stable, machine-readable error raised while validating or reading a ZIP. */\nexport class ZipSafetyError extends Error {\n  readonly code: ZipSafetyErrorCode;\n  readonly path?: string;\n  readonly limit?: number;\n  readonly actual?: number;\n\n  constructor(code: ZipSafetyErrorCode, message: string, options: ZipSafetyErrorOptions = {}) {\n    super(message);\n    this.name = 'ZipSafetyError';\n    this.code = code;\n    this.path = options.path;\n    this.limit = options.limit;\n    this.actual = options.actual;\n    if (options.cause !== undefined) {\n      (this as Error & { cause?: unknown }).cause = options.cause;\n    }\n  }\n}\n\nexport interface ValidatedZipEntry {\n  path: string;\n  entry: JSZip.JSZipObject;\n  declaredSize?: number;\n  compressedSize?: number;\n  crc32?: number;\n}\n\nexport interface ResolvedZipSafetyLimits {\n  maxEntries: number;\n  maxEntryUncompressedBytes: number;\n  maxUncompressedBytes: number;\n  maxCompressionRatio: number;\n}\n\nexport const DEFAULT_MAX_ZIP_ENTRIES = 10_000;\nexport const DEFAULT_MAX_ZIP_UNCOMPRESSED_BYTES = 512 * 1024 * 1024;\nexport const DEFAULT_MAX_ZIP_COMPRESSION_RATIO = 1_000;\n\n/**\n * Validate central-directory metadata before any member is decompressed.\n * JSZip normalizes traversal names, so inspect `unsafeOriginalName` too.\n */\nexport function validateZipArchive(zip: JSZip, limits: ZipSafetyLimits = {}): ValidatedZipEntry[] {\n  throwIfZipAborted(limits.signal);\n  const resolved = resolveZipSafetyLimits(limits);\n  const files: ValidatedZipEntry[] = [];\n  let memberCount = 0;\n  let declaredTotal = 0;\n  let oversizedEntry: { path: string; actual: number; limit: number } | undefined;\n\n  zip.forEach((relativePath, entry) => {\n    throwIfZipAborted(limits.signal);\n    memberCount++;\n    if (entry.dir) return;\n    const originalPath = originalEntryPath(entry, relativePath);\n    if (!isSafeArchivePath(originalPath)) {\n      throw new ZipSafetyError(\n        'unsafe-path',\n        `ZIP import: archive contains an unsafe path: ${originalPath}.`,\n        { path: originalPath },\n      );\n    }\n\n    const metadata = compressedMetadata(entry, originalPath);\n    if (\n      metadata.uncompressedSize !== undefined &&\n      metadata.uncompressedSize > resolved.maxEntryUncompressedBytes\n    ) {\n      oversizedEntry ??= {\n        path: originalPath,\n        actual: metadata.uncompressedSize,\n        limit: resolved.maxEntryUncompressedBytes,\n      };\n    }\n\n    const ratio =\n      metadata.uncompressedSize === undefined || metadata.compressedSize === undefined\n        ? undefined\n        : compressionRatio(metadata.uncompressedSize, metadata.compressedSize);\n    if (ratio !== undefined && ratio > resolved.maxCompressionRatio) {\n      throw compressionRatioError(originalPath, ratio, resolved.maxCompressionRatio);\n    }\n\n    declaredTotal += metadata.uncompressedSize ?? 0;\n    if (!Number.isSafeInteger(declaredTotal)) throw invalidMetadataError(originalPath);\n    files.push({\n      path: relativePath,\n      entry,\n      ...(metadata.uncompressedSize !== undefined\n        ? { declaredSize: metadata.uncompressedSize }\n        : {}),\n      ...(metadata.compressedSize !== undefined ? { compressedSize: metadata.compressedSize } : {}),\n      ...(metadata.crc32 !== undefined ? { crc32: metadata.crc32 } : {}),\n    });\n  });\n\n  if (memberCount > resolved.maxEntries) {\n    throw tooManyEntriesError(memberCount, resolved.maxEntries);\n  }\n  if (declaredTotal > resolved.maxUncompressedBytes) {\n    throw archiveTooLargeError(declaredTotal, resolved.maxUncompressedBytes);\n  }\n  if (oversizedEntry) {\n    throw entryTooLargeError(oversizedEntry.path, oversizedEntry.actual, oversizedEntry.limit);\n  }\n  return files;\n}\n\n/** Preserve the caller's exact cancellation reason across ZIP/OOXML layers. */\nexport function throwIfZipAborted(signal?: AbortSignal): void {\n  if (!signal?.aborted) return;\n  throw signal.reason ?? new Error('ZIP operation was cancelled');\n}\n\n/** Reject a path that could be interpreted outside an archive's logical root. */\nexport function assertSafeZipPath(path: string): void {\n  if (!isSafeArchivePath(path)) {\n    throw new ZipSafetyError('unsafe-path', `ZIP archive path is unsafe: ${path}.`, { path });\n  }\n}\n\nexport function resolveZipSafetyLimits(limits: ZipSafetyLimits): ResolvedZipSafetyLimits {\n  const maxEntries = limits.maxEntries ?? DEFAULT_MAX_ZIP_ENTRIES;\n  const maxUncompressedBytes = limits.maxUncompressedBytes ?? DEFAULT_MAX_ZIP_UNCOMPRESSED_BYTES;\n  const maxEntryUncompressedBytes = limits.maxEntryUncompressedBytes ?? maxUncompressedBytes;\n  const maxCompressionRatio = limits.maxCompressionRatio ?? DEFAULT_MAX_ZIP_COMPRESSION_RATIO;\n\n  assertNonNegativeInteger('maxEntries', maxEntries);\n  assertNonNegativeFinite('maxUncompressedBytes', maxUncompressedBytes);\n  assertNonNegativeFinite('maxEntryUncompressedBytes', maxEntryUncompressedBytes);\n  if (!Number.isFinite(maxCompressionRatio) || maxCompressionRatio < 1) {\n    throw invalidLimitError(\n      'maxCompressionRatio must be a finite number greater than or equal to 1',\n    );\n  }\n  return {\n    maxEntries,\n    maxEntryUncompressedBytes,\n    maxUncompressedBytes,\n    maxCompressionRatio,\n  };\n}\n\nexport function assertNonNegativeFinite(name: string, value: number): void {\n  if (!Number.isFinite(value) || value < 0) {\n    throw invalidLimitError(`${name} must be a non-negative finite number`);\n  }\n}\n\nexport function entryTooLargeError(path: string, actual: number, limit: number): ZipSafetyError {\n  return new ZipSafetyError(\n    'entry-too-large',\n    `ZIP import: archive member ${path} exceeds ${limit} byte per-entry limit.`,\n    { path, limit, actual },\n  );\n}\n\nexport function tooManyEntriesError(actual: number, limit: number): ZipSafetyError {\n  return new ZipSafetyError(\n    'too-many-entries',\n    `ZIP import: archive has ${actual} files; limit is ${limit}.`,\n    { limit, actual },\n  );\n}\n\nexport function archiveTooLargeError(actual: number, limit: number): ZipSafetyError {\n  return new ZipSafetyError(\n    'archive-too-large',\n    `ZIP import: uncompressed content exceeds ${limit} byte limit.`,\n    { limit, actual },\n  );\n}\n\nexport function compressionRatioError(path: string, actual: number, limit: number): ZipSafetyError {\n  return new ZipSafetyError(\n    'compression-ratio-exceeded',\n    `ZIP import: archive member ${path} exceeds ${limit}:1 compression-ratio limit.`,\n    { path, limit, actual },\n  );\n}\n\nexport function compressionRatio(uncompressedBytes: number, compressedBytes: number): number {\n  if (uncompressedBytes === 0) return 0;\n  if (compressedBytes === 0) return Number.POSITIVE_INFINITY;\n  return uncompressedBytes / compressedBytes;\n}\n\nfunction assertNonNegativeInteger(name: string, value: number): void {\n  if (!Number.isInteger(value) || value < 0) {\n    throw invalidLimitError(`${name} must be a non-negative integer`);\n  }\n}\n\nfunction invalidLimitError(detail: string): ZipSafetyError {\n  return new ZipSafetyError('invalid-limit', `ZIP import: ${detail}.`);\n}\n\nfunction originalEntryPath(entry: JSZip.JSZipObject, relativePath: string): string {\n  return (\n    (\n      entry as JSZip.JSZipObject & {\n        unsafeOriginalName?: string;\n      }\n    ).unsafeOriginalName ?? relativePath\n  );\n}\n\nfunction compressedMetadata(\n  entry: JSZip.JSZipObject,\n  path: string,\n): { uncompressedSize?: number; compressedSize?: number; crc32?: number } {\n  const data = (\n    entry as unknown as {\n      _data?: { uncompressedSize?: number; compressedSize?: number; crc32?: number };\n    }\n  )._data;\n  const uncompressedSize = data?.uncompressedSize;\n  const compressedSize = data?.compressedSize;\n  const crc32 = data?.crc32;\n  if (\n    (uncompressedSize !== undefined && !isValidMetadataInteger(uncompressedSize)) ||\n    (compressedSize !== undefined && !isValidMetadataInteger(compressedSize)) ||\n    (crc32 !== undefined && !Number.isInteger(crc32))\n  ) {\n    throw invalidMetadataError(path);\n  }\n  return {\n    ...(uncompressedSize !== undefined ? { uncompressedSize } : {}),\n    ...(compressedSize !== undefined ? { compressedSize } : {}),\n    ...(crc32 !== undefined ? { crc32 } : {}),\n  };\n}\n\nfunction isValidMetadataInteger(value: number): boolean {\n  return Number.isSafeInteger(value) && value >= 0;\n}\n\nfunction invalidMetadataError(path: string): ZipSafetyError {\n  return new ZipSafetyError(\n    'invalid-entry-metadata',\n    `ZIP import: archive member has invalid size or checksum metadata: ${path}.`,\n    { path },\n  );\n}\n\nfunction isSafeArchivePath(path: string): boolean {\n  const segments = path.split('/');\n  return !(\n    path.startsWith('/') ||\n    /^[a-zA-Z]:[\\\\/]/.test(path) ||\n    path.includes('\\\\') ||\n    Array.from(path).some((character) => {\n      const codePoint = character.codePointAt(0) ?? 0;\n      return codePoint < 0x20 || codePoint === 0x7f;\n    }) ||\n    segments.some((segment) => segment === '' || segment === '.' || segment === '..')\n  );\n}\n","/** Incremental JSZip member reads governed by one shared archive budget. */\n\nimport JSZip from 'jszip';\nimport {\n  archiveTooLargeError,\n  assertNonNegativeFinite,\n  compressionRatio,\n  compressionRatioError,\n  entryTooLargeError,\n  resolveZipSafetyLimits,\n  throwIfZipAborted,\n  validateZipArchive,\n  tooManyEntriesError,\n  ZipSafetyError,\n  type ResolvedZipSafetyLimits,\n  type ValidatedZipEntry,\n  type ZipSafetyErrorCode,\n  type ZipSafetyLimits,\n} from './zipLimits.js';\nimport { declaredZipEntryCount, prepareZipInput, type ZipInput } from './zipEntryCount.js';\n\ninterface ActiveZipRead {\n  stop(error: unknown): void;\n}\n\ninterface ZipChunkStream {\n  on(event: 'data', callback: (chunk: Uint8Array) => void): ZipChunkStream;\n  on(event: 'error', callback: (error: unknown) => void): ZipChunkStream;\n  on(event: 'end', callback: () => void): ZipChunkStream;\n  pause(): ZipChunkStream;\n  resume(): ZipChunkStream;\n}\n\ninterface StreamableZipObject {\n  internalStream(type: 'uint8array'): ZipChunkStream;\n}\n\n/**\n * A JSZip archive whose member reads share one actual-byte budget.\n *\n * JSZip's promise API accumulates a complete inflated member before returning.\n * This wrapper instead consumes `internalStream('uint8array')`, checks every\n * emitted chunk, and pauses every active stream as soon as any limit fails.\n * Completed reads are cached so repeated OOXML part access is neither inflated\n * nor charged twice.\n */\nexport interface BoundedZipArchive {\n  readonly zip: JSZip;\n  readonly entries: readonly ValidatedZipEntry[];\n  readonly emittedUncompressedBytes: number;\n  read(path: string, maxBytes?: number): Promise<Uint8Array | null>;\n  readText(path: string, maxBytes?: number): Promise<string | null>;\n  release(path: string): void;\n}\n\nclass JsZipBoundedArchive implements BoundedZipArchive {\n  readonly zip: JSZip;\n  readonly entries: readonly ValidatedZipEntry[];\n\n  private readonly limits: ResolvedZipSafetyLimits;\n  private readonly entriesByPath: ReadonlyMap<string, ValidatedZipEntry>;\n  private readonly signal?: AbortSignal;\n  private readonly reads = new Map<string, Promise<Uint8Array>>();\n  private readonly activeReads = new Set<ActiveZipRead>();\n  private terminalError?: ZipSafetyError;\n  private emittedBytes = 0;\n\n  constructor(\n    zip: JSZip,\n    entries: readonly ValidatedZipEntry[],\n    limits: ResolvedZipSafetyLimits,\n    signal?: AbortSignal,\n  ) {\n    this.zip = zip;\n    this.entries = entries;\n    this.limits = limits;\n    this.signal = signal;\n    this.entriesByPath = new Map(entries.map((entry) => [entry.path, entry]));\n  }\n\n  /** Actual uncompressed bytes accepted from JSZip streams so far. */\n  get emittedUncompressedBytes(): number {\n    return this.emittedBytes;\n  }\n\n  /** Read and cache one member, returning null when it does not exist. */\n  async read(path: string, maxBytes?: number): Promise<Uint8Array | null> {\n    throwIfZipAborted(this.signal);\n    this.throwIfFailed();\n    if (maxBytes !== undefined) assertNonNegativeFinite('member read limit', maxBytes);\n    const entry = this.entriesByPath.get(path);\n    if (!entry) return null;\n\n    let pending = this.reads.get(path);\n    if (!pending) {\n      pending = this.streamEntry(entry, maxBytes);\n      this.reads.set(path, pending);\n    }\n    let bytes: Uint8Array;\n    try {\n      bytes = await pending;\n    } catch (error: unknown) {\n      // Cancellation is scoped to the current operation, not archive\n      // corruption. Do not leave a cancelled read cached for a later caller.\n      if (this.reads.get(path) === pending && !this.terminalError) this.reads.delete(path);\n      throw error;\n    }\n    throwIfZipAborted(this.signal);\n    if (maxBytes !== undefined && bytes.byteLength > maxBytes) {\n      const error = entryTooLargeError(path, bytes.byteLength, maxBytes);\n      this.failArchive(error);\n      throw error;\n    }\n    return bytes;\n  }\n\n  /** Read one UTF-8 text member, returning null when it does not exist. */\n  async readText(path: string, maxBytes?: number): Promise<string | null> {\n    const bytes = await this.read(path, maxBytes);\n    return bytes ? new TextDecoder().decode(bytes) : null;\n  }\n\n  /** Release a cached member when a sequential consumer has taken ownership. */\n  release(path: string): void {\n    this.reads.delete(path);\n  }\n\n  private streamEntry(metadata: ValidatedZipEntry, readLimit?: number): Promise<Uint8Array> {\n    throwIfZipAborted(this.signal);\n    const { path, entry, declaredSize, crc32: expectedCrc } = metadata;\n    const effectiveEntryLimit = Math.min(\n      this.limits.maxEntryUncompressedBytes,\n      readLimit ?? Number.POSITIVE_INFINITY,\n    );\n    // Never trust a declaration enough to allocate it up front. A forged\n    // 511 MiB size must not force 511 MiB of memory for a tiny member.\n    let output: Uint8Array = new Uint8Array(0);\n    let stream: ZipChunkStream;\n    try {\n      stream = (entry as unknown as StreamableZipObject).internalStream('uint8array');\n    } catch (error: unknown) {\n      const safeError = asZipSafetyError(error, path);\n      this.failArchive(safeError);\n      return Promise.reject(safeError);\n    }\n\n    return new Promise<Uint8Array>((resolve, reject) => {\n      let settled = false;\n      let written = 0;\n      let crc = 0xffffffff;\n      const removeAbortListener = (): void =>\n        this.signal?.removeEventListener('abort', handleAbort);\n      const handleAbort = (): void =>\n        controller.stop(this.signal?.reason ?? new Error('ZIP operation was cancelled'));\n\n      const controller: ActiveZipRead = {\n        stop: (error) => {\n          if (settled) return;\n          settled = true;\n          this.activeReads.delete(controller);\n          removeAbortListener();\n          // Public JSZip cancellation is cooperative. It prevents another\n          // compressed-input tick; data already emitted synchronously by the\n          // current tick is ignored because `settled` is now true.\n          try {\n            stream.pause();\n          } catch {\n            // Reject with the original safety failure even if a malformed\n            // third-party stream cannot be paused cleanly.\n          }\n          reject(error);\n        },\n      };\n      this.activeReads.add(controller);\n      if (this.signal) {\n        this.signal.addEventListener('abort', handleAbort, { once: true });\n        if (this.signal.aborted) {\n          handleAbort();\n          return;\n        }\n      }\n\n      stream\n        .on('data', (chunk: Uint8Array) => {\n          if (settled) return;\n          const nextWritten = written + chunk.byteLength;\n          try {\n            throwIfZipAborted(this.signal);\n            this.assertChunkAllowed(metadata, nextWritten, chunk.byteLength, effectiveEntryLimit);\n            output = growOutput(output, nextWritten, declaredSize, effectiveEntryLimit);\n            output.set(chunk, written);\n            written = nextWritten;\n            crc = updateCrc32(crc, chunk);\n          } catch (error: unknown) {\n            if (this.signal?.aborted) controller.stop(error);\n            else this.failArchive(asZipSafetyError(error, path));\n          }\n        })\n        .on('error', (error: unknown) => {\n          if (settled) return;\n          const message = error instanceof Error ? error.message : String(error);\n          const code: ZipSafetyErrorCode = message.includes('uncompressed data size mismatch')\n            ? 'size-mismatch'\n            : 'decompression-failed';\n          this.failArchive(\n            new ZipSafetyError(code, `ZIP import: could not decompress ${path}: ${message}`, {\n              path,\n              cause: error,\n            }),\n          );\n        })\n        .on('end', () => {\n          if (settled) return;\n          if (declaredSize !== undefined && written !== declaredSize) {\n            this.failArchive(\n              new ZipSafetyError(\n                'size-mismatch',\n                `ZIP import: archive member size does not match its metadata: ${path}.`,\n                { path, actual: written },\n              ),\n            );\n            return;\n          }\n          const actualCrc = (crc ^ 0xffffffff) >>> 0;\n          if (expectedCrc !== undefined && actualCrc !== expectedCrc >>> 0) {\n            this.failArchive(\n              new ZipSafetyError('crc-mismatch', `ZIP import: CRC32 mismatch for ${path}.`, {\n                path,\n              }),\n            );\n            return;\n          }\n\n          settled = true;\n          this.activeReads.delete(controller);\n          removeAbortListener();\n          resolve(output.byteLength === written ? output : output.slice(0, written));\n        })\n        .resume();\n    });\n  }\n\n  private assertChunkAllowed(\n    entry: ValidatedZipEntry,\n    nextEntryBytes: number,\n    chunkBytes: number,\n    effectiveEntryLimit: number,\n  ): void {\n    if (entry.declaredSize !== undefined && nextEntryBytes > entry.declaredSize) {\n      throw new ZipSafetyError(\n        'size-mismatch',\n        `ZIP import: archive member size does not match its metadata: ${entry.path}.`,\n        { path: entry.path, actual: nextEntryBytes },\n      );\n    }\n    if (\n      effectiveEntryLimit < this.limits.maxUncompressedBytes &&\n      nextEntryBytes > effectiveEntryLimit\n    ) {\n      throw entryTooLargeError(entry.path, nextEntryBytes, effectiveEntryLimit);\n    }\n\n    const nextTotal = this.emittedBytes + chunkBytes;\n    if (nextTotal > this.limits.maxUncompressedBytes) {\n      throw archiveTooLargeError(nextTotal, this.limits.maxUncompressedBytes);\n    }\n    if (nextEntryBytes > effectiveEntryLimit) {\n      throw entryTooLargeError(entry.path, nextEntryBytes, effectiveEntryLimit);\n    }\n\n    const ratio =\n      entry.compressedSize === undefined\n        ? undefined\n        : compressionRatio(nextEntryBytes, entry.compressedSize);\n    if (ratio !== undefined && ratio > this.limits.maxCompressionRatio) {\n      throw compressionRatioError(entry.path, ratio, this.limits.maxCompressionRatio);\n    }\n    this.emittedBytes = nextTotal;\n  }\n\n  private failArchive(error: ZipSafetyError): void {\n    if (this.terminalError) return;\n    this.terminalError = error;\n    for (const active of [...this.activeReads]) active.stop(error);\n  }\n\n  private throwIfFailed(): void {\n    if (this.terminalError) throw this.terminalError;\n  }\n}\n\n/** Load with JSZip, validate metadata, and create a shared bounded read session. */\nexport async function openBoundedZipArchive(\n  data: ZipInput,\n  limits: ZipSafetyLimits = {},\n): Promise<BoundedZipArchive> {\n  throwIfZipAborted(limits.signal);\n  const resolved = resolveZipSafetyLimits(limits);\n  let prepared: { input: ZipInput; bytes?: Uint8Array };\n  try {\n    prepared = await prepareZipInput(data, limits.signal);\n  } catch (error: unknown) {\n    if (limits.signal?.aborted) throw limits.signal.reason ?? error;\n    throw invalidArchiveError(error);\n  }\n  throwIfZipAborted(limits.signal);\n  if (prepared.bytes) {\n    const declaredEntries = declaredZipEntryCount(prepared.bytes);\n    if (declaredEntries !== undefined && declaredEntries > resolved.maxEntries) {\n      throw tooManyEntriesError(declaredEntries, resolved.maxEntries);\n    }\n  }\n  let zip: JSZip;\n  try {\n    zip = await JSZip.loadAsync(prepared.input);\n  } catch (error: unknown) {\n    if (limits.signal?.aborted) throw limits.signal.reason ?? error;\n    throw invalidArchiveError(error);\n  }\n  throwIfZipAborted(limits.signal);\n  return createBoundedZipArchive(zip, limits);\n}\n\nfunction invalidArchiveError(cause: unknown): ZipSafetyError {\n  return new ZipSafetyError('invalid-archive', 'ZIP import: archive is not readable.', { cause });\n}\n\n/** Wrap an existing JSZip instance in the same validation and shared budget. */\nexport function createBoundedZipArchive(\n  zip: JSZip,\n  limits: ZipSafetyLimits = {},\n): BoundedZipArchive {\n  throwIfZipAborted(limits.signal);\n  const resolved = resolveZipSafetyLimits(limits);\n  const entries = validateZipArchive(zip, limits);\n  throwIfZipAborted(limits.signal);\n  return new JsZipBoundedArchive(zip, entries, resolved, limits.signal);\n}\n\nfunction asZipSafetyError(error: unknown, path: string): ZipSafetyError {\n  if (error instanceof ZipSafetyError) return error;\n  return new ZipSafetyError(\n    'decompression-failed',\n    `ZIP import: could not decompress ${path}: ${error instanceof Error ? error.message : String(error)}`,\n    { path, cause: error },\n  );\n}\n\nfunction growOutput(\n  current: Uint8Array,\n  required: number,\n  declaredSize: number | undefined,\n  limit: number,\n): Uint8Array {\n  if (required <= current.byteLength) return current;\n  const maximum = Math.min(declaredSize ?? limit, limit);\n  const grownSize = current.byteLength === 0 ? required : current.byteLength * 2;\n  const nextSize = Math.min(maximum, Math.max(required, grownSize));\n  const next = new Uint8Array(nextSize);\n  next.set(current);\n  return next;\n}\n\nlet crcTable: Uint32Array | undefined;\n\nfunction updateCrc32(crc: number, bytes: Uint8Array): number {\n  const table = crcTable ?? (crcTable = makeCrcTable());\n  let next = crc >>> 0;\n  for (const byte of bytes) next = table[(next ^ byte) & 0xff]! ^ (next >>> 8);\n  return next >>> 0;\n}\n\nfunction makeCrcTable(): Uint32Array {\n  const table = new Uint32Array(256);\n  for (let n = 0; n < table.length; n++) {\n    let value = n;\n    for (let bit = 0; bit < 8; bit++) {\n      value = (value & 1) !== 0 ? 0xedb88320 ^ (value >>> 1) : value >>> 1;\n    }\n    table[n] = value >>> 0;\n  }\n  return table;\n}\n","/** Narrow EOCD preflight for rejecting record-count bombs before JSZip allocation. */\n\nimport { throwIfZipAborted } from './zipLimits.js';\n\nconst END_OF_CENTRAL_DIRECTORY = 0x06054b50;\nconst ZIP64_END_OF_CENTRAL_DIRECTORY = 0x06064b50;\nconst ZIP64_END_LOCATOR = 0x07064b50;\nconst UINT16_MAX = 0xffff;\nconst MIN_EOCD_BYTES = 22;\nconst MAX_ZIP_COMMENT_BYTES = 0xffff;\n\nexport type ZipInput = ArrayBuffer | Uint8Array | Blob;\n\n/** Materialize Blob input once when possible so preflight bytes feed JSZip too. */\nexport async function prepareZipInput(\n  data: ZipInput,\n  signal?: AbortSignal,\n): Promise<{ input: ZipInput; bytes?: Uint8Array }> {\n  throwIfZipAborted(signal);\n  if (ArrayBuffer.isView(data)) {\n    const bytes = new Uint8Array(data.buffer, data.byteOffset, data.byteLength);\n    return { input: bytes, bytes };\n  }\n  if (!isBlobLike(data)) {\n    const bytes = new Uint8Array(data);\n    return { input: bytes, bytes };\n  }\n\n  const bytes = await readBlobBytes(data, signal);\n  throwIfZipAborted(signal);\n  return bytes ? { input: bytes, bytes } : { input: data };\n}\n\n/**\n * Read the declared total central-directory record count when unambiguous.\n * Returns undefined for absent, trailing, malformed, or unsupported metadata;\n * JSZip remains authoritative in those cases.\n */\nexport function declaredZipEntryCount(bytes: Uint8Array): number | undefined {\n  const eocdOffset = findEocd(bytes);\n  if (eocdOffset === undefined) return undefined;\n  const view = new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength);\n  const count = view.getUint16(eocdOffset + 10, true);\n  if (count !== UINT16_MAX) return count;\n  return readZip64EntryCount(view, eocdOffset);\n}\n\nfunction findEocd(bytes: Uint8Array): number | undefined {\n  if (bytes.byteLength < MIN_EOCD_BYTES) return undefined;\n  const view = new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength);\n  const earliest = Math.max(0, bytes.byteLength - MIN_EOCD_BYTES - MAX_ZIP_COMMENT_BYTES);\n  for (let offset = bytes.byteLength - MIN_EOCD_BYTES; offset >= earliest; offset--) {\n    if (view.getUint32(offset, true) !== END_OF_CENTRAL_DIRECTORY) continue;\n    const commentLength = view.getUint16(offset + 20, true);\n    if (offset + MIN_EOCD_BYTES + commentLength === bytes.byteLength) return offset;\n  }\n  return undefined;\n}\n\nfunction readZip64EntryCount(view: DataView, eocdOffset: number): number | undefined {\n  const locatorOffset = eocdOffset - 20;\n  if (locatorOffset < 0 || view.getUint32(locatorOffset, true) !== ZIP64_END_LOCATOR) {\n    return undefined;\n  }\n  const recordOffset = readSafeUint64(view, locatorOffset + 8);\n  if (\n    recordOffset === undefined ||\n    recordOffset < 0 ||\n    recordOffset + 40 > view.byteLength ||\n    view.getUint32(recordOffset, true) !== ZIP64_END_OF_CENTRAL_DIRECTORY\n  ) {\n    return undefined;\n  }\n  return readSafeUint64(view, recordOffset + 32);\n}\n\nfunction readSafeUint64(view: DataView, offset: number): number | undefined {\n  if (offset < 0 || offset + 8 > view.byteLength) return undefined;\n  const low = view.getUint32(offset, true);\n  const high = view.getUint32(offset + 4, true);\n  const value = high * 0x1_0000_0000 + low;\n  return Number.isSafeInteger(value) ? value : undefined;\n}\n\nfunction isBlobLike(data: ZipInput): data is Blob {\n  const candidate = data as Blob;\n  return typeof candidate.size === 'number' && typeof candidate.slice === 'function';\n}\n\nasync function readBlobBytes(blob: Blob, signal?: AbortSignal): Promise<Uint8Array | undefined> {\n  const arrayBuffer = (blob as Blob & { arrayBuffer?: () => Promise<ArrayBuffer> }).arrayBuffer;\n  if (typeof arrayBuffer === 'function') {\n    return new Uint8Array(await raceWithAbort(arrayBuffer.call(blob), signal));\n  }\n  if (typeof FileReader === 'undefined') return undefined;\n  return new Promise((resolve, reject) => {\n    const reader = new FileReader();\n    let settled = false;\n    const cleanup = (): void => signal?.removeEventListener('abort', handleAbort);\n    const finish = (work: () => void): void => {\n      if (settled) return;\n      settled = true;\n      cleanup();\n      work();\n    };\n    const handleAbort = (): void => {\n      if (settled) return;\n      const reason = signal?.reason ?? new Error('ZIP operation was cancelled');\n      // Mark the promise settled before FileReader.abort(): browsers are\n      // allowed to dispatch `abort` synchronously and re-enter this handler.\n      finish(() => reject(reason));\n      try {\n        reader.abort();\n      } catch {\n        // Preserve the caller's reason if a platform reader is already done.\n      }\n    };\n    reader.onload = () => finish(() => resolve(new Uint8Array(reader.result as ArrayBuffer)));\n    reader.onerror = () =>\n      finish(() => reject(reader.error ?? new Error('Could not read ZIP blob.')));\n    reader.onabort = handleAbort;\n    signal?.addEventListener('abort', handleAbort, { once: true });\n    if (signal?.aborted) {\n      handleAbort();\n      return;\n    }\n    reader.readAsArrayBuffer(blob);\n  });\n}\n\nfunction raceWithAbort<T>(work: Promise<T>, signal?: AbortSignal): Promise<T> {\n  throwIfZipAborted(signal);\n  if (!signal) return work;\n  return new Promise<T>((resolve, reject) => {\n    let settled = false;\n    const finish = (complete: () => void): void => {\n      if (settled) return;\n      settled = true;\n      signal.removeEventListener('abort', handleAbort);\n      complete();\n    };\n    const handleAbort = (): void =>\n      finish(() => reject(signal.reason ?? new Error('ZIP operation was cancelled')));\n    signal.addEventListener('abort', handleAbort, { once: true });\n    if (signal.aborted) handleAbort();\n    work.then(\n      (value) => finish(() => resolve(value)),\n      (error: unknown) => finish(() => reject(error)),\n    );\n  });\n}\n"],"mappings":"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","names":["bytes"]}