@xyo-network/hash 2.90.11 → 2.90.13

package/dist/browser/worker/jsHash-bundle.js

@@ -0,0 +1,3322 @@
+"use strict";
+(() => {
+  var __create = Object.create;
+  var __defProp = Object.defineProperty;
+  var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+  var __getOwnPropNames = Object.getOwnPropertyNames;
+  var __getProtoOf = Object.getPrototypeOf;
+  var __hasOwnProp = Object.prototype.hasOwnProperty;
+  var __commonJS = (cb, mod) => function __require() {
+    return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
+  };
+  var __copyProps = (to, from, except, desc) => {
+    if (from && typeof from === "object" || typeof from === "function") {
+      for (let key of __getOwnPropNames(from))
+        if (!__hasOwnProp.call(to, key) && key !== except)
+          __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+    }
+    return to;
+  };
+  var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+    // If the importer is in node compatibility mode or this is not an ESM
+    // file that has been converted to a CommonJS file using a Babel-
+    // compatible transform (i.e. "__esModule" has not been set), then set
+    // "default" to the CommonJS "module.exports" for node compatibility.
+    isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+    mod
+  ));
+
+  // ../../../../../../node_modules/inherits/inherits_browser.js
+  var require_inherits_browser = __commonJS({
+    "../../../../../../node_modules/inherits/inherits_browser.js"(exports, module) {
+      if (typeof Object.create === "function") {
+        module.exports = function inherits(ctor, superCtor) {
+          if (superCtor) {
+            ctor.super_ = superCtor;
+            ctor.prototype = Object.create(superCtor.prototype, {
+              constructor: {
+                value: ctor,
+                enumerable: false,
+                writable: true,
+                configurable: true
+              }
+            });
+          }
+        };
+      } else {
+        module.exports = function inherits(ctor, superCtor) {
+          if (superCtor) {
+            ctor.super_ = superCtor;
+            var TempCtor = function() {
+            };
+            TempCtor.prototype = superCtor.prototype;
+            ctor.prototype = new TempCtor();
+            ctor.prototype.constructor = ctor;
+          }
+        };
+      }
+    }
+  });
+
+  // ../../../../../../node_modules/base64-js/index.js
+  var require_base64_js = __commonJS({
+    "../../../../../../node_modules/base64-js/index.js"(exports) {
+      "use strict";
+      exports.byteLength = byteLength;
+      exports.toByteArray = toByteArray;
+      exports.fromByteArray = fromByteArray;
+      var lookup = [];
+      var revLookup = [];
+      var Arr = typeof Uint8Array !== "undefined" ? Uint8Array : Array;
+      var code = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
+      for (i = 0, len = code.length; i < len; ++i) {
+        lookup[i] = code[i];
+        revLookup[code.charCodeAt(i)] = i;
+      }
+      var i;
+      var len;
+      revLookup["-".charCodeAt(0)] = 62;
+      revLookup["_".charCodeAt(0)] = 63;
+      function getLens(b64) {
+        var len2 = b64.length;
+        if (len2 % 4 > 0) {
+          throw new Error("Invalid string. Length must be a multiple of 4");
+        }
+        var validLen = b64.indexOf("=");
+        if (validLen === -1)
+          validLen = len2;
+        var placeHoldersLen = validLen === len2 ? 0 : 4 - validLen % 4;
+        return [validLen, placeHoldersLen];
+      }
+      function byteLength(b64) {
+        var lens = getLens(b64);
+        var validLen = lens[0];
+        var placeHoldersLen = lens[1];
+        return (validLen + placeHoldersLen) * 3 / 4 - placeHoldersLen;
+      }
+      function _byteLength(b64, validLen, placeHoldersLen) {
+        return (validLen + placeHoldersLen) * 3 / 4 - placeHoldersLen;
+      }
+      function toByteArray(b64) {
+        var tmp;
+        var lens = getLens(b64);
+        var validLen = lens[0];
+        var placeHoldersLen = lens[1];
+        var arr = new Arr(_byteLength(b64, validLen, placeHoldersLen));
+        var curByte = 0;
+        var len2 = placeHoldersLen > 0 ? validLen - 4 : validLen;
+        var i2;
+        for (i2 = 0; i2 < len2; i2 += 4) {
+          tmp = revLookup[b64.charCodeAt(i2)] << 18 | revLookup[b64.charCodeAt(i2 + 1)] << 12 | revLookup[b64.charCodeAt(i2 + 2)] << 6 | revLookup[b64.charCodeAt(i2 + 3)];
+          arr[curByte++] = tmp >> 16 & 255;
+          arr[curByte++] = tmp >> 8 & 255;
+          arr[curByte++] = tmp & 255;
+        }
+        if (placeHoldersLen === 2) {
+          tmp = revLookup[b64.charCodeAt(i2)] << 2 | revLookup[b64.charCodeAt(i2 + 1)] >> 4;
+          arr[curByte++] = tmp & 255;
+        }
+        if (placeHoldersLen === 1) {
+          tmp = revLookup[b64.charCodeAt(i2)] << 10 | revLookup[b64.charCodeAt(i2 + 1)] << 4 | revLookup[b64.charCodeAt(i2 + 2)] >> 2;
+          arr[curByte++] = tmp >> 8 & 255;
+          arr[curByte++] = tmp & 255;
+        }
+        return arr;
+      }
+      function tripletToBase64(num) {
+        return lookup[num >> 18 & 63] + lookup[num >> 12 & 63] + lookup[num >> 6 & 63] + lookup[num & 63];
+      }
+      function encodeChunk(uint8, start, end) {
+        var tmp;
+        var output = [];
+        for (var i2 = start; i2 < end; i2 += 3) {
+          tmp = (uint8[i2] << 16 & 16711680) + (uint8[i2 + 1] << 8 & 65280) + (uint8[i2 + 2] & 255);
+          output.push(tripletToBase64(tmp));
+        }
+        return output.join("");
+      }
+      function fromByteArray(uint8) {
+        var tmp;
+        var len2 = uint8.length;
+        var extraBytes = len2 % 3;
+        var parts = [];
+        var maxChunkLength = 16383;
+        for (var i2 = 0, len22 = len2 - extraBytes; i2 < len22; i2 += maxChunkLength) {
+          parts.push(encodeChunk(uint8, i2, i2 + maxChunkLength > len22 ? len22 : i2 + maxChunkLength));
+        }
+        if (extraBytes === 1) {
+          tmp = uint8[len2 - 1];
+          parts.push(
+            lookup[tmp >> 2] + lookup[tmp << 4 & 63] + "=="
+          );
+        } else if (extraBytes === 2) {
+          tmp = (uint8[len2 - 2] << 8) + uint8[len2 - 1];
+          parts.push(
+            lookup[tmp >> 10] + lookup[tmp >> 4 & 63] + lookup[tmp << 2 & 63] + "="
+          );
+        }
+        return parts.join("");
+      }
+    }
+  });
+
+  // ../../../../../../node_modules/ieee754/index.js
+  var require_ieee754 = __commonJS({
+    "../../../../../../node_modules/ieee754/index.js"(exports) {
+      exports.read = function(buffer, offset, isLE, mLen, nBytes) {
+        var e, m;
+        var eLen = nBytes * 8 - mLen - 1;
+        var eMax = (1 << eLen) - 1;
+        var eBias = eMax >> 1;
+        var nBits = -7;
+        var i = isLE ? nBytes - 1 : 0;
+        var d = isLE ? -1 : 1;
+        var s = buffer[offset + i];
+        i += d;
+        e = s & (1 << -nBits) - 1;
+        s >>= -nBits;
+        nBits += eLen;
+        for (; nBits > 0; e = e * 256 + buffer[offset + i], i += d, nBits -= 8) {
+        }
+        m = e & (1 << -nBits) - 1;
+        e >>= -nBits;
+        nBits += mLen;
+        for (; nBits > 0; m = m * 256 + buffer[offset + i], i += d, nBits -= 8) {
+        }
+        if (e === 0) {
+          e = 1 - eBias;
+        } else if (e === eMax) {
+          return m ? NaN : (s ? -1 : 1) * Infinity;
+        } else {
+          m = m + Math.pow(2, mLen);
+          e = e - eBias;
+        }
+        return (s ? -1 : 1) * m * Math.pow(2, e - mLen);
+      };
+      exports.write = function(buffer, value, offset, isLE, mLen, nBytes) {
+        var e, m, c;
+        var eLen = nBytes * 8 - mLen - 1;
+        var eMax = (1 << eLen) - 1;
+        var eBias = eMax >> 1;
+        var rt = mLen === 23 ? Math.pow(2, -24) - Math.pow(2, -77) : 0;
+        var i = isLE ? 0 : nBytes - 1;
+        var d = isLE ? 1 : -1;
+        var s = value < 0 || value === 0 && 1 / value < 0 ? 1 : 0;
+        value = Math.abs(value);
+        if (isNaN(value) || value === Infinity) {
+          m = isNaN(value) ? 1 : 0;
+          e = eMax;
+        } else {
+          e = Math.floor(Math.log(value) / Math.LN2);
+          if (value * (c = Math.pow(2, -e)) < 1) {
+            e--;
+            c *= 2;
+          }
+          if (e + eBias >= 1) {
+            value += rt / c;
+          } else {
+            value += rt * Math.pow(2, 1 - eBias);
+          }
+          if (value * c >= 2) {
+            e++;
+            c /= 2;
+          }
+          if (e + eBias >= eMax) {
+            m = 0;
+            e = eMax;
+          } else if (e + eBias >= 1) {
+            m = (value * c - 1) * Math.pow(2, mLen);
+            e = e + eBias;
+          } else {
+            m = value * Math.pow(2, eBias - 1) * Math.pow(2, mLen);
+            e = 0;
+          }
+        }
+        for (; mLen >= 8; buffer[offset + i] = m & 255, i += d, m /= 256, mLen -= 8) {
+        }
+        e = e << mLen | m;
+        eLen += mLen;
+        for (; eLen > 0; buffer[offset + i] = e & 255, i += d, e /= 256, eLen -= 8) {
+        }
+        buffer[offset + i - d] |= s * 128;
+      };
+    }
+  });
+
+  // ../../../../../../node_modules/buffer/index.js
+  var require_buffer = __commonJS({
+    "../../../../../../node_modules/buffer/index.js"(exports) {
+      "use strict";
+      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;
+      exports.Buffer = Buffer2;
+      exports.SlowBuffer = SlowBuffer;
+      exports.INSPECT_MAX_BYTES = 50;
+      var K_MAX_LENGTH = 2147483647;
+      exports.kMaxLength = K_MAX_LENGTH;
+      Buffer2.TYPED_ARRAY_SUPPORT = typedArraySupport();
+      if (!Buffer2.TYPED_ARRAY_SUPPORT && typeof console !== "undefined" && typeof console.error === "function") {
+        console.error(
+          "This browser lacks typed array (Uint8Array) support which is required by `buffer` v5.x. Use `buffer` v4.x if you require old browser support."
+        );
+      }
+      function typedArraySupport() {
+        try {
+          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;
+        }
+      }
+      Object.defineProperty(Buffer2.prototype, "parent", {
+        enumerable: true,
+        get: function() {
+          if (!Buffer2.isBuffer(this))
+            return void 0;
+          return this.buffer;
+        }
+      });
+      Object.defineProperty(Buffer2.prototype, "offset", {
+        enumerable: true,
+        get: function() {
+          if (!Buffer2.isBuffer(this))
+            return void 0;
+          return this.byteOffset;
+        }
+      });
+      function createBuffer(length) {
+        if (length > K_MAX_LENGTH) {
+          throw new RangeError('The value "' + length + '" is invalid for option "size"');
+        }
+        const buf = new Uint8Array(length);
+        Object.setPrototypeOf(buf, Buffer2.prototype);
+        return buf;
+      }
+      function Buffer2(arg, encodingOrOffset, length) {
+        if (typeof arg === "number") {
+          if (typeof encodingOrOffset === "string") {
+            throw new TypeError(
+              'The "string" argument must be of type string. Received type number'
+            );
+          }
+          return allocUnsafe(arg);
+        }
+        return from(arg, encodingOrOffset, length);
+      }
+      Buffer2.poolSize = 8192;
+      function from(value, encodingOrOffset, length) {
+        if (typeof value === "string") {
+          return fromString(value, encodingOrOffset);
+        }
+        if (ArrayBuffer.isView(value)) {
+          return fromArrayView(value);
+        }
+        if (value == null) {
+          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'
+          );
+        }
+        const valueOf = value.valueOf && value.valueOf();
+        if (valueOf != null && valueOf !== value) {
+          return Buffer2.from(valueOf, encodingOrOffset, length);
+        }
+        const b = fromObject(value);
+        if (b)
+          return b;
+        if (typeof Symbol !== "undefined" && Symbol.toPrimitive != null && typeof value[Symbol.toPrimitive] === "function") {
+          return Buffer2.from(value[Symbol.toPrimitive]("string"), encodingOrOffset, length);
+        }
+        throw new TypeError(
+          "The first argument must be one of type string, Buffer, ArrayBuffer, Array, or Array-like Object. Received type " + typeof value
+        );
+      }
+      Buffer2.from = function(value, encodingOrOffset, length) {
+        return from(value, encodingOrOffset, length);
+      };
+      Object.setPrototypeOf(Buffer2.prototype, Uint8Array.prototype);
+      Object.setPrototypeOf(Buffer2, Uint8Array);
+      function assertSize(size) {
+        if (typeof size !== "number") {
+          throw new TypeError('"size" argument must be of type number');
+        } else if (size < 0) {
+          throw new RangeError('The value "' + size + '" is invalid for option "size"');
+        }
+      }
+      function alloc(size, fill, encoding) {
+        assertSize(size);
+        if (size <= 0) {
+          return createBuffer(size);
+        }
+        if (fill !== void 0) {
+          return typeof encoding === "string" ? createBuffer(size).fill(fill, encoding) : createBuffer(size).fill(fill);
+        }
+        return createBuffer(size);
+      }
+      Buffer2.alloc = function(size, fill, encoding) {
+        return alloc(size, fill, encoding);
+      };
+      function allocUnsafe(size) {
+        assertSize(size);
+        return createBuffer(size < 0 ? 0 : checked(size) | 0);
+      }
+      Buffer2.allocUnsafe = function(size) {
+        return allocUnsafe(size);
+      };
+      Buffer2.allocUnsafeSlow = function(size) {
+        return allocUnsafe(size);
+      };
+      function fromString(string, encoding) {
+        if (typeof encoding !== "string" || encoding === "") {
+          encoding = "utf8";
+        }
+        if (!Buffer2.isEncoding(encoding)) {
+          throw new TypeError("Unknown encoding: " + encoding);
+        }
+        const length = byteLength(string, encoding) | 0;
+        let buf = createBuffer(length);
+        const actual = buf.write(string, encoding);
+        if (actual !== length) {
+          buf = buf.slice(0, actual);
+        }
+        return buf;
+      }
+      function fromArrayLike(array) {
+        const length = array.length < 0 ? 0 : checked(array.length) | 0;
+        const buf = createBuffer(length);
+        for (let i = 0; i < length; i += 1) {
+          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');
+        }
+        if (array.byteLength < byteOffset + (length || 0)) {
+          throw new RangeError('"length" is outside of buffer bounds');
+        }
+        let buf;
+        if (byteOffset === void 0 && length === void 0) {
+          buf = new Uint8Array(array);
+        } else if (length === void 0) {
+          buf = new Uint8Array(array, byteOffset);
+        } else {
+          buf = new Uint8Array(array, byteOffset, length);
+        }
+        Object.setPrototypeOf(buf, Buffer2.prototype);
+        return buf;
+      }
+      function fromObject(obj) {
+        if (Buffer2.isBuffer(obj)) {
+          const len = checked(obj.length) | 0;
+          const buf = createBuffer(len);
+          if (buf.length === 0) {
+            return buf;
+          }
+          obj.copy(buf, 0, 0, len);
+          return buf;
+        }
+        if (obj.length !== void 0) {
+          if (typeof obj.length !== "number" || numberIsNaN(obj.length)) {
+            return createBuffer(0);
+          }
+          return fromArrayLike(obj);
+        }
+        if (obj.type === "Buffer" && Array.isArray(obj.data)) {
+          return fromArrayLike(obj.data);
+        }
+      }
+      function checked(length) {
+        if (length >= K_MAX_LENGTH) {
+          throw new RangeError("Attempt to allocate Buffer larger than maximum size: 0x" + K_MAX_LENGTH.toString(16) + " bytes");
+        }
+        return length | 0;
+      }
+      function SlowBuffer(length) {
+        if (+length != length) {
+          length = 0;
+        }
+        return Buffer2.alloc(+length);
+      }
+      Buffer2.isBuffer = function isBuffer(b) {
+        return b != null && b._isBuffer === true && b !== Buffer2.prototype;
+      };
+      Buffer2.compare = function compare(a, b) {
+        if (isInstance(a, Uint8Array))
+          a = Buffer2.from(a, a.offset, a.byteLength);
+        if (isInstance(b, Uint8Array))
+          b = Buffer2.from(b, b.offset, b.byteLength);
+        if (!Buffer2.isBuffer(a) || !Buffer2.isBuffer(b)) {
+          throw new TypeError(
+            'The "buf1", "buf2" arguments must be one of type Buffer or Uint8Array'
+          );
+        }
+        if (a === b)
+          return 0;
+        let x = a.length;
+        let y = b.length;
+        for (let i = 0, len = Math.min(x, y); i < len; ++i) {
+          if (a[i] !== b[i]) {
+            x = a[i];
+            y = b[i];
+            break;
+          }
+        }
+        if (x < y)
+          return -1;
+        if (y < x)
+          return 1;
+        return 0;
+      };
+      Buffer2.isEncoding = function isEncoding(encoding) {
+        switch (String(encoding).toLowerCase()) {
+          case "hex":
+          case "utf8":
+          case "utf-8":
+          case "ascii":
+          case "latin1":
+          case "binary":
+          case "base64":
+          case "ucs2":
+          case "ucs-2":
+          case "utf16le":
+          case "utf-16le":
+            return true;
+          default:
+            return false;
+        }
+      };
+      Buffer2.concat = function concat(list, length) {
+        if (!Array.isArray(list)) {
+          throw new TypeError('"list" argument must be an Array of Buffers');
+        }
+        if (list.length === 0) {
+          return Buffer2.alloc(0);
+        }
+        let i;
+        if (length === void 0) {
+          length = 0;
+          for (i = 0; i < list.length; ++i) {
+            length += list[i].length;
+          }
+        }
+        const buffer = Buffer2.allocUnsafe(length);
+        let pos = 0;
+        for (i = 0; i < list.length; ++i) {
+          let buf = list[i];
+          if (isInstance(buf, Uint8Array)) {
+            if (pos + buf.length > buffer.length) {
+              if (!Buffer2.isBuffer(buf))
+                buf = Buffer2.from(buf);
+              buf.copy(buffer, pos);
+            } else {
+              Uint8Array.prototype.set.call(
+                buffer,
+                buf,
+                pos
+              );
+            }
+          } else if (!Buffer2.isBuffer(buf)) {
+            throw new TypeError('"list" argument must be an Array of Buffers');
+          } else {
+            buf.copy(buffer, pos);
+          }
+          pos += buf.length;
+        }
+        return buffer;
+      };
+      function byteLength(string, encoding) {
+        if (Buffer2.isBuffer(string)) {
+          return string.length;
+        }
+        if (ArrayBuffer.isView(string) || isInstance(string, ArrayBuffer)) {
+          return string.byteLength;
+        }
+        if (typeof string !== "string") {
+          throw new TypeError(
+            'The "string" argument must be one of type string, Buffer, or ArrayBuffer. Received type ' + typeof string
+          );
+        }
+        const len = string.length;
+        const mustMatch = arguments.length > 2 && arguments[2] === true;
+        if (!mustMatch && len === 0)
+          return 0;
+        let loweredCase = false;
+        for (; ; ) {
+          switch (encoding) {
+            case "ascii":
+            case "latin1":
+            case "binary":
+              return len;
+            case "utf8":
+            case "utf-8":
+              return utf8ToBytes(string).length;
+            case "ucs2":
+            case "ucs-2":
+            case "utf16le":
+            case "utf-16le":
+              return len * 2;
+            case "hex":
+              return len >>> 1;
+            case "base64":
+              return base64ToBytes(string).length;
+            default:
+              if (loweredCase) {
+                return mustMatch ? -1 : utf8ToBytes(string).length;
+              }
+              encoding = ("" + encoding).toLowerCase();
+              loweredCase = true;
+          }
+        }
+      }
+      Buffer2.byteLength = byteLength;
+      function slowToString(encoding, start, end) {
+        let loweredCase = false;
+        if (start === void 0 || start < 0) {
+          start = 0;
+        }
+        if (start > this.length) {
+          return "";
+        }
+        if (end === void 0 || end > this.length) {
+          end = this.length;
+        }
+        if (end <= 0) {
+          return "";
+        }
+        end >>>= 0;
+        start >>>= 0;
+        if (end <= start) {
+          return "";
+        }
+        if (!encoding)
+          encoding = "utf8";
+        while (true) {
+          switch (encoding) {
+            case "hex":
+              return hexSlice(this, start, end);
+            case "utf8":
+            case "utf-8":
+              return utf8Slice(this, start, end);
+            case "ascii":
+              return asciiSlice(this, start, end);
+            case "latin1":
+            case "binary":
+              return latin1Slice(this, start, end);
+            case "base64":
+              return base64Slice(this, start, end);
+            case "ucs2":
+            case "ucs-2":
+            case "utf16le":
+            case "utf-16le":
+              return utf16leSlice(this, start, end);
+            default:
+              if (loweredCase)
+                throw new TypeError("Unknown encoding: " + encoding);
+              encoding = (encoding + "").toLowerCase();
+              loweredCase = true;
+          }
+        }
+      }
+      Buffer2.prototype._isBuffer = true;
+      function swap(b, n, m) {
+        const i = b[n];
+        b[n] = b[m];
+        b[m] = i;
+      }
+      Buffer2.prototype.swap16 = function swap16() {
+        const len = this.length;
+        if (len % 2 !== 0) {
+          throw new RangeError("Buffer size must be a multiple of 16-bits");
+        }
+        for (let i = 0; i < len; i += 2) {
+          swap(this, i, i + 1);
+        }
+        return this;
+      };
+      Buffer2.prototype.swap32 = function swap32() {
+        const len = this.length;
+        if (len % 4 !== 0) {
+          throw new RangeError("Buffer size must be a multiple of 32-bits");
+        }
+        for (let i = 0; i < len; i += 4) {
+          swap(this, i, i + 3);
+          swap(this, i + 1, i + 2);
+        }
+        return this;
+      };
+      Buffer2.prototype.swap64 = function swap64() {
+        const len = this.length;
+        if (len % 8 !== 0) {
+          throw new RangeError("Buffer size must be a multiple of 64-bits");
+        }
+        for (let i = 0; i < len; i += 8) {
+          swap(this, i, i + 7);
+          swap(this, i + 1, i + 6);
+          swap(this, i + 2, i + 5);
+          swap(this, i + 3, i + 4);
+        }
+        return this;
+      };
+      Buffer2.prototype.toString = function toString() {
+        const length = this.length;
+        if (length === 0)
+          return "";
+        if (arguments.length === 0)
+          return utf8Slice(this, 0, length);
+        return slowToString.apply(this, arguments);
+      };
+      Buffer2.prototype.toLocaleString = Buffer2.prototype.toString;
+      Buffer2.prototype.equals = function equals(b) {
+        if (!Buffer2.isBuffer(b))
+          throw new TypeError("Argument must be a Buffer");
+        if (this === b)
+          return true;
+        return Buffer2.compare(this, b) === 0;
+      };
+      Buffer2.prototype.inspect = function inspect() {
+        let str = "";
+        const max = exports.INSPECT_MAX_BYTES;
+        str = this.toString("hex", 0, max).replace(/(.{2})/g, "$1 ").trim();
+        if (this.length > max)
+          str += " ... ";
+        return "<Buffer " + str + ">";
+      };
+      if (customInspectSymbol) {
+        Buffer2.prototype[customInspectSymbol] = Buffer2.prototype.inspect;
+      }
+      Buffer2.prototype.compare = function compare(target, start, end, thisStart, thisEnd) {
+        if (isInstance(target, Uint8Array)) {
+          target = Buffer2.from(target, target.offset, target.byteLength);
+        }
+        if (!Buffer2.isBuffer(target)) {
+          throw new TypeError(
+            'The "target" argument must be one of type Buffer or Uint8Array. Received type ' + typeof target
+          );
+        }
+        if (start === void 0) {
+          start = 0;
+        }
+        if (end === void 0) {
+          end = target ? target.length : 0;
+        }
+        if (thisStart === void 0) {
+          thisStart = 0;
+        }
+        if (thisEnd === void 0) {
+          thisEnd = this.length;
+        }
+        if (start < 0 || end > target.length || thisStart < 0 || thisEnd > this.length) {
+          throw new RangeError("out of range index");
+        }
+        if (thisStart >= thisEnd && start >= end) {
+          return 0;
+        }
+        if (thisStart >= thisEnd) {
+          return -1;
+        }
+        if (start >= end) {
+          return 1;
+        }
+        start >>>= 0;
+        end >>>= 0;
+        thisStart >>>= 0;
+        thisEnd >>>= 0;
+        if (this === target)
+          return 0;
+        let x = thisEnd - thisStart;
+        let y = end - start;
+        const len = Math.min(x, y);
+        const thisCopy = this.slice(thisStart, thisEnd);
+        const targetCopy = target.slice(start, end);
+        for (let i = 0; i < len; ++i) {
+          if (thisCopy[i] !== targetCopy[i]) {
+            x = thisCopy[i];
+            y = targetCopy[i];
+            break;
+          }
+        }
+        if (x < y)
+          return -1;
+        if (y < x)
+          return 1;
+        return 0;
+      };
+      function bidirectionalIndexOf(buffer, val, byteOffset, encoding, dir) {
+        if (buffer.length === 0)
+          return -1;
+        if (typeof byteOffset === "string") {
+          encoding = byteOffset;
+          byteOffset = 0;
+        } else if (byteOffset > 2147483647) {
+          byteOffset = 2147483647;
+        } else if (byteOffset < -2147483648) {
+          byteOffset = -2147483648;
+        }
+        byteOffset = +byteOffset;
+        if (numberIsNaN(byteOffset)) {
+          byteOffset = dir ? 0 : buffer.length - 1;
+        }
+        if (byteOffset < 0)
+          byteOffset = buffer.length + byteOffset;
+        if (byteOffset >= buffer.length) {
+          if (dir)
+            return -1;
+          else
+            byteOffset = buffer.length - 1;
+        } else if (byteOffset < 0) {
+          if (dir)
+            byteOffset = 0;
+          else
+            return -1;
+        }
+        if (typeof val === "string") {
+          val = Buffer2.from(val, encoding);
+        }
+        if (Buffer2.isBuffer(val)) {
+          if (val.length === 0) {
+            return -1;
+          }
+          return arrayIndexOf(buffer, val, byteOffset, encoding, dir);
+        } else if (typeof val === "number") {
+          val = val & 255;
+          if (typeof Uint8Array.prototype.indexOf === "function") {
+            if (dir) {
+              return Uint8Array.prototype.indexOf.call(buffer, val, byteOffset);
+            } else {
+              return Uint8Array.prototype.lastIndexOf.call(buffer, val, byteOffset);
+            }
+          }
+          return arrayIndexOf(buffer, [val], byteOffset, encoding, dir);
+        }
+        throw new TypeError("val must be string, number or Buffer");
+      }
+      function arrayIndexOf(arr, val, byteOffset, encoding, dir) {
+        let indexSize = 1;
+        let arrLength = arr.length;
+        let valLength = val.length;
+        if (encoding !== void 0) {
+          encoding = String(encoding).toLowerCase();
+          if (encoding === "ucs2" || encoding === "ucs-2" || encoding === "utf16le" || encoding === "utf-16le") {
+            if (arr.length < 2 || val.length < 2) {
+              return -1;
+            }
+            indexSize = 2;
+            arrLength /= 2;
+            valLength /= 2;
+            byteOffset /= 2;
+          }
+        }
+        function read(buf, i2) {
+          if (indexSize === 1) {
+            return buf[i2];
+          } else {
+            return buf.readUInt16BE(i2 * indexSize);
+          }
+        }
+        let i;
+        if (dir) {
+          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;
+              if (i - foundIndex + 1 === valLength)
+                return foundIndex * indexSize;
+            } else {
+              if (foundIndex !== -1)
+                i -= i - foundIndex;
+              foundIndex = -1;
+            }
+          }
+        } else {
+          if (byteOffset + valLength > arrLength)
+            byteOffset = arrLength - valLength;
+          for (i = byteOffset; i >= 0; i--) {
+            let found = true;
+            for (let j = 0; j < valLength; j++) {
+              if (read(arr, i + j) !== read(val, j)) {
+                found = false;
+                break;
+              }
+            }
+            if (found)
+              return i;
+          }
+        }
+        return -1;
+      }
+      Buffer2.prototype.includes = function includes(val, byteOffset, encoding) {
+        return this.indexOf(val, byteOffset, encoding) !== -1;
+      };
+      Buffer2.prototype.indexOf = function indexOf(val, byteOffset, encoding) {
+        return bidirectionalIndexOf(this, val, byteOffset, encoding, true);
+      };
+      Buffer2.prototype.lastIndexOf = function lastIndexOf(val, byteOffset, encoding) {
+        return bidirectionalIndexOf(this, val, byteOffset, encoding, false);
+      };
+      function hexWrite(buf, string, offset, length) {
+        offset = Number(offset) || 0;
+        const remaining = buf.length - offset;
+        if (!length) {
+          length = remaining;
+        } else {
+          length = Number(length);
+          if (length > remaining) {
+            length = remaining;
+          }
+        }
+        const strLen = string.length;
+        if (length > strLen / 2) {
+          length = strLen / 2;
+        }
+        let i;
+        for (i = 0; i < length; ++i) {
+          const parsed = parseInt(string.substr(i * 2, 2), 16);
+          if (numberIsNaN(parsed))
+            return i;
+          buf[offset + i] = parsed;
+        }
+        return i;
+      }
+      function utf8Write(buf, string, offset, length) {
+        return blitBuffer(utf8ToBytes(string, buf.length - offset), buf, offset, length);
+      }
+      function asciiWrite(buf, string, offset, length) {
+        return blitBuffer(asciiToBytes(string), buf, offset, length);
+      }
+      function base64Write(buf, string, offset, length) {
+        return blitBuffer(base64ToBytes(string), buf, offset, length);
+      }
+      function ucs2Write(buf, string, offset, length) {
+        return blitBuffer(utf16leToBytes(string, buf.length - offset), buf, offset, length);
+      }
+      Buffer2.prototype.write = function write(string, offset, length, encoding) {
+        if (offset === void 0) {
+          encoding = "utf8";
+          length = this.length;
+          offset = 0;
+        } else if (length === void 0 && typeof offset === "string") {
+          encoding = offset;
+          length = this.length;
+          offset = 0;
+        } else if (isFinite(offset)) {
+          offset = offset >>> 0;
+          if (isFinite(length)) {
+            length = length >>> 0;
+            if (encoding === void 0)
+              encoding = "utf8";
+          } else {
+            encoding = length;
+            length = void 0;
+          }
+        } else {
+          throw new Error(
+            "Buffer.write(string, encoding, offset[, length]) is no longer supported"
+          );
+        }
+        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";
+        let loweredCase = false;
+        for (; ; ) {
+          switch (encoding) {
+            case "hex":
+              return hexWrite(this, string, offset, length);
+            case "utf8":
+            case "utf-8":
+              return utf8Write(this, string, offset, length);
+            case "ascii":
+            case "latin1":
+            case "binary":
+              return asciiWrite(this, string, offset, length);
+            case "base64":
+              return base64Write(this, string, offset, length);
+            case "ucs2":
+            case "ucs-2":
+            case "utf16le":
+            case "utf-16le":
+              return ucs2Write(this, string, offset, length);
+            default:
+              if (loweredCase)
+                throw new TypeError("Unknown encoding: " + encoding);
+              encoding = ("" + encoding).toLowerCase();
+              loweredCase = true;
+          }
+        }
+      };
+      Buffer2.prototype.toJSON = function toJSON() {
+        return {
+          type: "Buffer",
+          data: Array.prototype.slice.call(this._arr || this, 0)
+        };
+      };
+      function base64Slice(buf, start, end) {
+        if (start === 0 && end === buf.length) {
+          return base64.fromByteArray(buf);
+        } else {
+          return base64.fromByteArray(buf.slice(start, end));
+        }
+      }
+      function utf8Slice(buf, start, end) {
+        end = Math.min(buf.length, end);
+        const res = [];
+        let i = start;
+        while (i < end) {
+          const firstByte = buf[i];
+          let codePoint = null;
+          let bytesPerSequence = firstByte > 239 ? 4 : firstByte > 223 ? 3 : firstByte > 191 ? 2 : 1;
+          if (i + bytesPerSequence <= end) {
+            let secondByte, thirdByte, fourthByte, tempCodePoint;
+            switch (bytesPerSequence) {
+              case 1:
+                if (firstByte < 128) {
+                  codePoint = firstByte;
+                }
+                break;
+              case 2:
+                secondByte = buf[i + 1];
+                if ((secondByte & 192) === 128) {
+                  tempCodePoint = (firstByte & 31) << 6 | secondByte & 63;
+                  if (tempCodePoint > 127) {
+                    codePoint = tempCodePoint;
+                  }
+                }
+                break;
+              case 3:
+                secondByte = buf[i + 1];
+                thirdByte = buf[i + 2];
+                if ((secondByte & 192) === 128 && (thirdByte & 192) === 128) {
+                  tempCodePoint = (firstByte & 15) << 12 | (secondByte & 63) << 6 | thirdByte & 63;
+                  if (tempCodePoint > 2047 && (tempCodePoint < 55296 || tempCodePoint > 57343)) {
+                    codePoint = tempCodePoint;
+                  }
+                }
+                break;
+              case 4:
+                secondByte = buf[i + 1];
+                thirdByte = buf[i + 2];
+                fourthByte = buf[i + 3];
+                if ((secondByte & 192) === 128 && (thirdByte & 192) === 128 && (fourthByte & 192) === 128) {
+                  tempCodePoint = (firstByte & 15) << 18 | (secondByte & 63) << 12 | (thirdByte & 63) << 6 | fourthByte & 63;
+                  if (tempCodePoint > 65535 && tempCodePoint < 1114112) {
+                    codePoint = tempCodePoint;
+                  }
+                }
+            }
+          }
+          if (codePoint === null) {
+            codePoint = 65533;
+            bytesPerSequence = 1;
+          } else if (codePoint > 65535) {
+            codePoint -= 65536;
+            res.push(codePoint >>> 10 & 1023 | 55296);
+            codePoint = 56320 | codePoint & 1023;
+          }
+          res.push(codePoint);
+          i += bytesPerSequence;
+        }
+        return decodeCodePointsArray(res);
+      }
+      var MAX_ARGUMENTS_LENGTH = 4096;
+      function decodeCodePointsArray(codePoints) {
+        const len = codePoints.length;
+        if (len <= MAX_ARGUMENTS_LENGTH) {
+          return String.fromCharCode.apply(String, codePoints);
+        }
+        let res = "";
+        let i = 0;
+        while (i < len) {
+          res += String.fromCharCode.apply(
+            String,
+            codePoints.slice(i, i += MAX_ARGUMENTS_LENGTH)
+          );
+        }
+        return res;
+      }
+      function asciiSlice(buf, start, end) {
+        let ret = "";
+        end = Math.min(buf.length, end);
+        for (let i = start; i < end; ++i) {
+          ret += String.fromCharCode(buf[i] & 127);
+        }
+        return ret;
+      }
+      function latin1Slice(buf, start, end) {
+        let ret = "";
+        end = Math.min(buf.length, end);
+        for (let i = start; i < end; ++i) {
+          ret += String.fromCharCode(buf[i]);
+        }
+        return ret;
+      }
+      function hexSlice(buf, start, end) {
+        const len = buf.length;
+        if (!start || start < 0)
+          start = 0;
+        if (!end || end < 0 || end > len)
+          end = len;
+        let out = "";
+        for (let i = start; i < end; ++i) {
+          out += hexSliceLookupTable[buf[i]];
+        }
+        return out;
+      }
+      function utf16leSlice(buf, start, end) {
+        const bytes = buf.slice(start, end);
+        let res = "";
+        for (let i = 0; i < bytes.length - 1; i += 2) {
+          res += String.fromCharCode(bytes[i] + bytes[i + 1] * 256);
+        }
+        return res;
+      }
+      Buffer2.prototype.slice = function slice(start, end) {
+        const len = this.length;
+        start = ~~start;
+        end = end === void 0 ? len : ~~end;
+        if (start < 0) {
+          start += len;
+          if (start < 0)
+            start = 0;
+        } else if (start > len) {
+          start = len;
+        }
+        if (end < 0) {
+          end += len;
+          if (end < 0)
+            end = 0;
+        } else if (end > len) {
+          end = len;
+        }
+        if (end < start)
+          end = start;
+        const newBuf = this.subarray(start, end);
+        Object.setPrototypeOf(newBuf, Buffer2.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");
+      }
+      Buffer2.prototype.readUintLE = Buffer2.prototype.readUIntLE = function readUIntLE(offset, byteLength2, noAssert) {
+        offset = offset >>> 0;
+        byteLength2 = byteLength2 >>> 0;
+        if (!noAssert)
+          checkOffset(offset, byteLength2, this.length);
+        let val = this[offset];
+        let mul = 1;
+        let i = 0;
+        while (++i < byteLength2 && (mul *= 256)) {
+          val += this[offset + i] * mul;
+        }
+        return val;
+      };
+      Buffer2.prototype.readUintBE = Buffer2.prototype.readUIntBE = function readUIntBE(offset, byteLength2, noAssert) {
+        offset = offset >>> 0;
+        byteLength2 = byteLength2 >>> 0;
+        if (!noAssert) {
+          checkOffset(offset, byteLength2, this.length);
+        }
+        let val = this[offset + --byteLength2];
+        let mul = 1;
+        while (byteLength2 > 0 && (mul *= 256)) {
+          val += this[offset + --byteLength2] * mul;
+        }
+        return val;
+      };
+      Buffer2.prototype.readUint8 = Buffer2.prototype.readUInt8 = function readUInt8(offset, noAssert) {
+        offset = offset >>> 0;
+        if (!noAssert)
+          checkOffset(offset, 1, this.length);
+        return this[offset];
+      };
+      Buffer2.prototype.readUint16LE = Buffer2.prototype.readUInt16LE = function readUInt16LE(offset, noAssert) {
+        offset = offset >>> 0;
+        if (!noAssert)
+          checkOffset(offset, 2, this.length);
+        return this[offset] | this[offset + 1] << 8;
+      };
+      Buffer2.prototype.readUint16BE = Buffer2.prototype.readUInt16BE = function readUInt16BE(offset, noAssert) {
+        offset = offset >>> 0;
+        if (!noAssert)
+          checkOffset(offset, 2, this.length);
+        return this[offset] << 8 | this[offset + 1];
+      };
+      Buffer2.prototype.readUint32LE = Buffer2.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;
+      };
+      Buffer2.prototype.readUint32BE = Buffer2.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]);
+      };
+      Buffer2.prototype.readBigUInt64LE = defineBigIntMethod(function readBigUInt64LE(offset) {
+        offset = offset >>> 0;
+        validateNumber(offset, "offset");
+        const first = this[offset];
+        const last = this[offset + 7];
+        if (first === void 0 || last === void 0) {
+          boundsError(offset, this.length - 8);
+        }
+        const lo = first + this[++offset] * 2 ** 8 + this[++offset] * 2 ** 16 + this[++offset] * 2 ** 24;
+        const hi = this[++offset] + this[++offset] * 2 ** 8 + this[++offset] * 2 ** 16 + last * 2 ** 24;
+        return BigInt(lo) + (BigInt(hi) << BigInt(32));
+      });
+      Buffer2.prototype.readBigUInt64BE = defineBigIntMethod(function readBigUInt64BE(offset) {
+        offset = offset >>> 0;
+        validateNumber(offset, "offset");
+        const first = this[offset];
+        const last = this[offset + 7];
+        if (first === void 0 || last === void 0) {
+          boundsError(offset, this.length - 8);
+        }
+        const hi = first * 2 ** 24 + this[++offset] * 2 ** 16 + this[++offset] * 2 ** 8 + this[++offset];
+        const lo = this[++offset] * 2 ** 24 + this[++offset] * 2 ** 16 + this[++offset] * 2 ** 8 + last;
+        return (BigInt(hi) << BigInt(32)) + BigInt(lo);
+      });
+      Buffer2.prototype.readIntLE = function readIntLE(offset, byteLength2, noAssert) {
+        offset = offset >>> 0;
+        byteLength2 = byteLength2 >>> 0;
+        if (!noAssert)
+          checkOffset(offset, byteLength2, this.length);
+        let val = this[offset];
+        let mul = 1;
+        let i = 0;
+        while (++i < byteLength2 && (mul *= 256)) {
+          val += this[offset + i] * mul;
+        }
+        mul *= 128;
+        if (val >= mul)
+          val -= Math.pow(2, 8 * byteLength2);
+        return val;
+      };
+      Buffer2.prototype.readIntBE = function readIntBE(offset, byteLength2, noAssert) {
+        offset = offset >>> 0;
+        byteLength2 = byteLength2 >>> 0;
+        if (!noAssert)
+          checkOffset(offset, byteLength2, this.length);
+        let i = byteLength2;
+        let mul = 1;
+        let val = this[offset + --i];
+        while (i > 0 && (mul *= 256)) {
+          val += this[offset + --i] * mul;
+        }
+        mul *= 128;
+        if (val >= mul)
+          val -= Math.pow(2, 8 * byteLength2);
+        return val;
+      };
+      Buffer2.prototype.readInt8 = function readInt8(offset, noAssert) {
+        offset = offset >>> 0;
+        if (!noAssert)
+          checkOffset(offset, 1, this.length);
+        if (!(this[offset] & 128))
+          return this[offset];
+        return (255 - this[offset] + 1) * -1;
+      };
+      Buffer2.prototype.readInt16LE = function readInt16LE(offset, noAssert) {
+        offset = offset >>> 0;
+        if (!noAssert)
+          checkOffset(offset, 2, this.length);
+        const val = this[offset] | this[offset + 1] << 8;
+        return val & 32768 ? val | 4294901760 : val;
+      };
+      Buffer2.prototype.readInt16BE = function readInt16BE(offset, noAssert) {
+        offset = offset >>> 0;
+        if (!noAssert)
+          checkOffset(offset, 2, this.length);
+        const val = this[offset + 1] | this[offset] << 8;
+        return val & 32768 ? val | 4294901760 : val;
+      };
+      Buffer2.prototype.readInt32LE = function readInt32LE(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] << 24;
+      };
+      Buffer2.prototype.readInt32BE = function readInt32BE(offset, noAssert) {
+        offset = offset >>> 0;
+        if (!noAssert)
+          checkOffset(offset, 4, this.length);
+        return this[offset] << 24 | this[offset + 1] << 16 | this[offset + 2] << 8 | this[offset + 3];
+      };
+      Buffer2.prototype.readBigInt64LE = defineBigIntMethod(function readBigInt64LE(offset) {
+        offset = offset >>> 0;
+        validateNumber(offset, "offset");
+        const first = this[offset];
+        const last = this[offset + 7];
+        if (first === void 0 || last === void 0) {
+          boundsError(offset, this.length - 8);
+        }
+        const val = this[offset + 4] + this[offset + 5] * 2 ** 8 + this[offset + 6] * 2 ** 16 + (last << 24);
+        return (BigInt(val) << BigInt(32)) + BigInt(first + this[++offset] * 2 ** 8 + this[++offset] * 2 ** 16 + this[++offset] * 2 ** 24);
+      });
+      Buffer2.prototype.readBigInt64BE = defineBigIntMethod(function readBigInt64BE(offset) {
+        offset = offset >>> 0;
+        validateNumber(offset, "offset");
+        const first = this[offset];
+        const last = this[offset + 7];
+        if (first === void 0 || last === void 0) {
+          boundsError(offset, this.length - 8);
+        }
+        const val = (first << 24) + // Overflow
+        this[++offset] * 2 ** 16 + this[++offset] * 2 ** 8 + this[++offset];
+        return (BigInt(val) << BigInt(32)) + BigInt(this[++offset] * 2 ** 24 + this[++offset] * 2 ** 16 + this[++offset] * 2 ** 8 + last);
+      });
+      Buffer2.prototype.readFloatLE = function readFloatLE(offset, noAssert) {
+        offset = offset >>> 0;
+        if (!noAssert)
+          checkOffset(offset, 4, this.length);
+        return ieee754.read(this, offset, true, 23, 4);
+      };
+      Buffer2.prototype.readFloatBE = function readFloatBE(offset, noAssert) {
+        offset = offset >>> 0;
+        if (!noAssert)
+          checkOffset(offset, 4, this.length);
+        return ieee754.read(this, offset, false, 23, 4);
+      };
+      Buffer2.prototype.readDoubleLE = function readDoubleLE(offset, noAssert) {
+        offset = offset >>> 0;
+        if (!noAssert)
+          checkOffset(offset, 8, this.length);
+        return ieee754.read(this, offset, true, 52, 8);
+      };
+      Buffer2.prototype.readDoubleBE = function readDoubleBE(offset, noAssert) {
+        offset = offset >>> 0;
+        if (!noAssert)
+          checkOffset(offset, 8, this.length);
+        return ieee754.read(this, offset, false, 52, 8);
+      };
+      function checkInt(buf, value, offset, ext, max, min) {
+        if (!Buffer2.isBuffer(buf))
+          throw new TypeError('"buffer" argument must be a Buffer instance');
+        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");
+      }
+      Buffer2.prototype.writeUintLE = Buffer2.prototype.writeUIntLE = function writeUIntLE(value, offset, byteLength2, noAssert) {
+        value = +value;
+        offset = offset >>> 0;
+        byteLength2 = byteLength2 >>> 0;
+        if (!noAssert) {
+          const maxBytes = Math.pow(2, 8 * byteLength2) - 1;
+          checkInt(this, value, offset, byteLength2, maxBytes, 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;
+      };
+      Buffer2.prototype.writeUintBE = Buffer2.prototype.writeUIntBE = function writeUIntBE(value, offset, byteLength2, noAssert) {
+        value = +value;
+        offset = offset >>> 0;
+        byteLength2 = byteLength2 >>> 0;
+        if (!noAssert) {
+          const maxBytes = Math.pow(2, 8 * byteLength2) - 1;
+          checkInt(this, value, offset, byteLength2, maxBytes, 0);
+        }
+        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;
+      };
+      Buffer2.prototype.writeUint8 = Buffer2.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;
+      };
+      Buffer2.prototype.writeUint16LE = Buffer2.prototype.writeUInt16LE = function writeUInt16LE(value, offset, noAssert) {
+        value = +value;
+        offset = offset >>> 0;
+        if (!noAssert)
+          checkInt(this, value, offset, 2, 65535, 0);
+        this[offset] = value & 255;
+        this[offset + 1] = value >>> 8;
+        return offset + 2;
+      };
+      Buffer2.prototype.writeUint16BE = Buffer2.prototype.writeUInt16BE = function writeUInt16BE(value, offset, noAssert) {
+        value = +value;
+        offset = offset >>> 0;
+        if (!noAssert)
+          checkInt(this, value, offset, 2, 65535, 0);
+        this[offset] = value >>> 8;
+        this[offset + 1] = value & 255;
+        return offset + 2;
+      };
+      Buffer2.prototype.writeUint32LE = Buffer2.prototype.writeUInt32LE = function writeUInt32LE(value, offset, noAssert) {
+        value = +value;
+        offset = offset >>> 0;
+        if (!noAssert)
+          checkInt(this, value, offset, 4, 4294967295, 0);
+        this[offset + 3] = value >>> 24;
+        this[offset + 2] = value >>> 16;
+        this[offset + 1] = value >>> 8;
+        this[offset] = value & 255;
+        return offset + 4;
+      };
+      Buffer2.prototype.writeUint32BE = Buffer2.prototype.writeUInt32BE = function writeUInt32BE(value, offset, noAssert) {
+        value = +value;
+        offset = offset >>> 0;
+        if (!noAssert)
+          checkInt(this, value, offset, 4, 4294967295, 0);
+        this[offset] = value >>> 24;
+        this[offset + 1] = value >>> 16;
+        this[offset + 2] = value >>> 8;
+        this[offset + 3] = value & 255;
+        return offset + 4;
+      };
+      function wrtBigUInt64LE(buf, value, offset, min, max) {
+        checkIntBI(value, min, max, buf, offset, 7);
+        let lo = Number(value & BigInt(4294967295));
+        buf[offset++] = lo;
+        lo = lo >> 8;
+        buf[offset++] = lo;
+        lo = lo >> 8;
+        buf[offset++] = lo;
+        lo = lo >> 8;
+        buf[offset++] = lo;
+        let hi = Number(value >> BigInt(32) & BigInt(4294967295));
+        buf[offset++] = hi;
+        hi = hi >> 8;
+        buf[offset++] = hi;
+        hi = hi >> 8;
+        buf[offset++] = hi;
+        hi = hi >> 8;
+        buf[offset++] = hi;
+        return offset;
+      }
+      function wrtBigUInt64BE(buf, value, offset, min, max) {
+        checkIntBI(value, min, max, buf, offset, 7);
+        let lo = Number(value & BigInt(4294967295));
+        buf[offset + 7] = lo;
+        lo = lo >> 8;
+        buf[offset + 6] = lo;
+        lo = lo >> 8;
+        buf[offset + 5] = lo;
+        lo = lo >> 8;
+        buf[offset + 4] = lo;
+        let hi = Number(value >> BigInt(32) & BigInt(4294967295));
+        buf[offset + 3] = hi;
+        hi = hi >> 8;
+        buf[offset + 2] = hi;
+        hi = hi >> 8;
+        buf[offset + 1] = hi;
+        hi = hi >> 8;
+        buf[offset] = hi;
+        return offset + 8;
+      }
+      Buffer2.prototype.writeBigUInt64LE = defineBigIntMethod(function writeBigUInt64LE(value, offset = 0) {
+        return wrtBigUInt64LE(this, value, offset, BigInt(0), BigInt("0xffffffffffffffff"));
+      });
+      Buffer2.prototype.writeBigUInt64BE = defineBigIntMethod(function writeBigUInt64BE(value, offset = 0) {
+        return wrtBigUInt64BE(this, value, offset, BigInt(0), BigInt("0xffffffffffffffff"));
+      });
+      Buffer2.prototype.writeIntLE = function writeIntLE(value, offset, byteLength2, noAssert) {
+        value = +value;
+        offset = offset >>> 0;
+        if (!noAssert) {
+          const limit = Math.pow(2, 8 * byteLength2 - 1);
+          checkInt(this, value, offset, byteLength2, limit - 1, -limit);
+        }
+        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) {
+            sub = 1;
+          }
+          this[offset + i] = (value / mul >> 0) - sub & 255;
+        }
+        return offset + byteLength2;
+      };
+      Buffer2.prototype.writeIntBE = function writeIntBE(value, offset, byteLength2, noAssert) {
+        value = +value;
+        offset = offset >>> 0;
+        if (!noAssert) {
+          const limit = Math.pow(2, 8 * byteLength2 - 1);
+          checkInt(this, value, offset, byteLength2, limit - 1, -limit);
+        }
+        let i = byteLength2 - 1;
+        let mul = 1;
+        let sub = 0;
+        this[offset + i] = value & 255;
+        while (--i >= 0 && (mul *= 256)) {
+          if (value < 0 && sub === 0 && this[offset + i + 1] !== 0) {
+            sub = 1;
+          }
+          this[offset + i] = (value / mul >> 0) - sub & 255;
+        }
+        return offset + byteLength2;
+      };
+      Buffer2.prototype.writeInt8 = function writeInt8(value, offset, noAssert) {
+        value = +value;
+        offset = offset >>> 0;
+        if (!noAssert)
+          checkInt(this, value, offset, 1, 127, -128);
+        if (value < 0)
+          value = 255 + value + 1;
+        this[offset] = value & 255;
+        return offset + 1;
+      };
+      Buffer2.prototype.writeInt16LE = function writeInt16LE(value, offset, noAssert) {
+        value = +value;
+        offset = offset >>> 0;
+        if (!noAssert)
+          checkInt(this, value, offset, 2, 32767, -32768);
+        this[offset] = value & 255;
+        this[offset + 1] = value >>> 8;
+        return offset + 2;
+      };
+      Buffer2.prototype.writeInt16BE = function writeInt16BE(value, offset, noAssert) {
+        value = +value;
+        offset = offset >>> 0;
+        if (!noAssert)
+          checkInt(this, value, offset, 2, 32767, -32768);
+        this[offset] = value >>> 8;
+        this[offset + 1] = value & 255;
+        return offset + 2;
+      };
+      Buffer2.prototype.writeInt32LE = function writeInt32LE(value, offset, noAssert) {
+        value = +value;
+        offset = offset >>> 0;
+        if (!noAssert)
+          checkInt(this, value, offset, 4, 2147483647, -2147483648);
+        this[offset] = value & 255;
+        this[offset + 1] = value >>> 8;
+        this[offset + 2] = value >>> 16;
+        this[offset + 3] = value >>> 24;
+        return offset + 4;
+      };
+      Buffer2.prototype.writeInt32BE = function writeInt32BE(value, offset, noAssert) {
+        value = +value;
+        offset = offset >>> 0;
+        if (!noAssert)
+          checkInt(this, value, offset, 4, 2147483647, -2147483648);
+        if (value < 0)
+          value = 4294967295 + value + 1;
+        this[offset] = value >>> 24;
+        this[offset + 1] = value >>> 16;
+        this[offset + 2] = value >>> 8;
+        this[offset + 3] = value & 255;
+        return offset + 4;
+      };
+      Buffer2.prototype.writeBigInt64LE = defineBigIntMethod(function writeBigInt64LE(value, offset = 0) {
+        return wrtBigUInt64LE(this, value, offset, -BigInt("0x8000000000000000"), BigInt("0x7fffffffffffffff"));
+      });
+      Buffer2.prototype.writeBigInt64BE = defineBigIntMethod(function writeBigInt64BE(value, offset = 0) {
+        return wrtBigUInt64BE(this, value, offset, -BigInt("0x8000000000000000"), BigInt("0x7fffffffffffffff"));
+      });
+      function checkIEEE754(buf, value, offset, ext, max, min) {
+        if (offset + ext > buf.length)
+          throw new RangeError("Index out of range");
+        if (offset < 0)
+          throw new RangeError("Index out of range");
+      }
+      function writeFloat(buf, value, offset, littleEndian, noAssert) {
+        value = +value;
+        offset = offset >>> 0;
+        if (!noAssert) {
+          checkIEEE754(buf, value, offset, 4, 34028234663852886e22, -34028234663852886e22);
+        }
+        ieee754.write(buf, value, offset, littleEndian, 23, 4);
+        return offset + 4;
+      }
+      Buffer2.prototype.writeFloatLE = function writeFloatLE(value, offset, noAssert) {
+        return writeFloat(this, value, offset, true, noAssert);
+      };
+      Buffer2.prototype.writeFloatBE = function writeFloatBE(value, offset, noAssert) {
+        return writeFloat(this, value, offset, false, noAssert);
+      };
+      function writeDouble(buf, value, offset, littleEndian, noAssert) {
+        value = +value;
+        offset = offset >>> 0;
+        if (!noAssert) {
+          checkIEEE754(buf, value, offset, 8, 17976931348623157e292, -17976931348623157e292);
+        }
+        ieee754.write(buf, value, offset, littleEndian, 52, 8);
+        return offset + 8;
+      }
+      Buffer2.prototype.writeDoubleLE = function writeDoubleLE(value, offset, noAssert) {
+        return writeDouble(this, value, offset, true, noAssert);
+      };
+      Buffer2.prototype.writeDoubleBE = function writeDoubleBE(value, offset, noAssert) {
+        return writeDouble(this, value, offset, false, noAssert);
+      };
+      Buffer2.prototype.copy = function copy(target, targetStart, start, end) {
+        if (!Buffer2.isBuffer(target))
+          throw new TypeError("argument should be a Buffer");
+        if (!start)
+          start = 0;
+        if (!end && end !== 0)
+          end = this.length;
+        if (targetStart >= target.length)
+          targetStart = target.length;
+        if (!targetStart)
+          targetStart = 0;
+        if (end > 0 && end < start)
+          end = start;
+        if (end === start)
+          return 0;
+        if (target.length === 0 || this.length === 0)
+          return 0;
+        if (targetStart < 0) {
+          throw new RangeError("targetStart out of bounds");
+        }
+        if (start < 0 || start >= this.length)
+          throw new RangeError("Index out of range");
+        if (end < 0)
+          throw new RangeError("sourceEnd out of bounds");
+        if (end > this.length)
+          end = this.length;
+        if (target.length - targetStart < end - start) {
+          end = target.length - targetStart + start;
+        }
+        const len = end - start;
+        if (this === target && typeof Uint8Array.prototype.copyWithin === "function") {
+          this.copyWithin(targetStart, start, end);
+        } else {
+          Uint8Array.prototype.set.call(
+            target,
+            this.subarray(start, end),
+            targetStart
+          );
+        }
+        return len;
+      };
+      Buffer2.prototype.fill = function fill(val, start, end, encoding) {
+        if (typeof val === "string") {
+          if (typeof start === "string") {
+            encoding = start;
+            start = 0;
+            end = this.length;
+          } else if (typeof end === "string") {
+            encoding = end;
+            end = this.length;
+          }
+          if (encoding !== void 0 && typeof encoding !== "string") {
+            throw new TypeError("encoding must be a string");
+          }
+          if (typeof encoding === "string" && !Buffer2.isEncoding(encoding)) {
+            throw new TypeError("Unknown encoding: " + encoding);
+          }
+          if (val.length === 1) {
+            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");
+        }
+        if (end <= start) {
+          return this;
+        }
+        start = start >>> 0;
+        end = end === void 0 ? this.length : end >>> 0;
+        if (!val)
+          val = 0;
+        let i;
+        if (typeof val === "number") {
+          for (i = start; i < end; ++i) {
+            this[i] = val;
+          }
+        } else {
+          const bytes = Buffer2.isBuffer(val) ? val : Buffer2.from(val, encoding);
+          const len = bytes.length;
+          if (len === 0) {
+            throw new TypeError('The value "' + val + '" is invalid for argument "value"');
+          }
+          for (i = 0; i < end - start; ++i) {
+            this[i + start] = bytes[i % len];
+          }
+        }
+        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];
+        str = str.trim().replace(INVALID_BASE64_RE, "");
+        if (str.length < 2)
+          return "";
+        while (str.length % 4 !== 0) {
+          str = str + "=";
+        }
+        return str;
+      }
+      function utf8ToBytes(string, units) {
+        units = units || Infinity;
+        let codePoint;
+        const length = string.length;
+        let leadSurrogate = null;
+        const bytes = [];
+        for (let i = 0; i < length; ++i) {
+          codePoint = string.charCodeAt(i);
+          if (codePoint > 55295 && codePoint < 57344) {
+            if (!leadSurrogate) {
+              if (codePoint > 56319) {
+                if ((units -= 3) > -1)
+                  bytes.push(239, 191, 189);
+                continue;
+              } else if (i + 1 === length) {
+                if ((units -= 3) > -1)
+                  bytes.push(239, 191, 189);
+                continue;
+              }
+              leadSurrogate = codePoint;
+              continue;
+            }
+            if (codePoint < 56320) {
+              if ((units -= 3) > -1)
+                bytes.push(239, 191, 189);
+              leadSurrogate = codePoint;
+              continue;
+            }
+            codePoint = (leadSurrogate - 55296 << 10 | codePoint - 56320) + 65536;
+          } else if (leadSurrogate) {
+            if ((units -= 3) > -1)
+              bytes.push(239, 191, 189);
+          }
+          leadSurrogate = null;
+          if (codePoint < 128) {
+            if ((units -= 1) < 0)
+              break;
+            bytes.push(codePoint);
+          } else if (codePoint < 2048) {
+            if ((units -= 2) < 0)
+              break;
+            bytes.push(
+              codePoint >> 6 | 192,
+              codePoint & 63 | 128
+            );
+          } else if (codePoint < 65536) {
+            if ((units -= 3) < 0)
+              break;
+            bytes.push(
+              codePoint >> 12 | 224,
+              codePoint >> 6 & 63 | 128,
+              codePoint & 63 | 128
+            );
+          } else if (codePoint < 1114112) {
+            if ((units -= 4) < 0)
+              break;
+            bytes.push(
+              codePoint >> 18 | 240,
+              codePoint >> 12 & 63 | 128,
+              codePoint >> 6 & 63 | 128,
+              codePoint & 63 | 128
+            );
+          } else {
+            throw new Error("Invalid code point");
+          }
+        }
+        return bytes;
+      }
+      function asciiToBytes(str) {
+        const byteArray = [];
+        for (let i = 0; i < str.length; ++i) {
+          byteArray.push(str.charCodeAt(i) & 255);
+        }
+        return byteArray;
+      }
+      function utf16leToBytes(str, units) {
+        let c, hi, lo;
+        const byteArray = [];
+        for (let i = 0; i < str.length; ++i) {
+          if ((units -= 2) < 0)
+            break;
+          c = str.charCodeAt(i);
+          hi = c >> 8;
+          lo = c % 256;
+          byteArray.push(lo);
+          byteArray.push(hi);
+        }
+        return byteArray;
+      }
+      function base64ToBytes(str) {
+        return base64.toByteArray(base64clean(str));
+      }
+      function blitBuffer(src, dst, offset, length) {
+        let i;
+        for (i = 0; i < length; ++i) {
+          if (i + offset >= dst.length || i >= src.length)
+            break;
+          dst[i + offset] = src[i];
+        }
+        return i;
+      }
+      function isInstance(obj, type) {
+        return obj instanceof type || obj != null && obj.constructor != null && obj.constructor.name != null && obj.constructor.name === type.name;
+      }
+      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");
+      }
+    }
+  });
+
+  // ../../../../../../node_modules/safe-buffer/index.js
+  var require_safe_buffer = __commonJS({
+    "../../../../../../node_modules/safe-buffer/index.js"(exports, module) {
+      var buffer = require_buffer();
+      var Buffer2 = buffer.Buffer;
+      function copyProps(src, dst) {
+        for (var key in src) {
+          dst[key] = src[key];
+        }
+      }
+      if (Buffer2.from && Buffer2.alloc && Buffer2.allocUnsafe && Buffer2.allocUnsafeSlow) {
+        module.exports = buffer;
+      } else {
+        copyProps(buffer, exports);
+        exports.Buffer = SafeBuffer;
+      }
+      function SafeBuffer(arg, encodingOrOffset, length) {
+        return Buffer2(arg, encodingOrOffset, length);
+      }
+      SafeBuffer.prototype = Object.create(Buffer2.prototype);
+      copyProps(Buffer2, SafeBuffer);
+      SafeBuffer.from = function(arg, encodingOrOffset, length) {
+        if (typeof arg === "number") {
+          throw new TypeError("Argument must not be a number");
+        }
+        return Buffer2(arg, encodingOrOffset, length);
+      };
+      SafeBuffer.alloc = function(size, fill, encoding) {
+        if (typeof size !== "number") {
+          throw new TypeError("Argument must be a number");
+        }
+        var buf = Buffer2(size);
+        if (fill !== void 0) {
+          if (typeof encoding === "string") {
+            buf.fill(fill, encoding);
+          } else {
+            buf.fill(fill);
+          }
+        } else {
+          buf.fill(0);
+        }
+        return buf;
+      };
+      SafeBuffer.allocUnsafe = function(size) {
+        if (typeof size !== "number") {
+          throw new TypeError("Argument must be a number");
+        }
+        return Buffer2(size);
+      };
+      SafeBuffer.allocUnsafeSlow = function(size) {
+        if (typeof size !== "number") {
+          throw new TypeError("Argument must be a number");
+        }
+        return buffer.SlowBuffer(size);
+      };
+    }
+  });
+
+  // ../../../../../../node_modules/sha.js/hash.js
+  var require_hash = __commonJS({
+    "../../../../../../node_modules/sha.js/hash.js"(exports, module) {
+      var Buffer2 = require_safe_buffer().Buffer;
+      function Hash(blockSize, finalSize) {
+        this._block = Buffer2.alloc(blockSize);
+        this._finalSize = finalSize;
+        this._blockSize = blockSize;
+        this._len = 0;
+      }
+      Hash.prototype.update = function(data, enc) {
+        if (typeof data === "string") {
+          enc = enc || "utf8";
+          data = Buffer2.from(data, enc);
+        }
+        var block = this._block;
+        var blockSize = this._blockSize;
+        var length = data.length;
+        var accum = this._len;
+        for (var offset = 0; offset < length; ) {
+          var assigned = accum % blockSize;
+          var remainder = Math.min(length - offset, blockSize - assigned);
+          for (var i = 0; i < remainder; i++) {
+            block[assigned + i] = data[offset + i];
+          }
+          accum += remainder;
+          offset += remainder;
+          if (accum % blockSize === 0) {
+            this._update(block);
+          }
+        }
+        this._len += length;
+        return this;
+      };
+      Hash.prototype.digest = function(enc) {
+        var rem = this._len % this._blockSize;
+        this._block[rem] = 128;
+        this._block.fill(0, rem + 1);
+        if (rem >= this._finalSize) {
+          this._update(this._block);
+          this._block.fill(0);
+        }
+        var bits = this._len * 8;
+        if (bits <= 4294967295) {
+          this._block.writeUInt32BE(bits, this._blockSize - 4);
+        } else {
+          var lowBits = (bits & 4294967295) >>> 0;
+          var highBits = (bits - lowBits) / 4294967296;
+          this._block.writeUInt32BE(highBits, this._blockSize - 8);
+          this._block.writeUInt32BE(lowBits, this._blockSize - 4);
+        }
+        this._update(this._block);
+        var hash = this._hash();
+        return enc ? hash.toString(enc) : hash;
+      };
+      Hash.prototype._update = function() {
+        throw new Error("_update must be implemented by subclass");
+      };
+      module.exports = Hash;
+    }
+  });
+
+  // ../../../../../../node_modules/sha.js/sha.js
+  var require_sha = __commonJS({
+    "../../../../../../node_modules/sha.js/sha.js"(exports, module) {
+      var inherits = require_inherits_browser();
+      var Hash = require_hash();
+      var Buffer2 = require_safe_buffer().Buffer;
+      var K = [
+        1518500249,
+        1859775393,
+        2400959708 | 0,
+        3395469782 | 0
+      ];
+      var W = new Array(80);
+      function Sha() {
+        this.init();
+        this._w = W;
+        Hash.call(this, 64, 56);
+      }
+      inherits(Sha, Hash);
+      Sha.prototype.init = function() {
+        this._a = 1732584193;
+        this._b = 4023233417;
+        this._c = 2562383102;
+        this._d = 271733878;
+        this._e = 3285377520;
+        return this;
+      };
+      function rotl5(num) {
+        return num << 5 | num >>> 27;
+      }
+      function rotl30(num) {
+        return num << 30 | num >>> 2;
+      }
+      function ft(s, b, c, d) {
+        if (s === 0)
+          return b & c | ~b & d;
+        if (s === 2)
+          return b & c | b & d | c & d;
+        return b ^ c ^ d;
+      }
+      Sha.prototype._update = function(M) {
+        var W2 = this._w;
+        var a = this._a | 0;
+        var b = this._b | 0;
+        var c = this._c | 0;
+        var d = this._d | 0;
+        var e = this._e | 0;
+        for (var i = 0; i < 16; ++i)
+          W2[i] = M.readInt32BE(i * 4);
+        for (; i < 80; ++i)
+          W2[i] = W2[i - 3] ^ W2[i - 8] ^ W2[i - 14] ^ W2[i - 16];
+        for (var j = 0; j < 80; ++j) {
+          var s = ~~(j / 20);
+          var t = rotl5(a) + ft(s, b, c, d) + e + W2[j] + K[s] | 0;
+          e = d;
+          d = c;
+          c = rotl30(b);
+          b = a;
+          a = t;
+        }
+        this._a = a + this._a | 0;
+        this._b = b + this._b | 0;
+        this._c = c + this._c | 0;
+        this._d = d + this._d | 0;
+        this._e = e + this._e | 0;
+      };
+      Sha.prototype._hash = function() {
+        var H = Buffer2.allocUnsafe(20);
+        H.writeInt32BE(this._a | 0, 0);
+        H.writeInt32BE(this._b | 0, 4);
+        H.writeInt32BE(this._c | 0, 8);
+        H.writeInt32BE(this._d | 0, 12);
+        H.writeInt32BE(this._e | 0, 16);
+        return H;
+      };
+      module.exports = Sha;
+    }
+  });
+
+  // ../../../../../../node_modules/sha.js/sha1.js
+  var require_sha1 = __commonJS({
+    "../../../../../../node_modules/sha.js/sha1.js"(exports, module) {
+      var inherits = require_inherits_browser();
+      var Hash = require_hash();
+      var Buffer2 = require_safe_buffer().Buffer;
+      var K = [
+        1518500249,
+        1859775393,
+        2400959708 | 0,
+        3395469782 | 0
+      ];
+      var W = new Array(80);
+      function Sha1() {
+        this.init();
+        this._w = W;
+        Hash.call(this, 64, 56);
+      }
+      inherits(Sha1, Hash);
+      Sha1.prototype.init = function() {
+        this._a = 1732584193;
+        this._b = 4023233417;
+        this._c = 2562383102;
+        this._d = 271733878;
+        this._e = 3285377520;
+        return this;
+      };
+      function rotl1(num) {
+        return num << 1 | num >>> 31;
+      }
+      function rotl5(num) {
+        return num << 5 | num >>> 27;
+      }
+      function rotl30(num) {
+        return num << 30 | num >>> 2;
+      }
+      function ft(s, b, c, d) {
+        if (s === 0)
+          return b & c | ~b & d;
+        if (s === 2)
+          return b & c | b & d | c & d;
+        return b ^ c ^ d;
+      }
+      Sha1.prototype._update = function(M) {
+        var W2 = this._w;
+        var a = this._a | 0;
+        var b = this._b | 0;
+        var c = this._c | 0;
+        var d = this._d | 0;
+        var e = this._e | 0;
+        for (var i = 0; i < 16; ++i)
+          W2[i] = M.readInt32BE(i * 4);
+        for (; i < 80; ++i)
+          W2[i] = rotl1(W2[i - 3] ^ W2[i - 8] ^ W2[i - 14] ^ W2[i - 16]);
+        for (var j = 0; j < 80; ++j) {
+          var s = ~~(j / 20);
+          var t = rotl5(a) + ft(s, b, c, d) + e + W2[j] + K[s] | 0;
+          e = d;
+          d = c;
+          c = rotl30(b);
+          b = a;
+          a = t;
+        }
+        this._a = a + this._a | 0;
+        this._b = b + this._b | 0;
+        this._c = c + this._c | 0;
+        this._d = d + this._d | 0;
+        this._e = e + this._e | 0;
+      };
+      Sha1.prototype._hash = function() {
+        var H = Buffer2.allocUnsafe(20);
+        H.writeInt32BE(this._a | 0, 0);
+        H.writeInt32BE(this._b | 0, 4);
+        H.writeInt32BE(this._c | 0, 8);
+        H.writeInt32BE(this._d | 0, 12);
+        H.writeInt32BE(this._e | 0, 16);
+        return H;
+      };
+      module.exports = Sha1;
+    }
+  });
+
+  // ../../../../../../node_modules/sha.js/sha256.js
+  var require_sha256 = __commonJS({
+    "../../../../../../node_modules/sha.js/sha256.js"(exports, module) {
+      var inherits = require_inherits_browser();
+      var Hash = require_hash();
+      var Buffer2 = require_safe_buffer().Buffer;
+      var K = [
+        1116352408,
+        1899447441,
+        3049323471,
+        3921009573,
+        961987163,
+        1508970993,
+        2453635748,
+        2870763221,
+        3624381080,
+        310598401,
+        607225278,
+        1426881987,
+        1925078388,
+        2162078206,
+        2614888103,
+        3248222580,
+        3835390401,
+        4022224774,
+        264347078,
+        604807628,
+        770255983,
+        1249150122,
+        1555081692,
+        1996064986,
+        2554220882,
+        2821834349,
+        2952996808,
+        3210313671,
+        3336571891,
+        3584528711,
+        113926993,
+        338241895,
+        666307205,
+        773529912,
+        1294757372,
+        1396182291,
+        1695183700,
+        1986661051,
+        2177026350,
+        2456956037,
+        2730485921,
+        2820302411,
+        3259730800,
+        3345764771,
+        3516065817,
+        3600352804,
+        4094571909,
+        275423344,
+        430227734,
+        506948616,
+        659060556,
+        883997877,
+        958139571,
+        1322822218,
+        1537002063,
+        1747873779,
+        1955562222,
+        2024104815,
+        2227730452,
+        2361852424,
+        2428436474,
+        2756734187,
+        3204031479,
+        3329325298
+      ];
+      var W = new Array(64);
+      function Sha256() {
+        this.init();
+        this._w = W;
+        Hash.call(this, 64, 56);
+      }
+      inherits(Sha256, Hash);
+      Sha256.prototype.init = function() {
+        this._a = 1779033703;
+        this._b = 3144134277;
+        this._c = 1013904242;
+        this._d = 2773480762;
+        this._e = 1359893119;
+        this._f = 2600822924;
+        this._g = 528734635;
+        this._h = 1541459225;
+        return this;
+      };
+      function ch(x, y, z) {
+        return z ^ x & (y ^ z);
+      }
+      function maj(x, y, z) {
+        return x & y | z & (x | y);
+      }
+      function sigma0(x) {
+        return (x >>> 2 | x << 30) ^ (x >>> 13 | x << 19) ^ (x >>> 22 | x << 10);
+      }
+      function sigma1(x) {
+        return (x >>> 6 | x << 26) ^ (x >>> 11 | x << 21) ^ (x >>> 25 | x << 7);
+      }
+      function gamma0(x) {
+        return (x >>> 7 | x << 25) ^ (x >>> 18 | x << 14) ^ x >>> 3;
+      }
+      function gamma1(x) {
+        return (x >>> 17 | x << 15) ^ (x >>> 19 | x << 13) ^ x >>> 10;
+      }
+      Sha256.prototype._update = function(M) {
+        var W2 = this._w;
+        var a = this._a | 0;
+        var b = this._b | 0;
+        var c = this._c | 0;
+        var d = this._d | 0;
+        var e = this._e | 0;
+        var f = this._f | 0;
+        var g = this._g | 0;
+        var h = this._h | 0;
+        for (var i = 0; i < 16; ++i)
+          W2[i] = M.readInt32BE(i * 4);
+        for (; i < 64; ++i)
+          W2[i] = gamma1(W2[i - 2]) + W2[i - 7] + gamma0(W2[i - 15]) + W2[i - 16] | 0;
+        for (var j = 0; j < 64; ++j) {
+          var T1 = h + sigma1(e) + ch(e, f, g) + K[j] + W2[j] | 0;
+          var T2 = sigma0(a) + maj(a, b, c) | 0;
+          h = g;
+          g = f;
+          f = e;
+          e = d + T1 | 0;
+          d = c;
+          c = b;
+          b = a;
+          a = T1 + T2 | 0;
+        }
+        this._a = a + this._a | 0;
+        this._b = b + this._b | 0;
+        this._c = c + this._c | 0;
+        this._d = d + this._d | 0;
+        this._e = e + this._e | 0;
+        this._f = f + this._f | 0;
+        this._g = g + this._g | 0;
+        this._h = h + this._h | 0;
+      };
+      Sha256.prototype._hash = function() {
+        var H = Buffer2.allocUnsafe(32);
+        H.writeInt32BE(this._a, 0);
+        H.writeInt32BE(this._b, 4);
+        H.writeInt32BE(this._c, 8);
+        H.writeInt32BE(this._d, 12);
+        H.writeInt32BE(this._e, 16);
+        H.writeInt32BE(this._f, 20);
+        H.writeInt32BE(this._g, 24);
+        H.writeInt32BE(this._h, 28);
+        return H;
+      };
+      module.exports = Sha256;
+    }
+  });
+
+  // ../../../../../../node_modules/sha.js/sha224.js
+  var require_sha224 = __commonJS({
+    "../../../../../../node_modules/sha.js/sha224.js"(exports, module) {
+      var inherits = require_inherits_browser();
+      var Sha256 = require_sha256();
+      var Hash = require_hash();
+      var Buffer2 = require_safe_buffer().Buffer;
+      var W = new Array(64);
+      function Sha224() {
+        this.init();
+        this._w = W;
+        Hash.call(this, 64, 56);
+      }
+      inherits(Sha224, Sha256);
+      Sha224.prototype.init = function() {
+        this._a = 3238371032;
+        this._b = 914150663;
+        this._c = 812702999;
+        this._d = 4144912697;
+        this._e = 4290775857;
+        this._f = 1750603025;
+        this._g = 1694076839;
+        this._h = 3204075428;
+        return this;
+      };
+      Sha224.prototype._hash = function() {
+        var H = Buffer2.allocUnsafe(28);
+        H.writeInt32BE(this._a, 0);
+        H.writeInt32BE(this._b, 4);
+        H.writeInt32BE(this._c, 8);
+        H.writeInt32BE(this._d, 12);
+        H.writeInt32BE(this._e, 16);
+        H.writeInt32BE(this._f, 20);
+        H.writeInt32BE(this._g, 24);
+        return H;
+      };
+      module.exports = Sha224;
+    }
+  });
+
+  // ../../../../../../node_modules/sha.js/sha512.js
+  var require_sha512 = __commonJS({
+    "../../../../../../node_modules/sha.js/sha512.js"(exports, module) {
+      var inherits = require_inherits_browser();
+      var Hash = require_hash();
+      var Buffer2 = require_safe_buffer().Buffer;
+      var K = [
+        1116352408,
+        3609767458,
+        1899447441,
+        602891725,
+        3049323471,
+        3964484399,
+        3921009573,
+        2173295548,
+        961987163,
+        4081628472,
+        1508970993,
+        3053834265,
+        2453635748,
+        2937671579,
+        2870763221,
+        3664609560,
+        3624381080,
+        2734883394,
+        310598401,
+        1164996542,
+        607225278,
+        1323610764,
+        1426881987,
+        3590304994,
+        1925078388,
+        4068182383,
+        2162078206,
+        991336113,
+        2614888103,
+        633803317,
+        3248222580,
+        3479774868,
+        3835390401,
+        2666613458,
+        4022224774,
+        944711139,
+        264347078,
+        2341262773,
+        604807628,
+        2007800933,
+        770255983,
+        1495990901,
+        1249150122,
+        1856431235,
+        1555081692,
+        3175218132,
+        1996064986,
+        2198950837,
+        2554220882,
+        3999719339,
+        2821834349,
+        766784016,
+        2952996808,
+        2566594879,
+        3210313671,
+        3203337956,
+        3336571891,
+        1034457026,
+        3584528711,
+        2466948901,
+        113926993,
+        3758326383,
+        338241895,
+        168717936,
+        666307205,
+        1188179964,
+        773529912,
+        1546045734,
+        1294757372,
+        1522805485,
+        1396182291,
+        2643833823,
+        1695183700,
+        2343527390,
+        1986661051,
+        1014477480,
+        2177026350,
+        1206759142,
+        2456956037,
+        344077627,
+        2730485921,
+        1290863460,
+        2820302411,
+        3158454273,
+        3259730800,
+        3505952657,
+        3345764771,
+        106217008,
+        3516065817,
+        3606008344,
+        3600352804,
+        1432725776,
+        4094571909,
+        1467031594,
+        275423344,
+        851169720,
+        430227734,
+        3100823752,
+        506948616,
+        1363258195,
+        659060556,
+        3750685593,
+        883997877,
+        3785050280,
+        958139571,
+        3318307427,
+        1322822218,
+        3812723403,
+        1537002063,
+        2003034995,
+        1747873779,
+        3602036899,
+        1955562222,
+        1575990012,
+        2024104815,
+        1125592928,
+        2227730452,
+        2716904306,
+        2361852424,
+        442776044,
+        2428436474,
+        593698344,
+        2756734187,
+        3733110249,
+        3204031479,
+        2999351573,
+        3329325298,
+        3815920427,
+        3391569614,
+        3928383900,
+        3515267271,
+        566280711,
+        3940187606,
+        3454069534,
+        4118630271,
+        4000239992,
+        116418474,
+        1914138554,
+        174292421,
+        2731055270,
+        289380356,
+        3203993006,
+        460393269,
+        320620315,
+        685471733,
+        587496836,
+        852142971,
+        1086792851,
+        1017036298,
+        365543100,
+        1126000580,
+        2618297676,
+        1288033470,
+        3409855158,
+        1501505948,
+        4234509866,
+        1607167915,
+        987167468,
+        1816402316,
+        1246189591
+      ];
+      var W = new Array(160);
+      function Sha512() {
+        this.init();
+        this._w = W;
+        Hash.call(this, 128, 112);
+      }
+      inherits(Sha512, Hash);
+      Sha512.prototype.init = function() {
+        this._ah = 1779033703;
+        this._bh = 3144134277;
+        this._ch = 1013904242;
+        this._dh = 2773480762;
+        this._eh = 1359893119;
+        this._fh = 2600822924;
+        this._gh = 528734635;
+        this._hh = 1541459225;
+        this._al = 4089235720;
+        this._bl = 2227873595;
+        this._cl = 4271175723;
+        this._dl = 1595750129;
+        this._el = 2917565137;
+        this._fl = 725511199;
+        this._gl = 4215389547;
+        this._hl = 327033209;
+        return this;
+      };
+      function Ch(x, y, z) {
+        return z ^ x & (y ^ z);
+      }
+      function maj(x, y, z) {
+        return x & y | z & (x | y);
+      }
+      function sigma0(x, xl) {
+        return (x >>> 28 | xl << 4) ^ (xl >>> 2 | x << 30) ^ (xl >>> 7 | x << 25);
+      }
+      function sigma1(x, xl) {
+        return (x >>> 14 | xl << 18) ^ (x >>> 18 | xl << 14) ^ (xl >>> 9 | x << 23);
+      }
+      function Gamma0(x, xl) {
+        return (x >>> 1 | xl << 31) ^ (x >>> 8 | xl << 24) ^ x >>> 7;
+      }
+      function Gamma0l(x, xl) {
+        return (x >>> 1 | xl << 31) ^ (x >>> 8 | xl << 24) ^ (x >>> 7 | xl << 25);
+      }
+      function Gamma1(x, xl) {
+        return (x >>> 19 | xl << 13) ^ (xl >>> 29 | x << 3) ^ x >>> 6;
+      }
+      function Gamma1l(x, xl) {
+        return (x >>> 19 | xl << 13) ^ (xl >>> 29 | x << 3) ^ (x >>> 6 | xl << 26);
+      }
+      function getCarry(a, b) {
+        return a >>> 0 < b >>> 0 ? 1 : 0;
+      }
+      Sha512.prototype._update = function(M) {
+        var W2 = this._w;
+        var ah = this._ah | 0;
+        var bh = this._bh | 0;
+        var ch = this._ch | 0;
+        var dh = this._dh | 0;
+        var eh = this._eh | 0;
+        var fh = this._fh | 0;
+        var gh = this._gh | 0;
+        var hh = this._hh | 0;
+        var al = this._al | 0;
+        var bl = this._bl | 0;
+        var cl = this._cl | 0;
+        var dl = this._dl | 0;
+        var el = this._el | 0;
+        var fl = this._fl | 0;
+        var gl = this._gl | 0;
+        var hl = this._hl | 0;
+        for (var i = 0; i < 32; i += 2) {
+          W2[i] = M.readInt32BE(i * 4);
+          W2[i + 1] = M.readInt32BE(i * 4 + 4);
+        }
+        for (; i < 160; i += 2) {
+          var xh = W2[i - 15 * 2];
+          var xl = W2[i - 15 * 2 + 1];
+          var gamma0 = Gamma0(xh, xl);
+          var gamma0l = Gamma0l(xl, xh);
+          xh = W2[i - 2 * 2];
+          xl = W2[i - 2 * 2 + 1];
+          var gamma1 = Gamma1(xh, xl);
+          var gamma1l = Gamma1l(xl, xh);
+          var Wi7h = W2[i - 7 * 2];
+          var Wi7l = W2[i - 7 * 2 + 1];
+          var Wi16h = W2[i - 16 * 2];
+          var Wi16l = W2[i - 16 * 2 + 1];
+          var Wil = gamma0l + Wi7l | 0;
+          var Wih = gamma0 + Wi7h + getCarry(Wil, gamma0l) | 0;
+          Wil = Wil + gamma1l | 0;
+          Wih = Wih + gamma1 + getCarry(Wil, gamma1l) | 0;
+          Wil = Wil + Wi16l | 0;
+          Wih = Wih + Wi16h + getCarry(Wil, Wi16l) | 0;
+          W2[i] = Wih;
+          W2[i + 1] = Wil;
+        }
+        for (var j = 0; j < 160; j += 2) {
+          Wih = W2[j];
+          Wil = W2[j + 1];
+          var majh = maj(ah, bh, ch);
+          var majl = maj(al, bl, cl);
+          var sigma0h = sigma0(ah, al);
+          var sigma0l = sigma0(al, ah);
+          var sigma1h = sigma1(eh, el);
+          var sigma1l = sigma1(el, eh);
+          var Kih = K[j];
+          var Kil = K[j + 1];
+          var chh = Ch(eh, fh, gh);
+          var chl = Ch(el, fl, gl);
+          var t1l = hl + sigma1l | 0;
+          var t1h = hh + sigma1h + getCarry(t1l, hl) | 0;
+          t1l = t1l + chl | 0;
+          t1h = t1h + chh + getCarry(t1l, chl) | 0;
+          t1l = t1l + Kil | 0;
+          t1h = t1h + Kih + getCarry(t1l, Kil) | 0;
+          t1l = t1l + Wil | 0;
+          t1h = t1h + Wih + getCarry(t1l, Wil) | 0;
+          var t2l = sigma0l + majl | 0;
+          var t2h = sigma0h + majh + getCarry(t2l, sigma0l) | 0;
+          hh = gh;
+          hl = gl;
+          gh = fh;
+          gl = fl;
+          fh = eh;
+          fl = el;
+          el = dl + t1l | 0;
+          eh = dh + t1h + getCarry(el, dl) | 0;
+          dh = ch;
+          dl = cl;
+          ch = bh;
+          cl = bl;
+          bh = ah;
+          bl = al;
+          al = t1l + t2l | 0;
+          ah = t1h + t2h + getCarry(al, t1l) | 0;
+        }
+        this._al = this._al + al | 0;
+        this._bl = this._bl + bl | 0;
+        this._cl = this._cl + cl | 0;
+        this._dl = this._dl + dl | 0;
+        this._el = this._el + el | 0;
+        this._fl = this._fl + fl | 0;
+        this._gl = this._gl + gl | 0;
+        this._hl = this._hl + hl | 0;
+        this._ah = this._ah + ah + getCarry(this._al, al) | 0;
+        this._bh = this._bh + bh + getCarry(this._bl, bl) | 0;
+        this._ch = this._ch + ch + getCarry(this._cl, cl) | 0;
+        this._dh = this._dh + dh + getCarry(this._dl, dl) | 0;
+        this._eh = this._eh + eh + getCarry(this._el, el) | 0;
+        this._fh = this._fh + fh + getCarry(this._fl, fl) | 0;
+        this._gh = this._gh + gh + getCarry(this._gl, gl) | 0;
+        this._hh = this._hh + hh + getCarry(this._hl, hl) | 0;
+      };
+      Sha512.prototype._hash = function() {
+        var H = Buffer2.allocUnsafe(64);
+        function writeInt64BE(h, l, offset) {
+          H.writeInt32BE(h, offset);
+          H.writeInt32BE(l, offset + 4);
+        }
+        writeInt64BE(this._ah, this._al, 0);
+        writeInt64BE(this._bh, this._bl, 8);
+        writeInt64BE(this._ch, this._cl, 16);
+        writeInt64BE(this._dh, this._dl, 24);
+        writeInt64BE(this._eh, this._el, 32);
+        writeInt64BE(this._fh, this._fl, 40);
+        writeInt64BE(this._gh, this._gl, 48);
+        writeInt64BE(this._hh, this._hl, 56);
+        return H;
+      };
+      module.exports = Sha512;
+    }
+  });
+
+  // ../../../../../../node_modules/sha.js/sha384.js
+  var require_sha384 = __commonJS({
+    "../../../../../../node_modules/sha.js/sha384.js"(exports, module) {
+      var inherits = require_inherits_browser();
+      var SHA512 = require_sha512();
+      var Hash = require_hash();
+      var Buffer2 = require_safe_buffer().Buffer;
+      var W = new Array(160);
+      function Sha384() {
+        this.init();
+        this._w = W;
+        Hash.call(this, 128, 112);
+      }
+      inherits(Sha384, SHA512);
+      Sha384.prototype.init = function() {
+        this._ah = 3418070365;
+        this._bh = 1654270250;
+        this._ch = 2438529370;
+        this._dh = 355462360;
+        this._eh = 1731405415;
+        this._fh = 2394180231;
+        this._gh = 3675008525;
+        this._hh = 1203062813;
+        this._al = 3238371032;
+        this._bl = 914150663;
+        this._cl = 812702999;
+        this._dl = 4144912697;
+        this._el = 4290775857;
+        this._fl = 1750603025;
+        this._gl = 1694076839;
+        this._hl = 3204075428;
+        return this;
+      };
+      Sha384.prototype._hash = function() {
+        var H = Buffer2.allocUnsafe(48);
+        function writeInt64BE(h, l, offset) {
+          H.writeInt32BE(h, offset);
+          H.writeInt32BE(l, offset + 4);
+        }
+        writeInt64BE(this._ah, this._al, 0);
+        writeInt64BE(this._bh, this._bl, 8);
+        writeInt64BE(this._ch, this._cl, 16);
+        writeInt64BE(this._dh, this._dl, 24);
+        writeInt64BE(this._eh, this._el, 32);
+        writeInt64BE(this._fh, this._fl, 40);
+        return H;
+      };
+      module.exports = Sha384;
+    }
+  });
+
+  // ../../../../../../node_modules/sha.js/index.js
+  var require_sha2 = __commonJS({
+    "../../../../../../node_modules/sha.js/index.js"(exports, module) {
+      var exports = module.exports = function SHA(algorithm) {
+        algorithm = algorithm.toLowerCase();
+        var Algorithm = exports[algorithm];
+        if (!Algorithm)
+          throw new Error(algorithm + " is not supported (we accept pull requests)");
+        return new Algorithm();
+      };
+      exports.sha = require_sha();
+      exports.sha1 = require_sha1();
+      exports.sha224 = require_sha224();
+      exports.sha256 = require_sha256();
+      exports.sha384 = require_sha384();
+      exports.sha512 = require_sha512();
+    }
+  });
+
+  // ../../../../../../node_modules/is-observable/index.js
+  var require_is_observable = __commonJS({
+    "../../../../../../node_modules/is-observable/index.js"(exports, module) {
+      "use strict";
+      module.exports = (value) => {
+        if (!value) {
+          return false;
+        }
+        if (typeof Symbol.observable === "symbol" && typeof value[Symbol.observable] === "function") {
+          return value === value[Symbol.observable]();
+        }
+        if (typeof value["@@observable"] === "function") {
+          return value === value["@@observable"]();
+        }
+        return false;
+      };
+    }
+  });
+
+  // ../../../../../../node_modules/threads/dist/serializers.js
+  var require_serializers = __commonJS({
+    "../../../../../../node_modules/threads/dist/serializers.js"(exports) {
+      "use strict";
+      Object.defineProperty(exports, "__esModule", { value: true });
+      exports.DefaultSerializer = exports.extendSerializer = void 0;
+      function extendSerializer(extend, implementation) {
+        const fallbackDeserializer = extend.deserialize.bind(extend);
+        const fallbackSerializer = extend.serialize.bind(extend);
+        return {
+          deserialize(message) {
+            return implementation.deserialize(message, fallbackDeserializer);
+          },
+          serialize(input) {
+            return implementation.serialize(input, fallbackSerializer);
+          }
+        };
+      }
+      exports.extendSerializer = extendSerializer;
+      var DefaultErrorSerializer = {
+        deserialize(message) {
+          return Object.assign(Error(message.message), {
+            name: message.name,
+            stack: message.stack
+          });
+        },
+        serialize(error) {
+          return {
+            __error_marker: "$$error",
+            message: error.message,
+            name: error.name,
+            stack: error.stack
+          };
+        }
+      };
+      var isSerializedError = (thing) => thing && typeof thing === "object" && "__error_marker" in thing && thing.__error_marker === "$$error";
+      exports.DefaultSerializer = {
+        deserialize(message) {
+          if (isSerializedError(message)) {
+            return DefaultErrorSerializer.deserialize(message);
+          } else {
+            return message;
+          }
+        },
+        serialize(input) {
+          if (input instanceof Error) {
+            return DefaultErrorSerializer.serialize(input);
+          } else {
+            return input;
+          }
+        }
+      };
+    }
+  });
+
+  // ../../../../../../node_modules/threads/dist/common.js
+  var require_common = __commonJS({
+    "../../../../../../node_modules/threads/dist/common.js"(exports) {
+      "use strict";
+      Object.defineProperty(exports, "__esModule", { value: true });
+      exports.serialize = exports.deserialize = exports.registerSerializer = void 0;
+      var serializers_1 = require_serializers();
+      var registeredSerializer = serializers_1.DefaultSerializer;
+      function registerSerializer2(serializer) {
+        registeredSerializer = serializers_1.extendSerializer(registeredSerializer, serializer);
+      }
+      exports.registerSerializer = registerSerializer2;
+      function deserialize(message) {
+        return registeredSerializer.deserialize(message);
+      }
+      exports.deserialize = deserialize;
+      function serialize(input) {
+        return registeredSerializer.serialize(input);
+      }
+      exports.serialize = serialize;
+    }
+  });
+
+  // ../../../../../../node_modules/threads/dist/symbols.js
+  var require_symbols = __commonJS({
+    "../../../../../../node_modules/threads/dist/symbols.js"(exports) {
+      "use strict";
+      Object.defineProperty(exports, "__esModule", { value: true });
+      exports.$worker = exports.$transferable = exports.$terminate = exports.$events = exports.$errors = void 0;
+      exports.$errors = Symbol("thread.errors");
+      exports.$events = Symbol("thread.events");
+      exports.$terminate = Symbol("thread.terminate");
+      exports.$transferable = Symbol("thread.transferable");
+      exports.$worker = Symbol("thread.worker");
+    }
+  });
+
+  // ../../../../../../node_modules/threads/dist/transferable.js
+  var require_transferable = __commonJS({
+    "../../../../../../node_modules/threads/dist/transferable.js"(exports) {
+      "use strict";
+      Object.defineProperty(exports, "__esModule", { value: true });
+      exports.Transfer = exports.isTransferDescriptor = void 0;
+      var symbols_1 = require_symbols();
+      function isTransferable(thing) {
+        if (!thing || typeof thing !== "object")
+          return false;
+        return true;
+      }
+      function isTransferDescriptor(thing) {
+        return thing && typeof thing === "object" && thing[symbols_1.$transferable];
+      }
+      exports.isTransferDescriptor = isTransferDescriptor;
+      function Transfer2(payload, transferables) {
+        if (!transferables) {
+          if (!isTransferable(payload))
+            throw Error();
+          transferables = [payload];
+        }
+        return {
+          [symbols_1.$transferable]: true,
+          send: payload,
+          transferables
+        };
+      }
+      exports.Transfer = Transfer2;
+    }
+  });
+
+  // ../../../../../../node_modules/threads/dist/types/messages.js
+  var require_messages = __commonJS({
+    "../../../../../../node_modules/threads/dist/types/messages.js"(exports) {
+      "use strict";
+      Object.defineProperty(exports, "__esModule", { value: true });
+      exports.WorkerMessageType = exports.MasterMessageType = void 0;
+      var MasterMessageType;
+      (function(MasterMessageType2) {
+        MasterMessageType2["cancel"] = "cancel";
+        MasterMessageType2["run"] = "run";
+      })(MasterMessageType = exports.MasterMessageType || (exports.MasterMessageType = {}));
+      var WorkerMessageType;
+      (function(WorkerMessageType2) {
+        WorkerMessageType2["error"] = "error";
+        WorkerMessageType2["init"] = "init";
+        WorkerMessageType2["result"] = "result";
+        WorkerMessageType2["running"] = "running";
+        WorkerMessageType2["uncaughtError"] = "uncaughtError";
+      })(WorkerMessageType = exports.WorkerMessageType || (exports.WorkerMessageType = {}));
+    }
+  });
+
+  // ../../../../../../node_modules/threads/dist/worker/implementation.browser.js
+  var require_implementation_browser = __commonJS({
+    "../../../../../../node_modules/threads/dist/worker/implementation.browser.js"(exports) {
+      "use strict";
+      Object.defineProperty(exports, "__esModule", { value: true });
+      var isWorkerRuntime = function isWorkerRuntime2() {
+        const isWindowContext = typeof self !== "undefined" && typeof Window !== "undefined" && self instanceof Window;
+        return typeof self !== "undefined" && self.postMessage && !isWindowContext ? true : false;
+      };
+      var postMessageToMaster = function postMessageToMaster2(data, transferList) {
+        self.postMessage(data, transferList);
+      };
+      var subscribeToMasterMessages = function subscribeToMasterMessages2(onMessage) {
+        const messageHandler = (messageEvent) => {
+          onMessage(messageEvent.data);
+        };
+        const unsubscribe = () => {
+          self.removeEventListener("message", messageHandler);
+        };
+        self.addEventListener("message", messageHandler);
+        return unsubscribe;
+      };
+      exports.default = {
+        isWorkerRuntime,
+        postMessageToMaster,
+        subscribeToMasterMessages
+      };
+    }
+  });
+
+  // ../../../../../../node_modules/threads/dist/worker/index.js
+  var require_worker = __commonJS({
+    "../../../../../../node_modules/threads/dist/worker/index.js"(exports) {
+      "use strict";
+      var __awaiter = exports && exports.__awaiter || function(thisArg, _arguments, P, generator) {
+        function adopt(value) {
+          return value instanceof P ? value : new P(function(resolve) {
+            resolve(value);
+          });
+        }
+        return new (P || (P = Promise))(function(resolve, reject) {
+          function fulfilled(value) {
+            try {
+              step(generator.next(value));
+            } catch (e) {
+              reject(e);
+            }
+          }
+          function rejected(value) {
+            try {
+              step(generator["throw"](value));
+            } catch (e) {
+              reject(e);
+            }
+          }
+          function step(result) {
+            result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected);
+          }
+          step((generator = generator.apply(thisArg, _arguments || [])).next());
+        });
+      };
+      var __importDefault = exports && exports.__importDefault || function(mod) {
+        return mod && mod.__esModule ? mod : { "default": mod };
+      };
+      Object.defineProperty(exports, "__esModule", { value: true });
+      exports.expose = exports.isWorkerRuntime = exports.Transfer = exports.registerSerializer = void 0;
+      var is_observable_1 = __importDefault(require_is_observable());
+      var common_1 = require_common();
+      var transferable_1 = require_transferable();
+      var messages_1 = require_messages();
+      var implementation_1 = __importDefault(require_implementation_browser());
+      var common_2 = require_common();
+      Object.defineProperty(exports, "registerSerializer", { enumerable: true, get: function() {
+        return common_2.registerSerializer;
+      } });
+      var transferable_2 = require_transferable();
+      Object.defineProperty(exports, "Transfer", { enumerable: true, get: function() {
+        return transferable_2.Transfer;
+      } });
+      exports.isWorkerRuntime = implementation_1.default.isWorkerRuntime;
+      var exposeCalled = false;
+      var activeSubscriptions = /* @__PURE__ */ new Map();
+      var isMasterJobCancelMessage = (thing) => thing && thing.type === messages_1.MasterMessageType.cancel;
+      var isMasterJobRunMessage = (thing) => thing && thing.type === messages_1.MasterMessageType.run;
+      var isObservable = (thing) => is_observable_1.default(thing) || isZenObservable(thing);
+      function isZenObservable(thing) {
+        return thing && typeof thing === "object" && typeof thing.subscribe === "function";
+      }
+      function deconstructTransfer(thing) {
+        return transferable_1.isTransferDescriptor(thing) ? { payload: thing.send, transferables: thing.transferables } : { payload: thing, transferables: void 0 };
+      }
+      function postFunctionInitMessage() {
+        const initMessage = {
+          type: messages_1.WorkerMessageType.init,
+          exposed: {
+            type: "function"
+          }
+        };
+        implementation_1.default.postMessageToMaster(initMessage);
+      }
+      function postModuleInitMessage(methodNames) {
+        const initMessage = {
+          type: messages_1.WorkerMessageType.init,
+          exposed: {
+            type: "module",
+            methods: methodNames
+          }
+        };
+        implementation_1.default.postMessageToMaster(initMessage);
+      }
+      function postJobErrorMessage(uid, rawError) {
+        const { payload: error, transferables } = deconstructTransfer(rawError);
+        const errorMessage = {
+          type: messages_1.WorkerMessageType.error,
+          uid,
+          error: common_1.serialize(error)
+        };
+        implementation_1.default.postMessageToMaster(errorMessage, transferables);
+      }
+      function postJobResultMessage(uid, completed, resultValue) {
+        const { payload, transferables } = deconstructTransfer(resultValue);
+        const resultMessage = {
+          type: messages_1.WorkerMessageType.result,
+          uid,
+          complete: completed ? true : void 0,
+          payload
+        };
+        implementation_1.default.postMessageToMaster(resultMessage, transferables);
+      }
+      function postJobStartMessage(uid, resultType) {
+        const startMessage = {
+          type: messages_1.WorkerMessageType.running,
+          uid,
+          resultType
+        };
+        implementation_1.default.postMessageToMaster(startMessage);
+      }
+      function postUncaughtErrorMessage(error) {
+        try {
+          const errorMessage = {
+            type: messages_1.WorkerMessageType.uncaughtError,
+            error: common_1.serialize(error)
+          };
+          implementation_1.default.postMessageToMaster(errorMessage);
+        } catch (subError) {
+          console.error("Not reporting uncaught error back to master thread as it occured while reporting an uncaught error already.\nLatest error:", subError, "\nOriginal error:", error);
+        }
+      }
+      function runFunction(jobUID, fn, args) {
+        return __awaiter(this, void 0, void 0, function* () {
+          let syncResult;
+          try {
+            syncResult = fn(...args);
+          } catch (error) {
+            return postJobErrorMessage(jobUID, error);
+          }
+          const resultType = isObservable(syncResult) ? "observable" : "promise";
+          postJobStartMessage(jobUID, resultType);
+          if (isObservable(syncResult)) {
+            const subscription = syncResult.subscribe((value) => postJobResultMessage(jobUID, false, common_1.serialize(value)), (error) => {
+              postJobErrorMessage(jobUID, common_1.serialize(error));
+              activeSubscriptions.delete(jobUID);
+            }, () => {
+              postJobResultMessage(jobUID, true);
+              activeSubscriptions.delete(jobUID);
+            });
+            activeSubscriptions.set(jobUID, subscription);
+          } else {
+            try {
+              const result = yield syncResult;
+              postJobResultMessage(jobUID, true, common_1.serialize(result));
+            } catch (error) {
+              postJobErrorMessage(jobUID, common_1.serialize(error));
+            }
+          }
+        });
+      }
+      function expose2(exposed) {
+        if (!implementation_1.default.isWorkerRuntime()) {
+          throw Error("expose() called in the master thread.");
+        }
+        if (exposeCalled) {
+          throw Error("expose() called more than once. This is not possible. Pass an object to expose() if you want to expose multiple functions.");
+        }
+        exposeCalled = true;
+        if (typeof exposed === "function") {
+          implementation_1.default.subscribeToMasterMessages((messageData) => {
+            if (isMasterJobRunMessage(messageData) && !messageData.method) {
+              runFunction(messageData.uid, exposed, messageData.args.map(common_1.deserialize));
+            }
+          });
+          postFunctionInitMessage();
+        } else if (typeof exposed === "object" && exposed) {
+          implementation_1.default.subscribeToMasterMessages((messageData) => {
+            if (isMasterJobRunMessage(messageData) && messageData.method) {
+              runFunction(messageData.uid, exposed[messageData.method], messageData.args.map(common_1.deserialize));
+            }
+          });
+          const methodNames = Object.keys(exposed).filter((key) => typeof exposed[key] === "function");
+          postModuleInitMessage(methodNames);
+        } else {
+          throw Error(`Invalid argument passed to expose(). Expected a function or an object, got: ${exposed}`);
+        }
+        implementation_1.default.subscribeToMasterMessages((messageData) => {
+          if (isMasterJobCancelMessage(messageData)) {
+            const jobUID = messageData.uid;
+            const subscription = activeSubscriptions.get(jobUID);
+            if (subscription) {
+              subscription.unsubscribe();
+              activeSubscriptions.delete(jobUID);
+            }
+          }
+        });
+      }
+      exports.expose = expose2;
+      if (typeof self !== "undefined" && typeof self.addEventListener === "function" && implementation_1.default.isWorkerRuntime()) {
+        self.addEventListener("error", (event) => {
+          setTimeout(() => postUncaughtErrorMessage(event.error || event), 250);
+        });
+        self.addEventListener("unhandledrejection", (event) => {
+          const error = event.reason;
+          if (error && typeof error.message === "string") {
+            setTimeout(() => postUncaughtErrorMessage(error), 250);
+          }
+        });
+      }
+      if (typeof process !== "undefined" && typeof process.on === "function" && implementation_1.default.isWorkerRuntime()) {
+        process.on("uncaughtException", (error) => {
+          setTimeout(() => postUncaughtErrorMessage(error), 250);
+        });
+        process.on("unhandledRejection", (error) => {
+          if (error && typeof error.message === "string") {
+            setTimeout(() => postUncaughtErrorMessage(error), 250);
+          }
+        });
+      }
+    }
+  });
+
+  // ../../../../../../node_modules/@xylabs/hex/dist/node/index.js
+  var assertError = (value, assert, defaultMessage) => {
+    if (assert) {
+      const assertString = typeof assert === "string" ? assert : typeof assert === "boolean" ? defaultMessage : assert(value, defaultMessage);
+      if (assertString) {
+        throw new Error(assertString === true ? defaultMessage : assertString);
+      }
+    }
+    return void 0;
+  };
+  var bitsToNibbles = (value) => {
+    const nibbles = value >> 2;
+    if (value !== nibbles << 2)
+      throw new Error("Bits for nibbles must multiple of 4");
+    return nibbles;
+  };
+  var hexRegex = /^[\da-f]+$/i;
+  var hexRegexWithPrefix = /0x[\da-f]+$/i;
+  var isHex = (value, config) => {
+    if (typeof value !== "string")
+      return false;
+    const valueCharLength = (config == null ? void 0 : config.prefix) ? value.length - 2 : value.length;
+    if ((config == null ? void 0 : config.bitLength) !== void 0 && valueCharLength !== bitsToNibbles(config == null ? void 0 : config.bitLength))
+      return false;
+    return (config == null ? void 0 : config.prefix) ? hexRegexWithPrefix.test(value) : hexRegex.test(value);
+  };
+  var hexFromHexString = (value, config = {}) => {
+    const { prefix = false, byteSize = 8 } = config;
+    const nibbleBoundary = bitsToNibbles(byteSize);
+    const unPadded = (value.startsWith("0x") ? value.slice(2) : value).toLowerCase();
+    if (isHex(unPadded)) {
+      const padded = unPadded.padStart(unPadded.length + unPadded.length % nibbleBoundary, "0");
+      return prefix ? `0x${padded}` : padded;
+    } else {
+      throw new Error("Received string is not a value hex");
+    }
+  };
+  var isHash = (value, bitLength = 256) => {
+    return isHex(value, { bitLength });
+  };
+  function asHash(value, assert) {
+    let stringValue = void 0;
+    switch (typeof value) {
+      case "string": {
+        stringValue = hexFromHexString(value);
+        break;
+      }
+      default: {
+        return assert ? assertError(value, assert, `Unsupported type [${typeof value}]`) : void 0;
+      }
+    }
+    return isHash(stringValue) ? stringValue : assertError(value, assert, `Value is not a Hash [${value}]`);
+  }
+
+  // src/worker/jsHash.ts
+  var import_sha = __toESM(require_sha2(), 1);
+
+  // ../../../../../../node_modules/threads/worker.mjs
+  var import_worker = __toESM(require_worker(), 1);
+  var expose = import_worker.default.expose;
+  var registerSerializer = import_worker.default.registerSerializer;
+  var Transfer = import_worker.default.Transfer;
+
+  // src/worker/jsHash.ts
+  expose({
+    hash(data) {
+      return asHash((0, import_sha.default)("sha256").update(data).digest().toString("hex"), true);
+    }
+  });
+})();
+/*! Bundled license information:
+
+ieee754/index.js:
+  (*! ieee754. BSD-3-Clause License. Feross Aboukhadijeh <https://feross.org/opensource> *)
+
+buffer/index.js:
+  (*!
+   * The buffer module from node.js, for the browser.
+   *
+   * @author   Feross Aboukhadijeh <https://feross.org>
+   * @license  MIT
+   *)
+
+safe-buffer/index.js:
+  (*! safe-buffer. MIT License. Feross Aboukhadijeh <https://feross.org/opensource> *)
+*/