better-dsh 0.2.5 → 0.3.0

package/lib/main-CupOhMp5.js

@@ -0,0 +1,1432 @@
+import { createHash } from "node:crypto";
+import childProcess, { execFile, execSync, spawn, spawnSync } from "node:child_process";
+import { mkdir, readdir, unlink } from "node:fs/promises";
+import path from "node:path";
+import { URL as URL$1, urlToHttpOptions } from "node:url";
+import fs, { accessSync, constants, existsSync, readFileSync } from "node:fs";
+import os from "node:os";
+import readline from "node:readline";
+import { debuglog, promisify } from "node:util";
+import { EventEmitter } from "node:events";
+import * as http from "node:http";
+import * as https from "node:https";
+
+//#region node_modules/@puppeteer/browsers/lib/browser-data/types.js
+/**
+* @license
+* Copyright 2023 Google Inc.
+* SPDX-License-Identifier: Apache-2.0
+*/
+/**
+* Supported browsers.
+*
+* @public
+*/
+var Browser;
+(function(Browser$1) {
+	Browser$1["CHROME"] = "chrome";
+	Browser$1["CHROMEHEADLESSSHELL"] = "chrome-headless-shell";
+	Browser$1["CHROMIUM"] = "chromium";
+	Browser$1["FIREFOX"] = "firefox";
+	Browser$1["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
+*/
+var BrowserPlatform;
+(function(BrowserPlatform$1) {
+	BrowserPlatform$1["LINUX"] = "linux";
+	BrowserPlatform$1["LINUX_ARM"] = "linux_arm";
+	BrowserPlatform$1["MAC"] = "mac";
+	BrowserPlatform$1["MAC_ARM"] = "mac_arm";
+	BrowserPlatform$1["WIN32"] = "win32";
+	BrowserPlatform$1["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
+*/
+var BrowserTag;
+(function(BrowserTag$1) {
+	BrowserTag$1["CANARY"] = "canary";
+	BrowserTag$1["NIGHTLY"] = "nightly";
+	BrowserTag$1["BETA"] = "beta";
+	BrowserTag$1["DEV"] = "dev";
+	BrowserTag$1["DEVEDITION"] = "devedition";
+	BrowserTag$1["STABLE"] = "stable";
+	BrowserTag$1["ESR"] = "esr";
+	BrowserTag$1["LATEST"] = "latest";
+})(BrowserTag || (BrowserTag = {}));
+/**
+* @public
+*/
+var ChromeReleaseChannel;
+(function(ChromeReleaseChannel$1) {
+	ChromeReleaseChannel$1["STABLE"] = "stable";
+	ChromeReleaseChannel$1["DEV"] = "dev";
+	ChromeReleaseChannel$1["CANARY"] = "canary";
+	ChromeReleaseChannel$1["BETA"] = "beta";
+})(ChromeReleaseChannel || (ChromeReleaseChannel = {}));
+
+//#endregion
+//#region node_modules/@puppeteer/browsers/lib/httpUtil.js
+async function httpRequest(url, method, response, keepAlive = true) {
+	let agent;
+	try {
+		const { ProxyAgent } = await import("proxy-agent");
+		agent = new ProxyAgent();
+	} catch {}
+	const options = {
+		protocol: url.protocol,
+		hostname: url.hostname,
+		port: url.port,
+		path: url.pathname + url.search,
+		method,
+		headers: keepAlive ? { Connection: "keep-alive" } : void 0,
+		auth: urlToHttpOptions(url).auth,
+		agent
+	};
+	const requestCallback = (res) => {
+		if (res.statusCode && res.statusCode >= 300 && res.statusCode < 400 && res.headers.location) {
+			httpRequest(new URL$1(res.headers.location), method, response);
+			res.resume();
+		} else response(res);
+	};
+	const request = options.protocol === "https:" ? https.request(options, requestCallback) : http.request(options, requestCallback);
+	request.end();
+	return request;
+}
+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());
+	}
+}
+function getText(url) {
+	return new Promise(async (resolve$1, reject) => {
+		try {
+			(await httpRequest(url, "GET", (response) => {
+				let data = "";
+				if (response.statusCode && response.statusCode >= 400) return reject(/* @__PURE__ */ new Error(`Got status code ${response.statusCode}`));
+				response.on("data", (chunk) => {
+					data += chunk;
+				});
+				response.on("end", () => {
+					try {
+						return resolve$1(String(data));
+					} catch {
+						return reject(/* @__PURE__ */ new Error(`Failed to read text response from ${url}`));
+					}
+				});
+			}, false)).on("error", (err) => {
+				reject(err);
+			});
+		} catch (err) {
+			reject(err);
+		}
+	});
+}
+
+//#endregion
+//#region node_modules/@puppeteer/browsers/lib/browser-data/chrome.js
+function folder$3(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";
+	}
+}
+function resolveDownloadUrl$4(platform, buildId, baseUrl = "https://storage.googleapis.com/chrome-for-testing-public") {
+	return `${baseUrl}/${resolveDownloadPath$4(platform, buildId).join("/")}`;
+}
+function resolveDownloadPath$4(platform, buildId) {
+	return [
+		buildId,
+		folder$3(platform),
+		`chrome-${folder$3(platform)}.zip`
+	];
+}
+function relativeExecutablePath$4(platform, _buildId) {
+	switch (platform) {
+		case BrowserPlatform.MAC:
+		case BrowserPlatform.MAC_ARM: return path.join("chrome-" + folder$3(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$3(platform), "chrome.exe");
+	}
+}
+let baseVersionUrl$1 = "https://googlechromelabs.github.io/chrome-for-testing";
+async function getLastKnownGoodReleaseForChannel(channel) {
+	const data = await getJSON(new URL(`${baseVersionUrl$1}/last-known-good-versions.json`));
+	for (const channel$1 of Object.keys(data.channels)) {
+		data.channels[channel$1.toLowerCase()] = data.channels[channel$1];
+		delete data.channels[channel$1];
+	}
+	return data.channels[channel];
+}
+async function getLastKnownGoodReleaseForMilestone(milestone) {
+	return (await getJSON(new URL(`${baseVersionUrl$1}/latest-versions-per-milestone.json`))).milestones[milestone];
+}
+async function getLastKnownGoodReleaseForBuild(buildPrefix) {
+	return (await getJSON(new URL(`${baseVersionUrl$1}/latest-patch-versions-per-build.json`))).builds[buildPrefix];
+}
+async function resolveBuildId$3(channel) {
+	if (Object.values(ChromeReleaseChannel).includes(channel)) return (await getLastKnownGoodReleaseForChannel(channel)).version;
+	if (channel.match(/^\d+$/)) return (await getLastKnownGoodReleaseForMilestone(channel))?.version;
+	if (channel.match(/^\d+\.\d+\.\d+$/)) return (await getLastKnownGoodReleaseForBuild(channel))?.version;
+}
+const WINDOWS_ENV_PARAM_NAMES = [
+	"PROGRAMFILES",
+	"ProgramW6432",
+	"ProgramFiles(x86)",
+	"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 {
+		const result = execSync(`cmd.exe /c echo %${variable.toLocaleUpperCase()}%`, {
+			stdio: [
+				"ignore",
+				"pipe",
+				"ignore"
+			],
+			encoding: "utf-8"
+		}).trim();
+		if (result) return result;
+	} catch {}
+}
+function getWslLocation(channel) {
+	if (!execSync("wslinfo --version", {
+		stdio: [
+			"ignore",
+			"pipe",
+			"ignore"
+		],
+		encoding: "utf-8"
+	}).trim()) throw new Error("Not in WSL or unsupported version of WSL.");
+	const wslPrefixes = /* @__PURE__ */ new Set();
+	for (const name of WINDOWS_ENV_PARAM_NAMES) {
+		const wslPrefix = getWslVariable(name);
+		if (wslPrefix) wslPrefixes.add(wslPrefix);
+	}
+	return getChromeWindowsLocation(channel, wslPrefixes).map((path$1) => {
+		return execSync(`wslpath "${path$1}"`).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 {}
+	return locations;
+}
+function resolveSystemExecutablePaths$1(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;
+			}));
+			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);
+	}
+}
+function resolveDefaultUserDataDir$1(platform, channel) {
+	switch (platform) {
+		case BrowserPlatform.WIN64:
+		case BrowserPlatform.WIN32: 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: 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: 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");
+}
+function compareVersions$2(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;
+}
+
+//#endregion
+//#region node_modules/@puppeteer/browsers/lib/browser-data/chrome-headless-shell.js
+function folder$2(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";
+	}
+}
+function resolveDownloadUrl$3(platform, buildId, baseUrl = "https://storage.googleapis.com/chrome-for-testing-public") {
+	return `${baseUrl}/${resolveDownloadPath$3(platform, buildId).join("/")}`;
+}
+function resolveDownloadPath$3(platform, buildId) {
+	return [
+		buildId,
+		folder$2(platform),
+		`chrome-headless-shell-${folder$2(platform)}.zip`
+	];
+}
+function relativeExecutablePath$3(platform, _buildId) {
+	switch (platform) {
+		case BrowserPlatform.MAC:
+		case BrowserPlatform.MAC_ARM: return path.join("chrome-headless-shell-" + folder$2(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$2(platform), "chrome-headless-shell.exe");
+	}
+}
+
+//#endregion
+//#region node_modules/@puppeteer/browsers/lib/browser-data/chromedriver.js
+function folder$1(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";
+	}
+}
+function resolveDownloadUrl$2(platform, buildId, baseUrl = "https://storage.googleapis.com/chrome-for-testing-public") {
+	return `${baseUrl}/${resolveDownloadPath$2(platform, buildId).join("/")}`;
+}
+function resolveDownloadPath$2(platform, buildId) {
+	return [
+		buildId,
+		folder$1(platform),
+		`chromedriver-${folder$1(platform)}.zip`
+	];
+}
+function relativeExecutablePath$2(platform, _buildId) {
+	switch (platform) {
+		case BrowserPlatform.MAC:
+		case BrowserPlatform.MAC_ARM: return path.join("chromedriver-" + folder$1(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$1(platform), "chromedriver.exe");
+	}
+}
+
+//#endregion
+//#region node_modules/@puppeteer/browsers/lib/browser-data/chromium.js
+function archive$1(platform, buildId) {
+	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: return parseInt(buildId, 10) > 591479 ? "chrome-win" : "chrome-win32";
+	}
+}
+function folder(platform) {
+	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";
+	}
+}
+function resolveDownloadUrl$1(platform, buildId, baseUrl = "https://storage.googleapis.com/chromium-browser-snapshots") {
+	return `${baseUrl}/${resolveDownloadPath$1(platform, buildId).join("/")}`;
+}
+function resolveDownloadPath$1(platform, buildId) {
+	return [
+		folder(platform),
+		buildId,
+		`${archive$1(platform, buildId)}.zip`
+	];
+}
+function relativeExecutablePath$1(platform, _buildId) {
+	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");
+	}
+}
+async function resolveBuildId$2(platform) {
+	return await getText(new URL(`https://storage.googleapis.com/chromium-browser-snapshots/${folder(platform)}/LAST_CHANGE`));
+}
+function compareVersions$1(a, b) {
+	return Number(a) - Number(b);
+}
+
+//#endregion
+//#region node_modules/@puppeteer/browsers/lib/browser-data/firefox.js
+function getFormat(buildId) {
+	return Number(buildId.split(".").shift()) >= 135 ? "xz" : "bz2";
+}
+function archiveNightly(platform, buildId) {
+	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, buildId) {
+	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) {
+	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) {
+	for (const value of Object.values(FirefoxChannel)) if (buildId.startsWith(value + "_")) {
+		buildId = buildId.substring(value.length + 1);
+		return [value, buildId];
+	}
+	return [FirefoxChannel.NIGHTLY, buildId];
+}
+function resolveDownloadUrl(platform, buildId, baseUrl) {
+	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("/")}`;
+}
+function resolveDownloadPath(platform, buildId) {
+	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)
+		];
+	}
+}
+function relativeExecutablePath(platform, buildId) {
+	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");
+		}
+	}
+}
+var FirefoxChannel;
+(function(FirefoxChannel$1) {
+	FirefoxChannel$1["STABLE"] = "stable";
+	FirefoxChannel$1["ESR"] = "esr";
+	FirefoxChannel$1["DEVEDITION"] = "devedition";
+	FirefoxChannel$1["BETA"] = "beta";
+	FirefoxChannel$1["NIGHTLY"] = "nightly";
+})(FirefoxChannel || (FirefoxChannel = {}));
+let baseVersionUrl = "https://product-details.mozilla.org/1.0";
+async function resolveBuildId$1(channel = FirefoxChannel.NIGHTLY) {
+	const channelToVersionKey = {
+		[FirefoxChannel.ESR]: "FIREFOX_ESR",
+		[FirefoxChannel.STABLE]: "LATEST_FIREFOX_VERSION",
+		[FirefoxChannel.DEVEDITION]: "FIREFOX_DEVEDITION",
+		[FirefoxChannel.BETA]: "FIREFOX_DEVEDITION",
+		[FirefoxChannel.NIGHTLY]: "FIREFOX_NIGHTLY"
+	};
+	const version = (await getJSON(new URL(`${baseVersionUrl}/firefox_versions.json`)))[channelToVersionKey[channel]];
+	if (!version) throw new Error(`Channel ${channel} is not found.`);
+	return channel + "_" + version;
+}
+async function createProfile$1(options) {
+	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) {
+	const server = "dummy.test";
+	const defaultPrefs = {
+		"app.normandy.api_url": "",
+		"app.update.checkInstallTime": false,
+		"app.update.disabledForTesting": true,
+		"apz.content_response_timeout": 6e4,
+		"browser.contentblocking.features.standard": "-tp,tpPrivate,cookieBehavior0,-cryptoTP,-fp",
+		"browser.dom.window.dump.enabled": true,
+		"browser.newtabpage.activity-stream.feeds.system.topstories": false,
+		"browser.newtabpage.enabled": false,
+		"browser.pagethumbnails.capturing_disabled": true,
+		"browser.safebrowsing.blockedURIs.enabled": false,
+		"browser.safebrowsing.downloads.enabled": false,
+		"browser.safebrowsing.malware.enabled": false,
+		"browser.safebrowsing.phishing.enabled": false,
+		"browser.search.update": false,
+		"browser.sessionstore.resume_from_crash": false,
+		"browser.shell.checkDefaultBrowser": false,
+		"browser.startup.homepage": "about:blank",
+		"browser.startup.homepage_override.mstone": "ignore",
+		"browser.startup.page": 0,
+		"browser.tabs.disableBackgroundZombification": false,
+		"browser.tabs.warnOnCloseOtherTabs": false,
+		"browser.tabs.warnOnOpen": false,
+		"browser.translations.automaticallyPopup": false,
+		"browser.uitour.enabled": false,
+		"browser.urlbar.suggest.searches": false,
+		"browser.usedOnWindows10.introURL": "",
+		"browser.warnOnQuit": false,
+		"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,
+		"datareporting.policy.dataSubmissionEnabled": false,
+		"datareporting.policy.dataSubmissionPolicyBypassNotification": true,
+		"devtools.jsonview.enabled": false,
+		"dom.disable_open_during_load": false,
+		"dom.file.createInChild": true,
+		"dom.ipc.reportProcessHangs": false,
+		"dom.max_chrome_script_run_time": 0,
+		"dom.max_script_run_time": 0,
+		"extensions.autoDisableScopes": 0,
+		"extensions.enabledScopes": 5,
+		"extensions.getAddons.cache.enabled": false,
+		"extensions.installDistroAddons": false,
+		"extensions.update.enabled": false,
+		"extensions.update.notifyUser": false,
+		"extensions.webservice.discoverURL": `http://${server}/dummy/discoveryURL`,
+		"focusmanager.testmode": true,
+		"general.useragent.updates.enabled": false,
+		"geo.provider.testing": true,
+		"geo.wifi.scan": false,
+		"hangmonitor.timeout": 0,
+		"javascript.options.showInConsole": true,
+		"media.gmp-manager.updateEnabled": false,
+		"media.sanity-test.disabled": true,
+		"network.cookie.sameSite.laxByDefault": false,
+		"network.http.prompt-temp-redirect": false,
+		"network.http.speculative-parallel-limit": 0,
+		"network.manage-offline-status": false,
+		"network.sntp.pools": server,
+		"plugin.state.flash": 0,
+		"privacy.trackingprotection.enabled": false,
+		"remote.enabled": true,
+		"remote.bidi.dismiss_file_pickers.enabled": true,
+		"screenshots.browser.component.enabled": false,
+		"security.certerrors.mitm.priming.enabled": false,
+		"security.fileuri.strict_origin_policy": false,
+		"security.notification_enable_delay": 0,
+		"services.settings.server": `http://${server}/dummy/blocklist/`,
+		"signon.autofillForms": false,
+		"signon.rememberSignons": false,
+		"startup.homepage_welcome_url": "about:blank",
+		"startup.homepage_welcome_url.additional": "",
+		"toolkit.cosmeticAnimations.enabled": false,
+		"toolkit.startup.max_resumed_crashes": -1
+	};
+	return Object.assign(defaultPrefs, extraPrefs);
+}
+async function backupFile(input) {
+	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) {
+	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)});`;
+	});
+	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;
+}
+function compareVersions(a, b) {
+	return parseInt(a.replace(".", ""), 16) - parseInt(b.replace(".", ""), 16);
+}
+
+//#endregion
+//#region node_modules/@puppeteer/browsers/lib/browser-data/browser-data.js
+const downloadUrls = {
+	[Browser.CHROMEDRIVER]: resolveDownloadUrl$2,
+	[Browser.CHROMEHEADLESSSHELL]: resolveDownloadUrl$3,
+	[Browser.CHROME]: resolveDownloadUrl$4,
+	[Browser.CHROMIUM]: resolveDownloadUrl$1,
+	[Browser.FIREFOX]: resolveDownloadUrl
+};
+const downloadPaths = {
+	[Browser.CHROMEDRIVER]: resolveDownloadPath$2,
+	[Browser.CHROMEHEADLESSSHELL]: resolveDownloadPath$3,
+	[Browser.CHROME]: resolveDownloadPath$4,
+	[Browser.CHROMIUM]: resolveDownloadPath$1,
+	[Browser.FIREFOX]: resolveDownloadPath
+};
+const executablePathByBrowser = {
+	[Browser.CHROMEDRIVER]: relativeExecutablePath$2,
+	[Browser.CHROMEHEADLESSSHELL]: relativeExecutablePath$3,
+	[Browser.CHROME]: relativeExecutablePath$4,
+	[Browser.CHROMIUM]: relativeExecutablePath$1,
+	[Browser.FIREFOX]: relativeExecutablePath
+};
+const versionComparators = {
+	[Browser.CHROMEDRIVER]: compareVersions$2,
+	[Browser.CHROMEHEADLESSSHELL]: compareVersions$2,
+	[Browser.CHROME]: compareVersions$2,
+	[Browser.CHROMIUM]: compareVersions$1,
+	[Browser.FIREFOX]: compareVersions
+};
+/**
+* @internal
+*/
+async function resolveBuildIdForBrowserTag(browser, platform, tag) {
+	switch (browser) {
+		case Browser.FIREFOX: switch (tag) {
+			case BrowserTag.LATEST: return await resolveBuildId$1(FirefoxChannel.NIGHTLY);
+			case BrowserTag.BETA: return await resolveBuildId$1(FirefoxChannel.BETA);
+			case BrowserTag.NIGHTLY: return await resolveBuildId$1(FirefoxChannel.NIGHTLY);
+			case BrowserTag.DEVEDITION: return await resolveBuildId$1(FirefoxChannel.DEVEDITION);
+			case BrowserTag.STABLE: return await resolveBuildId$1(FirefoxChannel.STABLE);
+			case BrowserTag.ESR: return await resolveBuildId$1(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 resolveBuildId$3(ChromeReleaseChannel.CANARY);
+			case BrowserTag.BETA: return await resolveBuildId$3(ChromeReleaseChannel.BETA);
+			case BrowserTag.CANARY: return await resolveBuildId$3(ChromeReleaseChannel.CANARY);
+			case BrowserTag.DEV: return await resolveBuildId$3(ChromeReleaseChannel.DEV);
+			case BrowserTag.STABLE: return await resolveBuildId$3(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 resolveBuildId$3(ChromeReleaseChannel.CANARY);
+			case BrowserTag.BETA: return await resolveBuildId$3(ChromeReleaseChannel.BETA);
+			case BrowserTag.DEV: return await resolveBuildId$3(ChromeReleaseChannel.DEV);
+			case BrowserTag.STABLE: return await resolveBuildId$3(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 resolveBuildId$3(ChromeReleaseChannel.CANARY);
+			case BrowserTag.BETA: return await resolveBuildId$3(ChromeReleaseChannel.BETA);
+			case BrowserTag.DEV: return await resolveBuildId$3(ChromeReleaseChannel.DEV);
+			case BrowserTag.STABLE: return await resolveBuildId$3(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 resolveBuildId$2(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
+*/
+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 resolveBuildId$3(tag);
+			if (chromeResult) return chromeResult;
+			return tag;
+		case Browser.CHROMEDRIVER:
+			const chromeDriverResult = await resolveBuildId$3(tag);
+			if (chromeDriverResult) return chromeDriverResult;
+			return tag;
+		case Browser.CHROMEHEADLESSSHELL:
+			const chromeHeadlessShellResult = await resolveBuildId$3(tag);
+			if (chromeHeadlessShellResult) return chromeHeadlessShellResult;
+			return tag;
+		case Browser.CHROMIUM: return tag;
+	}
+}
+/**
+* @public
+*/
+async function createProfile(browser, opts) {
+	switch (browser) {
+		case Browser.FIREFOX: return await createProfile$1(opts);
+		case Browser.CHROME:
+		case Browser.CHROMIUM: throw new Error(`Profile creation is not support for ${browser} yet`);
+	}
+}
+/**
+* Returns the expected default user data dir for the given channel. It does not
+* check if the dir actually exists.
+*
+* @public
+*/
+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 resolveDefaultUserDataDir$1(platform, channel);
+	}
+}
+/**
+* @internal
+*
+* Returns multiple paths where the executable may be located at on the current system
+* ordered by likelihood (based on heuristics).
+*/
+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 resolveSystemExecutablePaths$1(platform, channel);
+	}
+}
+/**
+* Returns a version comparator for the given browser that can be used to sort
+* browser versions.
+*
+* @public
+*/
+function getVersionComparator(browser) {
+	return versionComparators[browser];
+}
+
+//#endregion
+//#region node_modules/@puppeteer/browsers/lib/debug.js
+const debug = (prefix) => {
+	const log = debuglog(prefix);
+	return log.enabled ? log : void 0;
+};
+
+//#endregion
+//#region node_modules/@puppeteer/browsers/lib/detectPlatform.js
+/**
+* @public
+*/
+function detectBrowserPlatform() {
+	const platform = os.platform();
+	const arch = os.arch();
+	switch (platform) {
+		case "darwin": return arch === "arm64" ? BrowserPlatform.MAC_ARM : BrowserPlatform.MAC;
+		case "linux": return arch === "arm64" ? BrowserPlatform.LINUX_ARM : BrowserPlatform.LINUX;
+		case "win32": return arch === "x64" || arch === "arm64" && isWindows11(os.release()) ? BrowserPlatform.WIN64 : BrowserPlatform.WIN32;
+		default: return;
+	}
+}
+/**
+* Windows 11 is identified by the version 10.0.22000 or greater
+* @internal
+*/
+function isWindows11(version) {
+	const parts = version.split(".");
+	if (parts.length > 2) {
+		const major = parseInt(parts[0], 10);
+		const minor = parseInt(parts[1], 10);
+		const patch = parseInt(parts[2], 10);
+		return major > 10 || major === 10 && minor > 0 || major === 10 && minor === 0 && patch >= 22e3;
+	}
+	return false;
+}
+
+//#endregion
+//#region node_modules/@puppeteer/browsers/lib/Cache.js
+const debugCache = debug("puppeteer:browsers:cache");
+/**
+* @public
+*/
+var InstalledBrowser = class {
+	browser;
+	buildId;
+	platform;
+	executablePath;
+	#cache;
+	/**
+	* @internal
+	*/
+	constructor(cache, browser, buildId, platform) {
+		this.#cache = cache;
+		this.browser = browser;
+		this.buildId = buildId;
+		this.platform = platform;
+		this.executablePath = cache.computeExecutablePath({
+			browser,
+			buildId,
+			platform
+		});
+	}
+	/**
+	* Path to the root of the installation folder. Use
+	* {@link computeExecutablePath} to get the path to the executable binary.
+	*/
+	get path() {
+		return this.#cache.installationDir(this.browser, this.platform, this.buildId);
+	}
+	readMetadata() {
+		return this.#cache.readMetadata(this.browser);
+	}
+	writeMetadata(metadata) {
+		this.#cache.writeMetadata(this.browser, metadata);
+	}
+};
+/**
+* The cache used by Puppeteer relies on the following structure:
+*
+* - rootDir
+*   -- <browser1> | browserRoot(browser1)
+*   ---- <platform>-<buildId> | installationDir()
+*   ------ the browser-platform-buildId
+*   ------ specific structure.
+*   -- <browser2> | browserRoot(browser2)
+*   ---- <platform>-<buildId> | installationDir()
+*   ------ the browser-platform-buildId
+*   ------ specific structure.
+*   @internal
+*/
+var Cache = class {
+	#rootDir;
+	constructor(rootDir) {
+		this.#rootDir = rootDir;
+	}
+	/**
+	* @internal
+	*/
+	get rootDir() {
+		return this.#rootDir;
+	}
+	browserRoot(browser) {
+		return path.join(this.#rootDir, browser);
+	}
+	metadataFile(browser) {
+		return path.join(this.browserRoot(browser), ".metadata");
+	}
+	readMetadata(browser) {
+		const metatadaPath = this.metadataFile(browser);
+		if (!fs.existsSync(metatadaPath)) return { aliases: {} };
+		const data = JSON.parse(fs.readFileSync(metatadaPath, "utf8"));
+		if (typeof data !== "object") throw new Error(".metadata is not an object");
+		return data;
+	}
+	writeMetadata(browser, metadata) {
+		const metatadaPath = this.metadataFile(browser);
+		fs.mkdirSync(path.dirname(metatadaPath), { recursive: true });
+		fs.writeFileSync(metatadaPath, JSON.stringify(metadata, null, 2));
+	}
+	readExecutablePath(browser, platform, buildId) {
+		const metadata = this.readMetadata(browser);
+		const key = `${platform}-${buildId}`;
+		return metadata.executablePaths?.[key] ?? null;
+	}
+	writeExecutablePath(browser, platform, buildId, executablePath) {
+		const metadata = this.readMetadata(browser);
+		if (!metadata.executablePaths) metadata.executablePaths = {};
+		const key = `${platform}-${buildId}`;
+		metadata.executablePaths[key] = executablePath;
+		this.writeMetadata(browser, metadata);
+	}
+	resolveAlias(browser, alias) {
+		const metadata = this.readMetadata(browser);
+		if (alias === "latest") return Object.values(metadata.aliases || {}).sort(getVersionComparator(browser)).at(-1);
+		return metadata.aliases[alias];
+	}
+	installationDir(browser, platform, buildId) {
+		return path.join(this.browserRoot(browser), `${platform}-${buildId}`);
+	}
+	clear() {
+		fs.rmSync(this.#rootDir, {
+			force: true,
+			recursive: true,
+			maxRetries: 10,
+			retryDelay: 500
+		});
+	}
+	uninstall(browser, platform, buildId) {
+		const metadata = this.readMetadata(browser);
+		for (const alias of Object.keys(metadata.aliases)) if (metadata.aliases[alias] === buildId) delete metadata.aliases[alias];
+		const key = `${platform}-${buildId}`;
+		if (metadata.executablePaths?.[key]) {
+			delete metadata.executablePaths[key];
+			this.writeMetadata(browser, metadata);
+		}
+		fs.rmSync(this.installationDir(browser, platform, buildId), {
+			force: true,
+			recursive: true,
+			maxRetries: 10,
+			retryDelay: 500
+		});
+	}
+	getInstalledBrowsers() {
+		if (!fs.existsSync(this.#rootDir)) return [];
+		return fs.readdirSync(this.#rootDir).filter((t) => {
+			return Object.values(Browser).includes(t);
+		}).flatMap((browser) => {
+			return fs.readdirSync(this.browserRoot(browser)).map((file) => {
+				const result = parseFolderPath(path.join(this.browserRoot(browser), file));
+				if (!result) return null;
+				return new InstalledBrowser(this, browser, result.buildId, result.platform);
+			}).filter((item) => {
+				return item !== null;
+			});
+		});
+	}
+	computeExecutablePath(options) {
+		options.platform ??= detectBrowserPlatform();
+		if (!options.platform) throw new Error(`Cannot download a binary for the provided platform: ${os.platform()} (${os.arch()})`);
+		try {
+			options.buildId = this.resolveAlias(options.browser, options.buildId) ?? options.buildId;
+		} catch {
+			debugCache?.("could not read .metadata file for the browser");
+		}
+		const installationDir = this.installationDir(options.browser, options.platform, options.buildId);
+		const storedExecutablePath = this.readExecutablePath(options.browser, options.platform, options.buildId);
+		if (storedExecutablePath) return path.join(installationDir, storedExecutablePath);
+		return path.join(installationDir, executablePathByBrowser[options.browser](options.platform, options.buildId));
+	}
+};
+function parseFolderPath(folderPath) {
+	const splits = path.basename(folderPath).split("-");
+	if (splits.length !== 2) return;
+	const [platform, buildId] = splits;
+	if (!buildId || !platform) return;
+	return {
+		platform,
+		buildId
+	};
+}
+
+//#endregion
+//#region node_modules/@puppeteer/browsers/lib/launch.js
+const debugLaunch = debug("puppeteer:browsers:launcher");
+/**
+* @public
+*/
+function computeExecutablePath(options) {
+	if (options.cacheDir === null) {
+		options.platform ??= detectBrowserPlatform();
+		if (options.platform === void 0) throw new Error(`No platform specified. Couldn't auto-detect browser platform.`);
+		return executablePathByBrowser[options.browser](options.platform, options.buildId);
+	}
+	return new Cache(options.cacheDir).computeExecutablePath(options);
+}
+/**
+* Returns a path to a system-wide Chrome installation given a release channel
+* name by checking known installation locations (using
+* {@link https://pptr.dev/browsers-api/browsers.computesystemexecutablepath}).
+* If Chrome instance is not found at the expected path, an error is thrown.
+*
+* @public
+*/
+function computeSystemExecutablePath(options) {
+	options.platform ??= detectBrowserPlatform();
+	if (!options.platform) throw new Error(`Cannot download a binary for the provided platform: ${os.platform()} (${os.arch()})`);
+	const paths = resolveSystemExecutablePaths(options.browser, options.platform, options.channel);
+	for (const path$1 of paths) try {
+		accessSync(path$1);
+		return path$1;
+	} catch {}
+	throw new Error(`Could not find Google Chrome executable for channel '${options.channel}' at:${paths.map((path$1) => {
+		return `\n - ${path$1}`;
+	})}.`);
+}
+/**
+* Launches a browser process according to {@link LaunchOptions}.
+*
+* @public
+*/
+function launch(opts) {
+	return new Process(opts);
+}
+/**
+* @public
+*/
+const CDP_WEBSOCKET_ENDPOINT_REGEX = /^DevTools listening on (ws:\/\/.*)$/;
+/**
+* @public
+*/
+const WEBDRIVER_BIDI_WEBSOCKET_ENDPOINT_REGEX = /^WebDriver BiDi listening on (ws:\/\/.*)$/;
+const processListeners = /* @__PURE__ */ new Map();
+const dispatchers = {
+	exit: (...args) => {
+		processListeners.get("exit")?.forEach((handler) => {
+			return handler(...args);
+		});
+	},
+	SIGINT: (...args) => {
+		processListeners.get("SIGINT")?.forEach((handler) => {
+			return handler(...args);
+		});
+	},
+	SIGHUP: (...args) => {
+		processListeners.get("SIGHUP")?.forEach((handler) => {
+			return handler(...args);
+		});
+	},
+	SIGTERM: (...args) => {
+		processListeners.get("SIGTERM")?.forEach((handler) => {
+			return handler(...args);
+		});
+	}
+};
+function subscribeToProcessEvent(event, handler) {
+	const listeners = processListeners.get(event) || [];
+	if (listeners.length === 0) process.on(event, dispatchers[event]);
+	listeners.push(handler);
+	processListeners.set(event, listeners);
+}
+function unsubscribeFromProcessEvent(event, handler) {
+	const listeners = processListeners.get(event) || [];
+	const existingListenerIdx = listeners.indexOf(handler);
+	if (existingListenerIdx === -1) return;
+	listeners.splice(existingListenerIdx, 1);
+	processListeners.set(event, listeners);
+	if (listeners.length === 0) process.off(event, dispatchers[event]);
+}
+/**
+* @public
+*/
+var Process = class {
+	#executablePath;
+	#args;
+	#browserProcess;
+	#exited = false;
+	#hooksRan = false;
+	#onExitHook = async () => {};
+	#browserProcessExiting;
+	#logs = [];
+	#maxLogLinesSize = 1e3;
+	#lineEmitter = new EventEmitter();
+	#onAbort = () => {
+		this.kill();
+	};
+	#signal;
+	constructor(opts) {
+		this.#executablePath = opts.executablePath;
+		this.#args = opts.args ?? [];
+		this.#signal = opts.signal;
+		if (this.#signal?.aborted) throw new Error(this.#signal.reason ? this.#signal.reason : "Launch aborted");
+		this.#signal?.addEventListener("abort", this.#onAbort, { once: true });
+		opts.pipe ??= false;
+		opts.dumpio ??= false;
+		opts.handleSIGINT ??= true;
+		opts.handleSIGTERM ??= true;
+		opts.handleSIGHUP ??= true;
+		opts.detached ??= process.platform !== "win32";
+		const stdio = this.#configureStdio({ pipe: opts.pipe });
+		const env = opts.env || {};
+		debugLaunch?.(`Launching ${this.#executablePath} ${this.#args.join(" ")}`, {
+			detached: opts.detached,
+			env: Object.keys(env).reduce((res, key) => {
+				if (key.toLowerCase().startsWith("puppeteer_")) res[key] = env[key];
+				return res;
+			}, {}),
+			stdio
+		});
+		this.#browserProcess = childProcess.spawn(this.#executablePath, this.#args, {
+			detached: opts.detached,
+			env,
+			stdio
+		});
+		this.#recordStream(this.#browserProcess.stderr);
+		this.#recordStream(this.#browserProcess.stdout);
+		debugLaunch?.(`Launched ${this.#browserProcess.pid}`);
+		if (opts.dumpio) {
+			this.#browserProcess.stderr?.pipe(process.stderr);
+			this.#browserProcess.stdout?.pipe(process.stdout);
+		}
+		subscribeToProcessEvent("exit", this.#onDriverProcessExit);
+		if (opts.handleSIGINT) subscribeToProcessEvent("SIGINT", this.#onDriverProcessSignal);
+		if (opts.handleSIGTERM) subscribeToProcessEvent("SIGTERM", this.#onDriverProcessSignal);
+		if (opts.handleSIGHUP) subscribeToProcessEvent("SIGHUP", this.#onDriverProcessSignal);
+		if (opts.onExit) this.#onExitHook = opts.onExit;
+		this.#browserProcessExiting = new Promise((resolve$1, reject) => {
+			this.#browserProcess.once("exit", async () => {
+				debugLaunch?.(`Browser process ${this.#browserProcess.pid} onExit`);
+				this.#clearListeners();
+				this.#exited = true;
+				try {
+					await this.#runHooks();
+				} catch (err) {
+					reject(err);
+					return;
+				}
+				resolve$1();
+			});
+		});
+	}
+	async #runHooks() {
+		if (this.#hooksRan) return;
+		this.#hooksRan = true;
+		await this.#onExitHook();
+	}
+	get nodeProcess() {
+		return this.#browserProcess;
+	}
+	#configureStdio(opts) {
+		if (opts.pipe) return [
+			"pipe",
+			"pipe",
+			"pipe",
+			"pipe",
+			"pipe"
+		];
+		else return [
+			"pipe",
+			"pipe",
+			"pipe"
+		];
+	}
+	#clearListeners() {
+		unsubscribeFromProcessEvent("exit", this.#onDriverProcessExit);
+		unsubscribeFromProcessEvent("SIGINT", this.#onDriverProcessSignal);
+		unsubscribeFromProcessEvent("SIGTERM", this.#onDriverProcessSignal);
+		unsubscribeFromProcessEvent("SIGHUP", this.#onDriverProcessSignal);
+		this.#signal?.removeEventListener("abort", this.#onAbort);
+	}
+	#onDriverProcessExit = (_code) => {
+		this.kill();
+	};
+	#onDriverProcessSignal = (signal) => {
+		switch (signal) {
+			case "SIGINT":
+				this.kill();
+				process.exit(130);
+			case "SIGTERM":
+			case "SIGHUP":
+				this.close();
+				break;
+		}
+	};
+	async close() {
+		await this.#runHooks();
+		if (!this.#exited) this.kill();
+		return await this.#browserProcessExiting;
+	}
+	hasClosed() {
+		return this.#browserProcessExiting;
+	}
+	kill() {
+		debugLaunch?.(`Trying to kill ${this.#browserProcess.pid}`);
+		if (this.#browserProcess && this.#browserProcess.pid && pidExists(this.#browserProcess.pid)) try {
+			debugLaunch?.(`Browser process ${this.#browserProcess.pid} exists`);
+			if (process.platform === "win32") try {
+				childProcess.execSync(`taskkill /pid ${this.#browserProcess.pid} /T /F`);
+			} catch (error) {
+				debugLaunch?.(`Killing ${this.#browserProcess.pid} using taskkill failed`, error);
+				this.#browserProcess.kill();
+			}
+			else {
+				const processGroupId = -this.#browserProcess.pid;
+				try {
+					process.kill(processGroupId, "SIGKILL");
+				} catch (error) {
+					debugLaunch?.(`Killing ${this.#browserProcess.pid} using process.kill failed`, error);
+					this.#browserProcess.kill("SIGKILL");
+				}
+			}
+		} catch (error) {
+			throw new Error(`${PROCESS_ERROR_EXPLANATION}\nError cause: ${isErrorLike(error) ? error.stack : error}`);
+		}
+		this.#clearListeners();
+	}
+	#recordStream(stream) {
+		const rl = readline.createInterface(stream);
+		const cleanup = () => {
+			rl.off("line", onLine);
+			rl.off("close", onClose);
+			try {
+				rl.close();
+			} catch {}
+		};
+		const onLine = (line) => {
+			if (line.trim() === "") return;
+			this.#logs.push(line);
+			const delta = this.#logs.length - this.#maxLogLinesSize;
+			if (delta) this.#logs.splice(0, delta);
+			this.#lineEmitter.emit("line", line);
+		};
+		const onClose = () => {
+			cleanup();
+		};
+		rl.on("line", onLine);
+		rl.on("close", onClose);
+	}
+	/**
+	* Get recent logs (stderr + stdout) emitted by the browser.
+	*
+	* @public
+	*/
+	getRecentLogs() {
+		return [...this.#logs];
+	}
+	waitForLineOutput(regex, timeout = 0) {
+		return new Promise((resolve$1, reject) => {
+			const onClose = (errorOrCode) => {
+				cleanup();
+				reject(new Error([
+					`Failed to launch the browser process: ${errorOrCode instanceof Error ? ` ${errorOrCode.message}` : ` Code: ${errorOrCode}`}`,
+					"",
+					`stderr:`,
+					this.getRecentLogs().join("\n"),
+					"",
+					"TROUBLESHOOTING: https://pptr.dev/troubleshooting",
+					""
+				].join("\n")));
+			};
+			this.#browserProcess.on("exit", onClose);
+			this.#browserProcess.on("error", onClose);
+			const timeoutId = timeout > 0 ? setTimeout(onTimeout, timeout) : void 0;
+			this.#lineEmitter.on("line", onLine);
+			const cleanup = () => {
+				clearTimeout(timeoutId);
+				this.#lineEmitter.off("line", onLine);
+				this.#browserProcess.off("exit", onClose);
+				this.#browserProcess.off("error", onClose);
+			};
+			function onTimeout() {
+				cleanup();
+				reject(new TimeoutError(`Timed out after ${timeout} ms while waiting for the WS endpoint URL to appear in stdout!`));
+			}
+			for (const line of this.#logs) onLine(line);
+			function onLine(line) {
+				const match = line.match(regex);
+				if (!match) return;
+				cleanup();
+				resolve$1(match[1]);
+			}
+		});
+	}
+};
+const PROCESS_ERROR_EXPLANATION = `Puppeteer was unable to kill the process which ran the browser binary.
+This means that, on future Puppeteer launches, Puppeteer might not be able to launch the browser.
+Please check your open processes and ensure that the browser processes that Puppeteer launched have been killed.
+If you think this is a bug, please report it on the Puppeteer issue tracker.`;
+/**
+* @internal
+*/
+function pidExists(pid) {
+	try {
+		return process.kill(pid, 0);
+	} catch (error) {
+		if (isErrnoException(error)) {
+			if (error.code && error.code === "ESRCH") return false;
+		}
+		throw error;
+	}
+}
+/**
+* @internal
+*/
+function isErrorLike(obj) {
+	return typeof obj === "object" && obj !== null && "name" in obj && "message" in obj;
+}
+/**
+* @internal
+*/
+function isErrnoException(obj) {
+	return isErrorLike(obj) && ("errno" in obj || "code" in obj || "path" in obj || "syscall" in obj);
+}
+/**
+* @public
+*/
+var TimeoutError = class extends Error {
+	/**
+	* @internal
+	*/
+	constructor(message) {
+		super(message);
+		this.name = this.constructor.name;
+		Error.captureStackTrace(this, this.constructor);
+	}
+};
+
+//#endregion
+//#region node_modules/@puppeteer/browsers/lib/fileUtil.js
+const execFileAsync = promisify(execFile);
+const debugFileUtil = debug("puppeteer:browsers:fileUtil");
+
+//#endregion
+//#region node_modules/@puppeteer/browsers/lib/install.js
+const debugInstall = debug("puppeteer:browsers:install");
+/**
+*
+* @public
+*/
+async function uninstall(options) {
+	options.platform ??= detectBrowserPlatform();
+	if (!options.platform) throw new Error(`Cannot detect the browser platform for: ${os.platform()} (${os.arch()})`);
+	new Cache(options.cacheDir).uninstall(options.browser, options.platform, options.buildId);
+}
+/**
+* Returns metadata about browsers installed in the cache directory.
+*
+* @public
+*/
+async function getInstalledBrowsers(options) {
+	return new Cache(options.cacheDir).getInstalledBrowsers();
+}
+
+//#endregion
+export { Browser as _, TimeoutError as a, ChromeReleaseChannel as b, computeSystemExecutablePath as c, InstalledBrowser as d, detectBrowserPlatform as f, resolveDefaultUserDataDir as g, resolveBuildId as h, Process as i, launch as l, getVersionComparator as m, uninstall as n, WEBDRIVER_BIDI_WEBSOCKET_ENDPOINT_REGEX as o, createProfile as p, CDP_WEBSOCKET_ENDPOINT_REGEX as r, computeExecutablePath as s, getInstalledBrowsers as t, Cache as u, BrowserPlatform as v, BrowserTag as y };