@veilgroup/sdk-woro 0.1.1

package/dist/index.js

@@ -0,0 +1,2300 @@
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require : typeof Proxy !== "undefined" ? new Proxy(x, {
+  get: (a, b) => (typeof require !== "undefined" ? require : a)[b]
+}) : x)(function(x) {
+  if (typeof require !== "undefined") return require.apply(this, arguments);
+  throw Error('Dynamic require of "' + x + '" is not supported');
+});
+var __commonJS = (cb, mod) => function __require2() {
+  try {
+    return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
+  } catch (e) {
+    throw mod = 0, e;
+  }
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+
+// node_modules/crypto-js/core.js
+var require_core = __commonJS({
+  "node_modules/crypto-js/core.js"(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 crypto3;
+        if (typeof globalThis !== "undefined" && globalThis.crypto) {
+          crypto3 = globalThis.crypto;
+        }
+        if (typeof self !== "undefined" && self.crypto) {
+          crypto3 = self.crypto;
+        }
+        if (typeof globalThis !== "undefined" && globalThis.crypto) {
+          crypto3 = globalThis.crypto;
+        }
+        if (!crypto3 && typeof globalThis !== "undefined" && globalThis.msCrypto) {
+          crypto3 = globalThis.msCrypto;
+        }
+        if (!crypto3 && typeof global !== "undefined" && global.crypto) {
+          crypto3 = global.crypto;
+        }
+        if (!crypto3 && typeof __require === "function") {
+          try {
+            crypto3 = __require("crypto");
+          } catch (err) {
+          }
+        }
+        var cryptoSecureRandomInt = function() {
+          if (crypto3) {
+            if (typeof crypto3.getRandomValues === "function") {
+              try {
+                return crypto3.getRandomValues(new Uint32Array(1))[0];
+              } catch (err) {
+              }
+            }
+            if (typeof crypto3.randomBytes === "function") {
+              try {
+                return crypto3.randomBytes(4).readInt32LE();
+              } catch (err) {
+              }
+            }
+          }
+          throw new Error("Native crypto module could not be used to get secure random number.");
+        };
+        var create = Object.create || /* @__PURE__ */ (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 = /* @__PURE__ */ (function() {
+          return {
+            /**
+             * Creates a new object that inherits from this object.
+             *
+             * @param {Object} overrides Properties to copy into the new object.
+             *
+             * @return {Object} The new object.
+             *
+             * @static
+             *
+             * @example
+             *
+             *     var MyType = CryptoJS.lib.Base.extend({
+             *         field: 'value',
+             *
+             *         method: function () {
+             *         }
+             *     });
+             */
+            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;
+            },
+            /**
+             * Extends this object and runs the init method.
+             * Arguments to create() will be passed to init().
+             *
+             * @return {Object} The new object.
+             *
+             * @static
+             *
+             * @example
+             *
+             *     var instance = MyType.create();
+             */
+            create: function() {
+              var instance = this.extend();
+              instance.init.apply(instance, arguments);
+              return instance;
+            },
+            /**
+             * Initializes a newly created object.
+             * Override this method to add some logic when your objects are created.
+             *
+             * @example
+             *
+             *     var MyType = CryptoJS.lib.Base.extend({
+             *         init: function () {
+             *             // ...
+             *         }
+             *     });
+             */
+            init: function() {
+            },
+            /**
+             * Copies properties into this object.
+             *
+             * @param {Object} properties The properties to mix in.
+             *
+             * @example
+             *
+             *     MyType.mixIn({
+             *         field: 'value'
+             *     });
+             */
+            mixIn: function(properties) {
+              for (var propertyName in properties) {
+                if (properties.hasOwnProperty(propertyName)) {
+                  this[propertyName] = properties[propertyName];
+                }
+              }
+              if (properties.hasOwnProperty("toString")) {
+                this.toString = properties.toString;
+              }
+            },
+            /**
+             * Creates a copy of this object.
+             *
+             * @return {Object} The clone.
+             *
+             * @example
+             *
+             *     var clone = instance.clone();
+             */
+            clone: function() {
+              return this.init.prototype.extend(this);
+            }
+          };
+        })();
+        var WordArray = C_lib.WordArray = Base.extend({
+          /**
+           * Initializes a newly created word array.
+           *
+           * @param {Array} words (Optional) An array of 32-bit words.
+           * @param {number} sigBytes (Optional) The number of significant bytes in the words.
+           *
+           * @example
+           *
+           *     var wordArray = CryptoJS.lib.WordArray.create();
+           *     var wordArray = CryptoJS.lib.WordArray.create([0x00010203, 0x04050607]);
+           *     var wordArray = CryptoJS.lib.WordArray.create([0x00010203, 0x04050607], 6);
+           */
+          init: function(words, sigBytes) {
+            words = this.words = words || [];
+            if (sigBytes != undefined2) {
+              this.sigBytes = sigBytes;
+            } else {
+              this.sigBytes = words.length * 4;
+            }
+          },
+          /**
+           * Converts this word array to a string.
+           *
+           * @param {Encoder} encoder (Optional) The encoding strategy to use. Default: CryptoJS.enc.Hex
+           *
+           * @return {string} The stringified word array.
+           *
+           * @example
+           *
+           *     var string = wordArray + '';
+           *     var string = wordArray.toString();
+           *     var string = wordArray.toString(CryptoJS.enc.Utf8);
+           */
+          toString: function(encoder) {
+            return (encoder || Hex).stringify(this);
+          },
+          /**
+           * Concatenates a word array to this word array.
+           *
+           * @param {WordArray} wordArray The word array to append.
+           *
+           * @return {WordArray} This word array.
+           *
+           * @example
+           *
+           *     wordArray1.concat(wordArray2);
+           */
+          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;
+          },
+          /**
+           * Removes insignificant bits.
+           *
+           * @example
+           *
+           *     wordArray.clamp();
+           */
+          clamp: function() {
+            var words = this.words;
+            var sigBytes = this.sigBytes;
+            words[sigBytes >>> 2] &= 4294967295 << 32 - sigBytes % 4 * 8;
+            words.length = Math2.ceil(sigBytes / 4);
+          },
+          /**
+           * Creates a copy of this word array.
+           *
+           * @return {WordArray} The clone.
+           *
+           * @example
+           *
+           *     var clone = wordArray.clone();
+           */
+          clone: function() {
+            var clone = Base.clone.call(this);
+            clone.words = this.words.slice(0);
+            return clone;
+          },
+          /**
+           * Creates a word array filled with random bytes.
+           *
+           * @param {number} nBytes The number of random bytes to generate.
+           *
+           * @return {WordArray} The random word array.
+           *
+           * @static
+           *
+           * @example
+           *
+           *     var wordArray = CryptoJS.lib.WordArray.random(16);
+           */
+          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 = {
+          /**
+           * Converts a word array to a hex string.
+           *
+           * @param {WordArray} wordArray The word array.
+           *
+           * @return {string} The hex string.
+           *
+           * @static
+           *
+           * @example
+           *
+           *     var hexString = CryptoJS.enc.Hex.stringify(wordArray);
+           */
+          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("");
+          },
+          /**
+           * Converts a hex string to a word array.
+           *
+           * @param {string} hexStr The hex string.
+           *
+           * @return {WordArray} The word array.
+           *
+           * @static
+           *
+           * @example
+           *
+           *     var wordArray = CryptoJS.enc.Hex.parse(hexString);
+           */
+          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 = {
+          /**
+           * Converts a word array to a Latin1 string.
+           *
+           * @param {WordArray} wordArray The word array.
+           *
+           * @return {string} The Latin1 string.
+           *
+           * @static
+           *
+           * @example
+           *
+           *     var latin1String = CryptoJS.enc.Latin1.stringify(wordArray);
+           */
+          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("");
+          },
+          /**
+           * Converts a Latin1 string to a word array.
+           *
+           * @param {string} latin1Str The Latin1 string.
+           *
+           * @return {WordArray} The word array.
+           *
+           * @static
+           *
+           * @example
+           *
+           *     var wordArray = CryptoJS.enc.Latin1.parse(latin1String);
+           */
+          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 = {
+          /**
+           * Converts a word array to a UTF-8 string.
+           *
+           * @param {WordArray} wordArray The word array.
+           *
+           * @return {string} The UTF-8 string.
+           *
+           * @static
+           *
+           * @example
+           *
+           *     var utf8String = CryptoJS.enc.Utf8.stringify(wordArray);
+           */
+          stringify: function(wordArray) {
+            try {
+              return decodeURIComponent(escape(Latin1.stringify(wordArray)));
+            } catch (e) {
+              throw new Error("Malformed UTF-8 data");
+            }
+          },
+          /**
+           * Converts a UTF-8 string to a word array.
+           *
+           * @param {string} utf8Str The UTF-8 string.
+           *
+           * @return {WordArray} The word array.
+           *
+           * @static
+           *
+           * @example
+           *
+           *     var wordArray = CryptoJS.enc.Utf8.parse(utf8String);
+           */
+          parse: function(utf8Str) {
+            return Latin1.parse(unescape(encodeURIComponent(utf8Str)));
+          }
+        };
+        var BufferedBlockAlgorithm = C_lib.BufferedBlockAlgorithm = Base.extend({
+          /**
+           * Resets this block algorithm's data buffer to its initial state.
+           *
+           * @example
+           *
+           *     bufferedBlockAlgorithm.reset();
+           */
+          reset: function() {
+            this._data = new WordArray.init();
+            this._nDataBytes = 0;
+          },
+          /**
+           * Adds new data to this block algorithm's buffer.
+           *
+           * @param {WordArray|string} data The data to append. Strings are converted to a WordArray using UTF-8.
+           *
+           * @example
+           *
+           *     bufferedBlockAlgorithm._append('data');
+           *     bufferedBlockAlgorithm._append(wordArray);
+           */
+          _append: function(data) {
+            if (typeof data == "string") {
+              data = Utf8.parse(data);
+            }
+            this._data.concat(data);
+            this._nDataBytes += data.sigBytes;
+          },
+          /**
+           * Processes available data blocks.
+           *
+           * This method invokes _doProcessBlock(offset), which must be implemented by a concrete subtype.
+           *
+           * @param {boolean} doFlush Whether all blocks and partial blocks should be processed.
+           *
+           * @return {WordArray} The processed data.
+           *
+           * @example
+           *
+           *     var processedData = bufferedBlockAlgorithm._process();
+           *     var processedData = bufferedBlockAlgorithm._process(!!'flush');
+           */
+          _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);
+          },
+          /**
+           * Creates a copy of this object.
+           *
+           * @return {Object} The clone.
+           *
+           * @example
+           *
+           *     var clone = bufferedBlockAlgorithm.clone();
+           */
+          clone: function() {
+            var clone = Base.clone.call(this);
+            clone._data = this._data.clone();
+            return clone;
+          },
+          _minBufferSize: 0
+        });
+        var Hasher = C_lib.Hasher = BufferedBlockAlgorithm.extend({
+          /**
+           * Configuration options.
+           */
+          cfg: Base.extend(),
+          /**
+           * Initializes a newly created hasher.
+           *
+           * @param {Object} cfg (Optional) The configuration options to use for this hash computation.
+           *
+           * @example
+           *
+           *     var hasher = CryptoJS.algo.SHA256.create();
+           */
+          init: function(cfg) {
+            this.cfg = this.cfg.extend(cfg);
+            this.reset();
+          },
+          /**
+           * Resets this hasher to its initial state.
+           *
+           * @example
+           *
+           *     hasher.reset();
+           */
+          reset: function() {
+            BufferedBlockAlgorithm.reset.call(this);
+            this._doReset();
+          },
+          /**
+           * Updates this hasher with a message.
+           *
+           * @param {WordArray|string} messageUpdate The message to append.
+           *
+           * @return {Hasher} This hasher.
+           *
+           * @example
+           *
+           *     hasher.update('message');
+           *     hasher.update(wordArray);
+           */
+          update: function(messageUpdate) {
+            this._append(messageUpdate);
+            this._process();
+            return this;
+          },
+          /**
+           * Finalizes the hash computation.
+           * Note that the finalize operation is effectively a destructive, read-once operation.
+           *
+           * @param {WordArray|string} messageUpdate (Optional) A final message update.
+           *
+           * @return {WordArray} The hash.
+           *
+           * @example
+           *
+           *     var hash = hasher.finalize();
+           *     var hash = hasher.finalize('message');
+           *     var hash = hasher.finalize(wordArray);
+           */
+          finalize: function(messageUpdate) {
+            if (messageUpdate) {
+              this._append(messageUpdate);
+            }
+            var hash2 = this._doFinalize();
+            return hash2;
+          },
+          blockSize: 512 / 32,
+          /**
+           * Creates a shortcut function to a hasher's object interface.
+           *
+           * @param {Hasher} hasher The hasher to create a helper for.
+           *
+           * @return {Function} The shortcut function.
+           *
+           * @static
+           *
+           * @example
+           *
+           *     var SHA256 = CryptoJS.lib.Hasher._createHelper(CryptoJS.algo.SHA256);
+           */
+          _createHelper: function(hasher) {
+            return function(message, cfg) {
+              return new hasher.init(cfg).finalize(message);
+            };
+          },
+          /**
+           * Creates a shortcut function to the HMAC's object interface.
+           *
+           * @param {Hasher} hasher The hasher to use in this HMAC helper.
+           *
+           * @return {Function} The shortcut function.
+           *
+           * @static
+           *
+           * @example
+           *
+           *     var HmacSHA256 = CryptoJS.lib.Hasher._createHmacHelper(CryptoJS.algo.SHA256);
+           */
+          _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;
+    });
+  }
+});
+
+// node_modules/crypto-js/sha256.js
+var require_sha256 = __commonJS({
+  "node_modules/crypto-js/sha256.js"(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 H = [];
+        var K = [];
+        (function() {
+          function isPrime(n2) {
+            var sqrtN = Math2.sqrt(n2);
+            for (var factor = 2; factor <= sqrtN; factor++) {
+              if (!(n2 % factor)) {
+                return false;
+              }
+            }
+            return true;
+          }
+          function getFractionalBits(n2) {
+            return (n2 - (n2 | 0)) * 4294967296 | 0;
+          }
+          var n = 2;
+          var nPrime = 0;
+          while (nPrime < 64) {
+            if (isPrime(n)) {
+              if (nPrime < 8) {
+                H[nPrime] = getFractionalBits(Math2.pow(n, 1 / 2));
+              }
+              K[nPrime] = getFractionalBits(Math2.pow(n, 1 / 3));
+              nPrime++;
+            }
+            n++;
+          }
+        })();
+        var W = [];
+        var SHA256 = C_algo.SHA256 = Hasher.extend({
+          _doReset: function() {
+            this._hash = new WordArray.init(H.slice(0));
+          },
+          _doProcessBlock: function(M, offset) {
+            var H2 = this._hash.words;
+            var a = H2[0];
+            var b = H2[1];
+            var c = H2[2];
+            var d = H2[3];
+            var e = H2[4];
+            var f = H2[5];
+            var g = H2[6];
+            var h = H2[7];
+            for (var i = 0; i < 64; i++) {
+              if (i < 16) {
+                W[i] = M[offset + i] | 0;
+              } else {
+                var gamma0x = W[i - 15];
+                var gamma0 = (gamma0x << 25 | gamma0x >>> 7) ^ (gamma0x << 14 | gamma0x >>> 18) ^ gamma0x >>> 3;
+                var gamma1x = W[i - 2];
+                var gamma1 = (gamma1x << 15 | gamma1x >>> 17) ^ (gamma1x << 13 | gamma1x >>> 19) ^ gamma1x >>> 10;
+                W[i] = gamma0 + W[i - 7] + gamma1 + W[i - 16];
+              }
+              var ch = e & f ^ ~e & g;
+              var maj = a & b ^ a & c ^ b & c;
+              var sigma0 = (a << 30 | a >>> 2) ^ (a << 19 | a >>> 13) ^ (a << 10 | a >>> 22);
+              var sigma1 = (e << 26 | e >>> 6) ^ (e << 21 | e >>> 11) ^ (e << 7 | e >>> 25);
+              var t1 = h + sigma1 + ch + K[i] + W[i];
+              var t2 = sigma0 + maj;
+              h = g;
+              g = f;
+              f = e;
+              e = d + t1 | 0;
+              d = c;
+              c = b;
+              b = a;
+              a = t1 + t2 | 0;
+            }
+            H2[0] = H2[0] + a | 0;
+            H2[1] = H2[1] + b | 0;
+            H2[2] = H2[2] + c | 0;
+            H2[3] = H2[3] + d | 0;
+            H2[4] = H2[4] + e | 0;
+            H2[5] = H2[5] + f | 0;
+            H2[6] = H2[6] + g | 0;
+            H2[7] = H2[7] + h | 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] = Math2.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.SHA256 = Hasher._createHelper(SHA256);
+        C.HmacSHA256 = Hasher._createHmacHelper(SHA256);
+      })(Math);
+      return CryptoJS.SHA256;
+    });
+  }
+});
+
+// node_modules/crypto-js/hmac.js
+var require_hmac = __commonJS({
+  "node_modules/crypto-js/hmac.js"(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({
+          /**
+           * Initializes a newly created HMAC.
+           *
+           * @param {Hasher} hasher The hash algorithm to use.
+           * @param {WordArray|string} key The secret key.
+           *
+           * @example
+           *
+           *     var hmacHasher = CryptoJS.algo.HMAC.create(CryptoJS.algo.SHA256, key);
+           */
+          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();
+          },
+          /**
+           * Resets this HMAC to its initial state.
+           *
+           * @example
+           *
+           *     hmacHasher.reset();
+           */
+          reset: function() {
+            var hasher = this._hasher;
+            hasher.reset();
+            hasher.update(this._iKey);
+          },
+          /**
+           * Updates this HMAC with a message.
+           *
+           * @param {WordArray|string} messageUpdate The message to append.
+           *
+           * @return {HMAC} This HMAC instance.
+           *
+           * @example
+           *
+           *     hmacHasher.update('message');
+           *     hmacHasher.update(wordArray);
+           */
+          update: function(messageUpdate) {
+            this._hasher.update(messageUpdate);
+            return this;
+          },
+          /**
+           * Finalizes the HMAC computation.
+           * Note that the finalize operation is effectively a destructive, read-once operation.
+           *
+           * @param {WordArray|string} messageUpdate (Optional) A final message update.
+           *
+           * @return {WordArray} The HMAC.
+           *
+           * @example
+           *
+           *     var hmac = hmacHasher.finalize();
+           *     var hmac = hmacHasher.finalize('message');
+           *     var hmac = hmacHasher.finalize(wordArray);
+           */
+          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;
+          }
+        });
+      })();
+    });
+  }
+});
+
+// node_modules/crypto-js/hmac-sha256.js
+var require_hmac_sha256 = __commonJS({
+  "node_modules/crypto-js/hmac-sha256.js"(exports, module) {
+    (function(root, factory, undef) {
+      if (typeof exports === "object") {
+        module.exports = exports = factory(require_core(), require_sha256(), require_hmac());
+      } else if (typeof define === "function" && define.amd) {
+        define(["./core", "./sha256", "./hmac"], factory);
+      } else {
+        factory(root.CryptoJS);
+      }
+    })(exports, function(CryptoJS) {
+      return CryptoJS.HmacSHA256;
+    });
+  }
+});
+
+// node_modules/crypto-js/enc-base64.js
+var require_enc_base64 = __commonJS({
+  "node_modules/crypto-js/enc-base64.js"(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 = {
+          /**
+           * Converts a word array to a Base64 string.
+           *
+           * @param {WordArray} wordArray The word array.
+           *
+           * @return {string} The Base64 string.
+           *
+           * @static
+           *
+           * @example
+           *
+           *     var base64String = CryptoJS.enc.Base64.stringify(wordArray);
+           */
+          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("");
+          },
+          /**
+           * Converts a Base64 string to a word array.
+           *
+           * @param {string} base64Str The Base64 string.
+           *
+           * @return {WordArray} The word array.
+           *
+           * @static
+           *
+           * @example
+           *
+           *     var wordArray = CryptoJS.enc.Base64.parse(base64String);
+           */
+          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;
+    });
+  }
+});
+
+// node_modules/crypto-js/enc-hex.js
+var require_enc_hex = __commonJS({
+  "node_modules/crypto-js/enc-hex.js"(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.Hex;
+    });
+  }
+});
+
+// node_modules/crypto-js/enc-utf8.js
+var require_enc_utf8 = __commonJS({
+  "node_modules/crypto-js/enc-utf8.js"(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;
+    });
+  }
+});
+
+// node_modules/aws-cognito-srp-client/dist/bigInteger.js
+function BigInteger(a, b) {
+  if (a != null)
+    this.fromString(a, b);
+}
+function nbi() {
+  return new BigInteger(null);
+}
+var dbits;
+var canary = 244837814094590;
+var j_lm = (canary & 16777215) == 15715070;
+function am1(i, x, w, j, c, n) {
+  while (--n >= 0) {
+    var v = x * this[i++] + w[j] + c;
+    c = Math.floor(v / 67108864);
+    w[j++] = v & 67108863;
+  }
+  return c;
+}
+function am2(i, x, w, j, c, n) {
+  var xl = x & 32767, xh = x >> 15;
+  while (--n >= 0) {
+    var l = this[i] & 32767;
+    var h = this[i++] >> 15;
+    var m = xh * l + h * xl;
+    l = xl * l + ((m & 32767) << 15) + w[j] + (c & 1073741823);
+    c = (l >>> 30) + (m >>> 15) + xh * h + (c >>> 30);
+    w[j++] = l & 1073741823;
+  }
+  return c;
+}
+function am3(i, x, w, j, c, n) {
+  var xl = x & 16383, xh = x >> 14;
+  while (--n >= 0) {
+    var l = this[i] & 16383;
+    var h = this[i++] >> 14;
+    var m = xh * l + h * xl;
+    l = xl * l + ((m & 16383) << 14) + w[j] + c;
+    c = (l >> 28) + (m >> 14) + xh * h;
+    w[j++] = l & 268435455;
+  }
+  return c;
+}
+var inBrowser = typeof navigator !== "undefined";
+if (inBrowser && j_lm && navigator.appName == "Microsoft Internet Explorer") {
+  BigInteger.prototype.am = am2;
+  dbits = 30;
+} else if (inBrowser && j_lm && navigator.appName != "Netscape") {
+  BigInteger.prototype.am = am1;
+  dbits = 26;
+} else {
+  BigInteger.prototype.am = am3;
+  dbits = 28;
+}
+BigInteger.prototype.DB = dbits;
+BigInteger.prototype.DM = (1 << dbits) - 1;
+BigInteger.prototype.DV = 1 << dbits;
+var BI_FP = 52;
+BigInteger.prototype.FV = Math.pow(2, BI_FP);
+BigInteger.prototype.F1 = BI_FP - dbits;
+BigInteger.prototype.F2 = 2 * dbits - BI_FP;
+var BI_RM = "0123456789abcdefghijklmnopqrstuvwxyz";
+var BI_RC = [];
+var rr;
+var vv;
+rr = "0".charCodeAt(0);
+for (vv = 0; vv <= 9; ++vv)
+  BI_RC[rr++] = vv;
+rr = "a".charCodeAt(0);
+for (vv = 10; vv < 36; ++vv)
+  BI_RC[rr++] = vv;
+rr = "A".charCodeAt(0);
+for (vv = 10; vv < 36; ++vv)
+  BI_RC[rr++] = vv;
+function int2char(n) {
+  return BI_RM.charAt(n);
+}
+function intAt(s, i) {
+  var c = BI_RC[s.charCodeAt(i)];
+  return c == null ? -1 : c;
+}
+function copyTo(r) {
+  for (var i = this.t - 1; i >= 0; --i)
+    r[i] = this[i];
+  r.t = this.t;
+  r.s = this.s;
+}
+function fromInt(x) {
+  this.t = 1;
+  this.s = x < 0 ? -1 : 0;
+  if (x > 0)
+    this[0] = x;
+  else if (x < -1)
+    this[0] = x + this.DV;
+  else
+    this.t = 0;
+}
+function nbv(i) {
+  var r = nbi();
+  r.fromInt(i);
+  return r;
+}
+function fromString(s, b) {
+  var k;
+  if (b == 16)
+    k = 4;
+  else if (b == 8)
+    k = 3;
+  else if (b == 2)
+    k = 1;
+  else if (b == 32)
+    k = 5;
+  else if (b == 4)
+    k = 2;
+  else
+    throw new Error("Only radix 2, 4, 8, 16, 32 are supported");
+  this.t = 0;
+  this.s = 0;
+  var i = s.length, mi = false, sh = 0;
+  while (--i >= 0) {
+    var x = intAt(s, i);
+    if (x < 0) {
+      if (s.charAt(i) == "-")
+        mi = true;
+      continue;
+    }
+    mi = false;
+    if (sh == 0)
+      this[this.t++] = x;
+    else if (sh + k > this.DB) {
+      this[this.t - 1] |= (x & (1 << this.DB - sh) - 1) << sh;
+      this[this.t++] = x >> this.DB - sh;
+    } else
+      this[this.t - 1] |= x << sh;
+    sh += k;
+    if (sh >= this.DB)
+      sh -= this.DB;
+  }
+  this.clamp();
+  if (mi)
+    BigInteger.ZERO.subTo(this, this);
+}
+function clamp() {
+  var c = this.s & this.DM;
+  while (this.t > 0 && this[this.t - 1] == c)
+    --this.t;
+}
+function bnToString(b) {
+  if (this.s < 0)
+    return "-" + this.negate().toString(b);
+  var k;
+  if (b == 16)
+    k = 4;
+  else if (b == 8)
+    k = 3;
+  else if (b == 2)
+    k = 1;
+  else if (b == 32)
+    k = 5;
+  else if (b == 4)
+    k = 2;
+  else
+    throw new Error("Only radix 2, 4, 8, 16, 32 are supported");
+  var km = (1 << k) - 1;
+  var d, m = false, r = "", i = this.t;
+  var p = this.DB - i * this.DB % k;
+  if (i-- > 0) {
+    if (p < this.DB && (d = this[i] >> p) > 0) {
+      m = true;
+      r = int2char(d);
+    }
+    while (i >= 0) {
+      if (p < k) {
+        d = (this[i] & (1 << p) - 1) << k - p;
+        d |= this[--i] >> (p += this.DB - k);
+      } else {
+        d = this[i] >> (p -= k) & km;
+        if (p <= 0) {
+          p += this.DB;
+          --i;
+        }
+      }
+      if (d > 0)
+        m = true;
+      if (m)
+        r += int2char(d);
+    }
+  }
+  return m ? r : "0";
+}
+function bnNegate() {
+  var r = nbi();
+  BigInteger.ZERO.subTo(this, r);
+  return r;
+}
+function bnAbs() {
+  return this.s < 0 ? this.negate() : this;
+}
+function bnCompareTo(a) {
+  var r = this.s - a.s;
+  if (r != 0)
+    return r;
+  var i = this.t;
+  r = i - a.t;
+  if (r != 0)
+    return this.s < 0 ? -r : r;
+  while (--i >= 0)
+    if ((r = this[i] - a[i]) != 0)
+      return r;
+  return 0;
+}
+function nbits(x) {
+  var r = 1, t;
+  if ((t = x >>> 16) != 0) {
+    x = t;
+    r += 16;
+  }
+  if ((t = x >> 8) != 0) {
+    x = t;
+    r += 8;
+  }
+  if ((t = x >> 4) != 0) {
+    x = t;
+    r += 4;
+  }
+  if ((t = x >> 2) != 0) {
+    x = t;
+    r += 2;
+  }
+  if ((t = x >> 1) != 0) {
+    x = t;
+    r += 1;
+  }
+  return r;
+}
+function bnBitLength() {
+  if (this.t <= 0)
+    return 0;
+  return this.DB * (this.t - 1) + nbits(this[this.t - 1] ^ this.s & this.DM);
+}
+function dlShiftTo(n, r) {
+  var i;
+  for (i = this.t - 1; i >= 0; --i)
+    r[i + n] = this[i];
+  for (i = n - 1; i >= 0; --i)
+    r[i] = 0;
+  r.t = this.t + n;
+  r.s = this.s;
+}
+function drShiftTo(n, r) {
+  for (var i = n; i < this.t; ++i)
+    r[i - n] = this[i];
+  r.t = Math.max(this.t - n, 0);
+  r.s = this.s;
+}
+function lShiftTo(n, r) {
+  var bs = n % this.DB;
+  var cbs = this.DB - bs;
+  var bm = (1 << cbs) - 1;
+  var ds = Math.floor(n / this.DB);
+  var c = this.s << bs & this.DM, i;
+  for (i = this.t - 1; i >= 0; --i) {
+    r[i + ds + 1] = this[i] >> cbs | c;
+    c = (this[i] & bm) << bs;
+  }
+  for (i = ds - 1; i >= 0; --i)
+    r[i] = 0;
+  r[ds] = c;
+  r.t = this.t + ds + 1;
+  r.s = this.s;
+  r.clamp();
+}
+function rShiftTo(n, r) {
+  r.s = this.s;
+  var ds = Math.floor(n / this.DB);
+  if (ds >= this.t) {
+    r.t = 0;
+    return;
+  }
+  var bs = n % this.DB;
+  var cbs = this.DB - bs;
+  var bm = (1 << bs) - 1;
+  r[0] = this[ds] >> bs;
+  for (var i = ds + 1; i < this.t; ++i) {
+    r[i - ds - 1] |= (this[i] & bm) << cbs;
+    r[i - ds] = this[i] >> bs;
+  }
+  if (bs > 0)
+    r[this.t - ds - 1] |= (this.s & bm) << cbs;
+  r.t = this.t - ds;
+  r.clamp();
+}
+function subTo(a, r) {
+  var i = 0, c = 0;
+  var m = Math.min(a.t, this.t);
+  while (i < m) {
+    c += this[i] - a[i];
+    r[i++] = c & this.DM;
+    c >>= this.DB;
+  }
+  if (a.t < this.t) {
+    c -= a.s;
+    while (i < this.t) {
+      c += this[i];
+      r[i++] = c & this.DM;
+      c >>= this.DB;
+    }
+    c += this.s;
+  } else {
+    c += this.s;
+    while (i < a.t) {
+      c -= a[i];
+      r[i++] = c & this.DM;
+      c >>= this.DB;
+    }
+    c -= a.s;
+  }
+  r.s = c < 0 ? -1 : 0;
+  if (c < -1)
+    r[i++] = this.DV + c;
+  else if (c > 0)
+    r[i++] = c;
+  r.t = i;
+  r.clamp();
+}
+function multiplyTo(a, r) {
+  var x = this.abs(), y = a.abs();
+  var i = x.t;
+  r.t = i + y.t;
+  while (--i >= 0)
+    r[i] = 0;
+  for (i = 0; i < y.t; ++i)
+    r[i + x.t] = x.am(0, y[i], r, i, 0, x.t);
+  r.s = 0;
+  r.clamp();
+  if (this.s != a.s)
+    BigInteger.ZERO.subTo(r, r);
+}
+function squareTo(r) {
+  var x = this.abs();
+  var i = r.t = 2 * x.t;
+  while (--i >= 0)
+    r[i] = 0;
+  for (i = 0; i < x.t - 1; ++i) {
+    var c = x.am(i, x[i], r, 2 * i, 0, 1);
+    if ((r[i + x.t] += x.am(i + 1, 2 * x[i], r, 2 * i + 1, c, x.t - i - 1)) >= x.DV) {
+      r[i + x.t] -= x.DV;
+      r[i + x.t + 1] = 1;
+    }
+  }
+  if (r.t > 0)
+    r[r.t - 1] += x.am(i, x[i], r, 2 * i, 0, 1);
+  r.s = 0;
+  r.clamp();
+}
+function divRemTo(m, q, r) {
+  var pm = m.abs();
+  if (pm.t <= 0)
+    return;
+  var pt = this.abs();
+  if (pt.t < pm.t) {
+    if (q != null)
+      q.fromInt(0);
+    if (r != null)
+      this.copyTo(r);
+    return;
+  }
+  if (r == null)
+    r = nbi();
+  var y = nbi(), ts = this.s, ms = m.s;
+  var nsh = this.DB - nbits(pm[pm.t - 1]);
+  if (nsh > 0) {
+    pm.lShiftTo(nsh, y);
+    pt.lShiftTo(nsh, r);
+  } else {
+    pm.copyTo(y);
+    pt.copyTo(r);
+  }
+  var ys = y.t;
+  var y0 = y[ys - 1];
+  if (y0 == 0)
+    return;
+  var yt = y0 * (1 << this.F1) + (ys > 1 ? y[ys - 2] >> this.F2 : 0);
+  var d1 = this.FV / yt, d2 = (1 << this.F1) / yt, e = 1 << this.F2;
+  var i = r.t, j = i - ys;
+  var t = q == null ? nbi() : q;
+  y.dlShiftTo(j, t);
+  if (r.compareTo(t) >= 0) {
+    r[r.t++] = 1;
+    r.subTo(t, r);
+  }
+  BigInteger.ONE.dlShiftTo(ys, t);
+  t.subTo(y, y);
+  while (y.t < ys)
+    y[y.t++] = 0;
+  while (--j >= 0) {
+    var qd = r[--i] == y0 ? this.DM : Math.floor(r[i] * d1 + (r[i - 1] + e) * d2);
+    if ((r[i] += y.am(0, qd, r, j, 0, ys)) < qd) {
+      y.dlShiftTo(j, t);
+      r.subTo(t, r);
+      while (r[i] < --qd)
+        r.subTo(t, r);
+    }
+  }
+  if (q != null) {
+    r.drShiftTo(ys, q);
+    if (ts != ms)
+      BigInteger.ZERO.subTo(q, q);
+  }
+  r.t = ys;
+  r.clamp();
+  if (nsh > 0)
+    r.rShiftTo(nsh, r);
+  if (ts < 0)
+    BigInteger.ZERO.subTo(r, r);
+}
+function bnMod(a) {
+  var r = nbi();
+  this.abs().divRemTo(a, null, r);
+  if (this.s < 0 && r.compareTo(BigInteger.ZERO) > 0)
+    a.subTo(r, r);
+  return r;
+}
+function invDigit() {
+  if (this.t < 1)
+    return 0;
+  var x = this[0];
+  if ((x & 1) == 0)
+    return 0;
+  var y = x & 3;
+  y = y * (2 - (x & 15) * y) & 15;
+  y = y * (2 - (x & 255) * y) & 255;
+  y = y * (2 - ((x & 65535) * y & 65535)) & 65535;
+  y = y * (2 - x * y % this.DV) % this.DV;
+  return y > 0 ? this.DV - y : -y;
+}
+function bnEquals(a) {
+  return this.compareTo(a) == 0;
+}
+function addTo(a, r) {
+  var i = 0, c = 0;
+  var m = Math.min(a.t, this.t);
+  while (i < m) {
+    c += this[i] + a[i];
+    r[i++] = c & this.DM;
+    c >>= this.DB;
+  }
+  if (a.t < this.t) {
+    c += a.s;
+    while (i < this.t) {
+      c += this[i];
+      r[i++] = c & this.DM;
+      c >>= this.DB;
+    }
+    c += this.s;
+  } else {
+    c += this.s;
+    while (i < a.t) {
+      c += a[i];
+      r[i++] = c & this.DM;
+      c >>= this.DB;
+    }
+    c += a.s;
+  }
+  r.s = c < 0 ? -1 : 0;
+  if (c > 0)
+    r[i++] = c;
+  else if (c < -1)
+    r[i++] = this.DV + c;
+  r.t = i;
+  r.clamp();
+}
+function bnAdd(a) {
+  var r = nbi();
+  this.addTo(a, r);
+  return r;
+}
+function bnSubtract(a) {
+  var r = nbi();
+  this.subTo(a, r);
+  return r;
+}
+function bnMultiply(a) {
+  var r = nbi();
+  this.multiplyTo(a, r);
+  return r;
+}
+function bnDivide(a) {
+  var r = nbi();
+  this.divRemTo(a, r, null);
+  return r;
+}
+function Montgomery(m) {
+  this.m = m;
+  this.mp = m.invDigit();
+  this.mpl = this.mp & 32767;
+  this.mph = this.mp >> 15;
+  this.um = (1 << m.DB - 15) - 1;
+  this.mt2 = 2 * m.t;
+}
+function montConvert(x) {
+  var r = nbi();
+  x.abs().dlShiftTo(this.m.t, r);
+  r.divRemTo(this.m, null, r);
+  if (x.s < 0 && r.compareTo(BigInteger.ZERO) > 0)
+    this.m.subTo(r, r);
+  return r;
+}
+function montRevert(x) {
+  var r = nbi();
+  x.copyTo(r);
+  this.reduce(r);
+  return r;
+}
+function montReduce(x) {
+  while (x.t <= this.mt2)
+    x[x.t++] = 0;
+  for (var i = 0; i < this.m.t; ++i) {
+    var j = x[i] & 32767;
+    var u0 = j * this.mpl + ((j * this.mph + (x[i] >> 15) * this.mpl & this.um) << 15) & x.DM;
+    j = i + this.m.t;
+    x[j] += this.m.am(0, u0, x, i, 0, this.m.t);
+    while (x[j] >= x.DV) {
+      x[j] -= x.DV;
+      x[++j]++;
+    }
+  }
+  x.clamp();
+  x.drShiftTo(this.m.t, x);
+  if (x.compareTo(this.m) >= 0)
+    x.subTo(this.m, x);
+}
+function montSqrTo(x, r) {
+  x.squareTo(r);
+  this.reduce(r);
+}
+function montMulTo(x, y, r) {
+  x.multiplyTo(y, r);
+  this.reduce(r);
+}
+Montgomery.prototype.convert = montConvert;
+Montgomery.prototype.revert = montRevert;
+Montgomery.prototype.reduce = montReduce;
+Montgomery.prototype.mulTo = montMulTo;
+Montgomery.prototype.sqrTo = montSqrTo;
+function bnModPow(e, m, callback) {
+  var i = e.bitLength(), r = nbv(1);
+  var z = new Montgomery(m);
+  var k;
+  if (i <= 0)
+    return r;
+  else if (i < 18)
+    k = 1;
+  else if (i < 48)
+    k = 3;
+  else if (i < 144)
+    k = 4;
+  else if (i < 768)
+    k = 5;
+  else
+    k = 6;
+  var g = [], k1 = k - 1, km = (1 << k) - 1;
+  var n = 3;
+  g[1] = z.convert(this);
+  if (k > 1) {
+    var g2 = nbi();
+    z.sqrTo(g[1], g2);
+    while (n <= km) {
+      g[n] = nbi();
+      z.mulTo(g2, g[n - 2], g[n]);
+      n += 2;
+    }
+  }
+  var j = e.t - 1, w, is1 = true, r2 = nbi(), t;
+  i = nbits(e[j]) - 1;
+  while (j >= 0) {
+    if (i >= k1)
+      w = e[j] >> i - k1 & km;
+    else {
+      w = (e[j] & (1 << i + 1) - 1) << k1 - i;
+      if (j > 0)
+        w |= e[j - 1] >> this.DB + i - k1;
+    }
+    n = k;
+    while ((w & 1) == 0) {
+      w >>= 1;
+      --n;
+    }
+    if ((i -= n) < 0) {
+      i += this.DB;
+      --j;
+    }
+    if (is1) {
+      g[w].copyTo(r);
+      is1 = false;
+    } else {
+      while (n > 1) {
+        z.sqrTo(r, r2);
+        z.sqrTo(r2, r);
+        n -= 2;
+      }
+      if (n > 0)
+        z.sqrTo(r, r2);
+      else {
+        t = r;
+        r = r2;
+        r2 = t;
+      }
+      z.mulTo(r2, g[w], r);
+    }
+    while (j >= 0 && (e[j] & 1 << i) == 0) {
+      z.sqrTo(r, r2);
+      t = r;
+      r = r2;
+      r2 = t;
+      if (--i < 0) {
+        i = this.DB - 1;
+        --j;
+      }
+    }
+  }
+  var result = z.revert(r);
+  if (callback) {
+    callback(null, result);
+  }
+  return result;
+}
+function bnIsZero() {
+  return this.compareTo(BigInteger.ZERO) == 0;
+}
+BigInteger.prototype.copyTo = copyTo;
+BigInteger.prototype.fromInt = fromInt;
+BigInteger.prototype.fromString = fromString;
+BigInteger.prototype.clamp = clamp;
+BigInteger.prototype.dlShiftTo = dlShiftTo;
+BigInteger.prototype.drShiftTo = drShiftTo;
+BigInteger.prototype.lShiftTo = lShiftTo;
+BigInteger.prototype.rShiftTo = rShiftTo;
+BigInteger.prototype.subTo = subTo;
+BigInteger.prototype.multiplyTo = multiplyTo;
+BigInteger.prototype.squareTo = squareTo;
+BigInteger.prototype.divRemTo = divRemTo;
+BigInteger.prototype.invDigit = invDigit;
+BigInteger.prototype.addTo = addTo;
+BigInteger.prototype.toString = bnToString;
+BigInteger.prototype.abs = bnAbs;
+BigInteger.prototype.negate = bnNegate;
+BigInteger.prototype.compareTo = bnCompareTo;
+BigInteger.prototype.bitLength = bnBitLength;
+BigInteger.prototype.mod = bnMod;
+BigInteger.prototype.equals = bnEquals;
+BigInteger.prototype.add = bnAdd;
+BigInteger.prototype.subtract = bnSubtract;
+BigInteger.prototype.multiply = bnMultiply;
+BigInteger.prototype.divide = bnDivide;
+BigInteger.prototype.modPow = bnModPow;
+BigInteger.prototype.isZero = bnIsZero;
+BigInteger.ZERO = nbv(0);
+BigInteger.ONE = nbv(1);
+var bigInt = function(str, radix) {
+  return new BigInteger(str, radix);
+};
+var bigInteger_default = bigInt;
+
+// node_modules/aws-cognito-srp-client/dist/cryptoUtils.js
+var import_sha256 = __toESM(require_sha256());
+var import_hmac_sha256 = __toESM(require_hmac_sha256());
+var import_enc_base64 = __toESM(require_enc_base64());
+var import_enc_hex = __toESM(require_enc_hex());
+var import_enc_utf8 = __toESM(require_enc_utf8());
+var polyFillCrypto = function() {
+  if (typeof globalThis !== "undefined" && globalThis.crypto) {
+    return globalThis.crypto;
+  }
+  if (typeof globalThis !== "undefined" && globalThis.msCrypto) {
+    return globalThis.msCrypto;
+  }
+  if (typeof __require === "function") {
+    return __require("crypto").webcrypto;
+  }
+};
+var crypto2 = polyFillCrypto();
+var padHex = function(bigInteger) {
+  var hashStr = bigInteger.toString(16);
+  if (hashStr.length % 2 === 1) {
+    hashStr = "0".concat(hashStr);
+  } else if ("89ABCDEFabcdef".indexOf(hashStr[0]) !== -1) {
+    hashStr = "00".concat(hashStr);
+  }
+  return hashStr;
+};
+var hash = function(str) {
+  var hashHex = (0, import_sha256.default)(str).toString();
+  return new Array(64 - hashHex.length).join("0") + hashHex;
+};
+var hexHash = function(hexStr) {
+  return hash(import_enc_hex.default.parse(hexStr));
+};
+var getRandomIntFromNativeCrypto = function() {
+  if (crypto2) {
+    if (typeof crypto2.getRandomValues === "function") {
+      try {
+        return crypto2.getRandomValues(new Uint32Array(1))[0];
+      } catch (err) {
+      }
+    }
+    if (typeof crypto2.randomBytes === "function") {
+      try {
+        return crypto2.randomBytes(4).readInt32LE();
+      } catch (err) {
+      }
+    }
+  }
+  throw new Error("Native crypto module could not be used to get secure random number.");
+};
+var randomValue = function(nBytes) {
+  var words = [];
+  for (var i = 0; i < nBytes; i += 4) {
+    words.push(getRandomIntFromNativeCrypto());
+  }
+  var hexChars = [];
+  for (var i = 0; i < nBytes; i++) {
+    var bite = words[i >>> 2] >>> 24 - i % 4 * 8 & 255;
+    hexChars.push((bite >>> 4).toString(16));
+    hexChars.push((bite & 15).toString(16));
+  }
+  var hexRandom = hexChars.join("");
+  var randomInt = bigInteger_default(hexRandom, 16);
+  return randomInt;
+};
+var computehkdf = function(ikm, salt) {
+  var infoBits = import_enc_utf8.default.parse("Caldera Derived Key").concat(import_enc_utf8.default.parse(String.fromCharCode(1)));
+  var prk = (0, import_hmac_sha256.default)(ikm, salt);
+  var hmac = (0, import_hmac_sha256.default)(infoBits, prk);
+  return import_enc_hex.default.parse(hmac.toString().slice(0, 32));
+};
+var computeSignature = function(message, key) {
+  return import_enc_base64.default.stringify((0, import_hmac_sha256.default)(message, key));
+};
+
+// node_modules/aws-cognito-srp-client/dist/index.js
+var import_enc_base642 = __toESM(require_enc_base64());
+var import_enc_hex2 = __toESM(require_enc_hex());
+var import_enc_utf82 = __toESM(require_enc_utf8());
+var initN = "FFFFFFFFFFFFFFFFC90FDAA22168C234C4C6628B80DC1CD129024E088A67CC74020BBEA63B139B22514A08798E3404DDEF9519B3CD3A431B302B0A6DF25F14374FE1356D6D51C245E485B576625E7EC6F44C42E9A637ED6B0BFF5CB6F406B7EDEE386BFB5A899FA5AE9F24117C4B1FE649286651ECE45B3DC2007CB8A163BF0598DA48361C55D39A69163FA8FD24CF5F83655D23DCA3AD961C62F356208552BB9ED529077096966D670C354E4ABC9804F1746C08CA18217C32905E462E36CE3BE39E772C180E86039B2783A2EC07A28FB5C55DF06F4C52C9DE2BCBF6955817183995497CEA956AE515D2261898FA051015728E5A8AAAC42DAD33170D04507A33A85521ABDF1CBA64ECFB850458DBEF0A8AEA71575D060C7DB3970F85A6E1E4C7ABF5AE8CDB0933D71E8C94E04A25619DCEE3D2261AD2EE6BF12FFA06D98A0864D87602733EC86A64521F2B18177B200CBBE117577A615D6C770988C0BAD946E208E24FA074E5AB3143DB5BFCE0FD108E4B82D120A93AD2CAFFFFFFFFFFFFFFFF";
+var Srp = (
+  /** @class */
+  (function() {
+    function Srp2(poolId) {
+      this.g = bigInteger_default("2", 16);
+      this.N = bigInteger_default(initN, 16);
+      this.k = bigInteger_default(hexHash(padHex(this.N) + padHex(this.g)), 16);
+      this.poolName = poolId.split("_")[1];
+    }
+    Srp2.prototype.getA = function() {
+      this.a = randomValue(128);
+      this.A = this.g.modPow(this.a, this.N);
+      if (this.A.mod(this.N).isZero()) {
+        new Error("Illegal paramater. A mod N cannot be 0.");
+      }
+      return this.A.toString(16);
+    };
+    Srp2.prototype.getSignature = function(username, strB, strSalt, secretBlock, password) {
+      var B = bigInteger_default(strB, 16);
+      if (B.mod(this.N).isZero()) {
+        new Error("Illegal paramater. B mod N cannot be 0.");
+      }
+      var salt = bigInteger_default(strSalt, 16);
+      var U = bigInteger_default(hexHash(padHex(this.A) + padHex(B)), 16);
+      if (U.isZero()) {
+        throw new Error("U cannot be zero.");
+      }
+      var usernamePasswordHash = hash(import_enc_utf82.default.parse(this.poolName + username + ":" + password));
+      var x = bigInteger_default(hexHash(padHex(salt) + usernamePasswordHash), 16);
+      var S = B.subtract(this.k.multiply(this.g.modPow(x, this.N))).modPow(this.a.add(U.multiply(x)), this.N);
+      var paddedS = padHex(S);
+      var hkdf = computehkdf(import_enc_hex2.default.parse(paddedS), import_enc_hex2.default.parse(padHex(U)));
+      var timestamp = getNowString();
+      var message = import_enc_utf82.default.parse(this.poolName).concat(import_enc_utf82.default.parse(username)).concat(import_enc_base642.default.parse(secretBlock)).concat(import_enc_utf82.default.parse(timestamp));
+      var signature = computeSignature(message, hkdf);
+      return { timestamp, signature };
+    };
+    return Srp2;
+  })()
+);
+var dist_default = Srp;
+var getNowString = function() {
+  var now = /* @__PURE__ */ new Date();
+  var monthNames = [
+    "Jan",
+    "Feb",
+    "Mar",
+    "Apr",
+    "May",
+    "Jun",
+    "Jul",
+    "Aug",
+    "Sep",
+    "Oct",
+    "Nov",
+    "Dec"
+  ];
+  var weekNames = ["Sun", "Mon", "Tue", "Wed", "Thu", "Fri", "Sat"];
+  var weekDay = weekNames[now.getUTCDay()];
+  var month = monthNames[now.getUTCMonth()];
+  var day = now.getUTCDate();
+  var hours = now.getUTCHours();
+  if (hours < 10) {
+    hours = "0".concat(hours);
+  }
+  var minutes = now.getUTCMinutes();
+  if (minutes < 10) {
+    minutes = "0".concat(minutes);
+  }
+  var seconds = now.getUTCSeconds();
+  if (seconds < 10) {
+    seconds = "0".concat(seconds);
+  }
+  var year = now.getUTCFullYear();
+  var dateNow = "".concat(weekDay, " ").concat(month, " ").concat(day, " ").concat(hours, ":").concat(minutes, ":").concat(seconds, " UTC ").concat(year);
+  return dateNow;
+};
+
+// src/errors.ts
+var WoroApiError = class extends Error {
+  constructor(status, message, code) {
+    super(message);
+    this.status = status;
+    this.code = code;
+    this.name = "WoroApiError";
+  }
+  status;
+  code;
+};
+var WoroAuthError = class extends Error {
+  constructor(message, code) {
+    super(message);
+    this.code = code;
+    this.name = "WoroAuthError";
+  }
+  code;
+};
+var WoroPayloadError = class extends Error {
+  constructor(message, rawPayload) {
+    super(message);
+    this.rawPayload = rawPayload;
+    this.name = "WoroPayloadError";
+  }
+  rawPayload;
+};
+
+// src/payload.ts
+var WORO_MAX_PAYLOAD_BYTES = 1048576;
+var WORO_ENVELOPE_CONTENT_TYPE = "application/vnd.woro.sdk-payload";
+var MAGIC = new Uint8Array([87, 79, 82, 79]);
+var VERSION = 1;
+var FLAG_COMPRESSED = 1;
+var FLAG_ENCRYPTED = 2;
+var NONCE_BYTES = 12;
+var TAG_BYTES = 16;
+async function toBytes(input) {
+  if (typeof input === "string") return new TextEncoder().encode(input);
+  if (input instanceof Blob) return new Uint8Array(await input.arrayBuffer());
+  if (input instanceof ArrayBuffer) return new Uint8Array(input.slice(0));
+  if (ArrayBuffer.isView(input)) {
+    return new Uint8Array(input.buffer.slice(input.byteOffset, input.byteOffset + input.byteLength));
+  }
+  throw new TypeError("Payload must be a string, Blob, ArrayBuffer, or typed array.");
+}
+async function encodePayload(input, options = {}) {
+  const original = await toBytes(input);
+  if (original.byteLength > WORO_MAX_PAYLOAD_BYTES) {
+    throw new WoroPayloadError(`Original payload exceeds WORO's ${WORO_MAX_PAYLOAD_BYTES}-byte limit.`);
+  }
+  const contentType = options.contentType ?? (input instanceof Blob && input.type ? input.type : typeof input === "string" ? "text/plain; charset=utf-8" : "application/octet-stream");
+  const encryptionKey = options.encryptionKey;
+  if (encryptionKey && encryptionKey.byteLength !== 32) {
+    throw new WoroPayloadError("AES-256-GCM requires a 32-byte encryption key.");
+  }
+  let data = original;
+  let compressed = false;
+  if (options.compress !== false && original.byteLength > 0) {
+    const candidate = await gzip(original);
+    const envelopeBytes = 7 + 2 + new TextEncoder().encode(contentType).byteLength;
+    const savesBytes = encryptionKey ? candidate.byteLength < original.byteLength : candidate.byteLength + envelopeBytes < original.byteLength;
+    if (savesBytes) {
+      data = candidate;
+      compressed = true;
+    }
+  }
+  if (!compressed && !encryptionKey && contentType.split(";", 1)[0]?.trim().toLowerCase() !== WORO_ENVELOPE_CONTENT_TYPE) {
+    return { bytes: original, contentType };
+  }
+  const mediaType = new TextEncoder().encode(contentType);
+  if (mediaType.byteLength > 65535) throw new WoroPayloadError("Content-Type is too long to encode.");
+  const cleartext = new Uint8Array(2 + mediaType.byteLength + data.byteLength);
+  new DataView(cleartext.buffer).setUint16(0, mediaType.byteLength, false);
+  cleartext.set(mediaType, 2);
+  cleartext.set(data, 2 + mediaType.byteLength);
+  const flags = (compressed ? FLAG_COMPRESSED : 0) | (encryptionKey ? FLAG_ENCRYPTED : 0);
+  const nonce = encryptionKey ? crypto.getRandomValues(new Uint8Array(NONCE_BYTES)) : new Uint8Array(0);
+  const header = new Uint8Array(7 + nonce.byteLength);
+  header.set(MAGIC, 0);
+  header[4] = VERSION;
+  header[5] = flags;
+  header[6] = nonce.byteLength;
+  header.set(nonce, 7);
+  const body = encryptionKey ? new Uint8Array(await crypto.subtle.encrypt(
+    { name: "AES-GCM", iv: asArrayBuffer(nonce), additionalData: asArrayBuffer(header), tagLength: TAG_BYTES * 8 },
+    await importAesKey(encryptionKey, ["encrypt"]),
+    asArrayBuffer(cleartext)
+  )) : cleartext;
+  const bytes = new Uint8Array(header.byteLength + body.byteLength);
+  bytes.set(header, 0);
+  bytes.set(body, header.byteLength);
+  return { bytes, contentType: WORO_ENVELOPE_CONTENT_TYPE };
+}
+async function decodePayload(bytes, responseContentType, encryptionKey) {
+  if (responseContentType.split(";", 1)[0]?.trim().toLowerCase() !== WORO_ENVELOPE_CONTENT_TYPE) {
+    return { bytes, contentType: responseContentType || "application/octet-stream" };
+  }
+  if (bytes.byteLength < 9 || !MAGIC.every((byte, index) => bytes[index] === byte)) {
+    throw new WoroPayloadError("The WORO package payload envelope is invalid.");
+  }
+  const version = bytes[4];
+  const flags = bytes[5];
+  const nonceLength = bytes[6];
+  if (version !== VERSION || (flags & ~(FLAG_COMPRESSED | FLAG_ENCRYPTED)) !== 0) {
+    throw new WoroPayloadError("The WORO package payload uses an unsupported envelope version or option.");
+  }
+  const encrypted = (flags & FLAG_ENCRYPTED) !== 0;
+  const compressed = (flags & FLAG_COMPRESSED) !== 0;
+  if (encrypted && nonceLength !== NONCE_BYTES || !encrypted && nonceLength !== 0) {
+    throw new WoroPayloadError("The WORO package payload envelope has an invalid nonce.");
+  }
+  const headerLength = 7 + nonceLength;
+  if (bytes.byteLength < headerLength + (encrypted ? TAG_BYTES : 2)) {
+    throw new WoroPayloadError("The WORO package payload envelope is truncated.");
+  }
+  let cleartext = bytes.subarray(headerLength);
+  if (encrypted) {
+    if (!encryptionKey) throw new WoroPayloadError("This payload is encrypted; provide its 32-byte encryption key.", bytes.slice());
+    if (encryptionKey.byteLength !== 32) throw new WoroPayloadError("AES-256-GCM requires a 32-byte encryption key.");
+    try {
+      cleartext = new Uint8Array(await crypto.subtle.decrypt(
+        { name: "AES-GCM", iv: asArrayBuffer(bytes.subarray(7, headerLength)), additionalData: asArrayBuffer(bytes.subarray(0, headerLength)), tagLength: TAG_BYTES * 8 },
+        await importAesKey(encryptionKey, ["decrypt"]),
+        asArrayBuffer(cleartext)
+      ));
+    } catch {
+      throw new WoroPayloadError("Payload decryption failed; the key is wrong or the data was modified.", bytes.slice());
+    }
+  } else if (encryptionKey) {
+  }
+  if (cleartext.byteLength < 2) throw new WoroPayloadError("The WORO package payload metadata is truncated.");
+  const mediaTypeLength = new DataView(cleartext.buffer, cleartext.byteOffset, cleartext.byteLength).getUint16(0, false);
+  if (cleartext.byteLength < 2 + mediaTypeLength) throw new WoroPayloadError("The WORO package payload media type is truncated.");
+  let contentType;
+  try {
+    contentType = new TextDecoder("utf-8", { fatal: true }).decode(cleartext.subarray(2, 2 + mediaTypeLength));
+  } catch {
+    throw new WoroPayloadError("The WORO package payload media type is invalid.");
+  }
+  let payload = cleartext.subarray(2 + mediaTypeLength);
+  if (compressed) {
+    try {
+      payload = await gunzip(payload);
+    } catch (error) {
+      if (error instanceof WoroPayloadError) throw new WoroPayloadError(error.message, bytes.slice());
+      throw error;
+    }
+    if (payload.byteLength > WORO_MAX_PAYLOAD_BYTES) {
+      throw new WoroPayloadError(`Decoded payload exceeds WORO's ${WORO_MAX_PAYLOAD_BYTES}-byte limit.`, bytes.slice());
+    }
+  }
+  return { bytes: payload, contentType: contentType || "application/octet-stream" };
+}
+async function importAesKey(key, usages) {
+  return crypto.subtle.importKey("raw", asArrayBuffer(key), { name: "AES-GCM", length: 256 }, false, usages);
+}
+async function gzip(bytes) {
+  if (typeof CompressionStream === "undefined") throw new WoroPayloadError("This runtime does not provide gzip compression streams.");
+  const stream = new Blob([asArrayBuffer(bytes)]).stream().pipeThrough(new CompressionStream("gzip"));
+  return await collectStream(stream, WORO_MAX_PAYLOAD_BYTES + 64 * 1024);
+}
+async function gunzip(bytes) {
+  if (typeof DecompressionStream === "undefined") throw new WoroPayloadError("This runtime does not provide gzip decompression streams.");
+  try {
+    const stream = new Blob([asArrayBuffer(bytes)]).stream().pipeThrough(new DecompressionStream("gzip"));
+    return await collectStream(stream, WORO_MAX_PAYLOAD_BYTES);
+  } catch (error) {
+    if (error instanceof WoroPayloadError) throw error;
+    throw new WoroPayloadError("The compressed WORO package payload is invalid.");
+  }
+}
+async function collectStream(stream, maxBytes) {
+  const reader = stream.getReader();
+  const chunks = [];
+  let total = 0;
+  try {
+    while (true) {
+      const { done, value } = await reader.read();
+      if (done) break;
+      total += value.byteLength;
+      if (total > maxBytes) {
+        await reader.cancel();
+        throw new WoroPayloadError(`Decoded payload exceeds WORO's ${maxBytes}-byte limit.`);
+      }
+      chunks.push(value);
+    }
+  } finally {
+    reader.releaseLock();
+  }
+  const output = new Uint8Array(total);
+  let offset = 0;
+  for (const chunk of chunks) {
+    output.set(chunk, offset);
+    offset += chunk.byteLength;
+  }
+  return output;
+}
+function asArrayBuffer(bytes) {
+  return bytes.buffer.slice(bytes.byteOffset, bytes.byteOffset + bytes.byteLength);
+}
+
+// src/client.ts
+var WORO_PRODUCTION_URL = "https://woro.veilgroup.au";
+var WoroClient = class {
+  baseUrl;
+  fetcher;
+  cognito;
+  writeToken;
+  idToken;
+  idTokenExpiresAt;
+  constructor(options = {}) {
+    this.baseUrl = (options.baseUrl ?? WORO_PRODUCTION_URL).replace(/\/+$/, "");
+    this.writeToken = options.writeToken;
+    this.idToken = options.idToken;
+    this.cognito = options.cognito;
+    this.fetcher = options.fetch ?? fetch;
+  }
+  setWriteToken(token) {
+    this.writeToken = token;
+  }
+  setIdToken(token, expiresInSeconds) {
+    this.idToken = token;
+    this.idTokenExpiresAt = token && expiresInSeconds !== void 0 ? Date.now() + expiresInSeconds * 1e3 : void 0;
+  }
+  signOut() {
+    this.setIdToken(void 0);
+  }
+  async signIn(username, password) {
+    if (!this.cognito) throw new WoroAuthError("Cognito region, userPoolId, and appClientId are required for sign-in.");
+    if (!username || !password) throw new WoroAuthError("A Cognito username and password are required.");
+    const srp = new dist_default(this.cognito.userPoolId);
+    const endpoint = `https://cognito-idp.${this.cognito.region}.amazonaws.com/`;
+    const initialResponse = await this.fetcher(endpoint, {
+      method: "POST",
+      headers: {
+        "content-type": "application/x-amz-json-1.1",
+        "x-amz-target": "AWSCognitoIdentityProviderService.InitiateAuth"
+      },
+      body: JSON.stringify({
+        AuthFlow: "USER_SRP_AUTH",
+        ClientId: this.cognito.appClientId,
+        AuthParameters: { USERNAME: username, SRP_A: srp.getA() }
+      })
+    });
+    const initial = await parseCognitoResponse(initialResponse, "InitiateAuth");
+    if (initial.ChallengeName !== "PASSWORD_VERIFIER") {
+      throw new WoroAuthError(`Cognito requires an unsupported challenge (${String(initial.ChallengeName ?? "unknown")}). This package supports SRP password sign-in without MFA or forced password reset.`);
+    }
+    const challenge = asRecord(initial.ChallengeParameters);
+    const srpUsername = stringField(challenge, "USER_ID_FOR_SRP") ?? username;
+    const srpB = stringField(challenge, "SRP_B");
+    const salt = stringField(challenge, "SALT");
+    const secretBlock = stringField(challenge, "SECRET_BLOCK");
+    const session = stringField(initial, "Session");
+    if (!srpB || !salt || !secretBlock || !session) throw new WoroAuthError("Cognito returned an incomplete SRP challenge.");
+    const proof = srp.getSignature(srpUsername, srpB, salt, secretBlock, password);
+    const finalResponse = await this.fetcher(endpoint, {
+      method: "POST",
+      headers: {
+        "content-type": "application/x-amz-json-1.1",
+        "x-amz-target": "AWSCognitoIdentityProviderService.RespondToAuthChallenge"
+      },
+      body: JSON.stringify({
+        ChallengeName: "PASSWORD_VERIFIER",
+        ClientId: this.cognito.appClientId,
+        Session: session,
+        ChallengeResponses: {
+          USERNAME: srpUsername,
+          PASSWORD_CLAIM_SECRET_BLOCK: secretBlock,
+          PASSWORD_CLAIM_SIGNATURE: proof.signature,
+          TIMESTAMP: proof.timestamp
+        }
+      })
+    });
+    const final = await parseCognitoResponse(finalResponse, "RespondToAuthChallenge");
+    const authResult = asRecord(final.AuthenticationResult);
+    const idToken = stringField(authResult, "IdToken");
+    if (!idToken) throw new WoroAuthError("Cognito sign-in did not return an ID token.");
+    const expiresIn = numberField(authResult, "ExpiresIn") ?? 3600;
+    this.setIdToken(idToken, expiresIn);
+    return { idToken, expiresIn };
+  }
+  async writeSecret(input, options = {}) {
+    const encoded = await encodePayload(input, options);
+    if (encoded.bytes.byteLength === 0) throw new TypeError("An empty payload creates an empty slot in WORO. Use createEmptySlot() explicitly.");
+    this.assertPayloadSize(encoded.bytes);
+    const response = await this.request("/secret", {
+      method: "POST",
+      headers: {
+        "content-type": encoded.contentType,
+        "x-api-key": this.getWriteToken(options.writeToken)
+      },
+      body: new Blob([toArrayBuffer(encoded.bytes)])
+    });
+    return await response.json();
+  }
+  async createEmptySlot(writeToken) {
+    const response = await this.request("/secret", {
+      method: "POST",
+      headers: { "x-api-key": this.getWriteToken(writeToken) }
+    });
+    return await response.json();
+  }
+  async fillSecret(readToken, input, options = {}) {
+    const encoded = await encodePayload(input, options);
+    if (encoded.bytes.byteLength === 0) throw new TypeError("An empty payload cannot fill a WORO slot.");
+    this.assertPayloadSize(encoded.bytes);
+    await this.request(`/secret/${encodeURIComponent(readToken)}`, {
+      method: "PUT",
+      headers: { "content-type": encoded.contentType },
+      body: new Blob([toArrayBuffer(encoded.bytes)])
+    });
+  }
+  async readSecret(readToken, options = {}) {
+    const response = await this.request(`/secret/${encodeURIComponent(readToken)}`, { method: "GET" });
+    const bytes = new Uint8Array(await response.arrayBuffer());
+    const payload = await decodePayload(bytes, response.headers.get("content-type") ?? "application/octet-stream", options.encryptionKey);
+    return { data: payload.bytes, contentType: payload.contentType };
+  }
+  async deleteSecret(readToken) {
+    await this.request(`/secret/${encodeURIComponent(readToken)}`, { method: "DELETE" });
+  }
+  async getSecretStatus(readToken) {
+    const response = await this.request(`/secret/${encodeURIComponent(readToken)}`, {
+      method: "HEAD",
+      headers: this.authorizationHeaders()
+    });
+    return {
+      state: response.headers.get("x-woro-secret-state"),
+      createdAt: response.headers.get("x-woro-secret-created-at"),
+      expiresAt: response.headers.get("x-woro-secret-expires-at"),
+      uploadedAt: response.headers.get("x-woro-secret-uploaded-at"),
+      redeemedAt: response.headers.get("x-woro-secret-redeemed-at"),
+      deletedAt: response.headers.get("x-woro-secret-deleted-at")
+    };
+  }
+  async getAccount() {
+    return await (await this.request("/account", { method: "GET", headers: this.authorizationHeaders() })).json();
+  }
+  async getAccountBalance() {
+    return await (await this.request("/account/balance", { method: "GET", headers: this.authorizationHeaders() })).json();
+  }
+  async listWriteTokens() {
+    const body = await (await this.request("/account/tokens", { method: "GET", headers: this.authorizationHeaders() })).json();
+    if (Array.isArray(body)) return body;
+    const items = asRecord(body).tokens;
+    return Array.isArray(items) ? items : [];
+  }
+  async createWriteToken(label) {
+    const response = await this.request("/account/tokens", {
+      method: "POST",
+      headers: { ...this.authorizationHeaders(), "content-type": "application/json" },
+      body: JSON.stringify({ label })
+    });
+    return await response.json();
+  }
+  async revokeWriteToken(tokenId) {
+    await this.request(`/account/tokens/${encodeURIComponent(tokenId)}`, {
+      method: "DELETE",
+      headers: this.authorizationHeaders()
+    });
+  }
+  async checkWriteToken(writeToken = this.getWriteToken()) {
+    const response = await this.request("/account/token", {
+      method: "HEAD",
+      headers: { ...this.authorizationHeaders(), "x-api-key": writeToken }
+    });
+    return response.headers.get("x-woro-token-state");
+  }
+  getWriteToken(override) {
+    const token = override ?? this.writeToken;
+    if (!token) throw new WoroAuthError("A WORO write token is required for this operation.");
+    return token;
+  }
+  authorizationHeaders() {
+    if (!this.idToken) throw new WoroAuthError("Sign in to the Cognito account before using this operation.");
+    if (this.idTokenExpiresAt !== void 0 && Date.now() >= this.idTokenExpiresAt) {
+      this.signOut();
+      throw new WoroAuthError("The Cognito ID token has expired; sign in again.");
+    }
+    return { authorization: `Bearer ${this.idToken}` };
+  }
+  assertPayloadSize(bytes) {
+    if (bytes.byteLength > WORO_MAX_PAYLOAD_BYTES) {
+      throw new WoroApiError(413, `Encoded payload exceeds WORO's ${WORO_MAX_PAYLOAD_BYTES}-byte limit.`, "secret_too_large");
+    }
+  }
+  async request(path, init) {
+    const response = await this.fetcher(`${this.baseUrl}${path}`, { ...init, cache: "no-store" });
+    if (!response.ok) throw await apiError(response);
+    return response;
+  }
+};
+async function parseCognitoResponse(response, operation) {
+  let result;
+  try {
+    result = await response.json();
+  } catch {
+    result = void 0;
+  }
+  if (!response.ok) {
+    const body = asRecord(result);
+    const code = stringField(body, "__type")?.split("#").pop();
+    const message = stringField(body, "message") ?? `Cognito ${operation} failed with HTTP ${response.status}.`;
+    throw new WoroAuthError(message, code);
+  }
+  return asRecord(result);
+}
+async function apiError(response) {
+  let code;
+  let message = `WORO request failed with HTTP ${response.status}.`;
+  try {
+    const body = asRecord(await response.json());
+    code = stringField(body, "code") ?? stringField(body, "error");
+    const detail = stringField(body, "error");
+    if (detail && detail.length <= 200) message = detail;
+  } catch {
+  }
+  return new WoroApiError(response.status, message, code);
+}
+function asRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value) ? value : {};
+}
+function stringField(value, key) {
+  return typeof value[key] === "string" ? value[key] : void 0;
+}
+function numberField(value, key) {
+  return typeof value[key] === "number" && Number.isFinite(value[key]) ? value[key] : void 0;
+}
+function toArrayBuffer(bytes) {
+  return bytes.buffer.slice(bytes.byteOffset, bytes.byteOffset + bytes.byteLength);
+}
+export {
+  WORO_ENVELOPE_CONTENT_TYPE,
+  WORO_MAX_PAYLOAD_BYTES,
+  WORO_PRODUCTION_URL,
+  WoroApiError,
+  WoroAuthError,
+  WoroClient,
+  WoroPayloadError,
+  decodePayload,
+  encodePayload,
+  toBytes
+};
+//# sourceMappingURL=index.js.map