better-dsh 0.2.5 → 0.3.0-c

package/lib/puppeteer-core-CSk2PtSm.js

@@ -0,0 +1,1136 @@
+import { _ as Browser$1, a as TimeoutError$1, c as computeSystemExecutablePath, f as detectBrowserPlatform, h as resolveBuildId, l as launch$1, n as uninstall, o as WEBDRIVER_BIDI_WEBSOCKET_ENDPOINT_REGEX, p as createProfile, r as CDP_WEBSOCKET_ENDPOINT_REGEX, s as computeExecutablePath, t as getInstalledBrowsers } from "./main-CupOhMp5.js";
+import { C as unitToPixels, Ct as getCapturedLogs, E as paperFormats, F as bufferCount, J as fromEvent, K as firstValueFrom, M as assert, Q as map, S as timeout, St as debug, T as withSourcePuppeteerURLIfNone, Tt as environment, W as filter, Z as lastValueFrom, _ as isNumber, _t as PuppeteerError, a as UTILITY_WORLD_NAME, at as race, b as isString, bt as TouchError, c as evaluationString, d as fromEmitterEvent, dt as takeUntil, f as getReadableAsTypedArray, ft as tap, g as isDate, gt as ProtocolError, h as getSourceUrlComment, ht as ConnectionClosedError, i as SOURCE_URL_REGEX, l as filterAsync, m as getSourcePuppeteerURLIfAvailable, mt as timer, n as NETWORK_IDLE_TIME, o as debugCatchError, p as getReadableFromProtocolStream, q as from, r as PuppeteerURL, s as debugError, t as DEFAULT_VIEWPORT, u as fromAbortSignal, v as isPlainObject, vt as TargetCloseError, w as validateDialogType, wt as setLogCapture, x as parsePDFOptions, xt as UnsupportedOperation, y as isRegExp, yt as TimeoutError, z as concatMap } from "./util-BHL_dfV_.js";
+import { $ as pageBindingInitString, $n as Deferred, $t as scriptInjector, A as NetworkManager, An as guarded, At as DEFAULT_INTERCEPT_RESOLUTION_PRIORITY, B as MAIN_WORLD, Bn as AsyncDisposableStack, Bt as throwIfDetached, C as WebMCPToolCall, Cn as NodeLocator, Ct as WebWorkerEvent, D as CdpTouchscreen, Dn as DeviceRequestPrompt, Dt as normalizeHeaderValue, E as CdpTouchHandle, En as TimeoutSettings, Et as WaitTask, F as CdpFrame, Fn as Browser, Ft as headersArray, G as CdpJSHandle, Gn as asyncDisposeSymbol, Gt as XPathQueryHandler, H as FrameManagerEvent, Hn as DisposableStack, Ht as bindIsolatedHandle, I as referrerPolicyToProtocol, In as WEB_PERMISSION_TO_PROTOCOL_PERMISSION, It as Dialog, J as addPageBinding, Jn as CallbackRegistry, Jt as PQueryHandler, K as releaseObject, Kn as disposeSymbol, Kt as TextQueryHandler, L as LifecycleWatcher, Ln as CDPSession, Lt as Accessibility, M as CdpHTTPResponse, Mt as InterceptResolutionAction, N as CdpHTTPRequest, Nt as STATUS_TEXTS, O as _keyDefinitions, On as BrowserContext, Ot as SecurityDetails, P as FrameTree, Pn as Mutex, Pt as handleError, Q as createEvaluationError, Qn as rewriteError, Qt as ScriptInjector, R as IsolatedWorld, Rn as CDPSessionEvent, Rt as Frame, S as WebMCPTool, Sn as MappedLocator, St as WebWorker, T as CdpMouse, Tn as RaceLocator, Tt as TaskManager, U as ExecutionContext, Un as DisposableStackPolyfill, Ut as JSHandle, V as PUPPETEER_WORLD, Vn as AsyncDisposableStackPolyfill, Vt as ElementHandle, W as CdpElementHandle, Wn as SuppressedError, Wt as getQueryHandlerAndSelector, X as createClientError, Xn as isErrnoException, Xt as CustomQueryHandlerRegistry, Y as convertConsoleMessageLevel, Yn as createProtocolErrorMessage, Yt as PierceQueryHandler, Z as createConsoleMessage, Zn as isErrorLike, Zt as customQueryHandlers, _ as CdpBrowserContext, _n as DelegatedLocator, _t as Mouse, a as KnownDevices, at as CdpPreloadScript, b as convertSameSiteFromPuppeteerToCdp, bn as Locator, bt as createIncrementalIdGenerator, c as _connectToCdpBrowser, cn as Tracing, ct as isTargetClosedError, d as CdpTarget, dn as CSSCoverage, dt as ConsoleMessage, en as ARIAQueryHandler, et as valueFromJSHandle, f as DevToolsTarget, fn as Coverage, ft as CdpBluetoothEmulation, g as WorkerTarget, gn as supportedMetrics, gt as Keyboard, h as PageTarget, hn as setDefaultScreenshotOptions, ht as TargetType, i as assertSupportedUrlRestrictions, it as CdpDeviceRequestPromptManager, j as NetworkEventManager, jt as HTTPRequest, k as FrameManager, kt as HTTPResponse, l as CdpBrowser, ln as EmulatedState, lt as CdpCDPSession, m as OtherTarget, mn as Page, mt as Target, n as TaskQueue, nn as LazyArg, nt as valueFromRemoteObjectReference, o as PredefinedNetworkConditions, on as AsyncIterableUtil, ot as CdpDialog, p as InitializationStatus, pn as JSCoverage, pt as Binding, q as CDP_BINDING_PREFIX, qn as Callback, qt as parsePSelectors, r as Puppeteer, rn as transposeIterableHandle, rt as CdpDeviceRequestPrompt, s as ExtensionTransport, sn as FileChooser, st as Connection, t as PUPPETEER_REVISIONS, tn as QueryHandler, tt as valueFromPrimitiveRemoteObject, u as TargetManager, un as EmulationManager, ut as NetworkManagerEvent, v as CdpPage, vn as FilteredLocator, vt as MouseButton, w as CdpKeyboard, wn as RETRY_DELAY, wt as Realm, x as WebMCP, xn as LocatorEvent, xt as Extension, y as convertCookiesPartitionKeyFromPuppeteerToCdp, yn as FunctionLocator, yt as Touchscreen, z as CdpWebWorker, zn as EventEmitter, zt as FrameEvent } from "./index-browser-CysrjMyM.js";
+import { t as BrowserWebSocketTransport } from "./BrowserWebSocketTransport-wm99h94r.js";
+import { t as convertPuppeteerChannelToBrowsersChannel } from "./LaunchOptions-kGXcZOe0.js";
+import { t as NodeWebSocketTransport } from "./NodeWebSocketTransport-D9ysYGLM.js";
+import { spawn, spawnSync } from "node:child_process";
+import { mkdtemp, rename, unlink } from "node:fs/promises";
+import path, { dirname, join } from "node:path";
+import fs, { existsSync } from "node:fs";
+import os, { tmpdir } from "node:os";
+import { debuglog } from "node:util";
+import { PassThrough } from "node:stream";
+
+//#region node_modules/puppeteer-core/lib/puppeteer/node-env-setup.js
+environment.value = {
+	fs,
+	path,
+	debuglog,
+	ScreenRecorder: environment.value.ScreenRecorder
+};
+
+//#endregion
+//#region node_modules/puppeteer-core/lib/puppeteer/node/PipeTransport.js
+/**
+* @internal
+*/
+var PipeTransport = class {
+	#pipeWrite;
+	#subscriptions = new DisposableStack();
+	#isClosed = false;
+	#pendingMessage = [];
+	onclose;
+	onmessage;
+	constructor(pipeWrite, pipeRead) {
+		this.#pipeWrite = pipeWrite;
+		const pipeReadEmitter = this.#subscriptions.use(new EventEmitter(pipeRead));
+		pipeReadEmitter.on("data", (buffer) => {
+			return this.#dispatch(buffer);
+		});
+		pipeReadEmitter.on("close", () => {
+			if (this.onclose) this.onclose.call(null);
+		});
+		pipeReadEmitter.on("error", debugCatchError);
+		this.#subscriptions.use(new EventEmitter(pipeWrite)).on("error", debugCatchError);
+	}
+	send(message) {
+		assert(!this.#isClosed, "`PipeTransport` is closed.");
+		this.#pipeWrite.write(message);
+		this.#pipeWrite.write("\0");
+	}
+	#dispatch(buffer) {
+		assert(!this.#isClosed, "`PipeTransport` is closed.");
+		this.#pendingMessage.push(buffer);
+		if (buffer.indexOf("\0") === -1) return;
+		const concatBuffer = Buffer.concat(this.#pendingMessage);
+		let start = 0;
+		let end = concatBuffer.indexOf("\0");
+		while (end !== -1) {
+			const message = concatBuffer.toString(void 0, start, end);
+			setImmediate(() => {
+				if (this.onmessage) this.onmessage.call(null, message);
+			});
+			start = end + 1;
+			end = concatBuffer.indexOf("\0", start);
+		}
+		if (start >= concatBuffer.length) this.#pendingMessage = [];
+		else this.#pendingMessage = [concatBuffer.subarray(start)];
+	}
+	close() {
+		this.#isClosed = true;
+		this.#subscriptions.dispose();
+	}
+};
+
+//#endregion
+//#region node_modules/puppeteer-core/lib/puppeteer/node/BrowserLauncher.js
+/**
+* @internal
+*/
+function getBrowserTypeDisplayName(browserType) {
+	switch (browserType) {
+		case Browser$1.FIREFOX:
+		case Browser$1.CHROME: return browserType.charAt(0).toUpperCase() + browserType.slice(1);
+		default: return browserType;
+	}
+}
+/**
+* Describes a launcher - a class that is able to create and launch a browser instance.
+*
+* @public
+*/
+var BrowserLauncher = class {
+	#browser;
+	/**
+	* @internal
+	*/
+	puppeteer;
+	/**
+	* @internal
+	*/
+	constructor(puppeteer$1, browser) {
+		this.puppeteer = puppeteer$1;
+		this.#browser = browser;
+	}
+	get browser() {
+		return this.#browser;
+	}
+	async launch(options = {}) {
+		const { dumpio = false, enableExtensions = false, extensionsEnabledInIncognito = [], env = process.env, handleSIGINT = true, handleSIGTERM = true, handleSIGHUP = true, acceptInsecureCerts = false, networkEnabled = true, issuesEnabled = true, defaultViewport = DEFAULT_VIEWPORT, downloadBehavior, slowMo = 0, timeout: timeout$1 = 3e4, waitForInitialPage = true, protocolTimeout, handleDevToolsAsPage, idGenerator = createIncrementalIdGenerator(), blocklist, allowlist } = options;
+		let { protocol } = options;
+		if (this.#browser === "firefox" && protocol === void 0) protocol = "webDriverBiDi";
+		assertSupportedUrlRestrictions({
+			allowlist,
+			blocklist,
+			protocol
+		});
+		if (this.#browser === "firefox" && protocol === "cdp") throw new Error("Connecting to Firefox using CDP is no longer supported");
+		const launchArgs = await this.computeLaunchArguments({
+			...options,
+			protocol
+		});
+		if (!existsSync(launchArgs.executablePath)) throw new Error(`Browser was not found at the configured executablePath (${launchArgs.executablePath})`);
+		const usePipe = launchArgs.args.includes("--remote-debugging-pipe");
+		const onProcessExit = async () => {
+			await this.cleanUserDataDir(launchArgs.userDataDir, { isTemp: launchArgs.isTempUserDataDir });
+		};
+		if (this.#browser === "firefox" && protocol === "webDriverBiDi" && usePipe) throw new Error("Pipe connections are not supported with Firefox and WebDriver BiDi");
+		const browserProcess = launch$1({
+			executablePath: launchArgs.executablePath,
+			args: launchArgs.args,
+			handleSIGHUP,
+			handleSIGTERM,
+			handleSIGINT,
+			dumpio,
+			env,
+			pipe: usePipe,
+			onExit: onProcessExit,
+			signal: options.signal
+		});
+		let browser;
+		let cdpConnection;
+		let closing = false;
+		const browserCloseCallback = async () => {
+			if (closing) return;
+			closing = true;
+			await this.closeBrowser(browserProcess, cdpConnection);
+		};
+		try {
+			if (this.#browser === "firefox") browser = await this.createBiDiBrowser(browserProcess, browserCloseCallback, {
+				timeout: timeout$1,
+				protocolTimeout,
+				slowMo,
+				defaultViewport,
+				acceptInsecureCerts,
+				networkEnabled,
+				idGenerator
+			});
+			else {
+				if (usePipe) cdpConnection = await this.createCdpPipeConnection(browserProcess, {
+					timeout: timeout$1,
+					protocolTimeout,
+					slowMo,
+					idGenerator
+				});
+				else cdpConnection = await this.createCdpSocketConnection(browserProcess, {
+					timeout: timeout$1,
+					protocolTimeout,
+					slowMo,
+					idGenerator
+				});
+				if (protocol === "webDriverBiDi") browser = await this.createBiDiOverCdpBrowser(browserProcess, cdpConnection, browserCloseCallback, {
+					defaultViewport,
+					acceptInsecureCerts,
+					networkEnabled,
+					issuesEnabled
+				});
+				else browser = await CdpBrowser._create(cdpConnection, [], acceptInsecureCerts, defaultViewport, downloadBehavior, browserProcess.nodeProcess, browserCloseCallback, options.targetFilter, void 0, void 0, networkEnabled, issuesEnabled, handleDevToolsAsPage, blocklist, allowlist);
+			}
+		} catch (error) {
+			browserCloseCallback();
+			const logs = browserProcess.getRecentLogs().join("\n");
+			if (logs.includes("Failed to create a ProcessSingleton for your profile directory") || process.platform === "win32" && existsSync(join(launchArgs.userDataDir, "lockfile"))) throw new Error(`The browser is already running for ${launchArgs.userDataDir}. Use a different \`userDataDir\` or stop the running browser first.`);
+			if (logs.includes("Missing X server") && options.headless === false) throw new Error(`Missing X server to start the headful browser. Either set headless to true or use xvfb-run to run your Puppeteer script.`);
+			if (error instanceof TimeoutError$1) throw new TimeoutError(error.message);
+			throw error;
+		}
+		if (Array.isArray(enableExtensions)) await Promise.all([enableExtensions.map((path$1) => {
+			return browser.installExtension(path$1, { enabledInIncognito: extensionsEnabledInIncognito.includes(path$1) });
+		})]);
+		if (waitForInitialPage) await this.waitForPageTarget(browser, timeout$1);
+		return browser;
+	}
+	/**
+	* @internal
+	*/
+	async closeBrowser(browserProcess, cdpConnection) {
+		if (cdpConnection) try {
+			await cdpConnection.closeBrowser();
+			await browserProcess.hasClosed();
+		} catch (error) {
+			debugError?.(error);
+			await browserProcess.close();
+		}
+		else await firstValueFrom(race(from(browserProcess.hasClosed()), timer(5e3).pipe(map(() => {
+			return from(browserProcess.close());
+		}))));
+	}
+	/**
+	* @internal
+	*/
+	async waitForPageTarget(browser, timeout$1) {
+		try {
+			await browser.waitForTarget((t) => {
+				return t.type() === "page";
+			}, { timeout: timeout$1 });
+		} catch (error) {
+			await browser.close();
+			throw error;
+		}
+	}
+	/**
+	* @internal
+	*/
+	async createCdpSocketConnection(browserProcess, opts) {
+		const browserWSEndpoint = await browserProcess.waitForLineOutput(CDP_WEBSOCKET_ENDPOINT_REGEX, opts.timeout);
+		return new Connection(browserWSEndpoint, await NodeWebSocketTransport.create(browserWSEndpoint), opts.slowMo, opts.protocolTimeout, false, opts.idGenerator);
+	}
+	/**
+	* @internal
+	*/
+	async createCdpPipeConnection(browserProcess, opts) {
+		const { 3: pipeWrite, 4: pipeRead } = browserProcess.nodeProcess.stdio;
+		return new Connection("", new PipeTransport(pipeWrite, pipeRead), opts.slowMo, opts.protocolTimeout, false, opts.idGenerator);
+	}
+	/**
+	* @internal
+	*/
+	async createBiDiOverCdpBrowser(browserProcess, cdpConnection, closeCallback, opts) {
+		const bidiOnly = process.env["PUPPETEER_WEBDRIVER_BIDI_ONLY"] === "true";
+		const BiDi = await import(
+			/* webpackIgnore: true */
+			"./bidi-BalpKaJc.js"
+);
+		const bidiConnection = await BiDi.connectBidiOverCdp(cdpConnection);
+		return await BiDi.BidiBrowser.create({
+			connection: bidiConnection,
+			cdpConnection: bidiOnly ? void 0 : cdpConnection,
+			closeCallback,
+			process: browserProcess.nodeProcess,
+			defaultViewport: opts.defaultViewport,
+			acceptInsecureCerts: opts.acceptInsecureCerts,
+			networkEnabled: opts.networkEnabled,
+			issuesEnabled: opts.issuesEnabled
+		});
+	}
+	/**
+	* @internal
+	*/
+	async createBiDiBrowser(browserProcess, closeCallback, opts) {
+		const browserWSEndpoint = await browserProcess.waitForLineOutput(WEBDRIVER_BIDI_WEBSOCKET_ENDPOINT_REGEX, opts.timeout) + "/session";
+		const transport = await NodeWebSocketTransport.create(browserWSEndpoint);
+		const BiDi = await import(
+			/* webpackIgnore: true */
+			"./bidi-BalpKaJc.js"
+);
+		const bidiConnection = new BiDi.BidiConnection(browserWSEndpoint, transport, opts.idGenerator, opts.slowMo, opts.protocolTimeout);
+		return await BiDi.BidiBrowser.create({
+			connection: bidiConnection,
+			closeCallback,
+			process: browserProcess.nodeProcess,
+			defaultViewport: opts.defaultViewport,
+			acceptInsecureCerts: opts.acceptInsecureCerts,
+			networkEnabled: opts.networkEnabled ?? true,
+			issuesEnabled: opts.issuesEnabled ?? true
+		});
+	}
+	/**
+	* @internal
+	*/
+	async getProfilePath() {
+		return join((await this.puppeteer.configuration()).temporaryDirectory ?? tmpdir(), `puppeteer_dev_${this.browser}_profile-`);
+	}
+	/**
+	* @internal
+	*/
+	async resolveExecutablePath(headless, validatePath = true) {
+		const config = await this.puppeteer.configuration();
+		let executablePath$1 = config.executablePath;
+		if (executablePath$1) {
+			if (validatePath && !existsSync(executablePath$1)) throw new Error(`Tried to find the browser at the configured path (${executablePath$1}), but no executable was found.`);
+			return executablePath$1;
+		}
+		function puppeteerBrowserToInstalledBrowser(browser, headless$1) {
+			switch (browser) {
+				case "chrome":
+					if (headless$1 === "shell") return Browser$1.CHROMEHEADLESSSHELL;
+					return Browser$1.CHROME;
+				case "firefox": return Browser$1.FIREFOX;
+			}
+			return Browser$1.CHROME;
+		}
+		const browserType = puppeteerBrowserToInstalledBrowser(this.browser, headless);
+		const defaultDownloadPath = await this.puppeteer.defaultDownloadPath();
+		const browserVersion = await this.puppeteer.browserVersion();
+		executablePath$1 = computeExecutablePath({
+			cacheDir: defaultDownloadPath,
+			browser: browserType,
+			buildId: browserVersion
+		});
+		if (validatePath && !existsSync(executablePath$1)) {
+			const configVersion = config?.[this.browser]?.version;
+			if (configVersion) throw new Error(`Tried to find the browser at the configured path (${executablePath$1}) for version ${configVersion}, but no executable was found.`);
+			throw new Error(`Could not find ${getBrowserTypeDisplayName(browserType)} (ver. ${browserVersion}). This can occur if either\n 1. you did not perform an installation before running the script (e.g. \`npx puppeteer browsers install ${browserType}\`) or\n 2. your cache path is incorrectly configured (which is: ${config.cacheDirectory}).\nFor (2), check out our guide on configuring puppeteer at https://pptr.dev/guides/configuration.`);
+		}
+		return executablePath$1;
+	}
+};
+
+//#endregion
+//#region node_modules/puppeteer-core/lib/puppeteer/node/util/fs.js
+const rmOptions = {
+	force: true,
+	recursive: true,
+	maxRetries: 5
+};
+/**
+* @internal
+*/
+async function rm$1(path$1) {
+	await fs.promises.rm(path$1, rmOptions);
+}
+
+//#endregion
+//#region node_modules/puppeteer-core/lib/puppeteer/node/ChromeLauncher.js
+/**
+* @internal
+*/
+var ChromeLauncher = class extends BrowserLauncher {
+	constructor(puppeteer$1) {
+		super(puppeteer$1, "chrome");
+	}
+	async launch(options = {}) {
+		if ((await this.puppeteer.configuration()).logLevel === "warn" && process.platform === "darwin" && process.arch === "x64") {
+			if (os.cpus()[0]?.model.includes("Apple")) console.warn([
+				"\x1B[1m\x1B[43m\x1B[30m",
+				"Degraded performance warning:\x1B[0m\x1B[33m",
+				"Launching Chrome on Mac Silicon (arm64) from an x64 Node installation results in",
+				"Rosetta translating the Chrome binary, even if Chrome is already arm64. This would",
+				"result in huge performance issues. To resolve this, you must run Puppeteer with",
+				"a version of Node built for arm64."
+			].join("\n  "));
+		}
+		return await super.launch(options);
+	}
+	/**
+	* @internal
+	*/
+	async computeLaunchArguments(options = {}) {
+		const { ignoreDefaultArgs = false, args = [], pipe = false, debuggingPort, channel, executablePath: executablePath$1 } = options;
+		const chromeArguments = [];
+		if (!ignoreDefaultArgs) chromeArguments.push(...this.defaultArgs(options));
+		else if (Array.isArray(ignoreDefaultArgs)) chromeArguments.push(...this.defaultArgs(options).filter((arg) => {
+			return !ignoreDefaultArgs.includes(arg);
+		}));
+		else chromeArguments.push(...args);
+		if (!chromeArguments.some((argument) => {
+			return argument.startsWith("--remote-debugging-");
+		})) if (pipe) {
+			assert(!debuggingPort, "Browser should be launched with either pipe or debugging port - not both.");
+			chromeArguments.push("--remote-debugging-pipe");
+		} else chromeArguments.push(`--remote-debugging-port=${debuggingPort || 0}`);
+		let isTempUserDataDir = false;
+		const userDataDirIndex = chromeArguments.findIndex((arg) => {
+			return arg.startsWith("--user-data-dir");
+		});
+		let userDataDir;
+		if (userDataDirIndex < 0) {
+			isTempUserDataDir = true;
+			userDataDir = await mkdtemp(await this.getProfilePath());
+			chromeArguments.push(`--user-data-dir=${userDataDir}`);
+		} else {
+			const parsedUserDataDir = chromeArguments[userDataDirIndex].split("=", 2)[1];
+			assert(typeof parsedUserDataDir === "string", "`--user-data-dir` is malformed");
+			userDataDir = parsedUserDataDir;
+		}
+		let chromeExecutable = executablePath$1;
+		if (!chromeExecutable) {
+			assert(channel || !this.puppeteer._isPuppeteerCore, `An \`executablePath\` or \`channel\` must be specified for \`puppeteer-core\``);
+			chromeExecutable = channel ? await this.executablePath(channel) : await this.resolveExecutablePath(options.headless ?? true);
+		}
+		return {
+			executablePath: chromeExecutable,
+			args: chromeArguments,
+			isTempUserDataDir,
+			userDataDir
+		};
+	}
+	/**
+	* @internal
+	*/
+	async cleanUserDataDir(path$1, opts) {
+		if (opts.isTemp) try {
+			await rm$1(path$1);
+		} catch (error) {
+			debugError?.(error);
+			throw error;
+		}
+	}
+	defaultArgs(options = {}) {
+		const userDisabledFeatures = getFeatures("--disable-features", options.args);
+		if (options.args && userDisabledFeatures.length > 0) removeMatchingFlags(options.args, "--disable-features");
+		const turnOnExperimentalFeaturesForTesting = process.env["PUPPETEER_TEST_EXPERIMENTAL_CHROME_FEATURES"] === "true";
+		const userEnabledFeatures = getFeatures("--enable-features", options.args);
+		if (options.args && userEnabledFeatures.length > 0) removeMatchingFlags(options.args, "--enable-features");
+		const enabledFeatures = ["PdfOopif", ...userEnabledFeatures].filter((feature) => {
+			return feature !== "";
+		});
+		const chromeArguments = [
+			"--allow-pre-commit-input",
+			"--disable-background-networking",
+			"--disable-background-timer-throttling",
+			"--disable-backgrounding-occluded-windows",
+			"--disable-breakpad",
+			"--disable-client-side-phishing-detection",
+			"--disable-component-extensions-with-background-pages",
+			"--disable-crash-reporter",
+			"--disable-default-apps",
+			"--disable-dev-shm-usage",
+			"--disable-hang-monitor",
+			"--disable-infobars",
+			"--disable-ipc-flooding-protection",
+			"--disable-popup-blocking",
+			"--disable-prompt-on-repost",
+			"--disable-renderer-backgrounding",
+			"--disable-search-engine-choice-screen",
+			"--disable-sync",
+			"--enable-automation",
+			"--export-tagged-pdf",
+			"--force-color-profile=srgb",
+			"--generate-pdf-document-outline",
+			"--metrics-recording-only",
+			"--no-first-run",
+			"--password-store=basic",
+			"--use-mock-keychain",
+			`--disable-features=${[
+				"Translate",
+				"AcceptCHFrame",
+				"MediaRouter",
+				"OptimizationHints",
+				"WebUIReloadButton",
+				...turnOnExperimentalFeaturesForTesting ? [] : ["ProcessPerSiteUpToMainFrameThreshold", "IsolateSandboxedIframes"],
+				...userDisabledFeatures
+			].filter((feature) => {
+				return feature !== "";
+			}).filter((disabledFeature) => {
+				return !enabledFeatures.includes(disabledFeature);
+			}).join(",")}`,
+			`--enable-features=${enabledFeatures.join(",")}`
+		].filter((arg) => {
+			return arg !== "";
+		});
+		const { devtools = false, headless = !devtools, args = [], userDataDir, enableExtensions = false } = options;
+		if (process.env["PUPPETEER_DANGEROUS_NO_SANDBOX"] === "true" && !args.includes("--no-sandbox")) chromeArguments.push("--no-sandbox");
+		if (userDataDir) chromeArguments.push(`--user-data-dir=${path.posix.isAbsolute(userDataDir) || path.win32.isAbsolute(userDataDir) ? userDataDir : path.resolve(userDataDir)}`);
+		if (devtools) chromeArguments.push("--auto-open-devtools-for-tabs");
+		if (headless) chromeArguments.push(headless === "shell" ? "--headless" : "--headless=new", "--hide-scrollbars", "--mute-audio");
+		if (!enableExtensions) chromeArguments.push("--disable-extensions");
+		if (args.every((arg) => {
+			return arg.startsWith("-");
+		})) chromeArguments.push("about:blank");
+		chromeArguments.push(...args);
+		return chromeArguments;
+	}
+	async executablePath(channel, validatePath = true) {
+		if (channel) return computeSystemExecutablePath({
+			browser: Browser$1.CHROME,
+			channel: convertPuppeteerChannelToBrowsersChannel(channel)
+		});
+		else return await this.resolveExecutablePath(void 0, validatePath);
+	}
+};
+/**
+* Extracts all features from the given command-line flag
+* (e.g. `--enable-features`, `--enable-features=`).
+*
+* Example input:
+* ["--enable-features=NetworkService,NetworkServiceInProcess", "--enable-features=Foo"]
+*
+* Example output:
+* ["NetworkService", "NetworkServiceInProcess", "Foo"]
+*
+* @internal
+*/
+function getFeatures(flag, options = []) {
+	const prefix = flag.endsWith("=") ? flag : `${flag}=`;
+	return options.filter((s) => {
+		return s.startsWith(prefix);
+	}).flatMap((s) => {
+		return s.substring(s.indexOf("=") + 1).trim().split(",").map((feature) => {
+			return feature.trim();
+		});
+	}).filter((s) => {
+		return s;
+	});
+}
+/**
+* Removes all elements in-place from the given string array
+* that match the given command-line flag.
+*
+* @internal
+*/
+function removeMatchingFlags(array, flag) {
+	const prefix = flag.endsWith("=") ? flag : `${flag}=`;
+	let i = 0;
+	while (i < array.length) if (array[i].startsWith(prefix)) array.splice(i, 1);
+	else i++;
+	return array;
+}
+
+//#endregion
+//#region node_modules/puppeteer-core/lib/puppeteer/node/FirefoxLauncher.js
+/**
+* @internal
+*/
+var FirefoxLauncher = class FirefoxLauncher extends BrowserLauncher {
+	constructor(puppeteer$1) {
+		super(puppeteer$1, "firefox");
+	}
+	static getPreferences(extraPrefsFirefox) {
+		return {
+			...extraPrefsFirefox,
+			"fission.webContentIsolationStrategy": 0
+		};
+	}
+	/**
+	* @internal
+	*/
+	async computeLaunchArguments(options = {}) {
+		const { ignoreDefaultArgs = false, args = [], executablePath: executablePath$1, pipe = false, extraPrefsFirefox = {}, debuggingPort = null } = options;
+		const firefoxArguments = [];
+		if (!ignoreDefaultArgs) firefoxArguments.push(...this.defaultArgs(options));
+		else if (Array.isArray(ignoreDefaultArgs)) firefoxArguments.push(...this.defaultArgs(options).filter((arg) => {
+			return !ignoreDefaultArgs.includes(arg);
+		}));
+		else firefoxArguments.push(...args);
+		if (!firefoxArguments.some((argument) => {
+			return argument.startsWith("--remote-debugging-");
+		})) {
+			if (pipe) assert(debuggingPort === null, "Browser should be launched with either pipe or debugging port - not both.");
+			firefoxArguments.push(`--remote-debugging-port=${debuggingPort || 0}`);
+		}
+		let userDataDir;
+		let isTempUserDataDir = true;
+		const profileArgIndex = firefoxArguments.findIndex((arg) => {
+			return ["-profile", "--profile"].includes(arg);
+		});
+		if (profileArgIndex !== -1) {
+			userDataDir = firefoxArguments[profileArgIndex + 1];
+			if (!userDataDir) throw new Error(`Missing value for profile command line argument`);
+			isTempUserDataDir = false;
+		} else {
+			userDataDir = await mkdtemp(await this.getProfilePath());
+			firefoxArguments.push("--profile");
+			firefoxArguments.push(userDataDir);
+		}
+		await createProfile(Browser$1.FIREFOX, {
+			path: userDataDir,
+			preferences: FirefoxLauncher.getPreferences(extraPrefsFirefox)
+		});
+		let firefoxExecutable;
+		if (this.puppeteer._isPuppeteerCore || executablePath$1) {
+			assert(executablePath$1, `An \`executablePath\` must be specified for \`puppeteer-core\``);
+			firefoxExecutable = executablePath$1;
+		} else firefoxExecutable = await this.executablePath(void 0);
+		return {
+			isTempUserDataDir,
+			userDataDir,
+			args: firefoxArguments,
+			executablePath: firefoxExecutable
+		};
+	}
+	/**
+	* @internal
+	*/
+	async cleanUserDataDir(userDataDir, opts) {
+		if (opts.isTemp) try {
+			await rm$1(userDataDir);
+		} catch (error) {
+			debugError?.(error);
+			throw error;
+		}
+		else try {
+			const backupSuffix = ".puppeteer";
+			const results = await Promise.allSettled(["prefs.js", "user.js"].map(async (file) => {
+				const prefsBackupPath = path.join(userDataDir, file + backupSuffix);
+				if (fs.existsSync(prefsBackupPath)) {
+					const prefsPath = path.join(userDataDir, file);
+					await unlink(prefsPath);
+					await rename(prefsBackupPath, prefsPath);
+				}
+			}));
+			for (const result of results) if (result.status === "rejected") throw result.reason;
+		} catch (error) {
+			debugError?.(error);
+		}
+	}
+	async executablePath(_, validatePath = true) {
+		return await this.resolveExecutablePath(void 0, validatePath);
+	}
+	defaultArgs(options = {}) {
+		const { devtools = false, headless = !devtools, args = [], userDataDir = null } = options;
+		const firefoxArguments = [];
+		switch (os.platform()) {
+			case "darwin":
+				firefoxArguments.push("--foreground");
+				break;
+			case "win32":
+				firefoxArguments.push("--wait-for-browser");
+				break;
+		}
+		if (userDataDir) {
+			firefoxArguments.push("--profile");
+			firefoxArguments.push(userDataDir);
+		}
+		if (headless) firefoxArguments.push("--headless");
+		if (devtools) firefoxArguments.push("--devtools");
+		if (args.every((arg) => {
+			return arg.startsWith("-");
+		})) firefoxArguments.push("about:blank");
+		firefoxArguments.push(...args);
+		return firefoxArguments;
+	}
+};
+
+//#endregion
+//#region node_modules/puppeteer-core/lib/puppeteer/node/PuppeteerNode.js
+/**
+* Extends the main {@link Puppeteer} class with Node specific behaviour for
+* fetching and downloading browsers.
+*
+* If you're using Puppeteer in a Node environment, this is the class you'll get
+* when you run `import puppeteer from 'puppeteer'`.
+*
+* @remarks
+* The most common method to use is {@link PuppeteerNode.launch | launch}, which
+* is used to launch and connect to a new browser instance.
+*
+* See {@link Puppeteer | the main Puppeteer class} for methods common to all
+* environments, such as {@link Puppeteer.connect}.
+*
+* @example
+* The following is a typical example of using Puppeteer to drive automation:
+*
+* ```ts
+* import puppeteer from 'puppeteer';
+*
+* const browser = await puppeteer.launch();
+* const page = await browser.newPage();
+* await page.goto('https://www.google.com');
+* // other actions...
+* await browser.close();
+* ```
+*
+* Once you have created a `page` you have access to a large API to interact
+* with the page, navigate, or find certain elements in that page.
+* The {@link Page | `page` documentation} lists all the available methods.
+*
+* @public
+*/
+var PuppeteerNode = class extends Puppeteer {
+	#launcher;
+	#lastLaunchedBrowser;
+	configuration;
+	/**
+	* @internal
+	*/
+	constructor(settings) {
+		const { configuration,...commonSettings } = settings;
+		super(commonSettings);
+		if (configuration) this.configuration = configuration;
+		else this.configuration = () => {
+			return Promise.resolve({});
+		};
+		this.connect = this.connect.bind(this);
+		this.launch = this.launch.bind(this);
+		this.executablePath = this.executablePath.bind(this);
+		this.defaultArgs = this.defaultArgs.bind(this);
+		this.trimCache = this.trimCache.bind(this);
+	}
+	/**
+	* This method attaches Puppeteer to an existing browser instance.
+	*
+	* @param options - Set of configurable options to set on the browser.
+	* @returns Promise which resolves to browser instance.
+	*/
+	connect(options) {
+		return super.connect(options);
+	}
+	/**
+	* Launches a browser instance with given arguments and options when
+	* specified.
+	*
+	* When using with `puppeteer-core`,
+	* {@link LaunchOptions.executablePath | options.executablePath} or
+	* {@link LaunchOptions.channel | options.channel} must be provided.
+	*
+	* @example
+	* You can use {@link LaunchOptions.ignoreDefaultArgs | options.ignoreDefaultArgs}
+	* to filter out `--mute-audio` from default arguments:
+	*
+	* ```ts
+	* const browser = await puppeteer.launch({
+	*   ignoreDefaultArgs: ['--mute-audio'],
+	* });
+	* ```
+	*
+	* @remarks
+	* Puppeteer can also be used to control the Chrome browser, but it works best
+	* with the version of Chrome for Testing downloaded by default.
+	* There is no guarantee it will work with any other version. If Google Chrome
+	* (rather than Chrome for Testing) is preferred, a
+	* {@link https://www.google.com/chrome/browser/canary.html | Chrome Canary}
+	* or
+	* {@link https://www.chromium.org/getting-involved/dev-channel | Dev Channel}
+	* build is suggested. See
+	* {@link https://www.howtogeek.com/202825/what%E2%80%99s-the-difference-between-chromium-and-chrome/ | this article}
+	* for a description of the differences between Chromium and Chrome.
+	* {@link https://chromium.googlesource.com/chromium/src/+/lkgr/docs/chromium_browser_vs_google_chrome.md | This article}
+	* describes some differences for Linux users. See
+	* {@link https://developer.chrome.com/blog/chrome-for-testing/ | this doc} for the description
+	* of Chrome for Testing.
+	*
+	* @param options - Options to configure launching behavior.
+	*/
+	async launch(options = {}) {
+		const { browser = await this.defaultBrowser() } = options;
+		this.#lastLaunchedBrowser = browser;
+		if (!["chrome", "firefox"].includes(browser)) throw new Error(`Unknown product: ${browser}`);
+		this.#launcher = this.#getLauncher(browser);
+		return await this.#launcher.launch(options);
+	}
+	/**
+	* @internal
+	*/
+	#getLauncher(browser) {
+		if (this.#launcher && this.#launcher.browser === browser) return this.#launcher;
+		switch (browser) {
+			case "chrome": return new ChromeLauncher(this);
+			case "firefox": return new FirefoxLauncher(this);
+			default: throw new Error(`Unknown product: ${browser}`);
+		}
+	}
+	async executablePath(optsOrChannel) {
+		if (optsOrChannel === void 0) return await this.#getLauncher(await this.lastLaunchedBrowser()).executablePath(void 0, false);
+		if (typeof optsOrChannel === "string") return await this.#getLauncher("chrome").executablePath(optsOrChannel, false);
+		return await this.#getLauncher(optsOrChannel.browser ?? await this.lastLaunchedBrowser()).resolveExecutablePath(optsOrChannel.headless, false);
+	}
+	/**
+	* @internal
+	*/
+	async browserVersion() {
+		const config = await this.configuration();
+		const lastLaunched = await this.lastLaunchedBrowser();
+		return config?.[lastLaunched]?.version ?? PUPPETEER_REVISIONS[lastLaunched];
+	}
+	/**
+	* The default download path for puppeteer. For puppeteer-core, this
+	* code should never be called as it is never defined.
+	*
+	* @internal
+	*/
+	async defaultDownloadPath() {
+		return (await this.configuration()).cacheDirectory;
+	}
+	/**
+	* The name of the browser that was last launched.
+	*/
+	async lastLaunchedBrowser() {
+		return this.#lastLaunchedBrowser ?? await this.defaultBrowser();
+	}
+	/**
+	* The name of the browser that will be launched by default. For
+	* `puppeteer`, this is influenced by your configuration. Otherwise, it's
+	* `chrome`.
+	*/
+	async defaultBrowser() {
+		return (await this.configuration()).defaultBrowser ?? "chrome";
+	}
+	/**
+	* @param options - Set of configurable options to set on the browser.
+	*
+	* @returns The default arguments that the browser will be launched with.
+	*/
+	async defaultArgs(options = {}) {
+		return this.#getLauncher(options.browser ?? await this.lastLaunchedBrowser()).defaultArgs(options);
+	}
+	/**
+	* Removes all non-current Firefox and Chrome binaries in the cache directory
+	* identified by the provided Puppeteer configuration. The current browser
+	* version is determined by resolving PUPPETEER_REVISIONS from Puppeteer
+	* unless `configuration.browserRevision` is provided.
+	*
+	* @remarks
+	*
+	* Note that the method does not check if any other Puppeteer versions
+	* installed on the host that use the same cache directory require the
+	* non-current binaries.
+	*
+	* @public
+	*/
+	async trimCache() {
+		const platform = detectBrowserPlatform();
+		if (!platform) throw new Error("The current platform is not supported.");
+		const config = await this.configuration();
+		const cacheDir = config.cacheDirectory;
+		const installedBrowsers = await getInstalledBrowsers({ cacheDir });
+		const puppeteerBrowsers = [{
+			product: "chrome",
+			browser: Browser$1.CHROME,
+			currentBuildId: ""
+		}, {
+			product: "firefox",
+			browser: Browser$1.FIREFOX,
+			currentBuildId: ""
+		}];
+		await Promise.all(puppeteerBrowsers.map(async (item) => {
+			const tag = config?.[item.product]?.version ?? PUPPETEER_REVISIONS[item.product];
+			item.currentBuildId = await resolveBuildId(item.browser, platform, tag);
+		}));
+		const currentBrowserBuilds = new Set(puppeteerBrowsers.map((browser) => {
+			return `${browser.browser}_${browser.currentBuildId}`;
+		}));
+		const currentBrowsers = new Set(puppeteerBrowsers.map((browser) => {
+			return browser.browser;
+		}));
+		for (const installedBrowser of installedBrowsers) {
+			if (!currentBrowsers.has(installedBrowser.browser)) continue;
+			if (currentBrowserBuilds.has(`${installedBrowser.browser}_${installedBrowser.buildId}`)) continue;
+			await uninstall({
+				browser: installedBrowser.browser,
+				platform,
+				cacheDir,
+				buildId: installedBrowser.buildId
+			});
+		}
+	}
+};
+
+//#endregion
+//#region node_modules/puppeteer-core/lib/puppeteer/node/ScreenRecorder.js
+/**
+* @license
+* Copyright 2023 Google Inc.
+* SPDX-License-Identifier: Apache-2.0
+*/
+var __runInitializers = void 0 && (void 0).__runInitializers || function(thisArg, initializers, value) {
+	var useValue = arguments.length > 2;
+	for (var i = 0; i < initializers.length; i++) value = useValue ? initializers[i].call(thisArg, value) : initializers[i].call(thisArg);
+	return useValue ? value : void 0;
+};
+var __esDecorate = void 0 && (void 0).__esDecorate || function(ctor, descriptorIn, decorators, contextIn, initializers, extraInitializers) {
+	function accept(f) {
+		if (f !== void 0 && typeof f !== "function") throw new TypeError("Function expected");
+		return f;
+	}
+	var kind = contextIn.kind, key = kind === "getter" ? "get" : kind === "setter" ? "set" : "value";
+	var target = !descriptorIn && ctor ? contextIn["static"] ? ctor : ctor.prototype : null;
+	var descriptor = descriptorIn || (target ? Object.getOwnPropertyDescriptor(target, contextIn.name) : {});
+	var _, done = false;
+	for (var i = decorators.length - 1; i >= 0; i--) {
+		var context = {};
+		for (var p in contextIn) context[p] = p === "access" ? {} : contextIn[p];
+		for (var p in contextIn.access) context.access[p] = contextIn.access[p];
+		context.addInitializer = function(f) {
+			if (done) throw new TypeError("Cannot add initializers after decoration has completed");
+			extraInitializers.push(accept(f || null));
+		};
+		var result = (0, decorators[i])(kind === "accessor" ? {
+			get: descriptor.get,
+			set: descriptor.set
+		} : descriptor[key], context);
+		if (kind === "accessor") {
+			if (result === void 0) continue;
+			if (result === null || typeof result !== "object") throw new TypeError("Object expected");
+			if (_ = accept(result.get)) descriptor.get = _;
+			if (_ = accept(result.set)) descriptor.set = _;
+			if (_ = accept(result.init)) initializers.unshift(_);
+		} else if (_ = accept(result)) if (kind === "field") initializers.unshift(_);
+		else descriptor[key] = _;
+	}
+	if (target) Object.defineProperty(target, contextIn.name, descriptor);
+	done = true;
+};
+var __setFunctionName = void 0 && (void 0).__setFunctionName || function(f, name, prefix) {
+	if (typeof name === "symbol") name = name.description ? "[".concat(name.description, "]") : "";
+	return Object.defineProperty(f, "name", {
+		configurable: true,
+		value: prefix ? "".concat(prefix, " ", name) : name
+	});
+};
+const CRF_VALUE = 30;
+const DEFAULT_FPS = 30;
+const debugFfmpeg = debug("puppeteer:ffmpeg");
+/**
+* Computes how many encoder frames to emit for a captured frame that spans
+* `[previousTimestamp, timestamp]`, so that the cumulative number of emitted
+* frames tracks a constant-`fps` grid anchored at `startTimestamp`.
+*
+* Counting each interval independently with
+* `Math.round(fps * (timestamp - previousTimestamp))` is wrong when frames are
+* captured faster than `fps`: every sub-`1/fps` interval still rounds up to a
+* whole frame, so the emitted frame count grows with the capture rate instead
+* of staying at `fps * duration`, which stretches playback (and, for very high
+* capture rates, the per-interval value rounds down to 0 and frames are
+* dropped). Differencing the rounded cumulative position keeps the total at
+* `Math.round(fps * (lastTimestamp - startTimestamp))`, independent of the
+* capture rate.
+*
+* Timestamps are in seconds (CDP `Page.screencastFrame` metadata timestamps).
+*
+* @internal
+*/
+function countFrames(startTimestamp, previousTimestamp, timestamp, fps) {
+	const end = Math.round((timestamp - startTimestamp) * fps);
+	const start = Math.round((previousTimestamp - startTimestamp) * fps);
+	return Math.max(0, end - start);
+}
+/**
+* @public
+*/
+let ScreenRecorder = (() => {
+	let _classSuper = PassThrough;
+	let _instanceExtraInitializers = [];
+	let _private_writeFrame_decorators;
+	let _private_writeFrame_descriptor;
+	let _stop_decorators;
+	return class ScreenRecorder$1 extends _classSuper {
+		static {
+			const _metadata = typeof Symbol === "function" && Symbol.metadata ? Object.create(_classSuper[Symbol.metadata] ?? null) : void 0;
+			__esDecorate(this, _private_writeFrame_descriptor = { value: __setFunctionName(async function(buffer) {
+				const error = await new Promise((resolve$1) => {
+					this.#process.stdin.write(buffer, resolve$1);
+				});
+				if (error) console.log(`ffmpeg failed to write: ${error.message}.`);
+			}, "#writeFrame") }, _private_writeFrame_decorators, {
+				kind: "method",
+				name: "#writeFrame",
+				static: false,
+				private: true,
+				access: {
+					has: (obj) => #writeFrame in obj,
+					get: (obj) => obj.#writeFrame
+				},
+				metadata: _metadata
+			}, null, _instanceExtraInitializers);
+			__esDecorate(this, null, _stop_decorators, {
+				kind: "method",
+				name: "stop",
+				static: false,
+				private: false,
+				access: {
+					has: (obj) => "stop" in obj,
+					get: (obj) => obj.stop
+				},
+				metadata: _metadata
+			}, null, _instanceExtraInitializers);
+			if (_metadata) Object.defineProperty(this, Symbol.metadata, {
+				enumerable: true,
+				configurable: true,
+				writable: true,
+				value: _metadata
+			});
+		}
+		#page = __runInitializers(this, _instanceExtraInitializers);
+		#process;
+		#controller = new AbortController();
+		#lastFrame;
+		#fps;
+		/**
+		* @internal
+		*/
+		constructor(page, width, height, { ffmpegPath, speed, scale, crop, format, fps, loop, delay, quality, colors, path: path$1, overwrite } = {}) {
+			super({ allowHalfOpen: false });
+			ffmpegPath ??= "ffmpeg";
+			format ??= "webm";
+			fps ??= DEFAULT_FPS;
+			loop ||= -1;
+			delay ??= -1;
+			quality ??= CRF_VALUE;
+			colors ??= 256;
+			overwrite ??= true;
+			this.#fps = fps;
+			const { error } = spawnSync(ffmpegPath);
+			if (error) throw error;
+			const filters = [`crop='min(${width},iw):min(${height},ih):0:0'`, `pad=${width}:${height}:0:0`];
+			if (speed) filters.push(`setpts=${1 / speed}*PTS`);
+			if (crop) filters.push(`crop=${crop.width}:${crop.height}:${crop.x}:${crop.y}`);
+			if (scale) filters.push(`scale=iw*${scale}:-1:flags=lanczos`);
+			const formatArgs = this.#getFormatArgs(format, fps, loop, delay, quality, colors);
+			const vf = formatArgs.indexOf("-vf");
+			if (vf !== -1) filters.push(formatArgs.splice(vf, 2).at(-1) ?? "");
+			if (path$1) fs.mkdirSync(dirname(path$1), { recursive: overwrite });
+			this.#process = spawn(ffmpegPath, [
+				["-loglevel", "error"],
+				["-avioflags", "direct"],
+				[
+					"-fpsprobesize",
+					"0",
+					"-probesize",
+					"32",
+					"-analyzeduration",
+					"0",
+					"-fflags",
+					"nobuffer"
+				],
+				[
+					"-framerate",
+					`${fps}`,
+					"-f",
+					"image2pipe",
+					"-vcodec",
+					"png",
+					"-i",
+					"pipe:0"
+				],
+				["-an"],
+				["-threads", "1"],
+				["-b:v", "0"],
+				formatArgs,
+				["-vf", filters.join()],
+				[overwrite ? "-y" : "-n"],
+				"pipe:1"
+			].flat(), { stdio: [
+				"pipe",
+				"pipe",
+				"pipe"
+			] });
+			this.#process.stdout.pipe(this);
+			this.#process.stderr.on("data", (data) => {
+				debugFfmpeg?.(data.toString("utf8"));
+			});
+			this.#page = page;
+			const { client } = this.#page.mainFrame();
+			client.once(CDPSessionEvent.Disconnected, () => {
+				this.stop().catch(debugCatchError);
+			});
+			let startTimestamp;
+			this.#lastFrame = lastValueFrom(fromEmitterEvent(client, "Page.screencastFrame").pipe(tap((event) => {
+				client.send("Page.screencastFrameAck", { sessionId: event.sessionId });
+			}), filter((event) => {
+				return event.metadata.timestamp !== void 0;
+			}), map((event) => {
+				return {
+					buffer: Buffer.from(event.data, "base64"),
+					timestamp: event.metadata.timestamp
+				};
+			}), bufferCount(2, 1), concatMap(([{ timestamp: previousTimestamp, buffer }, { timestamp }]) => {
+				startTimestamp ??= previousTimestamp;
+				return from(Array(countFrames(startTimestamp, previousTimestamp, timestamp, fps)).fill(buffer));
+			}), map((buffer) => {
+				this.#writeFrame(buffer);
+				return [buffer, performance.now()];
+			}), takeUntil(fromEvent(this.#controller.signal, "abort"))), { defaultValue: [Buffer.from([]), performance.now()] });
+		}
+		#getFormatArgs(format, fps, loop, delay, quality, colors) {
+			const libvpx = [
+				["-vcodec", "vp9"],
+				["-crf", `${quality}`],
+				[
+					"-deadline",
+					"realtime",
+					"-cpu-used",
+					`${Math.min(os.cpus().length / 2, 8)}`
+				]
+			];
+			switch (format) {
+				case "webm": return [...libvpx, ["-f", "webm"]].flat();
+				case "gif":
+					fps = DEFAULT_FPS === fps ? 20 : "source_fps";
+					if (loop === Infinity) loop = 0;
+					if (delay !== -1) delay /= 10;
+					return [
+						["-vf", `fps=${fps},split[s0][s1];[s0]palettegen=stats_mode=diff:max_colors=${colors}[p];[s1][p]paletteuse=dither=bayer`],
+						["-loop", `${loop}`],
+						["-final_delay", `${delay}`],
+						["-f", "gif"]
+					].flat();
+				case "mp4": return [
+					...libvpx,
+					["-movflags", "hybrid_fragmented"],
+					["-f", "mp4"]
+				].flat();
+			}
+		}
+		get #writeFrame() {
+			return _private_writeFrame_descriptor.value;
+		}
+		/**
+		* Stops the recorder.
+		*
+		* @public
+		*/
+		async stop() {
+			if (this.#controller.signal.aborted) return;
+			await this.#page._stopScreencast().catch(debugCatchError);
+			this.#controller.abort();
+			const [buffer, timestamp] = await this.#lastFrame;
+			await Promise.all(Array(Math.max(1, Math.round(this.#fps * (performance.now() - timestamp) / 1e3))).fill(buffer).map(this.#writeFrame.bind(this)));
+			this.#process.stdin.end();
+			await new Promise((resolve$1) => {
+				this.#process.once("close", resolve$1);
+			});
+		}
+		/**
+		* @internal
+		*/
+		async [(_private_writeFrame_decorators = [guarded()], _stop_decorators = [guarded()], asyncDisposeSymbol)]() {
+			await this.stop();
+			await super[asyncDisposeSymbol]();
+		}
+	};
+})();
+
+//#endregion
+//#region node_modules/puppeteer-core/lib/puppeteer/puppeteer-core.js
+environment.value.ScreenRecorder = ScreenRecorder;
+/**
+* @public
+*/
+const puppeteer = new PuppeteerNode({ isPuppeteerCore: true });
+const { connect, defaultArgs, executablePath, launch } = puppeteer;
+var puppeteer_core_default = puppeteer;
+
+//#endregion
+export { ARIAQueryHandler, Accessibility, AsyncDisposableStack, AsyncDisposableStackPolyfill, AsyncIterableUtil, Binding, Browser, BrowserContext, BrowserLauncher, BrowserWebSocketTransport, CDPSession, CDPSessionEvent, CDP_BINDING_PREFIX, CSSCoverage, Callback, CallbackRegistry, CdpBluetoothEmulation, CdpBrowser, CdpBrowserContext, CdpCDPSession, CdpDeviceRequestPrompt, CdpDeviceRequestPromptManager, CdpDialog, CdpElementHandle, CdpFrame, CdpHTTPRequest, CdpHTTPResponse, CdpJSHandle, CdpKeyboard, CdpMouse, CdpPage, CdpPreloadScript, CdpTarget, CdpTouchHandle, CdpTouchscreen, CdpWebWorker, ChromeLauncher, Connection, ConnectionClosedError, ConsoleMessage, Coverage, CustomQueryHandlerRegistry, DEFAULT_INTERCEPT_RESOLUTION_PRIORITY, DEFAULT_VIEWPORT, Deferred, DelegatedLocator, DevToolsTarget, DeviceRequestPrompt, Dialog, DisposableStack, DisposableStackPolyfill, ElementHandle, EmulatedState, EmulationManager, EventEmitter, ExecutionContext, Extension, ExtensionTransport, FileChooser, FilteredLocator, FirefoxLauncher, Frame, FrameEvent, FrameManager, FrameManagerEvent, FrameTree, FunctionLocator, HTTPRequest, HTTPResponse, InitializationStatus, InterceptResolutionAction, IsolatedWorld, JSCoverage, JSHandle, Keyboard, KnownDevices, LazyArg, LifecycleWatcher, Locator, LocatorEvent, MAIN_WORLD, MappedLocator, Mouse, MouseButton, Mutex, NETWORK_IDLE_TIME, NetworkEventManager, NetworkManager, NetworkManagerEvent, NodeLocator, OtherTarget, PQueryHandler, PUPPETEER_REVISIONS, PUPPETEER_WORLD, Page, PageTarget, PierceQueryHandler, PipeTransport, PredefinedNetworkConditions, ProtocolError, Puppeteer, PuppeteerError, PuppeteerNode, PuppeteerURL, QueryHandler, RETRY_DELAY, RaceLocator, Realm, SOURCE_URL_REGEX, STATUS_TEXTS, ScreenRecorder, ScriptInjector, SecurityDetails, SuppressedError, Target, TargetCloseError, TargetManager, TargetType, TaskManager, TaskQueue, TextQueryHandler, TimeoutError, TimeoutSettings, TouchError, Touchscreen, Tracing, UTILITY_WORLD_NAME, UnsupportedOperation, WEB_PERMISSION_TO_PROTOCOL_PERMISSION, WaitTask, WebMCP, WebMCPTool, WebMCPToolCall, WebWorker, WebWorkerEvent, WorkerTarget, XPathQueryHandler, _connectToCdpBrowser, _keyDefinitions, addPageBinding, assert, asyncDisposeSymbol, bindIsolatedHandle, connect, convertConsoleMessageLevel, convertCookiesPartitionKeyFromPuppeteerToCdp, convertSameSiteFromPuppeteerToCdp, countFrames, createClientError, createConsoleMessage, createEvaluationError, createIncrementalIdGenerator, createProtocolErrorMessage, customQueryHandlers, debug, debugCatchError, debugError, puppeteer_core_default as default, defaultArgs, disposeSymbol, evaluationString, executablePath, filterAsync, fromAbortSignal, fromEmitterEvent, getBrowserTypeDisplayName, getCapturedLogs, getFeatures, getQueryHandlerAndSelector, getReadableAsTypedArray, getReadableFromProtocolStream, getSourcePuppeteerURLIfAvailable, getSourceUrlComment, handleError, headersArray, isDate, isErrnoException, isErrorLike, isNumber, isPlainObject, isRegExp, isString, isTargetClosedError, launch, normalizeHeaderValue, pageBindingInitString, paperFormats, parsePDFOptions, parsePSelectors, referrerPolicyToProtocol, releaseObject, removeMatchingFlags, rewriteError, scriptInjector, setDefaultScreenshotOptions, setLogCapture, supportedMetrics, throwIfDetached, timeout, transposeIterableHandle, unitToPixels, validateDialogType, valueFromJSHandle, valueFromPrimitiveRemoteObject, valueFromRemoteObjectReference, withSourcePuppeteerURLIfNone };