@veilgroup/sdk-woro 0.1.1

package/dist/index.cjs

@@ -0,0 +1,2883 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __esm = (fn, res, err) => function __init() {
+  if (err) throw err[0];
+  try {
+    return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
+  } catch (e) {
+    throw err = [e], e;
+  }
+};
+var __commonJS = (cb, mod) => function __require() {
+  try {
+    return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
+  } catch (e) {
+    throw mod = 0, e;
+  }
+};
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+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
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// node_modules/tslib/tslib.es6.mjs
+var tslib_es6_exports = {};
+__export(tslib_es6_exports, {
+  __addDisposableResource: () => __addDisposableResource,
+  __assign: () => __assign,
+  __asyncDelegator: () => __asyncDelegator,
+  __asyncGenerator: () => __asyncGenerator,
+  __asyncValues: () => __asyncValues,
+  __await: () => __await,
+  __awaiter: () => __awaiter,
+  __classPrivateFieldGet: () => __classPrivateFieldGet,
+  __classPrivateFieldIn: () => __classPrivateFieldIn,
+  __classPrivateFieldSet: () => __classPrivateFieldSet,
+  __createBinding: () => __createBinding,
+  __decorate: () => __decorate,
+  __disposeResources: () => __disposeResources,
+  __esDecorate: () => __esDecorate,
+  __exportStar: () => __exportStar,
+  __extends: () => __extends,
+  __generator: () => __generator,
+  __importDefault: () => __importDefault,
+  __importStar: () => __importStar,
+  __makeTemplateObject: () => __makeTemplateObject,
+  __metadata: () => __metadata,
+  __param: () => __param,
+  __propKey: () => __propKey,
+  __read: () => __read,
+  __rest: () => __rest,
+  __rewriteRelativeImportExtension: () => __rewriteRelativeImportExtension,
+  __runInitializers: () => __runInitializers,
+  __setFunctionName: () => __setFunctionName,
+  __spread: () => __spread,
+  __spreadArray: () => __spreadArray,
+  __spreadArrays: () => __spreadArrays,
+  __values: () => __values,
+  default: () => tslib_es6_default
+});
+function __extends(d, b) {
+  if (typeof b !== "function" && b !== null)
+    throw new TypeError("Class extends value " + String(b) + " is not a constructor or null");
+  extendStatics(d, b);
+  function __() {
+    this.constructor = d;
+  }
+  d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
+}
+function __rest(s, e) {
+  var t = {};
+  for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
+    t[p] = s[p];
+  if (s != null && typeof Object.getOwnPropertySymbols === "function")
+    for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
+      if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
+        t[p[i]] = s[p[i]];
+    }
+  return t;
+}
+function __decorate(decorators, target, key, desc) {
+  var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+  if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+  else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+  return c > 3 && r && Object.defineProperty(target, key, r), r;
+}
+function __param(paramIndex, decorator) {
+  return function(target, key) {
+    decorator(target, key, paramIndex);
+  };
+}
+function __esDecorate(ctor, descriptorIn, decorators, contextIn, initializers, extraInitializers) {
+  function accept(f) {
+    if (f !== void 0 && typeof f !== "function") throw new TypeError("Function expected");
+    return f;
+  }
+  var kind = contextIn.kind, key = kind === "getter" ? "get" : kind === "setter" ? "set" : "value";
+  var target = !descriptorIn && ctor ? contextIn["static"] ? ctor : ctor.prototype : null;
+  var descriptor = descriptorIn || (target ? Object.getOwnPropertyDescriptor(target, contextIn.name) : {});
+  var _, done = false;
+  for (var i = decorators.length - 1; i >= 0; i--) {
+    var context = {};
+    for (var p in contextIn) context[p] = p === "access" ? {} : contextIn[p];
+    for (var p in contextIn.access) context.access[p] = contextIn.access[p];
+    context.addInitializer = function(f) {
+      if (done) throw new TypeError("Cannot add initializers after decoration has completed");
+      extraInitializers.push(accept(f || null));
+    };
+    var result = (0, decorators[i])(kind === "accessor" ? { get: descriptor.get, set: descriptor.set } : descriptor[key], context);
+    if (kind === "accessor") {
+      if (result === void 0) continue;
+      if (result === null || typeof result !== "object") throw new TypeError("Object expected");
+      if (_ = accept(result.get)) descriptor.get = _;
+      if (_ = accept(result.set)) descriptor.set = _;
+      if (_ = accept(result.init)) initializers.unshift(_);
+    } else if (_ = accept(result)) {
+      if (kind === "field") initializers.unshift(_);
+      else descriptor[key] = _;
+    }
+  }
+  if (target) Object.defineProperty(target, contextIn.name, descriptor);
+  done = true;
+}
+function __runInitializers(thisArg, initializers, value) {
+  var useValue = arguments.length > 2;
+  for (var i = 0; i < initializers.length; i++) {
+    value = useValue ? initializers[i].call(thisArg, value) : initializers[i].call(thisArg);
+  }
+  return useValue ? value : void 0;
+}
+function __propKey(x) {
+  return typeof x === "symbol" ? x : "".concat(x);
+}
+function __setFunctionName(f, name, prefix) {
+  if (typeof name === "symbol") name = name.description ? "[".concat(name.description, "]") : "";
+  return Object.defineProperty(f, "name", { configurable: true, value: prefix ? "".concat(prefix, " ", name) : name });
+}
+function __metadata(metadataKey, metadataValue) {
+  if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(metadataKey, metadataValue);
+}
+function __awaiter(thisArg, _arguments, P, generator) {
+  function adopt(value) {
+    return value instanceof P ? value : new P(function(resolve) {
+      resolve(value);
+    });
+  }
+  return new (P || (P = Promise))(function(resolve, reject) {
+    function fulfilled(value) {
+      try {
+        step(generator.next(value));
+      } catch (e) {
+        reject(e);
+      }
+    }
+    function rejected(value) {
+      try {
+        step(generator["throw"](value));
+      } catch (e) {
+        reject(e);
+      }
+    }
+    function step(result) {
+      result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected);
+    }
+    step((generator = generator.apply(thisArg, _arguments || [])).next());
+  });
+}
+function __generator(thisArg, body) {
+  var _ = { label: 0, sent: function() {
+    if (t[0] & 1) throw t[1];
+    return t[1];
+  }, trys: [], ops: [] }, f, y, t, g = Object.create((typeof Iterator === "function" ? Iterator : Object).prototype);
+  return g.next = verb(0), g["throw"] = verb(1), g["return"] = verb(2), typeof Symbol === "function" && (g[Symbol.iterator] = function() {
+    return this;
+  }), g;
+  function verb(n) {
+    return function(v) {
+      return step([n, v]);
+    };
+  }
+  function step(op) {
+    if (f) throw new TypeError("Generator is already executing.");
+    while (g && (g = 0, op[0] && (_ = 0)), _) try {
+      if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
+      if (y = 0, t) op = [op[0] & 2, t.value];
+      switch (op[0]) {
+        case 0:
+        case 1:
+          t = op;
+          break;
+        case 4:
+          _.label++;
+          return { value: op[1], done: false };
+        case 5:
+          _.label++;
+          y = op[1];
+          op = [0];
+          continue;
+        case 7:
+          op = _.ops.pop();
+          _.trys.pop();
+          continue;
+        default:
+          if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) {
+            _ = 0;
+            continue;
+          }
+          if (op[0] === 3 && (!t || op[1] > t[0] && op[1] < t[3])) {
+            _.label = op[1];
+            break;
+          }
+          if (op[0] === 6 && _.label < t[1]) {
+            _.label = t[1];
+            t = op;
+            break;
+          }
+          if (t && _.label < t[2]) {
+            _.label = t[2];
+            _.ops.push(op);
+            break;
+          }
+          if (t[2]) _.ops.pop();
+          _.trys.pop();
+          continue;
+      }
+      op = body.call(thisArg, _);
+    } catch (e) {
+      op = [6, e];
+      y = 0;
+    } finally {
+      f = t = 0;
+    }
+    if (op[0] & 5) throw op[1];
+    return { value: op[0] ? op[1] : void 0, done: true };
+  }
+}
+function __exportStar(m, o) {
+  for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(o, p)) __createBinding(o, m, p);
+}
+function __values(o) {
+  var s = typeof Symbol === "function" && Symbol.iterator, m = s && o[s], i = 0;
+  if (m) return m.call(o);
+  if (o && typeof o.length === "number") return {
+    next: function() {
+      if (o && i >= o.length) o = void 0;
+      return { value: o && o[i++], done: !o };
+    }
+  };
+  throw new TypeError(s ? "Object is not iterable." : "Symbol.iterator is not defined.");
+}
+function __read(o, n) {
+  var m = typeof Symbol === "function" && o[Symbol.iterator];
+  if (!m) return o;
+  var i = m.call(o), r, ar = [], e;
+  try {
+    while ((n === void 0 || n-- > 0) && !(r = i.next()).done) ar.push(r.value);
+  } catch (error) {
+    e = { error };
+  } finally {
+    try {
+      if (r && !r.done && (m = i["return"])) m.call(i);
+    } finally {
+      if (e) throw e.error;
+    }
+  }
+  return ar;
+}
+function __spread() {
+  for (var ar = [], i = 0; i < arguments.length; i++)
+    ar = ar.concat(__read(arguments[i]));
+  return ar;
+}
+function __spreadArrays() {
+  for (var s = 0, i = 0, il = arguments.length; i < il; i++) s += arguments[i].length;
+  for (var r = Array(s), k = 0, i = 0; i < il; i++)
+    for (var a = arguments[i], j = 0, jl = a.length; j < jl; j++, k++)
+      r[k] = a[j];
+  return r;
+}
+function __spreadArray(to, from, pack) {
+  if (pack || arguments.length === 2) for (var i = 0, l = from.length, ar; i < l; i++) {
+    if (ar || !(i in from)) {
+      if (!ar) ar = Array.prototype.slice.call(from, 0, i);
+      ar[i] = from[i];
+    }
+  }
+  return to.concat(ar || Array.prototype.slice.call(from));
+}
+function __await(v) {
+  return this instanceof __await ? (this.v = v, this) : new __await(v);
+}
+function __asyncGenerator(thisArg, _arguments, generator) {
+  if (!Symbol.asyncIterator) throw new TypeError("Symbol.asyncIterator is not defined.");
+  var g = generator.apply(thisArg, _arguments || []), i, q = [];
+  return i = Object.create((typeof AsyncIterator === "function" ? AsyncIterator : Object).prototype), verb("next"), verb("throw"), verb("return", awaitReturn), i[Symbol.asyncIterator] = function() {
+    return this;
+  }, i;
+  function awaitReturn(f) {
+    return function(v) {
+      return Promise.resolve(v).then(f, reject);
+    };
+  }
+  function verb(n, f) {
+    if (g[n]) {
+      i[n] = function(v) {
+        return new Promise(function(a, b) {
+          q.push([n, v, a, b]) > 1 || resume(n, v);
+        });
+      };
+      if (f) i[n] = f(i[n]);
+    }
+  }
+  function resume(n, v) {
+    try {
+      step(g[n](v));
+    } catch (e) {
+      settle(q[0][3], e);
+    }
+  }
+  function step(r) {
+    r.value instanceof __await ? Promise.resolve(r.value.v).then(fulfill, reject) : settle(q[0][2], r);
+  }
+  function fulfill(value) {
+    resume("next", value);
+  }
+  function reject(value) {
+    resume("throw", value);
+  }
+  function settle(f, v) {
+    if (f(v), q.shift(), q.length) resume(q[0][0], q[0][1]);
+  }
+}
+function __asyncDelegator(o) {
+  var i, p;
+  return i = {}, verb("next"), verb("throw", function(e) {
+    throw e;
+  }), verb("return"), i[Symbol.iterator] = function() {
+    return this;
+  }, i;
+  function verb(n, f) {
+    i[n] = o[n] ? function(v) {
+      return (p = !p) ? { value: __await(o[n](v)), done: false } : f ? f(v) : v;
+    } : f;
+  }
+}
+function __asyncValues(o) {
+  if (!Symbol.asyncIterator) throw new TypeError("Symbol.asyncIterator is not defined.");
+  var m = o[Symbol.asyncIterator], i;
+  return m ? m.call(o) : (o = typeof __values === "function" ? __values(o) : o[Symbol.iterator](), i = {}, verb("next"), verb("throw"), verb("return"), i[Symbol.asyncIterator] = function() {
+    return this;
+  }, i);
+  function verb(n) {
+    i[n] = o[n] && function(v) {
+      return new Promise(function(resolve, reject) {
+        v = o[n](v), settle(resolve, reject, v.done, v.value);
+      });
+    };
+  }
+  function settle(resolve, reject, d, v) {
+    Promise.resolve(v).then(function(v2) {
+      resolve({ value: v2, done: d });
+    }, reject);
+  }
+}
+function __makeTemplateObject(cooked, raw) {
+  if (Object.defineProperty) {
+    Object.defineProperty(cooked, "raw", { value: raw });
+  } else {
+    cooked.raw = raw;
+  }
+  return cooked;
+}
+function __importStar(mod) {
+  if (mod && mod.__esModule) return mod;
+  var result = {};
+  if (mod != null) {
+    for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+  }
+  __setModuleDefault(result, mod);
+  return result;
+}
+function __importDefault(mod) {
+  return mod && mod.__esModule ? mod : { default: mod };
+}
+function __classPrivateFieldGet(receiver, state, kind, f) {
+  if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a getter");
+  if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
+  return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
+}
+function __classPrivateFieldSet(receiver, state, value, kind, f) {
+  if (kind === "m") throw new TypeError("Private method is not writable");
+  if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a setter");
+  if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot write private member to an object whose class did not declare it");
+  return kind === "a" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value), value;
+}
+function __classPrivateFieldIn(state, receiver) {
+  if (receiver === null || typeof receiver !== "object" && typeof receiver !== "function") throw new TypeError("Cannot use 'in' operator on non-object");
+  return typeof state === "function" ? receiver === state : state.has(receiver);
+}
+function __addDisposableResource(env, value, async) {
+  if (value !== null && value !== void 0) {
+    if (typeof value !== "object" && typeof value !== "function") throw new TypeError("Object expected.");
+    var dispose, inner;
+    if (async) {
+      if (!Symbol.asyncDispose) throw new TypeError("Symbol.asyncDispose is not defined.");
+      dispose = value[Symbol.asyncDispose];
+    }
+    if (dispose === void 0) {
+      if (!Symbol.dispose) throw new TypeError("Symbol.dispose is not defined.");
+      dispose = value[Symbol.dispose];
+      if (async) inner = dispose;
+    }
+    if (typeof dispose !== "function") throw new TypeError("Object not disposable.");
+    if (inner) dispose = function() {
+      try {
+        inner.call(this);
+      } catch (e) {
+        return Promise.reject(e);
+      }
+    };
+    env.stack.push({ value, dispose, async });
+  } else if (async) {
+    env.stack.push({ async: true });
+  }
+  return value;
+}
+function __disposeResources(env) {
+  function fail(e) {
+    env.error = env.hasError ? new _SuppressedError(e, env.error, "An error was suppressed during disposal.") : e;
+    env.hasError = true;
+  }
+  var r, s = 0;
+  function next() {
+    while (r = env.stack.pop()) {
+      try {
+        if (!r.async && s === 1) return s = 0, env.stack.push(r), Promise.resolve().then(next);
+        if (r.dispose) {
+          var result = r.dispose.call(r.value);
+          if (r.async) return s |= 2, Promise.resolve(result).then(next, function(e) {
+            fail(e);
+            return next();
+          });
+        } else s |= 1;
+      } catch (e) {
+        fail(e);
+      }
+    }
+    if (s === 1) return env.hasError ? Promise.reject(env.error) : Promise.resolve();
+    if (env.hasError) throw env.error;
+  }
+  return next();
+}
+function __rewriteRelativeImportExtension(path, preserveJsx) {
+  if (typeof path === "string" && /^\.\.?\//.test(path)) {
+    return path.replace(/\.(tsx)$|((?:\.d)?)((?:\.[^./]+?)?)\.([cm]?)ts$/i, function(m, tsx, d, ext, cm) {
+      return tsx ? preserveJsx ? ".jsx" : ".js" : d && (!ext || !cm) ? m : d + ext + "." + cm.toLowerCase() + "js";
+    });
+  }
+  return path;
+}
+var extendStatics, __assign, __createBinding, __setModuleDefault, ownKeys, _SuppressedError, tslib_es6_default;
+var init_tslib_es6 = __esm({
+  "node_modules/tslib/tslib.es6.mjs"() {
+    extendStatics = function(d, b) {
+      extendStatics = Object.setPrototypeOf || { __proto__: [] } instanceof Array && function(d2, b2) {
+        d2.__proto__ = b2;
+      } || function(d2, b2) {
+        for (var p in b2) if (Object.prototype.hasOwnProperty.call(b2, p)) d2[p] = b2[p];
+      };
+      return extendStatics(d, b);
+    };
+    __assign = function() {
+      __assign = Object.assign || function __assign2(t) {
+        for (var s, i = 1, n = arguments.length; i < n; i++) {
+          s = arguments[i];
+          for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p)) t[p] = s[p];
+        }
+        return t;
+      };
+      return __assign.apply(this, arguments);
+    };
+    __createBinding = Object.create ? (function(o, m, k, k2) {
+      if (k2 === void 0) k2 = k;
+      var desc = Object.getOwnPropertyDescriptor(m, k);
+      if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+        desc = { enumerable: true, get: function() {
+          return m[k];
+        } };
+      }
+      Object.defineProperty(o, k2, desc);
+    }) : (function(o, m, k, k2) {
+      if (k2 === void 0) k2 = k;
+      o[k2] = m[k];
+    });
+    __setModuleDefault = Object.create ? (function(o, v) {
+      Object.defineProperty(o, "default", { enumerable: true, value: v });
+    }) : function(o, v) {
+      o["default"] = v;
+    };
+    ownKeys = function(o) {
+      ownKeys = Object.getOwnPropertyNames || function(o2) {
+        var ar = [];
+        for (var k in o2) if (Object.prototype.hasOwnProperty.call(o2, k)) ar[ar.length] = k;
+        return ar;
+      };
+      return ownKeys(o);
+    };
+    _SuppressedError = typeof SuppressedError === "function" ? SuppressedError : function(error, suppressed, message) {
+      var e = new Error(message);
+      return e.name = "SuppressedError", e.error = error, e.suppressed = suppressed, e;
+    };
+    tslib_es6_default = {
+      __extends,
+      __assign,
+      __rest,
+      __decorate,
+      __param,
+      __esDecorate,
+      __runInitializers,
+      __propKey,
+      __setFunctionName,
+      __metadata,
+      __awaiter,
+      __generator,
+      __createBinding,
+      __exportStar,
+      __values,
+      __read,
+      __spread,
+      __spreadArrays,
+      __spreadArray,
+      __await,
+      __asyncGenerator,
+      __asyncDelegator,
+      __asyncValues,
+      __makeTemplateObject,
+      __importStar,
+      __importDefault,
+      __classPrivateFieldGet,
+      __classPrivateFieldSet,
+      __classPrivateFieldIn,
+      __addDisposableResource,
+      __disposeResources,
+      __rewriteRelativeImportExtension
+    };
+  }
+});
+
+// node_modules/aws-cognito-srp-client/dist/cjs/bigInteger.js
+var require_bigInteger = __commonJS({
+  "node_modules/aws-cognito-srp-client/dist/cjs/bigInteger.js"(exports2) {
+    "use strict";
+    Object.defineProperty(exports2, "__esModule", { value: true });
+    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);
+    };
+    exports2.default = bigInt;
+  }
+});
+
+// node_modules/crypto-js/core.js
+var require_core = __commonJS({
+  "node_modules/crypto-js/core.js"(exports2, module2) {
+    (function(root, factory) {
+      if (typeof exports2 === "object") {
+        module2.exports = exports2 = factory();
+      } else if (typeof define === "function" && define.amd) {
+        define([], factory);
+      } else {
+        root.CryptoJS = factory();
+      }
+    })(exports2, function() {
+      var CryptoJS = CryptoJS || (function(Math2, undefined2) {
+        var crypto2;
+        if (typeof window !== "undefined" && window.crypto) {
+          crypto2 = window.crypto;
+        }
+        if (typeof self !== "undefined" && self.crypto) {
+          crypto2 = self.crypto;
+        }
+        if (typeof globalThis !== "undefined" && globalThis.crypto) {
+          crypto2 = globalThis.crypto;
+        }
+        if (!crypto2 && typeof window !== "undefined" && window.msCrypto) {
+          crypto2 = window.msCrypto;
+        }
+        if (!crypto2 && typeof global !== "undefined" && global.crypto) {
+          crypto2 = global.crypto;
+        }
+        if (!crypto2 && typeof require === "function") {
+          try {
+            crypto2 = require("crypto");
+          } catch (err) {
+          }
+        }
+        var cryptoSecureRandomInt = 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 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 hash = this._doFinalize();
+            return hash;
+          },
+          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"(exports2, module2) {
+    (function(root, factory) {
+      if (typeof exports2 === "object") {
+        module2.exports = exports2 = factory(require_core());
+      } else if (typeof define === "function" && define.amd) {
+        define(["./core"], factory);
+      } else {
+        factory(root.CryptoJS);
+      }
+    })(exports2, 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"(exports2, module2) {
+    (function(root, factory) {
+      if (typeof exports2 === "object") {
+        module2.exports = exports2 = factory(require_core());
+      } else if (typeof define === "function" && define.amd) {
+        define(["./core"], factory);
+      } else {
+        factory(root.CryptoJS);
+      }
+    })(exports2, 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"(exports2, module2) {
+    (function(root, factory, undef) {
+      if (typeof exports2 === "object") {
+        module2.exports = exports2 = factory(require_core(), require_sha256(), require_hmac());
+      } else if (typeof define === "function" && define.amd) {
+        define(["./core", "./sha256", "./hmac"], factory);
+      } else {
+        factory(root.CryptoJS);
+      }
+    })(exports2, function(CryptoJS) {
+      return CryptoJS.HmacSHA256;
+    });
+  }
+});
+
+// node_modules/crypto-js/enc-base64.js
+var require_enc_base64 = __commonJS({
+  "node_modules/crypto-js/enc-base64.js"(exports2, module2) {
+    (function(root, factory) {
+      if (typeof exports2 === "object") {
+        module2.exports = exports2 = factory(require_core());
+      } else if (typeof define === "function" && define.amd) {
+        define(["./core"], factory);
+      } else {
+        factory(root.CryptoJS);
+      }
+    })(exports2, 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"(exports2, module2) {
+    (function(root, factory) {
+      if (typeof exports2 === "object") {
+        module2.exports = exports2 = factory(require_core());
+      } else if (typeof define === "function" && define.amd) {
+        define(["./core"], factory);
+      } else {
+        factory(root.CryptoJS);
+      }
+    })(exports2, 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"(exports2, module2) {
+    (function(root, factory) {
+      if (typeof exports2 === "object") {
+        module2.exports = exports2 = factory(require_core());
+      } else if (typeof define === "function" && define.amd) {
+        define(["./core"], factory);
+      } else {
+        factory(root.CryptoJS);
+      }
+    })(exports2, function(CryptoJS) {
+      return CryptoJS.enc.Utf8;
+    });
+  }
+});
+
+// node_modules/aws-cognito-srp-client/dist/cjs/cryptoUtils.js
+var require_cryptoUtils = __commonJS({
+  "node_modules/aws-cognito-srp-client/dist/cjs/cryptoUtils.js"(exports2) {
+    "use strict";
+    Object.defineProperty(exports2, "__esModule", { value: true });
+    exports2.computeSignature = exports2.computehkdf = exports2.randomValue = exports2.hexHash = exports2.hash = exports2.padHex = void 0;
+    var tslib_1 = (init_tslib_es6(), __toCommonJS(tslib_es6_exports));
+    var bigInteger_1 = (0, tslib_1.__importDefault)(require_bigInteger());
+    var sha256_1 = (0, tslib_1.__importDefault)(require_sha256());
+    var hmac_sha256_1 = (0, tslib_1.__importDefault)(require_hmac_sha256());
+    var enc_base64_1 = (0, tslib_1.__importDefault)(require_enc_base64());
+    var enc_hex_1 = (0, tslib_1.__importDefault)(require_enc_hex());
+    var enc_utf8_1 = (0, tslib_1.__importDefault)(require_enc_utf8());
+    var polyFillCrypto = function() {
+      if (typeof window !== "undefined" && window.crypto) {
+        return window.crypto;
+      }
+      if (typeof window !== "undefined" && window.msCrypto) {
+        return window.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;
+    };
+    exports2.padHex = padHex;
+    var hash = function(str) {
+      var hashHex = (0, sha256_1.default)(str).toString();
+      return new Array(64 - hashHex.length).join("0") + hashHex;
+    };
+    exports2.hash = hash;
+    var hexHash = function(hexStr) {
+      return (0, exports2.hash)(enc_hex_1.default.parse(hexStr));
+    };
+    exports2.hexHash = hexHash;
+    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 = (0, bigInteger_1.default)(hexRandom, 16);
+      return randomInt;
+    };
+    exports2.randomValue = randomValue;
+    var computehkdf = function(ikm, salt) {
+      var infoBits = enc_utf8_1.default.parse("Caldera Derived Key").concat(enc_utf8_1.default.parse(String.fromCharCode(1)));
+      var prk = (0, hmac_sha256_1.default)(ikm, salt);
+      var hmac = (0, hmac_sha256_1.default)(infoBits, prk);
+      return enc_hex_1.default.parse(hmac.toString().slice(0, 32));
+    };
+    exports2.computehkdf = computehkdf;
+    var computeSignature = function(message, key) {
+      return enc_base64_1.default.stringify((0, hmac_sha256_1.default)(message, key));
+    };
+    exports2.computeSignature = computeSignature;
+  }
+});
+
+// node_modules/aws-cognito-srp-client/dist/cjs/index.js
+var require_cjs = __commonJS({
+  "node_modules/aws-cognito-srp-client/dist/cjs/index.js"(exports2) {
+    "use strict";
+    Object.defineProperty(exports2, "__esModule", { value: true });
+    var tslib_1 = (init_tslib_es6(), __toCommonJS(tslib_es6_exports));
+    var bigInteger_1 = (0, tslib_1.__importDefault)(require_bigInteger());
+    var cryptoUtils_1 = require_cryptoUtils();
+    var enc_base64_1 = (0, tslib_1.__importDefault)(require_enc_base64());
+    var enc_hex_1 = (0, tslib_1.__importDefault)(require_enc_hex());
+    var enc_utf8_1 = (0, tslib_1.__importDefault)(require_enc_utf8());
+    var initN = "FFFFFFFFFFFFFFFFC90FDAA22168C234C4C6628B80DC1CD129024E088A67CC74020BBEA63B139B22514A08798E3404DDEF9519B3CD3A431B302B0A6DF25F14374FE1356D6D51C245E485B576625E7EC6F44C42E9A637ED6B0BFF5CB6F406B7EDEE386BFB5A899FA5AE9F24117C4B1FE649286651ECE45B3DC2007CB8A163BF0598DA48361C55D39A69163FA8FD24CF5F83655D23DCA3AD961C62F356208552BB9ED529077096966D670C354E4ABC9804F1746C08CA18217C32905E462E36CE3BE39E772C180E86039B2783A2EC07A28FB5C55DF06F4C52C9DE2BCBF6955817183995497CEA956AE515D2261898FA051015728E5A8AAAC42DAD33170D04507A33A85521ABDF1CBA64ECFB850458DBEF0A8AEA71575D060C7DB3970F85A6E1E4C7ABF5AE8CDB0933D71E8C94E04A25619DCEE3D2261AD2EE6BF12FFA06D98A0864D87602733EC86A64521F2B18177B200CBBE117577A615D6C770988C0BAD946E208E24FA074E5AB3143DB5BFCE0FD108E4B82D120A93AD2CAFFFFFFFFFFFFFFFF";
+    var Srp2 = (
+      /** @class */
+      (function() {
+        function Srp3(poolId) {
+          this.g = (0, bigInteger_1.default)("2", 16);
+          this.N = (0, bigInteger_1.default)(initN, 16);
+          this.k = (0, bigInteger_1.default)((0, cryptoUtils_1.hexHash)((0, cryptoUtils_1.padHex)(this.N) + (0, cryptoUtils_1.padHex)(this.g)), 16);
+          this.poolName = poolId.split("_")[1];
+        }
+        Srp3.prototype.getA = function() {
+          this.a = (0, cryptoUtils_1.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);
+        };
+        Srp3.prototype.getSignature = function(username, strB, strSalt, secretBlock, password) {
+          var B = (0, bigInteger_1.default)(strB, 16);
+          if (B.mod(this.N).isZero()) {
+            new Error("Illegal paramater. B mod N cannot be 0.");
+          }
+          var salt = (0, bigInteger_1.default)(strSalt, 16);
+          var U = (0, bigInteger_1.default)((0, cryptoUtils_1.hexHash)((0, cryptoUtils_1.padHex)(this.A) + (0, cryptoUtils_1.padHex)(B)), 16);
+          if (U.isZero()) {
+            throw new Error("U cannot be zero.");
+          }
+          var usernamePasswordHash = (0, cryptoUtils_1.hash)(enc_utf8_1.default.parse(this.poolName + username + ":" + password));
+          var x = (0, bigInteger_1.default)((0, cryptoUtils_1.hexHash)((0, cryptoUtils_1.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 = (0, cryptoUtils_1.padHex)(S);
+          var hkdf = (0, cryptoUtils_1.computehkdf)(enc_hex_1.default.parse(paddedS), enc_hex_1.default.parse((0, cryptoUtils_1.padHex)(U)));
+          var timestamp = getNowString();
+          var message = enc_utf8_1.default.parse(this.poolName).concat(enc_utf8_1.default.parse(username)).concat(enc_base64_1.default.parse(secretBlock)).concat(enc_utf8_1.default.parse(timestamp));
+          var signature = (0, cryptoUtils_1.computeSignature)(message, hkdf);
+          return { timestamp, signature };
+        };
+        return Srp3;
+      })()
+    );
+    exports2.default = Srp2;
+    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/index.ts
+var index_exports = {};
+__export(index_exports, {
+  WORO_ENVELOPE_CONTENT_TYPE: () => WORO_ENVELOPE_CONTENT_TYPE,
+  WORO_MAX_PAYLOAD_BYTES: () => WORO_MAX_PAYLOAD_BYTES,
+  WORO_PRODUCTION_URL: () => WORO_PRODUCTION_URL,
+  WoroApiError: () => WoroApiError,
+  WoroAuthError: () => WoroAuthError,
+  WoroClient: () => WoroClient,
+  WoroPayloadError: () => WoroPayloadError,
+  decodePayload: () => decodePayload,
+  encodePayload: () => encodePayload,
+  toBytes: () => toBytes
+});
+module.exports = __toCommonJS(index_exports);
+
+// src/client.ts
+var import_aws_cognito_srp_client = __toESM(require_cjs(), 1);
+
+// 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 import_aws_cognito_srp_client.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);
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  WORO_ENVELOPE_CONTENT_TYPE,
+  WORO_MAX_PAYLOAD_BYTES,
+  WORO_PRODUCTION_URL,
+  WoroApiError,
+  WoroAuthError,
+  WoroClient,
+  WoroPayloadError,
+  decodePayload,
+  encodePayload,
+  toBytes
+});
+//# sourceMappingURL=index.cjs.map