@mcp-use/inspector 0.9.0-canary.1 → 0.9.0-canary.2

package/dist/client/assets/{winston-BlqNOObA.js → winston-nzaZqgVL.js}

@@ -1,4 +1,5 @@
-import { b as getAugmentedNamespace, g as getDefaultExportFromCjs } from "./index-B6TgCktd.js";
+import { bh as getAugmentedNamespace, bi as getDefaultExportFromCjs } from "./index-BaR5HKmC.js";
+import { u as util } from "./util-D59LNlyU.js";
 import { o as os } from "./__vite-browser-external-CHS79mP1.js";
 import { r as requireBase64Js } from "./index-DX0TIfSM.js";
 import { p as path } from "./path-QsnVvLoj.js";
@@ -23,10 +24,10 @@ function _mergeNamespaces(n, m) {
 }
 var winston$2 = {};
 var browser$2 = {};
-var format$3;
+var format$2;
 var hasRequiredFormat$1;
 function requireFormat$1() {
-  if (hasRequiredFormat$1) return format$3;
+  if (hasRequiredFormat$1) return format$2;
   hasRequiredFormat$1 = 1;
   function _typeof(o) {
     "@babel/helpers - typeof";
@@ -118,7 +119,7 @@ function requireFormat$1() {
     _inherits(InvalidFormatError2, _Error);
     return _createClass(InvalidFormatError2);
   })(/* @__PURE__ */ _wrapNativeSuper(Error));
-  format$3 = function(formatFn) {
+  format$2 = function(formatFn) {
     if (formatFn.length > 2) {
       throw new InvalidFormatError(formatFn);
     }
@@ -133,32 +134,12 @@ function requireFormat$1() {
     createFormatWrap.Format = Format;
     return createFormatWrap;
   };
-  return format$3;
+  return format$2;
 }
 var colorize = { exports: {} };
 var safe = { exports: {} };
 var colors = { exports: {} };
-function debuglog() {
-  return () => {
-  };
-}
-function inspect(obj) {
-  return JSON.stringify(obj);
-}
-function inherits() {
-}
-function format$2() {
-}
-const util = { debuglog, inspect, inherits, format: format$2 };
-const util$1 = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
-  __proto__: null,
-  debuglog,
-  default: util,
-  format: format$2,
-  inherits,
-  inspect
-}, Symbol.toStringTag, { value: "Module" }));
-const require$$0$2 = /* @__PURE__ */ getAugmentedNamespace(util$1);
+const require$$0$2 = /* @__PURE__ */ getAugmentedNamespace(util);
 var styles = { exports: {} };
 var hasRequiredStyles;
 function requireStyles() {
@@ -2280,7 +2261,7 @@ var hasRequiredPrettyPrint;
 function requirePrettyPrint() {
   if (hasRequiredPrettyPrint) return prettyPrint;
   hasRequiredPrettyPrint = 1;
-  var inspect2 = require$$0$2.inspect;
+  var inspect = require$$0$2.inspect;
   var format2 = requireFormat$1();
   var _require = requireTripleBeam(), LEVEL = _require.LEVEL, MESSAGE = _require.MESSAGE, SPLAT = _require.SPLAT;
   prettyPrint = format2(function(info) {
@@ -2289,7 +2270,7 @@ function requirePrettyPrint() {
     delete stripped[LEVEL];
     delete stripped[MESSAGE];
     delete stripped[SPLAT];
-    info[MESSAGE] = inspect2(stripped, false, opts.depth || null, opts.colorize);
+    info[MESSAGE] = inspect(stripped, false, opts.depth || null, opts.colorize);
     return info;
   });
   return prettyPrint;
@@ -3098,380 +3079,12 @@ function requireBrowser$1() {
   }
   return browser$1;
 }
-var events = { exports: {} };
-var hasRequiredEvents;
-function requireEvents() {
-  if (hasRequiredEvents) return events.exports;
-  hasRequiredEvents = 1;
-  var R = typeof Reflect === "object" ? Reflect : null;
-  var ReflectApply = R && typeof R.apply === "function" ? R.apply : function ReflectApply2(target, receiver, args) {
-    return Function.prototype.apply.call(target, receiver, args);
-  };
-  var ReflectOwnKeys;
-  if (R && typeof R.ownKeys === "function") {
-    ReflectOwnKeys = R.ownKeys;
-  } else if (Object.getOwnPropertySymbols) {
-    ReflectOwnKeys = function ReflectOwnKeys2(target) {
-      return Object.getOwnPropertyNames(target).concat(Object.getOwnPropertySymbols(target));
-    };
-  } else {
-    ReflectOwnKeys = function ReflectOwnKeys2(target) {
-      return Object.getOwnPropertyNames(target);
-    };
-  }
-  function ProcessEmitWarning(warning) {
-    if (console && console.warn) console.warn(warning);
-  }
-  var NumberIsNaN = Number.isNaN || function NumberIsNaN2(value) {
-    return value !== value;
-  };
-  function EventEmitter() {
-    EventEmitter.init.call(this);
-  }
-  events.exports = EventEmitter;
-  events.exports.once = once2;
-  EventEmitter.EventEmitter = EventEmitter;
-  EventEmitter.prototype._events = void 0;
-  EventEmitter.prototype._eventsCount = 0;
-  EventEmitter.prototype._maxListeners = void 0;
-  var defaultMaxListeners = 10;
-  function checkListener(listener) {
-    if (typeof listener !== "function") {
-      throw new TypeError('The "listener" argument must be of type Function. Received type ' + typeof listener);
-    }
-  }
-  Object.defineProperty(EventEmitter, "defaultMaxListeners", {
-    enumerable: true,
-    get: function() {
-      return defaultMaxListeners;
-    },
-    set: function(arg) {
-      if (typeof arg !== "number" || arg < 0 || NumberIsNaN(arg)) {
-        throw new RangeError('The value of "defaultMaxListeners" is out of range. It must be a non-negative number. Received ' + arg + ".");
-      }
-      defaultMaxListeners = arg;
-    }
-  });
-  EventEmitter.init = function() {
-    if (this._events === void 0 || this._events === Object.getPrototypeOf(this)._events) {
-      this._events = /* @__PURE__ */ Object.create(null);
-      this._eventsCount = 0;
-    }
-    this._maxListeners = this._maxListeners || void 0;
-  };
-  EventEmitter.prototype.setMaxListeners = function setMaxListeners(n) {
-    if (typeof n !== "number" || n < 0 || NumberIsNaN(n)) {
-      throw new RangeError('The value of "n" is out of range. It must be a non-negative number. Received ' + n + ".");
-    }
-    this._maxListeners = n;
-    return this;
-  };
-  function _getMaxListeners(that) {
-    if (that._maxListeners === void 0)
-      return EventEmitter.defaultMaxListeners;
-    return that._maxListeners;
-  }
-  EventEmitter.prototype.getMaxListeners = function getMaxListeners() {
-    return _getMaxListeners(this);
-  };
-  EventEmitter.prototype.emit = function emit(type) {
-    var args = [];
-    for (var i = 1; i < arguments.length; i++) args.push(arguments[i]);
-    var doError = type === "error";
-    var events2 = this._events;
-    if (events2 !== void 0)
-      doError = doError && events2.error === void 0;
-    else if (!doError)
-      return false;
-    if (doError) {
-      var er;
-      if (args.length > 0)
-        er = args[0];
-      if (er instanceof Error) {
-        throw er;
-      }
-      var err = new Error("Unhandled error." + (er ? " (" + er.message + ")" : ""));
-      err.context = er;
-      throw err;
-    }
-    var handler = events2[type];
-    if (handler === void 0)
-      return false;
-    if (typeof handler === "function") {
-      ReflectApply(handler, this, args);
-    } else {
-      var len = handler.length;
-      var listeners = arrayClone(handler, len);
-      for (var i = 0; i < len; ++i)
-        ReflectApply(listeners[i], this, args);
-    }
-    return true;
-  };
-  function _addListener(target, type, listener, prepend) {
-    var m;
-    var events2;
-    var existing;
-    checkListener(listener);
-    events2 = target._events;
-    if (events2 === void 0) {
-      events2 = target._events = /* @__PURE__ */ Object.create(null);
-      target._eventsCount = 0;
-    } else {
-      if (events2.newListener !== void 0) {
-        target.emit(
-          "newListener",
-          type,
-          listener.listener ? listener.listener : listener
-        );
-        events2 = target._events;
-      }
-      existing = events2[type];
-    }
-    if (existing === void 0) {
-      existing = events2[type] = listener;
-      ++target._eventsCount;
-    } else {
-      if (typeof existing === "function") {
-        existing = events2[type] = prepend ? [listener, existing] : [existing, listener];
-      } else if (prepend) {
-        existing.unshift(listener);
-      } else {
-        existing.push(listener);
-      }
-      m = _getMaxListeners(target);
-      if (m > 0 && existing.length > m && !existing.warned) {
-        existing.warned = true;
-        var w = new Error("Possible EventEmitter memory leak detected. " + existing.length + " " + String(type) + " listeners added. Use emitter.setMaxListeners() to increase limit");
-        w.name = "MaxListenersExceededWarning";
-        w.emitter = target;
-        w.type = type;
-        w.count = existing.length;
-        ProcessEmitWarning(w);
-      }
-    }
-    return target;
-  }
-  EventEmitter.prototype.addListener = function addListener(type, listener) {
-    return _addListener(this, type, listener, false);
-  };
-  EventEmitter.prototype.on = EventEmitter.prototype.addListener;
-  EventEmitter.prototype.prependListener = function prependListener(type, listener) {
-    return _addListener(this, type, listener, true);
-  };
-  function onceWrapper() {
-    if (!this.fired) {
-      this.target.removeListener(this.type, this.wrapFn);
-      this.fired = true;
-      if (arguments.length === 0)
-        return this.listener.call(this.target);
-      return this.listener.apply(this.target, arguments);
-    }
-  }
-  function _onceWrap(target, type, listener) {
-    var state2 = { fired: false, wrapFn: void 0, target, type, listener };
-    var wrapped = onceWrapper.bind(state2);
-    wrapped.listener = listener;
-    state2.wrapFn = wrapped;
-    return wrapped;
-  }
-  EventEmitter.prototype.once = function once3(type, listener) {
-    checkListener(listener);
-    this.on(type, _onceWrap(this, type, listener));
-    return this;
-  };
-  EventEmitter.prototype.prependOnceListener = function prependOnceListener(type, listener) {
-    checkListener(listener);
-    this.prependListener(type, _onceWrap(this, type, listener));
-    return this;
-  };
-  EventEmitter.prototype.removeListener = function removeListener(type, listener) {
-    var list, events2, position, i, originalListener;
-    checkListener(listener);
-    events2 = this._events;
-    if (events2 === void 0)
-      return this;
-    list = events2[type];
-    if (list === void 0)
-      return this;
-    if (list === listener || list.listener === listener) {
-      if (--this._eventsCount === 0)
-        this._events = /* @__PURE__ */ Object.create(null);
-      else {
-        delete events2[type];
-        if (events2.removeListener)
-          this.emit("removeListener", type, list.listener || listener);
-      }
-    } else if (typeof list !== "function") {
-      position = -1;
-      for (i = list.length - 1; i >= 0; i--) {
-        if (list[i] === listener || list[i].listener === listener) {
-          originalListener = list[i].listener;
-          position = i;
-          break;
-        }
-      }
-      if (position < 0)
-        return this;
-      if (position === 0)
-        list.shift();
-      else {
-        spliceOne(list, position);
-      }
-      if (list.length === 1)
-        events2[type] = list[0];
-      if (events2.removeListener !== void 0)
-        this.emit("removeListener", type, originalListener || listener);
-    }
-    return this;
-  };
-  EventEmitter.prototype.off = EventEmitter.prototype.removeListener;
-  EventEmitter.prototype.removeAllListeners = function removeAllListeners(type) {
-    var listeners, events2, i;
-    events2 = this._events;
-    if (events2 === void 0)
-      return this;
-    if (events2.removeListener === void 0) {
-      if (arguments.length === 0) {
-        this._events = /* @__PURE__ */ Object.create(null);
-        this._eventsCount = 0;
-      } else if (events2[type] !== void 0) {
-        if (--this._eventsCount === 0)
-          this._events = /* @__PURE__ */ Object.create(null);
-        else
-          delete events2[type];
-      }
-      return this;
-    }
-    if (arguments.length === 0) {
-      var keys = Object.keys(events2);
-      var key;
-      for (i = 0; i < keys.length; ++i) {
-        key = keys[i];
-        if (key === "removeListener") continue;
-        this.removeAllListeners(key);
-      }
-      this.removeAllListeners("removeListener");
-      this._events = /* @__PURE__ */ Object.create(null);
-      this._eventsCount = 0;
-      return this;
-    }
-    listeners = events2[type];
-    if (typeof listeners === "function") {
-      this.removeListener(type, listeners);
-    } else if (listeners !== void 0) {
-      for (i = listeners.length - 1; i >= 0; i--) {
-        this.removeListener(type, listeners[i]);
-      }
-    }
-    return this;
-  };
-  function _listeners(target, type, unwrap) {
-    var events2 = target._events;
-    if (events2 === void 0)
-      return [];
-    var evlistener = events2[type];
-    if (evlistener === void 0)
-      return [];
-    if (typeof evlistener === "function")
-      return unwrap ? [evlistener.listener || evlistener] : [evlistener];
-    return unwrap ? unwrapListeners(evlistener) : arrayClone(evlistener, evlistener.length);
-  }
-  EventEmitter.prototype.listeners = function listeners(type) {
-    return _listeners(this, type, true);
-  };
-  EventEmitter.prototype.rawListeners = function rawListeners(type) {
-    return _listeners(this, type, false);
-  };
-  EventEmitter.listenerCount = function(emitter, type) {
-    if (typeof emitter.listenerCount === "function") {
-      return emitter.listenerCount(type);
-    } else {
-      return listenerCount.call(emitter, type);
-    }
-  };
-  EventEmitter.prototype.listenerCount = listenerCount;
-  function listenerCount(type) {
-    var events2 = this._events;
-    if (events2 !== void 0) {
-      var evlistener = events2[type];
-      if (typeof evlistener === "function") {
-        return 1;
-      } else if (evlistener !== void 0) {
-        return evlistener.length;
-      }
-    }
-    return 0;
-  }
-  EventEmitter.prototype.eventNames = function eventNames() {
-    return this._eventsCount > 0 ? ReflectOwnKeys(this._events) : [];
-  };
-  function arrayClone(arr, n) {
-    var copy = new Array(n);
-    for (var i = 0; i < n; ++i)
-      copy[i] = arr[i];
-    return copy;
-  }
-  function spliceOne(list, index) {
-    for (; index + 1 < list.length; index++)
-      list[index] = list[index + 1];
-    list.pop();
-  }
-  function unwrapListeners(arr) {
-    var ret = new Array(arr.length);
-    for (var i = 0; i < ret.length; ++i) {
-      ret[i] = arr[i].listener || arr[i];
-    }
-    return ret;
-  }
-  function once2(emitter, name) {
-    return new Promise(function(resolve, reject) {
-      function errorListener(err) {
-        emitter.removeListener(name, resolver);
-        reject(err);
-      }
-      function resolver() {
-        if (typeof emitter.removeListener === "function") {
-          emitter.removeListener("error", errorListener);
-        }
-        resolve([].slice.call(arguments));
-      }
-      eventTargetAgnosticAddListener(emitter, name, resolver, { once: true });
-      if (name !== "error") {
-        addErrorHandlerIfEventEmitter(emitter, errorListener, { once: true });
-      }
-    });
-  }
-  function addErrorHandlerIfEventEmitter(emitter, handler, flags) {
-    if (typeof emitter.on === "function") {
-      eventTargetAgnosticAddListener(emitter, "error", handler, flags);
-    }
-  }
-  function eventTargetAgnosticAddListener(emitter, name, listener, flags) {
-    if (typeof emitter.on === "function") {
-      if (flags.once) {
-        emitter.once(name, listener);
-      } else {
-        emitter.on(name, listener);
-      }
-    } else if (typeof emitter.addEventListener === "function") {
-      emitter.addEventListener(name, function wrapListener(arg) {
-        if (flags.once) {
-          emitter.removeEventListener(name, wrapListener);
-        }
-        listener(arg);
-      });
-    } else {
-      throw new TypeError('The "emitter" argument must be of type EventEmitter. Received type ' + typeof emitter);
-    }
-  }
-  return events.exports;
-}
 var streamBrowser;
 var hasRequiredStreamBrowser;
 function requireStreamBrowser() {
   if (hasRequiredStreamBrowser) return streamBrowser;
   hasRequiredStreamBrowser = 1;
-  streamBrowser = requireEvents().EventEmitter;
+  streamBrowser = require$$0$1.EventEmitter;
   return streamBrowser;
 }
 var buffer = {};
@@ -3564,13 +3177,13 @@ function requireBuffer() {
   if (hasRequiredBuffer) return buffer;
   hasRequiredBuffer = 1;
   (function(exports$1) {
-    const base64 = requireBase64Js();
-    const ieee7542 = requireIeee754();
-    const customInspectSymbol = typeof Symbol === "function" && typeof Symbol["for"] === "function" ? Symbol["for"]("nodejs.util.inspect.custom") : null;
+    var base64 = requireBase64Js();
+    var ieee7542 = requireIeee754();
+    var customInspectSymbol = typeof Symbol === "function" && typeof Symbol["for"] === "function" ? Symbol["for"]("nodejs.util.inspect.custom") : null;
     exports$1.Buffer = Buffer2;
     exports$1.SlowBuffer = SlowBuffer;
     exports$1.INSPECT_MAX_BYTES = 50;
-    const K_MAX_LENGTH = 2147483647;
+    var K_MAX_LENGTH = 2147483647;
     exports$1.kMaxLength = K_MAX_LENGTH;
     Buffer2.TYPED_ARRAY_SUPPORT = typedArraySupport();
     if (!Buffer2.TYPED_ARRAY_SUPPORT && typeof console !== "undefined" && typeof console.error === "function") {
@@ -3580,8 +3193,8 @@ function requireBuffer() {
     }
     function typedArraySupport() {
       try {
-        const arr = new Uint8Array(1);
-        const proto = { foo: function() {
+        var arr = new Uint8Array(1);
+        var proto = { foo: function() {
           return 42;
         } };
         Object.setPrototypeOf(proto, Uint8Array.prototype);
@@ -3609,7 +3222,7 @@ function requireBuffer() {
       if (length > K_MAX_LENGTH) {
         throw new RangeError('The value "' + length + '" is invalid for option "size"');
       }
-      const buf = new Uint8Array(length);
+      var buf = new Uint8Array(length);
       Object.setPrototypeOf(buf, Buffer2.prototype);
       return buf;
     }
@@ -3648,14 +3261,18 @@ function requireBuffer() {
           'The "value" argument must not be of type number. Received type number'
         );
       }
-      const valueOf = value.valueOf && value.valueOf();
+      var valueOf = value.valueOf && value.valueOf();
       if (valueOf != null && valueOf !== value) {
         return Buffer2.from(valueOf, encodingOrOffset, length);
       }
-      const b = fromObject(value);
+      var b = fromObject(value);
       if (b) return b;
       if (typeof Symbol !== "undefined" && Symbol.toPrimitive != null && typeof value[Symbol.toPrimitive] === "function") {
-        return Buffer2.from(value[Symbol.toPrimitive]("string"), encodingOrOffset, length);
+        return Buffer2.from(
+          value[Symbol.toPrimitive]("string"),
+          encodingOrOffset,
+          length
+        );
       }
       throw new TypeError(
         "The first argument must be one of type string, Buffer, ArrayBuffer, Array, or Array-like Object. Received type " + typeof value
@@ -3703,25 +3320,25 @@ function requireBuffer() {
       if (!Buffer2.isEncoding(encoding)) {
         throw new TypeError("Unknown encoding: " + encoding);
       }
-      const length = byteLength(string, encoding) | 0;
-      let buf = createBuffer(length);
-      const actual = buf.write(string, encoding);
+      var length = byteLength(string, encoding) | 0;
+      var buf = createBuffer(length);
+      var actual = buf.write(string, encoding);
       if (actual !== length) {
         buf = buf.slice(0, actual);
       }
       return buf;
     }
     function fromArrayLike(array) {
-      const length = array.length < 0 ? 0 : checked(array.length) | 0;
-      const buf = createBuffer(length);
-      for (let i = 0; i < length; i += 1) {
+      var length = array.length < 0 ? 0 : checked(array.length) | 0;
+      var buf = createBuffer(length);
+      for (var i = 0; i < length; i += 1) {
         buf[i] = array[i] & 255;
       }
       return buf;
     }
     function fromArrayView(arrayView) {
       if (isInstance(arrayView, Uint8Array)) {
-        const copy = new Uint8Array(arrayView);
+        var copy = new Uint8Array(arrayView);
         return fromArrayBuffer(copy.buffer, copy.byteOffset, copy.byteLength);
       }
       return fromArrayLike(arrayView);
@@ -3733,7 +3350,7 @@ function requireBuffer() {
       if (array.byteLength < byteOffset + (length || 0)) {
         throw new RangeError('"length" is outside of buffer bounds');
       }
-      let buf;
+      var buf;
       if (byteOffset === void 0 && length === void 0) {
         buf = new Uint8Array(array);
       } else if (length === void 0) {
@@ -3746,8 +3363,8 @@ function requireBuffer() {
     }
     function fromObject(obj) {
       if (Buffer2.isBuffer(obj)) {
-        const len = checked(obj.length) | 0;
-        const buf = createBuffer(len);
+        var len = checked(obj.length) | 0;
+        var buf = createBuffer(len);
         if (buf.length === 0) {
           return buf;
         }
@@ -3788,9 +3405,9 @@ function requireBuffer() {
         );
       }
       if (a === b) return 0;
-      let x = a.length;
-      let y = b.length;
-      for (let i = 0, len = Math.min(x, y); i < len; ++i) {
+      var x = a.length;
+      var y = b.length;
+      for (var i = 0, len = Math.min(x, y); i < len; ++i) {
         if (a[i] !== b[i]) {
           x = a[i];
           y = b[i];
@@ -3826,21 +3443,20 @@ function requireBuffer() {
       if (list.length === 0) {
         return Buffer2.alloc(0);
       }
-      let i;
+      var i;
       if (length === void 0) {
         length = 0;
         for (i = 0; i < list.length; ++i) {
           length += list[i].length;
         }
       }
-      const buffer2 = Buffer2.allocUnsafe(length);
-      let pos = 0;
+      var buffer2 = Buffer2.allocUnsafe(length);
+      var pos = 0;
       for (i = 0; i < list.length; ++i) {
-        let buf = list[i];
+        var buf = list[i];
         if (isInstance(buf, Uint8Array)) {
           if (pos + buf.length > buffer2.length) {
-            if (!Buffer2.isBuffer(buf)) buf = Buffer2.from(buf);
-            buf.copy(buffer2, pos);
+            Buffer2.from(buf).copy(buffer2, pos);
           } else {
             Uint8Array.prototype.set.call(
               buffer2,
@@ -3869,10 +3485,10 @@ function requireBuffer() {
           'The "string" argument must be one of type string, Buffer, or ArrayBuffer. Received type ' + typeof string
         );
       }
-      const len = string.length;
-      const mustMatch = arguments.length > 2 && arguments[2] === true;
+      var len = string.length;
+      var mustMatch = arguments.length > 2 && arguments[2] === true;
       if (!mustMatch && len === 0) return 0;
-      let loweredCase = false;
+      var loweredCase = false;
       for (; ; ) {
         switch (encoding) {
           case "ascii":
@@ -3902,7 +3518,7 @@ function requireBuffer() {
     }
     Buffer2.byteLength = byteLength;
     function slowToString(encoding, start, end) {
-      let loweredCase = false;
+      var loweredCase = false;
       if (start === void 0 || start < 0) {
         start = 0;
       }
@@ -3949,37 +3565,37 @@ function requireBuffer() {
     }
     Buffer2.prototype._isBuffer = true;
     function swap(b, n, m) {
-      const i = b[n];
+      var i = b[n];
       b[n] = b[m];
       b[m] = i;
     }
     Buffer2.prototype.swap16 = function swap16() {
-      const len = this.length;
+      var len = this.length;
       if (len % 2 !== 0) {
         throw new RangeError("Buffer size must be a multiple of 16-bits");
       }
-      for (let i = 0; i < len; i += 2) {
+      for (var i = 0; i < len; i += 2) {
         swap(this, i, i + 1);
       }
       return this;
     };
     Buffer2.prototype.swap32 = function swap32() {
-      const len = this.length;
+      var len = this.length;
       if (len % 4 !== 0) {
         throw new RangeError("Buffer size must be a multiple of 32-bits");
       }
-      for (let i = 0; i < len; i += 4) {
+      for (var i = 0; i < len; i += 4) {
         swap(this, i, i + 3);
         swap(this, i + 1, i + 2);
       }
       return this;
     };
     Buffer2.prototype.swap64 = function swap64() {
-      const len = this.length;
+      var len = this.length;
       if (len % 8 !== 0) {
         throw new RangeError("Buffer size must be a multiple of 64-bits");
       }
-      for (let i = 0; i < len; i += 8) {
+      for (var i = 0; i < len; i += 8) {
         swap(this, i, i + 7);
         swap(this, i + 1, i + 6);
         swap(this, i + 2, i + 5);
@@ -3988,7 +3604,7 @@ function requireBuffer() {
       return this;
     };
     Buffer2.prototype.toString = function toString() {
-      const length = this.length;
+      var length = this.length;
       if (length === 0) return "";
       if (arguments.length === 0) return utf8Slice(this, 0, length);
       return slowToString.apply(this, arguments);
@@ -3999,9 +3615,9 @@ function requireBuffer() {
       if (this === b) return true;
       return Buffer2.compare(this, b) === 0;
     };
-    Buffer2.prototype.inspect = function inspect2() {
-      let str = "";
-      const max = exports$1.INSPECT_MAX_BYTES;
+    Buffer2.prototype.inspect = function inspect() {
+      var str = "";
+      var max = exports$1.INSPECT_MAX_BYTES;
       str = this.toString("hex", 0, max).replace(/(.{2})/g, "$1 ").trim();
       if (this.length > max) str += " ... ";
       return "<Buffer " + str + ">";
@@ -4047,12 +3663,12 @@ function requireBuffer() {
       thisStart >>>= 0;
       thisEnd >>>= 0;
       if (this === target) return 0;
-      let x = thisEnd - thisStart;
-      let y = end - start;
-      const len = Math.min(x, y);
-      const thisCopy = this.slice(thisStart, thisEnd);
-      const targetCopy = target.slice(start, end);
-      for (let i = 0; i < len; ++i) {
+      var x = thisEnd - thisStart;
+      var y = end - start;
+      var len = Math.min(x, y);
+      var thisCopy = this.slice(thisStart, thisEnd);
+      var targetCopy = target.slice(start, end);
+      for (var i = 0; i < len; ++i) {
         if (thisCopy[i] !== targetCopy[i]) {
           x = thisCopy[i];
           y = targetCopy[i];
@@ -4107,9 +3723,9 @@ function requireBuffer() {
       throw new TypeError("val must be string, number or Buffer");
     }
     function arrayIndexOf(arr, val, byteOffset, encoding, dir) {
-      let indexSize = 1;
-      let arrLength = arr.length;
-      let valLength = val.length;
+      var indexSize = 1;
+      var arrLength = arr.length;
+      var valLength = val.length;
       if (encoding !== void 0) {
         encoding = String(encoding).toLowerCase();
         if (encoding === "ucs2" || encoding === "ucs-2" || encoding === "utf16le" || encoding === "utf-16le") {
@@ -4129,9 +3745,9 @@ function requireBuffer() {
           return buf.readUInt16BE(i2 * indexSize);
         }
       }
-      let i;
+      var i;
       if (dir) {
-        let foundIndex = -1;
+        var foundIndex = -1;
         for (i = byteOffset; i < arrLength; i++) {
           if (read(arr, i) === read(val, foundIndex === -1 ? 0 : i - foundIndex)) {
             if (foundIndex === -1) foundIndex = i;
@@ -4144,8 +3760,8 @@ function requireBuffer() {
       } else {
         if (byteOffset + valLength > arrLength) byteOffset = arrLength - valLength;
         for (i = byteOffset; i >= 0; i--) {
-          let found = true;
-          for (let j = 0; j < valLength; j++) {
+          var found = true;
+          for (var j = 0; j < valLength; j++) {
             if (read(arr, i + j) !== read(val, j)) {
               found = false;
               break;
@@ -4167,7 +3783,7 @@ function requireBuffer() {
     };
     function hexWrite(buf, string, offset, length) {
       offset = Number(offset) || 0;
-      const remaining = buf.length - offset;
+      var remaining = buf.length - offset;
       if (!length) {
         length = remaining;
       } else {
@@ -4176,13 +3792,12 @@ function requireBuffer() {
           length = remaining;
         }
       }
-      const strLen = string.length;
+      var strLen = string.length;
       if (length > strLen / 2) {
         length = strLen / 2;
       }
-      let i;
-      for (i = 0; i < length; ++i) {
-        const parsed = parseInt(string.substr(i * 2, 2), 16);
+      for (var i = 0; i < length; ++i) {
+        var parsed = parseInt(string.substr(i * 2, 2), 16);
         if (numberIsNaN(parsed)) return i;
         buf[offset + i] = parsed;
       }
@@ -4223,13 +3838,13 @@ function requireBuffer() {
           "Buffer.write(string, encoding, offset[, length]) is no longer supported"
         );
       }
-      const remaining = this.length - offset;
+      var remaining = this.length - offset;
       if (length === void 0 || length > remaining) length = remaining;
       if (string.length > 0 && (length < 0 || offset < 0) || offset > this.length) {
         throw new RangeError("Attempt to write outside buffer bounds");
       }
       if (!encoding) encoding = "utf8";
-      let loweredCase = false;
+      var loweredCase = false;
       for (; ; ) {
         switch (encoding) {
           case "hex":
@@ -4270,14 +3885,14 @@ function requireBuffer() {
     }
     function utf8Slice(buf, start, end) {
       end = Math.min(buf.length, end);
-      const res = [];
-      let i = start;
+      var res = [];
+      var i = start;
       while (i < end) {
-        const firstByte = buf[i];
-        let codePoint = null;
-        let bytesPerSequence = firstByte > 239 ? 4 : firstByte > 223 ? 3 : firstByte > 191 ? 2 : 1;
+        var firstByte = buf[i];
+        var codePoint = null;
+        var bytesPerSequence = firstByte > 239 ? 4 : firstByte > 223 ? 3 : firstByte > 191 ? 2 : 1;
         if (i + bytesPerSequence <= end) {
-          let secondByte, thirdByte, fourthByte, tempCodePoint;
+          var secondByte, thirdByte, fourthByte, tempCodePoint;
           switch (bytesPerSequence) {
             case 1:
               if (firstByte < 128) {
@@ -4328,14 +3943,14 @@ function requireBuffer() {
       }
       return decodeCodePointsArray(res);
     }
-    const MAX_ARGUMENTS_LENGTH = 4096;
+    var MAX_ARGUMENTS_LENGTH = 4096;
     function decodeCodePointsArray(codePoints) {
-      const len = codePoints.length;
+      var len = codePoints.length;
       if (len <= MAX_ARGUMENTS_LENGTH) {
         return String.fromCharCode.apply(String, codePoints);
       }
-      let res = "";
-      let i = 0;
+      var res = "";
+      var i = 0;
       while (i < len) {
         res += String.fromCharCode.apply(
           String,
@@ -4345,41 +3960,41 @@ function requireBuffer() {
       return res;
     }
     function asciiSlice(buf, start, end) {
-      let ret = "";
+      var ret = "";
       end = Math.min(buf.length, end);
-      for (let i = start; i < end; ++i) {
+      for (var i = start; i < end; ++i) {
         ret += String.fromCharCode(buf[i] & 127);
       }
       return ret;
     }
     function latin1Slice(buf, start, end) {
-      let ret = "";
+      var ret = "";
       end = Math.min(buf.length, end);
-      for (let i = start; i < end; ++i) {
+      for (var i = start; i < end; ++i) {
         ret += String.fromCharCode(buf[i]);
       }
       return ret;
     }
     function hexSlice(buf, start, end) {
-      const len = buf.length;
+      var len = buf.length;
       if (!start || start < 0) start = 0;
       if (!end || end < 0 || end > len) end = len;
-      let out = "";
-      for (let i = start; i < end; ++i) {
+      var out = "";
+      for (var i = start; i < end; ++i) {
         out += hexSliceLookupTable[buf[i]];
       }
       return out;
     }
     function utf16leSlice(buf, start, end) {
-      const bytes = buf.slice(start, end);
-      let res = "";
-      for (let i = 0; i < bytes.length - 1; i += 2) {
+      var bytes = buf.slice(start, end);
+      var res = "";
+      for (var i = 0; i < bytes.length - 1; i += 2) {
         res += String.fromCharCode(bytes[i] + bytes[i + 1] * 256);
       }
       return res;
     }
     Buffer2.prototype.slice = function slice(start, end) {
-      const len = this.length;
+      var len = this.length;
       start = ~~start;
       end = end === void 0 ? len : ~~end;
       if (start < 0) {
@@ -4395,7 +4010,7 @@ function requireBuffer() {
         end = len;
       }
       if (end < start) end = start;
-      const newBuf = this.subarray(start, end);
+      var newBuf = this.subarray(start, end);
       Object.setPrototypeOf(newBuf, Buffer2.prototype);
       return newBuf;
     };
@@ -4407,9 +4022,9 @@ function requireBuffer() {
       offset = offset >>> 0;
       byteLength2 = byteLength2 >>> 0;
       if (!noAssert) checkOffset(offset, byteLength2, this.length);
-      let val = this[offset];
-      let mul = 1;
-      let i = 0;
+      var val = this[offset];
+      var mul = 1;
+      var i = 0;
       while (++i < byteLength2 && (mul *= 256)) {
         val += this[offset + i] * mul;
       }
@@ -4421,8 +4036,8 @@ function requireBuffer() {
       if (!noAssert) {
         checkOffset(offset, byteLength2, this.length);
       }
-      let val = this[offset + --byteLength2];
-      let mul = 1;
+      var val = this[offset + --byteLength2];
+      var mul = 1;
       while (byteLength2 > 0 && (mul *= 256)) {
         val += this[offset + --byteLength2] * mul;
       }
@@ -4453,37 +4068,13 @@ function requireBuffer() {
       if (!noAssert) checkOffset(offset, 4, this.length);
       return this[offset] * 16777216 + (this[offset + 1] << 16 | this[offset + 2] << 8 | this[offset + 3]);
     };
-    Buffer2.prototype.readBigUInt64LE = defineBigIntMethod(function readBigUInt64LE(offset) {
-      offset = offset >>> 0;
-      validateNumber(offset, "offset");
-      const first = this[offset];
-      const last = this[offset + 7];
-      if (first === void 0 || last === void 0) {
-        boundsError(offset, this.length - 8);
-      }
-      const lo = first + this[++offset] * 2 ** 8 + this[++offset] * 2 ** 16 + this[++offset] * 2 ** 24;
-      const hi = this[++offset] + this[++offset] * 2 ** 8 + this[++offset] * 2 ** 16 + last * 2 ** 24;
-      return BigInt(lo) + (BigInt(hi) << BigInt(32));
-    });
-    Buffer2.prototype.readBigUInt64BE = defineBigIntMethod(function readBigUInt64BE(offset) {
-      offset = offset >>> 0;
-      validateNumber(offset, "offset");
-      const first = this[offset];
-      const last = this[offset + 7];
-      if (first === void 0 || last === void 0) {
-        boundsError(offset, this.length - 8);
-      }
-      const hi = first * 2 ** 24 + this[++offset] * 2 ** 16 + this[++offset] * 2 ** 8 + this[++offset];
-      const lo = this[++offset] * 2 ** 24 + this[++offset] * 2 ** 16 + this[++offset] * 2 ** 8 + last;
-      return (BigInt(hi) << BigInt(32)) + BigInt(lo);
-    });
     Buffer2.prototype.readIntLE = function readIntLE(offset, byteLength2, noAssert) {
       offset = offset >>> 0;
       byteLength2 = byteLength2 >>> 0;
       if (!noAssert) checkOffset(offset, byteLength2, this.length);
-      let val = this[offset];
-      let mul = 1;
-      let i = 0;
+      var val = this[offset];
+      var mul = 1;
+      var i = 0;
       while (++i < byteLength2 && (mul *= 256)) {
         val += this[offset + i] * mul;
       }
@@ -4495,9 +4086,9 @@ function requireBuffer() {
       offset = offset >>> 0;
       byteLength2 = byteLength2 >>> 0;
       if (!noAssert) checkOffset(offset, byteLength2, this.length);
-      let i = byteLength2;
-      let mul = 1;
-      let val = this[offset + --i];
+      var i = byteLength2;
+      var mul = 1;
+      var val = this[offset + --i];
       while (i > 0 && (mul *= 256)) {
         val += this[offset + --i] * mul;
       }
@@ -4514,13 +4105,13 @@ function requireBuffer() {
     Buffer2.prototype.readInt16LE = function readInt16LE(offset, noAssert) {
       offset = offset >>> 0;
       if (!noAssert) checkOffset(offset, 2, this.length);
-      const val = this[offset] | this[offset + 1] << 8;
+      var val = this[offset] | this[offset + 1] << 8;
       return val & 32768 ? val | 4294901760 : val;
     };
     Buffer2.prototype.readInt16BE = function readInt16BE(offset, noAssert) {
       offset = offset >>> 0;
       if (!noAssert) checkOffset(offset, 2, this.length);
-      const val = this[offset + 1] | this[offset] << 8;
+      var val = this[offset + 1] | this[offset] << 8;
       return val & 32768 ? val | 4294901760 : val;
     };
     Buffer2.prototype.readInt32LE = function readInt32LE(offset, noAssert) {
@@ -4533,29 +4124,6 @@ function requireBuffer() {
       if (!noAssert) checkOffset(offset, 4, this.length);
       return this[offset] << 24 | this[offset + 1] << 16 | this[offset + 2] << 8 | this[offset + 3];
     };
-    Buffer2.prototype.readBigInt64LE = defineBigIntMethod(function readBigInt64LE(offset) {
-      offset = offset >>> 0;
-      validateNumber(offset, "offset");
-      const first = this[offset];
-      const last = this[offset + 7];
-      if (first === void 0 || last === void 0) {
-        boundsError(offset, this.length - 8);
-      }
-      const val = this[offset + 4] + this[offset + 5] * 2 ** 8 + this[offset + 6] * 2 ** 16 + (last << 24);
-      return (BigInt(val) << BigInt(32)) + BigInt(first + this[++offset] * 2 ** 8 + this[++offset] * 2 ** 16 + this[++offset] * 2 ** 24);
-    });
-    Buffer2.prototype.readBigInt64BE = defineBigIntMethod(function readBigInt64BE(offset) {
-      offset = offset >>> 0;
-      validateNumber(offset, "offset");
-      const first = this[offset];
-      const last = this[offset + 7];
-      if (first === void 0 || last === void 0) {
-        boundsError(offset, this.length - 8);
-      }
-      const val = (first << 24) + // Overflow
-      this[++offset] * 2 ** 16 + this[++offset] * 2 ** 8 + this[++offset];
-      return (BigInt(val) << BigInt(32)) + BigInt(this[++offset] * 2 ** 24 + this[++offset] * 2 ** 16 + this[++offset] * 2 ** 8 + last);
-    });
     Buffer2.prototype.readFloatLE = function readFloatLE(offset, noAssert) {
       offset = offset >>> 0;
       if (!noAssert) checkOffset(offset, 4, this.length);
@@ -4586,11 +4154,11 @@ function requireBuffer() {
       offset = offset >>> 0;
       byteLength2 = byteLength2 >>> 0;
       if (!noAssert) {
-        const maxBytes = Math.pow(2, 8 * byteLength2) - 1;
+        var maxBytes = Math.pow(2, 8 * byteLength2) - 1;
         checkInt(this, value, offset, byteLength2, maxBytes, 0);
       }
-      let mul = 1;
-      let i = 0;
+      var mul = 1;
+      var i = 0;
       this[offset] = value & 255;
       while (++i < byteLength2 && (mul *= 256)) {
         this[offset + i] = value / mul & 255;
@@ -4602,11 +4170,11 @@ function requireBuffer() {
       offset = offset >>> 0;
       byteLength2 = byteLength2 >>> 0;
       if (!noAssert) {
-        const maxBytes = Math.pow(2, 8 * byteLength2) - 1;
+        var maxBytes = Math.pow(2, 8 * byteLength2) - 1;
         checkInt(this, value, offset, byteLength2, maxBytes, 0);
       }
-      let i = byteLength2 - 1;
-      let mul = 1;
+      var i = byteLength2 - 1;
+      var mul = 1;
       this[offset + i] = value & 255;
       while (--i >= 0 && (mul *= 256)) {
         this[offset + i] = value / mul & 255;
@@ -4656,62 +4224,16 @@ function requireBuffer() {
       this[offset + 3] = value & 255;
       return offset + 4;
     };
-    function wrtBigUInt64LE(buf, value, offset, min, max) {
-      checkIntBI(value, min, max, buf, offset, 7);
-      let lo = Number(value & BigInt(4294967295));
-      buf[offset++] = lo;
-      lo = lo >> 8;
-      buf[offset++] = lo;
-      lo = lo >> 8;
-      buf[offset++] = lo;
-      lo = lo >> 8;
-      buf[offset++] = lo;
-      let hi = Number(value >> BigInt(32) & BigInt(4294967295));
-      buf[offset++] = hi;
-      hi = hi >> 8;
-      buf[offset++] = hi;
-      hi = hi >> 8;
-      buf[offset++] = hi;
-      hi = hi >> 8;
-      buf[offset++] = hi;
-      return offset;
-    }
-    function wrtBigUInt64BE(buf, value, offset, min, max) {
-      checkIntBI(value, min, max, buf, offset, 7);
-      let lo = Number(value & BigInt(4294967295));
-      buf[offset + 7] = lo;
-      lo = lo >> 8;
-      buf[offset + 6] = lo;
-      lo = lo >> 8;
-      buf[offset + 5] = lo;
-      lo = lo >> 8;
-      buf[offset + 4] = lo;
-      let hi = Number(value >> BigInt(32) & BigInt(4294967295));
-      buf[offset + 3] = hi;
-      hi = hi >> 8;
-      buf[offset + 2] = hi;
-      hi = hi >> 8;
-      buf[offset + 1] = hi;
-      hi = hi >> 8;
-      buf[offset] = hi;
-      return offset + 8;
-    }
-    Buffer2.prototype.writeBigUInt64LE = defineBigIntMethod(function writeBigUInt64LE(value, offset = 0) {
-      return wrtBigUInt64LE(this, value, offset, BigInt(0), BigInt("0xffffffffffffffff"));
-    });
-    Buffer2.prototype.writeBigUInt64BE = defineBigIntMethod(function writeBigUInt64BE(value, offset = 0) {
-      return wrtBigUInt64BE(this, value, offset, BigInt(0), BigInt("0xffffffffffffffff"));
-    });
     Buffer2.prototype.writeIntLE = function writeIntLE(value, offset, byteLength2, noAssert) {
       value = +value;
       offset = offset >>> 0;
       if (!noAssert) {
-        const limit = Math.pow(2, 8 * byteLength2 - 1);
+        var limit = Math.pow(2, 8 * byteLength2 - 1);
         checkInt(this, value, offset, byteLength2, limit - 1, -limit);
       }
-      let i = 0;
-      let mul = 1;
-      let sub = 0;
+      var i = 0;
+      var mul = 1;
+      var sub = 0;
       this[offset] = value & 255;
       while (++i < byteLength2 && (mul *= 256)) {
         if (value < 0 && sub === 0 && this[offset + i - 1] !== 0) {
@@ -4725,12 +4247,12 @@ function requireBuffer() {
       value = +value;
       offset = offset >>> 0;
       if (!noAssert) {
-        const limit = Math.pow(2, 8 * byteLength2 - 1);
+        var limit = Math.pow(2, 8 * byteLength2 - 1);
         checkInt(this, value, offset, byteLength2, limit - 1, -limit);
       }
-      let i = byteLength2 - 1;
-      let mul = 1;
-      let sub = 0;
+      var i = byteLength2 - 1;
+      var mul = 1;
+      var sub = 0;
       this[offset + i] = value & 255;
       while (--i >= 0 && (mul *= 256)) {
         if (value < 0 && sub === 0 && this[offset + i + 1] !== 0) {
@@ -4785,12 +4307,6 @@ function requireBuffer() {
       this[offset + 3] = value & 255;
       return offset + 4;
     };
-    Buffer2.prototype.writeBigInt64LE = defineBigIntMethod(function writeBigInt64LE(value, offset = 0) {
-      return wrtBigUInt64LE(this, value, offset, -BigInt("0x8000000000000000"), BigInt("0x7fffffffffffffff"));
-    });
-    Buffer2.prototype.writeBigInt64BE = defineBigIntMethod(function writeBigInt64BE(value, offset = 0) {
-      return wrtBigUInt64BE(this, value, offset, -BigInt("0x8000000000000000"), BigInt("0x7fffffffffffffff"));
-    });
     function checkIEEE754(buf, value, offset, ext, max, min) {
       if (offset + ext > buf.length) throw new RangeError("Index out of range");
       if (offset < 0) throw new RangeError("Index out of range");
@@ -4843,7 +4359,7 @@ function requireBuffer() {
       if (target.length - targetStart < end - start) {
         end = target.length - targetStart + start;
       }
-      const len = end - start;
+      var len = end - start;
       if (this === target && typeof Uint8Array.prototype.copyWithin === "function") {
         this.copyWithin(targetStart, start, end);
       } else {
@@ -4872,7 +4388,7 @@ function requireBuffer() {
           throw new TypeError("Unknown encoding: " + encoding);
         }
         if (val.length === 1) {
-          const code = val.charCodeAt(0);
+          var code = val.charCodeAt(0);
           if (encoding === "utf8" && code < 128 || encoding === "latin1") {
             val = code;
           }
@@ -4891,14 +4407,14 @@ function requireBuffer() {
       start = start >>> 0;
       end = end === void 0 ? this.length : end >>> 0;
       if (!val) val = 0;
-      let i;
+      var i;
       if (typeof val === "number") {
         for (i = start; i < end; ++i) {
           this[i] = val;
         }
       } else {
-        const bytes = Buffer2.isBuffer(val) ? val : Buffer2.from(val, encoding);
-        const len = bytes.length;
+        var bytes = Buffer2.isBuffer(val) ? val : Buffer2.from(val, encoding);
+        var len = bytes.length;
         if (len === 0) {
           throw new TypeError('The value "' + val + '" is invalid for argument "value"');
         }
@@ -4908,122 +4424,7 @@ function requireBuffer() {
       }
       return this;
     };
-    const errors2 = {};
-    function E(sym, getMessage, Base) {
-      errors2[sym] = class NodeError extends Base {
-        constructor() {
-          super();
-          Object.defineProperty(this, "message", {
-            value: getMessage.apply(this, arguments),
-            writable: true,
-            configurable: true
-          });
-          this.name = `${this.name} [${sym}]`;
-          this.stack;
-          delete this.name;
-        }
-        get code() {
-          return sym;
-        }
-        set code(value) {
-          Object.defineProperty(this, "code", {
-            configurable: true,
-            enumerable: true,
-            value,
-            writable: true
-          });
-        }
-        toString() {
-          return `${this.name} [${sym}]: ${this.message}`;
-        }
-      };
-    }
-    E(
-      "ERR_BUFFER_OUT_OF_BOUNDS",
-      function(name) {
-        if (name) {
-          return `${name} is outside of buffer bounds`;
-        }
-        return "Attempt to access memory outside buffer bounds";
-      },
-      RangeError
-    );
-    E(
-      "ERR_INVALID_ARG_TYPE",
-      function(name, actual) {
-        return `The "${name}" argument must be of type number. Received type ${typeof actual}`;
-      },
-      TypeError
-    );
-    E(
-      "ERR_OUT_OF_RANGE",
-      function(str, range, input) {
-        let msg = `The value of "${str}" is out of range.`;
-        let received = input;
-        if (Number.isInteger(input) && Math.abs(input) > 2 ** 32) {
-          received = addNumericalSeparator(String(input));
-        } else if (typeof input === "bigint") {
-          received = String(input);
-          if (input > BigInt(2) ** BigInt(32) || input < -(BigInt(2) ** BigInt(32))) {
-            received = addNumericalSeparator(received);
-          }
-          received += "n";
-        }
-        msg += ` It must be ${range}. Received ${received}`;
-        return msg;
-      },
-      RangeError
-    );
-    function addNumericalSeparator(val) {
-      let res = "";
-      let i = val.length;
-      const start = val[0] === "-" ? 1 : 0;
-      for (; i >= start + 4; i -= 3) {
-        res = `_${val.slice(i - 3, i)}${res}`;
-      }
-      return `${val.slice(0, i)}${res}`;
-    }
-    function checkBounds(buf, offset, byteLength2) {
-      validateNumber(offset, "offset");
-      if (buf[offset] === void 0 || buf[offset + byteLength2] === void 0) {
-        boundsError(offset, buf.length - (byteLength2 + 1));
-      }
-    }
-    function checkIntBI(value, min, max, buf, offset, byteLength2) {
-      if (value > max || value < min) {
-        const n = typeof min === "bigint" ? "n" : "";
-        let range;
-        {
-          if (min === 0 || min === BigInt(0)) {
-            range = `>= 0${n} and < 2${n} ** ${(byteLength2 + 1) * 8}${n}`;
-          } else {
-            range = `>= -(2${n} ** ${(byteLength2 + 1) * 8 - 1}${n}) and < 2 ** ${(byteLength2 + 1) * 8 - 1}${n}`;
-          }
-        }
-        throw new errors2.ERR_OUT_OF_RANGE("value", range, value);
-      }
-      checkBounds(buf, offset, byteLength2);
-    }
-    function validateNumber(value, name) {
-      if (typeof value !== "number") {
-        throw new errors2.ERR_INVALID_ARG_TYPE(name, "number", value);
-      }
-    }
-    function boundsError(value, length, type) {
-      if (Math.floor(value) !== value) {
-        validateNumber(value, type);
-        throw new errors2.ERR_OUT_OF_RANGE("offset", "an integer", value);
-      }
-      if (length < 0) {
-        throw new errors2.ERR_BUFFER_OUT_OF_BOUNDS();
-      }
-      throw new errors2.ERR_OUT_OF_RANGE(
-        "offset",
-        `>= ${0} and <= ${length}`,
-        value
-      );
-    }
-    const INVALID_BASE64_RE = /[^+/0-9A-Za-z-_]/g;
+    var INVALID_BASE64_RE = /[^+/0-9A-Za-z-_]/g;
     function base64clean(str) {
       str = str.split("=")[0];
       str = str.trim().replace(INVALID_BASE64_RE, "");
@@ -5035,11 +4436,11 @@ function requireBuffer() {
     }
     function utf8ToBytes(string, units) {
       units = units || Infinity;
-      let codePoint;
-      const length = string.length;
-      let leadSurrogate = null;
-      const bytes = [];
-      for (let i = 0; i < length; ++i) {
+      var codePoint;
+      var length = string.length;
+      var leadSurrogate = null;
+      var bytes = [];
+      for (var i = 0; i < length; ++i) {
         codePoint = string.charCodeAt(i);
         if (codePoint > 55295 && codePoint < 57344) {
           if (!leadSurrogate) {
@@ -5094,16 +4495,16 @@ function requireBuffer() {
       return bytes;
     }
     function asciiToBytes(str) {
-      const byteArray = [];
-      for (let i = 0; i < str.length; ++i) {
+      var byteArray = [];
+      for (var i = 0; i < str.length; ++i) {
         byteArray.push(str.charCodeAt(i) & 255);
       }
       return byteArray;
     }
     function utf16leToBytes(str, units) {
-      let c, hi, lo;
-      const byteArray = [];
-      for (let i = 0; i < str.length; ++i) {
+      var c, hi, lo;
+      var byteArray = [];
+      for (var i = 0; i < str.length; ++i) {
         if ((units -= 2) < 0) break;
         c = str.charCodeAt(i);
         hi = c >> 8;
@@ -5117,8 +4518,7 @@ function requireBuffer() {
       return base64.toByteArray(base64clean(str));
     }
     function blitBuffer(src, dst, offset, length) {
-      let i;
-      for (i = 0; i < length; ++i) {
+      for (var i = 0; i < length; ++i) {
         if (i + offset >= dst.length || i >= src.length) break;
         dst[i + offset] = src[i];
       }
@@ -5130,23 +4530,17 @@ function requireBuffer() {
     function numberIsNaN(obj) {
       return obj !== obj;
     }
-    const hexSliceLookupTable = (function() {
-      const alphabet = "0123456789abcdef";
-      const table = new Array(256);
-      for (let i = 0; i < 16; ++i) {
-        const i16 = i * 16;
-        for (let j = 0; j < 16; ++j) {
+    var hexSliceLookupTable = (function() {
+      var alphabet = "0123456789abcdef";
+      var table = new Array(256);
+      for (var i = 0; i < 16; ++i) {
+        var i16 = i * 16;
+        for (var j = 0; j < 16; ++j) {
           table[i16 + j] = alphabet[i] + alphabet[j];
         }
       }
       return table;
     })();
-    function defineBigIntMethod(fn) {
-      return typeof BigInt === "undefined" ? BufferBigIntNotDefined : fn;
-    }
-    function BufferBigIntNotDefined() {
-      throw new Error("BigInt not supported");
-    }
   })(buffer);
   return buffer;
 }
@@ -5379,7 +4773,7 @@ function requireInherits_browser() {
   if (hasRequiredInherits_browser) return inherits_browser.exports;
   hasRequiredInherits_browser = 1;
   if (typeof Object.create === "function") {
-    inherits_browser.exports = function inherits2(ctor, superCtor) {
+    inherits_browser.exports = function inherits(ctor, superCtor) {
       if (superCtor) {
         ctor.super_ = superCtor;
         ctor.prototype = Object.create(superCtor.prototype, {
@@ -5393,7 +4787,7 @@ function requireInherits_browser() {
       }
     };
   } else {
-    inherits_browser.exports = function inherits2(ctor, superCtor) {
+    inherits_browser.exports = function inherits(ctor, superCtor) {
       if (superCtor) {
         ctor.super_ = superCtor;
         var TempCtor = function() {
@@ -5475,8 +4869,8 @@ function requireBuffer_list() {
     return String(input);
   }
   var _require = requireBuffer(), Buffer2 = _require.Buffer;
-  var _require2 = require$$0$2, inspect2 = _require2.inspect;
-  var custom = inspect2 && inspect2.custom || "inspect";
+  var _require2 = require$$0$2, inspect = _require2.inspect;
+  var custom = inspect && inspect.custom || "inspect";
   function copyBuffer(src, target, offset) {
     Buffer2.prototype.copy.call(src, target, offset);
   }
@@ -5633,7 +5027,7 @@ function requireBuffer_list() {
     }, {
       key: custom,
       value: function value(_, options) {
-        return inspect2(this, _objectSpread(_objectSpread({}, options), {}, {
+        return inspect(this, _objectSpread(_objectSpread({}, options), {}, {
           // Only inspect one level.
           depth: 0,
           // It should not recurse.
@@ -6234,7 +5628,7 @@ function require_stream_readable() {
   _stream_readable = Readable;
   var Duplex;
   Readable.ReadableState = ReadableState;
-  requireEvents().EventEmitter;
+  require$$0$1.EventEmitter;
   var EElistenerCount = function EElistenerCount2(emitter, type) {
     return emitter.listeners(type).length;
   };