@sapiom/browser-pay 0.0.0-stage → 0.1.0

package/dist/esm/interceptor.js

@@ -0,0 +1,946 @@
+import { CdpConnection } from "./cdp.js";
+import { paymentIdempotencyKey, } from "./contract.js";
+import { redactHeld, textHoldsPlaceholderNumber, } from "./detect.js";
+import { isRecord } from "./guards.js";
+import { silentLogger } from "./logger.js";
+import { isRelayTimeout, RelayTimeoutError, } from "./relay.js";
+const DEFAULT_TIMEOUT_MS = 20000;
+const TARGET_FILTER = [{ type: "page" }, { type: "iframe" }];
+const CHILD_FILTER = [{ type: "iframe" }];
+/** GET/HEAD with no body and no held number in the URL. Safe to continue immediately. */
+function canContinueWithoutReading(method, url, hasBody, placeholderNumber) {
+    const verb = method.toUpperCase();
+    if (verb !== "GET" && verb !== "HEAD")
+        return false;
+    if (hasBody)
+        return false;
+    return !textHoldsPlaceholderNumber(url, placeholderNumber);
+}
+/**
+ * Captcha widgets and the session solver. Holding them on Fetch or the
+ * debugger stalls the solver past its own timeout.
+ */
+function isSolverTraffic(url) {
+    let parsed;
+    try {
+        parsed = new URL(url);
+    }
+    catch {
+        return false;
+    }
+    const host = parsed.hostname.toLowerCase();
+    if (host === "hcaptcha.com" ||
+        host.endsWith(".hcaptcha.com") ||
+        host === "recaptcha.net" ||
+        host.endsWith(".recaptcha.net") ||
+        host === "challenges.cloudflare.com" ||
+        host === "anchorbrowser.io" ||
+        host.endsWith(".anchorbrowser.io")) {
+        return true;
+    }
+    return parsed.pathname.toLowerCase().includes("/recaptcha/");
+}
+// CDP writes the body bytes itself. These headers would describe a different
+// representation (gzip, a length from the processor hop) than the bytes we fulfill.
+const RESPONSE_HOP = new Set([
+    "connection",
+    "keep-alive",
+    "transfer-encoding",
+    "te",
+    "trailer",
+    "upgrade",
+    "content-encoding",
+    "content-length",
+]);
+// Blank frames stay armed. Disarming about:blank and arming again on the
+// next URL drops the navigation that leaves the blank document.
+function shouldArm(session) {
+    return !isHandsOffTarget(session);
+}
+function isHandsOffTarget(session) {
+    if (session.type === "worker" ||
+        session.type === "shared_worker" ||
+        session.type === "service_worker") {
+        return true;
+    }
+    if (session.url.startsWith("chrome-extension:"))
+        return true;
+    return isSolverTraffic(session.url);
+}
+export async function attachInterceptor(target, options) {
+    assertAttachOptions(options);
+    const connection = await CdpConnection.connect(resolveCdpUrl(target));
+    try {
+        return await new PaymentInterceptor(connection, options).start();
+    }
+    catch (error) {
+        connection.close();
+        throw error;
+    }
+}
+class PaymentInterceptor {
+    constructor(connection, options) {
+        this.connection = connection;
+        this.options = options;
+        this.sessions = new Map();
+        this.byTarget = new Map();
+        this.enabledSessions = new Set();
+        this.listeners = new Set();
+        this.inflight = new Map();
+        this.relayFlights = new Map();
+        this.unknownKeys = new Set();
+        this.loggedRefusals = new Set();
+        this.pendingArms = new Set();
+        this.backlog = [];
+        this.buffering = true;
+        this.closed = false;
+        this.timeoutMs = options.timeoutMs ?? DEFAULT_TIMEOUT_MS;
+        this.logger = options.logger ?? silentLogger;
+    }
+    get number() {
+        return this.options.placeholder.number;
+    }
+    async start() {
+        this.connection.onEvent((event) => this.dispatch(event));
+        await this.connection.send("Target.setAutoAttach", {
+            autoAttach: true,
+            waitForDebuggerOnStart: true,
+            flatten: true,
+            filter: TARGET_FILTER,
+        });
+        await this.connection
+            .send("Target.setDiscoverTargets", { discover: true })
+            .catch(() => { });
+        await this.attachExistingFrames();
+        await Promise.all([...this.pendingArms]);
+        this.buffering = false;
+        return {
+            on: (listener) => this.subscribe(listener),
+            detach: () => this.detach(),
+        };
+    }
+    dispatch(event) {
+        if (event.method === "Fetch.requestPaused") {
+            this.onPaused(event);
+            return;
+        }
+        if (this.closed)
+            return;
+        if (event.method === "Target.attachedToTarget")
+            this.onAttached(event);
+        else if (event.method === "Target.detachedFromTarget")
+            this.onDetached(event);
+        else if (event.method === "Target.targetInfoChanged") {
+            this.onTargetInfoChanged(event);
+        }
+    }
+    onAttached(event) {
+        const params = parseAttachedTarget(event.params);
+        if (!params)
+            return;
+        const sessionId = params.sessionId;
+        const info = params.targetInfo;
+        if (this.byTarget.has(info.targetId)) {
+            // setAutoAttach already owns this target. A second session would pause
+            // every request twice.
+            void this.resumeIfWaiting(sessionId, params.waitingForDebugger).then(() => this.connection
+                .send("Target.detachFromTarget", { sessionId })
+                .catch(() => { }));
+            return;
+        }
+        const session = this.trackSession({
+            sessionId,
+            targetId: info.targetId,
+            type: info.type,
+            url: info.url,
+            fetchEnabled: false,
+            ...(event.sessionId ? { parentSessionId: event.sessionId } : {}),
+        });
+        const arm = (async () => {
+            if (info.type === "page" || info.type === "iframe") {
+                await this.autoAttachChildren(sessionId);
+            }
+            await this.enableSession(session.sessionId, params.waitingForDebugger);
+        })();
+        this.pendingArms.add(arm);
+        void arm.finally(() => {
+            this.pendingArms.delete(arm);
+        });
+    }
+    onDetached(event) {
+        const sessionId = readStringField(event.params, "sessionId");
+        if (!sessionId)
+            return;
+        const session = this.sessions.get(sessionId);
+        if (!session)
+            return;
+        this.sessions.delete(sessionId);
+        this.enabledSessions.delete(sessionId);
+        if (this.byTarget.get(session.targetId) === session) {
+            this.byTarget.delete(session.targetId);
+        }
+    }
+    onTargetInfoChanged(event) {
+        const info = parseTargetInfoChange(event.params);
+        if (!info)
+            return;
+        const session = this.byTarget.get(info.targetId);
+        if (!session)
+            return;
+        session.url = info.url;
+        if (!shouldArm(session)) {
+            this.disarm(session);
+            return;
+        }
+        if (!session.fetchEnabled)
+            void this.armOrClose(session);
+    }
+    disarm(session) {
+        if (session.fetchEnabled) {
+            session.fetchEnabled = false;
+            void this.connection
+                .send("Fetch.disable", {}, session.sessionId)
+                .catch(() => { });
+        }
+        void this.resumeIfWaiting(session.sessionId, true);
+    }
+    async enableSession(sessionId, waitingForDebugger) {
+        if (this.enabledSessions.has(sessionId)) {
+            await this.resumeIfWaiting(sessionId, waitingForDebugger);
+            return;
+        }
+        this.enabledSessions.add(sessionId);
+        const session = this.sessions.get(sessionId);
+        if (!session || !shouldArm(session)) {
+            await this.resumeIfWaiting(sessionId, waitingForDebugger);
+            return;
+        }
+        // Fetch has to be on before the target runs, or the card iframe can post
+        // before we are listening.
+        const armed = await this.armOrClose(session);
+        if (!armed)
+            return;
+        await this.resumeIfWaiting(sessionId, waitingForDebugger);
+    }
+    async armOrClose(session) {
+        const armed = await armFetch(this.connection, session);
+        if (armed)
+            return true;
+        if (this.closed)
+            return false;
+        this.emit({
+            type: "failed",
+            url: this.safe(session.url || session.targetId),
+            reason: "intercept_unavailable",
+        });
+        await this.connection
+            .send("Target.closeTarget", { targetId: session.targetId })
+            .catch(() => { });
+        return false;
+    }
+    async autoAttachChildren(sessionId) {
+        await this.connection
+            .send("Target.setAutoAttach", {
+            autoAttach: true,
+            waitForDebuggerOnStart: true,
+            flatten: true,
+            filter: CHILD_FILTER,
+        }, sessionId)
+            .catch(() => { });
+    }
+    async resumeIfWaiting(sessionId, waitingForDebugger) {
+        if (!waitingForDebugger)
+            return;
+        await this.connection
+            .send("Runtime.runIfWaitingForDebugger", {}, sessionId)
+            .catch(() => { });
+    }
+    async attachExistingFrames() {
+        const listed = await this.connection
+            .send("Target.getTargets")
+            .catch(() => undefined);
+        for (const info of parseTargetInfos(listed)) {
+            if (info.type !== "iframe")
+                continue;
+            if (this.byTarget.has(info.targetId))
+                continue;
+            const attached = await this.connection
+                .send("Target.attachToTarget", {
+                targetId: info.targetId,
+                flatten: true,
+            })
+                .catch(() => undefined);
+            const sessionId = readAttachedSessionId(attached);
+            if (!sessionId || this.sessions.has(sessionId))
+                continue;
+            const session = this.trackSession({
+                sessionId,
+                targetId: info.targetId,
+                type: "iframe",
+                url: info.url,
+                fetchEnabled: false,
+            });
+            await this.autoAttachChildren(sessionId);
+            await this.enableSession(session.sessionId, false);
+        }
+    }
+    trackSession(session) {
+        this.sessions.set(session.sessionId, session);
+        this.byTarget.set(session.targetId, session);
+        return session;
+    }
+    onPaused(event) {
+        const sessionId = event.sessionId;
+        const parsed = parsePaused(event.params);
+        if (!sessionId || !parsed)
+            return;
+        const { requestId, request } = parsed;
+        if (!this.sessions.has(sessionId)) {
+            void failRequest(this.connection, sessionId, requestId);
+            this.emit({
+                type: "failed",
+                url: this.safe(request.url),
+                reason: "unknown_session",
+            });
+            return;
+        }
+        const key = inflightKey(sessionId, requestId);
+        if (this.inflight.has(key))
+            return;
+        const entry = {
+            key,
+            sessionId,
+            requestId,
+            phase: { status: "open" },
+        };
+        this.inflight.set(key, entry);
+        if (canContinueWithoutReading(request.method, request.url, postDataPlan(request) !== "empty", this.number)) {
+            void this.settle(entry, "continue");
+            return;
+        }
+        void this.handlePaused(entry, request);
+    }
+    async handlePaused(entry, request) {
+        const safeUrl = this.safe(request.url);
+        try {
+            const decision = await this.decide(entry, request, safeUrl);
+            await this.apply(entry, safeUrl, decision);
+        }
+        catch {
+            await this.settle(entry, "fail");
+            this.emit({ type: "failed", url: safeUrl, reason: "network" });
+        }
+    }
+    async decide(entry, request, safeUrl) {
+        const read = await this.readHeld(entry.sessionId, request);
+        if (read.kind === "unreadable") {
+            return { action: "fail", reason: "unreadable_body" };
+        }
+        if (read.kind === "miss")
+            return { action: "continue" };
+        if (this.closed)
+            return { action: "fail", reason: "detached" };
+        const targetType = this.sessions.get(entry.sessionId)?.type ?? "";
+        this.emit({
+            type: "paused",
+            url: safeUrl,
+            method: request.method,
+            targetType,
+        });
+        const pageOrigin = await readPageOrigin(this.connection, this.sessions, entry.sessionId);
+        if (!pageOrigin || this.closed) {
+            return {
+                action: "fail",
+                reason: pageOrigin ? "detached" : "page_origin",
+            };
+        }
+        const idempotencyKey = paymentIdempotencyKey(request.method, request.url, read.body);
+        if (this.unknownKeys.has(idempotencyKey)) {
+            return { action: "fail", reason: "unknown" };
+        }
+        const relayed = await this.callRelay(request, read.body, pageOrigin, idempotencyKey);
+        if (relayed.action === "fail")
+            return relayed;
+        return this.decisionForOutcome(relayed.response, idempotencyKey);
+    }
+    async readHeld(sessionId, request) {
+        const urlHeld = textHoldsPlaceholderNumber(request.url, this.number);
+        if (urlHeld && this.closed)
+            return { kind: "held", body: "" };
+        if (postDataPlan(request) === "empty") {
+            return urlHeld ? { kind: "held", body: "" } : { kind: "miss" };
+        }
+        const body = await readBody(this.connection, sessionId, request);
+        if (body === undefined)
+            return { kind: "unreadable" };
+        if (urlHeld || textHoldsPlaceholderNumber(body, this.number)) {
+            return { kind: "held", body };
+        }
+        return { kind: "miss" };
+    }
+    async callRelay(request, body, pageOrigin, idempotencyKey) {
+        const flight = this.relayOnce(idempotencyKey, (signal) => this.options.relay.relay({
+            injectionRef: this.options.placeholder.injectionRef,
+            profileId: this.options.profileId,
+            pageOrigin,
+            request: {
+                method: request.method,
+                url: request.url,
+                headers: forwardedHeaders(request.headers),
+                body,
+            },
+            idempotencyKey,
+        }, { signal }));
+        try {
+            const response = await failAfter(flight.promise, this.timeoutMs);
+            this.releaseWaiter(flight);
+            return { action: "ok", response };
+        }
+        catch (error) {
+            this.releaseWaiter(flight);
+            return {
+                action: "fail",
+                reason: this.closed ? "detached" : failureReason(error),
+            };
+        }
+    }
+    decisionForOutcome(response, idempotencyKey) {
+        if (response.outcome === "unknown") {
+            this.unknownKeys.add(idempotencyKey);
+            return { action: "fail", reason: "unknown" };
+        }
+        if (response.outcome === "refused") {
+            this.logRefusalOnce(idempotencyKey, response.reason);
+            return { action: "refused", reason: response.reason };
+        }
+        if (textHoldsPlaceholderNumber(response.response.body, this.number)) {
+            return { action: "fail", reason: "response_credential" };
+        }
+        return { action: "relayed", response: response.response };
+    }
+    logRefusalOnce(idempotencyKey, reason) {
+        if (this.loggedRefusals.has(idempotencyKey))
+            return;
+        this.loggedRefusals.add(idempotencyKey);
+        this.logger.warn("payment relay refused the paused request", { reason });
+    }
+    async apply(entry, safeUrl, decision) {
+        if (decision.action === "continue") {
+            await this.settle(entry, "continue");
+            return;
+        }
+        if (decision.action === "fail") {
+            await this.settle(entry, "fail");
+            this.emit({ type: "failed", url: safeUrl, reason: decision.reason });
+            return;
+        }
+        if (decision.action === "refused") {
+            await this.settle(entry, "fail");
+            this.emit({ type: "refused", url: safeUrl, reason: decision.reason });
+            return;
+        }
+        const fulfilled = await this.settle(entry, { fulfill: decision.response });
+        this.emit(fulfilled
+            ? { type: "relayed", url: safeUrl, status: decision.response.status }
+            : {
+                type: "relayed_unfulfilled",
+                url: safeUrl,
+                status: decision.response.status,
+            });
+    }
+    async settle(entry, action) {
+        if (entry.phase.status !== "open")
+            return false;
+        if (action === "continue") {
+            const done = continueRequest(this.connection, entry.sessionId, entry.requestId).finally(() => {
+                entry.phase = { status: "done" };
+                this.inflight.delete(entry.key);
+            });
+            entry.phase = { status: "continuing", done };
+            await done;
+            return true;
+        }
+        entry.phase = { status: "done" };
+        try {
+            if (action === "fail") {
+                await failRequest(this.connection, entry.sessionId, entry.requestId);
+                return true;
+            }
+            await fulfillRequest(this.connection, entry.sessionId, entry.requestId, action.fulfill);
+            return true;
+        }
+        catch {
+            await failRequest(this.connection, entry.sessionId, entry.requestId);
+            return false;
+        }
+        finally {
+            this.inflight.delete(entry.key);
+        }
+    }
+    async drainInflight() {
+        const entries = [...this.inflight.values()];
+        await Promise.all(entries.map(async (entry) => {
+            if (entry.phase.status === "continuing") {
+                await entry.phase.done;
+                return;
+            }
+            if (entry.phase.status === "open")
+                await this.settle(entry, "fail");
+        }));
+    }
+    relayOnce(key, start) {
+        const existing = this.relayFlights.get(key);
+        if (existing && !existing.controller.signal.aborted) {
+            existing.waiters += 1;
+            return existing;
+        }
+        const controller = new AbortController();
+        const promise = start(controller.signal).finally(() => {
+            const current = this.relayFlights.get(key);
+            if (current?.controller === controller)
+                this.relayFlights.delete(key);
+        });
+        void promise.catch(() => { });
+        const flight = { controller, waiters: 1, promise };
+        this.relayFlights.set(key, flight);
+        return flight;
+    }
+    releaseWaiter(flight) {
+        flight.waiters -= 1;
+        if (flight.waiters > 0)
+            return;
+        flight.controller.abort();
+    }
+    async detach() {
+        if (this.closed)
+            return;
+        this.closed = true;
+        this.buffering = false;
+        this.backlog = null;
+        for (const flight of this.relayFlights.values())
+            flight.controller.abort();
+        await this.drainInflight();
+        for (const sessionId of this.sessions.keys()) {
+            await this.connection
+                .send("Fetch.disable", {}, sessionId)
+                .catch(() => { });
+        }
+        // A pause delivered while disable was in flight is still failed or
+        // continued here, before the socket goes away.
+        await this.drainInflight();
+        await this.connection
+            .send("Target.setAutoAttach", {
+            autoAttach: false,
+            waitForDebuggerOnStart: false,
+            flatten: true,
+        })
+            .catch(() => { });
+        this.connection.close();
+    }
+    subscribe(listener) {
+        const missed = this.backlog;
+        this.backlog = null;
+        this.listeners.add(listener);
+        if (missed) {
+            for (const event of missed)
+                this.deliver(listener, event);
+        }
+        return () => {
+            this.listeners.delete(listener);
+        };
+    }
+    emit(event) {
+        if (this.buffering && this.backlog) {
+            this.backlog.push(event);
+            return;
+        }
+        for (const listener of this.listeners)
+            this.deliver(listener, event);
+    }
+    deliver(listener, event) {
+        try {
+            listener(event);
+        }
+        catch {
+            // A listener must not break interception.
+        }
+    }
+    safe(value) {
+        return redactHeld(value, this.number);
+    }
+}
+function inflightKey(sessionId, requestId) {
+    return `${sessionId}\n${requestId}`;
+}
+function failureReason(error) {
+    return isRelayTimeout(error) ? "timeout" : "network";
+}
+function failAfter(promise, ms) {
+    return new Promise((resolve, reject) => {
+        const timer = setTimeout(() => {
+            reject(new RelayTimeoutError());
+        }, ms);
+        promise.then((value) => {
+            clearTimeout(timer);
+            resolve(value);
+        }, (error) => {
+            clearTimeout(timer);
+            reject(error instanceof Error ? error : new Error("Payment relay failed"));
+        });
+    });
+}
+function postDataPlan(request) {
+    if (typeof request.postData === "string" && request.postData.length > 0) {
+        return "inline";
+    }
+    if (request.postDataEntries && request.postDataEntries.length > 0) {
+        const missing = request.postDataEntries.some((entry) => typeof entry.bytes !== "string" || entry.bytes.length === 0);
+        return missing ? "fetch" : "entries";
+    }
+    if (request.hasPostData)
+        return "fetch";
+    return "empty";
+}
+async function readBody(connection, sessionId, request) {
+    const plan = postDataPlan(request);
+    if (plan === "empty")
+        return "";
+    if (plan === "inline")
+        return request.postData ?? "";
+    if (plan === "entries") {
+        return Buffer.concat((request.postDataEntries ?? []).map((entry) => Buffer.from(entry.bytes ?? "", "base64"))).toString("utf8");
+    }
+    if (!request.networkId)
+        return undefined;
+    try {
+        const result = await connection.send("Network.getRequestPostData", { requestId: request.networkId }, sessionId);
+        const postData = readStringField(result, "postData");
+        if (!postData)
+            return undefined;
+        const body = isRecord(result) && result.base64Encoded === true
+            ? Buffer.from(postData, "base64").toString("utf8")
+            : postData;
+        if (isMultipart(request.headers) && multipartOmitsFileBytes(body)) {
+            return undefined;
+        }
+        return body;
+    }
+    catch {
+        return undefined;
+    }
+}
+async function readPageOrigin(connection, sessions, sessionId) {
+    const pageSessionId = topPageSession(sessions, sessionId);
+    if (pageSessionId) {
+        const fromPage = await originFromSession(connection, sessions, pageSessionId);
+        if (fromPage)
+            return fromPage;
+    }
+    const ancestors = await connection
+        .send("Runtime.evaluate", {
+        expression: "location.ancestorOrigins[location.ancestorOrigins.length - 1]",
+        returnByValue: true,
+    }, sessionId)
+        .catch(() => null);
+    const value = evaluatedString(ancestors);
+    if (value && /^https?:\/\//.test(value))
+        return value;
+    return undefined;
+}
+async function originFromSession(connection, sessions, sessionId) {
+    const evaluated = await connection
+        .send("Runtime.evaluate", { expression: "location.origin", returnByValue: true }, sessionId)
+        .catch(() => null);
+    const value = evaluatedString(evaluated);
+    if (value && /^https?:\/\//.test(value))
+        return value;
+    const url = sessions.get(sessionId)?.url;
+    if (!url)
+        return undefined;
+    try {
+        const origin = new URL(url).origin;
+        return /^https?:\/\//.test(origin) ? origin : undefined;
+    }
+    catch {
+        return undefined;
+    }
+}
+function topPageSession(sessions, sessionId) {
+    let current = sessionId;
+    const visited = new Set();
+    while (current && !visited.has(current)) {
+        visited.add(current);
+        const session = sessions.get(current);
+        if (!session)
+            break;
+        if (session.type === "page")
+            return current;
+        if (!session.parentSessionId)
+            break;
+        current = session.parentSessionId;
+    }
+    const pages = [...sessions.values()].filter((session) => session.type === "page");
+    if (pages.length === 1)
+        return pages[0].sessionId;
+    return undefined;
+}
+const FORWARDED_HEADERS = new Set([
+    "accept",
+    "content-type",
+    "shopify-identification-signature",
+]);
+function forwardedHeaders(raw) {
+    const out = {};
+    const take = (name, value) => {
+        const key = name.toLowerCase();
+        if (!FORWARDED_HEADERS.has(key) || value.length > 8192)
+            return;
+        out[key] = value;
+    };
+    if (Array.isArray(raw)) {
+        for (const entry of raw) {
+            if (Array.isArray(entry) &&
+                entry.length === 2 &&
+                typeof entry[0] === "string" &&
+                typeof entry[1] === "string") {
+                take(entry[0], entry[1]);
+                continue;
+            }
+            if (isRecord(entry) && typeof entry.name === "string") {
+                take(entry.name, typeof entry.value === "string" ? entry.value : "");
+            }
+        }
+        return out;
+    }
+    if (isRecord(raw)) {
+        for (const [key, value] of Object.entries(raw)) {
+            if (typeof value === "string")
+                take(key, value);
+        }
+    }
+    return out;
+}
+function parseAttachedTarget(value) {
+    if (!isRecord(value) || typeof value.sessionId !== "string")
+        return undefined;
+    if (!isRecord(value.targetInfo))
+        return undefined;
+    const info = value.targetInfo;
+    if (typeof info.targetId !== "string" || typeof info.type !== "string") {
+        return undefined;
+    }
+    return {
+        sessionId: value.sessionId,
+        waitingForDebugger: value.waitingForDebugger === true,
+        targetInfo: {
+            targetId: info.targetId,
+            type: info.type,
+            url: typeof info.url === "string" ? info.url : "",
+        },
+    };
+}
+function parsePaused(value) {
+    if (!isRecord(value) || typeof value.requestId !== "string")
+        return undefined;
+    if (!isRecord(value.request))
+        return undefined;
+    const request = value.request;
+    return {
+        requestId: value.requestId,
+        request: {
+            url: typeof request.url === "string" ? request.url : "",
+            method: typeof request.method === "string" ? request.method : "GET",
+            headers: request.headers,
+            postData: typeof request.postData === "string" ? request.postData : undefined,
+            hasPostData: request.hasPostData === true,
+            postDataEntries: parsePostDataEntries(request.postDataEntries),
+            ...(typeof value.networkId === "string" && value.networkId.length > 0
+                ? { networkId: value.networkId }
+                : {}),
+        },
+    };
+}
+function parsePostDataEntries(value) {
+    if (!Array.isArray(value))
+        return undefined;
+    const entries = [];
+    for (const entry of value) {
+        if (!isRecord(entry)) {
+            entries.push({});
+            continue;
+        }
+        entries.push(typeof entry.bytes === "string" ? { bytes: entry.bytes } : {});
+    }
+    return entries;
+}
+function parseTargetInfoChange(value) {
+    if (!isRecord(value) || !isRecord(value.targetInfo))
+        return undefined;
+    const info = value.targetInfo;
+    if (typeof info.targetId !== "string" || typeof info.url !== "string") {
+        return undefined;
+    }
+    return { targetId: info.targetId, url: info.url };
+}
+function evaluatedString(value) {
+    if (!isRecord(value) || !isRecord(value.result))
+        return undefined;
+    return typeof value.result.value === "string"
+        ? value.result.value
+        : undefined;
+}
+function readStringField(value, key) {
+    if (!isRecord(value))
+        return undefined;
+    const field = value[key];
+    return typeof field === "string" ? field : undefined;
+}
+function headerValue(headers, name) {
+    const wanted = name.toLowerCase();
+    if (Array.isArray(headers)) {
+        for (const entry of headers) {
+            if (Array.isArray(entry) &&
+                entry.length === 2 &&
+                typeof entry[0] === "string" &&
+                typeof entry[1] === "string" &&
+                entry[0].toLowerCase() === wanted) {
+                return entry[1];
+            }
+            if (isRecord(entry) &&
+                typeof entry.name === "string" &&
+                entry.name.toLowerCase() === wanted &&
+                typeof entry.value === "string") {
+                return entry.value;
+            }
+        }
+        return "";
+    }
+    if (isRecord(headers)) {
+        for (const [key, value] of Object.entries(headers)) {
+            if (key.toLowerCase() === wanted && typeof value === "string") {
+                return value;
+            }
+        }
+    }
+    return "";
+}
+function isMultipart(headers) {
+    return headerValue(headers, "content-type")
+        .toLowerCase()
+        .includes("multipart/");
+}
+// The retrieved body keeps a file part's filename header and drops its bytes.
+function multipartOmitsFileBytes(body) {
+    return /content-disposition:[^\r\n]*[;\s]filename\s*\*?=/i.test(body);
+}
+async function armFetch(connection, session) {
+    if (session.fetchEnabled)
+        return true;
+    try {
+        await connection
+            .send("Network.enable", {}, session.sessionId)
+            .catch(() => { });
+        await connection.send("Fetch.enable", { patterns: [{ urlPattern: "*", requestStage: "Request" }] }, session.sessionId);
+    }
+    catch {
+        return false;
+    }
+    session.fetchEnabled = true;
+    return true;
+}
+async function continueRequest(connection, sessionId, requestId) {
+    try {
+        await connection.send("Fetch.continueRequest", { requestId }, sessionId);
+    }
+    catch {
+        await failRequest(connection, sessionId, requestId);
+    }
+}
+async function failRequest(connection, sessionId, requestId) {
+    await connection
+        .send("Fetch.failRequest", { requestId, errorReason: "BlockedByClient" }, sessionId)
+        .catch(() => { });
+}
+async function fulfillRequest(connection, sessionId, requestId, response) {
+    const responseHeaders = Object.entries(response.headers).flatMap(([name, value]) => {
+        if (RESPONSE_HOP.has(name.toLowerCase()))
+            return [];
+        return [{ name, value }];
+    });
+    await connection.send("Fetch.fulfillRequest", {
+        requestId,
+        responseCode: response.status,
+        responseHeaders,
+        body: Buffer.from(response.body, "utf8").toString("base64"),
+    }, sessionId);
+}
+function parseTargetInfos(value) {
+    if (!isRecord(value) || !Array.isArray(value.targetInfos))
+        return [];
+    const infos = [];
+    for (const entry of value.targetInfos) {
+        if (!isRecord(entry))
+            continue;
+        if (typeof entry.targetId !== "string" || typeof entry.type !== "string") {
+            continue;
+        }
+        infos.push({
+            targetId: entry.targetId,
+            type: entry.type,
+            url: typeof entry.url === "string" ? entry.url : "",
+        });
+    }
+    return infos;
+}
+function readAttachedSessionId(value) {
+    if (!isRecord(value) || typeof value.sessionId !== "string")
+        return undefined;
+    return value.sessionId.length > 0 ? value.sessionId : undefined;
+}
+function assertAttachOptions(options) {
+    if (typeof options.relay?.relay !== "function") {
+        throw new Error("A payment relay is required");
+    }
+    if (!options.profileId) {
+        throw new Error("profileId is required");
+    }
+    const digits = options.placeholder?.number?.replace(/\D/g, "") ?? "";
+    if (!options.placeholder?.injectionRef || digits.length === 0) {
+        throw new Error("placeholder.injectionRef and placeholder.number are required");
+    }
+}
+function resolveCdpUrl(target) {
+    if (typeof target === "string") {
+        if (!target)
+            throw new Error("A CDP websocket URL is required");
+        return target;
+    }
+    const direct = callString(target, "wsEndpoint");
+    if (direct)
+        return direct;
+    const browser = callObject(target, "browser");
+    const fromBrowser = browser ? callString(browser, "wsEndpoint") : undefined;
+    if (fromBrowser)
+        return fromBrowser;
+    const context = callObject(target, "context");
+    const nested = context ? callObject(context, "browser") : undefined;
+    const fromContext = nested ? callString(nested, "wsEndpoint") : undefined;
+    if (fromContext)
+        return fromContext;
+    throw new Error("Pass a CDP websocket URL, or a Playwright/Puppeteer browser or page whose browser exposes wsEndpoint()");
+}
+function callString(target, key) {
+    const method = Reflect.get(target, key);
+    if (typeof method !== "function")
+        return undefined;
+    const value = method.call(target);
+    return typeof value === "string" && value.length > 0 ? value : undefined;
+}
+function callObject(target, key) {
+    const method = Reflect.get(target, key);
+    if (typeof method !== "function")
+        return undefined;
+    const value = method.call(target);
+    return typeof value === "object" && value !== null ? value : undefined;
+}
+//# sourceMappingURL=interceptor.js.map