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

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

@@ -1,4 +1,4 @@
-import { bh as getAugmentedNamespace, bi as getDefaultExportFromCjs } from "./index-BaR5HKmC.js";
+import { bh as getAugmentedNamespace, bi as getDefaultExportFromCjs } from "./index-DlUHZ9Rv.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";
@@ -3079,12 +3079,380 @@ 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 = require$$0$1.EventEmitter;
+  streamBrowser = requireEvents().EventEmitter;
   return streamBrowser;
 }
 var buffer = {};
@@ -3177,13 +3545,13 @@ function requireBuffer() {
   if (hasRequiredBuffer) return buffer;
   hasRequiredBuffer = 1;
   (function(exports$1) {
-    var base64 = requireBase64Js();
-    var ieee7542 = requireIeee754();
-    var customInspectSymbol = typeof Symbol === "function" && typeof Symbol["for"] === "function" ? Symbol["for"]("nodejs.util.inspect.custom") : null;
+    const base64 = requireBase64Js();
+    const ieee7542 = requireIeee754();
+    const 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;
-    var K_MAX_LENGTH = 2147483647;
+    const 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") {
@@ -3193,8 +3561,8 @@ function requireBuffer() {
     }
     function typedArraySupport() {
       try {
-        var arr = new Uint8Array(1);
-        var proto = { foo: function() {
+        const arr = new Uint8Array(1);
+        const proto = { foo: function() {
           return 42;
         } };
         Object.setPrototypeOf(proto, Uint8Array.prototype);
@@ -3222,7 +3590,7 @@ function requireBuffer() {
       if (length > K_MAX_LENGTH) {
         throw new RangeError('The value "' + length + '" is invalid for option "size"');
       }
-      var buf = new Uint8Array(length);
+      const buf = new Uint8Array(length);
       Object.setPrototypeOf(buf, Buffer2.prototype);
       return buf;
     }
@@ -3261,18 +3629,14 @@ function requireBuffer() {
           'The "value" argument must not be of type number. Received type number'
         );
       }
-      var valueOf = value.valueOf && value.valueOf();
+      const valueOf = value.valueOf && value.valueOf();
       if (valueOf != null && valueOf !== value) {
         return Buffer2.from(valueOf, encodingOrOffset, length);
       }
-      var b = fromObject(value);
+      const 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
@@ -3320,25 +3684,25 @@ function requireBuffer() {
       if (!Buffer2.isEncoding(encoding)) {
         throw new TypeError("Unknown encoding: " + encoding);
       }
-      var length = byteLength(string, encoding) | 0;
-      var buf = createBuffer(length);
-      var actual = buf.write(string, encoding);
+      const length = byteLength(string, encoding) | 0;
+      let buf = createBuffer(length);
+      const actual = buf.write(string, encoding);
       if (actual !== length) {
         buf = buf.slice(0, actual);
       }
       return buf;
     }
     function fromArrayLike(array) {
-      var length = array.length < 0 ? 0 : checked(array.length) | 0;
-      var buf = createBuffer(length);
-      for (var i = 0; i < length; i += 1) {
+      const length = array.length < 0 ? 0 : checked(array.length) | 0;
+      const buf = createBuffer(length);
+      for (let i = 0; i < length; i += 1) {
         buf[i] = array[i] & 255;
       }
       return buf;
     }
     function fromArrayView(arrayView) {
       if (isInstance(arrayView, Uint8Array)) {
-        var copy = new Uint8Array(arrayView);
+        const copy = new Uint8Array(arrayView);
         return fromArrayBuffer(copy.buffer, copy.byteOffset, copy.byteLength);
       }
       return fromArrayLike(arrayView);
@@ -3350,7 +3714,7 @@ function requireBuffer() {
       if (array.byteLength < byteOffset + (length || 0)) {
         throw new RangeError('"length" is outside of buffer bounds');
       }
-      var buf;
+      let buf;
       if (byteOffset === void 0 && length === void 0) {
         buf = new Uint8Array(array);
       } else if (length === void 0) {
@@ -3363,8 +3727,8 @@ function requireBuffer() {
     }
     function fromObject(obj) {
       if (Buffer2.isBuffer(obj)) {
-        var len = checked(obj.length) | 0;
-        var buf = createBuffer(len);
+        const len = checked(obj.length) | 0;
+        const buf = createBuffer(len);
         if (buf.length === 0) {
           return buf;
         }
@@ -3405,9 +3769,9 @@ function requireBuffer() {
         );
       }
       if (a === b) return 0;
-      var x = a.length;
-      var y = b.length;
-      for (var i = 0, len = Math.min(x, y); i < len; ++i) {
+      let x = a.length;
+      let y = b.length;
+      for (let i = 0, len = Math.min(x, y); i < len; ++i) {
         if (a[i] !== b[i]) {
           x = a[i];
           y = b[i];
@@ -3443,20 +3807,21 @@ function requireBuffer() {
       if (list.length === 0) {
         return Buffer2.alloc(0);
       }
-      var i;
+      let i;
       if (length === void 0) {
         length = 0;
         for (i = 0; i < list.length; ++i) {
           length += list[i].length;
         }
       }
-      var buffer2 = Buffer2.allocUnsafe(length);
-      var pos = 0;
+      const buffer2 = Buffer2.allocUnsafe(length);
+      let pos = 0;
       for (i = 0; i < list.length; ++i) {
-        var buf = list[i];
+        let buf = list[i];
         if (isInstance(buf, Uint8Array)) {
           if (pos + buf.length > buffer2.length) {
-            Buffer2.from(buf).copy(buffer2, pos);
+            if (!Buffer2.isBuffer(buf)) buf = Buffer2.from(buf);
+            buf.copy(buffer2, pos);
           } else {
             Uint8Array.prototype.set.call(
               buffer2,
@@ -3485,10 +3850,10 @@ function requireBuffer() {
           'The "string" argument must be one of type string, Buffer, or ArrayBuffer. Received type ' + typeof string
         );
       }
-      var len = string.length;
-      var mustMatch = arguments.length > 2 && arguments[2] === true;
+      const len = string.length;
+      const mustMatch = arguments.length > 2 && arguments[2] === true;
       if (!mustMatch && len === 0) return 0;
-      var loweredCase = false;
+      let loweredCase = false;
       for (; ; ) {
         switch (encoding) {
           case "ascii":
@@ -3518,7 +3883,7 @@ function requireBuffer() {
     }
     Buffer2.byteLength = byteLength;
     function slowToString(encoding, start, end) {
-      var loweredCase = false;
+      let loweredCase = false;
       if (start === void 0 || start < 0) {
         start = 0;
       }
@@ -3565,37 +3930,37 @@ function requireBuffer() {
     }
     Buffer2.prototype._isBuffer = true;
     function swap(b, n, m) {
-      var i = b[n];
+      const i = b[n];
       b[n] = b[m];
       b[m] = i;
     }
     Buffer2.prototype.swap16 = function swap16() {
-      var len = this.length;
+      const len = this.length;
       if (len % 2 !== 0) {
         throw new RangeError("Buffer size must be a multiple of 16-bits");
       }
-      for (var i = 0; i < len; i += 2) {
+      for (let i = 0; i < len; i += 2) {
         swap(this, i, i + 1);
       }
       return this;
     };
     Buffer2.prototype.swap32 = function swap32() {
-      var len = this.length;
+      const len = this.length;
       if (len % 4 !== 0) {
         throw new RangeError("Buffer size must be a multiple of 32-bits");
       }
-      for (var i = 0; i < len; i += 4) {
+      for (let i = 0; i < len; i += 4) {
         swap(this, i, i + 3);
         swap(this, i + 1, i + 2);
       }
       return this;
     };
     Buffer2.prototype.swap64 = function swap64() {
-      var len = this.length;
+      const len = this.length;
       if (len % 8 !== 0) {
         throw new RangeError("Buffer size must be a multiple of 64-bits");
       }
-      for (var i = 0; i < len; i += 8) {
+      for (let i = 0; i < len; i += 8) {
         swap(this, i, i + 7);
         swap(this, i + 1, i + 6);
         swap(this, i + 2, i + 5);
@@ -3604,7 +3969,7 @@ function requireBuffer() {
       return this;
     };
     Buffer2.prototype.toString = function toString() {
-      var length = this.length;
+      const length = this.length;
       if (length === 0) return "";
       if (arguments.length === 0) return utf8Slice(this, 0, length);
       return slowToString.apply(this, arguments);
@@ -3616,8 +3981,8 @@ function requireBuffer() {
       return Buffer2.compare(this, b) === 0;
     };
     Buffer2.prototype.inspect = function inspect() {
-      var str = "";
-      var max = exports$1.INSPECT_MAX_BYTES;
+      let str = "";
+      const 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 + ">";
@@ -3663,12 +4028,12 @@ function requireBuffer() {
       thisStart >>>= 0;
       thisEnd >>>= 0;
       if (this === target) return 0;
-      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) {
+      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) {
         if (thisCopy[i] !== targetCopy[i]) {
           x = thisCopy[i];
           y = targetCopy[i];
@@ -3723,9 +4088,9 @@ function requireBuffer() {
       throw new TypeError("val must be string, number or Buffer");
     }
     function arrayIndexOf(arr, val, byteOffset, encoding, dir) {
-      var indexSize = 1;
-      var arrLength = arr.length;
-      var valLength = val.length;
+      let indexSize = 1;
+      let arrLength = arr.length;
+      let valLength = val.length;
       if (encoding !== void 0) {
         encoding = String(encoding).toLowerCase();
         if (encoding === "ucs2" || encoding === "ucs-2" || encoding === "utf16le" || encoding === "utf-16le") {
@@ -3745,9 +4110,9 @@ function requireBuffer() {
           return buf.readUInt16BE(i2 * indexSize);
         }
       }
-      var i;
+      let i;
       if (dir) {
-        var foundIndex = -1;
+        let foundIndex = -1;
         for (i = byteOffset; i < arrLength; i++) {
           if (read(arr, i) === read(val, foundIndex === -1 ? 0 : i - foundIndex)) {
             if (foundIndex === -1) foundIndex = i;
@@ -3760,8 +4125,8 @@ function requireBuffer() {
       } else {
         if (byteOffset + valLength > arrLength) byteOffset = arrLength - valLength;
         for (i = byteOffset; i >= 0; i--) {
-          var found = true;
-          for (var j = 0; j < valLength; j++) {
+          let found = true;
+          for (let j = 0; j < valLength; j++) {
             if (read(arr, i + j) !== read(val, j)) {
               found = false;
               break;
@@ -3783,7 +4148,7 @@ function requireBuffer() {
     };
     function hexWrite(buf, string, offset, length) {
       offset = Number(offset) || 0;
-      var remaining = buf.length - offset;
+      const remaining = buf.length - offset;
       if (!length) {
         length = remaining;
       } else {
@@ -3792,12 +4157,13 @@ function requireBuffer() {
           length = remaining;
         }
       }
-      var strLen = string.length;
+      const strLen = string.length;
       if (length > strLen / 2) {
         length = strLen / 2;
       }
-      for (var i = 0; i < length; ++i) {
-        var parsed = parseInt(string.substr(i * 2, 2), 16);
+      let i;
+      for (i = 0; i < length; ++i) {
+        const parsed = parseInt(string.substr(i * 2, 2), 16);
         if (numberIsNaN(parsed)) return i;
         buf[offset + i] = parsed;
       }
@@ -3838,13 +4204,13 @@ function requireBuffer() {
           "Buffer.write(string, encoding, offset[, length]) is no longer supported"
         );
       }
-      var remaining = this.length - offset;
+      const 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";
-      var loweredCase = false;
+      let loweredCase = false;
       for (; ; ) {
         switch (encoding) {
           case "hex":
@@ -3885,14 +4251,14 @@ function requireBuffer() {
     }
     function utf8Slice(buf, start, end) {
       end = Math.min(buf.length, end);
-      var res = [];
-      var i = start;
+      const res = [];
+      let i = start;
       while (i < end) {
-        var firstByte = buf[i];
-        var codePoint = null;
-        var bytesPerSequence = firstByte > 239 ? 4 : firstByte > 223 ? 3 : firstByte > 191 ? 2 : 1;
+        const firstByte = buf[i];
+        let codePoint = null;
+        let bytesPerSequence = firstByte > 239 ? 4 : firstByte > 223 ? 3 : firstByte > 191 ? 2 : 1;
         if (i + bytesPerSequence <= end) {
-          var secondByte, thirdByte, fourthByte, tempCodePoint;
+          let secondByte, thirdByte, fourthByte, tempCodePoint;
           switch (bytesPerSequence) {
             case 1:
               if (firstByte < 128) {
@@ -3943,14 +4309,14 @@ function requireBuffer() {
       }
       return decodeCodePointsArray(res);
     }
-    var MAX_ARGUMENTS_LENGTH = 4096;
+    const MAX_ARGUMENTS_LENGTH = 4096;
     function decodeCodePointsArray(codePoints) {
-      var len = codePoints.length;
+      const len = codePoints.length;
       if (len <= MAX_ARGUMENTS_LENGTH) {
         return String.fromCharCode.apply(String, codePoints);
       }
-      var res = "";
-      var i = 0;
+      let res = "";
+      let i = 0;
       while (i < len) {
         res += String.fromCharCode.apply(
           String,
@@ -3960,41 +4326,41 @@ function requireBuffer() {
       return res;
     }
     function asciiSlice(buf, start, end) {
-      var ret = "";
+      let ret = "";
       end = Math.min(buf.length, end);
-      for (var i = start; i < end; ++i) {
+      for (let i = start; i < end; ++i) {
         ret += String.fromCharCode(buf[i] & 127);
       }
       return ret;
     }
     function latin1Slice(buf, start, end) {
-      var ret = "";
+      let ret = "";
       end = Math.min(buf.length, end);
-      for (var i = start; i < end; ++i) {
+      for (let i = start; i < end; ++i) {
         ret += String.fromCharCode(buf[i]);
       }
       return ret;
     }
     function hexSlice(buf, start, end) {
-      var len = buf.length;
+      const len = buf.length;
       if (!start || start < 0) start = 0;
       if (!end || end < 0 || end > len) end = len;
-      var out = "";
-      for (var i = start; i < end; ++i) {
+      let out = "";
+      for (let i = start; i < end; ++i) {
         out += hexSliceLookupTable[buf[i]];
       }
       return out;
     }
     function utf16leSlice(buf, start, end) {
-      var bytes = buf.slice(start, end);
-      var res = "";
-      for (var i = 0; i < bytes.length - 1; i += 2) {
+      const bytes = buf.slice(start, end);
+      let res = "";
+      for (let 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) {
-      var len = this.length;
+      const len = this.length;
       start = ~~start;
       end = end === void 0 ? len : ~~end;
       if (start < 0) {
@@ -4010,7 +4376,7 @@ function requireBuffer() {
         end = len;
       }
       if (end < start) end = start;
-      var newBuf = this.subarray(start, end);
+      const newBuf = this.subarray(start, end);
       Object.setPrototypeOf(newBuf, Buffer2.prototype);
       return newBuf;
     };
@@ -4022,9 +4388,9 @@ function requireBuffer() {
       offset = offset >>> 0;
       byteLength2 = byteLength2 >>> 0;
       if (!noAssert) checkOffset(offset, byteLength2, this.length);
-      var val = this[offset];
-      var mul = 1;
-      var i = 0;
+      let val = this[offset];
+      let mul = 1;
+      let i = 0;
       while (++i < byteLength2 && (mul *= 256)) {
         val += this[offset + i] * mul;
       }
@@ -4036,8 +4402,8 @@ function requireBuffer() {
       if (!noAssert) {
         checkOffset(offset, byteLength2, this.length);
       }
-      var val = this[offset + --byteLength2];
-      var mul = 1;
+      let val = this[offset + --byteLength2];
+      let mul = 1;
       while (byteLength2 > 0 && (mul *= 256)) {
         val += this[offset + --byteLength2] * mul;
       }
@@ -4068,13 +4434,37 @@ 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);
-      var val = this[offset];
-      var mul = 1;
-      var i = 0;
+      let val = this[offset];
+      let mul = 1;
+      let i = 0;
       while (++i < byteLength2 && (mul *= 256)) {
         val += this[offset + i] * mul;
       }
@@ -4086,9 +4476,9 @@ function requireBuffer() {
       offset = offset >>> 0;
       byteLength2 = byteLength2 >>> 0;
       if (!noAssert) checkOffset(offset, byteLength2, this.length);
-      var i = byteLength2;
-      var mul = 1;
-      var val = this[offset + --i];
+      let i = byteLength2;
+      let mul = 1;
+      let val = this[offset + --i];
       while (i > 0 && (mul *= 256)) {
         val += this[offset + --i] * mul;
       }
@@ -4105,13 +4495,13 @@ function requireBuffer() {
     Buffer2.prototype.readInt16LE = function readInt16LE(offset, noAssert) {
       offset = offset >>> 0;
       if (!noAssert) checkOffset(offset, 2, this.length);
-      var val = this[offset] | this[offset + 1] << 8;
+      const 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);
-      var val = this[offset + 1] | this[offset] << 8;
+      const val = this[offset + 1] | this[offset] << 8;
       return val & 32768 ? val | 4294901760 : val;
     };
     Buffer2.prototype.readInt32LE = function readInt32LE(offset, noAssert) {
@@ -4124,6 +4514,29 @@ 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);
@@ -4154,11 +4567,11 @@ function requireBuffer() {
       offset = offset >>> 0;
       byteLength2 = byteLength2 >>> 0;
       if (!noAssert) {
-        var maxBytes = Math.pow(2, 8 * byteLength2) - 1;
+        const maxBytes = Math.pow(2, 8 * byteLength2) - 1;
         checkInt(this, value, offset, byteLength2, maxBytes, 0);
       }
-      var mul = 1;
-      var i = 0;
+      let mul = 1;
+      let i = 0;
       this[offset] = value & 255;
       while (++i < byteLength2 && (mul *= 256)) {
         this[offset + i] = value / mul & 255;
@@ -4170,11 +4583,11 @@ function requireBuffer() {
       offset = offset >>> 0;
       byteLength2 = byteLength2 >>> 0;
       if (!noAssert) {
-        var maxBytes = Math.pow(2, 8 * byteLength2) - 1;
+        const maxBytes = Math.pow(2, 8 * byteLength2) - 1;
         checkInt(this, value, offset, byteLength2, maxBytes, 0);
       }
-      var i = byteLength2 - 1;
-      var mul = 1;
+      let i = byteLength2 - 1;
+      let mul = 1;
       this[offset + i] = value & 255;
       while (--i >= 0 && (mul *= 256)) {
         this[offset + i] = value / mul & 255;
@@ -4224,16 +4637,62 @@ 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) {
-        var limit = Math.pow(2, 8 * byteLength2 - 1);
+        const limit = Math.pow(2, 8 * byteLength2 - 1);
         checkInt(this, value, offset, byteLength2, limit - 1, -limit);
       }
-      var i = 0;
-      var mul = 1;
-      var sub = 0;
+      let i = 0;
+      let mul = 1;
+      let sub = 0;
       this[offset] = value & 255;
       while (++i < byteLength2 && (mul *= 256)) {
         if (value < 0 && sub === 0 && this[offset + i - 1] !== 0) {
@@ -4247,12 +4706,12 @@ function requireBuffer() {
       value = +value;
       offset = offset >>> 0;
       if (!noAssert) {
-        var limit = Math.pow(2, 8 * byteLength2 - 1);
+        const limit = Math.pow(2, 8 * byteLength2 - 1);
         checkInt(this, value, offset, byteLength2, limit - 1, -limit);
       }
-      var i = byteLength2 - 1;
-      var mul = 1;
-      var sub = 0;
+      let i = byteLength2 - 1;
+      let mul = 1;
+      let sub = 0;
       this[offset + i] = value & 255;
       while (--i >= 0 && (mul *= 256)) {
         if (value < 0 && sub === 0 && this[offset + i + 1] !== 0) {
@@ -4307,6 +4766,12 @@ 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");
@@ -4359,7 +4824,7 @@ function requireBuffer() {
       if (target.length - targetStart < end - start) {
         end = target.length - targetStart + start;
       }
-      var len = end - start;
+      const len = end - start;
       if (this === target && typeof Uint8Array.prototype.copyWithin === "function") {
         this.copyWithin(targetStart, start, end);
       } else {
@@ -4388,7 +4853,7 @@ function requireBuffer() {
           throw new TypeError("Unknown encoding: " + encoding);
         }
         if (val.length === 1) {
-          var code = val.charCodeAt(0);
+          const code = val.charCodeAt(0);
           if (encoding === "utf8" && code < 128 || encoding === "latin1") {
             val = code;
           }
@@ -4407,14 +4872,14 @@ function requireBuffer() {
       start = start >>> 0;
       end = end === void 0 ? this.length : end >>> 0;
       if (!val) val = 0;
-      var i;
+      let i;
       if (typeof val === "number") {
         for (i = start; i < end; ++i) {
           this[i] = val;
         }
       } else {
-        var bytes = Buffer2.isBuffer(val) ? val : Buffer2.from(val, encoding);
-        var len = bytes.length;
+        const bytes = Buffer2.isBuffer(val) ? val : Buffer2.from(val, encoding);
+        const len = bytes.length;
         if (len === 0) {
           throw new TypeError('The value "' + val + '" is invalid for argument "value"');
         }
@@ -4424,7 +4889,122 @@ function requireBuffer() {
       }
       return this;
     };
-    var INVALID_BASE64_RE = /[^+/0-9A-Za-z-_]/g;
+    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;
     function base64clean(str) {
       str = str.split("=")[0];
       str = str.trim().replace(INVALID_BASE64_RE, "");
@@ -4436,11 +5016,11 @@ function requireBuffer() {
     }
     function utf8ToBytes(string, units) {
       units = units || Infinity;
-      var codePoint;
-      var length = string.length;
-      var leadSurrogate = null;
-      var bytes = [];
-      for (var i = 0; i < length; ++i) {
+      let codePoint;
+      const length = string.length;
+      let leadSurrogate = null;
+      const bytes = [];
+      for (let i = 0; i < length; ++i) {
         codePoint = string.charCodeAt(i);
         if (codePoint > 55295 && codePoint < 57344) {
           if (!leadSurrogate) {
@@ -4495,16 +5075,16 @@ function requireBuffer() {
       return bytes;
     }
     function asciiToBytes(str) {
-      var byteArray = [];
-      for (var i = 0; i < str.length; ++i) {
+      const byteArray = [];
+      for (let i = 0; i < str.length; ++i) {
         byteArray.push(str.charCodeAt(i) & 255);
       }
       return byteArray;
     }
     function utf16leToBytes(str, units) {
-      var c, hi, lo;
-      var byteArray = [];
-      for (var i = 0; i < str.length; ++i) {
+      let c, hi, lo;
+      const byteArray = [];
+      for (let i = 0; i < str.length; ++i) {
         if ((units -= 2) < 0) break;
         c = str.charCodeAt(i);
         hi = c >> 8;
@@ -4518,7 +5098,8 @@ function requireBuffer() {
       return base64.toByteArray(base64clean(str));
     }
     function blitBuffer(src, dst, offset, length) {
-      for (var i = 0; i < length; ++i) {
+      let i;
+      for (i = 0; i < length; ++i) {
         if (i + offset >= dst.length || i >= src.length) break;
         dst[i + offset] = src[i];
       }
@@ -4530,17 +5111,23 @@ function requireBuffer() {
     function numberIsNaN(obj) {
       return obj !== obj;
     }
-    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) {
+    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) {
           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;
 }
@@ -5628,7 +6215,7 @@ function require_stream_readable() {
   _stream_readable = Readable;
   var Duplex;
   Readable.ReadableState = ReadableState;
-  require$$0$1.EventEmitter;
+  requireEvents().EventEmitter;
   var EElistenerCount = function EElistenerCount2(emitter, type) {
     return emitter.listeners(type).length;
   };