lambda-live-debugger 1.12.8 → 1.12.9

package/node_modules/toml/lib/compiler.js

@@ -5,6 +5,17 @@ var INT64_MAX = 2n ** 63n - 1n;
 var MAX_SAFE = BigInt(Number.MAX_SAFE_INTEGER);
 var MIN_SAFE = BigInt(Number.MIN_SAFE_INTEGER);
 
+// TOML's redefinition rules depend on how a table came to exist, not on its
+// shape, so every container the compiler creates is tagged with its origin.
+// Values that arrive from the parser (dates, static arrays, primitives) are
+// never tagged, which is what stops key paths from descending into them and
+// on into their prototype chains.
+var HEADER_TABLE = "header";     // [a]
+var IMPLICIT_TABLE = "implicit"; // `a` in [a.b]; a later [a] header may still define it
+var DOTTED_TABLE = "dotted";     // `a` in a.b = 1
+var INLINE_TABLE = "inline";     // a = { b = 1 }; closed once parsed
+var TABLE_ARRAY = "table-array"; // [[a]]
+
 function compile(nodes, inputText, options) {
   options = options || {};
   var temporal = null;
@@ -19,13 +30,10 @@ function compile(nodes, inputText, options) {
     }
   }
 
-  var assignedPaths = new Set();
-  var valueAssignments = new Set();
-  var explicitTablePaths = new Set();
-  var currentPath = [];
-  var ownedContainers = new WeakSet();
-  var data = createTable();
+  var containerKinds = new WeakMap();
+  var data = createTable(HEADER_TABLE);
   var context = data;
+  var currentPath = [];
 
   return reduce(nodes);
 
@@ -67,46 +75,43 @@ function compile(nodes, inputText, options) {
   }
 
   function assign(node) {
-    var keys = node.key;
-    var value = node.value;
-    var off = node.offset;
-
-    if (!Array.isArray(keys)) keys = [keys];
-
-    var reduced = reduceValueNode(value);
+    var keys = Array.isArray(node.key) ? node.key : [node.key];
+    assignDotted(context, keys, reduceValueNode(node.value), node.offset, currentPath);
+  }
 
-    var target = context;
+  // Walks `keys` down from `table`, creating intermediate tables as needed,
+  // and stores `value` under the last key. `prefix` names the path leading to
+  // `table` and is only used in error messages.
+  function assignDotted(table, keys, value, off, prefix) {
     for (var i = 0; i < keys.length - 1; i++) {
-      var k = keys[i];
-      var intermediatePath = makeFullPath(keys.slice(0, i + 1));
-
-      if (typeof target[k] === "undefined") {
-        target[k] = createTable();
-        assignedPaths.add(intermediatePath);
-      } else if (typeof target[k] !== "object" || target[k] === null || Array.isArray(target[k])) {
-        genError("Cannot redefine existing key '" + intermediatePath + "'.", off);
-      } else if (valueAssignments.has(intermediatePath)) {
-        genError("Cannot redefine existing key '" + intermediatePath + "'.", off);
-      } else if (explicitTablePaths.has(intermediatePath) && intermediatePath !== pathKey(currentPath)) {
-        genError("Cannot use dotted keys to extend table '" + intermediatePath + "' defined elsewhere.", off);
+      var key = keys[i];
+      var next = table[key];
+      if (next === undefined) {
+        next = createTable(DOTTED_TABLE);
+        table[key] = next;
+      } else {
+        var kind = containerKinds.get(next);
+        if (kind !== DOTTED_TABLE && kind !== IMPLICIT_TABLE) {
+          var path = pathKey(prefix.concat(keys.slice(0, i + 1)));
+          if (kind === HEADER_TABLE) {
+            genError("Cannot use dotted keys to extend table '" + path + "' defined elsewhere.", off);
+          }
+          if (kind === INLINE_TABLE) {
+            genError("Cannot extend inline table '" + path + "'.", off);
+          }
+          genError("Cannot redefine existing key '" + path + "'.", off);
+        }
       }
-      target = target[k];
+      table = next;
     }
 
     var lastKey = keys[keys.length - 1];
-    var fullPath = makeFullPath(keys);
-
-    if (typeof target[lastKey] !== "undefined") {
-      genError("Cannot redefine existing key '" + fullPath + "'.", off);
+    if (table[lastKey] !== undefined) {
+      genError("Cannot redefine existing key '" + pathKey(prefix.concat(keys)) + "'.", off);
     }
-
-    target[lastKey] = reduced;
-
-    assignedPaths.add(fullPath);
-    valueAssignments.add(fullPath);
+    table[lastKey] = value;
   }
 
-
   function reduceValueNode(node) {
     if (node.type === "Integer") {
       return reduceInteger(node);
@@ -162,162 +167,114 @@ function compile(nodes, inputText, options) {
   }
 
   function reduceInlineTableNode(values) {
-    var obj = createTable();
-    var definedKeys = new Set();
+    var table = createTable(INLINE_TABLE);
 
     for (var i = 0; i < values.length; i++) {
       var val = values[i];
       if (val.type !== "InlineTableValue") continue;
 
-      var keys = val.key;
-      if (!Array.isArray(keys)) keys = [keys];
-
-      var reduced = reduceValueNode(val.value);
-      setNestedKey(obj, keys, reduced, val.offset, definedKeys);
-
-      definedKeys.add(pathKey(keys));
+      var keys = Array.isArray(val.key) ? val.key : [val.key];
+      assignDotted(table, keys, reduceValueNode(val.value), val.offset, []);
     }
 
-    return obj;
-  }
-
-  function setNestedKey(obj, keys, value, off, definedKeys) {
-    for (var i = 0; i < keys.length - 1; i++) {
-      var k = keys[i];
-      var intermediatePath = pathKey(keys.slice(0, i + 1));
-      if (typeof obj[k] === "undefined") {
-        obj[k] = createTable();
-      } else if (typeof obj[k] !== "object" || obj[k] === null || Array.isArray(obj[k])) {
-        genError("Cannot redefine existing key '" + intermediatePath + "'.", off);
-      } else if (definedKeys && definedKeys.has(intermediatePath)) {
-        genError("Cannot extend inline table '" + intermediatePath + "'.", off);
-      }
-      obj = obj[k];
-    }
-    var lastKey = keys[keys.length - 1];
-    if (typeof obj[lastKey] !== "undefined") {
-      genError("Cannot redefine existing key '" + pathKey(keys) + "'.", off);
-    }
-    obj[lastKey] = value;
+    return table;
   }
 
   function setPath(node) {
     var path = node.value;
-    var quotedPath = path.map(quoteDottedString).join(".");
     var off = node.offset;
 
-    if (assignedPaths.has(quotedPath)) {
-      genError("Cannot redefine existing key '" + path + "'.", off);
+    var parent = resolveParentTable(path, off);
+    var name = path[path.length - 1];
+    var table = parent[name];
+
+    if (table === undefined) {
+      table = createTable(HEADER_TABLE);
+      parent[name] = table;
+    } else if (containerKinds.get(table) === IMPLICIT_TABLE) {
+      containerKinds.set(table, HEADER_TABLE);
+    } else {
+      genError("Cannot redefine existing key '" + pathKey(path) + "'.", off);
     }
-    assignedPaths.add(quotedPath);
-    explicitTablePaths.add(quotedPath);
-    context = deepRef(data, path, createTable(), off);
+
+    context = table;
     currentPath = path;
   }
 
   function addTableArray(node) {
     var path = node.value;
-    var quotedPath = path.map(quoteDottedString).join(".");
     var off = node.offset;
 
-    if (valueAssignments.has(quotedPath)) {
-      genError("Cannot append to statically defined array '" + quotedPath + "'.", off);
+    var parent = resolveParentTable(path, off);
+    var name = path[path.length - 1];
+    var tableArray = parent[name];
+
+    if (tableArray === undefined) {
+      tableArray = createTableArray();
+      parent[name] = tableArray;
+    } else if (containerKinds.get(tableArray) !== TABLE_ARRAY) {
+      if (Array.isArray(tableArray)) {
+        genError("Cannot append to statically defined array '" + pathKey(path) + "'.", off);
+      }
+      genError("Cannot redefine existing key '" + pathKey(path) + "'.", off);
     }
 
-    // Clear this table array path and paths nested under it.
-    assignedPaths.forEach(function(p) {
-      if (isSameOrSubPath(p, quotedPath)) assignedPaths.delete(p);
-    });
-    valueAssignments.forEach(function(p) {
-      if (isSameOrSubPath(p, quotedPath)) valueAssignments.delete(p);
-    });
-    assignedPaths.add(quotedPath);
-    context = deepRef(data, path, createTableArray(), off);
+    var table = createTable(HEADER_TABLE);
+    tableArray.push(table);
+    context = table;
     currentPath = path;
-
-    if (context instanceof Array) {
-      var newObj = createTable();
-      context.push(newObj);
-      context = newObj;
-    } else {
-      genError("Cannot redefine existing key '" + path + "'.", off);
-    }
   }
 
-  function deepRef(start, keys, value, off) {
-    var ctx = start;
-
-    for (var i = 0; i < keys.length; i++) {
-      var key = keys[i];
-      var traversedPath = pathKey(keys.slice(0, i + 1));
-      if (typeof ctx[key] === "undefined") {
-        if (i === keys.length - 1) {
-          ctx[key] = value;
-        } else {
-          ctx[key] = createTable();
-        }
-      } else if (i !== keys.length - 1 && valueAssignments.has(traversedPath)) {
-        genError("Cannot redefine existing key '" + traversedPath + "'.", off);
+  // Returns the table a header's last key belongs in, creating implicit
+  // tables along the way. A path through an array of tables refers to its
+  // most recent element.
+  function resolveParentTable(path, off) {
+    var table = data;
+    for (var i = 0; i < path.length - 1; i++) {
+      var key = path[i];
+      var next = table[key];
+      if (next === undefined) {
+        next = createTable(IMPLICIT_TABLE);
+        table[key] = next;
       }
 
-      ctx = ctx[key];
-      if (i < keys.length - 1) {
-        if (!isOwnedContainer(ctx)) {
-          genError("Cannot redefine existing key '" + traversedPath + "'.", off);
-        }
-        if (ctx instanceof Array) {
-          if (!ctx.length) {
-            genError("Cannot redefine existing key '" + traversedPath + "'.", off);
-          }
-          ctx = ctx[ctx.length - 1];
-          if (!isOwnedContainer(ctx)) {
-            genError("Cannot redefine existing key '" + traversedPath + "'.", off);
-          }
-        }
+      var kind = containerKinds.get(next);
+      if (kind === TABLE_ARRAY) {
+        next = next[next.length - 1];
+      } else if (kind === undefined || kind === INLINE_TABLE) {
+        genError("Cannot redefine existing key '" + pathKey(path.slice(0, i + 1)) + "'.", off);
       }
+      table = next;
     }
-
-    return ctx;
+    return table;
   }
 
   function reduceArray(array) {
     return array.map(reduceValueNode);
   }
 
-  function quoteDottedString(str) {
-    if (str.indexOf(".") > -1) {
-      return "\"" + str + "\"";
-    } else {
-      return str;
-    }
-  }
-
-  function createTable() {
+  function createTable(kind) {
     var table = Object.create(null);
-    ownedContainers.add(table);
+    containerKinds.set(table, kind);
     return table;
   }
 
   function createTableArray() {
     var tableArray = [];
-    ownedContainers.add(tableArray);
+    containerKinds.set(tableArray, TABLE_ARRAY);
     return tableArray;
   }
 
-  function isOwnedContainer(value) {
-    return value !== null && typeof value === "object" && ownedContainers.has(value);
-  }
-
   function pathKey(keys) {
     return keys.map(quoteDottedString).join(".");
   }
 
-  function makeFullPath(keys) {
-    return pathKey(currentPath.concat(keys));
-  }
-
-  function isSameOrSubPath(path, prefix) {
-    return path === prefix || path.indexOf(prefix + ".") === 0;
+  function quoteDottedString(str) {
+    if (str.indexOf(".") > -1) {
+      return "\"" + str + "\"";
+    } else {
+      return str;
+    }
   }
 }
 

package/node_modules/toml/lib/parser.js

@@ -323,10 +323,10 @@ function peg$parse(input, options) {
   function peg$f39(sign, digits) {    return (sign === '-' ? '-' : '') + digits  }
   function peg$f40() {    return '0'  }
   function peg$f41(sign, digits) {    return (sign || '') + digits  }
-  function peg$f42(digits) {    return node('Integer', BigInt('0x' + stripUnderscores(digits)), offset())  }
-  function peg$f43(digits) {    return node('Integer', BigInt('0o' + stripUnderscores(digits)), offset())  }
-  function peg$f44(digits) {    return node('Integer', BigInt('0b' + stripUnderscores(digits)), offset())  }
-  function peg$f45(text) {    return node('Integer', BigInt(stripUnderscores(text)), offset())  }
+  function peg$f42(digits) {    return integerNode(16, digits, offset())  }
+  function peg$f43(digits) {    return integerNode(8, digits, offset())  }
+  function peg$f44(digits) {    return integerNode(2, digits, offset())  }
+  function peg$f45(text) {    return integerNode(10, text, offset())  }
   function peg$f46(sign) {    return (sign || '') + '0'  }
   function peg$f47(sign, digits) {    return (sign || '') + digits  }
   function peg$f48() {    return node('Boolean', true, offset())  }
@@ -4416,6 +4416,22 @@ function peg$parse(input, options) {
     return str.indexOf('_') === -1 ? str : str.replace(/_/g, '');
   }
 
+  // Digits in the largest int64 magnitude for each base. BigInt conversion
+  // is super-linear in digit count, so a literal that cannot fit is rejected
+  // by length before converting (GHSA-9qmh-m7c6-f92p); the compiler still
+  // performs the exact range check on what gets through.
+  var MAX_INT64_DIGITS = { 2: 63, 8: 21, 10: 19, 16: 16 };
+  var RADIX_PREFIX = { 2: '0b', 8: '0o', 10: '', 16: '0x' };
+
+  function integerNode(radix, text, off) {
+    var digits = stripUnderscores(text);
+    var significant = digits.replace(/^[+-]?0*/, '');
+    if (significant.length > MAX_INT64_DIGITS[radix]) {
+      genError("Integer literal is outside the 64-bit signed integer range required by TOML.", off);
+    }
+    return node('Integer', BigInt(RADIX_PREFIX[radix] + digits), off);
+  }
+
   function convertCodePoint(str) {
     var num = parseInt(str, 16);
 

package/node_modules/toml/package.json

@@ -1,6 +1,6 @@
 {
   "name": "toml",
-  "version": "5.0.0",
+  "version": "5.0.1",
   "description": "TOML parser for Node.js (TOML v1.1.0 compliant)",
   "main": "index.js",
   "types": "index.d.ts",

package/node_modules/undici-types/client.d.ts

@@ -33,7 +33,7 @@ export declare namespace Client {
   export interface Options {
     /** The maximum length of request headers in bytes. Default: Node.js' `--max-http-header-size` or `16384` (16KiB). */
     maxHeaderSize?: number;
-    /** The amount of time, in milliseconds, the parser will wait to receive the complete HTTP headers (Node 14 and above only). Default: `300e3` milliseconds (300s). */
+    /** The amount of time, in milliseconds, the parser will wait to receive the complete HTTP headers (Node 14 and above only). Default: `300e3` milliseconds (300s). HTTP/1.1 parser timeouts are not guaranteed to fire with exact millisecond precision: delays up to 1000ms use native timers, while larger delays use lower-overhead fast timers with a target resolution around 500ms. */
     headersTimeout?: number;
     /** @deprecated unsupported socketTimeout, use headersTimeout & bodyTimeout instead */
     socketTimeout?: never;
@@ -41,7 +41,7 @@ export declare namespace Client {
     requestTimeout?: never;
     /** The timeout for establishing a socket connection, in milliseconds. Use `0` to disable it entirely. Default: `10e3` milliseconds (10s). */
     connectTimeout?: number;
-    /** The timeout after which a request will time out, in milliseconds. Monitors time between receiving body data. Use `0` to disable it entirely. Default: `300e3` milliseconds (300s). */
+    /** The timeout after which a request will time out, in milliseconds. Monitors time between receiving body data. Use `0` to disable it entirely. Default: `300e3` milliseconds (300s). HTTP/1.1 parser timeouts are not guaranteed to fire with exact millisecond precision: delays up to 1000ms use native timers, while larger delays use lower-overhead fast timers with a target resolution around 500ms. */
     bodyTimeout?: number;
     /** @deprecated unsupported idleTimeout, use keepAliveTimeout instead */
     idleTimeout?: never;
@@ -57,7 +57,7 @@ export declare namespace Client {
     keepAliveTimeoutThreshold?: number;
     /** An IPC endpoint, either a Unix domain socket or Windows named pipe. Default: `null`. */
     socketPath?: string;
-    /** The amount of concurrent requests to be sent over the single TCP/TLS connection according to [RFC7230](https://tools.ietf.org/html/rfc7230#section-6.3.2). Default: `1`. */
+    /** The amount of concurrent requests to be sent over the single TCP/TLS connection according to [RFC7230](https://tools.ietf.org/html/rfc7230#section-6.3.2). Only enable values greater than `1` when the remote server is trusted. Default: `1`. */
     pipelining?: number;
     /** @deprecated use the connect option instead */
     tls?: never;
@@ -116,6 +116,11 @@ export declare namespace Client {
     bytesRead?: number
   }
   export interface WebSocketOptions {
+    /**
+     * Maximum number of fragments in a message. Set to 0 to disable the limit.
+     * @default 131072
+     */
+    maxFragments?: number;
     /**
      * Maximum allowed payload size in bytes for WebSocket messages.
      * Applied to uncompressed messages, compressed frame payloads, and decompressed (permessage-deflate) messages.

package/node_modules/undici-types/connector.d.ts

@@ -7,6 +7,7 @@ declare function buildConnector (options?: buildConnector.BuildOptions): buildCo
 declare namespace buildConnector {
   export type BuildOptions = (ConnectionOptions | TcpNetConnectOpts | IpcNetConnectOpts) & {
     allowH2?: boolean;
+    preferH2?: boolean;
     maxCachedSessions?: number | null;
     socketPath?: string | null;
     timeout?: number | null;

package/node_modules/undici-types/cookies.d.ts

@@ -18,7 +18,7 @@ export interface Cookie {
 export function deleteCookie (
   headers: Headers,
   name: string,
-  attributes?: { name?: string, domain?: string }
+  attributes?: { path?: string, domain?: string }
 ): void
 
 export function getCookies (headers: Headers): Record<string, string>

package/node_modules/undici-types/dispatcher.d.ts

@@ -111,13 +111,13 @@ declare namespace Dispatcher {
     idempotent?: boolean;
     /** Whether the response is expected to take a long time and would end up blocking the pipeline. When this is set to `true` further pipelining will be avoided on the same connection until headers have been received. Defaults to `method !== 'HEAD'`. */
     blocking?: boolean;
-    /** The IP Type of Service (ToS) value for the request socket. Must be an integer between 0 and 255. Default: `0` */
+    /** The IP Type of Service (ToS) value for the request socket. Must be an integer between 0 and 255. */
     typeOfService?: number | null;
     /** Upgrade the request. Should be used to specify the kind of upgrade i.e. `'Websocket'`. Default: `method === 'CONNECT' || null`. */
     upgrade?: boolean | string | null;
-    /** The amount of time, in milliseconds, the parser will wait to receive the complete HTTP headers. Defaults to 300 seconds. */
+    /** The amount of time, in milliseconds, the parser will wait to receive the complete HTTP headers. Defaults to 300 seconds. HTTP/1.1 parser timeouts are not guaranteed to fire with exact millisecond precision: delays up to 1000ms use native timers, while larger delays use lower-overhead fast timers with a target resolution around 500ms. */
     headersTimeout?: number | null;
-    /** The timeout after which a request will time out, in milliseconds. Monitors time between receiving body data. Use 0 to disable it entirely. Defaults to 300 seconds. */
+    /** The timeout after which a request will time out, in milliseconds. Monitors time between receiving body data. Use 0 to disable it entirely. Defaults to 300 seconds. HTTP/1.1 parser timeouts are not guaranteed to fire with exact millisecond precision: delays up to 1000ms use native timers, while larger delays use lower-overhead fast timers with a target resolution around 500ms. */
     bodyTimeout?: number | null;
     /** Whether the request should stablish a keep-alive or not. Default `false` */
     reset?: boolean;

package/node_modules/undici-types/errors.d.ts

@@ -154,6 +154,16 @@ declare namespace Errors {
     code: 'UND_ERR_PRX_TLS'
   }
 
+  export class ProxyConnectionError extends UndiciError {
+    constructor (
+      cause?: Error,
+      message?: string,
+      options?: Record<any, any>
+    )
+    name: 'ProxyConnectionError'
+    code: 'UND_ERR_PRX_CONN'
+  }
+
   export class MaxOriginsReachedError extends UndiciError {
     name: 'MaxOriginsReachedError'
     code: 'UND_ERR_MAX_ORIGINS_REACHED'

package/node_modules/undici-types/fetch.d.ts

@@ -36,7 +36,10 @@ export class BodyMixin {
   readonly bytes: () => Promise<Uint8Array>
   /**
    * @deprecated This method is not recommended for parsing multipart/form-data bodies in server environments.
-   * It is recommended to use a library such as [@fastify/busboy](https://www.npmjs.com/package/@fastify/busboy) as follows:
+   * Calling body.formData() buffers and parses the entire body. Since this is dictated by the spec,
+   * this method must only be called on responses from trusted servers.
+   * For responses from untrusted or user-controlled servers, use a dedicated streaming parser such as
+   * [@fastify/busboy](https://www.npmjs.com/package/@fastify/busboy) and apply application-specific limits as follows:
    *
    * @example
    * ```js
@@ -54,6 +57,7 @@ export class BodyMixin {
   readonly formData: () => Promise<FormData>
   readonly json: () => Promise<unknown>
   readonly text: () => Promise<string>
+  readonly textStream: () => ReadableStream<string>
 }
 
 export interface SpecIterator<T, TReturn = any, TNext = undefined> {

package/node_modules/undici-types/handlers.d.ts

@@ -1,6 +1,8 @@
 import Dispatcher from './dispatcher'
 
 export declare class RedirectHandler implements Dispatcher.DispatchHandler {
+  static buildDispatch (dispatcher: Dispatcher, maxRedirections: number): Dispatcher.Dispatch
+
   constructor (
     dispatch: Dispatcher.Dispatch,
     maxRedirections: number,

package/node_modules/undici-types/interceptors.d.ts

@@ -8,7 +8,7 @@ export default Interceptors
 declare namespace Interceptors {
   export type DumpInterceptorOpts = { maxSize?: number }
   export type RetryInterceptorOpts = RetryHandler.RetryOptions
-  export type RedirectInterceptorOpts = { maxRedirections?: number, throwOnMaxRedirect?: boolean }
+  export type RedirectInterceptorOpts = { maxRedirections?: number, throwOnMaxRedirect?: boolean, stripHeadersOnRedirect?: string[], stripHeadersOnCrossOriginRedirect?: string[] }
   export type DecompressInterceptorOpts = {
     skipErrorResponses?: boolean
     skipStatusCodes?: number[]

package/node_modules/undici-types/mock-interceptor.d.ts

@@ -75,9 +75,13 @@ declare namespace MockInterceptor {
     opts: MockResponseCallbackOptions
   ) => TData | Buffer | string
 
+  export type MockReplyOptions<TData extends object = object> = {
+    statusCode: number, data?: TData | Buffer | string, responseOptions?: MockResponseOptions
+  }
+
   export type MockReplyOptionsCallback<TData extends object = object> = (
     opts: MockResponseCallbackOptions
-  ) => { statusCode: number, data?: TData | Buffer | string, responseOptions?: MockResponseOptions }
+  ) => MockReplyOptions<TData> | Promise<MockReplyOptions<TData>>
 }
 
 interface Interceptable extends Dispatcher {

package/node_modules/undici-types/package.json

@@ -1,6 +1,6 @@
 {
   "name": "undici-types",
-  "version": "8.3.0",
+  "version": "8.9.0",
   "description": "A stand-alone types package for Undici",
   "homepage": "https://undici.nodejs.org",
   "bugs": {

package/node_modules/undici-types/proxy-agent.d.ts

@@ -24,6 +24,13 @@ declare namespace ProxyAgent {
     requestTls?: buildConnector.BuildOptions;
     proxyTls?: buildConnector.BuildOptions;
     clientFactory?(origin: URL, opts: object): Dispatcher;
+    /**
+     * Undici tunnels via CONNECT when the target endpoint uses HTTPS, and
+     * forwards (HTTP/1.1 absolute-form request-target, per RFC 9112 §3.2.2)
+     * otherwise, regardless of whether the proxy URL is HTTP or HTTPS. The
+     * non-tunneled forwarding path does not negotiate HTTP/2 with the proxy.
+     * Set to true to force tunneling for plain HTTP requests as well.
+     */
     proxyTunnel?: boolean;
   }
 }