conductor-oss 0.61.9 → 0.61.11

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

@@ -0,0 +1,143 @@
+/**
+ * @license
+ * Copyright 2026 Google Inc.
+ * SPDX-License-Identifier: Apache-2.0
+ */
+// Module-level active session. Concurrent bars share a session; a new session
+// starts whenever no bar is currently active (or the stream changes).
+let activeBar = null;
+/**
+ * Manages one or more concurrent progress bars on separate terminal lines.
+ * Use {@link ProgressBar.createBarTicker} to add a bar; concurrent calls
+ * automatically share a session so bars don't overwrite each other.
+ *
+ * @internal
+ */
+export class ProgressBar {
+    #stream;
+    #totalRows = 0;
+    #doneCount = 0;
+    #bars = [];
+    #renderScheduled = false;
+    #lastRenderTime = 0;
+    #allDone = false;
+    constructor(stream) {
+        this.#stream = stream;
+    }
+    /**
+     * Returns a `tick(delta)` function for a new progress bar. If another bar
+     * is already active on the same stream, the new bar appears on the next line
+     * and both update in place. The trailing newline is emitted automatically
+     * once every bar in the session has reached 100%.
+     */
+    static createBarTicker(title, total, stream = process.stderr) {
+        // Start a fresh session when none is active or the stream changed.
+        if (!activeBar || activeBar.#stream !== stream) {
+            activeBar = new ProgressBar(stream);
+        }
+        return activeBar.#addBar(title, total);
+    }
+    #claimRow() {
+        const row = this.#totalRows++;
+        if (row > 0 && this.#stream.isTTY) {
+            // Cursor is parked at col 0 of the previous bottom row; \n opens the
+            // new line and moves the cursor there, establishing the new bottom row.
+            this.#stream.write('\n');
+        }
+        return row;
+    }
+    #addBar(title, total) {
+        const row = this.#claimRow();
+        this.#bars.push({
+            title,
+            total,
+            downloaded: 0,
+            startTime: 0,
+            lastRendered: '',
+        });
+        let doneNotified = false;
+        return (delta) => {
+            const bar = this.#bars[row];
+            if (bar.startTime === 0) {
+                bar.startTime = Date.now();
+            }
+            bar.downloaded += delta;
+            const isDone = bar.downloaded >= bar.total;
+            if (isDone || Date.now() - this.#lastRenderTime >= 100) {
+                this.#scheduleRender();
+            }
+            if (isDone && !doneNotified) {
+                doneNotified = true;
+                this.#onBarDone();
+            }
+        };
+    }
+    // Defers to a microtask so multiple ticks in the same turn share one render
+    // pass and the cursor only moves once.
+    #scheduleRender() {
+        if (!this.#renderScheduled) {
+            this.#renderScheduled = true;
+            queueMicrotask(() => {
+                this.#renderScheduled = false;
+                this.#lastRenderTime = Date.now();
+                this.#renderAll();
+            });
+        }
+    }
+    #computeRendered(row) {
+        const bar = this.#bars[row];
+        const ratio = Math.min(1, Math.max(0, bar.downloaded / bar.total));
+        const percent = Math.round(ratio * 100);
+        const elapsedMs = bar.startTime > 0 ? Date.now() - bar.startTime : 0;
+        const rate = elapsedMs > 0 ? bar.downloaded / elapsedMs : 0; // bytes/ms
+        const etaSec = rate > 0 ? (bar.total - bar.downloaded) / rate / 1000 : 0;
+        const width = 20;
+        const completeCount = Math.round(width * ratio);
+        const barStr = '='.repeat(completeCount) + ' '.repeat(width - completeCount);
+        const status = ratio >= 1 ? 'unpacking' : `${percent}% ${etaSec.toFixed(1)}s`;
+        return `${bar.title} [${barStr}] ${status} `;
+    }
+    // Invariant: cursor is at col 0 of the bottom row before and after this call.
+    // Single top-down pass: go up to bar 0, render each bar, come back to bottom.
+    #renderAll() {
+        if (!this.#stream.isTTY) {
+            return;
+        }
+        const N = this.#totalRows;
+        if (N === 0) {
+            return;
+        }
+        // Move cursor to top of bar area.
+        if (N > 1) {
+            this.#stream.moveCursor(0, -(N - 1));
+        }
+        for (let row = 0; row < N; row++) {
+            const rendered = this.#computeRendered(row);
+            if (rendered !== this.#bars[row].lastRendered) {
+                this.#stream.cursorTo(0);
+                this.#stream.write(rendered);
+                this.#stream.clearLine(1);
+                this.#bars[row].lastRendered = rendered;
+            }
+            if (row < N - 1) {
+                this.#stream.moveCursor(0, 1);
+            }
+        }
+        // Park cursor at col 0 of the bottom row.
+        this.#stream.cursorTo(0);
+        if (this.#allDone) {
+            activeBar = null;
+            this.#stream.write('\n');
+        }
+    }
+    #onBarDone() {
+        this.#doneCount++;
+        if (this.#doneCount >= this.#totalRows && this.#totalRows > 0) {
+            this.#allDone = true;
+            // Don't emit \n here — the pending render microtask hasn't run yet.
+            // #renderAll() will emit it after the final pass so the cursor is
+            // already past the last bar line before the newline moves it.
+        }
+    }
+}
+//# sourceMappingURL=ProgressBar.js.map

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

@@ -0,0 +1,235 @@
+/**
+ * @license
+ * Copyright 2023 Google Inc.
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import * as chromeHeadlessShell from './chrome-headless-shell.js';
+import * as chrome from './chrome.js';
+import * as chromedriver from './chromedriver.js';
+import * as chromium from './chromium.js';
+import * as firefox from './firefox.js';
+import { Browser, BrowserPlatform, BrowserTag, ChromeReleaseChannel, verifyChromeReleaseChannel, } from './types.js';
+export const downloadUrls = {
+    [Browser.CHROMEDRIVER]: chromedriver.resolveDownloadUrl,
+    [Browser.CHROMEHEADLESSSHELL]: chromeHeadlessShell.resolveDownloadUrl,
+    [Browser.CHROME]: chrome.resolveDownloadUrl,
+    [Browser.CHROMIUM]: chromium.resolveDownloadUrl,
+    [Browser.FIREFOX]: firefox.resolveDownloadUrl,
+};
+export const downloadPaths = {
+    [Browser.CHROMEDRIVER]: chromedriver.resolveDownloadPath,
+    [Browser.CHROMEHEADLESSSHELL]: chromeHeadlessShell.resolveDownloadPath,
+    [Browser.CHROME]: chrome.resolveDownloadPath,
+    [Browser.CHROMIUM]: chromium.resolveDownloadPath,
+    [Browser.FIREFOX]: firefox.resolveDownloadPath,
+};
+export const executablePathByBrowser = {
+    [Browser.CHROMEDRIVER]: chromedriver.relativeExecutablePath,
+    [Browser.CHROMEHEADLESSSHELL]: chromeHeadlessShell.relativeExecutablePath,
+    [Browser.CHROME]: chrome.relativeExecutablePath,
+    [Browser.CHROMIUM]: chromium.relativeExecutablePath,
+    [Browser.FIREFOX]: firefox.relativeExecutablePath,
+};
+export const versionComparators = {
+    [Browser.CHROMEDRIVER]: chromedriver.compareVersions,
+    [Browser.CHROMEHEADLESSSHELL]: chromeHeadlessShell.compareVersions,
+    [Browser.CHROME]: chrome.compareVersions,
+    [Browser.CHROMIUM]: chromium.compareVersions,
+    [Browser.FIREFOX]: firefox.compareVersions,
+};
+export { Browser, BrowserPlatform, ChromeReleaseChannel, verifyChromeReleaseChannel, };
+/**
+ * @internal
+ */
+async function resolveBuildIdForBrowserTag(browser, platform, tag) {
+    switch (browser) {
+        case Browser.FIREFOX:
+            switch (tag) {
+                case BrowserTag.LATEST:
+                    return await firefox.resolveBuildId(firefox.FirefoxChannel.NIGHTLY);
+                case BrowserTag.BETA:
+                    return await firefox.resolveBuildId(firefox.FirefoxChannel.BETA);
+                case BrowserTag.NIGHTLY:
+                    return await firefox.resolveBuildId(firefox.FirefoxChannel.NIGHTLY);
+                case BrowserTag.DEVEDITION:
+                    return await firefox.resolveBuildId(firefox.FirefoxChannel.DEVEDITION);
+                case BrowserTag.STABLE:
+                    return await firefox.resolveBuildId(firefox.FirefoxChannel.STABLE);
+                case BrowserTag.ESR:
+                    return await firefox.resolveBuildId(firefox.FirefoxChannel.ESR);
+                case BrowserTag.CANARY:
+                case BrowserTag.DEV:
+                    throw new Error(`${tag.toUpperCase()} is not available for Firefox`);
+            }
+        case Browser.CHROME: {
+            switch (tag) {
+                case BrowserTag.LATEST:
+                    return await chrome.resolveBuildId(ChromeReleaseChannel.CANARY);
+                case BrowserTag.BETA:
+                    return await chrome.resolveBuildId(ChromeReleaseChannel.BETA);
+                case BrowserTag.CANARY:
+                    return await chrome.resolveBuildId(ChromeReleaseChannel.CANARY);
+                case BrowserTag.DEV:
+                    return await chrome.resolveBuildId(ChromeReleaseChannel.DEV);
+                case BrowserTag.STABLE:
+                    return await chrome.resolveBuildId(ChromeReleaseChannel.STABLE);
+                case BrowserTag.NIGHTLY:
+                case BrowserTag.DEVEDITION:
+                case BrowserTag.ESR:
+                    throw new Error(`${tag.toUpperCase()} is not available for Chrome`);
+            }
+        }
+        case Browser.CHROMEDRIVER: {
+            switch (tag) {
+                case BrowserTag.LATEST:
+                case BrowserTag.CANARY:
+                    return await chromedriver.resolveBuildId(ChromeReleaseChannel.CANARY);
+                case BrowserTag.BETA:
+                    return await chromedriver.resolveBuildId(ChromeReleaseChannel.BETA);
+                case BrowserTag.DEV:
+                    return await chromedriver.resolveBuildId(ChromeReleaseChannel.DEV);
+                case BrowserTag.STABLE:
+                    return await chromedriver.resolveBuildId(ChromeReleaseChannel.STABLE);
+                case BrowserTag.NIGHTLY:
+                case BrowserTag.DEVEDITION:
+                case BrowserTag.ESR:
+                    throw new Error(`${tag.toUpperCase()} is not available for ChromeDriver`);
+            }
+        }
+        case Browser.CHROMEHEADLESSSHELL: {
+            switch (tag) {
+                case BrowserTag.LATEST:
+                case BrowserTag.CANARY:
+                    return await chromeHeadlessShell.resolveBuildId(ChromeReleaseChannel.CANARY);
+                case BrowserTag.BETA:
+                    return await chromeHeadlessShell.resolveBuildId(ChromeReleaseChannel.BETA);
+                case BrowserTag.DEV:
+                    return await chromeHeadlessShell.resolveBuildId(ChromeReleaseChannel.DEV);
+                case BrowserTag.STABLE:
+                    return await chromeHeadlessShell.resolveBuildId(ChromeReleaseChannel.STABLE);
+                case BrowserTag.NIGHTLY:
+                case BrowserTag.DEVEDITION:
+                case BrowserTag.ESR:
+                    throw new Error(`${tag} is not available for chrome-headless-shell`);
+            }
+        }
+        case Browser.CHROMIUM:
+            switch (tag) {
+                case BrowserTag.LATEST:
+                    return await chromium.resolveBuildId(platform);
+                case BrowserTag.NIGHTLY:
+                case BrowserTag.CANARY:
+                case BrowserTag.DEV:
+                case BrowserTag.DEVEDITION:
+                case BrowserTag.BETA:
+                case BrowserTag.STABLE:
+                case BrowserTag.ESR:
+                    throw new Error(`${tag} is not supported for Chromium. Use 'latest' instead.`);
+            }
+    }
+}
+/**
+ * @public
+ */
+export async function resolveBuildId(browser, platform, tag) {
+    const browserTag = tag;
+    if (Object.values(BrowserTag).includes(browserTag)) {
+        return await resolveBuildIdForBrowserTag(browser, platform, browserTag);
+    }
+    switch (browser) {
+        case Browser.FIREFOX:
+            return tag;
+        case Browser.CHROME:
+            const chromeResult = await chrome.resolveBuildId(tag);
+            if (chromeResult) {
+                return chromeResult;
+            }
+            return tag;
+        case Browser.CHROMEDRIVER:
+            const chromeDriverResult = await chromedriver.resolveBuildId(tag);
+            if (chromeDriverResult) {
+                return chromeDriverResult;
+            }
+            return tag;
+        case Browser.CHROMEHEADLESSSHELL:
+            const chromeHeadlessShellResult = await chromeHeadlessShell.resolveBuildId(tag);
+            if (chromeHeadlessShellResult) {
+                return chromeHeadlessShellResult;
+            }
+            return tag;
+        case Browser.CHROMIUM:
+            return tag;
+    }
+}
+/**
+ * @public
+ */
+export async function createProfile(browser, opts) {
+    switch (browser) {
+        case Browser.FIREFOX:
+            return await firefox.createProfile(opts);
+        case Browser.CHROME:
+        case Browser.CHROMIUM:
+            throw new Error(`Profile creation is not support for ${browser} yet`);
+    }
+}
+/**
+ * @public
+ *
+ * Gets the first resolved system path
+ */
+export function resolveSystemExecutablePath(browser, platform, channel) {
+    switch (browser) {
+        case Browser.CHROMEDRIVER:
+        case Browser.CHROMEHEADLESSSHELL:
+        case Browser.FIREFOX:
+        case Browser.CHROMIUM:
+            throw new Error(`System browser detection is not supported for ${browser} yet.`);
+        case Browser.CHROME:
+            return chrome.resolveSystemExecutablePaths(platform, channel)[0];
+    }
+}
+/**
+ * Returns the expected default user data dir for the given channel. It does not
+ * check if the dir actually exists.
+ *
+ * @public
+ */
+export function resolveDefaultUserDataDir(browser, platform, channel) {
+    switch (browser) {
+        case Browser.CHROMEDRIVER:
+        case Browser.CHROMEHEADLESSSHELL:
+        case Browser.FIREFOX:
+        case Browser.CHROMIUM:
+            throw new Error(`Default user dir detection is not supported for ${browser} yet.`);
+        case Browser.CHROME:
+            return chrome.resolveDefaultUserDataDir(platform, channel);
+    }
+}
+/**
+ * @internal
+ *
+ * Returns multiple paths where the executable may be located at on the current system
+ * ordered by likelihood (based on heuristics).
+ */
+export function resolveSystemExecutablePaths(browser, platform, channel) {
+    switch (browser) {
+        case Browser.CHROMEDRIVER:
+        case Browser.CHROMEHEADLESSSHELL:
+        case Browser.FIREFOX:
+        case Browser.CHROMIUM:
+            throw new Error(`System browser detection is not supported for ${browser} yet.`);
+        case Browser.CHROME:
+            return chrome.resolveSystemExecutablePaths(platform, channel);
+    }
+}
+/**
+ * Returns a version comparator for the given browser that can be used to sort
+ * browser versions.
+ *
+ * @public
+ */
+export function getVersionComparator(browser) {
+    return versionComparators[browser];
+}
+//# sourceMappingURL=browser-data.js.map

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

@@ -0,0 +1,302 @@
+/**
+ * @license
+ * Copyright 2023 Google Inc.
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { execSync } from 'node:child_process';
+import os from 'node:os';
+import path from 'node:path';
+import { getJSON } from '../httpUtil.js';
+import { BrowserPlatform, ChromeReleaseChannel } from './types.js';
+function folder(platform) {
+    switch (platform) {
+        case BrowserPlatform.LINUX_ARM:
+        case BrowserPlatform.LINUX:
+            return 'linux64';
+        case BrowserPlatform.MAC_ARM:
+            return 'mac-arm64';
+        case BrowserPlatform.MAC:
+            return 'mac-x64';
+        case BrowserPlatform.WIN32:
+            return 'win32';
+        case BrowserPlatform.WIN64:
+            return 'win64';
+    }
+}
+export function resolveDownloadUrl(platform, buildId, baseUrl = 'https://storage.googleapis.com/chrome-for-testing-public') {
+    return `${baseUrl}/${resolveDownloadPath(platform, buildId).join('/')}`;
+}
+export function resolveDownloadPath(platform, buildId) {
+    return [buildId, folder(platform), `chrome-${folder(platform)}.zip`];
+}
+export function relativeExecutablePath(platform, _buildId) {
+    switch (platform) {
+        case BrowserPlatform.MAC:
+        case BrowserPlatform.MAC_ARM:
+            return path.join('chrome-' + folder(platform), 'Google Chrome for Testing.app', 'Contents', 'MacOS', 'Google Chrome for Testing');
+        case BrowserPlatform.LINUX_ARM:
+        case BrowserPlatform.LINUX:
+            return path.join('chrome-linux64', 'chrome');
+        case BrowserPlatform.WIN32:
+        case BrowserPlatform.WIN64:
+            return path.join('chrome-' + folder(platform), 'chrome.exe');
+    }
+}
+let baseVersionUrl = 'https://googlechromelabs.github.io/chrome-for-testing';
+export function changeBaseVersionUrlForTesting(url) {
+    baseVersionUrl = url;
+}
+export function resetBaseVersionUrlForTesting() {
+    baseVersionUrl = 'https://googlechromelabs.github.io/chrome-for-testing';
+}
+export async function getLastKnownGoodReleaseForChannel(channel) {
+    const data = (await getJSON(new URL(`${baseVersionUrl}/last-known-good-versions.json`)));
+    for (const channel of Object.keys(data.channels)) {
+        data.channels[channel.toLowerCase()] = data.channels[channel];
+        delete data.channels[channel];
+    }
+    return data.channels[channel];
+}
+export async function getLastKnownGoodReleaseForMilestone(milestone) {
+    const data = (await getJSON(new URL(`${baseVersionUrl}/latest-versions-per-milestone.json`)));
+    return data.milestones[milestone];
+}
+export async function getLastKnownGoodReleaseForBuild(
+/**
+ * @example `112.0.23`,
+ */
+buildPrefix) {
+    const data = (await getJSON(new URL(`${baseVersionUrl}/latest-patch-versions-per-build.json`)));
+    return data.builds[buildPrefix];
+}
+export async function resolveBuildId(channel) {
+    if (Object.values(ChromeReleaseChannel).includes(channel)) {
+        return (await getLastKnownGoodReleaseForChannel(channel)).version;
+    }
+    if (channel.match(/^\d+$/)) {
+        // Potentially a milestone.
+        return (await getLastKnownGoodReleaseForMilestone(channel))?.version;
+    }
+    if (channel.match(/^\d+\.\d+\.\d+$/)) {
+        // Potentially a build prefix without the patch version.
+        return (await getLastKnownGoodReleaseForBuild(channel))?.version;
+    }
+    return;
+}
+const WINDOWS_ENV_PARAM_NAMES = [
+    'PROGRAMFILES',
+    'ProgramW6432',
+    'ProgramFiles(x86)',
+    // https://source.chromium.org/chromium/chromium/src/+/main:chrome/installer/mini_installer/README.md
+    'LOCALAPPDATA',
+];
+function getChromeWindowsLocation(channel, locationsPrefixes) {
+    if (locationsPrefixes.size === 0) {
+        throw new Error('Non of the common Windows Env variables were set');
+    }
+    let suffix;
+    switch (channel) {
+        case ChromeReleaseChannel.STABLE:
+            suffix = 'Google\\Chrome\\Application\\chrome.exe';
+            break;
+        case ChromeReleaseChannel.BETA:
+            suffix = 'Google\\Chrome Beta\\Application\\chrome.exe';
+            break;
+        case ChromeReleaseChannel.CANARY:
+            suffix = 'Google\\Chrome SxS\\Application\\chrome.exe';
+            break;
+        case ChromeReleaseChannel.DEV:
+            suffix = 'Google\\Chrome Dev\\Application\\chrome.exe';
+            break;
+    }
+    return [...locationsPrefixes.values()].map(l => {
+        return path.win32.join(l, suffix);
+    });
+}
+function getWslVariable(variable) {
+    try {
+        // The Windows env for the paths are not passed down
+        // to WSL, so we evoke `cmd.exe` which is usually on the PATH
+        // from which the env can be access with all uppercase names.
+        // The return value is a Windows Path - `C:\Program Files`.
+        const result = execSync(`cmd.exe /c echo %${variable.toLocaleUpperCase()}%`, {
+            // We need to ignore the stderr as cmd.exe
+            // prints a message about wrong UNC path not supported.
+            stdio: ['ignore', 'pipe', 'ignore'],
+            encoding: 'utf-8',
+        }).trim();
+        if (result) {
+            return result;
+        }
+    }
+    catch { }
+    return;
+}
+function getWslLocation(channel) {
+    const wslVersion = execSync('wslinfo --version', {
+        stdio: ['ignore', 'pipe', 'ignore'],
+        encoding: 'utf-8',
+    }).trim();
+    if (!wslVersion) {
+        throw new Error('Not in WSL or unsupported version of WSL.');
+    }
+    const wslPrefixes = new Set();
+    for (const name of WINDOWS_ENV_PARAM_NAMES) {
+        const wslPrefix = getWslVariable(name);
+        if (wslPrefix) {
+            wslPrefixes.add(wslPrefix);
+        }
+    }
+    const windowsPath = getChromeWindowsLocation(channel, wslPrefixes);
+    return windowsPath.map(path => {
+        // The above command returned the Windows paths `C:\Program Files\...\chrome.exe`
+        // Use the `wslpath` utility tool to transform into the mounted disk
+        return execSync(`wslpath "${path}"`).toString().trim();
+    });
+}
+function getChromeLinuxOrWslLocation(channel) {
+    const locations = [];
+    switch (channel) {
+        case ChromeReleaseChannel.STABLE:
+            locations.push('/opt/google/chrome/chrome');
+            break;
+        case ChromeReleaseChannel.BETA:
+            locations.push('/opt/google/chrome-beta/chrome');
+            break;
+        case ChromeReleaseChannel.CANARY:
+            locations.push('/opt/google/chrome-canary/chrome');
+            break;
+        case ChromeReleaseChannel.DEV:
+            locations.push('/opt/google/chrome-unstable/chrome');
+            break;
+    }
+    try {
+        const wslPath = getWslLocation(channel);
+        if (wslPath) {
+            locations.push(...wslPath);
+        }
+    }
+    catch {
+        // Ignore WSL errors
+    }
+    return locations;
+}
+export function resolveSystemExecutablePaths(platform, channel) {
+    switch (platform) {
+        case BrowserPlatform.WIN64:
+        case BrowserPlatform.WIN32:
+            const prefixLocation = new Set(WINDOWS_ENV_PARAM_NAMES.map(name => {
+                return process.env[name];
+            }).filter((l) => {
+                return !!l;
+            }));
+            // Fallbacks in case env vars are misconfigured.
+            prefixLocation.add('C:\\Program Files');
+            prefixLocation.add('C:\\Program Files (x86)');
+            prefixLocation.add('D:\\Program Files');
+            prefixLocation.add('D:\\Program Files (x86)');
+            return getChromeWindowsLocation(channel, prefixLocation);
+        case BrowserPlatform.MAC_ARM:
+        case BrowserPlatform.MAC:
+            switch (channel) {
+                case ChromeReleaseChannel.STABLE:
+                    return [
+                        '/Applications/Google Chrome.app/Contents/MacOS/Google Chrome',
+                    ];
+                case ChromeReleaseChannel.BETA:
+                    return [
+                        '/Applications/Google Chrome Beta.app/Contents/MacOS/Google Chrome Beta',
+                    ];
+                case ChromeReleaseChannel.CANARY:
+                    return [
+                        '/Applications/Google Chrome Canary.app/Contents/MacOS/Google Chrome Canary',
+                    ];
+                case ChromeReleaseChannel.DEV:
+                    return [
+                        '/Applications/Google Chrome Dev.app/Contents/MacOS/Google Chrome Dev',
+                    ];
+            }
+        case BrowserPlatform.LINUX_ARM:
+        case BrowserPlatform.LINUX:
+            return getChromeLinuxOrWslLocation(channel);
+    }
+}
+export function resolveDefaultUserDataDir(platform, channel) {
+    switch (platform) {
+        case BrowserPlatform.WIN64:
+        case BrowserPlatform.WIN32:
+            // https://source.chromium.org/chromium/chromium/src/+/main:chrome/common/chrome_paths_win.cc;l=42;drc=4c86c7940a47c36b8bf52c134483ef2da86caa62
+            switch (channel) {
+                case ChromeReleaseChannel.STABLE:
+                    return path.join(getLocalAppDataWin(), 'Google', 'Chrome', 'User Data');
+                case ChromeReleaseChannel.BETA:
+                    return path.join(getLocalAppDataWin(), 'Google', 'Chrome Beta', 'User Data');
+                case ChromeReleaseChannel.CANARY:
+                    return path.join(getLocalAppDataWin(), 'Google', 'Chrome SxS', 'User Data');
+                case ChromeReleaseChannel.DEV:
+                    return path.join(getLocalAppDataWin(), 'Google', 'Chrome Dev', 'User Data');
+            }
+        case BrowserPlatform.MAC_ARM:
+        case BrowserPlatform.MAC:
+            // https://source.chromium.org/chromium/chromium/src/+/main:chrome/common/chrome_paths_mac.mm;l=86;drc=4c86c7940a47c36b8bf52c134483ef2da86caa62
+            switch (channel) {
+                case ChromeReleaseChannel.STABLE:
+                    return path.join(getBaseUserDataDirPathMac(), 'Chrome');
+                case ChromeReleaseChannel.BETA:
+                    return path.join(getBaseUserDataDirPathMac(), 'Chrome Beta');
+                case ChromeReleaseChannel.DEV:
+                    return path.join(getBaseUserDataDirPathMac(), 'Chrome Dev');
+                case ChromeReleaseChannel.CANARY:
+                    return path.join(getBaseUserDataDirPathMac(), 'Chrome Canary');
+            }
+        case BrowserPlatform.LINUX_ARM:
+        case BrowserPlatform.LINUX:
+            // https://source.chromium.org/chromium/chromium/src/+/main:chrome/common/chrome_paths_linux.cc;l=80;drc=4c86c7940a47c36b8bf52c134483ef2da86caa62
+            switch (channel) {
+                case ChromeReleaseChannel.STABLE:
+                    return path.join(getConfigHomeLinux(), 'google-chrome');
+                case ChromeReleaseChannel.BETA:
+                    return path.join(getConfigHomeLinux(), 'google-chrome-beta');
+                case ChromeReleaseChannel.CANARY:
+                    return path.join(getConfigHomeLinux(), 'google-chrome-canary');
+                case ChromeReleaseChannel.DEV:
+                    return path.join(getConfigHomeLinux(), 'google-chrome-unstable');
+            }
+    }
+}
+function getLocalAppDataWin() {
+    return (process.env['LOCALAPPDATA'] || path.join(os.homedir(), 'AppData', 'Local'));
+}
+function getConfigHomeLinux() {
+    return (process.env['CHROME_CONFIG_HOME'] ||
+        process.env['XDG_CONFIG_HOME'] ||
+        path.join(os.homedir(), '.config'));
+}
+function getBaseUserDataDirPathMac() {
+    return path.join(os.homedir(), 'Library', 'Application Support', 'Google');
+}
+export function compareVersions(a, b) {
+    const cleanA = a.trim();
+    const cleanB = b.trim();
+    const versionRegex = /^\d+(?:\.\d+){0,3}$/;
+    if (!versionRegex.test(cleanA)) {
+        throw new Error(`Version ${a} is not a valid Chrome version`);
+    }
+    if (!versionRegex.test(cleanB)) {
+        throw new Error(`Version ${b} is not a valid Chrome version`);
+    }
+    const aParts = cleanA.split('.').map(Number);
+    const bParts = cleanB.split('.').map(Number);
+    for (let i = 0; i < 4; i++) {
+        const aPart = aParts[i] ?? 0;
+        const bPart = bParts[i] ?? 0;
+        if (aPart > bPart) {
+            return 1;
+        }
+        if (aPart < bPart) {
+            return -1;
+        }
+    }
+    return 0;
+}
+//# sourceMappingURL=chrome.js.map