worker.js

/*
hey, devnull here, just go down to the couple last lines of the file.
plus I do not recommend editing this file in vscode as parsing this
still semi obfuscated piece of code is going to take a lot of time,
also yeah there is a license for the original version of this code
that was left by it's original creator (not null)
*/
/*! For license information please see worker.js.LICENSE.txt */
var t = {
    452: function (t, e, r) {
      var i;
      t.exports =
        ((i = r(249)),
        r(269),
        r(214),
        r(888),
        r(109),
        (function () {
          var t = i,
            e = t.lib.BlockCipher,
            r = t.algo,
            n = [],
            o = [],
            s = [],
            a = [],
            c = [],
            h = [],
            f = [],
            l = [],
            u = [],
            d = [];
          !(function () {
            for (var t = [], e = 0; e < 256; e++)
              t[e] = e < 128 ? e << 1 : (e << 1) ^ 283;
            var r = 0,
              i = 0;
            for (e = 0; e < 256; e++) {
              var p = i ^ (i << 1) ^ (i << 2) ^ (i << 3) ^ (i << 4);
              (p = (p >>> 8) ^ (255 & p) ^ 99), (n[r] = p), (o[p] = r);
              var v = t[r],
                _ = t[v],
                y = t[_],
                g = (257 * t[p]) ^ (16843008 * p);
              (s[r] = (g << 24) | (g >>> 8)),
                (a[r] = (g << 16) | (g >>> 16)),
                (c[r] = (g << 8) | (g >>> 24)),
                (h[r] = g),
                (g =
                  (16843009 * y) ^ (65537 * _) ^ (257 * v) ^ (16843008 * r)),
                (f[p] = (g << 24) | (g >>> 8)),
                (l[p] = (g << 16) | (g >>> 16)),
                (u[p] = (g << 8) | (g >>> 24)),
                (d[p] = g),
                r ? ((r = v ^ t[t[t[y ^ v]]]), (i ^= t[t[i]])) : (r = i = 1);
            }
          })();
          var p = [0, 1, 2, 4, 8, 16, 32, 64, 128, 27, 54],
            v = (r.AES = e.extend({
              _doReset: function () {
                if (!this._nRounds || this._keyPriorReset !== this._key) {
                  for (
                    var t = (this._keyPriorReset = this._key),
                      e = t.words,
                      r = t.sigBytes / 4,
                      i = 4 * ((this._nRounds = r + 6) + 1),
                      o = (this._keySchedule = []),
                      s = 0;
                    s < i;
                    s++
                  )
                    s < r
                      ? (o[s] = e[s])
                      : ((h = o[s - 1]),
                        s % r
                          ? r > 6 &&
                            s % r == 4 &&
                            (h =
                              (n[h >>> 24] << 24) |
                              (n[(h >>> 16) & 255] << 16) |
                              (n[(h >>> 8) & 255] << 8) |
                              n[255 & h])
                          : ((h =
                              (n[(h = (h << 8) | (h >>> 24)) >>> 24] << 24) |
                              (n[(h >>> 16) & 255] << 16) |
                              (n[(h >>> 8) & 255] << 8) |
                              n[255 & h]),
                            (h ^= p[(s / r) | 0] << 24)),
                        (o[s] = o[s - r] ^ h));
                  for (
                    var a = (this._invKeySchedule = []), c = 0;
                    c < i;
                    c++
                  ) {
                    if (((s = i - c), c % 4)) var h = o[s];
                    else h = o[s - 4];
                    a[c] =
                      c < 4 || s <= 4
                        ? h
                        : f[n[h >>> 24]] ^ l[n[(h >>> 16) & 255]] ^ u[n[(h >>> 8) & 255]] ^ d[n[255 & h]];
                  }
                }
              },
              encryptBlock: function (t, e) {
                this._doCryptBlock(t, e, this._keySchedule, s, a, c, h, n);
              },
              decryptBlock: function (t, e) {
                var r = t[e + 1];
                (t[e + 1] = t[e + 3]),
                  (t[e + 3] = r),
                  this._doCryptBlock(
                    t,
                    e,
                    this._invKeySchedule,
                    f,
                    l,
                    u,
                    d,
                    o
                  ),
                  (r = t[e + 1]),
                  (t[e + 1] = t[e + 3]),
                  (t[e + 3] = r);
              },
              _doCryptBlock: function (t, e, r, i, n, o, s, a) {
                for (
                  var c = this._nRounds,
                    h = t[e] ^ r[0],
                    f = t[e + 1] ^ r[1],
                    l = t[e + 2] ^ r[2],
                    u = t[e + 3] ^ r[3],
                    d = 4,
                    p = 1;
                  p < c;
                  p++
                ) {
                  var v =
                      i[h >>> 24] ^
                      n[(f >>> 16) & 255] ^
                      o[(l >>> 8) & 255] ^
                      s[255 & u] ^
                      r[d++],
                    _ =
                      i[f >>> 24] ^
                      n[(l >>> 16) & 255] ^
                      o[(u >>> 8) & 255] ^
                      s[255 & h] ^
                      r[d++],
                    y =
                      i[l >>> 24] ^
                      n[(u >>> 16) & 255] ^
                      o[(h >>> 8) & 255] ^
                      s[255 & f] ^
                      r[d++],
                    g =
                      i[u >>> 24] ^
                      n[(h >>> 16) & 255] ^
                      o[(f >>> 8) & 255] ^
                      s[255 & l] ^
                      r[d++];
                  (h = v), (f = _), (l = y), (u = g);
                }
                (v =
                  ((a[h >>> 24] << 24) |
                    (a[(f >>> 16) & 255] << 16) |
                    (a[(l >>> 8) & 255] << 8) |
                    a[255 & u]) ^
                  r[d++]),
                  (_ =
                    ((a[f >>> 24] << 24) |
                      (a[(l >>> 16) & 255] << 16) |
                      (a[(u >>> 8) & 255] << 8) |
                      a[255 & h]) ^
                    r[d++]),
                  (y =
                    ((a[l >>> 24] << 24) |
                      (a[(u >>> 16) & 255] << 16) |
                      (a[(h >>> 8) & 255] << 8) |
                      a[255 & f]) ^
                    r[d++]),
                  (g =
                    ((a[u >>> 24] << 24) |
                      (a[(h >>> 16) & 255] << 16) |
                      (a[(f >>> 8) & 255] << 8) |
                      a[255 & l]) ^
                    r[d++]),
                  (t[e] = v),
                  (t[e + 1] = _),
                  (t[e + 2] = y),
                  (t[e + 3] = g);
              },
              keySize: 8,
            }));
          t.AES = e._createHelper(v);
        })(),
        i.AES);
    },
    109: function (t, e, r) {
      var i, n, o, s, a, c, h, f, l, u, d, p, v, _, y, g, B, w, k;
      t.exports =
        ((i = r(249)),
        r(888),
        void (
          i.lib.Cipher ||
          ((n = i),
          (o = n.lib),
          (s = o.Base),
          (a = o.WordArray),
          (c = o.BufferedBlockAlgorithm),
          (h = n.enc),
          h.Utf8,
          (f = h.Base64),
          (l = n.algo.EvpKDF),
          (u = o.Cipher =
            c.extend({
              cfg: s.extend(),
              createEncryptor: function (t, e) {
                return this.create(this._ENC_XFORM_MODE, t, e);
              },
              createDecryptor: function (t, e) {
                return this.create(this._DEC_XFORM_MODE, t, e);
              },
              init: function (t, e, r) {
                (this.cfg = this.cfg.extend(r)),
                  (this._xformMode = t),
                  (this._key = e),
                  this.reset();
              },
              reset: function () {
                c.reset.call(this), this._doReset();
              },
              process: function (t) {
                return this._append(t), this._process();
              },
              finalize: function (t) {
                return t && this._append(t), this._doFinalize();
              },
              keySize: 4,
              ivSize: 4,
              _ENC_XFORM_MODE: 1,
              _DEC_XFORM_MODE: 2,
              _createHelper: (function () {
                function t(t) {
                  return "string" == typeof t ? k : B;
                }
                return function (e) {
                  return {
                    encrypt: function (r, i, n) {
                      return t(i).encrypt(e, r, i, n);
                    },
                    decrypt: function (r, i, n) {
                      return t(i).decrypt(e, r, i, n);
                    },
                  };
                };
              })(),
            })),
          (o.StreamCipher = u.extend({
            _doFinalize: function () {
              return this._process(!0);
            },
            blockSize: 1,
          })),
          (d = n.mode = {}),
          (p = o.BlockCipherMode =
            s.extend({
              createEncryptor: function (t, e) {
                return this.Encryptor.create(t, e);
              },
              createDecryptor: function (t, e) {
                return this.Decryptor.create(t, e);
              },
              init: function (t, e) {
                (this._cipher = t), (this._iv = e);
              },
            })),
          (v = d.CBC =
            (function () {
              var t = p.extend();
              function e(t, e, r) {
                var i,
                  n = this._iv;
                n ? ((i = n), (this._iv = void 0)) : (i = this._prevBlock);
                for (var o = 0; o < r; o++) t[e + o] ^= i[o];
              }
              return (
                (t.Encryptor = t.extend({
                  processBlock: function (t, r) {
                    var i = this._cipher,
                      n = i.blockSize;
                    e.call(this, t, r, n),
                      i.encryptBlock(t, r),
                      (this._prevBlock = t.slice(r, r + n));
                  },
                })),
                (t.Decryptor = t.extend({
                  processBlock: function (t, r) {
                    var i = this._cipher,
                      n = i.blockSize,
                      o = t.slice(r, r + n);
                    i.decryptBlock(t, r),
                      e.call(this, t, r, n),
                      (this._prevBlock = o);
                  },
                })),
                t
              );
            })()),
          (_ = (n.pad = {}).Pkcs7 =
            {
              pad: function (t, e) {
                for (
                  var r = 4 * e,
                    i = r - (t.sigBytes % r),
                    n = (i << 24) | (i << 16) | (i << 8) | i,
                    o = [],
                    s = 0;
                  s < i;
                  s += 4
                )
                  o.push(n);
                var c = a.create(o, i);
                t.concat(c);
              },
              unpad: function (t) {
                var e = 255 & t.words[(t.sigBytes - 1) >>> 2];
                t.sigBytes -= e;
              },
            }),
          (o.BlockCipher = u.extend({
            cfg: u.cfg.extend({ mode: v, padding: _ }),
            reset: function () {
              var t;
              u.reset.call(this);
              var e = this.cfg,
                r = e.iv,
                i = e.mode;
              this._xformMode == this._ENC_XFORM_MODE
                ? (t = i.createEncryptor)
                : ((t = i.createDecryptor), (this._minBufferSize = 1)),
                this._mode && this._mode.__creator == t
                  ? this._mode.init(this, r && r.words)
                  : ((this._mode = t.call(i, this, r && r.words)),
                    (this._mode.__creator = t));
            },
            _doProcessBlock: function (t, e) {
              this._mode.processBlock(t, e);
            },
            _doFinalize: function () {
              var t,
                e = this.cfg.padding;
              return (
                this._xformMode == this._ENC_XFORM_MODE
                  ? (e.pad(this._data, this.blockSize),
                    (t = this._process(!0)))
                  : ((t = this._process(!0)), e.unpad(t)),
                t
              );
            },
            blockSize: 4,
          })),
          (y = o.CipherParams =
            s.extend({
              init: function (t) {
                this.mixIn(t);
              },
              toString: function (t) {
                return (t || this.formatter).stringify(this);
              },
            })),
          (g = (n.format = {}).OpenSSL =
            {
              stringify: function (t) {
                var e = t.ciphertext,
                  r = t.salt;
                return (
                  r
                    ? a.create([1398893684, 1701076831]).concat(r).concat(e)
                    : e
                ).toString(f);
              },
              parse: function (t) {
                var e,
                  r = f.parse(t),
                  i = r.words;
                return (
                  1398893684 == i[0] &&
                    1701076831 == i[1] &&
                    ((e = a.create(i.slice(2, 4))),
                    i.splice(0, 4),
                    (r.sigBytes -= 16)),
                  y.create({ ciphertext: r, salt: e })
                );
              },
            }),
          (B = o.SerializableCipher =
            s.extend({
              cfg: s.extend({ format: g }),
              encrypt: function (t, e, r, i) {
                i = this.cfg.extend(i);
                var n = t.createEncryptor(r, i),
                  o = n.finalize(e),
                  s = n.cfg;
                return y.create({
                  ciphertext: o,
                  key: r,
                  iv: s.iv,
                  algorithm: t,
                  mode: s.mode,
                  padding: s.padding,
                  blockSize: t.blockSize,
                  formatter: i.format,
                });
              },
              decrypt: function (t, e, r, i) {
                return (
                  (i = this.cfg.extend(i)),
                  (e = this._parse(e, i.format)),
                  t.createDecryptor(r, i).finalize(e.ciphertext)
                );
              },
              _parse: function (t, e) {
                return "string" == typeof t ? e.parse(t, this) : t;
              },
            })),
          (w = (n.kdf = {}).OpenSSL =
            {
              execute: function (t, e, r, i) {
                i || (i = a.random(8));
                var n = l.create({ keySize: e + r }).compute(t, i),
                  o = a.create(n.words.slice(e), 4 * r);
                return (
                  (n.sigBytes = 4 * e), y.create({ key: n, iv: o, salt: i })
                );
              },
            }),
          (k = o.PasswordBasedCipher =
            B.extend({
              cfg: B.cfg.extend({ kdf: w }),
              encrypt: function (t, e, r, i) {
                var n = (i = this.cfg.extend(i)).kdf.execute(
                  r,
                  t.keySize,
                  t.ivSize
                );
                i.iv = n.iv;
                var o = B.encrypt.call(this, t, e, n.key, i);
                return o.mixIn(n), o;
              },
              decrypt: function (t, e, r, i) {
                (i = this.cfg.extend(i)), (e = this._parse(e, i.format));
                var n = i.kdf.execute(r, t.keySize, t.ivSize, e.salt);
                return (i.iv = n.iv), B.decrypt.call(this, t, e, n.key, i);
              },
            })))
        ));
    },
    249: function (t, e, r) {
      var i;
      t.exports =
        ((i =
          i ||
          (function (t, e) {
            var i;
            if (
              ("undefined" != typeof window &&
                window.crypto &&
                (i = window.crypto),
              "undefined" != typeof self && self.crypto && (i = self.crypto),
              "undefined" != typeof globalThis &&
                globalThis.crypto &&
                (i = globalThis.crypto),
              !i &&
                "undefined" != typeof window &&
                window.msCrypto &&
                (i = window.msCrypto),
              !i && void 0 !== r.g && r.g.crypto && (i = r.g.crypto),
              !i)
            )
              try {
                i = r(480);
              } catch (t) {}
            var n = function () {
                if (i) {
                  if ("function" == typeof i.getRandomValues)
                    try {
                      return i.getRandomValues(new Uint32Array(1))[0];
                    } catch (t) {}
                  if ("function" == typeof i.randomBytes)
                    try {
                      return i.randomBytes(4).readInt32LE();
                    } catch (t) {}
                }
                throw new Error(
                  "Native crypto module could not be used to get secure random number."
                );
              },
              o =
                Object.create ||
                (function () {
                  function t() {}
                  return function (e) {
                    var r;
                    return (
                      (t.prototype = e),
                      (r = new t()),
                      (t.prototype = null),
                      r
                    );
                  };
                })(),
              s = {},
              a = (s.lib = {}),
              c = (a.Base = {
                extend: function (t) {
                  var e = o(this);
                  return (
                    t && e.mixIn(t),
                    (e.hasOwnProperty("init") && this.init !== e.init) ||
                      (e.init = function () {
                        e.$super.init.apply(this, arguments);
                      }),
                    (e.init.prototype = e),
                    (e.$super = this),
                    e
                  );
                },
                create: function () {
                  var t = this.extend();
                  return t.init.apply(t, arguments), t;
                },
                init: function () {},
                mixIn: function (t) {
                  for (var e in t) t.hasOwnProperty(e) && (this[e] = t[e]);
                  t.hasOwnProperty("toString") &&
                    (this.toString = t.toString);
                },
                clone: function () {
                  return this.init.prototype.extend(this);
                },
              }),
              h = (a.WordArray = c.extend({
                init: function (t, e) {
                  (t = this.words = t || []),
                    (this.sigBytes = null != e ? e : 4 * t.length);
                },
                toString: function (t) {
                  return (t || l).stringify(this);
                },
                concat: function (t) {
                  var e = this.words,
                    r = t.words,
                    i = this.sigBytes,
                    n = t.sigBytes;
                  if ((this.clamp(), i % 4))
                    for (var o = 0; o < n; o++) {
                      var s = (r[o >>> 2] >>> (24 - (o % 4) * 8)) & 255;
                      e[(i + o) >>> 2] |= s << (24 - ((i + o) % 4) * 8);
                    }
                  else
                    for (var a = 0; a < n; a += 4)
                      e[(i + a) >>> 2] = r[a >>> 2];
                  return (this.sigBytes += n), this;
                },
                clamp: function () {
                  var e = this.words,
                    r = this.sigBytes;
                  (e[r >>> 2] &= 4294967295 << (32 - (r % 4) * 8)),
                    (e.length = t.ceil(r / 4));
                },
                clone: function () {
                  var t = c.clone.call(this);
                  return (t.words = this.words.slice(0)), t;
                },
                random: function (t) {
                  for (var e = [], r = 0; r < t; r += 4) e.push(n());
                  return new h.init(e, t);
                },
              })),
              f = (s.enc = {}),
              l = (f.Hex = {
                stringify: function (t) {
                  for (
                    var e = t.words, r = t.sigBytes, i = [], n = 0;
                    n < r;
                    n++
                  ) {
                    var o = (e[n >>> 2] >>> (24 - (n % 4) * 8)) & 255;
                    i.push((o >>> 4).toString(16)),
                      i.push((15 & o).toString(16));
                  }
                  return i.join("");
                },
                parse: function (t) {
                  for (var e = t.length, r = [], i = 0; i < e; i += 2)
                    r[i >>> 3] |=
                      parseInt(t.substr(i, 2), 16) << (24 - (i % 8) * 4);
                  return new h.init(r, e / 2);
                },
              }),
              u = (f.Latin1 = {
                stringify: function (t) {
                  for (
                    var e = t.words, r = t.sigBytes, i = [], n = 0;
                    n < r;
                    n++
                  ) {
                    var o = (e[n >>> 2] >>> (24 - (n % 4) * 8)) & 255;
                    i.push(String.fromCharCode(o));
                  }
                  return i.join("");
                },
                parse: function (t) {
                  for (var e = t.length, r = [], i = 0; i < e; i++)
                    r[i >>> 2] |=
                      (255 & t.charCodeAt(i)) << (24 - (i % 4) * 8);
                  return new h.init(r, e);
                },
              }),
              d = (f.Utf8 = {
                stringify: function (t) {
                  try {
                    return decodeURIComponent(escape(u.stringify(t)));
                  } catch (t) {
                    throw new Error("Malformed UTF-8 data");
                  }
                },
                parse: function (t) {
                  return u.parse(unescape(encodeURIComponent(t)));
                },
              }),
              p = (a.BufferedBlockAlgorithm = c.extend({
                reset: function () {
                  (this._data = new h.init()), (this._nDataBytes = 0);
                },
                _append: function (t) {
                  "string" == typeof t && (t = d.parse(t)),
                    this._data.concat(t),
                    (this._nDataBytes += t.sigBytes);
                },
                _process: function (e) {
                  var r,
                    i = this._data,
                    n = i.words,
                    o = i.sigBytes,
                    s = this.blockSize,
                    a = o / (4 * s),
                    c =
                      (a = e
                        ? t.ceil(a)
                        : t.max((0 | a) - this._minBufferSize, 0)) * s,
                    f = t.min(4 * c, o);
                  if (c) {
                    for (var l = 0; l < c; l += s) this._doProcessBlock(n, l);
                    (r = n.splice(0, c)), (i.sigBytes -= f);
                  }
                  return new h.init(r, f);
                },
                clone: function () {
                  var t = c.clone.call(this);
                  return (t._data = this._data.clone()), t;
                },
                _minBufferSize: 0,
              })),
              v =
                ((a.Hasher = p.extend({
                  cfg: c.extend(),
                  init: function (t) {
                    (this.cfg = this.cfg.extend(t)), this.reset();
                  },
                  reset: function () {
                    p.reset.call(this), this._doReset();
                  },
                  update: function (t) {
                    return this._append(t), this._process(), this;
                  },
                  finalize: function (t) {
                    return t && this._append(t), this._doFinalize();
                  },
                  blockSize: 16,
                  _createHelper: function (t) {
                    return function (e, r) {
                      return new t.init(r).finalize(e);
                    };
                  },
                  _createHmacHelper: function (t) {
                    return function (e, r) {
                      return new v.HMAC.init(t, r).finalize(e);
                    };
                  },
                })),
                (s.algo = {}));
            return s;
          })(Math)),
        i);
    },
    269: function (t, e, r) {
      var i, n, o;
      t.exports =
        ((i = r(249)),
        (o = (n = i).lib.WordArray),
        (n.enc.Base64 = {
          stringify: function (t) {
            var e = t.words,
              r = t.sigBytes,
              i = this._map;
            t.clamp();
            for (var n = [], o = 0; o < r; o += 3)
              for (
                var s =
                    (((e[o >>> 2] >>> (24 - (o % 4) * 8)) & 255) << 16) |
                    (((e[(o + 1) >>> 2] >>> (24 - ((o + 1) % 4) * 8)) &
                      255) <<
                      8) |
                    ((e[(o + 2) >>> 2] >>> (24 - ((o + 2) % 4) * 8)) & 255),
                  a = 0;
                a < 4 && o + 0.75 * a < r;
                a++
              )
                n.push(i.charAt((s >>> (6 * (3 - a))) & 63));
            var c = i.charAt(64);
            if (c) for (; n.length % 4; ) n.push(c);
            return n.join("");
          },
          parse: function (t) {
            var e = t.length,
              r = this._map,
              i = this._reverseMap;
            if (!i) {
              i = this._reverseMap = [];
              for (var n = 0; n < r.length; n++) i[r.charCodeAt(n)] = n;
            }
            var s = r.charAt(64);
            if (s) {
              var a = t.indexOf(s);
              -1 !== a && (e = a);
            }
            return (function (t, e, r) {
              for (var i = [], n = 0, s = 0; s < e; s++)
                if (s % 4) {
                  var a =
                    (r[t.charCodeAt(s - 1)] << ((s % 4) * 2)) |
                    (r[t.charCodeAt(s)] >>> (6 - (s % 4) * 2));
                  (i[n >>> 2] |= a << (24 - (n % 4) * 8)), n++;
                }
              return o.create(i, n);
            })(t, e, i);
          },
          _map: "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/=",
        }),
        i.enc.Base64);
    },
    786: function (t, e, r) {
      var i, n, o;
      t.exports =
        ((i = r(249)),
        (o = (n = i).lib.WordArray),
        (n.enc.Base64url = {
          stringify: function (t, e = !0) {
            var r = t.words,
              i = t.sigBytes,
              n = e ? this._safe_map : this._map;
            t.clamp();
            for (var o = [], s = 0; s < i; s += 3)
              for (
                var a =
                    (((r[s >>> 2] >>> (24 - (s % 4) * 8)) & 255) << 16) |
                    (((r[(s + 1) >>> 2] >>> (24 - ((s + 1) % 4) * 8)) &
                      255) <<
                      8) |
                    ((r[(s + 2) >>> 2] >>> (24 - ((s + 2) % 4) * 8)) & 255),
                  c = 0;
                c < 4 && s + 0.75 * c < i;
                c++
              )
                o.push(n.charAt((a >>> (6 * (3 - c))) & 63));
            var h = n.charAt(64);
            if (h) for (; o.length % 4; ) o.push(h);
            return o.join("");
          },
          parse: function (t, e = !0) {
            var r = t.length,
              i = e ? this._safe_map : this._map,
              n = this._reverseMap;
            if (!n) {
              n = this._reverseMap = [];
              for (var s = 0; s < i.length; s++) n[i.charCodeAt(s)] = s;
            }
            var a = i.charAt(64);
            if (a) {
              var c = t.indexOf(a);
              -1 !== c && (r = c);
            }
            return (function (t, e, r) {
              for (var i = [], n = 0, s = 0; s < e; s++)
                if (s % 4) {
                  var a =
                    (r[t.charCodeAt(s - 1)] << ((s % 4) * 2)) |
                    (r[t.charCodeAt(s)] >>> (6 - (s % 4) * 2));
                  (i[n >>> 2] |= a << (24 - (n % 4) * 8)), n++;
                }
              return o.create(i, n);
            })(t, r, n);
          },
          _map: "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/=",
          _safe_map:
            "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789-_",
        }),
        i.enc.Base64url);
    },
    298: function (t, e, r) {
      var i;
      t.exports =
        ((i = r(249)),
        (function () {
          var t = i,
            e = t.lib.WordArray,
            r = t.enc;
          function n(t) {
            return ((t << 8) & 4278255360) | ((t >>> 8) & 16711935);
          }
          (r.Utf16 = r.Utf16BE =
            {
              stringify: function (t) {
                for (
                  var e = t.words, r = t.sigBytes, i = [], n = 0;
                  n < r;
                  n += 2
                ) {
                  var o = (e[n >>> 2] >>> (16 - (n % 4) * 8)) & 65535;
                  i.push(String.fromCharCode(o));
                }
                return i.join("");
              },
              parse: function (t) {
                for (var r = t.length, i = [], n = 0; n < r; n++)
                  i[n >>> 1] |= t.charCodeAt(n) << (16 - (n % 2) * 16);
                return e.create(i, 2 * r);
              },
            }),
            (r.Utf16LE = {
              stringify: function (t) {
                for (
                  var e = t.words, r = t.sigBytes, i = [], o = 0;
                  o < r;
                  o += 2
                ) {
                  var s = n((e[o >>> 2] >>> (16 - (o % 4) * 8)) & 65535);
                  i.push(String.fromCharCode(s));
                }
                return i.join("");
              },
              parse: function (t) {
                for (var r = t.length, i = [], o = 0; o < r; o++)
                  i[o >>> 1] |= n(t.charCodeAt(o) << (16 - (o % 2) * 16));
                return e.create(i, 2 * r);
              },
            });
        })(),
        i.enc.Utf16);
    },
    888: function (t, e, r) {
      var i, n, o, s, a, c, h, f;
      t.exports =
        ((f = r(249)),
        r(783),
        r(824),
        (o = (n = (i = f).lib).Base),
        (s = n.WordArray),
        (c = (a = i.algo).MD5),
        (h = a.EvpKDF =
          o.extend({
            cfg: o.extend({ keySize: 4, hasher: c, iterations: 1 }),
            init: function (t) {
              this.cfg = this.cfg.extend(t);
            },
            compute: function (t, e) {
              for (
                var r,
                  i = this.cfg,
                  n = i.hasher.create(),
                  o = s.create(),
                  a = o.words,
                  c = i.keySize,
                  h = i.iterations;
                a.length < c;

              ) {
                r && n.update(r), (r = n.update(t).finalize(e)), n.reset();
                for (var f = 1; f < h; f++) (r = n.finalize(r)), n.reset();
                o.concat(r);
              }
              return (o.sigBytes = 4 * c), o;
            },
          })),
        (i.EvpKDF = function (t, e, r) {
          return h.create(r).compute(t, e);
        }),
        f.EvpKDF);
    },
    209: function (t, e, r) {
      var i, n, o, s;
      t.exports =
        ((s = r(249)),
        r(109),
        (n = (i = s).lib.CipherParams),
        (o = i.enc.Hex),
        (i.format.Hex = {
          stringify: function (t) {
            return t.ciphertext.toString(o);
          },
          parse: function (t) {
            var e = o.parse(t);
            return n.create({ ciphertext: e });
          },
        }),
        s.format.Hex);
    },
    824: function (t, e, r) {
      var i, n, o;
      t.exports =
        ((n = (i = r(249)).lib.Base),
        (o = i.enc.Utf8),
        void (i.algo.HMAC = n.extend({
          init: function (t, e) {
            (t = this._hasher = new t.init()),
              "string" == typeof e && (e = o.parse(e));
            var r = t.blockSize,
              i = 4 * r;
            e.sigBytes > i && (e = t.finalize(e)), e.clamp();
            for (
              var n = (this._oKey = e.clone()),
                s = (this._iKey = e.clone()),
                a = n.words,
                c = s.words,
                h = 0;
              h < r;
              h++
            )
              (a[h] ^= 1549556828), (c[h] ^= 909522486);
            (n.sigBytes = s.sigBytes = i), this.reset();
          },
          reset: function () {
            var t = this._hasher;
            t.reset(), t.update(this._iKey);
          },
          update: function (t) {
            return this._hasher.update(t), this;
          },
          finalize: function (t) {
            var e = this._hasher,
              r = e.finalize(t);
            return e.reset(), e.finalize(this._oKey.clone().concat(r));
          },
        })));
    },
    354: function (t, e, r) {
      var i;
      t.exports =
        ((i = r(249)),
        r(938),
        r(433),
        r(298),
        r(269),
        r(786),
        r(214),
        r(783),
        r(153),
        r(792),
        r(34),
        r(460),
        r(327),
        r(706),
        r(824),
        r(112),
        r(888),
        r(109),
        r(568),
        r(242),
        r(968),
        r(660),
        r(148),
        r(615),
        r(807),
        r(77),
        r(475),
        r(991),
        r(209),
        r(452),
        r(253),
        r(857),
        r(454),
        r(974),
        i);
    },
    433: function (t, e, r) {
      var i;
      t.exports =
        ((i = r(249)),
        (function () {
          if ("function" == typeof ArrayBuffer) {
            var t = i.lib.WordArray,
              e = t.init,
              r = (t.init = function (t) {
                if (
                  (t instanceof ArrayBuffer && (t = new Uint8Array(t)),
                  (t instanceof Int8Array ||
                    ("undefined""Invalid key length - 3DES requires the key length to be 64, 128, 192 or >192."
                );
              var e = t.slice(0, 2),
                i = t.length < 4 ? t.slice(0, 2) : t.slice(2, 4),
                n = t.length < 6 ? t.slice(0, 2) : t.slice(4, 6);
              (this._des1 = l.createEncryptor(r.create(e))),
                (this._des2 = l.createEncryptor(r.create(i))),
                (this._des3 = l.createEncryptor(r.create(n)));
            },
            encryptBlock: function (t, e) {
              this._des1.encryptBlock(t, e),
                this._des2.decryptBlock(t, e),
                this._des3.encryptBlock(t, e);
            },
            decryptBlock: function (t, e) {
              this._des3.decryptBlock(t, e),
                this._des2.encryptBlock(t, e),
                this._des1.decryptBlock(t, e);
            },
            keySize: 6,
            ivSize: 2,
            blockSize: 2,
          }));
          t.TripleDES = n._createHelper(p);
        })(),
        i.TripleDES);
    },
    938: function (t, e, r) {
      var i, n, o, s, a, c;
      t.exports =
        ((i = r(249)),
        (o = (n = i).lib),
        (s = o.Base),
        (a = o.WordArray),
        ((c = n.x64 = {}).Word = s.extend({
          init: function (t, e) {
            (this.high = t), (this.low = e);
          },
        })),
        (c.WordArray = s.extend({
          init: function (t, e) {
            (t = this.words = t || []),
              (this.sigBytes = null != e ? e : 8 * t.length);
          },
          toX32: function () {
            for (
              var t = this.words, e = t.length, r = [], i = 0;
              i < e;
              i++
            ) {
              var n = t[i];
              r.push(n.high), r.push(n.low);
            }
            return a.create(r, this.sigBytes);
          },
          clone: function () {
            for (
              var t = s.clone.call(this),
                e = (t.words = this.words.slice(0)),
                r = e.length,
                i = 0;
              i < r;
              i++
            )
              e[i] = e[i].clone();
            return t;
          },
        })),
        i);
    },
    480: () => {},
  }

var e = {};


function r(i) {
  var n = e[i];
  if (void 0 !== n) return n.exports;
  var o = (e[i] = { exports: {} });
  return t[i].call(o.exports, o, o.exports, r), o.exports;
}

r.n = (t) => {
  var e = t && t.__esModule ? () => t.default : () => t;
  return r.d(e, { a: e }), e;
}

r.d = (t, e) => {
  for (var i in e)
    r.o(e, i) &&
      !r.o(t, i) &&
      Object.defineProperty(t, i, { enumerable: !0, get: e[i] });
}

r.g = (function () {
  if ("object" == typeof globalThis) return globalThis;
  try {
    return this || new Function("return this")();
  } catch (t) {
    if ("object" == typeof window) return window;
  }
})()

r.o = (t, e) => Object.prototype.hasOwnProperty.call(t, e)

"use strict";
var t = r(354);

/*
the code above this comment is still a bit obfuscated but it doesn't matter
because it's just creating the SHA256 function for us
*/

self.onmessage = ({ data: { attempt: attempt, difficulty: difficulty, salt: salt } }) => {
  const n = t.SHA256(`${salt}${attempt}`);

  // below is the check if we got it right
  const o = Math.clz32(n.words[0]) >= difficulty;

  self.postMessage({
    attempt: e,
    solution: o ? n.toString(t.enc.Hex) : null,
  });
};