rubycrawl 0.1.0

data/node/node_modules/playwright-core/lib/server/fetch.js

@@ -0,0 +1,621 @@
+"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 fetch_exports = {};
+__export(fetch_exports, {
+  APIRequestContext: () => APIRequestContext,
+  BrowserContextAPIRequestContext: () => BrowserContextAPIRequestContext,
+  GlobalAPIRequestContext: () => GlobalAPIRequestContext
+});
+module.exports = __toCommonJS(fetch_exports);
+var import_http = __toESM(require("http"));
+var import_https = __toESM(require("https"));
+var import_stream = require("stream");
+var import_tls = require("tls");
+var zlib = __toESM(require("zlib"));
+var import_utils = require("../utils");
+var import_crypto = require("./utils/crypto");
+var import_userAgent = require("./utils/userAgent");
+var import_browserContext = require("./browserContext");
+var import_cookieStore = require("./cookieStore");
+var import_formData = require("./formData");
+var import_instrumentation = require("./instrumentation");
+var import_progress = require("./progress");
+var import_socksClientCertificatesInterceptor = require("./socksClientCertificatesInterceptor");
+var import_happyEyeballs = require("./utils/happyEyeballs");
+var import_tracing = require("./trace/recorder/tracing");
+class APIRequestContext extends import_instrumentation.SdkObject {
+  constructor(parent) {
+    super(parent, "request-context");
+    this.fetchResponses = /* @__PURE__ */ new Map();
+    this.fetchLog = /* @__PURE__ */ new Map();
+    APIRequestContext.allInstances.add(this);
+  }
+  static {
+    this.Events = {
+      Dispose: "dispose",
+      Request: "request",
+      RequestFinished: "requestfinished"
+    };
+  }
+  static {
+    this.allInstances = /* @__PURE__ */ new Set();
+  }
+  static findResponseBody(guid) {
+    for (const request of APIRequestContext.allInstances) {
+      const body = request.fetchResponses.get(guid);
+      if (body)
+        return body;
+    }
+    return void 0;
+  }
+  _disposeImpl() {
+    APIRequestContext.allInstances.delete(this);
+    this.fetchResponses.clear();
+    this.fetchLog.clear();
+    this.emit(APIRequestContext.Events.Dispose);
+  }
+  disposeResponse(fetchUid) {
+    this.fetchResponses.delete(fetchUid);
+    this.fetchLog.delete(fetchUid);
+  }
+  _storeResponseBody(body) {
+    const uid = (0, import_crypto.createGuid)();
+    this.fetchResponses.set(uid, body);
+    return uid;
+  }
+  async fetch(progress, params) {
+    const defaults = this._defaultOptions();
+    const headers = {
+      "user-agent": defaults.userAgent,
+      "accept": "*/*",
+      "accept-encoding": "gzip,deflate,br"
+    };
+    if (defaults.extraHTTPHeaders) {
+      for (const { name, value } of defaults.extraHTTPHeaders)
+        setHeader(headers, name, value);
+    }
+    if (params.headers) {
+      for (const { name, value } of params.headers)
+        setHeader(headers, name, value);
+    }
+    const requestUrl = new URL((0, import_utils.constructURLBasedOnBaseURL)(defaults.baseURL, params.url));
+    if (params.encodedParams) {
+      requestUrl.search = params.encodedParams;
+    } else if (params.params) {
+      for (const { name, value } of params.params)
+        requestUrl.searchParams.append(name, value);
+    }
+    const credentials = this._getHttpCredentials(requestUrl);
+    if (credentials?.send === "always")
+      setBasicAuthorizationHeader(headers, credentials);
+    const method = params.method?.toUpperCase() || "GET";
+    const proxy = defaults.proxy;
+    let agent;
+    if (proxy?.server !== "per-context")
+      agent = (0, import_utils.createProxyAgent)(proxy, requestUrl);
+    let maxRedirects = params.maxRedirects ?? (defaults.maxRedirects ?? 20);
+    maxRedirects = maxRedirects === 0 ? -1 : maxRedirects;
+    const options = {
+      method,
+      headers,
+      agent,
+      maxRedirects,
+      ...(0, import_socksClientCertificatesInterceptor.getMatchingTLSOptionsForOrigin)(this._defaultOptions().clientCertificates, requestUrl.origin),
+      __testHookLookup: params.__testHookLookup
+    };
+    if (params.ignoreHTTPSErrors || defaults.ignoreHTTPSErrors)
+      options.rejectUnauthorized = false;
+    const postData = serializePostData(params, headers);
+    if (postData)
+      setHeader(headers, "content-length", String(postData.byteLength));
+    const fetchResponse = await this._sendRequestWithRetries(progress, requestUrl, options, postData, params.maxRetries);
+    const fetchUid = this._storeResponseBody(fetchResponse.body);
+    this.fetchLog.set(fetchUid, progress.metadata.log);
+    const failOnStatusCode = params.failOnStatusCode !== void 0 ? params.failOnStatusCode : !!defaults.failOnStatusCode;
+    if (failOnStatusCode && (fetchResponse.status < 200 || fetchResponse.status >= 400)) {
+      let responseText = "";
+      if (fetchResponse.body.byteLength) {
+        let text = fetchResponse.body.toString("utf8");
+        if (text.length > 1e3)
+          text = text.substring(0, 997) + "...";
+        responseText = `
+Response text:
+${text}`;
+      }
+      throw new Error(`${fetchResponse.status} ${fetchResponse.statusText}${responseText}`);
+    }
+    return { ...fetchResponse, fetchUid };
+  }
+  _parseSetCookieHeader(responseUrl, setCookie) {
+    if (!setCookie)
+      return [];
+    const url = new URL(responseUrl);
+    const defaultPath = "/" + url.pathname.substr(1).split("/").slice(0, -1).join("/");
+    const cookies = [];
+    for (const header of setCookie) {
+      const cookie = parseCookie(header);
+      if (!cookie)
+        continue;
+      if (!cookie.domain)
+        cookie.domain = url.hostname;
+      else
+        (0, import_utils.assert)(cookie.domain.startsWith(".") || !cookie.domain.includes("."));
+      if (!(0, import_cookieStore.domainMatches)(url.hostname, cookie.domain))
+        continue;
+      if (!cookie.path || !cookie.path.startsWith("/"))
+        cookie.path = defaultPath;
+      cookies.push(cookie);
+    }
+    return cookies;
+  }
+  async _updateRequestCookieHeader(progress, url, headers) {
+    if (getHeader(headers, "cookie") !== void 0)
+      return;
+    const contextCookies = await progress.race(this._cookies(url));
+    const cookies = contextCookies.filter((c) => new import_cookieStore.Cookie(c).matches(url));
+    if (cookies.length) {
+      const valueArray = cookies.map((c) => `${c.name}=${c.value}`);
+      setHeader(headers, "cookie", valueArray.join("; "));
+    }
+  }
+  async _sendRequestWithRetries(progress, url, options, postData, maxRetries) {
+    maxRetries ??= 0;
+    let backoff = 250;
+    for (let i = 0; i <= maxRetries; i++) {
+      try {
+        return await this._sendRequest(progress, url, options, postData);
+      } catch (e) {
+        if ((0, import_progress.isAbortError)(e))
+          throw e;
+        e = (0, import_socksClientCertificatesInterceptor.rewriteOpenSSLErrorIfNeeded)(e);
+        if (maxRetries === 0)
+          throw e;
+        if (i === maxRetries)
+          throw new Error(`Failed after ${i + 1} attempt(s): ${e}`);
+        if (e.code !== "ECONNRESET")
+          throw e;
+        progress.log(`  Received ECONNRESET, will retry after ${backoff}ms.`);
+        await progress.wait(backoff);
+        backoff *= 2;
+      }
+    }
+    throw new Error("Unreachable");
+  }
+  async _sendRequest(progress, url, options, postData) {
+    await this._updateRequestCookieHeader(progress, url, options.headers);
+    const requestCookies = getHeader(options.headers, "cookie")?.split(";").map((p) => {
+      const [name, value] = p.split("=").map((v) => v.trim());
+      return { name, value };
+    }) || [];
+    const requestEvent = {
+      url,
+      method: options.method,
+      headers: options.headers,
+      cookies: requestCookies,
+      postData
+    };
+    this.emit(APIRequestContext.Events.Request, requestEvent);
+    let destroyRequest;
+    const resultPromise = new Promise((fulfill, reject) => {
+      const requestConstructor = (url.protocol === "https:" ? import_https.default : import_http.default).request;
+      const agent = options.agent || (url.protocol === "https:" ? import_happyEyeballs.httpsHappyEyeballsAgent : import_happyEyeballs.httpHappyEyeballsAgent);
+      const requestOptions = { ...options, agent };
+      const startAt = (0, import_utils.monotonicTime)();
+      let reusedSocketAt;
+      let dnsLookupAt;
+      let tcpConnectionAt;
+      let tlsHandshakeAt;
+      let requestFinishAt;
+      let serverIPAddress;
+      let serverPort;
+      let securityDetails;
+      const listeners = [];
+      const request = requestConstructor(url, requestOptions, async (response) => {
+        const responseAt = (0, import_utils.monotonicTime)();
+        const notifyRequestFinished = (body2) => {
+          const endAt = (0, import_utils.monotonicTime)();
+          const connectEnd = tlsHandshakeAt ?? tcpConnectionAt;
+          const timings = {
+            send: requestFinishAt - startAt,
+            wait: responseAt - requestFinishAt,
+            receive: endAt - responseAt,
+            dns: dnsLookupAt ? dnsLookupAt - startAt : -1,
+            connect: connectEnd ? connectEnd - startAt : -1,
+            // "If [ssl] is defined then the time is also included in the connect field "
+            ssl: tlsHandshakeAt ? tlsHandshakeAt - tcpConnectionAt : -1,
+            blocked: reusedSocketAt ? reusedSocketAt - startAt : -1
+          };
+          const requestFinishedEvent = {
+            requestEvent,
+            httpVersion: response.httpVersion,
+            statusCode: response.statusCode || 0,
+            statusMessage: response.statusMessage || "",
+            headers: response.headers,
+            rawHeaders: response.rawHeaders,
+            cookies,
+            body: body2,
+            timings,
+            serverIPAddress,
+            serverPort,
+            securityDetails
+          };
+          this.emit(APIRequestContext.Events.RequestFinished, requestFinishedEvent);
+        };
+        progress.log(`\u2190 ${response.statusCode} ${response.statusMessage}`);
+        for (const [name, value] of Object.entries(response.headers))
+          progress.log(`  ${name}: ${value}`);
+        const cookies = this._parseSetCookieHeader(response.url || url.toString(), response.headers["set-cookie"]);
+        if (cookies.length) {
+          try {
+            await this._addCookies(cookies);
+          } catch (e) {
+            await Promise.all(cookies.map((c) => this._addCookies([c]).catch(() => {
+            })));
+          }
+        }
+        if (redirectStatus.includes(response.statusCode) && options.maxRedirects >= 0) {
+          if (options.maxRedirects === 0) {
+            reject(new Error("Max redirect count exceeded"));
+            request.destroy();
+            return;
+          }
+          const headers = { ...options.headers };
+          removeHeader(headers, `cookie`);
+          const status = response.statusCode;
+          let method = options.method;
+          if ((status === 301 || status === 302) && method === "POST" || status === 303 && !["GET", "HEAD"].includes(method)) {
+            method = "GET";
+            postData = void 0;
+            removeHeader(headers, `content-encoding`);
+            removeHeader(headers, `content-language`);
+            removeHeader(headers, `content-length`);
+            removeHeader(headers, `content-location`);
+            removeHeader(headers, `content-type`);
+          }
+          const redirectOptions = {
+            method,
+            headers,
+            agent: options.agent,
+            maxRedirects: options.maxRedirects - 1,
+            ...(0, import_socksClientCertificatesInterceptor.getMatchingTLSOptionsForOrigin)(this._defaultOptions().clientCertificates, url.origin),
+            __testHookLookup: options.__testHookLookup
+          };
+          if (options.rejectUnauthorized === false)
+            redirectOptions.rejectUnauthorized = false;
+          const locationHeaderValue = Buffer.from(response.headers.location ?? "", "latin1").toString("utf8");
+          if (locationHeaderValue) {
+            let locationURL;
+            try {
+              locationURL = new URL(locationHeaderValue, url);
+            } catch (error) {
+              reject(new Error(`uri requested responds with an invalid redirect URL: ${locationHeaderValue}`));
+              request.destroy();
+              return;
+            }
+            if (headers["host"])
+              headers["host"] = locationURL.host;
+            notifyRequestFinished();
+            fulfill(this._sendRequest(progress, locationURL, redirectOptions, postData));
+            request.destroy();
+            return;
+          }
+        }
+        if (response.statusCode === 401 && !getHeader(options.headers, "authorization")) {
+          const auth = response.headers["www-authenticate"];
+          const credentials = this._getHttpCredentials(url);
+          if (auth?.trim().startsWith("Basic") && credentials) {
+            setBasicAuthorizationHeader(options.headers, credentials);
+            notifyRequestFinished();
+            fulfill(this._sendRequest(progress, url, options, postData));
+            request.destroy();
+            return;
+          }
+        }
+        response.on("aborted", () => reject(new Error("aborted")));
+        const chunks = [];
+        const notifyBodyFinished = () => {
+          const body2 = Buffer.concat(chunks);
+          notifyRequestFinished(body2);
+          fulfill({
+            url: response.url || url.toString(),
+            status: response.statusCode || 0,
+            statusText: response.statusMessage || "",
+            headers: toHeadersArray(response.rawHeaders),
+            body: body2
+          });
+        };
+        let body = response;
+        let transform;
+        const encoding = response.headers["content-encoding"];
+        if (encoding === "gzip" || encoding === "x-gzip") {
+          transform = zlib.createGunzip({
+            flush: zlib.constants.Z_SYNC_FLUSH,
+            finishFlush: zlib.constants.Z_SYNC_FLUSH
+          });
+        } else if (encoding === "br") {
+          transform = zlib.createBrotliDecompress({
+            flush: zlib.constants.BROTLI_OPERATION_FLUSH,
+            finishFlush: zlib.constants.BROTLI_OPERATION_FLUSH
+          });
+        } else if (encoding === "deflate") {
+          transform = zlib.createInflate();
+        }
+        if (transform) {
+          const emptyStreamTransform = new SafeEmptyStreamTransform(notifyBodyFinished);
+          body = (0, import_stream.pipeline)(response, emptyStreamTransform, transform, (e) => {
+            if (e)
+              reject(new Error(`failed to decompress '${encoding}' encoding: ${e.message}`));
+          });
+          body.on("error", (e) => reject(new Error(`failed to decompress '${encoding}' encoding: ${e}`)));
+        } else {
+          body.on("error", reject);
+        }
+        body.on("data", (chunk) => chunks.push(chunk));
+        body.on("end", notifyBodyFinished);
+      });
+      request.on("error", reject);
+      destroyRequest = () => request.destroy();
+      listeners.push(
+        import_utils.eventsHelper.addEventListener(this, APIRequestContext.Events.Dispose, () => {
+          reject(new Error("Request context disposed."));
+          request.destroy();
+        })
+      );
+      request.on("close", () => import_utils.eventsHelper.removeEventListeners(listeners));
+      request.on("socket", (socket) => {
+        if (request.reusedSocket) {
+          reusedSocketAt = (0, import_utils.monotonicTime)();
+          return;
+        }
+        const happyEyeBallsTimings = (0, import_happyEyeballs.timingForSocket)(socket);
+        dnsLookupAt = happyEyeBallsTimings.dnsLookupAt;
+        tcpConnectionAt = happyEyeBallsTimings.tcpConnectionAt;
+        listeners.push(
+          import_utils.eventsHelper.addEventListener(socket, "lookup", () => {
+            dnsLookupAt = (0, import_utils.monotonicTime)();
+          }),
+          import_utils.eventsHelper.addEventListener(socket, "connect", () => {
+            tcpConnectionAt = (0, import_utils.monotonicTime)();
+          }),
+          import_utils.eventsHelper.addEventListener(socket, "secureConnect", () => {
+            tlsHandshakeAt = (0, import_utils.monotonicTime)();
+            if (socket instanceof import_tls.TLSSocket) {
+              const peerCertificate = socket.getPeerCertificate();
+              securityDetails = {
+                protocol: socket.getProtocol() ?? void 0,
+                subjectName: peerCertificate.subject.CN,
+                validFrom: new Date(peerCertificate.valid_from).getTime() / 1e3,
+                validTo: new Date(peerCertificate.valid_to).getTime() / 1e3,
+                issuer: peerCertificate.issuer.CN
+              };
+            }
+          })
+        );
+        serverIPAddress = socket.remoteAddress;
+        serverPort = socket.remotePort;
+      });
+      request.on("finish", () => {
+        requestFinishAt = (0, import_utils.monotonicTime)();
+      });
+      progress.log(`\u2192 ${options.method} ${url.toString()}`);
+      if (options.headers) {
+        for (const [name, value] of Object.entries(options.headers))
+          progress.log(`  ${name}: ${value}`);
+      }
+      if (postData)
+        request.write(postData);
+      request.end();
+    });
+    return progress.race(resultPromise).catch((error) => {
+      destroyRequest?.();
+      throw error;
+    });
+  }
+  _getHttpCredentials(url) {
+    if (!this._defaultOptions().httpCredentials?.origin || url.origin.toLowerCase() === this._defaultOptions().httpCredentials?.origin?.toLowerCase())
+      return this._defaultOptions().httpCredentials;
+    return void 0;
+  }
+}
+class SafeEmptyStreamTransform extends import_stream.Transform {
+  constructor(onEmptyStreamCallback) {
+    super();
+    this._receivedSomeData = false;
+    this._onEmptyStreamCallback = onEmptyStreamCallback;
+  }
+  _transform(chunk, encoding, callback) {
+    this._receivedSomeData = true;
+    callback(null, chunk);
+  }
+  _flush(callback) {
+    if (this._receivedSomeData)
+      callback(null);
+    else
+      this._onEmptyStreamCallback();
+  }
+}
+class BrowserContextAPIRequestContext extends APIRequestContext {
+  constructor(context) {
+    super(context);
+    this._context = context;
+    context.once(import_browserContext.BrowserContext.Events.Close, () => this._disposeImpl());
+  }
+  tracing() {
+    return this._context.tracing;
+  }
+  async dispose(options) {
+    this._closeReason = options.reason;
+    this.fetchResponses.clear();
+  }
+  _defaultOptions() {
+    return {
+      userAgent: this._context._options.userAgent || this._context._browser.userAgent(),
+      extraHTTPHeaders: this._context._options.extraHTTPHeaders,
+      failOnStatusCode: void 0,
+      httpCredentials: this._context._options.httpCredentials,
+      proxy: this._context._options.proxy || this._context._browser.options.proxy,
+      ignoreHTTPSErrors: this._context._options.ignoreHTTPSErrors,
+      baseURL: this._context._options.baseURL,
+      clientCertificates: this._context._options.clientCertificates
+    };
+  }
+  async _addCookies(cookies) {
+    await this._context.addCookies(cookies);
+  }
+  async _cookies(url) {
+    return await this._context.cookies(url.toString());
+  }
+  async storageState(progress, indexedDB) {
+    return this._context.storageState(progress, indexedDB);
+  }
+}
+class GlobalAPIRequestContext extends APIRequestContext {
+  constructor(playwright, options) {
+    super(playwright);
+    this._cookieStore = new import_cookieStore.CookieStore();
+    this.attribution.context = this;
+    if (options.storageState) {
+      this._origins = options.storageState.origins?.map((origin) => ({ indexedDB: [], ...origin }));
+      this._cookieStore.addCookies(options.storageState.cookies || []);
+    }
+    (0, import_browserContext.verifyClientCertificates)(options.clientCertificates);
+    this._options = {
+      baseURL: options.baseURL,
+      userAgent: options.userAgent || (0, import_userAgent.getUserAgent)(),
+      extraHTTPHeaders: options.extraHTTPHeaders,
+      failOnStatusCode: !!options.failOnStatusCode,
+      ignoreHTTPSErrors: !!options.ignoreHTTPSErrors,
+      maxRedirects: options.maxRedirects,
+      httpCredentials: options.httpCredentials,
+      clientCertificates: options.clientCertificates,
+      proxy: options.proxy
+    };
+    this._tracing = new import_tracing.Tracing(this, options.tracesDir);
+  }
+  tracing() {
+    return this._tracing;
+  }
+  async dispose(options) {
+    this._closeReason = options.reason;
+    await this._tracing.flush();
+    await this._tracing.deleteTmpTracesDir();
+    this._disposeImpl();
+  }
+  _defaultOptions() {
+    return this._options;
+  }
+  async _addCookies(cookies) {
+    this._cookieStore.addCookies(cookies);
+  }
+  async _cookies(url) {
+    return this._cookieStore.cookies(url);
+  }
+  async storageState(progress, indexedDB = false) {
+    return {
+      cookies: this._cookieStore.allCookies(),
+      origins: (this._origins || []).map((origin) => ({ ...origin, indexedDB: indexedDB ? origin.indexedDB : [] }))
+    };
+  }
+}
+function toHeadersArray(rawHeaders) {
+  const result = [];
+  for (let i = 0; i < rawHeaders.length; i += 2)
+    result.push({ name: rawHeaders[i], value: rawHeaders[i + 1] });
+  return result;
+}
+const redirectStatus = [301, 302, 303, 307, 308];
+function parseCookie(header) {
+  const raw = (0, import_cookieStore.parseRawCookie)(header);
+  if (!raw)
+    return null;
+  const cookie = {
+    domain: "",
+    path: "",
+    expires: -1,
+    httpOnly: false,
+    secure: false,
+    // From https://developer.mozilla.org/en-US/docs/Web/HTTP/Headers/Set-Cookie/SameSite
+    // The cookie-sending behavior if SameSite is not specified is SameSite=Lax.
+    sameSite: "Lax",
+    ...raw
+  };
+  return cookie;
+}
+function serializePostData(params, headers) {
+  (0, import_utils.assert)((params.postData ? 1 : 0) + (params.jsonData ? 1 : 0) + (params.formData ? 1 : 0) + (params.multipartData ? 1 : 0) <= 1, `Only one of 'data', 'form' or 'multipart' can be specified`);
+  if (params.jsonData !== void 0) {
+    setHeader(headers, "content-type", "application/json", true);
+    return Buffer.from(params.jsonData, "utf8");
+  } else if (params.formData) {
+    const searchParams = new URLSearchParams();
+    for (const { name, value } of params.formData)
+      searchParams.append(name, value);
+    setHeader(headers, "content-type", "application/x-www-form-urlencoded", true);
+    return Buffer.from(searchParams.toString(), "utf8");
+  } else if (params.multipartData) {
+    const formData = new import_formData.MultipartFormData();
+    for (const field of params.multipartData) {
+      if (field.file)
+        formData.addFileField(field.name, field.file);
+      else if (field.value)
+        formData.addField(field.name, field.value);
+    }
+    setHeader(headers, "content-type", formData.contentTypeHeader(), true);
+    return formData.finish();
+  } else if (params.postData !== void 0) {
+    setHeader(headers, "content-type", "application/octet-stream", true);
+    return params.postData;
+  }
+  return void 0;
+}
+function setHeader(headers, name, value, keepExisting = false) {
+  const existing = Object.entries(headers).find((pair) => pair[0].toLowerCase() === name.toLowerCase());
+  if (!existing)
+    headers[name] = value;
+  else if (!keepExisting)
+    headers[existing[0]] = value;
+}
+function getHeader(headers, name) {
+  const existing = Object.entries(headers).find((pair) => pair[0].toLowerCase() === name.toLowerCase());
+  return existing ? existing[1] : void 0;
+}
+function removeHeader(headers, name) {
+  delete headers[name];
+}
+function setBasicAuthorizationHeader(headers, credentials) {
+  const { username, password } = credentials;
+  const encoded = Buffer.from(`${username || ""}:${password || ""}`).toString("base64");
+  setHeader(headers, "authorization", `Basic ${encoded}`);
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  APIRequestContext,
+  BrowserContextAPIRequestContext,
+  GlobalAPIRequestContext
+});

data/node/node_modules/playwright-core/lib/server/fileChooser.js

@@ -0,0 +1,43 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+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 __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var fileChooser_exports = {};
+__export(fileChooser_exports, {
+  FileChooser: () => FileChooser
+});
+module.exports = __toCommonJS(fileChooser_exports);
+class FileChooser {
+  constructor(page, elementHandle, isMultiple) {
+    this._page = page;
+    this._elementHandle = elementHandle;
+    this._isMultiple = isMultiple;
+  }
+  element() {
+    return this._elementHandle;
+  }
+  isMultiple() {
+    return this._isMultiple;
+  }
+  page() {
+    return this._page;
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  FileChooser
+});