@roxybrowser/playwright 2.0.2-beta.0

package/dist/browserContext.js

@@ -0,0 +1,1129 @@
+import { STATUS_CODES } from "node:http";
+import { randomUUID } from "node:crypto";
+import { mkdtemp, readFile } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { createApiResponse, fetchWithRetries, RoxyAPIRequestContext } from "./apiRequestContext.js";
+import { RoxyBrowserContextClockDelegate } from "./browserContextClock.js";
+import { RoxyClock } from "./clock.js";
+import { TimeoutError } from "./errors.js";
+import { normalizeExtraHTTPHeaders } from "./httpHeaders.js";
+import { RoxyPage } from "./page.js";
+import { serializePageFunction } from "./evaluation.js";
+import { urlMatches } from "./urlMatch.js";
+import { RoxyVideo } from "./video.js";
+const DEFAULT_CONTEXT_EVENT_TIMEOUT_MS = 30_000;
+const BUBBLED_PAGE_EVENTS = [
+    "console",
+    "dialog",
+    "request",
+    "requestfailed",
+    "requestfinished",
+    "response"
+];
+export class RoxyBrowserContext {
+    adapter;
+    humanDefaults;
+    options;
+    pageSet = new Set();
+    pageByAdapter = new Map();
+    adapterByPage = new WeakMap();
+    pendingPageRegistrations = new Map();
+    emittedPages = new WeakSet();
+    clockDelegate;
+    listeners = new Map();
+    pageEventDisposers = new WeakMap();
+    routeHandlers = [];
+    websocketRouteHandlers = [];
+    initScripts = new Set();
+    routeMatcherIds = new WeakMap();
+    disposeAdapterPageListener;
+    closed = false;
+    nextRouteMatcherId = 0;
+    videoOutputDirPromise = null;
+    clock;
+    request = new RoxyAPIRequestContext();
+    constructor(adapter, humanDefaults, options = {}, browserName = "chromium") {
+        this.adapter = adapter;
+        this.humanDefaults = humanDefaults;
+        this.options = options;
+        this.clockDelegate = new RoxyBrowserContextClockDelegate(this, browserName);
+        this.clock = new RoxyClock(this.clockDelegate);
+        this.disposeAdapterPageListener =
+            this.adapter.onPage?.((pageAdapter, openerAdapter, hasWindowOpener) => this.attachDiscoveredPage(pageAdapter, openerAdapter ?? null, hasWindowOpener ?? true)) ?? null;
+    }
+    async newPage() {
+        const pageAdapter = await this.adapter.newPage();
+        const page = await this.registerPage(pageAdapter);
+        this.emitPageEventOnce(page);
+        return page;
+    }
+    async addInitScript(script, arg) {
+        const source = await evaluationScript(script, arg);
+        if (this.adapter.addInitScript) {
+            return this.adapter.addInitScript(source);
+        }
+        const entry = {
+            source,
+            disposablesByPage: new WeakMap()
+        };
+        this.initScripts.add(entry);
+        await Promise.all(Array.from(this.pageSet, async (page) => {
+            const disposable = await page.addInitScript(source);
+            entry.disposablesByPage.set(page, disposable);
+        }));
+        return {
+            dispose: async () => {
+                if (!this.initScripts.delete(entry)) {
+                    return;
+                }
+                await Promise.all(Array.from(this.pageSet, async (page) => {
+                    await entry.disposablesByPage.get(page)?.dispose();
+                }));
+            }
+        };
+    }
+    async addCookies(cookies) {
+        if (!this.adapter.addCookies) {
+            throw new Error("Browser context cookies are not supported by this protocol adapter.");
+        }
+        await this.adapter.addCookies(cookies);
+    }
+    async cookies(urls) {
+        if (!this.adapter.cookies) {
+            throw new Error("Browser context cookies are not supported by this protocol adapter.");
+        }
+        const normalizedUrls = urls === undefined ? undefined : Array.isArray(urls) ? [...urls] : [urls];
+        return this.adapter.cookies(normalizedUrls);
+    }
+    async clearCookies(options) {
+        if (!this.adapter.clearCookies) {
+            throw new Error("Browser context cookies are not supported by this protocol adapter.");
+        }
+        await this.adapter.clearCookies(options);
+    }
+    pages() {
+        return Array.from(this.pageSet);
+    }
+    async close() {
+        if (this.closed) {
+            return;
+        }
+        this.closed = true;
+        try {
+            this.disposeAdapterPageListener?.();
+            await Promise.all(Array.from(this.pageSet).map(async (page) => {
+                await page.close();
+            }));
+        }
+        finally {
+            await this.request.dispose();
+            await this.adapter.close();
+            this.emit("close", this);
+        }
+    }
+    async setExtraHTTPHeaders(headers) {
+        await this.adapter.setExtraHTTPHeaders(normalizeExtraHTTPHeaders(headers));
+    }
+    async route(url, handler, options = {}) {
+        this.routeHandlers.push({
+            matcher: url,
+            handler,
+            activeInvocations: new Set(),
+            ignoreExceptions: false,
+            remainingTimes: options.times ?? null
+        });
+        await this.installRouteInterceptorsOnPages();
+        return {
+            dispose: async () => {
+                const index = this.routeHandlers.findIndex((entry) => entry.matcher === url && entry.handler === handler);
+                if (index >= 0) {
+                    this.routeHandlers.splice(index, 1);
+                }
+                await this.syncRouteInterceptionOnPages();
+            }
+        };
+    }
+    async routeWebSocket(url, handler) {
+        this.websocketRouteHandlers.push({
+            matcher: url,
+            handler
+        });
+        await this.installRouteInterceptorsOnPages();
+    }
+    async unroute(url, handler) {
+        const removed = [];
+        for (let index = this.routeHandlers.length - 1; index >= 0; index -= 1) {
+            const entry = this.routeHandlers[index];
+            if (!entry) {
+                continue;
+            }
+            if (this.routeMatcherKey(entry.matcher) !== this.routeMatcherKey(url)) {
+                continue;
+            }
+            if (handler && entry.handler !== handler) {
+                continue;
+            }
+            removed.push(entry);
+            this.routeHandlers.splice(index, 1);
+        }
+        await this.stopRouteHandlers(removed, "default");
+        await this.syncRouteInterceptionOnPages();
+    }
+    async unrouteAll(options) {
+        const removed = [...this.routeHandlers];
+        this.routeHandlers.length = 0;
+        await this.stopRouteHandlers(removed, options?.behavior ?? "default");
+        await this.syncRouteInterceptionOnPages();
+    }
+    async storageState(options) {
+        return this.request.storageState(options);
+    }
+    detachPage(page) {
+        this.pageSet.delete(page);
+        const disposers = this.pageEventDisposers.get(page);
+        if (disposers) {
+            for (const dispose of disposers) {
+                dispose();
+            }
+            this.pageEventDisposers.delete(page);
+        }
+        const adapter = this.adapterByPage.get(page);
+        if (adapter) {
+            this.pageByAdapter.delete(adapter);
+            this.pendingPageRegistrations.delete(adapter);
+            this.adapterByPage.delete(page);
+        }
+        this.clockDelegate.detachPage(page);
+    }
+    on(event, listener) {
+        return this.addListener(event, listener);
+    }
+    once(event, listener) {
+        const wrapped = ((payload) => {
+            this.removeListener(event, listener);
+            listener(payload);
+        });
+        const entries = this.ensureListenerSet(event);
+        entries.add({
+            original: listener,
+            wrapped: wrapped
+        });
+        return this;
+    }
+    addListener(event, listener) {
+        const entries = this.ensureListenerSet(event);
+        entries.add({
+            original: listener,
+            wrapped: listener
+        });
+        return this;
+    }
+    removeListener(event, listener) {
+        const entries = this.listeners.get(event);
+        if (!entries) {
+            return this;
+        }
+        for (const entry of Array.from(entries)) {
+            if (entry.original === listener) {
+                entries.delete(entry);
+            }
+        }
+        if (entries.size === 0) {
+            this.listeners.delete(event);
+        }
+        return this;
+    }
+    off(event, listener) {
+        return this.removeListener(event, listener);
+    }
+    async waitForEvent(event, optionsOrPredicate) {
+        const predicate = typeof optionsOrPredicate === "function"
+            ? optionsOrPredicate
+            : optionsOrPredicate?.predicate;
+        const timeout = typeof optionsOrPredicate === "function"
+            ? DEFAULT_CONTEXT_EVENT_TIMEOUT_MS
+            : optionsOrPredicate?.timeout ?? DEFAULT_CONTEXT_EVENT_TIMEOUT_MS;
+        return new Promise((resolve, reject) => {
+            const timer = timeout === 0
+                ? null
+                : setTimeout(() => {
+                    cleanup();
+                    reject(new Error(`Timeout ${timeout}ms exceeded while waiting for event "${String(event)}"`));
+                }, timeout);
+            const cleanup = () => {
+                if (timer) {
+                    clearTimeout(timer);
+                }
+                this.removeListener(event, listener);
+                if (event !== "close") {
+                    this.removeListener("close", closeListener);
+                }
+            };
+            const closeListener = (() => {
+                cleanup();
+                reject(new Error("Browser context has been closed."));
+            });
+            const listener = (async (payload) => {
+                try {
+                    if (predicate && !(await predicate(payload))) {
+                        return;
+                    }
+                    cleanup();
+                    resolve(payload);
+                }
+                catch (error) {
+                    cleanup();
+                    reject(error instanceof Error ? error : new Error(String(error)));
+                }
+            });
+            if (event !== "close") {
+                this.on("close", closeListener);
+            }
+            this.on(event, listener);
+        });
+    }
+    async attachDiscoveredPage(pageAdapter, openerAdapter, hasWindowOpener) {
+        const pageRegistration = this.registerPage(pageAdapter);
+        const page = await pageRegistration;
+        const resolvedOpenerAdapter = openerAdapter ?? await this.resolvePageAdapterByTargetId(this.openerTargetIdOf(pageAdapter));
+        const opener = resolvedOpenerAdapter
+            ? await this.registerPage(resolvedOpenerAdapter)
+            : hasWindowOpener
+                ? this.resolveFallbackPopupOpener(page)
+                : null;
+        if (!opener) {
+            this.emitPageEventOnce(page);
+            return;
+        }
+        if (opener === page) {
+            return;
+        }
+        page.setOpener(hasWindowOpener ? opener : null);
+        this.emitPageEventOnce(page);
+        opener.emitPopup(page);
+        await pageRegistration;
+    }
+    async registerPage(pageAdapter) {
+        const pending = this.pendingPageRegistrations.get(pageAdapter);
+        if (pending) {
+            return pending;
+        }
+        const existing = this.pageByAdapter.get(pageAdapter);
+        if (existing) {
+            return existing;
+        }
+        const registration = this.createPage(pageAdapter);
+        this.pendingPageRegistrations.set(pageAdapter, registration);
+        try {
+            return await registration;
+        }
+        finally {
+            this.pendingPageRegistrations.delete(pageAdapter);
+        }
+    }
+    async createPage(pageAdapter) {
+        const page = new RoxyPage(pageAdapter, this.humanDefaults, this, this.options);
+        this.pageSet.add(page);
+        this.pageByAdapter.set(pageAdapter, page);
+        this.adapterByPage.set(page, pageAdapter);
+        this.attachPageEventBubbling(page);
+        try {
+            for (const entry of this.initScripts) {
+                const disposable = await page.addInitScript(entry.source);
+                entry.disposablesByPage.set(page, disposable);
+            }
+            await page._ensurePlaywrightBuiltinsInstalled().catch((error) => {
+                if (isClosedPageRegistrationError(error)) {
+                    return;
+                }
+                throw error;
+            });
+            await this.clockDelegate.attachPage(page).catch((error) => {
+                if (isClosedPageRegistrationError(error)) {
+                    return;
+                }
+                throw error;
+            });
+            if (this.options.recordVideo) {
+                await this.enableRecordVideo(page, this.options.recordVideo).catch((error) => {
+                    if (isClosedPageRegistrationError(error)) {
+                        return;
+                    }
+                    throw error;
+                });
+            }
+            if (this._hasRouteInterception()) {
+                await page._ensureRouteInterceptorsInstalled().catch((error) => {
+                    if (isClosedPageRegistrationError(error)) {
+                        return;
+                    }
+                    throw error;
+                });
+            }
+            return page;
+        }
+        catch (error) {
+            if (isClosedPageRegistrationError(error)) {
+                return page;
+            }
+            this.pageSet.delete(page);
+            this.pageByAdapter.delete(pageAdapter);
+            this.adapterByPage.delete(page);
+            this.clockDelegate.detachPage(page);
+            throw error;
+        }
+    }
+    emitPageEventOnce(page) {
+        if (this.emittedPages.has(page)) {
+            return;
+        }
+        this.emittedPages.add(page);
+        this.emit("page", page);
+    }
+    async enableRecordVideo(page, options) {
+        const directory = await this.resolveVideoOutputDirectory(options.dir);
+        const videoPath = join(directory, `${randomUUID()}.webm`);
+        const videoSize = options.size ?? this.deriveDefaultRecordVideoSize();
+        let resolveFinished;
+        let rejectFinished;
+        const finished = new Promise((resolve, reject) => {
+            resolveFinished = resolve;
+            rejectFinished = reject;
+        });
+        const video = new RoxyVideo(videoPath, finished);
+        page.setVideo(video);
+        try {
+            const recording = await page.startVideoRecording({
+                path: videoPath,
+                size: videoSize,
+                ...(options.showActions ? { showActions: options.showActions } : {})
+            });
+            page.setVideo(video, async () => {
+                try {
+                    await recording.dispose();
+                    resolveFinished();
+                }
+                catch (error) {
+                    rejectFinished(error);
+                    throw error;
+                }
+            }, rejectFinished);
+        }
+        catch (error) {
+            page.setVideo(null);
+            rejectFinished(error);
+            throw error;
+        }
+    }
+    async resolveVideoOutputDirectory(configuredDirectory) {
+        if (configuredDirectory) {
+            return configuredDirectory;
+        }
+        if (!this.videoOutputDirPromise) {
+            this.videoOutputDirPromise = mkdtemp(join(tmpdir(), "roxy-videos-"));
+        }
+        return this.videoOutputDirPromise;
+    }
+    deriveDefaultRecordVideoSize() {
+        if (Object.prototype.hasOwnProperty.call(this.options, "viewport") && this.options.viewport === null) {
+            return {
+                width: 800,
+                height: 600
+            };
+        }
+        if (this.options.viewport) {
+            const scale = Math.min(1, 800 / Math.max(this.options.viewport.width, this.options.viewport.height));
+            return {
+                width: Math.max(2, Math.floor(this.options.viewport.width * scale)) & ~1,
+                height: Math.max(2, Math.floor(this.options.viewport.height * scale)) & ~1
+            };
+        }
+        return {
+            width: 800,
+            height: 450
+        };
+    }
+    async resolvePageAdapterByTargetId(targetId) {
+        if (!targetId) {
+            return null;
+        }
+        for (const adapter of this.pageByAdapter.keys()) {
+            if (this.targetIdOf(adapter) === targetId) {
+                return adapter;
+            }
+        }
+        for (const adapter of this.pendingPageRegistrations.keys()) {
+            if (this.targetIdOf(adapter) === targetId) {
+                return adapter;
+            }
+        }
+        return null;
+    }
+    openerTargetIdOf(pageAdapter) {
+        return pageAdapter.__roxyOpenerTargetId;
+    }
+    targetIdOf(pageAdapter) {
+        return pageAdapter.__roxyTargetId;
+    }
+    resolveFallbackPopupOpener(page) {
+        const candidates = Array.from(this.pageSet).filter((candidate) => candidate !== page);
+        return candidates.length === 1 ? (candidates[0] ?? null) : null;
+    }
+    ensureListenerSet(event) {
+        const existing = this.listeners.get(event);
+        if (existing) {
+            return existing;
+        }
+        const created = new Set();
+        this.listeners.set(event, created);
+        return created;
+    }
+    emit(event, payload) {
+        const entries = this.listeners.get(event);
+        if (!entries?.size) {
+            return false;
+        }
+        for (const entry of Array.from(entries)) {
+            const listener = entry.wrapped;
+            listener(payload);
+        }
+        return true;
+    }
+    shouldAutoHandleDialog(_page) {
+        return (this.listeners.get("dialog")?.size ?? 0) === 0;
+    }
+    attachPageEventBubbling(page) {
+        const disposers = [];
+        for (const event of BUBBLED_PAGE_EVENTS) {
+            const listener = ((payload) => {
+                this.emit(event, payload);
+            });
+            disposers.push(page.attachInternalListener(event, listener));
+        }
+        this.pageEventDisposers.set(page, disposers);
+    }
+    async _onWebSocketRoute(websocketroute) {
+        for (let index = this.websocketRouteHandlers.length - 1; index >= 0; index -= 1) {
+            const entry = this.websocketRouteHandlers[index];
+            if (!entry || !this.matchesWebSocketRoute(websocketroute.url(), entry.matcher)) {
+                continue;
+            }
+            await entry.handler(websocketroute);
+            return true;
+        }
+        return false;
+    }
+    _hasRequestRoutes() {
+        return this.routeHandlers.length > 0;
+    }
+    _hasWebSocketRoutes() {
+        return this.websocketRouteHandlers.length > 0;
+    }
+    _hasRouteInterception() {
+        return this.routeHandlers.length > 0 || this.websocketRouteHandlers.length > 0;
+    }
+    _contextRouteHandlers() {
+        return [...this.routeHandlers];
+    }
+    _findLiveContextRouteHandlerIndex(entry) {
+        return this.routeHandlers.indexOf(entry);
+    }
+    _consumeContextRouteHandler(entry, liveIndex) {
+        if (entry.remainingTimes !== null && entry.remainingTimes <= 1) {
+            this.routeHandlers.splice(liveIndex, 1);
+        }
+        else if (entry.remainingTimes !== null) {
+            entry.remainingTimes -= 1;
+        }
+    }
+    _buildRouteFulfillDecision(request, options) {
+        return buildFulfillDecision(request, options);
+    }
+    _matchesRouteMatcher(url, matcher) {
+        if (url.startsWith("data:")) {
+            return false;
+        }
+        const normalizedUrl = tryParseUrl(url)?.toString() ?? url;
+        return urlMatches(this.options.baseURL, normalizedUrl, matcher, true);
+    }
+    matchesWebSocketRoute(url, matcher) {
+        const normalizedUrl = tryParseUrl(url)?.toString() ?? url;
+        return urlMatches(this.options.baseURL, normalizedUrl, matcher, true);
+    }
+    async installRouteInterceptorsOnPages() {
+        if (this.adapter.setRequestInterceptor) {
+            await this.adapter.setRequestInterceptor((call) => this.dispatchContextRoutedRequest(call));
+            return;
+        }
+        await Promise.all(Array.from(this.pageSet, async (page) => page._ensureRouteInterceptorsInstalled()));
+    }
+    async syncRouteInterceptionOnPages() {
+        if (this.adapter.setRequestInterceptor) {
+            await this.adapter.setRequestInterceptor(this._hasRequestRoutes() ? (call) => this.dispatchContextRoutedRequest(call) : null);
+            return;
+        }
+        await Promise.all(Array.from(this.pageSet, async (page) => page._syncRouteInterceptionForContext()));
+    }
+    async dispatchContextRoutedRequest(call) {
+        let requestState = {
+            ...call,
+            headers: normalizeHeaderRecord(call.headers)
+        };
+        let routedResponse = null;
+        let routedFailure = null;
+        const request = createContextRouteRequest(() => requestState, () => routedResponse, () => routedFailure);
+        const handlers = [...this.routeHandlers];
+        for (let index = handlers.length - 1; index >= 0; index -= 1) {
+            const entry = handlers[index];
+            if (!entry || !this._matchesRouteMatcher(requestState.url, entry.matcher)) {
+                continue;
+            }
+            const liveIndex = this._findLiveContextRouteHandlerIndex(entry);
+            if (liveIndex === -1) {
+                continue;
+            }
+            this._consumeContextRouteHandler(entry, liveIndex);
+            let routeOutcome = null;
+            let routeHandled = false;
+            let resolveRouteHandled;
+            const routeHandledPromise = new Promise((resolve) => {
+                resolveRouteHandled = resolve;
+            });
+            const ensureRouteIsUnhandled = () => {
+                if (routeHandled) {
+                    throw new Error("Route is already handled!");
+                }
+            };
+            const reportRouteHandled = (outcome) => {
+                routeOutcome ??= outcome;
+                resolveRouteHandled(routeOutcome);
+            };
+            const route = {
+                abort: async (errorCode) => {
+                    ensureRouteIsUnhandled();
+                    routeHandled = true;
+                    routedFailure = { errorText: errorCode ?? "failed" };
+                    reportRouteHandled({
+                        kind: "finish",
+                        decision: {
+                            action: "abort",
+                            ...(errorCode !== undefined ? { errorCode } : {})
+                        }
+                    });
+                },
+                continue: async (options) => {
+                    ensureRouteIsUnhandled();
+                    routeHandled = true;
+                    requestState = applyContextRouteOverrides(requestState, options);
+                    reportRouteHandled({
+                        kind: "finish",
+                        decision: {
+                            action: "continue",
+                            headers: { ...requestState.headers },
+                            method: requestState.method,
+                            ...serializePostDataFields(requestState.postData, deserializeSerializedPostData(requestState.postData, requestState.postDataBufferBase64 ?? null).buffer),
+                            url: requestState.url
+                        }
+                    });
+                },
+                fallback: async (options) => {
+                    ensureRouteIsUnhandled();
+                    routeHandled = true;
+                    requestState = applyContextRouteOverrides(requestState, options);
+                    reportRouteHandled({ kind: "fallback" });
+                },
+                fetch: async (options) => {
+                    ensureRouteIsUnhandled();
+                    const fetchedRequest = applyContextRouteOverrides(requestState, options);
+                    const response = await fetchContextRouteRequest(fetchedRequest, options);
+                    routedResponse = createRoutedResponse(await responseDataFromResponse(response), request);
+                    return response;
+                },
+                fulfill: async (options = {}) => {
+                    ensureRouteIsUnhandled();
+                    const decision = await this._buildRouteFulfillDecision(requestState, options);
+                    routeHandled = true;
+                    routedResponse = createRoutedResponse({
+                        body: decision.body,
+                        ...(decision.bodyBufferBase64 != null
+                            ? { bodyBufferBase64: decision.bodyBufferBase64 }
+                            : {}),
+                        headers: { ...decision.headers },
+                        status: decision.status,
+                        statusText: decision.statusText,
+                        url: decision.url
+                    }, request);
+                    reportRouteHandled({
+                        kind: "finish",
+                        decision
+                    });
+                },
+                request: () => request
+            };
+            let resolveInvocation;
+            const invocation = {
+                complete: new Promise((resolve) => {
+                    resolveInvocation = resolve;
+                }),
+                resolve: () => {
+                    resolveInvocation();
+                }
+            };
+            entry.activeInvocations.add(invocation);
+            let resolvedOutcome = null;
+            try {
+                const [handledOutcome] = await Promise.all([
+                    routeHandledPromise,
+                    Promise.resolve().then(() => entry.handler(route, request))
+                ]);
+                resolvedOutcome = handledOutcome;
+            }
+            catch (error) {
+                if (!entry.ignoreExceptions) {
+                    throw error;
+                }
+                resolvedOutcome = routeOutcome;
+            }
+            finally {
+                invocation.resolve();
+                entry.activeInvocations.delete(invocation);
+            }
+            if (!resolvedOutcome) {
+                continue;
+            }
+            if (resolvedOutcome.kind === "fallback") {
+                continue;
+            }
+            return resolvedOutcome.decision;
+        }
+        return {
+            action: "continue",
+            headers: { ...requestState.headers },
+            method: requestState.method,
+            ...serializePostDataFields(requestState.postData, deserializeSerializedPostData(requestState.postData, requestState.postDataBufferBase64 ?? null).buffer),
+            url: requestState.url
+        };
+    }
+    async stopRouteHandlers(entries, behavior) {
+        if (behavior === "ignoreErrors") {
+            for (const entry of entries) {
+                entry.ignoreExceptions = true;
+                for (const invocation of entry.activeInvocations) {
+                    invocation.resolve();
+                }
+            }
+            return;
+        }
+        if (behavior === "wait") {
+            await Promise.all(entries.flatMap((entry) => Array.from(entry.activeInvocations, (invocation) => invocation.complete)));
+        }
+    }
+    routeMatcherKey(matcher) {
+        if (typeof matcher === "string") {
+            return `string:${matcher}`;
+        }
+        if (matcher instanceof RegExp) {
+            return `regexp:${matcher.source}/${matcher.flags}`;
+        }
+        const existing = this.routeMatcherIds.get(matcher);
+        if (existing) {
+            return existing;
+        }
+        const id = `matcher:${++this.nextRouteMatcherId}`;
+        this.routeMatcherIds.set(matcher, id);
+        return id;
+    }
+}
+function tryParseUrl(url) {
+    try {
+        return new URL(url);
+    }
+    catch {
+        return null;
+    }
+}
+function isClosedPageRegistrationError(error) {
+    const message = String(error instanceof Error ? error.message : error).toLowerCase();
+    return (message.includes("target page, context or browser has been closed")
+        || message.includes("browser context has been closed")
+        || message.includes("session closed")
+        || message.includes("session with given id not found")
+        || message.includes("connection closed")
+        || message.includes("target closed")
+        || message.includes("websocket connection closed")
+        || message.includes("write epipe"));
+}
+async function evaluationScript(script, arg) {
+    if (typeof script === "function") {
+        const source = serializePageFunction(script);
+        const argString = Object.is(arg, undefined) ? "undefined" : JSON.stringify(arg);
+        return `(${source})(${argString})`;
+    }
+    if (arg !== undefined) {
+        throw new Error("Cannot evaluate a string with arguments");
+    }
+    if (typeof script === "string") {
+        return script;
+    }
+    if (script.content !== undefined) {
+        return script.content;
+    }
+    if (script.path !== undefined) {
+        const source = await readFile(script.path, "utf8");
+        return `${source}\n//# sourceURL=${script.path.replace(/\n/g, "")}`;
+    }
+    throw new Error("Either path or content property must be present");
+}
+function applyContextRouteOverrides(request, options) {
+    if (!options) {
+        return request;
+    }
+    const headers = options.headers === undefined
+        ? request.headers
+        : Array.isArray(options.headers)
+            ? Object.fromEntries(options.headers.map((header) => [header.name, header.value]))
+            : { ...options.headers };
+    const normalizedPostData = options.postData !== undefined
+        ? normalizeSerializedPostData(options.postData)
+        : deserializeSerializedPostData(request.postData, request.postDataBufferBase64 ?? null);
+    return {
+        ...request,
+        headers,
+        method: options.method ?? request.method,
+        ...serializePostDataFields(normalizedPostData.text, normalizedPostData.buffer),
+        url: options.url ?? request.url
+    };
+}
+function normalizeSerializedPostData(value) {
+    if (value === undefined || value === null) {
+        return { buffer: null, text: null };
+    }
+    if (typeof value === "string") {
+        return {
+            buffer: Buffer.from(value, "utf8"),
+            text: value
+        };
+    }
+    if (Buffer.isBuffer(value)) {
+        return {
+            buffer: Buffer.from(value),
+            text: value.toString("utf8")
+        };
+    }
+    const text = JSON.stringify(value);
+    return {
+        buffer: Buffer.from(text, "utf8"),
+        text
+    };
+}
+function deserializeSerializedPostData(text, base64) {
+    if (base64 !== null) {
+        const buffer = Buffer.from(base64, "base64");
+        return {
+            buffer,
+            text: text ?? buffer.toString("utf8")
+        };
+    }
+    if (text === null) {
+        return { buffer: null, text: null };
+    }
+    return {
+        buffer: Buffer.from(text, "utf8"),
+        text
+    };
+}
+function serializePostDataFields(text, buffer) {
+    return {
+        postData: text,
+        ...(buffer ? { postDataBufferBase64: buffer.toString("base64") } : {})
+    };
+}
+function createContextRouteRequest(current, currentResponse, currentFailure) {
+    return {
+        allHeaders: async () => ({ ...current().headers }),
+        existingResponse: () => currentResponse(),
+        failure: () => currentFailure(),
+        frame: () => {
+            throw new Error("Request.frame is not available for context-level protocol interception.");
+        },
+        headers: () => ({ ...current().headers }),
+        headersArray: async () => Object.entries(current().headers).map(([name, value]) => ({ name, value })),
+        headerValue: async (name) => current().headers[name.toLowerCase()] ?? null,
+        isNavigationRequest: () => current().isNavigationRequest ?? false,
+        method: () => current().method,
+        postData: () => deserializeSerializedPostData(current().postData, current().postDataBufferBase64 ?? null).text,
+        postDataBuffer: () => {
+            const buffer = deserializeSerializedPostData(current().postData, current().postDataBufferBase64 ?? null).buffer;
+            return buffer ? Buffer.from(buffer) : null;
+        },
+        postDataJSON: () => {
+            const { text } = deserializeSerializedPostData(current().postData, current().postDataBufferBase64 ?? null);
+            if (text === null) {
+                return null;
+            }
+            try {
+                return JSON.parse(text);
+            }
+            catch {
+                return null;
+            }
+        },
+        redirectedFrom: () => null,
+        redirectedTo: () => null,
+        resourceType: () => current().resourceType ?? "fetch",
+        response: async () => currentResponse(),
+        serviceWorker: () => null,
+        sizes: async () => {
+            const response = currentResponse();
+            const requestBody = deserializeSerializedPostData(current().postData, current().postDataBufferBase64 ?? null).buffer;
+            const responseHeaders = response ? await response.allHeaders() : {};
+            return {
+                requestBodySize: requestBody?.byteLength ?? 0,
+                requestHeadersSize: headerSize(current().headers),
+                responseBodySize: response ? await measureResponseBodySize(response) : 0,
+                responseHeadersSize: headerSize(responseHeaders)
+            };
+        },
+        timing: () => ({
+            startTime: Date.now(),
+            domainLookupStart: -1,
+            domainLookupEnd: -1,
+            connectStart: -1,
+            secureConnectionStart: -1,
+            connectEnd: -1,
+            requestStart: 0,
+            responseStart: -1,
+            responseEnd: -1
+        }),
+        url: () => current().url
+    };
+}
+async function fetchContextRouteRequest(request, options) {
+    const fetchRequest = applyContextRouteOverrides(request, options);
+    const requestBody = deserializeSerializedPostData(fetchRequest.postData, fetchRequest.postDataBufferBase64 ?? null).buffer;
+    const headers = { ...fetchRequest.headers };
+    if (options?.postData !== undefined && headers["content-type"] === undefined) {
+        if (Buffer.isBuffer(options.postData)) {
+            headers["content-type"] = "application/octet-stream";
+        }
+        else if (typeof options.postData === "object" &&
+            options.postData !== null &&
+            !Buffer.isBuffer(options.postData)) {
+            headers["content-type"] = "application/json";
+        }
+    }
+    const controller = new AbortController();
+    const timeout = options?.timeout ?? DEFAULT_CONTEXT_EVENT_TIMEOUT_MS;
+    const timeoutHandle = timeout > 0
+        ? setTimeout(() => controller.abort(new TimeoutError(`route.fetch: Timeout ${timeout}ms exceeded`)), timeout)
+        : null;
+    try {
+        const response = await fetchWithRetries(fetchRequest.url, {
+            allowGetOrHeadBody: true,
+            ...(!requestBody ? {} : { body: requestBody }),
+            headers,
+            method: fetchRequest.method,
+            signal: controller.signal,
+            ...(options?.maxRedirects !== undefined ? { maxRedirects: options.maxRedirects } : {}),
+            ...(options?.maxRetries !== undefined ? { maxRetries: options.maxRetries } : {})
+        });
+        return createApiResponse(response);
+    }
+    finally {
+        if (timeoutHandle) {
+            clearTimeout(timeoutHandle);
+        }
+    }
+}
+function bufferToText(value) {
+    return Buffer.isBuffer(value) ? value.toString("utf8") : value;
+}
+function normalizeHeaderRecord(headers) {
+    const normalized = {};
+    for (const [name, value] of Object.entries(headers)) {
+        normalized[name.toLowerCase()] = value;
+    }
+    return normalized;
+}
+function hasExplicitHeader(headers, name) {
+    if (!headers) {
+        return false;
+    }
+    return Object.keys(headers).some((headerName) => headerName.toLowerCase() === name.toLowerCase());
+}
+function statusTextForCode(status) {
+    return STATUS_CODES[status] ?? "Unknown";
+}
+function inferMimeType(path) {
+    if (path.endsWith(".html"))
+        return "text/html";
+    if (path.endsWith(".json"))
+        return "application/json";
+    if (path.endsWith(".txt"))
+        return "text/plain";
+    if (path.endsWith(".css"))
+        return "text/css";
+    if (path.endsWith(".js"))
+        return "application/javascript";
+    if (path.endsWith(".svg"))
+        return "image/svg+xml";
+    if (path.endsWith(".png"))
+        return "image/png";
+    if (path.endsWith(".jpg") || path.endsWith(".jpeg"))
+        return "image/jpeg";
+    if (path.endsWith(".webp"))
+        return "image/webp";
+    return "application/octet-stream";
+}
+function headerSize(headers) {
+    return Object.entries(headers).reduce((size, [name, value]) => size + Buffer.byteLength(`${name}: ${value}\r\n`, "utf8"), 2);
+}
+async function measureResponseBodySize(response) {
+    const body = await response.body();
+    return body ? body.length : 0;
+}
+function createRoutedResponse(data, request) {
+    const body = data.bodyBufferBase64 !== undefined
+        ? Buffer.from(data.bodyBufferBase64, "base64")
+        : Buffer.from(data.body, "utf8");
+    return {
+        allHeaders: async () => ({ ...data.headers }),
+        body: async () => Buffer.from(body),
+        finished: async () => null,
+        frame: () => {
+            throw new Error("Response.frame is not available for context-level protocol interception.");
+        },
+        fromServiceWorker: () => false,
+        headerValue: async (name) => data.headers[name.toLowerCase()] ?? null,
+        headerValues: async (name) => {
+            const value = data.headers[name.toLowerCase()];
+            return value === undefined ? [] : [value];
+        },
+        headers: () => ({ ...data.headers }),
+        headersArray: async () => Object.entries(data.headers).map(([name, value]) => ({ name, value })),
+        httpVersion: async () => "HTTP/1.1",
+        json: async () => JSON.parse(body.toString("utf8")),
+        ok: () => data.status >= 200 && data.status <= 299,
+        request: () => request,
+        securityDetails: async () => null,
+        serverAddr: async () => null,
+        status: () => data.status,
+        statusText: () => data.statusText,
+        text: async () => body.toString("utf8"),
+        url: () => data.url
+    };
+}
+async function responseDataFromResponse(response) {
+    const bodyBuffer = await responseBodyBuffer(response);
+    return {
+        body: bodyBuffer.toString("utf8"),
+        ...(bodyBuffer.length ? { bodyBufferBase64: bodyBuffer.toString("base64") } : {}),
+        headers: normalizeHeaderRecord(await responseHeadersRecord(response)),
+        status: getResponseStatus(response),
+        statusText: getResponseStatusText(response),
+        url: response.url()
+    };
+}
+async function responseHeadersRecord(response) {
+    if ("allHeaders" in response && typeof response.allHeaders === "function") {
+        return response.allHeaders();
+    }
+    if (typeof response.headers === "function") {
+        return response.headers();
+    }
+    return Object.fromEntries(response.headers.map((header) => [header.name, header.value]));
+}
+function getResponseStatus(response) {
+    return typeof response.status === "function" ? response.status() : response.status;
+}
+function getResponseStatusText(response) {
+    return typeof response.statusText === "function" ? response.statusText() : response.statusText;
+}
+async function responseBodyBuffer(response) {
+    if ("body" in response && typeof response.body === "function") {
+        return response.body();
+    }
+    return Buffer.from(await response.text(), "utf8");
+}
+async function buildFulfillDecision(request, options) {
+    if (options.json !== undefined && options.body !== undefined) {
+        throw new Error("Can specify either body or json parameters");
+    }
+    const responseHeaders = options.response ? await responseHeadersRecord(options.response) : {};
+    const headers = normalizeHeaderRecord({
+        ...responseHeaders,
+        ...(options.headers ?? {})
+    });
+    let body = "";
+    let bodyBuffer = null;
+    if (options.path) {
+        bodyBuffer = await readFile(options.path);
+        body = bodyBuffer.toString("utf8");
+        if (!hasExplicitHeader(options.headers, "content-type")) {
+            headers["content-type"] = inferMimeType(options.path);
+        }
+    }
+    else if (options.json !== undefined) {
+        body = JSON.stringify(options.json);
+        bodyBuffer = Buffer.from(body, "utf8");
+        if (!("content-type" in headers) && !options.contentType) {
+            headers["content-type"] = "application/json";
+        }
+    }
+    else if (options.body !== undefined) {
+        body = bufferToText(options.body);
+        bodyBuffer = Buffer.isBuffer(options.body)
+            ? Buffer.from(options.body)
+            : Buffer.from(body, "utf8");
+    }
+    else if (options.response) {
+        bodyBuffer = await responseBodyBuffer(options.response);
+        body = bodyBuffer.toString("utf8");
+    }
+    if (options.contentType && !options.path) {
+        headers["content-type"] = options.contentType;
+    }
+    if (bodyBuffer !== null && !hasExplicitHeader(options.headers, "content-length")) {
+        headers["content-length"] = String(bodyBuffer.byteLength);
+    }
+    maybeAddCorsHeaders(request, headers);
+    const inheritedStatus = options.response ? getResponseStatus(options.response) : undefined;
+    const inheritedStatusText = options.response ? getResponseStatusText(options.response) : undefined;
+    const status = options.status ?? inheritedStatus ?? 200;
+    return {
+        action: "fulfill",
+        body,
+        ...(bodyBuffer ? { bodyBufferBase64: bodyBuffer.toString("base64") } : {}),
+        headers,
+        status,
+        statusText: inheritedStatusText ?? statusTextForCode(status),
+        url: request.url
+    };
+}
+function maybeAddCorsHeaders(request, headers) {
+    const origin = request.headers.origin;
+    if (!origin) {
+        return;
+    }
+    let requestUrl;
+    try {
+        requestUrl = new URL(request.url);
+    }
+    catch {
+        return;
+    }
+    if (!requestUrl.protocol.startsWith("http")) {
+        return;
+    }
+    if (requestUrl.origin === origin.trim()) {
+        return;
+    }
+    if (Object.keys(headers).some((name) => name.toLowerCase() === "access-control-allow-origin")) {
+        return;
+    }
+    headers["access-control-allow-origin"] = origin;
+    headers["access-control-allow-credentials"] = "true";
+    headers.vary = "Origin";
+}
+//# sourceMappingURL=browserContext.js.map