single-file-cli 2.0.77 → 2.0.79

package/lib/cdp-client.js

@@ -1,5 +1,5 @@
 /*
- * Copyright 2010-2024 Gildas Lormeau
+ * Copyright 2010-2025 Gildas Lormeau
  * contact : gildas.lormeau <at> gmail.com
  * 
  * This file is part of SingleFile.
@@ -21,506 +21,379 @@
  *   Source.
  */
 
-/* global setTimeout, clearTimeout, URL, fetch, AbortController, window, top, singlefile, btoa, Headers, Deno */
+/* global setTimeout, clearTimeout, URL, AbortController */
 
-import { launchBrowser, closeBrowser } from "./browser.js";
+import {
+	launchBrowser,
+	closeBrowser
+} from "./browser.js";
+import {
+	CDP,
+	options
+} from "simple-cdp";
 import {
 	FETCH_FUNCTION_NAME,
 	RESOLVE_FETCH_FUNCTION_NAME,
 	REJECT_FETCH_FUNCTION_NAME,
 	getScriptSource,
-	getHookScriptSource
+	getHookScriptSource,
+	getPageDataScriptSource
 } from "./single-file-script.js";
-import { CDP, options } from "simple-cdp";
+import {
+	fetch,
+	waitForTimeout,
+	arrayBufferToBase64,
+	getAlternativeUrl
+} from "./cdp-client-util.js";
 
 const LOAD_TIMEOUT_ERROR = "ERR_LOAD_TIMEOUT";
 const CAPTURE_TIMEOUT_ERROR = "ERR_CAPTURE_TIMEOUT";
 const NETWORK_STATES = ["InteractiveTime", "networkIdle", "networkAlmostIdle", "load", "DOMContentLoaded"];
 const MINIMIZED_WINDOW_STATE = "minimized";
 const SINGLE_FILE_WORLD_NAME = "singlefile";
-const EMPTY_PAGE_URL = "about:blank";
 const CAPTURE_SCREENSHOT_FUNCTION_NAME = "captureScreenshot";
 const PRINT_TO_PDF_FUNCTION_NAME = "printToPDF";
 const SET_SCREENSHOT_FUNCTION_NAME = "setScreenshot";
 const SET_PDF_FUNCTION_NAME = "setPDF";
 const SET_PAGE_DATA_FUNCTION_NAME = "setPageData";
-const REDIRECT_STATUS_CODES = [301, 302, 303, 307, 308];
-
-export { initialize, getPageData, closeBrowser };
+const BINDING_CALLED_EVENT_TYPE = "bindingCalled";
 
-async function fetchWithFileSupport(url, fetchOptions = {}) {
-	if (url.startsWith("file://")) {
-		const filePath = decodeURIComponent(url.replace(/^file:\/\//, ""));
-		let fileData;
-		if (typeof Deno !== "undefined") {
-			const response = await fetch(url, fetchOptions);
-			return response;
-		} else {
-			const { readFile } = await import("node:fs/promises");
-			try {
-				fileData = await readFile(filePath);
-				return {
-					status: 200,
-					headers: new Headers({
-						"content-type": "application/octet-stream",
-						"content-length": fileData.length.toString()
-					}),
-					arrayBuffer: async () => fileData.buffer
-				};
-			} catch {
-				return {
-					status: 404,
-					headers: new Headers({
-						"content-type": "text/plain",
-						"content-length": "0"
-					}),
-					arrayBuffer: async () => new ArrayBuffer(0)
-				};
-			}
-		}
-	} else {
-		return await fetch(url, fetchOptions);
-	}
-}
+export {
+	initialize,
+	getPageData,
+	closeBrowser
+};
 
 async function initialize(singleFileOptions) {
 	if (singleFileOptions.browserServer) {
 		options.apiUrl = singleFileOptions.browserServer;
 	} else {
-		options.apiUrl = "http://localhost:" + (await launchBrowser(getBrowserOptions(singleFileOptions)));
+		const LOCALHOST = "http://localhost:";
+		const browserOptions = {};
+		browserOptions.args = singleFileOptions.browserArgs;
+		browserOptions.headless = singleFileOptions.browserHeadless;
+		browserOptions.executablePath = singleFileOptions.browserExecutablePath;
+		browserOptions.debug = singleFileOptions.browserDebug;
+		browserOptions.disableWebSecurity = singleFileOptions.browserDisableWebSecurity;
+		browserOptions.width = singleFileOptions.browserWidth;
+		browserOptions.height = singleFileOptions.browserHeight;
+		browserOptions.userAgent = singleFileOptions.userAgent;
+		browserOptions.httpProxyServer = singleFileOptions.httpProxyServer;
+		options.apiUrl = LOCALHOST + (await launchBrowser(browserOptions));
 	}
 }
 
 async function getPageData(options) {
-	const debugMessages = [];
-	const consoleMessages = [];
+	const EMPTY_PAGE_URL = "about:blank";
+	const pageContext = { options, consoleMessages: [], debugMessages: [], httpInfo: {} };
 	let targetInfo;
 	try {
-		if (options.debugMessagesFile) {
-			debugMessages.push([Date.now(), ["Loading page", EMPTY_PAGE_URL]]);
-		}
+		logData(["Loading page", EMPTY_PAGE_URL], pageContext);
 		targetInfo = await CDP.createTarget(EMPTY_PAGE_URL);
-		const { Browser, Security, Page, Emulation, Fetch, Network, Runtime, Debugger, Console } = new CDP(targetInfo);
-		if (options.consoleMessagesFile) {
-			if (options.debugMessagesFile) {
-				debugMessages.push([Date.now(), ["Enabling console messages"]]);
-			}
-			await Console.enable();
-			Console.addEventListener("messageAdded", ({ params }) => {
-				const { message } = params;
-				consoleMessages.push(message);
-			});
-		}
-		if (options.browserStartMinimized) {
-			const { windowId, bounds } = await Browser.getWindowForTarget({ targetId: targetInfo.id });
-			if (bounds.windowState !== MINIMIZED_WINDOW_STATE) {
-				if (options.debugMessagesFile) {
-					debugMessages.push([Date.now(), ["Minimizing window"]]);
-				}
-				await Browser.setWindowBounds({ windowId, bounds: { windowState: MINIMIZED_WINDOW_STATE } });
-			}
-		}
-		if (options.browserIgnoreHTTPSErrors !== undefined && options.browserIgnoreHTTPSErrors) {
-			if (options.debugMessagesFile) {
-				debugMessages.push([Date.now(), ["Ignoring HTTPS errors"]]);
-			}
-			await Security.setIgnoreCertificateErrors({ ignore: true });
-		}
-		if (options.browserMobileEmulation || options.browserDeviceWidth || options.browserDeviceHeight || options.browserDeviceScaleFactor || options.platform || options.acceptLanguage) {
-			if (options.browserMobileEmulation || options.browserDeviceWidth || options.browserDeviceHeight || options.browserDeviceScaleFactor) {
-				let browserDeviceWidth;
-				if (!options.browserDeviceWidth) {
-					const { result } = await Runtime.evaluate({ expression: "window.innerWidth" });
-					browserDeviceWidth = result.value;
-				}
-				let browserDeviceHeight;
-				if (!options.browserDeviceHeight) {
-					const { result } = await Runtime.evaluate({ expression: "window.innerHeight" });
-					browserDeviceHeight = result.value;
-				}
-				let browserDeviceScaleFactor;
-				if (!options.browserDeviceScaleFactor) {
-					const { result } = await Runtime.evaluate({ expression: "window.devicePixelRatio" });
-					browserDeviceScaleFactor = result.value;
-				}
-				const deviceMetricsOptions = {
-					mobile: Boolean(options.browserMobileEmulation),
-					width: options.browserDeviceWidth || (options.browserMobileEmulation ? 360 : options.width || browserDeviceWidth),
-					height: options.browserDeviceHeight || (options.browserMobileEmulation ? 800 : options.height || browserDeviceHeight),
-					deviceScaleFactor: options.browserDeviceScaleFactor || (options.browserMobileEmulation ? 2 : browserDeviceScaleFactor)
-				};
-				if (options.debugMessagesFile) {
-					debugMessages.push([Date.now(), ["Emulating device metrics", JSON.stringify(deviceMetricsOptions)]]);
-				}
-				await Emulation.setDeviceMetricsOverride(deviceMetricsOptions);
-			}
-			if (options.browserMobileEmulation || options.platform || options.acceptLanguage) {
-				const { userAgent, product } = await Browser.getVersion();
-				const agentOptions = {
-					userAgent: options.userAgent || (options.browserMobileEmulation ? "Mozilla/5.0 (Linux; Android 10; K) AppleWebKit/537.36 (KHTML, like Gecko) " + product + " Mobile Safari/537.36" : userAgent)
-				};
-				if (options.acceptLanguage) {
-					agentOptions.acceptLanguage = options.acceptLanguage;
-				}
-				if (options.platform || options.browserMobileEmulation) {
-					agentOptions.platform = options.platform || "Android";
-				}
-				if (options.debugMessagesFile) {
-					debugMessages.push([Date.now(), ["Emulating user agent", JSON.stringify(agentOptions)]]);
-				}
-				await Emulation.setUserAgentOverride(agentOptions);
-			}
+		const cdp = new CDP(targetInfo);
+		await setupConsoleLogging(cdp, pageContext);
+		await setupBrowserWindow(cdp, targetInfo.id, pageContext);
+		await setupSecurity(cdp, pageContext);
+		await setupDeviceEmulation(cdp, pageContext);
+		await setupNetworkInterception(cdp, pageContext);
+		await setupScriptInjection(cdp, pageContext);
+		const contextId = await getContextId(cdp, pageContext);
+		const pageDataPromise = setupPageDataCapture(cdp, contextId, pageContext);
+		await setupBindings(cdp, contextId, pageContext);
+		await capturePageData(cdp, contextId, pageContext);
+		await disableCdpDomains(cdp, pageContext);
+		return await finalizePageData(pageDataPromise, pageContext);
+	} catch (error) {
+		if (shouldRetryWithFallback(error)) {
+			return await retryWithFallback();
 		}
-		const handleAuthRequests = Boolean(options.httpProxyUsername);
-		const patterns = handleAuthRequests ? [{ requestStage: "Request" }, { requestStage: "Response" }] : [{ requestStage: "Response" }];
-		await Fetch.enable({ handleAuthRequests, patterns });
-		if (handleAuthRequests) {
-			Fetch.addEventListener("authRequired", async ({ params }) => {
-				if (options.debugMessagesFile) {
-					debugMessages.push([Date.now(), ["Authenticating"]]);
-				}
-				await Fetch.continueWithAuth({
-					requestId: params.requestId,
-					authChallengeResponse: {
-						response: "ProvideCredentials",
-						username: options.httpProxyUsername,
-						password: options.httpProxyPassword
-					}
-				});
-			});
+		attachDebugInfo(error, pageContext);
+		throw error;
+	} finally {
+		logData(["Closing page"], pageContext);
+		await closeTarget();
+		logData(["Finishing"], pageContext);
+	}
+
+	function shouldRetryWithFallback(error) {
+		return error.code === LOAD_TIMEOUT_ERROR &&
+			options.browserWaitUntilFallback &&
+			options.browserWaitUntil &&
+			NETWORK_STATES.indexOf(options.browserWaitUntil) < NETWORK_STATES.length - 1;
+	}
+
+	async function retryWithFallback() {
+		const browserWaitUntil = NETWORK_STATES[(NETWORK_STATES.indexOf(options.browserWaitUntil) + 1)];
+		logData(["Retrying with waitUntil", browserWaitUntil], pageContext);
+		options.browserWaitUntil = browserWaitUntil;
+		await closeTarget();
+		return await getPageData(options);
+	}
+
+	async function closeTarget() {
+		if (targetInfo && !options.browserDebug) {
+			await CDP.closeTarget(targetInfo.id);
+			targetInfo = null;
 		}
-		let url = options.url;
-		let alternativeUrl = new URL(url);
-		if (!alternativeUrl.pathname.endsWith("/")) {
-			alternativeUrl.pathname = alternativeUrl.pathname + "/";
+	}
+}
+
+async function setupConsoleLogging({ Console }, { options, consoleMessages, debugMessages }) {
+	const CONSOLE_MESSAGE_ADDED_EVENT_TYPE = "messageAdded";
+	if (options.consoleMessagesFile) {
+		logData(["Enabling console messages"], { options, debugMessages });
+		await Console.enable();
+		Console.addEventListener(CONSOLE_MESSAGE_ADDED_EVENT_TYPE, ({ params }) => {
+			consoleMessages.push(params.message);
+		});
+	}
+}
+
+async function setupBrowserWindow({ Browser }, targetId, { options, debugMessages }) {
+	if (options.browserStartMinimized) {
+		const { windowId, bounds } = await Browser.getWindowForTarget({ targetId });
+		if (bounds.windowState !== MINIMIZED_WINDOW_STATE) {
+			logData(["Minimizing window"], { options, debugMessages });
+			await Browser.setWindowBounds({ windowId, bounds: { windowState: MINIMIZED_WINDOW_STATE } });
 		}
-		alternativeUrl = alternativeUrl.href;
-		let httpInfo;
-		Fetch.addEventListener("requestPaused", async ({ params }) => {
-			const { requestId, request, resourceType, responseHeaders, responseStatusCode, responseStatusText } = params;
-			if (resourceType == "Document" && (options.outputJson && !httpInfo && (request.url == url || request.url == alternativeUrl) && responseStatusCode !== undefined)) {
-				if (REDIRECT_STATUS_CODES.includes(responseStatusCode)) {
-					const redirect = responseHeaders.find(header => header.name.toLowerCase() == "location").value;
-					if (redirect) {
-						url = new URL(redirect, url).href;
-					}
-					if (options.debugMessagesFile) {
-						debugMessages.push([Date.now(), ["Redirecting", url]]);
-					}
-				} else {
-					httpInfo = {
-						request: {
-							url: request.url,
-							method: request.method,
-							headers: request.headers,
-							referrerPolicy: request.referrerPolicy
-						},
-						resourceType,
-						response: {
-							status: responseStatusCode,
-							statusText: responseStatusText,
-							headers: responseHeaders
-						}
-					};
-				}
-			} else if (options.blockedURLPatterns && options.blockedURLPatterns.length) {
-				const blockedURL = options.blockedURLPatterns.find(blockedURL => new RegExp(blockedURL).test(request.url));
-				if (blockedURL) {
-					try {
-						if (options.debugMessagesFile) {
-							debugMessages.push([Date.now(), ["Blocking request", request.url]]);
-						}
-						await Fetch.failRequest({ requestId, errorReason: "Aborted" });
-					} catch {
-						// ignored
-					}
-				}
+	}
+}
+
+async function setupSecurity({ Security }, { options, debugMessages }) {
+	if (options.browserIgnoreHTTPSErrors !== undefined && options.browserIgnoreHTTPSErrors) {
+		logData(["Ignoring HTTPS errors"], { options, debugMessages });
+		await Security.setIgnoreCertificateErrors({ ignore: true });
+	}
+}
+
+async function setupDeviceEmulation({ Browser, Emulation, Runtime }, { options, debugMessages }) {
+	const needsDeviceMetrics = options.browserMobileEmulation || options.browserDeviceWidth ||
+		options.browserDeviceHeight || options.browserDeviceScaleFactor;
+	const needsUserAgent = options.browserMobileEmulation || options.platform || options.acceptLanguage;
+	if (needsDeviceMetrics) {
+		await setupDeviceMetrics({ Emulation, Runtime }, { options, debugMessages });
+	}
+	if (needsUserAgent) {
+		await setupUserAgent({ Browser, Emulation }, { options, debugMessages });
+	}
+}
+
+async function setupDeviceMetrics({ Emulation, Runtime }, { options, debugMessages }) {
+	const INNER_WIDTH_PROPERTY = "window.innerWidth";
+	const INNER_HEIGHT_PROPERTY = "window.innerHeight";
+	const DEVICE_PIXEL_RATIO_PROPERTY = "window.devicePixelRatio";
+	const browserDeviceWidth = options.browserDeviceWidth ||
+		(await Runtime.evaluate({ expression: INNER_WIDTH_PROPERTY })).result.value;
+	const browserDeviceHeight = options.browserDeviceHeight ||
+		(await Runtime.evaluate({ expression: INNER_HEIGHT_PROPERTY })).result.value;
+	const browserDeviceScaleFactor = options.browserDeviceScaleFactor ||
+		(await Runtime.evaluate({ expression: DEVICE_PIXEL_RATIO_PROPERTY })).result.value;
+	const deviceMetricsOptions = {
+		mobile: Boolean(options.browserMobileEmulation),
+		width: options.browserDeviceWidth || (options.browserMobileEmulation ? 360 : options.width || browserDeviceWidth),
+		height: options.browserDeviceHeight || (options.browserMobileEmulation ? 800 : options.height || browserDeviceHeight),
+		deviceScaleFactor: options.browserDeviceScaleFactor || (options.browserMobileEmulation ? 2 : browserDeviceScaleFactor)
+	};
+	logData(["Emulating device metrics", JSON.stringify(deviceMetricsOptions)], { options, debugMessages });
+	await Emulation.setDeviceMetricsOverride(deviceMetricsOptions);
+}
+
+async function setupUserAgent({ Browser, Emulation }, { options, debugMessages }) {
+	const ANDROID_PLATFORM = "Android";
+	const { userAgent, product } = await Browser.getVersion();
+	const defaultMobileUA = `Mozilla/5.0 (Linux; Android 10; K) AppleWebKit/537.36 (KHTML, like Gecko) ${product} Mobile Safari/537.36`;
+	const agentOptions = {
+		userAgent: options.userAgent || (options.browserMobileEmulation ? defaultMobileUA : userAgent)
+	};
+	if (options.acceptLanguage) {
+		agentOptions.acceptLanguage = options.acceptLanguage;
+	}
+	if (options.platform || options.browserMobileEmulation) {
+		agentOptions.platform = options.platform || ANDROID_PLATFORM;
+	}
+	logData(["Emulating user agent", JSON.stringify(agentOptions)], { options, debugMessages });
+	await Emulation.setUserAgentOverride(agentOptions);
+}
+
+async function setupNetworkInterception({ Browser, Emulation, Fetch, Network }, { options, debugMessages, httpInfo }) {
+	const REQUEST_STAGE = "Request";
+	const RESPONSE_STAGE = "Response";
+	const DENY_BEHAVIOR = "deny";
+	const handleAuthRequests = Boolean(options.httpProxyUsername);
+	const patterns = handleAuthRequests ?
+		[{ requestStage: REQUEST_STAGE }, { requestStage: RESPONSE_STAGE }] :
+		[{ requestStage: RESPONSE_STAGE }];
+	await Fetch.enable({ handleAuthRequests, patterns });
+	if (handleAuthRequests) {
+		setupProxyAuth({ Fetch }, { options, debugMessages });
+	}
+	setupRequestInterception({ Fetch }, { options, debugMessages, httpInfo });
+	if (options.httpHeaders) {
+		await setupHttpHeaders({ Network }, { options, debugMessages });
+	}
+	if (options.emulateMediaFeatures) {
+		await setupMediaFeatures({ Emulation }, { options, debugMessages });
+	}
+	if (options.browserCookies && options.browserCookies.length) {
+		await setupCookies({ Network }, { options, debugMessages });
+	}
+	await Browser.setDownloadBehavior({ behavior: DENY_BEHAVIOR });
+}
+
+function setupProxyAuth({ Fetch }, { options, debugMessages }) {
+	const AUTH_REQUIRED_EVENT_TYPE = "authRequired";
+	const PROVIDE_CREDENTIALS_RESPONSE = "ProvideCredentials";
+	Fetch.addEventListener(AUTH_REQUIRED_EVENT_TYPE, async ({ params }) => {
+		logData(["Authenticating"], { options, debugMessages });
+		await Fetch.continueWithAuth({
+			requestId: params.requestId,
+			authChallengeResponse: {
+				response: PROVIDE_CREDENTIALS_RESPONSE,
+				username: options.httpProxyUsername,
+				password: options.httpProxyPassword
 			}
+		});
+	});
+}
+
+function setupRequestInterception({ Fetch }, { options, debugMessages, httpInfo }) {
+	const REQUEST_PAUSED_EVENT_TYPE = "requestPaused";
+	const ABORTED_ERROR_REASON = "Aborted";
+	const urlState = { url: options.url, alternativeUrl: getAlternativeUrl(options.url) };
+	Fetch.addEventListener(REQUEST_PAUSED_EVENT_TYPE, async ({ params }) => {
+		const { requestId, request } = params;
+		captureHttpInfo(params, urlState, { options, debugMessages, httpInfo });
+		if (shouldBlockRequest(request.url)) {
 			try {
-				await Fetch.continueRequest({ requestId });
+				await Fetch.failRequest({ requestId, errorReason: ABORTED_ERROR_REASON });
+				return;
 			} catch {
 				// ignored
 			}
-		});
-		if (options.httpHeaders) {
-			if (options.debugMessagesFile) {
-				debugMessages.push([Date.now(), ["Setting HTTP headers", JSON.stringify(options.httpHeaders)]]);
-			}
-			await Network.enable();
-			await Network.setExtraHTTPHeaders({ headers: options.httpHeaders });
-		}
-		if (options.emulateMediaFeatures) {
-			for (const mediaFeature of options.emulateMediaFeatures) {
-				if (options.debugMessagesFile) {
-					debugMessages.push([Date.now(), ["Emulating media feature", mediaFeature.name, mediaFeature.value]]);
-				}
-				await Emulation.setEmulatedMedia({
-					media: mediaFeature.name,
-					features: mediaFeature.value.split(",").map(feature => feature.trim())
-				});
-			}
 		}
-		if (options.browserCookies && options.browserCookies.length) {
-			if (options.debugMessagesFile) {
-				debugMessages.push([Date.now(), ["Setting cookies", JSON.stringify(options.browserCookies)]]);
-			}
-			await Network.setCookies({ cookies: options.browserCookies });
+		try {
+			await Fetch.continueRequest({ requestId });
+		} catch {
+			// ignored
 		}
-		await Browser.setDownloadBehavior({ behavior: "deny" });
-		await Page.addScriptToEvaluateOnNewDocument({
-			source: getHookScriptSource(),
-			runImmediately: true
-		});
-		await Page.addScriptToEvaluateOnNewDocument({
-			source: await getScriptSource(options),
-			runImmediately: true,
-			worldName: SINGLE_FILE_WORLD_NAME
-		});
-		const [contextId] = await Promise.all([
-			loadPage({ Page, Runtime }, options, debugMessages),
-			options.browserDebug ? waitForDebuggerReady({ Debugger }) : Promise.resolve()
-		]);
-		await Runtime.addBinding({ name: SET_PAGE_DATA_FUNCTION_NAME, executionContextId: contextId });
-		if (options.embedScreenshot && options.compressContent) {
-			await Runtime.addBinding({ name: CAPTURE_SCREENSHOT_FUNCTION_NAME, executionContextId: contextId });
-			Runtime.addEventListener("bindingCalled", async ({ params }) => {
-				if (params.name === CAPTURE_SCREENSHOT_FUNCTION_NAME) {
-					if (options.debugMessagesFile) {
-						debugMessages.push([Date.now(), ["Capturing screenshot"]]);
-					}
-					try {
-						let screenshotOptions = { captureBeyondViewport: true };
-						if (options.embedScreenshotOptions) {
-							try {
-								screenshotOptions = JSON.parse(options.embedScreenshotOptions);
-							} catch {
-								// ignored
-							}
-						}
-						screenshotOptions.format = "png";
-						const { data } = await Page.captureScreenshot(screenshotOptions);
-						await Runtime.evaluate({ expression: `globalThis.${SET_SCREENSHOT_FUNCTION_NAME}(${JSON.stringify(data)})`, contextId });
-					} catch {
-						await Runtime.evaluate({ expression: `globalThis.${SET_SCREENSHOT_FUNCTION_NAME}(${JSON.stringify("")})`, contextId });
-					}
-				}
-			});
+	});
+
+	function shouldBlockRequest(requestUrl) {
+		if (!options.blockedURLPatterns || !options.blockedURLPatterns.length) {
+			return false;
 		}
-		if (options.embedPdf) {
-			await Runtime.addBinding({ name: PRINT_TO_PDF_FUNCTION_NAME, executionContextId: contextId });
-			Runtime.addEventListener("bindingCalled", async ({ params }) => {
-				if (params.name === PRINT_TO_PDF_FUNCTION_NAME) {
-					if (options.debugMessagesFile) {
-						debugMessages.push([Date.now(), ["Printing to PDF", options.embedPdfOptions || ""]]);
-					}
-					let pdfOptions = {};
-					if (options.embedPdfOptions) {
-						try {
-							pdfOptions = JSON.parse(options.embedPdfOptions);
-						} catch {
-							// ignored
-						}
-					}
-					try {
-						const { data } = await Page.printToPDF(pdfOptions);
-						await Runtime.evaluate({ expression: `globalThis.${SET_PDF_FUNCTION_NAME}(${JSON.stringify(data)})`, contextId });
-					} catch {
-						await Runtime.evaluate({ expression: `globalThis.${SET_PDF_FUNCTION_NAME}(${JSON.stringify("")})`, contextId });
-					}
-				}
-			});
+		const blockedURL = options.blockedURLPatterns.find(pattern =>
+			new RegExp(pattern).test(requestUrl)
+		);
+		if (blockedURL) {
+			logData(["Blocking request", requestUrl], { options, debugMessages });
+			return true;
 		}
-		await Runtime.addBinding({ name: FETCH_FUNCTION_NAME, executionContextId: contextId });
-		Runtime.addEventListener("bindingCalled", async ({ params }) => {
-			if (params.name === FETCH_FUNCTION_NAME) {
-				let { payload } = params;
-				payload = JSON.parse(payload);
-				const { requestId, url, options: fetchOptions } = payload;
-				if (options.debugMessagesFile) {
-					debugMessages.push([Date.now(), ["Fetching URL", url]]);
-				}
-				try {
-					const response = await fetchWithFileSupport(url, fetchOptions);
-					const arrayBuffer = await response.arrayBuffer();
-					const uint8Array = new Uint8Array(arrayBuffer);
-					const data = btoa(String.fromCharCode.apply(null, uint8Array));
-					const result = {
-						status: response.status,
-						headers: Object.fromEntries(response.headers.entries()),
-						data
-					};
-					await Runtime.evaluate({
-						expression: `globalThis.${RESOLVE_FETCH_FUNCTION_NAME}(${JSON.stringify(requestId)}, ${JSON.stringify(result)})`,
-						contextId
-					});
-				} catch (error) {
-					const errorResult = {
-						error: error.message,
-						code: error.code
-					};
-					await Runtime.evaluate({
-						expression: `globalThis.${REJECT_FETCH_FUNCTION_NAME}(${JSON.stringify(requestId)}, ${JSON.stringify(errorResult)})`,
-						contextId
-					});
-				}
+		return false;
+	}
+}
+
+function captureHttpInfo(params, urlState, { options, debugMessages, httpInfo }) {
+	const REDIRECT_STATUS_CODES = [301, 302, 303, 307, 308];
+	const DOCUMENT_RESOURCE_TYPE = "Document";
+	const LOCATION_HEADER_NAME = "location";
+	const { request, resourceType, responseHeaders, responseStatusCode, responseStatusText } = params;
+	const shouldCapture = resourceType === DOCUMENT_RESOURCE_TYPE &&
+		options.outputJson &&
+		!httpInfo.request &&
+		responseStatusCode !== undefined &&
+		(request.url === urlState.url || request.url === urlState.alternativeUrl);
+	if (shouldCapture) {
+		if (REDIRECT_STATUS_CODES.includes(responseStatusCode)) {
+			const redirect = responseHeaders.find(header => header.name.toLowerCase() === LOCATION_HEADER_NAME)?.value;
+			if (redirect) {
+				urlState.url = new URL(redirect, urlState.url).href;
 			}
-		});
-		const pageDataPromise = new Promise(resolve => {
-			let pageDataResponse = "";
-			Runtime.addEventListener("bindingCalled", ({ params }) => {
-				if (params.name === SET_PAGE_DATA_FUNCTION_NAME) {
-					const { payload } = params;
-					if (payload.length) {
-						pageDataResponse += payload;
-					} else {
-						if (options.debugMessagesFile) {
-							debugMessages.push([Date.now(), ["Setting page data"]]);
-						}
-						const result = JSON.parse(pageDataResponse);
-						if (result.content instanceof Array) {
-							result.content = new Uint8Array(result.content);
-						}
-						resolve(result);
-					}
+			logData(["Redirecting", urlState.url], { options, debugMessages });
+		} else {
+			Object.assign(httpInfo, {
+				request: {
+					url: request.url,
+					method: request.method,
+					headers: request.headers,
+					referrerPolicy: request.referrerPolicy
+				},
+				resourceType,
+				response: {
+					status: responseStatusCode,
+					statusText: responseStatusText,
+					headers: responseHeaders
 				}
 			});
-		});
-		if (options.browserWaitDelay) {
-			if (options.debugMessagesFile) {
-				debugMessages.push([Date.now(), [`Waiting ${options.browserWaitDelay} ms`]]);
-			}
-			await new Promise(resolve => setTimeout(resolve, options.browserWaitDelay));
-		}
-		const captureTimeoutAbortController = new AbortController();
-		const captureTimeoutAbortSignal = captureTimeoutAbortController.signal;
-		try {
-			if (options.debugMessagesFile) {
-				debugMessages.push([Date.now(), ["Capturing page"]]);
-			}
-			const { result } = await Promise.race([
-				Runtime.evaluate({
-					expression: `(${getPageDataScriptSource.toString()})(${JSON.stringify(options)},${JSON.stringify([SET_SCREENSHOT_FUNCTION_NAME, SET_PDF_FUNCTION_NAME, SET_PAGE_DATA_FUNCTION_NAME, CAPTURE_SCREENSHOT_FUNCTION_NAME, PRINT_TO_PDF_FUNCTION_NAME])})`,
-					awaitPromise: true,
-					returnByValue: true,
-					contextId
-				}),
-				waitForTimeout(captureTimeoutAbortSignal, options.browserCaptureMaxTime, "Capture timeout", CAPTURE_TIMEOUT_ERROR)
-			]);
-			const { subtype, description } = result;
-			if (subtype === "error") {
-				throw new Error(description);
-			}
-		} finally {
-			if (!captureTimeoutAbortSignal.aborted) {
-				captureTimeoutAbortController.abort();
-			}
-			await Runtime.disable();
-			await Page.disable();
-			if (options.httpHeaders) {
-				await Network.disable();
-			}
-		}
-		const pageData = await pageDataPromise;
-		if (options.consoleMessagesFile) {
-			await Console.disable();
-			pageData.consoleMessages = consoleMessages;
-		}
-		if (options.debugMessagesFile) {
-			pageData.debugMessages = debugMessages;
-			debugMessages.push([Date.now(), ["Returning page data"]]);
-		}
-		Object.assign(pageData, httpInfo);
-		return pageData;
-	} catch (error) {
-		if (error.code === LOAD_TIMEOUT_ERROR && options.browserWaitUntilFallback && options.browserWaitUntil) {
-			const browserWaitUntil = NETWORK_STATES[(NETWORK_STATES.indexOf(options.browserWaitUntil) + 1)];
-			if (browserWaitUntil) {
-				if (options.debugMessagesFile) {
-					debugMessages.push([Date.now(), ["Retrying with waitUntil", browserWaitUntil]]);
-				}
-				options.browserWaitUntil = browserWaitUntil;
-				await closeTarget();
-				return await getPageData(options);
-			}
-		}
-		if (options.consoleMessagesFile) {
-			error.consoleMessages = consoleMessages;
-		}
-		if (options.debugMessagesFile) {
-			error.debugMessages = debugMessages;
-		}
-		throw error;
-	} finally {
-		if (options.debugMessagesFile) {
-			debugMessages.push([Date.now(), ["Closing page"]]);
-		}
-		await closeTarget();
-		if (options.debugMessagesFile) {
-			debugMessages.push([Date.now(), ["Finishing"]]);
 		}
 	}
+}
 
-	async function closeTarget() {
-		if (targetInfo && !options.browserDebug) {
-			await CDP.closeTarget(targetInfo.id);
-			targetInfo = null;
-		}
+async function setupHttpHeaders({ Network }, { options, debugMessages }) {
+	logData(["Setting HTTP headers", JSON.stringify(options.httpHeaders)], { options, debugMessages });
+	await Network.enable();
+	await Network.setExtraHTTPHeaders({ headers: options.httpHeaders });
+}
+
+async function setupMediaFeatures({ Emulation }, { options, debugMessages }) {
+	for (const mediaFeature of options.emulateMediaFeatures) {
+		logData(["Emulating media feature", mediaFeature.name, mediaFeature.value], { options, debugMessages });
+		await Emulation.setEmulatedMedia({
+			media: mediaFeature.name,
+			features: mediaFeature.value.split(",").map(feature => feature.trim())
+		});
 	}
 }
 
-function getPageDataScriptSource(options, [SET_SCREENSHOT_FUNCTION_NAME, SET_PDF_FUNCTION_NAME, SET_PAGE_DATA_FUNCTION_NAME, CAPTURE_SCREENSHOT_FUNCTION_NAME, PRINT_TO_PDF_FUNCTION_NAME]) {
-	if ((options.embedScreenshot || options.embedPdf) && options.compressContent) {
-		let screenshot, pdf;
-		if (options.embedScreenshot) {
-			screenshot = new Promise(resolve => globalThis[SET_SCREENSHOT_FUNCTION_NAME] = async data =>
-				resolve(Array.from(new Uint8Array(await (await fetch("data:image/png;base64," + data)).arrayBuffer()))));
-		}
-		if (options.embedPdf) {
-			pdf = new Promise(resolve => globalThis[SET_PDF_FUNCTION_NAME] = async data =>
-				resolve(Array.from(new Uint8Array(await (await fetch("data:application/pdf;base64," + data)).arrayBuffer()))));
-		}
-		let pendingCapture;
-		options.onprogress = async event => {
-			if (event.type == event.RESOURCES_INITIALIZING && window == top && !pendingCapture) {
-				pendingCapture = true;
-				if (globalThis[CAPTURE_SCREENSHOT_FUNCTION_NAME]) {
-					globalThis[CAPTURE_SCREENSHOT_FUNCTION_NAME]("");
-					options.embeddedImage = await screenshot;
-				}
-				if (globalThis[PRINT_TO_PDF_FUNCTION_NAME]) {
-					globalThis[PRINT_TO_PDF_FUNCTION_NAME]("");
-					options.embeddedPdf = await pdf;
-				}
+async function setupCookies({ Network }, { options, debugMessages }) {
+	logData(["Setting cookies", JSON.stringify(options.browserCookies)], { options, debugMessages });
+	await Network.setCookies({ cookies: options.browserCookies });
+}
+
+async function setupScriptInjection({ Page }, { options }) {
+	await Page.addScriptToEvaluateOnNewDocument({
+		source: getHookScriptSource(),
+		runImmediately: true
+	});
+	await Page.addScriptToEvaluateOnNewDocument({
+		source: await getScriptSource(options),
+		runImmediately: true,
+		worldName: SINGLE_FILE_WORLD_NAME
+	});
+}
+
+async function getContextId({ Debugger, Page, Runtime }, { options, debugMessages }) {
+	const [contextId] = await Promise.all([
+		loadPage({ Page, Runtime }, { options, debugMessages }),
+		options.browserDebug ? waitForDebuggerReady() : Promise.resolve()
+	]);
+	return contextId;
+
+	async function waitForDebuggerReady() {
+		await Debugger.enable();
+		await Debugger.pause();
+		await new Promise(resolve => {
+			const RESUMED_EVENT = "resumed";
+			Debugger.addEventListener(RESUMED_EVENT, onResumed);
+			function onResumed() {
+				Debugger.removeEventListener(RESUMED_EVENT, onResumed);
+				resolve();
 			}
-		};
+		});
 	}
-	const MAX_CONTENT_SIZE = 32 * 1024 * 1024;
-	return singlefile.getPageData(options).then(data => {
-		if (data.content instanceof Uint8Array) {
-			data.content = Array.from(data.content);
-		}
-		data = JSON.stringify(data);
-		let indexData = 0;
-		do {
-			globalThis[SET_PAGE_DATA_FUNCTION_NAME](data.slice(indexData, indexData + MAX_CONTENT_SIZE));
-			indexData += MAX_CONTENT_SIZE;
-		} while (indexData < data.length);
-		globalThis[SET_PAGE_DATA_FUNCTION_NAME]("");
-	});
 }
 
-async function loadPage({ Page, Runtime }, options, debugMessages) {
+async function loadPage({ Page, Runtime }, { options, debugMessages }) {
+	const LOAD_TIMEOUT_ERROR_MESSAGE = "Load timeout";
 	await Runtime.enable();
 	await Page.enable();
 	const loadTimeoutAbortController = new AbortController();
 	const loadTimeoutAbortSignal = loadTimeoutAbortController.signal;
 	try {
-		if (options.debugMessagesFile) {
-			debugMessages.push([Date.now(), ["Loading page", options.url]]);
-		}
+		logData(["Loading page", options.url], { options, debugMessages });
 		const [contextId] = await Promise.race([
-			Promise.all([getTopFrameContextId({ Page, Runtime }, options, debugMessages), Page.navigate({ url: options.url })]),
-			waitForTimeout(loadTimeoutAbortSignal, options.browserLoadMaxTime, "Load timeout", LOAD_TIMEOUT_ERROR)
+			Promise.all([getTopFrameContextId({ Page, Runtime }, { options, debugMessages }), Page.navigate({ url: options.url })]),
+			waitForTimeout(loadTimeoutAbortSignal, options.browserLoadMaxTime, LOAD_TIMEOUT_ERROR_MESSAGE, LOAD_TIMEOUT_ERROR)
 		]);
 		return contextId;
 	} finally {
@@ -532,163 +405,311 @@ async function loadPage({ Page, Runtime }, options, debugMessages) {
 	}
 }
 
-async function getTopFrameContextId({ Page, Runtime }, options, debugMessages) {
-	const CONTEXT_CREATED_EVENT = "executionContextCreated";
-	const contextIds = [];
-	let topFrameId;
+async function getTopFrameContextId({ Page, Runtime }, { options, debugMessages }) {
+	await Page.setLifecycleEventsEnabled({ enabled: true });
+	const state = { topFrameId: undefined, contextIds: [] };
+	const removeContextListener = setupContextCreatedListener({ Runtime }, state);
 	try {
-		Runtime.addEventListener(CONTEXT_CREATED_EVENT, onExecutionContextCreated);
-		await waitForPageReady({ Page }, options);
-		if (options.debugMessagesFile) {
-			debugMessages.push([Date.now(), ["Getting execution context"]]);
-		}
-		const contextId = await getContextId();
-		if (contextId === undefined) {
-			throw new Error("Execution context not found");
-		} else {
-			return contextId;
-		}
+		await waitForPageReadyState({ Page }, state, { options, debugMessages });
+		const contextId = await findValidSingleFileContext({ Runtime }, state.contextIds, { options, debugMessages });
+		return contextId;
 	} finally {
-		Runtime.removeEventListener(CONTEXT_CREATED_EVENT, onExecutionContextCreated);
+		removeContextListener();
+		await Page.setLifecycleEventsEnabled({ enabled: false });
 	}
+}
 
-	function onExecutionContextCreated({ params }) {
+function setupContextCreatedListener({ Runtime }, state) {
+	const EXECUTION_CONTEXT_CREATED_EVENT_TYPE = "executionContextCreated";
+	const onContextCreated = ({ params }) => {
 		const { context } = params;
-		const { name, auxData = {} } = context;
-		if (name === SINGLE_FILE_WORLD_NAME && topFrameId !== undefined && auxData.frameId === topFrameId) {
-			contextIds.unshift(context.id);
+		if (context.name === SINGLE_FILE_WORLD_NAME && context.auxData?.frameId === state.topFrameId) {
+			state.contextIds.push(context.id);
 		}
-	}
+	};
+	Runtime.addEventListener(EXECUTION_CONTEXT_CREATED_EVENT_TYPE, onContextCreated);
+	return () => Runtime.removeEventListener(EXECUTION_CONTEXT_CREATED_EVENT_TYPE, onContextCreated);
+}
 
-	async function waitForPageReady({ Page }, options) {
-		let resolveCallbackTimeout;
-		await Page.setLifecycleEventsEnabled({ enabled: true });
-		try {
-			await new Promise((resolve, reject) => {
-				const LIFE_CYCLE_EVENT = "lifecycleEvent";
-				const FRAME_NAVIGATED_EVENT = "frameNavigated";
-				Page.addEventListener(LIFE_CYCLE_EVENT, onLifecycleEvent);
-				Page.addEventListener(FRAME_NAVIGATED_EVENT, onFrameNavigated);
-
-				function onLifecycleEvent({ params }) {
-					const { frameId, name } = params;
-					if (frameId === topFrameId) {
-						if (options.debugMessagesFile) {
-							debugMessages.push([Date.now(), ["Detecting lifecycle event", name]]);
-						}
-						if (name === options.browserWaitUntil || (resolveCallbackTimeout && NETWORK_STATES.indexOf(name) < NETWORK_STATES.indexOf(options.browserWaitUntil))) {
-							clearTimeout(resolveCallbackTimeout);
-							if (options.debugMessagesFile) {
-								debugMessages.push([Date.now(), [`Waiting ${options.browserWaitUntilDelay} ms`]]);
-							}
-							setTimeout(() => {
-								if (options.debugMessagesFile) {
-									debugMessages.push([Date.now(), ["Detecting page ready"]]);
-								}
-								removeListeners();
-								resolve();
-							}, options.browserWaitUntilDelay);
-						}
-					}
-				}
+async function waitForPageReadyState({ Page }, state, { options, debugMessages }) {
+	const LIFE_CYCLE_EVENT_TYPE = "lifecycleEvent";
+	const FRAME_NAVIGATED_EVENT_TYPE = "frameNavigated";
+	await new Promise((resolve, reject) => {
+		const timeoutState = { timeoutId: undefined };
+		const cleanup = () => {
+			Page.removeEventListener(LIFE_CYCLE_EVENT_TYPE, onLifecycleEvent);
+			Page.removeEventListener(FRAME_NAVIGATED_EVENT_TYPE, onFrameNavigated);
+		};
+		const onLifecycleEvent = createLifecycleEventHandler(state, timeoutState, resolve, cleanup, { options, debugMessages });
+		const onFrameNavigated = createFrameNavigatedHandler(state, timeoutState, reject, cleanup, { options, debugMessages });
+		Page.addEventListener(LIFE_CYCLE_EVENT_TYPE, onLifecycleEvent);
+		Page.addEventListener(FRAME_NAVIGATED_EVENT_TYPE, onFrameNavigated);
+	});
+}
 
-				function onFrameNavigated({ params }) {
-					const { frame } = params;
-					if (!frame.parentId) {
-						if (frame.unreachableUrl) {
-							clearTimeout(resolveCallbackTimeout);
-							removeListeners();
-							reject(new Error("Unreachable URL: " + frame.unreachableUrl));
-						} else {
-							if (options.debugMessagesFile) {
-								debugMessages.push([Date.now(), ["Detecting top frame ID"]]);
-							}
-							topFrameId = frame.id;
-						}
-					}
-				}
+function createLifecycleEventHandler(state, timeoutState, resolve, cleanup, { options, debugMessages }) {
+	return ({ params }) => {
+		const { frameId, name } = params;
+		if (frameId === state.topFrameId) {
+			logData(["Detecting lifecycle event", name], { options, debugMessages });
+		}
+		const shouldResolve = name === options.browserWaitUntil ||
+			(timeoutState.timeoutId && NETWORK_STATES.indexOf(name) < NETWORK_STATES.indexOf(options.browserWaitUntil));
+		if (shouldResolve) {
+			clearTimeout(timeoutState.timeoutId);
+			logData([`Waiting ${options.browserWaitUntilDelay} ms`], { options, debugMessages });
+			setTimeout(() => {
+				logData(["Detecting page ready"], { options, debugMessages });
+				cleanup();
+				resolve();
+			}, options.browserWaitUntilDelay);
+		}
+	};
+};
 
-				function removeListeners() {
-					Page.removeEventListener(LIFE_CYCLE_EVENT, onLifecycleEvent);
-					Page.removeEventListener(FRAME_NAVIGATED_EVENT, onFrameNavigated);
-				}
-			});
-		} finally {
-			await Page.setLifecycleEventsEnabled({ enabled: false });
+function createFrameNavigatedHandler(state, timeoutState, reject, cleanup, { options, debugMessages }) {
+	const UNREACHABLE_URL_ERROR_MESSAGE = "Unreachable URL";
+	return ({ params }) => {
+		const { frame } = params;
+		if (!frame.parentId) {
+			if (frame.unreachableUrl) {
+				clearTimeout(timeoutState.timeoutId);
+				cleanup();
+				reject(new Error(UNREACHABLE_URL_ERROR_MESSAGE + ": " + frame.unreachableUrl));
+			} else {
+				logData(["Detecting top frame ID"], { options, debugMessages });
+				state.topFrameId = frame.id;
+			}
 		}
-	}
+	};
+}
 
-	async function getContextId() {
-		let contextId;
-		if (contextIds.length) {
-			let contextIdIndex = 0;
-			do {
-				if (await testExecutionContext(contextIds[contextIdIndex])) {
-					contextId = contextIds[contextIdIndex];
-				}
-				contextIdIndex++;
-			} while (contextId === undefined && contextIdIndex < contextIds.length);
-		}
-		return contextId;
+async function findValidSingleFileContext({ Runtime }, contextIds, { options, debugMessages }) {
+	const CONTEXT_NOT_FOUND_ERROR_MESSAGE = "Execution context not found for SingleFile world";
+	const SINGLE_FILE_DETECTION_TEST = "typeof singlefile !== 'undefined'";
+	const NO_VALID_CONTEXT_ERROR_MESSAGE = "No valid SingleFile execution context found";
+	logData(["Getting execution context"], { options, debugMessages });
+	if (!contextIds.length) {
+		throw new Error(CONTEXT_NOT_FOUND_ERROR_MESSAGE);
 	}
-
-	async function testExecutionContext(contextId) {
+	for (const contextId of contextIds) {
 		try {
 			const { result } = await Runtime.evaluate({
-				expression: "singlefile !== undefined",
+				expression: SINGLE_FILE_DETECTION_TEST,
 				contextId
 			});
-			return result.value === true;
+			if (result.value === true) {
+				return contextId;
+			}
 		} catch {
 			// ignored
 		}
-		return false;
 	}
+	throw new Error(NO_VALID_CONTEXT_ERROR_MESSAGE);
+}
+
+function setupPageDataCapture({ Runtime }, contextId, { options, debugMessages }) {
+	return new Promise(resolve => {
+		let pageDataResponse = "";
+		Runtime.addEventListener(BINDING_CALLED_EVENT_TYPE, ({ params }) => {
+			if (params.name === SET_PAGE_DATA_FUNCTION_NAME) {
+				const { payload } = params;
+				if (payload.length) {
+					pageDataResponse += payload;
+				} else {
+					logData(["Setting page data"], { options, debugMessages });
+					const result = JSON.parse(pageDataResponse);
+					if (result.content instanceof Array) {
+						result.content = new Uint8Array(result.content);
+					}
+					resolve(result);
+				}
+			}
+		});
+	});
 }
 
-function waitForTimeout(abortSignal, maxDelay, errorMessage, errorCode) {
-	return new Promise((resolve, reject) => {
-		const ABORT_EVENT = "abort";
-		abortSignal.addEventListener(ABORT_EVENT, onAbort);
-		const timeoutId = setTimeout(() => {
-			abortSignal.removeEventListener(ABORT_EVENT, onAbort);
-			const error = new Error(errorMessage);
-			error.code = errorCode;
-			reject(error);
-		}, maxDelay);
+async function setupBindings({ Page, Runtime }, contextId, { options, debugMessages }) {
+	await Runtime.addBinding({ name: SET_PAGE_DATA_FUNCTION_NAME, executionContextId: contextId });
+	if (options.embedScreenshot && options.compressContent) {
+		await setupScreenshotCapture({ Page, Runtime }, contextId, { options, debugMessages });
+	}
+	if (options.embedPdf) {
+		await setupPdfCapture({ Page, Runtime }, contextId, { options, debugMessages });
+	}
+	await Runtime.addBinding({ name: FETCH_FUNCTION_NAME, executionContextId: contextId });
+	Runtime.addEventListener(BINDING_CALLED_EVENT_TYPE, async ({ params }) => {
+		if (params.name === FETCH_FUNCTION_NAME) {
+			await handleFetchRequest({ Runtime }, params, contextId, { options, debugMessages });
+		}
+	});
+}
 
-		function onAbort() {
-			abortSignal.removeEventListener(ABORT_EVENT, onAbort);
-			clearTimeout(timeoutId);
-			resolve();
+async function setupScreenshotCapture({ Page, Runtime }, contextId, { options, debugMessages }) {
+	await Runtime.addBinding({ name: CAPTURE_SCREENSHOT_FUNCTION_NAME, executionContextId: contextId });
+	Runtime.addEventListener(BINDING_CALLED_EVENT_TYPE, async ({ params }) => {
+		if (params.name === CAPTURE_SCREENSHOT_FUNCTION_NAME) {
+			logData(["Capturing screenshot"], { options, debugMessages });
+			try {
+				const screenshotOptions = parseScreenshotOptions(options.embedScreenshotOptions);
+				const { data } = await Page.captureScreenshot(screenshotOptions);
+				await callBrowserFunction({ Runtime }, contextId, SET_SCREENSHOT_FUNCTION_NAME, [data]);
+			} catch {
+				await callBrowserFunction({ Runtime }, contextId, SET_SCREENSHOT_FUNCTION_NAME, [""]);
+			}
 		}
 	});
+
+	function parseScreenshotOptions(optionsString) {
+		const PNG_FORMAT = "png";
+		let screenshotOptions = { captureBeyondViewport: true };
+		if (optionsString) {
+			try {
+				screenshotOptions = JSON.parse(optionsString);
+			} catch {
+				// ignored
+			}
+		}
+		screenshotOptions.format = PNG_FORMAT;
+		return screenshotOptions;
+	}
 }
 
-async function waitForDebuggerReady({ Debugger }) {
-	await Debugger.enable();
-	await Debugger.pause();
-	await new Promise(resolve => {
-		const RESUMED_EVENT = "resumed";
-		Debugger.addEventListener(RESUMED_EVENT, onResumed);
+async function setupPdfCapture({ Page, Runtime }, contextId, { options, debugMessages }) {
+	await Runtime.addBinding({ name: PRINT_TO_PDF_FUNCTION_NAME, executionContextId: contextId });
+	Runtime.addEventListener(BINDING_CALLED_EVENT_TYPE, async ({ params }) => {
+		if (params.name !== PRINT_TO_PDF_FUNCTION_NAME) {
+			logData(["Printing to PDF", options.embedPdfOptions || ""], { options, debugMessages });
+			const pdfOptions = parsePdfOptions(options.embedPdfOptions);
+			try {
+				const { data } = await Page.printToPDF(pdfOptions);
+				await callBrowserFunction({ Runtime }, contextId, SET_PDF_FUNCTION_NAME, [data]);
+			} catch {
+				await callBrowserFunction({ Runtime }, contextId, SET_PDF_FUNCTION_NAME, [""]);
+			}
+		}
+	});
 
-		function onResumed() {
-			Debugger.removeEventListener(RESUMED_EVENT, onResumed);
-			resolve();
+	function parsePdfOptions(optionsString) {
+		let pdfOptions = {};
+		if (optionsString) {
+			try {
+				pdfOptions = JSON.parse(optionsString);
+			} catch {
+				// ignored
+			}
 		}
+		return pdfOptions;
+	}
+}
+
+async function handleFetchRequest({ Runtime }, params, contextId, { options, debugMessages }) {
+	const { payload } = params;
+	const { requestId, url, options: fetchOptions } = JSON.parse(payload);
+	logData(["Fetching URL", url], { options, debugMessages });
+	try {
+		const response = await fetch(url, fetchOptions);
+		const arrayBuffer = await response.arrayBuffer();
+		const base64Data = arrayBufferToBase64(arrayBuffer);
+		const result = {
+			status: response.status,
+			headers: Object.fromEntries(response.headers.entries()),
+			data: base64Data
+		};
+		await callBrowserFunction({ Runtime }, contextId, RESOLVE_FETCH_FUNCTION_NAME, [requestId, result]);
+	} catch (error) {
+		const errorResult = {
+			error: error.message,
+			code: error.code
+		};
+		await callBrowserFunction({ Runtime }, contextId, REJECT_FETCH_FUNCTION_NAME, [requestId, errorResult]);
+	}
+}
+
+async function callBrowserFunction({ Runtime }, contextId, functionName, args) {
+	const serializedArgs = args.map(arg => JSON.stringify(arg)).join(", ");
+	await Runtime.evaluate({
+		expression: `globalThis.${functionName}(${serializedArgs})`,
+		contextId
 	});
 }
 
-function getBrowserOptions(options) {
-	const browserOptions = {};
-	browserOptions.args = options.browserArgs;
-	browserOptions.headless = options.browserHeadless;
-	browserOptions.executablePath = options.browserExecutablePath;
-	browserOptions.debug = options.browserDebug;
-	browserOptions.disableWebSecurity = options.browserDisableWebSecurity;
-	browserOptions.width = options.browserWidth;
-	browserOptions.height = options.browserHeight;
-	browserOptions.userAgent = options.userAgent;
-	browserOptions.httpProxyServer = options.httpProxyServer;
-	return browserOptions;
+async function capturePageData({ Runtime }, contextId, { options, debugMessages }) {
+	const CAPTURE_TIMEOUT_ERROR_MESSAGE = "Capture timeout";
+	const ERROR_SUBTYPE = "error";
+	const captureTimeoutAbortController = new AbortController();
+	const captureTimeoutAbortSignal = captureTimeoutAbortController.signal;
+	if (options.browserWaitDelay) {
+		logData([`Waiting ${options.browserWaitDelay} ms`], { options, debugMessages });
+		await new Promise(resolve => setTimeout(resolve, options.browserWaitDelay));
+	}
+	try {
+		logData(["Capturing page"], { options, debugMessages });
+		const captureScript = `(${getPageDataScriptSource.toString()})(${JSON.stringify(options)},${JSON.stringify([
+			SET_SCREENSHOT_FUNCTION_NAME,
+			SET_PDF_FUNCTION_NAME,
+			SET_PAGE_DATA_FUNCTION_NAME,
+			CAPTURE_SCREENSHOT_FUNCTION_NAME,
+			PRINT_TO_PDF_FUNCTION_NAME
+		])})`;
+		const { result } = await Promise.race([
+			Runtime.evaluate({
+				expression: captureScript,
+				awaitPromise: true,
+				returnByValue: true,
+				contextId
+			}),
+			waitForTimeout(captureTimeoutAbortSignal, options.browserCaptureMaxTime, CAPTURE_TIMEOUT_ERROR_MESSAGE, CAPTURE_TIMEOUT_ERROR)
+		]);
+		if (result.subtype === ERROR_SUBTYPE) {
+			throw new Error(result.description);
+		}
+	} finally {
+		if (!captureTimeoutAbortSignal.aborted) {
+			captureTimeoutAbortController.abort();
+		}
+	}
+}
+
+async function disableCdpDomains({ Console, Network, Page, Runtime }, { options }) {
+	await Runtime.disable();
+	await Page.disable();
+	if (options.httpHeaders) {
+		await Network.disable();
+	}
+	if (options.consoleMessagesFile) {
+		await Console.disable();
+	}
+}
+
+async function finalizePageData(pageDataPromise, { options, consoleMessages, debugMessages, httpInfo }) {
+	const pageData = await pageDataPromise;
+	logData(["Returning page data"], { options, debugMessages });
+	if (options.consoleMessagesFile) {
+		pageData.consoleMessages = consoleMessages;
+	}
+	if (options.debugMessagesFile) {
+		pageData.debugMessages = debugMessages;
+	}
+	Object.assign(pageData, httpInfo);
+	if (options.browserWaitEndDelay) {
+		logData([`Waiting ${options.browserWaitEndDelay} ms after processing`], { options, debugMessages });
+		await new Promise(resolve => setTimeout(resolve, options.browserWaitEndDelay));
+	}
+	return pageData;
+}
+
+function attachDebugInfo(error, { options, consoleMessages, debugMessages }) {
+	if (options.consoleMessagesFile) {
+		error.consoleMessages = consoleMessages;
+	}
+	if (options.debugMessagesFile) {
+		error.debugMessages = debugMessages;
+	}
 }
+
+function logData(data, { options, debugMessages }) {
+	if (options.debugMessagesFile) {
+		debugMessages.push([Date.now(), data]);
+	}
+}