@zowe/db2-for-zowe-cli 6.1.16 → 6.1.17

package/node_modules/adm-zip/methods/zipcrypto.js

@@ -0,0 +1,175 @@
+"use strict";
+
+// node crypt, we use it for generate salt
+// eslint-disable-next-line node/no-unsupported-features/node-builtins
+const { randomFillSync } = require("crypto");
+const Errors = require("../util/errors");
+
+// generate CRC32 lookup table
+const crctable = new Uint32Array(256).map((t, crc) => {
+    for (let j = 0; j < 8; j++) {
+        if (0 !== (crc & 1)) {
+            crc = (crc >>> 1) ^ 0xedb88320;
+        } else {
+            crc >>>= 1;
+        }
+    }
+    return crc >>> 0;
+});
+
+// C-style uInt32 Multiply (discards higher bits, when JS multiply discards lower bits)
+const uMul = (a, b) => Math.imul(a, b) >>> 0;
+
+// crc32 byte single update (actually same function is part of utils.crc32 function :) )
+const crc32update = (pCrc32, bval) => {
+    return crctable[(pCrc32 ^ bval) & 0xff] ^ (pCrc32 >>> 8);
+};
+
+// function for generating salt for encrytion header
+const genSalt = () => {
+    if ("function" === typeof randomFillSync) {
+        return randomFillSync(Buffer.alloc(12));
+    } else {
+        // fallback if function is not defined
+        return genSalt.node();
+    }
+};
+
+// salt generation with node random function (mainly as fallback)
+genSalt.node = () => {
+    const salt = Buffer.alloc(12);
+    const len = salt.length;
+    for (let i = 0; i < len; i++) salt[i] = (Math.random() * 256) & 0xff;
+    return salt;
+};
+
+// general config
+const config = {
+    genSalt
+};
+
+// Class Initkeys handles same basic ops with keys
+function Initkeys(pw) {
+    const pass = Buffer.isBuffer(pw) ? pw : Buffer.from(pw);
+    this.keys = new Uint32Array([0x12345678, 0x23456789, 0x34567890]);
+    for (let i = 0; i < pass.length; i++) {
+        this.updateKeys(pass[i]);
+    }
+}
+
+Initkeys.prototype.updateKeys = function (byteValue) {
+    const keys = this.keys;
+    keys[0] = crc32update(keys[0], byteValue);
+    keys[1] += keys[0] & 0xff;
+    keys[1] = uMul(keys[1], 134775813) + 1;
+    keys[2] = crc32update(keys[2], keys[1] >>> 24);
+    return byteValue;
+};
+
+Initkeys.prototype.next = function () {
+    const k = (this.keys[2] | 2) >>> 0; // key
+    return (uMul(k, k ^ 1) >> 8) & 0xff; // decode
+};
+
+function make_decrypter(/*Buffer*/ pwd) {
+    // 1. Stage initialize key
+    const keys = new Initkeys(pwd);
+
+    // return decrypter function
+    return function (/*Buffer*/ data) {
+        // result - we create new Buffer for results
+        const result = Buffer.alloc(data.length);
+        let pos = 0;
+        // process input data
+        for (let c of data) {
+            //c ^= keys.next();
+            //result[pos++] = c; // decode & Save Value
+            result[pos++] = keys.updateKeys(c ^ keys.next()); // update keys with decoded byte
+        }
+        return result;
+    };
+}
+
+function make_encrypter(/*Buffer*/ pwd) {
+    // 1. Stage initialize key
+    const keys = new Initkeys(pwd);
+
+    // return encrypting function, result and pos is here so we dont have to merge buffers later
+    return function (/*Buffer*/ data, /*Buffer*/ result, /* Number */ pos = 0) {
+        // result - we create new Buffer for results
+        if (!result) result = Buffer.alloc(data.length);
+        // process input data
+        for (let c of data) {
+            const k = keys.next(); // save key byte
+            result[pos++] = c ^ k; // save val
+            keys.updateKeys(c); // update keys with decoded byte
+        }
+        return result;
+    };
+}
+
+function decrypt(/*Buffer*/ data, /*Object*/ header, /*String, Buffer*/ pwd) {
+    if (!data || !Buffer.isBuffer(data) || data.length < 12) {
+        return Buffer.alloc(0);
+    }
+
+    // 1. We Initialize and generate decrypting function
+    const decrypter = make_decrypter(pwd);
+
+    // 2. decrypt salt what is always 12 bytes and is a part of file content
+    const salt = decrypter(data.slice(0, 12));
+
+    // if bit 3 (0x08) of the general-purpose flags field is set, check salt[11] with the high byte of the header time
+    // 2 byte data block (as per Info-Zip spec), otherwise check with the high byte of the header entry
+    const verifyByte = (header.flags & 0x8) === 0x8 ? header.timeHighByte : header.crc >>> 24;
+
+    //3. does password meet expectations
+    if (salt[11] !== verifyByte) {
+        throw Errors.WRONG_PASSWORD();
+    }
+
+    // 4. decode content
+    return decrypter(data.slice(12));
+}
+
+// lets add way to populate salt, NOT RECOMMENDED for production but maybe useful for testing general functionality
+function _salter(data) {
+    if (Buffer.isBuffer(data) && data.length >= 12) {
+        // be aware - currently salting buffer data is modified
+        config.genSalt = function () {
+            return data.slice(0, 12);
+        };
+    } else if (data === "node") {
+        // test salt generation with node random function
+        config.genSalt = genSalt.node;
+    } else {
+        // if value is not acceptable config gets reset.
+        config.genSalt = genSalt;
+    }
+}
+
+function encrypt(/*Buffer*/ data, /*Object*/ header, /*String, Buffer*/ pwd, /*Boolean*/ oldlike = false) {
+    // 1. test data if data is not Buffer we make buffer from it
+    if (data == null) data = Buffer.alloc(0);
+    // if data is not buffer be make buffer from it
+    if (!Buffer.isBuffer(data)) data = Buffer.from(data.toString());
+
+    // 2. We Initialize and generate encrypting function
+    const encrypter = make_encrypter(pwd);
+
+    // 3. generate salt (12-bytes of random data)
+    const salt = config.genSalt();
+    salt[11] = (header.crc >>> 24) & 0xff;
+
+    // old implementations (before PKZip 2.04g) used two byte check
+    if (oldlike) salt[10] = (header.crc >>> 16) & 0xff;
+
+    // 4. create output
+    const result = Buffer.alloc(data.length + 12);
+    encrypter(salt, result);
+
+    // finally encode content
+    return encrypter(data, result, 12);
+}
+
+module.exports = { decrypt, encrypt, _salter };

package/node_modules/adm-zip/package.json

@@ -0,0 +1,56 @@
+{
+  "name": "adm-zip",
+  "version": "0.6.0",
+  "description": "Javascript implementation of zip for nodejs with support for electron original-fs. Allows user to create or extract zip files both in memory or to/from disk",
+  "scripts": {
+    "test": "mocha -R spec",
+    "test:format": "npm run format:prettier:raw -- --check",
+    "format": "npm run format:prettier",
+    "format:prettier": "npm run format:prettier:raw -- --write",
+    "format:prettier:raw": "prettier \"**/*.{js,yml,json}\""
+  },
+  "keywords": [
+    "zip",
+    "methods",
+    "archive",
+    "unzip"
+  ],
+  "homepage": "https://github.com/cthackers/adm-zip",
+  "author": "Nasca Iacob <adm-zip@pm.me> (https://github.com/cthackers)",
+  "bugs": {
+    "email": "adm-zip@pm.me",
+    "url": "https://github.com/cthackers/adm-zip/issues"
+  },
+  "license": "MIT",
+  "files": [
+    "adm-zip.js",
+    "headers",
+    "methods",
+    "util",
+    "zipEntry.js",
+    "zipFile.js",
+    "types.d.ts",
+    "LICENSE"
+  ],
+  "main": "adm-zip.js",
+  "types": "types.d.ts",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/cthackers/adm-zip.git"
+  },
+  "engines": {
+    "node": ">=14.0"
+  },
+  "overrides": {
+    "mocha": {
+      "chokidar": "^4.0.3"
+    }
+  },
+  "devDependencies": {
+    "chai": "^6.2.2",
+    "iconv-lite": "^0.7.2",
+    "mocha": "12.0.0-beta-10",
+    "prettier": "^3.8.1",
+    "rimraf": "^3.0.2"
+  }
+}

package/node_modules/adm-zip/types.d.ts

@@ -0,0 +1,223 @@
+/// <reference types="node" />
+
+import type { Stats } from "fs";
+
+declare namespace AdmZip {
+    /** Options accepted by the AdmZip constructor. */
+    interface InitOptions {
+        /** If true, disables sorting of the entries by name. */
+        noSort: boolean;
+        /** Read all entries during load (slower initial load, avoids lazy parsing later). */
+        readEntries: boolean;
+        /** Default compression method for new entries (see Constants: STORED = 0, DEFLATED = 8). */
+        method: number;
+        /** Custom filesystem implementation (e.g. Electron's `original-fs`). */
+        fs: unknown | null;
+        /** Filename used by `writeZip`/`writeZipPromise` when none is supplied. */
+        filename?: string;
+        /** Raw zip buffer to load (alternative to passing a Buffer as the first argument). */
+        input?: Buffer;
+        /** Custom text encoder/decoder for entry names (e.g. to support MBCS via iconv-lite). */
+        decoder?: ZipTextDecoder;
+    }
+
+    /** Encoder/decoder used for entry names and comments. */
+    interface ZipTextDecoder {
+        /** Whether names are encoded as UTF-8 (sets the EFS flag). May be a predicate per name. */
+        efs?: boolean | ((entryName: string) => boolean);
+        encode(data: string): Buffer;
+        decode(data: Buffer | Uint8Array): string;
+    }
+
+    /** Filter deciding whether an entry is included when adding a local folder. */
+    type EntryFilter = RegExp | ((entryPath: string) => boolean);
+
+    /** The central-directory / local file header of a single entry. */
+    interface IZipEntryHeader {
+        made: number;
+        version: number;
+        flags: number;
+        flags_efs: boolean;
+        flags_desc: boolean;
+        method: number;
+        time: Date;
+        timeval: number;
+        readonly timeHighByte: number;
+        crc: number;
+        compressedSize: number;
+        size: number;
+        fileNameLength: number;
+        extraLength: number;
+        extraLocalLength: number;
+        commentLength: number;
+        diskNumStart: number;
+        inAttr: number;
+        attr: number;
+        /** Unix permission bits (e.g. 0o755), derived from `attr`. */
+        readonly fileAttr: number;
+        offset: number;
+        readonly encrypted: boolean;
+        readonly centralHeaderSize: number;
+        readonly realDataOffset: number;
+        readonly localHeader: Record<string, number | boolean>;
+        loadLocalHeaderFromBinary(input: Buffer): Buffer;
+        loadFromBinary(data: Buffer): void;
+        localHeaderToBinary(): Buffer;
+        centralHeaderToBinary(): Buffer;
+        toJSON(): object;
+        toString(): string;
+    }
+
+    /** A single file or directory inside the archive. */
+    interface IZipEntry {
+        /** Full path of the entry within the archive. */
+        entryName: string;
+        /** Raw (un-decoded) entry name bytes. */
+        readonly rawEntryName: Buffer;
+        /** The base name of the entry (last path segment). */
+        readonly name: string;
+        /** Extra field bytes. */
+        extra: Buffer;
+        /** Entry comment. */
+        comment: string;
+        readonly isDirectory: boolean;
+        /** Whether the name uses UTF-8 (EFS) encoding. */
+        readonly efs: boolean;
+        header: IZipEntryHeader;
+        /** MS-DOS / unix packed attribute value. */
+        attr: number;
+        getCompressedData(): Buffer;
+        getCompressedDataAsync(callback: (data: Buffer) => void): void;
+        setData(value: string | Buffer): void;
+        /** Decompress and return the entry content. Throws on a bad CRC. */
+        getData(pass?: string | Buffer): Buffer;
+        getDataAsync(callback: (data: Buffer, err?: string) => void, pass?: string | Buffer): void;
+        packCentralHeader(): Buffer;
+        packLocalHeader(): Buffer;
+        toJSON(): object;
+        toString(): string;
+    }
+}
+
+declare class AdmZip {
+    /**
+     * @param fileNameOrRawData Path to a zip file, a Buffer with zip data, or an options object.
+     * @param options Additional options.
+     */
+    constructor(fileNameOrRawData?: string | Buffer, options?: Partial<AdmZip.InitOptions>);
+    constructor(options?: Partial<AdmZip.InitOptions>);
+
+    /** Extract an entry and return its content as a Buffer, or null if not found. */
+    readFile(entry: string | AdmZip.IZipEntry, pass?: string | Buffer): Buffer | null;
+
+    /** Number of child entries for a directory entry (0 for files). */
+    childCount(entry: string | AdmZip.IZipEntry): number;
+
+    /** Asynchronously extract an entry's content. */
+    readFileAsync(entry: string | AdmZip.IZipEntry, callback: (data: Buffer | null, err?: string) => void): void;
+
+    /** Extract an entry and return its content as text (default encoding utf8). */
+    readAsText(entry: string | AdmZip.IZipEntry, encoding?: string): string;
+
+    /** Asynchronously extract an entry's content as text. */
+    readAsTextAsync(entry: string | AdmZip.IZipEntry, callback: (data: string, err?: string) => void, encoding?: string): void;
+
+    /** Remove an entry (and, for a directory, optionally its children). */
+    deleteFile(entry: string | AdmZip.IZipEntry, withSubfolders?: boolean): void;
+
+    /** Remove a single entry. */
+    deleteEntry(entry: string | AdmZip.IZipEntry): void;
+
+    /** Set the archive-level comment. */
+    addZipComment(comment: string): void;
+
+    /** Get the archive-level comment. */
+    getZipComment(): string;
+
+    /** Set the comment of a single entry. */
+    addZipEntryComment(entry: string | AdmZip.IZipEntry, comment: string): void;
+
+    /** Get the comment of a single entry. */
+    getZipEntryComment(entry: string | AdmZip.IZipEntry): string;
+
+    /** Replace the content of an existing entry. */
+    updateFile(entry: string | AdmZip.IZipEntry, content: Buffer): void;
+
+    /** Add a file from disk to the archive. */
+    addLocalFile(localPath: string, zipPath?: string, zipName?: string, comment?: string): void;
+
+    /** Asynchronously add a file from disk to the archive. */
+    addLocalFileAsync(
+        options: string | { localPath: string; zipPath?: string; zipName?: string; comment?: string },
+        callback: (err: Error | undefined, done: boolean) => void
+    ): void;
+
+    /** Add a folder and all of its nested files/directories to the archive. */
+    addLocalFolder(localPath: string, zipPath?: string, filter?: AdmZip.EntryFilter): void;
+
+    /** Asynchronously add a folder and its contents to the archive. */
+    addLocalFolderAsync(localPath: string, callback: (success?: boolean, err?: string) => void, zipPath?: string, filter?: AdmZip.EntryFilter): void;
+
+    /** Asynchronously add a folder and its contents to the archive. */
+    addLocalFolderAsync2(
+        options: string | { localPath: string; zipPath?: string; filter?: AdmZip.EntryFilter; namefix?: "latin1" | ((name: string) => string) },
+        callback: (err: Error | undefined, done?: boolean) => void
+    ): void;
+
+    /** Promise-returning variant of `addLocalFolderAsync2`. */
+    addLocalFolderPromise(localPath: string, props?: { zipPath?: string; filter?: AdmZip.EntryFilter; namefix?: "latin1" | ((name: string) => string) }): Promise<void>;
+
+    /**
+     * Create an entry from in-memory content.
+     * For a directory, `entryName` must end in `/` and `content` should be an empty buffer.
+     * @param attr Unix permission bits as a number, or a filesystem `Stats` object.
+     */
+    addFile(entryName: string, content: Buffer | string, comment?: string, attr?: number | Stats): AdmZip.IZipEntry;
+
+    /** All entries in the archive. */
+    getEntries(password?: string): AdmZip.IZipEntry[];
+
+    /** Look up a single entry by name, or null if absent. */
+    getEntry(name: string): AdmZip.IZipEntry | null;
+
+    /** Number of entries in the archive. */
+    getEntryCount(): number;
+
+    /** Iterate every entry. */
+    forEach(callback: (entry: AdmZip.IZipEntry) => void): void;
+
+    /** Extract a single entry (or a directory subtree) to disk. Returns success. */
+    extractEntryTo(
+        entry: string | AdmZip.IZipEntry,
+        targetPath: string,
+        maintainEntryPath?: boolean,
+        overwrite?: boolean,
+        keepOriginalPermission?: boolean,
+        outFileName?: string
+    ): boolean;
+
+    /** Verify every entry decompresses with a valid CRC. */
+    test(pass?: string | Buffer): boolean;
+
+    /** Extract the entire archive to disk. */
+    extractAllTo(targetPath: string, overwrite?: boolean, keepOriginalPermission?: boolean, pass?: string | Buffer): void;
+
+    /** Asynchronously extract the entire archive to disk. Returns a Promise when no callback is given. */
+    extractAllToAsync(targetPath: string, overwrite?: boolean, keepOriginalPermission?: boolean): Promise<void>;
+    extractAllToAsync(targetPath: string, overwrite: boolean, keepOriginalPermission: boolean, callback: (error?: Error) => void): void;
+
+    /** Write the archive to disk (uses the constructor filename if none supplied). */
+    writeZip(targetFileName?: string, callback?: (error: Error | null) => void): void;
+
+    /** Promise-returning variant of `writeZip`. */
+    writeZipPromise(targetFileName?: string, props?: { overwrite?: boolean; perm?: number }): Promise<void>;
+
+    /** Serialize the archive to a Buffer asynchronously. */
+    toBufferPromise(): Promise<Buffer>;
+
+    /** Serialize the archive to a Buffer. With callbacks it runs asynchronously and returns null. */
+    toBuffer(): Buffer;
+    toBuffer(onSuccess: (buffer: Buffer) => void, onFail?: (error: unknown) => void, onItemStart?: (name: string) => void, onItemEnd?: (name: string) => void): null;
+}
+
+export = AdmZip;

package/node_modules/adm-zip/util/constants.js

@@ -0,0 +1,142 @@
+module.exports = {
+    /* The local file header */
+    LOCHDR           : 30, // LOC header size
+    LOCSIG           : 0x04034b50, // "PK\003\004"
+    LOCVER           : 4,	// version needed to extract
+    LOCFLG           : 6, // general purpose bit flag
+    LOCHOW           : 8, // compression method
+    LOCTIM           : 10, // modification time (2 bytes time, 2 bytes date)
+    LOCCRC           : 14, // uncompressed file crc-32 value
+    LOCSIZ           : 18, // compressed size
+    LOCLEN           : 22, // uncompressed size
+    LOCNAM           : 26, // filename length
+    LOCEXT           : 28, // extra field length
+
+    /* The Data descriptor */
+    EXTSIG           : 0x08074b50, // "PK\007\008"
+    EXTHDR           : 16, // EXT header size
+    EXTCRC           : 4, // uncompressed file crc-32 value
+    EXTSIZ           : 8, // compressed size
+    EXTLEN           : 12, // uncompressed size
+
+    /* The central directory file header */
+    CENHDR           : 46, // CEN header size
+    CENSIG           : 0x02014b50, // "PK\001\002"
+    CENVEM           : 4, // version made by
+    CENVER           : 6, // version needed to extract
+    CENFLG           : 8, // encrypt, decrypt flags
+    CENHOW           : 10, // compression method
+    CENTIM           : 12, // modification time (2 bytes time, 2 bytes date)
+    CENCRC           : 16, // uncompressed file crc-32 value
+    CENSIZ           : 20, // compressed size
+    CENLEN           : 24, // uncompressed size
+    CENNAM           : 28, // filename length
+    CENEXT           : 30, // extra field length
+    CENCOM           : 32, // file comment length
+    CENDSK           : 34, // volume number start
+    CENATT           : 36, // internal file attributes
+    CENATX           : 38, // external file attributes (host system dependent)
+    CENOFF           : 42, // LOC header offset
+
+    /* The entries in the end of central directory */
+    ENDHDR           : 22, // END header size
+    ENDSIG           : 0x06054b50, // "PK\005\006"
+    ENDSUB           : 8, // number of entries on this disk
+    ENDTOT           : 10, // total number of entries
+    ENDSIZ           : 12, // central directory size in bytes
+    ENDOFF           : 16, // offset of first CEN header
+    ENDCOM           : 20, // zip file comment length
+
+    END64HDR         : 20, // zip64 END header size
+    END64SIG         : 0x07064b50, // zip64 Locator signature, "PK\006\007"
+    END64START       : 4, // number of the disk with the start of the zip64
+    END64OFF         : 8, // relative offset of the zip64 end of central directory
+    END64NUMDISKS    : 16, // total number of disks
+
+    ZIP64SIG         : 0x06064b50, // zip64 signature, "PK\006\006"
+    ZIP64HDR         : 56, // zip64 record minimum size
+    ZIP64LEAD        : 12, // leading bytes at the start of the record, not counted by the value stored in ZIP64SIZE
+    ZIP64SIZE        : 4, // zip64 size of the central directory record
+    ZIP64VEM         : 12, // zip64 version made by
+    ZIP64VER         : 14, // zip64 version needed to extract
+    ZIP64DSK         : 16, // zip64 number of this disk
+    ZIP64DSKDIR      : 20, // number of the disk with the start of the record directory
+    ZIP64SUB         : 24, // number of entries on this disk
+    ZIP64TOT         : 32, // total number of entries
+    ZIP64SIZB        : 40, // zip64 central directory size in bytes
+    ZIP64OFF         : 48, // offset of start of central directory with respect to the starting disk number
+    ZIP64EXTRA       : 56, // extensible data sector
+
+    /* Compression methods */
+    STORED           : 0, // no compression
+    SHRUNK           : 1, // shrunk
+    REDUCED1         : 2, // reduced with compression factor 1
+    REDUCED2         : 3, // reduced with compression factor 2
+    REDUCED3         : 4, // reduced with compression factor 3
+    REDUCED4         : 5, // reduced with compression factor 4
+    IMPLODED         : 6, // imploded
+    // 7 reserved for Tokenizing compression algorithm
+    DEFLATED         : 8, // deflated
+    ENHANCED_DEFLATED: 9, // enhanced deflated
+    PKWARE           : 10,// PKWare DCL imploded
+    // 11 reserved by PKWARE
+    BZIP2            : 12, //  compressed using BZIP2
+    // 13 reserved by PKWARE
+    LZMA             : 14, // LZMA
+    // 15-17 reserved by PKWARE
+    IBM_TERSE        : 18, // compressed using IBM TERSE
+    IBM_LZ77         : 19, // IBM LZ77 z
+    AES_ENCRYPT      : 99, // WinZIP AES encryption method
+
+    /* General purpose bit flag */
+    // values can obtained with expression 2**bitnr
+    FLG_ENC          : 1,    // Bit 0: encrypted file
+    FLG_COMP1        : 2,    // Bit 1, compression option
+    FLG_COMP2        : 4,    // Bit 2, compression option
+    FLG_DESC         : 8,    // Bit 3, data descriptor
+    FLG_ENH          : 16,   // Bit 4, enhanced deflating
+    FLG_PATCH        : 32,   // Bit 5, indicates that the file is compressed patched data.
+    FLG_STR          : 64,   // Bit 6, strong encryption (patented)
+                             // Bits 7-10: Currently unused.
+    FLG_EFS          : 2048, // Bit 11: Language encoding flag (EFS)
+                             // Bit 12: Reserved by PKWARE for enhanced compression.
+                             // Bit 13: encrypted the Central Directory (patented).
+                             // Bits 14-15: Reserved by PKWARE.
+    FLG_MSK          : 4096, // mask header values
+
+    /* Load type */
+    FILE             : 2,
+    BUFFER           : 1,
+    NONE             : 0,
+
+    /* 4.5 Extensible data fields */
+    EF_ID            : 0,
+    EF_SIZE          : 2,
+
+    /* Header IDs */
+    ID_ZIP64         : 0x0001,
+    ID_AVINFO        : 0x0007,
+    ID_PFS           : 0x0008,
+    ID_OS2           : 0x0009,
+    ID_NTFS          : 0x000a,
+    ID_OPENVMS       : 0x000c,
+    ID_UNIX          : 0x000d,
+    ID_FORK          : 0x000e,
+    ID_PATCH         : 0x000f,
+    ID_X509_PKCS7    : 0x0014,
+    ID_X509_CERTID_F : 0x0015,
+    ID_X509_CERTID_C : 0x0016,
+    ID_STRONGENC     : 0x0017,
+    ID_RECORD_MGT    : 0x0018,
+    ID_X509_PKCS7_RL : 0x0019,
+    ID_IBM1          : 0x0065,
+    ID_IBM2          : 0x0066,
+    ID_POSZIP        : 0x4690,
+
+    EF_ZIP64_OR_32   : 0xffffffff,
+    EF_ZIP64_OR_16   : 0xffff,
+    EF_ZIP64_SUNCOMP : 0,
+    EF_ZIP64_SCOMP   : 8,
+    EF_ZIP64_RHO     : 16,
+    EF_ZIP64_DSN     : 24
+};

package/node_modules/adm-zip/util/decoder.js

@@ -0,0 +1,5 @@
+module.exports = {
+    efs: true,
+    encode: (data) => Buffer.from(data, "utf8"),
+    decode: (data) => data.toString("utf8")
+};

package/node_modules/adm-zip/util/errors.js

@@ -0,0 +1,63 @@
+const errors = {
+    /* Header error messages */
+    INVALID_LOC: "Invalid LOC header (bad signature)",
+    INVALID_CEN: "Invalid CEN header (bad signature)",
+    INVALID_END: "Invalid END header (bad signature)",
+
+    /* Descriptor */
+    DESCRIPTOR_NOT_EXIST: "No descriptor present",
+    DESCRIPTOR_UNKNOWN: "Unknown descriptor format",
+    DESCRIPTOR_FAULTY: "Descriptor data is malformed",
+
+    /* ZipEntry error messages*/
+    NO_DATA: "Nothing to decompress",
+    BAD_CRC: "CRC32 checksum failed {0}",
+    FILE_IN_THE_WAY: "There is a file in the way: {0}",
+    UNKNOWN_METHOD: "Invalid/unsupported compression method",
+
+    /* Inflater error messages */
+    AVAIL_DATA: "inflate::Available inflate data did not terminate",
+    INVALID_DISTANCE: "inflate::Invalid literal/length or distance code in fixed or dynamic block",
+    TO_MANY_CODES: "inflate::Dynamic block code description: too many length or distance codes",
+    INVALID_REPEAT_LEN: "inflate::Dynamic block code description: repeat more than specified lengths",
+    INVALID_REPEAT_FIRST: "inflate::Dynamic block code description: repeat lengths with no first length",
+    INCOMPLETE_CODES: "inflate::Dynamic block code description: code lengths codes incomplete",
+    INVALID_DYN_DISTANCE: "inflate::Dynamic block code description: invalid distance code lengths",
+    INVALID_CODES_LEN: "inflate::Dynamic block code description: invalid literal/length code lengths",
+    INVALID_STORE_BLOCK: "inflate::Stored block length did not match one's complement",
+    INVALID_BLOCK_TYPE: "inflate::Invalid block type (type == 3)",
+
+    /* ADM-ZIP error messages */
+    CANT_EXTRACT_FILE: "Could not extract the file",
+    CANT_OVERRIDE: "Target file already exists",
+    DISK_ENTRY_TOO_LARGE: "Number of disk entries is too large",
+    NO_ZIP: "No zip file was loaded",
+    NO_ENTRY: "Entry doesn't exist",
+    DIRECTORY_CONTENT_ERROR: "A directory cannot have content",
+    FILE_NOT_FOUND: 'File not found: "{0}"',
+    NOT_IMPLEMENTED: "Not implemented",
+    INVALID_FILENAME: "Invalid filename",
+    INVALID_FORMAT: "Invalid or unsupported zip format. No END header found",
+    INVALID_PASS_PARAM: "Incompatible password parameter",
+    WRONG_PASSWORD: "Wrong Password",
+
+    /* ADM-ZIP */
+    COMMENT_TOO_LONG: "Comment is too long", // Comment can be max 65535 bytes long (NOTE: some non-US characters may take more space)
+    EXTRA_FIELD_PARSE_ERROR: "Extra field parsing error"
+};
+
+// template
+function E(message) {
+    return function (...args) {
+        if (args.length) { // Allow {0} .. {9} arguments in error message, based on argument number
+            message = message.replace(/\{(\d)\}/g, (_, n) => args[n] || '');
+        }
+
+        return new Error('ADM-ZIP: ' + message);
+    };
+}
+
+// Init errors with template
+for (const msg of Object.keys(errors)) {
+    exports[msg] = E(errors[msg]);
+}