@file-viewer/renderer-data 3.0.3 → 3.1.0

package/dist/vendor/avsc.cjs

@@ -223,13 +223,14 @@ var require_ieee754 = __commonJS({
   }
 });
 
-// ../../../node_modules/.pnpm/buffer@5.2.1/node_modules/buffer/index.js
+// ../../../node_modules/.pnpm/buffer@6.0.3/node_modules/buffer/index.js
 var require_buffer = __commonJS({
-  "../../../node_modules/.pnpm/buffer@5.2.1/node_modules/buffer/index.js"(exports2) {
+  "../../../node_modules/.pnpm/buffer@6.0.3/node_modules/buffer/index.js"(exports2) {
     "use strict";
     init_browser_globals();
     var base64 = require_base64_js();
     var ieee754 = require_ieee754();
+    var customInspectSymbol = typeof Symbol === "function" && typeof Symbol["for"] === "function" ? Symbol["for"]("nodejs.util.inspect.custom") : null;
     exports2.Buffer = Buffer3;
     exports2.SlowBuffer = SlowBuffer;
     exports2.INSPECT_MAX_BYTES = 50;
@@ -243,10 +244,12 @@ var require_buffer = __commonJS({
     }
     function typedArraySupport() {
       try {
-        var arr = new Uint8Array(1);
-        arr.__proto__ = { __proto__: Uint8Array.prototype, foo: function() {
+        const arr = new Uint8Array(1);
+        const proto = { foo: function() {
           return 42;
         } };
+        Object.setPrototypeOf(proto, Uint8Array.prototype);
+        Object.setPrototypeOf(arr, proto);
         return arr.foo() === 42;
       } catch (e) {
         return false;
@@ -270,8 +273,8 @@ var require_buffer = __commonJS({
       if (length > K_MAX_LENGTH) {
         throw new RangeError('The value "' + length + '" is invalid for option "size"');
       }
-      var buf = new Uint8Array(length);
-      buf.__proto__ = Buffer3.prototype;
+      const buf = new Uint8Array(length);
+      Object.setPrototypeOf(buf, Buffer3.prototype);
       return buf;
     }
     function Buffer3(arg, encodingOrOffset, length) {
@@ -285,47 +288,38 @@ var require_buffer = __commonJS({
       }
       return from(arg, encodingOrOffset, length);
     }
-    if (typeof Symbol !== "undefined" && Symbol.species != null && Buffer3[Symbol.species] === Buffer3) {
-      Object.defineProperty(Buffer3, Symbol.species, {
-        value: null,
-        configurable: true,
-        enumerable: false,
-        writable: false
-      });
-    }
     Buffer3.poolSize = 8192;
     function from(value, encodingOrOffset, length) {
       if (typeof value === "string") {
         return fromString(value, encodingOrOffset);
       }
       if (ArrayBuffer.isView(value)) {
-        return fromArrayLike(value);
+        return fromArrayView(value);
       }
       if (value == null) {
-        throw TypeError(
+        throw new TypeError(
           "The first argument must be one of type string, Buffer, ArrayBuffer, Array, or Array-like Object. Received type " + typeof value
         );
       }
       if (isInstance(value, ArrayBuffer) || value && isInstance(value.buffer, ArrayBuffer)) {
         return fromArrayBuffer(value, encodingOrOffset, length);
       }
+      if (typeof SharedArrayBuffer !== "undefined" && (isInstance(value, SharedArrayBuffer) || value && isInstance(value.buffer, SharedArrayBuffer))) {
+        return fromArrayBuffer(value, encodingOrOffset, length);
+      }
       if (typeof value === "number") {
         throw new TypeError(
           '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 Buffer3.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 Buffer3.from(
-          value[Symbol.toPrimitive]("string"),
-          encodingOrOffset,
-          length
-        );
+        return Buffer3.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
@@ -334,8 +328,8 @@ var require_buffer = __commonJS({
     Buffer3.from = function(value, encodingOrOffset, length) {
       return from(value, encodingOrOffset, length);
     };
-    Buffer3.prototype.__proto__ = Uint8Array.prototype;
-    Buffer3.__proto__ = Uint8Array;
+    Object.setPrototypeOf(Buffer3.prototype, Uint8Array.prototype);
+    Object.setPrototypeOf(Buffer3, Uint8Array);
     function assertSize(size) {
       if (typeof size !== "number") {
         throw new TypeError('"size" argument must be of type number');
@@ -373,22 +367,29 @@ var require_buffer = __commonJS({
       if (!Buffer3.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)) {
+        const copy = new Uint8Array(arrayView);
+        return fromArrayBuffer(copy.buffer, copy.byteOffset, copy.byteLength);
+      }
+      return fromArrayLike(arrayView);
+    }
     function fromArrayBuffer(array, byteOffset, length) {
       if (byteOffset < 0 || array.byteLength < byteOffset) {
         throw new RangeError('"offset" is outside of buffer bounds');
@@ -396,7 +397,7 @@ var require_buffer = __commonJS({
       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) {
@@ -404,13 +405,13 @@ var require_buffer = __commonJS({
       } else {
         buf = new Uint8Array(array, byteOffset, length);
       }
-      buf.__proto__ = Buffer3.prototype;
+      Object.setPrototypeOf(buf, Buffer3.prototype);
       return buf;
     }
     function fromObject(obj) {
       if (Buffer3.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;
         }
@@ -451,9 +452,9 @@ var require_buffer = __commonJS({
         );
       }
       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];
@@ -489,24 +490,33 @@ var require_buffer = __commonJS({
       if (list.length === 0) {
         return Buffer3.alloc(0);
       }
-      var i;
+      let i;
       if (length === void 0) {
         length = 0;
         for (i = 0; i < list.length; ++i) {
           length += list[i].length;
         }
       }
-      var buffer = Buffer3.allocUnsafe(length);
-      var pos = 0;
+      const buffer = Buffer3.allocUnsafe(length);
+      let pos = 0;
       for (i = 0; i < list.length; ++i) {
-        var buf = list[i];
+        let buf = list[i];
         if (isInstance(buf, Uint8Array)) {
-          buf = Buffer3.from(buf);
-        }
-        if (!Buffer3.isBuffer(buf)) {
+          if (pos + buf.length > buffer.length) {
+            if (!Buffer3.isBuffer(buf)) buf = Buffer3.from(buf);
+            buf.copy(buffer, pos);
+          } else {
+            Uint8Array.prototype.set.call(
+              buffer,
+              buf,
+              pos
+            );
+          }
+        } else if (!Buffer3.isBuffer(buf)) {
           throw new TypeError('"list" argument must be an Array of Buffers');
+        } else {
+          buf.copy(buffer, pos);
         }
-        buf.copy(buffer, pos);
         pos += buf.length;
       }
       return buffer;
@@ -523,10 +533,10 @@ var require_buffer = __commonJS({
           '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":
@@ -556,7 +566,7 @@ var require_buffer = __commonJS({
     }
     Buffer3.byteLength = byteLength;
     function slowToString(encoding, start, end) {
-      var loweredCase = false;
+      let loweredCase = false;
       if (start === void 0 || start < 0) {
         start = 0;
       }
@@ -603,37 +613,37 @@ var require_buffer = __commonJS({
     }
     Buffer3.prototype._isBuffer = true;
     function swap(b, n, m) {
-      var i = b[n];
+      const i = b[n];
       b[n] = b[m];
       b[m] = i;
     }
     Buffer3.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;
     };
     Buffer3.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;
     };
     Buffer3.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);
@@ -642,7 +652,7 @@ var require_buffer = __commonJS({
       return this;
     };
     Buffer3.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);
@@ -654,12 +664,15 @@ var require_buffer = __commonJS({
       return Buffer3.compare(this, b) === 0;
     };
     Buffer3.prototype.inspect = function inspect() {
-      var str = "";
-      var max = exports2.INSPECT_MAX_BYTES;
+      let str = "";
+      const max = exports2.INSPECT_MAX_BYTES;
       str = this.toString("hex", 0, max).replace(/(.{2})/g, "$1 ").trim();
       if (this.length > max) str += " ... ";
       return "<Buffer " + str + ">";
     };
+    if (customInspectSymbol) {
+      Buffer3.prototype[customInspectSymbol] = Buffer3.prototype.inspect;
+    }
     Buffer3.prototype.compare = function compare(target, start, end, thisStart, thisEnd) {
       if (isInstance(target, Uint8Array)) {
         target = Buffer3.from(target, target.offset, target.byteLength);
@@ -698,12 +711,12 @@ var require_buffer = __commonJS({
       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];
@@ -758,9 +771,9 @@ var require_buffer = __commonJS({
       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") {
@@ -780,9 +793,9 @@ var require_buffer = __commonJS({
           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;
@@ -795,8 +808,8 @@ var require_buffer = __commonJS({
       } 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;
@@ -818,7 +831,7 @@ var require_buffer = __commonJS({
     };
     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 {
@@ -827,12 +840,13 @@ var require_buffer = __commonJS({
           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;
       }
@@ -844,9 +858,6 @@ var require_buffer = __commonJS({
     function asciiWrite(buf, string, offset, length) {
       return blitBuffer(asciiToBytes(string), buf, offset, length);
     }
-    function latin1Write(buf, string, offset, length) {
-      return asciiWrite(buf, string, offset, length);
-    }
     function base64Write(buf, string, offset, length) {
       return blitBuffer(base64ToBytes(string), buf, offset, length);
     }
@@ -876,13 +887,13 @@ var require_buffer = __commonJS({
           "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":
@@ -891,10 +902,9 @@ var require_buffer = __commonJS({
           case "utf-8":
             return utf8Write(this, string, offset, length);
           case "ascii":
-            return asciiWrite(this, string, offset, length);
           case "latin1":
           case "binary":
-            return latin1Write(this, string, offset, length);
+            return asciiWrite(this, string, offset, length);
           case "base64":
             return base64Write(this, string, offset, length);
           case "ucs2":
@@ -924,14 +934,14 @@ var require_buffer = __commonJS({
     }
     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) {
@@ -984,12 +994,12 @@ var require_buffer = __commonJS({
     }
     var 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,
@@ -999,41 +1009,41 @@ var require_buffer = __commonJS({
       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) {
-        out += toHex(buf[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; 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;
     }
     Buffer3.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) {
@@ -1049,71 +1059,95 @@ var require_buffer = __commonJS({
         end = len;
       }
       if (end < start) end = start;
-      var newBuf = this.subarray(start, end);
-      newBuf.__proto__ = Buffer3.prototype;
+      const newBuf = this.subarray(start, end);
+      Object.setPrototypeOf(newBuf, Buffer3.prototype);
       return newBuf;
     };
     function checkOffset(offset, ext, length) {
       if (offset % 1 !== 0 || offset < 0) throw new RangeError("offset is not uint");
       if (offset + ext > length) throw new RangeError("Trying to access beyond buffer length");
     }
-    Buffer3.prototype.readUIntLE = function readUIntLE(offset, byteLength2, noAssert) {
+    Buffer3.prototype.readUintLE = Buffer3.prototype.readUIntLE = function readUIntLE(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;
       }
       return val;
     };
-    Buffer3.prototype.readUIntBE = function readUIntBE(offset, byteLength2, noAssert) {
+    Buffer3.prototype.readUintBE = Buffer3.prototype.readUIntBE = function readUIntBE(offset, byteLength2, noAssert) {
       offset = offset >>> 0;
       byteLength2 = byteLength2 >>> 0;
       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;
       }
       return val;
     };
-    Buffer3.prototype.readUInt8 = function readUInt8(offset, noAssert) {
+    Buffer3.prototype.readUint8 = Buffer3.prototype.readUInt8 = function readUInt8(offset, noAssert) {
       offset = offset >>> 0;
       if (!noAssert) checkOffset(offset, 1, this.length);
       return this[offset];
     };
-    Buffer3.prototype.readUInt16LE = function readUInt16LE(offset, noAssert) {
+    Buffer3.prototype.readUint16LE = Buffer3.prototype.readUInt16LE = function readUInt16LE(offset, noAssert) {
       offset = offset >>> 0;
       if (!noAssert) checkOffset(offset, 2, this.length);
       return this[offset] | this[offset + 1] << 8;
     };
-    Buffer3.prototype.readUInt16BE = function readUInt16BE(offset, noAssert) {
+    Buffer3.prototype.readUint16BE = Buffer3.prototype.readUInt16BE = function readUInt16BE(offset, noAssert) {
       offset = offset >>> 0;
       if (!noAssert) checkOffset(offset, 2, this.length);
       return this[offset] << 8 | this[offset + 1];
     };
-    Buffer3.prototype.readUInt32LE = function readUInt32LE(offset, noAssert) {
+    Buffer3.prototype.readUint32LE = Buffer3.prototype.readUInt32LE = function readUInt32LE(offset, noAssert) {
       offset = offset >>> 0;
       if (!noAssert) checkOffset(offset, 4, this.length);
       return (this[offset] | this[offset + 1] << 8 | this[offset + 2] << 16) + this[offset + 3] * 16777216;
     };
-    Buffer3.prototype.readUInt32BE = function readUInt32BE(offset, noAssert) {
+    Buffer3.prototype.readUint32BE = Buffer3.prototype.readUInt32BE = function readUInt32BE(offset, noAssert) {
       offset = offset >>> 0;
       if (!noAssert) checkOffset(offset, 4, this.length);
       return this[offset] * 16777216 + (this[offset + 1] << 16 | this[offset + 2] << 8 | this[offset + 3]);
     };
+    Buffer3.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));
+    });
+    Buffer3.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);
+    });
     Buffer3.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;
       }
@@ -1125,9 +1159,9 @@ var require_buffer = __commonJS({
       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;
       }
@@ -1144,13 +1178,13 @@ var require_buffer = __commonJS({
     Buffer3.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;
     };
     Buffer3.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;
     };
     Buffer3.prototype.readInt32LE = function readInt32LE(offset, noAssert) {
@@ -1163,6 +1197,29 @@ var require_buffer = __commonJS({
       if (!noAssert) checkOffset(offset, 4, this.length);
       return this[offset] << 24 | this[offset + 1] << 16 | this[offset + 2] << 8 | this[offset + 3];
     };
+    Buffer3.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);
+    });
+    Buffer3.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);
+    });
     Buffer3.prototype.readFloatLE = function readFloatLE(offset, noAssert) {
       offset = offset >>> 0;
       if (!noAssert) checkOffset(offset, 4, this.length);
@@ -1188,46 +1245,46 @@ var require_buffer = __commonJS({
       if (value > max || value < min) throw new RangeError('"value" argument is out of bounds');
       if (offset + ext > buf.length) throw new RangeError("Index out of range");
     }
-    Buffer3.prototype.writeUIntLE = function writeUIntLE(value, offset, byteLength2, noAssert) {
+    Buffer3.prototype.writeUintLE = Buffer3.prototype.writeUIntLE = function writeUIntLE(value, offset, byteLength2, noAssert) {
       value = +value;
       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;
       }
       return offset + byteLength2;
     };
-    Buffer3.prototype.writeUIntBE = function writeUIntBE(value, offset, byteLength2, noAssert) {
+    Buffer3.prototype.writeUintBE = Buffer3.prototype.writeUIntBE = function writeUIntBE(value, offset, byteLength2, noAssert) {
       value = +value;
       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;
       }
       return offset + byteLength2;
     };
-    Buffer3.prototype.writeUInt8 = function writeUInt8(value, offset, noAssert) {
+    Buffer3.prototype.writeUint8 = Buffer3.prototype.writeUInt8 = function writeUInt8(value, offset, noAssert) {
       value = +value;
       offset = offset >>> 0;
       if (!noAssert) checkInt(this, value, offset, 1, 255, 0);
       this[offset] = value & 255;
       return offset + 1;
     };
-    Buffer3.prototype.writeUInt16LE = function writeUInt16LE(value, offset, noAssert) {
+    Buffer3.prototype.writeUint16LE = Buffer3.prototype.writeUInt16LE = function writeUInt16LE(value, offset, noAssert) {
       value = +value;
       offset = offset >>> 0;
       if (!noAssert) checkInt(this, value, offset, 2, 65535, 0);
@@ -1235,7 +1292,7 @@ var require_buffer = __commonJS({
       this[offset + 1] = value >>> 8;
       return offset + 2;
     };
-    Buffer3.prototype.writeUInt16BE = function writeUInt16BE(value, offset, noAssert) {
+    Buffer3.prototype.writeUint16BE = Buffer3.prototype.writeUInt16BE = function writeUInt16BE(value, offset, noAssert) {
       value = +value;
       offset = offset >>> 0;
       if (!noAssert) checkInt(this, value, offset, 2, 65535, 0);
@@ -1243,7 +1300,7 @@ var require_buffer = __commonJS({
       this[offset + 1] = value & 255;
       return offset + 2;
     };
-    Buffer3.prototype.writeUInt32LE = function writeUInt32LE(value, offset, noAssert) {
+    Buffer3.prototype.writeUint32LE = Buffer3.prototype.writeUInt32LE = function writeUInt32LE(value, offset, noAssert) {
       value = +value;
       offset = offset >>> 0;
       if (!noAssert) checkInt(this, value, offset, 4, 4294967295, 0);
@@ -1253,7 +1310,7 @@ var require_buffer = __commonJS({
       this[offset] = value & 255;
       return offset + 4;
     };
-    Buffer3.prototype.writeUInt32BE = function writeUInt32BE(value, offset, noAssert) {
+    Buffer3.prototype.writeUint32BE = Buffer3.prototype.writeUInt32BE = function writeUInt32BE(value, offset, noAssert) {
       value = +value;
       offset = offset >>> 0;
       if (!noAssert) checkInt(this, value, offset, 4, 4294967295, 0);
@@ -1263,16 +1320,62 @@ var require_buffer = __commonJS({
       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;
+    }
+    Buffer3.prototype.writeBigUInt64LE = defineBigIntMethod(function writeBigUInt64LE(value, offset = 0) {
+      return wrtBigUInt64LE(this, value, offset, BigInt(0), BigInt("0xffffffffffffffff"));
+    });
+    Buffer3.prototype.writeBigUInt64BE = defineBigIntMethod(function writeBigUInt64BE(value, offset = 0) {
+      return wrtBigUInt64BE(this, value, offset, BigInt(0), BigInt("0xffffffffffffffff"));
+    });
     Buffer3.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) {
@@ -1286,12 +1389,12 @@ var require_buffer = __commonJS({
       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) {
@@ -1346,6 +1449,12 @@ var require_buffer = __commonJS({
       this[offset + 3] = value & 255;
       return offset + 4;
     };
+    Buffer3.prototype.writeBigInt64LE = defineBigIntMethod(function writeBigInt64LE(value, offset = 0) {
+      return wrtBigUInt64LE(this, value, offset, -BigInt("0x8000000000000000"), BigInt("0x7fffffffffffffff"));
+    });
+    Buffer3.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");
@@ -1398,13 +1507,9 @@ var require_buffer = __commonJS({
       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 if (this === target && start < targetStart && targetStart < end) {
-        for (var i = len - 1; i >= 0; --i) {
-          target[i + targetStart] = this[i + start];
-        }
       } else {
         Uint8Array.prototype.set.call(
           target,
@@ -1431,13 +1536,15 @@ var require_buffer = __commonJS({
           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;
           }
         }
       } else if (typeof val === "number") {
         val = val & 255;
+      } else if (typeof val === "boolean") {
+        val = Number(val);
       }
       if (start < 0 || this.length < start || this.length < end) {
         throw new RangeError("Out of range index");
@@ -1448,14 +1555,14 @@ var require_buffer = __commonJS({
       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 = Buffer3.isBuffer(val) ? val : Buffer3.from(val, encoding);
-        var len = bytes.length;
+        const bytes = Buffer3.isBuffer(val) ? val : Buffer3.from(val, encoding);
+        const len = bytes.length;
         if (len === 0) {
           throw new TypeError('The value "' + val + '" is invalid for argument "value"');
         }
@@ -1465,6 +1572,123 @@ var require_buffer = __commonJS({
       }
       return this;
     };
+    var errors = {};
+    function E(sym, getMessage, Base) {
+      errors[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 (byteLength2 > 3) {
+          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}`;
+          }
+        } else {
+          range = `>= ${min}${n} and <= ${max}${n}`;
+        }
+        throw new errors.ERR_OUT_OF_RANGE("value", range, value);
+      }
+      checkBounds(buf, offset, byteLength2);
+    }
+    function validateNumber(value, name) {
+      if (typeof value !== "number") {
+        throw new errors.ERR_INVALID_ARG_TYPE(name, "number", value);
+      }
+    }
+    function boundsError(value, length, type) {
+      if (Math.floor(value) !== value) {
+        validateNumber(value, type);
+        throw new errors.ERR_OUT_OF_RANGE(type || "offset", "an integer", value);
+      }
+      if (length < 0) {
+        throw new errors.ERR_BUFFER_OUT_OF_BOUNDS();
+      }
+      throw new errors.ERR_OUT_OF_RANGE(
+        type || "offset",
+        `>= ${type ? 1 : 0} and <= ${length}`,
+        value
+      );
+    }
     var INVALID_BASE64_RE = /[^+/0-9A-Za-z-_]/g;
     function base64clean(str) {
       str = str.split("=")[0];
@@ -1475,17 +1699,13 @@ var require_buffer = __commonJS({
       }
       return str;
     }
-    function toHex(n) {
-      if (n < 16) return "0" + n.toString(16);
-      return n.toString(16);
-    }
     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) {
@@ -1540,16 +1760,16 @@ var require_buffer = __commonJS({
       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;
@@ -1563,7 +1783,8 @@ var require_buffer = __commonJS({
       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];
       }
@@ -1575,6 +1796,23 @@ var require_buffer = __commonJS({
     function numberIsNaN(obj) {
       return obj !== obj;
     }
+    var 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");
+    }
   }
 });
 
@@ -9202,9 +9440,9 @@ var require_stream_duplex = __commonJS({
   }
 });
 
-// ../../../node_modules/.pnpm/safe-buffer@5.1.2/node_modules/safe-buffer/index.js
+// ../../../node_modules/.pnpm/safe-buffer@5.2.1/node_modules/safe-buffer/index.js
 var require_safe_buffer = __commonJS({
-  "../../../node_modules/.pnpm/safe-buffer@5.1.2/node_modules/safe-buffer/index.js"(exports2, module2) {
+  "../../../node_modules/.pnpm/safe-buffer@5.2.1/node_modules/safe-buffer/index.js"(exports2, module2) {
     init_browser_globals();
     var buffer = require_buffer();
     var Buffer3 = buffer.Buffer;
@@ -9222,6 +9460,7 @@ var require_safe_buffer = __commonJS({
     function SafeBuffer(arg, encodingOrOffset, length) {
       return Buffer3(arg, encodingOrOffset, length);
     }
+    SafeBuffer.prototype = Object.create(Buffer3.prototype);
     copyProps(Buffer3, SafeBuffer);
     SafeBuffer.from = function(arg, encodingOrOffset, length) {
       if (typeof arg === "number") {
@@ -9260,9 +9499,9 @@ var require_safe_buffer = __commonJS({
   }
 });
 
-// ../../../node_modules/.pnpm/string_decoder@1.1.1/node_modules/string_decoder/lib/string_decoder.js
+// ../../../node_modules/.pnpm/string_decoder@1.3.0/node_modules/string_decoder/lib/string_decoder.js
 var require_string_decoder = __commonJS({
-  "../../../node_modules/.pnpm/string_decoder@1.1.1/node_modules/string_decoder/lib/string_decoder.js"(exports2) {
+  "../../../node_modules/.pnpm/string_decoder@1.3.0/node_modules/string_decoder/lib/string_decoder.js"(exports2) {
     "use strict";
     init_browser_globals();
     var Buffer3 = require_safe_buffer().Buffer;
@@ -13752,124 +13991,866 @@ var require_avsc_services = __commonJS({
   }
 });
 
-// ../../../node_modules/.pnpm/object-keys@1.1.1/node_modules/object-keys/isArguments.js
-var require_isArguments = __commonJS({
-  "../../../node_modules/.pnpm/object-keys@1.1.1/node_modules/object-keys/isArguments.js"(exports2, module2) {
+// ../../../node_modules/.pnpm/assert@2.1.0/node_modules/assert/build/internal/errors.js
+var require_errors = __commonJS({
+  "../../../node_modules/.pnpm/assert@2.1.0/node_modules/assert/build/internal/errors.js"(exports2, module2) {
     "use strict";
     init_browser_globals();
-    var toStr = Object.prototype.toString;
-    module2.exports = function isArguments(value) {
-      var str = toStr.call(value);
-      var isArgs = str === "[object Arguments]";
-      if (!isArgs) {
-        isArgs = str !== "[object Array]" && value !== null && typeof value === "object" && typeof value.length === "number" && value.length >= 0 && toStr.call(value.callee) === "[object Function]";
+    function _typeof(o) {
+      "@babel/helpers - typeof";
+      return _typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function(o2) {
+        return typeof o2;
+      } : function(o2) {
+        return o2 && "function" == typeof Symbol && o2.constructor === Symbol && o2 !== Symbol.prototype ? "symbol" : typeof o2;
+      }, _typeof(o);
+    }
+    function _defineProperties(target, props) {
+      for (var i = 0; i < props.length; i++) {
+        var descriptor = props[i];
+        descriptor.enumerable = descriptor.enumerable || false;
+        descriptor.configurable = true;
+        if ("value" in descriptor) descriptor.writable = true;
+        Object.defineProperty(target, _toPropertyKey(descriptor.key), descriptor);
       }
-      return isArgs;
-    };
-  }
-});
-
-// ../../../node_modules/.pnpm/object-keys@1.1.1/node_modules/object-keys/implementation.js
-var require_implementation2 = __commonJS({
-  "../../../node_modules/.pnpm/object-keys@1.1.1/node_modules/object-keys/implementation.js"(exports2, module2) {
-    "use strict";
-    init_browser_globals();
-    var keysShim;
-    if (!Object.keys) {
-      has = Object.prototype.hasOwnProperty;
-      toStr = Object.prototype.toString;
-      isArgs = require_isArguments();
-      isEnumerable = Object.prototype.propertyIsEnumerable;
-      hasDontEnumBug = !isEnumerable.call({ toString: null }, "toString");
-      hasProtoEnumBug = isEnumerable.call(function() {
-      }, "prototype");
-      dontEnums = [
-        "toString",
-        "toLocaleString",
-        "valueOf",
-        "hasOwnProperty",
-        "isPrototypeOf",
-        "propertyIsEnumerable",
-        "constructor"
-      ];
-      equalsConstructorPrototype = function(o) {
-        var ctor = o.constructor;
-        return ctor && ctor.prototype === o;
-      };
-      excludedKeys = {
-        $applicationCache: true,
-        $console: true,
-        $external: true,
-        $frame: true,
-        $frameElement: true,
-        $frames: true,
-        $innerHeight: true,
-        $innerWidth: true,
-        $onmozfullscreenchange: true,
-        $onmozfullscreenerror: true,
-        $outerHeight: true,
-        $outerWidth: true,
-        $pageXOffset: true,
-        $pageYOffset: true,
-        $parent: true,
-        $scrollLeft: true,
-        $scrollTop: true,
-        $scrollX: true,
-        $scrollY: true,
-        $self: true,
-        $webkitIndexedDB: true,
-        $webkitStorageInfo: true,
-        $window: true
+    }
+    function _createClass(Constructor, protoProps, staticProps) {
+      if (protoProps) _defineProperties(Constructor.prototype, protoProps);
+      if (staticProps) _defineProperties(Constructor, staticProps);
+      Object.defineProperty(Constructor, "prototype", { writable: false });
+      return Constructor;
+    }
+    function _toPropertyKey(arg) {
+      var key = _toPrimitive(arg, "string");
+      return _typeof(key) === "symbol" ? key : String(key);
+    }
+    function _toPrimitive(input, hint) {
+      if (_typeof(input) !== "object" || input === null) return input;
+      var prim = input[Symbol.toPrimitive];
+      if (prim !== void 0) {
+        var res = prim.call(input, hint || "default");
+        if (_typeof(res) !== "object") return res;
+        throw new TypeError("@@toPrimitive must return a primitive value.");
+      }
+      return (hint === "string" ? String : Number)(input);
+    }
+    function _classCallCheck(instance, Constructor) {
+      if (!(instance instanceof Constructor)) {
+        throw new TypeError("Cannot call a class as a function");
+      }
+    }
+    function _inherits(subClass, superClass) {
+      if (typeof superClass !== "function" && superClass !== null) {
+        throw new TypeError("Super expression must either be null or a function");
+      }
+      subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, writable: true, configurable: true } });
+      Object.defineProperty(subClass, "prototype", { writable: false });
+      if (superClass) _setPrototypeOf(subClass, superClass);
+    }
+    function _setPrototypeOf(o, p) {
+      _setPrototypeOf = Object.setPrototypeOf ? Object.setPrototypeOf.bind() : function _setPrototypeOf2(o2, p2) {
+        o2.__proto__ = p2;
+        return o2;
       };
-      hasAutomationEqualityBug = (function() {
-        if (typeof window === "undefined") {
-          return false;
-        }
-        for (var k in window) {
-          try {
-            if (!excludedKeys["$" + k] && has.call(window, k) && window[k] !== null && typeof window[k] === "object") {
-              try {
-                equalsConstructorPrototype(window[k]);
-              } catch (e) {
-                return true;
-              }
-            }
-          } catch (e) {
-            return true;
-          }
+      return _setPrototypeOf(o, p);
+    }
+    function _createSuper(Derived) {
+      var hasNativeReflectConstruct = _isNativeReflectConstruct();
+      return function _createSuperInternal() {
+        var Super = _getPrototypeOf(Derived), result;
+        if (hasNativeReflectConstruct) {
+          var NewTarget = _getPrototypeOf(this).constructor;
+          result = Reflect.construct(Super, arguments, NewTarget);
+        } else {
+          result = Super.apply(this, arguments);
         }
+        return _possibleConstructorReturn(this, result);
+      };
+    }
+    function _possibleConstructorReturn(self2, call) {
+      if (call && (_typeof(call) === "object" || typeof call === "function")) {
+        return call;
+      } else if (call !== void 0) {
+        throw new TypeError("Derived constructors may only return object or undefined");
+      }
+      return _assertThisInitialized(self2);
+    }
+    function _assertThisInitialized(self2) {
+      if (self2 === void 0) {
+        throw new ReferenceError("this hasn't been initialised - super() hasn't been called");
+      }
+      return self2;
+    }
+    function _isNativeReflectConstruct() {
+      if (typeof Reflect === "undefined" || !Reflect.construct) return false;
+      if (Reflect.construct.sham) return false;
+      if (typeof Proxy === "function") return true;
+      try {
+        Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function() {
+        }));
+        return true;
+      } catch (e) {
         return false;
-      })();
-      equalsConstructorPrototypeIfNotBuggy = function(o) {
-        if (typeof window === "undefined" || !hasAutomationEqualityBug) {
-          return equalsConstructorPrototype(o);
-        }
-        try {
-          return equalsConstructorPrototype(o);
-        } catch (e) {
-          return false;
-        }
+      }
+    }
+    function _getPrototypeOf(o) {
+      _getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf.bind() : function _getPrototypeOf2(o2) {
+        return o2.__proto__ || Object.getPrototypeOf(o2);
       };
-      keysShim = function keys(object) {
-        var isObject = object !== null && typeof object === "object";
-        var isFunction = toStr.call(object) === "[object Function]";
-        var isArguments = isArgs(object);
-        var isString = isObject && toStr.call(object) === "[object String]";
-        var theKeys = [];
-        if (!isObject && !isFunction && !isArguments) {
-          throw new TypeError("Object.keys called on a non-object");
+      return _getPrototypeOf(o);
+    }
+    var codes = {};
+    var assert;
+    var util2;
+    function createErrorType(code, message, Base) {
+      if (!Base) {
+        Base = Error;
+      }
+      function getMessage(arg1, arg2, arg3) {
+        if (typeof message === "string") {
+          return message;
+        } else {
+          return message(arg1, arg2, arg3);
         }
-        var skipProto = hasProtoEnumBug && isFunction;
-        if (isString && object.length > 0 && !has.call(object, 0)) {
-          for (var i = 0; i < object.length; ++i) {
-            theKeys.push(String(i));
-          }
+      }
+      var NodeError = /* @__PURE__ */ (function(_Base) {
+        _inherits(NodeError2, _Base);
+        var _super = _createSuper(NodeError2);
+        function NodeError2(arg1, arg2, arg3) {
+          var _this;
+          _classCallCheck(this, NodeError2);
+          _this = _super.call(this, getMessage(arg1, arg2, arg3));
+          _this.code = code;
+          return _this;
         }
-        if (isArguments && object.length > 0) {
-          for (var j = 0; j < object.length; ++j) {
-            theKeys.push(String(j));
-          }
-        } else {
+        return _createClass(NodeError2);
+      })(Base);
+      codes[code] = NodeError;
+    }
+    function oneOf(expected, thing) {
+      if (Array.isArray(expected)) {
+        var len = expected.length;
+        expected = expected.map(function(i) {
+          return String(i);
+        });
+        if (len > 2) {
+          return "one of ".concat(thing, " ").concat(expected.slice(0, len - 1).join(", "), ", or ") + expected[len - 1];
+        } else if (len === 2) {
+          return "one of ".concat(thing, " ").concat(expected[0], " or ").concat(expected[1]);
+        } else {
+          return "of ".concat(thing, " ").concat(expected[0]);
+        }
+      } else {
+        return "of ".concat(thing, " ").concat(String(expected));
+      }
+    }
+    function startsWith(str, search, pos) {
+      return str.substr(!pos || pos < 0 ? 0 : +pos, search.length) === search;
+    }
+    function endsWith(str, search, this_len) {
+      if (this_len === void 0 || this_len > str.length) {
+        this_len = str.length;
+      }
+      return str.substring(this_len - search.length, this_len) === search;
+    }
+    function includes(str, search, start) {
+      if (typeof start !== "number") {
+        start = 0;
+      }
+      if (start + search.length > str.length) {
+        return false;
+      } else {
+        return str.indexOf(search, start) !== -1;
+      }
+    }
+    createErrorType("ERR_AMBIGUOUS_ARGUMENT", 'The "%s" argument is ambiguous. %s', TypeError);
+    createErrorType("ERR_INVALID_ARG_TYPE", function(name, expected, actual) {
+      if (assert === void 0) assert = require_assert();
+      assert(typeof name === "string", "'name' must be a string");
+      var determiner;
+      if (typeof expected === "string" && startsWith(expected, "not ")) {
+        determiner = "must not be";
+        expected = expected.replace(/^not /, "");
+      } else {
+        determiner = "must be";
+      }
+      var msg;
+      if (endsWith(name, " argument")) {
+        msg = "The ".concat(name, " ").concat(determiner, " ").concat(oneOf(expected, "type"));
+      } else {
+        var type = includes(name, ".") ? "property" : "argument";
+        msg = 'The "'.concat(name, '" ').concat(type, " ").concat(determiner, " ").concat(oneOf(expected, "type"));
+      }
+      msg += ". Received type ".concat(_typeof(actual));
+      return msg;
+    }, TypeError);
+    createErrorType("ERR_INVALID_ARG_VALUE", function(name, value) {
+      var reason = arguments.length > 2 && arguments[2] !== void 0 ? arguments[2] : "is invalid";
+      if (util2 === void 0) util2 = require_util();
+      var inspected = util2.inspect(value);
+      if (inspected.length > 128) {
+        inspected = "".concat(inspected.slice(0, 128), "...");
+      }
+      return "The argument '".concat(name, "' ").concat(reason, ". Received ").concat(inspected);
+    }, TypeError, RangeError);
+    createErrorType("ERR_INVALID_RETURN_VALUE", function(input, name, value) {
+      var type;
+      if (value && value.constructor && value.constructor.name) {
+        type = "instance of ".concat(value.constructor.name);
+      } else {
+        type = "type ".concat(_typeof(value));
+      }
+      return "Expected ".concat(input, ' to be returned from the "').concat(name, '"') + " function but got ".concat(type, ".");
+    }, TypeError);
+    createErrorType("ERR_MISSING_ARGS", function() {
+      for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
+        args[_key] = arguments[_key];
+      }
+      if (assert === void 0) assert = require_assert();
+      assert(args.length > 0, "At least one arg needs to be specified");
+      var msg = "The ";
+      var len = args.length;
+      args = args.map(function(a) {
+        return '"'.concat(a, '"');
+      });
+      switch (len) {
+        case 1:
+          msg += "".concat(args[0], " argument");
+          break;
+        case 2:
+          msg += "".concat(args[0], " and ").concat(args[1], " arguments");
+          break;
+        default:
+          msg += args.slice(0, len - 1).join(", ");
+          msg += ", and ".concat(args[len - 1], " arguments");
+          break;
+      }
+      return "".concat(msg, " must be specified");
+    }, TypeError);
+    module2.exports.codes = codes;
+  }
+});
+
+// ../../../node_modules/.pnpm/assert@2.1.0/node_modules/assert/build/internal/assert/assertion_error.js
+var require_assertion_error = __commonJS({
+  "../../../node_modules/.pnpm/assert@2.1.0/node_modules/assert/build/internal/assert/assertion_error.js"(exports2, module2) {
+    "use strict";
+    init_browser_globals();
+    function ownKeys(e, r) {
+      var t = Object.keys(e);
+      if (Object.getOwnPropertySymbols) {
+        var o = Object.getOwnPropertySymbols(e);
+        r && (o = o.filter(function(r2) {
+          return Object.getOwnPropertyDescriptor(e, r2).enumerable;
+        })), t.push.apply(t, o);
+      }
+      return t;
+    }
+    function _objectSpread(e) {
+      for (var r = 1; r < arguments.length; r++) {
+        var t = null != arguments[r] ? arguments[r] : {};
+        r % 2 ? ownKeys(Object(t), true).forEach(function(r2) {
+          _defineProperty(e, r2, t[r2]);
+        }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(e, Object.getOwnPropertyDescriptors(t)) : ownKeys(Object(t)).forEach(function(r2) {
+          Object.defineProperty(e, r2, Object.getOwnPropertyDescriptor(t, r2));
+        });
+      }
+      return e;
+    }
+    function _defineProperty(obj, key, value) {
+      key = _toPropertyKey(key);
+      if (key in obj) {
+        Object.defineProperty(obj, key, { value, enumerable: true, configurable: true, writable: true });
+      } else {
+        obj[key] = value;
+      }
+      return obj;
+    }
+    function _classCallCheck(instance, Constructor) {
+      if (!(instance instanceof Constructor)) {
+        throw new TypeError("Cannot call a class as a function");
+      }
+    }
+    function _defineProperties(target, props) {
+      for (var i = 0; i < props.length; i++) {
+        var descriptor = props[i];
+        descriptor.enumerable = descriptor.enumerable || false;
+        descriptor.configurable = true;
+        if ("value" in descriptor) descriptor.writable = true;
+        Object.defineProperty(target, _toPropertyKey(descriptor.key), descriptor);
+      }
+    }
+    function _createClass(Constructor, protoProps, staticProps) {
+      if (protoProps) _defineProperties(Constructor.prototype, protoProps);
+      if (staticProps) _defineProperties(Constructor, staticProps);
+      Object.defineProperty(Constructor, "prototype", { writable: false });
+      return Constructor;
+    }
+    function _toPropertyKey(arg) {
+      var key = _toPrimitive(arg, "string");
+      return _typeof(key) === "symbol" ? key : String(key);
+    }
+    function _toPrimitive(input, hint) {
+      if (_typeof(input) !== "object" || input === null) return input;
+      var prim = input[Symbol.toPrimitive];
+      if (prim !== void 0) {
+        var res = prim.call(input, hint || "default");
+        if (_typeof(res) !== "object") return res;
+        throw new TypeError("@@toPrimitive must return a primitive value.");
+      }
+      return (hint === "string" ? String : Number)(input);
+    }
+    function _inherits(subClass, superClass) {
+      if (typeof superClass !== "function" && superClass !== null) {
+        throw new TypeError("Super expression must either be null or a function");
+      }
+      subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, writable: true, configurable: true } });
+      Object.defineProperty(subClass, "prototype", { writable: false });
+      if (superClass) _setPrototypeOf(subClass, superClass);
+    }
+    function _createSuper(Derived) {
+      var hasNativeReflectConstruct = _isNativeReflectConstruct();
+      return function _createSuperInternal() {
+        var Super = _getPrototypeOf(Derived), result;
+        if (hasNativeReflectConstruct) {
+          var NewTarget = _getPrototypeOf(this).constructor;
+          result = Reflect.construct(Super, arguments, NewTarget);
+        } else {
+          result = Super.apply(this, arguments);
+        }
+        return _possibleConstructorReturn(this, result);
+      };
+    }
+    function _possibleConstructorReturn(self2, call) {
+      if (call && (_typeof(call) === "object" || typeof call === "function")) {
+        return call;
+      } else if (call !== void 0) {
+        throw new TypeError("Derived constructors may only return object or undefined");
+      }
+      return _assertThisInitialized(self2);
+    }
+    function _assertThisInitialized(self2) {
+      if (self2 === void 0) {
+        throw new ReferenceError("this hasn't been initialised - super() hasn't been called");
+      }
+      return self2;
+    }
+    function _wrapNativeSuper(Class) {
+      var _cache = typeof Map === "function" ? /* @__PURE__ */ new Map() : void 0;
+      _wrapNativeSuper = function _wrapNativeSuper2(Class2) {
+        if (Class2 === null || !_isNativeFunction(Class2)) return Class2;
+        if (typeof Class2 !== "function") {
+          throw new TypeError("Super expression must either be null or a function");
+        }
+        if (typeof _cache !== "undefined") {
+          if (_cache.has(Class2)) return _cache.get(Class2);
+          _cache.set(Class2, Wrapper);
+        }
+        function Wrapper() {
+          return _construct(Class2, arguments, _getPrototypeOf(this).constructor);
+        }
+        Wrapper.prototype = Object.create(Class2.prototype, { constructor: { value: Wrapper, enumerable: false, writable: true, configurable: true } });
+        return _setPrototypeOf(Wrapper, Class2);
+      };
+      return _wrapNativeSuper(Class);
+    }
+    function _construct(Parent, args, Class) {
+      if (_isNativeReflectConstruct()) {
+        _construct = Reflect.construct.bind();
+      } else {
+        _construct = function _construct2(Parent2, args2, Class2) {
+          var a = [null];
+          a.push.apply(a, args2);
+          var Constructor = Function.bind.apply(Parent2, a);
+          var instance = new Constructor();
+          if (Class2) _setPrototypeOf(instance, Class2.prototype);
+          return instance;
+        };
+      }
+      return _construct.apply(null, arguments);
+    }
+    function _isNativeReflectConstruct() {
+      if (typeof Reflect === "undefined" || !Reflect.construct) return false;
+      if (Reflect.construct.sham) return false;
+      if (typeof Proxy === "function") return true;
+      try {
+        Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function() {
+        }));
+        return true;
+      } catch (e) {
+        return false;
+      }
+    }
+    function _isNativeFunction(fn) {
+      return Function.toString.call(fn).indexOf("[native code]") !== -1;
+    }
+    function _setPrototypeOf(o, p) {
+      _setPrototypeOf = Object.setPrototypeOf ? Object.setPrototypeOf.bind() : function _setPrototypeOf2(o2, p2) {
+        o2.__proto__ = p2;
+        return o2;
+      };
+      return _setPrototypeOf(o, p);
+    }
+    function _getPrototypeOf(o) {
+      _getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf.bind() : function _getPrototypeOf2(o2) {
+        return o2.__proto__ || Object.getPrototypeOf(o2);
+      };
+      return _getPrototypeOf(o);
+    }
+    function _typeof(o) {
+      "@babel/helpers - typeof";
+      return _typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function(o2) {
+        return typeof o2;
+      } : function(o2) {
+        return o2 && "function" == typeof Symbol && o2.constructor === Symbol && o2 !== Symbol.prototype ? "symbol" : typeof o2;
+      }, _typeof(o);
+    }
+    var _require = require_util();
+    var inspect = _require.inspect;
+    var _require2 = require_errors();
+    var ERR_INVALID_ARG_TYPE = _require2.codes.ERR_INVALID_ARG_TYPE;
+    function endsWith(str, search, this_len) {
+      if (this_len === void 0 || this_len > str.length) {
+        this_len = str.length;
+      }
+      return str.substring(this_len - search.length, this_len) === search;
+    }
+    function repeat(str, count) {
+      count = Math.floor(count);
+      if (str.length == 0 || count == 0) return "";
+      var maxCount = str.length * count;
+      count = Math.floor(Math.log(count) / Math.log(2));
+      while (count) {
+        str += str;
+        count--;
+      }
+      str += str.substring(0, maxCount - str.length);
+      return str;
+    }
+    var blue = "";
+    var green = "";
+    var red = "";
+    var white = "";
+    var kReadableOperator = {
+      deepStrictEqual: "Expected values to be strictly deep-equal:",
+      strictEqual: "Expected values to be strictly equal:",
+      strictEqualObject: 'Expected "actual" to be reference-equal to "expected":',
+      deepEqual: "Expected values to be loosely deep-equal:",
+      equal: "Expected values to be loosely equal:",
+      notDeepStrictEqual: 'Expected "actual" not to be strictly deep-equal to:',
+      notStrictEqual: 'Expected "actual" to be strictly unequal to:',
+      notStrictEqualObject: 'Expected "actual" not to be reference-equal to "expected":',
+      notDeepEqual: 'Expected "actual" not to be loosely deep-equal to:',
+      notEqual: 'Expected "actual" to be loosely unequal to:',
+      notIdentical: "Values identical but not reference-equal:"
+    };
+    var kMaxShortLength = 10;
+    function copyError(source) {
+      var keys = Object.keys(source);
+      var target = Object.create(Object.getPrototypeOf(source));
+      keys.forEach(function(key) {
+        target[key] = source[key];
+      });
+      Object.defineProperty(target, "message", {
+        value: source.message
+      });
+      return target;
+    }
+    function inspectValue(val) {
+      return inspect(val, {
+        compact: false,
+        customInspect: false,
+        depth: 1e3,
+        maxArrayLength: Infinity,
+        // Assert compares only enumerable properties (with a few exceptions).
+        showHidden: false,
+        // Having a long line as error is better than wrapping the line for
+        // comparison for now.
+        // TODO(BridgeAR): `breakLength` should be limited as soon as soon as we
+        // have meta information about the inspected properties (i.e., know where
+        // in what line the property starts and ends).
+        breakLength: Infinity,
+        // Assert does not detect proxies currently.
+        showProxy: false,
+        sorted: true,
+        // Inspect getters as we also check them when comparing entries.
+        getters: true
+      });
+    }
+    function createErrDiff(actual, expected, operator) {
+      var other = "";
+      var res = "";
+      var lastPos = 0;
+      var end = "";
+      var skipped = false;
+      var actualInspected = inspectValue(actual);
+      var actualLines = actualInspected.split("\n");
+      var expectedLines = inspectValue(expected).split("\n");
+      var i = 0;
+      var indicator = "";
+      if (operator === "strictEqual" && _typeof(actual) === "object" && _typeof(expected) === "object" && actual !== null && expected !== null) {
+        operator = "strictEqualObject";
+      }
+      if (actualLines.length === 1 && expectedLines.length === 1 && actualLines[0] !== expectedLines[0]) {
+        var inputLength = actualLines[0].length + expectedLines[0].length;
+        if (inputLength <= kMaxShortLength) {
+          if ((_typeof(actual) !== "object" || actual === null) && (_typeof(expected) !== "object" || expected === null) && (actual !== 0 || expected !== 0)) {
+            return "".concat(kReadableOperator[operator], "\n\n") + "".concat(actualLines[0], " !== ").concat(expectedLines[0], "\n");
+          }
+        } else if (operator !== "strictEqualObject") {
+          var maxLength = import_browser.default.stderr && import_browser.default.stderr.isTTY ? import_browser.default.stderr.columns : 80;
+          if (inputLength < maxLength) {
+            while (actualLines[0][i] === expectedLines[0][i]) {
+              i++;
+            }
+            if (i > 2) {
+              indicator = "\n  ".concat(repeat(" ", i), "^");
+              i = 0;
+            }
+          }
+        }
+      }
+      var a = actualLines[actualLines.length - 1];
+      var b = expectedLines[expectedLines.length - 1];
+      while (a === b) {
+        if (i++ < 2) {
+          end = "\n  ".concat(a).concat(end);
+        } else {
+          other = a;
+        }
+        actualLines.pop();
+        expectedLines.pop();
+        if (actualLines.length === 0 || expectedLines.length === 0) break;
+        a = actualLines[actualLines.length - 1];
+        b = expectedLines[expectedLines.length - 1];
+      }
+      var maxLines = Math.max(actualLines.length, expectedLines.length);
+      if (maxLines === 0) {
+        var _actualLines = actualInspected.split("\n");
+        if (_actualLines.length > 30) {
+          _actualLines[26] = "".concat(blue, "...").concat(white);
+          while (_actualLines.length > 27) {
+            _actualLines.pop();
+          }
+        }
+        return "".concat(kReadableOperator.notIdentical, "\n\n").concat(_actualLines.join("\n"), "\n");
+      }
+      if (i > 3) {
+        end = "\n".concat(blue, "...").concat(white).concat(end);
+        skipped = true;
+      }
+      if (other !== "") {
+        end = "\n  ".concat(other).concat(end);
+        other = "";
+      }
+      var printedLines = 0;
+      var msg = kReadableOperator[operator] + "\n".concat(green, "+ actual").concat(white, " ").concat(red, "- expected").concat(white);
+      var skippedMsg = " ".concat(blue, "...").concat(white, " Lines skipped");
+      for (i = 0; i < maxLines; i++) {
+        var cur = i - lastPos;
+        if (actualLines.length < i + 1) {
+          if (cur > 1 && i > 2) {
+            if (cur > 4) {
+              res += "\n".concat(blue, "...").concat(white);
+              skipped = true;
+            } else if (cur > 3) {
+              res += "\n  ".concat(expectedLines[i - 2]);
+              printedLines++;
+            }
+            res += "\n  ".concat(expectedLines[i - 1]);
+            printedLines++;
+          }
+          lastPos = i;
+          other += "\n".concat(red, "-").concat(white, " ").concat(expectedLines[i]);
+          printedLines++;
+        } else if (expectedLines.length < i + 1) {
+          if (cur > 1 && i > 2) {
+            if (cur > 4) {
+              res += "\n".concat(blue, "...").concat(white);
+              skipped = true;
+            } else if (cur > 3) {
+              res += "\n  ".concat(actualLines[i - 2]);
+              printedLines++;
+            }
+            res += "\n  ".concat(actualLines[i - 1]);
+            printedLines++;
+          }
+          lastPos = i;
+          res += "\n".concat(green, "+").concat(white, " ").concat(actualLines[i]);
+          printedLines++;
+        } else {
+          var expectedLine = expectedLines[i];
+          var actualLine = actualLines[i];
+          var divergingLines = actualLine !== expectedLine && (!endsWith(actualLine, ",") || actualLine.slice(0, -1) !== expectedLine);
+          if (divergingLines && endsWith(expectedLine, ",") && expectedLine.slice(0, -1) === actualLine) {
+            divergingLines = false;
+            actualLine += ",";
+          }
+          if (divergingLines) {
+            if (cur > 1 && i > 2) {
+              if (cur > 4) {
+                res += "\n".concat(blue, "...").concat(white);
+                skipped = true;
+              } else if (cur > 3) {
+                res += "\n  ".concat(actualLines[i - 2]);
+                printedLines++;
+              }
+              res += "\n  ".concat(actualLines[i - 1]);
+              printedLines++;
+            }
+            lastPos = i;
+            res += "\n".concat(green, "+").concat(white, " ").concat(actualLine);
+            other += "\n".concat(red, "-").concat(white, " ").concat(expectedLine);
+            printedLines += 2;
+          } else {
+            res += other;
+            other = "";
+            if (cur === 1 || i === 0) {
+              res += "\n  ".concat(actualLine);
+              printedLines++;
+            }
+          }
+        }
+        if (printedLines > 20 && i < maxLines - 2) {
+          return "".concat(msg).concat(skippedMsg, "\n").concat(res, "\n").concat(blue, "...").concat(white).concat(other, "\n") + "".concat(blue, "...").concat(white);
+        }
+      }
+      return "".concat(msg).concat(skipped ? skippedMsg : "", "\n").concat(res).concat(other).concat(end).concat(indicator);
+    }
+    var AssertionError = /* @__PURE__ */ (function(_Error, _inspect$custom) {
+      _inherits(AssertionError2, _Error);
+      var _super = _createSuper(AssertionError2);
+      function AssertionError2(options) {
+        var _this;
+        _classCallCheck(this, AssertionError2);
+        if (_typeof(options) !== "object" || options === null) {
+          throw new ERR_INVALID_ARG_TYPE("options", "Object", options);
+        }
+        var message = options.message, operator = options.operator, stackStartFn = options.stackStartFn;
+        var actual = options.actual, expected = options.expected;
+        var limit = Error.stackTraceLimit;
+        Error.stackTraceLimit = 0;
+        if (message != null) {
+          _this = _super.call(this, String(message));
+        } else {
+          if (import_browser.default.stderr && import_browser.default.stderr.isTTY) {
+            if (import_browser.default.stderr && import_browser.default.stderr.getColorDepth && import_browser.default.stderr.getColorDepth() !== 1) {
+              blue = "\x1B[34m";
+              green = "\x1B[32m";
+              white = "\x1B[39m";
+              red = "\x1B[31m";
+            } else {
+              blue = "";
+              green = "";
+              white = "";
+              red = "";
+            }
+          }
+          if (_typeof(actual) === "object" && actual !== null && _typeof(expected) === "object" && expected !== null && "stack" in actual && actual instanceof Error && "stack" in expected && expected instanceof Error) {
+            actual = copyError(actual);
+            expected = copyError(expected);
+          }
+          if (operator === "deepStrictEqual" || operator === "strictEqual") {
+            _this = _super.call(this, createErrDiff(actual, expected, operator));
+          } else if (operator === "notDeepStrictEqual" || operator === "notStrictEqual") {
+            var base = kReadableOperator[operator];
+            var res = inspectValue(actual).split("\n");
+            if (operator === "notStrictEqual" && _typeof(actual) === "object" && actual !== null) {
+              base = kReadableOperator.notStrictEqualObject;
+            }
+            if (res.length > 30) {
+              res[26] = "".concat(blue, "...").concat(white);
+              while (res.length > 27) {
+                res.pop();
+              }
+            }
+            if (res.length === 1) {
+              _this = _super.call(this, "".concat(base, " ").concat(res[0]));
+            } else {
+              _this = _super.call(this, "".concat(base, "\n\n").concat(res.join("\n"), "\n"));
+            }
+          } else {
+            var _res = inspectValue(actual);
+            var other = "";
+            var knownOperators = kReadableOperator[operator];
+            if (operator === "notDeepEqual" || operator === "notEqual") {
+              _res = "".concat(kReadableOperator[operator], "\n\n").concat(_res);
+              if (_res.length > 1024) {
+                _res = "".concat(_res.slice(0, 1021), "...");
+              }
+            } else {
+              other = "".concat(inspectValue(expected));
+              if (_res.length > 512) {
+                _res = "".concat(_res.slice(0, 509), "...");
+              }
+              if (other.length > 512) {
+                other = "".concat(other.slice(0, 509), "...");
+              }
+              if (operator === "deepEqual" || operator === "equal") {
+                _res = "".concat(knownOperators, "\n\n").concat(_res, "\n\nshould equal\n\n");
+              } else {
+                other = " ".concat(operator, " ").concat(other);
+              }
+            }
+            _this = _super.call(this, "".concat(_res).concat(other));
+          }
+        }
+        Error.stackTraceLimit = limit;
+        _this.generatedMessage = !message;
+        Object.defineProperty(_assertThisInitialized(_this), "name", {
+          value: "AssertionError [ERR_ASSERTION]",
+          enumerable: false,
+          writable: true,
+          configurable: true
+        });
+        _this.code = "ERR_ASSERTION";
+        _this.actual = actual;
+        _this.expected = expected;
+        _this.operator = operator;
+        if (Error.captureStackTrace) {
+          Error.captureStackTrace(_assertThisInitialized(_this), stackStartFn);
+        }
+        _this.stack;
+        _this.name = "AssertionError";
+        return _possibleConstructorReturn(_this);
+      }
+      _createClass(AssertionError2, [{
+        key: "toString",
+        value: function toString() {
+          return "".concat(this.name, " [").concat(this.code, "]: ").concat(this.message);
+        }
+      }, {
+        key: _inspect$custom,
+        value: function value(recurseTimes, ctx) {
+          return inspect(this, _objectSpread(_objectSpread({}, ctx), {}, {
+            customInspect: false,
+            depth: 0
+          }));
+        }
+      }]);
+      return AssertionError2;
+    })(/* @__PURE__ */ _wrapNativeSuper(Error), inspect.custom);
+    module2.exports = AssertionError;
+  }
+});
+
+// ../../../node_modules/.pnpm/object-keys@1.1.1/node_modules/object-keys/isArguments.js
+var require_isArguments = __commonJS({
+  "../../../node_modules/.pnpm/object-keys@1.1.1/node_modules/object-keys/isArguments.js"(exports2, module2) {
+    "use strict";
+    init_browser_globals();
+    var toStr = Object.prototype.toString;
+    module2.exports = function isArguments(value) {
+      var str = toStr.call(value);
+      var isArgs = str === "[object Arguments]";
+      if (!isArgs) {
+        isArgs = str !== "[object Array]" && value !== null && typeof value === "object" && typeof value.length === "number" && value.length >= 0 && toStr.call(value.callee) === "[object Function]";
+      }
+      return isArgs;
+    };
+  }
+});
+
+// ../../../node_modules/.pnpm/object-keys@1.1.1/node_modules/object-keys/implementation.js
+var require_implementation2 = __commonJS({
+  "../../../node_modules/.pnpm/object-keys@1.1.1/node_modules/object-keys/implementation.js"(exports2, module2) {
+    "use strict";
+    init_browser_globals();
+    var keysShim;
+    if (!Object.keys) {
+      has = Object.prototype.hasOwnProperty;
+      toStr = Object.prototype.toString;
+      isArgs = require_isArguments();
+      isEnumerable = Object.prototype.propertyIsEnumerable;
+      hasDontEnumBug = !isEnumerable.call({ toString: null }, "toString");
+      hasProtoEnumBug = isEnumerable.call(function() {
+      }, "prototype");
+      dontEnums = [
+        "toString",
+        "toLocaleString",
+        "valueOf",
+        "hasOwnProperty",
+        "isPrototypeOf",
+        "propertyIsEnumerable",
+        "constructor"
+      ];
+      equalsConstructorPrototype = function(o) {
+        var ctor = o.constructor;
+        return ctor && ctor.prototype === o;
+      };
+      excludedKeys = {
+        $applicationCache: true,
+        $console: true,
+        $external: true,
+        $frame: true,
+        $frameElement: true,
+        $frames: true,
+        $innerHeight: true,
+        $innerWidth: true,
+        $onmozfullscreenchange: true,
+        $onmozfullscreenerror: true,
+        $outerHeight: true,
+        $outerWidth: true,
+        $pageXOffset: true,
+        $pageYOffset: true,
+        $parent: true,
+        $scrollLeft: true,
+        $scrollTop: true,
+        $scrollX: true,
+        $scrollY: true,
+        $self: true,
+        $webkitIndexedDB: true,
+        $webkitStorageInfo: true,
+        $window: true
+      };
+      hasAutomationEqualityBug = (function() {
+        if (typeof window === "undefined") {
+          return false;
+        }
+        for (var k in window) {
+          try {
+            if (!excludedKeys["$" + k] && has.call(window, k) && window[k] !== null && typeof window[k] === "object") {
+              try {
+                equalsConstructorPrototype(window[k]);
+              } catch (e) {
+                return true;
+              }
+            }
+          } catch (e) {
+            return true;
+          }
+        }
+        return false;
+      })();
+      equalsConstructorPrototypeIfNotBuggy = function(o) {
+        if (typeof window === "undefined" || !hasAutomationEqualityBug) {
+          return equalsConstructorPrototype(o);
+        }
+        try {
+          return equalsConstructorPrototype(o);
+        } catch (e) {
+          return false;
+        }
+      };
+      keysShim = function keys(object) {
+        var isObject = object !== null && typeof object === "object";
+        var isFunction = toStr.call(object) === "[object Function]";
+        var isArguments = isArgs(object);
+        var isString = isObject && toStr.call(object) === "[object String]";
+        var theKeys = [];
+        if (!isObject && !isFunction && !isArguments) {
+          throw new TypeError("Object.keys called on a non-object");
+        }
+        var skipProto = hasProtoEnumBug && isFunction;
+        if (isString && object.length > 0 && !has.call(object, 0)) {
+          for (var i = 0; i < object.length; ++i) {
+            theKeys.push(String(i));
+          }
+        }
+        if (isArguments && object.length > 0) {
+          for (var j = 0; j < object.length; ++j) {
+            theKeys.push(String(j));
+          }
+        } else {
           for (var name in object) {
             if (!(skipProto && name === "prototype") && has.call(object, name)) {
               theKeys.push(String(name));
@@ -14033,314 +15014,1252 @@ var require_polyfill = __commonJS({
   }
 });
 
-// ../../../node_modules/.pnpm/assert@1.5.1/node_modules/assert/assert.js
-var require_assert = __commonJS({
-  "../../../node_modules/.pnpm/assert@1.5.1/node_modules/assert/assert.js"(exports2, module2) {
+// ../../../node_modules/.pnpm/object-is@1.1.6/node_modules/object-is/implementation.js
+var require_implementation4 = __commonJS({
+  "../../../node_modules/.pnpm/object-is@1.1.6/node_modules/object-is/implementation.js"(exports2, module2) {
     "use strict";
     init_browser_globals();
-    var objectAssign = require_polyfill()();
+    var numberIsNaN = function(value) {
+      return value !== value;
+    };
+    module2.exports = function is(a, b) {
+      if (a === 0 && b === 0) {
+        return 1 / a === 1 / b;
+      }
+      if (a === b) {
+        return true;
+      }
+      if (numberIsNaN(a) && numberIsNaN(b)) {
+        return true;
+      }
+      return false;
+    };
+  }
+});
+
+// ../../../node_modules/.pnpm/object-is@1.1.6/node_modules/object-is/polyfill.js
+var require_polyfill2 = __commonJS({
+  "../../../node_modules/.pnpm/object-is@1.1.6/node_modules/object-is/polyfill.js"(exports2, module2) {
+    "use strict";
+    init_browser_globals();
+    var implementation = require_implementation4();
+    module2.exports = function getPolyfill() {
+      return typeof Object.is === "function" ? Object.is : implementation;
+    };
+  }
+});
+
+// ../../../node_modules/.pnpm/call-bind@1.0.9/node_modules/call-bind/callBound.js
+var require_callBound = __commonJS({
+  "../../../node_modules/.pnpm/call-bind@1.0.9/node_modules/call-bind/callBound.js"(exports2, module2) {
+    "use strict";
+    init_browser_globals();
+    var GetIntrinsic = require_get_intrinsic();
+    var callBind = require_call_bind();
+    var $indexOf = callBind(GetIntrinsic("String.prototype.indexOf"));
+    module2.exports = function callBoundIntrinsic(name, allowMissing) {
+      var intrinsic = GetIntrinsic(name, !!allowMissing);
+      if (typeof intrinsic === "function" && $indexOf(name, ".prototype.") > -1) {
+        return callBind(intrinsic);
+      }
+      return intrinsic;
+    };
+  }
+});
+
+// ../../../node_modules/.pnpm/define-properties@1.2.1/node_modules/define-properties/index.js
+var require_define_properties = __commonJS({
+  "../../../node_modules/.pnpm/define-properties@1.2.1/node_modules/define-properties/index.js"(exports2, module2) {
+    "use strict";
+    init_browser_globals();
+    var keys = require_object_keys();
+    var hasSymbols = typeof Symbol === "function" && typeof /* @__PURE__ */ Symbol("foo") === "symbol";
+    var toStr = Object.prototype.toString;
+    var concat = Array.prototype.concat;
+    var defineDataProperty = require_define_data_property();
+    var isFunction = function(fn) {
+      return typeof fn === "function" && toStr.call(fn) === "[object Function]";
+    };
+    var supportsDescriptors = require_has_property_descriptors()();
+    var defineProperty = function(object, name, value, predicate) {
+      if (name in object) {
+        if (predicate === true) {
+          if (object[name] === value) {
+            return;
+          }
+        } else if (!isFunction(predicate) || !predicate()) {
+          return;
+        }
+      }
+      if (supportsDescriptors) {
+        defineDataProperty(object, name, value, true);
+      } else {
+        defineDataProperty(object, name, value);
+      }
+    };
+    var defineProperties = function(object, map) {
+      var predicates = arguments.length > 2 ? arguments[2] : {};
+      var props = keys(map);
+      if (hasSymbols) {
+        props = concat.call(props, Object.getOwnPropertySymbols(map));
+      }
+      for (var i = 0; i < props.length; i += 1) {
+        defineProperty(object, props[i], map[props[i]], predicates[props[i]]);
+      }
+    };
+    defineProperties.supportsDescriptors = !!supportsDescriptors;
+    module2.exports = defineProperties;
+  }
+});
+
+// ../../../node_modules/.pnpm/object-is@1.1.6/node_modules/object-is/shim.js
+var require_shim = __commonJS({
+  "../../../node_modules/.pnpm/object-is@1.1.6/node_modules/object-is/shim.js"(exports2, module2) {
+    "use strict";
+    init_browser_globals();
+    var getPolyfill = require_polyfill2();
+    var define = require_define_properties();
+    module2.exports = function shimObjectIs() {
+      var polyfill = getPolyfill();
+      define(Object, { is: polyfill }, {
+        is: function testObjectIs() {
+          return Object.is !== polyfill;
+        }
+      });
+      return polyfill;
+    };
+  }
+});
+
+// ../../../node_modules/.pnpm/object-is@1.1.6/node_modules/object-is/index.js
+var require_object_is = __commonJS({
+  "../../../node_modules/.pnpm/object-is@1.1.6/node_modules/object-is/index.js"(exports2, module2) {
+    "use strict";
+    init_browser_globals();
+    var define = require_define_properties();
+    var callBind = require_call_bind();
+    var implementation = require_implementation4();
+    var getPolyfill = require_polyfill2();
+    var shim = require_shim();
+    var polyfill = callBind(getPolyfill(), Object);
+    define(polyfill, {
+      getPolyfill,
+      implementation,
+      shim
+    });
+    module2.exports = polyfill;
+  }
+});
+
+// ../../../node_modules/.pnpm/is-nan@1.3.2/node_modules/is-nan/implementation.js
+var require_implementation5 = __commonJS({
+  "../../../node_modules/.pnpm/is-nan@1.3.2/node_modules/is-nan/implementation.js"(exports2, module2) {
+    "use strict";
+    init_browser_globals();
+    module2.exports = function isNaN2(value) {
+      return value !== value;
+    };
+  }
+});
+
+// ../../../node_modules/.pnpm/is-nan@1.3.2/node_modules/is-nan/polyfill.js
+var require_polyfill3 = __commonJS({
+  "../../../node_modules/.pnpm/is-nan@1.3.2/node_modules/is-nan/polyfill.js"(exports2, module2) {
+    "use strict";
+    init_browser_globals();
+    var implementation = require_implementation5();
+    module2.exports = function getPolyfill() {
+      if (Number.isNaN && Number.isNaN(NaN) && !Number.isNaN("a")) {
+        return Number.isNaN;
+      }
+      return implementation;
+    };
+  }
+});
+
+// ../../../node_modules/.pnpm/is-nan@1.3.2/node_modules/is-nan/shim.js
+var require_shim2 = __commonJS({
+  "../../../node_modules/.pnpm/is-nan@1.3.2/node_modules/is-nan/shim.js"(exports2, module2) {
+    "use strict";
+    init_browser_globals();
+    var define = require_define_properties();
+    var getPolyfill = require_polyfill3();
+    module2.exports = function shimNumberIsNaN() {
+      var polyfill = getPolyfill();
+      define(Number, { isNaN: polyfill }, {
+        isNaN: function testIsNaN() {
+          return Number.isNaN !== polyfill;
+        }
+      });
+      return polyfill;
+    };
+  }
+});
+
+// ../../../node_modules/.pnpm/is-nan@1.3.2/node_modules/is-nan/index.js
+var require_is_nan = __commonJS({
+  "../../../node_modules/.pnpm/is-nan@1.3.2/node_modules/is-nan/index.js"(exports2, module2) {
+    "use strict";
+    init_browser_globals();
+    var callBind = require_call_bind();
+    var define = require_define_properties();
+    var implementation = require_implementation5();
+    var getPolyfill = require_polyfill3();
+    var shim = require_shim2();
+    var polyfill = callBind(getPolyfill(), Number);
+    define(polyfill, {
+      getPolyfill,
+      implementation,
+      shim
+    });
+    module2.exports = polyfill;
+  }
+});
+
+// ../../../node_modules/.pnpm/assert@2.1.0/node_modules/assert/build/internal/util/comparisons.js
+var require_comparisons = __commonJS({
+  "../../../node_modules/.pnpm/assert@2.1.0/node_modules/assert/build/internal/util/comparisons.js"(exports2, module2) {
+    "use strict";
+    init_browser_globals();
+    function _slicedToArray(arr, i) {
+      return _arrayWithHoles(arr) || _iterableToArrayLimit(arr, i) || _unsupportedIterableToArray(arr, i) || _nonIterableRest();
+    }
+    function _nonIterableRest() {
+      throw new TypeError("Invalid attempt to destructure non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
+    }
+    function _unsupportedIterableToArray(o, minLen) {
+      if (!o) return;
+      if (typeof o === "string") return _arrayLikeToArray(o, minLen);
+      var n = Object.prototype.toString.call(o).slice(8, -1);
+      if (n === "Object" && o.constructor) n = o.constructor.name;
+      if (n === "Map" || n === "Set") return Array.from(o);
+      if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen);
+    }
+    function _arrayLikeToArray(arr, len) {
+      if (len == null || len > arr.length) len = arr.length;
+      for (var i = 0, arr2 = new Array(len); i < len; i++) arr2[i] = arr[i];
+      return arr2;
+    }
+    function _iterableToArrayLimit(r, l) {
+      var t = null == r ? null : "undefined" != typeof Symbol && r[Symbol.iterator] || r["@@iterator"];
+      if (null != t) {
+        var e, n, i, u, a = [], f = true, o = false;
+        try {
+          if (i = (t = t.call(r)).next, 0 === l) {
+            if (Object(t) !== t) return;
+            f = false;
+          } else for (; !(f = (e = i.call(t)).done) && (a.push(e.value), a.length !== l); f = true) ;
+        } catch (r2) {
+          o = true, n = r2;
+        } finally {
+          try {
+            if (!f && null != t.return && (u = t.return(), Object(u) !== u)) return;
+          } finally {
+            if (o) throw n;
+          }
+        }
+        return a;
+      }
+    }
+    function _arrayWithHoles(arr) {
+      if (Array.isArray(arr)) return arr;
+    }
+    function _typeof(o) {
+      "@babel/helpers - typeof";
+      return _typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function(o2) {
+        return typeof o2;
+      } : function(o2) {
+        return o2 && "function" == typeof Symbol && o2.constructor === Symbol && o2 !== Symbol.prototype ? "symbol" : typeof o2;
+      }, _typeof(o);
+    }
+    var regexFlagsSupported = /a/g.flags !== void 0;
+    var arrayFromSet = function arrayFromSet2(set) {
+      var array = [];
+      set.forEach(function(value) {
+        return array.push(value);
+      });
+      return array;
+    };
+    var arrayFromMap = function arrayFromMap2(map) {
+      var array = [];
+      map.forEach(function(value, key) {
+        return array.push([key, value]);
+      });
+      return array;
+    };
+    var objectIs = Object.is ? Object.is : require_object_is();
+    var objectGetOwnPropertySymbols = Object.getOwnPropertySymbols ? Object.getOwnPropertySymbols : function() {
+      return [];
+    };
+    var numberIsNaN = Number.isNaN ? Number.isNaN : require_is_nan();
+    function uncurryThis(f) {
+      return f.call.bind(f);
+    }
+    var hasOwnProperty = uncurryThis(Object.prototype.hasOwnProperty);
+    var propertyIsEnumerable = uncurryThis(Object.prototype.propertyIsEnumerable);
+    var objectToString = uncurryThis(Object.prototype.toString);
+    var _require$types = require_util().types;
+    var isAnyArrayBuffer = _require$types.isAnyArrayBuffer;
+    var isArrayBufferView = _require$types.isArrayBufferView;
+    var isDate = _require$types.isDate;
+    var isMap = _require$types.isMap;
+    var isRegExp = _require$types.isRegExp;
+    var isSet = _require$types.isSet;
+    var isNativeError = _require$types.isNativeError;
+    var isBoxedPrimitive = _require$types.isBoxedPrimitive;
+    var isNumberObject = _require$types.isNumberObject;
+    var isStringObject = _require$types.isStringObject;
+    var isBooleanObject = _require$types.isBooleanObject;
+    var isBigIntObject = _require$types.isBigIntObject;
+    var isSymbolObject = _require$types.isSymbolObject;
+    var isFloat32Array = _require$types.isFloat32Array;
+    var isFloat64Array = _require$types.isFloat64Array;
+    function isNonIndex(key) {
+      if (key.length === 0 || key.length > 10) return true;
+      for (var i = 0; i < key.length; i++) {
+        var code = key.charCodeAt(i);
+        if (code < 48 || code > 57) return true;
+      }
+      return key.length === 10 && key >= Math.pow(2, 32);
+    }
+    function getOwnNonIndexProperties(value) {
+      return Object.keys(value).filter(isNonIndex).concat(objectGetOwnPropertySymbols(value).filter(Object.prototype.propertyIsEnumerable.bind(value)));
+    }
     function compare(a, b) {
       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) {
-        if (a[i] !== b[i]) {
-          x = a[i];
-          y = b[i];
-          break;
+      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];
+          break;
+        }
+      }
+      if (x < y) {
+        return -1;
+      }
+      if (y < x) {
+        return 1;
+      }
+      return 0;
+    }
+    var ONLY_ENUMERABLE = void 0;
+    var kStrict = true;
+    var kLoose = false;
+    var kNoIterator = 0;
+    var kIsArray = 1;
+    var kIsSet = 2;
+    var kIsMap = 3;
+    function areSimilarRegExps(a, b) {
+      return regexFlagsSupported ? a.source === b.source && a.flags === b.flags : RegExp.prototype.toString.call(a) === RegExp.prototype.toString.call(b);
+    }
+    function areSimilarFloatArrays(a, b) {
+      if (a.byteLength !== b.byteLength) {
+        return false;
+      }
+      for (var offset = 0; offset < a.byteLength; offset++) {
+        if (a[offset] !== b[offset]) {
+          return false;
+        }
+      }
+      return true;
+    }
+    function areSimilarTypedArrays(a, b) {
+      if (a.byteLength !== b.byteLength) {
+        return false;
+      }
+      return compare(new Uint8Array(a.buffer, a.byteOffset, a.byteLength), new Uint8Array(b.buffer, b.byteOffset, b.byteLength)) === 0;
+    }
+    function areEqualArrayBuffers(buf1, buf2) {
+      return buf1.byteLength === buf2.byteLength && compare(new Uint8Array(buf1), new Uint8Array(buf2)) === 0;
+    }
+    function isEqualBoxedPrimitive(val1, val2) {
+      if (isNumberObject(val1)) {
+        return isNumberObject(val2) && objectIs(Number.prototype.valueOf.call(val1), Number.prototype.valueOf.call(val2));
+      }
+      if (isStringObject(val1)) {
+        return isStringObject(val2) && String.prototype.valueOf.call(val1) === String.prototype.valueOf.call(val2);
+      }
+      if (isBooleanObject(val1)) {
+        return isBooleanObject(val2) && Boolean.prototype.valueOf.call(val1) === Boolean.prototype.valueOf.call(val2);
+      }
+      if (isBigIntObject(val1)) {
+        return isBigIntObject(val2) && BigInt.prototype.valueOf.call(val1) === BigInt.prototype.valueOf.call(val2);
+      }
+      return isSymbolObject(val2) && Symbol.prototype.valueOf.call(val1) === Symbol.prototype.valueOf.call(val2);
+    }
+    function innerDeepEqual(val1, val2, strict, memos) {
+      if (val1 === val2) {
+        if (val1 !== 0) return true;
+        return strict ? objectIs(val1, val2) : true;
+      }
+      if (strict) {
+        if (_typeof(val1) !== "object") {
+          return typeof val1 === "number" && numberIsNaN(val1) && numberIsNaN(val2);
+        }
+        if (_typeof(val2) !== "object" || val1 === null || val2 === null) {
+          return false;
+        }
+        if (Object.getPrototypeOf(val1) !== Object.getPrototypeOf(val2)) {
+          return false;
+        }
+      } else {
+        if (val1 === null || _typeof(val1) !== "object") {
+          if (val2 === null || _typeof(val2) !== "object") {
+            return val1 == val2;
+          }
+          return false;
+        }
+        if (val2 === null || _typeof(val2) !== "object") {
+          return false;
+        }
+      }
+      var val1Tag = objectToString(val1);
+      var val2Tag = objectToString(val2);
+      if (val1Tag !== val2Tag) {
+        return false;
+      }
+      if (Array.isArray(val1)) {
+        if (val1.length !== val2.length) {
+          return false;
+        }
+        var keys1 = getOwnNonIndexProperties(val1, ONLY_ENUMERABLE);
+        var keys2 = getOwnNonIndexProperties(val2, ONLY_ENUMERABLE);
+        if (keys1.length !== keys2.length) {
+          return false;
+        }
+        return keyCheck(val1, val2, strict, memos, kIsArray, keys1);
+      }
+      if (val1Tag === "[object Object]") {
+        if (!isMap(val1) && isMap(val2) || !isSet(val1) && isSet(val2)) {
+          return false;
+        }
+      }
+      if (isDate(val1)) {
+        if (!isDate(val2) || Date.prototype.getTime.call(val1) !== Date.prototype.getTime.call(val2)) {
+          return false;
+        }
+      } else if (isRegExp(val1)) {
+        if (!isRegExp(val2) || !areSimilarRegExps(val1, val2)) {
+          return false;
+        }
+      } else if (isNativeError(val1) || val1 instanceof Error) {
+        if (val1.message !== val2.message || val1.name !== val2.name) {
+          return false;
+        }
+      } else if (isArrayBufferView(val1)) {
+        if (!strict && (isFloat32Array(val1) || isFloat64Array(val1))) {
+          if (!areSimilarFloatArrays(val1, val2)) {
+            return false;
+          }
+        } else if (!areSimilarTypedArrays(val1, val2)) {
+          return false;
+        }
+        var _keys = getOwnNonIndexProperties(val1, ONLY_ENUMERABLE);
+        var _keys2 = getOwnNonIndexProperties(val2, ONLY_ENUMERABLE);
+        if (_keys.length !== _keys2.length) {
+          return false;
+        }
+        return keyCheck(val1, val2, strict, memos, kNoIterator, _keys);
+      } else if (isSet(val1)) {
+        if (!isSet(val2) || val1.size !== val2.size) {
+          return false;
+        }
+        return keyCheck(val1, val2, strict, memos, kIsSet);
+      } else if (isMap(val1)) {
+        if (!isMap(val2) || val1.size !== val2.size) {
+          return false;
+        }
+        return keyCheck(val1, val2, strict, memos, kIsMap);
+      } else if (isAnyArrayBuffer(val1)) {
+        if (!areEqualArrayBuffers(val1, val2)) {
+          return false;
+        }
+      } else if (isBoxedPrimitive(val1) && !isEqualBoxedPrimitive(val1, val2)) {
+        return false;
+      }
+      return keyCheck(val1, val2, strict, memos, kNoIterator);
+    }
+    function getEnumerables(val, keys) {
+      return keys.filter(function(k) {
+        return propertyIsEnumerable(val, k);
+      });
+    }
+    function keyCheck(val1, val2, strict, memos, iterationType, aKeys) {
+      if (arguments.length === 5) {
+        aKeys = Object.keys(val1);
+        var bKeys = Object.keys(val2);
+        if (aKeys.length !== bKeys.length) {
+          return false;
+        }
+      }
+      var i = 0;
+      for (; i < aKeys.length; i++) {
+        if (!hasOwnProperty(val2, aKeys[i])) {
+          return false;
+        }
+      }
+      if (strict && arguments.length === 5) {
+        var symbolKeysA = objectGetOwnPropertySymbols(val1);
+        if (symbolKeysA.length !== 0) {
+          var count = 0;
+          for (i = 0; i < symbolKeysA.length; i++) {
+            var key = symbolKeysA[i];
+            if (propertyIsEnumerable(val1, key)) {
+              if (!propertyIsEnumerable(val2, key)) {
+                return false;
+              }
+              aKeys.push(key);
+              count++;
+            } else if (propertyIsEnumerable(val2, key)) {
+              return false;
+            }
+          }
+          var symbolKeysB = objectGetOwnPropertySymbols(val2);
+          if (symbolKeysA.length !== symbolKeysB.length && getEnumerables(val2, symbolKeysB).length !== count) {
+            return false;
+          }
+        } else {
+          var _symbolKeysB = objectGetOwnPropertySymbols(val2);
+          if (_symbolKeysB.length !== 0 && getEnumerables(val2, _symbolKeysB).length !== 0) {
+            return false;
+          }
         }
       }
-      if (x < y) {
-        return -1;
+      if (aKeys.length === 0 && (iterationType === kNoIterator || iterationType === kIsArray && val1.length === 0 || val1.size === 0)) {
+        return true;
       }
-      if (y < x) {
-        return 1;
+      if (memos === void 0) {
+        memos = {
+          val1: /* @__PURE__ */ new Map(),
+          val2: /* @__PURE__ */ new Map(),
+          position: 0
+        };
+      } else {
+        var val2MemoA = memos.val1.get(val1);
+        if (val2MemoA !== void 0) {
+          var val2MemoB = memos.val2.get(val2);
+          if (val2MemoB !== void 0) {
+            return val2MemoA === val2MemoB;
+          }
+        }
+        memos.position++;
+      }
+      memos.val1.set(val1, memos.position);
+      memos.val2.set(val2, memos.position);
+      var areEq = objEquiv(val1, val2, strict, aKeys, memos, iterationType);
+      memos.val1.delete(val1);
+      memos.val2.delete(val2);
+      return areEq;
+    }
+    function setHasEqualElement(set, val1, strict, memo) {
+      var setValues = arrayFromSet(set);
+      for (var i = 0; i < setValues.length; i++) {
+        var val2 = setValues[i];
+        if (innerDeepEqual(val1, val2, strict, memo)) {
+          set.delete(val2);
+          return true;
+        }
       }
-      return 0;
+      return false;
     }
-    function isBuffer(b) {
-      if (globalThis.Buffer && typeof globalThis.Buffer.isBuffer === "function") {
-        return globalThis.Buffer.isBuffer(b);
+    function findLooseMatchingPrimitives(prim) {
+      switch (_typeof(prim)) {
+        case "undefined":
+          return null;
+        case "object":
+          return void 0;
+        case "symbol":
+          return false;
+        case "string":
+          prim = +prim;
+        // Loose equal entries exist only if the string is possible to convert to
+        // a regular number and not NaN.
+        // Fall through
+        case "number":
+          if (numberIsNaN(prim)) {
+            return false;
+          }
       }
-      return !!(b != null && b._isBuffer);
+      return true;
     }
-    var util2 = require_util();
-    var hasOwn = Object.prototype.hasOwnProperty;
-    var pSlice = Array.prototype.slice;
-    var functionsHaveNames = (function() {
-      return function foo() {
-      }.name === "foo";
-    })();
-    function pToString(obj) {
-      return Object.prototype.toString.call(obj);
+    function setMightHaveLoosePrim(a, b, prim) {
+      var altValue = findLooseMatchingPrimitives(prim);
+      if (altValue != null) return altValue;
+      return b.has(altValue) && !a.has(altValue);
     }
-    function isView(arrbuf) {
-      if (isBuffer(arrbuf)) {
-        return false;
+    function mapMightHaveLoosePrim(a, b, prim, item, memo) {
+      var altValue = findLooseMatchingPrimitives(prim);
+      if (altValue != null) {
+        return altValue;
       }
-      if (typeof globalThis.ArrayBuffer !== "function") {
+      var curB = b.get(altValue);
+      if (curB === void 0 && !b.has(altValue) || !innerDeepEqual(item, curB, false, memo)) {
         return false;
       }
-      if (typeof ArrayBuffer.isView === "function") {
-        return ArrayBuffer.isView(arrbuf);
-      }
-      if (!arrbuf) {
-        return false;
+      return !a.has(altValue) && innerDeepEqual(item, curB, false, memo);
+    }
+    function setEquiv(a, b, strict, memo) {
+      var set = null;
+      var aValues = arrayFromSet(a);
+      for (var i = 0; i < aValues.length; i++) {
+        var val = aValues[i];
+        if (_typeof(val) === "object" && val !== null) {
+          if (set === null) {
+            set = /* @__PURE__ */ new Set();
+          }
+          set.add(val);
+        } else if (!b.has(val)) {
+          if (strict) return false;
+          if (!setMightHaveLoosePrim(a, b, val)) {
+            return false;
+          }
+          if (set === null) {
+            set = /* @__PURE__ */ new Set();
+          }
+          set.add(val);
+        }
       }
-      if (arrbuf instanceof DataView) {
-        return true;
+      if (set !== null) {
+        var bValues = arrayFromSet(b);
+        for (var _i = 0; _i < bValues.length; _i++) {
+          var _val = bValues[_i];
+          if (_typeof(_val) === "object" && _val !== null) {
+            if (!setHasEqualElement(set, _val, strict, memo)) return false;
+          } else if (!strict && !a.has(_val) && !setHasEqualElement(set, _val, strict, memo)) {
+            return false;
+          }
+        }
+        return set.size === 0;
       }
-      if (arrbuf.buffer && arrbuf.buffer instanceof ArrayBuffer) {
-        return true;
+      return true;
+    }
+    function mapHasEqualEntry(set, map, key1, item1, strict, memo) {
+      var setValues = arrayFromSet(set);
+      for (var i = 0; i < setValues.length; i++) {
+        var key2 = setValues[i];
+        if (innerDeepEqual(key1, key2, strict, memo) && innerDeepEqual(item1, map.get(key2), strict, memo)) {
+          set.delete(key2);
+          return true;
+        }
       }
       return false;
     }
-    var assert = module2.exports = ok;
-    var regex = /\s*function\s+([^\(\s]*)\s*/;
-    function getName(func) {
-      if (!util2.isFunction(func)) {
-        return;
+    function mapEquiv(a, b, strict, memo) {
+      var set = null;
+      var aEntries = arrayFromMap(a);
+      for (var i = 0; i < aEntries.length; i++) {
+        var _aEntries$i = _slicedToArray(aEntries[i], 2), key = _aEntries$i[0], item1 = _aEntries$i[1];
+        if (_typeof(key) === "object" && key !== null) {
+          if (set === null) {
+            set = /* @__PURE__ */ new Set();
+          }
+          set.add(key);
+        } else {
+          var item2 = b.get(key);
+          if (item2 === void 0 && !b.has(key) || !innerDeepEqual(item1, item2, strict, memo)) {
+            if (strict) return false;
+            if (!mapMightHaveLoosePrim(a, b, key, item1, memo)) return false;
+            if (set === null) {
+              set = /* @__PURE__ */ new Set();
+            }
+            set.add(key);
+          }
+        }
       }
-      if (functionsHaveNames) {
-        return func.name;
-      }
-      var str = func.toString();
-      var match = str.match(regex);
-      return match && match[1];
-    }
-    assert.AssertionError = function AssertionError(options) {
-      this.name = "AssertionError";
-      this.actual = options.actual;
-      this.expected = options.expected;
-      this.operator = options.operator;
-      if (options.message) {
-        this.message = options.message;
-        this.generatedMessage = false;
-      } else {
-        this.message = getMessage(this);
-        this.generatedMessage = true;
+      if (set !== null) {
+        var bEntries = arrayFromMap(b);
+        for (var _i2 = 0; _i2 < bEntries.length; _i2++) {
+          var _bEntries$_i = _slicedToArray(bEntries[_i2], 2), _key = _bEntries$_i[0], item = _bEntries$_i[1];
+          if (_typeof(_key) === "object" && _key !== null) {
+            if (!mapHasEqualEntry(set, a, _key, item, strict, memo)) return false;
+          } else if (!strict && (!a.has(_key) || !innerDeepEqual(a.get(_key), item, false, memo)) && !mapHasEqualEntry(set, a, _key, item, false, memo)) {
+            return false;
+          }
+        }
+        return set.size === 0;
       }
-      var stackStartFunction = options.stackStartFunction || fail;
-      if (Error.captureStackTrace) {
-        Error.captureStackTrace(this, stackStartFunction);
-      } else {
-        var err = new Error();
-        if (err.stack) {
-          var out = err.stack;
-          var fn_name = getName(stackStartFunction);
-          var idx = out.indexOf("\n" + fn_name);
-          if (idx >= 0) {
-            var next_line = out.indexOf("\n", idx + 1);
-            out = out.substring(next_line + 1);
+      return true;
+    }
+    function objEquiv(a, b, strict, keys, memos, iterationType) {
+      var i = 0;
+      if (iterationType === kIsSet) {
+        if (!setEquiv(a, b, strict, memos)) {
+          return false;
+        }
+      } else if (iterationType === kIsMap) {
+        if (!mapEquiv(a, b, strict, memos)) {
+          return false;
+        }
+      } else if (iterationType === kIsArray) {
+        for (; i < a.length; i++) {
+          if (hasOwnProperty(a, i)) {
+            if (!hasOwnProperty(b, i) || !innerDeepEqual(a[i], b[i], strict, memos)) {
+              return false;
+            }
+          } else if (hasOwnProperty(b, i)) {
+            return false;
+          } else {
+            var keysA = Object.keys(a);
+            for (; i < keysA.length; i++) {
+              var key = keysA[i];
+              if (!hasOwnProperty(b, key) || !innerDeepEqual(a[key], b[key], strict, memos)) {
+                return false;
+              }
+            }
+            if (keysA.length !== Object.keys(b).length) {
+              return false;
+            }
+            return true;
           }
-          this.stack = out;
         }
       }
+      for (i = 0; i < keys.length; i++) {
+        var _key2 = keys[i];
+        if (!innerDeepEqual(a[_key2], b[_key2], strict, memos)) {
+          return false;
+        }
+      }
+      return true;
+    }
+    function isDeepEqual(val1, val2) {
+      return innerDeepEqual(val1, val2, kLoose);
+    }
+    function isDeepStrictEqual(val1, val2) {
+      return innerDeepEqual(val1, val2, kStrict);
+    }
+    module2.exports = {
+      isDeepEqual,
+      isDeepStrictEqual
     };
-    util2.inherits(assert.AssertionError, Error);
-    function truncate(s, n) {
-      if (typeof s === "string") {
-        return s.length < n ? s : s.slice(0, n);
-      } else {
-        return s;
+  }
+});
+
+// ../../../node_modules/.pnpm/assert@2.1.0/node_modules/assert/build/assert.js
+var require_assert = __commonJS({
+  "../../../node_modules/.pnpm/assert@2.1.0/node_modules/assert/build/assert.js"(exports2, module2) {
+    "use strict";
+    init_browser_globals();
+    function _typeof(o) {
+      "@babel/helpers - typeof";
+      return _typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function(o2) {
+        return typeof o2;
+      } : function(o2) {
+        return o2 && "function" == typeof Symbol && o2.constructor === Symbol && o2 !== Symbol.prototype ? "symbol" : typeof o2;
+      }, _typeof(o);
+    }
+    function _defineProperties(target, props) {
+      for (var i = 0; i < props.length; i++) {
+        var descriptor = props[i];
+        descriptor.enumerable = descriptor.enumerable || false;
+        descriptor.configurable = true;
+        if ("value" in descriptor) descriptor.writable = true;
+        Object.defineProperty(target, _toPropertyKey(descriptor.key), descriptor);
       }
     }
-    function inspect(something) {
-      if (functionsHaveNames || !util2.isFunction(something)) {
-        return util2.inspect(something);
+    function _createClass(Constructor, protoProps, staticProps) {
+      if (protoProps) _defineProperties(Constructor.prototype, protoProps);
+      if (staticProps) _defineProperties(Constructor, staticProps);
+      Object.defineProperty(Constructor, "prototype", { writable: false });
+      return Constructor;
+    }
+    function _toPropertyKey(arg) {
+      var key = _toPrimitive(arg, "string");
+      return _typeof(key) === "symbol" ? key : String(key);
+    }
+    function _toPrimitive(input, hint) {
+      if (_typeof(input) !== "object" || input === null) return input;
+      var prim = input[Symbol.toPrimitive];
+      if (prim !== void 0) {
+        var res = prim.call(input, hint || "default");
+        if (_typeof(res) !== "object") return res;
+        throw new TypeError("@@toPrimitive must return a primitive value.");
       }
-      var rawname = getName(something);
-      var name = rawname ? ": " + rawname : "";
-      return "[Function" + name + "]";
+      return (hint === "string" ? String : Number)(input);
     }
-    function getMessage(self2) {
-      return truncate(inspect(self2.actual), 128) + " " + self2.operator + " " + truncate(inspect(self2.expected), 128);
+    function _classCallCheck(instance, Constructor) {
+      if (!(instance instanceof Constructor)) {
+        throw new TypeError("Cannot call a class as a function");
+      }
     }
-    function fail(actual, expected, message, operator, stackStartFunction) {
-      throw new assert.AssertionError({
-        message,
+    var _require = require_errors();
+    var _require$codes = _require.codes;
+    var ERR_AMBIGUOUS_ARGUMENT = _require$codes.ERR_AMBIGUOUS_ARGUMENT;
+    var ERR_INVALID_ARG_TYPE = _require$codes.ERR_INVALID_ARG_TYPE;
+    var ERR_INVALID_ARG_VALUE = _require$codes.ERR_INVALID_ARG_VALUE;
+    var ERR_INVALID_RETURN_VALUE = _require$codes.ERR_INVALID_RETURN_VALUE;
+    var ERR_MISSING_ARGS = _require$codes.ERR_MISSING_ARGS;
+    var AssertionError = require_assertion_error();
+    var _require2 = require_util();
+    var inspect = _require2.inspect;
+    var _require$types = require_util().types;
+    var isPromise = _require$types.isPromise;
+    var isRegExp = _require$types.isRegExp;
+    var objectAssign = require_polyfill()();
+    var objectIs = require_polyfill2()();
+    var RegExpPrototypeTest = require_callBound()("RegExp.prototype.test");
+    var isDeepEqual;
+    var isDeepStrictEqual;
+    function lazyLoadComparison() {
+      var comparison = require_comparisons();
+      isDeepEqual = comparison.isDeepEqual;
+      isDeepStrictEqual = comparison.isDeepStrictEqual;
+    }
+    var warned = false;
+    var assert = module2.exports = ok;
+    var NO_EXCEPTION_SENTINEL = {};
+    function innerFail(obj) {
+      if (obj.message instanceof Error) throw obj.message;
+      throw new AssertionError(obj);
+    }
+    function fail(actual, expected, message, operator, stackStartFn) {
+      var argsLen = arguments.length;
+      var internalMessage;
+      if (argsLen === 0) {
+        internalMessage = "Failed";
+      } else if (argsLen === 1) {
+        message = actual;
+        actual = void 0;
+      } else {
+        if (warned === false) {
+          warned = true;
+          var warn = import_browser.default.emitWarning ? import_browser.default.emitWarning : console.warn.bind(console);
+          warn("assert.fail() with more than one argument is deprecated. Please use assert.strictEqual() instead or only pass a message.", "DeprecationWarning", "DEP0094");
+        }
+        if (argsLen === 2) operator = "!=";
+      }
+      if (message instanceof Error) throw message;
+      var errArgs = {
         actual,
         expected,
-        operator,
-        stackStartFunction
-      });
+        operator: operator === void 0 ? "fail" : operator,
+        stackStartFn: stackStartFn || fail
+      };
+      if (message !== void 0) {
+        errArgs.message = message;
+      }
+      var err = new AssertionError(errArgs);
+      if (internalMessage) {
+        err.message = internalMessage;
+        err.generatedMessage = true;
+      }
+      throw err;
     }
     assert.fail = fail;
-    function ok(value, message) {
-      if (!value) fail(value, true, message, "==", assert.ok);
+    assert.AssertionError = AssertionError;
+    function innerOk(fn, argLen, value, message) {
+      if (!value) {
+        var generatedMessage = false;
+        if (argLen === 0) {
+          generatedMessage = true;
+          message = "No value argument passed to `assert.ok()`";
+        } else if (message instanceof Error) {
+          throw message;
+        }
+        var err = new AssertionError({
+          actual: value,
+          expected: true,
+          message,
+          operator: "==",
+          stackStartFn: fn
+        });
+        err.generatedMessage = generatedMessage;
+        throw err;
+      }
+    }
+    function ok() {
+      for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
+        args[_key] = arguments[_key];
+      }
+      innerOk.apply(void 0, [ok, args.length].concat(args));
     }
     assert.ok = ok;
     assert.equal = function equal(actual, expected, message) {
-      if (actual != expected) fail(actual, expected, message, "==", assert.equal);
+      if (arguments.length < 2) {
+        throw new ERR_MISSING_ARGS("actual", "expected");
+      }
+      if (actual != expected) {
+        innerFail({
+          actual,
+          expected,
+          message,
+          operator: "==",
+          stackStartFn: equal
+        });
+      }
     };
     assert.notEqual = function notEqual(actual, expected, message) {
+      if (arguments.length < 2) {
+        throw new ERR_MISSING_ARGS("actual", "expected");
+      }
       if (actual == expected) {
-        fail(actual, expected, message, "!=", assert.notEqual);
+        innerFail({
+          actual,
+          expected,
+          message,
+          operator: "!=",
+          stackStartFn: notEqual
+        });
       }
     };
     assert.deepEqual = function deepEqual(actual, expected, message) {
-      if (!_deepEqual(actual, expected, false)) {
-        fail(actual, expected, message, "deepEqual", assert.deepEqual);
+      if (arguments.length < 2) {
+        throw new ERR_MISSING_ARGS("actual", "expected");
+      }
+      if (isDeepEqual === void 0) lazyLoadComparison();
+      if (!isDeepEqual(actual, expected)) {
+        innerFail({
+          actual,
+          expected,
+          message,
+          operator: "deepEqual",
+          stackStartFn: deepEqual
+        });
       }
     };
-    assert.deepStrictEqual = function deepStrictEqual(actual, expected, message) {
-      if (!_deepEqual(actual, expected, true)) {
-        fail(actual, expected, message, "deepStrictEqual", assert.deepStrictEqual);
+    assert.notDeepEqual = function notDeepEqual(actual, expected, message) {
+      if (arguments.length < 2) {
+        throw new ERR_MISSING_ARGS("actual", "expected");
+      }
+      if (isDeepEqual === void 0) lazyLoadComparison();
+      if (isDeepEqual(actual, expected)) {
+        innerFail({
+          actual,
+          expected,
+          message,
+          operator: "notDeepEqual",
+          stackStartFn: notDeepEqual
+        });
       }
     };
-    function _deepEqual(actual, expected, strict2, memos) {
-      if (actual === expected) {
-        return true;
-      } else if (isBuffer(actual) && isBuffer(expected)) {
-        return compare(actual, expected) === 0;
-      } else if (util2.isDate(actual) && util2.isDate(expected)) {
-        return actual.getTime() === expected.getTime();
-      } else if (util2.isRegExp(actual) && util2.isRegExp(expected)) {
-        return actual.source === expected.source && actual.global === expected.global && actual.multiline === expected.multiline && actual.lastIndex === expected.lastIndex && actual.ignoreCase === expected.ignoreCase;
-      } else if ((actual === null || typeof actual !== "object") && (expected === null || typeof expected !== "object")) {
-        return strict2 ? actual === expected : actual == expected;
-      } else if (isView(actual) && isView(expected) && pToString(actual) === pToString(expected) && !(actual instanceof Float32Array || actual instanceof Float64Array)) {
-        return compare(
-          new Uint8Array(actual.buffer),
-          new Uint8Array(expected.buffer)
-        ) === 0;
-      } else if (isBuffer(actual) !== isBuffer(expected)) {
-        return false;
-      } else {
-        memos = memos || { actual: [], expected: [] };
-        var actualIndex = memos.actual.indexOf(actual);
-        if (actualIndex !== -1) {
-          if (actualIndex === memos.expected.indexOf(expected)) {
-            return true;
-          }
-        }
-        memos.actual.push(actual);
-        memos.expected.push(expected);
-        return objEquiv(actual, expected, strict2, memos);
-      }
-    }
-    function isArguments(object) {
-      return Object.prototype.toString.call(object) == "[object Arguments]";
-    }
-    function objEquiv(a, b, strict2, actualVisitedObjects) {
-      if (a === null || a === void 0 || b === null || b === void 0)
-        return false;
-      if (util2.isPrimitive(a) || util2.isPrimitive(b))
-        return a === b;
-      if (strict2 && Object.getPrototypeOf(a) !== Object.getPrototypeOf(b))
-        return false;
-      var aIsArgs = isArguments(a);
-      var bIsArgs = isArguments(b);
-      if (aIsArgs && !bIsArgs || !aIsArgs && bIsArgs)
-        return false;
-      if (aIsArgs) {
-        a = pSlice.call(a);
-        b = pSlice.call(b);
-        return _deepEqual(a, b, strict2);
-      }
-      var ka = objectKeys(a);
-      var kb = objectKeys(b);
-      var key, i;
-      if (ka.length !== kb.length)
-        return false;
-      ka.sort();
-      kb.sort();
-      for (i = ka.length - 1; i >= 0; i--) {
-        if (ka[i] !== kb[i])
-          return false;
-      }
-      for (i = ka.length - 1; i >= 0; i--) {
-        key = ka[i];
-        if (!_deepEqual(a[key], b[key], strict2, actualVisitedObjects))
-          return false;
-      }
-      return true;
-    }
-    assert.notDeepEqual = function notDeepEqual(actual, expected, message) {
-      if (_deepEqual(actual, expected, false)) {
-        fail(actual, expected, message, "notDeepEqual", assert.notDeepEqual);
+    assert.deepStrictEqual = function deepStrictEqual(actual, expected, message) {
+      if (arguments.length < 2) {
+        throw new ERR_MISSING_ARGS("actual", "expected");
+      }
+      if (isDeepEqual === void 0) lazyLoadComparison();
+      if (!isDeepStrictEqual(actual, expected)) {
+        innerFail({
+          actual,
+          expected,
+          message,
+          operator: "deepStrictEqual",
+          stackStartFn: deepStrictEqual
+        });
       }
     };
     assert.notDeepStrictEqual = notDeepStrictEqual;
     function notDeepStrictEqual(actual, expected, message) {
-      if (_deepEqual(actual, expected, true)) {
-        fail(actual, expected, message, "notDeepStrictEqual", notDeepStrictEqual);
+      if (arguments.length < 2) {
+        throw new ERR_MISSING_ARGS("actual", "expected");
+      }
+      if (isDeepEqual === void 0) lazyLoadComparison();
+      if (isDeepStrictEqual(actual, expected)) {
+        innerFail({
+          actual,
+          expected,
+          message,
+          operator: "notDeepStrictEqual",
+          stackStartFn: notDeepStrictEqual
+        });
       }
     }
     assert.strictEqual = function strictEqual(actual, expected, message) {
-      if (actual !== expected) {
-        fail(actual, expected, message, "===", assert.strictEqual);
+      if (arguments.length < 2) {
+        throw new ERR_MISSING_ARGS("actual", "expected");
+      }
+      if (!objectIs(actual, expected)) {
+        innerFail({
+          actual,
+          expected,
+          message,
+          operator: "strictEqual",
+          stackStartFn: strictEqual
+        });
       }
     };
     assert.notStrictEqual = function notStrictEqual(actual, expected, message) {
-      if (actual === expected) {
-        fail(actual, expected, message, "!==", assert.notStrictEqual);
+      if (arguments.length < 2) {
+        throw new ERR_MISSING_ARGS("actual", "expected");
+      }
+      if (objectIs(actual, expected)) {
+        innerFail({
+          actual,
+          expected,
+          message,
+          operator: "notStrictEqual",
+          stackStartFn: notStrictEqual
+        });
       }
     };
-    function expectedException(actual, expected) {
-      if (!actual || !expected) {
-        return false;
-      }
-      if (Object.prototype.toString.call(expected) == "[object RegExp]") {
-        return expected.test(actual);
+    var Comparison = /* @__PURE__ */ _createClass(function Comparison2(obj, keys, actual) {
+      var _this = this;
+      _classCallCheck(this, Comparison2);
+      keys.forEach(function(key) {
+        if (key in obj) {
+          if (actual !== void 0 && typeof actual[key] === "string" && isRegExp(obj[key]) && RegExpPrototypeTest(obj[key], actual[key])) {
+            _this[key] = actual[key];
+          } else {
+            _this[key] = obj[key];
+          }
+        }
+      });
+    });
+    function compareExceptionKey(actual, expected, key, message, keys, fn) {
+      if (!(key in actual) || !isDeepStrictEqual(actual[key], expected[key])) {
+        if (!message) {
+          var a = new Comparison(actual, keys);
+          var b = new Comparison(expected, keys, actual);
+          var err = new AssertionError({
+            actual: a,
+            expected: b,
+            operator: "deepStrictEqual",
+            stackStartFn: fn
+          });
+          err.actual = actual;
+          err.expected = expected;
+          err.operator = fn.name;
+          throw err;
+        }
+        innerFail({
+          actual,
+          expected,
+          message,
+          operator: fn.name,
+          stackStartFn: fn
+        });
       }
-      try {
-        if (actual instanceof expected) {
-          return true;
+    }
+    function expectedException(actual, expected, msg, fn) {
+      if (typeof expected !== "function") {
+        if (isRegExp(expected)) return RegExpPrototypeTest(expected, actual);
+        if (arguments.length === 2) {
+          throw new ERR_INVALID_ARG_TYPE("expected", ["Function", "RegExp"], expected);
         }
-      } catch (e) {
+        if (_typeof(actual) !== "object" || actual === null) {
+          var err = new AssertionError({
+            actual,
+            expected,
+            message: msg,
+            operator: "deepStrictEqual",
+            stackStartFn: fn
+          });
+          err.operator = fn.name;
+          throw err;
+        }
+        var keys = Object.keys(expected);
+        if (expected instanceof Error) {
+          keys.push("name", "message");
+        } else if (keys.length === 0) {
+          throw new ERR_INVALID_ARG_VALUE("error", expected, "may not be an empty object");
+        }
+        if (isDeepEqual === void 0) lazyLoadComparison();
+        keys.forEach(function(key) {
+          if (typeof actual[key] === "string" && isRegExp(expected[key]) && RegExpPrototypeTest(expected[key], actual[key])) {
+            return;
+          }
+          compareExceptionKey(actual, expected, key, msg, keys, fn);
+        });
+        return true;
+      }
+      if (expected.prototype !== void 0 && actual instanceof expected) {
+        return true;
       }
       if (Error.isPrototypeOf(expected)) {
         return false;
       }
       return expected.call({}, actual) === true;
     }
-    function _tryBlock(block) {
-      var error;
+    function getActual(fn) {
+      if (typeof fn !== "function") {
+        throw new ERR_INVALID_ARG_TYPE("fn", "Function", fn);
+      }
       try {
-        block();
+        fn();
       } catch (e) {
-        error = e;
+        return e;
+      }
+      return NO_EXCEPTION_SENTINEL;
+    }
+    function checkIsPromise(obj) {
+      return isPromise(obj) || obj !== null && _typeof(obj) === "object" && typeof obj.then === "function" && typeof obj.catch === "function";
+    }
+    function waitForActual(promiseFn) {
+      return Promise.resolve().then(function() {
+        var resultPromise;
+        if (typeof promiseFn === "function") {
+          resultPromise = promiseFn();
+          if (!checkIsPromise(resultPromise)) {
+            throw new ERR_INVALID_RETURN_VALUE("instance of Promise", "promiseFn", resultPromise);
+          }
+        } else if (checkIsPromise(promiseFn)) {
+          resultPromise = promiseFn;
+        } else {
+          throw new ERR_INVALID_ARG_TYPE("promiseFn", ["Function", "Promise"], promiseFn);
+        }
+        return Promise.resolve().then(function() {
+          return resultPromise;
+        }).then(function() {
+          return NO_EXCEPTION_SENTINEL;
+        }).catch(function(e) {
+          return e;
+        });
+      });
+    }
+    function expectsError(stackStartFn, actual, error, message) {
+      if (typeof error === "string") {
+        if (arguments.length === 4) {
+          throw new ERR_INVALID_ARG_TYPE("error", ["Object", "Error", "Function", "RegExp"], error);
+        }
+        if (_typeof(actual) === "object" && actual !== null) {
+          if (actual.message === error) {
+            throw new ERR_AMBIGUOUS_ARGUMENT("error/message", 'The error message "'.concat(actual.message, '" is identical to the message.'));
+          }
+        } else if (actual === error) {
+          throw new ERR_AMBIGUOUS_ARGUMENT("error/message", 'The error "'.concat(actual, '" is identical to the message.'));
+        }
+        message = error;
+        error = void 0;
+      } else if (error != null && _typeof(error) !== "object" && typeof error !== "function") {
+        throw new ERR_INVALID_ARG_TYPE("error", ["Object", "Error", "Function", "RegExp"], error);
+      }
+      if (actual === NO_EXCEPTION_SENTINEL) {
+        var details = "";
+        if (error && error.name) {
+          details += " (".concat(error.name, ")");
+        }
+        details += message ? ": ".concat(message) : ".";
+        var fnType = stackStartFn.name === "rejects" ? "rejection" : "exception";
+        innerFail({
+          actual: void 0,
+          expected: error,
+          operator: stackStartFn.name,
+          message: "Missing expected ".concat(fnType).concat(details),
+          stackStartFn
+        });
+      }
+      if (error && !expectedException(actual, error, message, stackStartFn)) {
+        throw actual;
       }
-      return error;
     }
-    function _throws(shouldThrow, block, expected, message) {
-      var actual;
-      if (typeof block !== "function") {
-        throw new TypeError('"block" argument must be a function');
+    function expectsNoError(stackStartFn, actual, error, message) {
+      if (actual === NO_EXCEPTION_SENTINEL) return;
+      if (typeof error === "string") {
+        message = error;
+        error = void 0;
+      }
+      if (!error || expectedException(actual, error)) {
+        var details = message ? ": ".concat(message) : ".";
+        var fnType = stackStartFn.name === "doesNotReject" ? "rejection" : "exception";
+        innerFail({
+          actual,
+          expected: error,
+          operator: stackStartFn.name,
+          message: "Got unwanted ".concat(fnType).concat(details, "\n") + 'Actual message: "'.concat(actual && actual.message, '"'),
+          stackStartFn
+        });
       }
-      if (typeof expected === "string") {
-        message = expected;
-        expected = null;
+      throw actual;
+    }
+    assert.throws = function throws(promiseFn) {
+      for (var _len2 = arguments.length, args = new Array(_len2 > 1 ? _len2 - 1 : 0), _key2 = 1; _key2 < _len2; _key2++) {
+        args[_key2 - 1] = arguments[_key2];
       }
-      actual = _tryBlock(block);
-      message = (expected && expected.name ? " (" + expected.name + ")." : ".") + (message ? " " + message : ".");
-      if (shouldThrow && !actual) {
-        fail(actual, expected, "Missing expected exception" + message);
+      expectsError.apply(void 0, [throws, getActual(promiseFn)].concat(args));
+    };
+    assert.rejects = function rejects(promiseFn) {
+      for (var _len3 = arguments.length, args = new Array(_len3 > 1 ? _len3 - 1 : 0), _key3 = 1; _key3 < _len3; _key3++) {
+        args[_key3 - 1] = arguments[_key3];
       }
-      var userProvidedMessage = typeof message === "string";
-      var isUnwantedException = !shouldThrow && util2.isError(actual);
-      var isUnexpectedException = !shouldThrow && actual && !expected;
-      if (isUnwantedException && userProvidedMessage && expectedException(actual, expected) || isUnexpectedException) {
-        fail(actual, expected, "Got unwanted exception" + message);
+      return waitForActual(promiseFn).then(function(result) {
+        return expectsError.apply(void 0, [rejects, result].concat(args));
+      });
+    };
+    assert.doesNotThrow = function doesNotThrow(fn) {
+      for (var _len4 = arguments.length, args = new Array(_len4 > 1 ? _len4 - 1 : 0), _key4 = 1; _key4 < _len4; _key4++) {
+        args[_key4 - 1] = arguments[_key4];
       }
-      if (shouldThrow && actual && expected && !expectedException(actual, expected) || !shouldThrow && actual) {
-        throw actual;
+      expectsNoError.apply(void 0, [doesNotThrow, getActual(fn)].concat(args));
+    };
+    assert.doesNotReject = function doesNotReject(fn) {
+      for (var _len5 = arguments.length, args = new Array(_len5 > 1 ? _len5 - 1 : 0), _key5 = 1; _key5 < _len5; _key5++) {
+        args[_key5 - 1] = arguments[_key5];
+      }
+      return waitForActual(fn).then(function(result) {
+        return expectsNoError.apply(void 0, [doesNotReject, result].concat(args));
+      });
+    };
+    assert.ifError = function ifError(err) {
+      if (err !== null && err !== void 0) {
+        var message = "ifError got unwanted exception: ";
+        if (_typeof(err) === "object" && typeof err.message === "string") {
+          if (err.message.length === 0 && err.constructor) {
+            message += err.constructor.name;
+          } else {
+            message += err.message;
+          }
+        } else {
+          message += inspect(err);
+        }
+        var newErr = new AssertionError({
+          actual: err,
+          expected: null,
+          operator: "ifError",
+          message,
+          stackStartFn: ifError
+        });
+        var origStack = err.stack;
+        if (typeof origStack === "string") {
+          var tmp2 = origStack.split("\n");
+          tmp2.shift();
+          var tmp1 = newErr.stack.split("\n");
+          for (var i = 0; i < tmp2.length; i++) {
+            var pos = tmp1.indexOf(tmp2[i]);
+            if (pos !== -1) {
+              tmp1 = tmp1.slice(0, pos);
+              break;
+            }
+          }
+          newErr.stack = "".concat(tmp1.join("\n"), "\n").concat(tmp2.join("\n"));
+        }
+        throw newErr;
       }
-    }
-    assert.throws = function(block, error, message) {
-      _throws(true, block, error, message);
     };
-    assert.doesNotThrow = function(block, error, message) {
-      _throws(false, block, error, message);
+    function internalMatch(string, regexp, message, fn, fnName) {
+      if (!isRegExp(regexp)) {
+        throw new ERR_INVALID_ARG_TYPE("regexp", "RegExp", regexp);
+      }
+      var match = fnName === "match";
+      if (typeof string !== "string" || RegExpPrototypeTest(regexp, string) !== match) {
+        if (message instanceof Error) {
+          throw message;
+        }
+        var generatedMessage = !message;
+        message = message || (typeof string !== "string" ? 'The "string" argument must be of type string. Received type ' + "".concat(_typeof(string), " (").concat(inspect(string), ")") : (match ? "The input did not match the regular expression " : "The input was expected to not match the regular expression ") + "".concat(inspect(regexp), ". Input:\n\n").concat(inspect(string), "\n"));
+        var err = new AssertionError({
+          actual: string,
+          expected: regexp,
+          message,
+          operator: fnName,
+          stackStartFn: fn
+        });
+        err.generatedMessage = generatedMessage;
+        throw err;
+      }
+    }
+    assert.match = function match(string, regexp, message) {
+      internalMatch(string, regexp, message, match, "match");
     };
-    assert.ifError = function(err) {
-      if (err) throw err;
+    assert.doesNotMatch = function doesNotMatch(string, regexp, message) {
+      internalMatch(string, regexp, message, doesNotMatch, "doesNotMatch");
     };
-    function strict(value, message) {
-      if (!value) fail(value, true, message, "==", strict);
+    function strict() {
+      for (var _len6 = arguments.length, args = new Array(_len6), _key6 = 0; _key6 < _len6; _key6++) {
+        args[_key6] = arguments[_key6];
+      }
+      innerOk.apply(void 0, [strict, args.length].concat(args));
     }
     assert.strict = objectAssign(strict, assert, {
       equal: assert.strictEqual,
@@ -14349,13 +16268,6 @@ var require_assert = __commonJS({
       notDeepEqual: assert.notDeepStrictEqual
     });
     assert.strict.strict = assert.strict;
-    var objectKeys = Object.keys || function(obj) {
-      var keys = [];
-      for (var key in obj) {
-        if (hasOwn.call(obj, key)) keys.push(key);
-      }
-      return keys;
-    };
   }
 });
 
@@ -19517,7 +21429,10 @@ buffer/index.js:
    * @license  MIT
    *)
 
-assert/assert.js:
+safe-buffer/index.js:
+  (*! safe-buffer. MIT License. Feross Aboukhadijeh <https://feross.org/opensource> *)
+
+assert/build/internal/util/comparisons.js:
   (*!
    * The buffer module from node.js, for the browser.
    *