Update dashboard, kb, memory +4 more (+28 ~18 -1)

node_modules/@puppeteer/browsers/src/browser-data/browser-data.ts

@@ -0,0 +1,302 @@
+/**
+ * @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,
+  type ProfileOptions,
+} from './types.js';
+
+export type {ProfileOptions};
+
+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};
+
+/**
+ * @internal
+ */
+async function resolveBuildIdForBrowserTag(
+  browser: Browser,
+  platform: BrowserPlatform,
+  tag: BrowserTag,
+): Promise<string> {
+  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: Browser,
+  platform: BrowserPlatform,
+  tag: string | BrowserTag,
+): Promise<string> {
+  const browserTag = tag as BrowserTag;
+  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: Browser,
+  opts: ProfileOptions,
+): Promise<void> {
+  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
+ *
+ * Get's the first resolved system path
+ */
+export function resolveSystemExecutablePath(
+  browser: Browser,
+  platform: BrowserPlatform,
+  channel: ChromeReleaseChannel,
+): string {
+  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: Browser,
+  platform: BrowserPlatform,
+  channel: ChromeReleaseChannel,
+): string {
+  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: Browser,
+  platform: BrowserPlatform,
+  channel: ChromeReleaseChannel,
+): [string, ...string[]] {
+  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: Browser,
+): (a: string, b: string) => number {
+  return versionComparators[browser];
+}

node_modules/@puppeteer/browsers/src/browser-data/chrome-headless-shell.ts

@@ -0,0 +1,71 @@
+/**
+ * @license
+ * Copyright 2023 Google Inc.
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import path from 'node:path';
+
+import {BrowserPlatform} from './types.js';
+
+function folder(platform: BrowserPlatform): string {
+  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: BrowserPlatform,
+  buildId: string,
+  baseUrl = 'https://storage.googleapis.com/chrome-for-testing-public',
+): string {
+  return `${baseUrl}/${resolveDownloadPath(platform, buildId).join('/')}`;
+}
+
+export function resolveDownloadPath(
+  platform: BrowserPlatform,
+  buildId: string,
+): string[] {
+  return [
+    buildId,
+    folder(platform),
+    `chrome-headless-shell-${folder(platform)}.zip`,
+  ];
+}
+
+export function relativeExecutablePath(
+  platform: BrowserPlatform,
+  _buildId: string,
+): string {
+  switch (platform) {
+    case BrowserPlatform.MAC:
+    case BrowserPlatform.MAC_ARM:
+      return path.join(
+        'chrome-headless-shell-' + folder(platform),
+        'chrome-headless-shell',
+      );
+    case BrowserPlatform.LINUX_ARM:
+    case BrowserPlatform.LINUX:
+      return path.join(
+        'chrome-headless-shell-linux64',
+        'chrome-headless-shell',
+      );
+    case BrowserPlatform.WIN32:
+    case BrowserPlatform.WIN64:
+      return path.join(
+        'chrome-headless-shell-' + folder(platform),
+        'chrome-headless-shell.exe',
+      );
+  }
+}
+
+export {resolveBuildId, compareVersions} from './chrome.js';

node_modules/@puppeteer/browsers/src/browser-data/chrome.ts

@@ -0,0 +1,422 @@
+/**
+ * @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 semver from 'semver';
+
+import {getJSON} from '../httpUtil.js';
+
+import {BrowserPlatform, ChromeReleaseChannel} from './types.js';
+
+function folder(platform: BrowserPlatform): string {
+  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: BrowserPlatform,
+  buildId: string,
+  baseUrl = 'https://storage.googleapis.com/chrome-for-testing-public',
+): string {
+  return `${baseUrl}/${resolveDownloadPath(platform, buildId).join('/')}`;
+}
+
+export function resolveDownloadPath(
+  platform: BrowserPlatform,
+  buildId: string,
+): string[] {
+  return [buildId, folder(platform), `chrome-${folder(platform)}.zip`];
+}
+
+export function relativeExecutablePath(
+  platform: BrowserPlatform,
+  _buildId: string,
+): string {
+  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: string): void {
+  baseVersionUrl = url;
+}
+export function resetBaseVersionUrlForTesting(): void {
+  baseVersionUrl = 'https://googlechromelabs.github.io/chrome-for-testing';
+}
+
+export async function getLastKnownGoodReleaseForChannel(
+  channel: ChromeReleaseChannel,
+): Promise<{version: string; revision: string}> {
+  const data = (await getJSON(
+    new URL(`${baseVersionUrl}/last-known-good-versions.json`),
+  )) as {
+    channels: Record<string, {version: string}>;
+  };
+
+  for (const channel of Object.keys(data.channels)) {
+    data.channels[channel.toLowerCase()] = data.channels[channel]!;
+    delete data.channels[channel];
+  }
+
+  return (
+    data as {
+      channels: Record<
+        ChromeReleaseChannel,
+        {version: string; revision: string}
+      >;
+    }
+  ).channels[channel];
+}
+
+export async function getLastKnownGoodReleaseForMilestone(
+  milestone: string,
+): Promise<{version: string; revision: string} | undefined> {
+  const data = (await getJSON(
+    new URL(`${baseVersionUrl}/latest-versions-per-milestone.json`),
+  )) as {
+    milestones: Record<string, {version: string; revision: string}>;
+  };
+  return data.milestones[milestone] as
+    | {version: string; revision: string}
+    | undefined;
+}
+
+export async function getLastKnownGoodReleaseForBuild(
+  /**
+   * @example `112.0.23`,
+   */
+  buildPrefix: string,
+): Promise<{version: string; revision: string} | undefined> {
+  const data = (await getJSON(
+    new URL(`${baseVersionUrl}/latest-patch-versions-per-build.json`),
+  )) as {
+    builds: Record<string, {version: string; revision: string}>;
+  };
+  return data.builds[buildPrefix] as
+    | {version: string; revision: string}
+    | undefined;
+}
+
+export async function resolveBuildId(
+  channel: ChromeReleaseChannel,
+): Promise<string>;
+export async function resolveBuildId(
+  channel: string,
+): Promise<string | undefined>;
+export async function resolveBuildId(
+  channel: ChromeReleaseChannel | string,
+): Promise<string | undefined> {
+  if (
+    Object.values(ChromeReleaseChannel).includes(
+      channel as ChromeReleaseChannel,
+    )
+  ) {
+    return (
+      await getLastKnownGoodReleaseForChannel(channel as ChromeReleaseChannel)
+    ).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: ChromeReleaseChannel,
+  locationsPrefixes: Set<string>,
+): [string, ...string[]] {
+  if (locationsPrefixes.size === 0) {
+    throw new Error('Non of the common Windows Env variables were set');
+  }
+
+  let suffix: string;
+  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);
+  }) as [string, ...string[]];
+}
+
+function getWslVariable(variable: string): string | undefined {
+  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: ChromeReleaseChannel): [string, ...string[]] {
+  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<string>();
+  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();
+  }) as [string, ...string[]];
+}
+
+function getChromeLinuxOrWslLocation(
+  channel: ChromeReleaseChannel,
+): [string, ...string[]] {
+  const locations: string[] = [];
+
+  try {
+    const wslPath = getWslLocation(channel);
+    if (wslPath) {
+      locations.push(...wslPath);
+    }
+  } catch {
+    // Ignore WSL errors
+  }
+
+  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;
+  }
+
+  return locations as [string, ...string[]];
+}
+
+export function resolveSystemExecutablePaths(
+  platform: BrowserPlatform,
+  channel: ChromeReleaseChannel,
+): [string, ...string[]] {
+  switch (platform) {
+    case BrowserPlatform.WIN64:
+    case BrowserPlatform.WIN32:
+      const prefixLocation = new Set<string>(
+        WINDOWS_ENV_PARAM_NAMES.map(name => {
+          return process.env[name];
+        }).filter((l): l is string => {
+          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: BrowserPlatform,
+  channel: ChromeReleaseChannel,
+): string {
+  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: string, b: string): number {
+  if (!semver.valid(a)) {
+    throw new Error(`Version ${a} is not a valid semver version`);
+  }
+  if (!semver.valid(b)) {
+    throw new Error(`Version ${b} is not a valid semver version`);
+  }
+  if (semver.gt(a, b)) {
+    return 1;
+  } else if (semver.lt(a, b)) {
+    return -1;
+  } else {
+    return 0;
+  }
+}

node_modules/@puppeteer/browsers/src/browser-data/chromedriver.ts

@@ -0,0 +1,58 @@
+/**
+ * @license
+ * Copyright 2023 Google Inc.
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import path from 'node:path';
+
+import {BrowserPlatform} from './types.js';
+
+function folder(platform: BrowserPlatform): string {
+  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: BrowserPlatform,
+  buildId: string,
+  baseUrl = 'https://storage.googleapis.com/chrome-for-testing-public',
+): string {
+  return `${baseUrl}/${resolveDownloadPath(platform, buildId).join('/')}`;
+}
+
+export function resolveDownloadPath(
+  platform: BrowserPlatform,
+  buildId: string,
+): string[] {
+  return [buildId, folder(platform), `chromedriver-${folder(platform)}.zip`];
+}
+
+export function relativeExecutablePath(
+  platform: BrowserPlatform,
+  _buildId: string,
+): string {
+  switch (platform) {
+    case BrowserPlatform.MAC:
+    case BrowserPlatform.MAC_ARM:
+      return path.join('chromedriver-' + folder(platform), 'chromedriver');
+    case BrowserPlatform.LINUX_ARM:
+    case BrowserPlatform.LINUX:
+      return path.join('chromedriver-linux64', 'chromedriver');
+    case BrowserPlatform.WIN32:
+    case BrowserPlatform.WIN64:
+      return path.join('chromedriver-' + folder(platform), 'chromedriver.exe');
+  }
+}
+
+export {resolveBuildId, compareVersions} from './chrome.js';

node_modules/@puppeteer/browsers/src/browser-data/chromium.ts

@@ -0,0 +1,95 @@
+/**
+ * @license
+ * Copyright 2023 Google Inc.
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+import path from 'node:path';
+
+import {getText} from '../httpUtil.js';
+
+import {BrowserPlatform} from './types.js';
+
+function archive(platform: BrowserPlatform, buildId: string): string {
+  switch (platform) {
+    case BrowserPlatform.LINUX_ARM:
+    case BrowserPlatform.LINUX:
+      return 'chrome-linux';
+    case BrowserPlatform.MAC_ARM:
+    case BrowserPlatform.MAC:
+      return 'chrome-mac';
+    case BrowserPlatform.WIN32:
+    case BrowserPlatform.WIN64:
+      // Windows archive name changed at r591479.
+      return parseInt(buildId, 10) > 591479 ? 'chrome-win' : 'chrome-win32';
+  }
+}
+
+function folder(platform: BrowserPlatform): string {
+  switch (platform) {
+    case BrowserPlatform.LINUX_ARM:
+    case BrowserPlatform.LINUX:
+      return 'Linux_x64';
+    case BrowserPlatform.MAC_ARM:
+      return 'Mac_Arm';
+    case BrowserPlatform.MAC:
+      return 'Mac';
+    case BrowserPlatform.WIN32:
+      return 'Win';
+    case BrowserPlatform.WIN64:
+      return 'Win_x64';
+  }
+}
+
+export function resolveDownloadUrl(
+  platform: BrowserPlatform,
+  buildId: string,
+  baseUrl = 'https://storage.googleapis.com/chromium-browser-snapshots',
+): string {
+  return `${baseUrl}/${resolveDownloadPath(platform, buildId).join('/')}`;
+}
+
+export function resolveDownloadPath(
+  platform: BrowserPlatform,
+  buildId: string,
+): string[] {
+  return [folder(platform), buildId, `${archive(platform, buildId)}.zip`];
+}
+
+export function relativeExecutablePath(
+  platform: BrowserPlatform,
+  _buildId: string,
+): string {
+  switch (platform) {
+    case BrowserPlatform.MAC:
+    case BrowserPlatform.MAC_ARM:
+      return path.join(
+        'chrome-mac',
+        'Chromium.app',
+        'Contents',
+        'MacOS',
+        'Chromium',
+      );
+    case BrowserPlatform.LINUX_ARM:
+    case BrowserPlatform.LINUX:
+      return path.join('chrome-linux', 'chrome');
+    case BrowserPlatform.WIN32:
+    case BrowserPlatform.WIN64:
+      return path.join('chrome-win', 'chrome.exe');
+  }
+}
+export async function resolveBuildId(
+  platform: BrowserPlatform,
+): Promise<string> {
+  return await getText(
+    new URL(
+      `https://storage.googleapis.com/chromium-browser-snapshots/${folder(
+        platform,
+      )}/LAST_CHANGE`,
+    ),
+  );
+}
+
+export function compareVersions(a: string, b: string): number {
+  return Number(a) - Number(b);
+}

node_modules/@puppeteer/browsers/src/browser-data/firefox.ts

@@ -0,0 +1,469 @@
+/**
+ * @license
+ * Copyright 2023 Google Inc.
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+import fs from 'node:fs';
+import path from 'node:path';
+
+import {getJSON} from '../httpUtil.js';
+
+import {BrowserPlatform, type ProfileOptions} from './types.js';
+
+function getFormat(buildId: string): string {
+  const majorVersion = Number(buildId.split('.').shift()!);
+  return majorVersion >= 135 ? 'xz' : 'bz2';
+}
+
+function archiveNightly(platform: BrowserPlatform, buildId: string): string {
+  switch (platform) {
+    case BrowserPlatform.LINUX:
+      return `firefox-${buildId}.en-US.linux-x86_64.tar.${getFormat(buildId)}`;
+    case BrowserPlatform.LINUX_ARM:
+      return `firefox-${buildId}.en-US.linux-aarch64.tar.${getFormat(buildId)}`;
+    case BrowserPlatform.MAC_ARM:
+    case BrowserPlatform.MAC:
+      return `firefox-${buildId}.en-US.mac.dmg`;
+    case BrowserPlatform.WIN32:
+    case BrowserPlatform.WIN64:
+      return `firefox-${buildId}.en-US.${platform}.zip`;
+  }
+}
+
+function archive(platform: BrowserPlatform, buildId: string): string {
+  switch (platform) {
+    case BrowserPlatform.LINUX_ARM:
+    case BrowserPlatform.LINUX:
+      return `firefox-${buildId}.tar.${getFormat(buildId)}`;
+    case BrowserPlatform.MAC_ARM:
+    case BrowserPlatform.MAC:
+      return `Firefox ${buildId}.dmg`;
+    case BrowserPlatform.WIN32:
+    case BrowserPlatform.WIN64:
+      return `Firefox Setup ${buildId}.exe`;
+  }
+}
+
+function platformName(platform: BrowserPlatform): string {
+  switch (platform) {
+    case BrowserPlatform.LINUX:
+      return `linux-x86_64`;
+    case BrowserPlatform.LINUX_ARM:
+      return `linux-aarch64`;
+    case BrowserPlatform.MAC_ARM:
+    case BrowserPlatform.MAC:
+      return `mac`;
+    case BrowserPlatform.WIN32:
+    case BrowserPlatform.WIN64:
+      return platform;
+  }
+}
+
+function parseBuildId(buildId: string): [FirefoxChannel, string] {
+  for (const value of Object.values(FirefoxChannel)) {
+    if (buildId.startsWith(value + '_')) {
+      buildId = buildId.substring(value.length + 1);
+      return [value, buildId];
+    }
+  }
+  // Older versions do not have channel as the prefix.«
+  return [FirefoxChannel.NIGHTLY, buildId];
+}
+
+export function resolveDownloadUrl(
+  platform: BrowserPlatform,
+  buildId: string,
+  baseUrl?: string,
+): string {
+  const [channel] = parseBuildId(buildId);
+  switch (channel) {
+    case FirefoxChannel.NIGHTLY:
+      baseUrl ??=
+        'https://archive.mozilla.org/pub/firefox/nightly/latest-mozilla-central';
+      break;
+    case FirefoxChannel.DEVEDITION:
+      baseUrl ??= 'https://archive.mozilla.org/pub/devedition/releases';
+      break;
+    case FirefoxChannel.BETA:
+    case FirefoxChannel.STABLE:
+    case FirefoxChannel.ESR:
+      baseUrl ??= 'https://archive.mozilla.org/pub/firefox/releases';
+      break;
+  }
+  return `${baseUrl}/${resolveDownloadPath(platform, buildId).join('/')}`;
+}
+
+export function resolveDownloadPath(
+  platform: BrowserPlatform,
+  buildId: string,
+): string[] {
+  const [channel, resolvedBuildId] = parseBuildId(buildId);
+  switch (channel) {
+    case FirefoxChannel.NIGHTLY:
+      return [archiveNightly(platform, resolvedBuildId)];
+    case FirefoxChannel.DEVEDITION:
+    case FirefoxChannel.BETA:
+    case FirefoxChannel.STABLE:
+    case FirefoxChannel.ESR:
+      return [
+        resolvedBuildId,
+        platformName(platform),
+        'en-US',
+        archive(platform, resolvedBuildId),
+      ];
+  }
+}
+
+export function relativeExecutablePath(
+  platform: BrowserPlatform,
+  buildId: string,
+): string {
+  const [channel] = parseBuildId(buildId);
+  switch (channel) {
+    case FirefoxChannel.NIGHTLY:
+      switch (platform) {
+        case BrowserPlatform.MAC_ARM:
+        case BrowserPlatform.MAC:
+          return path.join(
+            'Firefox Nightly.app',
+            'Contents',
+            'MacOS',
+            'firefox',
+          );
+        case BrowserPlatform.LINUX_ARM:
+        case BrowserPlatform.LINUX:
+          return path.join('firefox', 'firefox');
+        case BrowserPlatform.WIN32:
+        case BrowserPlatform.WIN64:
+          return path.join('firefox', 'firefox.exe');
+      }
+    case FirefoxChannel.BETA:
+    case FirefoxChannel.DEVEDITION:
+    case FirefoxChannel.ESR:
+    case FirefoxChannel.STABLE:
+      switch (platform) {
+        case BrowserPlatform.MAC_ARM:
+        case BrowserPlatform.MAC:
+          return path.join('Firefox.app', 'Contents', 'MacOS', 'firefox');
+        case BrowserPlatform.LINUX_ARM:
+        case BrowserPlatform.LINUX:
+          return path.join('firefox', 'firefox');
+        case BrowserPlatform.WIN32:
+        case BrowserPlatform.WIN64:
+          return path.join('core', 'firefox.exe');
+      }
+  }
+}
+
+export enum FirefoxChannel {
+  STABLE = 'stable',
+  ESR = 'esr',
+  DEVEDITION = 'devedition',
+  BETA = 'beta',
+  NIGHTLY = 'nightly',
+}
+
+let baseVersionUrl = 'https://product-details.mozilla.org/1.0';
+
+export function changeBaseVersionUrlForTesting(url: string): void {
+  baseVersionUrl = url;
+}
+
+export function resetBaseVersionUrlForTesting(): void {
+  baseVersionUrl = 'https://product-details.mozilla.org/1.0';
+}
+
+export async function resolveBuildId(
+  channel: FirefoxChannel = FirefoxChannel.NIGHTLY,
+): Promise<string> {
+  const channelToVersionKey = {
+    [FirefoxChannel.ESR]: 'FIREFOX_ESR',
+    [FirefoxChannel.STABLE]: 'LATEST_FIREFOX_VERSION',
+    [FirefoxChannel.DEVEDITION]: 'FIREFOX_DEVEDITION',
+    [FirefoxChannel.BETA]: 'FIREFOX_DEVEDITION',
+    [FirefoxChannel.NIGHTLY]: 'FIREFOX_NIGHTLY',
+  };
+  const versions = (await getJSON(
+    new URL(`${baseVersionUrl}/firefox_versions.json`),
+  )) as Record<string, string>;
+  const version = versions[channelToVersionKey[channel]];
+  if (!version) {
+    throw new Error(`Channel ${channel} is not found.`);
+  }
+  return channel + '_' + version;
+}
+
+export async function createProfile(options: ProfileOptions): Promise<void> {
+  if (!fs.existsSync(options.path)) {
+    await fs.promises.mkdir(options.path, {
+      recursive: true,
+    });
+  }
+  await syncPreferences({
+    preferences: {
+      ...defaultProfilePreferences(options.preferences),
+      ...options.preferences,
+    },
+    path: options.path,
+  });
+}
+
+function defaultProfilePreferences(
+  extraPrefs: Record<string, unknown>,
+): Record<string, unknown> {
+  const server = 'dummy.test';
+
+  const defaultPrefs = {
+    // Make sure Shield doesn't hit the network.
+    'app.normandy.api_url': '',
+    // Disable Firefox old build background check
+    'app.update.checkInstallTime': false,
+    // Disable automatically upgrading Firefox
+    'app.update.disabledForTesting': true,
+
+    // Increase the APZ content response timeout to 1 minute
+    'apz.content_response_timeout': 60000,
+
+    // Prevent various error message on the console
+    // jest-puppeteer asserts that no error message is emitted by the console
+    'browser.contentblocking.features.standard':
+      '-tp,tpPrivate,cookieBehavior0,-cryptoTP,-fp',
+
+    // Enable the dump function: which sends messages to the system
+    // console
+    // https://bugzilla.mozilla.org/show_bug.cgi?id=1543115
+    'browser.dom.window.dump.enabled': true,
+    // Disable topstories
+    'browser.newtabpage.activity-stream.feeds.system.topstories': false,
+    // Always display a blank page
+    'browser.newtabpage.enabled': false,
+    // Background thumbnails in particular cause grief: and disabling
+    // thumbnails in general cannot hurt
+    'browser.pagethumbnails.capturing_disabled': true,
+
+    // Disable safebrowsing components.
+    'browser.safebrowsing.blockedURIs.enabled': false,
+    'browser.safebrowsing.downloads.enabled': false,
+    'browser.safebrowsing.malware.enabled': false,
+    'browser.safebrowsing.phishing.enabled': false,
+
+    // Disable updates to search engines.
+    'browser.search.update': false,
+    // Do not restore the last open set of tabs if the browser has crashed
+    'browser.sessionstore.resume_from_crash': false,
+    // Skip check for default browser on startup
+    'browser.shell.checkDefaultBrowser': false,
+
+    // Disable newtabpage
+    'browser.startup.homepage': 'about:blank',
+    // Do not redirect user when a milstone upgrade of Firefox is detected
+    'browser.startup.homepage_override.mstone': 'ignore',
+    // Start with a blank page about:blank
+    'browser.startup.page': 0,
+
+    // Do not allow background tabs to be zombified on Android: otherwise for
+    // tests that open additional tabs: the test harness tab itself might get
+    // unloaded
+    'browser.tabs.disableBackgroundZombification': false,
+    // Do not warn when closing all other open tabs
+    'browser.tabs.warnOnCloseOtherTabs': false,
+    // Do not warn when multiple tabs will be opened
+    'browser.tabs.warnOnOpen': false,
+
+    // Do not automatically offer translations, as tests do not expect this.
+    'browser.translations.automaticallyPopup': false,
+
+    // Disable the UI tour.
+    'browser.uitour.enabled': false,
+    // Turn off search suggestions in the location bar so as not to trigger
+    // network connections.
+    'browser.urlbar.suggest.searches': false,
+    // Disable first run splash page on Windows 10
+    'browser.usedOnWindows10.introURL': '',
+    // Do not warn on quitting Firefox
+    'browser.warnOnQuit': false,
+
+    // Defensively disable data reporting systems
+    'datareporting.healthreport.documentServerURI': `http://${server}/dummy/healthreport/`,
+    'datareporting.healthreport.logging.consoleEnabled': false,
+    'datareporting.healthreport.service.enabled': false,
+    'datareporting.healthreport.service.firstRun': false,
+    'datareporting.healthreport.uploadEnabled': false,
+
+    // Do not show datareporting policy notifications which can interfere with tests
+    'datareporting.policy.dataSubmissionEnabled': false,
+    'datareporting.policy.dataSubmissionPolicyBypassNotification': true,
+
+    // DevTools JSONViewer sometimes fails to load dependencies with its require.js.
+    // This doesn't affect Puppeteer but spams console (Bug 1424372)
+    'devtools.jsonview.enabled': false,
+
+    // Disable popup-blocker
+    'dom.disable_open_during_load': false,
+
+    // Enable the support for File object creation in the content process
+    // Required for |Page.setFileInputFiles| protocol method.
+    'dom.file.createInChild': true,
+
+    // Disable the ProcessHangMonitor
+    'dom.ipc.reportProcessHangs': false,
+
+    // Disable slow script dialogues
+    'dom.max_chrome_script_run_time': 0,
+    'dom.max_script_run_time': 0,
+
+    // Only load extensions from the application and user profile
+    // AddonManager.SCOPE_PROFILE + AddonManager.SCOPE_APPLICATION
+    'extensions.autoDisableScopes': 0,
+    'extensions.enabledScopes': 5,
+
+    // Disable metadata caching for installed add-ons by default
+    'extensions.getAddons.cache.enabled': false,
+
+    // Disable installing any distribution extensions or add-ons.
+    'extensions.installDistroAddons': false,
+
+    // Turn off extension updates so they do not bother tests
+    'extensions.update.enabled': false,
+
+    // Turn off extension updates so they do not bother tests
+    'extensions.update.notifyUser': false,
+
+    // Make sure opening about:addons will not hit the network
+    'extensions.webservice.discoverURL': `http://${server}/dummy/discoveryURL`,
+
+    // Allow the application to have focus even it runs in the background
+    'focusmanager.testmode': true,
+
+    // Disable useragent updates
+    'general.useragent.updates.enabled': false,
+
+    // Always use network provider for geolocation tests so we bypass the
+    // macOS dialog raised by the corelocation provider
+    'geo.provider.testing': true,
+
+    // Do not scan Wifi
+    'geo.wifi.scan': false,
+
+    // No hang monitor
+    'hangmonitor.timeout': 0,
+
+    // Show chrome errors and warnings in the error console
+    'javascript.options.showInConsole': true,
+
+    // Disable download and usage of OpenH264: and Widevine plugins
+    'media.gmp-manager.updateEnabled': false,
+
+    // Disable the GFX sanity window
+    'media.sanity-test.disabled': true,
+
+    // Disable experimental feature that is only available in Nightly
+    'network.cookie.sameSite.laxByDefault': false,
+
+    // Do not prompt for temporary redirects
+    'network.http.prompt-temp-redirect': false,
+
+    // Disable speculative connections so they are not reported as leaking
+    // when they are hanging around
+    'network.http.speculative-parallel-limit': 0,
+
+    // Do not automatically switch between offline and online
+    'network.manage-offline-status': false,
+
+    // Make sure SNTP requests do not hit the network
+    'network.sntp.pools': server,
+
+    // Disable Flash.
+    'plugin.state.flash': 0,
+
+    'privacy.trackingprotection.enabled': false,
+
+    // Can be removed once Firefox 89 is no longer supported
+    // https://bugzilla.mozilla.org/show_bug.cgi?id=1710839
+    'remote.enabled': true,
+
+    // Until Bug 1999693 is resolved, this preference needs to be set to allow
+    // Webdriver BiDi to automatically dismiss file pickers.
+    'remote.bidi.dismiss_file_pickers.enabled': true,
+
+    // Disabled screenshots component
+    'screenshots.browser.component.enabled': false,
+
+    // Don't do network connections for mitm priming
+    'security.certerrors.mitm.priming.enabled': false,
+
+    // Local documents have access to all other local documents,
+    // including directory listings
+    'security.fileuri.strict_origin_policy': false,
+
+    // Do not wait for the notification button security delay
+    'security.notification_enable_delay': 0,
+
+    // Ensure blocklist updates do not hit the network
+    'services.settings.server': `http://${server}/dummy/blocklist/`,
+
+    // Do not automatically fill sign-in forms with known usernames and
+    // passwords
+    'signon.autofillForms': false,
+
+    // Disable password capture, so that tests that include forms are not
+    // influenced by the presence of the persistent doorhanger notification
+    'signon.rememberSignons': false,
+
+    // Disable first-run welcome page
+    'startup.homepage_welcome_url': 'about:blank',
+
+    // Disable first-run welcome page
+    'startup.homepage_welcome_url.additional': '',
+
+    // Disable browser animations (tabs, fullscreen, sliding alerts)
+    'toolkit.cosmeticAnimations.enabled': false,
+
+    // Prevent starting into safe mode after application crashes
+    'toolkit.startup.max_resumed_crashes': -1,
+  };
+
+  return Object.assign(defaultPrefs, extraPrefs);
+}
+
+async function backupFile(input: string): Promise<void> {
+  if (!fs.existsSync(input)) {
+    return;
+  }
+  await fs.promises.copyFile(input, input + '.puppeteer');
+}
+
+/**
+ * Populates the user.js file with custom preferences as needed to allow
+ * Firefox's support to properly function. These preferences will be
+ * automatically copied over to prefs.js during startup of Firefox. To be
+ * able to restore the original values of preferences a backup of prefs.js
+ * will be created.
+ */
+async function syncPreferences(options: ProfileOptions): Promise<void> {
+  const prefsPath = path.join(options.path, 'prefs.js');
+  const userPath = path.join(options.path, 'user.js');
+
+  const lines = Object.entries(options.preferences).map(([key, value]) => {
+    return `user_pref(${JSON.stringify(key)}, ${JSON.stringify(value)});`;
+  });
+
+  // Use allSettled to prevent corruption.
+  const result = await Promise.allSettled([
+    backupFile(userPath).then(async () => {
+      await fs.promises.writeFile(userPath, lines.join('\n'));
+    }),
+    backupFile(prefsPath),
+  ]);
+  for (const command of result) {
+    if (command.status === 'rejected') {
+      throw command.reason;
+    }
+  }
+}
+
+export function compareVersions(a: string, b: string): number {
+  // TODO: this is a not very reliable check.
+  return parseInt(a.replace('.', ''), 16) - parseInt(b.replace('.', ''), 16);
+}

node_modules/@puppeteer/browsers/src/browser-data/types.ts

@@ -0,0 +1,70 @@
+/**
+ * @license
+ * Copyright 2023 Google Inc.
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+/**
+ * Supported browsers.
+ *
+ * @public
+ */
+export enum Browser {
+  CHROME = 'chrome',
+  CHROMEHEADLESSSHELL = 'chrome-headless-shell',
+  CHROMIUM = 'chromium',
+  FIREFOX = 'firefox',
+  CHROMEDRIVER = 'chromedriver',
+}
+
+/**
+ * Platform names used to identify a OS platform x architecture combination in the way
+ * that is relevant for the browser download.
+ *
+ * @public
+ */
+export enum BrowserPlatform {
+  LINUX = 'linux',
+  LINUX_ARM = 'linux_arm',
+  MAC = 'mac',
+  MAC_ARM = 'mac_arm',
+  WIN32 = 'win32',
+  WIN64 = 'win64',
+}
+
+/**
+ * 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 enum BrowserTag {
+  CANARY = 'canary',
+  NIGHTLY = 'nightly',
+  BETA = 'beta',
+  DEV = 'dev',
+  DEVEDITION = 'devedition',
+  STABLE = 'stable',
+  ESR = 'esr',
+  LATEST = 'latest',
+}
+
+/**
+ * @public
+ */
+export interface ProfileOptions {
+  preferences: Record<string, unknown>;
+  path: string;
+}
+
+/**
+ * @public
+ */
+export enum ChromeReleaseChannel {
+  STABLE = 'stable',
+  DEV = 'dev',
+  CANARY = 'canary',
+  BETA = 'beta',
+}