@zip.js/zip.js 2.8.51 → 2.8.52

package/index.d.ts

@@ -395,6 +395,8 @@ export interface WorkerConfiguration {
   /**
    * `true` to use the native API `CompressionStream`/`DecompressionStream` to compress/decompress data.
    *
+   * When compressing, the native API is only used when `level` is undefined or equal to 6, see {@link ZipWriterConstructorOptions#level}.
+   *
    * @defaultValue true
    */
   useCompressionStream?: boolean;
@@ -1152,6 +1154,12 @@ export class ZipReader<Type> {
   ): AsyncGenerator<Entry, boolean>;
   /**
    * Closes the zip file
+   *
+   * @remarks It cancels the `ReadableStream` instance passed to the constructor when nothing has been read
+   * from it, which is the only resource a {@link ZipReader} instance can hold. It does nothing otherwise: the
+   * stream is already consumed once {@link ZipReader#getEntries} has read the entries into memory, and the
+   * {@link Reader} instances are never closed, they belong to the caller. The entries returned by
+   * {@link ZipReader#getEntries} can therefore still be read after calling it.
    */
   close(): Promise<void>;
 }
@@ -1435,7 +1443,12 @@ export interface ZipReaderOptions {
    */
   signal?: AbortSignal;
   /**
-   * `true` to prevent closing of {@link Writer#writable} when calling {@link FileEntry#getData}.
+   * `true` to prevent closing of {@link WritableWriter#writable} when calling {@link FileEntry#getData}.
+   *
+   * @remarks
+   * It only applies to the writable owned by the caller. It is ignored by the {@link Writer} instances
+   * returning the written data, such as {@link BlobWriter} or {@link TextWriter}, whose writable is
+   * created internally and must be closed for {@link Writer#getData} to resolve.
    *
    * @defaultValue false
    */
@@ -1606,11 +1619,12 @@ export interface LocalDirectory {
    */
   extraFieldNTFS?: EntryExtraField;
   /**
-   * The Unix extra field.
+   * The Info-ZIP Unix type 2 extra field (0x7855). Its uid/gid are stored in the local file header only, the
+   * central directory version carries no data and merely flags their presence.
    */
   extraFieldUnix?: EntryExtraField;
   /**
-   * The Info-ZIP Unix extra field.
+   * The Info-ZIP New Unix extra field (0x7875), storing variable-length uid/gid in both headers.
    */
   extraFieldInfoZip?: EntryExtraField;
   /**
@@ -1694,8 +1708,22 @@ export interface EntryMetaData {
   filenameUTF8: boolean;
   /**
    * `true` if the entry is an executable file
+   *
+   * Always `false` when {@link EntryMetaData#symlink} is `true`: the permissions of a symbolic link
+   * are not meaningful, Unix systems store them as `0o777`.
    */
   executable: boolean;
+  /**
+   * `true` if the entry is a symbolic link, i.e. if the Unix file type stored in
+   * {@link EntryMetaData#externalFileAttributes} is `S_IFLNK` (`0o120000`).
+   *
+   * The target of the link is the content of the entry, stored as a path with no trailing NUL
+   * character. It is read like any other entry, e.g. with `entry.getData(new TextWriter())`.
+   *
+   * The path is not validated: it can be absolute or escape the archive with `..` segments. It must
+   * be checked before being used to resolve a file.
+   */
+  symlink: boolean;
   /**
    * `true` if the content of the entry is encrypted.
    */
@@ -1819,10 +1847,18 @@ export interface EntryMetaData {
   };
   /**
    * Unix owner id when available.
+   *
+   * The value is read from the central directory. The Info-ZIP Unix extra fields type 1 (0x5855) and type 2
+   * (0x7855) store the ids in the local file header only, so entries carrying just these fields leave the
+   * property undefined until the data has been read; the ids are then available in
+   * {@link EntryMetaData#localDirectory}. The Info-ZIP New Unix extra field (0x7875) and the PKWARE Unix
+   * extra field (0x000d) store the ids in both headers and are unaffected.
    */
   uid?: number;
   /**
    * Unix group id when available.
+   *
+   * See {@link EntryMetaData#uid} for the fields storing the ids in the local file header only.
    */
   gid?: number;
   /**
@@ -1908,11 +1944,12 @@ export interface EntryMetaData {
    */
   extraFieldNTFS?: EntryExtraField;
   /**
-   * The Unix extra field.
+   * The Info-ZIP Unix type 2 extra field (0x7855). Its uid/gid are stored in the local file header only, the
+   * central directory version carries no data and merely flags their presence.
    */
   extraFieldUnix?: EntryExtraField;
   /**
-   * The Info-ZIP Unix extra field.
+   * The Info-ZIP New Unix extra field (0x7875), storing variable-length uid/gid in both headers.
    */
   extraFieldInfoZip?: EntryExtraField;
   /**
@@ -1941,6 +1978,11 @@ export interface EntryMetaData {
   extraFieldUSDZ?: EntryExtraField;
   /**
    * The local file header fields, set when the entry data has been read.
+   *
+   * The local file header is the only place where the Info-ZIP Unix extra fields type 1 (0x5855) and type 2
+   * (0x7855) store the uid/gid, so this is where they are read for entries carrying just these fields, e.g.
+   * with `entry.localDirectory.extraFieldUnixType1.uid`. The values are not merged into
+   * {@link EntryMetaData#uid} and {@link EntryMetaData#gid}, which are read from the central directory.
    */
   localDirectory?: LocalDirectory;
 }
@@ -2312,6 +2354,12 @@ export interface ZipWriterConstructorOptions extends WorkerConfiguration {
    *
    * The minimum value is 0 and means that no compression is applied. The maximum value is 9.
    *
+   * The native API `CompressionStream` does not support compression levels. Any value other than 6,
+   * its de facto level, disables `useCompressionStream` and compresses the data with the embedded
+   * implementation instead. Note that the compressed data produced at a given level can still vary
+   * between platforms. Set `useCompressionStream` to `false` to get deterministic output across
+   * platforms.
+   *
    * @defaultValue 6
    */
   level?: number;
@@ -2331,6 +2379,13 @@ export interface ZipWriterConstructorOptions extends WorkerConfiguration {
    * The optional `dispose` method is called once the entry has been processed (on success, error, or abort) so a resource-backed buffer can release its resource.
    *
    * See {@link createOPFSTempStream} for a ready-made OPFS-backed implementation, {@link createSyncAccessHandleTempStream} for a faster worker-only variant, and {@link createBlobTempStream} for a `Blob`-backed one.
+   *
+   * @remarks The `readable` side is consumed only once the `writable` side has been closed, since the local
+   * header written before it holds the size and the CRC-32 of the entry. The object must therefore be able to
+   * hold a whole entry, either by buffering it like the default
+   * `new TransformStream(undefined, undefined, { highWaterMark: Infinity })` does, or by draining it like the
+   * three implementations above do. A factory returning `new TransformStream()` deadlocks instead, its default
+   * queuing strategy holding a single chunk.
    */
   createTempStream?: () => TempStream | Promise<TempStream>;
   /**
@@ -2467,6 +2522,12 @@ export interface ZipWriterConstructorOptions extends WorkerConfiguration {
    * attribute for folder entries, Unix default permissions when `msDosCompatible` is `false`).
    */
   externalFileAttributes?: number;
+  /**
+   * The external file attribute.
+   *
+   * @deprecated Use {@link ZipWriterConstructorOptions#externalFileAttributes} instead.
+   */
+  externalFileAttribute?: number;
   /**
    * The Unix owner id to write in the Unix extra field or as part of the external attributes.
    */
@@ -2477,6 +2538,15 @@ export interface ZipWriterConstructorOptions extends WorkerConfiguration {
   gid?: number;
   /**
    * The Unix mode (st_mode bits) to use when writing external attributes.
+   *
+   * The value includes the Unix file type, so it is also how a symbolic link is written: pass
+   * `0o120777` and use the path of the link target as the content of the entry. Extractors that
+   * support symbolic links, e.g. Info-ZIP `unzip`, then restore the entry as a link.
+   *
+   * When the value carries no file type, the type of the entry is added: `S_IFDIR` (`0o040000`)
+   * for a folder entry, `S_IFREG` (`0o100000`) otherwise. Set
+   * {@link ZipWriterConstructorOptions#externalFileAttributes} instead to write a mode with no
+   * file type.
    */
   unixMode?: number;
   /**
@@ -2505,6 +2575,12 @@ export interface ZipWriterConstructorOptions extends WorkerConfiguration {
    * @defaultValue 0
    */
   internalFileAttributes?: number;
+  /**
+   * The internal file attribute.
+   *
+   * @deprecated Use {@link ZipWriterConstructorOptions#internalFileAttributes} instead.
+   */
+  internalFileAttribute?: number;
   /**
    * When provided, the low 8-bit MS-DOS attributes to write into external file attributes.
    * Must be an integer between 0 and 255.
@@ -2537,6 +2613,16 @@ export interface ZipWriterConstructorOptions extends WorkerConfiguration {
   usdz?: boolean;
   /**
    * `true` to write the data as-is without compressing it and without crypting it.
+   *
+   * @remarks
+   * The {@link ZipWriterConstructorOptions#level} and {@link ZipWriterAddDataOptions#compressionMethod} options
+   * do not apply to data written as-is, and the entries with no content, e.g. the directories, ignore this
+   * option entirely. Setting the {@link ZipWriterConstructorOptions#password} or the
+   * {@link ZipWriterConstructorOptions#rawPassword} option throws an
+   * {@link ERR_UNSUPPORTED_ENCRYPTION_PASS_THROUGH} error, unless the
+   * {@link ZipWriterConstructorOptions#encrypted} option is set to `true` to declare that the data is already
+   * encrypted. In that case the password encrypts the other entries only, and the data written as-is keeps the
+   * password it was encrypted with, which is not verified.
    */
   passThrough?: boolean;
   /**
@@ -2563,6 +2649,13 @@ export interface ZipWriterConstructorOptions extends WorkerConfiguration {
 
 /**
  * Represents options passed to {@link FileEntry#getData}, {@link ZipWriter.add} and `{@link ZipDirectory}.export*`.
+ *
+ * @remarks
+ * When passed to `{@link ZipDirectory}.export*`, these functions report the progress of the whole archive instead
+ * of the progress of each entry: {@link EntryDataOnprogressOptions#onstart} and
+ * {@link EntryDataOnprogressOptions#onend} are called once, and the total number of bytes is the sum of the sizes
+ * of all the entries. Use {@link ZipDirectoryEntryExportOptions#onentryprogress} to be notified when each entry
+ * is written.
  */
 export interface EntryDataOnprogressOptions {
   /**
@@ -2630,6 +2723,10 @@ declare class ZipEntry {
   parent?: ZipEntry;
   /**
    * The uncompressed size of the content.
+   *
+   * @remarks It is the size of the raw compressed content when the entry has been imported with the
+   * `passThrough` option set to `true`, since the entry holds the compressed data in that case. The
+   * uncompressed size of the original entry remains available in {@link ZipEntry#data}.
    */
   uncompressedSize: number;
   /**
@@ -2932,6 +3029,10 @@ export class ZipDirectoryEntry extends ZipEntry {
   /**
    * Adds an entry with content provided via a `FileSystemEntry` instance
    *
+   * The options apply to every entry added, including the directories. The
+   * {@link ZipWriterConstructorOptions#lastModDate} option replaces the last modification date of the
+   * files, which is otherwise taken from each `FileSystemEntry` instance.
+   *
    * @param fileSystemEntry The `FileSystemEntry` instance.
    * @param options The options.
    * @returns A promise resolving to an array of {@link ZipFileEntry} or a {@link ZipDirectoryEntry} instances.
@@ -2947,6 +3048,10 @@ export class ZipDirectoryEntry extends ZipEntry {
    * whose {@link EntryError#entryName} is the path of the handle that failed, relative to the parent
    * of `fileSystemHandle`.
    *
+   * The options apply to every entry added, including the directories. The
+   * {@link ZipWriterConstructorOptions#lastModDate} option replaces the last modification date of the
+   * files, which is otherwise taken from each `FileSystemHandle` instance.
+   *
    * @param fileSystemHandle The `fileSystemHandle` instance.
    * @param options The options.
    * @returns A promise resolving to an array of {@link ZipFileEntry} or a {@link ZipDirectoryEntry} instances.
@@ -2960,6 +3065,9 @@ export class ZipDirectoryEntry extends ZipEntry {
    *
    * @param blob The `Blob` instance.
    * @param options  The options.
+   *
+   * @remarks Use {@link ZipDirectoryEntry#importZip} with a {@link ZipReader} instance to read the data of the
+   * zip file itself, e.g. its {@link ZipReader#prependedData} or its {@link ZipReader#comment} property.
    */
   importBlob(
     blob: Blob,
@@ -2970,6 +3078,9 @@ export class ZipDirectoryEntry extends ZipEntry {
    *
    * @param dataURI The Data URI `string` encoded in Base64.
    * @param options  The options.
+   *
+   * @remarks Use {@link ZipDirectoryEntry#importZip} with a {@link ZipReader} instance to read the data of the
+   * zip file itself, e.g. its {@link ZipReader#prependedData} or its {@link ZipReader#comment} property.
    */
   importData64URI(
     dataURI: string,
@@ -2980,6 +3091,9 @@ export class ZipDirectoryEntry extends ZipEntry {
    *
    * @param array The `Uint8Array` instance.
    * @param options  The options.
+   *
+   * @remarks Use {@link ZipDirectoryEntry#importZip} with a {@link ZipReader} instance to read the data of the
+   * zip file itself, e.g. its {@link ZipReader#prependedData} or its {@link ZipReader#comment} property.
    */
   importUint8Array(
     array: Uint8Array,
@@ -2990,6 +3104,9 @@ export class ZipDirectoryEntry extends ZipEntry {
    *
    * @param url The URL.
    * @param options  The options.
+   *
+   * @remarks Use {@link ZipDirectoryEntry#importZip} with a {@link ZipReader} instance to read the data of the
+   * zip file itself, e.g. its {@link ZipReader#prependedData} or its {@link ZipReader#comment} property.
    */
   importHttpContent(
     url: string,
@@ -3000,21 +3117,30 @@ export class ZipDirectoryEntry extends ZipEntry {
    *
    * @param readable The `ReadableStream` instance.
    * @param options  The options.
+   *
+   * @remarks Use {@link ZipDirectoryEntry#importZip} with a {@link ZipReader} instance to read the data of the
+   * zip file itself, e.g. its {@link ZipReader#prependedData} or its {@link ZipReader#comment} property.
    */
   importReadable(
     readable: ReadableStream,
     options?: ZipReaderConstructorOptions
   ): Promise<[ZipEntry]>;
   /**
-   * Extracts a zip file provided via a custom {@link Reader} instance into the entry
+   * Extracts a zip file provided via a custom {@link Reader} instance or a {@link ZipReader} instance into
+   * the entry
    *
-   * @param reader The {@link Reader} instance.
+   * @param reader The {@link Reader} instance or the {@link ZipReader} instance.
    * @param options  The options.
    *
    * @remarks The filename of each entry is split into path components to build the tree of entries. Empty
    * components and `"."` components are ignored, so `"a//b.txt"`, `"./a/b.txt"` and `"a/./b.txt"` all produce
    * the same `"a/b.txt"` entry. Filenames are normalized and validated beforehand, see
    * {@link GetEntriesOptions#normalizeFilename} and {@link GetEntriesOptions#filenameValidation}.
+   *
+   * Passing a {@link ZipReader} instance is the way to read the data of the zip file itself, e.g. its
+   * {@link ZipReader#prependedData} or its {@link ZipReader#comment} property, since the instance created
+   * otherwise is not exposed. Its options are used as defaults for the options passed here, and it must not
+   * have read its entries yet when it is created over a `ReadableStream` instance, which can only be read once.
    */
   importZip(
     reader:
@@ -3023,7 +3149,8 @@ export class ZipDirectoryEntry extends ZipEntry {
       | ReadableStream
       | Reader<unknown>[]
       | ReadableReader[]
-      | ReadableStream[],
+      | ReadableStream[]
+      | ZipReader<unknown>,
     options?: ZipReaderConstructorOptions
   ): Promise<[ZipEntry]>;
   /**
@@ -3081,7 +3208,7 @@ export class ZipDirectoryEntry extends ZipEntry {
    * Running the same export again is the supported way to recover, since directories are merged and
    * files are overwritten.
    *
-   * @remarks An entry flagged as a symbolic link by its {@link EntryMetaData#externalFileAttributes} is written
+   * @remarks An entry flagged as a symbolic link by {@link EntryMetaData#symlink} is written
    * as a regular file whose content is the path of the link target, because the File System Access API cannot
    * create symbolic links.
    *
@@ -3108,6 +3235,34 @@ export class ZipDirectoryEntry extends ZipEntry {
       | AsyncGenerator<Writer<unknown> | WritableWriter | WritableStream>,
     options?: ZipDirectoryEntryExportOptions
   ): Promise<unknown>;
+  /**
+   * Computes the exact size in bytes of the zip file that `export*()` would produce for the entry
+   * and its descendants, without reading or compressing any data.
+   *
+   * Pass the same options object that will be passed to the export method, otherwise the result
+   * will not match. The size is only determinable when every descendant is stored (i.e. `level` is
+   * set to 0) or passed through, and has a known size; {@link ERR_UNDETERMINED_SIZE} is thrown
+   * otherwise. Encryption does not prevent it, the overhead of ZipCrypto and AES being fixed.
+   *
+   * The intended use is setting the `Content-Length` header of a zip file streamed over HTTP.
+   *
+   * @remarks Entries added with {@link ZipDirectoryEntry#addReadable} never have a known size, and
+   * entries added with {@link ZipDirectoryEntry#addHttpContent} only get one once their content has
+   * been read. The returned size assumes a single output file, it does not apply to split zip files.
+   *
+   * {@link ERR_UNDETERMINED_SIZE} is also thrown when the size depends on the order in which the
+   * entries are physically written, which the buffered write path only determines at write time.
+   * This happens when `usdz` is set, since the alignment padding depends on the offset of each
+   * entry, and when the archive exceeds 4GB, since the offsets recorded in the central directory
+   * are then extended to 64 bits. Passing `bufferedWrite: false` makes both determinable again,
+   * as does exporting a directory whose children are all files. It is thrown as well when
+   * `signCentralDirectory` is set, the length of the signature being unknown until it is computed.
+   *
+   * @param options The options.
+   * @returns A promise resolving to the size in bytes.
+   * @throws {@link ERR_UNDETERMINED_SIZE} if the size cannot be determined.
+   */
+  getExportedSize(options?: ZipDirectoryEntryExportOptions): Promise<number>;
 }
 
 /**
@@ -3131,6 +3286,37 @@ export interface ZipDirectoryEntryGetChildrenOptions {
 
 /**
  * Represents the options passed to `{@link ZipDirectoryEntry}#export*()`.
+ *
+ * @remarks
+ * The options set here apply to every entry of the exported zip file, including the entries imported
+ * from a zip file: such an entry keeps the metadata of the entry it was imported from, e.g. its
+ * {@link ZipWriterConstructorOptions#lastModDate} option, only when the option is not set here. The
+ * options passed when adding an entry to the filesystem take precedence over the options set here, and
+ * the options describing the data of the entries exported as-is, e.g.
+ * {@link ZipWriterConstructorOptions#compressionMethod} and
+ * {@link ZipWriterAddDataOptions#uncompressedSize}, are always the ones of the original entries.
+ *
+ * The {@link ZipWriterConstructorOptions#password} option encrypts the exported zip file. It never
+ * decrypts the entries being exported: the password of an entry imported from an encrypted zip file
+ * must be passed in the {@link ZipDirectoryEntryExportOptions#readerOptions} option instead.
+ *
+ * Likewise, the {@link ZipWriterConstructorOptions#passThrough} option describes the data returned
+ * by the Reader instances. Exporting entries imported from a zip file as-is is done with the
+ * {@link ZipReaderOptions#passThrough} option in the
+ * {@link ZipDirectoryEntryExportOptions#readerOptions} option instead. Setting it here throws an
+ * {@link ERR_INVALID_PASS_THROUGH} error, unless the {@link ZipWriterAddDataOptions#uncompressedSize}
+ * option of every entry holding content is known.
+ *
+ * Exporting entries as-is and setting the {@link ZipWriterConstructorOptions#password} option throws an
+ * {@link ERR_UNSUPPORTED_ENCRYPTION_PASS_THROUGH} error, since the data of these entries is copied
+ * verbatim and cannot be encrypted. Entries imported from an encrypted zip file are an exception: they
+ * are exported as-is without error, and keep the password they were encrypted with.
+ *
+ * The {@link ZipWriterConstructorOptions#preventClose} option only applies when the caller owns the
+ * writable, i.e. when a {@link WritableWriter} instance is passed to
+ * {@link ZipDirectoryEntry#exportZip} or {@link ZipDirectoryEntry#exportWritable}. It is ignored by the
+ * other `{@link ZipDirectoryEntry}#export*()` methods, whose Writer instance can only return its data
+ * once its writable is closed.
  */
 export interface ZipDirectoryEntryExportOptions
   extends ZipWriterConstructorOptions,
@@ -3144,13 +3330,66 @@ export interface ZipDirectoryEntryExportOptions
    */
   mimeType?: string;
   /**
-   * The options passed to the Reader instances
+   * The function called each time an entry is written.
+   *
+   * @remarks
+   * This function reports the entries whereas {@link EntryDataOnprogressOptions#onprogress} reports the
+   * bytes. It is called once per entry, after the entry has been written, so `progress` reaches `total`
+   * when the last entry is written.
+   *
+   * When {@link ZipWriterConstructorOptions#bufferedWrite} is enabled, the entries are written
+   * concurrently: `progress` counts the entries written instead of giving the position of the entry in
+   * the zip file.
+   *
+   * @param progress The number of entries written.
+   * @param total The total number of entries.
+   * @param entry The entry written.
+   * @returns An empty promise or `undefined`.
+   */
+  onentryprogress?(
+    progress: number,
+    total: number,
+    entry: EntryMetaData
+  ): Promise<void> | void;
+  /**
+   * The global comment of the zip file, see {@link ZipWriter#close}.
+   *
+   * @remarks
+   * The {@link ZipWriterAddDataOptions#comment} option is the comment of an entry: setting it here
+   * comments every entry of the exported zip file instead of the zip file itself.
+   */
+  globalComment?: Uint8Array;
+  /**
+   * The function called for signing the central directory, see
+   * {@link ZipWriterCloseOptions#signCentralDirectory}.
+   *
+   * @param directory The raw data of the central directory records.
+   * @returns The data of the digital signature record.
+   */
+  signCentralDirectory?(
+    directory: Uint8Array
+  ): Uint8Array | PromiseLike<Uint8Array>;
+  /**
+   * The options passed to the Reader instances.
+   *
+   * @remarks
+   * The {@link ZipReaderOptions#password} option must be set here to export entries imported from an
+   * encrypted zip file, since the {@link ZipDirectoryEntryExportOptions#password} option sets the
+   * password used to encrypt the exported zip file instead.
+   *
+   * The {@link ZipReaderOptions#passThrough} option set here exports the entries imported from a zip
+   * file as-is, without decompressing and decrypting them, exactly as importing them with this option
+   * does. It is ignored by the entries added to the filesystem, which are compressed as usual.
    */
   readerOptions?: ZipReaderConstructorOptions;
 }
 
 /**
  * Represents the options passed to {@link ZipDirectoryEntry#exportFileSystemHandle} and {@link FS#exportFileSystemHandle}.
+ *
+ * @remarks
+ * The {@link ZipReaderOptions#preventClose} option is ignored: the export owns the writable of each
+ * file it creates and must close it for the data to be written.
  */
 export interface ZipDirectoryEntryExportFileSystemHandleOptions
   extends EntryGetDataOptions {
@@ -3165,6 +3404,15 @@ export interface ZipDirectoryEntryExportFileSystemHandleOptions
    * @defaultValue false
    */
   concurrent?: boolean;
+  /**
+   * The options passed to the Reader instances.
+   *
+   * @remarks
+   * These options override the ones passed at the top level. The {@link ZipReaderOptions#password}
+   * option can be set here or at the top level, unlike {@link ZipDirectoryEntryExportOptions} where
+   * the top-level password encrypts the exported zip file instead.
+   */
+  readerOptions?: ZipReaderConstructorOptions;
 }
 
 /**
@@ -3212,6 +3460,7 @@ export interface FS
     | "exportWritable"
     | "exportFileSystemHandle"
     | "exportZip"
+    | "getExportedSize"
     | "isPasswordProtected"
     | "checkPassword"
   > {}
@@ -3422,6 +3671,10 @@ export const ERR_INVALID_ENCRYPTION_STRENGTH: string;
  * Unsupported encryption in USDZ files error
  */
 export const ERR_UNSUPPORTED_ENCRYPTION_USDZ: string;
+/**
+ * Unsupported encryption in pass-through entries error
+ */
+export const ERR_UNSUPPORTED_ENCRYPTION_PASS_THROUGH: string;
 /**
  * Invalid format error
  */
@@ -3475,8 +3728,13 @@ export const ERR_ITERATOR_COMPLETED_TOO_SOON: string;
  * Undefined uncompressed size error
  */
 export const ERR_UNDEFINED_UNCOMPRESSED_SIZE: string;
+export const ERR_UNDETERMINED_SIZE: string;
 /**
  * Undefined reader error
+ *
+ * @remarks Thrown when adding an entry with the {@link ZipWriterConstructorOptions#passThrough} option set to `true`
+ * and no Reader instance: the headers of such an entry describe its content verbatim and would declare content that
+ * is not there. Directory entries are exempt, they have no content to write as-is.
  */
 export const ERR_UNDEFINED_READER: string;
 /**
@@ -3530,6 +3788,16 @@ export const ERR_INVALID_LEVEL: string;
  * would produce an archive that cannot be opened with the equivalent {@link ZipWriterConstructorOptions#password}.
  */
 export const ERR_INVALID_PASSWORD_TYPE: string;
+/**
+ * Invalid passThrough option error (thrown by `{@link ZipDirectoryEntry}#export*()` and
+ * {@link ZipDirectoryEntry#getExportedSize} when an entry would be written as-is without a known uncompressed size)
+ *
+ * @remarks The {@link ZipWriterConstructorOptions#passThrough} option describes the data returned by the Reader
+ * instances, which the filesystem API creates itself. Use the {@link ZipReaderOptions#passThrough} option in the
+ * {@link ZipDirectoryEntryExportOptions#readerOptions} option to export the entries imported from a zip file as-is,
+ * or set the {@link ZipWriterAddDataOptions#uncompressedSize} option of each entry holding compressed data.
+ */
+export const ERR_INVALID_PASS_THROUGH: string;
 /**
  * Entry already exists error (thrown by the filesystem API when adding an entry whose filename already exists)
  */