@tonyclaw/agent-inspector 3.0.15 → 3.0.17

package/.output/server/_libs/has-flag.mjs

@@ -0,0 +1,16 @@
+var hasFlag;
+var hasRequiredHasFlag;
+function requireHasFlag() {
+  if (hasRequiredHasFlag) return hasFlag;
+  hasRequiredHasFlag = 1;
+  hasFlag = (flag, argv = process.argv) => {
+    const prefix = flag.startsWith("-") ? "" : flag.length === 1 ? "-" : "--";
+    const position = argv.indexOf(prefix + flag);
+    const terminatorPosition = argv.indexOf("--");
+    return position !== -1 && (terminatorPosition === -1 || position < terminatorPosition);
+  };
+  return hasFlag;
+}
+export {
+  requireHasFlag as r
+};

package/.output/server/_libs/https-proxy-agent.mjs

@@ -0,0 +1,280 @@
+import require$$2 from "assert";
+import require$$0 from "net";
+import require$$4 from "tls";
+import { r as requireSrc } from "./debug.mjs";
+import { r as requireDist$1 } from "./agent-base.mjs";
+import require$$7 from "url";
+function _mergeNamespaces(n, m) {
+  for (var i = 0; i < m.length; i++) {
+    const e = m[i];
+    if (typeof e !== "string" && !Array.isArray(e)) {
+      for (const k in e) {
+        if (k !== "default" && !(k in n)) {
+          const d = Object.getOwnPropertyDescriptor(e, k);
+          if (d) {
+            Object.defineProperty(n, k, d.get ? d : {
+              enumerable: true,
+              get: function() {
+                return e[k];
+              }
+            });
+          }
+        }
+      }
+    }
+  }
+  return Object.freeze(n);
+}
+var dist = {};
+var parseProxyResponse = {};
+var hasRequiredParseProxyResponse;
+function requireParseProxyResponse() {
+  if (hasRequiredParseProxyResponse) return parseProxyResponse;
+  hasRequiredParseProxyResponse = 1;
+  var __importDefault = parseProxyResponse && parseProxyResponse.__importDefault || function(mod) {
+    return mod && mod.__esModule ? mod : { "default": mod };
+  };
+  Object.defineProperty(parseProxyResponse, "__esModule", { value: true });
+  parseProxyResponse.parseProxyResponse = void 0;
+  const debug_1 = __importDefault(requireSrc());
+  const debug = (0, debug_1.default)("https-proxy-agent:parse-proxy-response");
+  function parseProxyResponse$1(socket) {
+    return new Promise((resolve, reject) => {
+      let buffersLength = 0;
+      const buffers = [];
+      function read() {
+        const b = socket.read();
+        if (b)
+          ondata(b);
+        else
+          socket.once("readable", read);
+      }
+      function cleanup() {
+        socket.removeListener("end", onend);
+        socket.removeListener("error", onerror);
+        socket.removeListener("readable", read);
+      }
+      function onend() {
+        cleanup();
+        debug("onend");
+        reject(new Error("Proxy connection ended before receiving CONNECT response"));
+      }
+      function onerror(err) {
+        cleanup();
+        debug("onerror %o", err);
+        reject(err);
+      }
+      function ondata(b) {
+        buffers.push(b);
+        buffersLength += b.length;
+        const buffered = Buffer.concat(buffers, buffersLength);
+        const endOfHeaders = buffered.indexOf("\r\n\r\n");
+        if (endOfHeaders === -1) {
+          debug("have not received end of HTTP headers yet...");
+          read();
+          return;
+        }
+        const headerParts = buffered.slice(0, endOfHeaders).toString("ascii").split("\r\n");
+        const firstLine = headerParts.shift();
+        if (!firstLine) {
+          socket.destroy();
+          return reject(new Error("No header received from proxy CONNECT response"));
+        }
+        const firstLineParts = firstLine.split(" ");
+        const statusCode = +firstLineParts[1];
+        const statusText = firstLineParts.slice(2).join(" ");
+        const headers = {};
+        for (const header of headerParts) {
+          if (!header)
+            continue;
+          const firstColon = header.indexOf(":");
+          if (firstColon === -1) {
+            socket.destroy();
+            return reject(new Error(`Invalid header from proxy CONNECT response: "${header}"`));
+          }
+          const key = header.slice(0, firstColon).toLowerCase();
+          const value = header.slice(firstColon + 1).trimStart();
+          const current = headers[key];
+          if (typeof current === "string") {
+            headers[key] = [current, value];
+          } else if (Array.isArray(current)) {
+            current.push(value);
+          } else {
+            headers[key] = value;
+          }
+        }
+        debug("got proxy server response: %o %o", firstLine, headers);
+        cleanup();
+        resolve({
+          connect: {
+            statusCode,
+            statusText,
+            headers
+          },
+          buffered
+        });
+      }
+      socket.on("error", onerror);
+      socket.on("end", onend);
+      read();
+    });
+  }
+  parseProxyResponse.parseProxyResponse = parseProxyResponse$1;
+  return parseProxyResponse;
+}
+var hasRequiredDist;
+function requireDist() {
+  if (hasRequiredDist) return dist;
+  hasRequiredDist = 1;
+  var __createBinding = dist && dist.__createBinding || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === void 0) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() {
+        return m[k];
+      } };
+    }
+    Object.defineProperty(o, k2, desc);
+  }) : (function(o, m, k, k2) {
+    if (k2 === void 0) k2 = k;
+    o[k2] = m[k];
+  }));
+  var __setModuleDefault = dist && dist.__setModuleDefault || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+  }) : function(o, v) {
+    o["default"] = v;
+  });
+  var __importStar = dist && dist.__importStar || function(mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) {
+      for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    }
+    __setModuleDefault(result, mod);
+    return result;
+  };
+  var __importDefault = dist && dist.__importDefault || function(mod) {
+    return mod && mod.__esModule ? mod : { "default": mod };
+  };
+  Object.defineProperty(dist, "__esModule", { value: true });
+  dist.HttpsProxyAgent = void 0;
+  const net = __importStar(require$$0);
+  const tls = __importStar(require$$4);
+  const assert_1 = __importDefault(require$$2);
+  const debug_1 = __importDefault(requireSrc());
+  const agent_base_1 = requireDist$1();
+  const url_1 = require$$7;
+  const parse_proxy_response_1 = requireParseProxyResponse();
+  const debug = (0, debug_1.default)("https-proxy-agent");
+  const setServernameFromNonIpHost = (options) => {
+    if (options.servername === void 0 && options.host && !net.isIP(options.host)) {
+      return {
+        ...options,
+        servername: options.host
+      };
+    }
+    return options;
+  };
+  class HttpsProxyAgent extends agent_base_1.Agent {
+    constructor(proxy, opts) {
+      super(opts);
+      this.options = { path: void 0 };
+      this.proxy = typeof proxy === "string" ? new url_1.URL(proxy) : proxy;
+      this.proxyHeaders = opts?.headers ?? {};
+      debug("Creating new HttpsProxyAgent instance: %o", this.proxy.href);
+      const host = (this.proxy.hostname || this.proxy.host).replace(/^\[|\]$/g, "");
+      const port = this.proxy.port ? parseInt(this.proxy.port, 10) : this.proxy.protocol === "https:" ? 443 : 80;
+      this.connectOpts = {
+        // Attempt to negotiate http/1.1 for proxy servers that support http/2
+        ALPNProtocols: ["http/1.1"],
+        ...opts ? omit(opts, "headers") : null,
+        host,
+        port
+      };
+    }
+    /**
+     * Called when the node-core HTTP client library is creating a
+     * new HTTP request.
+     */
+    async connect(req, opts) {
+      const { proxy } = this;
+      if (!opts.host) {
+        throw new TypeError('No "host" provided');
+      }
+      let socket;
+      if (proxy.protocol === "https:") {
+        debug("Creating `tls.Socket`: %o", this.connectOpts);
+        socket = tls.connect(setServernameFromNonIpHost(this.connectOpts));
+      } else {
+        debug("Creating `net.Socket`: %o", this.connectOpts);
+        socket = net.connect(this.connectOpts);
+      }
+      const headers = typeof this.proxyHeaders === "function" ? this.proxyHeaders() : { ...this.proxyHeaders };
+      const host = net.isIPv6(opts.host) ? `[${opts.host}]` : opts.host;
+      let payload = `CONNECT ${host}:${opts.port} HTTP/1.1\r
+`;
+      if (proxy.username || proxy.password) {
+        const auth = `${decodeURIComponent(proxy.username)}:${decodeURIComponent(proxy.password)}`;
+        headers["Proxy-Authorization"] = `Basic ${Buffer.from(auth).toString("base64")}`;
+      }
+      headers.Host = `${host}:${opts.port}`;
+      if (!headers["Proxy-Connection"]) {
+        headers["Proxy-Connection"] = this.keepAlive ? "Keep-Alive" : "close";
+      }
+      for (const name of Object.keys(headers)) {
+        payload += `${name}: ${headers[name]}\r
+`;
+      }
+      const proxyResponsePromise = (0, parse_proxy_response_1.parseProxyResponse)(socket);
+      socket.write(`${payload}\r
+`);
+      const { connect, buffered } = await proxyResponsePromise;
+      req.emit("proxyConnect", connect);
+      this.emit("proxyConnect", connect, req);
+      if (connect.statusCode === 200) {
+        req.once("socket", resume);
+        if (opts.secureEndpoint) {
+          debug("Upgrading socket connection to TLS");
+          return tls.connect({
+            ...omit(setServernameFromNonIpHost(opts), "host", "path", "port"),
+            socket
+          });
+        }
+        return socket;
+      }
+      socket.destroy();
+      const fakeSocket = new net.Socket({ writable: false });
+      fakeSocket.readable = true;
+      req.once("socket", (s) => {
+        debug("Replaying proxy buffer for failed request");
+        (0, assert_1.default)(s.listenerCount("data") > 0);
+        s.push(buffered);
+        s.push(null);
+      });
+      return fakeSocket;
+    }
+  }
+  HttpsProxyAgent.protocols = ["http", "https"];
+  dist.HttpsProxyAgent = HttpsProxyAgent;
+  function resume(socket) {
+    socket.resume();
+  }
+  function omit(obj, ...keys) {
+    const ret = {};
+    let key;
+    for (key in obj) {
+      if (!keys.includes(key)) {
+        ret[key] = obj[key];
+      }
+    }
+    return ret;
+  }
+  return dist;
+}
+var distExports = requireDist();
+const index = /* @__PURE__ */ _mergeNamespaces({
+  __proto__: null
+}, [distExports]);
+export {
+  index as i
+};

package/.output/server/_libs/json-bigint.mjs

@@ -0,0 +1,413 @@
+import { r as requireBignumber } from "./bignumber.js.mjs";
+var jsonBigint = { exports: {} };
+var stringify = { exports: {} };
+var hasRequiredStringify;
+function requireStringify() {
+  if (hasRequiredStringify) return stringify.exports;
+  hasRequiredStringify = 1;
+  (function(module) {
+    var BigNumber = requireBignumber();
+    var JSON = module.exports;
+    (function() {
+      var escapable = /[\\\"\x00-\x1f\x7f-\x9f\u00ad\u0600-\u0604\u070f\u17b4\u17b5\u200c-\u200f\u2028-\u202f\u2060-\u206f\ufeff\ufff0-\uffff]/g, gap, indent, meta = {
+        // table of character substitutions
+        "\b": "\\b",
+        "	": "\\t",
+        "\n": "\\n",
+        "\f": "\\f",
+        "\r": "\\r",
+        '"': '\\"',
+        "\\": "\\\\"
+      }, rep;
+      function quote(string) {
+        escapable.lastIndex = 0;
+        return escapable.test(string) ? '"' + string.replace(escapable, function(a) {
+          var c = meta[a];
+          return typeof c === "string" ? c : "\\u" + ("0000" + a.charCodeAt(0).toString(16)).slice(-4);
+        }) + '"' : '"' + string + '"';
+      }
+      function str(key, holder) {
+        var i, k, v, length, mind = gap, partial, value = holder[key], isBigNumber = value != null && (value instanceof BigNumber || BigNumber.isBigNumber(value));
+        if (value && typeof value === "object" && typeof value.toJSON === "function") {
+          value = value.toJSON(key);
+        }
+        if (typeof rep === "function") {
+          value = rep.call(holder, key, value);
+        }
+        switch (typeof value) {
+          case "string":
+            if (isBigNumber) {
+              return value;
+            } else {
+              return quote(value);
+            }
+          case "number":
+            return isFinite(value) ? String(value) : "null";
+          case "boolean":
+          case "null":
+          case "bigint":
+            return String(value);
+          // If the type is 'object', we might be dealing with an object or an array or
+          // null.
+          case "object":
+            if (!value) {
+              return "null";
+            }
+            gap += indent;
+            partial = [];
+            if (Object.prototype.toString.apply(value) === "[object Array]") {
+              length = value.length;
+              for (i = 0; i < length; i += 1) {
+                partial[i] = str(i, value) || "null";
+              }
+              v = partial.length === 0 ? "[]" : gap ? "[\n" + gap + partial.join(",\n" + gap) + "\n" + mind + "]" : "[" + partial.join(",") + "]";
+              gap = mind;
+              return v;
+            }
+            if (rep && typeof rep === "object") {
+              length = rep.length;
+              for (i = 0; i < length; i += 1) {
+                if (typeof rep[i] === "string") {
+                  k = rep[i];
+                  v = str(k, value);
+                  if (v) {
+                    partial.push(quote(k) + (gap ? ": " : ":") + v);
+                  }
+                }
+              }
+            } else {
+              Object.keys(value).forEach(function(k2) {
+                var v2 = str(k2, value);
+                if (v2) {
+                  partial.push(quote(k2) + (gap ? ": " : ":") + v2);
+                }
+              });
+            }
+            v = partial.length === 0 ? "{}" : gap ? "{\n" + gap + partial.join(",\n" + gap) + "\n" + mind + "}" : "{" + partial.join(",") + "}";
+            gap = mind;
+            return v;
+        }
+      }
+      if (typeof JSON.stringify !== "function") {
+        JSON.stringify = function(value, replacer, space) {
+          var i;
+          gap = "";
+          indent = "";
+          if (typeof space === "number") {
+            for (i = 0; i < space; i += 1) {
+              indent += " ";
+            }
+          } else if (typeof space === "string") {
+            indent = space;
+          }
+          rep = replacer;
+          if (replacer && typeof replacer !== "function" && (typeof replacer !== "object" || typeof replacer.length !== "number")) {
+            throw new Error("JSON.stringify");
+          }
+          return str("", { "": value });
+        };
+      }
+    })();
+  })(stringify);
+  return stringify.exports;
+}
+var parse;
+var hasRequiredParse;
+function requireParse() {
+  if (hasRequiredParse) return parse;
+  hasRequiredParse = 1;
+  var BigNumber = null;
+  const suspectProtoRx = /(?:_|\\u005[Ff])(?:_|\\u005[Ff])(?:p|\\u0070)(?:r|\\u0072)(?:o|\\u006[Ff])(?:t|\\u0074)(?:o|\\u006[Ff])(?:_|\\u005[Ff])(?:_|\\u005[Ff])/;
+  const suspectConstructorRx = /(?:c|\\u0063)(?:o|\\u006[Ff])(?:n|\\u006[Ee])(?:s|\\u0073)(?:t|\\u0074)(?:r|\\u0072)(?:u|\\u0075)(?:c|\\u0063)(?:t|\\u0074)(?:o|\\u006[Ff])(?:r|\\u0072)/;
+  var json_parse = function(options) {
+    var _options = {
+      strict: false,
+      // not being strict means do not generate syntax errors for "duplicate key"
+      storeAsString: false,
+      // toggles whether the values should be stored as BigNumber (default) or a string
+      alwaysParseAsBig: false,
+      // toggles whether all numbers should be Big
+      useNativeBigInt: false,
+      // toggles whether to use native BigInt instead of bignumber.js
+      protoAction: "error",
+      constructorAction: "error"
+    };
+    if (options !== void 0 && options !== null) {
+      if (options.strict === true) {
+        _options.strict = true;
+      }
+      if (options.storeAsString === true) {
+        _options.storeAsString = true;
+      }
+      _options.alwaysParseAsBig = options.alwaysParseAsBig === true ? options.alwaysParseAsBig : false;
+      _options.useNativeBigInt = options.useNativeBigInt === true ? options.useNativeBigInt : false;
+      if (typeof options.constructorAction !== "undefined") {
+        if (options.constructorAction === "error" || options.constructorAction === "ignore" || options.constructorAction === "preserve") {
+          _options.constructorAction = options.constructorAction;
+        } else {
+          throw new Error(
+            `Incorrect value for constructorAction option, must be "error", "ignore" or undefined but passed ${options.constructorAction}`
+          );
+        }
+      }
+      if (typeof options.protoAction !== "undefined") {
+        if (options.protoAction === "error" || options.protoAction === "ignore" || options.protoAction === "preserve") {
+          _options.protoAction = options.protoAction;
+        } else {
+          throw new Error(
+            `Incorrect value for protoAction option, must be "error", "ignore" or undefined but passed ${options.protoAction}`
+          );
+        }
+      }
+    }
+    var at, ch, escapee = {
+      '"': '"',
+      "\\": "\\",
+      "/": "/",
+      b: "\b",
+      f: "\f",
+      n: "\n",
+      r: "\r",
+      t: "	"
+    }, text, error = function(m) {
+      throw {
+        name: "SyntaxError",
+        message: m,
+        at,
+        text
+      };
+    }, next = function(c) {
+      if (c && c !== ch) {
+        error("Expected '" + c + "' instead of '" + ch + "'");
+      }
+      ch = text.charAt(at);
+      at += 1;
+      return ch;
+    }, number = function() {
+      var number2, string2 = "";
+      if (ch === "-") {
+        string2 = "-";
+        next("-");
+      }
+      while (ch >= "0" && ch <= "9") {
+        string2 += ch;
+        next();
+      }
+      if (ch === ".") {
+        string2 += ".";
+        while (next() && ch >= "0" && ch <= "9") {
+          string2 += ch;
+        }
+      }
+      if (ch === "e" || ch === "E") {
+        string2 += ch;
+        next();
+        if (ch === "-" || ch === "+") {
+          string2 += ch;
+          next();
+        }
+        while (ch >= "0" && ch <= "9") {
+          string2 += ch;
+          next();
+        }
+      }
+      number2 = +string2;
+      if (!isFinite(number2)) {
+        error("Bad number");
+      } else {
+        if (BigNumber == null) BigNumber = requireBignumber();
+        if (string2.length > 15)
+          return _options.storeAsString ? string2 : _options.useNativeBigInt ? BigInt(string2) : new BigNumber(string2);
+        else
+          return !_options.alwaysParseAsBig ? number2 : _options.useNativeBigInt ? BigInt(number2) : new BigNumber(number2);
+      }
+    }, string = function() {
+      var hex, i, string2 = "", uffff;
+      if (ch === '"') {
+        var startAt = at;
+        while (next()) {
+          if (ch === '"') {
+            if (at - 1 > startAt) string2 += text.substring(startAt, at - 1);
+            next();
+            return string2;
+          }
+          if (ch === "\\") {
+            if (at - 1 > startAt) string2 += text.substring(startAt, at - 1);
+            next();
+            if (ch === "u") {
+              uffff = 0;
+              for (i = 0; i < 4; i += 1) {
+                hex = parseInt(next(), 16);
+                if (!isFinite(hex)) {
+                  break;
+                }
+                uffff = uffff * 16 + hex;
+              }
+              string2 += String.fromCharCode(uffff);
+            } else if (typeof escapee[ch] === "string") {
+              string2 += escapee[ch];
+            } else {
+              break;
+            }
+            startAt = at;
+          }
+        }
+      }
+      error("Bad string");
+    }, white = function() {
+      while (ch && ch <= " ") {
+        next();
+      }
+    }, word = function() {
+      switch (ch) {
+        case "t":
+          next("t");
+          next("r");
+          next("u");
+          next("e");
+          return true;
+        case "f":
+          next("f");
+          next("a");
+          next("l");
+          next("s");
+          next("e");
+          return false;
+        case "n":
+          next("n");
+          next("u");
+          next("l");
+          next("l");
+          return null;
+      }
+      error("Unexpected '" + ch + "'");
+    }, value, array = function() {
+      var array2 = [];
+      if (ch === "[") {
+        next("[");
+        white();
+        if (ch === "]") {
+          next("]");
+          return array2;
+        }
+        while (ch) {
+          array2.push(value());
+          white();
+          if (ch === "]") {
+            next("]");
+            return array2;
+          }
+          next(",");
+          white();
+        }
+      }
+      error("Bad array");
+    }, object = function() {
+      var key, object2 = /* @__PURE__ */ Object.create(null);
+      if (ch === "{") {
+        next("{");
+        white();
+        if (ch === "}") {
+          next("}");
+          return object2;
+        }
+        while (ch) {
+          key = string();
+          white();
+          next(":");
+          if (_options.strict === true && Object.hasOwnProperty.call(object2, key)) {
+            error('Duplicate key "' + key + '"');
+          }
+          if (suspectProtoRx.test(key) === true) {
+            if (_options.protoAction === "error") {
+              error("Object contains forbidden prototype property");
+            } else if (_options.protoAction === "ignore") {
+              value();
+            } else {
+              object2[key] = value();
+            }
+          } else if (suspectConstructorRx.test(key) === true) {
+            if (_options.constructorAction === "error") {
+              error("Object contains forbidden constructor property");
+            } else if (_options.constructorAction === "ignore") {
+              value();
+            } else {
+              object2[key] = value();
+            }
+          } else {
+            object2[key] = value();
+          }
+          white();
+          if (ch === "}") {
+            next("}");
+            return object2;
+          }
+          next(",");
+          white();
+        }
+      }
+      error("Bad object");
+    };
+    value = function() {
+      white();
+      switch (ch) {
+        case "{":
+          return object();
+        case "[":
+          return array();
+        case '"':
+          return string();
+        case "-":
+          return number();
+        default:
+          return ch >= "0" && ch <= "9" ? number() : word();
+      }
+    };
+    return function(source, reviver) {
+      var result;
+      text = source + "";
+      at = 0;
+      ch = " ";
+      result = value();
+      white();
+      if (ch) {
+        error("Syntax error");
+      }
+      return typeof reviver === "function" ? (function walk(holder, key) {
+        var v, value2 = holder[key];
+        if (value2 && typeof value2 === "object") {
+          Object.keys(value2).forEach(function(k) {
+            v = walk(value2, k);
+            if (v !== void 0) {
+              value2[k] = v;
+            } else {
+              delete value2[k];
+            }
+          });
+        }
+        return reviver.call(holder, key, value2);
+      })({ "": result }, "") : result;
+    };
+  };
+  parse = json_parse;
+  return parse;
+}
+var hasRequiredJsonBigint;
+function requireJsonBigint() {
+  if (hasRequiredJsonBigint) return jsonBigint.exports;
+  hasRequiredJsonBigint = 1;
+  var json_stringify = requireStringify().stringify;
+  var json_parse = requireParse();
+  jsonBigint.exports = function(options) {
+    return {
+      parse: json_parse(options),
+      stringify: json_stringify
+    };
+  };
+  jsonBigint.exports.parse = json_parse();
+  jsonBigint.exports.stringify = json_stringify;
+  return jsonBigint.exports;
+}
+export {
+  requireJsonBigint as r
+};