@zip.js/zip.js
    Preparing search index...

    Interface ZipReaderConstructorOptions

    Represents the options passed to the constructor of ZipReader, and {@link ZipDirectory}#import*.

    interface ZipReaderConstructorOptions {
        checkAmbiguity?: boolean;
        checkAuthenticationCode?: boolean;
        checkCrc32?: boolean;
        checkLocalDirectory?: boolean;
        checkLocalFilename?: boolean;
        checkOverlappingEntry?: boolean;
        checkOverlappingEntryOnly?: boolean;
        checkPasswordOnly?: boolean;
        checkSignature?: boolean;
        commentEncoding?: string;
        extractAppendedData?: boolean;
        extractPrependedData?: boolean;
        filenameEncoding?: string;
        filenameValidation?: "balanced" | "strict" | "tolerant";
        maxAppendedDataSize?: number;
        passThrough?: boolean | "compressed";
        password?: string;
        preventClose?: boolean;
        rawPassword?: Uint8Array<ArrayBufferLike>;
        signal?: AbortSignal;
        strictness?: "balanced" | "strict" | "tolerant";
        transferStreams?: boolean;
        useCompressionStream?: boolean;
        useWebWorkers?: boolean;
        decodeText?(
            value: Uint8Array,
            encoding: string,
            type: "filename" | "comment",
        ): string | undefined;
        decryptCentralDirectory?(
            data: Uint8Array,
            encryptionInfo?: DirectoryEncryptionInfo,
        ): Uint8Array<ArrayBufferLike> | PromiseLike<Uint8Array<ArrayBufferLike>>;
        normalizeFilename?(filename: string): string | undefined;
    }

    Hierarchy (View Summary)

    Index
    checkAmbiguity?: boolean

    true to throw an ERR_AMBIGUOUS_ARCHIVE error when calling FileEntry#getData if the local file header of the entry disagrees with its central directory record in a way that could make other tools (e.g. streaming readers based on local file headers) interpret the entry differently. This detects mismatched filenames, general purpose bit flags (encryption, data descriptor and language encoding flags), compression methods, CRC-32 checksums and sizes. The extra fields are not compared because the zip specification allows them to differ.

    This is the boolean form of ZipReaderOptions#strictness: true means "strict" and false means any value but "strict". When both options are set, the value passed to FileEntry#getData takes precedence over the value passed to the constructor of ZipReader, and strictness takes precedence over checkAmbiguity when both are set at the same level. false downgrades an inherited "strict" value to "balanced" and leaves an inherited "tolerant" value unchanged.

    false
    
    checkAuthenticationCode?: boolean

    true to verify the authentication code of entries encrypted with AES. The verification detects encrypted data tampered or corrupted after the encryption.

    true
    
    checkCrc32?: boolean

    true to verify the CRC-32 checksum of the entry against the value stored in the zip file. The verification is run on the decompressed data and covers the whole read pipeline. It also applies to entries encrypted with AES in AE-1 format. It is skipped for entries in AE-2 format because they store a zeroed CRC-32 value.

    false
    
    checkLocalDirectory?: boolean

    true to reject the entry with an ERR_AMBIGUOUS_ARCHIVE error when its local file header disagrees with its central directory record while calling FileEntry#getData, false to deposit the differences on EntryMetaData#warnings instead. This is the entry-level half of ZipReaderOptions#checkAmbiguity, exposed on its own so it can be enabled without the archive-level checks and disabled without giving up the rest of ZipReaderOptions#strictness. It is the only way to validate the local file headers of a self-extracting archive, since GetEntriesOptions#checkAmbiguity rejects prepended data outright.

    true compares the filename as well, like ZipReaderOptions#strictness set to "strict"; false compares everything except the filename, like "tolerant". Set ZipReaderOptions#checkLocalFilename to control the filename comparison on its own. An explicit value takes precedence over the strictness default at every level.

    true when ZipReaderOptions#strictness is "strict" or "balanced", false when it is "tolerant".

    checkLocalFilename?: boolean

    true to compare the filename of the local file header with the one of the central directory record when calling 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 ZipReaderOptions#strictness set to "strict". This option selects what is compared without changing whether a difference throws or warns, which ZipReaderOptions#checkLocalDirectory decides. It is therefore the only way to obtain 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" }.

    the value of ZipReaderOptions#checkLocalDirectory when it is set, otherwise true when ZipReaderOptions#strictness is "strict" and false when it is "balanced" or "tolerant".

    checkOverlappingEntry?: boolean

    true to throw an ERR_OVERLAPPING_ENTRY error when calling FileEntry#getData if the entry overlaps with another entry on which FileEntry#getData has already been called (with the option checkOverlappingEntry or checkOverlappingEntryOnly set to true).

    false
    
    checkOverlappingEntryOnly?: boolean

    true to throw an ERR_OVERLAPPING_ENTRY error when calling FileEntry#getData if the entry overlaps with another entry on which FileEntry#getData has already been called (with the option checkOverlappingEntry or checkOverlappingEntryOnly set to true) without trying to read the content of the entry.

    false
    
    checkPasswordOnly?: boolean

    true to check only if the password is valid.

    false
    
    checkSignature?: boolean

    true to check the CRC-32 checksum of the entry.

    Use ZipReaderOptions#checkCrc32 instead.

    false
    
    commentEncoding?: string

    The encoding of the comment of the entry.

    The option is ignored when the general purpose bit 11 is set in the header of the entry, and valid UTF-8 is detected when the option is not set, see GetEntriesOptions#filenameEncoding.

    extractAppendedData?: boolean

    true to extract the appended data into ZipReader#appendedData.

    false
    
    extractPrependedData?: boolean

    true to extract the prepended data into ZipReader#prependedData.

    false
    
    filenameEncoding?: string

    The encoding of the filename of the entry.

    The option is ignored when the general purpose bit 11 is set in the header of the entry: such a filename is always decoded as UTF-8. It is only read when the bit is not set. When the option is not set either, a filename holding bytes outside ASCII is decoded as UTF-8 if they form valid UTF-8, since many writers store UTF-8 without setting the bit (macOS Archive Utility, ditto, the macOS build of Info-ZIP zip, Java 6), and as IBM Code Page 437 otherwise. Set the option to decode such filenames as another legacy encoding instead.

    filenameValidation?: "balanced" | "strict" | "tolerant"

    How strictly the filename of each entry should be validated. A rejected name throws an ERR_UNSAFE_FILENAME error carrying the offending name in its filename property.

    • "strict": reject the names rejected by "balanced", plus the names that do not map cleanly to a file path, i.e. empty names, names containing a "." path component or an empty one (e.g. "a//b.txt"), and names containing a NUL character.
    • "balanced": reject names that would escape the directory they are extracted into, i.e. names containing a ".." path component delimited by slashes or by backslashes (e.g. "..\\file.txt", which a Windows host resolves as a parent directory), and absolute names, i.e. names starting with "/", with a drive letter (e.g. "C:/file.txt") or with a backslash (root-relative and UNC paths on Windows).
    • "tolerant": never reject a name.

    A backslash is otherwise not interpreted as a path separator: it is a valid filename character on UNIX systems, and it also occurs as the trail byte of legitimate double-byte filenames (e.g. CP932) decoded with another charset.

    Names are validated, never rewritten, so the filename reported for an entry always matches its central directory record.

    The value of GetEntriesOptions#strictness.

    maxAppendedDataSize?: number

    The maximum number of bytes tolerated after the zip structure before the archive is rejected. Defaults to 0 when GetEntriesOptions#strictness is "strict", 65535 when it is "balanced", and Infinity when it is "tolerant".

    An explicit value takes precedence over the strictness default at every level, so it can loosen "strict" or reintroduce a rejection under "tolerant". It also bounds how far back the end of central directory record is searched for, so a value smaller than the amount of data actually appended surfaces an ERR_EOCDR_NOT_FOUND error when the record lies beyond the searched region and an ERR_AMBIGUOUS_ARCHIVE error otherwise.

    passThrough?: boolean | "compressed"

    true to read the data as-is without decompressing it and without decrypting it, "compressed" to decrypt it without decompressing it.

    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 ZipReaderOptions#password option and throws an ERR_INVALID_PASSWORD error when it is wrong, whereas true never looks at the password. The ZipReaderOptions#checkAuthenticationCode option applies as well. The 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 ERR_INVALID_PASS_THROUGH_VALUE error. The filesystem API copies entries verbatim and only accepts a boolean, see ERR_UNSUPPORTED_PASS_THROUGH_VALUE.

    password?: string

    The password used to decrypt the content of the entry.

    preventClose?: boolean

    true to prevent closing of WritableWriter#writable when calling FileEntry#getData.

    It only applies to the writable owned by the caller. It is ignored by the Writer instances returning the written data, such as BlobWriter or TextWriter, whose writable is created internally and must be closed for Writer#getData to resolve.

    false
    
    rawPassword?: Uint8Array<ArrayBufferLike>

    The password used to encrypt the content of the entry (raw).

    signal?: AbortSignal

    The AbortSignal instance used to cancel the decompression.

    A signal already aborted when the operation starts rejects it with ERR_ABORTED as the reason of the AbortError, or with signal.reason when it is set, without relying on the signal option of pipeTo that the oldest supported engines ignore.

    strictness?: "balanced" | "strict" | "tolerant"

    How tolerant the reader should be when the local file header of an entry disagrees with its central directory record.

    • "strict": compare the filename, the general purpose bit flag, the compression method, the CRC-32 checksum and the sizes, and throw an 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 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, and the reason the filename is left out below "strict". Use ZipReaderOptions#checkLocalDirectory to request or suppress the whole comparison explicitly, and ZipReaderOptions#checkLocalFilename to include or exclude the filename on its own.

    "balanced"
    
    transferStreams?: boolean

    true to transfer stream ownership to web workers.

    true
    
    useCompressionStream?: boolean

    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 ZipWriterConstructorOptions#level.

    true
    
    useWebWorkers?: boolean

    true to use web workers to compress/decompress data in non-blocking background processes.

    true
    
    • The function called for decoding the filename and the comment of the entry.

      Parameters

      • value: Uint8Array

        The raw text value.

      • encoding: string

        The encoding of the text.

      • type: "filename" | "comment"

        The type of the decoded text, "filename" or "comment".

      Returns string | undefined

      The decoded text value or undefined if the raw text value should be decoded by zip.js.

    • The function called for decrypting the central directory when it is encrypted (see the Strong Encryption Specification in the ZIP format specification). Without this function, reading such an archive throws an ERR_ENCRYPTED_CENTRAL_DIRECTORY error. zip.js provides the encrypted data and the related metadata but does not implement the decryption itself.

      Parameters

      • data: Uint8Array

        The raw data stored in place of the central directory, i.e. the decryption header followed by the encrypted (and possibly compressed) central directory, as stored in the zip file.

      • OptionalencryptionInfo: DirectoryEncryptionInfo

        The encryption metadata read from the Zip64 end of central directory record, or undefined if the zip file does not contain a version 2 record.

      Returns Uint8Array<ArrayBufferLike> | PromiseLike<Uint8Array<ArrayBufferLike>>

      The decrypted and decompressed central directory records.

    • The function called for normalizing the filename of each entry, e.g. to repair the names rejected by GetEntriesOptions#filenameValidation.

      It is called with the decoded filename, after GetEntriesOptions#decodeText and before the name is validated, so a name it fails to repair is still rejected. The returned name becomes the name of the entry: it is used to detect directory entries by their trailing "/", and to detect duplicate filenames when GetEntriesOptions#checkAmbiguity is set, so two names normalized into the same name are reported as an ERR_AMBIGUOUS_ARCHIVE error instead of silently shadowing each other. The raw filename remains available in EntryMetaData#rawFilename.

      Parameters

      • filename: string

        The decoded filename.

      Returns string | undefined

      The normalized filename or undefined to keep the decoded filename.