conductor-oss 0.61.9 → 0.61.11

package/web/.next/standalone/node_modules/@puppeteer/browsers/lib/browser-data/types.js

@@ -0,0 +1,72 @@
+/**
+ * @license
+ * Copyright 2023 Google Inc.
+ * SPDX-License-Identifier: Apache-2.0
+ */
+/**
+ * Supported browsers.
+ *
+ * @public
+ */
+export var Browser;
+(function (Browser) {
+    Browser["CHROME"] = "chrome";
+    Browser["CHROMEHEADLESSSHELL"] = "chrome-headless-shell";
+    Browser["CHROMIUM"] = "chromium";
+    Browser["FIREFOX"] = "firefox";
+    Browser["CHROMEDRIVER"] = "chromedriver";
+})(Browser || (Browser = {}));
+/**
+ * Platform names used to identify a OS platform x architecture combination in the way
+ * that is relevant for the browser download.
+ *
+ * @public
+ */
+export var BrowserPlatform;
+(function (BrowserPlatform) {
+    BrowserPlatform["LINUX"] = "linux";
+    BrowserPlatform["LINUX_ARM"] = "linux_arm";
+    BrowserPlatform["MAC"] = "mac";
+    BrowserPlatform["MAC_ARM"] = "mac_arm";
+    BrowserPlatform["WIN32"] = "win32";
+    BrowserPlatform["WIN64"] = "win64";
+})(BrowserPlatform || (BrowserPlatform = {}));
+/**
+ * Enum describing a release channel for a browser.
+ *
+ * You can use this in combination with {@link resolveBuildId} to resolve
+ * a build ID based on a release channel.
+ *
+ * @public
+ */
+export var BrowserTag;
+(function (BrowserTag) {
+    BrowserTag["CANARY"] = "canary";
+    BrowserTag["NIGHTLY"] = "nightly";
+    BrowserTag["BETA"] = "beta";
+    BrowserTag["DEV"] = "dev";
+    BrowserTag["DEVEDITION"] = "devedition";
+    BrowserTag["STABLE"] = "stable";
+    BrowserTag["ESR"] = "esr";
+    BrowserTag["LATEST"] = "latest";
+})(BrowserTag || (BrowserTag = {}));
+/**
+ * @public
+ */
+export var ChromeReleaseChannel;
+(function (ChromeReleaseChannel) {
+    ChromeReleaseChannel["STABLE"] = "stable";
+    ChromeReleaseChannel["DEV"] = "dev";
+    ChromeReleaseChannel["CANARY"] = "canary";
+    ChromeReleaseChannel["BETA"] = "beta";
+})(ChromeReleaseChannel || (ChromeReleaseChannel = {}));
+/**
+ * @internal
+ */
+export function verifyChromeReleaseChannel(value) {
+    if (Object.values(ChromeReleaseChannel).includes(value)) {
+        return value;
+    }
+    throw new Error(`Invalid Chrome channel: ${value}`);
+}
+//# sourceMappingURL=types.js.map

package/web/.next/standalone/node_modules/@puppeteer/browsers/lib/debug.js

@@ -0,0 +1,11 @@
+/**
+ * @license
+ * Copyright 2023 Google Inc.
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { debuglog } from 'node:util';
+export const debug = (prefix) => {
+    const log = debuglog(prefix);
+    return log.enabled ? log : undefined;
+};
+//# sourceMappingURL=debug.js.map

package/web/.next/standalone/node_modules/@puppeteer/browsers/lib/fileUtil.js

@@ -0,0 +1,316 @@
+/**
+ * @license
+ * Copyright 2023 Google Inc.
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { spawnSync, spawn, execFile } from 'node:child_process';
+import { constants, createReadStream, createWriteStream } from 'node:fs';
+import { mkdir, readdir, symlink } from 'node:fs/promises';
+import * as path from 'node:path';
+import { Stream, Writable } from 'node:stream';
+import { pipeline } from 'node:stream/promises';
+import { promisify } from 'node:util';
+import { debug } from './debug.js';
+const execFileAsync = promisify(execFile);
+const debugFileUtil = debug('puppeteer:browsers:fileUtil');
+/**
+ * @internal
+ */
+export async function unpackArchive(archivePath, folderPath) {
+    if (!path.isAbsolute(folderPath)) {
+        folderPath = path.resolve(process.cwd(), folderPath);
+    }
+    if (archivePath.endsWith('.zip')) {
+        await mkdir(folderPath, { recursive: true });
+        await extractZip(archivePath, folderPath);
+    }
+    else if (archivePath.endsWith('.tar.bz2')) {
+        await extractTar(archivePath, folderPath, 'bzip2');
+    }
+    else if (archivePath.endsWith('.dmg')) {
+        await mkdir(folderPath);
+        await installDMG(archivePath, folderPath);
+    }
+    else if (archivePath.endsWith('.exe')) {
+        // Firefox on Windows.
+        const result = spawnSync(archivePath, [`/ExtractDir=${folderPath}`], {
+            env: {
+                __compat_layer: 'RunAsInvoker',
+            },
+        });
+        if (result.status !== 0) {
+            throw new Error(`Failed to extract ${archivePath} to ${folderPath}: ${result.output}`);
+        }
+    }
+    else if (archivePath.endsWith('.tar.xz')) {
+        await extractTar(archivePath, folderPath, 'xz');
+    }
+    else {
+        throw new Error(`Unsupported archive format: ${archivePath}`);
+    }
+}
+function createTransformStream(child) {
+    const stream = new Stream.Transform({
+        transform(chunk, encoding, callback) {
+            if (!child.stdin.write(chunk, encoding)) {
+                child.stdin.once('drain', callback);
+            }
+            else {
+                callback();
+            }
+        },
+        flush(callback) {
+            if (child.stdout.destroyed) {
+                callback();
+            }
+            else {
+                child.stdin.end();
+                child.stdout.on('close', callback);
+            }
+        },
+    });
+    child.stdin.on('error', e => {
+        if ('code' in e && e.code === 'EPIPE') {
+            // finished before reading the file finished (i.e. head)
+            stream.emit('end');
+        }
+        else {
+            stream.destroy(e);
+        }
+    });
+    child.stdout
+        .on('data', data => {
+        return stream.push(data);
+    })
+        .on('error', e => {
+        return stream.destroy(e);
+    });
+    child.once('close', () => {
+        return stream.end();
+    });
+    return stream;
+}
+/**
+ * @internal
+ */
+export const internalConstantsForTesting = {
+    xz: 'xz',
+    bzip2: 'bzip2',
+};
+/**
+ * @internal
+ */
+async function extractTar(tarPath, folderPath, decompressUtilityName) {
+    const { unpackTar } = await import('modern-tar/fs');
+    return await new Promise((fulfill, reject) => {
+        function handleError(utilityName) {
+            return (error) => {
+                if ('code' in error && error.code === 'ENOENT') {
+                    error = new Error(`\`${utilityName}\` utility is required to unpack this archive`, {
+                        cause: error,
+                    });
+                }
+                reject(error);
+            };
+        }
+        const unpack = spawn(internalConstantsForTesting[decompressUtilityName], ['-d'], {
+            stdio: ['pipe', 'pipe', 'inherit'],
+        })
+            .once('error', handleError(decompressUtilityName))
+            .once('exit', code => {
+            debugFileUtil?.(`${decompressUtilityName} exited, code=${code}`);
+        });
+        const tar = unpackTar(folderPath);
+        tar.once('error', handleError('tar'));
+        tar.once('finish', fulfill);
+        createReadStream(tarPath).pipe(createTransformStream(unpack)).pipe(tar);
+    });
+}
+/**
+ * @internal
+ */
+async function installDMG(dmgPath, folderPath) {
+    const { stdout } = await execFileAsync('hdiutil', [
+        'attach',
+        '-nobrowse',
+        '-noautoopen',
+        dmgPath,
+    ]);
+    const volumes = stdout.match(/\/Volumes\/(.*)/m);
+    if (!volumes) {
+        throw new Error(`Could not find volume path in ${stdout}`);
+    }
+    const mountPath = volumes[0];
+    try {
+        const fileNames = await readdir(mountPath);
+        const appName = fileNames.find(item => {
+            return typeof item === 'string' && item.endsWith('.app');
+        });
+        if (!appName) {
+            throw new Error(`Cannot find app in ${mountPath}`);
+        }
+        const mountedPath = path.join(mountPath, appName);
+        await execFileAsync('cp', ['-R', mountedPath, folderPath]);
+    }
+    finally {
+        await execFileAsync('hdiutil', ['detach', mountPath, '-quiet']);
+    }
+}
+/**
+ * @internal
+ */
+class ArchiverUnavailableError extends Error {
+}
+/**
+ * @internal
+ */
+async function extractZip(archivePath, folderPath) {
+    for (const extract of [extractZipWithCli, extractZipWithYauzl]) {
+        try {
+            await extract(archivePath, folderPath);
+            return;
+        }
+        catch (error) {
+            if (!(error instanceof ArchiverUnavailableError)) {
+                throw error;
+            }
+        }
+    }
+    throw new Error(`Extraction failed: no zip archiver is available. Install \`unzip\` (or \`tar.exe\`/Powershell on Windows), or add the optional \`yauzl\` dependency.`);
+}
+/**
+ * @internal
+ */
+export async function extractZipWithYauzl(archivePath, folderPath) {
+    const { default: yauzl } = await import(
+    /* webpackIgnore: true */ 'yauzl').catch(() => {
+        throw new ArchiverUnavailableError('Extraction failed: The optional `yauzl` dependency is not installed.');
+    });
+    const open = promisify(yauzl.open);
+    try {
+        const zipFile = await open(archivePath, { lazyEntries: true });
+        await new Promise((resolve, reject) => {
+            zipFile
+                .on('error', reject)
+                .on('end', resolve)
+                .on('entry', entry => {
+                extractZipEntry(zipFile, entry, folderPath).then(() => {
+                    zipFile.readEntry();
+                }, reject);
+            })
+                .readEntry();
+        });
+    }
+    catch (error) {
+        throw new Error(`Extraction failed: ${archivePath}`, { cause: error });
+    }
+}
+/**
+ * @internal
+ */
+async function extractZipWithCli(archivePath, folderPath) {
+    try {
+        if (process.platform === 'win32') {
+            const systemRoot = process.env['SystemRoot'] ?? process.env['SYSTEMROOT'] ?? 'C:\\Windows';
+            try {
+                const systemTar = `${systemRoot}\\System32\\tar.exe`;
+                // -x: extract files
+                // -f: specify the archive file
+                // -C: extract to the specified directory
+                await execFileAsync(systemTar, ['-xf', archivePath, '-C', folderPath]);
+                return;
+            }
+            catch (tarError) {
+                debugFileUtil?.(`tar.exe extraction failed: ${tarError}`);
+            }
+            try {
+                await execFileAsync('powershell.exe', [
+                    '-NoProfile',
+                    '-NonInteractive',
+                    '-Command',
+                    '& { Expand-Archive -LiteralPath $args[0] -DestinationPath $args[1] -Force }',
+                    archivePath,
+                    folderPath,
+                ]);
+                return;
+            }
+            catch (powershellError) {
+                debugFileUtil?.(`powershell.exe extraction failed: ${powershellError}`);
+            }
+            await execFileAsync('pwsh.exe', [
+                '-NoProfile',
+                '-NonInteractive',
+                '-Command',
+                '& { Expand-Archive -LiteralPath $args[0] -DestinationPath $args[1] -Force }',
+                archivePath,
+                folderPath,
+            ]);
+        }
+        else {
+            // -o: overwrite existing files without prompting
+            // -d: extract files into the specified directory
+            await execFileAsync('unzip', ['-o', archivePath, '-d', folderPath]);
+        }
+    }
+    catch (error) {
+        if (error?.code === 'ENOENT') {
+            throw new ArchiverUnavailableError(`Extraction failed: Required native binary ('tar.exe', 'powershell.exe', 'pwsh.exe' or 'unzip') was not found in the system PATH.`);
+        }
+        throw new Error(`Extraction failed: ${error?.stderr?.toString() || error?.message}`);
+    }
+}
+/**
+ * @internal
+ */
+function isInsideDirectory(directory, candidate) {
+    const resolvedDirectory = path.resolve(directory);
+    const resolvedCandidate = path.resolve(candidate);
+    return (resolvedCandidate === resolvedDirectory ||
+        resolvedCandidate.startsWith(resolvedDirectory + path.sep));
+}
+/**
+ * @internal
+ */
+async function extractZipEntry(zipFile, entry, folderPath) {
+    const { S_IFMT, S_IFDIR, S_IFLNK } = constants;
+    // see https://github.com/max-mapper/extract-zip/blob/v2.0.1/index.js#L90-L107
+    const unixMode = entry.externalFileAttributes >>> 16;
+    const isDirectory = (unixMode & S_IFMT) === S_IFDIR ||
+        entry.fileName.endsWith('/') ||
+        (entry.versionMadeBy >> 8 === 0 && entry.externalFileAttributes === 0x10);
+    const isSymlink = (unixMode & S_IFMT) === S_IFLNK;
+    // Fall back to sensible defaults for archives without Unix attributes.
+    const mode = unixMode === 0 ? (isDirectory ? 0o755 : 0o644) : unixMode & 0o777;
+    const destination = path.join(folderPath, entry.fileName);
+    if (isDirectory) {
+        await mkdir(destination, { recursive: true, mode });
+        return;
+    }
+    await mkdir(path.dirname(destination), { recursive: true });
+    const readStream = await promisify(zipFile.openReadStream.bind(zipFile))(entry);
+    if (isSymlink) {
+        // Consume the symlink target in pipe semantics rather than via async
+        // iteration (e.g. stream/consumers `text()`): yauzl <3.3.1 read streams
+        // never emit "close", which hangs consumers (thejoshwolfe/yauzl#169)
+        const chunks = [];
+        await pipeline(readStream, new Writable({
+            write(chunk, _encoding, callback) {
+                // yauzl opens entries in binary mode, so chunks are always Buffers.
+                if (chunk instanceof Buffer) {
+                    chunks.push(chunk);
+                }
+                callback();
+            },
+        }));
+        const linkTarget = Buffer.concat(chunks).toString();
+        // Verify that the link does not resolve outside of the target directory.
+        const resolvedLinkTarget = path.resolve(path.dirname(destination), linkTarget);
+        if (!isInsideDirectory(folderPath, resolvedLinkTarget)) {
+            throw new Error(`Zip symlink "${entry.fileName}" would point outside of the target directory.`);
+        }
+        await symlink(linkTarget, destination);
+        return;
+    }
+    await pipeline(readStream, createWriteStream(destination, { mode }));
+}
+//# sourceMappingURL=fileUtil.js.map

package/web/.next/standalone/node_modules/@puppeteer/browsers/lib/httpUtil.js

@@ -0,0 +1,176 @@
+/**
+ * @license
+ * Copyright 2023 Google Inc.
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { createHash } from 'node:crypto';
+import { createWriteStream, unlinkSync } from 'node:fs';
+import * as http from 'node:http';
+import * as https from 'node:https';
+import { URL, urlToHttpOptions } from 'node:url';
+export async function headHttpRequest(url) {
+    return await new Promise(resolve => {
+        httpRequest(url, 'HEAD', response => {
+            // consume response data free node process
+            response.resume();
+            resolve(response.statusCode === 200);
+        }, false)
+            .then(request => {
+            request.on('error', () => {
+                resolve(false);
+            });
+        })
+            .catch(() => {
+            resolve(false);
+        });
+    });
+}
+export async function httpRequest(url, method, response, keepAlive = true) {
+    let agent;
+    try {
+        const { ProxyAgent } = await import('proxy-agent');
+        agent = new ProxyAgent();
+    }
+    catch {
+        // Standard Node.js agents will be used.
+    }
+    const options = {
+        protocol: url.protocol,
+        hostname: url.hostname,
+        port: url.port,
+        path: url.pathname + url.search,
+        method,
+        headers: keepAlive ? { Connection: 'keep-alive' } : undefined,
+        auth: urlToHttpOptions(url).auth,
+        agent,
+    };
+    const requestCallback = (res) => {
+        if (res.statusCode &&
+            res.statusCode >= 300 &&
+            res.statusCode < 400 &&
+            res.headers.location) {
+            void httpRequest(new URL(res.headers.location), method, response);
+            // consume response data to free up memory
+            // And prevents the connection from being kept alive
+            res.resume();
+        }
+        else {
+            response(res);
+        }
+    };
+    const request = options.protocol === 'https:'
+        ? https.request(options, requestCallback)
+        : http.request(options, requestCallback);
+    request.end();
+    return request;
+}
+class HashVerifier {
+    #hash = createHash('sha256');
+    update(chunk) {
+        this.#hash.update(chunk);
+    }
+    verify(url, destinationPath, expectedHash) {
+        const actualHash = this.#hash.digest('hex');
+        if (actualHash !== expectedHash.toLowerCase()) {
+            try {
+                unlinkSync(destinationPath);
+            }
+            catch { }
+            throw new Error(`Integrity check failed for downloaded browser archive.\n` +
+                `  URL:      ${url}\n` +
+                `  Expected: ${expectedHash.toLowerCase()}\n` +
+                `  Actual:   ${actualHash}`);
+        }
+    }
+}
+/**
+ * @internal
+ */
+export function downloadFile(url, destinationPath, progressCallback, expectedHash) {
+    return new Promise(async (resolve, reject) => {
+        let downloadedBytes = 0;
+        let totalBytes = 0;
+        const verifier = expectedHash ? new HashVerifier() : null;
+        try {
+            const request = await httpRequest(url, 'GET', response => {
+                if (response.statusCode !== 200) {
+                    const error = new Error(`Download failed: server returned code ${response.statusCode}. URL: ${url}`);
+                    // consume response data to free up memory
+                    response.resume();
+                    reject(error);
+                    return;
+                }
+                const file = createWriteStream(destinationPath);
+                file.on('close', () => {
+                    if (verifier && expectedHash) {
+                        try {
+                            verifier.verify(url, destinationPath, expectedHash);
+                        }
+                        catch (err) {
+                            reject(err);
+                            return;
+                        }
+                    }
+                    return resolve();
+                });
+                file.on('error', error => {
+                    return reject(error);
+                });
+                totalBytes = parseInt(response.headers['content-length'], 10);
+                response.on('data', (chunk) => {
+                    downloadedBytes += chunk.length;
+                    verifier?.update(chunk);
+                    if (progressCallback) {
+                        progressCallback(downloadedBytes, totalBytes);
+                    }
+                });
+                response.pipe(file);
+            });
+            request.on('error', error => {
+                return reject(error);
+            });
+        }
+        catch (error) {
+            reject(error);
+        }
+    });
+}
+export async function getJSON(url) {
+    const text = await getText(url);
+    try {
+        return JSON.parse(text);
+    }
+    catch {
+        throw new Error('Could not parse JSON from ' + url.toString());
+    }
+}
+export function getText(url) {
+    return new Promise(async (resolve, reject) => {
+        try {
+            const request = await httpRequest(url, 'GET', response => {
+                let data = '';
+                if (response.statusCode && response.statusCode >= 400) {
+                    return reject(new Error(`Got status code ${response.statusCode}`));
+                }
+                response.on('data', chunk => {
+                    data += chunk;
+                });
+                response.on('end', () => {
+                    try {
+                        return resolve(String(data));
+                    }
+                    catch {
+                        return reject(new Error(`Failed to read text response from ${url}`));
+                    }
+                });
+            }, false);
+            request.on('error', err => {
+                reject(err);
+            });
+        }
+        catch (err) {
+            reject(err);
+        }
+    });
+}
+//# sourceMappingURL=httpUtil.js.map