stacks 0.56.24 → 0.58.18

package/core/src/security/dist/index.js

@@ -0,0 +1,3288 @@
+// @bun
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getProtoOf = Object.getPrototypeOf;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __toESM = (mod, isNodeMode, target) => {
+  target = mod != null ? __create(__getProtoOf(mod)) : {};
+  const to = isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target;
+  for (let key of __getOwnPropNames(mod))
+    if (!__hasOwnProp.call(to, key))
+      __defProp(to, key, {
+        get: () => mod[key],
+        enumerable: true
+      });
+  return to;
+};
+var __commonJS = (cb, mod) => () => (mod || cb((mod = { exports: {} }).exports, mod), mod.exports);
+var __require = (id) => {
+  return import.meta.require(id);
+};
+
+// /Users/chrisbreuer/Code/stacks/node_modules/crypto-js/core.js
+var require_core = __commonJS((exports, module) => {
+  (function(root, factory) {
+    if (typeof exports === "object") {
+      module.exports = exports = factory();
+    } else if (typeof define === "function" && define.amd) {
+      define([], factory);
+    } else {
+      root.CryptoJS = factory();
+    }
+  })(exports, function() {
+    var CryptoJS = CryptoJS || function(Math2, undefined2) {
+      var crypto;
+      if (typeof window !== "undefined" && window.crypto) {
+        crypto = window.crypto;
+      }
+      if (typeof self !== "undefined" && self.crypto) {
+        crypto = self.crypto;
+      }
+      if (typeof globalThis !== "undefined" && globalThis.crypto) {
+        crypto = globalThis.crypto;
+      }
+      if (!crypto && typeof window !== "undefined" && window.msCrypto) {
+        crypto = window.msCrypto;
+      }
+      if (!crypto && typeof global !== "undefined" && global.crypto) {
+        crypto = global.crypto;
+      }
+      if (!crypto && typeof require === "function") {
+        try {
+          crypto = import.meta.require("crypto");
+        } catch (err) {
+        }
+      }
+      var cryptoSecureRandomInt = function() {
+        if (crypto) {
+          if (typeof crypto.getRandomValues === "function") {
+            try {
+              return crypto.getRandomValues(new Uint32Array(1))[0];
+            } catch (err) {
+            }
+          }
+          if (typeof crypto.randomBytes === "function") {
+            try {
+              return crypto.randomBytes(4).readInt32LE();
+            } catch (err) {
+            }
+          }
+        }
+        throw new Error("Native crypto module could not be used to get secure random number.");
+      };
+      var create = Object.create || function() {
+        function F() {
+        }
+        return function(obj) {
+          var subtype;
+          F.prototype = obj;
+          subtype = new F;
+          F.prototype = null;
+          return subtype;
+        };
+      }();
+      var C = {};
+      var C_lib = C.lib = {};
+      var Base = C_lib.Base = function() {
+        return {
+          extend: function(overrides) {
+            var subtype = create(this);
+            if (overrides) {
+              subtype.mixIn(overrides);
+            }
+            if (!subtype.hasOwnProperty("init") || this.init === subtype.init) {
+              subtype.init = function() {
+                subtype.$super.init.apply(this, arguments);
+              };
+            }
+            subtype.init.prototype = subtype;
+            subtype.$super = this;
+            return subtype;
+          },
+          create: function() {
+            var instance = this.extend();
+            instance.init.apply(instance, arguments);
+            return instance;
+          },
+          init: function() {
+          },
+          mixIn: function(properties) {
+            for (var propertyName in properties) {
+              if (properties.hasOwnProperty(propertyName)) {
+                this[propertyName] = properties[propertyName];
+              }
+            }
+            if (properties.hasOwnProperty("toString")) {
+              this.toString = properties.toString;
+            }
+          },
+          clone: function() {
+            return this.init.prototype.extend(this);
+          }
+        };
+      }();
+      var WordArray = C_lib.WordArray = Base.extend({
+        init: function(words, sigBytes) {
+          words = this.words = words || [];
+          if (sigBytes != undefined2) {
+            this.sigBytes = sigBytes;
+          } else {
+            this.sigBytes = words.length * 4;
+          }
+        },
+        toString: function(encoder) {
+          return (encoder || Hex).stringify(this);
+        },
+        concat: function(wordArray) {
+          var thisWords = this.words;
+          var thatWords = wordArray.words;
+          var thisSigBytes = this.sigBytes;
+          var thatSigBytes = wordArray.sigBytes;
+          this.clamp();
+          if (thisSigBytes % 4) {
+            for (var i = 0;i < thatSigBytes; i++) {
+              var thatByte = thatWords[i >>> 2] >>> 24 - i % 4 * 8 & 255;
+              thisWords[thisSigBytes + i >>> 2] |= thatByte << 24 - (thisSigBytes + i) % 4 * 8;
+            }
+          } else {
+            for (var j = 0;j < thatSigBytes; j += 4) {
+              thisWords[thisSigBytes + j >>> 2] = thatWords[j >>> 2];
+            }
+          }
+          this.sigBytes += thatSigBytes;
+          return this;
+        },
+        clamp: function() {
+          var words = this.words;
+          var sigBytes = this.sigBytes;
+          words[sigBytes >>> 2] &= 4294967295 << 32 - sigBytes % 4 * 8;
+          words.length = Math2.ceil(sigBytes / 4);
+        },
+        clone: function() {
+          var clone = Base.clone.call(this);
+          clone.words = this.words.slice(0);
+          return clone;
+        },
+        random: function(nBytes) {
+          var words = [];
+          for (var i = 0;i < nBytes; i += 4) {
+            words.push(cryptoSecureRandomInt());
+          }
+          return new WordArray.init(words, nBytes);
+        }
+      });
+      var C_enc = C.enc = {};
+      var Hex = C_enc.Hex = {
+        stringify: function(wordArray) {
+          var words = wordArray.words;
+          var sigBytes = wordArray.sigBytes;
+          var hexChars = [];
+          for (var i = 0;i < sigBytes; i++) {
+            var bite = words[i >>> 2] >>> 24 - i % 4 * 8 & 255;
+            hexChars.push((bite >>> 4).toString(16));
+            hexChars.push((bite & 15).toString(16));
+          }
+          return hexChars.join("");
+        },
+        parse: function(hexStr) {
+          var hexStrLength = hexStr.length;
+          var words = [];
+          for (var i = 0;i < hexStrLength; i += 2) {
+            words[i >>> 3] |= parseInt(hexStr.substr(i, 2), 16) << 24 - i % 8 * 4;
+          }
+          return new WordArray.init(words, hexStrLength / 2);
+        }
+      };
+      var Latin1 = C_enc.Latin1 = {
+        stringify: function(wordArray) {
+          var words = wordArray.words;
+          var sigBytes = wordArray.sigBytes;
+          var latin1Chars = [];
+          for (var i = 0;i < sigBytes; i++) {
+            var bite = words[i >>> 2] >>> 24 - i % 4 * 8 & 255;
+            latin1Chars.push(String.fromCharCode(bite));
+          }
+          return latin1Chars.join("");
+        },
+        parse: function(latin1Str) {
+          var latin1StrLength = latin1Str.length;
+          var words = [];
+          for (var i = 0;i < latin1StrLength; i++) {
+            words[i >>> 2] |= (latin1Str.charCodeAt(i) & 255) << 24 - i % 4 * 8;
+          }
+          return new WordArray.init(words, latin1StrLength);
+        }
+      };
+      var Utf8 = C_enc.Utf8 = {
+        stringify: function(wordArray) {
+          try {
+            return decodeURIComponent(escape(Latin1.stringify(wordArray)));
+          } catch (e) {
+            throw new Error("Malformed UTF-8 data");
+          }
+        },
+        parse: function(utf8Str) {
+          return Latin1.parse(unescape(encodeURIComponent(utf8Str)));
+        }
+      };
+      var BufferedBlockAlgorithm = C_lib.BufferedBlockAlgorithm = Base.extend({
+        reset: function() {
+          this._data = new WordArray.init;
+          this._nDataBytes = 0;
+        },
+        _append: function(data) {
+          if (typeof data == "string") {
+            data = Utf8.parse(data);
+          }
+          this._data.concat(data);
+          this._nDataBytes += data.sigBytes;
+        },
+        _process: function(doFlush) {
+          var processedWords;
+          var data = this._data;
+          var dataWords = data.words;
+          var dataSigBytes = data.sigBytes;
+          var blockSize = this.blockSize;
+          var blockSizeBytes = blockSize * 4;
+          var nBlocksReady = dataSigBytes / blockSizeBytes;
+          if (doFlush) {
+            nBlocksReady = Math2.ceil(nBlocksReady);
+          } else {
+            nBlocksReady = Math2.max((nBlocksReady | 0) - this._minBufferSize, 0);
+          }
+          var nWordsReady = nBlocksReady * blockSize;
+          var nBytesReady = Math2.min(nWordsReady * 4, dataSigBytes);
+          if (nWordsReady) {
+            for (var offset = 0;offset < nWordsReady; offset += blockSize) {
+              this._doProcessBlock(dataWords, offset);
+            }
+            processedWords = dataWords.splice(0, nWordsReady);
+            data.sigBytes -= nBytesReady;
+          }
+          return new WordArray.init(processedWords, nBytesReady);
+        },
+        clone: function() {
+          var clone = Base.clone.call(this);
+          clone._data = this._data.clone();
+          return clone;
+        },
+        _minBufferSize: 0
+      });
+      var Hasher = C_lib.Hasher = BufferedBlockAlgorithm.extend({
+        cfg: Base.extend(),
+        init: function(cfg) {
+          this.cfg = this.cfg.extend(cfg);
+          this.reset();
+        },
+        reset: function() {
+          BufferedBlockAlgorithm.reset.call(this);
+          this._doReset();
+        },
+        update: function(messageUpdate) {
+          this._append(messageUpdate);
+          this._process();
+          return this;
+        },
+        finalize: function(messageUpdate) {
+          if (messageUpdate) {
+            this._append(messageUpdate);
+          }
+          var hash = this._doFinalize();
+          return hash;
+        },
+        blockSize: 512 / 32,
+        _createHelper: function(hasher) {
+          return function(message, cfg) {
+            return new hasher.init(cfg).finalize(message);
+          };
+        },
+        _createHmacHelper: function(hasher) {
+          return function(message, key) {
+            return new C_algo.HMAC.init(hasher, key).finalize(message);
+          };
+        }
+      });
+      var C_algo = C.algo = {};
+      return C;
+    }(Math);
+    return CryptoJS;
+  });
+});
+
+// /Users/chrisbreuer/Code/stacks/node_modules/crypto-js/enc-utf8.js
+var require_enc_utf8 = __commonJS((exports, module) => {
+  (function(root, factory) {
+    if (typeof exports === "object") {
+      module.exports = exports = factory(require_core());
+    } else if (typeof define === "function" && define.amd) {
+      define(["./core"], factory);
+    } else {
+      factory(root.CryptoJS);
+    }
+  })(exports, function(CryptoJS) {
+    return CryptoJS.enc.Utf8;
+  });
+});
+
+// /Users/chrisbreuer/Code/stacks/node_modules/crypto-js/enc-base64.js
+var require_enc_base64 = __commonJS((exports, module) => {
+  (function(root, factory) {
+    if (typeof exports === "object") {
+      module.exports = exports = factory(require_core());
+    } else if (typeof define === "function" && define.amd) {
+      define(["./core"], factory);
+    } else {
+      factory(root.CryptoJS);
+    }
+  })(exports, function(CryptoJS) {
+    (function() {
+      var C = CryptoJS;
+      var C_lib = C.lib;
+      var WordArray = C_lib.WordArray;
+      var C_enc = C.enc;
+      var Base64 = C_enc.Base64 = {
+        stringify: function(wordArray) {
+          var words = wordArray.words;
+          var sigBytes = wordArray.sigBytes;
+          var map = this._map;
+          wordArray.clamp();
+          var base64Chars = [];
+          for (var i = 0;i < sigBytes; i += 3) {
+            var byte1 = words[i >>> 2] >>> 24 - i % 4 * 8 & 255;
+            var byte2 = words[i + 1 >>> 2] >>> 24 - (i + 1) % 4 * 8 & 255;
+            var byte3 = words[i + 2 >>> 2] >>> 24 - (i + 2) % 4 * 8 & 255;
+            var triplet = byte1 << 16 | byte2 << 8 | byte3;
+            for (var j = 0;j < 4 && i + j * 0.75 < sigBytes; j++) {
+              base64Chars.push(map.charAt(triplet >>> 6 * (3 - j) & 63));
+            }
+          }
+          var paddingChar = map.charAt(64);
+          if (paddingChar) {
+            while (base64Chars.length % 4) {
+              base64Chars.push(paddingChar);
+            }
+          }
+          return base64Chars.join("");
+        },
+        parse: function(base64Str) {
+          var base64StrLength = base64Str.length;
+          var map = this._map;
+          var reverseMap = this._reverseMap;
+          if (!reverseMap) {
+            reverseMap = this._reverseMap = [];
+            for (var j = 0;j < map.length; j++) {
+              reverseMap[map.charCodeAt(j)] = j;
+            }
+          }
+          var paddingChar = map.charAt(64);
+          if (paddingChar) {
+            var paddingIndex = base64Str.indexOf(paddingChar);
+            if (paddingIndex !== -1) {
+              base64StrLength = paddingIndex;
+            }
+          }
+          return parseLoop(base64Str, base64StrLength, reverseMap);
+        },
+        _map: "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/="
+      };
+      function parseLoop(base64Str, base64StrLength, reverseMap) {
+        var words = [];
+        var nBytes = 0;
+        for (var i = 0;i < base64StrLength; i++) {
+          if (i % 4) {
+            var bits1 = reverseMap[base64Str.charCodeAt(i - 1)] << i % 4 * 2;
+            var bits2 = reverseMap[base64Str.charCodeAt(i)] >>> 6 - i % 4 * 2;
+            var bitsCombined = bits1 | bits2;
+            words[nBytes >>> 2] |= bitsCombined << 24 - nBytes % 4 * 8;
+            nBytes++;
+          }
+        }
+        return WordArray.create(words, nBytes);
+      }
+    })();
+    return CryptoJS.enc.Base64;
+  });
+});
+
+// /Users/chrisbreuer/Code/stacks/node_modules/crypto-js/md5.js
+var require_md5 = __commonJS((exports, module) => {
+  (function(root, factory) {
+    if (typeof exports === "object") {
+      module.exports = exports = factory(require_core());
+    } else if (typeof define === "function" && define.amd) {
+      define(["./core"], factory);
+    } else {
+      factory(root.CryptoJS);
+    }
+  })(exports, function(CryptoJS) {
+    (function(Math2) {
+      var C = CryptoJS;
+      var C_lib = C.lib;
+      var WordArray = C_lib.WordArray;
+      var Hasher = C_lib.Hasher;
+      var C_algo = C.algo;
+      var T = [];
+      (function() {
+        for (var i = 0;i < 64; i++) {
+          T[i] = Math2.abs(Math2.sin(i + 1)) * 4294967296 | 0;
+        }
+      })();
+      var MD5 = C_algo.MD5 = Hasher.extend({
+        _doReset: function() {
+          this._hash = new WordArray.init([
+            1732584193,
+            4023233417,
+            2562383102,
+            271733878
+          ]);
+        },
+        _doProcessBlock: function(M, offset) {
+          for (var i = 0;i < 16; i++) {
+            var offset_i = offset + i;
+            var M_offset_i = M[offset_i];
+            M[offset_i] = (M_offset_i << 8 | M_offset_i >>> 24) & 16711935 | (M_offset_i << 24 | M_offset_i >>> 8) & 4278255360;
+          }
+          var H = this._hash.words;
+          var M_offset_0 = M[offset + 0];
+          var M_offset_1 = M[offset + 1];
+          var M_offset_2 = M[offset + 2];
+          var M_offset_3 = M[offset + 3];
+          var M_offset_4 = M[offset + 4];
+          var M_offset_5 = M[offset + 5];
+          var M_offset_6 = M[offset + 6];
+          var M_offset_7 = M[offset + 7];
+          var M_offset_8 = M[offset + 8];
+          var M_offset_9 = M[offset + 9];
+          var M_offset_10 = M[offset + 10];
+          var M_offset_11 = M[offset + 11];
+          var M_offset_12 = M[offset + 12];
+          var M_offset_13 = M[offset + 13];
+          var M_offset_14 = M[offset + 14];
+          var M_offset_15 = M[offset + 15];
+          var a = H[0];
+          var b = H[1];
+          var c = H[2];
+          var d = H[3];
+          a = FF(a, b, c, d, M_offset_0, 7, T[0]);
+          d = FF(d, a, b, c, M_offset_1, 12, T[1]);
+          c = FF(c, d, a, b, M_offset_2, 17, T[2]);
+          b = FF(b, c, d, a, M_offset_3, 22, T[3]);
+          a = FF(a, b, c, d, M_offset_4, 7, T[4]);
+          d = FF(d, a, b, c, M_offset_5, 12, T[5]);
+          c = FF(c, d, a, b, M_offset_6, 17, T[6]);
+          b = FF(b, c, d, a, M_offset_7, 22, T[7]);
+          a = FF(a, b, c, d, M_offset_8, 7, T[8]);
+          d = FF(d, a, b, c, M_offset_9, 12, T[9]);
+          c = FF(c, d, a, b, M_offset_10, 17, T[10]);
+          b = FF(b, c, d, a, M_offset_11, 22, T[11]);
+          a = FF(a, b, c, d, M_offset_12, 7, T[12]);
+          d = FF(d, a, b, c, M_offset_13, 12, T[13]);
+          c = FF(c, d, a, b, M_offset_14, 17, T[14]);
+          b = FF(b, c, d, a, M_offset_15, 22, T[15]);
+          a = GG(a, b, c, d, M_offset_1, 5, T[16]);
+          d = GG(d, a, b, c, M_offset_6, 9, T[17]);
+          c = GG(c, d, a, b, M_offset_11, 14, T[18]);
+          b = GG(b, c, d, a, M_offset_0, 20, T[19]);
+          a = GG(a, b, c, d, M_offset_5, 5, T[20]);
+          d = GG(d, a, b, c, M_offset_10, 9, T[21]);
+          c = GG(c, d, a, b, M_offset_15, 14, T[22]);
+          b = GG(b, c, d, a, M_offset_4, 20, T[23]);
+          a = GG(a, b, c, d, M_offset_9, 5, T[24]);
+          d = GG(d, a, b, c, M_offset_14, 9, T[25]);
+          c = GG(c, d, a, b, M_offset_3, 14, T[26]);
+          b = GG(b, c, d, a, M_offset_8, 20, T[27]);
+          a = GG(a, b, c, d, M_offset_13, 5, T[28]);
+          d = GG(d, a, b, c, M_offset_2, 9, T[29]);
+          c = GG(c, d, a, b, M_offset_7, 14, T[30]);
+          b = GG(b, c, d, a, M_offset_12, 20, T[31]);
+          a = HH(a, b, c, d, M_offset_5, 4, T[32]);
+          d = HH(d, a, b, c, M_offset_8, 11, T[33]);
+          c = HH(c, d, a, b, M_offset_11, 16, T[34]);
+          b = HH(b, c, d, a, M_offset_14, 23, T[35]);
+          a = HH(a, b, c, d, M_offset_1, 4, T[36]);
+          d = HH(d, a, b, c, M_offset_4, 11, T[37]);
+          c = HH(c, d, a, b, M_offset_7, 16, T[38]);
+          b = HH(b, c, d, a, M_offset_10, 23, T[39]);
+          a = HH(a, b, c, d, M_offset_13, 4, T[40]);
+          d = HH(d, a, b, c, M_offset_0, 11, T[41]);
+          c = HH(c, d, a, b, M_offset_3, 16, T[42]);
+          b = HH(b, c, d, a, M_offset_6, 23, T[43]);
+          a = HH(a, b, c, d, M_offset_9, 4, T[44]);
+          d = HH(d, a, b, c, M_offset_12, 11, T[45]);
+          c = HH(c, d, a, b, M_offset_15, 16, T[46]);
+          b = HH(b, c, d, a, M_offset_2, 23, T[47]);
+          a = II(a, b, c, d, M_offset_0, 6, T[48]);
+          d = II(d, a, b, c, M_offset_7, 10, T[49]);
+          c = II(c, d, a, b, M_offset_14, 15, T[50]);
+          b = II(b, c, d, a, M_offset_5, 21, T[51]);
+          a = II(a, b, c, d, M_offset_12, 6, T[52]);
+          d = II(d, a, b, c, M_offset_3, 10, T[53]);
+          c = II(c, d, a, b, M_offset_10, 15, T[54]);
+          b = II(b, c, d, a, M_offset_1, 21, T[55]);
+          a = II(a, b, c, d, M_offset_8, 6, T[56]);
+          d = II(d, a, b, c, M_offset_15, 10, T[57]);
+          c = II(c, d, a, b, M_offset_6, 15, T[58]);
+          b = II(b, c, d, a, M_offset_13, 21, T[59]);
+          a = II(a, b, c, d, M_offset_4, 6, T[60]);
+          d = II(d, a, b, c, M_offset_11, 10, T[61]);
+          c = II(c, d, a, b, M_offset_2, 15, T[62]);
+          b = II(b, c, d, a, M_offset_9, 21, T[63]);
+          H[0] = H[0] + a | 0;
+          H[1] = H[1] + b | 0;
+          H[2] = H[2] + c | 0;
+          H[3] = H[3] + d | 0;
+        },
+        _doFinalize: function() {
+          var data = this._data;
+          var dataWords = data.words;
+          var nBitsTotal = this._nDataBytes * 8;
+          var nBitsLeft = data.sigBytes * 8;
+          dataWords[nBitsLeft >>> 5] |= 128 << 24 - nBitsLeft % 32;
+          var nBitsTotalH = Math2.floor(nBitsTotal / 4294967296);
+          var nBitsTotalL = nBitsTotal;
+          dataWords[(nBitsLeft + 64 >>> 9 << 4) + 15] = (nBitsTotalH << 8 | nBitsTotalH >>> 24) & 16711935 | (nBitsTotalH << 24 | nBitsTotalH >>> 8) & 4278255360;
+          dataWords[(nBitsLeft + 64 >>> 9 << 4) + 14] = (nBitsTotalL << 8 | nBitsTotalL >>> 24) & 16711935 | (nBitsTotalL << 24 | nBitsTotalL >>> 8) & 4278255360;
+          data.sigBytes = (dataWords.length + 1) * 4;
+          this._process();
+          var hash = this._hash;
+          var H = hash.words;
+          for (var i = 0;i < 4; i++) {
+            var H_i = H[i];
+            H[i] = (H_i << 8 | H_i >>> 24) & 16711935 | (H_i << 24 | H_i >>> 8) & 4278255360;
+          }
+          return hash;
+        },
+        clone: function() {
+          var clone = Hasher.clone.call(this);
+          clone._hash = this._hash.clone();
+          return clone;
+        }
+      });
+      function FF(a, b, c, d, x, s, t) {
+        var n = a + (b & c | ~b & d) + x + t;
+        return (n << s | n >>> 32 - s) + b;
+      }
+      function GG(a, b, c, d, x, s, t) {
+        var n = a + (b & d | c & ~d) + x + t;
+        return (n << s | n >>> 32 - s) + b;
+      }
+      function HH(a, b, c, d, x, s, t) {
+        var n = a + (b ^ c ^ d) + x + t;
+        return (n << s | n >>> 32 - s) + b;
+      }
+      function II(a, b, c, d, x, s, t) {
+        var n = a + (c ^ (b | ~d)) + x + t;
+        return (n << s | n >>> 32 - s) + b;
+      }
+      C.MD5 = Hasher._createHelper(MD5);
+      C.HmacMD5 = Hasher._createHmacHelper(MD5);
+    })(Math);
+    return CryptoJS.MD5;
+  });
+});
+
+// /Users/chrisbreuer/Code/stacks/node_modules/crypto-js/sha1.js
+var require_sha1 = __commonJS((exports, module) => {
+  (function(root, factory) {
+    if (typeof exports === "object") {
+      module.exports = exports = factory(require_core());
+    } else if (typeof define === "function" && define.amd) {
+      define(["./core"], factory);
+    } else {
+      factory(root.CryptoJS);
+    }
+  })(exports, function(CryptoJS) {
+    (function() {
+      var C = CryptoJS;
+      var C_lib = C.lib;
+      var WordArray = C_lib.WordArray;
+      var Hasher = C_lib.Hasher;
+      var C_algo = C.algo;
+      var W = [];
+      var SHA1 = C_algo.SHA1 = Hasher.extend({
+        _doReset: function() {
+          this._hash = new WordArray.init([
+            1732584193,
+            4023233417,
+            2562383102,
+            271733878,
+            3285377520
+          ]);
+        },
+        _doProcessBlock: function(M, offset) {
+          var H = this._hash.words;
+          var a = H[0];
+          var b = H[1];
+          var c = H[2];
+          var d = H[3];
+          var e = H[4];
+          for (var i = 0;i < 80; i++) {
+            if (i < 16) {
+              W[i] = M[offset + i] | 0;
+            } else {
+              var n = W[i - 3] ^ W[i - 8] ^ W[i - 14] ^ W[i - 16];
+              W[i] = n << 1 | n >>> 31;
+            }
+            var t = (a << 5 | a >>> 27) + e + W[i];
+            if (i < 20) {
+              t += (b & c | ~b & d) + 1518500249;
+            } else if (i < 40) {
+              t += (b ^ c ^ d) + 1859775393;
+            } else if (i < 60) {
+              t += (b & c | b & d | c & d) - 1894007588;
+            } else {
+              t += (b ^ c ^ d) - 899497514;
+            }
+            e = d;
+            d = c;
+            c = b << 30 | b >>> 2;
+            b = a;
+            a = t;
+          }
+          H[0] = H[0] + a | 0;
+          H[1] = H[1] + b | 0;
+          H[2] = H[2] + c | 0;
+          H[3] = H[3] + d | 0;
+          H[4] = H[4] + e | 0;
+        },
+        _doFinalize: function() {
+          var data = this._data;
+          var dataWords = data.words;
+          var nBitsTotal = this._nDataBytes * 8;
+          var nBitsLeft = data.sigBytes * 8;
+          dataWords[nBitsLeft >>> 5] |= 128 << 24 - nBitsLeft % 32;
+          dataWords[(nBitsLeft + 64 >>> 9 << 4) + 14] = Math.floor(nBitsTotal / 4294967296);
+          dataWords[(nBitsLeft + 64 >>> 9 << 4) + 15] = nBitsTotal;
+          data.sigBytes = dataWords.length * 4;
+          this._process();
+          return this._hash;
+        },
+        clone: function() {
+          var clone = Hasher.clone.call(this);
+          clone._hash = this._hash.clone();
+          return clone;
+        }
+      });
+      C.SHA1 = Hasher._createHelper(SHA1);
+      C.HmacSHA1 = Hasher._createHmacHelper(SHA1);
+    })();
+    return CryptoJS.SHA1;
+  });
+});
+
+// /Users/chrisbreuer/Code/stacks/node_modules/crypto-js/hmac.js
+var require_hmac = __commonJS((exports, module) => {
+  (function(root, factory) {
+    if (typeof exports === "object") {
+      module.exports = exports = factory(require_core());
+    } else if (typeof define === "function" && define.amd) {
+      define(["./core"], factory);
+    } else {
+      factory(root.CryptoJS);
+    }
+  })(exports, function(CryptoJS) {
+    (function() {
+      var C = CryptoJS;
+      var C_lib = C.lib;
+      var Base = C_lib.Base;
+      var C_enc = C.enc;
+      var Utf8 = C_enc.Utf8;
+      var C_algo = C.algo;
+      var HMAC = C_algo.HMAC = Base.extend({
+        init: function(hasher, key) {
+          hasher = this._hasher = new hasher.init;
+          if (typeof key == "string") {
+            key = Utf8.parse(key);
+          }
+          var hasherBlockSize = hasher.blockSize;
+          var hasherBlockSizeBytes = hasherBlockSize * 4;
+          if (key.sigBytes > hasherBlockSizeBytes) {
+            key = hasher.finalize(key);
+          }
+          key.clamp();
+          var oKey = this._oKey = key.clone();
+          var iKey = this._iKey = key.clone();
+          var oKeyWords = oKey.words;
+          var iKeyWords = iKey.words;
+          for (var i = 0;i < hasherBlockSize; i++) {
+            oKeyWords[i] ^= 1549556828;
+            iKeyWords[i] ^= 909522486;
+          }
+          oKey.sigBytes = iKey.sigBytes = hasherBlockSizeBytes;
+          this.reset();
+        },
+        reset: function() {
+          var hasher = this._hasher;
+          hasher.reset();
+          hasher.update(this._iKey);
+        },
+        update: function(messageUpdate) {
+          this._hasher.update(messageUpdate);
+          return this;
+        },
+        finalize: function(messageUpdate) {
+          var hasher = this._hasher;
+          var innerHash = hasher.finalize(messageUpdate);
+          hasher.reset();
+          var hmac = hasher.finalize(this._oKey.clone().concat(innerHash));
+          return hmac;
+        }
+      });
+    })();
+  });
+});
+
+// /Users/chrisbreuer/Code/stacks/node_modules/crypto-js/evpkdf.js
+var require_evpkdf = __commonJS((exports, module) => {
+  (function(root, factory, undef) {
+    if (typeof exports === "object") {
+      module.exports = exports = factory(require_core(), require_sha1(), require_hmac());
+    } else if (typeof define === "function" && define.amd) {
+      define(["./core", "./sha1", "./hmac"], factory);
+    } else {
+      factory(root.CryptoJS);
+    }
+  })(exports, function(CryptoJS) {
+    (function() {
+      var C = CryptoJS;
+      var C_lib = C.lib;
+      var Base = C_lib.Base;
+      var WordArray = C_lib.WordArray;
+      var C_algo = C.algo;
+      var MD5 = C_algo.MD5;
+      var EvpKDF = C_algo.EvpKDF = Base.extend({
+        cfg: Base.extend({
+          keySize: 128 / 32,
+          hasher: MD5,
+          iterations: 1
+        }),
+        init: function(cfg) {
+          this.cfg = this.cfg.extend(cfg);
+        },
+        compute: function(password, salt) {
+          var block;
+          var cfg = this.cfg;
+          var hasher = cfg.hasher.create();
+          var derivedKey = WordArray.create();
+          var derivedKeyWords = derivedKey.words;
+          var keySize = cfg.keySize;
+          var iterations = cfg.iterations;
+          while (derivedKeyWords.length < keySize) {
+            if (block) {
+              hasher.update(block);
+            }
+            block = hasher.update(password).finalize(salt);
+            hasher.reset();
+            for (var i = 1;i < iterations; i++) {
+              block = hasher.finalize(block);
+              hasher.reset();
+            }
+            derivedKey.concat(block);
+          }
+          derivedKey.sigBytes = keySize * 4;
+          return derivedKey;
+        }
+      });
+      C.EvpKDF = function(password, salt, cfg) {
+        return EvpKDF.create(cfg).compute(password, salt);
+      };
+    })();
+    return CryptoJS.EvpKDF;
+  });
+});
+
+// /Users/chrisbreuer/Code/stacks/node_modules/crypto-js/cipher-core.js
+var require_cipher_core = __commonJS((exports, module) => {
+  (function(root, factory, undef) {
+    if (typeof exports === "object") {
+      module.exports = exports = factory(require_core(), require_evpkdf());
+    } else if (typeof define === "function" && define.amd) {
+      define(["./core", "./evpkdf"], factory);
+    } else {
+      factory(root.CryptoJS);
+    }
+  })(exports, function(CryptoJS) {
+    CryptoJS.lib.Cipher || function(undefined2) {
+      var C = CryptoJS;
+      var C_lib = C.lib;
+      var Base = C_lib.Base;
+      var WordArray = C_lib.WordArray;
+      var BufferedBlockAlgorithm = C_lib.BufferedBlockAlgorithm;
+      var C_enc = C.enc;
+      var Utf8 = C_enc.Utf8;
+      var Base64 = C_enc.Base64;
+      var C_algo = C.algo;
+      var EvpKDF = C_algo.EvpKDF;
+      var Cipher = C_lib.Cipher = BufferedBlockAlgorithm.extend({
+        cfg: Base.extend(),
+        createEncryptor: function(key, cfg) {
+          return this.create(this._ENC_XFORM_MODE, key, cfg);
+        },
+        createDecryptor: function(key, cfg) {
+          return this.create(this._DEC_XFORM_MODE, key, cfg);
+        },
+        init: function(xformMode, key, cfg) {
+          this.cfg = this.cfg.extend(cfg);
+          this._xformMode = xformMode;
+          this._key = key;
+          this.reset();
+        },
+        reset: function() {
+          BufferedBlockAlgorithm.reset.call(this);
+          this._doReset();
+        },
+        process: function(dataUpdate) {
+          this._append(dataUpdate);
+          return this._process();
+        },
+        finalize: function(dataUpdate) {
+          if (dataUpdate) {
+            this._append(dataUpdate);
+          }
+          var finalProcessedData = this._doFinalize();
+          return finalProcessedData;
+        },
+        keySize: 128 / 32,
+        ivSize: 128 / 32,
+        _ENC_XFORM_MODE: 1,
+        _DEC_XFORM_MODE: 2,
+        _createHelper: function() {
+          function selectCipherStrategy(key) {
+            if (typeof key == "string") {
+              return PasswordBasedCipher;
+            } else {
+              return SerializableCipher;
+            }
+          }
+          return function(cipher) {
+            return {
+              encrypt: function(message, key, cfg) {
+                return selectCipherStrategy(key).encrypt(cipher, message, key, cfg);
+              },
+              decrypt: function(ciphertext, key, cfg) {
+                return selectCipherStrategy(key).decrypt(cipher, ciphertext, key, cfg);
+              }
+            };
+          };
+        }()
+      });
+      var StreamCipher = C_lib.StreamCipher = Cipher.extend({
+        _doFinalize: function() {
+          var finalProcessedBlocks = this._process(true);
+          return finalProcessedBlocks;
+        },
+        blockSize: 1
+      });
+      var C_mode = C.mode = {};
+      var BlockCipherMode = C_lib.BlockCipherMode = Base.extend({
+        createEncryptor: function(cipher, iv) {
+          return this.Encryptor.create(cipher, iv);
+        },
+        createDecryptor: function(cipher, iv) {
+          return this.Decryptor.create(cipher, iv);
+        },
+        init: function(cipher, iv) {
+          this._cipher = cipher;
+          this._iv = iv;
+        }
+      });
+      var CBC = C_mode.CBC = function() {
+        var CBC2 = BlockCipherMode.extend();
+        CBC2.Encryptor = CBC2.extend({
+          processBlock: function(words, offset) {
+            var cipher = this._cipher;
+            var blockSize = cipher.blockSize;
+            xorBlock.call(this, words, offset, blockSize);
+            cipher.encryptBlock(words, offset);
+            this._prevBlock = words.slice(offset, offset + blockSize);
+          }
+        });
+        CBC2.Decryptor = CBC2.extend({
+          processBlock: function(words, offset) {
+            var cipher = this._cipher;
+            var blockSize = cipher.blockSize;
+            var thisBlock = words.slice(offset, offset + blockSize);
+            cipher.decryptBlock(words, offset);
+            xorBlock.call(this, words, offset, blockSize);
+            this._prevBlock = thisBlock;
+          }
+        });
+        function xorBlock(words, offset, blockSize) {
+          var block;
+          var iv = this._iv;
+          if (iv) {
+            block = iv;
+            this._iv = undefined2;
+          } else {
+            block = this._prevBlock;
+          }
+          for (var i = 0;i < blockSize; i++) {
+            words[offset + i] ^= block[i];
+          }
+        }
+        return CBC2;
+      }();
+      var C_pad = C.pad = {};
+      var Pkcs7 = C_pad.Pkcs7 = {
+        pad: function(data, blockSize) {
+          var blockSizeBytes = blockSize * 4;
+          var nPaddingBytes = blockSizeBytes - data.sigBytes % blockSizeBytes;
+          var paddingWord = nPaddingBytes << 24 | nPaddingBytes << 16 | nPaddingBytes << 8 | nPaddingBytes;
+          var paddingWords = [];
+          for (var i = 0;i < nPaddingBytes; i += 4) {
+            paddingWords.push(paddingWord);
+          }
+          var padding = WordArray.create(paddingWords, nPaddingBytes);
+          data.concat(padding);
+        },
+        unpad: function(data) {
+          var nPaddingBytes = data.words[data.sigBytes - 1 >>> 2] & 255;
+          data.sigBytes -= nPaddingBytes;
+        }
+      };
+      var BlockCipher = C_lib.BlockCipher = Cipher.extend({
+        cfg: Cipher.cfg.extend({
+          mode: CBC,
+          padding: Pkcs7
+        }),
+        reset: function() {
+          var modeCreator;
+          Cipher.reset.call(this);
+          var cfg = this.cfg;
+          var iv = cfg.iv;
+          var mode = cfg.mode;
+          if (this._xformMode == this._ENC_XFORM_MODE) {
+            modeCreator = mode.createEncryptor;
+          } else {
+            modeCreator = mode.createDecryptor;
+            this._minBufferSize = 1;
+          }
+          if (this._mode && this._mode.__creator == modeCreator) {
+            this._mode.init(this, iv && iv.words);
+          } else {
+            this._mode = modeCreator.call(mode, this, iv && iv.words);
+            this._mode.__creator = modeCreator;
+          }
+        },
+        _doProcessBlock: function(words, offset) {
+          this._mode.processBlock(words, offset);
+        },
+        _doFinalize: function() {
+          var finalProcessedBlocks;
+          var padding = this.cfg.padding;
+          if (this._xformMode == this._ENC_XFORM_MODE) {
+            padding.pad(this._data, this.blockSize);
+            finalProcessedBlocks = this._process(true);
+          } else {
+            finalProcessedBlocks = this._process(true);
+            padding.unpad(finalProcessedBlocks);
+          }
+          return finalProcessedBlocks;
+        },
+        blockSize: 128 / 32
+      });
+      var CipherParams = C_lib.CipherParams = Base.extend({
+        init: function(cipherParams) {
+          this.mixIn(cipherParams);
+        },
+        toString: function(formatter) {
+          return (formatter || this.formatter).stringify(this);
+        }
+      });
+      var C_format = C.format = {};
+      var OpenSSLFormatter = C_format.OpenSSL = {
+        stringify: function(cipherParams) {
+          var wordArray;
+          var ciphertext = cipherParams.ciphertext;
+          var salt = cipherParams.salt;
+          if (salt) {
+            wordArray = WordArray.create([1398893684, 1701076831]).concat(salt).concat(ciphertext);
+          } else {
+            wordArray = ciphertext;
+          }
+          return wordArray.toString(Base64);
+        },
+        parse: function(openSSLStr) {
+          var salt;
+          var ciphertext = Base64.parse(openSSLStr);
+          var ciphertextWords = ciphertext.words;
+          if (ciphertextWords[0] == 1398893684 && ciphertextWords[1] == 1701076831) {
+            salt = WordArray.create(ciphertextWords.slice(2, 4));
+            ciphertextWords.splice(0, 4);
+            ciphertext.sigBytes -= 16;
+          }
+          return CipherParams.create({ ciphertext, salt });
+        }
+      };
+      var SerializableCipher = C_lib.SerializableCipher = Base.extend({
+        cfg: Base.extend({
+          format: OpenSSLFormatter
+        }),
+        encrypt: function(cipher, message, key, cfg) {
+          cfg = this.cfg.extend(cfg);
+          var encryptor = cipher.createEncryptor(key, cfg);
+          var ciphertext = encryptor.finalize(message);
+          var cipherCfg = encryptor.cfg;
+          return CipherParams.create({
+            ciphertext,
+            key,
+            iv: cipherCfg.iv,
+            algorithm: cipher,
+            mode: cipherCfg.mode,
+            padding: cipherCfg.padding,
+            blockSize: cipher.blockSize,
+            formatter: cfg.format
+          });
+        },
+        decrypt: function(cipher, ciphertext, key, cfg) {
+          cfg = this.cfg.extend(cfg);
+          ciphertext = this._parse(ciphertext, cfg.format);
+          var plaintext = cipher.createDecryptor(key, cfg).finalize(ciphertext.ciphertext);
+          return plaintext;
+        },
+        _parse: function(ciphertext, format) {
+          if (typeof ciphertext == "string") {
+            return format.parse(ciphertext, this);
+          } else {
+            return ciphertext;
+          }
+        }
+      });
+      var C_kdf = C.kdf = {};
+      var OpenSSLKdf = C_kdf.OpenSSL = {
+        execute: function(password, keySize, ivSize, salt, hasher) {
+          if (!salt) {
+            salt = WordArray.random(64 / 8);
+          }
+          if (!hasher) {
+            var key = EvpKDF.create({ keySize: keySize + ivSize }).compute(password, salt);
+          } else {
+            var key = EvpKDF.create({ keySize: keySize + ivSize, hasher }).compute(password, salt);
+          }
+          var iv = WordArray.create(key.words.slice(keySize), ivSize * 4);
+          key.sigBytes = keySize * 4;
+          return CipherParams.create({ key, iv, salt });
+        }
+      };
+      var PasswordBasedCipher = C_lib.PasswordBasedCipher = SerializableCipher.extend({
+        cfg: SerializableCipher.cfg.extend({
+          kdf: OpenSSLKdf
+        }),
+        encrypt: function(cipher, message, password, cfg) {
+          cfg = this.cfg.extend(cfg);
+          var derivedParams = cfg.kdf.execute(password, cipher.keySize, cipher.ivSize, cfg.salt, cfg.hasher);
+          cfg.iv = derivedParams.iv;
+          var ciphertext = SerializableCipher.encrypt.call(this, cipher, message, derivedParams.key, cfg);
+          ciphertext.mixIn(derivedParams);
+          return ciphertext;
+        },
+        decrypt: function(cipher, ciphertext, password, cfg) {
+          cfg = this.cfg.extend(cfg);
+          ciphertext = this._parse(ciphertext, cfg.format);
+          var derivedParams = cfg.kdf.execute(password, cipher.keySize, cipher.ivSize, ciphertext.salt, cfg.hasher);
+          cfg.iv = derivedParams.iv;
+          var plaintext = SerializableCipher.decrypt.call(this, cipher, ciphertext, derivedParams.key, cfg);
+          return plaintext;
+        }
+      });
+    }();
+  });
+});
+
+// /Users/chrisbreuer/Code/stacks/node_modules/crypto-js/aes.js
+var require_aes = __commonJS((exports, module) => {
+  (function(root, factory, undef) {
+    if (typeof exports === "object") {
+      module.exports = exports = factory(require_core(), require_enc_base64(), require_md5(), require_evpkdf(), require_cipher_core());
+    } else if (typeof define === "function" && define.amd) {
+      define(["./core", "./enc-base64", "./md5", "./evpkdf", "./cipher-core"], factory);
+    } else {
+      factory(root.CryptoJS);
+    }
+  })(exports, function(CryptoJS) {
+    (function() {
+      var C = CryptoJS;
+      var C_lib = C.lib;
+      var BlockCipher = C_lib.BlockCipher;
+      var C_algo = C.algo;
+      var SBOX = [];
+      var INV_SBOX = [];
+      var SUB_MIX_0 = [];
+      var SUB_MIX_1 = [];
+      var SUB_MIX_2 = [];
+      var SUB_MIX_3 = [];
+      var INV_SUB_MIX_0 = [];
+      var INV_SUB_MIX_1 = [];
+      var INV_SUB_MIX_2 = [];
+      var INV_SUB_MIX_3 = [];
+      (function() {
+        var d = [];
+        for (var i = 0;i < 256; i++) {
+          if (i < 128) {
+            d[i] = i << 1;
+          } else {
+            d[i] = i << 1 ^ 283;
+          }
+        }
+        var x = 0;
+        var xi = 0;
+        for (var i = 0;i < 256; i++) {
+          var sx = xi ^ xi << 1 ^ xi << 2 ^ xi << 3 ^ xi << 4;
+          sx = sx >>> 8 ^ sx & 255 ^ 99;
+          SBOX[x] = sx;
+          INV_SBOX[sx] = x;
+          var x2 = d[x];
+          var x4 = d[x2];
+          var x8 = d[x4];
+          var t = d[sx] * 257 ^ sx * 16843008;
+          SUB_MIX_0[x] = t << 24 | t >>> 8;
+          SUB_MIX_1[x] = t << 16 | t >>> 16;
+          SUB_MIX_2[x] = t << 8 | t >>> 24;
+          SUB_MIX_3[x] = t;
+          var t = x8 * 16843009 ^ x4 * 65537 ^ x2 * 257 ^ x * 16843008;
+          INV_SUB_MIX_0[sx] = t << 24 | t >>> 8;
+          INV_SUB_MIX_1[sx] = t << 16 | t >>> 16;
+          INV_SUB_MIX_2[sx] = t << 8 | t >>> 24;
+          INV_SUB_MIX_3[sx] = t;
+          if (!x) {
+            x = xi = 1;
+          } else {
+            x = x2 ^ d[d[d[x8 ^ x2]]];
+            xi ^= d[d[xi]];
+          }
+        }
+      })();
+      var RCON = [0, 1, 2, 4, 8, 16, 32, 64, 128, 27, 54];
+      var AES = C_algo.AES = BlockCipher.extend({
+        _doReset: function() {
+          var t;
+          if (this._nRounds && this._keyPriorReset === this._key) {
+            return;
+          }
+          var key = this._keyPriorReset = this._key;
+          var keyWords = key.words;
+          var keySize = key.sigBytes / 4;
+          var nRounds = this._nRounds = keySize + 6;
+          var ksRows = (nRounds + 1) * 4;
+          var keySchedule = this._keySchedule = [];
+          for (var ksRow = 0;ksRow < ksRows; ksRow++) {
+            if (ksRow < keySize) {
+              keySchedule[ksRow] = keyWords[ksRow];
+            } else {
+              t = keySchedule[ksRow - 1];
+              if (!(ksRow % keySize)) {
+                t = t << 8 | t >>> 24;
+                t = SBOX[t >>> 24] << 24 | SBOX[t >>> 16 & 255] << 16 | SBOX[t >>> 8 & 255] << 8 | SBOX[t & 255];
+                t ^= RCON[ksRow / keySize | 0] << 24;
+              } else if (keySize > 6 && ksRow % keySize == 4) {
+                t = SBOX[t >>> 24] << 24 | SBOX[t >>> 16 & 255] << 16 | SBOX[t >>> 8 & 255] << 8 | SBOX[t & 255];
+              }
+              keySchedule[ksRow] = keySchedule[ksRow - keySize] ^ t;
+            }
+          }
+          var invKeySchedule = this._invKeySchedule = [];
+          for (var invKsRow = 0;invKsRow < ksRows; invKsRow++) {
+            var ksRow = ksRows - invKsRow;
+            if (invKsRow % 4) {
+              var t = keySchedule[ksRow];
+            } else {
+              var t = keySchedule[ksRow - 4];
+            }
+            if (invKsRow < 4 || ksRow <= 4) {
+              invKeySchedule[invKsRow] = t;
+            } else {
+              invKeySchedule[invKsRow] = INV_SUB_MIX_0[SBOX[t >>> 24]] ^ INV_SUB_MIX_1[SBOX[t >>> 16 & 255]] ^ INV_SUB_MIX_2[SBOX[t >>> 8 & 255]] ^ INV_SUB_MIX_3[SBOX[t & 255]];
+            }
+          }
+        },
+        encryptBlock: function(M, offset) {
+          this._doCryptBlock(M, offset, this._keySchedule, SUB_MIX_0, SUB_MIX_1, SUB_MIX_2, SUB_MIX_3, SBOX);
+        },
+        decryptBlock: function(M, offset) {
+          var t = M[offset + 1];
+          M[offset + 1] = M[offset + 3];
+          M[offset + 3] = t;
+          this._doCryptBlock(M, offset, this._invKeySchedule, INV_SUB_MIX_0, INV_SUB_MIX_1, INV_SUB_MIX_2, INV_SUB_MIX_3, INV_SBOX);
+          var t = M[offset + 1];
+          M[offset + 1] = M[offset + 3];
+          M[offset + 3] = t;
+        },
+        _doCryptBlock: function(M, offset, keySchedule, SUB_MIX_02, SUB_MIX_12, SUB_MIX_22, SUB_MIX_32, SBOX2) {
+          var nRounds = this._nRounds;
+          var s0 = M[offset] ^ keySchedule[0];
+          var s1 = M[offset + 1] ^ keySchedule[1];
+          var s2 = M[offset + 2] ^ keySchedule[2];
+          var s3 = M[offset + 3] ^ keySchedule[3];
+          var ksRow = 4;
+          for (var round = 1;round < nRounds; round++) {
+            var t0 = SUB_MIX_02[s0 >>> 24] ^ SUB_MIX_12[s1 >>> 16 & 255] ^ SUB_MIX_22[s2 >>> 8 & 255] ^ SUB_MIX_32[s3 & 255] ^ keySchedule[ksRow++];
+            var t1 = SUB_MIX_02[s1 >>> 24] ^ SUB_MIX_12[s2 >>> 16 & 255] ^ SUB_MIX_22[s3 >>> 8 & 255] ^ SUB_MIX_32[s0 & 255] ^ keySchedule[ksRow++];
+            var t2 = SUB_MIX_02[s2 >>> 24] ^ SUB_MIX_12[s3 >>> 16 & 255] ^ SUB_MIX_22[s0 >>> 8 & 255] ^ SUB_MIX_32[s1 & 255] ^ keySchedule[ksRow++];
+            var t3 = SUB_MIX_02[s3 >>> 24] ^ SUB_MIX_12[s0 >>> 16 & 255] ^ SUB_MIX_22[s1 >>> 8 & 255] ^ SUB_MIX_32[s2 & 255] ^ keySchedule[ksRow++];
+            s0 = t0;
+            s1 = t1;
+            s2 = t2;
+            s3 = t3;
+          }
+          var t0 = (SBOX2[s0 >>> 24] << 24 | SBOX2[s1 >>> 16 & 255] << 16 | SBOX2[s2 >>> 8 & 255] << 8 | SBOX2[s3 & 255]) ^ keySchedule[ksRow++];
+          var t1 = (SBOX2[s1 >>> 24] << 24 | SBOX2[s2 >>> 16 & 255] << 16 | SBOX2[s3 >>> 8 & 255] << 8 | SBOX2[s0 & 255]) ^ keySchedule[ksRow++];
+          var t2 = (SBOX2[s2 >>> 24] << 24 | SBOX2[s3 >>> 16 & 255] << 16 | SBOX2[s0 >>> 8 & 255] << 8 | SBOX2[s1 & 255]) ^ keySchedule[ksRow++];
+          var t3 = (SBOX2[s3 >>> 24] << 24 | SBOX2[s0 >>> 16 & 255] << 16 | SBOX2[s1 >>> 8 & 255] << 8 | SBOX2[s2 & 255]) ^ keySchedule[ksRow++];
+          M[offset] = t0;
+          M[offset + 1] = t1;
+          M[offset + 2] = t2;
+          M[offset + 3] = t3;
+        },
+        keySize: 256 / 32
+      });
+      C.AES = BlockCipher._createHelper(AES);
+    })();
+    return CryptoJS.AES;
+  });
+});
+
+// /Users/chrisbreuer/Code/stacks/node_modules/bcryptjs/dist/bcrypt.js
+var require_bcrypt = __commonJS((exports, module) => {
+  (function(global2, factory) {
+    if (typeof define === "function" && define["amd"])
+      define([], factory);
+    else if (typeof require === "function" && typeof module === "object" && module && exports)
+      module["exports"] = factory();
+    else
+      (global2["dcodeIO"] = global2["dcodeIO"] || {})["bcrypt"] = factory();
+  })(exports, function() {
+    var bcrypt = {};
+    var randomFallback = null;
+    function random(len) {
+      if (typeof module !== "undefined" && module && module["exports"])
+        try {
+          return import.meta.require("crypto")["randomBytes"](len);
+        } catch (e) {
+        }
+      try {
+        var a;
+        (self["crypto"] || self["msCrypto"])["getRandomValues"](a = new Uint32Array(len));
+        return Array.prototype.slice.call(a);
+      } catch (e) {
+      }
+      if (!randomFallback)
+        throw Error("Neither WebCryptoAPI nor a crypto module is available. Use bcrypt.setRandomFallback to set an alternative");
+      return randomFallback(len);
+    }
+    var randomAvailable = false;
+    try {
+      random(1);
+      randomAvailable = true;
+    } catch (e) {
+    }
+    randomFallback = null;
+    bcrypt.setRandomFallback = function(random2) {
+      randomFallback = random2;
+    };
+    bcrypt.genSaltSync = function(rounds, seed_length) {
+      rounds = rounds || GENSALT_DEFAULT_LOG2_ROUNDS;
+      if (typeof rounds !== "number")
+        throw Error("Illegal arguments: " + typeof rounds + ", " + typeof seed_length);
+      if (rounds < 4)
+        rounds = 4;
+      else if (rounds > 31)
+        rounds = 31;
+      var salt = [];
+      salt.push("$2a$");
+      if (rounds < 10)
+        salt.push("0");
+      salt.push(rounds.toString());
+      salt.push("$");
+      salt.push(base64_encode(random(BCRYPT_SALT_LEN), BCRYPT_SALT_LEN));
+      return salt.join("");
+    };
+    bcrypt.genSalt = function(rounds, seed_length, callback) {
+      if (typeof seed_length === "function")
+        callback = seed_length, seed_length = undefined;
+      if (typeof rounds === "function")
+        callback = rounds, rounds = undefined;
+      if (typeof rounds === "undefined")
+        rounds = GENSALT_DEFAULT_LOG2_ROUNDS;
+      else if (typeof rounds !== "number")
+        throw Error("illegal arguments: " + typeof rounds);
+      function _async(callback2) {
+        nextTick(function() {
+          try {
+            callback2(null, bcrypt.genSaltSync(rounds));
+          } catch (err) {
+            callback2(err);
+          }
+        });
+      }
+      if (callback) {
+        if (typeof callback !== "function")
+          throw Error("Illegal callback: " + typeof callback);
+        _async(callback);
+      } else
+        return new Promise(function(resolve, reject) {
+          _async(function(err, res) {
+            if (err) {
+              reject(err);
+              return;
+            }
+            resolve(res);
+          });
+        });
+    };
+    bcrypt.hashSync = function(s, salt) {
+      if (typeof salt === "undefined")
+        salt = GENSALT_DEFAULT_LOG2_ROUNDS;
+      if (typeof salt === "number")
+        salt = bcrypt.genSaltSync(salt);
+      if (typeof s !== "string" || typeof salt !== "string")
+        throw Error("Illegal arguments: " + typeof s + ", " + typeof salt);
+      return _hash(s, salt);
+    };
+    bcrypt.hash = function(s, salt, callback, progressCallback) {
+      function _async(callback2) {
+        if (typeof s === "string" && typeof salt === "number")
+          bcrypt.genSalt(salt, function(err, salt2) {
+            _hash(s, salt2, callback2, progressCallback);
+          });
+        else if (typeof s === "string" && typeof salt === "string")
+          _hash(s, salt, callback2, progressCallback);
+        else
+          nextTick(callback2.bind(this, Error("Illegal arguments: " + typeof s + ", " + typeof salt)));
+      }
+      if (callback) {
+        if (typeof callback !== "function")
+          throw Error("Illegal callback: " + typeof callback);
+        _async(callback);
+      } else
+        return new Promise(function(resolve, reject) {
+          _async(function(err, res) {
+            if (err) {
+              reject(err);
+              return;
+            }
+            resolve(res);
+          });
+        });
+    };
+    function safeStringCompare(known, unknown) {
+      var right = 0, wrong = 0;
+      for (var i = 0, k = known.length;i < k; ++i) {
+        if (known.charCodeAt(i) === unknown.charCodeAt(i))
+          ++right;
+        else
+          ++wrong;
+      }
+      if (right < 0)
+        return false;
+      return wrong === 0;
+    }
+    bcrypt.compareSync = function(s, hash) {
+      if (typeof s !== "string" || typeof hash !== "string")
+        throw Error("Illegal arguments: " + typeof s + ", " + typeof hash);
+      if (hash.length !== 60)
+        return false;
+      return safeStringCompare(bcrypt.hashSync(s, hash.substr(0, hash.length - 31)), hash);
+    };
+    bcrypt.compare = function(s, hash, callback, progressCallback) {
+      function _async(callback2) {
+        if (typeof s !== "string" || typeof hash !== "string") {
+          nextTick(callback2.bind(this, Error("Illegal arguments: " + typeof s + ", " + typeof hash)));
+          return;
+        }
+        if (hash.length !== 60) {
+          nextTick(callback2.bind(this, null, false));
+          return;
+        }
+        bcrypt.hash(s, hash.substr(0, 29), function(err, comp) {
+          if (err)
+            callback2(err);
+          else
+            callback2(null, safeStringCompare(comp, hash));
+        }, progressCallback);
+      }
+      if (callback) {
+        if (typeof callback !== "function")
+          throw Error("Illegal callback: " + typeof callback);
+        _async(callback);
+      } else
+        return new Promise(function(resolve, reject) {
+          _async(function(err, res) {
+            if (err) {
+              reject(err);
+              return;
+            }
+            resolve(res);
+          });
+        });
+    };
+    bcrypt.getRounds = function(hash) {
+      if (typeof hash !== "string")
+        throw Error("Illegal arguments: " + typeof hash);
+      return parseInt(hash.split("$")[2], 10);
+    };
+    bcrypt.getSalt = function(hash) {
+      if (typeof hash !== "string")
+        throw Error("Illegal arguments: " + typeof hash);
+      if (hash.length !== 60)
+        throw Error("Illegal hash length: " + hash.length + " != 60");
+      return hash.substring(0, 29);
+    };
+    var nextTick = typeof process !== "undefined" && process && typeof process.nextTick === "function" ? typeof setImmediate === "function" ? setImmediate : process.nextTick : setTimeout;
+    function stringToBytes(str) {
+      var out = [], i = 0;
+      utfx.encodeUTF16toUTF8(function() {
+        if (i >= str.length)
+          return null;
+        return str.charCodeAt(i++);
+      }, function(b) {
+        out.push(b);
+      });
+      return out;
+    }
+    var BASE64_CODE = "./ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789".split("");
+    var BASE64_INDEX = [
+      -1,
+      -1,
+      -1,
+      -1,
+      -1,
+      -1,
+      -1,
+      -1,
+      -1,
+      -1,
+      -1,
+      -1,
+      -1,
+      -1,
+      -1,
+      -1,
+      -1,
+      -1,
+      -1,
+      -1,
+      -1,
+      -1,
+      -1,
+      -1,
+      -1,
+      -1,
+      -1,
+      -1,
+      -1,
+      -1,
+      -1,
+      -1,
+      -1,
+      -1,
+      -1,
+      -1,
+      -1,
+      -1,
+      -1,
+      -1,
+      -1,
+      -1,
+      -1,
+      -1,
+      -1,
+      -1,
+      0,
+      1,
+      54,
+      55,
+      56,
+      57,
+      58,
+      59,
+      60,
+      61,
+      62,
+      63,
+      -1,
+      -1,
+      -1,
+      -1,
+      -1,
+      -1,
+      -1,
+      2,
+      3,
+      4,
+      5,
+      6,
+      7,
+      8,
+      9,
+      10,
+      11,
+      12,
+      13,
+      14,
+      15,
+      16,
+      17,
+      18,
+      19,
+      20,
+      21,
+      22,
+      23,
+      24,
+      25,
+      26,
+      27,
+      -1,
+      -1,
+      -1,
+      -1,
+      -1,
+      -1,
+      28,
+      29,
+      30,
+      31,
+      32,
+      33,
+      34,
+      35,
+      36,
+      37,
+      38,
+      39,
+      40,
+      41,
+      42,
+      43,
+      44,
+      45,
+      46,
+      47,
+      48,
+      49,
+      50,
+      51,
+      52,
+      53,
+      -1,
+      -1,
+      -1,
+      -1,
+      -1
+    ];
+    var stringFromCharCode = String.fromCharCode;
+    function base64_encode(b, len) {
+      var off = 0, rs = [], c1, c2;
+      if (len <= 0 || len > b.length)
+        throw Error("Illegal len: " + len);
+      while (off < len) {
+        c1 = b[off++] & 255;
+        rs.push(BASE64_CODE[c1 >> 2 & 63]);
+        c1 = (c1 & 3) << 4;
+        if (off >= len) {
+          rs.push(BASE64_CODE[c1 & 63]);
+          break;
+        }
+        c2 = b[off++] & 255;
+        c1 |= c2 >> 4 & 15;
+        rs.push(BASE64_CODE[c1 & 63]);
+        c1 = (c2 & 15) << 2;
+        if (off >= len) {
+          rs.push(BASE64_CODE[c1 & 63]);
+          break;
+        }
+        c2 = b[off++] & 255;
+        c1 |= c2 >> 6 & 3;
+        rs.push(BASE64_CODE[c1 & 63]);
+        rs.push(BASE64_CODE[c2 & 63]);
+      }
+      return rs.join("");
+    }
+    function base64_decode(s, len) {
+      var off = 0, slen = s.length, olen = 0, rs = [], c1, c2, c3, c4, o, code;
+      if (len <= 0)
+        throw Error("Illegal len: " + len);
+      while (off < slen - 1 && olen < len) {
+        code = s.charCodeAt(off++);
+        c1 = code < BASE64_INDEX.length ? BASE64_INDEX[code] : -1;
+        code = s.charCodeAt(off++);
+        c2 = code < BASE64_INDEX.length ? BASE64_INDEX[code] : -1;
+        if (c1 == -1 || c2 == -1)
+          break;
+        o = c1 << 2 >>> 0;
+        o |= (c2 & 48) >> 4;
+        rs.push(stringFromCharCode(o));
+        if (++olen >= len || off >= slen)
+          break;
+        code = s.charCodeAt(off++);
+        c3 = code < BASE64_INDEX.length ? BASE64_INDEX[code] : -1;
+        if (c3 == -1)
+          break;
+        o = (c2 & 15) << 4 >>> 0;
+        o |= (c3 & 60) >> 2;
+        rs.push(stringFromCharCode(o));
+        if (++olen >= len || off >= slen)
+          break;
+        code = s.charCodeAt(off++);
+        c4 = code < BASE64_INDEX.length ? BASE64_INDEX[code] : -1;
+        o = (c3 & 3) << 6 >>> 0;
+        o |= c4;
+        rs.push(stringFromCharCode(o));
+        ++olen;
+      }
+      var res = [];
+      for (off = 0;off < olen; off++)
+        res.push(rs[off].charCodeAt(0));
+      return res;
+    }
+    var utfx = function() {
+      var utfx2 = {};
+      utfx2.MAX_CODEPOINT = 1114111;
+      utfx2.encodeUTF8 = function(src, dst) {
+        var cp = null;
+        if (typeof src === "number")
+          cp = src, src = function() {
+            return null;
+          };
+        while (cp !== null || (cp = src()) !== null) {
+          if (cp < 128)
+            dst(cp & 127);
+          else if (cp < 2048)
+            dst(cp >> 6 & 31 | 192), dst(cp & 63 | 128);
+          else if (cp < 65536)
+            dst(cp >> 12 & 15 | 224), dst(cp >> 6 & 63 | 128), dst(cp & 63 | 128);
+          else
+            dst(cp >> 18 & 7 | 240), dst(cp >> 12 & 63 | 128), dst(cp >> 6 & 63 | 128), dst(cp & 63 | 128);
+          cp = null;
+        }
+      };
+      utfx2.decodeUTF8 = function(src, dst) {
+        var a, b, c, d, fail = function(b2) {
+          b2 = b2.slice(0, b2.indexOf(null));
+          var err = Error(b2.toString());
+          err.name = "TruncatedError";
+          err["bytes"] = b2;
+          throw err;
+        };
+        while ((a = src()) !== null) {
+          if ((a & 128) === 0)
+            dst(a);
+          else if ((a & 224) === 192)
+            (b = src()) === null && fail([a, b]), dst((a & 31) << 6 | b & 63);
+          else if ((a & 240) === 224)
+            ((b = src()) === null || (c = src()) === null) && fail([a, b, c]), dst((a & 15) << 12 | (b & 63) << 6 | c & 63);
+          else if ((a & 248) === 240)
+            ((b = src()) === null || (c = src()) === null || (d = src()) === null) && fail([a, b, c, d]), dst((a & 7) << 18 | (b & 63) << 12 | (c & 63) << 6 | d & 63);
+          else
+            throw RangeError("Illegal starting byte: " + a);
+        }
+      };
+      utfx2.UTF16toUTF8 = function(src, dst) {
+        var c1, c2 = null;
+        while (true) {
+          if ((c1 = c2 !== null ? c2 : src()) === null)
+            break;
+          if (c1 >= 55296 && c1 <= 57343) {
+            if ((c2 = src()) !== null) {
+              if (c2 >= 56320 && c2 <= 57343) {
+                dst((c1 - 55296) * 1024 + c2 - 56320 + 65536);
+                c2 = null;
+                continue;
+              }
+            }
+          }
+          dst(c1);
+        }
+        if (c2 !== null)
+          dst(c2);
+      };
+      utfx2.UTF8toUTF16 = function(src, dst) {
+        var cp = null;
+        if (typeof src === "number")
+          cp = src, src = function() {
+            return null;
+          };
+        while (cp !== null || (cp = src()) !== null) {
+          if (cp <= 65535)
+            dst(cp);
+          else
+            cp -= 65536, dst((cp >> 10) + 55296), dst(cp % 1024 + 56320);
+          cp = null;
+        }
+      };
+      utfx2.encodeUTF16toUTF8 = function(src, dst) {
+        utfx2.UTF16toUTF8(src, function(cp) {
+          utfx2.encodeUTF8(cp, dst);
+        });
+      };
+      utfx2.decodeUTF8toUTF16 = function(src, dst) {
+        utfx2.decodeUTF8(src, function(cp) {
+          utfx2.UTF8toUTF16(cp, dst);
+        });
+      };
+      utfx2.calculateCodePoint = function(cp) {
+        return cp < 128 ? 1 : cp < 2048 ? 2 : cp < 65536 ? 3 : 4;
+      };
+      utfx2.calculateUTF8 = function(src) {
+        var cp, l = 0;
+        while ((cp = src()) !== null)
+          l += utfx2.calculateCodePoint(cp);
+        return l;
+      };
+      utfx2.calculateUTF16asUTF8 = function(src) {
+        var n = 0, l = 0;
+        utfx2.UTF16toUTF8(src, function(cp) {
+          ++n;
+          l += utfx2.calculateCodePoint(cp);
+        });
+        return [n, l];
+      };
+      return utfx2;
+    }();
+    Date.now = Date.now || function() {
+      return +new Date;
+    };
+    var BCRYPT_SALT_LEN = 16;
+    var GENSALT_DEFAULT_LOG2_ROUNDS = 10;
+    var BLOWFISH_NUM_ROUNDS = 16;
+    var MAX_EXECUTION_TIME = 100;
+    var P_ORIG = [
+      608135816,
+      2242054355,
+      320440878,
+      57701188,
+      2752067618,
+      698298832,
+      137296536,
+      3964562569,
+      1160258022,
+      953160567,
+      3193202383,
+      887688300,
+      3232508343,
+      3380367581,
+      1065670069,
+      3041331479,
+      2450970073,
+      2306472731
+    ];
+    var S_ORIG = [
+      3509652390,
+      2564797868,
+      805139163,
+      3491422135,
+      3101798381,
+      1780907670,
+      3128725573,
+      4046225305,
+      614570311,
+      3012652279,
+      134345442,
+      2240740374,
+      1667834072,
+      1901547113,
+      2757295779,
+      4103290238,
+      227898511,
+      1921955416,
+      1904987480,
+      2182433518,
+      2069144605,
+      3260701109,
+      2620446009,
+      720527379,
+      3318853667,
+      677414384,
+      3393288472,
+      3101374703,
+      2390351024,
+      1614419982,
+      1822297739,
+      2954791486,
+      3608508353,
+      3174124327,
+      2024746970,
+      1432378464,
+      3864339955,
+      2857741204,
+      1464375394,
+      1676153920,
+      1439316330,
+      715854006,
+      3033291828,
+      289532110,
+      2706671279,
+      2087905683,
+      3018724369,
+      1668267050,
+      732546397,
+      1947742710,
+      3462151702,
+      2609353502,
+      2950085171,
+      1814351708,
+      2050118529,
+      680887927,
+      999245976,
+      1800124847,
+      3300911131,
+      1713906067,
+      1641548236,
+      4213287313,
+      1216130144,
+      1575780402,
+      4018429277,
+      3917837745,
+      3693486850,
+      3949271944,
+      596196993,
+      3549867205,
+      258830323,
+      2213823033,
+      772490370,
+      2760122372,
+      1774776394,
+      2652871518,
+      566650946,
+      4142492826,
+      1728879713,
+      2882767088,
+      1783734482,
+      3629395816,
+      2517608232,
+      2874225571,
+      1861159788,
+      326777828,
+      3124490320,
+      2130389656,
+      2716951837,
+      967770486,
+      1724537150,
+      2185432712,
+      2364442137,
+      1164943284,
+      2105845187,
+      998989502,
+      3765401048,
+      2244026483,
+      1075463327,
+      1455516326,
+      1322494562,
+      910128902,
+      469688178,
+      1117454909,
+      936433444,
+      3490320968,
+      3675253459,
+      1240580251,
+      122909385,
+      2157517691,
+      634681816,
+      4142456567,
+      3825094682,
+      3061402683,
+      2540495037,
+      79693498,
+      3249098678,
+      1084186820,
+      1583128258,
+      426386531,
+      1761308591,
+      1047286709,
+      322548459,
+      995290223,
+      1845252383,
+      2603652396,
+      3431023940,
+      2942221577,
+      3202600964,
+      3727903485,
+      1712269319,
+      422464435,
+      3234572375,
+      1170764815,
+      3523960633,
+      3117677531,
+      1434042557,
+      442511882,
+      3600875718,
+      1076654713,
+      1738483198,
+      4213154764,
+      2393238008,
+      3677496056,
+      1014306527,
+      4251020053,
+      793779912,
+      2902807211,
+      842905082,
+      4246964064,
+      1395751752,
+      1040244610,
+      2656851899,
+      3396308128,
+      445077038,
+      3742853595,
+      3577915638,
+      679411651,
+      2892444358,
+      2354009459,
+      1767581616,
+      3150600392,
+      3791627101,
+      3102740896,
+      284835224,
+      4246832056,
+      1258075500,
+      768725851,
+      2589189241,
+      3069724005,
+      3532540348,
+      1274779536,
+      3789419226,
+      2764799539,
+      1660621633,
+      3471099624,
+      4011903706,
+      913787905,
+      3497959166,
+      737222580,
+      2514213453,
+      2928710040,
+      3937242737,
+      1804850592,
+      3499020752,
+      2949064160,
+      2386320175,
+      2390070455,
+      2415321851,
+      4061277028,
+      2290661394,
+      2416832540,
+      1336762016,
+      1754252060,
+      3520065937,
+      3014181293,
+      791618072,
+      3188594551,
+      3933548030,
+      2332172193,
+      3852520463,
+      3043980520,
+      413987798,
+      3465142937,
+      3030929376,
+      4245938359,
+      2093235073,
+      3534596313,
+      375366246,
+      2157278981,
+      2479649556,
+      555357303,
+      3870105701,
+      2008414854,
+      3344188149,
+      4221384143,
+      3956125452,
+      2067696032,
+      3594591187,
+      2921233993,
+      2428461,
+      544322398,
+      577241275,
+      1471733935,
+      610547355,
+      4027169054,
+      1432588573,
+      1507829418,
+      2025931657,
+      3646575487,
+      545086370,
+      48609733,
+      2200306550,
+      1653985193,
+      298326376,
+      1316178497,
+      3007786442,
+      2064951626,
+      458293330,
+      2589141269,
+      3591329599,
+      3164325604,
+      727753846,
+      2179363840,
+      146436021,
+      1461446943,
+      4069977195,
+      705550613,
+      3059967265,
+      3887724982,
+      4281599278,
+      3313849956,
+      1404054877,
+      2845806497,
+      146425753,
+      1854211946,
+      1266315497,
+      3048417604,
+      3681880366,
+      3289982499,
+      2909710000,
+      1235738493,
+      2632868024,
+      2414719590,
+      3970600049,
+      1771706367,
+      1449415276,
+      3266420449,
+      422970021,
+      1963543593,
+      2690192192,
+      3826793022,
+      1062508698,
+      1531092325,
+      1804592342,
+      2583117782,
+      2714934279,
+      4024971509,
+      1294809318,
+      4028980673,
+      1289560198,
+      2221992742,
+      1669523910,
+      35572830,
+      157838143,
+      1052438473,
+      1016535060,
+      1802137761,
+      1753167236,
+      1386275462,
+      3080475397,
+      2857371447,
+      1040679964,
+      2145300060,
+      2390574316,
+      1461121720,
+      2956646967,
+      4031777805,
+      4028374788,
+      33600511,
+      2920084762,
+      1018524850,
+      629373528,
+      3691585981,
+      3515945977,
+      2091462646,
+      2486323059,
+      586499841,
+      988145025,
+      935516892,
+      3367335476,
+      2599673255,
+      2839830854,
+      265290510,
+      3972581182,
+      2759138881,
+      3795373465,
+      1005194799,
+      847297441,
+      406762289,
+      1314163512,
+      1332590856,
+      1866599683,
+      4127851711,
+      750260880,
+      613907577,
+      1450815602,
+      3165620655,
+      3734664991,
+      3650291728,
+      3012275730,
+      3704569646,
+      1427272223,
+      778793252,
+      1343938022,
+      2676280711,
+      2052605720,
+      1946737175,
+      3164576444,
+      3914038668,
+      3967478842,
+      3682934266,
+      1661551462,
+      3294938066,
+      4011595847,
+      840292616,
+      3712170807,
+      616741398,
+      312560963,
+      711312465,
+      1351876610,
+      322626781,
+      1910503582,
+      271666773,
+      2175563734,
+      1594956187,
+      70604529,
+      3617834859,
+      1007753275,
+      1495573769,
+      4069517037,
+      2549218298,
+      2663038764,
+      504708206,
+      2263041392,
+      3941167025,
+      2249088522,
+      1514023603,
+      1998579484,
+      1312622330,
+      694541497,
+      2582060303,
+      2151582166,
+      1382467621,
+      776784248,
+      2618340202,
+      3323268794,
+      2497899128,
+      2784771155,
+      503983604,
+      4076293799,
+      907881277,
+      423175695,
+      432175456,
+      1378068232,
+      4145222326,
+      3954048622,
+      3938656102,
+      3820766613,
+      2793130115,
+      2977904593,
+      26017576,
+      3274890735,
+      3194772133,
+      1700274565,
+      1756076034,
+      4006520079,
+      3677328699,
+      720338349,
+      1533947780,
+      354530856,
+      688349552,
+      3973924725,
+      1637815568,
+      332179504,
+      3949051286,
+      53804574,
+      2852348879,
+      3044236432,
+      1282449977,
+      3583942155,
+      3416972820,
+      4006381244,
+      1617046695,
+      2628476075,
+      3002303598,
+      1686838959,
+      431878346,
+      2686675385,
+      1700445008,
+      1080580658,
+      1009431731,
+      832498133,
+      3223435511,
+      2605976345,
+      2271191193,
+      2516031870,
+      1648197032,
+      4164389018,
+      2548247927,
+      300782431,
+      375919233,
+      238389289,
+      3353747414,
+      2531188641,
+      2019080857,
+      1475708069,
+      455242339,
+      2609103871,
+      448939670,
+      3451063019,
+      1395535956,
+      2413381860,
+      1841049896,
+      1491858159,
+      885456874,
+      4264095073,
+      4001119347,
+      1565136089,
+      3898914787,
+      1108368660,
+      540939232,
+      1173283510,
+      2745871338,
+      3681308437,
+      4207628240,
+      3343053890,
+      4016749493,
+      1699691293,
+      1103962373,
+      3625875870,
+      2256883143,
+      3830138730,
+      1031889488,
+      3479347698,
+      1535977030,
+      4236805024,
+      3251091107,
+      2132092099,
+      1774941330,
+      1199868427,
+      1452454533,
+      157007616,
+      2904115357,
+      342012276,
+      595725824,
+      1480756522,
+      206960106,
+      497939518,
+      591360097,
+      863170706,
+      2375253569,
+      3596610801,
+      1814182875,
+      2094937945,
+      3421402208,
+      1082520231,
+      3463918190,
+      2785509508,
+      435703966,
+      3908032597,
+      1641649973,
+      2842273706,
+      3305899714,
+      1510255612,
+      2148256476,
+      2655287854,
+      3276092548,
+      4258621189,
+      236887753,
+      3681803219,
+      274041037,
+      1734335097,
+      3815195456,
+      3317970021,
+      1899903192,
+      1026095262,
+      4050517792,
+      356393447,
+      2410691914,
+      3873677099,
+      3682840055,
+      3913112168,
+      2491498743,
+      4132185628,
+      2489919796,
+      1091903735,
+      1979897079,
+      3170134830,
+      3567386728,
+      3557303409,
+      857797738,
+      1136121015,
+      1342202287,
+      507115054,
+      2535736646,
+      337727348,
+      3213592640,
+      1301675037,
+      2528481711,
+      1895095763,
+      1721773893,
+      3216771564,
+      62756741,
+      2142006736,
+      835421444,
+      2531993523,
+      1442658625,
+      3659876326,
+      2882144922,
+      676362277,
+      1392781812,
+      170690266,
+      3921047035,
+      1759253602,
+      3611846912,
+      1745797284,
+      664899054,
+      1329594018,
+      3901205900,
+      3045908486,
+      2062866102,
+      2865634940,
+      3543621612,
+      3464012697,
+      1080764994,
+      553557557,
+      3656615353,
+      3996768171,
+      991055499,
+      499776247,
+      1265440854,
+      648242737,
+      3940784050,
+      980351604,
+      3713745714,
+      1749149687,
+      3396870395,
+      4211799374,
+      3640570775,
+      1161844396,
+      3125318951,
+      1431517754,
+      545492359,
+      4268468663,
+      3499529547,
+      1437099964,
+      2702547544,
+      3433638243,
+      2581715763,
+      2787789398,
+      1060185593,
+      1593081372,
+      2418618748,
+      4260947970,
+      69676912,
+      2159744348,
+      86519011,
+      2512459080,
+      3838209314,
+      1220612927,
+      3339683548,
+      133810670,
+      1090789135,
+      1078426020,
+      1569222167,
+      845107691,
+      3583754449,
+      4072456591,
+      1091646820,
+      628848692,
+      1613405280,
+      3757631651,
+      526609435,
+      236106946,
+      48312990,
+      2942717905,
+      3402727701,
+      1797494240,
+      859738849,
+      992217954,
+      4005476642,
+      2243076622,
+      3870952857,
+      3732016268,
+      765654824,
+      3490871365,
+      2511836413,
+      1685915746,
+      3888969200,
+      1414112111,
+      2273134842,
+      3281911079,
+      4080962846,
+      172450625,
+      2569994100,
+      980381355,
+      4109958455,
+      2819808352,
+      2716589560,
+      2568741196,
+      3681446669,
+      3329971472,
+      1835478071,
+      660984891,
+      3704678404,
+      4045999559,
+      3422617507,
+      3040415634,
+      1762651403,
+      1719377915,
+      3470491036,
+      2693910283,
+      3642056355,
+      3138596744,
+      1364962596,
+      2073328063,
+      1983633131,
+      926494387,
+      3423689081,
+      2150032023,
+      4096667949,
+      1749200295,
+      3328846651,
+      309677260,
+      2016342300,
+      1779581495,
+      3079819751,
+      111262694,
+      1274766160,
+      443224088,
+      298511866,
+      1025883608,
+      3806446537,
+      1145181785,
+      168956806,
+      3641502830,
+      3584813610,
+      1689216846,
+      3666258015,
+      3200248200,
+      1692713982,
+      2646376535,
+      4042768518,
+      1618508792,
+      1610833997,
+      3523052358,
+      4130873264,
+      2001055236,
+      3610705100,
+      2202168115,
+      4028541809,
+      2961195399,
+      1006657119,
+      2006996926,
+      3186142756,
+      1430667929,
+      3210227297,
+      1314452623,
+      4074634658,
+      4101304120,
+      2273951170,
+      1399257539,
+      3367210612,
+      3027628629,
+      1190975929,
+      2062231137,
+      2333990788,
+      2221543033,
+      2438960610,
+      1181637006,
+      548689776,
+      2362791313,
+      3372408396,
+      3104550113,
+      3145860560,
+      296247880,
+      1970579870,
+      3078560182,
+      3769228297,
+      1714227617,
+      3291629107,
+      3898220290,
+      166772364,
+      1251581989,
+      493813264,
+      448347421,
+      195405023,
+      2709975567,
+      677966185,
+      3703036547,
+      1463355134,
+      2715995803,
+      1338867538,
+      1343315457,
+      2802222074,
+      2684532164,
+      233230375,
+      2599980071,
+      2000651841,
+      3277868038,
+      1638401717,
+      4028070440,
+      3237316320,
+      6314154,
+      819756386,
+      300326615,
+      590932579,
+      1405279636,
+      3267499572,
+      3150704214,
+      2428286686,
+      3959192993,
+      3461946742,
+      1862657033,
+      1266418056,
+      963775037,
+      2089974820,
+      2263052895,
+      1917689273,
+      448879540,
+      3550394620,
+      3981727096,
+      150775221,
+      3627908307,
+      1303187396,
+      508620638,
+      2975983352,
+      2726630617,
+      1817252668,
+      1876281319,
+      1457606340,
+      908771278,
+      3720792119,
+      3617206836,
+      2455994898,
+      1729034894,
+      1080033504,
+      976866871,
+      3556439503,
+      2881648439,
+      1522871579,
+      1555064734,
+      1336096578,
+      3548522304,
+      2579274686,
+      3574697629,
+      3205460757,
+      3593280638,
+      3338716283,
+      3079412587,
+      564236357,
+      2993598910,
+      1781952180,
+      1464380207,
+      3163844217,
+      3332601554,
+      1699332808,
+      1393555694,
+      1183702653,
+      3581086237,
+      1288719814,
+      691649499,
+      2847557200,
+      2895455976,
+      3193889540,
+      2717570544,
+      1781354906,
+      1676643554,
+      2592534050,
+      3230253752,
+      1126444790,
+      2770207658,
+      2633158820,
+      2210423226,
+      2615765581,
+      2414155088,
+      3127139286,
+      673620729,
+      2805611233,
+      1269405062,
+      4015350505,
+      3341807571,
+      4149409754,
+      1057255273,
+      2012875353,
+      2162469141,
+      2276492801,
+      2601117357,
+      993977747,
+      3918593370,
+      2654263191,
+      753973209,
+      36408145,
+      2530585658,
+      25011837,
+      3520020182,
+      2088578344,
+      530523599,
+      2918365339,
+      1524020338,
+      1518925132,
+      3760827505,
+      3759777254,
+      1202760957,
+      3985898139,
+      3906192525,
+      674977740,
+      4174734889,
+      2031300136,
+      2019492241,
+      3983892565,
+      4153806404,
+      3822280332,
+      352677332,
+      2297720250,
+      60907813,
+      90501309,
+      3286998549,
+      1016092578,
+      2535922412,
+      2839152426,
+      457141659,
+      509813237,
+      4120667899,
+      652014361,
+      1966332200,
+      2975202805,
+      55981186,
+      2327461051,
+      676427537,
+      3255491064,
+      2882294119,
+      3433927263,
+      1307055953,
+      942726286,
+      933058658,
+      2468411793,
+      3933900994,
+      4215176142,
+      1361170020,
+      2001714738,
+      2830558078,
+      3274259782,
+      1222529897,
+      1679025792,
+      2729314320,
+      3714953764,
+      1770335741,
+      151462246,
+      3013232138,
+      1682292957,
+      1483529935,
+      471910574,
+      1539241949,
+      458788160,
+      3436315007,
+      1807016891,
+      3718408830,
+      978976581,
+      1043663428,
+      3165965781,
+      1927990952,
+      4200891579,
+      2372276910,
+      3208408903,
+      3533431907,
+      1412390302,
+      2931980059,
+      4132332400,
+      1947078029,
+      3881505623,
+      4168226417,
+      2941484381,
+      1077988104,
+      1320477388,
+      886195818,
+      18198404,
+      3786409000,
+      2509781533,
+      112762804,
+      3463356488,
+      1866414978,
+      891333506,
+      18488651,
+      661792760,
+      1628790961,
+      3885187036,
+      3141171499,
+      876946877,
+      2693282273,
+      1372485963,
+      791857591,
+      2686433993,
+      3759982718,
+      3167212022,
+      3472953795,
+      2716379847,
+      445679433,
+      3561995674,
+      3504004811,
+      3574258232,
+      54117162,
+      3331405415,
+      2381918588,
+      3769707343,
+      4154350007,
+      1140177722,
+      4074052095,
+      668550556,
+      3214352940,
+      367459370,
+      261225585,
+      2610173221,
+      4209349473,
+      3468074219,
+      3265815641,
+      314222801,
+      3066103646,
+      3808782860,
+      282218597,
+      3406013506,
+      3773591054,
+      379116347,
+      1285071038,
+      846784868,
+      2669647154,
+      3771962079,
+      3550491691,
+      2305946142,
+      453669953,
+      1268987020,
+      3317592352,
+      3279303384,
+      3744833421,
+      2610507566,
+      3859509063,
+      266596637,
+      3847019092,
+      517658769,
+      3462560207,
+      3443424879,
+      370717030,
+      4247526661,
+      2224018117,
+      4143653529,
+      4112773975,
+      2788324899,
+      2477274417,
+      1456262402,
+      2901442914,
+      1517677493,
+      1846949527,
+      2295493580,
+      3734397586,
+      2176403920,
+      1280348187,
+      1908823572,
+      3871786941,
+      846861322,
+      1172426758,
+      3287448474,
+      3383383037,
+      1655181056,
+      3139813346,
+      901632758,
+      1897031941,
+      2986607138,
+      3066810236,
+      3447102507,
+      1393639104,
+      373351379,
+      950779232,
+      625454576,
+      3124240540,
+      4148612726,
+      2007998917,
+      544563296,
+      2244738638,
+      2330496472,
+      2058025392,
+      1291430526,
+      424198748,
+      50039436,
+      29584100,
+      3605783033,
+      2429876329,
+      2791104160,
+      1057563949,
+      3255363231,
+      3075367218,
+      3463963227,
+      1469046755,
+      985887462
+    ];
+    var C_ORIG = [
+      1332899944,
+      1700884034,
+      1701343084,
+      1684370003,
+      1668446532,
+      1869963892
+    ];
+    function _encipher(lr, off, P, S) {
+      var n, l = lr[off], r = lr[off + 1];
+      l ^= P[0];
+      n = S[l >>> 24];
+      n += S[256 | l >> 16 & 255];
+      n ^= S[512 | l >> 8 & 255];
+      n += S[768 | l & 255];
+      r ^= n ^ P[1];
+      n = S[r >>> 24];
+      n += S[256 | r >> 16 & 255];
+      n ^= S[512 | r >> 8 & 255];
+      n += S[768 | r & 255];
+      l ^= n ^ P[2];
+      n = S[l >>> 24];
+      n += S[256 | l >> 16 & 255];
+      n ^= S[512 | l >> 8 & 255];
+      n += S[768 | l & 255];
+      r ^= n ^ P[3];
+      n = S[r >>> 24];
+      n += S[256 | r >> 16 & 255];
+      n ^= S[512 | r >> 8 & 255];
+      n += S[768 | r & 255];
+      l ^= n ^ P[4];
+      n = S[l >>> 24];
+      n += S[256 | l >> 16 & 255];
+      n ^= S[512 | l >> 8 & 255];
+      n += S[768 | l & 255];
+      r ^= n ^ P[5];
+      n = S[r >>> 24];
+      n += S[256 | r >> 16 & 255];
+      n ^= S[512 | r >> 8 & 255];
+      n += S[768 | r & 255];
+      l ^= n ^ P[6];
+      n = S[l >>> 24];
+      n += S[256 | l >> 16 & 255];
+      n ^= S[512 | l >> 8 & 255];
+      n += S[768 | l & 255];
+      r ^= n ^ P[7];
+      n = S[r >>> 24];
+      n += S[256 | r >> 16 & 255];
+      n ^= S[512 | r >> 8 & 255];
+      n += S[768 | r & 255];
+      l ^= n ^ P[8];
+      n = S[l >>> 24];
+      n += S[256 | l >> 16 & 255];
+      n ^= S[512 | l >> 8 & 255];
+      n += S[768 | l & 255];
+      r ^= n ^ P[9];
+      n = S[r >>> 24];
+      n += S[256 | r >> 16 & 255];
+      n ^= S[512 | r >> 8 & 255];
+      n += S[768 | r & 255];
+      l ^= n ^ P[10];
+      n = S[l >>> 24];
+      n += S[256 | l >> 16 & 255];
+      n ^= S[512 | l >> 8 & 255];
+      n += S[768 | l & 255];
+      r ^= n ^ P[11];
+      n = S[r >>> 24];
+      n += S[256 | r >> 16 & 255];
+      n ^= S[512 | r >> 8 & 255];
+      n += S[768 | r & 255];
+      l ^= n ^ P[12];
+      n = S[l >>> 24];
+      n += S[256 | l >> 16 & 255];
+      n ^= S[512 | l >> 8 & 255];
+      n += S[768 | l & 255];
+      r ^= n ^ P[13];
+      n = S[r >>> 24];
+      n += S[256 | r >> 16 & 255];
+      n ^= S[512 | r >> 8 & 255];
+      n += S[768 | r & 255];
+      l ^= n ^ P[14];
+      n = S[l >>> 24];
+      n += S[256 | l >> 16 & 255];
+      n ^= S[512 | l >> 8 & 255];
+      n += S[768 | l & 255];
+      r ^= n ^ P[15];
+      n = S[r >>> 24];
+      n += S[256 | r >> 16 & 255];
+      n ^= S[512 | r >> 8 & 255];
+      n += S[768 | r & 255];
+      l ^= n ^ P[16];
+      lr[off] = r ^ P[BLOWFISH_NUM_ROUNDS + 1];
+      lr[off + 1] = l;
+      return lr;
+    }
+    function _streamtoword(data, offp) {
+      for (var i = 0, word = 0;i < 4; ++i)
+        word = word << 8 | data[offp] & 255, offp = (offp + 1) % data.length;
+      return { key: word, offp };
+    }
+    function _key(key, P, S) {
+      var offset = 0, lr = [0, 0], plen = P.length, slen = S.length, sw;
+      for (var i = 0;i < plen; i++)
+        sw = _streamtoword(key, offset), offset = sw.offp, P[i] = P[i] ^ sw.key;
+      for (i = 0;i < plen; i += 2)
+        lr = _encipher(lr, 0, P, S), P[i] = lr[0], P[i + 1] = lr[1];
+      for (i = 0;i < slen; i += 2)
+        lr = _encipher(lr, 0, P, S), S[i] = lr[0], S[i + 1] = lr[1];
+    }
+    function _ekskey(data, key, P, S) {
+      var offp = 0, lr = [0, 0], plen = P.length, slen = S.length, sw;
+      for (var i = 0;i < plen; i++)
+        sw = _streamtoword(key, offp), offp = sw.offp, P[i] = P[i] ^ sw.key;
+      offp = 0;
+      for (i = 0;i < plen; i += 2)
+        sw = _streamtoword(data, offp), offp = sw.offp, lr[0] ^= sw.key, sw = _streamtoword(data, offp), offp = sw.offp, lr[1] ^= sw.key, lr = _encipher(lr, 0, P, S), P[i] = lr[0], P[i + 1] = lr[1];
+      for (i = 0;i < slen; i += 2)
+        sw = _streamtoword(data, offp), offp = sw.offp, lr[0] ^= sw.key, sw = _streamtoword(data, offp), offp = sw.offp, lr[1] ^= sw.key, lr = _encipher(lr, 0, P, S), S[i] = lr[0], S[i + 1] = lr[1];
+    }
+    function _crypt(b, salt, rounds, callback, progressCallback) {
+      var cdata = C_ORIG.slice(), clen = cdata.length, err;
+      if (rounds < 4 || rounds > 31) {
+        err = Error("Illegal number of rounds (4-31): " + rounds);
+        if (callback) {
+          nextTick(callback.bind(this, err));
+          return;
+        } else
+          throw err;
+      }
+      if (salt.length !== BCRYPT_SALT_LEN) {
+        err = Error("Illegal salt length: " + salt.length + " != " + BCRYPT_SALT_LEN);
+        if (callback) {
+          nextTick(callback.bind(this, err));
+          return;
+        } else
+          throw err;
+      }
+      rounds = 1 << rounds >>> 0;
+      var P, S, i = 0, j;
+      if (Int32Array) {
+        P = new Int32Array(P_ORIG);
+        S = new Int32Array(S_ORIG);
+      } else {
+        P = P_ORIG.slice();
+        S = S_ORIG.slice();
+      }
+      _ekskey(salt, b, P, S);
+      function next() {
+        if (progressCallback)
+          progressCallback(i / rounds);
+        if (i < rounds) {
+          var start = Date.now();
+          for (;i < rounds; ) {
+            i = i + 1;
+            _key(b, P, S);
+            _key(salt, P, S);
+            if (Date.now() - start > MAX_EXECUTION_TIME)
+              break;
+          }
+        } else {
+          for (i = 0;i < 64; i++)
+            for (j = 0;j < clen >> 1; j++)
+              _encipher(cdata, j << 1, P, S);
+          var ret = [];
+          for (i = 0;i < clen; i++)
+            ret.push((cdata[i] >> 24 & 255) >>> 0), ret.push((cdata[i] >> 16 & 255) >>> 0), ret.push((cdata[i] >> 8 & 255) >>> 0), ret.push((cdata[i] & 255) >>> 0);
+          if (callback) {
+            callback(null, ret);
+            return;
+          } else
+            return ret;
+        }
+        if (callback)
+          nextTick(next);
+      }
+      if (typeof callback !== "undefined") {
+        next();
+      } else {
+        var res;
+        while (true)
+          if (typeof (res = next()) !== "undefined")
+            return res || [];
+      }
+    }
+    function _hash(s, salt, callback, progressCallback) {
+      var err;
+      if (typeof s !== "string" || typeof salt !== "string") {
+        err = Error("Invalid string / salt: Not a string");
+        if (callback) {
+          nextTick(callback.bind(this, err));
+          return;
+        } else
+          throw err;
+      }
+      var minor, offset;
+      if (salt.charAt(0) !== "$" || salt.charAt(1) !== "2") {
+        err = Error("Invalid salt version: " + salt.substring(0, 2));
+        if (callback) {
+          nextTick(callback.bind(this, err));
+          return;
+        } else
+          throw err;
+      }
+      if (salt.charAt(2) === "$")
+        minor = String.fromCharCode(0), offset = 3;
+      else {
+        minor = salt.charAt(2);
+        if (minor !== "a" && minor !== "b" && minor !== "y" || salt.charAt(3) !== "$") {
+          err = Error("Invalid salt revision: " + salt.substring(2, 4));
+          if (callback) {
+            nextTick(callback.bind(this, err));
+            return;
+          } else
+            throw err;
+        }
+        offset = 4;
+      }
+      if (salt.charAt(offset + 2) > "$") {
+        err = Error("Missing salt rounds");
+        if (callback) {
+          nextTick(callback.bind(this, err));
+          return;
+        } else
+          throw err;
+      }
+      var r1 = parseInt(salt.substring(offset, offset + 1), 10) * 10, r2 = parseInt(salt.substring(offset + 1, offset + 2), 10), rounds = r1 + r2, real_salt = salt.substring(offset + 3, offset + 25);
+      s += minor >= "a" ? "\0" : "";
+      var passwordb = stringToBytes(s), saltb = base64_decode(real_salt, BCRYPT_SALT_LEN);
+      function finish(bytes) {
+        var res = [];
+        res.push("$2");
+        if (minor >= "a")
+          res.push(minor);
+        res.push("$");
+        if (rounds < 10)
+          res.push("0");
+        res.push(rounds.toString());
+        res.push("$");
+        res.push(base64_encode(saltb, saltb.length));
+        res.push(base64_encode(bytes, C_ORIG.length * 4 - 1));
+        return res.join("");
+      }
+      if (typeof callback == "undefined")
+        return finish(_crypt(passwordb, saltb, rounds));
+      else {
+        _crypt(passwordb, saltb, rounds, function(err2, bytes) {
+          if (err2)
+            callback(err2, null);
+          else
+            callback(null, finish(bytes));
+        }, progressCallback);
+      }
+    }
+    bcrypt.encodeBase64 = base64_encode;
+    bcrypt.decodeBase64 = base64_decode;
+    return bcrypt;
+  });
+});
+
+// src/key.ts
+var enc_utf8 = __toESM(require_enc_utf8(), 1);
+var enc_base64 = __toESM(require_enc_base64(), 1);
+import {getRandomValues} from "crypto";
+function generateAppKey() {
+  const random = getRandomValues(new Uint8Array(32));
+  const encodedWord = enc_utf8.default.parse(random.toString());
+  const key = enc_base64.default.stringify(encodedWord);
+  return `base64:${key}`;
+}
+// src/crypt.ts
+var aes = __toESM(require_aes(), 1);
+var enc_utf82 = __toESM(require_enc_utf8(), 1);
+import {env as env2} from "@stacksjs/env";
+var encrypt = function(message) {
+  const passphrase = env2.APP_KEY;
+  if (!passphrase)
+    throw new Error("APP_KEY is not defined");
+  return aes.default.encrypt(message, passphrase).toString();
+};
+var decrypt = function(encrypted) {
+  const passphrase = env2.APP_KEY;
+  if (!passphrase)
+    throw new Error("APP_KEY is not defined");
+  return aes.default.decrypt(encrypted, passphrase).toString(enc_utf82.default);
+};
+// src/hash.ts
+var import_bcryptjs = __toESM(require_bcrypt(), 1);
+
+// /Users/chrisbreuer/Code/stacks/node_modules/js-base64/base64.mjs
+var version = "3.7.5";
+var VERSION = version;
+var _hasatob = typeof atob === "function";
+var _hasbtoa = typeof btoa === "function";
+var _hasBuffer = typeof Buffer === "function";
+var _TD = typeof TextDecoder === "function" ? new TextDecoder : undefined;
+var _TE = typeof TextEncoder === "function" ? new TextEncoder : undefined;
+var b64ch = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/=";
+var b64chs = Array.prototype.slice.call(b64ch);
+var b64tab = ((a) => {
+  let tab = {};
+  a.forEach((c, i) => tab[c] = i);
+  return tab;
+})(b64chs);
+var b64re = /^(?:[A-Za-z\d+\/]{4})*?(?:[A-Za-z\d+\/]{2}(?:==)?|[A-Za-z\d+\/]{3}=?)?$/;
+var _fromCC = String.fromCharCode.bind(String);
+var _U8Afrom = typeof Uint8Array.from === "function" ? Uint8Array.from.bind(Uint8Array) : (it) => new Uint8Array(Array.prototype.slice.call(it, 0));
+var _mkUriSafe = (src) => src.replace(/=/g, "").replace(/[+\/]/g, (m0) => m0 == "+" ? "-" : "_");
+var _tidyB64 = (s) => s.replace(/[^A-Za-z0-9\+\/]/g, "");
+var btoaPolyfill = (bin) => {
+  let u32, c0, c1, c2, asc = "";
+  const pad = bin.length % 3;
+  for (let i = 0;i < bin.length; ) {
+    if ((c0 = bin.charCodeAt(i++)) > 255 || (c1 = bin.charCodeAt(i++)) > 255 || (c2 = bin.charCodeAt(i++)) > 255)
+      throw new TypeError("invalid character found");
+    u32 = c0 << 16 | c1 << 8 | c2;
+    asc += b64chs[u32 >> 18 & 63] + b64chs[u32 >> 12 & 63] + b64chs[u32 >> 6 & 63] + b64chs[u32 & 63];
+  }
+  return pad ? asc.slice(0, pad - 3) + "===".substring(pad) : asc;
+};
+var _btoa = _hasbtoa ? (bin) => btoa(bin) : _hasBuffer ? (bin) => Buffer.from(bin, "binary").toString("base64") : btoaPolyfill;
+var _fromUint8Array = _hasBuffer ? (u8a) => Buffer.from(u8a).toString("base64") : (u8a) => {
+  const maxargs = 4096;
+  let strs = [];
+  for (let i = 0, l = u8a.length;i < l; i += maxargs) {
+    strs.push(_fromCC.apply(null, u8a.subarray(i, i + maxargs)));
+  }
+  return _btoa(strs.join(""));
+};
+var fromUint8Array = (u8a, urlsafe = false) => urlsafe ? _mkUriSafe(_fromUint8Array(u8a)) : _fromUint8Array(u8a);
+var cb_utob = (c) => {
+  if (c.length < 2) {
+    var cc = c.charCodeAt(0);
+    return cc < 128 ? c : cc < 2048 ? _fromCC(192 | cc >>> 6) + _fromCC(128 | cc & 63) : _fromCC(224 | cc >>> 12 & 15) + _fromCC(128 | cc >>> 6 & 63) + _fromCC(128 | cc & 63);
+  } else {
+    var cc = 65536 + (c.charCodeAt(0) - 55296) * 1024 + (c.charCodeAt(1) - 56320);
+    return _fromCC(240 | cc >>> 18 & 7) + _fromCC(128 | cc >>> 12 & 63) + _fromCC(128 | cc >>> 6 & 63) + _fromCC(128 | cc & 63);
+  }
+};
+var re_utob = /[\uD800-\uDBFF][\uDC00-\uDFFFF]|[^\x00-\x7F]/g;
+var utob = (u) => u.replace(re_utob, cb_utob);
+var _encode = _hasBuffer ? (s) => Buffer.from(s, "utf8").toString("base64") : _TE ? (s) => _fromUint8Array(_TE.encode(s)) : (s) => _btoa(utob(s));
+var encode = (src, urlsafe = false) => urlsafe ? _mkUriSafe(_encode(src)) : _encode(src);
+var encodeURI = (src) => encode(src, true);
+var re_btou = /[\xC0-\xDF][\x80-\xBF]|[\xE0-\xEF][\x80-\xBF]{2}|[\xF0-\xF7][\x80-\xBF]{3}/g;
+var cb_btou = (cccc) => {
+  switch (cccc.length) {
+    case 4:
+      var cp = (7 & cccc.charCodeAt(0)) << 18 | (63 & cccc.charCodeAt(1)) << 12 | (63 & cccc.charCodeAt(2)) << 6 | 63 & cccc.charCodeAt(3), offset = cp - 65536;
+      return _fromCC((offset >>> 10) + 55296) + _fromCC((offset & 1023) + 56320);
+    case 3:
+      return _fromCC((15 & cccc.charCodeAt(0)) << 12 | (63 & cccc.charCodeAt(1)) << 6 | 63 & cccc.charCodeAt(2));
+    default:
+      return _fromCC((31 & cccc.charCodeAt(0)) << 6 | 63 & cccc.charCodeAt(1));
+  }
+};
+var btou = (b) => b.replace(re_btou, cb_btou);
+var atobPolyfill = (asc) => {
+  asc = asc.replace(/\s+/g, "");
+  if (!b64re.test(asc))
+    throw new TypeError("malformed base64.");
+  asc += "==".slice(2 - (asc.length & 3));
+  let u24, bin = "", r1, r2;
+  for (let i = 0;i < asc.length; ) {
+    u24 = b64tab[asc.charAt(i++)] << 18 | b64tab[asc.charAt(i++)] << 12 | (r1 = b64tab[asc.charAt(i++)]) << 6 | (r2 = b64tab[asc.charAt(i++)]);
+    bin += r1 === 64 ? _fromCC(u24 >> 16 & 255) : r2 === 64 ? _fromCC(u24 >> 16 & 255, u24 >> 8 & 255) : _fromCC(u24 >> 16 & 255, u24 >> 8 & 255, u24 & 255);
+  }
+  return bin;
+};
+var _atob = _hasatob ? (asc) => atob(_tidyB64(asc)) : _hasBuffer ? (asc) => Buffer.from(asc, "base64").toString("binary") : atobPolyfill;
+var _toUint8Array = _hasBuffer ? (a) => _U8Afrom(Buffer.from(a, "base64")) : (a) => _U8Afrom(_atob(a).split("").map((c) => c.charCodeAt(0)));
+var toUint8Array = (a) => _toUint8Array(_unURI(a));
+var _decode = _hasBuffer ? (a) => Buffer.from(a, "base64").toString("utf8") : _TD ? (a) => _TD.decode(_toUint8Array(a)) : (a) => btou(_atob(a));
+var _unURI = (a) => _tidyB64(a.replace(/[-_]/g, (m0) => m0 == "-" ? "+" : "/"));
+var decode = (src) => _decode(_unURI(src));
+var isValid = (src) => {
+  if (typeof src !== "string")
+    return false;
+  const s = src.replace(/\s+/g, "").replace(/={0,2}$/, "");
+  return !/[^\s0-9a-zA-Z\+/]/.test(s) || !/[^\s0-9a-zA-Z\-_]/.test(s);
+};
+var _noEnum = (v) => {
+  return {
+    value: v,
+    enumerable: false,
+    writable: true,
+    configurable: true
+  };
+};
+var extendString = function() {
+  const _add = (name, body) => Object.defineProperty(String.prototype, name, _noEnum(body));
+  _add("fromBase64", function() {
+    return decode(this);
+  });
+  _add("toBase64", function(urlsafe) {
+    return encode(this, urlsafe);
+  });
+  _add("toBase64URI", function() {
+    return encode(this, true);
+  });
+  _add("toBase64URL", function() {
+    return encode(this, true);
+  });
+  _add("toUint8Array", function() {
+    return toUint8Array(this);
+  });
+};
+var extendUint8Array = function() {
+  const _add = (name, body) => Object.defineProperty(Uint8Array.prototype, name, _noEnum(body));
+  _add("toBase64", function(urlsafe) {
+    return fromUint8Array(this, urlsafe);
+  });
+  _add("toBase64URI", function() {
+    return fromUint8Array(this, true);
+  });
+  _add("toBase64URL", function() {
+    return fromUint8Array(this, true);
+  });
+};
+var extendBuiltins = () => {
+  extendString();
+  extendUint8Array();
+};
+var gBase64 = {
+  version,
+  VERSION,
+  atob: _atob,
+  atobPolyfill,
+  btoa: _btoa,
+  btoaPolyfill,
+  fromBase64: decode,
+  toBase64: encode,
+  encode,
+  encodeURI,
+  encodeURL: encodeURI,
+  utob,
+  btou,
+  decode,
+  isValid,
+  fromUint8Array,
+  toUint8Array,
+  extendString,
+  extendUint8Array,
+  extendBuiltins
+};
+
+// src/hash.ts
+var md5 = __toESM(require_md5(), 1);
+import {hashing} from "@stacksjs/config";
+async function make(password, algorithm = "bcrypt") {
+  if (algorithm === "bcrypt")
+    return bcryptEncode(password);
+  if (algorithm === "base64")
+    return base64Encode(password);
+  throw new Error("Unsupported algorithm");
+}
+async function verify(password, hash, algorithm) {
+  if (algorithm === "bcrypt")
+    return bcryptVerify(password, hash);
+  if (algorithm === "base64")
+    return base64Verify(password, hash);
+  throw new Error("Unsupported algorithm");
+}
+async function bcryptEncode(password) {
+  if (!hashing.bcrypt)
+    throw new Error("Bcrypt hashing is not configured");
+  const salt = import_bcryptjs.default.genSaltSync(hashing.bcrypt.rounds);
+  const hash = await import_bcryptjs.default.hash(password, salt);
+  return hash;
+}
+async function bcryptVerify(password, hash) {
+  return await import_bcryptjs.default.compare(password, hash);
+}
+var base64Encode = function(password) {
+  return gBase64.encode(password);
+};
+var base64Verify = function(password, hash) {
+  return gBase64.decode(hash) === password;
+};
+var md5Encode = function(password) {
+  return md5.default(password);
+};
+export {
+  verify as verifyHash,
+  md5Encode,
+  make as makeHash,
+  generateAppKey,
+  encrypt,
+  decrypt,
+  bcryptVerify,
+  bcryptEncode,
+  base64Verify,
+  base64Encode
+};