@zip.js/zip.js 2.11.4 → 2.12.0

package/index.d.ts

@@ -461,6 +461,8 @@ export interface Configuration extends WorkerConfiguration {
    * The base URL against which the relative URIs are resolved, i.e. {@link Configuration#workerURI},
    * {@link Configuration#wasmURI} and {@link CodecDefinition#codecURI}.
    *
+   * It must be a string, see {@link ERR_INVALID_BASE_URI}: it is posted to the web workers, and a `URL` object cannot be cloned.
+   *
    * @defaultValue the URL of the module of zip.js
    */
   baseURI?: string;
@@ -481,9 +483,13 @@ export interface Configuration extends WorkerConfiguration {
    * The worker is created as a module worker, unless the URI is a Data URI or a Blob URI, in which case it is created as a classic
    * worker. See {@link Configuration#createWorker} for an example of classic worker script installing a polyfill of the Streams API.
    *
+   * It can also be a function returning the URI, which is how the builds embedding the worker script produce it on demand. The
+   * function is called with `useBlobURI` set to `true` first, and called again with `false` when creating the worker from the Blob
+   * URI it returned failed, e.g. when the CSP of the page blocks Blob URIs. Anything else is rejected, see {@link ERR_INVALID_URI}.
+   *
    * @defaultValue "./core/web-worker-wasm.js", or "./core/web-worker-native.js" for the builds using the native implementations
    */
-  workerURI?: string;
+  workerURI?: string | ((useBlobURI: boolean) => string);
   /**
    * The function used to create the web workers, taking precedence over `workerURI`.
    *
@@ -524,9 +530,13 @@ export interface Configuration extends WorkerConfiguration {
    * });
    * ```
    *
+   * It can also be a function returning the URI, called the first time the module is needed. That is how the builds embedding the
+   * WebAssembly module produce their Data URI, and the way to defer an expensive resolution until it is known to be useful.
+   * Anything else is rejected, see {@link ERR_INVALID_URI}.
+   *
    * @defaultValue "./core/streams/zlib-wasm/zlib-streams.wasm"
    */
-  wasmURI?: string;
+  wasmURI?: string | (() => string);
   /**
    * The size of the chunks in bytes during data compression/decompression.
    *
@@ -572,6 +582,13 @@ export interface Configuration extends WorkerConfiguration {
 
 /**
  * Represents configuration passed to {@link configure}, the constructor of {@link ZipReader}, {@link FileEntry#getData}, the constructor of {@link ZipWriter}, and {@link ZipWriter#add}.
+ *
+ * @remarks
+ * The three options below are read as truthy values, they are not converted. Any non-empty string is therefore
+ * `true`, `"false"` and `"0"` included. This is deliberate, so that an expression such as
+ * `useWebWorkers: supported && enabled` keeps working, but it differs from the numeric options, which do accept
+ * the string a form control, a query string or an environment variable yields. A boolean read from one of those
+ * must be converted by the caller.
  */
 export interface WorkerConfiguration {
   /**
@@ -1095,6 +1112,9 @@ export interface WritableWriter {
    * updated as the data is written, so a writer needing the value (e.g. to compute the offset of a
    * disk) can read it. A value set before the first write is kept and used as the starting offset
    * instead of being reset to 0.
+   *
+   * It must therefore be assignable, see {@link ERR_WRITER_SIZE_NOT_WRITABLE}: a getter with no setter
+   * is rejected when the writer is passed, not once the first entry has been written.
    */
   size?: number;
   /**
@@ -1348,6 +1368,10 @@ export class ZipReaderStream<T> {
    * @remarks The properties deposited on an entry while its data is read, i.e.
    * {@link EntryMetaData#warnings} and {@link EntryMetaData#localDirectory}, are shared with the
    * chunk, so they are readable on it once its `readable` property has been consumed.
+   *
+   * An entry is decompressed on demand, when its `readable` property starts being read, so a chunk
+   * whose data is never read costs nothing and skipping entries is free. Cancelling this stream
+   * releases the entry being read, cancels the source and closes the underlying {@link ZipReader}.
    */
   readable: ReadableStream<
     Omit<Entry, "getData"> & { readable?: ReadableStream<Uint8Array> }
@@ -1479,6 +1503,8 @@ export class ZipReader<Type> {
    * one of them and the evidence is already in hand, the same reason string is deposited as a warning instead —
    * {@link WARNING_APPENDED_DATA}, {@link WARNING_PREPENDED_DATA}, {@link WARNING_TRAILING_CENTRAL_DIRECTORY_DATA},
    * {@link WARNING_DUPLICATE_FILENAME} and {@link WARNING_MISMATCHED_ZIP64_END_OF_CENTRAL_DIRECTORY}.
+   * {@link WARNING_MULTIPLE_END_OF_CENTRAL_DIRECTORY} is the one reason of that group which is never tolerated,
+   * so it is only ever the reason of an error.
    *
    * The warnings related to the local file header of an entry are deposited on
    * {@link EntryMetaData#warnings} when its data is read, not here.
@@ -1510,6 +1536,16 @@ export class ZipReader<Type> {
    * {@link ZipReader#getEntries} can therefore still be read after calling it.
    */
   close(): Promise<void>;
+  /**
+   * Calls {@link ZipReader#close}, making the instance usable with `await using`
+   *
+   * @remarks
+   * The method is only defined when the runtime provides `Symbol.asyncDispose`. Its declaration is
+   * ignored by TypeScript versions that do not declare the symbol either, i.e. before 5.2 or without
+   * the `esnext.disposable` library, so that the declarations of the library keep compiling there.
+   */
+  // @ts-ignore Symbol.asyncDispose is declared from TypeScript 5.2 with the esnext.disposable library
+  [Symbol.asyncDispose](): Promise<void>;
 }
 
 /**
@@ -1775,18 +1811,20 @@ export interface DirectoryEncryptionInfo {
 export interface ZipReaderOptions {
   /**
    * How tolerant the reader should be when the local file header of an entry disagrees with its central
-   * directory record. Any difference throws an {@link ERR_AMBIGUOUS_ARCHIVE} error.
+   * directory record.
    *
    * - `"strict"`: compare the filename, the general purpose bit flag, the compression method, the CRC-32
-   * checksum and the sizes.
-   * - `"balanced"`: compare everything except the filename.
-   * - `"tolerant"`: compare nothing and trust the central directory record.
+   * checksum and the sizes, and throw an {@link ERR_AMBIGUOUS_ARCHIVE} error on any difference.
+   * - `"balanced"`: compare everything except the filename, and throw on any difference.
+   * - `"tolerant"`: compare everything except the filename, and deposit the differences on
+   * {@link EntryMetaData#warnings} instead of throwing.
    *
    * Every field except the filename is read from the local file header anyway, to locate the entry data, so
    * the comparison `"balanced"` performs reads no additional bytes. Comparing the filename reads the filename
    * bytes as well, which costs one extra read per entry whenever the local file header carries no extra field
-   * — the common case in practice. Use {@link ZipReaderOptions#checkLocalDirectory} to request or suppress the
-   * whole comparison explicitly.
+   * — the common case in practice, and the reason the filename is left out below `"strict"`. Use
+   * {@link ZipReaderOptions#checkLocalDirectory} to request or suppress the whole comparison explicitly, and
+   * {@link ZipReaderOptions#checkLocalFilename} to include or exclude the filename on its own.
    *
    * @defaultValue "balanced"
    */
@@ -1809,21 +1847,40 @@ export interface ZipReaderOptions {
    */
   checkAmbiguity?: boolean;
   /**
-   * `true` to validate the local file header of the entry against its central directory record when calling
-   * {@link FileEntry#getData}, `false` to skip that validation. This is the entry-level half of
+   * `true` to reject the entry with an {@link ERR_AMBIGUOUS_ARCHIVE} error when its local file header
+   * disagrees with its central directory record while calling {@link FileEntry#getData}, `false` to deposit
+   * the differences on {@link EntryMetaData#warnings} instead. This is the entry-level half of
    * {@link ZipReaderOptions#checkAmbiguity}, exposed on its own so it can be enabled without the archive-level
    * checks and disabled without giving up the rest of {@link ZipReaderOptions#strictness}. It is the only way to
    * validate the local file headers of a self-extracting archive, since
    * {@link GetEntriesOptions#checkAmbiguity} rejects prepended data outright.
    *
    * `true` compares the filename as well, like {@link ZipReaderOptions#strictness} set to `"strict"`; `false`
-   * compares nothing, like `"tolerant"`. An explicit value takes precedence over the strictness default at
-   * every level.
+   * compares everything except the filename, like `"tolerant"`. Set
+   * {@link ZipReaderOptions#checkLocalFilename} to control the filename comparison on its own. An explicit
+   * value takes precedence over the strictness default at every level.
    *
    * @defaultValue `true` when {@link ZipReaderOptions#strictness} is `"strict"` or `"balanced"`, `false` when
    * it is `"tolerant"`.
    */
   checkLocalDirectory?: boolean;
+  /**
+   * `true` to compare the filename of the local file header with the one of the central directory record when
+   * calling {@link FileEntry#getData}, `false` to leave the filename out of that comparison.
+   *
+   * Comparing the filename costs one extra read per entry whenever the local file header carries no extra
+   * field, which is why it is left out below {@link ZipReaderOptions#strictness} set to `"strict"`. This option
+   * selects what is compared without changing whether a difference throws or warns, which
+   * {@link ZipReaderOptions#checkLocalDirectory} decides. It is therefore the only way to obtain
+   * {@link WARNING_MISMATCHED_LOCAL_FILE_HEADER_FILENAME} as a warning, with
+   * `{ checkLocalFilename: true, checkLocalDirectory: false }`, and the only way to keep every other check of
+   * `"strict"` without paying the extra read, with `{ checkLocalFilename: false, strictness: "strict" }`.
+   *
+   * @defaultValue the value of {@link ZipReaderOptions#checkLocalDirectory} when it is set, otherwise `true`
+   * when {@link ZipReaderOptions#strictness} is `"strict"` and `false` when it is `"balanced"` or
+   * `"tolerant"`.
+   */
+  checkLocalFilename?: boolean;
   /**
    * `true` to check only if the password is valid.
    *
@@ -1875,9 +1932,31 @@ export interface ZipReaderOptions {
    */
   password?: string;
   /**
-   * `true` to read the data as-is without decompressing it and without decrypting it.
+   * `true` to read the data as-is without decompressing it and without decrypting it, `"compressed"` to decrypt
+   * it without decompressing it.
+   *
+   * @remarks
+   * The codecs run in a fixed order, the data is decrypted and then decompressed, so this option selects how
+   * many of these two stages are skipped rather than which one. `"compressed"` therefore returns the data of the
+   * entry still compressed but no longer encrypted, and it is the only way to obtain it: the value `true` returns
+   * the stored bytes, which are still encrypted, and an unset value returns the content itself. Reading an entry
+   * which is not encrypted gives the same result with `true` and with `"compressed"`.
+   *
+   * Since the encryption is undone, `"compressed"` needs the {@link ZipReaderOptions#password} option and
+   * throws an {@link ERR_INVALID_PASSWORD} error when it is wrong, whereas `true` never looks at the password.
+   * The {@link ZipReaderOptions#checkAuthenticationCode} option applies as well. The
+   * {@link ZipReaderOptions#checkCrc32} option does not, since the CRC32 of the entry describes its
+   * content and the content is not decompressed.
+   *
+   * Two entries holding the same content encrypted with two different passwords have no bytes in common when
+   * they are read with `true`, because the salt is drawn per entry. Read with `"compressed"` they are identical,
+   * which is what makes it possible to compare the content of encrypted entries without decompressing them.
+   *
+   * A value which is neither a boolean, `"compressed"` nor unset throws an {@link ERR_INVALID_PASS_THROUGH_VALUE}
+   * error. The filesystem API copies entries verbatim and only accepts a boolean, see
+   * {@link ERR_UNSUPPORTED_PASS_THROUGH_VALUE}.
    */
-  passThrough?: boolean;
+  passThrough?: boolean | "compressed";
   /**
    * The password used to encrypt the content of the entry (raw).
    */
@@ -2189,9 +2268,11 @@ export interface LocalDirectory {
    * The filename of the entry stored in the local file header (raw), which is allowed to differ from
    * {@link EntryMetaData#rawFilename}.
    *
-   * Only defined when the local filename has been read, i.e. when the {@link ZipReaderOptions#strictness} option
-   * is set to `"strict"` or when the {@link ZipReaderOptions#checkLocalDirectory} option is set to `true`, since
-   * reading it costs one read the central directory does not need.
+   * Only defined when the local filename has been read, i.e. when the {@link ZipReaderOptions#checkLocalFilename}
+   * option is set to `true`, or is unset and either the {@link ZipReaderOptions#strictness} option is set to
+   * `"strict"` or the {@link ZipReaderOptions#checkLocalDirectory} option is set to `true`. Setting
+   * `checkLocalFilename` to `false` suppresses the read whatever the other two say, since reading it costs one
+   * read the central directory does not need.
    */
   rawFilename?: Uint8Array;
   /**
@@ -2280,6 +2361,19 @@ export interface EntryError extends Error {
    * `true` if the zip file is corrupted because the entry data could not be written entirely.
    */
   corruptedEntry?: boolean;
+  /**
+   * The number of bytes of the entry that reached the writer before the failure, set whenever a
+   * compression or decompression stream fails, i.e. on a corrupt entry, an invalid CRC32, a reader
+   * erroring mid-entry or an aborted signal.
+   *
+   * @remarks
+   * It is the counterpart of {@link EntryError#corruptedEntry}: the first says the entry is
+   * incomplete, this one says how much of it was written. zip.js reads it itself to keep the offsets
+   * of the entries written after the failed one correct, which is what makes the salvage described in
+   * {@link ZipWriter#close} possible, so it counts the bytes the writer actually received rather than
+   * the bytes the codec produced.
+   */
+  outputSize?: number;
   /**
    * The entry whose data overlaps the data of the entry being read, set on the
    * {@link ERR_OVERLAPPING_ENTRY} error raised by {@link ZipReaderOptions#checkOverlappingEntry}.
@@ -2625,14 +2719,18 @@ export interface EntryMetaData {
    * disabled, e.g. with `strictness: "tolerant"` — the local file header mismatches the enabled check rejects
    * with {@link ERR_AMBIGUOUS_ARCHIVE}: {@link WARNING_MISMATCHED_LOCAL_FILE_HEADER_BIT_FLAG},
    * {@link WARNING_MISMATCHED_LOCAL_FILE_HEADER_COMPRESSION_METHOD} and
-   * {@link WARNING_MISMATCHED_LOCAL_FILE_HEADER_CRC32_OR_SIZES}. The archive-level warnings are deposited on
-   * {@link ZipReader#warnings} instead.
+   * {@link WARNING_MISMATCHED_LOCAL_FILE_HEADER_CRC32_OR_SIZES}, plus
+   * {@link WARNING_MISMATCHED_LOCAL_FILE_HEADER_FILENAME} when
+   * {@link ZipReaderOptions#checkLocalFilename} is enabled on its own, since disabling
+   * {@link ZipReaderOptions#checkLocalDirectory} leaves the filename out of the comparison. The archive-level
+   * warnings are deposited on {@link ZipReader#warnings} instead.
    */
   warnings?: ArchiveWarning[];
 }
 
 /**
- * Represents a non-fatal diagnostic deposited on {@link ZipReader#warnings} or {@link EntryMetaData#warnings}.
+ * Represents a non-fatal diagnostic deposited on {@link ZipReader#warnings}, {@link EntryMetaData#warnings} or
+ * {@link ZipWriter#warnings}.
  */
 export interface ArchiveWarning {
   /**
@@ -2853,6 +2951,20 @@ export class ZipWriter<Type> {
    * `true` if the zip contains at least one entry that has been partially written.
    */
   readonly hasCorruptedEntries?: boolean;
+  /**
+   * The non-fatal diagnostics deposited while writing the entries, accumulated over the life of the instance.
+   *
+   * @remarks
+   * A warning reports an adjustment the writer made silently rather than failing, so what it produced is not
+   * what was asked for: {@link WARNING_COMPRESSION_UNAVAILABLE} when no deflate codec is available and the
+   * entries are stored instead, and {@link WARNING_CLAMPED_LAST_MODIFICATION_DATE} when a date outside the
+   * MS-DOS range is written and no extra field carries the original value.
+   *
+   * Each reason is deposited once, with the filename of the first entry it applied to, so an archive whose
+   * entries are all affected reports one warning rather than one per entry. Read it after the entries have been
+   * added; {@link ZipWriter#close} deposits none of its own.
+   */
+  warnings?: ArchiveWarning[];
 
   /**
    * Adds the entries of an existing zip file into the current zip. This method can be called at any
@@ -2919,7 +3031,10 @@ export class ZipWriter<Type> {
    * particular, Windows path separators ("\\") are not converted and become part of the filename,
    * which is interpreted inconsistently by zip tools, and leading or trailing whitespace is
    * preserved, which Windows filesystems cannot represent at the end of a name.
-   * @param reader The  {@link Reader} instance used to read the content of the entry.
+   * @param reader The {@link Reader} instance used to read the content of the entry. It can be
+   * omitted, or passed as `undefined` or `null`, to write an entry with no content: a directory, or
+   * an empty file. The two spellings are equivalent; `null` is the convenient one when the value
+   * comes from a conditional expression, as in a loop copying entries where directories have no data.
    * @param options The options.
    * @returns A promise resolving to an {@link EntryMetaData} instance.
    */
@@ -2931,7 +3046,8 @@ export class ZipWriter<Type> {
       | ReadableStream
       | Reader<unknown>[]
       | ReadableReader[]
-      | ReadableStream[],
+      | ReadableStream[]
+      | null,
     options?: ZipWriterAddDataOptions
   ): Promise<EntryMetaData>;
 
@@ -2959,11 +3075,29 @@ export class ZipWriter<Type> {
    * counts as reporting them: catching the error of this method and calling it again finalizes the
    * zip file without the failed entries.
    *
+   * Once the zip file has been finalized, calling this method again does nothing and returns the same
+   * content. Only a call that threw can be retried, which is what makes the salvage above possible.
+   *
    * @param comment The global comment of the zip file.
    * @param options The options.
    * @returns The content of the zip file.
    */
   close(comment?: Uint8Array, options?: ZipWriterCloseOptions): Promise<Type>;
+  /**
+   * Calls {@link ZipWriter#close}, making the instance usable with `await using`
+   *
+   * @remarks
+   * The zip file is therefore finalized when the block is left, including when it is left by an
+   * error: the entries written until then are readable, like the ones a salvaging
+   * {@link ZipWriter#close} keeps. Closing the instance explicitly to collect its content stays the
+   * common case, and the disposal that follows does nothing.
+   *
+   * The method is only defined when the runtime provides `Symbol.asyncDispose`. Its declaration is
+   * ignored by TypeScript versions that do not declare the symbol either, i.e. before 5.2 or without
+   * the `esnext.disposable` library, so that the declarations of the library keep compiling there.
+   */
+  // @ts-ignore Symbol.asyncDispose is declared from TypeScript 5.2 with the esnext.disposable library
+  [Symbol.asyncDispose](): Promise<void>;
 }
 
 /**
@@ -3009,23 +3143,72 @@ export interface ZipWriterAddDataOptions
    */
   centralExtraField?: Map<number, Uint8Array>;
   /**
-   * The uncompressed size of the entry. This option is ignored if the {@link ZipWriterConstructorOptions#passThrough} option is not set to `true`.
+   * The uncompressed size of the entry. This option is ignored if the {@link ZipWriterConstructorOptions#passThrough} option is unset
+   * or `false`. It is required when it is set to `true` or to `"compressed"`, since the size cannot be derived from data which is not
+   * decompressed.
    */
   uncompressedSize?: number;
   /**
-   * The CRC-32 checksum of the content. This option is ignored if the {@link ZipWriterConstructorOptions#passThrough} option is not set to `true`.
+   * The CRC-32 checksum of the content. This option is ignored if the {@link ZipWriterConstructorOptions#passThrough} option is unset
+   * or `false`, and it is the caller's to supply otherwise, since the checksum cannot be computed from data which is not decompressed.
    *
-   * When the entry is AES-encrypted (see {@link ZipWriterConstructorOptions#encrypted}), setting this option marks the entry as AE-1
-   * and stores the checksum in the entry headers, e.g. when copying an AE-1 entry read with the
-   * {@link ZipReaderOptions#passThrough} option. Otherwise, the entry is marked as AE-2 and the checksum fields are set to 0.
+   * When the entry is AES-encrypted, this option is only stored when the encryption stage is passed through too, i.e. when
+   * {@link ZipWriterConstructorOptions#passThrough} is set to `true` and the data is copied verbatim from an archive which already
+   * published the checksum (see {@link ZipWriterConstructorOptions#encrypted}). The entry is then marked as AE-1. When the option is
+   * set to `"compressed"` the writer performs the encryption itself, so storing the checksum of the content would disclose what that
+   * encryption hides: the option is ignored, the entry is marked as AE-2 and the checksum fields are set to 0. See the remarks of
+   * {@link ZipWriterConstructorOptions#password}.
    */
   crc32?: number;
   /**
-   * The signature (CRC32 checksum) of the content. This option is ignored if the {@link ZipWriterConstructorOptions#passThrough} option is not set to `true`.
+   * The signature (CRC32 checksum) of the content. This option is ignored if the {@link ZipWriterConstructorOptions#passThrough} option
+   * is unset or `false`.
    *
    * @deprecated Use {@link ZipWriterAddDataOptions#crc32} instead.
    */
   signature?: number;
+  /**
+   * The entry the data comes from, e.g. one returned by {@link ZipReader#getEntries}, used as a source of default values for the
+   * options describing it.
+   *
+   * @remarks
+   * Copying an entry from one zip file into another needs about ten options forwarded, and forwarding a subset of them corrupts the
+   * copy silently rather than throwing: the writer cannot tell that {@link EntryMetaData#compressionMethod} describes data it is
+   * about to store verbatim. This option hands it the entry instead, and the options describing that entry are read from it.
+   *
+   * {@link EntryMetaData#externalFileAttributes}, {@link EntryMetaData#versionMadeBy}, {@link EntryMetaData#comment},
+   * {@link EntryMetaData#lastModDate}, {@link EntryMetaData#creationDate}, {@link EntryMetaData#lastAccessDate},
+   * {@link EntryMetaData#internalFileAttributes}, {@link DirectoryEntry#directory}, {@link EntryMetaData#uid},
+   * {@link EntryMetaData#gid} and the extra fields of the entry which zip.js does not interpret itself are always read from it.
+   *
+   * {@link ZipWriterAddDataOptions#uncompressedSize}, {@link ZipWriterAddDataOptions#crc32},
+   * {@link EntryMetaData#compressionMethod}, {@link ZipWriterConstructorOptions#dataDescriptor} and
+   * {@link ZipWriterConstructorOptions#rawLastModDate} are read from it as well when the
+   * {@link ZipWriterConstructorOptions#passThrough} option is set, since the data is then stored as it is read.
+   * {@link ZipWriterConstructorOptions#encrypted}, {@link ZipWriterConstructorOptions#zipCrypto} and
+   * {@link ZipWriterConstructorOptions#encryptionStrength} are only read from it when that option is set to `true`, i.e. when the
+   * encryption stage is passed through too: with `"compressed"` the writer performs the encryption itself and the scheme is the
+   * caller's to choose, so carrying the scheme of the source over would rekey an entry into the very scheme it was read from.
+   *
+   * Every value read from the entry is a default against the options of the same {@link ZipWriter#add} call: an option written
+   * next to it wins. Against the options the {@link ZipWriter} was constructed with the precedence is the other way round, since
+   * the values read from the entry are merged into the options of the call, so a date pinned on the writer does not normalize a
+   * copied entry. Note that {@link ZipDirectoryEntry#exportZip} resolves the same conflict the opposite way, an export option
+   * overriding the metadata of an imported entry. The filename is not one of these values, it stays the
+   * first argument of {@link ZipWriter#add}, so an entry can be copied under another name.
+   *
+   * {@link ZipWriterConstructorOptions#encrypted} is one of the values read from the entry, so copying an encrypted entry with
+   * `passThrough` set to `true` takes the branch documented on that option: the ciphertext is written as-is and keeps the
+   * password it was encrypted with, while a {@link ZipWriterConstructorOptions#password} in scope encrypts the other entries
+   * only. Re-keying an entry is what `passThrough` set to `"compressed"` is for, since the encryption stage runs there.
+   *
+   * A value which is not an object throws an {@link ERR_INVALID_ENTRY} error, and changing the
+   * {@link ZipWriterConstructorOptions#lastModDate} of an entry encrypted with ZipCrypto throws an
+   * {@link ERR_ZIP_CRYPTO_LAST_MOD_DATE} error when the encryption stage is passed through as well, i.e. when
+   * {@link ZipWriterConstructorOptions#passThrough} is `true` rather than `"compressed"`. Under `"compressed"` the
+   * entry is encrypted again, or not encrypted at all, so the date is free to change. See the remarks of that option.
+   */
+  entry?: Entry;
 }
 
 /**
@@ -3094,9 +3277,13 @@ export interface ZipWriterConstructorOptions extends WorkerConfiguration {
    *
    * When no deflate implementation is available at all, i.e. the environment provides no usable
    * `CompressionStream` and the embedded implementation cannot be loaded, the entry is stored
-   * instead of being compressed rather than failing. The {@link EntryMetaData#compressionMethod} of
-   * the entry returned by {@link ZipWriter#add} is `0` in that case, which is how the fallback is
-   * detected.
+   * instead of being compressed rather than failing. The fallback is reported twice: the
+   * {@link EntryMetaData#compressionMethod} of the entry returned by {@link ZipWriter#add} is `0`,
+   * and {@link WARNING_COMPRESSION_UNAVAILABLE} is deposited on {@link ZipWriter#warnings}.
+   *
+   * When the {@link ZipWriterConstructorOptions#passThrough} option passes the compression stage through,
+   * nothing is compressed and this option declares the level bits of the general purpose bit flag instead,
+   * see the remarks of that option.
    *
    * @defaultValue 6
    */
@@ -3214,6 +3401,14 @@ export interface ZipWriterConstructorOptions extends WorkerConfiguration {
    *
    * When set to `false`, the maximum last modification date cannot exceed December 31, 2107 and the maximum accuracy is 2 seconds, dates being truncated to the whole second and odd seconds rounded up to the next even second.
    *
+   * @remarks Some zip-based formats forbid any extra field on a specific entry, which the default value of this
+   * option would write. OpenDocument requires its `mimetype` entry to come first, to be stored without compression
+   * and to carry no extra field, so a conformant ODF package needs both this option set to `false` and
+   * {@link ZipWriterConstructorOptions#level} set to `0` on that entry. EPUB asks for the same pair: OCF states
+   * that the `mimetype` file must not be compressed or encrypted and that there must not be an extra field in its
+   * ZIP header, which is what pins the byte offset of `application/epub+zip` so a reader can sniff the format
+   * without parsing the archive, and epubcheck reports an extra field there as an error.
+   *
    * @defaultValue true
    */
   extendedTimestamp?: boolean;
@@ -3263,15 +3458,24 @@ export interface ZipWriterConstructorOptions extends WorkerConfiguration {
    * `true` to mark the file names as UTF-8 setting the general purpose bit 11 in the header (see Appendix D -
    * Language Encoding (EFS)), `false` to mark the names as compliant with the original IBM Code Page 437.
    *
-   * Note that this option only sets the flag, it does not ensure that the file names are in the correct
-   * encoding: when it is set to `false`, the names are still encoded in UTF-8 unless the
+   * By default the flag is derived from the content: it is set when the encoded name or the encoded comment
+   * of the entry holds a byte outside printable ASCII, and cleared otherwise. Printable ASCII is spelled
+   * identically in UTF-8 and in Code Page 437, so the flag carries no information there, and every other
+   * writer decides it the same way. A control character is not printable ASCII: Code Page 437 maps the bytes
+   * 0x01 to 0x1f and the byte 0x7f to the IBM graphic characters rather than to the control characters
+   * themselves, so a name or a comment holding one of them keeps the flag and stays readable. The comment is
+   * part of the test because the flag announces its encoding too, so deriving from the name alone would
+   * mislabel an ASCII name carrying a comment written in another language.
+   *
+   * Note that setting this option only sets the flag, it does not ensure that the file names are in the
+   * correct encoding: when it is set to `false`, the names are still encoded in UTF-8 unless the
    * {@link ZipWriterConstructorOptions#encodeText} option is also set to encode them in the intended code page.
    * Setting it to `false` alone therefore produces an archive whose file names are mislabeled, holding UTF-8
    * bytes announced as Code Page 437: the names holding characters outside of ASCII are decoded incorrectly
    * by the readers honoring the flag, including {@link ZipReader} unless
    * {@link GetEntriesOptions#filenameEncoding} is set to `"utf-8"`.
    *
-   * @defaultValue true
+   * @defaultValue `true` when the encoded name or comment holds a byte outside ASCII, `false` otherwise
    */
   useUnicodeFileNames?: boolean;
   /**
@@ -3426,20 +3630,49 @@ export interface ZipWriterConstructorOptions extends WorkerConfiguration {
    */
   usdz?: boolean;
   /**
-   * `true` to write the data as-is without compressing it and without crypting it.
+   * `true` to write the data as-is without compressing it and without crypting it, `"compressed"` to encrypt it
+   * without compressing it.
    *
    * @remarks
-   * The data is never compressed, so the {@link ZipWriterConstructorOptions#level} option does not apply and is
-   * ignored. The {@link ZipWriterAddDataOptions#compressionMethod} option selects no codec either, it declares
-   * how the data is already compressed and is written as-is in the entry headers. It must be set, otherwise an
-   * {@link ERR_UNDEFINED_COMPRESSION_METHOD} error is thrown. The entries with no content, e.g. the
-   * directories, ignore this option entirely. Setting the {@link ZipWriterConstructorOptions#password} or the
+   * The data is never compressed, so the {@link ZipWriterConstructorOptions#level} option selects no codec, and
+   * neither does the {@link ZipWriterAddDataOptions#compressionMethod} option: both describe how the data is
+   * already compressed and are written as-is in the entry headers, the method in its own field and the level in
+   * the level bits of the general purpose bit flag. The method must be set, otherwise an
+   * {@link ERR_UNDEFINED_COMPRESSION_METHOD} error is thrown; the level is optional and leaves those bits unset.
+   * The {@link ZipWriterAddDataOptions#crc32} option must be set as well, otherwise an {@link ERR_UNDEFINED_CRC32}
+   * error is thrown, unless the entry is written as AES in AE-2 format, which stores no checksum.
+   *
+   * The level is read from the options of the entry only. A level set on the options of the writer applies to
+   * the entries the writer compresses itself and is not inherited here, since it would describe data the writer
+   * never produced. A stored entry carries no level bits either way, they describe a deflate stream.
+   *
+   * 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.
    *
+   * The codecs run in a fixed order, the data is compressed and then encrypted, so this option selects how many
+   * of these two stages are skipped rather than which one. `"compressed"` declares that the data is already
+   * compressed but not yet encrypted, so the compression stage is skipped and the encryption stage runs: it
+   * encrypts an entry without recompressing it, which is what the `true` value cannot express and why it rejects
+   * a password. The {@link ZipWriterAddDataOptions#uncompressedSize} and
+   * {@link ZipWriterAddDataOptions#compressionMethod} options are still the caller's to declare, since neither
+   * can be derived from data which is not decompressed.
+   *
+   * The CRC32 of the entry cannot be computed either, so the {@link ZipWriterAddDataOptions#crc32} option is
+   * the caller's to declare as well. It is written as-is for an entry which is not AES-encrypted, i.e. for a
+   * plain or a ZipCrypto entry, both of which store the checksum in clear anyway. It is dropped for an
+   * AES-encrypted entry, which is marked AE-2 with the checksum fields set to 0: the encryption stage runs
+   * here, so this is a new encryption, and a stored plaintext checksum would let an attacker verify guessed
+   * content without knowing the password. Only the `true` value may mark an entry AE-1, and only because the
+   * data is then copied verbatim from an archive which already published that checksum.
+   *
+   * A value which is neither a boolean, `"compressed"` nor unset throws an {@link ERR_INVALID_PASS_THROUGH_VALUE}
+   * error. The filesystem API copies entries verbatim and only accepts a boolean, see
+   * {@link ERR_UNSUPPORTED_PASS_THROUGH_VALUE}.
+   *
    * When the data was encrypted with ZipCrypto, the verification byte stored in the encrypted data depends on
    * the last modification date of the source entry if the data descriptor is used. The
    * {@link ZipWriterConstructorOptions#dataDescriptor} and {@link ZipWriterConstructorOptions#rawLastModDate}
@@ -3447,9 +3680,12 @@ export interface ZipWriterConstructorOptions extends WorkerConfiguration {
    * {@link ERR_INVALID_PASSWORD} error. The filesystem API forwards them when exporting entries and throws an
    * {@link ERR_ZIP_CRYPTO_LAST_MOD_DATE} error if the date is overridden.
    */
-  passThrough?: boolean;
+  passThrough?: boolean | "compressed";
   /**
    * `true` to write encrypted data when `passThrough` is set to `true`.
+   *
+   * @remarks It declares that the data is already encrypted, so it does not apply when `passThrough` is set to
+   * `"compressed"`, which encrypts the data itself.
    */
   encrypted?: boolean;
   /**
@@ -4125,16 +4361,36 @@ export class ZipDirectoryEntry extends ZipEntry {
   /**
    * Creates a zip file via a custom {@link Writer} instance containing the entry and its descendants
    *
-   * @param writer The {@link Writer} instance.
+   * @remarks A {@link ZipWriter} instance can be passed instead of a {@link Writer}, the symmetric
+   * counterpart of passing a {@link ZipReader} to {@link ZipDirectoryEntry#importZip}. The entries are
+   * added to that writer and the archive is left open, so the caller closes it with
+   * {@link ZipWriter#close} and can add entries of its own before or after, export several trees into
+   * one archive, and read {@link ZipWriter#warnings}, which is otherwise unreachable through the
+   * filesystem API. The options of that writer keep governing the entries, exactly as they do for a
+   * direct call to {@link ZipWriter#add}, and the options passed here take precedence over them. The
+   * options that only apply when the writer is created are ignored. `bufferedWrite` is not one of
+   * them, it is honored here as it is on {@link ZipWriter#add}; what differs is its default, which
+   * the export sets to `true` only for a writer it creates itself. A supplied writer therefore
+   * buffers only when the option is passed here or to its own constructor.
+   *
+   * The archive is closed by the caller, so everything that happens at close time is the caller's to pass to
+   * {@link ZipWriter#close}, and passing it here instead does nothing. That covers
+   * {@link ZipDirectoryEntryExportOptions#globalComment}, which is the first argument of that method, and
+   * {@link ZipWriterCloseOptions#signCentralDirectory}, which is one of its options. Both describe the whole
+   * archive rather than the exported tree, so an archive composed of several trees carries one of each,
+   * written by the single {@link ZipWriter#close} call that finalizes it.
+   *
+   * @param writer The {@link Writer} instance, or the {@link ZipWriter} instance to add the entries to.
    * @param options  The options.
-   * @returns A promise resolving to the data.
+   * @returns A promise resolving to the data, or to the {@link ZipWriter} instance it was passed.
    */
   exportZip(
     writer:
       | Writer<unknown>
       | WritableWriter
       | WritableStream
-      | AsyncGenerator<Writer<unknown> | WritableWriter | WritableStream>,
+      | AsyncGenerator<Writer<unknown> | WritableWriter | WritableStream>
+      | ZipWriter<unknown>,
     options?: ZipDirectoryEntryExportOptions
   ): Promise<unknown>;
   /**
@@ -4142,7 +4398,10 @@ export class ZipDirectoryEntry extends ZipEntry {
    * 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
+   * will not match. The computation assumes the export creates the writer, where `bufferedWrite`
+   * defaults to `true`; a {@link ZipWriter} passed to {@link ZipDirectoryEntry#exportZip} defaults
+   * it to `false` instead, which adds a data descriptor to every entry, so pass the value that
+   * writer uses here too. 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.
    *
@@ -4155,13 +4414,20 @@ export class ZipDirectoryEntry extends ZipEntry {
    * {@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. A name holding `"/"` creates the
-   * directories it names, so `addText("a/b.txt", text)` builds a tree whose children are not all
-   * files, even though the directories created that way are not written. It is thrown as well when
+   * entry, and when the archive exceeds 4GB and the order could change the result, since the
+   * offsets recorded in the central directory are then extended to 64 bits. Entries of equal size
+   * put the same entries past 4GB whatever the order, so they stay determinable unless they differ
+   * in whether they already carry a zip64 field, which changes the cost of crossing that boundary.
+   * Passing `bufferedWrite: false` makes both determinable again, as does exporting a tree holding no
+   * directory that was added explicitly and has children: the directories a name holding `"/"` creates are
+   * exempt, so `addText("a/b.txt", text)` stays determinable, while `addDirectory("a")` followed by two
+   * `addText` calls on it does not. It is thrown as well when
    * `signCentralDirectory` is set, the length of the signature being unknown until it is computed.
    *
+   * An entry asking for compression is stored instead when no deflate implementation is reachable,
+   * which is what the export writes as well. Its size is determinable then, so the same call throws
+   * on a platform carrying deflate and returns a size on one that does not.
+   *
    * @param options The options.
    * @returns A promise resolving to the size in bytes.
    * @throws {@link ERR_UNDETERMINED_SIZE} if the size cannot be determined.
@@ -4173,7 +4439,15 @@ export class ZipDirectoryEntry extends ZipEntry {
  * Represents the options passed to `{@link ZipDirectoryEntry}#import*()`.
  */
 export interface ZipDirectoryEntryImportOptions
-  extends ZipReaderConstructorOptions {
+  extends Omit<ZipReaderConstructorOptions, "passThrough"> {
+  /**
+   * `true` to import the entries of the zip file as-is, without decompressing and decrypting them
+   *
+   * @remarks Only a boolean, where {@link ZipReaderOptions#passThrough} also takes `"compressed"`: the
+   * filesystem copies each entry through a writer, which has nowhere to put content that is still
+   * compressed. `"compressed"` throws an {@link ERR_UNSUPPORTED_PASS_THROUGH_VALUE} error.
+   */
+  passThrough?: boolean;
   /**
    * The policy applied when two entries of the imported zip file claim the same node of the tree
    *
@@ -4296,12 +4570,20 @@ export interface ZipDirectoryEntryExportOptions
    * @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.
+   *
+   * Ignored by {@link ZipDirectoryEntry#exportZip} when it is given a {@link ZipWriter}, since the archive is
+   * then closed by the caller: pass it to {@link ZipWriter#close} instead.
    */
   globalComment?: Uint8Array;
   /**
    * The function called for signing the central directory, see
    * {@link ZipWriterCloseOptions#signCentralDirectory}.
    *
+   * @remarks
+   * Ignored by {@link ZipDirectoryEntry#exportZip} when it is given a {@link ZipWriter}, since the archive is
+   * then closed by the caller: pass it to {@link ZipWriter#close} instead, which also keeps a single signature
+   * over an archive composed of several exported trees.
+   *
    * @param directory The raw data of the central directory records.
    * @returns The data of the digital signature record.
    */
@@ -4322,7 +4604,7 @@ export interface ZipDirectoryEntryExportOptions
    *
    * A value which is neither an object nor unset throws an {@link ERR_INVALID_READER_OPTIONS} error.
    */
-  readerOptions?: ZipReaderConstructorOptions;
+  readerOptions?: Omit<ZipReaderConstructorOptions, "passThrough"> & { passThrough?: boolean };
 }
 
 /**
@@ -4355,7 +4637,7 @@ export interface ZipDirectoryEntryExportFileSystemHandleOptions
    *
    * A value which is neither an object nor unset throws an {@link ERR_INVALID_READER_OPTIONS} error.
    */
-  readerOptions?: ZipReaderConstructorOptions;
+  readerOptions?: Omit<ZipReaderConstructorOptions, "passThrough"> & { passThrough?: boolean };
 }
 
 /**
@@ -4488,6 +4770,14 @@ export const fs: {
  * HTTP range error
  */
 export const ERR_HTTP_RANGE: string;
+/**
+ * HTTP status error (thrown by {@link HttpReader} when the server answers with a status other than 2xx, except
+ * 416, which throws {@link ERR_HTTP_RANGE} instead)
+ *
+ * @remarks This message is a prefix: the status text, or the status code when the server sends none, is
+ * appended to it, so it is matched with `String#startsWith` rather than with an equality test.
+ */
+export const ERR_HTTP_STATUS: string;
 /**
  * HTTP resource changed while being read error
  */
@@ -4630,6 +4920,27 @@ export const ERR_INVALID_SIGNAL: string;
  * {@link Configuration#useWebWorkers} set to `false` to compress and decompress data in the main thread instead.
  */
 export const ERR_INVALID_MAX_WORKERS: string;
+/**
+ * Invalid baseURI error
+ *
+ * @remarks
+ * Thrown by {@link configure} when {@link Configuration#baseURI} is neither falsy nor a string. A `URL` object used to be
+ * accepted here, because `new URL(uri, baseURI)` stringifies its base, and then failed much later with a `DataCloneError`
+ * the first time a web worker ran, since the base URL is posted to it. Unlike {@link Configuration#workerURI} and
+ * {@link Configuration#wasmURI}, it cannot be a function: it is resolved before any URI is.
+ */
+export const ERR_INVALID_BASE_URI: string;
+/**
+ * Invalid URI error
+ *
+ * @remarks
+ * Thrown by {@link configure} when {@link Configuration#workerURI} or {@link Configuration#wasmURI} is neither falsy, a string,
+ * nor a function. A function is not called at that point, so what it returns is not validated here: one returning something
+ * other than a string fails later and quietly, when loading the worker throws and the codecs fall back to the main thread.
+ * A falsy value keeps meaning "no worker" and "no WebAssembly module", which is how the
+ * entry points excluding them unset their URI.
+ */
+export const ERR_INVALID_URI: string;
 /**
  * Invalid version error
  */
@@ -4747,12 +5058,23 @@ export const ERR_UNDEFINED_UNCOMPRESSED_SIZE: string;
  * Undefined compression method error
  */
 export const ERR_UNDEFINED_COMPRESSION_METHOD: string;
+/**
+ * Undefined CRC32 error (thrown by {@link ZipWriter#add} when the {@link ZipWriterConstructorOptions#passThrough}
+ * option is set and the {@link ZipWriterAddDataOptions#crc32} option is unset on an entry which stores a checksum)
+ *
+ * @remarks The checksum cannot be computed from data which is not decompressed, and every entry stores one except
+ * an AES entry in AE-2 format, so writing the data as-is without declaring it would store a zero which other tools
+ * reject. Copying an entry read with the {@link ZipReaderOptions#passThrough} option set to `"compressed"` from an
+ * AE-2 source into an entry which is not AES-encrypted is therefore refused rather than written: that source
+ * published no checksum to carry over.
+ */
+export const ERR_UNDEFINED_CRC32: 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
+ * or to `"compressed"` 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;
@@ -4769,6 +5091,15 @@ export const ERR_INVALID_READER: string;
  * Writer not initialized error
  */
 export const ERR_WRITER_NOT_INITIALIZED: string;
+/**
+ * Invalid writer size error
+ *
+ * @remarks
+ * Thrown when {@link WritableWriter#size} cannot be assigned, e.g. when it is a getter with no setter, a read-only
+ * property or a frozen object. zip.js writes the number of bytes written into that property, so a writer refusing the
+ * assignment used to fail with a bare `TypeError` from the engine, and only once the first entry had been written.
+ */
+export const ERR_WRITER_SIZE_NOT_WRITABLE: string;
 /**
  * Zip file not empty error
  */
@@ -4828,6 +5159,28 @@ export const ERR_INVALID_PASSWORD_TYPE: string;
  * or set the {@link ZipWriterAddDataOptions#uncompressedSize} option of each entry holding compressed data.
  */
 export const ERR_INVALID_PASS_THROUGH: string;
+/**
+ * Invalid passThrough value error (thrown by {@link ZipReader#getEntries}, {@link FileEntry#getData} and
+ * {@link ZipWriter#add} when the {@link ZipReaderOptions#passThrough} or the
+ * {@link ZipWriterConstructorOptions#passThrough} option is neither a boolean, `"compressed"` nor unset)
+ *
+ * @remarks The option accepts a fixed set of values rather than any truthy one, because a misspelled string would
+ * otherwise pass both codec stages through and produce an archive holding data which is not the data the caller
+ * meant to write, with no error at any point.
+ */
+export const ERR_INVALID_PASS_THROUGH_VALUE: string;
+/**
+ * Unsupported passThrough value error (thrown by {@link ZipDirectoryEntry#importZip} and by
+ * `{@link ZipDirectoryEntry}#export*()` when the {@link ZipReaderOptions#passThrough} option is set to
+ * `"compressed"`)
+ *
+ * @remarks The filesystem API copies the entries of an imported zip file verbatim, forwarding the encryption
+ * metadata of each source entry to the Writer. Data which has been decrypted but not decompressed would be written
+ * under that metadata, i.e. an archive whose entries are marked encrypted over content which is not, so the value
+ * is refused rather than accepted and mishandled. Use {@link FileEntry#getData} and {@link ZipWriter#add} directly
+ * to decrypt an entry without decompressing it.
+ */
+export const ERR_UNSUPPORTED_PASS_THROUGH_VALUE: string;
 /**
  * Invalid readerOptions error (thrown by `{@link ZipDirectoryEntry}#export*()`,
  * {@link ZipDirectoryEntry#getExportedSize} and {@link ZipDirectoryEntry#exportFileSystemHandle} when the
@@ -4839,9 +5192,16 @@ export const ERR_INVALID_PASS_THROUGH: string;
  */
 export const ERR_INVALID_READER_OPTIONS: string;
 /**
- * Locked last modification date error (thrown by `{@link ZipDirectoryEntry}#export*()` and
- * {@link ZipDirectoryEntry#getExportedSize} when the date of an entry encrypted with ZipCrypto and exported with
- * {@link ZipReaderOptions#passThrough} set in {@link ZipDirectoryEntryExportOptions#readerOptions} is changed)
+ * Invalid entry error (thrown by {@link ZipWriter#add} when the {@link ZipWriterAddDataOptions#entry} option is
+ * neither an entry nor unset)
+ */
+export const ERR_INVALID_ENTRY: string;
+/**
+ * Locked last modification date error (thrown by {@link ZipWriter#add} when the date of an entry encrypted with
+ * ZipCrypto is changed while it is copied with the {@link ZipWriterConstructorOptions#passThrough} option set, and
+ * by `{@link ZipDirectoryEntry}#export*()` and {@link ZipDirectoryEntry#getExportedSize} when the date of such an
+ * entry exported with {@link ZipReaderOptions#passThrough} set in
+ * {@link ZipDirectoryEntryExportOptions#readerOptions} is changed)
  *
  * @remarks The ZipCrypto encryption header embeds a password verification byte derived from the time of the
  * entry: the encrypted data, copied as-is, only decrypts when the time in the rewritten headers still matches.
@@ -4868,8 +5228,28 @@ export const ERR_INVALID_DUPLICATES: string;
  */
 export const ERR_READABLE_CONSUMED: string;
 /**
- * Aborted operation error (thrown by {@link ZipDirectoryEntry#exportFileSystemHandle} when it is aborted via
- * {@link ZipReaderOptions#signal} on platforms which do not support the `reason` argument of
+ * Ancestor entry error (thrown by {@link ZipFS#move} and {@link ZipEntry#rename} when the destination is the
+ * moved entry itself or one of its descendants, which would detach the moved subtree from the tree)
+ */
+export const ERR_ANCESTOR_ENTRY: string;
+/**
+ * Root directory move error (thrown by {@link ZipFS#move} when the entry being moved is the root of the
+ * filesystem, which has no parent to be detached from)
+ */
+export const ERR_ROOT_DIRECTORY_NOT_MOVABLE: string;
+/**
+ * Target entry not a directory error (thrown by {@link ZipFS#move} when the destination entry is a file)
+ */
+export const ERR_TARGET_NOT_DIRECTORY: string;
+/**
+ * Parent entry not a directory error (thrown by the `add*()` methods of {@link ZipDirectoryEntry} when they are
+ * called on an entry that is not a directory)
+ */
+export const ERR_PARENT_NOT_DIRECTORY: string;
+/**
+ * Aborted operation error (thrown by {@link FileEntry#getData}, {@link ZipWriter#add} and
+ * {@link ZipDirectoryEntry#exportFileSystemHandle} when they are aborted via {@link ZipReaderOptions#signal} or
+ * {@link ZipWriterAddDataOptions#signal} on platforms which do not support the `reason` argument of
  * `AbortController#abort()`)
  *
  * @remarks The reason passed by the caller is discarded by these platforms and cannot be recovered, so a
@@ -4957,6 +5337,19 @@ export const WARNING_DUPLICATE_FILENAME: string;
  * both (see {@link ZipReader#warnings}); the reason of {@link ERR_AMBIGUOUS_ARCHIVE} under `strictness: "strict"`
  */
 export const WARNING_MISMATCHED_ZIP64_END_OF_CENTRAL_DIRECTORY: string;
+/**
+ * Warning reason: more than one end of central directory record reaches the end of the file, so another reader
+ * may select a different one and list different entries; the reason of {@link ERR_AMBIGUOUS_ARCHIVE} when
+ * {@link ZipReaderOptions#checkAmbiguity} is enabled
+ */
+export const WARNING_MULTIPLE_END_OF_CENTRAL_DIRECTORY: string;
+/**
+ * Warning reason: the filename of the local file header contradicts the central directory; the reason of
+ * {@link ERR_AMBIGUOUS_ARCHIVE} when {@link ZipReaderOptions#checkLocalDirectory} is enabled, and deposited on
+ * {@link EntryMetaData#warnings} when {@link ZipReaderOptions#checkLocalFilename} is enabled while
+ * {@link ZipReaderOptions#checkLocalDirectory} is disabled
+ */
+export const WARNING_MISMATCHED_LOCAL_FILE_HEADER_FILENAME: string;
 /**
  * Warning reason: the general purpose bit flag of the local file header contradicts the central directory
  * (see {@link EntryMetaData#warnings}); the reason of {@link ERR_AMBIGUOUS_ARCHIVE} when
@@ -4975,3 +5368,19 @@ export const WARNING_MISMATCHED_LOCAL_FILE_HEADER_COMPRESSION_METHOD: string;
  * {@link ZipReaderOptions#checkLocalDirectory} is enabled
  */
 export const WARNING_MISMATCHED_LOCAL_FILE_HEADER_CRC32_OR_SIZES: string;
+/**
+ * Warning reason: no deflate codec is available, so the entry is stored instead of being compressed
+ * (see {@link ZipWriter#warnings} and {@link EntryMetaData#compressionMethod})
+ */
+export const WARNING_COMPRESSION_UNAVAILABLE: string;
+/**
+ * Warning reason: the last modification date is outside the range the MS-DOS field can hold, i.e. before 1980
+ * or after 2107, and no extra field carries the original value, so the date written is the nearest bound
+ * (see {@link ZipWriter#warnings} and {@link EntryMetaData#lastModDate})
+ *
+ * @remarks {@link ZipWriterConstructorOptions#extendedTimestamp} is enabled by default and preserves the
+ * original value, so this reason only appears when no extra field is left to carry it: when it and
+ * {@link ZipWriterConstructorOptions#ntfsTimestamp} are both disabled, and also when the date falls outside
+ * the range an extended timestamp can hold, 1901-12-13 to 2038-01-19, and `ntfsTimestamp` alone is disabled.
+ */
+export const WARNING_CLAMPED_LAST_MODIFICATION_DATE: string;