@reclaimprotocol/attestor-core 4.0.3 → 5.0.1-beta.10

package/lib/browser/providers/http/index.d.ts

@@ -0,0 +1,18 @@
+import type { Provider, ProviderParams, ProviderSecretParams } from '#src/types/index.ts';
+type HTTPProviderParams = ProviderParams<'http'>;
+declare const HTTP_PROVIDER: Provider<'http'>;
+export declare function substituteParamValues(currentParams: HTTPProviderParams, secretParams?: ProviderSecretParams<'http'>, ignoreMissingParams?: boolean): {
+    newParams: HTTPProviderParams;
+    extractedValues: {
+        [_: string]: string;
+    };
+    hiddenBodyParts: {
+        index: number;
+        length: number;
+    }[];
+    hiddenURLParts: {
+        index: number;
+        length: number;
+    }[];
+};
+export default HTTP_PROVIDER;

package/lib/browser/providers/http/index.js

@@ -0,0 +1,640 @@
+import { areUint8ArraysEqual, concatenateUint8Arrays, uint8ArrayToBinaryStr } from "../../utils/tls-imports.js";
+import { encodeBase64 } from "ethers";
+import { DEFAULT_HTTPS_PORT, RECLAIM_USER_AGENT } from "../../config/index.js";
+import { AttestorVersion } from "../../proto/api.js";
+import {
+  buildHeaders,
+  convertResponsePosToAbsolutePos,
+  extractHTMLElementsIndexes,
+  extractJSONValueIndexes,
+  getRedactionsForChunkHeaders,
+  makeRegex,
+  matchRedactedStrings,
+  parseHttpResponse
+} from "../../providers/http/utils.js";
+import { isValidProxySessionId } from "../../utils/generics.js";
+import {
+  findIndexInUint8Array,
+  getHttpRequestDataFromTranscript,
+  logger,
+  REDACTION_CHAR_CODE,
+  strToUint8Array,
+  uint8ArrayToStr
+} from "../../utils/index.js";
+const OK_HTTP_HEADER = "HTTP/1.1 200";
+const dateHeaderRegex = "[dD]ate: ((?:Mon|Tue|Wed|Thu|Fri|Sat|Sun), (?:[0-3][0-9]) (?:Jan|Feb|Mar|Apr|May|Jun|Jul|Aug|Sep|Oct|Nov|Dec) (?:[0-9]{4}) (?:[01][0-9]|2[0-3])(?::[0-5][0-9]){2} GMT)";
+const dateDiff = 1e3 * 60 * 10;
+const HTTP_PROVIDER = {
+  hostPort: getHostPort,
+  writeRedactionMode(params) {
+    return "writeRedactionMode" in params ? params.writeRedactionMode : void 0;
+  },
+  geoLocation(params, secretParams) {
+    return "geoLocation" in params ? getGeoLocation(params, secretParams) : void 0;
+  },
+  proxySessionId(params, secretParams) {
+    return "proxySessionId" in params ? getProxySessionId(params, secretParams) : void 0;
+  },
+  additionalClientOptions(params) {
+    let defaultOptions = {
+      applicationLayerProtocols: ["http/1.1"]
+    };
+    if ("additionalClientOptions" in params) {
+      defaultOptions = {
+        ...defaultOptions,
+        ...params.additionalClientOptions
+      };
+    }
+    return defaultOptions;
+  },
+  createRequest(secretParams, params, logger2) {
+    if (!secretParams.cookieStr && !secretParams.authorisationHeader && !secretParams.headers) {
+      throw new Error("auth parameters are not set");
+    }
+    const pubHeaders = params.headers || {};
+    const secHeaders = { ...secretParams.headers };
+    if (secretParams.cookieStr) {
+      secHeaders["Cookie"] = secretParams.cookieStr;
+    }
+    if (secretParams.authorisationHeader) {
+      secHeaders["Authorization"] = secretParams.authorisationHeader;
+    }
+    const hasUserAgent = Object.keys(pubHeaders).some((k) => k.toLowerCase() === "user-agent") || Object.keys(secHeaders).some((k) => k.toLowerCase() === "user-agent");
+    if (!hasUserAgent) {
+      pubHeaders["User-Agent"] = RECLAIM_USER_AGENT;
+    }
+    const newParams = substituteParamValues(params, secretParams);
+    params = newParams.newParams;
+    const url = new URL(params.url);
+    const { pathname } = url;
+    const searchParams = params.url.includes("?") ? params.url.split("?")[1] : "";
+    logger2.info({ url: params.url, path: pathname, query: searchParams.toString() });
+    const body = params.body instanceof Uint8Array ? params.body : strToUint8Array(params.body || "");
+    const contentLength = body.length;
+    const reqLine = `${params.method} ${pathname}${searchParams?.length ? "?" + searchParams : ""} HTTP/1.1`;
+    const secHeadersList = buildHeaders(secHeaders);
+    logger2.info({ requestLine: reqLine });
+    const httpReqHeaderStr = [
+      reqLine,
+      `Host: ${getHostHeaderString(url)}`,
+      `Content-Length: ${contentLength}`,
+      "Connection: close",
+      //no compression
+      "Accept-Encoding: identity",
+      ...buildHeaders(pubHeaders),
+      ...secHeadersList,
+      "\r\n"
+    ].join("\r\n");
+    const headerStr = strToUint8Array(httpReqHeaderStr);
+    const data = concatenateUint8Arrays([headerStr, body]);
+    const secHeadersStr = secHeadersList.join("\r\n");
+    const tokenStartIndex = findIndexInUint8Array(data, strToUint8Array(secHeadersStr));
+    const redactions = [
+      {
+        fromIndex: tokenStartIndex,
+        toIndex: tokenStartIndex + secHeadersStr.length
+      }
+    ];
+    if (newParams.hiddenBodyParts?.length > 0) {
+      for (const hiddenBodyPart of newParams.hiddenBodyParts) {
+        if (hiddenBodyPart.length) {
+          redactions.push({
+            fromIndex: headerStr.length + hiddenBodyPart.index,
+            toIndex: headerStr.length + hiddenBodyPart.index + hiddenBodyPart.length
+          });
+        }
+      }
+    }
+    if (newParams.hiddenURLParts?.length > 0) {
+      for (const hiddenURLPart of newParams.hiddenURLParts) {
+        if (hiddenURLPart.length) {
+          redactions.push({
+            fromIndex: hiddenURLPart.index,
+            toIndex: hiddenURLPart.index + hiddenURLPart.length
+          });
+        }
+      }
+    }
+    redactions.sort((a, b) => a.toIndex - b.toIndex);
+    return {
+      data,
+      redactions
+    };
+  },
+  getResponseRedactions({ response, params: rawParams, logger: logger2, ctx }) {
+    logger2.debug({ response: encodeBase64(response), params: rawParams });
+    const res = parseHttpResponse(response);
+    if (!rawParams.responseRedactions?.length) {
+      return [];
+    }
+    if (res.statusCode / 100 >> 0 !== 2) {
+      logger2.error({ response: encodeBase64(response), params: rawParams });
+      throw new Error(
+        `Expected status 2xx, got ${res.statusCode} (${res.statusMessage})`
+      );
+    }
+    const newParams = substituteParamValues(rawParams, void 0, true);
+    const params = newParams.newParams;
+    const headerEndIndex = res.statusLineEndIndex;
+    const bodyStartIdx = res.bodyStartIndex ?? 0;
+    if (bodyStartIdx < 4) {
+      logger2.error({ response: encodeBase64(response) });
+      throw new Error("Failed to find response body");
+    }
+    const reveals = [
+      { fromIndex: 0, toIndex: headerEndIndex }
+    ];
+    if (shouldRevealCrlf(ctx)) {
+      const crlfs = response.slice(res.headerEndIdx, res.headerEndIdx + 4);
+      if (!areUint8ArraysEqual(crlfs, strToUint8Array("\r\n\r\n"))) {
+        logger2.error({ response: encodeBase64(response) });
+        throw new Error(
+          `Failed to find header/body separator at index ${res.headerEndIdx}`
+        );
+      }
+    }
+    reveals.push({ fromIndex: res.headerEndIdx, toIndex: res.headerEndIdx + 4 });
+    if (res.headerIndices["date"]) {
+      reveals.push(res.headerIndices["date"]);
+    }
+    const body = uint8ArrayToBinaryStr(res.body);
+    const redactions = [];
+    for (const rs of params.responseRedactions || []) {
+      const processor = processRedactionRequest(
+        body,
+        rs,
+        bodyStartIdx,
+        res.chunks
+      );
+      for (const { reveal, redactions: reds } of processor) {
+        reveals.push(reveal);
+        redactions.push(...reds);
+      }
+    }
+    reveals.sort((a, b) => a.toIndex - b.toIndex);
+    if (reveals.length > 1) {
+      let currentIndex = 0;
+      for (const r of reveals) {
+        if (currentIndex < r.fromIndex) {
+          redactions.push({ fromIndex: currentIndex, toIndex: r.fromIndex });
+        }
+        currentIndex = r.toIndex;
+      }
+      redactions.push({ fromIndex: currentIndex, toIndex: response.length });
+    }
+    for (const r of reveals) {
+      if (!r.hash) {
+        continue;
+      }
+      redactions.push(r);
+    }
+    redactions.sort((a, b) => a.toIndex - b.toIndex);
+    return redactions;
+  },
+  assertValidProviderReceipt({ receipt, params: paramsAny, logger: logger2, ctx }) {
+    logTranscript();
+    let extractedParams = {};
+    const secretParams = "secretParams" in paramsAny ? paramsAny.secretParams : void 0;
+    const newParams = substituteParamValues(paramsAny, secretParams, !secretParams);
+    const params = newParams.newParams;
+    extractedParams = { ...extractedParams, ...newParams.extractedValues };
+    const req = getHttpRequestDataFromTranscript(receipt);
+    if (req.method !== params.method.toLowerCase()) {
+      throw new Error(`Invalid method: ${req.method}`);
+    }
+    const url = new URL(params.url);
+    const { protocol, pathname } = url;
+    if (protocol !== "https:") {
+      logger2.error("params URL: %s", params.url);
+      throw new Error(`Expected protocol: https, found: ${protocol}`);
+    }
+    const searchParams = params.url.includes("?") ? params.url.split("?")[1] : "";
+    const expectedPath = pathname.replaceAll("%7B", "{").replaceAll("%7D", "}") + (searchParams?.length ? "?" + searchParams : "");
+    if (!matchRedactedStrings(strToUint8Array(expectedPath), strToUint8Array(req.url))) {
+      logger2.error("params URL: %s", params.url);
+      throw new Error(`Expected path: ${expectedPath}, found: ${req.url}`);
+    }
+    const expectedHostStr = getHostHeaderString(url);
+    if (req.headers.host !== expectedHostStr) {
+      throw new Error(`Expected host: ${expectedHostStr}, found: ${req.headers.host}`);
+    }
+    const connectionHeader = req.headers["connection"];
+    if (connectionHeader !== "close") {
+      throw new Error(`Connection header must be "close", got "${connectionHeader}"`);
+    }
+    const serverBlocks = receipt.filter((s) => s.sender === "server").map((r) => r.message).filter((b) => !b.every((b2) => b2 === REDACTION_CHAR_CODE));
+    const response = concatArrays(...serverBlocks);
+    let res;
+    res = uint8ArrayToStr(response);
+    const okRegex = makeRegex("^HTTP\\/1.1 2\\d{2}");
+    const matchRes = okRegex.exec(res);
+    if (!matchRes) {
+      const statusRegex = makeRegex("^HTTP\\/1.1 (\\d{3})");
+      const matchRes2 = statusRegex.exec(res);
+      if (matchRes2 && matchRes2.length > 1) {
+        throw new Error(`Provider returned error ${matchRes2[1]}`);
+      }
+      let lineEnd = res.indexOf("*");
+      if (lineEnd === -1) {
+        lineEnd = res.indexOf("\n");
+      }
+      if (lineEnd === -1) {
+        lineEnd = OK_HTTP_HEADER.length;
+      }
+      throw new Error(
+        `Response did not start with "HTTP/1.1 2XX" got "${res.slice(0, lineEnd)}"`
+      );
+    }
+    let bodyStart;
+    if (shouldRevealCrlf(ctx)) {
+      bodyStart = res.indexOf("\r\n\r\n", OK_HTTP_HEADER.length) + 4;
+      if (bodyStart < 4) {
+        throw new Error("Response body start not found");
+      }
+    } else {
+      bodyStart = OK_HTTP_HEADER.length;
+    }
+    const dateHeader = makeRegex(dateHeaderRegex).exec(res);
+    if (dateHeader && dateHeader.length > 1) {
+      const serverDate = new Date(dateHeader[1]);
+      if (Date.now() - serverDate.getTime() > dateDiff) {
+        logger2.info({ dateHeader: dateHeader[0], current: Date.now() }, "date header is off");
+      }
+    }
+    const paramBody = params.body instanceof Uint8Array ? params.body : strToUint8Array(params.body || "");
+    if (paramBody.length > 0 && !matchRedactedStrings(paramBody, req.body)) {
+      throw new Error("request body mismatch");
+    }
+    if (!secretParams) {
+      res = res.slice(bodyStart).replace(/(\*){3,}/g, "");
+    }
+    for (const { type, value, invert } of params.responseMatches || []) {
+      const inv = Boolean(invert);
+      switch (type) {
+        case "regex":
+          const regexRes = makeRegex(value).exec(res);
+          const match = regexRes !== null;
+          if (match === inv) {
+            throw new Error(
+              `Invalid receipt. Regex "${value}" ${invert ? "matched" : "didn't match"}`
+            );
+          }
+          if (!match) {
+            continue;
+          }
+          const groups = regexRes?.groups;
+          for (const paramName in groups || []) {
+            if (paramName in extractedParams) {
+              throw new Error(`Duplicate parameter ${paramName}`);
+            }
+            const value2 = groups?.[paramName];
+            if (typeof value2 !== "string") {
+              continue;
+            }
+            extractedParams[paramName] = value2;
+          }
+          break;
+        case "contains":
+          const includes = res.includes(value);
+          if (includes === inv) {
+            throw new Error(
+              `Invalid receipt. Response ${invert ? "contains" : "does not contain"} "${value}"`
+            );
+          }
+          break;
+        default:
+          throw new Error(`Invalid response match type ${type}`);
+      }
+    }
+    function concatArrays(...bufs) {
+      const totalSize = bufs.reduce((acc, e) => acc + e.length, 0);
+      const merged = new Uint8Array(totalSize);
+      let lenDone = 0;
+      for (const array of bufs) {
+        merged.set(array, lenDone);
+        lenDone += array.length;
+      }
+      return merged;
+    }
+    return { extractedParameters: extractedParams };
+    function logTranscript() {
+      const clientMsgs = receipt.filter((s) => s.sender === "client").map((m) => m.message);
+      const serverMsgs = receipt.filter((s) => s.sender === "server").map((m) => m.message);
+      const clientTranscript = encodeBase64(concatenateUint8Arrays(clientMsgs));
+      const serverTranscript = encodeBase64(concatenateUint8Arrays(serverMsgs));
+      logger2.debug({ request: clientTranscript, response: serverTranscript, params: paramsAny });
+    }
+  }
+};
+function shouldRevealCrlf({ version }) {
+  return version >= AttestorVersion.ATTESTOR_VERSION_2_0_1;
+}
+function getHostPort(params, secretParams) {
+  const { host } = new URL(getURL(params, secretParams));
+  if (!host) {
+    throw new Error("url is incorrect");
+  }
+  return host;
+}
+function getHostHeaderString(url) {
+  const host = url.hostname;
+  const port = url.port;
+  return port && +port !== DEFAULT_HTTPS_PORT ? `${host}:${port}` : host;
+}
+const paramsRegex = /{{([^{}]+)}}/sgi;
+function* processRedactionRequest(body, rs, bodyStartIdx, resChunks) {
+  let element = body;
+  let elementIdx = 0;
+  let elementLength = -1;
+  if (rs.xPath) {
+    const indexes = extractHTMLElementsIndexes(body, rs.xPath, !!rs.jsonPath);
+    for (const { start, end } of indexes) {
+      element = body.slice(start, end);
+      elementIdx = start;
+      elementLength = end - start;
+      if (rs.jsonPath) {
+        yield* processJsonPath();
+      } else if (rs.regex) {
+        yield* processRegexp();
+      } else {
+        yield* addRedaction();
+      }
+    }
+  } else if (rs.jsonPath) {
+    yield* processJsonPath();
+  } else if (rs.regex) {
+    yield* processRegexp();
+  } else {
+    throw new Error(
+      "Expected either xPath, jsonPath or regex for redaction"
+    );
+  }
+  function* processJsonPath() {
+    const jsonPathIndexes = extractJSONValueIndexes(element, rs.jsonPath);
+    const eIndex = elementIdx;
+    for (const ji of jsonPathIndexes) {
+      const jStart = ji.start;
+      const jEnd = ji.end;
+      element = body.slice(eIndex + jStart, eIndex + jEnd);
+      elementIdx = eIndex + jStart;
+      elementLength = jEnd - jStart;
+      if (rs.regex) {
+        yield* processRegexp();
+      } else {
+        yield* addRedaction();
+      }
+    }
+  }
+  function* processRegexp() {
+    logger.debug({
+      element: encodeBase64(strToUint8Array(element)),
+      body: encodeBase64(strToUint8Array(body))
+    });
+    const regexp = makeRegex(rs.regex);
+    const elem = element || body;
+    const match = regexp.exec(elem);
+    if (!match?.[0]) {
+      throw new Error(
+        `regexp ${rs.regex} does not match found element '${encodeBase64(strToUint8Array(elem))}'`
+      );
+    }
+    elementIdx += match.index;
+    elementLength = regexp.lastIndex - match.index;
+    element = match[0];
+    if (rs.hash && (!match.groups || Object.keys(match.groups).length > 1)) {
+      throw new Error(
+        "Exactly one named capture group is needed per hashed redaction"
+      );
+    }
+    if (!rs.hash || !match.groups) {
+      yield* addRedaction();
+      return;
+    }
+    const fullStr = match[0];
+    const grp = Object.values(match.groups)[0];
+    const grpIdx = fullStr.indexOf(grp);
+    elementLength = grpIdx;
+    element = fullStr.slice(0, grpIdx);
+    yield* addRedaction(null);
+    elementIdx += grpIdx;
+    element = grp;
+    elementLength = grp.length;
+    const reveal = getReveal(elementIdx, elementLength, rs.hash);
+    const chunkReds = getRedactionsForChunkHeaders(reveal.fromIndex, reveal.toIndex, resChunks);
+    if (chunkReds.length) {
+      throw new Error(
+        "Hash redactions cannot be performed if the redacted string is split between 2 or more HTTP chunks"
+      );
+    }
+    yield { reveal, redactions: chunkReds };
+    elementIdx += grp.length;
+    element = fullStr.slice(grpIdx + grp.length);
+    elementLength = element.length;
+    yield* addRedaction(null);
+  }
+  function* addRedaction(hash = rs.hash, _resChunks = resChunks) {
+    if (elementIdx < 0 || !elementLength) {
+      return;
+    }
+    const reveal = getReveal(elementIdx, elementLength, hash || void 0);
+    yield {
+      reveal,
+      redactions: getRedactionsForChunkHeaders(
+        reveal.fromIndex,
+        reveal.toIndex,
+        _resChunks
+      )
+    };
+  }
+  function getReveal(startIdx, len, hash) {
+    const from = convertResponsePosToAbsolutePos(
+      startIdx,
+      bodyStartIdx,
+      resChunks
+    );
+    const to = convertResponsePosToAbsolutePos(
+      startIdx + len,
+      bodyStartIdx,
+      resChunks
+    );
+    return { fromIndex: from, toIndex: to, hash };
+  }
+}
+function substituteParamValues(currentParams, secretParams, ignoreMissingParams) {
+  const params = JSON.parse(JSON.stringify(currentParams));
+  let extractedValues = {};
+  const hiddenURLParts = [];
+  const urlParams = extractAndReplaceTemplateValues(params.url, ignoreMissingParams);
+  if (urlParams) {
+    params.url = urlParams.newParam;
+    extractedValues = { ...urlParams.extractedValues };
+    if (urlParams.hiddenParts.length) {
+      const host = getHostHeaderString(new URL(params.url));
+      const offset = `https://${host}`.length - currentParams.method.length - 1;
+      for (const hiddenURLPart of urlParams.hiddenParts) {
+        hiddenURLParts.push({ index: hiddenURLPart.index - offset, length: hiddenURLPart.length });
+      }
+    }
+  }
+  let bodyParams;
+  let hiddenBodyParts = [];
+  if (params.body) {
+    const strBody = typeof params.body === "string" ? params.body : uint8ArrayToStr(params.body);
+    bodyParams = extractAndReplaceTemplateValues(strBody, ignoreMissingParams);
+    if (bodyParams) {
+      params.body = bodyParams.newParam;
+      extractedValues = { ...extractedValues, ...bodyParams.extractedValues };
+      hiddenBodyParts = bodyParams.hiddenParts;
+    }
+  }
+  const geoParams = extractAndReplaceTemplateValues(params.geoLocation);
+  if (geoParams) {
+    params.geoLocation = geoParams.newParam;
+    extractedValues = { ...extractedValues, ...geoParams.extractedValues };
+  }
+  const proxySessionIdParams = extractAndReplaceTemplateValues(params.proxySessionId);
+  if (proxySessionIdParams) {
+    params.proxySessionId = proxySessionIdParams.newParam;
+    extractedValues = { ...extractedValues, ...proxySessionIdParams.extractedValues };
+  }
+  if (params.responseRedactions) {
+    for (const r of params.responseRedactions) {
+      if (r.regex) {
+        const regexParams = extractAndReplaceTemplateValues(r.regex);
+        r.regex = regexParams?.newParam;
+      }
+      if (r.xPath) {
+        const xpathParams = extractAndReplaceTemplateValues(r.xPath);
+        r.xPath = xpathParams?.newParam;
+      }
+      if (r.jsonPath) {
+        const jsonPathParams = extractAndReplaceTemplateValues(r.jsonPath);
+        r.jsonPath = jsonPathParams?.newParam;
+      }
+    }
+  }
+  if (params.responseMatches) {
+    for (const r of params.responseMatches) {
+      if (r.value !== "") {
+        const matchParam = extractAndReplaceTemplateValues(r.value);
+        r.value = matchParam?.newParam;
+        extractedValues = { ...extractedValues, ...matchParam?.extractedValues };
+      }
+    }
+  }
+  return {
+    newParams: params,
+    extractedValues,
+    hiddenBodyParts,
+    hiddenURLParts
+  };
+  function extractAndReplaceTemplateValues(param, ignoreMissingParams2) {
+    if (!param) {
+      return null;
+    }
+    const extractedValues2 = {};
+    const hiddenParts = [];
+    let totalOffset = 0;
+    param = param.replace(paramsRegex, (match, pn, offset) => {
+      if (params.paramValues && pn in params.paramValues) {
+        extractedValues2[pn] = params.paramValues[pn];
+        totalOffset += params.paramValues[pn].length - match.length;
+        return params.paramValues[pn];
+      } else if (secretParams) {
+        if (secretParams?.paramValues && pn in secretParams?.paramValues) {
+          hiddenParts.push({
+            index: offset + totalOffset,
+            length: secretParams.paramValues[pn].length
+          });
+          totalOffset += secretParams.paramValues[pn].length - match.length;
+          return secretParams.paramValues[pn];
+        } else {
+          throw new Error(`parameter's "${pn}" value not found in paramValues and secret parameter's paramValues`);
+        }
+      } else {
+        if (!!!ignoreMissingParams2) {
+          throw new Error(`parameter's "${pn}" value not found in paramValues`);
+        } else {
+          return match;
+        }
+      }
+    });
+    return {
+      newParam: param,
+      extractedValues: extractedValues2,
+      hiddenParts
+    };
+  }
+}
+function getGeoLocation(v2Params, secretParams) {
+  if (v2Params?.geoLocation) {
+    const paramNames = /* @__PURE__ */ new Set();
+    let geo = v2Params.geoLocation;
+    let match = null;
+    while (match = paramsRegex.exec(geo)) {
+      paramNames.add(match[1]);
+    }
+    for (const pn of paramNames) {
+      if (v2Params.paramValues && pn in v2Params.paramValues) {
+        geo = geo?.replaceAll(`{{${pn}}}`, v2Params.paramValues[pn].toString());
+      } else if (secretParams?.paramValues && pn in secretParams.paramValues) {
+        geo = geo?.replaceAll(`{{${pn}}}`, secretParams.paramValues[pn].toString());
+      } else {
+        throw new Error(`parameter "${pn}" value not found in templateParams`);
+      }
+    }
+    const geoRegex = /^[A-Za-z]{2}$/sgiu;
+    if (!geoRegex.test(geo)) {
+      throw new Error(`Geolocation ${geo} is invalid`);
+    }
+    return geo;
+  }
+  return void 0;
+}
+function getProxySessionId(v2Params, secretParams) {
+  if (v2Params?.proxySessionId) {
+    const paramNames = /* @__PURE__ */ new Set();
+    let proxySessionIdValue = v2Params.proxySessionId;
+    let match = null;
+    while (match = paramsRegex.exec(proxySessionIdValue)) {
+      paramNames.add(match[1]);
+    }
+    for (const pn of paramNames) {
+      if (v2Params.paramValues && pn in v2Params.paramValues) {
+        proxySessionIdValue = proxySessionIdValue?.replaceAll(`{{${pn}}}`, v2Params.paramValues[pn].toString());
+      } else if (secretParams?.paramValues && pn in secretParams.paramValues) {
+        proxySessionIdValue = proxySessionIdValue?.replaceAll(`{{${pn}}}`, secretParams.paramValues[pn].toString());
+      } else {
+        throw new Error(`parameter "${pn}" value not found in templateParams`);
+      }
+    }
+    if (!isValidProxySessionId(proxySessionIdValue)) {
+      throw new Error(`proxySessionId ${proxySessionIdValue} is invalid`);
+    }
+    return proxySessionIdValue;
+  }
+  return void 0;
+}
+function getURL(v2Params, secretParams) {
+  let hostPort = v2Params?.url;
+  const paramNames = /* @__PURE__ */ new Set();
+  let match = null;
+  while (match = paramsRegex.exec(hostPort)) {
+    paramNames.add(match[1]);
+  }
+  for (const pn of paramNames) {
+    if (v2Params.paramValues && pn in v2Params.paramValues) {
+      hostPort = hostPort?.replaceAll(`{{${pn}}}`, v2Params.paramValues[pn].toString());
+    } else if (secretParams?.paramValues && pn in secretParams.paramValues) {
+      hostPort = hostPort?.replaceAll(`{{${pn}}}`, secretParams.paramValues[pn].toString());
+    } else {
+      throw new Error(`parameter "${pn}" value not found in templateParams`);
+    }
+  }
+  return hostPort;
+}
+var http_default = HTTP_PROVIDER;
+export {
+  http_default as default,
+  substituteParamValues
+};

package/lib/browser/providers/http/patch-parse5-tree.d.ts

@@ -0,0 +1,6 @@
+import { Node } from 'domhandler';
+declare module 'xpath' {
+    function parse(expr: string): {
+        select(opts: unknown): Node[];
+    };
+}

package/lib/browser/providers/http/patch-parse5-tree.js

@@ -0,0 +1,34 @@
+import { Element, Node } from "domhandler";
+Element.prototype.toString = function() {
+  throw new Error("Element.toString() is not supported");
+};
+Object.defineProperty(Node.prototype, "nodeName", {
+  get: function() {
+    return this.name;
+  }
+});
+Object.defineProperty(Node.prototype, "localName", {
+  get: function() {
+    return this.name;
+  }
+});
+const origAttributes = Object.getOwnPropertyDescriptor(
+  Element.prototype,
+  "attributes"
+)?.get;
+if (origAttributes) {
+  Object.defineProperty(Element.prototype, "attributes", {
+    get: function(...args) {
+      const attrs = origAttributes.call(this, ...args);
+      attrs.item = (idx) => {
+        const el = attrs[idx];
+        return { ...el, nodeType: 2, localName: el.name };
+      };
+      return attrs;
+    }
+  });
+} else {
+  console.warn(
+    "[WARN] Unable to patch DOM: Element.attributes property descriptor not found"
+  );
+}