npm - @gbozee/ultimate - Versions diffs - 0.0.2-37 → 0.0.2-40 - Mend

@gbozee/ultimate 0.0.2-37 → 0.0.2-40

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (3) hide show

package/dist/index.js CHANGED Viewed

@@ -18,426 +18,1633 @@ var __toESM = (mod, isNodeMode, target) => {
 var __commonJS = (cb, mod) => () => (mod || cb((mod = { exports: {} }).exports, mod), mod.exports);
 var __require = /* @__PURE__ */ createRequire(import.meta.url);
-// node_modules/smart-buffer/build/utils.js
-var require_utils = __commonJS((exports) => {
-  Object.defineProperty(exports, "__esModule", { value: true });
-  var buffer_1 = __require("buffer");
-  var ERRORS = {
-    INVALID_ENCODING: "Invalid encoding provided. Please specify a valid encoding the internal Node.js Buffer supports.",
-    INVALID_SMARTBUFFER_SIZE: "Invalid size provided. Size must be a valid integer greater than zero.",
-    INVALID_SMARTBUFFER_BUFFER: "Invalid Buffer provided in SmartBufferOptions.",
-    INVALID_SMARTBUFFER_OBJECT: "Invalid SmartBufferOptions object supplied to SmartBuffer constructor or factory methods.",
-    INVALID_OFFSET: "An invalid offset value was provided.",
-    INVALID_OFFSET_NON_NUMBER: "An invalid offset value was provided. A numeric value is required.",
-    INVALID_LENGTH: "An invalid length value was provided.",
-    INVALID_LENGTH_NON_NUMBER: "An invalid length value was provived. A numeric value is required.",
-    INVALID_TARGET_OFFSET: "Target offset is beyond the bounds of the internal SmartBuffer data.",
-    INVALID_TARGET_LENGTH: "Specified length value moves cursor beyong the bounds of the internal SmartBuffer data.",
-    INVALID_READ_BEYOND_BOUNDS: "Attempted to read beyond the bounds of the managed data.",
-    INVALID_WRITE_BEYOND_BOUNDS: "Attempted to write beyond the bounds of the managed data."
+// node_modules/ms/index.js
+var require_ms = __commonJS((exports, module) => {
+  var s = 1000;
+  var m = s * 60;
+  var h = m * 60;
+  var d = h * 24;
+  var w = d * 7;
+  var y = d * 365.25;
+  module.exports = function(val, options) {
+    options = options || {};
+    var type = typeof val;
+    if (type === "string" && val.length > 0) {
+      return parse(val);
+    } else if (type === "number" && isFinite(val)) {
+      return options.long ? fmtLong(val) : fmtShort(val);
+    }
+    throw new Error("val is not a non-empty string or a valid number. val=" + JSON.stringify(val));
   };
-  exports.ERRORS = ERRORS;
-  function checkEncoding(encoding) {
-    if (!buffer_1.Buffer.isEncoding(encoding)) {
-      throw new Error(ERRORS.INVALID_ENCODING);
+  function parse(str) {
+    str = String(str);
+    if (str.length > 100) {
+      return;
     }
-  }
-  exports.checkEncoding = checkEncoding;
-  function isFiniteInteger(value) {
-    return typeof value === "number" && isFinite(value) && isInteger(value);
-  }
-  exports.isFiniteInteger = isFiniteInteger;
-  function checkOffsetOrLengthValue(value, offset) {
-    if (typeof value === "number") {
-      if (!isFiniteInteger(value) || value < 0) {
-        throw new Error(offset ? ERRORS.INVALID_OFFSET : ERRORS.INVALID_LENGTH);
-      }
-    } else {
-      throw new Error(offset ? ERRORS.INVALID_OFFSET_NON_NUMBER : ERRORS.INVALID_LENGTH_NON_NUMBER);
+    var match = /^(-?(?:\d+)?\.?\d+) *(milliseconds?|msecs?|ms|seconds?|secs?|s|minutes?|mins?|m|hours?|hrs?|h|days?|d|weeks?|w|years?|yrs?|y)?$/i.exec(str);
+    if (!match) {
+      return;
     }
-  }
-  function checkLengthValue(length) {
-    checkOffsetOrLengthValue(length, false);
-  }
-  exports.checkLengthValue = checkLengthValue;
-  function checkOffsetValue(offset) {
-    checkOffsetOrLengthValue(offset, true);
-  }
-  exports.checkOffsetValue = checkOffsetValue;
-  function checkTargetOffset(offset, buff) {
-    if (offset < 0 || offset > buff.length) {
-      throw new Error(ERRORS.INVALID_TARGET_OFFSET);
+    var n = parseFloat(match[1]);
+    var type = (match[2] || "ms").toLowerCase();
+    switch (type) {
+      case "years":
+      case "year":
+      case "yrs":
+      case "yr":
+      case "y":
+        return n * y;
+      case "weeks":
+      case "week":
+      case "w":
+        return n * w;
+      case "days":
+      case "day":
+      case "d":
+        return n * d;
+      case "hours":
+      case "hour":
+      case "hrs":
+      case "hr":
+      case "h":
+        return n * h;
+      case "minutes":
+      case "minute":
+      case "mins":
+      case "min":
+      case "m":
+        return n * m;
+      case "seconds":
+      case "second":
+      case "secs":
+      case "sec":
+      case "s":
+        return n * s;
+      case "milliseconds":
+      case "millisecond":
+      case "msecs":
+      case "msec":
+      case "ms":
+        return n;
+      default:
+        return;
     }
   }
-  exports.checkTargetOffset = checkTargetOffset;
-  function isInteger(value) {
-    return typeof value === "number" && isFinite(value) && Math.floor(value) === value;
+  function fmtShort(ms) {
+    var msAbs = Math.abs(ms);
+    if (msAbs >= d) {
+      return Math.round(ms / d) + "d";
+    }
+    if (msAbs >= h) {
+      return Math.round(ms / h) + "h";
+    }
+    if (msAbs >= m) {
+      return Math.round(ms / m) + "m";
+    }
+    if (msAbs >= s) {
+      return Math.round(ms / s) + "s";
+    }
+    return ms + "ms";
   }
-  function bigIntAndBufferInt64Check(bufferMethod) {
-    if (typeof BigInt === "undefined") {
-      throw new Error("Platform does not support JS BigInt type.");
+  function fmtLong(ms) {
+    var msAbs = Math.abs(ms);
+    if (msAbs >= d) {
+      return plural(ms, msAbs, d, "day");
     }
-    if (typeof buffer_1.Buffer.prototype[bufferMethod] === "undefined") {
-      throw new Error(`Platform does not support Buffer.prototype.${bufferMethod}.`);
+    if (msAbs >= h) {
+      return plural(ms, msAbs, h, "hour");
+    }
+    if (msAbs >= m) {
+      return plural(ms, msAbs, m, "minute");
+    }
+    if (msAbs >= s) {
+      return plural(ms, msAbs, s, "second");
     }
+    return ms + " ms";
+  }
+  function plural(ms, msAbs, n, name) {
+    var isPlural = msAbs >= n * 1.5;
+    return Math.round(ms / n) + " " + name + (isPlural ? "s" : "");
   }
-  exports.bigIntAndBufferInt64Check = bigIntAndBufferInt64Check;
 });
-// node_modules/smart-buffer/build/smartbuffer.js
-var require_smartbuffer = __commonJS((exports) => {
-  Object.defineProperty(exports, "__esModule", { value: true });
-  var utils_1 = require_utils();
-  var DEFAULT_SMARTBUFFER_SIZE = 4096;
-  var DEFAULT_SMARTBUFFER_ENCODING = "utf8";
-  class SmartBuffer {
-    constructor(options) {
-      this.length = 0;
-      this._encoding = DEFAULT_SMARTBUFFER_ENCODING;
-      this._writeOffset = 0;
-      this._readOffset = 0;
-      if (SmartBuffer.isSmartBufferOptions(options)) {
-        if (options.encoding) {
-          utils_1.checkEncoding(options.encoding);
-          this._encoding = options.encoding;
+// node_modules/debug/src/common.js
+var require_common = __commonJS((exports, module) => {
+  function setup(env) {
+    createDebug.debug = createDebug;
+    createDebug.default = createDebug;
+    createDebug.coerce = coerce;
+    createDebug.disable = disable;
+    createDebug.enable = enable;
+    createDebug.enabled = enabled;
+    createDebug.humanize = require_ms();
+    createDebug.destroy = destroy;
+    Object.keys(env).forEach((key) => {
+      createDebug[key] = env[key];
+    });
+    createDebug.names = [];
+    createDebug.skips = [];
+    createDebug.formatters = {};
+    function selectColor(namespace) {
+      let hash = 0;
+      for (let i = 0;i < namespace.length; i++) {
+        hash = (hash << 5) - hash + namespace.charCodeAt(i);
+        hash |= 0;
+      }
+      return createDebug.colors[Math.abs(hash) % createDebug.colors.length];
+    }
+    createDebug.selectColor = selectColor;
+    function createDebug(namespace) {
+      let prevTime;
+      let enableOverride = null;
+      let namespacesCache;
+      let enabledCache;
+      function debug(...args) {
+        if (!debug.enabled) {
+          return;
         }
-        if (options.size) {
-          if (utils_1.isFiniteInteger(options.size) && options.size > 0) {
-            this._buff = Buffer.allocUnsafe(options.size);
-          } else {
-            throw new Error(utils_1.ERRORS.INVALID_SMARTBUFFER_SIZE);
+        const self2 = debug;
+        const curr = Number(new Date);
+        const ms = curr - (prevTime || curr);
+        self2.diff = ms;
+        self2.prev = prevTime;
+        self2.curr = curr;
+        prevTime = curr;
+        args[0] = createDebug.coerce(args[0]);
+        if (typeof args[0] !== "string") {
+          args.unshift("%O");
+        }
+        let index = 0;
+        args[0] = args[0].replace(/%([a-zA-Z%])/g, (match, format) => {
+          if (match === "%%") {
+            return "%";
           }
-        } else if (options.buff) {
-          if (Buffer.isBuffer(options.buff)) {
-            this._buff = options.buff;
-            this.length = options.buff.length;
-          } else {
-            throw new Error(utils_1.ERRORS.INVALID_SMARTBUFFER_BUFFER);
+          index++;
+          const formatter = createDebug.formatters[format];
+          if (typeof formatter === "function") {
+            const val = args[index];
+            match = formatter.call(self2, val);
+            args.splice(index, 1);
+            index--;
           }
-        } else {
-          this._buff = Buffer.allocUnsafe(DEFAULT_SMARTBUFFER_SIZE);
-        }
-      } else {
-        if (typeof options !== "undefined") {
-          throw new Error(utils_1.ERRORS.INVALID_SMARTBUFFER_OBJECT);
-        }
-        this._buff = Buffer.allocUnsafe(DEFAULT_SMARTBUFFER_SIZE);
+          return match;
+        });
+        createDebug.formatArgs.call(self2, args);
+        const logFn = self2.log || createDebug.log;
+        logFn.apply(self2, args);
       }
-    }
-    static fromSize(size, encoding) {
-      return new this({
-        size,
-        encoding
+      debug.namespace = namespace;
+      debug.useColors = createDebug.useColors();
+      debug.color = createDebug.selectColor(namespace);
+      debug.extend = extend;
+      debug.destroy = createDebug.destroy;
+      Object.defineProperty(debug, "enabled", {
+        enumerable: true,
+        configurable: false,
+        get: () => {
+          if (enableOverride !== null) {
+            return enableOverride;
+          }
+          if (namespacesCache !== createDebug.namespaces) {
+            namespacesCache = createDebug.namespaces;
+            enabledCache = createDebug.enabled(namespace);
+          }
+          return enabledCache;
+        },
+        set: (v) => {
+          enableOverride = v;
+        }
       });
+      if (typeof createDebug.init === "function") {
+        createDebug.init(debug);
+      }
+      return debug;
     }
-    static fromBuffer(buff, encoding) {
-      return new this({
-        buff,
-        encoding
-      });
+    function extend(namespace, delimiter) {
+      const newDebug = createDebug(this.namespace + (typeof delimiter === "undefined" ? ":" : delimiter) + namespace);
+      newDebug.log = this.log;
+      return newDebug;
     }
-    static fromOptions(options) {
-      return new this(options);
+    function enable(namespaces) {
+      createDebug.save(namespaces);
+      createDebug.namespaces = namespaces;
+      createDebug.names = [];
+      createDebug.skips = [];
+      const split = (typeof namespaces === "string" ? namespaces : "").trim().replace(" ", ",").split(",").filter(Boolean);
+      for (const ns of split) {
+        if (ns[0] === "-") {
+          createDebug.skips.push(ns.slice(1));
+        } else {
+          createDebug.names.push(ns);
+        }
+      }
     }
-    static isSmartBufferOptions(options) {
-      const castOptions = options;
-      return castOptions && (castOptions.encoding !== undefined || castOptions.size !== undefined || castOptions.buff !== undefined);
+    function matchesTemplate(search, template) {
+      let searchIndex = 0;
+      let templateIndex = 0;
+      let starIndex = -1;
+      let matchIndex = 0;
+      while (searchIndex < search.length) {
+        if (templateIndex < template.length && (template[templateIndex] === search[searchIndex] || template[templateIndex] === "*")) {
+          if (template[templateIndex] === "*") {
+            starIndex = templateIndex;
+            matchIndex = searchIndex;
+            templateIndex++;
+          } else {
+            searchIndex++;
+            templateIndex++;
+          }
+        } else if (starIndex !== -1) {
+          templateIndex = starIndex + 1;
+          matchIndex++;
+          searchIndex = matchIndex;
+        } else {
+          return false;
+        }
+      }
+      while (templateIndex < template.length && template[templateIndex] === "*") {
+        templateIndex++;
+      }
+      return templateIndex === template.length;
     }
-    readInt8(offset) {
-      return this._readNumberValue(Buffer.prototype.readInt8, 1, offset);
+    function disable() {
+      const namespaces = [
+        ...createDebug.names,
+        ...createDebug.skips.map((namespace) => "-" + namespace)
+      ].join(",");
+      createDebug.enable("");
+      return namespaces;
     }
-    readInt16BE(offset) {
-      return this._readNumberValue(Buffer.prototype.readInt16BE, 2, offset);
+    function enabled(name) {
+      for (const skip of createDebug.skips) {
+        if (matchesTemplate(name, skip)) {
+          return false;
+        }
+      }
+      for (const ns of createDebug.names) {
+        if (matchesTemplate(name, ns)) {
+          return true;
+        }
+      }
+      return false;
     }
-    readInt16LE(offset) {
-      return this._readNumberValue(Buffer.prototype.readInt16LE, 2, offset);
+    function coerce(val) {
+      if (val instanceof Error) {
+        return val.stack || val.message;
+      }
+      return val;
     }
-    readInt32BE(offset) {
-      return this._readNumberValue(Buffer.prototype.readInt32BE, 4, offset);
+    function destroy() {
+      console.warn("Instance method `debug.destroy()` is deprecated and no longer does anything. It will be removed in the next major version of `debug`.");
     }
-    readInt32LE(offset) {
-      return this._readNumberValue(Buffer.prototype.readInt32LE, 4, offset);
+    createDebug.enable(createDebug.load());
+    return createDebug;
+  }
+  module.exports = setup;
+});
+// node_modules/debug/src/browser.js
+var require_browser = __commonJS((exports, module) => {
+  exports.formatArgs = formatArgs;
+  exports.save = save;
+  exports.load = load;
+  exports.useColors = useColors;
+  exports.storage = localstorage();
+  exports.destroy = (() => {
+    let warned = false;
+    return () => {
+      if (!warned) {
+        warned = true;
+        console.warn("Instance method `debug.destroy()` is deprecated and no longer does anything. It will be removed in the next major version of `debug`.");
+      }
+    };
+  })();
+  exports.colors = [
+    "#0000CC",
+    "#0000FF",
+    "#0033CC",
+    "#0033FF",
+    "#0066CC",
+    "#0066FF",
+    "#0099CC",
+    "#0099FF",
+    "#00CC00",
+    "#00CC33",
+    "#00CC66",
+    "#00CC99",
+    "#00CCCC",
+    "#00CCFF",
+    "#3300CC",
+    "#3300FF",
+    "#3333CC",
+    "#3333FF",
+    "#3366CC",
+    "#3366FF",
+    "#3399CC",
+    "#3399FF",
+    "#33CC00",
+    "#33CC33",
+    "#33CC66",
+    "#33CC99",
+    "#33CCCC",
+    "#33CCFF",
+    "#6600CC",
+    "#6600FF",
+    "#6633CC",
+    "#6633FF",
+    "#66CC00",
+    "#66CC33",
+    "#9900CC",
+    "#9900FF",
+    "#9933CC",
+    "#9933FF",
+    "#99CC00",
+    "#99CC33",
+    "#CC0000",
+    "#CC0033",
+    "#CC0066",
+    "#CC0099",
+    "#CC00CC",
+    "#CC00FF",
+    "#CC3300",
+    "#CC3333",
+    "#CC3366",
+    "#CC3399",
+    "#CC33CC",
+    "#CC33FF",
+    "#CC6600",
+    "#CC6633",
+    "#CC9900",
+    "#CC9933",
+    "#CCCC00",
+    "#CCCC33",
+    "#FF0000",
+    "#FF0033",
+    "#FF0066",
+    "#FF0099",
+    "#FF00CC",
+    "#FF00FF",
+    "#FF3300",
+    "#FF3333",
+    "#FF3366",
+    "#FF3399",
+    "#FF33CC",
+    "#FF33FF",
+    "#FF6600",
+    "#FF6633",
+    "#FF9900",
+    "#FF9933",
+    "#FFCC00",
+    "#FFCC33"
+  ];
+  function useColors() {
+    if (typeof window !== "undefined" && window.process && (window.process.type === "renderer" || window.process.__nwjs)) {
+      return true;
     }
-    readBigInt64BE(offset) {
-      utils_1.bigIntAndBufferInt64Check("readBigInt64BE");
-      return this._readNumberValue(Buffer.prototype.readBigInt64BE, 8, offset);
+    if (typeof navigator !== "undefined" && navigator.userAgent && navigator.userAgent.toLowerCase().match(/(edge|trident)\/(\d+)/)) {
+      return false;
     }
-    readBigInt64LE(offset) {
-      utils_1.bigIntAndBufferInt64Check("readBigInt64LE");
-      return this._readNumberValue(Buffer.prototype.readBigInt64LE, 8, offset);
+    let m;
+    return typeof document !== "undefined" && document.documentElement && document.documentElement.style && document.documentElement.style.WebkitAppearance || typeof window !== "undefined" && window.console && (window.console.firebug || window.console.exception && window.console.table) || typeof navigator !== "undefined" && navigator.userAgent && (m = navigator.userAgent.toLowerCase().match(/firefox\/(\d+)/)) && parseInt(m[1], 10) >= 31 || typeof navigator !== "undefined" && navigator.userAgent && navigator.userAgent.toLowerCase().match(/applewebkit\/(\d+)/);
+  }
+  function formatArgs(args) {
+    args[0] = (this.useColors ? "%c" : "") + this.namespace + (this.useColors ? " %c" : " ") + args[0] + (this.useColors ? "%c " : " ") + "+" + module.exports.humanize(this.diff);
+    if (!this.useColors) {
+      return;
     }
-    writeInt8(value, offset) {
-      this._writeNumberValue(Buffer.prototype.writeInt8, 1, value, offset);
-      return this;
+    const c = "color: " + this.color;
+    args.splice(1, 0, c, "color: inherit");
+    let index = 0;
+    let lastC = 0;
+    args[0].replace(/%[a-zA-Z%]/g, (match) => {
+      if (match === "%%") {
+        return;
+      }
+      index++;
+      if (match === "%c") {
+        lastC = index;
+      }
+    });
+    args.splice(lastC, 0, c);
+  }
+  exports.log = console.debug || console.log || (() => {
+  });
+  function save(namespaces) {
+    try {
+      if (namespaces) {
+        exports.storage.setItem("debug", namespaces);
+      } else {
+        exports.storage.removeItem("debug");
+      }
+    } catch (error) {
     }
-    insertInt8(value, offset) {
-      return this._insertNumberValue(Buffer.prototype.writeInt8, 1, value, offset);
+  }
+  function load() {
+    let r;
+    try {
+      r = exports.storage.getItem("debug");
+    } catch (error) {
     }
-    writeInt16BE(value, offset) {
-      return this._writeNumberValue(Buffer.prototype.writeInt16BE, 2, value, offset);
+    if (!r && typeof process !== "undefined" && "env" in process) {
+      r = process.env.DEBUG;
     }
-    insertInt16BE(value, offset) {
-      return this._insertNumberValue(Buffer.prototype.writeInt16BE, 2, value, offset);
+    return r;
+  }
+  function localstorage() {
+    try {
+      return localStorage;
+    } catch (error) {
     }
-    writeInt16LE(value, offset) {
-      return this._writeNumberValue(Buffer.prototype.writeInt16LE, 2, value, offset);
-    }
-    insertInt16LE(value, offset) {
-      return this._insertNumberValue(Buffer.prototype.writeInt16LE, 2, value, offset);
-    }
-    writeInt32BE(value, offset) {
-      return this._writeNumberValue(Buffer.prototype.writeInt32BE, 4, value, offset);
+  }
+  module.exports = require_common()(exports);
+  var { formatters } = module.exports;
+  formatters.j = function(v) {
+    try {
+      return JSON.stringify(v);
+    } catch (error) {
+      return "[UnexpectedJSONParseError]: " + error.message;
     }
-    insertInt32BE(value, offset) {
-      return this._insertNumberValue(Buffer.prototype.writeInt32BE, 4, value, offset);
+  };
+});
+// node_modules/has-flag/index.js
+var require_has_flag = __commonJS((exports, module) => {
+  module.exports = (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);
+  };
+});
+// node_modules/supports-color/index.js
+var require_supports_color = __commonJS((exports, module) => {
+  var os = __require("os");
+  var tty = __require("tty");
+  var hasFlag = require_has_flag();
+  var { env } = process;
+  var forceColor;
+  if (hasFlag("no-color") || hasFlag("no-colors") || hasFlag("color=false") || hasFlag("color=never")) {
+    forceColor = 0;
+  } else if (hasFlag("color") || hasFlag("colors") || hasFlag("color=true") || hasFlag("color=always")) {
+    forceColor = 1;
+  }
+  if ("FORCE_COLOR" in env) {
+    if (env.FORCE_COLOR === "true") {
+      forceColor = 1;
+    } else if (env.FORCE_COLOR === "false") {
+      forceColor = 0;
+    } else {
+      forceColor = env.FORCE_COLOR.length === 0 ? 1 : Math.min(parseInt(env.FORCE_COLOR, 10), 3);
     }
-    writeInt32LE(value, offset) {
-      return this._writeNumberValue(Buffer.prototype.writeInt32LE, 4, value, offset);
+  }
+  function translateLevel(level) {
+    if (level === 0) {
+      return false;
     }
-    insertInt32LE(value, offset) {
-      return this._insertNumberValue(Buffer.prototype.writeInt32LE, 4, value, offset);
+    return {
+      level,
+      hasBasic: true,
+      has256: level >= 2,
+      has16m: level >= 3
+    };
+  }
+  function supportsColor(haveStream, streamIsTTY) {
+    if (forceColor === 0) {
+      return 0;
     }
-    writeBigInt64BE(value, offset) {
-      utils_1.bigIntAndBufferInt64Check("writeBigInt64BE");
-      return this._writeNumberValue(Buffer.prototype.writeBigInt64BE, 8, value, offset);
+    if (hasFlag("color=16m") || hasFlag("color=full") || hasFlag("color=truecolor")) {
+      return 3;
     }
-    insertBigInt64BE(value, offset) {
-      utils_1.bigIntAndBufferInt64Check("writeBigInt64BE");
-      return this._insertNumberValue(Buffer.prototype.writeBigInt64BE, 8, value, offset);
+    if (hasFlag("color=256")) {
+      return 2;
     }
-    writeBigInt64LE(value, offset) {
-      utils_1.bigIntAndBufferInt64Check("writeBigInt64LE");
-      return this._writeNumberValue(Buffer.prototype.writeBigInt64LE, 8, value, offset);
+    if (haveStream && !streamIsTTY && forceColor === undefined) {
+      return 0;
     }
-    insertBigInt64LE(value, offset) {
-      utils_1.bigIntAndBufferInt64Check("writeBigInt64LE");
-      return this._insertNumberValue(Buffer.prototype.writeBigInt64LE, 8, value, offset);
+    const min = forceColor || 0;
+    if (env.TERM === "dumb") {
+      return min;
     }
-    readUInt8(offset) {
-      return this._readNumberValue(Buffer.prototype.readUInt8, 1, offset);
+    if (process.platform === "win32") {
+      const osRelease = os.release().split(".");
+      if (Number(osRelease[0]) >= 10 && Number(osRelease[2]) >= 10586) {
+        return Number(osRelease[2]) >= 14931 ? 3 : 2;
+      }
+      return 1;
     }
-    readUInt16BE(offset) {
-      return this._readNumberValue(Buffer.prototype.readUInt16BE, 2, offset);
+    if ("CI" in env) {
+      if (["TRAVIS", "CIRCLECI", "APPVEYOR", "GITLAB_CI", "GITHUB_ACTIONS", "BUILDKITE"].some((sign) => (sign in env)) || env.CI_NAME === "codeship") {
+        return 1;
+      }
+      return min;
     }
-    readUInt16LE(offset) {
-      return this._readNumberValue(Buffer.prototype.readUInt16LE, 2, offset);
+    if ("TEAMCITY_VERSION" in env) {
+      return /^(9\.(0*[1-9]\d*)\.|\d{2,}\.)/.test(env.TEAMCITY_VERSION) ? 1 : 0;
     }
-    readUInt32BE(offset) {
-      return this._readNumberValue(Buffer.prototype.readUInt32BE, 4, offset);
+    if (env.COLORTERM === "truecolor") {
+      return 3;
     }
-    readUInt32LE(offset) {
-      return this._readNumberValue(Buffer.prototype.readUInt32LE, 4, offset);
+    if ("TERM_PROGRAM" in env) {
+      const version = parseInt((env.TERM_PROGRAM_VERSION || "").split(".")[0], 10);
+      switch (env.TERM_PROGRAM) {
+        case "iTerm.app":
+          return version >= 3 ? 3 : 2;
+        case "Apple_Terminal":
+          return 2;
+      }
     }
-    readBigUInt64BE(offset) {
-      utils_1.bigIntAndBufferInt64Check("readBigUInt64BE");
-      return this._readNumberValue(Buffer.prototype.readBigUInt64BE, 8, offset);
+    if (/-256(color)?$/i.test(env.TERM)) {
+      return 2;
     }
-    readBigUInt64LE(offset) {
-      utils_1.bigIntAndBufferInt64Check("readBigUInt64LE");
-      return this._readNumberValue(Buffer.prototype.readBigUInt64LE, 8, offset);
+    if (/^screen|^xterm|^vt100|^vt220|^rxvt|color|ansi|cygwin|linux/i.test(env.TERM)) {
+      return 1;
     }
-    writeUInt8(value, offset) {
-      return this._writeNumberValue(Buffer.prototype.writeUInt8, 1, value, offset);
+    if ("COLORTERM" in env) {
+      return 1;
     }
-    insertUInt8(value, offset) {
-      return this._insertNumberValue(Buffer.prototype.writeUInt8, 1, value, offset);
+    return min;
+  }
+  function getSupportLevel(stream) {
+    const level = supportsColor(stream, stream && stream.isTTY);
+    return translateLevel(level);
+  }
+  module.exports = {
+    supportsColor: getSupportLevel,
+    stdout: translateLevel(supportsColor(true, tty.isatty(1))),
+    stderr: translateLevel(supportsColor(true, tty.isatty(2)))
+  };
+});
+// node_modules/debug/src/node.js
+var require_node = __commonJS((exports, module) => {
+  var tty = __require("tty");
+  var util = __require("util");
+  exports.init = init;
+  exports.log = log;
+  exports.formatArgs = formatArgs;
+  exports.save = save;
+  exports.load = load;
+  exports.useColors = useColors;
+  exports.destroy = util.deprecate(() => {
+  }, "Instance method `debug.destroy()` is deprecated and no longer does anything. It will be removed in the next major version of `debug`.");
+  exports.colors = [6, 2, 3, 4, 5, 1];
+  try {
+    const supportsColor = require_supports_color();
+    if (supportsColor && (supportsColor.stderr || supportsColor).level >= 2) {
+      exports.colors = [
+        20,
+        21,
+        26,
+        27,
+        32,
+        33,
+        38,
+        39,
+        40,
+        41,
+        42,
+        43,
+        44,
+        45,
+        56,
+        57,
+        62,
+        63,
+        68,
+        69,
+        74,
+        75,
+        76,
+        77,
+        78,
+        79,
+        80,
+        81,
+        92,
+        93,
+        98,
+        99,
+        112,
+        113,
+        128,
+        129,
+        134,
+        135,
+        148,
+        149,
+        160,
+        161,
+        162,
+        163,
+        164,
+        165,
+        166,
+        167,
+        168,
+        169,
+        170,
+        171,
+        172,
+        173,
+        178,
+        179,
+        184,
+        185,
+        196,
+        197,
+        198,
+        199,
+        200,
+        201,
+        202,
+        203,
+        204,
+        205,
+        206,
+        207,
+        208,
+        209,
+        214,
+        215,
+        220,
+        221
+      ];
     }
-    writeUInt16BE(value, offset) {
-      return this._writeNumberValue(Buffer.prototype.writeUInt16BE, 2, value, offset);
+  } catch (error) {
+  }
+  exports.inspectOpts = Object.keys(process.env).filter((key) => {
+    return /^debug_/i.test(key);
+  }).reduce((obj, key) => {
+    const prop = key.substring(6).toLowerCase().replace(/_([a-z])/g, (_, k) => {
+      return k.toUpperCase();
+    });
+    let val = process.env[key];
+    if (/^(yes|on|true|enabled)$/i.test(val)) {
+      val = true;
+    } else if (/^(no|off|false|disabled)$/i.test(val)) {
+      val = false;
+    } else if (val === "null") {
+      val = null;
+    } else {
+      val = Number(val);
     }
-    insertUInt16BE(value, offset) {
-      return this._insertNumberValue(Buffer.prototype.writeUInt16BE, 2, value, offset);
+    obj[prop] = val;
+    return obj;
+  }, {});
+  function useColors() {
+    return "colors" in exports.inspectOpts ? Boolean(exports.inspectOpts.colors) : tty.isatty(process.stderr.fd);
+  }
+  function formatArgs(args) {
+    const { namespace: name, useColors: useColors2 } = this;
+    if (useColors2) {
+      const c = this.color;
+      const colorCode = "\x1B[3" + (c < 8 ? c : "8;5;" + c);
+      const prefix = `  ${colorCode};1m${name} \x1B[0m`;
+      args[0] = prefix + args[0].split(`
+`).join(`
+` + prefix);
+      args.push(colorCode + "m+" + module.exports.humanize(this.diff) + "\x1B[0m");
+    } else {
+      args[0] = getDate() + name + " " + args[0];
     }
-    writeUInt16LE(value, offset) {
-      return this._writeNumberValue(Buffer.prototype.writeUInt16LE, 2, value, offset);
+  }
+  function getDate() {
+    if (exports.inspectOpts.hideDate) {
+      return "";
     }
-    insertUInt16LE(value, offset) {
-      return this._insertNumberValue(Buffer.prototype.writeUInt16LE, 2, value, offset);
+    return new Date().toISOString() + " ";
+  }
+  function log(...args) {
+    return process.stderr.write(util.formatWithOptions(exports.inspectOpts, ...args) + `
+`);
+  }
+  function save(namespaces) {
+    if (namespaces) {
+      process.env.DEBUG = namespaces;
+    } else {
+      delete process.env.DEBUG;
     }
-    writeUInt32BE(value, offset) {
-      return this._writeNumberValue(Buffer.prototype.writeUInt32BE, 4, value, offset);
+  }
+  function load() {
+    return process.env.DEBUG;
+  }
+  function init(debug) {
+    debug.inspectOpts = {};
+    const keys = Object.keys(exports.inspectOpts);
+    for (let i = 0;i < keys.length; i++) {
+      debug.inspectOpts[keys[i]] = exports.inspectOpts[keys[i]];
     }
-    insertUInt32BE(value, offset) {
-      return this._insertNumberValue(Buffer.prototype.writeUInt32BE, 4, value, offset);
+  }
+  module.exports = require_common()(exports);
+  var { formatters } = module.exports;
+  formatters.o = function(v) {
+    this.inspectOpts.colors = this.useColors;
+    return util.inspect(v, this.inspectOpts).split(`
+`).map((str) => str.trim()).join(" ");
+  };
+  formatters.O = function(v) {
+    this.inspectOpts.colors = this.useColors;
+    return util.inspect(v, this.inspectOpts);
+  };
+});
+// node_modules/debug/src/index.js
+var require_src = __commonJS((exports, module) => {
+  if (typeof process === "undefined" || process.type === "renderer" || false || process.__nwjs) {
+    module.exports = require_browser();
+  } else {
+    module.exports = require_node();
+  }
+});
+// node_modules/agent-base/dist/helpers.js
+var require_helpers = __commonJS((exports) => {
+  var __createBinding = exports && exports.__createBinding || (Object.create ? function(o, m, k, k2) {
+    if (k2 === undefined)
+      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];
+      } };
     }
-    writeUInt32LE(value, offset) {
-      return this._writeNumberValue(Buffer.prototype.writeUInt32LE, 4, value, offset);
+    Object.defineProperty(o, k2, desc);
+  } : function(o, m, k, k2) {
+    if (k2 === undefined)
+      k2 = k;
+    o[k2] = m[k];
+  });
+  var __setModuleDefault = exports && exports.__setModuleDefault || (Object.create ? function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+  } : function(o, v) {
+    o["default"] = v;
+  });
+  var __importStar = exports && exports.__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);
     }
-    insertUInt32LE(value, offset) {
-      return this._insertNumberValue(Buffer.prototype.writeUInt32LE, 4, value, offset);
+    __setModuleDefault(result, mod);
+    return result;
+  };
+  Object.defineProperty(exports, "__esModule", { value: true });
+  exports.req = exports.json = exports.toBuffer = undefined;
+  var http = __importStar(__require("http"));
+  var https = __importStar(__require("https"));
+  async function toBuffer(stream) {
+    let length = 0;
+    const chunks = [];
+    for await (const chunk of stream) {
+      length += chunk.length;
+      chunks.push(chunk);
     }
-    writeBigUInt64BE(value, offset) {
-      utils_1.bigIntAndBufferInt64Check("writeBigUInt64BE");
-      return this._writeNumberValue(Buffer.prototype.writeBigUInt64BE, 8, value, offset);
+    return Buffer.concat(chunks, length);
+  }
+  exports.toBuffer = toBuffer;
+  async function json(stream) {
+    const buf = await toBuffer(stream);
+    const str = buf.toString("utf8");
+    try {
+      return JSON.parse(str);
+    } catch (_err) {
+      const err = _err;
+      err.message += ` (input: ${str})`;
+      throw err;
     }
-    insertBigUInt64BE(value, offset) {
-      utils_1.bigIntAndBufferInt64Check("writeBigUInt64BE");
-      return this._insertNumberValue(Buffer.prototype.writeBigUInt64BE, 8, value, offset);
+  }
+  exports.json = json;
+  function req(url, opts = {}) {
+    const href = typeof url === "string" ? url : url.href;
+    const req2 = (href.startsWith("https:") ? https : http).request(url, opts);
+    const promise = new Promise((resolve, reject) => {
+      req2.once("response", resolve).once("error", reject).end();
+    });
+    req2.then = promise.then.bind(promise);
+    return req2;
+  }
+  exports.req = req;
+});
+// node_modules/agent-base/dist/index.js
+var require_dist = __commonJS((exports) => {
+  var __createBinding = exports && exports.__createBinding || (Object.create ? function(o, m, k, k2) {
+    if (k2 === undefined)
+      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];
+      } };
     }
-    writeBigUInt64LE(value, offset) {
-      utils_1.bigIntAndBufferInt64Check("writeBigUInt64LE");
-      return this._writeNumberValue(Buffer.prototype.writeBigUInt64LE, 8, value, offset);
+    Object.defineProperty(o, k2, desc);
+  } : function(o, m, k, k2) {
+    if (k2 === undefined)
+      k2 = k;
+    o[k2] = m[k];
+  });
+  var __setModuleDefault = exports && exports.__setModuleDefault || (Object.create ? function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+  } : function(o, v) {
+    o["default"] = v;
+  });
+  var __importStar = exports && exports.__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);
     }
-    insertBigUInt64LE(value, offset) {
-      utils_1.bigIntAndBufferInt64Check("writeBigUInt64LE");
-      return this._insertNumberValue(Buffer.prototype.writeBigUInt64LE, 8, value, offset);
+    __setModuleDefault(result, mod);
+    return result;
+  };
+  var __exportStar = exports && exports.__exportStar || function(m, exports2) {
+    for (var p in m)
+      if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports2, p))
+        __createBinding(exports2, m, p);
+  };
+  Object.defineProperty(exports, "__esModule", { value: true });
+  exports.Agent = undefined;
+  var net = __importStar(__require("net"));
+  var http = __importStar(__require("http"));
+  var https_1 = __require("https");
+  __exportStar(require_helpers(), exports);
+  var INTERNAL = Symbol("AgentBaseInternalState");
+  class Agent extends http.Agent {
+    constructor(opts) {
+      super(opts);
+      this[INTERNAL] = {};
     }
-    readFloatBE(offset) {
-      return this._readNumberValue(Buffer.prototype.readFloatBE, 4, offset);
+    isSecureEndpoint(options) {
+      if (options) {
+        if (typeof options.secureEndpoint === "boolean") {
+          return options.secureEndpoint;
+        }
+        if (typeof options.protocol === "string") {
+          return options.protocol === "https:";
+        }
+      }
+      const { stack } = new Error;
+      if (typeof stack !== "string")
+        return false;
+      return stack.split(`
+`).some((l) => l.indexOf("(https.js:") !== -1 || l.indexOf("node:https:") !== -1);
     }
-    readFloatLE(offset) {
-      return this._readNumberValue(Buffer.prototype.readFloatLE, 4, offset);
+    incrementSockets(name) {
+      if (this.maxSockets === Infinity && this.maxTotalSockets === Infinity) {
+        return null;
+      }
+      if (!this.sockets[name]) {
+        this.sockets[name] = [];
+      }
+      const fakeSocket = new net.Socket({ writable: false });
+      this.sockets[name].push(fakeSocket);
+      this.totalSocketCount++;
+      return fakeSocket;
     }
-    writeFloatBE(value, offset) {
-      return this._writeNumberValue(Buffer.prototype.writeFloatBE, 4, value, offset);
+    decrementSockets(name, socket) {
+      if (!this.sockets[name] || socket === null) {
+        return;
+      }
+      const sockets = this.sockets[name];
+      const index = sockets.indexOf(socket);
+      if (index !== -1) {
+        sockets.splice(index, 1);
+        this.totalSocketCount--;
+        if (sockets.length === 0) {
+          delete this.sockets[name];
+        }
+      }
     }
-    insertFloatBE(value, offset) {
-      return this._insertNumberValue(Buffer.prototype.writeFloatBE, 4, value, offset);
-    }
-    writeFloatLE(value, offset) {
-      return this._writeNumberValue(Buffer.prototype.writeFloatLE, 4, value, offset);
-    }
-    insertFloatLE(value, offset) {
-      return this._insertNumberValue(Buffer.prototype.writeFloatLE, 4, value, offset);
+    getName(options) {
+      const secureEndpoint = typeof options.secureEndpoint === "boolean" ? options.secureEndpoint : this.isSecureEndpoint(options);
+      if (secureEndpoint) {
+        return https_1.Agent.prototype.getName.call(this, options);
+      }
+      return super.getName(options);
     }
-    readDoubleBE(offset) {
-      return this._readNumberValue(Buffer.prototype.readDoubleBE, 8, offset);
+    createSocket(req, options, cb) {
+      const connectOpts = {
+        ...options,
+        secureEndpoint: this.isSecureEndpoint(options)
+      };
+      const name = this.getName(connectOpts);
+      const fakeSocket = this.incrementSockets(name);
+      Promise.resolve().then(() => this.connect(req, connectOpts)).then((socket) => {
+        this.decrementSockets(name, fakeSocket);
+        if (socket instanceof http.Agent) {
+          try {
+            return socket.addRequest(req, connectOpts);
+          } catch (err) {
+            return cb(err);
+          }
+        }
+        this[INTERNAL].currentSocket = socket;
+        super.createSocket(req, options, cb);
+      }, (err) => {
+        this.decrementSockets(name, fakeSocket);
+        cb(err);
+      });
     }
-    readDoubleLE(offset) {
-      return this._readNumberValue(Buffer.prototype.readDoubleLE, 8, offset);
+    createConnection() {
+      const socket = this[INTERNAL].currentSocket;
+      this[INTERNAL].currentSocket = undefined;
+      if (!socket) {
+        throw new Error("No socket was returned in the `connect()` function");
+      }
+      return socket;
     }
-    writeDoubleBE(value, offset) {
-      return this._writeNumberValue(Buffer.prototype.writeDoubleBE, 8, value, offset);
+    get defaultPort() {
+      return this[INTERNAL].defaultPort ?? (this.protocol === "https:" ? 443 : 80);
     }
-    insertDoubleBE(value, offset) {
-      return this._insertNumberValue(Buffer.prototype.writeDoubleBE, 8, value, offset);
+    set defaultPort(v) {
+      if (this[INTERNAL]) {
+        this[INTERNAL].defaultPort = v;
+      }
     }
-    writeDoubleLE(value, offset) {
-      return this._writeNumberValue(Buffer.prototype.writeDoubleLE, 8, value, offset);
+    get protocol() {
+      return this[INTERNAL].protocol ?? (this.isSecureEndpoint() ? "https:" : "http:");
     }
-    insertDoubleLE(value, offset) {
-      return this._insertNumberValue(Buffer.prototype.writeDoubleLE, 8, value, offset);
+    set protocol(v) {
+      if (this[INTERNAL]) {
+        this[INTERNAL].protocol = v;
+      }
     }
-    readString(arg1, encoding) {
-      let lengthVal;
-      if (typeof arg1 === "number") {
-        utils_1.checkLengthValue(arg1);
-        lengthVal = Math.min(arg1, this.length - this._readOffset);
-      } else {
-        encoding = arg1;
-        lengthVal = this.length - this._readOffset;
+  }
+  exports.Agent = Agent;
+});
+// node_modules/https-proxy-agent/dist/parse-proxy-response.js
+var require_parse_proxy_response = __commonJS((exports) => {
+  var __importDefault = exports && exports.__importDefault || function(mod) {
+    return mod && mod.__esModule ? mod : { default: mod };
+  };
+  Object.defineProperty(exports, "__esModule", { value: true });
+  exports.parseProxyResponse = undefined;
+  var debug_1 = __importDefault(require_src());
+  var debug = (0, debug_1.default)("https-proxy-agent:parse-proxy-response");
+  function parseProxyResponse(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);
       }
-      if (typeof encoding !== "undefined") {
-        utils_1.checkEncoding(encoding);
+      function cleanup() {
+        socket.removeListener("end", onend);
+        socket.removeListener("error", onerror);
+        socket.removeListener("readable", read);
       }
-      const value = this._buff.slice(this._readOffset, this._readOffset + lengthVal).toString(encoding || this._encoding);
-      this._readOffset += lengthVal;
-      return value;
-    }
-    insertString(value, offset, encoding) {
-      utils_1.checkOffsetValue(offset);
-      return this._handleString(value, true, offset, encoding);
-    }
-    writeString(value, arg2, encoding) {
-      return this._handleString(value, false, arg2, encoding);
-    }
-    readStringNT(encoding) {
-      if (typeof encoding !== "undefined") {
-        utils_1.checkEncoding(encoding);
+      function onend() {
+        cleanup();
+        debug("onend");
+        reject(new Error("Proxy connection ended before receiving CONNECT response"));
       }
-      let nullPos = this.length;
-      for (let i2 = this._readOffset;i2 < this.length; i2++) {
-        if (this._buff[i2] === 0) {
-          nullPos = i2;
-          break;
+      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
+\r
+`);
+        if (endOfHeaders === -1) {
+          debug("have not received end of HTTP headers yet...");
+          read();
+          return;
+        }
+        const headerParts = buffered.slice(0, endOfHeaders).toString("ascii").split(`\r
+`);
+        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
+        });
       }
-      const value = this._buff.slice(this._readOffset, nullPos);
-      this._readOffset = nullPos + 1;
-      return value.toString(encoding || this._encoding);
+      socket.on("error", onerror);
+      socket.on("end", onend);
+      read();
+    });
+  }
+  exports.parseProxyResponse = parseProxyResponse;
+});
+// node_modules/https-proxy-agent/dist/index.js
+var require_dist2 = __commonJS((exports) => {
+  var __createBinding = exports && exports.__createBinding || (Object.create ? function(o, m, k, k2) {
+    if (k2 === undefined)
+      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];
+      } };
     }
-    insertStringNT(value, offset, encoding) {
-      utils_1.checkOffsetValue(offset);
-      this.insertString(value, offset, encoding);
-      this.insertUInt8(0, offset + value.length);
-      return this;
+    Object.defineProperty(o, k2, desc);
+  } : function(o, m, k, k2) {
+    if (k2 === undefined)
+      k2 = k;
+    o[k2] = m[k];
+  });
+  var __setModuleDefault = exports && exports.__setModuleDefault || (Object.create ? function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+  } : function(o, v) {
+    o["default"] = v;
+  });
+  var __importStar = exports && exports.__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);
     }
-    writeStringNT(value, arg2, encoding) {
-      this.writeString(value, arg2, encoding);
-      this.writeUInt8(0, typeof arg2 === "number" ? arg2 + value.length : this.writeOffset);
-      return this;
+    __setModuleDefault(result, mod);
+    return result;
+  };
+  var __importDefault = exports && exports.__importDefault || function(mod) {
+    return mod && mod.__esModule ? mod : { default: mod };
+  };
+  Object.defineProperty(exports, "__esModule", { value: true });
+  exports.HttpsProxyAgent = undefined;
+  var net = __importStar(__require("net"));
+  var tls = __importStar(__require("tls"));
+  var assert_1 = __importDefault(__require("assert"));
+  var debug_1 = __importDefault(require_src());
+  var agent_base_1 = require_dist();
+  var url_1 = __require("url");
+  var parse_proxy_response_1 = require_parse_proxy_response();
+  var debug = (0, debug_1.default)("https-proxy-agent");
+  var setServernameFromNonIpHost = (options) => {
+    if (options.servername === undefined && options.host && !net.isIP(options.host)) {
+      return {
+        ...options,
+        servername: options.host
+      };
     }
-    readBuffer(length) {
-      if (typeof length !== "undefined") {
-        utils_1.checkLengthValue(length);
+    return options;
+  };
+  class HttpsProxyAgent extends agent_base_1.Agent {
+    constructor(proxy, opts) {
+      super(opts);
+      this.options = { path: undefined };
+      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 = {
+        ALPNProtocols: ["http/1.1"],
+        ...opts ? omit(opts, "headers") : null,
+        host,
+        port
+      };
+    }
+    async connect(req, opts) {
+      const { proxy } = this;
+      if (!opts.host) {
+        throw new TypeError('No "host" provided');
       }
-      const lengthVal = typeof length === "number" ? length : this.length;
-      const endPoint = Math.min(this.length, this._readOffset + lengthVal);
-      const value = this._buff.slice(this._readOffset, endPoint);
-      this._readOffset = endPoint;
-      return value;
+      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;
     }
-    insertBuffer(value, offset) {
-      utils_1.checkOffsetValue(offset);
-      return this._handleBuffer(value, true, offset);
+  }
+  HttpsProxyAgent.protocols = ["http", "https"];
+  exports.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];
+      }
     }
-    writeBuffer(value, offset) {
-      return this._handleBuffer(value, false, offset);
+    return ret;
+  }
+});
+// node_modules/smart-buffer/build/utils.js
+var require_utils = __commonJS((exports) => {
+  Object.defineProperty(exports, "__esModule", { value: true });
+  var buffer_1 = __require("buffer");
+  var ERRORS = {
+    INVALID_ENCODING: "Invalid encoding provided. Please specify a valid encoding the internal Node.js Buffer supports.",
+    INVALID_SMARTBUFFER_SIZE: "Invalid size provided. Size must be a valid integer greater than zero.",
+    INVALID_SMARTBUFFER_BUFFER: "Invalid Buffer provided in SmartBufferOptions.",
+    INVALID_SMARTBUFFER_OBJECT: "Invalid SmartBufferOptions object supplied to SmartBuffer constructor or factory methods.",
+    INVALID_OFFSET: "An invalid offset value was provided.",
+    INVALID_OFFSET_NON_NUMBER: "An invalid offset value was provided. A numeric value is required.",
+    INVALID_LENGTH: "An invalid length value was provided.",
+    INVALID_LENGTH_NON_NUMBER: "An invalid length value was provived. A numeric value is required.",
+    INVALID_TARGET_OFFSET: "Target offset is beyond the bounds of the internal SmartBuffer data.",
+    INVALID_TARGET_LENGTH: "Specified length value moves cursor beyong the bounds of the internal SmartBuffer data.",
+    INVALID_READ_BEYOND_BOUNDS: "Attempted to read beyond the bounds of the managed data.",
+    INVALID_WRITE_BEYOND_BOUNDS: "Attempted to write beyond the bounds of the managed data."
+  };
+  exports.ERRORS = ERRORS;
+  function checkEncoding(encoding) {
+    if (!buffer_1.Buffer.isEncoding(encoding)) {
+      throw new Error(ERRORS.INVALID_ENCODING);
     }
-    readBufferNT() {
-      let nullPos = this.length;
-      for (let i2 = this._readOffset;i2 < this.length; i2++) {
-        if (this._buff[i2] === 0) {
-          nullPos = i2;
-          break;
-        }
+  }
+  exports.checkEncoding = checkEncoding;
+  function isFiniteInteger(value) {
+    return typeof value === "number" && isFinite(value) && isInteger(value);
+  }
+  exports.isFiniteInteger = isFiniteInteger;
+  function checkOffsetOrLengthValue(value, offset) {
+    if (typeof value === "number") {
+      if (!isFiniteInteger(value) || value < 0) {
+        throw new Error(offset ? ERRORS.INVALID_OFFSET : ERRORS.INVALID_LENGTH);
       }
-      const value = this._buff.slice(this._readOffset, nullPos);
-      this._readOffset = nullPos + 1;
-      return value;
+    } else {
+      throw new Error(offset ? ERRORS.INVALID_OFFSET_NON_NUMBER : ERRORS.INVALID_LENGTH_NON_NUMBER);
     }
-    insertBufferNT(value, offset) {
-      utils_1.checkOffsetValue(offset);
-      this.insertBuffer(value, offset);
-      this.insertUInt8(0, offset + value.length);
-      return this;
+  }
+  function checkLengthValue(length) {
+    checkOffsetOrLengthValue(length, false);
+  }
+  exports.checkLengthValue = checkLengthValue;
+  function checkOffsetValue(offset) {
+    checkOffsetOrLengthValue(offset, true);
+  }
+  exports.checkOffsetValue = checkOffsetValue;
+  function checkTargetOffset(offset, buff) {
+    if (offset < 0 || offset > buff.length) {
+      throw new Error(ERRORS.INVALID_TARGET_OFFSET);
     }
-    writeBufferNT(value, offset) {
-      if (typeof offset !== "undefined") {
-        utils_1.checkOffsetValue(offset);
-      }
-      this.writeBuffer(value, offset);
-      this.writeUInt8(0, typeof offset === "number" ? offset + value.length : this._writeOffset);
-      return this;
+  }
+  exports.checkTargetOffset = checkTargetOffset;
+  function isInteger(value) {
+    return typeof value === "number" && isFinite(value) && Math.floor(value) === value;
+  }
+  function bigIntAndBufferInt64Check(bufferMethod) {
+    if (typeof BigInt === "undefined") {
+      throw new Error("Platform does not support JS BigInt type.");
     }
-    clear() {
+    if (typeof buffer_1.Buffer.prototype[bufferMethod] === "undefined") {
+      throw new Error(`Platform does not support Buffer.prototype.${bufferMethod}.`);
+    }
+  }
+  exports.bigIntAndBufferInt64Check = bigIntAndBufferInt64Check;
+});
+// node_modules/smart-buffer/build/smartbuffer.js
+var require_smartbuffer = __commonJS((exports) => {
+  Object.defineProperty(exports, "__esModule", { value: true });
+  var utils_1 = require_utils();
+  var DEFAULT_SMARTBUFFER_SIZE = 4096;
+  var DEFAULT_SMARTBUFFER_ENCODING = "utf8";
+  class SmartBuffer {
+    constructor(options) {
+      this.length = 0;
+      this._encoding = DEFAULT_SMARTBUFFER_ENCODING;
       this._writeOffset = 0;
       this._readOffset = 0;
-      this.length = 0;
-      return this;
+      if (SmartBuffer.isSmartBufferOptions(options)) {
+        if (options.encoding) {
+          utils_1.checkEncoding(options.encoding);
+          this._encoding = options.encoding;
+        }
+        if (options.size) {
+          if (utils_1.isFiniteInteger(options.size) && options.size > 0) {
+            this._buff = Buffer.allocUnsafe(options.size);
+          } else {
+            throw new Error(utils_1.ERRORS.INVALID_SMARTBUFFER_SIZE);
+          }
+        } else if (options.buff) {
+          if (Buffer.isBuffer(options.buff)) {
+            this._buff = options.buff;
+            this.length = options.buff.length;
+          } else {
+            throw new Error(utils_1.ERRORS.INVALID_SMARTBUFFER_BUFFER);
+          }
+        } else {
+          this._buff = Buffer.allocUnsafe(DEFAULT_SMARTBUFFER_SIZE);
+        }
+      } else {
+        if (typeof options !== "undefined") {
+          throw new Error(utils_1.ERRORS.INVALID_SMARTBUFFER_OBJECT);
+        }
+        this._buff = Buffer.allocUnsafe(DEFAULT_SMARTBUFFER_SIZE);
+      }
     }
-    remaining() {
-      return this.length - this._readOffset;
+    static fromSize(size, encoding) {
+      return new this({
+        size,
+        encoding
+      });
     }
-    get readOffset() {
-      return this._readOffset;
+    static fromBuffer(buff, encoding) {
+      return new this({
+        buff,
+        encoding
+      });
     }
-    set readOffset(offset) {
-      utils_1.checkOffsetValue(offset);
-      utils_1.checkTargetOffset(offset, this);
-      this._readOffset = offset;
+    static fromOptions(options) {
+      return new this(options);
     }
-    get writeOffset() {
-      return this._writeOffset;
+    static isSmartBufferOptions(options) {
+      const castOptions = options;
+      return castOptions && (castOptions.encoding !== undefined || castOptions.size !== undefined || castOptions.buff !== undefined);
     }
-    set writeOffset(offset) {
-      utils_1.checkOffsetValue(offset);
-      utils_1.checkTargetOffset(offset, this);
-      this._writeOffset = offset;
+    readInt8(offset) {
+      return this._readNumberValue(Buffer.prototype.readInt8, 1, offset);
     }
-    get encoding() {
-      return this._encoding;
+    readInt16BE(offset) {
+      return this._readNumberValue(Buffer.prototype.readInt16BE, 2, offset);
+    }
+    readInt16LE(offset) {
+      return this._readNumberValue(Buffer.prototype.readInt16LE, 2, offset);
+    }
+    readInt32BE(offset) {
+      return this._readNumberValue(Buffer.prototype.readInt32BE, 4, offset);
+    }
+    readInt32LE(offset) {
+      return this._readNumberValue(Buffer.prototype.readInt32LE, 4, offset);
+    }
+    readBigInt64BE(offset) {
+      utils_1.bigIntAndBufferInt64Check("readBigInt64BE");
+      return this._readNumberValue(Buffer.prototype.readBigInt64BE, 8, offset);
+    }
+    readBigInt64LE(offset) {
+      utils_1.bigIntAndBufferInt64Check("readBigInt64LE");
+      return this._readNumberValue(Buffer.prototype.readBigInt64LE, 8, offset);
+    }
+    writeInt8(value, offset) {
+      this._writeNumberValue(Buffer.prototype.writeInt8, 1, value, offset);
+      return this;
+    }
+    insertInt8(value, offset) {
+      return this._insertNumberValue(Buffer.prototype.writeInt8, 1, value, offset);
+    }
+    writeInt16BE(value, offset) {
+      return this._writeNumberValue(Buffer.prototype.writeInt16BE, 2, value, offset);
+    }
+    insertInt16BE(value, offset) {
+      return this._insertNumberValue(Buffer.prototype.writeInt16BE, 2, value, offset);
+    }
+    writeInt16LE(value, offset) {
+      return this._writeNumberValue(Buffer.prototype.writeInt16LE, 2, value, offset);
+    }
+    insertInt16LE(value, offset) {
+      return this._insertNumberValue(Buffer.prototype.writeInt16LE, 2, value, offset);
+    }
+    writeInt32BE(value, offset) {
+      return this._writeNumberValue(Buffer.prototype.writeInt32BE, 4, value, offset);
+    }
+    insertInt32BE(value, offset) {
+      return this._insertNumberValue(Buffer.prototype.writeInt32BE, 4, value, offset);
+    }
+    writeInt32LE(value, offset) {
+      return this._writeNumberValue(Buffer.prototype.writeInt32LE, 4, value, offset);
+    }
+    insertInt32LE(value, offset) {
+      return this._insertNumberValue(Buffer.prototype.writeInt32LE, 4, value, offset);
+    }
+    writeBigInt64BE(value, offset) {
+      utils_1.bigIntAndBufferInt64Check("writeBigInt64BE");
+      return this._writeNumberValue(Buffer.prototype.writeBigInt64BE, 8, value, offset);
+    }
+    insertBigInt64BE(value, offset) {
+      utils_1.bigIntAndBufferInt64Check("writeBigInt64BE");
+      return this._insertNumberValue(Buffer.prototype.writeBigInt64BE, 8, value, offset);
+    }
+    writeBigInt64LE(value, offset) {
+      utils_1.bigIntAndBufferInt64Check("writeBigInt64LE");
+      return this._writeNumberValue(Buffer.prototype.writeBigInt64LE, 8, value, offset);
+    }
+    insertBigInt64LE(value, offset) {
+      utils_1.bigIntAndBufferInt64Check("writeBigInt64LE");
+      return this._insertNumberValue(Buffer.prototype.writeBigInt64LE, 8, value, offset);
+    }
+    readUInt8(offset) {
+      return this._readNumberValue(Buffer.prototype.readUInt8, 1, offset);
+    }
+    readUInt16BE(offset) {
+      return this._readNumberValue(Buffer.prototype.readUInt16BE, 2, offset);
+    }
+    readUInt16LE(offset) {
+      return this._readNumberValue(Buffer.prototype.readUInt16LE, 2, offset);
+    }
+    readUInt32BE(offset) {
+      return this._readNumberValue(Buffer.prototype.readUInt32BE, 4, offset);
+    }
+    readUInt32LE(offset) {
+      return this._readNumberValue(Buffer.prototype.readUInt32LE, 4, offset);
+    }
+    readBigUInt64BE(offset) {
+      utils_1.bigIntAndBufferInt64Check("readBigUInt64BE");
+      return this._readNumberValue(Buffer.prototype.readBigUInt64BE, 8, offset);
+    }
+    readBigUInt64LE(offset) {
+      utils_1.bigIntAndBufferInt64Check("readBigUInt64LE");
+      return this._readNumberValue(Buffer.prototype.readBigUInt64LE, 8, offset);
+    }
+    writeUInt8(value, offset) {
+      return this._writeNumberValue(Buffer.prototype.writeUInt8, 1, value, offset);
+    }
+    insertUInt8(value, offset) {
+      return this._insertNumberValue(Buffer.prototype.writeUInt8, 1, value, offset);
+    }
+    writeUInt16BE(value, offset) {
+      return this._writeNumberValue(Buffer.prototype.writeUInt16BE, 2, value, offset);
+    }
+    insertUInt16BE(value, offset) {
+      return this._insertNumberValue(Buffer.prototype.writeUInt16BE, 2, value, offset);
+    }
+    writeUInt16LE(value, offset) {
+      return this._writeNumberValue(Buffer.prototype.writeUInt16LE, 2, value, offset);
+    }
+    insertUInt16LE(value, offset) {
+      return this._insertNumberValue(Buffer.prototype.writeUInt16LE, 2, value, offset);
+    }
+    writeUInt32BE(value, offset) {
+      return this._writeNumberValue(Buffer.prototype.writeUInt32BE, 4, value, offset);
+    }
+    insertUInt32BE(value, offset) {
+      return this._insertNumberValue(Buffer.prototype.writeUInt32BE, 4, value, offset);
+    }
+    writeUInt32LE(value, offset) {
+      return this._writeNumberValue(Buffer.prototype.writeUInt32LE, 4, value, offset);
+    }
+    insertUInt32LE(value, offset) {
+      return this._insertNumberValue(Buffer.prototype.writeUInt32LE, 4, value, offset);
+    }
+    writeBigUInt64BE(value, offset) {
+      utils_1.bigIntAndBufferInt64Check("writeBigUInt64BE");
+      return this._writeNumberValue(Buffer.prototype.writeBigUInt64BE, 8, value, offset);
+    }
+    insertBigUInt64BE(value, offset) {
+      utils_1.bigIntAndBufferInt64Check("writeBigUInt64BE");
+      return this._insertNumberValue(Buffer.prototype.writeBigUInt64BE, 8, value, offset);
+    }
+    writeBigUInt64LE(value, offset) {
+      utils_1.bigIntAndBufferInt64Check("writeBigUInt64LE");
+      return this._writeNumberValue(Buffer.prototype.writeBigUInt64LE, 8, value, offset);
+    }
+    insertBigUInt64LE(value, offset) {
+      utils_1.bigIntAndBufferInt64Check("writeBigUInt64LE");
+      return this._insertNumberValue(Buffer.prototype.writeBigUInt64LE, 8, value, offset);
+    }
+    readFloatBE(offset) {
+      return this._readNumberValue(Buffer.prototype.readFloatBE, 4, offset);
+    }
+    readFloatLE(offset) {
+      return this._readNumberValue(Buffer.prototype.readFloatLE, 4, offset);
+    }
+    writeFloatBE(value, offset) {
+      return this._writeNumberValue(Buffer.prototype.writeFloatBE, 4, value, offset);
+    }
+    insertFloatBE(value, offset) {
+      return this._insertNumberValue(Buffer.prototype.writeFloatBE, 4, value, offset);
+    }
+    writeFloatLE(value, offset) {
+      return this._writeNumberValue(Buffer.prototype.writeFloatLE, 4, value, offset);
+    }
+    insertFloatLE(value, offset) {
+      return this._insertNumberValue(Buffer.prototype.writeFloatLE, 4, value, offset);
+    }
+    readDoubleBE(offset) {
+      return this._readNumberValue(Buffer.prototype.readDoubleBE, 8, offset);
+    }
+    readDoubleLE(offset) {
+      return this._readNumberValue(Buffer.prototype.readDoubleLE, 8, offset);
+    }
+    writeDoubleBE(value, offset) {
+      return this._writeNumberValue(Buffer.prototype.writeDoubleBE, 8, value, offset);
+    }
+    insertDoubleBE(value, offset) {
+      return this._insertNumberValue(Buffer.prototype.writeDoubleBE, 8, value, offset);
+    }
+    writeDoubleLE(value, offset) {
+      return this._writeNumberValue(Buffer.prototype.writeDoubleLE, 8, value, offset);
+    }
+    insertDoubleLE(value, offset) {
+      return this._insertNumberValue(Buffer.prototype.writeDoubleLE, 8, value, offset);
+    }
+    readString(arg1, encoding) {
+      let lengthVal;
+      if (typeof arg1 === "number") {
+        utils_1.checkLengthValue(arg1);
+        lengthVal = Math.min(arg1, this.length - this._readOffset);
+      } else {
+        encoding = arg1;
+        lengthVal = this.length - this._readOffset;
+      }
+      if (typeof encoding !== "undefined") {
+        utils_1.checkEncoding(encoding);
+      }
+      const value = this._buff.slice(this._readOffset, this._readOffset + lengthVal).toString(encoding || this._encoding);
+      this._readOffset += lengthVal;
+      return value;
+    }
+    insertString(value, offset, encoding) {
+      utils_1.checkOffsetValue(offset);
+      return this._handleString(value, true, offset, encoding);
+    }
+    writeString(value, arg2, encoding) {
+      return this._handleString(value, false, arg2, encoding);
+    }
+    readStringNT(encoding) {
+      if (typeof encoding !== "undefined") {
+        utils_1.checkEncoding(encoding);
+      }
+      let nullPos = this.length;
+      for (let i2 = this._readOffset;i2 < this.length; i2++) {
+        if (this._buff[i2] === 0) {
+          nullPos = i2;
+          break;
+        }
+      }
+      const value = this._buff.slice(this._readOffset, nullPos);
+      this._readOffset = nullPos + 1;
+      return value.toString(encoding || this._encoding);
+    }
+    insertStringNT(value, offset, encoding) {
+      utils_1.checkOffsetValue(offset);
+      this.insertString(value, offset, encoding);
+      this.insertUInt8(0, offset + value.length);
+      return this;
+    }
+    writeStringNT(value, arg2, encoding) {
+      this.writeString(value, arg2, encoding);
+      this.writeUInt8(0, typeof arg2 === "number" ? arg2 + value.length : this.writeOffset);
+      return this;
+    }
+    readBuffer(length) {
+      if (typeof length !== "undefined") {
+        utils_1.checkLengthValue(length);
+      }
+      const lengthVal = typeof length === "number" ? length : this.length;
+      const endPoint = Math.min(this.length, this._readOffset + lengthVal);
+      const value = this._buff.slice(this._readOffset, endPoint);
+      this._readOffset = endPoint;
+      return value;
+    }
+    insertBuffer(value, offset) {
+      utils_1.checkOffsetValue(offset);
+      return this._handleBuffer(value, true, offset);
+    }
+    writeBuffer(value, offset) {
+      return this._handleBuffer(value, false, offset);
+    }
+    readBufferNT() {
+      let nullPos = this.length;
+      for (let i2 = this._readOffset;i2 < this.length; i2++) {
+        if (this._buff[i2] === 0) {
+          nullPos = i2;
+          break;
+        }
+      }
+      const value = this._buff.slice(this._readOffset, nullPos);
+      this._readOffset = nullPos + 1;
+      return value;
+    }
+    insertBufferNT(value, offset) {
+      utils_1.checkOffsetValue(offset);
+      this.insertBuffer(value, offset);
+      this.insertUInt8(0, offset + value.length);
+      return this;
+    }
+    writeBufferNT(value, offset) {
+      if (typeof offset !== "undefined") {
+        utils_1.checkOffsetValue(offset);
+      }
+      this.writeBuffer(value, offset);
+      this.writeUInt8(0, typeof offset === "number" ? offset + value.length : this._writeOffset);
+      return this;
+    }
+    clear() {
+      this._writeOffset = 0;
+      this._readOffset = 0;
+      this.length = 0;
+      return this;
+    }
+    remaining() {
+      return this.length - this._readOffset;
+    }
+    get readOffset() {
+      return this._readOffset;
+    }
+    set readOffset(offset) {
+      utils_1.checkOffsetValue(offset);
+      utils_1.checkTargetOffset(offset, this);
+      this._readOffset = offset;
+    }
+    get writeOffset() {
+      return this._writeOffset;
+    }
+    set writeOffset(offset) {
+      utils_1.checkOffsetValue(offset);
+      utils_1.checkTargetOffset(offset, this);
+      this._writeOffset = offset;
+    }
+    get encoding() {
+      return this._encoding;
     }
     set encoding(encoding) {
       utils_1.checkEncoding(encoding);
@@ -714,7 +1921,7 @@ var require_util = __commonJS((exports) => {
 });
 // node_modules/ip-address/dist/common.js
-var require_common = __commonJS((exports) => {
+var require_common2 = __commonJS((exports) => {
   Object.defineProperty(exports, "__esModule", { value: true });
   exports.isCorrect = exports.isInSubnet = undefined;
   function isInSubnet(address) {
@@ -2426,7 +3633,7 @@ var require_ipv4 = __commonJS((exports) => {
   };
   Object.defineProperty(exports, "__esModule", { value: true });
   exports.Address4 = undefined;
-  var common = __importStar(require_common());
+  var common = __importStar(require_common2());
   var constants = __importStar(require_constants2());
   var address_error_1 = require_address_error();
   var jsbn_1 = require_jsbn();
@@ -2615,7 +3822,7 @@ var require_constants3 = __commonJS((exports) => {
 });
 // node_modules/ip-address/dist/v6/helpers.js
-var require_helpers = __commonJS((exports) => {
+var require_helpers2 = __commonJS((exports) => {
   Object.defineProperty(exports, "__esModule", { value: true });
   exports.simpleGroup = exports.spanLeadingZeroes = exports.spanAll = exports.spanAllZeroes = undefined;
   var sprintf_js_1 = require_sprintf();
@@ -2779,10 +3986,10 @@ var require_ipv6 = __commonJS((exports) => {
   };
   Object.defineProperty(exports, "__esModule", { value: true });
   exports.Address6 = undefined;
-  var common = __importStar(require_common());
+  var common = __importStar(require_common2());
   var constants4 = __importStar(require_constants2());
   var constants6 = __importStar(require_constants3());
-  var helpers = __importStar(require_helpers());
+  var helpers = __importStar(require_helpers2());
   var ipv4_1 = require_ipv4();
   var regular_expressions_1 = require_regular_expressions();
   var address_error_1 = require_address_error();
@@ -3391,12 +4598,12 @@ var require_ip_address = __commonJS((exports) => {
   Object.defineProperty(exports, "AddressError", { enumerable: true, get: function() {
     return address_error_1.AddressError;
   } });
-  var helpers = __importStar(require_helpers());
+  var helpers = __importStar(require_helpers2());
   exports.v6 = { helpers };
 });
 // node_modules/socks/build/common/helpers.js
-var require_helpers2 = __commonJS((exports) => {
+var require_helpers3 = __commonJS((exports) => {
   Object.defineProperty(exports, "__esModule", { value: true });
   exports.ipToBuffer = exports.int32ToIpv4 = exports.ipv4ToInt32 = exports.validateSocksClientChainOptions = exports.validateSocksClientOptions = undefined;
   var util_1 = require_util();
@@ -3580,7 +4787,7 @@ var require_socksclient = __commonJS((exports) => {
   var net = __require("net");
   var smart_buffer_1 = require_smartbuffer();
   var constants_1 = require_constants();
-  var helpers_1 = require_helpers2();
+  var helpers_1 = require_helpers3();
   var receivebuffer_1 = require_receivebuffer();
   var util_1 = require_util();
   Object.defineProperty(exports, "SocksClientError", { enumerable: true, get: function() {
@@ -4149,1254 +5356,7 @@ var require_build = __commonJS((exports) => {
   __exportStar(require_socksclient(), exports);
 });
-// node_modules/agent-base/dist/helpers.js
-var require_helpers3 = __commonJS((exports) => {
-  var __createBinding = exports && exports.__createBinding || (Object.create ? function(o, m, k, k2) {
-    if (k2 === undefined)
-      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 === undefined)
-      k2 = k;
-    o[k2] = m[k];
-  });
-  var __setModuleDefault = exports && exports.__setModuleDefault || (Object.create ? function(o, v) {
-    Object.defineProperty(o, "default", { enumerable: true, value: v });
-  } : function(o, v) {
-    o["default"] = v;
-  });
-  var __importStar = exports && exports.__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;
-  };
-  Object.defineProperty(exports, "__esModule", { value: true });
-  exports.req = exports.json = exports.toBuffer = undefined;
-  var http = __importStar(__require("http"));
-  var https = __importStar(__require("https"));
-  async function toBuffer(stream) {
-    let length = 0;
-    const chunks = [];
-    for await (const chunk of stream) {
-      length += chunk.length;
-      chunks.push(chunk);
-    }
-    return Buffer.concat(chunks, length);
-  }
-  exports.toBuffer = toBuffer;
-  async function json(stream) {
-    const buf = await toBuffer(stream);
-    const str = buf.toString("utf8");
-    try {
-      return JSON.parse(str);
-    } catch (_err) {
-      const err = _err;
-      err.message += ` (input: ${str})`;
-      throw err;
-    }
-  }
-  exports.json = json;
-  function req(url, opts = {}) {
-    const href = typeof url === "string" ? url : url.href;
-    const req2 = (href.startsWith("https:") ? https : http).request(url, opts);
-    const promise = new Promise((resolve, reject) => {
-      req2.once("response", resolve).once("error", reject).end();
-    });
-    req2.then = promise.then.bind(promise);
-    return req2;
-  }
-  exports.req = req;
-});
-// node_modules/agent-base/dist/index.js
-var require_dist = __commonJS((exports) => {
-  var __createBinding = exports && exports.__createBinding || (Object.create ? function(o, m, k, k2) {
-    if (k2 === undefined)
-      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 === undefined)
-      k2 = k;
-    o[k2] = m[k];
-  });
-  var __setModuleDefault = exports && exports.__setModuleDefault || (Object.create ? function(o, v) {
-    Object.defineProperty(o, "default", { enumerable: true, value: v });
-  } : function(o, v) {
-    o["default"] = v;
-  });
-  var __importStar = exports && exports.__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 __exportStar = exports && exports.__exportStar || function(m, exports2) {
-    for (var p in m)
-      if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports2, p))
-        __createBinding(exports2, m, p);
-  };
-  Object.defineProperty(exports, "__esModule", { value: true });
-  exports.Agent = undefined;
-  var net = __importStar(__require("net"));
-  var http = __importStar(__require("http"));
-  var https_1 = __require("https");
-  __exportStar(require_helpers3(), exports);
-  var INTERNAL = Symbol("AgentBaseInternalState");
-  class Agent extends http.Agent {
-    constructor(opts) {
-      super(opts);
-      this[INTERNAL] = {};
-    }
-    isSecureEndpoint(options) {
-      if (options) {
-        if (typeof options.secureEndpoint === "boolean") {
-          return options.secureEndpoint;
-        }
-        if (typeof options.protocol === "string") {
-          return options.protocol === "https:";
-        }
-      }
-      const { stack } = new Error;
-      if (typeof stack !== "string")
-        return false;
-      return stack.split(`
-`).some((l) => l.indexOf("(https.js:") !== -1 || l.indexOf("node:https:") !== -1);
-    }
-    incrementSockets(name) {
-      if (this.maxSockets === Infinity && this.maxTotalSockets === Infinity) {
-        return null;
-      }
-      if (!this.sockets[name]) {
-        this.sockets[name] = [];
-      }
-      const fakeSocket = new net.Socket({ writable: false });
-      this.sockets[name].push(fakeSocket);
-      this.totalSocketCount++;
-      return fakeSocket;
-    }
-    decrementSockets(name, socket) {
-      if (!this.sockets[name] || socket === null) {
-        return;
-      }
-      const sockets = this.sockets[name];
-      const index = sockets.indexOf(socket);
-      if (index !== -1) {
-        sockets.splice(index, 1);
-        this.totalSocketCount--;
-        if (sockets.length === 0) {
-          delete this.sockets[name];
-        }
-      }
-    }
-    getName(options) {
-      const secureEndpoint = typeof options.secureEndpoint === "boolean" ? options.secureEndpoint : this.isSecureEndpoint(options);
-      if (secureEndpoint) {
-        return https_1.Agent.prototype.getName.call(this, options);
-      }
-      return super.getName(options);
-    }
-    createSocket(req, options, cb) {
-      const connectOpts = {
-        ...options,
-        secureEndpoint: this.isSecureEndpoint(options)
-      };
-      const name = this.getName(connectOpts);
-      const fakeSocket = this.incrementSockets(name);
-      Promise.resolve().then(() => this.connect(req, connectOpts)).then((socket) => {
-        this.decrementSockets(name, fakeSocket);
-        if (socket instanceof http.Agent) {
-          try {
-            return socket.addRequest(req, connectOpts);
-          } catch (err) {
-            return cb(err);
-          }
-        }
-        this[INTERNAL].currentSocket = socket;
-        super.createSocket(req, options, cb);
-      }, (err) => {
-        this.decrementSockets(name, fakeSocket);
-        cb(err);
-      });
-    }
-    createConnection() {
-      const socket = this[INTERNAL].currentSocket;
-      this[INTERNAL].currentSocket = undefined;
-      if (!socket) {
-        throw new Error("No socket was returned in the `connect()` function");
-      }
-      return socket;
-    }
-    get defaultPort() {
-      return this[INTERNAL].defaultPort ?? (this.protocol === "https:" ? 443 : 80);
-    }
-    set defaultPort(v) {
-      if (this[INTERNAL]) {
-        this[INTERNAL].defaultPort = v;
-      }
-    }
-    get protocol() {
-      return this[INTERNAL].protocol ?? (this.isSecureEndpoint() ? "https:" : "http:");
-    }
-    set protocol(v) {
-      if (this[INTERNAL]) {
-        this[INTERNAL].protocol = v;
-      }
-    }
-  }
-  exports.Agent = Agent;
-});
-// node_modules/ms/index.js
-var require_ms = __commonJS((exports, module) => {
-  var s2 = 1000;
-  var m = s2 * 60;
-  var h = m * 60;
-  var d = h * 24;
-  var w = d * 7;
-  var y = d * 365.25;
-  module.exports = function(val, options) {
-    options = options || {};
-    var type = typeof val;
-    if (type === "string" && val.length > 0) {
-      return parse(val);
-    } else if (type === "number" && isFinite(val)) {
-      return options.long ? fmtLong(val) : fmtShort(val);
-    }
-    throw new Error("val is not a non-empty string or a valid number. val=" + JSON.stringify(val));
-  };
-  function parse(str) {
-    str = String(str);
-    if (str.length > 100) {
-      return;
-    }
-    var match = /^(-?(?:\d+)?\.?\d+) *(milliseconds?|msecs?|ms|seconds?|secs?|s|minutes?|mins?|m|hours?|hrs?|h|days?|d|weeks?|w|years?|yrs?|y)?$/i.exec(str);
-    if (!match) {
-      return;
-    }
-    var n2 = parseFloat(match[1]);
-    var type = (match[2] || "ms").toLowerCase();
-    switch (type) {
-      case "years":
-      case "year":
-      case "yrs":
-      case "yr":
-      case "y":
-        return n2 * y;
-      case "weeks":
-      case "week":
-      case "w":
-        return n2 * w;
-      case "days":
-      case "day":
-      case "d":
-        return n2 * d;
-      case "hours":
-      case "hour":
-      case "hrs":
-      case "hr":
-      case "h":
-        return n2 * h;
-      case "minutes":
-      case "minute":
-      case "mins":
-      case "min":
-      case "m":
-        return n2 * m;
-      case "seconds":
-      case "second":
-      case "secs":
-      case "sec":
-      case "s":
-        return n2 * s2;
-      case "milliseconds":
-      case "millisecond":
-      case "msecs":
-      case "msec":
-      case "ms":
-        return n2;
-      default:
-        return;
-    }
-  }
-  function fmtShort(ms) {
-    var msAbs = Math.abs(ms);
-    if (msAbs >= d) {
-      return Math.round(ms / d) + "d";
-    }
-    if (msAbs >= h) {
-      return Math.round(ms / h) + "h";
-    }
-    if (msAbs >= m) {
-      return Math.round(ms / m) + "m";
-    }
-    if (msAbs >= s2) {
-      return Math.round(ms / s2) + "s";
-    }
-    return ms + "ms";
-  }
-  function fmtLong(ms) {
-    var msAbs = Math.abs(ms);
-    if (msAbs >= d) {
-      return plural(ms, msAbs, d, "day");
-    }
-    if (msAbs >= h) {
-      return plural(ms, msAbs, h, "hour");
-    }
-    if (msAbs >= m) {
-      return plural(ms, msAbs, m, "minute");
-    }
-    if (msAbs >= s2) {
-      return plural(ms, msAbs, s2, "second");
-    }
-    return ms + " ms";
-  }
-  function plural(ms, msAbs, n2, name) {
-    var isPlural = msAbs >= n2 * 1.5;
-    return Math.round(ms / n2) + " " + name + (isPlural ? "s" : "");
-  }
-});
-// node_modules/debug/src/common.js
-var require_common2 = __commonJS((exports, module) => {
-  function setup(env) {
-    createDebug.debug = createDebug;
-    createDebug.default = createDebug;
-    createDebug.coerce = coerce;
-    createDebug.disable = disable;
-    createDebug.enable = enable;
-    createDebug.enabled = enabled;
-    createDebug.humanize = require_ms();
-    createDebug.destroy = destroy;
-    Object.keys(env).forEach((key) => {
-      createDebug[key] = env[key];
-    });
-    createDebug.names = [];
-    createDebug.skips = [];
-    createDebug.formatters = {};
-    function selectColor(namespace) {
-      let hash = 0;
-      for (let i2 = 0;i2 < namespace.length; i2++) {
-        hash = (hash << 5) - hash + namespace.charCodeAt(i2);
-        hash |= 0;
-      }
-      return createDebug.colors[Math.abs(hash) % createDebug.colors.length];
-    }
-    createDebug.selectColor = selectColor;
-    function createDebug(namespace) {
-      let prevTime;
-      let enableOverride = null;
-      let namespacesCache;
-      let enabledCache;
-      function debug(...args) {
-        if (!debug.enabled) {
-          return;
-        }
-        const self2 = debug;
-        const curr = Number(new Date);
-        const ms = curr - (prevTime || curr);
-        self2.diff = ms;
-        self2.prev = prevTime;
-        self2.curr = curr;
-        prevTime = curr;
-        args[0] = createDebug.coerce(args[0]);
-        if (typeof args[0] !== "string") {
-          args.unshift("%O");
-        }
-        let index = 0;
-        args[0] = args[0].replace(/%([a-zA-Z%])/g, (match, format) => {
-          if (match === "%%") {
-            return "%";
-          }
-          index++;
-          const formatter = createDebug.formatters[format];
-          if (typeof formatter === "function") {
-            const val = args[index];
-            match = formatter.call(self2, val);
-            args.splice(index, 1);
-            index--;
-          }
-          return match;
-        });
-        createDebug.formatArgs.call(self2, args);
-        const logFn = self2.log || createDebug.log;
-        logFn.apply(self2, args);
-      }
-      debug.namespace = namespace;
-      debug.useColors = createDebug.useColors();
-      debug.color = createDebug.selectColor(namespace);
-      debug.extend = extend;
-      debug.destroy = createDebug.destroy;
-      Object.defineProperty(debug, "enabled", {
-        enumerable: true,
-        configurable: false,
-        get: () => {
-          if (enableOverride !== null) {
-            return enableOverride;
-          }
-          if (namespacesCache !== createDebug.namespaces) {
-            namespacesCache = createDebug.namespaces;
-            enabledCache = createDebug.enabled(namespace);
-          }
-          return enabledCache;
-        },
-        set: (v) => {
-          enableOverride = v;
-        }
-      });
-      if (typeof createDebug.init === "function") {
-        createDebug.init(debug);
-      }
-      return debug;
-    }
-    function extend(namespace, delimiter) {
-      const newDebug = createDebug(this.namespace + (typeof delimiter === "undefined" ? ":" : delimiter) + namespace);
-      newDebug.log = this.log;
-      return newDebug;
-    }
-    function enable(namespaces) {
-      createDebug.save(namespaces);
-      createDebug.namespaces = namespaces;
-      createDebug.names = [];
-      createDebug.skips = [];
-      const split = (typeof namespaces === "string" ? namespaces : "").trim().replace(" ", ",").split(",").filter(Boolean);
-      for (const ns of split) {
-        if (ns[0] === "-") {
-          createDebug.skips.push(ns.slice(1));
-        } else {
-          createDebug.names.push(ns);
-        }
-      }
-    }
-    function matchesTemplate(search, template) {
-      let searchIndex = 0;
-      let templateIndex = 0;
-      let starIndex = -1;
-      let matchIndex = 0;
-      while (searchIndex < search.length) {
-        if (templateIndex < template.length && (template[templateIndex] === search[searchIndex] || template[templateIndex] === "*")) {
-          if (template[templateIndex] === "*") {
-            starIndex = templateIndex;
-            matchIndex = searchIndex;
-            templateIndex++;
-          } else {
-            searchIndex++;
-            templateIndex++;
-          }
-        } else if (starIndex !== -1) {
-          templateIndex = starIndex + 1;
-          matchIndex++;
-          searchIndex = matchIndex;
-        } else {
-          return false;
-        }
-      }
-      while (templateIndex < template.length && template[templateIndex] === "*") {
-        templateIndex++;
-      }
-      return templateIndex === template.length;
-    }
-    function disable() {
-      const namespaces = [
-        ...createDebug.names,
-        ...createDebug.skips.map((namespace) => "-" + namespace)
-      ].join(",");
-      createDebug.enable("");
-      return namespaces;
-    }
-    function enabled(name) {
-      for (const skip of createDebug.skips) {
-        if (matchesTemplate(name, skip)) {
-          return false;
-        }
-      }
-      for (const ns of createDebug.names) {
-        if (matchesTemplate(name, ns)) {
-          return true;
-        }
-      }
-      return false;
-    }
-    function coerce(val) {
-      if (val instanceof Error) {
-        return val.stack || val.message;
-      }
-      return val;
-    }
-    function destroy() {
-      console.warn("Instance method `debug.destroy()` is deprecated and no longer does anything. It will be removed in the next major version of `debug`.");
-    }
-    createDebug.enable(createDebug.load());
-    return createDebug;
-  }
-  module.exports = setup;
-});
-// node_modules/debug/src/browser.js
-var require_browser = __commonJS((exports, module) => {
-  exports.formatArgs = formatArgs;
-  exports.save = save;
-  exports.load = load;
-  exports.useColors = useColors;
-  exports.storage = localstorage();
-  exports.destroy = (() => {
-    let warned = false;
-    return () => {
-      if (!warned) {
-        warned = true;
-        console.warn("Instance method `debug.destroy()` is deprecated and no longer does anything. It will be removed in the next major version of `debug`.");
-      }
-    };
-  })();
-  exports.colors = [
-    "#0000CC",
-    "#0000FF",
-    "#0033CC",
-    "#0033FF",
-    "#0066CC",
-    "#0066FF",
-    "#0099CC",
-    "#0099FF",
-    "#00CC00",
-    "#00CC33",
-    "#00CC66",
-    "#00CC99",
-    "#00CCCC",
-    "#00CCFF",
-    "#3300CC",
-    "#3300FF",
-    "#3333CC",
-    "#3333FF",
-    "#3366CC",
-    "#3366FF",
-    "#3399CC",
-    "#3399FF",
-    "#33CC00",
-    "#33CC33",
-    "#33CC66",
-    "#33CC99",
-    "#33CCCC",
-    "#33CCFF",
-    "#6600CC",
-    "#6600FF",
-    "#6633CC",
-    "#6633FF",
-    "#66CC00",
-    "#66CC33",
-    "#9900CC",
-    "#9900FF",
-    "#9933CC",
-    "#9933FF",
-    "#99CC00",
-    "#99CC33",
-    "#CC0000",
-    "#CC0033",
-    "#CC0066",
-    "#CC0099",
-    "#CC00CC",
-    "#CC00FF",
-    "#CC3300",
-    "#CC3333",
-    "#CC3366",
-    "#CC3399",
-    "#CC33CC",
-    "#CC33FF",
-    "#CC6600",
-    "#CC6633",
-    "#CC9900",
-    "#CC9933",
-    "#CCCC00",
-    "#CCCC33",
-    "#FF0000",
-    "#FF0033",
-    "#FF0066",
-    "#FF0099",
-    "#FF00CC",
-    "#FF00FF",
-    "#FF3300",
-    "#FF3333",
-    "#FF3366",
-    "#FF3399",
-    "#FF33CC",
-    "#FF33FF",
-    "#FF6600",
-    "#FF6633",
-    "#FF9900",
-    "#FF9933",
-    "#FFCC00",
-    "#FFCC33"
-  ];
-  function useColors() {
-    if (typeof window !== "undefined" && window.process && (window.process.type === "renderer" || window.process.__nwjs)) {
-      return true;
-    }
-    if (typeof navigator !== "undefined" && navigator.userAgent && navigator.userAgent.toLowerCase().match(/(edge|trident)\/(\d+)/)) {
-      return false;
-    }
-    let m;
-    return typeof document !== "undefined" && document.documentElement && document.documentElement.style && document.documentElement.style.WebkitAppearance || typeof window !== "undefined" && window.console && (window.console.firebug || window.console.exception && window.console.table) || typeof navigator !== "undefined" && navigator.userAgent && (m = navigator.userAgent.toLowerCase().match(/firefox\/(\d+)/)) && parseInt(m[1], 10) >= 31 || typeof navigator !== "undefined" && navigator.userAgent && navigator.userAgent.toLowerCase().match(/applewebkit\/(\d+)/);
-  }
-  function formatArgs(args) {
-    args[0] = (this.useColors ? "%c" : "") + this.namespace + (this.useColors ? " %c" : " ") + args[0] + (this.useColors ? "%c " : " ") + "+" + module.exports.humanize(this.diff);
-    if (!this.useColors) {
-      return;
-    }
-    const c = "color: " + this.color;
-    args.splice(1, 0, c, "color: inherit");
-    let index = 0;
-    let lastC = 0;
-    args[0].replace(/%[a-zA-Z%]/g, (match) => {
-      if (match === "%%") {
-        return;
-      }
-      index++;
-      if (match === "%c") {
-        lastC = index;
-      }
-    });
-    args.splice(lastC, 0, c);
-  }
-  exports.log = console.debug || console.log || (() => {
-  });
-  function save(namespaces) {
-    try {
-      if (namespaces) {
-        exports.storage.setItem("debug", namespaces);
-      } else {
-        exports.storage.removeItem("debug");
-      }
-    } catch (error) {
-    }
-  }
-  function load() {
-    let r2;
-    try {
-      r2 = exports.storage.getItem("debug");
-    } catch (error) {
-    }
-    if (!r2 && typeof process !== "undefined" && "env" in process) {
-      r2 = process.env.DEBUG;
-    }
-    return r2;
-  }
-  function localstorage() {
-    try {
-      return localStorage;
-    } catch (error) {
-    }
-  }
-  module.exports = require_common2()(exports);
-  var { formatters } = module.exports;
-  formatters.j = function(v) {
-    try {
-      return JSON.stringify(v);
-    } catch (error) {
-      return "[UnexpectedJSONParseError]: " + error.message;
-    }
-  };
-});
-// node_modules/has-flag/index.js
-var require_has_flag = __commonJS((exports, module) => {
-  module.exports = (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);
-  };
-});
-// node_modules/supports-color/index.js
-var require_supports_color = __commonJS((exports, module) => {
-  var os = __require("os");
-  var tty = __require("tty");
-  var hasFlag = require_has_flag();
-  var { env } = process;
-  var forceColor;
-  if (hasFlag("no-color") || hasFlag("no-colors") || hasFlag("color=false") || hasFlag("color=never")) {
-    forceColor = 0;
-  } else if (hasFlag("color") || hasFlag("colors") || hasFlag("color=true") || hasFlag("color=always")) {
-    forceColor = 1;
-  }
-  if ("FORCE_COLOR" in env) {
-    if (env.FORCE_COLOR === "true") {
-      forceColor = 1;
-    } else if (env.FORCE_COLOR === "false") {
-      forceColor = 0;
-    } else {
-      forceColor = env.FORCE_COLOR.length === 0 ? 1 : Math.min(parseInt(env.FORCE_COLOR, 10), 3);
-    }
-  }
-  function translateLevel(level) {
-    if (level === 0) {
-      return false;
-    }
-    return {
-      level,
-      hasBasic: true,
-      has256: level >= 2,
-      has16m: level >= 3
-    };
-  }
-  function supportsColor(haveStream, streamIsTTY) {
-    if (forceColor === 0) {
-      return 0;
-    }
-    if (hasFlag("color=16m") || hasFlag("color=full") || hasFlag("color=truecolor")) {
-      return 3;
-    }
-    if (hasFlag("color=256")) {
-      return 2;
-    }
-    if (haveStream && !streamIsTTY && forceColor === undefined) {
-      return 0;
-    }
-    const min = forceColor || 0;
-    if (env.TERM === "dumb") {
-      return min;
-    }
-    if (process.platform === "win32") {
-      const osRelease = os.release().split(".");
-      if (Number(osRelease[0]) >= 10 && Number(osRelease[2]) >= 10586) {
-        return Number(osRelease[2]) >= 14931 ? 3 : 2;
-      }
-      return 1;
-    }
-    if ("CI" in env) {
-      if (["TRAVIS", "CIRCLECI", "APPVEYOR", "GITLAB_CI", "GITHUB_ACTIONS", "BUILDKITE"].some((sign) => (sign in env)) || env.CI_NAME === "codeship") {
-        return 1;
-      }
-      return min;
-    }
-    if ("TEAMCITY_VERSION" in env) {
-      return /^(9\.(0*[1-9]\d*)\.|\d{2,}\.)/.test(env.TEAMCITY_VERSION) ? 1 : 0;
-    }
-    if (env.COLORTERM === "truecolor") {
-      return 3;
-    }
-    if ("TERM_PROGRAM" in env) {
-      const version = parseInt((env.TERM_PROGRAM_VERSION || "").split(".")[0], 10);
-      switch (env.TERM_PROGRAM) {
-        case "iTerm.app":
-          return version >= 3 ? 3 : 2;
-        case "Apple_Terminal":
-          return 2;
-      }
-    }
-    if (/-256(color)?$/i.test(env.TERM)) {
-      return 2;
-    }
-    if (/^screen|^xterm|^vt100|^vt220|^rxvt|color|ansi|cygwin|linux/i.test(env.TERM)) {
-      return 1;
-    }
-    if ("COLORTERM" in env) {
-      return 1;
-    }
-    return min;
-  }
-  function getSupportLevel(stream) {
-    const level = supportsColor(stream, stream && stream.isTTY);
-    return translateLevel(level);
-  }
-  module.exports = {
-    supportsColor: getSupportLevel,
-    stdout: translateLevel(supportsColor(true, tty.isatty(1))),
-    stderr: translateLevel(supportsColor(true, tty.isatty(2)))
-  };
-});
-// node_modules/debug/src/node.js
-var require_node = __commonJS((exports, module) => {
-  var tty = __require("tty");
-  var util = __require("util");
-  exports.init = init;
-  exports.log = log;
-  exports.formatArgs = formatArgs;
-  exports.save = save;
-  exports.load = load;
-  exports.useColors = useColors;
-  exports.destroy = util.deprecate(() => {
-  }, "Instance method `debug.destroy()` is deprecated and no longer does anything. It will be removed in the next major version of `debug`.");
-  exports.colors = [6, 2, 3, 4, 5, 1];
-  try {
-    const supportsColor = require_supports_color();
-    if (supportsColor && (supportsColor.stderr || supportsColor).level >= 2) {
-      exports.colors = [
-        20,
-        21,
-        26,
-        27,
-        32,
-        33,
-        38,
-        39,
-        40,
-        41,
-        42,
-        43,
-        44,
-        45,
-        56,
-        57,
-        62,
-        63,
-        68,
-        69,
-        74,
-        75,
-        76,
-        77,
-        78,
-        79,
-        80,
-        81,
-        92,
-        93,
-        98,
-        99,
-        112,
-        113,
-        128,
-        129,
-        134,
-        135,
-        148,
-        149,
-        160,
-        161,
-        162,
-        163,
-        164,
-        165,
-        166,
-        167,
-        168,
-        169,
-        170,
-        171,
-        172,
-        173,
-        178,
-        179,
-        184,
-        185,
-        196,
-        197,
-        198,
-        199,
-        200,
-        201,
-        202,
-        203,
-        204,
-        205,
-        206,
-        207,
-        208,
-        209,
-        214,
-        215,
-        220,
-        221
-      ];
-    }
-  } catch (error) {
-  }
-  exports.inspectOpts = Object.keys(process.env).filter((key) => {
-    return /^debug_/i.test(key);
-  }).reduce((obj, key) => {
-    const prop = key.substring(6).toLowerCase().replace(/_([a-z])/g, (_, k) => {
-      return k.toUpperCase();
-    });
-    let val = process.env[key];
-    if (/^(yes|on|true|enabled)$/i.test(val)) {
-      val = true;
-    } else if (/^(no|off|false|disabled)$/i.test(val)) {
-      val = false;
-    } else if (val === "null") {
-      val = null;
-    } else {
-      val = Number(val);
-    }
-    obj[prop] = val;
-    return obj;
-  }, {});
-  function useColors() {
-    return "colors" in exports.inspectOpts ? Boolean(exports.inspectOpts.colors) : tty.isatty(process.stderr.fd);
-  }
-  function formatArgs(args) {
-    const { namespace: name, useColors: useColors2 } = this;
-    if (useColors2) {
-      const c = this.color;
-      const colorCode = "\x1B[3" + (c < 8 ? c : "8;5;" + c);
-      const prefix = `  ${colorCode};1m${name} \x1B[0m`;
-      args[0] = prefix + args[0].split(`
-`).join(`
-` + prefix);
-      args.push(colorCode + "m+" + module.exports.humanize(this.diff) + "\x1B[0m");
-    } else {
-      args[0] = getDate() + name + " " + args[0];
-    }
-  }
-  function getDate() {
-    if (exports.inspectOpts.hideDate) {
-      return "";
-    }
-    return new Date().toISOString() + " ";
-  }
-  function log(...args) {
-    return process.stderr.write(util.formatWithOptions(exports.inspectOpts, ...args) + `
-`);
-  }
-  function save(namespaces) {
-    if (namespaces) {
-      process.env.DEBUG = namespaces;
-    } else {
-      delete process.env.DEBUG;
-    }
-  }
-  function load() {
-    return process.env.DEBUG;
-  }
-  function init(debug) {
-    debug.inspectOpts = {};
-    const keys = Object.keys(exports.inspectOpts);
-    for (let i2 = 0;i2 < keys.length; i2++) {
-      debug.inspectOpts[keys[i2]] = exports.inspectOpts[keys[i2]];
-    }
-  }
-  module.exports = require_common2()(exports);
-  var { formatters } = module.exports;
-  formatters.o = function(v) {
-    this.inspectOpts.colors = this.useColors;
-    return util.inspect(v, this.inspectOpts).split(`
-`).map((str) => str.trim()).join(" ");
-  };
-  formatters.O = function(v) {
-    this.inspectOpts.colors = this.useColors;
-    return util.inspect(v, this.inspectOpts);
-  };
-});
-// node_modules/debug/src/index.js
-var require_src = __commonJS((exports, module) => {
-  if (typeof process === "undefined" || process.type === "renderer" || false || process.__nwjs) {
-    module.exports = require_browser();
-  } else {
-    module.exports = require_node();
-  }
-});
 // node_modules/socks-proxy-agent/dist/index.js
-var require_dist2 = __commonJS((exports) => {
-  var __createBinding = exports && exports.__createBinding || (Object.create ? function(o, m, k, k2) {
-    if (k2 === undefined)
-      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 === undefined)
-      k2 = k;
-    o[k2] = m[k];
-  });
-  var __setModuleDefault = exports && exports.__setModuleDefault || (Object.create ? function(o, v) {
-    Object.defineProperty(o, "default", { enumerable: true, value: v });
-  } : function(o, v) {
-    o["default"] = v;
-  });
-  var __importStar = exports && exports.__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 = exports && exports.__importDefault || function(mod) {
-    return mod && mod.__esModule ? mod : { default: mod };
-  };
-  Object.defineProperty(exports, "__esModule", { value: true });
-  exports.SocksProxyAgent = undefined;
-  var socks_1 = require_build();
-  var agent_base_1 = require_dist();
-  var debug_1 = __importDefault(require_src());
-  var dns = __importStar(__require("dns"));
-  var net = __importStar(__require("net"));
-  var tls = __importStar(__require("tls"));
-  var url_1 = __require("url");
-  var debug = (0, debug_1.default)("socks-proxy-agent");
-  var setServernameFromNonIpHost = (options) => {
-    if (options.servername === undefined && options.host && !net.isIP(options.host)) {
-      return {
-        ...options,
-        servername: options.host
-      };
-    }
-    return options;
-  };
-  function parseSocksURL(url) {
-    let lookup = false;
-    let type = 5;
-    const host = url.hostname;
-    const port = parseInt(url.port, 10) || 1080;
-    switch (url.protocol.replace(":", "")) {
-      case "socks4":
-        lookup = true;
-        type = 4;
-        break;
-      case "socks4a":
-        type = 4;
-        break;
-      case "socks5":
-        lookup = true;
-        type = 5;
-        break;
-      case "socks":
-        type = 5;
-        break;
-      case "socks5h":
-        type = 5;
-        break;
-      default:
-        throw new TypeError(`A "socks" protocol must be specified! Got: ${String(url.protocol)}`);
-    }
-    const proxy = {
-      host,
-      port,
-      type
-    };
-    if (url.username) {
-      Object.defineProperty(proxy, "userId", {
-        value: decodeURIComponent(url.username),
-        enumerable: false
-      });
-    }
-    if (url.password != null) {
-      Object.defineProperty(proxy, "password", {
-        value: decodeURIComponent(url.password),
-        enumerable: false
-      });
-    }
-    return { lookup, proxy };
-  }
-  class SocksProxyAgent extends agent_base_1.Agent {
-    constructor(uri, opts) {
-      super(opts);
-      const url = typeof uri === "string" ? new url_1.URL(uri) : uri;
-      const { proxy, lookup } = parseSocksURL(url);
-      this.shouldLookup = lookup;
-      this.proxy = proxy;
-      this.timeout = opts?.timeout ?? null;
-      this.socketOptions = opts?.socketOptions ?? null;
-    }
-    async connect(req, opts) {
-      const { shouldLookup, proxy, timeout } = this;
-      if (!opts.host) {
-        throw new Error("No `host` defined!");
-      }
-      let { host } = opts;
-      const { port, lookup: lookupFn = dns.lookup } = opts;
-      if (shouldLookup) {
-        host = await new Promise((resolve, reject) => {
-          lookupFn(host, {}, (err, res) => {
-            if (err) {
-              reject(err);
-            } else {
-              resolve(res);
-            }
-          });
-        });
-      }
-      const socksOpts = {
-        proxy,
-        destination: {
-          host,
-          port: typeof port === "number" ? port : parseInt(port, 10)
-        },
-        command: "connect",
-        timeout: timeout ?? undefined,
-        socket_options: this.socketOptions ?? undefined
-      };
-      const cleanup = (tlsSocket) => {
-        req.destroy();
-        socket.destroy();
-        if (tlsSocket)
-          tlsSocket.destroy();
-      };
-      debug("Creating socks proxy connection: %o", socksOpts);
-      const { socket } = await socks_1.SocksClient.createConnection(socksOpts);
-      debug("Successfully created socks proxy connection");
-      if (timeout !== null) {
-        socket.setTimeout(timeout);
-        socket.on("timeout", () => cleanup());
-      }
-      if (opts.secureEndpoint) {
-        debug("Upgrading socket connection to TLS");
-        const tlsSocket = tls.connect({
-          ...omit(setServernameFromNonIpHost(opts), "host", "path", "port"),
-          socket
-        });
-        tlsSocket.once("error", (error) => {
-          debug("Socket TLS error", error.message);
-          cleanup(tlsSocket);
-        });
-        return tlsSocket;
-      }
-      return socket;
-    }
-  }
-  SocksProxyAgent.protocols = [
-    "socks",
-    "socks4",
-    "socks4a",
-    "socks5",
-    "socks5h"
-  ];
-  exports.SocksProxyAgent = SocksProxyAgent;
-  function omit(obj, ...keys) {
-    const ret = {};
-    let key;
-    for (key in obj) {
-      if (!keys.includes(key)) {
-        ret[key] = obj[key];
-      }
-    }
-    return ret;
-  }
-});
-// node_modules/https-proxy-agent/dist/parse-proxy-response.js
-var require_parse_proxy_response = __commonJS((exports) => {
-  var __importDefault = exports && exports.__importDefault || function(mod) {
-    return mod && mod.__esModule ? mod : { default: mod };
-  };
-  Object.defineProperty(exports, "__esModule", { value: true });
-  exports.parseProxyResponse = undefined;
-  var debug_1 = __importDefault(require_src());
-  var debug = (0, debug_1.default)("https-proxy-agent:parse-proxy-response");
-  function parseProxyResponse(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
-\r
-`);
-        if (endOfHeaders === -1) {
-          debug("have not received end of HTTP headers yet...");
-          read();
-          return;
-        }
-        const headerParts = buffered.slice(0, endOfHeaders).toString("ascii").split(`\r
-`);
-        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();
-    });
-  }
-  exports.parseProxyResponse = parseProxyResponse;
-});
-// node_modules/https-proxy-agent/dist/index.js
 var require_dist3 = __commonJS((exports) => {
   var __createBinding = exports && exports.__createBinding || (Object.create ? function(o, m, k, k2) {
     if (k2 === undefined)
@@ -5434,15 +5394,15 @@ var require_dist3 = __commonJS((exports) => {
     return mod && mod.__esModule ? mod : { default: mod };
   };
   Object.defineProperty(exports, "__esModule", { value: true });
-  exports.HttpsProxyAgent = undefined;
+  exports.SocksProxyAgent = undefined;
+  var socks_1 = require_build();
+  var agent_base_1 = require_dist();
+  var debug_1 = __importDefault(require_src());
+  var dns = __importStar(__require("dns"));
   var net = __importStar(__require("net"));
   var tls = __importStar(__require("tls"));
-  var assert_1 = __importDefault(__require("assert"));
-  var debug_1 = __importDefault(require_src());
-  var agent_base_1 = require_dist();
   var url_1 = __require("url");
-  var parse_proxy_response_1 = require_parse_proxy_response();
-  var debug = (0, debug_1.default)("https-proxy-agent");
+  var debug = (0, debug_1.default)("socks-proxy-agent");
   var setServernameFromNonIpHost = (options) => {
     if (options.servername === undefined && options.host && !net.isIP(options.host)) {
       return {
@@ -5452,86 +5412,126 @@ var require_dist3 = __commonJS((exports) => {
     }
     return options;
   };
+  function parseSocksURL(url) {
+    let lookup = false;
+    let type = 5;
+    const host = url.hostname;
+    const port = parseInt(url.port, 10) || 1080;
+    switch (url.protocol.replace(":", "")) {
+      case "socks4":
+        lookup = true;
+        type = 4;
+        break;
+      case "socks4a":
+        type = 4;
+        break;
+      case "socks5":
+        lookup = true;
+        type = 5;
+        break;
+      case "socks":
+        type = 5;
+        break;
+      case "socks5h":
+        type = 5;
+        break;
+      default:
+        throw new TypeError(`A "socks" protocol must be specified! Got: ${String(url.protocol)}`);
+    }
+    const proxy = {
+      host,
+      port,
+      type
+    };
+    if (url.username) {
+      Object.defineProperty(proxy, "userId", {
+        value: decodeURIComponent(url.username),
+        enumerable: false
+      });
+    }
+    if (url.password != null) {
+      Object.defineProperty(proxy, "password", {
+        value: decodeURIComponent(url.password),
+        enumerable: false
+      });
+    }
+    return { lookup, proxy };
+  }
-  class HttpsProxyAgent extends agent_base_1.Agent {
-    constructor(proxy, opts) {
+  class SocksProxyAgent extends agent_base_1.Agent {
+    constructor(uri, opts) {
       super(opts);
-      this.options = { path: undefined };
-      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 = {
-        ALPNProtocols: ["http/1.1"],
-        ...opts ? omit(opts, "headers") : null,
-        host,
-        port
-      };
+      const url = typeof uri === "string" ? new url_1.URL(uri) : uri;
+      const { proxy, lookup } = parseSocksURL(url);
+      this.shouldLookup = lookup;
+      this.proxy = proxy;
+      this.timeout = opts?.timeout ?? null;
+      this.socketOptions = opts?.socketOptions ?? null;
     }
     async connect(req, opts) {
-      const { proxy } = this;
+      const { shouldLookup, proxy, timeout } = 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")}`;
+        throw new Error("No `host` defined!");
       }
-      headers.Host = `${host}:${opts.port}`;
-      if (!headers["Proxy-Connection"]) {
-        headers["Proxy-Connection"] = this.keepAlive ? "Keep-Alive" : "close";
+      let { host } = opts;
+      const { port, lookup: lookupFn = dns.lookup } = opts;
+      if (shouldLookup) {
+        host = await new Promise((resolve, reject) => {
+          lookupFn(host, {}, (err, res) => {
+            if (err) {
+              reject(err);
+            } else {
+              resolve(res);
+            }
+          });
+        });
       }
-      for (const name of Object.keys(headers)) {
-        payload += `${name}: ${headers[name]}\r
-`;
+      const socksOpts = {
+        proxy,
+        destination: {
+          host,
+          port: typeof port === "number" ? port : parseInt(port, 10)
+        },
+        command: "connect",
+        timeout: timeout ?? undefined,
+        socket_options: this.socketOptions ?? undefined
+      };
+      const cleanup = (tlsSocket) => {
+        req.destroy();
+        socket.destroy();
+        if (tlsSocket)
+          tlsSocket.destroy();
+      };
+      debug("Creating socks proxy connection: %o", socksOpts);
+      const { socket } = await socks_1.SocksClient.createConnection(socksOpts);
+      debug("Successfully created socks proxy connection");
+      if (timeout !== null) {
+        socket.setTimeout(timeout);
+        socket.on("timeout", () => cleanup());
       }
-      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;
+      if (opts.secureEndpoint) {
+        debug("Upgrading socket connection to TLS");
+        const tlsSocket = tls.connect({
+          ...omit(setServernameFromNonIpHost(opts), "host", "path", "port"),
+          socket
+        });
+        tlsSocket.once("error", (error) => {
+          debug("Socket TLS error", error.message);
+          cleanup(tlsSocket);
+        });
+        return tlsSocket;
       }
-      socket.destroy();
-      const fakeSocket = new net.Socket({ writable: false });
-      fakeSocket.readable = true;
-      req.once("socket", (s2) => {
-        debug("Replaying proxy buffer for failed request");
-        (0, assert_1.default)(s2.listenerCount("data") > 0);
-        s2.push(buffered);
-        s2.push(null);
-      });
-      return fakeSocket;
+      return socket;
     }
   }
-  HttpsProxyAgent.protocols = ["http", "https"];
-  exports.HttpsProxyAgent = HttpsProxyAgent;
-  function resume(socket) {
-    socket.resume();
-  }
+  SocksProxyAgent.protocols = [
+    "socks",
+    "socks4",
+    "socks4a",
+    "socks5",
+    "socks5h"
+  ];
+  exports.SocksProxyAgent = SocksProxyAgent;
   function omit(obj, ...keys) {
     const ret = {};
     let key;
@@ -31016,6 +31016,15 @@ var require_lib2 = __commonJS((exports) => {
   __exportStar(require_enum(), exports);
 });
+// src/database.ts
+var import_https_proxy_agent = __toESM(require_dist2(), 1);
+import {
+  createCipheriv,
+  createDecipheriv,
+  randomBytes,
+  scryptSync
+} from "crypto";
 // node_modules/pocketbase/dist/pocketbase.es.mjs
 class ClientResponseError extends Error {
   constructor(e) {
@@ -32102,14 +32111,7 @@ class Client {
 }
 // src/database.ts
-var import_socks_proxy_agent = __toESM(require_dist2(), 1);
-var import_https_proxy_agent = __toESM(require_dist3(), 1);
-import {
-  createCipheriv,
-  createDecipheriv,
-  randomBytes,
-  scryptSync
-} from "crypto";
+var import_socks_proxy_agent = __toESM(require_dist3(), 1);
 function encryptObject(obj, password) {
   const jsonString = JSON.stringify(obj);
   const salt = randomBytes(16);
@@ -32434,6 +32436,28 @@ class AppDatabase {
       kind
     });
   }
+  async cancelLimitOrders(payload) {
+    const { symbol, kind, account, cancelExchangeOrders } = payload;
+    const side = kind === "long" ? "buy" : "sell";
+    const orders = await this.pb.collection("orders").getFullList({
+      filter: `symbol:lower="${symbol.toLowerCase()}" && account.owner:lower="${account.owner.toLowerCase()}" && account.exchange:lower="${account.exchange.toLowerCase()}" && kind="${kind}" && side:lower="${side}" && stop = 0`
+    });
+    const exchange_order_ids = orders.map((o) => parseInt(o.order_id, 10));
+    try {
+      console.log(`Attempting to cancel ${exchange_order_ids.length} orders on ${account.exchange} for ${account.owner}...`);
+      const cancel_result = await cancelExchangeOrders({
+        symbol,
+        orders: exchange_order_ids
+      });
+      console.log("Exchange cancellation result:", cancel_result);
+      for (const order of orders) {
+        await this.pb.collection("orders").delete(order.id);
+      }
+      console.log("Successfully canceled orders from PocketBase.");
+    } catch (error) {
+      console.error("Error canceling exchange orders:", error);
+    }
+  }
   async cancelOrders(payload) {
     const { stop, cancelExchangeOrders, all, kind, account, symbol, price } = payload;
     let orders_to_cancel = [];
@@ -32572,12 +32596,12 @@ class AppDatabase {
     return null;
   }
   async getPositionStrategy(account) {
-    const _strategy_instance = await this.pb.collection("account_strategies").getFirstListItem(`account.owner:lower="${account.owner.toLowerCase()}" && account.exchange:lower="${account.exchange.toLowerCase()}"`, { expand: "strategy,focus_account" });
-    if (_strategy_instance) {
-      return {
-        strategy_instance: _strategy_instance?.expand?.strategy,
-        focus_account: _strategy_instance?.expand?.focus_account
-      };
+    const _strategy_instance = await this.pb.collection("account_strategies").getFullList({
+      filter: `account.owner:lower="${account.owner.toLowerCase()}" && account.exchange:lower="${account.exchange.toLowerCase()}"`,
+      expand: "account"
+    });
+    if (_strategy_instance.length > 0) {
+      return _strategy_instance[0];
     }
     return null;
   }
@@ -36372,7 +36396,7 @@ class ExchangeAccount {
     }
   }
   async cancelOrders(payload) {
-    const { symbol, kind, price: _price, all, stop } = payload;
+    const { symbol, kind, price: _price, all, stop, limit } = payload;
     let price = _price || 0;
     await this.getLiveExchangeInstance({
       symbol,
@@ -36383,6 +36407,14 @@ class ExchangeAccount {
       kind,
       update: true
     });
+    if (limit) {
+      return await this.app_db.cancelLimitOrders({
+        symbol,
+        kind,
+        account: this.instance,
+        cancelExchangeOrders: this.cancelExchangeOrders.bind(this)
+      });
+    }
     if (all) {
     } else {
       if (!price) {
@@ -36764,6 +36796,23 @@ class ExchangeAccount {
   async getPositionStrategy() {
     return await this.app_db.getPositionStrategy(this.instance);
   }
+  async toUpdate(payload) {
+    const { refresh } = payload;
+    const strategy = await this.getPositionStrategy();
+    if (!strategy) {
+      return;
+    }
+    const { symbol: _symbol, watch_symbol } = strategy;
+    const watch_positions = await this.syncAccount({
+      symbol: watch_symbol,
+      live_refresh: refresh,
+      update: true
+    });
+    const long_watch_position = watch_positions.find((x) => x.kind === "long");
+    const short_watch_position = watch_positions.find((x) => x.kind === "short");
+    if (long_watch_position.quantity === short_watch_position.quantity && long_watch_position.quantity > 0) {
+    }
+  }
   async buildReduceConfig(payload) {
     const positions = await this.syncAccount({
       symbol: payload.symbol
@@ -37094,13 +37143,24 @@ class ExchangeAccount {
     }
   }
   async triggerTradeFromConfig(payload) {
-    const { symbol, kind, place = true, stop, use_current } = payload;
+    const {
+      symbol,
+      kind,
+      place = true,
+      stop,
+      use_current,
+      ignore_config
+    } = payload;
     const position2 = await this.syncAccount({
       symbol,
       kind
     });
-    if (position2?.config) {
-      const config = position2.expand.config;
+    const config = await this.getPositionConfig({
+      symbol,
+      kind
+    });
+    let condition = ignore_config ? true : position2?.config;
+    if (condition) {
       let entry = payload.tp ? position2.entry || config.entry : config.entry;
       const v = stop ? "place_stop_orders" : "place_limit_orders";
       return await this.placeSharedOrder(v, {
@@ -37857,7 +37917,16 @@ class ExchangeAccount {
     return 0;
   }
   async placeTrade(payload) {
-    const { symbol, kind, place, tp, raw: _raw, cancel, stop } = payload;
+    const {
+      symbol,
+      kind,
+      place,
+      tp,
+      raw: _raw,
+      cancel,
+      stop,
+      ignore_config
+    } = payload;
     if (cancel) {
       await this.cancelOrders({
         symbol,
@@ -37869,7 +37938,8 @@ class ExchangeAccount {
         symbol,
         kind,
         raw: payload.raw,
-        stop
+        stop,
+        ignore_config
       });
     }
     await this.syncAccount({
@@ -37894,6 +37964,29 @@ class ExchangeAccount {
     }
     return result;
   }
+  async updateConfigPnl(payload) {
+    const { symbol, kind } = payload;
+    const position2 = await this.syncAccount({
+      symbol,
+      kind
+    });
+    if (!position2?.config) {
+      const config = await this.getPositionConfig({ symbol, kind });
+      if (config) {
+        await this.app_db.update_db_position(position2, { config: config.id });
+        await this.updateTargetPnl({
+          symbol,
+          kind
+        });
+        await this.app_db.update_db_position(position2, { config: null });
+      }
+    } else {
+      await this.updateTargetPnl({
+        symbol,
+        kind
+      });
+    }
+  }
 }
 function getExchangeKlass(exchange) {
   const func = exchange === "binance" ? BinanceExchange : BybitExchange;
@@ -38005,96 +38098,6 @@ class App {
       stop: payload.stop
     });
   }
-  async generateConfig(payload) {
-    const { symbol, kind } = payload;
-    const exchange_account = await this.getExchangeAccount(payload.account);
-    let focus_position = await exchange_account.syncAccount({
-      symbol,
-      kind: kind === "long" ? "short" : "long",
-      as_view: true
-    });
-    if (payload.update_orders) {
-      await exchange_account.syncOrders({
-        symbol,
-        kind,
-        update: true
-      });
-    }
-    const current_price = await exchange_account.getCurrentPrice(symbol);
-    const config_instance = await exchange_account.getPositionConfig({
-      symbol,
-      kind
-    });
-    const strategy = await exchange_account.getPositionStrategy();
-    if (strategy?.focus_account) {
-      const focus_exchange_account = await this.getExchangeAccount(strategy.focus_account);
-      const __payload = await focus_exchange_account.syncAccount({
-        symbol,
-        kind: kind === "long" ? "short" : "long",
-        as_view: true
-      });
-      focus_position = __payload;
-    }
-    if (focus_position && config_instance && strategy?.strategy_instance && focus_position?.liquidation && focus_position?.take_profit && focus_position?.target_pnl) {
-      const { strategy_instance } = strategy;
-      const risk_factor = payload.kind === "long" ? strategy_instance.long_risk_factor : strategy_instance.short_risk_factor;
-      let entry = strategy_instance.liquidation_as_entry ? focus_position.liquidation : strategy_instance.stop_as_entry && focus_position.stop_loss?.price ? focus_position.stop_loss.price : config_instance.entry;
-      let stop = strategy_instance.tp_as_stop ? focus_position.take_profit : strategy_instance.entry_as_stop ? focus_position.entry : config_instance.stop;
-      if (entry < 0) {
-        entry = current_price;
-      }
-      if (!risk_factor) {
-        return null;
-      }
-      let config = await exchange_account.generate_config_params({
-        entry,
-        stop,
-        risk_reward: config_instance.risk_reward,
-        risk: focus_position.target_pnl * risk_factor,
-        symbol
-      });
-      config = {
-        ...config_instance,
-        ...config,
-        place_stop: strategy_instance?.place_stop || false,
-        profit_percent: strategy_instance?.profit_percent || config_instance.profit_percent
-      };
-      let rr = {};
-      if (strategy_instance.save_config) {
-        rr = await this.app_db.createOrUpdatePositionConfig(config_instance, {
-          entry: config.entry,
-          stop: config.stop,
-          risk_reward: config.risk_reward,
-          risk: config.risk
-        });
-      }
-      if (payload.place_orders) {
-        const promises = [
-          exchange_account.placeSharedOrder("place_limit_orders", {
-            symbol,
-            entry: config.entry,
-            stop: config.stop,
-            risk_reward: config.risk_reward,
-            risk: config.risk,
-            place: true
-          })
-        ];
-        if (config.place_stop) {
-          promises.push(exchange_account.placeSharedOrder("place_stop_orders", {
-            symbol,
-            entry: config.entry,
-            stop: config.stop,
-            risk_reward: config.risk_reward,
-            risk: config.risk,
-            place: true
-          }));
-        }
-        return await Promise.all(promises);
-      }
-      return { ...rr, ...config };
-    }
-    return null;
-  }
   async updateReduceRatio(payload) {
     const { symbol } = payload;
     const exchange_account = await this.getExchangeAccount(payload.account);