@zip.js/zip.js 2.8.29 → 2.8.30

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
Files changed (38) hide show
  1. package/BENCHMARKS.md +35 -0
  2. package/deno.json +1 -1
  3. package/dist/zip-core.js +527 -48
  4. package/dist/zip-core.min.js +1 -1
  5. package/dist/zip-fs-core.js +413 -48
  6. package/dist/zip-fs-core.min.js +1 -1
  7. package/dist/zip-fs-native.js +589 -52
  8. package/dist/zip-fs-native.min.js +1 -1
  9. package/dist/zip-fs.js +587 -50
  10. package/dist/zip-fs.min.js +1 -1
  11. package/dist/zip-legacy.js +528 -49
  12. package/dist/zip-legacy.min.js +1 -1
  13. package/dist/zip-module.wasm +0 -0
  14. package/dist/zip-native.js +531 -52
  15. package/dist/zip-native.min.js +1 -1
  16. package/dist/zip-web-worker-native.js +1 -1
  17. package/dist/zip-web-worker.js +1 -1
  18. package/dist/zip.js +529 -50
  19. package/dist/zip.min.js +1 -1
  20. package/index-native.cjs +589 -52
  21. package/index-native.min.js +1 -1
  22. package/index.cjs +587 -50
  23. package/index.d.ts +126 -1
  24. package/index.min.js +1 -1
  25. package/lib/core/options.js +11 -1
  26. package/lib/core/streams/codecs/crc32.js +39 -11
  27. package/lib/core/streams/zip-entry-stream.js +85 -5
  28. package/lib/core/streams/zlib-js/zlib-streams.min.js +1 -1
  29. package/lib/core/streams/zlib-wasm/zlib-streams.wasm +0 -0
  30. package/lib/core/util/opfs-temp-stream.js +175 -0
  31. package/lib/core/web-worker-inline-native.js +1 -1
  32. package/lib/core/web-worker-inline-wasm.js +1 -1
  33. package/lib/core/zip-fs.js +58 -0
  34. package/lib/core/zip-reader.js +219 -31
  35. package/lib/core/zip-writer.js +11 -0
  36. package/lib/core/zlib-streams-inline.js +1 -1
  37. package/lib/zip-core-base.js +4 -1
  38. package/package.json +1 -1
package/dist/zip-legacy.js CHANGED
@@ -211,7 +211,7 @@
211
211
  }
212
212
  }
213
213
 
214
- const A="ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";function g(g){g({workerURI:g=>{const B="text/javascript",I=(g=>{g=(g=>{const B=(g=(g+"").replace(/[^A-Za-z0-9+/=]/g,"")).length,I=[];for(let C=0;B>C;C+=4){const B=A.indexOf(g[C])<<18|A.indexOf(g[C+1])<<12|(63&A.indexOf(g[C+2]))<<6|63&A.indexOf(g[C+3]);I.push(B>>16&255),"="!==g[C+2]&&I.push(B>>8&255),"="!==g[C+3]&&I.push(255&B);}return new Uint8Array(I)})(g);let B=new Uint8Array(1024),I=0;for(let A=0;A<g.length;){const E=g[A++];if(128&E){const Q=3+(127&E),Y=g[A++]<<8|g[A++],D=I-Y;C(I+Q);for(let A=0;Q>A;A++)B[I++]=B[D+A];}else {const Q=E;C(I+Q);for(let C=0;Q>C&&A<g.length;C++)B[I++]=g[A++];}}return (g=>{let B="";const I=g.length;let C=0;for(;I>C+2;C+=3){const I=g[C]<<16|g[C+1]<<8|g[C+2];B+=A[I>>18&63]+A[I>>12&63]+A[I>>6&63]+A[63&I];}const E=I-C;if(1===E){const I=g[C]<<16;B+=A[I>>18&63]+A[I>>12&63]+"==";}else if(2===E){const I=g[C]<<16|g[C+1]<<8;B+=A[I>>18&63]+A[I>>12&63]+A[I>>6&63]+"=";}return B})(new Uint8Array(B.buffer.slice(0,I)));function C(A){if(B.length<A){let g=2*B.length;for(;A>g;)g*=2;const C=new Uint8Array(g);C.set(B.subarray(0,I)),B=C;}}})("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");if(g){const A=atob(I),g=new Blob([A],{type:B});return URL.createObjectURL(g)}return "data:"+B+";base64,"+I}});}
214
+ const A="ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";function g(g){g({workerURI:g=>{const B="text/javascript",I=(g=>{g=(g=>{const B=(g=(g+"").replace(/[^A-Za-z0-9+/=]/g,"")).length,I=[];for(let E=0;B>E;E+=4){const B=A.indexOf(g[E])<<18|A.indexOf(g[E+1])<<12|(63&A.indexOf(g[E+2]))<<6|63&A.indexOf(g[E+3]);I.push(B>>16&255),"="!==g[E+2]&&I.push(B>>8&255),"="!==g[E+3]&&I.push(255&B);}return new Uint8Array(I)})(g);let B=new Uint8Array(1024),I=0;for(let A=0;A<g.length;){const C=g[A++];if(128&C){const Y=3+(127&C),Q=g[A++]<<8|g[A++],F=I-Q;E(I+Y);for(let A=0;Y>A;A++)B[I++]=B[F+A];}else {const Y=C;E(I+Y);for(let E=0;Y>E&&A<g.length;E++)B[I++]=g[A++];}}return (g=>{let B="";const I=g.length;let E=0;for(;I>E+2;E+=3){const I=g[E]<<16|g[E+1]<<8|g[E+2];B+=A[I>>18&63]+A[I>>12&63]+A[I>>6&63]+A[63&I];}const C=I-E;if(1===C){const I=g[E]<<16;B+=A[I>>18&63]+A[I>>12&63]+"==";}else if(2===C){const I=g[E]<<16|g[E+1]<<8;B+=A[I>>18&63]+A[I>>12&63]+A[I>>6&63]+"=";}return B})(new Uint8Array(B.buffer.slice(0,I)));function E(A){if(B.length<A){let g=2*B.length;for(;A>g;)g*=2;const E=new Uint8Array(g);E.set(B.subarray(0,I)),B=E;}}})("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");if(g){const A=atob(I),g=new Blob([A],{type:B});return URL.createObjectURL(g)}return "data:"+B+";base64,"+I}});}
215
215
 
216
216
  /*
217
217
  Copyright (c) 2022 Gildas Lormeau. All rights reserved.
@@ -241,18 +241,30 @@
241
241
  EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
242
242
  */
243
243
 
244
- const table = [];
245
- for (let i = 0; i < 256; i++) {
246
- let t = i;
244
+ // Slicing-by-8 CRC-32 (Intel / zlib). The eight 256-entry tables let the inner loop
245
+ // consume 8 bytes per iteration with a shorter dependency chain, ~4x the byte-at-a-time
246
+ // rate (measured ~320 -> ~1400 MB/s on 64KB chunks).
247
+ //
248
+ // Every table MUST stay a PACKED_SMI array: build with array literals (not `new Array(n)`,
249
+ // which is HOLEY) and store the signed int32 XOR result (no `>>> 0`). An unsigned or holey
250
+ // table becomes a V8 FixedDoubleArray whose every hot-loop lookup unboxes a double (~1.6x
251
+ // slower). Signedness is irrelevant to the result — the reads mask/shift it and the final
252
+ // `~crc` normalizes it. Do NOT reintroduce `>>> 0` here or switch to `new Array(256)`.
253
+ const T = [[], [], [], [], [], [], [], []];
254
+ for (let n = 0; n < 256; n++) {
255
+ let t = n;
247
256
  for (let j = 0; j < 8; j++) {
248
- if (t & 1) {
249
- t = (t >>> 1) ^ 0xEDB88320;
250
- } else {
251
- t = t >>> 1;
252
- }
257
+ t = (t & 1) ? (t >>> 1) ^ 0xEDB88320 : t >>> 1;
253
258
  }
254
- table[i] = t;
259
+ T[0][n] = t;
255
260
  }
261
+ for (let n = 0; n < 256; n++) {
262
+ for (let k = 1; k < 8; k++) {
263
+ const previous = T[k - 1][n];
264
+ T[k][n] = (previous >>> 8) ^ T[0][previous & 0xFF];
265
+ }
266
+ }
267
+ const [T0, T1, T2, T3, T4, T5, T6, T7] = T;
256
268
 
257
269
  class Crc32 {
258
270
 
@@ -262,8 +274,24 @@
262
274
 
263
275
  append(data) {
264
276
  let crc = this.crc | 0;
265
- for (let offset = 0, length = data.length | 0; offset < length; offset++) {
266
- crc = (crc >>> 8) ^ table[(crc ^ data[offset]) & 0xFF];
277
+ const length = data.length | 0;
278
+ let offset = 0;
279
+ // Process 8 bytes per iteration over the typed-array body. DataView.getInt32(le)
280
+ // reads an unaligned little-endian word as a signed int32 (no double boxing), so no
281
+ // alignment or endianness handling is needed; data.buffer guards non-typed inputs.
282
+ if (length >= 8 && data.buffer) {
283
+ const view = new DataView(data.buffer, data.byteOffset, length);
284
+ const end = length - 8;
285
+ for (; offset <= end; offset += 8) {
286
+ const a = crc ^ view.getInt32(offset, true);
287
+ const b = view.getInt32(offset + 4, true);
288
+ crc = T7[a & 0xFF] ^ T6[(a >>> 8) & 0xFF] ^ T5[(a >>> 16) & 0xFF] ^ T4[(a >>> 24) & 0xFF] ^
289
+ T3[b & 0xFF] ^ T2[(b >>> 8) & 0xFF] ^ T1[(b >>> 16) & 0xFF] ^ T0[(b >>> 24) & 0xFF];
290
+ }
291
+ }
292
+ // Remaining tail (and non-typed inputs) byte-at-a-time with the base table.
293
+ for (; offset < length; offset++) {
294
+ crc = (crc >>> 8) ^ T0[(crc ^ data[offset]) & 0xFF];
267
295
  }
268
296
  this.crc = crc;
269
297
  }
@@ -1697,21 +1725,40 @@
1697
1725
  const ERR_INVALID_COMPRESSED_DATA = "Invalid compressed data";
1698
1726
  const FORMAT_DEFLATE_RAW = "deflate-raw";
1699
1727
  const FORMAT_DEFLATE64_RAW = "deflate64-raw";
1728
+ const FORMAT_GZIP = "gzip";
1729
+ const GZIP_HEADER_LENGTH = 10;
1730
+ const GZIP_TRAILER_LENGTH = 8;
1700
1731
 
1701
1732
  class DeflateStream extends TransformStream {
1702
1733
 
1703
1734
  constructor(options, { chunkSize, CompressionStreamZlib, CompressionStream }) {
1704
1735
  super({});
1705
- const { compressed, encrypted, useCompressionStream, zipCrypto, signed, level } = options;
1736
+ const { compressed, encrypted, useCompressionStream, zipCrypto, signed, level, deflate64 } = options;
1706
1737
  const stream = this;
1707
- let crc32Stream, encryptionStream;
1738
+ let crc32Stream, encryptionStream, gzipCrc32Stream;
1708
1739
  let readable = super.readable;
1709
- if ((!encrypted || zipCrypto) && signed) {
1740
+ // The gzip trailer carries a CRC-32 of the uncompressed data (same polynomial as zip),
1741
+ // computed in native code for free during compression. On the native CompressionStream,
1742
+ // harvest it instead of running a separate CRC pass: compress as gzip, then strip the
1743
+ // fixed 10-byte header and 8-byte trailer to recover the exact raw-deflate payload
1744
+ // (byte-identical to a deflate-raw compression) while capturing the CRC. The CRC becomes
1745
+ // available at end-of-stream, exactly like Crc32Stream, so nothing downstream (data
1746
+ // descriptor, central directory, ZipCrypto) needs it any earlier. Not applied for the
1747
+ // pure-JS/WASM ports (a separate slice-by-8 CRC pass is as fast or faster there).
1748
+ const useGzipCrc32 = signed && compressed && !deflate64 && (!encrypted || zipCrypto) &&
1749
+ Boolean(useCompressionStream && CompressionStream);
1750
+ if ((!encrypted || zipCrypto) && signed && !useGzipCrc32) {
1710
1751
  crc32Stream = new Crc32Stream();
1711
1752
  readable = pipeThrough(readable, crc32Stream);
1712
1753
  }
1713
1754
  if (compressed) {
1714
- readable = pipeThroughCommpressionStream(readable, useCompressionStream, { level, chunkSize }, CompressionStream, CompressionStreamZlib, CompressionStream);
1755
+ if (useGzipCrc32) {
1756
+ gzipCrc32Stream = new GzipToRawDeflateStream();
1757
+ readable = pipeThroughBackpressured(readable, new CompressionStream(FORMAT_GZIP));
1758
+ readable = pipeThrough(readable, gzipCrc32Stream);
1759
+ } else {
1760
+ readable = pipeThroughCommpressionStream(readable, useCompressionStream, { level, chunkSize }, CompressionStream, CompressionStreamZlib, CompressionStream);
1761
+ }
1715
1762
  }
1716
1763
  if (encrypted) {
1717
1764
  if (zipCrypto) {
@@ -1727,13 +1774,74 @@
1727
1774
  signature = encryptionStream.signature;
1728
1775
  }
1729
1776
  if ((!encrypted || zipCrypto) && signed) {
1730
- signature = new DataView(crc32Stream.value.buffer).getUint32(0);
1777
+ signature = useGzipCrc32 ? gzipCrc32Stream.signature : new DataView(crc32Stream.value.buffer).getUint32(0);
1731
1778
  }
1732
1779
  stream.signature = signature;
1733
1780
  });
1734
1781
  }
1735
1782
  }
1736
1783
 
1784
+ // Converts a gzip stream into its raw-deflate payload while capturing the CRC-32 from the gzip
1785
+ // trailer. The CompressionStream gzip header is always the fixed 10-byte form (FLG=0, no optional
1786
+ // fields) per the Compression Streams spec, so it is stripped by length; the trailer is the last
1787
+ // 8 bytes (CRC-32 LE, then ISIZE LE). Bounded memory: at most GZIP_TRAILER_LENGTH bytes are held
1788
+ // back across chunks. The signature is read big-endian-agnostically as a number, matching the
1789
+ // value Crc32Stream produces, so the writer path is unchanged.
1790
+ class GzipToRawDeflateStream extends TransformStream {
1791
+
1792
+ constructor() {
1793
+ // deno-lint-ignore prefer-const
1794
+ let stream;
1795
+ let headerLeft = GZIP_HEADER_LENGTH;
1796
+ let tail = new Uint8Array(0);
1797
+ super({
1798
+ transform(chunk, controller) {
1799
+ if (headerLeft) {
1800
+ const dropped = Math.min(headerLeft, chunk.length);
1801
+ headerLeft -= dropped;
1802
+ chunk = chunk.subarray(dropped);
1803
+ if (!chunk.length) {
1804
+ return;
1805
+ }
1806
+ }
1807
+ const available = tail.length + chunk.length;
1808
+ if (available <= GZIP_TRAILER_LENGTH) {
1809
+ const pending = new Uint8Array(available);
1810
+ pending.set(tail);
1811
+ pending.set(chunk, tail.length);
1812
+ tail = pending;
1813
+ return;
1814
+ }
1815
+ // Emit everything except the trailing GZIP_TRAILER_LENGTH bytes as a standalone,
1816
+ // right-sized Uint8Array. Consumers may read chunk.buffer directly (e.g. custom
1817
+ // writers), so an aliased subarray of a larger buffer would leak the held-back
1818
+ // trailer bytes. Bytes are copied exactly once, into `output` or `tail`.
1819
+ const emitLength = available - GZIP_TRAILER_LENGTH;
1820
+ const output = new Uint8Array(emitLength);
1821
+ const fromTail = Math.min(emitLength, tail.length);
1822
+ output.set(tail.subarray(0, fromTail), 0);
1823
+ if (emitLength > fromTail) {
1824
+ output.set(chunk.subarray(0, emitLength - fromTail), fromTail);
1825
+ }
1826
+ controller.enqueue(output);
1827
+ const nextTail = new Uint8Array(GZIP_TRAILER_LENGTH);
1828
+ const tailRemaining = tail.length - fromTail;
1829
+ if (tailRemaining) {
1830
+ nextTail.set(tail.subarray(fromTail), 0);
1831
+ }
1832
+ nextTail.set(chunk.subarray(emitLength - fromTail), tailRemaining);
1833
+ tail = nextTail;
1834
+ },
1835
+ flush() {
1836
+ const dataView = new DataView(tail.buffer, tail.byteOffset, tail.byteLength);
1837
+ stream.signature = dataView.getUint32(0, true);
1838
+ stream.uncompressedSize = dataView.getUint32(4, true);
1839
+ }
1840
+ });
1841
+ stream = this;
1842
+ }
1843
+ }
1844
+
1737
1845
  class InflateStream extends TransformStream {
1738
1846
 
1739
1847
  constructor(options, { chunkSize, DecompressionStreamZlib, DecompressionStream }) {
@@ -3695,6 +3803,11 @@
3695
3803
  const OPTION_OFFSET = "offset";
3696
3804
  const OPTION_USDZ = "usdz";
3697
3805
  const OPTION_UNIX_EXTRA_FIELD_TYPE = "unixExtraFieldType";
3806
+ const OPTION_STRICTNESS = "strictness";
3807
+ const OPTION_MAX_APPENDED_DATA_SIZE = "maxAppendedDataSize";
3808
+ const STRICTNESS_STRICT = "strict";
3809
+ const STRICTNESS_BALANCED = "balanced";
3810
+ const STRICTNESS_TOLERANT = "tolerant";
3698
3811
 
3699
3812
  /*
3700
3813
  Copyright (c) 2025 Gildas Lormeau. All rights reserved.
@@ -3784,7 +3897,11 @@
3784
3897
  throw new Error(ERR_BAD_FORMAT);
3785
3898
  }
3786
3899
  reader.chunkSize = getChunkSize(config);
3787
- const endOfDirectoryInfo = await seekSignature(reader, END_OF_CENTRAL_DIR_SIGNATURE, reader.size, END_OF_CENTRAL_DIR_LENGTH, MAX_16_BITS * 16);
3900
+ const strictness = getStrictness(getOptionValue$1(zipReader, options, OPTION_STRICTNESS), getOptionValue$1(zipReader, options, OPTION_CHECK_AMBIGUITY));
3901
+ const checkAmbiguity = strictness == STRICTNESS_STRICT;
3902
+ const rejectAmbiguousEndOfDirectory = strictness != STRICTNESS_TOLERANT;
3903
+ const maxAppendedDataSize = getMaxAppendedDataSize(getOptionValue$1(zipReader, options, OPTION_MAX_APPENDED_DATA_SIZE), strictness);
3904
+ const { endOfDirectoryInfo, endOfDirectoryReachingEndCount } = await findEndOfCentralDirectory(reader, rejectAmbiguousEndOfDirectory, maxAppendedDataSize);
3788
3905
  if (!endOfDirectoryInfo) {
3789
3906
  const signatureArray = await readUint8Array(reader, 0, 4);
3790
3907
  const signatureView = getDataView$1(signatureArray);
@@ -3794,14 +3911,18 @@
3794
3911
  throw new Error(ERR_EOCDR_NOT_FOUND);
3795
3912
  }
3796
3913
  }
3914
+ // two or more end-anchored records that each dereference to a valid central directory cannot be told
3915
+ // apart (see comment_length ⟺ EOF): the archive is genuinely ambiguous, so refuse rather than guess
3916
+ if (rejectAmbiguousEndOfDirectory && endOfDirectoryReachingEndCount > 1) {
3917
+ throwAmbiguousArchive("multiple end of central directory records");
3918
+ }
3797
3919
  const endOfDirectoryView = getDataView$1(endOfDirectoryInfo);
3798
3920
  let directoryDataLength = getUint32(endOfDirectoryView, 12);
3799
3921
  let directoryDataOffset = getUint32(endOfDirectoryView, 16);
3800
3922
  const commentOffset = endOfDirectoryInfo.offset;
3801
3923
  const commentLength = getUint16(endOfDirectoryView, 20);
3802
3924
  const appendedDataOffset = commentOffset + END_OF_CENTRAL_DIR_LENGTH + commentLength;
3803
- const checkAmbiguity = getOptionValue$1(zipReader, options, OPTION_CHECK_AMBIGUITY);
3804
- if (checkAmbiguity && appendedDataOffset != reader.size) {
3925
+ if (reader.size - appendedDataOffset > maxAppendedDataSize) {
3805
3926
  throwAmbiguousArchive("appended data");
3806
3927
  }
3807
3928
  let lastDiskNumber = getUint16(endOfDirectoryView, 4);
@@ -3880,14 +4001,28 @@
3880
4001
  throw new Error(ERR_BAD_FORMAT);
3881
4002
  }
3882
4003
  const expectedDirectoryDataOffset = centralDirectoryEndOffset - directoryDataLength - (reader.lastDiskOffset || 0);
3883
- if (getUint32(directoryView, offset) != CENTRAL_FILE_HEADER_SIGNATURE && directoryDataOffset != expectedDirectoryDataOffset && diskNumber == lastDiskNumber) {
3884
- const originalDirectoryDataOffset = directoryDataOffset;
3885
- directoryDataOffset = expectedDirectoryDataOffset;
3886
- if (directoryDataOffset > originalDirectoryDataOffset) {
3887
- prependedDataLength += directoryDataOffset - originalDirectoryDataOffset;
4004
+ if (directoryDataOffset != expectedDirectoryDataOffset && diskNumber == lastDiskNumber) {
4005
+ // the reconciled offset (the directory ends exactly where the canonical record begins) is anchored
4006
+ // to the unforgeable end of the archive; the stored offset is not. Prefer the reconciled offset
4007
+ // unless the stored one points at a directory and the reconciled one does not — that exception
4008
+ // keeps a corrupt declared directory length from sending the read astray, while still moving off a
4009
+ // stored offset that only looks valid because an append remnant left the previous (identically
4010
+ // laid out) directory sitting there.
4011
+ const storedPointsAtDirectory = getUint32(directoryView, offset) == CENTRAL_FILE_HEADER_SIGNATURE;
4012
+ let reconcile = !storedPointsAtDirectory;
4013
+ if (!reconcile && expectedDirectoryDataOffset >= 0 && expectedDirectoryDataOffset + 4 <= reader.size) {
4014
+ const expectedSignatureArray = await readUint8Array(reader, expectedDirectoryDataOffset, 4, diskNumber);
4015
+ reconcile = getUint32(getDataView$1(expectedSignatureArray), 0) == CENTRAL_FILE_HEADER_SIGNATURE;
4016
+ }
4017
+ if (reconcile) {
4018
+ const originalDirectoryDataOffset = directoryDataOffset;
4019
+ directoryDataOffset = expectedDirectoryDataOffset;
4020
+ if (directoryDataOffset > originalDirectoryDataOffset) {
4021
+ prependedDataLength += directoryDataOffset - originalDirectoryDataOffset;
4022
+ }
4023
+ directoryArray = await readUint8Array(reader, directoryDataOffset, directoryDataLength, diskNumber);
4024
+ directoryView = getDataView$1(directoryArray);
3888
4025
  }
3889
- directoryArray = await readUint8Array(reader, directoryDataOffset, directoryDataLength, diskNumber);
3890
- directoryView = getDataView$1(directoryArray);
3891
4026
  }
3892
4027
  }
3893
4028
  const expectedDirectoryDataLength = centralDirectoryEndOffset - directoryDataOffset - (reader.lastDiskOffset || 0);
@@ -4144,7 +4279,7 @@
4144
4279
  extraFieldLength,
4145
4280
  filenameLength
4146
4281
  } = localDirectory;
4147
- const checkAmbiguity = getOptionValue$1(zipEntry, options, OPTION_CHECK_AMBIGUITY);
4282
+ const checkAmbiguity = getStrictness(getOptionValue$1(zipEntry, options, OPTION_STRICTNESS), getOptionValue$1(zipEntry, options, OPTION_CHECK_AMBIGUITY)) == STRICTNESS_STRICT;
4148
4283
  let rawLocalFilename = new Uint8Array();
4149
4284
  if (checkAmbiguity && (filenameLength || extraFieldLength)) {
4150
4285
  const trailingDataArray = await readUint8Array(reader, offset + HEADER_SIZE, filenameLength + extraFieldLength, diskNumberStart);
@@ -4594,26 +4729,191 @@
4594
4729
  readRanges.set(index, range);
4595
4730
  }
4596
4731
 
4597
- async function seekSignature(reader, signature, startOffset, minimumBytes, maximumLength) {
4598
- const signatureArray = new Uint8Array(4);
4599
- const signatureView = getDataView$1(signatureArray);
4600
- setUint32$1(signatureView, 0, signature);
4601
- const maximumBytes = minimumBytes + maximumLength;
4602
- return (await seek(minimumBytes)) || await seek(Math.min(maximumBytes, startOffset));
4603
-
4604
- async function seek(length) {
4605
- const offset = startOffset - length;
4606
- const bytes = await readUint8Array(reader, offset, length);
4607
- for (let indexByte = bytes.length - minimumBytes; indexByte >= 0; indexByte--) {
4608
- if (bytes[indexByte] == signatureArray[0] && bytes[indexByte + 1] == signatureArray[1] &&
4609
- bytes[indexByte + 2] == signatureArray[2] && bytes[indexByte + 3] == signatureArray[3]) {
4610
- return {
4611
- offset: offset + indexByte,
4612
- buffer: bytes.slice(indexByte, indexByte + minimumBytes).buffer
4613
- };
4732
+ function getStrictness(strictness, checkAmbiguity) {
4733
+ if (strictness === UNDEFINED_VALUE) {
4734
+ // `checkAmbiguity: true` is kept as a backward-compatible alias for the strictest mode
4735
+ return checkAmbiguity ? STRICTNESS_STRICT : STRICTNESS_BALANCED;
4736
+ }
4737
+ return strictness;
4738
+ }
4739
+
4740
+ function getMaxAppendedDataSize(maxAppendedDataSize, strictness) {
4741
+ if (maxAppendedDataSize !== UNDEFINED_VALUE) {
4742
+ return maxAppendedDataSize;
4743
+ }
4744
+ if (strictness == STRICTNESS_STRICT) {
4745
+ // the comment must reach the end of the file: no trailing data tolerated
4746
+ return 0;
4747
+ }
4748
+ if (strictness == STRICTNESS_TOLERANT) {
4749
+ return Infinity;
4750
+ }
4751
+ // balanced: tolerate up to a legal comment's worth of trailing data (a 16-bit length); beyond that the
4752
+ // trailing bytes cannot hide inside a comment, so they are treated as a second thing bolted onto the file
4753
+ return MAX_16_BITS;
4754
+ }
4755
+
4756
+ // cap on how many out-of-window central directory probes the scan below may issue. A legitimate archive needs
4757
+ // at most a couple (the canonical record, plus one more to detect genuine ambiguity); every other reachability
4758
+ // check is served from the tail window already in memory. The cap keeps an archive whose comment is stuffed
4759
+ // with unreachable end-anchored records from forcing an unbounded number of (potentially remote) reads.
4760
+ const MAX_END_OF_CENTRAL_DIR_PROBES = 64;
4761
+
4762
+ // reachability rankings for an end-anchored candidate record (see getCentralDirectoryReachability)
4763
+ const CENTRAL_DIRECTORY_UNREACHABLE = 0;
4764
+ const CENTRAL_DIRECTORY_PLAUSIBLE = 1;
4765
+ const CENTRAL_DIRECTORY_REACHABLE = 2;
4766
+
4767
+ // Locates the authoritative end of central directory record. The canonical record is the last one whose
4768
+ // declared comment reaches exactly the end of the file ("end-anchored") and that points to a central directory
4769
+ // ("reachable"); earlier signatures (stale append remnants, bytes embedded in a comment) are ignored. When two
4770
+ // or more end-anchored records point to a central directory the archive is ambiguous, and the count is returned
4771
+ // so the caller can refuse it. A record that reaches the end of the file but points to no central directory (an
4772
+ // empty archive) is only "plausible": it cannot be corroborated, so it never counts towards ambiguity and is
4773
+ // chosen only when no reachable record exists — otherwise an empty record forged in a comment could outrank the
4774
+ // genuine directory. When no record is end-anchored (appended data or an oversized comment), falls back to the
4775
+ // last record within the tolerated window that points to a directory (see seekEndOfCentralDirectory).
4776
+ async function findEndOfCentralDirectory(reader, rejectAmbiguous, maxAppendedDataSize) {
4777
+ const { size } = reader;
4778
+ // an end-anchored record can only live within the last END_OF_CENTRAL_DIR_LENGTH + MAX_16_BITS bytes,
4779
+ // since the comment length that ties it to the end of the file is a 16-bit field
4780
+ const anchoredLength = Math.min(size, END_OF_CENTRAL_DIR_LENGTH + MAX_16_BITS);
4781
+ const anchoredOffset = size - anchoredLength;
4782
+ const anchoredArray = await readUint8Array(reader, anchoredOffset, anchoredLength);
4783
+ const anchoredView = getDataView$1(anchoredArray);
4784
+ const remoteProbeBudget = { count: MAX_END_OF_CENTRAL_DIR_PROBES };
4785
+ let endOfDirectoryInfo;
4786
+ let plausibleEndOfDirectoryInfo;
4787
+ let endOfDirectoryReachingEndCount = 0;
4788
+ for (let indexByte = anchoredArray.length - END_OF_CENTRAL_DIR_LENGTH; indexByte >= 0; indexByte--) {
4789
+ if (getUint32(anchoredView, indexByte) == END_OF_CENTRAL_DIR_SIGNATURE) {
4790
+ const offset = anchoredOffset + indexByte;
4791
+ const commentLength = getUint16(anchoredView, indexByte + 20);
4792
+ // end-anchored: the declared comment extends exactly to the end of the file. The comment length is
4793
+ // attacker-controlled, but the reconciliation against the (unforgeable) end of file is not.
4794
+ if (offset + END_OF_CENTRAL_DIR_LENGTH + commentLength == size) {
4795
+ const reachability = await getCentralDirectoryReachability(reader, anchoredView, anchoredOffset, indexByte, offset, size, remoteProbeBudget);
4796
+ if (reachability == CENTRAL_DIRECTORY_REACHABLE) {
4797
+ if (!endOfDirectoryInfo) {
4798
+ endOfDirectoryInfo = {
4799
+ offset,
4800
+ buffer: anchoredArray.slice(indexByte, indexByte + END_OF_CENTRAL_DIR_LENGTH).buffer
4801
+ };
4802
+ }
4803
+ endOfDirectoryReachingEndCount++;
4804
+ // the canonical record (highest offset) is found first; a second one is enough to flag ambiguity
4805
+ if (!rejectAmbiguous || endOfDirectoryReachingEndCount > 1) {
4806
+ break;
4807
+ }
4808
+ } else if (reachability == CENTRAL_DIRECTORY_PLAUSIBLE && !plausibleEndOfDirectoryInfo) {
4809
+ plausibleEndOfDirectoryInfo = {
4810
+ offset,
4811
+ buffer: anchoredArray.slice(indexByte, indexByte + END_OF_CENTRAL_DIR_LENGTH).buffer
4812
+ };
4813
+ }
4814
+ }
4815
+ }
4816
+ }
4817
+ if (!endOfDirectoryInfo) {
4818
+ // no record points to a directory: prefer a plausible (empty) end-anchored record before scanning the
4819
+ // tolerated window for a bare signature
4820
+ endOfDirectoryInfo = plausibleEndOfDirectoryInfo;
4821
+ }
4822
+ if (!endOfDirectoryInfo) {
4823
+ endOfDirectoryInfo = await seekEndOfCentralDirectory(reader, maxAppendedDataSize, remoteProbeBudget);
4824
+ }
4825
+ return { endOfDirectoryInfo, endOfDirectoryReachingEndCount };
4826
+ }
4827
+
4828
+ // Fallback for findEndOfCentralDirectory when no record is end-anchored: appended data or an oversized comment
4829
+ // pushed the record's declared comment past the end of the file, so its position can no longer be reconciled
4830
+ // against the end of the file. Scans the tolerated window from the end and returns the first record that points
4831
+ // to a central directory, so a stray signature embedded in appended data cannot hijack discovery (which the
4832
+ // anchored scan already prevents for anchored records). Falls back to the first plausible (empty) record, then
4833
+ // to the last bare signature, so a degenerate archive still opens as before. The window ends at the file, so the
4834
+ // same in-window / metered reads as the anchored scan apply.
4835
+ async function seekEndOfCentralDirectory(reader, maxAppendedDataSize, remoteProbeBudget) {
4836
+ const { size } = reader;
4837
+ const searchLength = Math.min(size, maxAppendedDataSize == Infinity ? size :
4838
+ END_OF_CENTRAL_DIR_LENGTH + MAX_16_BITS + maxAppendedDataSize);
4839
+ const searchOffset = size - searchLength;
4840
+ const searchArray = await readUint8Array(reader, searchOffset, searchLength);
4841
+ const searchView = getDataView$1(searchArray);
4842
+ let firstSignatureInfo, plausibleInfo;
4843
+ for (let indexByte = searchArray.length - END_OF_CENTRAL_DIR_LENGTH; indexByte >= 0; indexByte--) {
4844
+ if (getUint32(searchView, indexByte) == END_OF_CENTRAL_DIR_SIGNATURE) {
4845
+ const offset = searchOffset + indexByte;
4846
+ const record = { offset, buffer: searchArray.slice(indexByte, indexByte + END_OF_CENTRAL_DIR_LENGTH).buffer };
4847
+ if (!firstSignatureInfo) {
4848
+ firstSignatureInfo = record;
4614
4849
  }
4850
+ const reachability = await getCentralDirectoryReachability(reader, searchView, searchOffset, indexByte, offset, size, remoteProbeBudget);
4851
+ if (reachability == CENTRAL_DIRECTORY_REACHABLE) {
4852
+ return record;
4853
+ }
4854
+ if (reachability == CENTRAL_DIRECTORY_PLAUSIBLE && !plausibleInfo) {
4855
+ plausibleInfo = record;
4856
+ }
4857
+ }
4858
+ }
4859
+ return plausibleInfo || firstSignatureInfo;
4860
+ }
4861
+
4862
+ // Ranks how strongly an end-anchored candidate record is backed by an actual central directory, used to decide
4863
+ // which record is canonical and which count towards ambiguity. It is intentionally conservative and does not
4864
+ // fully parse the directory (the caller does that for the canonical record):
4865
+ // - REACHABLE: the record dereferences a central directory (a central file header signature at the
4866
+ // reconciled offset), or, for a zip64 record, the zip64 locator that a genuine zip64 archive places
4867
+ // immediately before it. Only these count towards ambiguity.
4868
+ // - PLAUSIBLE: the record describes an empty archive, which has no central directory to dereference. Its
4869
+ // fields are indistinguishable from an empty end of central directory record forged inside a comment, so it
4870
+ // is accepted only as a last resort and never inflates the ambiguity count.
4871
+ // - UNREACHABLE: neither — stale append remnant or signature bytes embedded in a comment.
4872
+ // Signatures are read from the tail window (`view`, spanning `[anchoredOffset, size)`) when they fall inside it;
4873
+ // only a target below the window costs a (possibly remote) read, metered by `remoteProbeBudget` so a stuffed
4874
+ // comment cannot amplify into an unbounded number of requests.
4875
+ async function getCentralDirectoryReachability(reader, view, anchoredOffset, indexByte, offset, size, remoteProbeBudget) {
4876
+ const filesLength = getUint16(view, indexByte + 10);
4877
+ const directoryDataLength = getUint32(view, indexByte + 12);
4878
+ const directoryDataOffset = getUint32(view, indexByte + 16);
4879
+ if (filesLength == MAX_16_BITS || directoryDataLength == MAX_32_BITS || directoryDataOffset == MAX_32_BITS) {
4880
+ // saturated fields imply a zip64 record; corroborate it with the zip64 end of central directory locator
4881
+ // that sits immediately before it, so saturated bytes inside a comment cannot masquerade as one
4882
+ const locatorSignature = await readSignature(reader, view, anchoredOffset, offset - ZIP64_END_OF_CENTRAL_DIR_LOCATOR_LENGTH, size, remoteProbeBudget);
4883
+ return locatorSignature == ZIP64_END_OF_CENTRAL_DIR_LOCATOR_SIGNATURE ? CENTRAL_DIRECTORY_REACHABLE : CENTRAL_DIRECTORY_UNREACHABLE;
4884
+ }
4885
+ if (!filesLength && !directoryDataLength) {
4886
+ // a valid empty archive has no central directory to dereference
4887
+ return CENTRAL_DIRECTORY_PLAUSIBLE;
4888
+ }
4889
+ // the central directory ends where this record starts; reconcile the stored offset against that actual
4890
+ // position (see stored_cd_offset ⟺ eocd_pos − cd_size) so prepended data does not hide the directory
4891
+ for (const centralDirectoryOffset of [offset - directoryDataLength, directoryDataOffset]) {
4892
+ if (await readSignature(reader, view, anchoredOffset, centralDirectoryOffset, size, remoteProbeBudget) == CENTRAL_FILE_HEADER_SIGNATURE) {
4893
+ return CENTRAL_DIRECTORY_REACHABLE;
4615
4894
  }
4616
4895
  }
4896
+ return CENTRAL_DIRECTORY_UNREACHABLE;
4897
+ }
4898
+
4899
+ // Reads a 4-byte little-endian signature at `signatureOffset`, served from the tail window (`view`, spanning
4900
+ // `[anchoredOffset, size)`) when it falls inside it and otherwise from a metered (possibly remote) read. Returns
4901
+ // UNDEFINED_VALUE when the position is out of range or the out-of-window read budget is exhausted.
4902
+ async function readSignature(reader, view, anchoredOffset, signatureOffset, size, remoteProbeBudget) {
4903
+ if (signatureOffset < 0 || signatureOffset + 4 > size) {
4904
+ return UNDEFINED_VALUE;
4905
+ }
4906
+ if (signatureOffset >= anchoredOffset) {
4907
+ // the target sits inside the tail window already in memory: no extra read needed
4908
+ return getUint32(view, signatureOffset - anchoredOffset);
4909
+ }
4910
+ if (remoteProbeBudget.count > 0) {
4911
+ remoteProbeBudget.count--;
4912
+ const signatureArray = await readUint8Array(reader, signatureOffset, 4);
4913
+ return getUint32(getDataView$1(signatureArray), 0);
4914
+ }
4915
+ // out of budget: leave this candidate unverified rather than issue another read
4916
+ return UNDEFINED_VALUE;
4617
4917
  }
4618
4918
 
4619
4919
  function checkLocalDirectory(zipEntry, localDirectory, rawLocalFilename) {
@@ -4678,10 +4978,6 @@
4678
4978
  return Number(view.getBigUint64(offset, true));
4679
4979
  }
4680
4980
 
4681
- function setUint32$1(view, offset, value) {
4682
- view.setUint32(offset, value, true);
4683
- }
4684
-
4685
4981
  function getDataView$1(array) {
4686
4982
  return new DataView(array.buffer, array.byteOffset, array.byteLength);
4687
4983
  }
@@ -5471,6 +5767,17 @@
5471
5767
  if (releaseLockWriter) {
5472
5768
  releaseLockWriter();
5473
5769
  }
5770
+ // A buffered entry uses a temporary stream (see `createTempStream`). When that stream is
5771
+ // backed by a resource (a file, an OPFS handle, ...) it must be released on every exit path,
5772
+ // including the error path where the stream is otherwise abandoned without being closed or
5773
+ // cancelled. `dispose()` is optional and best-effort so it never masks the original outcome.
5774
+ if (bufferedWrite && fileWriter && fileWriter.dispose) {
5775
+ try {
5776
+ await fileWriter.dispose();
5777
+ } catch {
5778
+ // ignored
5779
+ }
5780
+ }
5474
5781
  }
5475
5782
 
5476
5783
  function requestLockCurrentFileEntry() {
@@ -6508,6 +6815,177 @@
6508
6815
  */
6509
6816
 
6510
6817
 
6818
+ const DEFAULT_THRESHOLD = 1024 * 1024;
6819
+ const DEFAULT_DIRECTORY_NAME = ".zip.js-temp";
6820
+
6821
+ // Builds a `createTempStream` factory (see `ZipWriter`'s option of the same name) that spills the
6822
+ // data of a buffered entry to the Origin Private File System (OPFS) instead of keeping it in memory.
6823
+ //
6824
+ // It is meant for the buffered-write path (keep-order concurrent `add()`, non-seekable output, ...),
6825
+ // where the compressed data of an entry has to be held until the writer is free. In memory that data
6826
+ // grows with the entry size; here it is written to an OPFS file and streamed back, so peak memory
6827
+ // stays bounded.
6828
+ //
6829
+ // It is hybrid on purpose: an entry stays fully in memory until it exceeds `thresholdBytes`, and only
6830
+ // then spills to a file. Small entries never touch the disk, so a workload made of many tiny entries
6831
+ // keeps the speed of the in-memory default; only genuinely large entries pay for (and benefit from)
6832
+ // the file round-trip.
6833
+ //
6834
+ // OPFS is a browser/worker feature; there is no fallback here. Feature-detect
6835
+ // `navigator.storage.getDirectory` (or inject `getDirectory`) before using it, and let the writer use
6836
+ // its in-memory default elsewhere.
6837
+ //
6838
+ // Options:
6839
+ // thresholdBytes spill to a file once a buffered entry exceeds this size (default 1 MiB).
6840
+ // directoryName name of the OPFS sub-directory holding the temp files (default ".zip.js-temp").
6841
+ // getDirectory returns (or resolves to) the root `FileSystemDirectoryHandle`. Defaults to
6842
+ // `navigator.storage.getDirectory()`. Inject it to run inside a worker with a
6843
+ // pre-obtained handle, or to test against a mock.
6844
+ function createOPFSTempStream(options = {}) {
6845
+ const {
6846
+ thresholdBytes = DEFAULT_THRESHOLD,
6847
+ directoryName = DEFAULT_DIRECTORY_NAME,
6848
+ getDirectory = () => navigator.storage.getDirectory()
6849
+ } = options;
6850
+ // The temp directory is resolved once and shared by every entry of this factory.
6851
+ let directoryHandlePromise;
6852
+ function getTempDirectory() {
6853
+ if (!directoryHandlePromise) {
6854
+ directoryHandlePromise = Promise.resolve(getDirectory())
6855
+ .then(root => root.getDirectoryHandle(directoryName, { create: true }));
6856
+ }
6857
+ return directoryHandlePromise;
6858
+ }
6859
+ return async function () {
6860
+ const memoryChunks = [];
6861
+ let bufferedSize = 0;
6862
+ let spilled = false;
6863
+ let fileName, fileHandle, fileWriter, fileReader;
6864
+
6865
+ // Move whatever is buffered in memory to a fresh OPFS file, then keep writing to that file.
6866
+ // `FileSystemWritableFileStream` is a `WritableStream`, so it is driven through the standard
6867
+ // writer API rather than its non-standard `write()`/`seek()` convenience methods.
6868
+ async function spillToFile() {
6869
+ const directoryHandle = await getTempDirectory();
6870
+ fileName = crypto.randomUUID();
6871
+ fileHandle = await directoryHandle.getFileHandle(fileName, { create: true });
6872
+ fileWriter = (await fileHandle.createWritable()).getWriter();
6873
+ spilled = true;
6874
+ for (const chunk of memoryChunks) {
6875
+ await fileWriter.write(chunk);
6876
+ }
6877
+ // Release the in-memory copy; from now on data lives in the file.
6878
+ memoryChunks.length = 0;
6879
+ }
6880
+
6881
+ const writable = new WritableStream({
6882
+ async write(chunk) {
6883
+ if (spilled) {
6884
+ await fileWriter.write(chunk);
6885
+ } else {
6886
+ memoryChunks.push(chunk);
6887
+ bufferedSize += chunk.length;
6888
+ if (bufferedSize > thresholdBytes) {
6889
+ await spillToFile();
6890
+ }
6891
+ }
6892
+ },
6893
+ async close() {
6894
+ if (fileWriter) {
6895
+ await fileWriter.close();
6896
+ fileWriter = null;
6897
+ }
6898
+ }
6899
+ });
6900
+
6901
+ // The writer always closes `writable` before reading `readable`, so `spilled` is final by the
6902
+ // time `pull` runs. It is read lazily here (not in `start`, which runs at construction time,
6903
+ // before anything is written and before `spilled` is known).
6904
+ let memoryIndex = 0;
6905
+ const readable = new ReadableStream({
6906
+ async pull(controller) {
6907
+ if (spilled) {
6908
+ if (!fileReader) {
6909
+ const file = await fileHandle.getFile();
6910
+ fileReader = file.stream().getReader();
6911
+ }
6912
+ const { value, done } = await fileReader.read();
6913
+ if (done) {
6914
+ controller.close();
6915
+ } else {
6916
+ controller.enqueue(value);
6917
+ }
6918
+ } else if (memoryIndex < memoryChunks.length) {
6919
+ controller.enqueue(memoryChunks[memoryIndex++]);
6920
+ } else {
6921
+ controller.close();
6922
+ }
6923
+ },
6924
+ async cancel(reason) {
6925
+ if (fileReader) {
6926
+ await fileReader.cancel(reason);
6927
+ }
6928
+ }
6929
+ }, { highWaterMark: 0 });
6930
+ // highWaterMark 0: do not pull (and possibly close on an empty buffer) until the consumer
6931
+ // actually reads, which the writer only does once the data has been fully written.
6932
+
6933
+ // Called by the writer on every exit path (success, error, abort). Best-effort: it must never
6934
+ // throw. Closes any still-open file writer, then deletes the temp file.
6935
+ async function dispose() {
6936
+ if (fileWriter) {
6937
+ try {
6938
+ await fileWriter.close();
6939
+ } catch {
6940
+ // ignored
6941
+ }
6942
+ fileWriter = null;
6943
+ }
6944
+ if (fileName) {
6945
+ try {
6946
+ const directoryHandle = await getTempDirectory();
6947
+ await directoryHandle.removeEntry(fileName);
6948
+ } catch {
6949
+ // ignored
6950
+ }
6951
+ fileHandle = fileName = null;
6952
+ }
6953
+ memoryChunks.length = 0;
6954
+ }
6955
+
6956
+ return { writable, readable, dispose };
6957
+ };
6958
+ }
6959
+
6960
+ /*
6961
+ Copyright (c) 2025 Gildas Lormeau. All rights reserved.
6962
+
6963
+ Redistribution and use in source and binary forms, with or without
6964
+ modification, are permitted provided that the following conditions are met:
6965
+
6966
+ 1. Redistributions of source code must retain the above copyright notice,
6967
+ this list of conditions and the following disclaimer.
6968
+
6969
+ 2. Redistributions in binary form must reproduce the above copyright
6970
+ notice, this list of conditions and the following disclaimer in
6971
+ the documentation and/or other materials provided with the distribution.
6972
+
6973
+ 3. The names of the authors may not be used to endorse or promote products
6974
+ derived from this software without specific prior written permission.
6975
+
6976
+ THIS SOFTWARE IS PROVIDED ''AS IS'' AND ANY EXPRESSED OR IMPLIED WARRANTIES,
6977
+ INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND
6978
+ FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL JCRAFT,
6979
+ INC. OR ANY CONTRIBUTORS TO THIS SOFTWARE BE LIABLE FOR ANY DIRECT, INDIRECT,
6980
+ INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
6981
+ LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA,
6982
+ OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
6983
+ LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
6984
+ NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE,
6985
+ EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
6986
+ */
6987
+
6988
+
6511
6989
  try {
6512
6990
  configure({ baseURI: (typeof document === 'undefined' && typeof location === 'undefined' ? require('u' + 'rl').pathToFileURL(__filename).href : typeof document === 'undefined' ? location.href : (_documentCurrentScript && _documentCurrentScript.tagName.toUpperCase() === 'SCRIPT' && _documentCurrentScript.src || new URL('zip-legacy.js', document.baseURI).href)) });
6513
6991
  } catch {
@@ -6593,6 +7071,7 @@
6593
7071
  exports.ZipWriter = ZipWriter;
6594
7072
  exports.ZipWriterStream = ZipWriterStream;
6595
7073
  exports.configure = configure;
7074
+ exports.createOPFSTempStream = createOPFSTempStream;
6596
7075
  exports.getMimeType = getMimeType;
6597
7076
  exports.terminateWorkers = terminateWorkers;
6598
7077