708 lines
31 KiB
Plaintext
708 lines
31 KiB
Plaintext
"use strict";
|
|
var __create = Object.create;
|
|
var __defProp = Object.defineProperty;
|
|
var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
|
|
var __getOwnPropNames = Object.getOwnPropertyNames;
|
|
var __getProtoOf = Object.getPrototypeOf;
|
|
var __hasOwnProp = Object.prototype.hasOwnProperty;
|
|
var __export = (target, all) => {
|
|
for (var name in all)
|
|
__defProp(target, name, { get: all[name], enumerable: true });
|
|
};
|
|
var __copyProps = (to, from, except, desc) => {
|
|
if (from && typeof from === "object" || typeof from === "function") {
|
|
for (let key of __getOwnPropNames(from))
|
|
if (!__hasOwnProp.call(to, key) && key !== except)
|
|
__defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
|
|
}
|
|
return to;
|
|
};
|
|
var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
|
|
// If the importer is in node compatibility mode or this is not an ESM
|
|
// file that has been converted to a CommonJS file using a Babel-
|
|
// compatible transform (i.e. "__esModule" has not been set), then set
|
|
// "default" to the CommonJS "module.exports" for node compatibility.
|
|
isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
|
|
mod
|
|
));
|
|
var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
|
|
var crNetworkManager_exports = {};
|
|
__export(crNetworkManager_exports, {
|
|
CRNetworkManager: () => CRNetworkManager
|
|
});
|
|
module.exports = __toCommonJS(crNetworkManager_exports);
|
|
var import_utils = require("../../utils");
|
|
var import_eventsHelper = require("../utils/eventsHelper");
|
|
var import_helper = require("../helper");
|
|
var network = __toESM(require("../network"));
|
|
var import_protocolError = require("../protocolError");
|
|
class CRNetworkManager {
|
|
constructor(page, serviceWorker) {
|
|
this._requestIdToRequest = /* @__PURE__ */ new Map();
|
|
this._requestIdToRequestWillBeSentEvent = /* @__PURE__ */ new Map();
|
|
this._credentials = null;
|
|
this._attemptedAuthentications = /* @__PURE__ */ new Set();
|
|
this._userRequestInterceptionEnabled = false;
|
|
this._protocolRequestInterceptionEnabled = false;
|
|
this._offline = false;
|
|
this._extraHTTPHeaders = [];
|
|
this._requestIdToRequestPausedEvent = /* @__PURE__ */ new Map();
|
|
this._responseExtraInfoTracker = new ResponseExtraInfoTracker();
|
|
this._sessions = /* @__PURE__ */ new Map();
|
|
this._page = page;
|
|
this._serviceWorker = serviceWorker;
|
|
}
|
|
async addSession(session, workerFrame, isMain) {
|
|
const sessionInfo = { session, isMain, workerFrame, eventListeners: [] };
|
|
sessionInfo.eventListeners = [
|
|
import_eventsHelper.eventsHelper.addEventListener(session, "Fetch.requestPaused", this._onRequestPaused.bind(this, sessionInfo)),
|
|
import_eventsHelper.eventsHelper.addEventListener(session, "Fetch.authRequired", this._onAuthRequired.bind(this, sessionInfo)),
|
|
import_eventsHelper.eventsHelper.addEventListener(session, "Network.requestWillBeSent", this._onRequestWillBeSent.bind(this, sessionInfo)),
|
|
import_eventsHelper.eventsHelper.addEventListener(session, "Network.requestWillBeSentExtraInfo", this._onRequestWillBeSentExtraInfo.bind(this)),
|
|
import_eventsHelper.eventsHelper.addEventListener(session, "Network.requestServedFromCache", this._onRequestServedFromCache.bind(this)),
|
|
import_eventsHelper.eventsHelper.addEventListener(session, "Network.responseReceived", this._onResponseReceived.bind(this, sessionInfo)),
|
|
import_eventsHelper.eventsHelper.addEventListener(session, "Network.responseReceivedExtraInfo", this._onResponseReceivedExtraInfo.bind(this)),
|
|
import_eventsHelper.eventsHelper.addEventListener(session, "Network.loadingFinished", this._onLoadingFinished.bind(this, sessionInfo)),
|
|
import_eventsHelper.eventsHelper.addEventListener(session, "Network.loadingFailed", this._onLoadingFailed.bind(this, sessionInfo))
|
|
];
|
|
if (this._page) {
|
|
sessionInfo.eventListeners.push(...[
|
|
import_eventsHelper.eventsHelper.addEventListener(session, "Network.webSocketCreated", (e) => this._page.frameManager.onWebSocketCreated(e.requestId, e.url)),
|
|
import_eventsHelper.eventsHelper.addEventListener(session, "Network.webSocketWillSendHandshakeRequest", (e) => this._page.frameManager.onWebSocketRequest(e.requestId)),
|
|
import_eventsHelper.eventsHelper.addEventListener(session, "Network.webSocketHandshakeResponseReceived", (e) => this._page.frameManager.onWebSocketResponse(e.requestId, e.response.status, e.response.statusText)),
|
|
import_eventsHelper.eventsHelper.addEventListener(session, "Network.webSocketFrameSent", (e) => e.response.payloadData && this._page.frameManager.onWebSocketFrameSent(e.requestId, e.response.opcode, e.response.payloadData)),
|
|
import_eventsHelper.eventsHelper.addEventListener(session, "Network.webSocketFrameReceived", (e) => e.response.payloadData && this._page.frameManager.webSocketFrameReceived(e.requestId, e.response.opcode, e.response.payloadData)),
|
|
import_eventsHelper.eventsHelper.addEventListener(session, "Network.webSocketClosed", (e) => this._page.frameManager.webSocketClosed(e.requestId)),
|
|
import_eventsHelper.eventsHelper.addEventListener(session, "Network.webSocketFrameError", (e) => this._page.frameManager.webSocketError(e.requestId, e.errorMessage))
|
|
]);
|
|
}
|
|
this._sessions.set(session, sessionInfo);
|
|
await Promise.all([
|
|
session.send("Network.enable"),
|
|
this._updateProtocolRequestInterceptionForSession(
|
|
sessionInfo,
|
|
true
|
|
/* initial */
|
|
),
|
|
this._setOfflineForSession(
|
|
sessionInfo,
|
|
true
|
|
/* initial */
|
|
),
|
|
this._setExtraHTTPHeadersForSession(
|
|
sessionInfo,
|
|
true
|
|
/* initial */
|
|
)
|
|
]);
|
|
}
|
|
removeSession(session) {
|
|
const info = this._sessions.get(session);
|
|
if (info)
|
|
import_eventsHelper.eventsHelper.removeEventListeners(info.eventListeners);
|
|
this._sessions.delete(session);
|
|
}
|
|
async _forEachSession(cb) {
|
|
await Promise.all([...this._sessions.values()].map((info) => {
|
|
if (info.isMain)
|
|
return cb(info);
|
|
return cb(info).catch((e) => {
|
|
if ((0, import_protocolError.isSessionClosedError)(e))
|
|
return;
|
|
throw e;
|
|
});
|
|
}));
|
|
}
|
|
async authenticate(credentials) {
|
|
this._credentials = credentials;
|
|
await this._updateProtocolRequestInterception();
|
|
}
|
|
async setOffline(offline) {
|
|
if (offline === this._offline)
|
|
return;
|
|
this._offline = offline;
|
|
await this._forEachSession((info) => this._setOfflineForSession(info));
|
|
}
|
|
async _setOfflineForSession(info, initial) {
|
|
if (initial && !this._offline)
|
|
return;
|
|
if (info.workerFrame)
|
|
return;
|
|
await info.session.send("Network.emulateNetworkConditions", {
|
|
offline: this._offline,
|
|
// values of 0 remove any active throttling. crbug.com/456324#c9
|
|
latency: 0,
|
|
downloadThroughput: -1,
|
|
uploadThroughput: -1
|
|
});
|
|
}
|
|
async setRequestInterception(value) {
|
|
this._userRequestInterceptionEnabled = value;
|
|
await this._updateProtocolRequestInterception();
|
|
}
|
|
async _updateProtocolRequestInterception() {
|
|
const enabled = this._userRequestInterceptionEnabled || !!this._credentials;
|
|
if (enabled === this._protocolRequestInterceptionEnabled)
|
|
return;
|
|
this._protocolRequestInterceptionEnabled = enabled;
|
|
await this._forEachSession((info) => this._updateProtocolRequestInterceptionForSession(info));
|
|
}
|
|
async _updateProtocolRequestInterceptionForSession(info, initial) {
|
|
const enabled = this._protocolRequestInterceptionEnabled;
|
|
if (initial && !enabled)
|
|
return;
|
|
const cachePromise = info.session.send("Network.setCacheDisabled", { cacheDisabled: enabled });
|
|
let fetchPromise = Promise.resolve(void 0);
|
|
if (!info.workerFrame) {
|
|
if (enabled)
|
|
fetchPromise = info.session.send("Fetch.enable", { handleAuthRequests: true, patterns: [{ urlPattern: "*", requestStage: "Request" }] });
|
|
else
|
|
fetchPromise = info.session.send("Fetch.disable");
|
|
}
|
|
await Promise.all([cachePromise, fetchPromise]);
|
|
}
|
|
async setExtraHTTPHeaders(extraHTTPHeaders) {
|
|
if (!this._extraHTTPHeaders.length && !extraHTTPHeaders.length)
|
|
return;
|
|
this._extraHTTPHeaders = extraHTTPHeaders;
|
|
await this._forEachSession((info) => this._setExtraHTTPHeadersForSession(info));
|
|
}
|
|
async _setExtraHTTPHeadersForSession(info, initial) {
|
|
if (initial && !this._extraHTTPHeaders.length)
|
|
return;
|
|
await info.session.send("Network.setExtraHTTPHeaders", { headers: (0, import_utils.headersArrayToObject)(
|
|
this._extraHTTPHeaders,
|
|
false
|
|
/* lowerCase */
|
|
) });
|
|
}
|
|
async clearCache() {
|
|
await this._forEachSession(async (info) => {
|
|
await info.session.send("Network.setCacheDisabled", { cacheDisabled: true });
|
|
if (!this._protocolRequestInterceptionEnabled)
|
|
await info.session.send("Network.setCacheDisabled", { cacheDisabled: false });
|
|
if (!info.workerFrame)
|
|
await info.session.send("Network.clearBrowserCache");
|
|
});
|
|
}
|
|
_onRequestWillBeSent(sessionInfo, event) {
|
|
if (this._protocolRequestInterceptionEnabled && !event.request.url.startsWith("data:")) {
|
|
const requestId = event.requestId;
|
|
const requestPausedEvent = this._requestIdToRequestPausedEvent.get(requestId);
|
|
if (requestPausedEvent) {
|
|
this._onRequest(sessionInfo, event, requestPausedEvent.sessionInfo, requestPausedEvent.event);
|
|
this._requestIdToRequestPausedEvent.delete(requestId);
|
|
} else {
|
|
this._requestIdToRequestWillBeSentEvent.set(event.requestId, { sessionInfo, event });
|
|
}
|
|
} else {
|
|
this._onRequest(sessionInfo, event, void 0, void 0);
|
|
}
|
|
}
|
|
_onRequestServedFromCache(event) {
|
|
this._responseExtraInfoTracker.requestServedFromCache(event);
|
|
}
|
|
_onRequestWillBeSentExtraInfo(event) {
|
|
this._responseExtraInfoTracker.requestWillBeSentExtraInfo(event);
|
|
}
|
|
_onAuthRequired(sessionInfo, event) {
|
|
let response = "Default";
|
|
const shouldProvideCredentials = this._shouldProvideCredentials(event.request.url);
|
|
if (this._attemptedAuthentications.has(event.requestId)) {
|
|
response = "CancelAuth";
|
|
} else if (shouldProvideCredentials) {
|
|
response = "ProvideCredentials";
|
|
this._attemptedAuthentications.add(event.requestId);
|
|
}
|
|
const { username, password } = shouldProvideCredentials && this._credentials ? this._credentials : { username: void 0, password: void 0 };
|
|
sessionInfo.session._sendMayFail("Fetch.continueWithAuth", {
|
|
requestId: event.requestId,
|
|
authChallengeResponse: { response, username, password }
|
|
});
|
|
}
|
|
_shouldProvideCredentials(url) {
|
|
if (!this._credentials)
|
|
return false;
|
|
return !this._credentials.origin || new URL(url).origin.toLowerCase() === this._credentials.origin.toLowerCase();
|
|
}
|
|
_onRequestPaused(sessionInfo, event) {
|
|
if (!event.networkId) {
|
|
sessionInfo.session._sendMayFail("Fetch.continueRequest", { requestId: event.requestId });
|
|
return;
|
|
}
|
|
if (event.request.url.startsWith("data:"))
|
|
return;
|
|
const requestId = event.networkId;
|
|
const requestWillBeSentEvent = this._requestIdToRequestWillBeSentEvent.get(requestId);
|
|
if (requestWillBeSentEvent) {
|
|
this._onRequest(requestWillBeSentEvent.sessionInfo, requestWillBeSentEvent.event, sessionInfo, event);
|
|
this._requestIdToRequestWillBeSentEvent.delete(requestId);
|
|
} else {
|
|
const existingRequest = this._requestIdToRequest.get(requestId);
|
|
const alreadyContinuedParams = existingRequest?._originalRequestRoute?._alreadyContinuedParams;
|
|
if (alreadyContinuedParams && !event.redirectedRequestId) {
|
|
sessionInfo.session._sendMayFail("Fetch.continueRequest", {
|
|
...alreadyContinuedParams,
|
|
requestId: event.requestId
|
|
});
|
|
return;
|
|
}
|
|
this._requestIdToRequestPausedEvent.set(requestId, { sessionInfo, event });
|
|
}
|
|
}
|
|
_onRequest(requestWillBeSentSessionInfo, requestWillBeSentEvent, requestPausedSessionInfo, requestPausedEvent) {
|
|
if (requestWillBeSentEvent.request.url.startsWith("data:"))
|
|
return;
|
|
let redirectedFrom = null;
|
|
if (requestWillBeSentEvent.redirectResponse) {
|
|
const request2 = this._requestIdToRequest.get(requestWillBeSentEvent.requestId);
|
|
if (request2) {
|
|
this._handleRequestRedirect(request2, requestWillBeSentEvent.redirectResponse, requestWillBeSentEvent.timestamp, requestWillBeSentEvent.redirectHasExtraInfo);
|
|
redirectedFrom = request2;
|
|
}
|
|
}
|
|
let frame = requestWillBeSentEvent.frameId ? this._page?.frameManager.frame(requestWillBeSentEvent.frameId) : requestWillBeSentSessionInfo.workerFrame;
|
|
if (!frame && this._page && requestPausedEvent && requestPausedEvent.frameId)
|
|
frame = this._page.frameManager.frame(requestPausedEvent.frameId);
|
|
if (!frame && this._page && requestWillBeSentEvent.frameId === (this._page?.delegate)._targetId) {
|
|
frame = this._page.frameManager.frameAttached(requestWillBeSentEvent.frameId, null);
|
|
}
|
|
const isInterceptedOptionsPreflight = !!requestPausedEvent && requestPausedEvent.request.method === "OPTIONS" && requestWillBeSentEvent.initiator.type === "preflight";
|
|
if (isInterceptedOptionsPreflight && (this._page || this._serviceWorker).needsRequestInterception()) {
|
|
const requestHeaders = requestPausedEvent.request.headers;
|
|
const responseHeaders = [
|
|
{ name: "Access-Control-Allow-Origin", value: requestHeaders["Origin"] || "*" },
|
|
{ name: "Access-Control-Allow-Methods", value: requestHeaders["Access-Control-Request-Method"] || "GET, POST, OPTIONS, DELETE" },
|
|
{ name: "Access-Control-Allow-Credentials", value: "true" }
|
|
];
|
|
if (requestHeaders["Access-Control-Request-Headers"])
|
|
responseHeaders.push({ name: "Access-Control-Allow-Headers", value: requestHeaders["Access-Control-Request-Headers"] });
|
|
requestPausedSessionInfo.session._sendMayFail("Fetch.fulfillRequest", {
|
|
requestId: requestPausedEvent.requestId,
|
|
responseCode: 204,
|
|
responsePhrase: network.statusText(204),
|
|
responseHeaders,
|
|
body: ""
|
|
});
|
|
return;
|
|
}
|
|
if (!frame && !this._serviceWorker) {
|
|
if (requestPausedEvent)
|
|
requestPausedSessionInfo.session._sendMayFail("Fetch.continueRequest", { requestId: requestPausedEvent.requestId });
|
|
return;
|
|
}
|
|
let route = null;
|
|
let headersOverride;
|
|
if (requestPausedEvent) {
|
|
if (redirectedFrom || !this._userRequestInterceptionEnabled && this._protocolRequestInterceptionEnabled) {
|
|
headersOverride = redirectedFrom?._originalRequestRoute?._alreadyContinuedParams?.headers;
|
|
if (headersOverride) {
|
|
const originalHeaders = Object.entries(requestPausedEvent.request.headers).map(([name, value]) => ({ name, value }));
|
|
headersOverride = network.applyHeadersOverrides(originalHeaders, headersOverride);
|
|
}
|
|
requestPausedSessionInfo.session._sendMayFail("Fetch.continueRequest", { requestId: requestPausedEvent.requestId, headers: headersOverride });
|
|
} else {
|
|
route = new RouteImpl(requestPausedSessionInfo.session, requestPausedEvent.requestId);
|
|
}
|
|
}
|
|
const isNavigationRequest = requestWillBeSentEvent.requestId === requestWillBeSentEvent.loaderId && requestWillBeSentEvent.type === "Document";
|
|
const documentId = isNavigationRequest ? requestWillBeSentEvent.loaderId : void 0;
|
|
const request = new InterceptableRequest({
|
|
session: requestWillBeSentSessionInfo.session,
|
|
context: (this._page || this._serviceWorker).browserContext,
|
|
frame: frame || null,
|
|
serviceWorker: this._serviceWorker || null,
|
|
documentId,
|
|
route,
|
|
requestWillBeSentEvent,
|
|
requestPausedEvent,
|
|
redirectedFrom,
|
|
headersOverride: headersOverride || null
|
|
});
|
|
this._requestIdToRequest.set(requestWillBeSentEvent.requestId, request);
|
|
if (route) {
|
|
request.request.setRawRequestHeaders((0, import_utils.headersObjectToArray)(requestPausedEvent.request.headers, "\n"));
|
|
}
|
|
(this._page?.frameManager || this._serviceWorker).requestStarted(request.request, route || void 0);
|
|
}
|
|
_createResponse(request, responsePayload, hasExtraInfo) {
|
|
const getResponseBody = async () => {
|
|
const contentLengthHeader = Object.entries(responsePayload.headers).find((header) => header[0].toLowerCase() === "content-length");
|
|
const expectedLength = contentLengthHeader ? +contentLengthHeader[1] : void 0;
|
|
const session = request.session;
|
|
const response2 = await session.send("Network.getResponseBody", { requestId: request._requestId });
|
|
if (response2.body || !expectedLength)
|
|
return Buffer.from(response2.body, response2.base64Encoded ? "base64" : "utf8");
|
|
if (request._originalRequestRoute?._fulfilled)
|
|
return Buffer.from("");
|
|
const resource = await session.send("Network.loadNetworkResource", { url: request.request.url(), frameId: this._serviceWorker ? void 0 : request.request.frame()._id, options: { disableCache: false, includeCredentials: true } });
|
|
const chunks = [];
|
|
while (resource.resource.stream) {
|
|
const chunk = await session.send("IO.read", { handle: resource.resource.stream });
|
|
chunks.push(Buffer.from(chunk.data, chunk.base64Encoded ? "base64" : "utf-8"));
|
|
if (chunk.eof) {
|
|
await session.send("IO.close", { handle: resource.resource.stream });
|
|
break;
|
|
}
|
|
}
|
|
return Buffer.concat(chunks);
|
|
};
|
|
const timingPayload = responsePayload.timing;
|
|
let timing;
|
|
if (timingPayload && !this._responseExtraInfoTracker.servedFromCache(request._requestId)) {
|
|
timing = {
|
|
startTime: (timingPayload.requestTime - request._timestamp + request._wallTime) * 1e3,
|
|
domainLookupStart: timingPayload.dnsStart,
|
|
domainLookupEnd: timingPayload.dnsEnd,
|
|
connectStart: timingPayload.connectStart,
|
|
secureConnectionStart: timingPayload.sslStart,
|
|
connectEnd: timingPayload.connectEnd,
|
|
requestStart: timingPayload.sendStart,
|
|
responseStart: timingPayload.receiveHeadersEnd
|
|
};
|
|
} else {
|
|
timing = {
|
|
startTime: request._wallTime * 1e3,
|
|
domainLookupStart: -1,
|
|
domainLookupEnd: -1,
|
|
connectStart: -1,
|
|
secureConnectionStart: -1,
|
|
connectEnd: -1,
|
|
requestStart: -1,
|
|
responseStart: -1
|
|
};
|
|
}
|
|
const response = new network.Response(request.request, responsePayload.status, responsePayload.statusText, (0, import_utils.headersObjectToArray)(responsePayload.headers), timing, getResponseBody, !!responsePayload.fromServiceWorker);
|
|
response._setHttpVersion(responsePayload?.protocol ?? null);
|
|
if (responsePayload?.remoteIPAddress && typeof responsePayload?.remotePort === "number") {
|
|
response._serverAddrFinished({
|
|
ipAddress: responsePayload.remoteIPAddress,
|
|
port: responsePayload.remotePort
|
|
});
|
|
} else {
|
|
response._serverAddrFinished();
|
|
}
|
|
response._securityDetailsFinished({
|
|
protocol: responsePayload?.securityDetails?.protocol,
|
|
subjectName: responsePayload?.securityDetails?.subjectName,
|
|
issuer: responsePayload?.securityDetails?.issuer,
|
|
validFrom: responsePayload?.securityDetails?.validFrom,
|
|
validTo: responsePayload?.securityDetails?.validTo
|
|
});
|
|
this._responseExtraInfoTracker.processResponse(request._requestId, response, hasExtraInfo);
|
|
return response;
|
|
}
|
|
_deleteRequest(request) {
|
|
this._requestIdToRequest.delete(request._requestId);
|
|
if (request._interceptionId)
|
|
this._attemptedAuthentications.delete(request._interceptionId);
|
|
}
|
|
_handleRequestRedirect(request, responsePayload, timestamp, hasExtraInfo) {
|
|
const response = this._createResponse(request, responsePayload, hasExtraInfo);
|
|
response.setTransferSize(null);
|
|
response.setEncodedBodySize(null);
|
|
response._requestFinished((timestamp - request._timestamp) * 1e3);
|
|
this._deleteRequest(request);
|
|
(this._page?.frameManager || this._serviceWorker).requestReceivedResponse(response);
|
|
(this._page?.frameManager || this._serviceWorker).reportRequestFinished(request.request, response);
|
|
}
|
|
_onResponseReceivedExtraInfo(event) {
|
|
this._responseExtraInfoTracker.responseReceivedExtraInfo(event);
|
|
}
|
|
_onResponseReceived(sessionInfo, event) {
|
|
let request = this._requestIdToRequest.get(event.requestId);
|
|
if (!request && event.response.fromServiceWorker) {
|
|
const requestWillBeSentEvent = this._requestIdToRequestWillBeSentEvent.get(event.requestId);
|
|
if (requestWillBeSentEvent) {
|
|
this._requestIdToRequestWillBeSentEvent.delete(event.requestId);
|
|
this._onRequest(sessionInfo, requestWillBeSentEvent.event, void 0, void 0);
|
|
request = this._requestIdToRequest.get(event.requestId);
|
|
}
|
|
}
|
|
if (!request)
|
|
return;
|
|
const response = this._createResponse(request, event.response, event.hasExtraInfo);
|
|
(this._page?.frameManager || this._serviceWorker).requestReceivedResponse(response);
|
|
}
|
|
_onLoadingFinished(sessionInfo, event) {
|
|
this._responseExtraInfoTracker.loadingFinished(event);
|
|
const request = this._requestIdToRequest.get(event.requestId);
|
|
if (!request)
|
|
return;
|
|
this._maybeUpdateRequestSession(sessionInfo, request);
|
|
const response = request.request._existingResponse();
|
|
if (response) {
|
|
response.setTransferSize(event.encodedDataLength);
|
|
response.responseHeadersSize().then((size) => response.setEncodedBodySize(event.encodedDataLength - size));
|
|
response._requestFinished(import_helper.helper.secondsToRoundishMillis(event.timestamp - request._timestamp));
|
|
}
|
|
this._deleteRequest(request);
|
|
(this._page?.frameManager || this._serviceWorker).reportRequestFinished(request.request, response);
|
|
}
|
|
_onLoadingFailed(sessionInfo, event) {
|
|
this._responseExtraInfoTracker.loadingFailed(event);
|
|
let request = this._requestIdToRequest.get(event.requestId);
|
|
if (!request) {
|
|
const requestWillBeSentEvent = this._requestIdToRequestWillBeSentEvent.get(event.requestId);
|
|
if (requestWillBeSentEvent) {
|
|
this._requestIdToRequestWillBeSentEvent.delete(event.requestId);
|
|
this._onRequest(sessionInfo, requestWillBeSentEvent.event, void 0, void 0);
|
|
request = this._requestIdToRequest.get(event.requestId);
|
|
}
|
|
}
|
|
if (!request)
|
|
return;
|
|
this._maybeUpdateRequestSession(sessionInfo, request);
|
|
const response = request.request._existingResponse();
|
|
if (response) {
|
|
response.setTransferSize(null);
|
|
response.setEncodedBodySize(null);
|
|
response._requestFinished(import_helper.helper.secondsToRoundishMillis(event.timestamp - request._timestamp));
|
|
} else {
|
|
request.request.setRawRequestHeaders(null);
|
|
}
|
|
this._deleteRequest(request);
|
|
request.request._setFailureText(event.errorText || event.blockedReason || "");
|
|
(this._page?.frameManager || this._serviceWorker).requestFailed(request.request, !!event.canceled);
|
|
}
|
|
_maybeUpdateRequestSession(sessionInfo, request) {
|
|
if (request.session !== sessionInfo.session && !sessionInfo.isMain && (request._documentId === request._requestId || sessionInfo.workerFrame))
|
|
request.session = sessionInfo.session;
|
|
}
|
|
}
|
|
class InterceptableRequest {
|
|
constructor(options) {
|
|
const { session, context, frame, documentId, route, requestWillBeSentEvent, requestPausedEvent, redirectedFrom, serviceWorker, headersOverride } = options;
|
|
this.session = session;
|
|
this._timestamp = requestWillBeSentEvent.timestamp;
|
|
this._wallTime = requestWillBeSentEvent.wallTime;
|
|
this._requestId = requestWillBeSentEvent.requestId;
|
|
this._interceptionId = requestPausedEvent && requestPausedEvent.requestId;
|
|
this._documentId = documentId;
|
|
this._originalRequestRoute = route ?? redirectedFrom?._originalRequestRoute;
|
|
const {
|
|
headers,
|
|
method,
|
|
url,
|
|
postDataEntries = null
|
|
} = requestPausedEvent ? requestPausedEvent.request : requestWillBeSentEvent.request;
|
|
let postDataBuffer = null;
|
|
const entries = postDataEntries?.filter((entry) => entry.bytes);
|
|
if (entries && entries.length)
|
|
postDataBuffer = Buffer.concat(entries.map((entry) => Buffer.from(entry.bytes, "base64")));
|
|
this.request = new network.Request(context, frame, serviceWorker, redirectedFrom?.request || null, documentId, url, toResourceType(requestWillBeSentEvent.type || "Other"), method, postDataBuffer, headersOverride || (0, import_utils.headersObjectToArray)(headers));
|
|
}
|
|
}
|
|
class RouteImpl {
|
|
constructor(session, interceptionId) {
|
|
this._fulfilled = false;
|
|
this._session = session;
|
|
this._interceptionId = interceptionId;
|
|
}
|
|
async continue(overrides) {
|
|
this._alreadyContinuedParams = {
|
|
requestId: this._interceptionId,
|
|
url: overrides.url,
|
|
headers: overrides.headers,
|
|
method: overrides.method,
|
|
postData: overrides.postData ? overrides.postData.toString("base64") : void 0
|
|
};
|
|
await catchDisallowedErrors(async () => {
|
|
await this._session.send("Fetch.continueRequest", this._alreadyContinuedParams);
|
|
});
|
|
}
|
|
async fulfill(response) {
|
|
this._fulfilled = true;
|
|
const body = response.isBase64 ? response.body : Buffer.from(response.body).toString("base64");
|
|
const responseHeaders = splitSetCookieHeader(response.headers);
|
|
await catchDisallowedErrors(async () => {
|
|
await this._session.send("Fetch.fulfillRequest", {
|
|
requestId: this._interceptionId,
|
|
responseCode: response.status,
|
|
responsePhrase: network.statusText(response.status),
|
|
responseHeaders,
|
|
body
|
|
});
|
|
});
|
|
}
|
|
async abort(errorCode = "failed") {
|
|
const errorReason = errorReasons[errorCode];
|
|
(0, import_utils.assert)(errorReason, "Unknown error code: " + errorCode);
|
|
await catchDisallowedErrors(async () => {
|
|
await this._session.send("Fetch.failRequest", {
|
|
requestId: this._interceptionId,
|
|
errorReason
|
|
});
|
|
});
|
|
}
|
|
}
|
|
async function catchDisallowedErrors(callback) {
|
|
try {
|
|
return await callback();
|
|
} catch (e) {
|
|
if ((0, import_protocolError.isProtocolError)(e) && e.message.includes("Invalid http status code or phrase"))
|
|
throw e;
|
|
if ((0, import_protocolError.isProtocolError)(e) && e.message.includes("Unsafe header"))
|
|
throw e;
|
|
}
|
|
}
|
|
function splitSetCookieHeader(headers) {
|
|
const index = headers.findIndex(({ name }) => name.toLowerCase() === "set-cookie");
|
|
if (index === -1)
|
|
return headers;
|
|
const header = headers[index];
|
|
const values = header.value.split("\n");
|
|
if (values.length === 1)
|
|
return headers;
|
|
const result = headers.slice();
|
|
result.splice(index, 1, ...values.map((value) => ({ name: header.name, value })));
|
|
return result;
|
|
}
|
|
const errorReasons = {
|
|
"aborted": "Aborted",
|
|
"accessdenied": "AccessDenied",
|
|
"addressunreachable": "AddressUnreachable",
|
|
"blockedbyclient": "BlockedByClient",
|
|
"blockedbyresponse": "BlockedByResponse",
|
|
"connectionaborted": "ConnectionAborted",
|
|
"connectionclosed": "ConnectionClosed",
|
|
"connectionfailed": "ConnectionFailed",
|
|
"connectionrefused": "ConnectionRefused",
|
|
"connectionreset": "ConnectionReset",
|
|
"internetdisconnected": "InternetDisconnected",
|
|
"namenotresolved": "NameNotResolved",
|
|
"timedout": "TimedOut",
|
|
"failed": "Failed"
|
|
};
|
|
class ResponseExtraInfoTracker {
|
|
constructor() {
|
|
this._requests = /* @__PURE__ */ new Map();
|
|
}
|
|
requestWillBeSentExtraInfo(event) {
|
|
const info = this._getOrCreateEntry(event.requestId);
|
|
info.requestWillBeSentExtraInfo.push(event);
|
|
this._patchHeaders(info, info.requestWillBeSentExtraInfo.length - 1);
|
|
this._checkFinished(info);
|
|
}
|
|
requestServedFromCache(event) {
|
|
const info = this._getOrCreateEntry(event.requestId);
|
|
info.servedFromCache = true;
|
|
}
|
|
servedFromCache(requestId) {
|
|
const info = this._requests.get(requestId);
|
|
return !!info?.servedFromCache;
|
|
}
|
|
responseReceivedExtraInfo(event) {
|
|
const info = this._getOrCreateEntry(event.requestId);
|
|
info.responseReceivedExtraInfo.push(event);
|
|
this._patchHeaders(info, info.responseReceivedExtraInfo.length - 1);
|
|
this._checkFinished(info);
|
|
}
|
|
processResponse(requestId, response, hasExtraInfo) {
|
|
let info = this._requests.get(requestId);
|
|
if (!hasExtraInfo || info?.servedFromCache) {
|
|
response.request().setRawRequestHeaders(null);
|
|
response.setResponseHeadersSize(null);
|
|
response.setRawResponseHeaders(null);
|
|
return;
|
|
}
|
|
info = this._getOrCreateEntry(requestId);
|
|
info.responses.push(response);
|
|
this._patchHeaders(info, info.responses.length - 1);
|
|
}
|
|
loadingFinished(event) {
|
|
const info = this._requests.get(event.requestId);
|
|
if (!info)
|
|
return;
|
|
info.loadingFinished = event;
|
|
this._checkFinished(info);
|
|
}
|
|
loadingFailed(event) {
|
|
const info = this._requests.get(event.requestId);
|
|
if (!info)
|
|
return;
|
|
info.loadingFailed = event;
|
|
this._checkFinished(info);
|
|
}
|
|
_getOrCreateEntry(requestId) {
|
|
let info = this._requests.get(requestId);
|
|
if (!info) {
|
|
info = {
|
|
requestId,
|
|
requestWillBeSentExtraInfo: [],
|
|
responseReceivedExtraInfo: [],
|
|
responses: []
|
|
};
|
|
this._requests.set(requestId, info);
|
|
}
|
|
return info;
|
|
}
|
|
_patchHeaders(info, index) {
|
|
const response = info.responses[index];
|
|
const requestExtraInfo = info.requestWillBeSentExtraInfo[index];
|
|
if (response && requestExtraInfo) {
|
|
response.request().setRawRequestHeaders((0, import_utils.headersObjectToArray)(requestExtraInfo.headers, "\n"));
|
|
info.requestWillBeSentExtraInfo[index] = void 0;
|
|
}
|
|
const responseExtraInfo = info.responseReceivedExtraInfo[index];
|
|
if (response && responseExtraInfo) {
|
|
response.setResponseHeadersSize(responseExtraInfo.headersText?.length || 0);
|
|
response.setRawResponseHeaders((0, import_utils.headersObjectToArray)(responseExtraInfo.headers, "\n"));
|
|
info.responseReceivedExtraInfo[index] = void 0;
|
|
}
|
|
}
|
|
_checkFinished(info) {
|
|
if (!info.loadingFinished && !info.loadingFailed)
|
|
return;
|
|
if (info.responses.length <= info.responseReceivedExtraInfo.length) {
|
|
this._stopTracking(info.requestId);
|
|
return;
|
|
}
|
|
}
|
|
_stopTracking(requestId) {
|
|
this._requests.delete(requestId);
|
|
}
|
|
}
|
|
function toResourceType(type) {
|
|
switch (type) {
|
|
case "Document":
|
|
return "document";
|
|
case "Stylesheet":
|
|
return "stylesheet";
|
|
case "Image":
|
|
return "image";
|
|
case "Media":
|
|
return "media";
|
|
case "Font":
|
|
return "font";
|
|
case "Script":
|
|
return "script";
|
|
case "TextTrack":
|
|
return "texttrack";
|
|
case "XHR":
|
|
return "xhr";
|
|
case "Fetch":
|
|
return "fetch";
|
|
case "EventSource":
|
|
return "eventsource";
|
|
case "WebSocket":
|
|
return "websocket";
|
|
case "Manifest":
|
|
return "manifest";
|
|
case "Ping":
|
|
return "ping";
|
|
case "CSPViolationReport":
|
|
return "cspreport";
|
|
case "Prefetch":
|
|
case "SignedExchange":
|
|
case "Preflight":
|
|
case "FedCM":
|
|
default:
|
|
return "other";
|
|
}
|
|
}
|
|
// Annotate the CommonJS export names for ESM import in node:
|
|
0 && (module.exports = {
|
|
CRNetworkManager
|
|
});
|