@vardario/cognito-client 0.1.3 → 0.1.4

package/dist/index.js

@@ -0,0 +1,3814 @@
+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 __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require : typeof Proxy !== "undefined" ? new Proxy(x, {
+  get: (a, b) => (typeof require !== "undefined" ? require : a)[b]
+}) : x)(function(x) {
+  if (typeof require !== "undefined")
+    return require.apply(this, arguments);
+  throw new Error('Dynamic require of "' + x + '" is not supported');
+});
+var __commonJS = (cb, mod) => function __require2() {
+  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/.pnpm/minimalistic-assert@1.0.1/node_modules/minimalistic-assert/index.js
+var require_minimalistic_assert = __commonJS({
+  "node_modules/.pnpm/minimalistic-assert@1.0.1/node_modules/minimalistic-assert/index.js"(exports, module) {
+    module.exports = assert;
+    function assert(val, msg) {
+      if (!val)
+        throw new Error(msg || "Assertion failed");
+    }
+    assert.equal = function assertEqual(l, r, msg) {
+      if (l != r)
+        throw new Error(msg || "Assertion failed: " + l + " != " + r);
+    };
+  }
+});
+
+// node_modules/.pnpm/inherits@2.0.4/node_modules/inherits/inherits_browser.js
+var require_inherits_browser = __commonJS({
+  "node_modules/.pnpm/inherits@2.0.4/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/.pnpm/inherits@2.0.4/node_modules/inherits/inherits.js
+var require_inherits = __commonJS({
+  "node_modules/.pnpm/inherits@2.0.4/node_modules/inherits/inherits.js"(exports, module) {
+    try {
+      util = __require("util");
+      if (typeof util.inherits !== "function")
+        throw "";
+      module.exports = util.inherits;
+    } catch (e) {
+      module.exports = require_inherits_browser();
+    }
+    var util;
+  }
+});
+
+// node_modules/.pnpm/hash.js@1.1.7/node_modules/hash.js/lib/hash/utils.js
+var require_utils = __commonJS({
+  "node_modules/.pnpm/hash.js@1.1.7/node_modules/hash.js/lib/hash/utils.js"(exports) {
+    "use strict";
+    var assert = require_minimalistic_assert();
+    var inherits = require_inherits();
+    exports.inherits = inherits;
+    function isSurrogatePair(msg, i) {
+      if ((msg.charCodeAt(i) & 64512) !== 55296) {
+        return false;
+      }
+      if (i < 0 || i + 1 >= msg.length) {
+        return false;
+      }
+      return (msg.charCodeAt(i + 1) & 64512) === 56320;
+    }
+    function toArray(msg, enc) {
+      if (Array.isArray(msg))
+        return msg.slice();
+      if (!msg)
+        return [];
+      var res = [];
+      if (typeof msg === "string") {
+        if (!enc) {
+          var p = 0;
+          for (var i = 0; i < msg.length; i++) {
+            var c = msg.charCodeAt(i);
+            if (c < 128) {
+              res[p++] = c;
+            } else if (c < 2048) {
+              res[p++] = c >> 6 | 192;
+              res[p++] = c & 63 | 128;
+            } else if (isSurrogatePair(msg, i)) {
+              c = 65536 + ((c & 1023) << 10) + (msg.charCodeAt(++i) & 1023);
+              res[p++] = c >> 18 | 240;
+              res[p++] = c >> 12 & 63 | 128;
+              res[p++] = c >> 6 & 63 | 128;
+              res[p++] = c & 63 | 128;
+            } else {
+              res[p++] = c >> 12 | 224;
+              res[p++] = c >> 6 & 63 | 128;
+              res[p++] = c & 63 | 128;
+            }
+          }
+        } else if (enc === "hex") {
+          msg = msg.replace(/[^a-z0-9]+/ig, "");
+          if (msg.length % 2 !== 0)
+            msg = "0" + msg;
+          for (i = 0; i < msg.length; i += 2)
+            res.push(parseInt(msg[i] + msg[i + 1], 16));
+        }
+      } else {
+        for (i = 0; i < msg.length; i++)
+          res[i] = msg[i] | 0;
+      }
+      return res;
+    }
+    exports.toArray = toArray;
+    function toHex(msg) {
+      var res = "";
+      for (var i = 0; i < msg.length; i++)
+        res += zero2(msg[i].toString(16));
+      return res;
+    }
+    exports.toHex = toHex;
+    function htonl(w) {
+      var res = w >>> 24 | w >>> 8 & 65280 | w << 8 & 16711680 | (w & 255) << 24;
+      return res >>> 0;
+    }
+    exports.htonl = htonl;
+    function toHex32(msg, endian) {
+      var res = "";
+      for (var i = 0; i < msg.length; i++) {
+        var w = msg[i];
+        if (endian === "little")
+          w = htonl(w);
+        res += zero8(w.toString(16));
+      }
+      return res;
+    }
+    exports.toHex32 = toHex32;
+    function zero2(word) {
+      if (word.length === 1)
+        return "0" + word;
+      else
+        return word;
+    }
+    exports.zero2 = zero2;
+    function zero8(word) {
+      if (word.length === 7)
+        return "0" + word;
+      else if (word.length === 6)
+        return "00" + word;
+      else if (word.length === 5)
+        return "000" + word;
+      else if (word.length === 4)
+        return "0000" + word;
+      else if (word.length === 3)
+        return "00000" + word;
+      else if (word.length === 2)
+        return "000000" + word;
+      else if (word.length === 1)
+        return "0000000" + word;
+      else
+        return word;
+    }
+    exports.zero8 = zero8;
+    function join32(msg, start, end, endian) {
+      var len = end - start;
+      assert(len % 4 === 0);
+      var res = new Array(len / 4);
+      for (var i = 0, k2 = start; i < res.length; i++, k2 += 4) {
+        var w;
+        if (endian === "big")
+          w = msg[k2] << 24 | msg[k2 + 1] << 16 | msg[k2 + 2] << 8 | msg[k2 + 3];
+        else
+          w = msg[k2 + 3] << 24 | msg[k2 + 2] << 16 | msg[k2 + 1] << 8 | msg[k2];
+        res[i] = w >>> 0;
+      }
+      return res;
+    }
+    exports.join32 = join32;
+    function split32(msg, endian) {
+      var res = new Array(msg.length * 4);
+      for (var i = 0, k2 = 0; i < msg.length; i++, k2 += 4) {
+        var m = msg[i];
+        if (endian === "big") {
+          res[k2] = m >>> 24;
+          res[k2 + 1] = m >>> 16 & 255;
+          res[k2 + 2] = m >>> 8 & 255;
+          res[k2 + 3] = m & 255;
+        } else {
+          res[k2 + 3] = m >>> 24;
+          res[k2 + 2] = m >>> 16 & 255;
+          res[k2 + 1] = m >>> 8 & 255;
+          res[k2] = m & 255;
+        }
+      }
+      return res;
+    }
+    exports.split32 = split32;
+    function rotr32(w, b) {
+      return w >>> b | w << 32 - b;
+    }
+    exports.rotr32 = rotr32;
+    function rotl32(w, b) {
+      return w << b | w >>> 32 - b;
+    }
+    exports.rotl32 = rotl32;
+    function sum32(a, b) {
+      return a + b >>> 0;
+    }
+    exports.sum32 = sum32;
+    function sum32_3(a, b, c) {
+      return a + b + c >>> 0;
+    }
+    exports.sum32_3 = sum32_3;
+    function sum32_4(a, b, c, d) {
+      return a + b + c + d >>> 0;
+    }
+    exports.sum32_4 = sum32_4;
+    function sum32_5(a, b, c, d, e) {
+      return a + b + c + d + e >>> 0;
+    }
+    exports.sum32_5 = sum32_5;
+    function sum64(buf, pos, ah, al) {
+      var bh = buf[pos];
+      var bl = buf[pos + 1];
+      var lo = al + bl >>> 0;
+      var hi = (lo < al ? 1 : 0) + ah + bh;
+      buf[pos] = hi >>> 0;
+      buf[pos + 1] = lo;
+    }
+    exports.sum64 = sum64;
+    function sum64_hi(ah, al, bh, bl) {
+      var lo = al + bl >>> 0;
+      var hi = (lo < al ? 1 : 0) + ah + bh;
+      return hi >>> 0;
+    }
+    exports.sum64_hi = sum64_hi;
+    function sum64_lo(ah, al, bh, bl) {
+      var lo = al + bl;
+      return lo >>> 0;
+    }
+    exports.sum64_lo = sum64_lo;
+    function sum64_4_hi(ah, al, bh, bl, ch, cl, dh, dl) {
+      var carry = 0;
+      var lo = al;
+      lo = lo + bl >>> 0;
+      carry += lo < al ? 1 : 0;
+      lo = lo + cl >>> 0;
+      carry += lo < cl ? 1 : 0;
+      lo = lo + dl >>> 0;
+      carry += lo < dl ? 1 : 0;
+      var hi = ah + bh + ch + dh + carry;
+      return hi >>> 0;
+    }
+    exports.sum64_4_hi = sum64_4_hi;
+    function sum64_4_lo(ah, al, bh, bl, ch, cl, dh, dl) {
+      var lo = al + bl + cl + dl;
+      return lo >>> 0;
+    }
+    exports.sum64_4_lo = sum64_4_lo;
+    function sum64_5_hi(ah, al, bh, bl, ch, cl, dh, dl, eh, el) {
+      var carry = 0;
+      var lo = al;
+      lo = lo + bl >>> 0;
+      carry += lo < al ? 1 : 0;
+      lo = lo + cl >>> 0;
+      carry += lo < cl ? 1 : 0;
+      lo = lo + dl >>> 0;
+      carry += lo < dl ? 1 : 0;
+      lo = lo + el >>> 0;
+      carry += lo < el ? 1 : 0;
+      var hi = ah + bh + ch + dh + eh + carry;
+      return hi >>> 0;
+    }
+    exports.sum64_5_hi = sum64_5_hi;
+    function sum64_5_lo(ah, al, bh, bl, ch, cl, dh, dl, eh, el) {
+      var lo = al + bl + cl + dl + el;
+      return lo >>> 0;
+    }
+    exports.sum64_5_lo = sum64_5_lo;
+    function rotr64_hi(ah, al, num) {
+      var r = al << 32 - num | ah >>> num;
+      return r >>> 0;
+    }
+    exports.rotr64_hi = rotr64_hi;
+    function rotr64_lo(ah, al, num) {
+      var r = ah << 32 - num | al >>> num;
+      return r >>> 0;
+    }
+    exports.rotr64_lo = rotr64_lo;
+    function shr64_hi(ah, al, num) {
+      return ah >>> num;
+    }
+    exports.shr64_hi = shr64_hi;
+    function shr64_lo(ah, al, num) {
+      var r = ah << 32 - num | al >>> num;
+      return r >>> 0;
+    }
+    exports.shr64_lo = shr64_lo;
+  }
+});
+
+// node_modules/.pnpm/hash.js@1.1.7/node_modules/hash.js/lib/hash/common.js
+var require_common = __commonJS({
+  "node_modules/.pnpm/hash.js@1.1.7/node_modules/hash.js/lib/hash/common.js"(exports) {
+    "use strict";
+    var utils = require_utils();
+    var assert = require_minimalistic_assert();
+    function BlockHash() {
+      this.pending = null;
+      this.pendingTotal = 0;
+      this.blockSize = this.constructor.blockSize;
+      this.outSize = this.constructor.outSize;
+      this.hmacStrength = this.constructor.hmacStrength;
+      this.padLength = this.constructor.padLength / 8;
+      this.endian = "big";
+      this._delta8 = this.blockSize / 8;
+      this._delta32 = this.blockSize / 32;
+    }
+    exports.BlockHash = BlockHash;
+    BlockHash.prototype.update = function update(msg, enc) {
+      msg = utils.toArray(msg, enc);
+      if (!this.pending)
+        this.pending = msg;
+      else
+        this.pending = this.pending.concat(msg);
+      this.pendingTotal += msg.length;
+      if (this.pending.length >= this._delta8) {
+        msg = this.pending;
+        var r = msg.length % this._delta8;
+        this.pending = msg.slice(msg.length - r, msg.length);
+        if (this.pending.length === 0)
+          this.pending = null;
+        msg = utils.join32(msg, 0, msg.length - r, this.endian);
+        for (var i = 0; i < msg.length; i += this._delta32)
+          this._update(msg, i, i + this._delta32);
+      }
+      return this;
+    };
+    BlockHash.prototype.digest = function digest(enc) {
+      this.update(this._pad());
+      assert(this.pending === null);
+      return this._digest(enc);
+    };
+    BlockHash.prototype._pad = function pad() {
+      var len = this.pendingTotal;
+      var bytes = this._delta8;
+      var k2 = bytes - (len + this.padLength) % bytes;
+      var res = new Array(k2 + this.padLength);
+      res[0] = 128;
+      for (var i = 1; i < k2; i++)
+        res[i] = 0;
+      len <<= 3;
+      if (this.endian === "big") {
+        for (var t = 8; t < this.padLength; t++)
+          res[i++] = 0;
+        res[i++] = 0;
+        res[i++] = 0;
+        res[i++] = 0;
+        res[i++] = 0;
+        res[i++] = len >>> 24 & 255;
+        res[i++] = len >>> 16 & 255;
+        res[i++] = len >>> 8 & 255;
+        res[i++] = len & 255;
+      } else {
+        res[i++] = len & 255;
+        res[i++] = len >>> 8 & 255;
+        res[i++] = len >>> 16 & 255;
+        res[i++] = len >>> 24 & 255;
+        res[i++] = 0;
+        res[i++] = 0;
+        res[i++] = 0;
+        res[i++] = 0;
+        for (t = 8; t < this.padLength; t++)
+          res[i++] = 0;
+      }
+      return res;
+    };
+  }
+});
+
+// node_modules/.pnpm/hash.js@1.1.7/node_modules/hash.js/lib/hash/sha/common.js
+var require_common2 = __commonJS({
+  "node_modules/.pnpm/hash.js@1.1.7/node_modules/hash.js/lib/hash/sha/common.js"(exports) {
+    "use strict";
+    var utils = require_utils();
+    var rotr32 = utils.rotr32;
+    function ft_1(s, x, y, z) {
+      if (s === 0)
+        return ch32(x, y, z);
+      if (s === 1 || s === 3)
+        return p32(x, y, z);
+      if (s === 2)
+        return maj32(x, y, z);
+    }
+    exports.ft_1 = ft_1;
+    function ch32(x, y, z) {
+      return x & y ^ ~x & z;
+    }
+    exports.ch32 = ch32;
+    function maj32(x, y, z) {
+      return x & y ^ x & z ^ y & z;
+    }
+    exports.maj32 = maj32;
+    function p32(x, y, z) {
+      return x ^ y ^ z;
+    }
+    exports.p32 = p32;
+    function s0_256(x) {
+      return rotr32(x, 2) ^ rotr32(x, 13) ^ rotr32(x, 22);
+    }
+    exports.s0_256 = s0_256;
+    function s1_256(x) {
+      return rotr32(x, 6) ^ rotr32(x, 11) ^ rotr32(x, 25);
+    }
+    exports.s1_256 = s1_256;
+    function g0_256(x) {
+      return rotr32(x, 7) ^ rotr32(x, 18) ^ x >>> 3;
+    }
+    exports.g0_256 = g0_256;
+    function g1_256(x) {
+      return rotr32(x, 17) ^ rotr32(x, 19) ^ x >>> 10;
+    }
+    exports.g1_256 = g1_256;
+  }
+});
+
+// node_modules/.pnpm/hash.js@1.1.7/node_modules/hash.js/lib/hash/sha/1.js
+var require__ = __commonJS({
+  "node_modules/.pnpm/hash.js@1.1.7/node_modules/hash.js/lib/hash/sha/1.js"(exports, module) {
+    "use strict";
+    var utils = require_utils();
+    var common = require_common();
+    var shaCommon = require_common2();
+    var rotl32 = utils.rotl32;
+    var sum32 = utils.sum32;
+    var sum32_5 = utils.sum32_5;
+    var ft_1 = shaCommon.ft_1;
+    var BlockHash = common.BlockHash;
+    var sha1_K = [
+      1518500249,
+      1859775393,
+      2400959708,
+      3395469782
+    ];
+    function SHA1() {
+      if (!(this instanceof SHA1))
+        return new SHA1();
+      BlockHash.call(this);
+      this.h = [
+        1732584193,
+        4023233417,
+        2562383102,
+        271733878,
+        3285377520
+      ];
+      this.W = new Array(80);
+    }
+    utils.inherits(SHA1, BlockHash);
+    module.exports = SHA1;
+    SHA1.blockSize = 512;
+    SHA1.outSize = 160;
+    SHA1.hmacStrength = 80;
+    SHA1.padLength = 64;
+    SHA1.prototype._update = function _update(msg, start) {
+      var W = this.W;
+      for (var i = 0; i < 16; i++)
+        W[i] = msg[start + i];
+      for (; i < W.length; i++)
+        W[i] = rotl32(W[i - 3] ^ W[i - 8] ^ W[i - 14] ^ W[i - 16], 1);
+      var a = this.h[0];
+      var b = this.h[1];
+      var c = this.h[2];
+      var d = this.h[3];
+      var e = this.h[4];
+      for (i = 0; i < W.length; i++) {
+        var s = ~~(i / 20);
+        var t = sum32_5(rotl32(a, 5), ft_1(s, b, c, d), e, W[i], sha1_K[s]);
+        e = d;
+        d = c;
+        c = rotl32(b, 30);
+        b = a;
+        a = t;
+      }
+      this.h[0] = sum32(this.h[0], a);
+      this.h[1] = sum32(this.h[1], b);
+      this.h[2] = sum32(this.h[2], c);
+      this.h[3] = sum32(this.h[3], d);
+      this.h[4] = sum32(this.h[4], e);
+    };
+    SHA1.prototype._digest = function digest(enc) {
+      if (enc === "hex")
+        return utils.toHex32(this.h, "big");
+      else
+        return utils.split32(this.h, "big");
+    };
+  }
+});
+
+// node_modules/.pnpm/hash.js@1.1.7/node_modules/hash.js/lib/hash/sha/256.js
+var require__2 = __commonJS({
+  "node_modules/.pnpm/hash.js@1.1.7/node_modules/hash.js/lib/hash/sha/256.js"(exports, module) {
+    "use strict";
+    var utils = require_utils();
+    var common = require_common();
+    var shaCommon = require_common2();
+    var assert = require_minimalistic_assert();
+    var sum32 = utils.sum32;
+    var sum32_4 = utils.sum32_4;
+    var sum32_5 = utils.sum32_5;
+    var ch32 = shaCommon.ch32;
+    var maj32 = shaCommon.maj32;
+    var s0_256 = shaCommon.s0_256;
+    var s1_256 = shaCommon.s1_256;
+    var g0_256 = shaCommon.g0_256;
+    var g1_256 = shaCommon.g1_256;
+    var BlockHash = common.BlockHash;
+    var sha256_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
+    ];
+    function SHA256() {
+      if (!(this instanceof SHA256))
+        return new SHA256();
+      BlockHash.call(this);
+      this.h = [
+        1779033703,
+        3144134277,
+        1013904242,
+        2773480762,
+        1359893119,
+        2600822924,
+        528734635,
+        1541459225
+      ];
+      this.k = sha256_K;
+      this.W = new Array(64);
+    }
+    utils.inherits(SHA256, BlockHash);
+    module.exports = SHA256;
+    SHA256.blockSize = 512;
+    SHA256.outSize = 256;
+    SHA256.hmacStrength = 192;
+    SHA256.padLength = 64;
+    SHA256.prototype._update = function _update(msg, start) {
+      var W = this.W;
+      for (var i = 0; i < 16; i++)
+        W[i] = msg[start + i];
+      for (; i < W.length; i++)
+        W[i] = sum32_4(g1_256(W[i - 2]), W[i - 7], g0_256(W[i - 15]), W[i - 16]);
+      var a = this.h[0];
+      var b = this.h[1];
+      var c = this.h[2];
+      var d = this.h[3];
+      var e = this.h[4];
+      var f = this.h[5];
+      var g2 = this.h[6];
+      var h = this.h[7];
+      assert(this.k.length === W.length);
+      for (i = 0; i < W.length; i++) {
+        var T1 = sum32_5(h, s1_256(e), ch32(e, f, g2), this.k[i], W[i]);
+        var T2 = sum32(s0_256(a), maj32(a, b, c));
+        h = g2;
+        g2 = f;
+        f = e;
+        e = sum32(d, T1);
+        d = c;
+        c = b;
+        b = a;
+        a = sum32(T1, T2);
+      }
+      this.h[0] = sum32(this.h[0], a);
+      this.h[1] = sum32(this.h[1], b);
+      this.h[2] = sum32(this.h[2], c);
+      this.h[3] = sum32(this.h[3], d);
+      this.h[4] = sum32(this.h[4], e);
+      this.h[5] = sum32(this.h[5], f);
+      this.h[6] = sum32(this.h[6], g2);
+      this.h[7] = sum32(this.h[7], h);
+    };
+    SHA256.prototype._digest = function digest(enc) {
+      if (enc === "hex")
+        return utils.toHex32(this.h, "big");
+      else
+        return utils.split32(this.h, "big");
+    };
+  }
+});
+
+// node_modules/.pnpm/hash.js@1.1.7/node_modules/hash.js/lib/hash/sha/224.js
+var require__3 = __commonJS({
+  "node_modules/.pnpm/hash.js@1.1.7/node_modules/hash.js/lib/hash/sha/224.js"(exports, module) {
+    "use strict";
+    var utils = require_utils();
+    var SHA256 = require__2();
+    function SHA224() {
+      if (!(this instanceof SHA224))
+        return new SHA224();
+      SHA256.call(this);
+      this.h = [
+        3238371032,
+        914150663,
+        812702999,
+        4144912697,
+        4290775857,
+        1750603025,
+        1694076839,
+        3204075428
+      ];
+    }
+    utils.inherits(SHA224, SHA256);
+    module.exports = SHA224;
+    SHA224.blockSize = 512;
+    SHA224.outSize = 224;
+    SHA224.hmacStrength = 192;
+    SHA224.padLength = 64;
+    SHA224.prototype._digest = function digest(enc) {
+      if (enc === "hex")
+        return utils.toHex32(this.h.slice(0, 7), "big");
+      else
+        return utils.split32(this.h.slice(0, 7), "big");
+    };
+  }
+});
+
+// node_modules/.pnpm/hash.js@1.1.7/node_modules/hash.js/lib/hash/sha/512.js
+var require__4 = __commonJS({
+  "node_modules/.pnpm/hash.js@1.1.7/node_modules/hash.js/lib/hash/sha/512.js"(exports, module) {
+    "use strict";
+    var utils = require_utils();
+    var common = require_common();
+    var assert = require_minimalistic_assert();
+    var rotr64_hi = utils.rotr64_hi;
+    var rotr64_lo = utils.rotr64_lo;
+    var shr64_hi = utils.shr64_hi;
+    var shr64_lo = utils.shr64_lo;
+    var sum64 = utils.sum64;
+    var sum64_hi = utils.sum64_hi;
+    var sum64_lo = utils.sum64_lo;
+    var sum64_4_hi = utils.sum64_4_hi;
+    var sum64_4_lo = utils.sum64_4_lo;
+    var sum64_5_hi = utils.sum64_5_hi;
+    var sum64_5_lo = utils.sum64_5_lo;
+    var BlockHash = common.BlockHash;
+    var sha512_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
+    ];
+    function SHA512() {
+      if (!(this instanceof SHA512))
+        return new SHA512();
+      BlockHash.call(this);
+      this.h = [
+        1779033703,
+        4089235720,
+        3144134277,
+        2227873595,
+        1013904242,
+        4271175723,
+        2773480762,
+        1595750129,
+        1359893119,
+        2917565137,
+        2600822924,
+        725511199,
+        528734635,
+        4215389547,
+        1541459225,
+        327033209
+      ];
+      this.k = sha512_K;
+      this.W = new Array(160);
+    }
+    utils.inherits(SHA512, BlockHash);
+    module.exports = SHA512;
+    SHA512.blockSize = 1024;
+    SHA512.outSize = 512;
+    SHA512.hmacStrength = 192;
+    SHA512.padLength = 128;
+    SHA512.prototype._prepareBlock = function _prepareBlock(msg, start) {
+      var W = this.W;
+      for (var i = 0; i < 32; i++)
+        W[i] = msg[start + i];
+      for (; i < W.length; i += 2) {
+        var c0_hi = g1_512_hi(W[i - 4], W[i - 3]);
+        var c0_lo = g1_512_lo(W[i - 4], W[i - 3]);
+        var c1_hi = W[i - 14];
+        var c1_lo = W[i - 13];
+        var c2_hi = g0_512_hi(W[i - 30], W[i - 29]);
+        var c2_lo = g0_512_lo(W[i - 30], W[i - 29]);
+        var c3_hi = W[i - 32];
+        var c3_lo = W[i - 31];
+        W[i] = sum64_4_hi(
+          c0_hi,
+          c0_lo,
+          c1_hi,
+          c1_lo,
+          c2_hi,
+          c2_lo,
+          c3_hi,
+          c3_lo
+        );
+        W[i + 1] = sum64_4_lo(
+          c0_hi,
+          c0_lo,
+          c1_hi,
+          c1_lo,
+          c2_hi,
+          c2_lo,
+          c3_hi,
+          c3_lo
+        );
+      }
+    };
+    SHA512.prototype._update = function _update(msg, start) {
+      this._prepareBlock(msg, start);
+      var W = this.W;
+      var ah = this.h[0];
+      var al = this.h[1];
+      var bh = this.h[2];
+      var bl = this.h[3];
+      var ch = this.h[4];
+      var cl = this.h[5];
+      var dh = this.h[6];
+      var dl = this.h[7];
+      var eh = this.h[8];
+      var el = this.h[9];
+      var fh = this.h[10];
+      var fl = this.h[11];
+      var gh = this.h[12];
+      var gl = this.h[13];
+      var hh = this.h[14];
+      var hl = this.h[15];
+      assert(this.k.length === W.length);
+      for (var i = 0; i < W.length; i += 2) {
+        var c0_hi = hh;
+        var c0_lo = hl;
+        var c1_hi = s1_512_hi(eh, el);
+        var c1_lo = s1_512_lo(eh, el);
+        var c2_hi = ch64_hi(eh, el, fh, fl, gh, gl);
+        var c2_lo = ch64_lo(eh, el, fh, fl, gh, gl);
+        var c3_hi = this.k[i];
+        var c3_lo = this.k[i + 1];
+        var c4_hi = W[i];
+        var c4_lo = W[i + 1];
+        var T1_hi = sum64_5_hi(
+          c0_hi,
+          c0_lo,
+          c1_hi,
+          c1_lo,
+          c2_hi,
+          c2_lo,
+          c3_hi,
+          c3_lo,
+          c4_hi,
+          c4_lo
+        );
+        var T1_lo = sum64_5_lo(
+          c0_hi,
+          c0_lo,
+          c1_hi,
+          c1_lo,
+          c2_hi,
+          c2_lo,
+          c3_hi,
+          c3_lo,
+          c4_hi,
+          c4_lo
+        );
+        c0_hi = s0_512_hi(ah, al);
+        c0_lo = s0_512_lo(ah, al);
+        c1_hi = maj64_hi(ah, al, bh, bl, ch, cl);
+        c1_lo = maj64_lo(ah, al, bh, bl, ch, cl);
+        var T2_hi = sum64_hi(c0_hi, c0_lo, c1_hi, c1_lo);
+        var T2_lo = sum64_lo(c0_hi, c0_lo, c1_hi, c1_lo);
+        hh = gh;
+        hl = gl;
+        gh = fh;
+        gl = fl;
+        fh = eh;
+        fl = el;
+        eh = sum64_hi(dh, dl, T1_hi, T1_lo);
+        el = sum64_lo(dl, dl, T1_hi, T1_lo);
+        dh = ch;
+        dl = cl;
+        ch = bh;
+        cl = bl;
+        bh = ah;
+        bl = al;
+        ah = sum64_hi(T1_hi, T1_lo, T2_hi, T2_lo);
+        al = sum64_lo(T1_hi, T1_lo, T2_hi, T2_lo);
+      }
+      sum64(this.h, 0, ah, al);
+      sum64(this.h, 2, bh, bl);
+      sum64(this.h, 4, ch, cl);
+      sum64(this.h, 6, dh, dl);
+      sum64(this.h, 8, eh, el);
+      sum64(this.h, 10, fh, fl);
+      sum64(this.h, 12, gh, gl);
+      sum64(this.h, 14, hh, hl);
+    };
+    SHA512.prototype._digest = function digest(enc) {
+      if (enc === "hex")
+        return utils.toHex32(this.h, "big");
+      else
+        return utils.split32(this.h, "big");
+    };
+    function ch64_hi(xh, xl, yh, yl, zh) {
+      var r = xh & yh ^ ~xh & zh;
+      if (r < 0)
+        r += 4294967296;
+      return r;
+    }
+    function ch64_lo(xh, xl, yh, yl, zh, zl) {
+      var r = xl & yl ^ ~xl & zl;
+      if (r < 0)
+        r += 4294967296;
+      return r;
+    }
+    function maj64_hi(xh, xl, yh, yl, zh) {
+      var r = xh & yh ^ xh & zh ^ yh & zh;
+      if (r < 0)
+        r += 4294967296;
+      return r;
+    }
+    function maj64_lo(xh, xl, yh, yl, zh, zl) {
+      var r = xl & yl ^ xl & zl ^ yl & zl;
+      if (r < 0)
+        r += 4294967296;
+      return r;
+    }
+    function s0_512_hi(xh, xl) {
+      var c0_hi = rotr64_hi(xh, xl, 28);
+      var c1_hi = rotr64_hi(xl, xh, 2);
+      var c2_hi = rotr64_hi(xl, xh, 7);
+      var r = c0_hi ^ c1_hi ^ c2_hi;
+      if (r < 0)
+        r += 4294967296;
+      return r;
+    }
+    function s0_512_lo(xh, xl) {
+      var c0_lo = rotr64_lo(xh, xl, 28);
+      var c1_lo = rotr64_lo(xl, xh, 2);
+      var c2_lo = rotr64_lo(xl, xh, 7);
+      var r = c0_lo ^ c1_lo ^ c2_lo;
+      if (r < 0)
+        r += 4294967296;
+      return r;
+    }
+    function s1_512_hi(xh, xl) {
+      var c0_hi = rotr64_hi(xh, xl, 14);
+      var c1_hi = rotr64_hi(xh, xl, 18);
+      var c2_hi = rotr64_hi(xl, xh, 9);
+      var r = c0_hi ^ c1_hi ^ c2_hi;
+      if (r < 0)
+        r += 4294967296;
+      return r;
+    }
+    function s1_512_lo(xh, xl) {
+      var c0_lo = rotr64_lo(xh, xl, 14);
+      var c1_lo = rotr64_lo(xh, xl, 18);
+      var c2_lo = rotr64_lo(xl, xh, 9);
+      var r = c0_lo ^ c1_lo ^ c2_lo;
+      if (r < 0)
+        r += 4294967296;
+      return r;
+    }
+    function g0_512_hi(xh, xl) {
+      var c0_hi = rotr64_hi(xh, xl, 1);
+      var c1_hi = rotr64_hi(xh, xl, 8);
+      var c2_hi = shr64_hi(xh, xl, 7);
+      var r = c0_hi ^ c1_hi ^ c2_hi;
+      if (r < 0)
+        r += 4294967296;
+      return r;
+    }
+    function g0_512_lo(xh, xl) {
+      var c0_lo = rotr64_lo(xh, xl, 1);
+      var c1_lo = rotr64_lo(xh, xl, 8);
+      var c2_lo = shr64_lo(xh, xl, 7);
+      var r = c0_lo ^ c1_lo ^ c2_lo;
+      if (r < 0)
+        r += 4294967296;
+      return r;
+    }
+    function g1_512_hi(xh, xl) {
+      var c0_hi = rotr64_hi(xh, xl, 19);
+      var c1_hi = rotr64_hi(xl, xh, 29);
+      var c2_hi = shr64_hi(xh, xl, 6);
+      var r = c0_hi ^ c1_hi ^ c2_hi;
+      if (r < 0)
+        r += 4294967296;
+      return r;
+    }
+    function g1_512_lo(xh, xl) {
+      var c0_lo = rotr64_lo(xh, xl, 19);
+      var c1_lo = rotr64_lo(xl, xh, 29);
+      var c2_lo = shr64_lo(xh, xl, 6);
+      var r = c0_lo ^ c1_lo ^ c2_lo;
+      if (r < 0)
+        r += 4294967296;
+      return r;
+    }
+  }
+});
+
+// node_modules/.pnpm/hash.js@1.1.7/node_modules/hash.js/lib/hash/sha/384.js
+var require__5 = __commonJS({
+  "node_modules/.pnpm/hash.js@1.1.7/node_modules/hash.js/lib/hash/sha/384.js"(exports, module) {
+    "use strict";
+    var utils = require_utils();
+    var SHA512 = require__4();
+    function SHA384() {
+      if (!(this instanceof SHA384))
+        return new SHA384();
+      SHA512.call(this);
+      this.h = [
+        3418070365,
+        3238371032,
+        1654270250,
+        914150663,
+        2438529370,
+        812702999,
+        355462360,
+        4144912697,
+        1731405415,
+        4290775857,
+        2394180231,
+        1750603025,
+        3675008525,
+        1694076839,
+        1203062813,
+        3204075428
+      ];
+    }
+    utils.inherits(SHA384, SHA512);
+    module.exports = SHA384;
+    SHA384.blockSize = 1024;
+    SHA384.outSize = 384;
+    SHA384.hmacStrength = 192;
+    SHA384.padLength = 128;
+    SHA384.prototype._digest = function digest(enc) {
+      if (enc === "hex")
+        return utils.toHex32(this.h.slice(0, 12), "big");
+      else
+        return utils.split32(this.h.slice(0, 12), "big");
+    };
+  }
+});
+
+// node_modules/.pnpm/hash.js@1.1.7/node_modules/hash.js/lib/hash/sha.js
+var require_sha = __commonJS({
+  "node_modules/.pnpm/hash.js@1.1.7/node_modules/hash.js/lib/hash/sha.js"(exports) {
+    "use strict";
+    exports.sha1 = require__();
+    exports.sha224 = require__3();
+    exports.sha256 = require__2();
+    exports.sha384 = require__5();
+    exports.sha512 = require__4();
+  }
+});
+
+// node_modules/.pnpm/hash.js@1.1.7/node_modules/hash.js/lib/hash/ripemd.js
+var require_ripemd = __commonJS({
+  "node_modules/.pnpm/hash.js@1.1.7/node_modules/hash.js/lib/hash/ripemd.js"(exports) {
+    "use strict";
+    var utils = require_utils();
+    var common = require_common();
+    var rotl32 = utils.rotl32;
+    var sum32 = utils.sum32;
+    var sum32_3 = utils.sum32_3;
+    var sum32_4 = utils.sum32_4;
+    var BlockHash = common.BlockHash;
+    function RIPEMD160() {
+      if (!(this instanceof RIPEMD160))
+        return new RIPEMD160();
+      BlockHash.call(this);
+      this.h = [1732584193, 4023233417, 2562383102, 271733878, 3285377520];
+      this.endian = "little";
+    }
+    utils.inherits(RIPEMD160, BlockHash);
+    exports.ripemd160 = RIPEMD160;
+    RIPEMD160.blockSize = 512;
+    RIPEMD160.outSize = 160;
+    RIPEMD160.hmacStrength = 192;
+    RIPEMD160.padLength = 64;
+    RIPEMD160.prototype._update = function update(msg, start) {
+      var A = this.h[0];
+      var B = this.h[1];
+      var C = this.h[2];
+      var D = this.h[3];
+      var E = this.h[4];
+      var Ah = A;
+      var Bh = B;
+      var Ch = C;
+      var Dh = D;
+      var Eh = E;
+      for (var j = 0; j < 80; j++) {
+        var T = sum32(
+          rotl32(
+            sum32_4(A, f(j, B, C, D), msg[r[j] + start], K(j)),
+            s[j]
+          ),
+          E
+        );
+        A = E;
+        E = D;
+        D = rotl32(C, 10);
+        C = B;
+        B = T;
+        T = sum32(
+          rotl32(
+            sum32_4(Ah, f(79 - j, Bh, Ch, Dh), msg[rh[j] + start], Kh(j)),
+            sh[j]
+          ),
+          Eh
+        );
+        Ah = Eh;
+        Eh = Dh;
+        Dh = rotl32(Ch, 10);
+        Ch = Bh;
+        Bh = T;
+      }
+      T = sum32_3(this.h[1], C, Dh);
+      this.h[1] = sum32_3(this.h[2], D, Eh);
+      this.h[2] = sum32_3(this.h[3], E, Ah);
+      this.h[3] = sum32_3(this.h[4], A, Bh);
+      this.h[4] = sum32_3(this.h[0], B, Ch);
+      this.h[0] = T;
+    };
+    RIPEMD160.prototype._digest = function digest(enc) {
+      if (enc === "hex")
+        return utils.toHex32(this.h, "little");
+      else
+        return utils.split32(this.h, "little");
+    };
+    function f(j, x, y, z) {
+      if (j <= 15)
+        return x ^ y ^ z;
+      else if (j <= 31)
+        return x & y | ~x & z;
+      else if (j <= 47)
+        return (x | ~y) ^ z;
+      else if (j <= 63)
+        return x & z | y & ~z;
+      else
+        return x ^ (y | ~z);
+    }
+    function K(j) {
+      if (j <= 15)
+        return 0;
+      else if (j <= 31)
+        return 1518500249;
+      else if (j <= 47)
+        return 1859775393;
+      else if (j <= 63)
+        return 2400959708;
+      else
+        return 2840853838;
+    }
+    function Kh(j) {
+      if (j <= 15)
+        return 1352829926;
+      else if (j <= 31)
+        return 1548603684;
+      else if (j <= 47)
+        return 1836072691;
+      else if (j <= 63)
+        return 2053994217;
+      else
+        return 0;
+    }
+    var r = [
+      0,
+      1,
+      2,
+      3,
+      4,
+      5,
+      6,
+      7,
+      8,
+      9,
+      10,
+      11,
+      12,
+      13,
+      14,
+      15,
+      7,
+      4,
+      13,
+      1,
+      10,
+      6,
+      15,
+      3,
+      12,
+      0,
+      9,
+      5,
+      2,
+      14,
+      11,
+      8,
+      3,
+      10,
+      14,
+      4,
+      9,
+      15,
+      8,
+      1,
+      2,
+      7,
+      0,
+      6,
+      13,
+      11,
+      5,
+      12,
+      1,
+      9,
+      11,
+      10,
+      0,
+      8,
+      12,
+      4,
+      13,
+      3,
+      7,
+      15,
+      14,
+      5,
+      6,
+      2,
+      4,
+      0,
+      5,
+      9,
+      7,
+      12,
+      2,
+      10,
+      14,
+      1,
+      3,
+      8,
+      11,
+      6,
+      15,
+      13
+    ];
+    var rh = [
+      5,
+      14,
+      7,
+      0,
+      9,
+      2,
+      11,
+      4,
+      13,
+      6,
+      15,
+      8,
+      1,
+      10,
+      3,
+      12,
+      6,
+      11,
+      3,
+      7,
+      0,
+      13,
+      5,
+      10,
+      14,
+      15,
+      8,
+      12,
+      4,
+      9,
+      1,
+      2,
+      15,
+      5,
+      1,
+      3,
+      7,
+      14,
+      6,
+      9,
+      11,
+      8,
+      12,
+      2,
+      10,
+      0,
+      4,
+      13,
+      8,
+      6,
+      4,
+      1,
+      3,
+      11,
+      15,
+      0,
+      5,
+      12,
+      2,
+      13,
+      9,
+      7,
+      10,
+      14,
+      12,
+      15,
+      10,
+      4,
+      1,
+      5,
+      8,
+      7,
+      6,
+      2,
+      13,
+      14,
+      0,
+      3,
+      9,
+      11
+    ];
+    var s = [
+      11,
+      14,
+      15,
+      12,
+      5,
+      8,
+      7,
+      9,
+      11,
+      13,
+      14,
+      15,
+      6,
+      7,
+      9,
+      8,
+      7,
+      6,
+      8,
+      13,
+      11,
+      9,
+      7,
+      15,
+      7,
+      12,
+      15,
+      9,
+      11,
+      7,
+      13,
+      12,
+      11,
+      13,
+      6,
+      7,
+      14,
+      9,
+      13,
+      15,
+      14,
+      8,
+      13,
+      6,
+      5,
+      12,
+      7,
+      5,
+      11,
+      12,
+      14,
+      15,
+      14,
+      15,
+      9,
+      8,
+      9,
+      14,
+      5,
+      6,
+      8,
+      6,
+      5,
+      12,
+      9,
+      15,
+      5,
+      11,
+      6,
+      8,
+      13,
+      12,
+      5,
+      12,
+      13,
+      14,
+      11,
+      8,
+      5,
+      6
+    ];
+    var sh = [
+      8,
+      9,
+      9,
+      11,
+      13,
+      15,
+      15,
+      5,
+      7,
+      7,
+      8,
+      11,
+      14,
+      14,
+      12,
+      6,
+      9,
+      13,
+      15,
+      7,
+      12,
+      8,
+      9,
+      11,
+      7,
+      7,
+      12,
+      7,
+      6,
+      15,
+      13,
+      11,
+      9,
+      7,
+      15,
+      11,
+      8,
+      6,
+      6,
+      14,
+      12,
+      13,
+      5,
+      14,
+      13,
+      13,
+      7,
+      5,
+      15,
+      5,
+      8,
+      11,
+      14,
+      14,
+      6,
+      14,
+      6,
+      9,
+      12,
+      9,
+      12,
+      5,
+      15,
+      8,
+      8,
+      5,
+      12,
+      9,
+      12,
+      5,
+      14,
+      6,
+      8,
+      13,
+      6,
+      5,
+      15,
+      13,
+      11,
+      11
+    ];
+  }
+});
+
+// node_modules/.pnpm/hash.js@1.1.7/node_modules/hash.js/lib/hash/hmac.js
+var require_hmac = __commonJS({
+  "node_modules/.pnpm/hash.js@1.1.7/node_modules/hash.js/lib/hash/hmac.js"(exports, module) {
+    "use strict";
+    var utils = require_utils();
+    var assert = require_minimalistic_assert();
+    function Hmac(hash, key, enc) {
+      if (!(this instanceof Hmac))
+        return new Hmac(hash, key, enc);
+      this.Hash = hash;
+      this.blockSize = hash.blockSize / 8;
+      this.outSize = hash.outSize / 8;
+      this.inner = null;
+      this.outer = null;
+      this._init(utils.toArray(key, enc));
+    }
+    module.exports = Hmac;
+    Hmac.prototype._init = function init(key) {
+      if (key.length > this.blockSize)
+        key = new this.Hash().update(key).digest();
+      assert(key.length <= this.blockSize);
+      for (var i = key.length; i < this.blockSize; i++)
+        key.push(0);
+      for (i = 0; i < key.length; i++)
+        key[i] ^= 54;
+      this.inner = new this.Hash().update(key);
+      for (i = 0; i < key.length; i++)
+        key[i] ^= 106;
+      this.outer = new this.Hash().update(key);
+    };
+    Hmac.prototype.update = function update(msg, enc) {
+      this.inner.update(msg, enc);
+      return this;
+    };
+    Hmac.prototype.digest = function digest(enc) {
+      this.outer.update(this.inner.digest());
+      return this.outer.digest(enc);
+    };
+  }
+});
+
+// node_modules/.pnpm/hash.js@1.1.7/node_modules/hash.js/lib/hash.js
+var require_hash = __commonJS({
+  "node_modules/.pnpm/hash.js@1.1.7/node_modules/hash.js/lib/hash.js"(exports) {
+    var hash = exports;
+    hash.utils = require_utils();
+    hash.common = require_common();
+    hash.sha = require_sha();
+    hash.ripemd = require_ripemd();
+    hash.hmac = require_hmac();
+    hash.sha1 = hash.sha.sha1;
+    hash.sha256 = hash.sha.sha256;
+    hash.sha224 = hash.sha.sha224;
+    hash.sha384 = hash.sha.sha384;
+    hash.sha512 = hash.sha.sha512;
+    hash.ripemd160 = hash.ripemd.ripemd160;
+  }
+});
+
+// node_modules/.pnpm/jsbn@1.1.0/node_modules/jsbn/index.js
+var require_jsbn = __commonJS({
+  "node_modules/.pnpm/jsbn@1.1.0/node_modules/jsbn/index.js"(exports, module) {
+    (function() {
+      var dbits;
+      var canary = 244837814094590;
+      var j_lm = (canary & 16777215) == 15715070;
+      function BigInteger3(a, b, c) {
+        if (a != null)
+          if ("number" == typeof a)
+            this.fromNumber(a, b, c);
+          else if (b == null && "string" != typeof a)
+            this.fromString(a, 256);
+          else
+            this.fromString(a, b);
+      }
+      function nbi() {
+        return new BigInteger3(null);
+      }
+      function am1(i, x, w, j, c, n) {
+        while (--n >= 0) {
+          var v = x * this[i++] + w[j] + c;
+          c = Math.floor(v / 67108864);
+          w[j++] = v & 67108863;
+        }
+        return c;
+      }
+      function am2(i, x, w, j, c, n) {
+        var xl = x & 32767, xh = x >> 15;
+        while (--n >= 0) {
+          var l = this[i] & 32767;
+          var h = this[i++] >> 15;
+          var m = xh * l + h * xl;
+          l = xl * l + ((m & 32767) << 15) + w[j] + (c & 1073741823);
+          c = (l >>> 30) + (m >>> 15) + xh * h + (c >>> 30);
+          w[j++] = l & 1073741823;
+        }
+        return c;
+      }
+      function am3(i, x, w, j, c, n) {
+        var xl = x & 16383, xh = x >> 14;
+        while (--n >= 0) {
+          var l = this[i] & 16383;
+          var h = this[i++] >> 14;
+          var m = xh * l + h * xl;
+          l = xl * l + ((m & 16383) << 14) + w[j] + c;
+          c = (l >> 28) + (m >> 14) + xh * h;
+          w[j++] = l & 268435455;
+        }
+        return c;
+      }
+      var inBrowser = typeof navigator !== "undefined";
+      if (inBrowser && j_lm && navigator.appName == "Microsoft Internet Explorer") {
+        BigInteger3.prototype.am = am2;
+        dbits = 30;
+      } else if (inBrowser && j_lm && navigator.appName != "Netscape") {
+        BigInteger3.prototype.am = am1;
+        dbits = 26;
+      } else {
+        BigInteger3.prototype.am = am3;
+        dbits = 28;
+      }
+      BigInteger3.prototype.DB = dbits;
+      BigInteger3.prototype.DM = (1 << dbits) - 1;
+      BigInteger3.prototype.DV = 1 << dbits;
+      var BI_FP = 52;
+      BigInteger3.prototype.FV = Math.pow(2, BI_FP);
+      BigInteger3.prototype.F1 = BI_FP - dbits;
+      BigInteger3.prototype.F2 = 2 * dbits - BI_FP;
+      var BI_RM = "0123456789abcdefghijklmnopqrstuvwxyz";
+      var BI_RC = new Array();
+      var rr, vv;
+      rr = "0".charCodeAt(0);
+      for (vv = 0; vv <= 9; ++vv)
+        BI_RC[rr++] = vv;
+      rr = "a".charCodeAt(0);
+      for (vv = 10; vv < 36; ++vv)
+        BI_RC[rr++] = vv;
+      rr = "A".charCodeAt(0);
+      for (vv = 10; vv < 36; ++vv)
+        BI_RC[rr++] = vv;
+      function int2char(n) {
+        return BI_RM.charAt(n);
+      }
+      function intAt(s, i) {
+        var c = BI_RC[s.charCodeAt(i)];
+        return c == null ? -1 : c;
+      }
+      function bnpCopyTo(r) {
+        for (var i = this.t - 1; i >= 0; --i)
+          r[i] = this[i];
+        r.t = this.t;
+        r.s = this.s;
+      }
+      function bnpFromInt(x) {
+        this.t = 1;
+        this.s = x < 0 ? -1 : 0;
+        if (x > 0)
+          this[0] = x;
+        else if (x < -1)
+          this[0] = x + this.DV;
+        else
+          this.t = 0;
+      }
+      function nbv(i) {
+        var r = nbi();
+        r.fromInt(i);
+        return r;
+      }
+      function bnpFromString(s, b) {
+        var k2;
+        if (b == 16)
+          k2 = 4;
+        else if (b == 8)
+          k2 = 3;
+        else if (b == 256)
+          k2 = 8;
+        else if (b == 2)
+          k2 = 1;
+        else if (b == 32)
+          k2 = 5;
+        else if (b == 4)
+          k2 = 2;
+        else {
+          this.fromRadix(s, b);
+          return;
+        }
+        this.t = 0;
+        this.s = 0;
+        var i = s.length, mi = false, sh = 0;
+        while (--i >= 0) {
+          var x = k2 == 8 ? s[i] & 255 : intAt(s, i);
+          if (x < 0) {
+            if (s.charAt(i) == "-")
+              mi = true;
+            continue;
+          }
+          mi = false;
+          if (sh == 0)
+            this[this.t++] = x;
+          else if (sh + k2 > this.DB) {
+            this[this.t - 1] |= (x & (1 << this.DB - sh) - 1) << sh;
+            this[this.t++] = x >> this.DB - sh;
+          } else
+            this[this.t - 1] |= x << sh;
+          sh += k2;
+          if (sh >= this.DB)
+            sh -= this.DB;
+        }
+        if (k2 == 8 && (s[0] & 128) != 0) {
+          this.s = -1;
+          if (sh > 0)
+            this[this.t - 1] |= (1 << this.DB - sh) - 1 << sh;
+        }
+        this.clamp();
+        if (mi)
+          BigInteger3.ZERO.subTo(this, this);
+      }
+      function bnpClamp() {
+        var c = this.s & this.DM;
+        while (this.t > 0 && this[this.t - 1] == c)
+          --this.t;
+      }
+      function bnToString(b) {
+        if (this.s < 0)
+          return "-" + this.negate().toString(b);
+        var k2;
+        if (b == 16)
+          k2 = 4;
+        else if (b == 8)
+          k2 = 3;
+        else if (b == 2)
+          k2 = 1;
+        else if (b == 32)
+          k2 = 5;
+        else if (b == 4)
+          k2 = 2;
+        else
+          return this.toRadix(b);
+        var km = (1 << k2) - 1, d, m = false, r = "", i = this.t;
+        var p = this.DB - i * this.DB % k2;
+        if (i-- > 0) {
+          if (p < this.DB && (d = this[i] >> p) > 0) {
+            m = true;
+            r = int2char(d);
+          }
+          while (i >= 0) {
+            if (p < k2) {
+              d = (this[i] & (1 << p) - 1) << k2 - p;
+              d |= this[--i] >> (p += this.DB - k2);
+            } else {
+              d = this[i] >> (p -= k2) & km;
+              if (p <= 0) {
+                p += this.DB;
+                --i;
+              }
+            }
+            if (d > 0)
+              m = true;
+            if (m)
+              r += int2char(d);
+          }
+        }
+        return m ? r : "0";
+      }
+      function bnNegate() {
+        var r = nbi();
+        BigInteger3.ZERO.subTo(this, r);
+        return r;
+      }
+      function bnAbs() {
+        return this.s < 0 ? this.negate() : this;
+      }
+      function bnCompareTo(a) {
+        var r = this.s - a.s;
+        if (r != 0)
+          return r;
+        var i = this.t;
+        r = i - a.t;
+        if (r != 0)
+          return this.s < 0 ? -r : r;
+        while (--i >= 0)
+          if ((r = this[i] - a[i]) != 0)
+            return r;
+        return 0;
+      }
+      function nbits(x) {
+        var r = 1, t2;
+        if ((t2 = x >>> 16) != 0) {
+          x = t2;
+          r += 16;
+        }
+        if ((t2 = x >> 8) != 0) {
+          x = t2;
+          r += 8;
+        }
+        if ((t2 = x >> 4) != 0) {
+          x = t2;
+          r += 4;
+        }
+        if ((t2 = x >> 2) != 0) {
+          x = t2;
+          r += 2;
+        }
+        if ((t2 = x >> 1) != 0) {
+          x = t2;
+          r += 1;
+        }
+        return r;
+      }
+      function bnBitLength() {
+        if (this.t <= 0)
+          return 0;
+        return this.DB * (this.t - 1) + nbits(this[this.t - 1] ^ this.s & this.DM);
+      }
+      function bnpDLShiftTo(n, r) {
+        var i;
+        for (i = this.t - 1; i >= 0; --i)
+          r[i + n] = this[i];
+        for (i = n - 1; i >= 0; --i)
+          r[i] = 0;
+        r.t = this.t + n;
+        r.s = this.s;
+      }
+      function bnpDRShiftTo(n, r) {
+        for (var i = n; i < this.t; ++i)
+          r[i - n] = this[i];
+        r.t = Math.max(this.t - n, 0);
+        r.s = this.s;
+      }
+      function bnpLShiftTo(n, r) {
+        var bs = n % this.DB;
+        var cbs = this.DB - bs;
+        var bm = (1 << cbs) - 1;
+        var ds = Math.floor(n / this.DB), c = this.s << bs & this.DM, i;
+        for (i = this.t - 1; i >= 0; --i) {
+          r[i + ds + 1] = this[i] >> cbs | c;
+          c = (this[i] & bm) << bs;
+        }
+        for (i = ds - 1; i >= 0; --i)
+          r[i] = 0;
+        r[ds] = c;
+        r.t = this.t + ds + 1;
+        r.s = this.s;
+        r.clamp();
+      }
+      function bnpRShiftTo(n, r) {
+        r.s = this.s;
+        var ds = Math.floor(n / this.DB);
+        if (ds >= this.t) {
+          r.t = 0;
+          return;
+        }
+        var bs = n % this.DB;
+        var cbs = this.DB - bs;
+        var bm = (1 << bs) - 1;
+        r[0] = this[ds] >> bs;
+        for (var i = ds + 1; i < this.t; ++i) {
+          r[i - ds - 1] |= (this[i] & bm) << cbs;
+          r[i - ds] = this[i] >> bs;
+        }
+        if (bs > 0)
+          r[this.t - ds - 1] |= (this.s & bm) << cbs;
+        r.t = this.t - ds;
+        r.clamp();
+      }
+      function bnpSubTo(a, r) {
+        var i = 0, c = 0, m = Math.min(a.t, this.t);
+        while (i < m) {
+          c += this[i] - a[i];
+          r[i++] = c & this.DM;
+          c >>= this.DB;
+        }
+        if (a.t < this.t) {
+          c -= a.s;
+          while (i < this.t) {
+            c += this[i];
+            r[i++] = c & this.DM;
+            c >>= this.DB;
+          }
+          c += this.s;
+        } else {
+          c += this.s;
+          while (i < a.t) {
+            c -= a[i];
+            r[i++] = c & this.DM;
+            c >>= this.DB;
+          }
+          c -= a.s;
+        }
+        r.s = c < 0 ? -1 : 0;
+        if (c < -1)
+          r[i++] = this.DV + c;
+        else if (c > 0)
+          r[i++] = c;
+        r.t = i;
+        r.clamp();
+      }
+      function bnpMultiplyTo(a, r) {
+        var x = this.abs(), y = a.abs();
+        var i = x.t;
+        r.t = i + y.t;
+        while (--i >= 0)
+          r[i] = 0;
+        for (i = 0; i < y.t; ++i)
+          r[i + x.t] = x.am(0, y[i], r, i, 0, x.t);
+        r.s = 0;
+        r.clamp();
+        if (this.s != a.s)
+          BigInteger3.ZERO.subTo(r, r);
+      }
+      function bnpSquareTo(r) {
+        var x = this.abs();
+        var i = r.t = 2 * x.t;
+        while (--i >= 0)
+          r[i] = 0;
+        for (i = 0; i < x.t - 1; ++i) {
+          var c = x.am(i, x[i], r, 2 * i, 0, 1);
+          if ((r[i + x.t] += x.am(i + 1, 2 * x[i], r, 2 * i + 1, c, x.t - i - 1)) >= x.DV) {
+            r[i + x.t] -= x.DV;
+            r[i + x.t + 1] = 1;
+          }
+        }
+        if (r.t > 0)
+          r[r.t - 1] += x.am(i, x[i], r, 2 * i, 0, 1);
+        r.s = 0;
+        r.clamp();
+      }
+      function bnpDivRemTo(m, q, r) {
+        var pm = m.abs();
+        if (pm.t <= 0)
+          return;
+        var pt = this.abs();
+        if (pt.t < pm.t) {
+          if (q != null)
+            q.fromInt(0);
+          if (r != null)
+            this.copyTo(r);
+          return;
+        }
+        if (r == null)
+          r = nbi();
+        var y = nbi(), ts = this.s, ms = m.s;
+        var nsh = this.DB - nbits(pm[pm.t - 1]);
+        if (nsh > 0) {
+          pm.lShiftTo(nsh, y);
+          pt.lShiftTo(nsh, r);
+        } else {
+          pm.copyTo(y);
+          pt.copyTo(r);
+        }
+        var ys = y.t;
+        var y0 = y[ys - 1];
+        if (y0 == 0)
+          return;
+        var yt = y0 * (1 << this.F1) + (ys > 1 ? y[ys - 2] >> this.F2 : 0);
+        var d1 = this.FV / yt, d2 = (1 << this.F1) / yt, e = 1 << this.F2;
+        var i = r.t, j = i - ys, t2 = q == null ? nbi() : q;
+        y.dlShiftTo(j, t2);
+        if (r.compareTo(t2) >= 0) {
+          r[r.t++] = 1;
+          r.subTo(t2, r);
+        }
+        BigInteger3.ONE.dlShiftTo(ys, t2);
+        t2.subTo(y, y);
+        while (y.t < ys)
+          y[y.t++] = 0;
+        while (--j >= 0) {
+          var qd = r[--i] == y0 ? this.DM : Math.floor(r[i] * d1 + (r[i - 1] + e) * d2);
+          if ((r[i] += y.am(0, qd, r, j, 0, ys)) < qd) {
+            y.dlShiftTo(j, t2);
+            r.subTo(t2, r);
+            while (r[i] < --qd)
+              r.subTo(t2, r);
+          }
+        }
+        if (q != null) {
+          r.drShiftTo(ys, q);
+          if (ts != ms)
+            BigInteger3.ZERO.subTo(q, q);
+        }
+        r.t = ys;
+        r.clamp();
+        if (nsh > 0)
+          r.rShiftTo(nsh, r);
+        if (ts < 0)
+          BigInteger3.ZERO.subTo(r, r);
+      }
+      function bnMod(a) {
+        var r = nbi();
+        this.abs().divRemTo(a, null, r);
+        if (this.s < 0 && r.compareTo(BigInteger3.ZERO) > 0)
+          a.subTo(r, r);
+        return r;
+      }
+      function Classic(m) {
+        this.m = m;
+      }
+      function cConvert(x) {
+        if (x.s < 0 || x.compareTo(this.m) >= 0)
+          return x.mod(this.m);
+        else
+          return x;
+      }
+      function cRevert(x) {
+        return x;
+      }
+      function cReduce(x) {
+        x.divRemTo(this.m, null, x);
+      }
+      function cMulTo(x, y, r) {
+        x.multiplyTo(y, r);
+        this.reduce(r);
+      }
+      function cSqrTo(x, r) {
+        x.squareTo(r);
+        this.reduce(r);
+      }
+      Classic.prototype.convert = cConvert;
+      Classic.prototype.revert = cRevert;
+      Classic.prototype.reduce = cReduce;
+      Classic.prototype.mulTo = cMulTo;
+      Classic.prototype.sqrTo = cSqrTo;
+      function bnpInvDigit() {
+        if (this.t < 1)
+          return 0;
+        var x = this[0];
+        if ((x & 1) == 0)
+          return 0;
+        var y = x & 3;
+        y = y * (2 - (x & 15) * y) & 15;
+        y = y * (2 - (x & 255) * y) & 255;
+        y = y * (2 - ((x & 65535) * y & 65535)) & 65535;
+        y = y * (2 - x * y % this.DV) % this.DV;
+        return y > 0 ? this.DV - y : -y;
+      }
+      function Montgomery(m) {
+        this.m = m;
+        this.mp = m.invDigit();
+        this.mpl = this.mp & 32767;
+        this.mph = this.mp >> 15;
+        this.um = (1 << m.DB - 15) - 1;
+        this.mt2 = 2 * m.t;
+      }
+      function montConvert(x) {
+        var r = nbi();
+        x.abs().dlShiftTo(this.m.t, r);
+        r.divRemTo(this.m, null, r);
+        if (x.s < 0 && r.compareTo(BigInteger3.ZERO) > 0)
+          this.m.subTo(r, r);
+        return r;
+      }
+      function montRevert(x) {
+        var r = nbi();
+        x.copyTo(r);
+        this.reduce(r);
+        return r;
+      }
+      function montReduce(x) {
+        while (x.t <= this.mt2)
+          x[x.t++] = 0;
+        for (var i = 0; i < this.m.t; ++i) {
+          var j = x[i] & 32767;
+          var u0 = j * this.mpl + ((j * this.mph + (x[i] >> 15) * this.mpl & this.um) << 15) & x.DM;
+          j = i + this.m.t;
+          x[j] += this.m.am(0, u0, x, i, 0, this.m.t);
+          while (x[j] >= x.DV) {
+            x[j] -= x.DV;
+            x[++j]++;
+          }
+        }
+        x.clamp();
+        x.drShiftTo(this.m.t, x);
+        if (x.compareTo(this.m) >= 0)
+          x.subTo(this.m, x);
+      }
+      function montSqrTo(x, r) {
+        x.squareTo(r);
+        this.reduce(r);
+      }
+      function montMulTo(x, y, r) {
+        x.multiplyTo(y, r);
+        this.reduce(r);
+      }
+      Montgomery.prototype.convert = montConvert;
+      Montgomery.prototype.revert = montRevert;
+      Montgomery.prototype.reduce = montReduce;
+      Montgomery.prototype.mulTo = montMulTo;
+      Montgomery.prototype.sqrTo = montSqrTo;
+      function bnpIsEven() {
+        return (this.t > 0 ? this[0] & 1 : this.s) == 0;
+      }
+      function bnpExp(e, z2) {
+        if (e > 4294967295 || e < 1)
+          return BigInteger3.ONE;
+        var r = nbi(), r2 = nbi(), g2 = z2.convert(this), i = nbits(e) - 1;
+        g2.copyTo(r);
+        while (--i >= 0) {
+          z2.sqrTo(r, r2);
+          if ((e & 1 << i) > 0)
+            z2.mulTo(r2, g2, r);
+          else {
+            var t2 = r;
+            r = r2;
+            r2 = t2;
+          }
+        }
+        return z2.revert(r);
+      }
+      function bnModPowInt(e, m) {
+        var z2;
+        if (e < 256 || m.isEven())
+          z2 = new Classic(m);
+        else
+          z2 = new Montgomery(m);
+        return this.exp(e, z2);
+      }
+      BigInteger3.prototype.copyTo = bnpCopyTo;
+      BigInteger3.prototype.fromInt = bnpFromInt;
+      BigInteger3.prototype.fromString = bnpFromString;
+      BigInteger3.prototype.clamp = bnpClamp;
+      BigInteger3.prototype.dlShiftTo = bnpDLShiftTo;
+      BigInteger3.prototype.drShiftTo = bnpDRShiftTo;
+      BigInteger3.prototype.lShiftTo = bnpLShiftTo;
+      BigInteger3.prototype.rShiftTo = bnpRShiftTo;
+      BigInteger3.prototype.subTo = bnpSubTo;
+      BigInteger3.prototype.multiplyTo = bnpMultiplyTo;
+      BigInteger3.prototype.squareTo = bnpSquareTo;
+      BigInteger3.prototype.divRemTo = bnpDivRemTo;
+      BigInteger3.prototype.invDigit = bnpInvDigit;
+      BigInteger3.prototype.isEven = bnpIsEven;
+      BigInteger3.prototype.exp = bnpExp;
+      BigInteger3.prototype.toString = bnToString;
+      BigInteger3.prototype.negate = bnNegate;
+      BigInteger3.prototype.abs = bnAbs;
+      BigInteger3.prototype.compareTo = bnCompareTo;
+      BigInteger3.prototype.bitLength = bnBitLength;
+      BigInteger3.prototype.mod = bnMod;
+      BigInteger3.prototype.modPowInt = bnModPowInt;
+      BigInteger3.ZERO = nbv(0);
+      BigInteger3.ONE = nbv(1);
+      function bnClone() {
+        var r = nbi();
+        this.copyTo(r);
+        return r;
+      }
+      function bnIntValue() {
+        if (this.s < 0) {
+          if (this.t == 1)
+            return this[0] - this.DV;
+          else if (this.t == 0)
+            return -1;
+        } else if (this.t == 1)
+          return this[0];
+        else if (this.t == 0)
+          return 0;
+        return (this[1] & (1 << 32 - this.DB) - 1) << this.DB | this[0];
+      }
+      function bnByteValue() {
+        return this.t == 0 ? this.s : this[0] << 24 >> 24;
+      }
+      function bnShortValue() {
+        return this.t == 0 ? this.s : this[0] << 16 >> 16;
+      }
+      function bnpChunkSize(r) {
+        return Math.floor(Math.LN2 * this.DB / Math.log(r));
+      }
+      function bnSigNum() {
+        if (this.s < 0)
+          return -1;
+        else if (this.t <= 0 || this.t == 1 && this[0] <= 0)
+          return 0;
+        else
+          return 1;
+      }
+      function bnpToRadix(b) {
+        if (b == null)
+          b = 10;
+        if (this.signum() == 0 || b < 2 || b > 36)
+          return "0";
+        var cs = this.chunkSize(b);
+        var a = Math.pow(b, cs);
+        var d = nbv(a), y = nbi(), z2 = nbi(), r = "";
+        this.divRemTo(d, y, z2);
+        while (y.signum() > 0) {
+          r = (a + z2.intValue()).toString(b).substr(1) + r;
+          y.divRemTo(d, y, z2);
+        }
+        return z2.intValue().toString(b) + r;
+      }
+      function bnpFromRadix(s, b) {
+        this.fromInt(0);
+        if (b == null)
+          b = 10;
+        var cs = this.chunkSize(b);
+        var d = Math.pow(b, cs), mi = false, j = 0, w = 0;
+        for (var i = 0; i < s.length; ++i) {
+          var x = intAt(s, i);
+          if (x < 0) {
+            if (s.charAt(i) == "-" && this.signum() == 0)
+              mi = true;
+            continue;
+          }
+          w = b * w + x;
+          if (++j >= cs) {
+            this.dMultiply(d);
+            this.dAddOffset(w, 0);
+            j = 0;
+            w = 0;
+          }
+        }
+        if (j > 0) {
+          this.dMultiply(Math.pow(b, j));
+          this.dAddOffset(w, 0);
+        }
+        if (mi)
+          BigInteger3.ZERO.subTo(this, this);
+      }
+      function bnpFromNumber(a, b, c) {
+        if ("number" == typeof b) {
+          if (a < 2)
+            this.fromInt(1);
+          else {
+            this.fromNumber(a, c);
+            if (!this.testBit(a - 1))
+              this.bitwiseTo(BigInteger3.ONE.shiftLeft(a - 1), op_or, this);
+            if (this.isEven())
+              this.dAddOffset(1, 0);
+            while (!this.isProbablePrime(b)) {
+              this.dAddOffset(2, 0);
+              if (this.bitLength() > a)
+                this.subTo(BigInteger3.ONE.shiftLeft(a - 1), this);
+            }
+          }
+        } else {
+          var x = new Array(), t2 = a & 7;
+          x.length = (a >> 3) + 1;
+          b.nextBytes(x);
+          if (t2 > 0)
+            x[0] &= (1 << t2) - 1;
+          else
+            x[0] = 0;
+          this.fromString(x, 256);
+        }
+      }
+      function bnToByteArray() {
+        var i = this.t, r = new Array();
+        r[0] = this.s;
+        var p = this.DB - i * this.DB % 8, d, k2 = 0;
+        if (i-- > 0) {
+          if (p < this.DB && (d = this[i] >> p) != (this.s & this.DM) >> p)
+            r[k2++] = d | this.s << this.DB - p;
+          while (i >= 0) {
+            if (p < 8) {
+              d = (this[i] & (1 << p) - 1) << 8 - p;
+              d |= this[--i] >> (p += this.DB - 8);
+            } else {
+              d = this[i] >> (p -= 8) & 255;
+              if (p <= 0) {
+                p += this.DB;
+                --i;
+              }
+            }
+            if ((d & 128) != 0)
+              d |= -256;
+            if (k2 == 0 && (this.s & 128) != (d & 128))
+              ++k2;
+            if (k2 > 0 || d != this.s)
+              r[k2++] = d;
+          }
+        }
+        return r;
+      }
+      function bnEquals(a) {
+        return this.compareTo(a) == 0;
+      }
+      function bnMin(a) {
+        return this.compareTo(a) < 0 ? this : a;
+      }
+      function bnMax(a) {
+        return this.compareTo(a) > 0 ? this : a;
+      }
+      function bnpBitwiseTo(a, op, r) {
+        var i, f, m = Math.min(a.t, this.t);
+        for (i = 0; i < m; ++i)
+          r[i] = op(this[i], a[i]);
+        if (a.t < this.t) {
+          f = a.s & this.DM;
+          for (i = m; i < this.t; ++i)
+            r[i] = op(this[i], f);
+          r.t = this.t;
+        } else {
+          f = this.s & this.DM;
+          for (i = m; i < a.t; ++i)
+            r[i] = op(f, a[i]);
+          r.t = a.t;
+        }
+        r.s = op(this.s, a.s);
+        r.clamp();
+      }
+      function op_and(x, y) {
+        return x & y;
+      }
+      function bnAnd(a) {
+        var r = nbi();
+        this.bitwiseTo(a, op_and, r);
+        return r;
+      }
+      function op_or(x, y) {
+        return x | y;
+      }
+      function bnOr(a) {
+        var r = nbi();
+        this.bitwiseTo(a, op_or, r);
+        return r;
+      }
+      function op_xor(x, y) {
+        return x ^ y;
+      }
+      function bnXor(a) {
+        var r = nbi();
+        this.bitwiseTo(a, op_xor, r);
+        return r;
+      }
+      function op_andnot(x, y) {
+        return x & ~y;
+      }
+      function bnAndNot(a) {
+        var r = nbi();
+        this.bitwiseTo(a, op_andnot, r);
+        return r;
+      }
+      function bnNot() {
+        var r = nbi();
+        for (var i = 0; i < this.t; ++i)
+          r[i] = this.DM & ~this[i];
+        r.t = this.t;
+        r.s = ~this.s;
+        return r;
+      }
+      function bnShiftLeft(n) {
+        var r = nbi();
+        if (n < 0)
+          this.rShiftTo(-n, r);
+        else
+          this.lShiftTo(n, r);
+        return r;
+      }
+      function bnShiftRight(n) {
+        var r = nbi();
+        if (n < 0)
+          this.lShiftTo(-n, r);
+        else
+          this.rShiftTo(n, r);
+        return r;
+      }
+      function lbit(x) {
+        if (x == 0)
+          return -1;
+        var r = 0;
+        if ((x & 65535) == 0) {
+          x >>= 16;
+          r += 16;
+        }
+        if ((x & 255) == 0) {
+          x >>= 8;
+          r += 8;
+        }
+        if ((x & 15) == 0) {
+          x >>= 4;
+          r += 4;
+        }
+        if ((x & 3) == 0) {
+          x >>= 2;
+          r += 2;
+        }
+        if ((x & 1) == 0)
+          ++r;
+        return r;
+      }
+      function bnGetLowestSetBit() {
+        for (var i = 0; i < this.t; ++i)
+          if (this[i] != 0)
+            return i * this.DB + lbit(this[i]);
+        if (this.s < 0)
+          return this.t * this.DB;
+        return -1;
+      }
+      function cbit(x) {
+        var r = 0;
+        while (x != 0) {
+          x &= x - 1;
+          ++r;
+        }
+        return r;
+      }
+      function bnBitCount() {
+        var r = 0, x = this.s & this.DM;
+        for (var i = 0; i < this.t; ++i)
+          r += cbit(this[i] ^ x);
+        return r;
+      }
+      function bnTestBit(n) {
+        var j = Math.floor(n / this.DB);
+        if (j >= this.t)
+          return this.s != 0;
+        return (this[j] & 1 << n % this.DB) != 0;
+      }
+      function bnpChangeBit(n, op) {
+        var r = BigInteger3.ONE.shiftLeft(n);
+        this.bitwiseTo(r, op, r);
+        return r;
+      }
+      function bnSetBit(n) {
+        return this.changeBit(n, op_or);
+      }
+      function bnClearBit(n) {
+        return this.changeBit(n, op_andnot);
+      }
+      function bnFlipBit(n) {
+        return this.changeBit(n, op_xor);
+      }
+      function bnpAddTo(a, r) {
+        var i = 0, c = 0, m = Math.min(a.t, this.t);
+        while (i < m) {
+          c += this[i] + a[i];
+          r[i++] = c & this.DM;
+          c >>= this.DB;
+        }
+        if (a.t < this.t) {
+          c += a.s;
+          while (i < this.t) {
+            c += this[i];
+            r[i++] = c & this.DM;
+            c >>= this.DB;
+          }
+          c += this.s;
+        } else {
+          c += this.s;
+          while (i < a.t) {
+            c += a[i];
+            r[i++] = c & this.DM;
+            c >>= this.DB;
+          }
+          c += a.s;
+        }
+        r.s = c < 0 ? -1 : 0;
+        if (c > 0)
+          r[i++] = c;
+        else if (c < -1)
+          r[i++] = this.DV + c;
+        r.t = i;
+        r.clamp();
+      }
+      function bnAdd(a) {
+        var r = nbi();
+        this.addTo(a, r);
+        return r;
+      }
+      function bnSubtract(a) {
+        var r = nbi();
+        this.subTo(a, r);
+        return r;
+      }
+      function bnMultiply(a) {
+        var r = nbi();
+        this.multiplyTo(a, r);
+        return r;
+      }
+      function bnSquare() {
+        var r = nbi();
+        this.squareTo(r);
+        return r;
+      }
+      function bnDivide(a) {
+        var r = nbi();
+        this.divRemTo(a, r, null);
+        return r;
+      }
+      function bnRemainder(a) {
+        var r = nbi();
+        this.divRemTo(a, null, r);
+        return r;
+      }
+      function bnDivideAndRemainder(a) {
+        var q = nbi(), r = nbi();
+        this.divRemTo(a, q, r);
+        return new Array(q, r);
+      }
+      function bnpDMultiply(n) {
+        this[this.t] = this.am(0, n - 1, this, 0, 0, this.t);
+        ++this.t;
+        this.clamp();
+      }
+      function bnpDAddOffset(n, w) {
+        if (n == 0)
+          return;
+        while (this.t <= w)
+          this[this.t++] = 0;
+        this[w] += n;
+        while (this[w] >= this.DV) {
+          this[w] -= this.DV;
+          if (++w >= this.t)
+            this[this.t++] = 0;
+          ++this[w];
+        }
+      }
+      function NullExp() {
+      }
+      function nNop(x) {
+        return x;
+      }
+      function nMulTo(x, y, r) {
+        x.multiplyTo(y, r);
+      }
+      function nSqrTo(x, r) {
+        x.squareTo(r);
+      }
+      NullExp.prototype.convert = nNop;
+      NullExp.prototype.revert = nNop;
+      NullExp.prototype.mulTo = nMulTo;
+      NullExp.prototype.sqrTo = nSqrTo;
+      function bnPow(e) {
+        return this.exp(e, new NullExp());
+      }
+      function bnpMultiplyLowerTo(a, n, r) {
+        var i = Math.min(this.t + a.t, n);
+        r.s = 0;
+        r.t = i;
+        while (i > 0)
+          r[--i] = 0;
+        var j;
+        for (j = r.t - this.t; i < j; ++i)
+          r[i + this.t] = this.am(0, a[i], r, i, 0, this.t);
+        for (j = Math.min(a.t, n); i < j; ++i)
+          this.am(0, a[i], r, i, 0, n - i);
+        r.clamp();
+      }
+      function bnpMultiplyUpperTo(a, n, r) {
+        --n;
+        var i = r.t = this.t + a.t - n;
+        r.s = 0;
+        while (--i >= 0)
+          r[i] = 0;
+        for (i = Math.max(n - this.t, 0); i < a.t; ++i)
+          r[this.t + i - n] = this.am(n - i, a[i], r, 0, 0, this.t + i - n);
+        r.clamp();
+        r.drShiftTo(1, r);
+      }
+      function Barrett(m) {
+        this.r2 = nbi();
+        this.q3 = nbi();
+        BigInteger3.ONE.dlShiftTo(2 * m.t, this.r2);
+        this.mu = this.r2.divide(m);
+        this.m = m;
+      }
+      function barrettConvert(x) {
+        if (x.s < 0 || x.t > 2 * this.m.t)
+          return x.mod(this.m);
+        else if (x.compareTo(this.m) < 0)
+          return x;
+        else {
+          var r = nbi();
+          x.copyTo(r);
+          this.reduce(r);
+          return r;
+        }
+      }
+      function barrettRevert(x) {
+        return x;
+      }
+      function barrettReduce(x) {
+        x.drShiftTo(this.m.t - 1, this.r2);
+        if (x.t > this.m.t + 1) {
+          x.t = this.m.t + 1;
+          x.clamp();
+        }
+        this.mu.multiplyUpperTo(this.r2, this.m.t + 1, this.q3);
+        this.m.multiplyLowerTo(this.q3, this.m.t + 1, this.r2);
+        while (x.compareTo(this.r2) < 0)
+          x.dAddOffset(1, this.m.t + 1);
+        x.subTo(this.r2, x);
+        while (x.compareTo(this.m) >= 0)
+          x.subTo(this.m, x);
+      }
+      function barrettSqrTo(x, r) {
+        x.squareTo(r);
+        this.reduce(r);
+      }
+      function barrettMulTo(x, y, r) {
+        x.multiplyTo(y, r);
+        this.reduce(r);
+      }
+      Barrett.prototype.convert = barrettConvert;
+      Barrett.prototype.revert = barrettRevert;
+      Barrett.prototype.reduce = barrettReduce;
+      Barrett.prototype.mulTo = barrettMulTo;
+      Barrett.prototype.sqrTo = barrettSqrTo;
+      function bnModPow(e, m) {
+        var i = e.bitLength(), k2, r = nbv(1), z2;
+        if (i <= 0)
+          return r;
+        else if (i < 18)
+          k2 = 1;
+        else if (i < 48)
+          k2 = 3;
+        else if (i < 144)
+          k2 = 4;
+        else if (i < 768)
+          k2 = 5;
+        else
+          k2 = 6;
+        if (i < 8)
+          z2 = new Classic(m);
+        else if (m.isEven())
+          z2 = new Barrett(m);
+        else
+          z2 = new Montgomery(m);
+        var g2 = new Array(), n = 3, k1 = k2 - 1, km = (1 << k2) - 1;
+        g2[1] = z2.convert(this);
+        if (k2 > 1) {
+          var g22 = nbi();
+          z2.sqrTo(g2[1], g22);
+          while (n <= km) {
+            g2[n] = nbi();
+            z2.mulTo(g22, g2[n - 2], g2[n]);
+            n += 2;
+          }
+        }
+        var j = e.t - 1, w, is1 = true, r2 = nbi(), t2;
+        i = nbits(e[j]) - 1;
+        while (j >= 0) {
+          if (i >= k1)
+            w = e[j] >> i - k1 & km;
+          else {
+            w = (e[j] & (1 << i + 1) - 1) << k1 - i;
+            if (j > 0)
+              w |= e[j - 1] >> this.DB + i - k1;
+          }
+          n = k2;
+          while ((w & 1) == 0) {
+            w >>= 1;
+            --n;
+          }
+          if ((i -= n) < 0) {
+            i += this.DB;
+            --j;
+          }
+          if (is1) {
+            g2[w].copyTo(r);
+            is1 = false;
+          } else {
+            while (n > 1) {
+              z2.sqrTo(r, r2);
+              z2.sqrTo(r2, r);
+              n -= 2;
+            }
+            if (n > 0)
+              z2.sqrTo(r, r2);
+            else {
+              t2 = r;
+              r = r2;
+              r2 = t2;
+            }
+            z2.mulTo(r2, g2[w], r);
+          }
+          while (j >= 0 && (e[j] & 1 << i) == 0) {
+            z2.sqrTo(r, r2);
+            t2 = r;
+            r = r2;
+            r2 = t2;
+            if (--i < 0) {
+              i = this.DB - 1;
+              --j;
+            }
+          }
+        }
+        return z2.revert(r);
+      }
+      function bnGCD(a) {
+        var x = this.s < 0 ? this.negate() : this.clone();
+        var y = a.s < 0 ? a.negate() : a.clone();
+        if (x.compareTo(y) < 0) {
+          var t2 = x;
+          x = y;
+          y = t2;
+        }
+        var i = x.getLowestSetBit(), g2 = y.getLowestSetBit();
+        if (g2 < 0)
+          return x;
+        if (i < g2)
+          g2 = i;
+        if (g2 > 0) {
+          x.rShiftTo(g2, x);
+          y.rShiftTo(g2, y);
+        }
+        while (x.signum() > 0) {
+          if ((i = x.getLowestSetBit()) > 0)
+            x.rShiftTo(i, x);
+          if ((i = y.getLowestSetBit()) > 0)
+            y.rShiftTo(i, y);
+          if (x.compareTo(y) >= 0) {
+            x.subTo(y, x);
+            x.rShiftTo(1, x);
+          } else {
+            y.subTo(x, y);
+            y.rShiftTo(1, y);
+          }
+        }
+        if (g2 > 0)
+          y.lShiftTo(g2, y);
+        return y;
+      }
+      function bnpModInt(n) {
+        if (n <= 0)
+          return 0;
+        var d = this.DV % n, r = this.s < 0 ? n - 1 : 0;
+        if (this.t > 0)
+          if (d == 0)
+            r = this[0] % n;
+          else
+            for (var i = this.t - 1; i >= 0; --i)
+              r = (d * r + this[i]) % n;
+        return r;
+      }
+      function bnModInverse(m) {
+        var ac = m.isEven();
+        if (this.isEven() && ac || m.signum() == 0)
+          return BigInteger3.ZERO;
+        var u = m.clone(), v = this.clone();
+        var a = nbv(1), b = nbv(0), c = nbv(0), d = nbv(1);
+        while (u.signum() != 0) {
+          while (u.isEven()) {
+            u.rShiftTo(1, u);
+            if (ac) {
+              if (!a.isEven() || !b.isEven()) {
+                a.addTo(this, a);
+                b.subTo(m, b);
+              }
+              a.rShiftTo(1, a);
+            } else if (!b.isEven())
+              b.subTo(m, b);
+            b.rShiftTo(1, b);
+          }
+          while (v.isEven()) {
+            v.rShiftTo(1, v);
+            if (ac) {
+              if (!c.isEven() || !d.isEven()) {
+                c.addTo(this, c);
+                d.subTo(m, d);
+              }
+              c.rShiftTo(1, c);
+            } else if (!d.isEven())
+              d.subTo(m, d);
+            d.rShiftTo(1, d);
+          }
+          if (u.compareTo(v) >= 0) {
+            u.subTo(v, u);
+            if (ac)
+              a.subTo(c, a);
+            b.subTo(d, b);
+          } else {
+            v.subTo(u, v);
+            if (ac)
+              c.subTo(a, c);
+            d.subTo(b, d);
+          }
+        }
+        if (v.compareTo(BigInteger3.ONE) != 0)
+          return BigInteger3.ZERO;
+        if (d.compareTo(m) >= 0)
+          return d.subtract(m);
+        if (d.signum() < 0)
+          d.addTo(m, d);
+        else
+          return d;
+        if (d.signum() < 0)
+          return d.add(m);
+        else
+          return d;
+      }
+      var lowprimes = [2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31, 37, 41, 43, 47, 53, 59, 61, 67, 71, 73, 79, 83, 89, 97, 101, 103, 107, 109, 113, 127, 131, 137, 139, 149, 151, 157, 163, 167, 173, 179, 181, 191, 193, 197, 199, 211, 223, 227, 229, 233, 239, 241, 251, 257, 263, 269, 271, 277, 281, 283, 293, 307, 311, 313, 317, 331, 337, 347, 349, 353, 359, 367, 373, 379, 383, 389, 397, 401, 409, 419, 421, 431, 433, 439, 443, 449, 457, 461, 463, 467, 479, 487, 491, 499, 503, 509, 521, 523, 541, 547, 557, 563, 569, 571, 577, 587, 593, 599, 601, 607, 613, 617, 619, 631, 641, 643, 647, 653, 659, 661, 673, 677, 683, 691, 701, 709, 719, 727, 733, 739, 743, 751, 757, 761, 769, 773, 787, 797, 809, 811, 821, 823, 827, 829, 839, 853, 857, 859, 863, 877, 881, 883, 887, 907, 911, 919, 929, 937, 941, 947, 953, 967, 971, 977, 983, 991, 997];
+      var lplim = (1 << 26) / lowprimes[lowprimes.length - 1];
+      function bnIsProbablePrime(t2) {
+        var i, x = this.abs();
+        if (x.t == 1 && x[0] <= lowprimes[lowprimes.length - 1]) {
+          for (i = 0; i < lowprimes.length; ++i)
+            if (x[0] == lowprimes[i])
+              return true;
+          return false;
+        }
+        if (x.isEven())
+          return false;
+        i = 1;
+        while (i < lowprimes.length) {
+          var m = lowprimes[i], j = i + 1;
+          while (j < lowprimes.length && m < lplim)
+            m *= lowprimes[j++];
+          m = x.modInt(m);
+          while (i < j)
+            if (m % lowprimes[i++] == 0)
+              return false;
+        }
+        return x.millerRabin(t2);
+      }
+      function bnpMillerRabin(t2) {
+        var n1 = this.subtract(BigInteger3.ONE);
+        var k2 = n1.getLowestSetBit();
+        if (k2 <= 0)
+          return false;
+        var r = n1.shiftRight(k2);
+        t2 = t2 + 1 >> 1;
+        if (t2 > lowprimes.length)
+          t2 = lowprimes.length;
+        var a = nbi();
+        for (var i = 0; i < t2; ++i) {
+          a.fromInt(lowprimes[Math.floor(Math.random() * lowprimes.length)]);
+          var y = a.modPow(r, this);
+          if (y.compareTo(BigInteger3.ONE) != 0 && y.compareTo(n1) != 0) {
+            var j = 1;
+            while (j++ < k2 && y.compareTo(n1) != 0) {
+              y = y.modPowInt(2, this);
+              if (y.compareTo(BigInteger3.ONE) == 0)
+                return false;
+            }
+            if (y.compareTo(n1) != 0)
+              return false;
+          }
+        }
+        return true;
+      }
+      BigInteger3.prototype.chunkSize = bnpChunkSize;
+      BigInteger3.prototype.toRadix = bnpToRadix;
+      BigInteger3.prototype.fromRadix = bnpFromRadix;
+      BigInteger3.prototype.fromNumber = bnpFromNumber;
+      BigInteger3.prototype.bitwiseTo = bnpBitwiseTo;
+      BigInteger3.prototype.changeBit = bnpChangeBit;
+      BigInteger3.prototype.addTo = bnpAddTo;
+      BigInteger3.prototype.dMultiply = bnpDMultiply;
+      BigInteger3.prototype.dAddOffset = bnpDAddOffset;
+      BigInteger3.prototype.multiplyLowerTo = bnpMultiplyLowerTo;
+      BigInteger3.prototype.multiplyUpperTo = bnpMultiplyUpperTo;
+      BigInteger3.prototype.modInt = bnpModInt;
+      BigInteger3.prototype.millerRabin = bnpMillerRabin;
+      BigInteger3.prototype.clone = bnClone;
+      BigInteger3.prototype.intValue = bnIntValue;
+      BigInteger3.prototype.byteValue = bnByteValue;
+      BigInteger3.prototype.shortValue = bnShortValue;
+      BigInteger3.prototype.signum = bnSigNum;
+      BigInteger3.prototype.toByteArray = bnToByteArray;
+      BigInteger3.prototype.equals = bnEquals;
+      BigInteger3.prototype.min = bnMin;
+      BigInteger3.prototype.max = bnMax;
+      BigInteger3.prototype.and = bnAnd;
+      BigInteger3.prototype.or = bnOr;
+      BigInteger3.prototype.xor = bnXor;
+      BigInteger3.prototype.andNot = bnAndNot;
+      BigInteger3.prototype.not = bnNot;
+      BigInteger3.prototype.shiftLeft = bnShiftLeft;
+      BigInteger3.prototype.shiftRight = bnShiftRight;
+      BigInteger3.prototype.getLowestSetBit = bnGetLowestSetBit;
+      BigInteger3.prototype.bitCount = bnBitCount;
+      BigInteger3.prototype.testBit = bnTestBit;
+      BigInteger3.prototype.setBit = bnSetBit;
+      BigInteger3.prototype.clearBit = bnClearBit;
+      BigInteger3.prototype.flipBit = bnFlipBit;
+      BigInteger3.prototype.add = bnAdd;
+      BigInteger3.prototype.subtract = bnSubtract;
+      BigInteger3.prototype.multiply = bnMultiply;
+      BigInteger3.prototype.divide = bnDivide;
+      BigInteger3.prototype.remainder = bnRemainder;
+      BigInteger3.prototype.divideAndRemainder = bnDivideAndRemainder;
+      BigInteger3.prototype.modPow = bnModPow;
+      BigInteger3.prototype.modInverse = bnModInverse;
+      BigInteger3.prototype.pow = bnPow;
+      BigInteger3.prototype.gcd = bnGCD;
+      BigInteger3.prototype.isProbablePrime = bnIsProbablePrime;
+      BigInteger3.prototype.square = bnSquare;
+      BigInteger3.prototype.Barrett = Barrett;
+      var rng_state;
+      var rng_pool;
+      var rng_pptr;
+      function rng_seed_int(x) {
+        rng_pool[rng_pptr++] ^= x & 255;
+        rng_pool[rng_pptr++] ^= x >> 8 & 255;
+        rng_pool[rng_pptr++] ^= x >> 16 & 255;
+        rng_pool[rng_pptr++] ^= x >> 24 & 255;
+        if (rng_pptr >= rng_psize)
+          rng_pptr -= rng_psize;
+      }
+      function rng_seed_time() {
+        rng_seed_int((/* @__PURE__ */ new Date()).getTime());
+      }
+      if (rng_pool == null) {
+        rng_pool = new Array();
+        rng_pptr = 0;
+        var t;
+        if (typeof window !== "undefined" && window.crypto) {
+          if (window.crypto.getRandomValues) {
+            var ua = new Uint8Array(32);
+            window.crypto.getRandomValues(ua);
+            for (t = 0; t < 32; ++t)
+              rng_pool[rng_pptr++] = ua[t];
+          } else if (navigator.appName == "Netscape" && navigator.appVersion < "5") {
+            var z = window.crypto.random(32);
+            for (t = 0; t < z.length; ++t)
+              rng_pool[rng_pptr++] = z.charCodeAt(t) & 255;
+          }
+        }
+        while (rng_pptr < rng_psize) {
+          t = Math.floor(65536 * Math.random());
+          rng_pool[rng_pptr++] = t >>> 8;
+          rng_pool[rng_pptr++] = t & 255;
+        }
+        rng_pptr = 0;
+        rng_seed_time();
+      }
+      function rng_get_byte() {
+        if (rng_state == null) {
+          rng_seed_time();
+          rng_state = prng_newstate();
+          rng_state.init(rng_pool);
+          for (rng_pptr = 0; rng_pptr < rng_pool.length; ++rng_pptr)
+            rng_pool[rng_pptr] = 0;
+          rng_pptr = 0;
+        }
+        return rng_state.next();
+      }
+      function rng_get_bytes(ba) {
+        var i;
+        for (i = 0; i < ba.length; ++i)
+          ba[i] = rng_get_byte();
+      }
+      function SecureRandom() {
+      }
+      SecureRandom.prototype.nextBytes = rng_get_bytes;
+      function Arcfour() {
+        this.i = 0;
+        this.j = 0;
+        this.S = new Array();
+      }
+      function ARC4init(key) {
+        var i, j, t2;
+        for (i = 0; i < 256; ++i)
+          this.S[i] = i;
+        j = 0;
+        for (i = 0; i < 256; ++i) {
+          j = j + this.S[i] + key[i % key.length] & 255;
+          t2 = this.S[i];
+          this.S[i] = this.S[j];
+          this.S[j] = t2;
+        }
+        this.i = 0;
+        this.j = 0;
+      }
+      function ARC4next() {
+        var t2;
+        this.i = this.i + 1 & 255;
+        this.j = this.j + this.S[this.i] & 255;
+        t2 = this.S[this.i];
+        this.S[this.i] = this.S[this.j];
+        this.S[this.j] = t2;
+        return this.S[t2 + this.S[this.i] & 255];
+      }
+      Arcfour.prototype.init = ARC4init;
+      Arcfour.prototype.next = ARC4next;
+      function prng_newstate() {
+        return new Arcfour();
+      }
+      var rng_psize = 256;
+      if (typeof exports !== "undefined") {
+        exports = module.exports = {
+          default: BigInteger3,
+          BigInteger: BigInteger3,
+          SecureRandom
+        };
+      } else {
+        this.jsbn = {
+          BigInteger: BigInteger3,
+          SecureRandom
+        };
+      }
+    }).call(exports);
+  }
+});
+
+// node_modules/.pnpm/randombytes@2.1.0/node_modules/randombytes/index.js
+var require_randombytes = __commonJS({
+  "node_modules/.pnpm/randombytes@2.1.0/node_modules/randombytes/index.js"(exports, module) {
+    module.exports = __require("crypto").randomBytes;
+  }
+});
+
+// src/cognito-client.ts
+var import_hash2 = __toESM(require_hash(), 1);
+var import_jsbn2 = __toESM(require_jsbn(), 1);
+var import_randombytes2 = __toESM(require_randombytes(), 1);
+import addSeconds from "date-fns/addSeconds";
+
+// src/error.ts
+var AuthError = /* @__PURE__ */ ((AuthError2) => {
+  AuthError2["UserConfirmedAlready"] = "user_confirmed_already";
+  AuthError2["UserDoesNotExist"] = "user_does_not_exist";
+  AuthError2["UserAlreadyExists"] = "user_already_exists";
+  AuthError2["EmailOrPasswordWrong"] = "email_or_password_wrong";
+  AuthError2["LimitExceededException"] = "limit_exceeded_exception";
+  AuthError2["UserNotAuthenticated"] = "user_not_authenticated";
+  AuthError2["PasswordAttempsExceeded"] = "password_attemps_exceeded";
+  AuthError2["UserEmailNotVerified"] = "user_email_not_verified";
+  AuthError2["Unknown"] = "unknown";
+  return AuthError2;
+})(AuthError || {});
+var AuthException = class extends Error {
+  constructor(message, authError) {
+    super(message);
+    this.authError = authError;
+  }
+};
+var ErrorCode = /* @__PURE__ */ ((ErrorCode2) => {
+  ErrorCode2["UserNotFoundException"] = "UserNotFoundException";
+  ErrorCode2["NotAuthorizedException"] = "NotAuthorizedException";
+  ErrorCode2["LimitExceededException"] = "LimitExceededException";
+  return ErrorCode2;
+})(ErrorCode || {});
+function getAuthError(errorResponse) {
+  const mapping = {
+    "UserNotFoundException:User cannot be confirmed. Current status is CONFIRMED": "user_confirmed_already" /* UserConfirmedAlready */,
+    "NotAuthorizedException:Incorrect username or password.": "email_or_password_wrong" /* EmailOrPasswordWrong */,
+    "LimitExceededException:Attempt limit exceeded, please try after some time.": "limit_exceeded_exception" /* LimitExceededException */,
+    "UserNotFoundException:Username/client id combination not found.": "user_does_not_exist" /* UserDoesNotExist */,
+    "UserNotFoundException:User does not exist.": "user_does_not_exist" /* UserDoesNotExist */,
+    "NotAuthorizedException:Password attempts exceeded": "password_attemps_exceeded" /* PasswordAttempsExceeded */,
+    "UsernameExistsException:An account with the given email already exists.": "user_already_exists" /* UserAlreadyExists */,
+    "InvalidParameterException:Cannot reset password for the user as there is no registered/verified email or phone_number": "user_email_not_verified" /* UserEmailNotVerified */,
+    "UserNotConfirmedException:User is not confirmed.": "user_email_not_verified" /* UserEmailNotVerified */
+  };
+  const message = `${errorResponse.__type}:${errorResponse.message}`;
+  const authError = mapping[message] || "unknown" /* Unknown */;
+  return new AuthException(message, authError);
+}
+
+// src/utils.ts
+var import_hash = __toESM(require_hash(), 1);
+var import_jsbn = __toESM(require_jsbn(), 1);
+var import_randombytes = __toESM(require_randombytes(), 1);
+import formatInTimeZone from "date-fns-tz/formatInTimeZone";
+var initN = "FFFFFFFFFFFFFFFFC90FDAA22168C234C4C6628B80DC1CD129024E088A67CC74020BBEA63B139B22514A08798E3404DDEF9519B3CD3A431B302B0A6DF25F14374FE1356D6D51C245E485B576625E7EC6F44C42E9A637ED6B0BFF5CB6F406B7EDEE386BFB5A899FA5AE9F24117C4B1FE649286651ECE45B3DC2007CB8A163BF0598DA48361C55D39A69163FA8FD24CF5F83655D23DCA3AD961C62F356208552BB9ED529077096966D670C354E4ABC9804F1746C08CA18217C32905E462E36CE3BE39E772C180E86039B2783A2EC07A28FB5C55DF06F4C52C9DE2BCBF6955817183995497CEA956AE515D2261898FA051015728E5A8AAAC42DAD33170D04507A33A85521ABDF1CBA64ECFB850458DBEF0A8AEA71575D060C7DB3970F85A6E1E4C7ABF5AE8CDB0933D71E8C94E04A25619DCEE3D2261AD2EE6BF12FFA06D98A0864D87602733EC86A64521F2B18177B200CBBE117577A615D6C770988C0BAD946E208E24FA074E5AB3143DB5BFCE0FD108E4B82D120A93AD2CAFFFFFFFFFFFFFFFF";
+var N = new import_jsbn.BigInteger(initN, 16);
+var g = new import_jsbn.BigInteger("2", 16);
+var k = new import_jsbn.BigInteger(hashHexString(`${padHex(N)}${padHex(g)}`), 16);
+function padHex(bigInt) {
+  const HEX_MSB_REGEX = /^[89a-f]/i;
+  const isNegative = bigInt.compareTo(import_jsbn.BigInteger.ZERO) < 0;
+  let hexStr = bigInt.abs().toString(16);
+  hexStr = hexStr.length % 2 !== 0 ? `0${hexStr}` : hexStr;
+  hexStr = HEX_MSB_REGEX.test(hexStr) ? `00${hexStr}` : hexStr;
+  if (isNegative) {
+    const invertedNibbles = hexStr.split("").map((x) => {
+      const invertedNibble = ~parseInt(x, 16) & 15;
+      return "0123456789ABCDEF".charAt(invertedNibble);
+    }).join("");
+    const flippedBitsBI = new import_jsbn.BigInteger(invertedNibbles, 16).add(import_jsbn.BigInteger.ONE);
+    hexStr = flippedBitsBI.toString(16);
+    if (hexStr.toUpperCase().startsWith("FF8")) {
+      hexStr = hexStr.substring(2);
+    }
+  }
+  return hexStr;
+}
+function hashHexString(str) {
+  return hashBuffer(Buffer.from(str, "hex"));
+}
+function hashBuffer(buffer) {
+  const hash = (0, import_hash.sha256)().update(buffer).digest("hex");
+  return new Array(64 - hash.length).join("0") + hash;
+}
+function generateSmallA() {
+  return new import_jsbn.BigInteger((0, import_randombytes.default)(128).toString("hex"), 16);
+}
+function generateA(smallA) {
+  const A = g.modPow(smallA, N);
+  return A;
+}
+function calculateU(A, B) {
+  return new import_jsbn.BigInteger(hashHexString(padHex(A) + padHex(B)), 16);
+}
+function calculateS(X, B, U, smallA) {
+  const gModPowXN = g.modPow(X, N);
+  const bMinusKMult = B.subtract(k.multiply(gModPowXN));
+  return bMinusKMult.modPow(smallA.add(U.multiply(X)), N).mod(N);
+}
+function calculateHKDF(ikm, salt) {
+  const infoBitsBuffer = Buffer.concat([
+    Buffer.from("Caldera Derived Key", "utf8"),
+    Buffer.from(String.fromCharCode(1), "utf8")
+  ]);
+  const prk = (0, import_hash.hmac)(import_hash.sha256, salt).update(ikm).digest();
+  const hmacResult = (0, import_hash.hmac)(import_hash.sha256, prk).update(infoBitsBuffer).digest();
+  return hmacResult.slice(0, 16);
+}
+function getPasswordAuthenticationKey(poolName, username, password, B, U, smallA, salt) {
+  const usernamePassword = `${poolName}${username}:${password}`;
+  const usernamePasswordHash = hashBuffer(Buffer.from(usernamePassword, "utf-8"));
+  const X = new import_jsbn.BigInteger(hashHexString(padHex(salt) + usernamePasswordHash), 16);
+  const S = calculateS(X, B, U, smallA);
+  return calculateHKDF(Buffer.from(padHex(S), "hex"), Buffer.from(padHex(U), "hex"));
+}
+function calculateSignature(poolName, userId, secretBlock, hkdf) {
+  const timeStamp = formatInTimeZone(/* @__PURE__ */ new Date(), "UTC", "EEE MMM d HH:mm:ss 'UTC' yyyy");
+  const concatBuffer = Buffer.concat([
+    Buffer.from(poolName, "utf8"),
+    Buffer.from(userId, "utf8"),
+    Buffer.from(secretBlock, "base64"),
+    Buffer.from(timeStamp, "utf8")
+  ]);
+  const signature = Buffer.from(
+    (0, import_hash.hmac)(import_hash.sha256, hkdf).update(concatBuffer).digest()
+  ).toString("base64");
+  return {
+    signature,
+    timeStamp
+  };
+}
+function decodeJwt(jwt) {
+  const [header, payload, signature] = jwt.split(".");
+  return {
+    header: JSON.parse(Buffer.from(header, "base64").toString("utf-8")),
+    payload: JSON.parse(Buffer.from(payload, "base64").toString("utf-8")),
+    signature
+  };
+}
+
+// src/cognito-client.ts
+var CognitoServiceTarget = /* @__PURE__ */ ((CognitoServiceTarget2) => {
+  CognitoServiceTarget2["InitiateAuth"] = "InitiateAuth";
+  CognitoServiceTarget2["RespondToAuthChallenge"] = "RespondToAuthChallenge";
+  CognitoServiceTarget2["SignUp"] = "SignUp";
+  CognitoServiceTarget2["ConfirmSignUp"] = "ConfirmSignUp";
+  CognitoServiceTarget2["ChangePassword"] = "ChangePassword";
+  CognitoServiceTarget2["RevokeToken"] = "RevokeToken";
+  CognitoServiceTarget2["ForgotPassword"] = "ForgotPassword";
+  CognitoServiceTarget2["ConfirmForgotPassword"] = "ConfirmForgotPassword";
+  CognitoServiceTarget2["ResendConfirmationCode"] = "ResendConfirmationCode";
+  CognitoServiceTarget2["UpdateUserAttributes"] = "UpdateUserAttributes";
+  CognitoServiceTarget2["VerifyUserAttribute"] = "VerifyUserAttribute";
+  return CognitoServiceTarget2;
+})(CognitoServiceTarget || {});
+var CognitoIdentityProvider = /* @__PURE__ */ ((CognitoIdentityProvider2) => {
+  CognitoIdentityProvider2["Cognito"] = "COGNITO";
+  CognitoIdentityProvider2["Google"] = "Google";
+  CognitoIdentityProvider2["Facebook"] = "Facebook";
+  CognitoIdentityProvider2["Amazon"] = "LoginWithAmazon";
+  CognitoIdentityProvider2["Apple"] = "SignInWithApple";
+  return CognitoIdentityProvider2;
+})(CognitoIdentityProvider || {});
+var CognitoClient = class {
+  constructor({ userPoolId, userPoolClientId, endpoint, sessionStorage, oAuth2: oAuth }) {
+    const [cognitoPoolRegion, cognitoPoolName] = userPoolId.split("_");
+    this.cognitoEndpoint = (endpoint || `https://cognito-idp.${cognitoPoolRegion}.amazonaws.com`).replace(/\/$/, "");
+    this.cognitoPoolName = cognitoPoolName;
+    this.userPoolClientId = userPoolClientId;
+    this.sessionStorage = sessionStorage;
+    this.oAuth = oAuth;
+  }
+  static getDecodedTokenFromSession(session) {
+    const { payload: idToken } = decodeJwt(session.idToken);
+    const { payload: accessToken } = decodeJwt(session.accessToken);
+    return {
+      idToken,
+      accessToken
+    };
+  }
+  async cognitoRequest(body, serviceTarget) {
+    const respondToAuthChallenge = await fetch(this.cognitoEndpoint, {
+      headers: {
+        "x-amz-target": `AWSCognitoIdentityProviderService.${serviceTarget}`,
+        "content-type": "application/x-amz-json-1.1"
+      },
+      method: "POST",
+      body: JSON.stringify(body)
+    });
+    if (respondToAuthChallenge.status < 200 || respondToAuthChallenge.status > 299) {
+      const errorMessage = await respondToAuthChallenge.json();
+      throw getAuthError(errorMessage);
+    }
+    return respondToAuthChallenge.json();
+  }
+  static authResultToSession(authenticationResult) {
+    return {
+      accessToken: authenticationResult.AccessToken,
+      idToken: authenticationResult.IdToken,
+      expiresIn: addSeconds(/* @__PURE__ */ new Date(), authenticationResult.ExpiresIn).getTime(),
+      refreshToken: authenticationResult.RefreshToken
+    };
+  }
+  /**
+   *
+   * Performs user authentication with username and password through ALLOW_USER_SRP_AUTH .
+   * @see https://docs.aws.amazon.com/cognito/latest/developerguide/amazon-cognito-user-pools-authentication-flow.html for more details
+   *
+   * @param username Username
+   * @param password Password
+   * @throws {AuthException}
+   */
+  async authenticateUserSrp(username, password) {
+    const smallA = generateSmallA();
+    const A = generateA(smallA);
+    const initiateAuthPayload = {
+      AuthFlow: "USER_SRP_AUTH",
+      ClientId: this.userPoolClientId,
+      AuthParameters: {
+        USERNAME: username,
+        SRP_A: A.toString(16)
+      },
+      ClientMetadata: {}
+    };
+    const challenge = await this.cognitoRequest(
+      initiateAuthPayload,
+      "InitiateAuth" /* InitiateAuth */
+    );
+    const B = new import_jsbn2.BigInteger(challenge.ChallengeParameters.SRP_B, 16);
+    const salt = new import_jsbn2.BigInteger(challenge.ChallengeParameters.SALT, 16);
+    const U = calculateU(A, B);
+    const hkdf = getPasswordAuthenticationKey(
+      this.cognitoPoolName,
+      challenge.ChallengeParameters.USER_ID_FOR_SRP,
+      password,
+      B,
+      U,
+      smallA,
+      salt
+    );
+    const { signature, timeStamp } = calculateSignature(
+      this.cognitoPoolName,
+      challenge.ChallengeParameters.USER_ID_FOR_SRP,
+      challenge.ChallengeParameters.SECRET_BLOCK,
+      hkdf
+    );
+    const respondToAuthChallengePayload = {
+      ChallengeName: "PASSWORD_VERIFIER",
+      ClientId: this.userPoolClientId,
+      ChallengeResponses: {
+        PASSWORD_CLAIM_SECRET_BLOCK: challenge.ChallengeParameters.SECRET_BLOCK,
+        PASSWORD_CLAIM_SIGNATURE: signature,
+        USERNAME: challenge.ChallengeParameters.USER_ID_FOR_SRP,
+        TIMESTAMP: timeStamp
+      },
+      ClientMetadata: {}
+    };
+    const { AuthenticationResult } = await this.cognitoRequest(
+      respondToAuthChallengePayload,
+      "RespondToAuthChallenge" /* RespondToAuthChallenge */
+    );
+    const session = CognitoClient.authResultToSession(AuthenticationResult);
+    this.sessionStorage.setSession(session);
+    return session;
+  }
+  /**
+   *
+   * Performs user authentication with username and password through USER_PASSWORD_AUTH .
+   * @see https://docs.aws.amazon.com/cognito/latest/developerguide/amazon-cognito-user-pools-authentication-flow.html for more details
+   *
+   * @param username Username
+   * @param password Password
+   * @throws {AuthException}
+   */
+  async authenticateUser(username, password) {
+    const initiateAuthPayload = {
+      AuthFlow: "USER_PASSWORD_AUTH",
+      ClientId: this.userPoolClientId,
+      AuthParameters: {
+        USERNAME: username,
+        PASSWORD: password
+      },
+      ClientMetadata: {}
+    };
+    const { AuthenticationResult } = await this.cognitoRequest(
+      initiateAuthPayload,
+      "InitiateAuth" /* InitiateAuth */
+    );
+    const session = CognitoClient.authResultToSession(AuthenticationResult);
+    this.sessionStorage.setSession(session);
+    return session;
+  }
+  async refreshSession(session) {
+    const refreshTokenPayload = {
+      AuthFlow: "REFRESH_TOKEN_AUTH",
+      ClientId: this.userPoolClientId,
+      AuthParameters: {
+        REFRESH_TOKEN: session.refreshToken
+      },
+      ClientMetadata: {}
+    };
+    const { AuthenticationResult } = await this.cognitoRequest(
+      refreshTokenPayload,
+      "InitiateAuth" /* InitiateAuth */
+    );
+    const newSession = CognitoClient.authResultToSession({
+      ...AuthenticationResult,
+      RefreshToken: session.refreshToken
+    });
+    this.sessionStorage.setSession(newSession);
+    return newSession;
+  }
+  /**
+   * Returns the current auth session.
+   * The auth session is only defined when we previously had a successful user authentication.
+   * This function will also take care to refresh the session with the refresh token in case
+   * the current session has expired.
+   *
+   * @throws {AuthException}
+   */
+  async getSession() {
+    const session = this.sessionStorage.getSession();
+    if (session) {
+      if ((/* @__PURE__ */ new Date()).getTime() >= session.expiresIn) {
+        return this.refreshSession(session);
+      }
+    }
+    return session;
+  }
+  /**
+   *
+   * @param username Username
+   * @param password Password
+   *
+   * @throws {AuthException}
+   */
+  async signUp(username, password, userAttributes) {
+    const signUpPayload = {
+      ClientId: this.userPoolClientId,
+      Username: username,
+      Password: password,
+      UserAttributes: userAttributes
+    };
+    const data = await this.cognitoRequest(signUpPayload, "SignUp" /* SignUp */);
+    return {
+      id: data.UserSub,
+      confirmed: data.UserConfirmed
+    };
+  }
+  /**
+   * Confirms the user registration via verification code.
+   *
+   * @param username Username
+   * @param code Confirmation code the user gets through the registration E-Mail
+   *
+   * @throws {AuthException}
+   */
+  async confirmSignUp(username, code) {
+    const confirmSignUpPayload = {
+      ClientId: this.userPoolClientId,
+      ConfirmationCode: code,
+      Username: username
+    };
+    const result = await this.cognitoRequest(confirmSignUpPayload, "ConfirmSignUp" /* ConfirmSignUp */);
+  }
+  /**
+   *
+   * @param currentPassword Current user password.
+   * @param newPassword  New user password.
+   *
+   * @throws {AuthException}
+   */
+  async changePassword(currentPassword, newPassword) {
+    const session = await this.getSession();
+    if (session === void 0) {
+      throw new AuthException("User must be authenticated", "user_not_authenticated" /* UserNotAuthenticated */);
+    }
+    const changePasswordPayload = {
+      PreviousPassword: currentPassword,
+      ProposedPassword: newPassword,
+      AccessToken: session.accessToken
+    };
+    const result = await this.cognitoRequest(changePasswordPayload, "ChangePassword" /* ChangePassword */);
+  }
+  async updateUserAttributes(userAttributes) {
+    const session = await this.getSession();
+    if (session === void 0) {
+      throw new AuthException("User must be authenticated", "user_not_authenticated" /* UserNotAuthenticated */);
+    }
+    const updateUserAttributesPayload = {
+      UserAttributes: userAttributes,
+      AccessToken: session.accessToken
+    };
+    const result = await this.cognitoRequest(updateUserAttributesPayload, "UpdateUserAttributes" /* UpdateUserAttributes */);
+  }
+  async verifyUserAttribute(attributeName, code) {
+    const session = await this.getSession();
+    if (session === void 0) {
+      throw new AuthException("User must be authenticated", "user_not_authenticated" /* UserNotAuthenticated */);
+    }
+    const verifyUserAttributePayload = {
+      AttributeName: attributeName,
+      Code: code,
+      AccessToken: session.accessToken
+    };
+    const result = await this.cognitoRequest(verifyUserAttributePayload, "VerifyUserAttribute" /* VerifyUserAttribute */);
+  }
+  /**
+   * Sign out the user and remove the current user session.
+   *
+   * @throws {AuthException}
+   */
+  async signOut() {
+    const session = await this.getSession();
+    if (session === void 0) {
+      throw new AuthException("User must be authenticated", "user_not_authenticated" /* UserNotAuthenticated */);
+    }
+    const revokeTokenPayload = {
+      Token: session.refreshToken,
+      ClientId: this.userPoolClientId
+    };
+    this.sessionStorage.setSession(void 0);
+    await this.cognitoRequest(revokeTokenPayload, "RevokeToken" /* RevokeToken */);
+  }
+  /**
+   * Request forgot password.
+   * @param username Username
+   *
+   * @throws {AuthException}
+   */
+  async forgotPassword(username) {
+    const forgotPasswordPayload = {
+      ClientId: this.userPoolClientId,
+      Username: username
+    };
+    await this.cognitoRequest(forgotPasswordPayload, "ForgotPassword" /* ForgotPassword */);
+  }
+  /**
+   * Confirms the new password via the given code send via cognito triggered by @see forgotPassword .
+   *
+   * @param username Username
+   * @param newPassword New password
+   * @param confirmationCode Confirmation code which the user got through E-mail
+   *
+   * @throws {AuthException}
+   */
+  async confirmForgotPassword(username, newPassword, confirmationCode) {
+    const confirmForgotPasswordPayload = {
+      ClientId: this.userPoolClientId,
+      Username: username,
+      ConfirmationCode: confirmationCode,
+      Password: newPassword
+    };
+    await this.cognitoRequest(confirmForgotPasswordPayload, "ConfirmForgotPassword" /* ConfirmForgotPassword */);
+  }
+  /**
+   * Triggers cognito to resend the confirmation code
+   * @param username Username
+   */
+  async resendConfirmationCode(username) {
+    const resendConfirmationCodePayLoad = {
+      ClientId: this.userPoolClientId,
+      Username: username
+    };
+    await this.cognitoRequest(resendConfirmationCodePayLoad, "ResendConfirmationCode" /* ResendConfirmationCode */);
+  }
+  /**
+   * Returns a link to Cognito`s Hosted UI for OAuth2 authentication.
+   * This method works in conjunction with @see handleCodeFlow .
+   *
+   * @param identityProvider When provided, this will generate a link which
+   * tells Cognito`s Hosted UI to redirect to the given federated identity provider.
+   *
+   * @throws {Error}
+   */
+  generateOAuthSignInUrl(identityProvider) {
+    if (this.oAuth === void 0) {
+      throw Error("You have to define oAuth options to use generateFederatedSignUrl");
+    }
+    const state = (0, import_randombytes2.default)(32).toString("hex");
+    const pkce = (0, import_randombytes2.default)(128).toString("hex");
+    const code_challenge = Buffer.from((0, import_hash2.sha256)().update(pkce).digest()).toString("base64").replace(/\+/g, "-").replace(/\//g, "_").replace(/=+$/, "");
+    const queryParams = new URLSearchParams();
+    queryParams.append("redirect_uri", this.oAuth.redirectUrl);
+    queryParams.append("response_type", this.oAuth.responseType);
+    queryParams.append("client_id", this.userPoolClientId);
+    identityProvider && queryParams.append("identity_provider", identityProvider);
+    queryParams.append("scope", this.oAuth.scopes.join(" "));
+    queryParams.append("state", state);
+    queryParams.append("code_challenge", code_challenge);
+    queryParams.append("code_challenge_method", "S256");
+    this.sessionStorage.setOauthVerificationParams({
+      state,
+      pkce
+    });
+    return `${this.oAuth.cognitoDomain}/oauth2/authorize?${queryParams.toString()}`;
+  }
+  /**
+   *
+   * Handles Cognito`s OAuth2 code flow after redirection from Cognito`s Hosted UI.
+   * The method call assumes that @see generateOAuthSignInUrl was used to
+   * generated the link to the Hosted UI.
+   *
+   * @param returnUrl The full return URL from redirection after a successful OAuth2
+   * authentication.
+   *
+   * @throws {Error}
+   */
+  async handleCodeFlow(returnUrl) {
+    if (this.oAuth === void 0) {
+      throw Error("You have to define oAuth options to use handleCodeFlow");
+    }
+    const url = new URL(returnUrl);
+    const code = url.searchParams.get("code");
+    const state = url.searchParams.get("state");
+    if (code === null || state === null) {
+      throw Error("code or state parameter is missing from return url.");
+    }
+    const oAuthVerificationParams = this.sessionStorage.getOauthVerificationParams();
+    if (oAuthVerificationParams === void 0) {
+      throw new Error("OAuth verification parameters are missing, did you forgot to call generateOAuthSignInUrl ?");
+    }
+    if (oAuthVerificationParams.state !== state) {
+      throw new Error(
+        "state parameter does not match with previous value generated by previous call of generateOAuthSignInUrl ."
+      );
+    }
+    const urlParams = new URLSearchParams();
+    urlParams.append("grant_type", "authorization_code");
+    urlParams.append("code", code);
+    urlParams.append("client_id", this.userPoolClientId);
+    urlParams.append("redirect_uri", this.oAuth.redirectUrl);
+    urlParams.append("code_verifier", oAuthVerificationParams.pkce);
+    const tokenEndpoint = `${this.oAuth.cognitoDomain}/oauth2/token`;
+    const response = await fetch(tokenEndpoint, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/x-www-form-urlencoded"
+      },
+      body: urlParams.toString()
+    });
+    const { access_token, refresh_token, id_token, expires_in, token_type, error } = await response.json();
+    if (error) {
+      throw new Error(error);
+    }
+    const session = CognitoClient.authResultToSession({
+      AccessToken: access_token,
+      RefreshToken: refresh_token,
+      IdToken: id_token,
+      ExpiresIn: expires_in,
+      TokenType: token_type
+    });
+    this.sessionStorage.setSession(session);
+    return session;
+  }
+};
+
+// src/session-storage/cookie-session-storage/cookie-session-storage.ts
+import { Cookies } from "@vardario/cookies";
+
+// src/session-storage/session-storage.ts
+var SessionStorage = class {
+};
+
+// src/session-storage/cookie-session-storage/cookie-session-storage.ts
+var CookieSessionStorage = class extends SessionStorage {
+  constructor(props) {
+    super();
+    this.props = {
+      domain: props.domain,
+      path: props.path ?? "/",
+      expires: props.expires ?? 365,
+      secure: props.secure ?? true,
+      sameSite: props.sameSite ?? "None",
+      cookieName: props.cookieName
+    };
+    this.cookies = new Cookies(this.props);
+    this.sessionCookieName = `${props.cookieName}`;
+    this.oAuthParamCookieName = `${props.cookieName}_oauth`;
+  }
+  getSession() {
+    const session = this.cookies.getCookie(this.sessionCookieName);
+    if (session === void 0) {
+      return void 0;
+    }
+    return JSON.parse(session);
+  }
+  setSession(session) {
+    this.cookies.setCookie(this.sessionCookieName, JSON.stringify(session));
+  }
+  getOauthVerificationParams() {
+    const oAuthParams = this.cookies.getCookie(this.oAuthParamCookieName);
+    if (oAuthParams === void 0) {
+      return void 0;
+    }
+    return JSON.parse(oAuthParams);
+  }
+  setOauthVerificationParams(oAuthParams) {
+    this.cookies.setCookie(this.oAuthParamCookieName, JSON.stringify(oAuthParams));
+  }
+};
+
+// src/session-storage/local-storage-session-storage.ts
+var LocalStorageSessionStorage = class extends SessionStorage {
+  constructor(props) {
+    super();
+    this.props = props;
+  }
+  getSession() {
+    const payload = window.localStorage.getItem(this.props.storageName);
+    if (payload === null) {
+      return void 0;
+    }
+    return JSON.parse(payload);
+  }
+  setSession(session) {
+    if (session === void 0) {
+      window.localStorage.removeItem(this.props.storageName);
+      return;
+    }
+    window.localStorage.setItem(this.props.storageName, JSON.stringify(session));
+  }
+  setOauthVerificationParams(oAuthParams) {
+    window.localStorage.setItem(`${this.props.storageName}_oauth`, JSON.stringify(oAuthParams));
+  }
+  getOauthVerificationParams() {
+    const payload = window.localStorage.getItem(`${this.props.storageName}_oauth`);
+    if (payload === null) {
+      return void 0;
+    }
+    return JSON.parse(payload);
+  }
+};
+
+// src/session-storage/memory-session-storage.ts
+var MemorySessionStorage = class extends SessionStorage {
+  getSession() {
+    return this.session;
+  }
+  setSession(session) {
+    this.session = session;
+  }
+  getOauthVerificationParams() {
+    return this.oAuthVerificationParams;
+  }
+  setOauthVerificationParams(oAuthParams) {
+    this.oAuthVerificationParams = oAuthParams;
+  }
+};
+export {
+  AuthError,
+  AuthException,
+  CognitoClient,
+  CognitoIdentityProvider,
+  CognitoServiceTarget,
+  CookieSessionStorage,
+  ErrorCode,
+  LocalStorageSessionStorage,
+  MemorySessionStorage,
+  SessionStorage,
+  getAuthError
+};