@appium/support 7.0.4 → 7.0.6

package/build/lib/zip.js

@@ -37,19 +37,20 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.extractAllTo = extractAllTo;
+exports._extractEntryTo = _extractEntryTo;
 exports.readEntries = readEntries;
 exports.toInMemoryZip = toInMemoryZip;
-exports._extractEntryTo = _extractEntryTo;
 exports.assertValidZip = assertValidZip;
 exports.toArchive = toArchive;
 const lodash_1 = __importDefault(require("lodash"));
-const bluebird_1 = __importDefault(require("bluebird"));
+const node_util_1 = require("node:util");
 const yauzl = __importStar(require("yauzl"));
 const archiver_1 = __importDefault(require("archiver"));
-const fs_1 = require("fs");
-const path_1 = __importDefault(require("path"));
-const stream_1 = __importDefault(require("stream"));
-const fs_2 = require("./fs");
+const node_fs_1 = require("node:fs");
+const node_path_1 = __importDefault(require("node:path"));
+const node_stream_1 = __importDefault(require("node:stream"));
+const promises_1 = require("node:stream/promises");
+const fs_1 = require("./fs");
 const system_1 = require("./system");
 const base64_stream_1 = require("base64-stream");
 const util_1 = require("./util");
@@ -57,167 +58,24 @@ const timing_1 = require("./timing");
 const logger_1 = __importDefault(require("./logger"));
 const get_stream_1 = __importDefault(require("get-stream"));
 const teen_process_1 = require("teen_process");
-/**
- * @type {(path: string, options?: yauzl.Options) => Promise<yauzl.ZipFile>}
- */
-const openZip = bluebird_1.default.promisify(yauzl.open);
-/**
- * @type {(source: NodeJS.ReadableStream, destination: NodeJS.WritableStream) => Promise<NodeJS.WritableStream>}
- */
-const pipeline = bluebird_1.default.promisify(stream_1.default.pipeline);
+const openZip = (0, node_util_1.promisify)(yauzl.open);
 const ZIP_MAGIC = 'PK';
-const IFMT = 61440;
-const IFDIR = 16384;
-const IFLNK = 40960;
-// This class is mostly copied from https://github.com/maxogden/extract-zip/blob/master/index.js
-class ZipExtractor {
-    /** @type {yauzl.ZipFile} */
-    zipfile;
-    constructor(sourcePath, opts = {}) {
-        this.zipPath = sourcePath;
-        this.opts = opts;
-        this.canceled = false;
-    }
-    extractFileName(entry) {
-        return lodash_1.default.isBuffer(entry.fileName)
-            ? entry.fileName.toString(this.opts.fileNamesEncoding)
-            : entry.fileName;
-    }
-    async extract() {
-        const { dir, fileNamesEncoding } = this.opts;
-        this.zipfile = await openZip(this.zipPath, {
-            lazyEntries: true,
-            // https://github.com/thejoshwolfe/yauzl/commit/cc7455ac789ba84973184e5ebde0581cdc4c3b39#diff-04c6e90faac2675aa89e2176d2eec7d8R95
-            decodeStrings: !fileNamesEncoding,
-        });
-        this.canceled = false;
-        return new bluebird_1.default((resolve, reject) => {
-            this.zipfile.on('error', (err) => {
-                this.canceled = true;
-                reject(err);
-            });
-            this.zipfile.readEntry();
-            this.zipfile.on('close', () => {
-                if (!this.canceled) {
-                    resolve();
-                }
-            });
-            this.zipfile.on('entry', async (entry) => {
-                if (this.canceled) {
-                    return;
-                }
-                const fileName = this.extractFileName(entry);
-                if (fileName.startsWith('__MACOSX/')) {
-                    this.zipfile.readEntry();
-                    return;
-                }
-                const destDir = path_1.default.dirname(path_1.default.join(dir, fileName));
-                try {
-                    await fs_2.fs.mkdir(destDir, { recursive: true });
-                    const canonicalDestDir = await fs_2.fs.realpath(destDir);
-                    const relativeDestDir = path_1.default.relative(dir, canonicalDestDir);
-                    if (relativeDestDir.split(path_1.default.sep).includes('..')) {
-                        new Error(`Out of bound path "${canonicalDestDir}" found while processing file ${fileName}`);
-                    }
-                    await this.extractEntry(entry);
-                    this.zipfile.readEntry();
-                }
-                catch (err) {
-                    this.canceled = true;
-                    this.zipfile.close();
-                    reject(err);
-                }
-            });
-        });
-    }
-    async extractEntry(entry) {
-        if (this.canceled) {
-            return;
-        }
-        const { dir } = this.opts;
-        const fileName = this.extractFileName(entry);
-        const dest = path_1.default.join(dir, fileName);
-        // convert external file attr int into a fs stat mode int
-        const mode = (entry.externalFileAttributes >> 16) & 0xffff;
-        // check if it's a symlink or dir (using stat mode constants)
-        const isSymlink = (mode & IFMT) === IFLNK;
-        const isDir = (mode & IFMT) === IFDIR ||
-            // Failsafe, borrowed from jsZip
-            fileName.endsWith('/') ||
-            // check for windows weird way of specifying a directory
-            // https://github.com/maxogden/extract-zip/issues/13#issuecomment-154494566
-            (entry.versionMadeBy >> 8 === 0 && entry.externalFileAttributes === 16);
-        const procMode = this.getExtractedMode(mode, isDir) & 0o777;
-        // always ensure folders are created
-        const destDir = isDir ? dest : path_1.default.dirname(dest);
-        const mkdirOptions = { recursive: true };
-        if (isDir) {
-            mkdirOptions.mode = procMode;
-        }
-        await fs_2.fs.mkdir(destDir, mkdirOptions);
-        if (isDir) {
-            return;
-        }
-        /** @type {(entry: yauzl.Entry) => Promise<NodeJS.ReadableStream>} */
-        const openReadStream = bluebird_1.default.promisify(this.zipfile.openReadStream.bind(this.zipfile));
-        const readStream = await openReadStream(entry);
-        if (isSymlink) {
-            // @ts-ignore This typecast is ok
-            const link = await (0, get_stream_1.default)(readStream);
-            await fs_2.fs.symlink(link, dest);
-        }
-        else {
-            await pipeline(readStream, fs_2.fs.createWriteStream(dest, { mode: procMode }));
-        }
-    }
-    getExtractedMode(entryMode, isDir) {
-        const { defaultDirMode, defaultFileMode } = this.opts;
-        let mode = entryMode;
-        // Set defaults, if necessary
-        if (mode === 0) {
-            if (isDir) {
-                if (defaultDirMode) {
-                    mode = parseInt(defaultDirMode, 10);
-                }
-                if (!mode) {
-                    mode = 0o755;
-                }
-            }
-            else {
-                if (defaultFileMode) {
-                    mode = parseInt(defaultFileMode, 10);
-                }
-                if (!mode) {
-                    mode = 0o644;
-                }
-            }
-        }
-        return mode;
-    }
-}
-/**
- * @typedef ExtractAllOptions
- * @property {string} [fileNamesEncoding] The encoding to use for extracted file names.
- * For ZIP archives created on MacOS it is usually expected to be `utf8`.
- * By default it is autodetected based on the entry metadata and is only needed to be set explicitly
- * if the particular archive does not comply to the standards, which leads to corrupted file names
- * after extraction. Only applicable if system unzip binary is NOT being used.
- * @property {boolean} [useSystemUnzip] If true, attempt to use system unzip; if this fails,
- * fallback to the JS unzip implementation.
- */
+const IFMT = 0b1111000000000000;
+const IFDIR = 0b0100000000000000;
+const IFLNK = 0b1010000000000000;
 /**
  * Extract zipfile to a directory
  *
- * @param {string} zipFilePath The full path to the source ZIP file
- * @param {string} destDir The full path to the destination folder
- * @param {ExtractAllOptions} [opts]
+ * @param zipFilePath The full path to the source ZIP file
+ * @param destDir The full path to the destination folder
+ * @param opts Extraction options
  */
-async function extractAllTo(zipFilePath, destDir, opts = /** @type {ExtractAllOptions} */ ({})) {
-    if (!path_1.default.isAbsolute(destDir)) {
+async function extractAllTo(zipFilePath, destDir, opts = {}) {
+    if (!node_path_1.default.isAbsolute(destDir)) {
         throw new Error(`Target path '${destDir}' is expected to be absolute`);
     }
-    await fs_2.fs.mkdir(destDir, { recursive: true });
-    const dir = await fs_2.fs.realpath(destDir);
+    await fs_1.fs.mkdir(destDir, { recursive: true });
+    const dir = await fs_1.fs.realpath(destDir);
     if (opts.useSystemUnzip) {
         try {
             await extractWithSystemUnzip(zipFilePath, dir);
@@ -233,100 +91,58 @@ async function extractAllTo(zipFilePath, destDir, opts = /** @type {ExtractAllOp
     });
     await extractor.extract();
 }
-/**
- * Executes system unzip (e.g., `/usr/bin/unzip`). If available, it is
- * significantly faster than the JS implementation.
- * By default all files in the destDir get overridden if already exist.
- *
- * @param {string} zipFilePath The full path to the source ZIP file
- * @param {string} destDir The full path to the destination folder.
- * This folder is expected to already exist before extracting the archive.
- */
-async function extractWithSystemUnzip(zipFilePath, destDir) {
-    const isWindowsHost = (0, system_1.isWindows)();
-    let executablePath;
-    try {
-        executablePath = await getExecutablePath(isWindowsHost ? 'powershell.exe' : 'unzip');
-    }
-    catch {
-        throw new Error('Could not find system unzip');
-    }
-    if (isWindowsHost) {
-        // on Windows we use PowerShell to unzip files
-        await (0, teen_process_1.exec)(executablePath, [
-            '-command',
-            'Expand-Archive',
-            '-LiteralPath',
-            zipFilePath,
-            '-DestinationPath',
-            destDir,
-            '-Force',
-        ]);
-    }
-    else {
-        // -q means quiet (no stdout)
-        // -o means overwrite
-        // -d is the dest dir
-        await (0, teen_process_1.exec)(executablePath, ['-q', '-o', zipFilePath, '-d', destDir]);
-    }
-}
 /**
  * Extract a single zip entry to a directory
  *
- * @param {yauzl.ZipFile} zipFile The source ZIP stream
- * @param {yauzl.Entry} entry The entry instance
- * @param {string} destDir The full path to the destination folder
+ * @private
+ * @param zipFile The source ZIP stream
+ * @param entry The entry instance
+ * @param destDir The full path to the destination folder
  */
 async function _extractEntryTo(zipFile, entry, destDir) {
-    const dstPath = path_1.default.resolve(destDir, entry.fileName);
+    const dstPath = node_path_1.default.resolve(destDir, entry.fileName);
+    if (!(0, util_1.isSubPath)(dstPath, destDir)) {
+        throw new Error(`Out of bound path "${dstPath}" found while processing file ${entry.fileName}`);
+    }
     // Create dest directory if doesn't exist already
     if (entry.fileName.endsWith('/')) {
-        if (!(await fs_2.fs.exists(dstPath))) {
-            await fs_2.fs.mkdirp(dstPath);
+        if (!(await fs_1.fs.exists(dstPath))) {
+            await fs_1.fs.mkdirp(dstPath);
         }
         return;
     }
-    else if (!(await fs_2.fs.exists(path_1.default.dirname(dstPath)))) {
-        await fs_2.fs.mkdirp(path_1.default.dirname(dstPath));
+    else if (!(await fs_1.fs.exists(node_path_1.default.dirname(dstPath)))) {
+        await fs_1.fs.mkdirp(node_path_1.default.dirname(dstPath));
     }
     // Create a write stream
-    const writeStream = (0, fs_1.createWriteStream)(dstPath, { flags: 'w' });
-    const writeStreamPromise = new bluebird_1.default((resolve, reject) => {
+    const writeStream = (0, node_fs_1.createWriteStream)(dstPath, { flags: 'w' });
+    const writeStreamPromise = new Promise((resolve, reject) => {
         writeStream.once('finish', resolve);
         writeStream.once('error', reject);
     });
-    // Create zipReadStream and pipe data to the write stream
-    // (for some odd reason B.promisify doesn't work on zipfile.openReadStream, it causes an error 'closed')
-    const zipReadStream = await new bluebird_1.default((resolve, reject) => {
-        zipFile.openReadStream(entry, (err, readStream) => (err ? reject(err) : resolve(readStream)));
-    });
-    const zipReadStreamPromise = new bluebird_1.default((resolve, reject) => {
+    const openReadStream = (0, node_util_1.promisify)(zipFile.openReadStream.bind(zipFile));
+    const zipReadStream = await openReadStream(entry);
+    const zipReadStreamPromise = new Promise((resolve, reject) => {
         zipReadStream.once('end', resolve);
         zipReadStream.once('error', reject);
     });
     zipReadStream.pipe(writeStream);
     // Wait for the zipReadStream and writeStream to end before returning
-    return await bluebird_1.default.all([zipReadStreamPromise, writeStreamPromise]);
+    await Promise.all([zipReadStreamPromise, writeStreamPromise]);
 }
-/**
- * @typedef ZipEntry
- * @property {yauzl.Entry} entry The actual entry instance
- * @property {function} extractEntryTo An async function, which accepts one parameter.
- * This parameter contains the destination folder path to which this function is going to extract the entry.
- */
 /**
  * Get entries for a zip folder
  *
- * @param {string} zipFilePath The full path to the source ZIP file
- * @param {function} onEntry Callback when entry is read.
+ * @param zipFilePath The full path to the source ZIP file
+ * @param onEntry Callback when entry is read.
  * The callback is expected to accept one argument of ZipEntry type.
- * The iteration through the source zip file will bi terminated as soon as
+ * The iteration through the source zip file will be terminated as soon as
  * the result of this function equals to `false`.
  */
 async function readEntries(zipFilePath, onEntry) {
     // Open a zip file and start reading entries
     const zipfile = await openZip(zipFilePath, { lazyEntries: true });
-    const zipReadStreamPromise = new bluebird_1.default((resolve, reject) => {
+    const zipReadStreamPromise = new Promise((resolve, reject) => {
         zipfile.once('end', resolve);
         zipfile.once('error', reject);
         // On each entry, call 'onEntry' and then read the next entry
@@ -343,43 +159,28 @@ async function readEntries(zipFilePath, onEntry) {
     });
     zipfile.readEntry();
     // Wait for the entries to finish being iterated through
-    return await zipReadStreamPromise;
+    await zipReadStreamPromise;
 }
-/**
- * @typedef ZipOptions
- * @property {boolean} [encodeToBase64=false] Whether to encode
- * the resulting archive to a base64-encoded string
- * @property {boolean} [isMetered=true] Whether to log the actual
- * archiver performance
- * @property {number} [maxSize=1073741824] The maximum size of
- * the resulting archive in bytes. This is set to 1GB by default, because
- * Appium limits the maximum HTTP body size to 1GB. Also, the NodeJS heap
- * size must be enough to keep the resulting object (usually this size is
- * limited to 1.4 GB)
- * @property {number} [level=9] The compression level. The maximum
- * level is 9 (the best compression, worst performance). The minimum
- * compression level is 0 (no compression).
- */
 /**
  * Converts contents of local directory to an in-memory .zip buffer
  *
- * @param {string} srcPath The full path to the folder or file being zipped
- * @param {ZipOptions} opts Zipping options
- * @returns {Promise<Buffer>} Zipped (and encoded if `encodeToBase64` is truthy)
+ * @param srcPath The full path to the folder or file being zipped
+ * @param opts Zipping options
+ * @returns Zipped (and encoded if `encodeToBase64` is truthy)
  * content of the source path as memory buffer
  * @throws {Error} if there was an error while reading the source
  * or the source is too big
  */
-async function toInMemoryZip(srcPath, opts = /** @type {ZipOptions} */ ({})) {
-    if (!(await fs_2.fs.exists(srcPath))) {
+async function toInMemoryZip(srcPath, opts = {}) {
+    if (!(await fs_1.fs.exists(srcPath))) {
         throw new Error(`No such file or folder: ${srcPath}`);
     }
     const { isMetered = true, encodeToBase64 = false, maxSize = 1 * util_1.GiB, level = 9 } = opts;
     const resultBuffers = [];
     let resultBuffersSize = 0;
     // Create a writable stream that zip buffers will be streamed to
-    const resultWriteStream = new stream_1.default.Writable({
-        write: (buffer, encoding, next) => {
+    const resultWriteStream = new node_stream_1.default.Writable({
+        write(buffer, _encoding, next) {
             resultBuffers.push(buffer);
             resultBuffersSize += buffer.length;
             if (maxSize > 0 && resultBuffersSize > maxSize) {
@@ -395,7 +196,7 @@ async function toInMemoryZip(srcPath, opts = /** @type {ZipOptions} */ ({})) {
     });
     let srcSize = null;
     const base64EncoderStream = encodeToBase64 ? new base64_stream_1.Base64Encode() : null;
-    const resultWriteStreamPromise = new bluebird_1.default((resolve, reject) => {
+    const resultWriteStreamPromise = new Promise((resolve, reject) => {
         resultWriteStream.once('error', (e) => {
             if (base64EncoderStream) {
                 archive.unpipe(base64EncoderStream);
@@ -413,17 +214,17 @@ async function toInMemoryZip(srcPath, opts = /** @type {ZipOptions} */ ({})) {
             resolve();
         });
     });
-    const archiveStreamPromise = new bluebird_1.default((resolve, reject) => {
+    const archiveStreamPromise = new Promise((resolve, reject) => {
         archive.once('finish', resolve);
         archive.once('error', (e) => reject(new Error(`Failed to archive '${srcPath}': ${e.message}`)));
     });
     const timer = isMetered ? new timing_1.Timer().start() : null;
-    if ((await fs_2.fs.stat(srcPath)).isDirectory()) {
+    if ((await fs_1.fs.stat(srcPath)).isDirectory()) {
         archive.directory(srcPath, false);
     }
     else {
         archive.file(srcPath, {
-            name: path_1.default.basename(srcPath),
+            name: node_path_1.default.basename(srcPath),
         });
     }
     if (base64EncoderStream) {
@@ -435,10 +236,10 @@ async function toInMemoryZip(srcPath, opts = /** @type {ZipOptions} */ ({})) {
     }
     archive.finalize();
     // Wait for the streams to finish
-    await bluebird_1.default.all([archiveStreamPromise, resultWriteStreamPromise]);
+    await Promise.all([archiveStreamPromise, resultWriteStreamPromise]);
     if (timer) {
         logger_1.default.debug(`Zipped ${encodeToBase64 ? 'and base64-encoded ' : ''}` +
-            `'${path_1.default.basename(srcPath)}' ` +
+            `'${node_path_1.default.basename(srcPath)}' ` +
             (srcSize ? `(${(0, util_1.toReadableSizeString)(srcSize)}) ` : '') +
             `in ${timer.getDuration().asSeconds.toFixed(3)}s ` +
             `(compression level: ${level})`);
@@ -449,21 +250,21 @@ async function toInMemoryZip(srcPath, opts = /** @type {ZipOptions} */ ({})) {
 /**
  * Verifies whether the given file is a valid ZIP archive
  *
- * @param {string} filePath - Full path to the file
+ * @param filePath - Full path to the file
  * @throws {Error} If the file does not exist or is not a valid ZIP archive
  */
 async function assertValidZip(filePath) {
-    if (!(await fs_2.fs.exists(filePath))) {
+    if (!(await fs_1.fs.exists(filePath))) {
         throw new Error(`The file at '${filePath}' does not exist`);
     }
-    const { size } = await fs_2.fs.stat(filePath);
+    const { size } = await fs_1.fs.stat(filePath);
     if (size < 4) {
         throw new Error(`The file at '${filePath}' is too small to be a ZIP archive`);
     }
-    const fd = await fs_2.fs.open(filePath, 'r');
+    const fd = await fs_1.fs.open(filePath, 'r');
     try {
         const buffer = Buffer.alloc(ZIP_MAGIC.length);
-        await fs_2.fs.read(fd, buffer, 0, ZIP_MAGIC.length, 0);
+        await fs_1.fs.read(fd, buffer, 0, ZIP_MAGIC.length, 0);
         const signature = buffer.toString('ascii');
         if (signature !== ZIP_MAGIC) {
             throw new Error(`The file signature '${signature}' of '${filePath}' ` +
@@ -472,45 +273,33 @@ async function assertValidZip(filePath) {
         return true;
     }
     finally {
-        await fs_2.fs.close(fd);
+        await fs_1.fs.close(fd);
     }
 }
-/**
- * @typedef ZipCompressionOptions
- * @property {number} level [9] - Compression level in range 0..9
- * (greater numbers mean better compression, but longer processing time)
- */
-/**
- * @typedef ZipSourceOptions
- * @property {string} [pattern='**\/*'] - GLOB pattern for compression
- * @property {string} [cwd] - The source root folder (the parent folder of
- * the destination file by default)
- * @property {string[]} [ignore] - The list of ignored patterns
- */
 /**
  * Creates an archive based on the given glob pattern
  *
- * @param {string} dstPath - The resulting archive path
- * @param {ZipSourceOptions} src - Source options
- * @param {ZipCompressionOptions} opts - Compression options
+ * @param dstPath - The resulting archive path
+ * @param src - Source options
+ * @param opts - Compression options
  * @throws {Error} If there was an error while creating the archive
  */
-async function toArchive(dstPath, src = /** @type {ZipSourceOptions} */ ({}), opts = /** @type {ZipCompressionOptions} */ ({})) {
+async function toArchive(dstPath, src = {}, opts = {}) {
     const { level = 9 } = opts;
-    const { pattern = '**/*', cwd = path_1.default.dirname(dstPath), ignore = [] } = src;
+    const { pattern = '**/*', cwd = node_path_1.default.dirname(dstPath), ignore = [] } = src;
     const archive = (0, archiver_1.default)('zip', { zlib: { level } });
-    const stream = fs_2.fs.createWriteStream(dstPath);
-    return await new bluebird_1.default((resolve, reject) => {
+    const outStream = fs_1.fs.createWriteStream(dstPath);
+    await new Promise((resolve, reject) => {
         archive
             .glob(pattern, {
             cwd,
             ignore,
         })
             .on('error', reject)
-            .pipe(stream);
-        stream
+            .pipe(outStream);
+        outStream
             .on('error', (e) => {
-            archive.unpipe(stream);
+            archive.unpipe(outStream);
             archive.abort();
             archive.destroy();
             reject(e);
@@ -519,16 +308,179 @@ async function toArchive(dstPath, src = /** @type {ZipSourceOptions} */ ({}), op
         archive.finalize();
     });
 }
+// This class is mostly copied from https://github.com/maxogden/extract-zip/blob/master/index.js
+class ZipExtractor {
+    zipfile;
+    zipPath;
+    opts;
+    canceled = false;
+    constructor(sourcePath, opts) {
+        this.zipPath = sourcePath;
+        this.opts = opts;
+    }
+    extractFileName(entry) {
+        if (Buffer.isBuffer(entry.fileName)) {
+            return entry.fileName.toString(this.opts.fileNamesEncoding);
+        }
+        return entry.fileName;
+    }
+    async extract() {
+        const { dir, fileNamesEncoding } = this.opts;
+        this.zipfile = await openZip(this.zipPath, {
+            lazyEntries: true,
+            // https://github.com/thejoshwolfe/yauzl/commit/cc7455ac789ba84973184e5ebde0581cdc4c3b39#diff-04c6e90faac2675aa89e2176d2eec7d8R95
+            decodeStrings: !fileNamesEncoding,
+        });
+        this.canceled = false;
+        return new Promise((resolve, reject) => {
+            this.zipfile.on('error', (err) => {
+                this.canceled = true;
+                reject(err);
+            });
+            this.zipfile.readEntry();
+            this.zipfile.on('close', () => {
+                if (!this.canceled) {
+                    resolve();
+                }
+            });
+            this.zipfile.on('entry', async (entry) => {
+                if (this.canceled) {
+                    return;
+                }
+                const fileName = this.extractFileName(entry);
+                if (fileName.startsWith('__MACOSX/')) {
+                    this.zipfile.readEntry();
+                    return;
+                }
+                const destDir = node_path_1.default.dirname(node_path_1.default.join(dir, fileName));
+                try {
+                    await fs_1.fs.mkdir(destDir, { recursive: true });
+                    const canonicalDestDir = await fs_1.fs.realpath(destDir);
+                    const relativeDestDir = node_path_1.default.relative(dir, canonicalDestDir);
+                    if (relativeDestDir.split(node_path_1.default.sep).includes('..')) {
+                        throw new Error(`Out of bound path "${canonicalDestDir}" found while processing file ${fileName}`);
+                    }
+                    await this.extractEntry(entry);
+                    this.zipfile.readEntry();
+                }
+                catch (err) {
+                    this.canceled = true;
+                    this.zipfile.close();
+                    reject(err);
+                }
+            });
+        });
+    }
+    async extractEntry(entry) {
+        if (this.canceled) {
+            return;
+        }
+        const { dir } = this.opts;
+        const fileName = this.extractFileName(entry);
+        const dest = node_path_1.default.join(dir, fileName);
+        // convert external file attr int into a fs stat mode int
+        const mode = (entry.externalFileAttributes >> 16) & 0xffff;
+        // check if it's a symlink or dir (using stat mode constants)
+        const isSymlink = (mode & IFMT) === IFLNK;
+        const isDir = (mode & IFMT) === IFDIR ||
+            // Failsafe, borrowed from jsZip
+            fileName.endsWith('/') ||
+            // check for windows weird way of specifying a directory
+            // https://github.com/maxogden/extract-zip/issues/13#issuecomment-154494566
+            (entry.versionMadeBy >> 8 === 0 && entry.externalFileAttributes === 16);
+        const procMode = this.getExtractedMode(mode, isDir) & 0o777;
+        // always ensure folders are created
+        const destDir = isDir ? dest : node_path_1.default.dirname(dest);
+        const mkdirOptions = { recursive: true };
+        if (isDir) {
+            mkdirOptions.mode = procMode;
+        }
+        await fs_1.fs.mkdir(destDir, mkdirOptions);
+        if (isDir) {
+            return;
+        }
+        const openReadStream = (0, node_util_1.promisify)(this.zipfile.openReadStream.bind(this.zipfile));
+        const readStream = await openReadStream(entry);
+        if (isSymlink) {
+            const link = await (0, get_stream_1.default)(readStream);
+            await fs_1.fs.symlink(link, dest);
+        }
+        else {
+            await (0, promises_1.pipeline)(readStream, fs_1.fs.createWriteStream(dest, { mode: procMode }));
+        }
+    }
+    getExtractedMode(entryMode, isDir) {
+        const { defaultDirMode, defaultFileMode } = this.opts;
+        let mode = entryMode;
+        // Set defaults, if necessary
+        if (mode === 0) {
+            if (isDir) {
+                if (defaultDirMode) {
+                    mode = parseInt(defaultDirMode, 10);
+                }
+                if (!mode) {
+                    mode = 0o755;
+                }
+            }
+            else {
+                if (defaultFileMode) {
+                    mode = parseInt(defaultFileMode, 10);
+                }
+                if (!mode) {
+                    mode = 0o644;
+                }
+            }
+        }
+        return mode;
+    }
+}
+/**
+ * Executes system unzip (e.g., `/usr/bin/unzip`). If available, it is
+ * significantly faster than the JS implementation.
+ * By default all files in the destDir get overridden if already exist.
+ *
+ * @param zipFilePath The full path to the source ZIP file
+ * @param destDir The full path to the destination folder.
+ * This folder is expected to already exist before extracting the archive.
+ */
+async function extractWithSystemUnzip(zipFilePath, destDir) {
+    const isWindowsHost = (0, system_1.isWindows)();
+    let executablePath;
+    try {
+        executablePath = await getExecutablePath(isWindowsHost ? 'powershell.exe' : 'unzip');
+    }
+    catch {
+        throw new Error('Could not find system unzip');
+    }
+    if (isWindowsHost) {
+        // on Windows we use PowerShell to unzip files
+        await (0, teen_process_1.exec)(executablePath, [
+            '-command',
+            'Expand-Archive',
+            '-LiteralPath',
+            zipFilePath,
+            '-DestinationPath',
+            destDir,
+            '-Force',
+        ]);
+    }
+    else {
+        // -q means quiet (no stdout)
+        // -o means overwrite
+        // -d is the dest dir
+        await (0, teen_process_1.exec)(executablePath, ['-q', '-o', zipFilePath, '-d', destDir]);
+    }
+}
 /**
  * Finds and memoizes the full path to the given executable.
  * Rejects if it is not found.
  */
 const getExecutablePath = lodash_1.default.memoize(
 /**
- * @returns {Promise<string>} Full Path to the executable
+ * @returns Full Path to the executable
  */
 async function getExecutablePath(binaryName) {
-    const fullPath = await fs_2.fs.which(binaryName);
+    const fullPath = await fs_1.fs.which(binaryName);
     logger_1.default.debug(`Found '${binaryName}' at '${fullPath}'`);
     return fullPath;
 });