@learncard/core 6.1.0 → 6.2.0

package/dist/core.cjs.development.js

@@ -2881,9 +2881,9 @@ var require_package = __commonJS({
   }
 });
 
-// (disabled):../../node_modules/.pnpm/buffer@5.2.1/node_modules/buffer/index.js
+// (disabled):../../node_modules/.pnpm/buffer@5.7.1/node_modules/buffer/index.js
 var require_buffer = __commonJS({
-  "(disabled):../../node_modules/.pnpm/buffer@5.2.1/node_modules/buffer/index.js"() {
+  "(disabled):../../node_modules/.pnpm/buffer@5.7.1/node_modules/buffer/index.js"() {
   }
 });
 
@@ -2930,12 +2930,12 @@ var require_bn = __commonJS({
       }
       BN3.BN = BN3;
       BN3.wordSize = 26;
-      var Buffer2;
+      var Buffer3;
       try {
         if (typeof window !== "undefined" && typeof window.Buffer !== "undefined") {
-          Buffer2 = window.Buffer;
+          Buffer3 = window.Buffer;
         } else {
-          Buffer2 = require_buffer().Buffer;
+          Buffer3 = require_buffer().Buffer;
         }
       } catch (e) {
       }
@@ -3376,8 +3376,8 @@ var require_bn = __commonJS({
         return this.toString(16);
       }, "toJSON");
       BN3.prototype.toBuffer = /* @__PURE__ */ __name(function toBuffer(endian, length2) {
-        assert2(typeof Buffer2 !== "undefined");
-        return this.toArrayLike(Buffer2, endian, length2);
+        assert2(typeof Buffer3 !== "undefined");
+        return this.toArrayLike(Buffer3, endian, length2);
       }, "toBuffer");
       BN3.prototype.toArray = /* @__PURE__ */ __name(function toArray(endian, length2) {
         return this.toArrayLike(Array, endian, length2);
@@ -23413,12 +23413,12 @@ var require_bn2 = __commonJS({
       }
       BN3.BN = BN3;
       BN3.wordSize = 26;
-      var Buffer2;
+      var Buffer3;
       try {
         if (typeof window !== "undefined" && typeof window.Buffer !== "undefined") {
-          Buffer2 = window.Buffer;
+          Buffer3 = window.Buffer;
         } else {
-          Buffer2 = require_buffer().Buffer;
+          Buffer3 = require_buffer().Buffer;
         }
       } catch (e) {
       }
@@ -23883,9 +23883,9 @@ var require_bn2 = __commonJS({
       BN3.prototype.toJSON = /* @__PURE__ */ __name(function toJSON2() {
         return this.toString(16, 2);
       }, "toJSON");
-      if (Buffer2) {
+      if (Buffer3) {
         BN3.prototype.toBuffer = /* @__PURE__ */ __name(function toBuffer(endian, length2) {
-          return this.toArrayLike(Buffer2, endian, length2);
+          return this.toArrayLike(Buffer3, endian, length2);
         }, "toBuffer");
       }
       BN3.prototype.toArray = /* @__PURE__ */ __name(function toArray(endian, length2) {
@@ -27421,7 +27421,7 @@ var require_lodash = __commonJS({
     var hasOwnProperty2 = objectProto.hasOwnProperty;
     var objectToString = objectProto.toString;
     var reIsNative = RegExp("^" + funcToString.call(hasOwnProperty2).replace(reRegExpChar, "\\$&").replace(/hasOwnProperty|(function).*?(?=\\\()| for .+?(?=\\\])/g, "$1.*?") + "$");
-    var Buffer2 = moduleExports ? root.Buffer : void 0;
+    var Buffer3 = moduleExports ? root.Buffer : void 0;
     var Symbol2 = root.Symbol;
     var Uint8Array2 = root.Uint8Array;
     var getPrototype = overArg(Object.getPrototypeOf, Object);
@@ -27429,7 +27429,7 @@ var require_lodash = __commonJS({
     var propertyIsEnumerable = objectProto.propertyIsEnumerable;
     var splice = arrayProto.splice;
     var nativeGetSymbols = Object.getOwnPropertySymbols;
-    var nativeIsBuffer = Buffer2 ? Buffer2.isBuffer : void 0;
+    var nativeIsBuffer = Buffer3 ? Buffer3.isBuffer : void 0;
     var nativeKeys = overArg(Object.keys, Object);
     var DataView2 = getNative(root, "DataView");
     var Map2 = getNative(root, "Map");
@@ -28453,7 +28453,7 @@ var require_dataloader = __commonJS({
       }
       __name(DataLoader3, "DataLoader");
       var _proto = DataLoader3.prototype;
-      _proto.load = /* @__PURE__ */ __name(function load2(key2) {
+      _proto.load = /* @__PURE__ */ __name(function load3(key2) {
         if (key2 === null || key2 === void 0) {
           throw new TypeError("The loader.load() function must be called with a value, " + ("but got: " + String(key2) + "."));
         }
@@ -29261,6 +29261,1667 @@ var require_src3 = __commonJS({
   }
 });
 
+// ../../node_modules/.pnpm/base64-js@1.5.1/node_modules/base64-js/index.js
+var require_base64_js = __commonJS({
+  "../../node_modules/.pnpm/base64-js@1.5.1/node_modules/base64-js/index.js"(exports) {
+    "use strict";
+    exports.byteLength = byteLength;
+    exports.toByteArray = toByteArray;
+    exports.fromByteArray = fromByteArray;
+    var lookup = [];
+    var revLookup = [];
+    var Arr = typeof Uint8Array !== "undefined" ? Uint8Array : Array;
+    var code5 = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
+    for (i = 0, len = code5.length; i < len; ++i) {
+      lookup[i] = code5[i];
+      revLookup[code5.charCodeAt(i)] = i;
+    }
+    var i;
+    var len;
+    revLookup["-".charCodeAt(0)] = 62;
+    revLookup["_".charCodeAt(0)] = 63;
+    function getLens(b64) {
+      var len2 = b64.length;
+      if (len2 % 4 > 0) {
+        throw new Error("Invalid string. Length must be a multiple of 4");
+      }
+      var validLen = b64.indexOf("=");
+      if (validLen === -1)
+        validLen = len2;
+      var placeHoldersLen = validLen === len2 ? 0 : 4 - validLen % 4;
+      return [validLen, placeHoldersLen];
+    }
+    __name(getLens, "getLens");
+    function byteLength(b64) {
+      var lens = getLens(b64);
+      var validLen = lens[0];
+      var placeHoldersLen = lens[1];
+      return (validLen + placeHoldersLen) * 3 / 4 - placeHoldersLen;
+    }
+    __name(byteLength, "byteLength");
+    function _byteLength(b64, validLen, placeHoldersLen) {
+      return (validLen + placeHoldersLen) * 3 / 4 - placeHoldersLen;
+    }
+    __name(_byteLength, "_byteLength");
+    function toByteArray(b64) {
+      var tmp;
+      var lens = getLens(b64);
+      var validLen = lens[0];
+      var placeHoldersLen = lens[1];
+      var arr = new Arr(_byteLength(b64, validLen, placeHoldersLen));
+      var curByte = 0;
+      var len2 = placeHoldersLen > 0 ? validLen - 4 : validLen;
+      var i2;
+      for (i2 = 0; i2 < len2; i2 += 4) {
+        tmp = revLookup[b64.charCodeAt(i2)] << 18 | revLookup[b64.charCodeAt(i2 + 1)] << 12 | revLookup[b64.charCodeAt(i2 + 2)] << 6 | revLookup[b64.charCodeAt(i2 + 3)];
+        arr[curByte++] = tmp >> 16 & 255;
+        arr[curByte++] = tmp >> 8 & 255;
+        arr[curByte++] = tmp & 255;
+      }
+      if (placeHoldersLen === 2) {
+        tmp = revLookup[b64.charCodeAt(i2)] << 2 | revLookup[b64.charCodeAt(i2 + 1)] >> 4;
+        arr[curByte++] = tmp & 255;
+      }
+      if (placeHoldersLen === 1) {
+        tmp = revLookup[b64.charCodeAt(i2)] << 10 | revLookup[b64.charCodeAt(i2 + 1)] << 4 | revLookup[b64.charCodeAt(i2 + 2)] >> 2;
+        arr[curByte++] = tmp >> 8 & 255;
+        arr[curByte++] = tmp & 255;
+      }
+      return arr;
+    }
+    __name(toByteArray, "toByteArray");
+    function tripletToBase64(num) {
+      return lookup[num >> 18 & 63] + lookup[num >> 12 & 63] + lookup[num >> 6 & 63] + lookup[num & 63];
+    }
+    __name(tripletToBase64, "tripletToBase64");
+    function encodeChunk(uint8, start, end) {
+      var tmp;
+      var output = [];
+      for (var i2 = start; i2 < end; i2 += 3) {
+        tmp = (uint8[i2] << 16 & 16711680) + (uint8[i2 + 1] << 8 & 65280) + (uint8[i2 + 2] & 255);
+        output.push(tripletToBase64(tmp));
+      }
+      return output.join("");
+    }
+    __name(encodeChunk, "encodeChunk");
+    function fromByteArray(uint8) {
+      var tmp;
+      var len2 = uint8.length;
+      var extraBytes = len2 % 3;
+      var parts = [];
+      var maxChunkLength = 16383;
+      for (var i2 = 0, len22 = len2 - extraBytes; i2 < len22; i2 += maxChunkLength) {
+        parts.push(encodeChunk(uint8, i2, i2 + maxChunkLength > len22 ? len22 : i2 + maxChunkLength));
+      }
+      if (extraBytes === 1) {
+        tmp = uint8[len2 - 1];
+        parts.push(lookup[tmp >> 2] + lookup[tmp << 4 & 63] + "==");
+      } else if (extraBytes === 2) {
+        tmp = (uint8[len2 - 2] << 8) + uint8[len2 - 1];
+        parts.push(lookup[tmp >> 10] + lookup[tmp >> 4 & 63] + lookup[tmp << 2 & 63] + "=");
+      }
+      return parts.join("");
+    }
+    __name(fromByteArray, "fromByteArray");
+  }
+});
+
+// ../../node_modules/.pnpm/ieee754@1.2.1/node_modules/ieee754/index.js
+var require_ieee754 = __commonJS({
+  "../../node_modules/.pnpm/ieee754@1.2.1/node_modules/ieee754/index.js"(exports) {
+    exports.read = function(buffer2, offset, isLE, mLen, nBytes) {
+      var e, m;
+      var eLen = nBytes * 8 - mLen - 1;
+      var eMax = (1 << eLen) - 1;
+      var eBias = eMax >> 1;
+      var nBits = -7;
+      var i = isLE ? nBytes - 1 : 0;
+      var d = isLE ? -1 : 1;
+      var s = buffer2[offset + i];
+      i += d;
+      e = s & (1 << -nBits) - 1;
+      s >>= -nBits;
+      nBits += eLen;
+      for (; nBits > 0; e = e * 256 + buffer2[offset + i], i += d, nBits -= 8) {
+      }
+      m = e & (1 << -nBits) - 1;
+      e >>= -nBits;
+      nBits += mLen;
+      for (; nBits > 0; m = m * 256 + buffer2[offset + i], i += d, nBits -= 8) {
+      }
+      if (e === 0) {
+        e = 1 - eBias;
+      } else if (e === eMax) {
+        return m ? NaN : (s ? -1 : 1) * Infinity;
+      } else {
+        m = m + Math.pow(2, mLen);
+        e = e - eBias;
+      }
+      return (s ? -1 : 1) * m * Math.pow(2, e - mLen);
+    };
+    exports.write = function(buffer2, value, offset, isLE, mLen, nBytes) {
+      var e, m, c;
+      var eLen = nBytes * 8 - mLen - 1;
+      var eMax = (1 << eLen) - 1;
+      var eBias = eMax >> 1;
+      var rt = mLen === 23 ? Math.pow(2, -24) - Math.pow(2, -77) : 0;
+      var i = isLE ? 0 : nBytes - 1;
+      var d = isLE ? 1 : -1;
+      var s = value < 0 || value === 0 && 1 / value < 0 ? 1 : 0;
+      value = Math.abs(value);
+      if (isNaN(value) || value === Infinity) {
+        m = isNaN(value) ? 1 : 0;
+        e = eMax;
+      } else {
+        e = Math.floor(Math.log(value) / Math.LN2);
+        if (value * (c = Math.pow(2, -e)) < 1) {
+          e--;
+          c *= 2;
+        }
+        if (e + eBias >= 1) {
+          value += rt / c;
+        } else {
+          value += rt * Math.pow(2, 1 - eBias);
+        }
+        if (value * c >= 2) {
+          e++;
+          c /= 2;
+        }
+        if (e + eBias >= eMax) {
+          m = 0;
+          e = eMax;
+        } else if (e + eBias >= 1) {
+          m = (value * c - 1) * Math.pow(2, mLen);
+          e = e + eBias;
+        } else {
+          m = value * Math.pow(2, eBias - 1) * Math.pow(2, mLen);
+          e = 0;
+        }
+      }
+      for (; mLen >= 8; buffer2[offset + i] = m & 255, i += d, m /= 256, mLen -= 8) {
+      }
+      e = e << mLen | m;
+      eLen += mLen;
+      for (; eLen > 0; buffer2[offset + i] = e & 255, i += d, e /= 256, eLen -= 8) {
+      }
+      buffer2[offset + i - d] |= s * 128;
+    };
+  }
+});
+
+// ../../node_modules/.pnpm/buffer@5.7.1/node_modules/buffer/index.js
+var require_buffer2 = __commonJS({
+  "../../node_modules/.pnpm/buffer@5.7.1/node_modules/buffer/index.js"(exports) {
+    "use strict";
+    var base642 = require_base64_js();
+    var ieee754 = require_ieee754();
+    var customInspectSymbol = typeof Symbol === "function" && typeof Symbol["for"] === "function" ? Symbol["for"]("nodejs.util.inspect.custom") : null;
+    exports.Buffer = Buffer3;
+    exports.SlowBuffer = SlowBuffer;
+    exports.INSPECT_MAX_BYTES = 50;
+    var K_MAX_LENGTH = 2147483647;
+    exports.kMaxLength = K_MAX_LENGTH;
+    Buffer3.TYPED_ARRAY_SUPPORT = typedArraySupport();
+    if (!Buffer3.TYPED_ARRAY_SUPPORT && typeof console !== "undefined" && typeof console.error === "function") {
+      console.error("This browser lacks typed array (Uint8Array) support which is required by `buffer` v5.x. Use `buffer` v4.x if you require old browser support.");
+    }
+    function typedArraySupport() {
+      try {
+        var arr = new Uint8Array(1);
+        var proto = { foo: function() {
+          return 42;
+        } };
+        Object.setPrototypeOf(proto, Uint8Array.prototype);
+        Object.setPrototypeOf(arr, proto);
+        return arr.foo() === 42;
+      } catch (e) {
+        return false;
+      }
+    }
+    __name(typedArraySupport, "typedArraySupport");
+    Object.defineProperty(Buffer3.prototype, "parent", {
+      enumerable: true,
+      get: function() {
+        if (!Buffer3.isBuffer(this))
+          return void 0;
+        return this.buffer;
+      }
+    });
+    Object.defineProperty(Buffer3.prototype, "offset", {
+      enumerable: true,
+      get: function() {
+        if (!Buffer3.isBuffer(this))
+          return void 0;
+        return this.byteOffset;
+      }
+    });
+    function createBuffer(length2) {
+      if (length2 > K_MAX_LENGTH) {
+        throw new RangeError('The value "' + length2 + '" is invalid for option "size"');
+      }
+      var buf2 = new Uint8Array(length2);
+      Object.setPrototypeOf(buf2, Buffer3.prototype);
+      return buf2;
+    }
+    __name(createBuffer, "createBuffer");
+    function Buffer3(arg, encodingOrOffset, length2) {
+      if (typeof arg === "number") {
+        if (typeof encodingOrOffset === "string") {
+          throw new TypeError('The "string" argument must be of type string. Received type number');
+        }
+        return allocUnsafe(arg);
+      }
+      return from4(arg, encodingOrOffset, length2);
+    }
+    __name(Buffer3, "Buffer");
+    Buffer3.poolSize = 8192;
+    function from4(value, encodingOrOffset, length2) {
+      if (typeof value === "string") {
+        return fromString6(value, encodingOrOffset);
+      }
+      if (ArrayBuffer.isView(value)) {
+        return fromArrayView(value);
+      }
+      if (value == null) {
+        throw new TypeError("The first argument must be one of type string, Buffer, ArrayBuffer, Array, or Array-like Object. Received type " + typeof value);
+      }
+      if (isInstance(value, ArrayBuffer) || value && isInstance(value.buffer, ArrayBuffer)) {
+        return fromArrayBuffer(value, encodingOrOffset, length2);
+      }
+      if (typeof SharedArrayBuffer !== "undefined" && (isInstance(value, SharedArrayBuffer) || value && isInstance(value.buffer, SharedArrayBuffer))) {
+        return fromArrayBuffer(value, encodingOrOffset, length2);
+      }
+      if (typeof value === "number") {
+        throw new TypeError('The "value" argument must not be of type number. Received type number');
+      }
+      var valueOf = value.valueOf && value.valueOf();
+      if (valueOf != null && valueOf !== value) {
+        return Buffer3.from(valueOf, encodingOrOffset, length2);
+      }
+      var b = fromObject(value);
+      if (b)
+        return b;
+      if (typeof Symbol !== "undefined" && Symbol.toPrimitive != null && typeof value[Symbol.toPrimitive] === "function") {
+        return Buffer3.from(value[Symbol.toPrimitive]("string"), encodingOrOffset, length2);
+      }
+      throw new TypeError("The first argument must be one of type string, Buffer, ArrayBuffer, Array, or Array-like Object. Received type " + typeof value);
+    }
+    __name(from4, "from");
+    Buffer3.from = function(value, encodingOrOffset, length2) {
+      return from4(value, encodingOrOffset, length2);
+    };
+    Object.setPrototypeOf(Buffer3.prototype, Uint8Array.prototype);
+    Object.setPrototypeOf(Buffer3, Uint8Array);
+    function assertSize(size) {
+      if (typeof size !== "number") {
+        throw new TypeError('"size" argument must be of type number');
+      } else if (size < 0) {
+        throw new RangeError('The value "' + size + '" is invalid for option "size"');
+      }
+    }
+    __name(assertSize, "assertSize");
+    function alloc2(size, fill, encoding) {
+      assertSize(size);
+      if (size <= 0) {
+        return createBuffer(size);
+      }
+      if (fill !== void 0) {
+        return typeof encoding === "string" ? createBuffer(size).fill(fill, encoding) : createBuffer(size).fill(fill);
+      }
+      return createBuffer(size);
+    }
+    __name(alloc2, "alloc");
+    Buffer3.alloc = function(size, fill, encoding) {
+      return alloc2(size, fill, encoding);
+    };
+    function allocUnsafe(size) {
+      assertSize(size);
+      return createBuffer(size < 0 ? 0 : checked(size) | 0);
+    }
+    __name(allocUnsafe, "allocUnsafe");
+    Buffer3.allocUnsafe = function(size) {
+      return allocUnsafe(size);
+    };
+    Buffer3.allocUnsafeSlow = function(size) {
+      return allocUnsafe(size);
+    };
+    function fromString6(string2, encoding) {
+      if (typeof encoding !== "string" || encoding === "") {
+        encoding = "utf8";
+      }
+      if (!Buffer3.isEncoding(encoding)) {
+        throw new TypeError("Unknown encoding: " + encoding);
+      }
+      var length2 = byteLength(string2, encoding) | 0;
+      var buf2 = createBuffer(length2);
+      var actual = buf2.write(string2, encoding);
+      if (actual !== length2) {
+        buf2 = buf2.slice(0, actual);
+      }
+      return buf2;
+    }
+    __name(fromString6, "fromString");
+    function fromArrayLike2(array) {
+      var length2 = array.length < 0 ? 0 : checked(array.length) | 0;
+      var buf2 = createBuffer(length2);
+      for (var i = 0; i < length2; i += 1) {
+        buf2[i] = array[i] & 255;
+      }
+      return buf2;
+    }
+    __name(fromArrayLike2, "fromArrayLike");
+    function fromArrayView(arrayView) {
+      if (isInstance(arrayView, Uint8Array)) {
+        var copy = new Uint8Array(arrayView);
+        return fromArrayBuffer(copy.buffer, copy.byteOffset, copy.byteLength);
+      }
+      return fromArrayLike2(arrayView);
+    }
+    __name(fromArrayView, "fromArrayView");
+    function fromArrayBuffer(array, byteOffset, length2) {
+      if (byteOffset < 0 || array.byteLength < byteOffset) {
+        throw new RangeError('"offset" is outside of buffer bounds');
+      }
+      if (array.byteLength < byteOffset + (length2 || 0)) {
+        throw new RangeError('"length" is outside of buffer bounds');
+      }
+      var buf2;
+      if (byteOffset === void 0 && length2 === void 0) {
+        buf2 = new Uint8Array(array);
+      } else if (length2 === void 0) {
+        buf2 = new Uint8Array(array, byteOffset);
+      } else {
+        buf2 = new Uint8Array(array, byteOffset, length2);
+      }
+      Object.setPrototypeOf(buf2, Buffer3.prototype);
+      return buf2;
+    }
+    __name(fromArrayBuffer, "fromArrayBuffer");
+    function fromObject(obj) {
+      if (Buffer3.isBuffer(obj)) {
+        var len = checked(obj.length) | 0;
+        var buf2 = createBuffer(len);
+        if (buf2.length === 0) {
+          return buf2;
+        }
+        obj.copy(buf2, 0, 0, len);
+        return buf2;
+      }
+      if (obj.length !== void 0) {
+        if (typeof obj.length !== "number" || numberIsNaN(obj.length)) {
+          return createBuffer(0);
+        }
+        return fromArrayLike2(obj);
+      }
+      if (obj.type === "Buffer" && Array.isArray(obj.data)) {
+        return fromArrayLike2(obj.data);
+      }
+    }
+    __name(fromObject, "fromObject");
+    function checked(length2) {
+      if (length2 >= K_MAX_LENGTH) {
+        throw new RangeError("Attempt to allocate Buffer larger than maximum size: 0x" + K_MAX_LENGTH.toString(16) + " bytes");
+      }
+      return length2 | 0;
+    }
+    __name(checked, "checked");
+    function SlowBuffer(length2) {
+      if (+length2 != length2) {
+        length2 = 0;
+      }
+      return Buffer3.alloc(+length2);
+    }
+    __name(SlowBuffer, "SlowBuffer");
+    Buffer3.isBuffer = /* @__PURE__ */ __name(function isBuffer3(b) {
+      return b != null && b._isBuffer === true && b !== Buffer3.prototype;
+    }, "isBuffer");
+    Buffer3.compare = /* @__PURE__ */ __name(function compare4(a, b) {
+      if (isInstance(a, Uint8Array))
+        a = Buffer3.from(a, a.offset, a.byteLength);
+      if (isInstance(b, Uint8Array))
+        b = Buffer3.from(b, b.offset, b.byteLength);
+      if (!Buffer3.isBuffer(a) || !Buffer3.isBuffer(b)) {
+        throw new TypeError('The "buf1", "buf2" arguments must be one of type Buffer or Uint8Array');
+      }
+      if (a === b)
+        return 0;
+      var x = a.length;
+      var y = b.length;
+      for (var i = 0, len = Math.min(x, y); i < len; ++i) {
+        if (a[i] !== b[i]) {
+          x = a[i];
+          y = b[i];
+          break;
+        }
+      }
+      if (x < y)
+        return -1;
+      if (y < x)
+        return 1;
+      return 0;
+    }, "compare");
+    Buffer3.isEncoding = /* @__PURE__ */ __name(function isEncoding(encoding) {
+      switch (String(encoding).toLowerCase()) {
+        case "hex":
+        case "utf8":
+        case "utf-8":
+        case "ascii":
+        case "latin1":
+        case "binary":
+        case "base64":
+        case "ucs2":
+        case "ucs-2":
+        case "utf16le":
+        case "utf-16le":
+          return true;
+        default:
+          return false;
+      }
+    }, "isEncoding");
+    Buffer3.concat = /* @__PURE__ */ __name(function concat4(list, length2) {
+      if (!Array.isArray(list)) {
+        throw new TypeError('"list" argument must be an Array of Buffers');
+      }
+      if (list.length === 0) {
+        return Buffer3.alloc(0);
+      }
+      var i;
+      if (length2 === void 0) {
+        length2 = 0;
+        for (i = 0; i < list.length; ++i) {
+          length2 += list[i].length;
+        }
+      }
+      var buffer2 = Buffer3.allocUnsafe(length2);
+      var pos = 0;
+      for (i = 0; i < list.length; ++i) {
+        var buf2 = list[i];
+        if (isInstance(buf2, Uint8Array)) {
+          if (pos + buf2.length > buffer2.length) {
+            Buffer3.from(buf2).copy(buffer2, pos);
+          } else {
+            Uint8Array.prototype.set.call(buffer2, buf2, pos);
+          }
+        } else if (!Buffer3.isBuffer(buf2)) {
+          throw new TypeError('"list" argument must be an Array of Buffers');
+        } else {
+          buf2.copy(buffer2, pos);
+        }
+        pos += buf2.length;
+      }
+      return buffer2;
+    }, "concat");
+    function byteLength(string2, encoding) {
+      if (Buffer3.isBuffer(string2)) {
+        return string2.length;
+      }
+      if (ArrayBuffer.isView(string2) || isInstance(string2, ArrayBuffer)) {
+        return string2.byteLength;
+      }
+      if (typeof string2 !== "string") {
+        throw new TypeError('The "string" argument must be one of type string, Buffer, or ArrayBuffer. Received type ' + typeof string2);
+      }
+      var len = string2.length;
+      var mustMatch = arguments.length > 2 && arguments[2] === true;
+      if (!mustMatch && len === 0)
+        return 0;
+      var loweredCase = false;
+      for (; ; ) {
+        switch (encoding) {
+          case "ascii":
+          case "latin1":
+          case "binary":
+            return len;
+          case "utf8":
+          case "utf-8":
+            return utf8ToBytes2(string2).length;
+          case "ucs2":
+          case "ucs-2":
+          case "utf16le":
+          case "utf-16le":
+            return len * 2;
+          case "hex":
+            return len >>> 1;
+          case "base64":
+            return base64ToBytes2(string2).length;
+          default:
+            if (loweredCase) {
+              return mustMatch ? -1 : utf8ToBytes2(string2).length;
+            }
+            encoding = ("" + encoding).toLowerCase();
+            loweredCase = true;
+        }
+      }
+    }
+    __name(byteLength, "byteLength");
+    Buffer3.byteLength = byteLength;
+    function slowToString(encoding, start, end) {
+      var loweredCase = false;
+      if (start === void 0 || start < 0) {
+        start = 0;
+      }
+      if (start > this.length) {
+        return "";
+      }
+      if (end === void 0 || end > this.length) {
+        end = this.length;
+      }
+      if (end <= 0) {
+        return "";
+      }
+      end >>>= 0;
+      start >>>= 0;
+      if (end <= start) {
+        return "";
+      }
+      if (!encoding)
+        encoding = "utf8";
+      while (true) {
+        switch (encoding) {
+          case "hex":
+            return hexSlice(this, start, end);
+          case "utf8":
+          case "utf-8":
+            return utf8Slice2(this, start, end);
+          case "ascii":
+            return asciiSlice(this, start, end);
+          case "latin1":
+          case "binary":
+            return latin1Slice(this, start, end);
+          case "base64":
+            return base64Slice(this, start, end);
+          case "ucs2":
+          case "ucs-2":
+          case "utf16le":
+          case "utf-16le":
+            return utf16leSlice(this, start, end);
+          default:
+            if (loweredCase)
+              throw new TypeError("Unknown encoding: " + encoding);
+            encoding = (encoding + "").toLowerCase();
+            loweredCase = true;
+        }
+      }
+    }
+    __name(slowToString, "slowToString");
+    Buffer3.prototype._isBuffer = true;
+    function swap(b, n, m) {
+      var i = b[n];
+      b[n] = b[m];
+      b[m] = i;
+    }
+    __name(swap, "swap");
+    Buffer3.prototype.swap16 = /* @__PURE__ */ __name(function swap16() {
+      var len = this.length;
+      if (len % 2 !== 0) {
+        throw new RangeError("Buffer size must be a multiple of 16-bits");
+      }
+      for (var i = 0; i < len; i += 2) {
+        swap(this, i, i + 1);
+      }
+      return this;
+    }, "swap16");
+    Buffer3.prototype.swap32 = /* @__PURE__ */ __name(function swap32() {
+      var len = this.length;
+      if (len % 4 !== 0) {
+        throw new RangeError("Buffer size must be a multiple of 32-bits");
+      }
+      for (var i = 0; i < len; i += 4) {
+        swap(this, i, i + 3);
+        swap(this, i + 1, i + 2);
+      }
+      return this;
+    }, "swap32");
+    Buffer3.prototype.swap64 = /* @__PURE__ */ __name(function swap64() {
+      var len = this.length;
+      if (len % 8 !== 0) {
+        throw new RangeError("Buffer size must be a multiple of 64-bits");
+      }
+      for (var i = 0; i < len; i += 8) {
+        swap(this, i, i + 7);
+        swap(this, i + 1, i + 6);
+        swap(this, i + 2, i + 5);
+        swap(this, i + 3, i + 4);
+      }
+      return this;
+    }, "swap64");
+    Buffer3.prototype.toString = /* @__PURE__ */ __name(function toString6() {
+      var length2 = this.length;
+      if (length2 === 0)
+        return "";
+      if (arguments.length === 0)
+        return utf8Slice2(this, 0, length2);
+      return slowToString.apply(this, arguments);
+    }, "toString");
+    Buffer3.prototype.toLocaleString = Buffer3.prototype.toString;
+    Buffer3.prototype.equals = /* @__PURE__ */ __name(function equals4(b) {
+      if (!Buffer3.isBuffer(b))
+        throw new TypeError("Argument must be a Buffer");
+      if (this === b)
+        return true;
+      return Buffer3.compare(this, b) === 0;
+    }, "equals");
+    Buffer3.prototype.inspect = /* @__PURE__ */ __name(function inspect5() {
+      var str = "";
+      var max = exports.INSPECT_MAX_BYTES;
+      str = this.toString("hex", 0, max).replace(/(.{2})/g, "$1 ").trim();
+      if (this.length > max)
+        str += " ... ";
+      return "<Buffer " + str + ">";
+    }, "inspect");
+    if (customInspectSymbol) {
+      Buffer3.prototype[customInspectSymbol] = Buffer3.prototype.inspect;
+    }
+    Buffer3.prototype.compare = /* @__PURE__ */ __name(function compare4(target, start, end, thisStart, thisEnd) {
+      if (isInstance(target, Uint8Array)) {
+        target = Buffer3.from(target, target.offset, target.byteLength);
+      }
+      if (!Buffer3.isBuffer(target)) {
+        throw new TypeError('The "target" argument must be one of type Buffer or Uint8Array. Received type ' + typeof target);
+      }
+      if (start === void 0) {
+        start = 0;
+      }
+      if (end === void 0) {
+        end = target ? target.length : 0;
+      }
+      if (thisStart === void 0) {
+        thisStart = 0;
+      }
+      if (thisEnd === void 0) {
+        thisEnd = this.length;
+      }
+      if (start < 0 || end > target.length || thisStart < 0 || thisEnd > this.length) {
+        throw new RangeError("out of range index");
+      }
+      if (thisStart >= thisEnd && start >= end) {
+        return 0;
+      }
+      if (thisStart >= thisEnd) {
+        return -1;
+      }
+      if (start >= end) {
+        return 1;
+      }
+      start >>>= 0;
+      end >>>= 0;
+      thisStart >>>= 0;
+      thisEnd >>>= 0;
+      if (this === target)
+        return 0;
+      var x = thisEnd - thisStart;
+      var y = end - start;
+      var len = Math.min(x, y);
+      var thisCopy = this.slice(thisStart, thisEnd);
+      var targetCopy = target.slice(start, end);
+      for (var i = 0; i < len; ++i) {
+        if (thisCopy[i] !== targetCopy[i]) {
+          x = thisCopy[i];
+          y = targetCopy[i];
+          break;
+        }
+      }
+      if (x < y)
+        return -1;
+      if (y < x)
+        return 1;
+      return 0;
+    }, "compare");
+    function bidirectionalIndexOf(buffer2, val, byteOffset, encoding, dir) {
+      if (buffer2.length === 0)
+        return -1;
+      if (typeof byteOffset === "string") {
+        encoding = byteOffset;
+        byteOffset = 0;
+      } else if (byteOffset > 2147483647) {
+        byteOffset = 2147483647;
+      } else if (byteOffset < -2147483648) {
+        byteOffset = -2147483648;
+      }
+      byteOffset = +byteOffset;
+      if (numberIsNaN(byteOffset)) {
+        byteOffset = dir ? 0 : buffer2.length - 1;
+      }
+      if (byteOffset < 0)
+        byteOffset = buffer2.length + byteOffset;
+      if (byteOffset >= buffer2.length) {
+        if (dir)
+          return -1;
+        else
+          byteOffset = buffer2.length - 1;
+      } else if (byteOffset < 0) {
+        if (dir)
+          byteOffset = 0;
+        else
+          return -1;
+      }
+      if (typeof val === "string") {
+        val = Buffer3.from(val, encoding);
+      }
+      if (Buffer3.isBuffer(val)) {
+        if (val.length === 0) {
+          return -1;
+        }
+        return arrayIndexOf(buffer2, val, byteOffset, encoding, dir);
+      } else if (typeof val === "number") {
+        val = val & 255;
+        if (typeof Uint8Array.prototype.indexOf === "function") {
+          if (dir) {
+            return Uint8Array.prototype.indexOf.call(buffer2, val, byteOffset);
+          } else {
+            return Uint8Array.prototype.lastIndexOf.call(buffer2, val, byteOffset);
+          }
+        }
+        return arrayIndexOf(buffer2, [val], byteOffset, encoding, dir);
+      }
+      throw new TypeError("val must be string, number or Buffer");
+    }
+    __name(bidirectionalIndexOf, "bidirectionalIndexOf");
+    function arrayIndexOf(arr, val, byteOffset, encoding, dir) {
+      var indexSize = 1;
+      var arrLength = arr.length;
+      var valLength = val.length;
+      if (encoding !== void 0) {
+        encoding = String(encoding).toLowerCase();
+        if (encoding === "ucs2" || encoding === "ucs-2" || encoding === "utf16le" || encoding === "utf-16le") {
+          if (arr.length < 2 || val.length < 2) {
+            return -1;
+          }
+          indexSize = 2;
+          arrLength /= 2;
+          valLength /= 2;
+          byteOffset /= 2;
+        }
+      }
+      function read2(buf2, i2) {
+        if (indexSize === 1) {
+          return buf2[i2];
+        } else {
+          return buf2.readUInt16BE(i2 * indexSize);
+        }
+      }
+      __name(read2, "read");
+      var i;
+      if (dir) {
+        var foundIndex = -1;
+        for (i = byteOffset; i < arrLength; i++) {
+          if (read2(arr, i) === read2(val, foundIndex === -1 ? 0 : i - foundIndex)) {
+            if (foundIndex === -1)
+              foundIndex = i;
+            if (i - foundIndex + 1 === valLength)
+              return foundIndex * indexSize;
+          } else {
+            if (foundIndex !== -1)
+              i -= i - foundIndex;
+            foundIndex = -1;
+          }
+        }
+      } else {
+        if (byteOffset + valLength > arrLength)
+          byteOffset = arrLength - valLength;
+        for (i = byteOffset; i >= 0; i--) {
+          var found = true;
+          for (var j = 0; j < valLength; j++) {
+            if (read2(arr, i + j) !== read2(val, j)) {
+              found = false;
+              break;
+            }
+          }
+          if (found)
+            return i;
+        }
+      }
+      return -1;
+    }
+    __name(arrayIndexOf, "arrayIndexOf");
+    Buffer3.prototype.includes = /* @__PURE__ */ __name(function includes(val, byteOffset, encoding) {
+      return this.indexOf(val, byteOffset, encoding) !== -1;
+    }, "includes");
+    Buffer3.prototype.indexOf = /* @__PURE__ */ __name(function indexOf(val, byteOffset, encoding) {
+      return bidirectionalIndexOf(this, val, byteOffset, encoding, true);
+    }, "indexOf");
+    Buffer3.prototype.lastIndexOf = /* @__PURE__ */ __name(function lastIndexOf(val, byteOffset, encoding) {
+      return bidirectionalIndexOf(this, val, byteOffset, encoding, false);
+    }, "lastIndexOf");
+    function hexWrite(buf2, string2, offset, length2) {
+      offset = Number(offset) || 0;
+      var remaining = buf2.length - offset;
+      if (!length2) {
+        length2 = remaining;
+      } else {
+        length2 = Number(length2);
+        if (length2 > remaining) {
+          length2 = remaining;
+        }
+      }
+      var strLen = string2.length;
+      if (length2 > strLen / 2) {
+        length2 = strLen / 2;
+      }
+      for (var i = 0; i < length2; ++i) {
+        var parsed = parseInt(string2.substr(i * 2, 2), 16);
+        if (numberIsNaN(parsed))
+          return i;
+        buf2[offset + i] = parsed;
+      }
+      return i;
+    }
+    __name(hexWrite, "hexWrite");
+    function utf8Write(buf2, string2, offset, length2) {
+      return blitBuffer(utf8ToBytes2(string2, buf2.length - offset), buf2, offset, length2);
+    }
+    __name(utf8Write, "utf8Write");
+    function asciiWrite(buf2, string2, offset, length2) {
+      return blitBuffer(asciiToBytes(string2), buf2, offset, length2);
+    }
+    __name(asciiWrite, "asciiWrite");
+    function base64Write(buf2, string2, offset, length2) {
+      return blitBuffer(base64ToBytes2(string2), buf2, offset, length2);
+    }
+    __name(base64Write, "base64Write");
+    function ucs2Write(buf2, string2, offset, length2) {
+      return blitBuffer(utf16leToBytes(string2, buf2.length - offset), buf2, offset, length2);
+    }
+    __name(ucs2Write, "ucs2Write");
+    Buffer3.prototype.write = /* @__PURE__ */ __name(function write(string2, offset, length2, encoding) {
+      if (offset === void 0) {
+        encoding = "utf8";
+        length2 = this.length;
+        offset = 0;
+      } else if (length2 === void 0 && typeof offset === "string") {
+        encoding = offset;
+        length2 = this.length;
+        offset = 0;
+      } else if (isFinite(offset)) {
+        offset = offset >>> 0;
+        if (isFinite(length2)) {
+          length2 = length2 >>> 0;
+          if (encoding === void 0)
+            encoding = "utf8";
+        } else {
+          encoding = length2;
+          length2 = void 0;
+        }
+      } else {
+        throw new Error("Buffer.write(string, encoding, offset[, length]) is no longer supported");
+      }
+      var remaining = this.length - offset;
+      if (length2 === void 0 || length2 > remaining)
+        length2 = remaining;
+      if (string2.length > 0 && (length2 < 0 || offset < 0) || offset > this.length) {
+        throw new RangeError("Attempt to write outside buffer bounds");
+      }
+      if (!encoding)
+        encoding = "utf8";
+      var loweredCase = false;
+      for (; ; ) {
+        switch (encoding) {
+          case "hex":
+            return hexWrite(this, string2, offset, length2);
+          case "utf8":
+          case "utf-8":
+            return utf8Write(this, string2, offset, length2);
+          case "ascii":
+          case "latin1":
+          case "binary":
+            return asciiWrite(this, string2, offset, length2);
+          case "base64":
+            return base64Write(this, string2, offset, length2);
+          case "ucs2":
+          case "ucs-2":
+          case "utf16le":
+          case "utf-16le":
+            return ucs2Write(this, string2, offset, length2);
+          default:
+            if (loweredCase)
+              throw new TypeError("Unknown encoding: " + encoding);
+            encoding = ("" + encoding).toLowerCase();
+            loweredCase = true;
+        }
+      }
+    }, "write");
+    Buffer3.prototype.toJSON = /* @__PURE__ */ __name(function toJSON2() {
+      return {
+        type: "Buffer",
+        data: Array.prototype.slice.call(this._arr || this, 0)
+      };
+    }, "toJSON");
+    function base64Slice(buf2, start, end) {
+      if (start === 0 && end === buf2.length) {
+        return base642.fromByteArray(buf2);
+      } else {
+        return base642.fromByteArray(buf2.slice(start, end));
+      }
+    }
+    __name(base64Slice, "base64Slice");
+    function utf8Slice2(buf2, start, end) {
+      end = Math.min(buf2.length, end);
+      var res = [];
+      var i = start;
+      while (i < end) {
+        var firstByte = buf2[i];
+        var codePoint = null;
+        var bytesPerSequence = firstByte > 239 ? 4 : firstByte > 223 ? 3 : firstByte > 191 ? 2 : 1;
+        if (i + bytesPerSequence <= end) {
+          var secondByte, thirdByte, fourthByte, tempCodePoint;
+          switch (bytesPerSequence) {
+            case 1:
+              if (firstByte < 128) {
+                codePoint = firstByte;
+              }
+              break;
+            case 2:
+              secondByte = buf2[i + 1];
+              if ((secondByte & 192) === 128) {
+                tempCodePoint = (firstByte & 31) << 6 | secondByte & 63;
+                if (tempCodePoint > 127) {
+                  codePoint = tempCodePoint;
+                }
+              }
+              break;
+            case 3:
+              secondByte = buf2[i + 1];
+              thirdByte = buf2[i + 2];
+              if ((secondByte & 192) === 128 && (thirdByte & 192) === 128) {
+                tempCodePoint = (firstByte & 15) << 12 | (secondByte & 63) << 6 | thirdByte & 63;
+                if (tempCodePoint > 2047 && (tempCodePoint < 55296 || tempCodePoint > 57343)) {
+                  codePoint = tempCodePoint;
+                }
+              }
+              break;
+            case 4:
+              secondByte = buf2[i + 1];
+              thirdByte = buf2[i + 2];
+              fourthByte = buf2[i + 3];
+              if ((secondByte & 192) === 128 && (thirdByte & 192) === 128 && (fourthByte & 192) === 128) {
+                tempCodePoint = (firstByte & 15) << 18 | (secondByte & 63) << 12 | (thirdByte & 63) << 6 | fourthByte & 63;
+                if (tempCodePoint > 65535 && tempCodePoint < 1114112) {
+                  codePoint = tempCodePoint;
+                }
+              }
+          }
+        }
+        if (codePoint === null) {
+          codePoint = 65533;
+          bytesPerSequence = 1;
+        } else if (codePoint > 65535) {
+          codePoint -= 65536;
+          res.push(codePoint >>> 10 & 1023 | 55296);
+          codePoint = 56320 | codePoint & 1023;
+        }
+        res.push(codePoint);
+        i += bytesPerSequence;
+      }
+      return decodeCodePointsArray2(res);
+    }
+    __name(utf8Slice2, "utf8Slice");
+    var MAX_ARGUMENTS_LENGTH2 = 4096;
+    function decodeCodePointsArray2(codePoints) {
+      var len = codePoints.length;
+      if (len <= MAX_ARGUMENTS_LENGTH2) {
+        return String.fromCharCode.apply(String, codePoints);
+      }
+      var res = "";
+      var i = 0;
+      while (i < len) {
+        res += String.fromCharCode.apply(String, codePoints.slice(i, i += MAX_ARGUMENTS_LENGTH2));
+      }
+      return res;
+    }
+    __name(decodeCodePointsArray2, "decodeCodePointsArray");
+    function asciiSlice(buf2, start, end) {
+      var ret = "";
+      end = Math.min(buf2.length, end);
+      for (var i = start; i < end; ++i) {
+        ret += String.fromCharCode(buf2[i] & 127);
+      }
+      return ret;
+    }
+    __name(asciiSlice, "asciiSlice");
+    function latin1Slice(buf2, start, end) {
+      var ret = "";
+      end = Math.min(buf2.length, end);
+      for (var i = start; i < end; ++i) {
+        ret += String.fromCharCode(buf2[i]);
+      }
+      return ret;
+    }
+    __name(latin1Slice, "latin1Slice");
+    function hexSlice(buf2, start, end) {
+      var len = buf2.length;
+      if (!start || start < 0)
+        start = 0;
+      if (!end || end < 0 || end > len)
+        end = len;
+      var out = "";
+      for (var i = start; i < end; ++i) {
+        out += hexSliceLookupTable[buf2[i]];
+      }
+      return out;
+    }
+    __name(hexSlice, "hexSlice");
+    function utf16leSlice(buf2, start, end) {
+      var bytes = buf2.slice(start, end);
+      var res = "";
+      for (var i = 0; i < bytes.length - 1; i += 2) {
+        res += String.fromCharCode(bytes[i] + bytes[i + 1] * 256);
+      }
+      return res;
+    }
+    __name(utf16leSlice, "utf16leSlice");
+    Buffer3.prototype.slice = /* @__PURE__ */ __name(function slice2(start, end) {
+      var len = this.length;
+      start = ~~start;
+      end = end === void 0 ? len : ~~end;
+      if (start < 0) {
+        start += len;
+        if (start < 0)
+          start = 0;
+      } else if (start > len) {
+        start = len;
+      }
+      if (end < 0) {
+        end += len;
+        if (end < 0)
+          end = 0;
+      } else if (end > len) {
+        end = len;
+      }
+      if (end < start)
+        end = start;
+      var newBuf = this.subarray(start, end);
+      Object.setPrototypeOf(newBuf, Buffer3.prototype);
+      return newBuf;
+    }, "slice");
+    function checkOffset(offset, ext, length2) {
+      if (offset % 1 !== 0 || offset < 0)
+        throw new RangeError("offset is not uint");
+      if (offset + ext > length2)
+        throw new RangeError("Trying to access beyond buffer length");
+    }
+    __name(checkOffset, "checkOffset");
+    Buffer3.prototype.readUintLE = Buffer3.prototype.readUIntLE = /* @__PURE__ */ __name(function readUIntLE(offset, byteLength2, noAssert) {
+      offset = offset >>> 0;
+      byteLength2 = byteLength2 >>> 0;
+      if (!noAssert)
+        checkOffset(offset, byteLength2, this.length);
+      var val = this[offset];
+      var mul3 = 1;
+      var i = 0;
+      while (++i < byteLength2 && (mul3 *= 256)) {
+        val += this[offset + i] * mul3;
+      }
+      return val;
+    }, "readUIntLE");
+    Buffer3.prototype.readUintBE = Buffer3.prototype.readUIntBE = /* @__PURE__ */ __name(function readUIntBE(offset, byteLength2, noAssert) {
+      offset = offset >>> 0;
+      byteLength2 = byteLength2 >>> 0;
+      if (!noAssert) {
+        checkOffset(offset, byteLength2, this.length);
+      }
+      var val = this[offset + --byteLength2];
+      var mul3 = 1;
+      while (byteLength2 > 0 && (mul3 *= 256)) {
+        val += this[offset + --byteLength2] * mul3;
+      }
+      return val;
+    }, "readUIntBE");
+    Buffer3.prototype.readUint8 = Buffer3.prototype.readUInt8 = /* @__PURE__ */ __name(function readUInt8(offset, noAssert) {
+      offset = offset >>> 0;
+      if (!noAssert)
+        checkOffset(offset, 1, this.length);
+      return this[offset];
+    }, "readUInt8");
+    Buffer3.prototype.readUint16LE = Buffer3.prototype.readUInt16LE = /* @__PURE__ */ __name(function readUInt16LE(offset, noAssert) {
+      offset = offset >>> 0;
+      if (!noAssert)
+        checkOffset(offset, 2, this.length);
+      return this[offset] | this[offset + 1] << 8;
+    }, "readUInt16LE");
+    Buffer3.prototype.readUint16BE = Buffer3.prototype.readUInt16BE = /* @__PURE__ */ __name(function readUInt16BE(offset, noAssert) {
+      offset = offset >>> 0;
+      if (!noAssert)
+        checkOffset(offset, 2, this.length);
+      return this[offset] << 8 | this[offset + 1];
+    }, "readUInt16BE");
+    Buffer3.prototype.readUint32LE = Buffer3.prototype.readUInt32LE = /* @__PURE__ */ __name(function readUInt32LE(offset, noAssert) {
+      offset = offset >>> 0;
+      if (!noAssert)
+        checkOffset(offset, 4, this.length);
+      return (this[offset] | this[offset + 1] << 8 | this[offset + 2] << 16) + this[offset + 3] * 16777216;
+    }, "readUInt32LE");
+    Buffer3.prototype.readUint32BE = Buffer3.prototype.readUInt32BE = /* @__PURE__ */ __name(function readUInt32BE(offset, noAssert) {
+      offset = offset >>> 0;
+      if (!noAssert)
+        checkOffset(offset, 4, this.length);
+      return this[offset] * 16777216 + (this[offset + 1] << 16 | this[offset + 2] << 8 | this[offset + 3]);
+    }, "readUInt32BE");
+    Buffer3.prototype.readIntLE = /* @__PURE__ */ __name(function readIntLE(offset, byteLength2, noAssert) {
+      offset = offset >>> 0;
+      byteLength2 = byteLength2 >>> 0;
+      if (!noAssert)
+        checkOffset(offset, byteLength2, this.length);
+      var val = this[offset];
+      var mul3 = 1;
+      var i = 0;
+      while (++i < byteLength2 && (mul3 *= 256)) {
+        val += this[offset + i] * mul3;
+      }
+      mul3 *= 128;
+      if (val >= mul3)
+        val -= Math.pow(2, 8 * byteLength2);
+      return val;
+    }, "readIntLE");
+    Buffer3.prototype.readIntBE = /* @__PURE__ */ __name(function readIntBE(offset, byteLength2, noAssert) {
+      offset = offset >>> 0;
+      byteLength2 = byteLength2 >>> 0;
+      if (!noAssert)
+        checkOffset(offset, byteLength2, this.length);
+      var i = byteLength2;
+      var mul3 = 1;
+      var val = this[offset + --i];
+      while (i > 0 && (mul3 *= 256)) {
+        val += this[offset + --i] * mul3;
+      }
+      mul3 *= 128;
+      if (val >= mul3)
+        val -= Math.pow(2, 8 * byteLength2);
+      return val;
+    }, "readIntBE");
+    Buffer3.prototype.readInt8 = /* @__PURE__ */ __name(function readInt8(offset, noAssert) {
+      offset = offset >>> 0;
+      if (!noAssert)
+        checkOffset(offset, 1, this.length);
+      if (!(this[offset] & 128))
+        return this[offset];
+      return (255 - this[offset] + 1) * -1;
+    }, "readInt8");
+    Buffer3.prototype.readInt16LE = /* @__PURE__ */ __name(function readInt16LE(offset, noAssert) {
+      offset = offset >>> 0;
+      if (!noAssert)
+        checkOffset(offset, 2, this.length);
+      var val = this[offset] | this[offset + 1] << 8;
+      return val & 32768 ? val | 4294901760 : val;
+    }, "readInt16LE");
+    Buffer3.prototype.readInt16BE = /* @__PURE__ */ __name(function readInt16BE(offset, noAssert) {
+      offset = offset >>> 0;
+      if (!noAssert)
+        checkOffset(offset, 2, this.length);
+      var val = this[offset + 1] | this[offset] << 8;
+      return val & 32768 ? val | 4294901760 : val;
+    }, "readInt16BE");
+    Buffer3.prototype.readInt32LE = /* @__PURE__ */ __name(function readInt32LE(offset, noAssert) {
+      offset = offset >>> 0;
+      if (!noAssert)
+        checkOffset(offset, 4, this.length);
+      return this[offset] | this[offset + 1] << 8 | this[offset + 2] << 16 | this[offset + 3] << 24;
+    }, "readInt32LE");
+    Buffer3.prototype.readInt32BE = /* @__PURE__ */ __name(function readInt32BE(offset, noAssert) {
+      offset = offset >>> 0;
+      if (!noAssert)
+        checkOffset(offset, 4, this.length);
+      return this[offset] << 24 | this[offset + 1] << 16 | this[offset + 2] << 8 | this[offset + 3];
+    }, "readInt32BE");
+    Buffer3.prototype.readFloatLE = /* @__PURE__ */ __name(function readFloatLE(offset, noAssert) {
+      offset = offset >>> 0;
+      if (!noAssert)
+        checkOffset(offset, 4, this.length);
+      return ieee754.read(this, offset, true, 23, 4);
+    }, "readFloatLE");
+    Buffer3.prototype.readFloatBE = /* @__PURE__ */ __name(function readFloatBE(offset, noAssert) {
+      offset = offset >>> 0;
+      if (!noAssert)
+        checkOffset(offset, 4, this.length);
+      return ieee754.read(this, offset, false, 23, 4);
+    }, "readFloatBE");
+    Buffer3.prototype.readDoubleLE = /* @__PURE__ */ __name(function readDoubleLE(offset, noAssert) {
+      offset = offset >>> 0;
+      if (!noAssert)
+        checkOffset(offset, 8, this.length);
+      return ieee754.read(this, offset, true, 52, 8);
+    }, "readDoubleLE");
+    Buffer3.prototype.readDoubleBE = /* @__PURE__ */ __name(function readDoubleBE(offset, noAssert) {
+      offset = offset >>> 0;
+      if (!noAssert)
+        checkOffset(offset, 8, this.length);
+      return ieee754.read(this, offset, false, 52, 8);
+    }, "readDoubleBE");
+    function checkInt(buf2, value, offset, ext, max, min) {
+      if (!Buffer3.isBuffer(buf2))
+        throw new TypeError('"buffer" argument must be a Buffer instance');
+      if (value > max || value < min)
+        throw new RangeError('"value" argument is out of bounds');
+      if (offset + ext > buf2.length)
+        throw new RangeError("Index out of range");
+    }
+    __name(checkInt, "checkInt");
+    Buffer3.prototype.writeUintLE = Buffer3.prototype.writeUIntLE = /* @__PURE__ */ __name(function writeUIntLE(value, offset, byteLength2, noAssert) {
+      value = +value;
+      offset = offset >>> 0;
+      byteLength2 = byteLength2 >>> 0;
+      if (!noAssert) {
+        var maxBytes = Math.pow(2, 8 * byteLength2) - 1;
+        checkInt(this, value, offset, byteLength2, maxBytes, 0);
+      }
+      var mul3 = 1;
+      var i = 0;
+      this[offset] = value & 255;
+      while (++i < byteLength2 && (mul3 *= 256)) {
+        this[offset + i] = value / mul3 & 255;
+      }
+      return offset + byteLength2;
+    }, "writeUIntLE");
+    Buffer3.prototype.writeUintBE = Buffer3.prototype.writeUIntBE = /* @__PURE__ */ __name(function writeUIntBE(value, offset, byteLength2, noAssert) {
+      value = +value;
+      offset = offset >>> 0;
+      byteLength2 = byteLength2 >>> 0;
+      if (!noAssert) {
+        var maxBytes = Math.pow(2, 8 * byteLength2) - 1;
+        checkInt(this, value, offset, byteLength2, maxBytes, 0);
+      }
+      var i = byteLength2 - 1;
+      var mul3 = 1;
+      this[offset + i] = value & 255;
+      while (--i >= 0 && (mul3 *= 256)) {
+        this[offset + i] = value / mul3 & 255;
+      }
+      return offset + byteLength2;
+    }, "writeUIntBE");
+    Buffer3.prototype.writeUint8 = Buffer3.prototype.writeUInt8 = /* @__PURE__ */ __name(function writeUInt8(value, offset, noAssert) {
+      value = +value;
+      offset = offset >>> 0;
+      if (!noAssert)
+        checkInt(this, value, offset, 1, 255, 0);
+      this[offset] = value & 255;
+      return offset + 1;
+    }, "writeUInt8");
+    Buffer3.prototype.writeUint16LE = Buffer3.prototype.writeUInt16LE = /* @__PURE__ */ __name(function writeUInt16LE(value, offset, noAssert) {
+      value = +value;
+      offset = offset >>> 0;
+      if (!noAssert)
+        checkInt(this, value, offset, 2, 65535, 0);
+      this[offset] = value & 255;
+      this[offset + 1] = value >>> 8;
+      return offset + 2;
+    }, "writeUInt16LE");
+    Buffer3.prototype.writeUint16BE = Buffer3.prototype.writeUInt16BE = /* @__PURE__ */ __name(function writeUInt16BE(value, offset, noAssert) {
+      value = +value;
+      offset = offset >>> 0;
+      if (!noAssert)
+        checkInt(this, value, offset, 2, 65535, 0);
+      this[offset] = value >>> 8;
+      this[offset + 1] = value & 255;
+      return offset + 2;
+    }, "writeUInt16BE");
+    Buffer3.prototype.writeUint32LE = Buffer3.prototype.writeUInt32LE = /* @__PURE__ */ __name(function writeUInt32LE(value, offset, noAssert) {
+      value = +value;
+      offset = offset >>> 0;
+      if (!noAssert)
+        checkInt(this, value, offset, 4, 4294967295, 0);
+      this[offset + 3] = value >>> 24;
+      this[offset + 2] = value >>> 16;
+      this[offset + 1] = value >>> 8;
+      this[offset] = value & 255;
+      return offset + 4;
+    }, "writeUInt32LE");
+    Buffer3.prototype.writeUint32BE = Buffer3.prototype.writeUInt32BE = /* @__PURE__ */ __name(function writeUInt32BE(value, offset, noAssert) {
+      value = +value;
+      offset = offset >>> 0;
+      if (!noAssert)
+        checkInt(this, value, offset, 4, 4294967295, 0);
+      this[offset] = value >>> 24;
+      this[offset + 1] = value >>> 16;
+      this[offset + 2] = value >>> 8;
+      this[offset + 3] = value & 255;
+      return offset + 4;
+    }, "writeUInt32BE");
+    Buffer3.prototype.writeIntLE = /* @__PURE__ */ __name(function writeIntLE(value, offset, byteLength2, noAssert) {
+      value = +value;
+      offset = offset >>> 0;
+      if (!noAssert) {
+        var limit = Math.pow(2, 8 * byteLength2 - 1);
+        checkInt(this, value, offset, byteLength2, limit - 1, -limit);
+      }
+      var i = 0;
+      var mul3 = 1;
+      var sub = 0;
+      this[offset] = value & 255;
+      while (++i < byteLength2 && (mul3 *= 256)) {
+        if (value < 0 && sub === 0 && this[offset + i - 1] !== 0) {
+          sub = 1;
+        }
+        this[offset + i] = (value / mul3 >> 0) - sub & 255;
+      }
+      return offset + byteLength2;
+    }, "writeIntLE");
+    Buffer3.prototype.writeIntBE = /* @__PURE__ */ __name(function writeIntBE(value, offset, byteLength2, noAssert) {
+      value = +value;
+      offset = offset >>> 0;
+      if (!noAssert) {
+        var limit = Math.pow(2, 8 * byteLength2 - 1);
+        checkInt(this, value, offset, byteLength2, limit - 1, -limit);
+      }
+      var i = byteLength2 - 1;
+      var mul3 = 1;
+      var sub = 0;
+      this[offset + i] = value & 255;
+      while (--i >= 0 && (mul3 *= 256)) {
+        if (value < 0 && sub === 0 && this[offset + i + 1] !== 0) {
+          sub = 1;
+        }
+        this[offset + i] = (value / mul3 >> 0) - sub & 255;
+      }
+      return offset + byteLength2;
+    }, "writeIntBE");
+    Buffer3.prototype.writeInt8 = /* @__PURE__ */ __name(function writeInt8(value, offset, noAssert) {
+      value = +value;
+      offset = offset >>> 0;
+      if (!noAssert)
+        checkInt(this, value, offset, 1, 127, -128);
+      if (value < 0)
+        value = 255 + value + 1;
+      this[offset] = value & 255;
+      return offset + 1;
+    }, "writeInt8");
+    Buffer3.prototype.writeInt16LE = /* @__PURE__ */ __name(function writeInt16LE(value, offset, noAssert) {
+      value = +value;
+      offset = offset >>> 0;
+      if (!noAssert)
+        checkInt(this, value, offset, 2, 32767, -32768);
+      this[offset] = value & 255;
+      this[offset + 1] = value >>> 8;
+      return offset + 2;
+    }, "writeInt16LE");
+    Buffer3.prototype.writeInt16BE = /* @__PURE__ */ __name(function writeInt16BE(value, offset, noAssert) {
+      value = +value;
+      offset = offset >>> 0;
+      if (!noAssert)
+        checkInt(this, value, offset, 2, 32767, -32768);
+      this[offset] = value >>> 8;
+      this[offset + 1] = value & 255;
+      return offset + 2;
+    }, "writeInt16BE");
+    Buffer3.prototype.writeInt32LE = /* @__PURE__ */ __name(function writeInt32LE(value, offset, noAssert) {
+      value = +value;
+      offset = offset >>> 0;
+      if (!noAssert)
+        checkInt(this, value, offset, 4, 2147483647, -2147483648);
+      this[offset] = value & 255;
+      this[offset + 1] = value >>> 8;
+      this[offset + 2] = value >>> 16;
+      this[offset + 3] = value >>> 24;
+      return offset + 4;
+    }, "writeInt32LE");
+    Buffer3.prototype.writeInt32BE = /* @__PURE__ */ __name(function writeInt32BE(value, offset, noAssert) {
+      value = +value;
+      offset = offset >>> 0;
+      if (!noAssert)
+        checkInt(this, value, offset, 4, 2147483647, -2147483648);
+      if (value < 0)
+        value = 4294967295 + value + 1;
+      this[offset] = value >>> 24;
+      this[offset + 1] = value >>> 16;
+      this[offset + 2] = value >>> 8;
+      this[offset + 3] = value & 255;
+      return offset + 4;
+    }, "writeInt32BE");
+    function checkIEEE754(buf2, value, offset, ext, max, min) {
+      if (offset + ext > buf2.length)
+        throw new RangeError("Index out of range");
+      if (offset < 0)
+        throw new RangeError("Index out of range");
+    }
+    __name(checkIEEE754, "checkIEEE754");
+    function writeFloat(buf2, value, offset, littleEndian, noAssert) {
+      value = +value;
+      offset = offset >>> 0;
+      if (!noAssert) {
+        checkIEEE754(buf2, value, offset, 4, 34028234663852886e22, -34028234663852886e22);
+      }
+      ieee754.write(buf2, value, offset, littleEndian, 23, 4);
+      return offset + 4;
+    }
+    __name(writeFloat, "writeFloat");
+    Buffer3.prototype.writeFloatLE = /* @__PURE__ */ __name(function writeFloatLE(value, offset, noAssert) {
+      return writeFloat(this, value, offset, true, noAssert);
+    }, "writeFloatLE");
+    Buffer3.prototype.writeFloatBE = /* @__PURE__ */ __name(function writeFloatBE(value, offset, noAssert) {
+      return writeFloat(this, value, offset, false, noAssert);
+    }, "writeFloatBE");
+    function writeDouble(buf2, value, offset, littleEndian, noAssert) {
+      value = +value;
+      offset = offset >>> 0;
+      if (!noAssert) {
+        checkIEEE754(buf2, value, offset, 8, 17976931348623157e292, -17976931348623157e292);
+      }
+      ieee754.write(buf2, value, offset, littleEndian, 52, 8);
+      return offset + 8;
+    }
+    __name(writeDouble, "writeDouble");
+    Buffer3.prototype.writeDoubleLE = /* @__PURE__ */ __name(function writeDoubleLE(value, offset, noAssert) {
+      return writeDouble(this, value, offset, true, noAssert);
+    }, "writeDoubleLE");
+    Buffer3.prototype.writeDoubleBE = /* @__PURE__ */ __name(function writeDoubleBE(value, offset, noAssert) {
+      return writeDouble(this, value, offset, false, noAssert);
+    }, "writeDoubleBE");
+    Buffer3.prototype.copy = /* @__PURE__ */ __name(function copy(target, targetStart, start, end) {
+      if (!Buffer3.isBuffer(target))
+        throw new TypeError("argument should be a Buffer");
+      if (!start)
+        start = 0;
+      if (!end && end !== 0)
+        end = this.length;
+      if (targetStart >= target.length)
+        targetStart = target.length;
+      if (!targetStart)
+        targetStart = 0;
+      if (end > 0 && end < start)
+        end = start;
+      if (end === start)
+        return 0;
+      if (target.length === 0 || this.length === 0)
+        return 0;
+      if (targetStart < 0) {
+        throw new RangeError("targetStart out of bounds");
+      }
+      if (start < 0 || start >= this.length)
+        throw new RangeError("Index out of range");
+      if (end < 0)
+        throw new RangeError("sourceEnd out of bounds");
+      if (end > this.length)
+        end = this.length;
+      if (target.length - targetStart < end - start) {
+        end = target.length - targetStart + start;
+      }
+      var len = end - start;
+      if (this === target && typeof Uint8Array.prototype.copyWithin === "function") {
+        this.copyWithin(targetStart, start, end);
+      } else {
+        Uint8Array.prototype.set.call(target, this.subarray(start, end), targetStart);
+      }
+      return len;
+    }, "copy");
+    Buffer3.prototype.fill = /* @__PURE__ */ __name(function fill(val, start, end, encoding) {
+      if (typeof val === "string") {
+        if (typeof start === "string") {
+          encoding = start;
+          start = 0;
+          end = this.length;
+        } else if (typeof end === "string") {
+          encoding = end;
+          end = this.length;
+        }
+        if (encoding !== void 0 && typeof encoding !== "string") {
+          throw new TypeError("encoding must be a string");
+        }
+        if (typeof encoding === "string" && !Buffer3.isEncoding(encoding)) {
+          throw new TypeError("Unknown encoding: " + encoding);
+        }
+        if (val.length === 1) {
+          var code5 = val.charCodeAt(0);
+          if (encoding === "utf8" && code5 < 128 || encoding === "latin1") {
+            val = code5;
+          }
+        }
+      } else if (typeof val === "number") {
+        val = val & 255;
+      } else if (typeof val === "boolean") {
+        val = Number(val);
+      }
+      if (start < 0 || this.length < start || this.length < end) {
+        throw new RangeError("Out of range index");
+      }
+      if (end <= start) {
+        return this;
+      }
+      start = start >>> 0;
+      end = end === void 0 ? this.length : end >>> 0;
+      if (!val)
+        val = 0;
+      var i;
+      if (typeof val === "number") {
+        for (i = start; i < end; ++i) {
+          this[i] = val;
+        }
+      } else {
+        var bytes = Buffer3.isBuffer(val) ? val : Buffer3.from(val, encoding);
+        var len = bytes.length;
+        if (len === 0) {
+          throw new TypeError('The value "' + val + '" is invalid for argument "value"');
+        }
+        for (i = 0; i < end - start; ++i) {
+          this[i + start] = bytes[i % len];
+        }
+      }
+      return this;
+    }, "fill");
+    var INVALID_BASE64_RE = /[^+/0-9A-Za-z-_]/g;
+    function base64clean(str) {
+      str = str.split("=")[0];
+      str = str.trim().replace(INVALID_BASE64_RE, "");
+      if (str.length < 2)
+        return "";
+      while (str.length % 4 !== 0) {
+        str = str + "=";
+      }
+      return str;
+    }
+    __name(base64clean, "base64clean");
+    function utf8ToBytes2(string2, units) {
+      units = units || Infinity;
+      var codePoint;
+      var length2 = string2.length;
+      var leadSurrogate = null;
+      var bytes = [];
+      for (var i = 0; i < length2; ++i) {
+        codePoint = string2.charCodeAt(i);
+        if (codePoint > 55295 && codePoint < 57344) {
+          if (!leadSurrogate) {
+            if (codePoint > 56319) {
+              if ((units -= 3) > -1)
+                bytes.push(239, 191, 189);
+              continue;
+            } else if (i + 1 === length2) {
+              if ((units -= 3) > -1)
+                bytes.push(239, 191, 189);
+              continue;
+            }
+            leadSurrogate = codePoint;
+            continue;
+          }
+          if (codePoint < 56320) {
+            if ((units -= 3) > -1)
+              bytes.push(239, 191, 189);
+            leadSurrogate = codePoint;
+            continue;
+          }
+          codePoint = (leadSurrogate - 55296 << 10 | codePoint - 56320) + 65536;
+        } else if (leadSurrogate) {
+          if ((units -= 3) > -1)
+            bytes.push(239, 191, 189);
+        }
+        leadSurrogate = null;
+        if (codePoint < 128) {
+          if ((units -= 1) < 0)
+            break;
+          bytes.push(codePoint);
+        } else if (codePoint < 2048) {
+          if ((units -= 2) < 0)
+            break;
+          bytes.push(codePoint >> 6 | 192, codePoint & 63 | 128);
+        } else if (codePoint < 65536) {
+          if ((units -= 3) < 0)
+            break;
+          bytes.push(codePoint >> 12 | 224, codePoint >> 6 & 63 | 128, codePoint & 63 | 128);
+        } else if (codePoint < 1114112) {
+          if ((units -= 4) < 0)
+            break;
+          bytes.push(codePoint >> 18 | 240, codePoint >> 12 & 63 | 128, codePoint >> 6 & 63 | 128, codePoint & 63 | 128);
+        } else {
+          throw new Error("Invalid code point");
+        }
+      }
+      return bytes;
+    }
+    __name(utf8ToBytes2, "utf8ToBytes");
+    function asciiToBytes(str) {
+      var byteArray = [];
+      for (var i = 0; i < str.length; ++i) {
+        byteArray.push(str.charCodeAt(i) & 255);
+      }
+      return byteArray;
+    }
+    __name(asciiToBytes, "asciiToBytes");
+    function utf16leToBytes(str, units) {
+      var c, hi, lo;
+      var byteArray = [];
+      for (var i = 0; i < str.length; ++i) {
+        if ((units -= 2) < 0)
+          break;
+        c = str.charCodeAt(i);
+        hi = c >> 8;
+        lo = c % 256;
+        byteArray.push(lo);
+        byteArray.push(hi);
+      }
+      return byteArray;
+    }
+    __name(utf16leToBytes, "utf16leToBytes");
+    function base64ToBytes2(str) {
+      return base642.toByteArray(base64clean(str));
+    }
+    __name(base64ToBytes2, "base64ToBytes");
+    function blitBuffer(src2, dst, offset, length2) {
+      for (var i = 0; i < length2; ++i) {
+        if (i + offset >= dst.length || i >= src2.length)
+          break;
+        dst[i + offset] = src2[i];
+      }
+      return i;
+    }
+    __name(blitBuffer, "blitBuffer");
+    function isInstance(obj, type) {
+      return obj instanceof type || obj != null && obj.constructor != null && obj.constructor.name != null && obj.constructor.name === type.name;
+    }
+    __name(isInstance, "isInstance");
+    function numberIsNaN(obj) {
+      return obj !== obj;
+    }
+    __name(numberIsNaN, "numberIsNaN");
+    var hexSliceLookupTable = function() {
+      var alphabet3 = "0123456789abcdef";
+      var table = new Array(256);
+      for (var i = 0; i < 16; ++i) {
+        var i16 = i * 16;
+        for (var j = 0; j < 16; ++j) {
+          table[i16 + j] = alphabet3[i] + alphabet3[j];
+        }
+      }
+      return table;
+    }();
+  }
+});
+
 // src/wallet/plugins/EthereumPlugin/erc20.abi.json
 var require_erc20_abi = __commonJS({
   "src/wallet/plugins/EthereumPlugin/erc20.abi.json"(exports, module2) {
@@ -35270,6 +36931,7 @@ __export(src_exports2, {
   ExpirationPlugin: () => ExpirationPlugin,
   emptyWallet: () => emptyWallet,
   generateWallet: () => generateWallet,
+  getCHAPIPlugin: () => getCHAPIPlugin,
   getDidKeyPlugin: () => getDidKeyPlugin,
   getDidKitPlugin: () => getDidKitPlugin,
   getEthereumPlugin: () => getEthereumPlugin,
@@ -36092,20 +37754,20 @@ var getDidKitPlugin = /* @__PURE__ */ __name((input) => __async(void 0, null, fu
       issueCredential: (_wallet, credential, options, keypair) => __async(void 0, null, function* () {
         return JSON.parse(yield issueCredential(JSON.stringify(credential), JSON.stringify(options), JSON.stringify(keypair)));
       }),
-      verifyCredential: (_wallet, credential) => __async(void 0, null, function* () {
-        return JSON.parse(yield verifyCredential(JSON.stringify(credential), "{}"));
+      verifyCredential: (_0, _1, ..._2) => __async(void 0, [_0, _1, ..._2], function* (_wallet, credential, options = {}) {
+        return JSON.parse(yield verifyCredential(JSON.stringify(credential), JSON.stringify(options)));
       }),
       issuePresentation: (_wallet, presentation, options, keypair) => __async(void 0, null, function* () {
         return JSON.parse(yield issuePresentation(JSON.stringify(presentation), JSON.stringify(options), JSON.stringify(keypair)));
       }),
-      verifyPresentation: (_wallet, presentation) => __async(void 0, null, function* () {
-        return JSON.parse(yield verifyPresentation(JSON.stringify(presentation), "{}"));
+      verifyPresentation: (_0, _1, ..._2) => __async(void 0, [_0, _1, ..._2], function* (_wallet, presentation, options = {}) {
+        return JSON.parse(yield verifyPresentation(JSON.stringify(presentation), JSON.stringify(options)));
       }),
       contextLoader: (_wallet, url) => __async(void 0, null, function* () {
         return JSON.parse(yield contextLoader(url));
       }),
-      resolveDid: (_wallet, did) => __async(void 0, null, function* () {
-        return JSON.parse(yield resolveDID(did, "{}"));
+      resolveDid: (_0, _1, ..._2) => __async(void 0, [_0, _1, ..._2], function* (_wallet, did, inputMetadata = {}) {
+        return JSON.parse(yield resolveDID(did, JSON.stringify(inputMetadata)));
       })
     }
   };
@@ -36126,8 +37788,1492 @@ var ExpirationPlugin = /* @__PURE__ */ __name((wallet) => ({
   }
 }), "ExpirationPlugin");
 
-// src/wallet/helpers/wallet.helpers.ts
-var recycleDependents = /* @__PURE__ */ __name((_methods) => ({}), "recycleDependents");
+// ../../node_modules/.pnpm/web-request-rpc@2.0.0/node_modules/web-request-rpc/utils.js
+var RPC_ERRORS = {
+  ParseError: {
+    message: "Parse error",
+    code: -32700
+  },
+  InvalidRequest: {
+    message: "Invalid Request",
+    code: -32600
+  },
+  MethodNotFound: {
+    message: "Method not found",
+    code: -32601
+  },
+  InvalidParams: {
+    message: "Invalid params",
+    code: -32602
+  },
+  InternalError: {
+    message: "Internal Error",
+    code: -32603
+  },
+  ServerError: {
+    message: "Server error",
+    code: -32e3
+  }
+};
+function parseUrl(url, base4) {
+  if (base4 === void 0) {
+    base4 = window.location.href;
+  }
+  if (typeof URL === "function") {
+    return new URL(url, base4);
+  }
+  if (typeof url !== "string") {
+    throw new TypeError('"url" must be a string.');
+  }
+  if (!url.includes(":")) {
+    if (base4.startsWith("http") && !url.startsWith("/")) {
+      url = base4 + "/" + url;
+    } else {
+      url = base4 + url;
+    }
+  }
+  const parser = document.createElement("a");
+  parser.href = url;
+  let origin = (parser.protocol || window.location.protocol) + "//";
+  if (parser.host) {
+    if (parser.protocol === "http:" && parser.port === "80" || parser.protocol === "https:" && parser.port === "443") {
+      origin += parser.hostname;
+    } else {
+      origin += parser.host;
+    }
+  } else {
+    origin += window.location.host;
+  }
+  let pathname = parser.pathname;
+  if (!pathname.startsWith("/")) {
+    pathname = "/" + pathname;
+  }
+  return {
+    host: parser.host || window.location.host,
+    hostname: parser.hostname,
+    origin,
+    protocol: parser.protocol,
+    pathname
+  };
+}
+__name(parseUrl, "parseUrl");
+function uuidv4(a, b) {
+  for (b = a = ""; a++ < 36; b += a * 51 & 52 ? (a ^ 15 ? 8 ^ Math.random() * (a ^ 20 ? 16 : 4) : 4).toString(16) : "-")
+    ;
+  return b;
+}
+__name(uuidv4, "uuidv4");
+function isValidMessage(message) {
+  return message && typeof message === "object" && message.jsonrpc === "2.0" && message.id && typeof message.id === "string";
+}
+__name(isValidMessage, "isValidMessage");
+function isValidRequest(message) {
+  return isValidMessage(message) && Array.isArray(message.params);
+}
+__name(isValidRequest, "isValidRequest");
+function isValidResponse(message) {
+  return isValidMessage(message) && !!("result" in message ^ "error" in message) && (!("error" in message) || isValidError(message.error));
+}
+__name(isValidResponse, "isValidResponse");
+function isValidError(error) {
+  return error && typeof error === "object" && typeof error.code === "number" && typeof error.message === "string";
+}
+__name(isValidError, "isValidError");
+function serializeError(error) {
+  const err = {
+    message: error.message
+  };
+  if (error.constructor.name !== "Error") {
+    err.constructor = error.constructor.name;
+  }
+  if ("name" in error) {
+    err.name = error.name;
+  }
+  if ("code" in error) {
+    err.code = error.code;
+  } else {
+    err.code = RPC_ERRORS.ServerError.code;
+  }
+  if ("details" in error) {
+    err.details = error.details;
+  }
+  return err;
+}
+__name(serializeError, "serializeError");
+function deserializeError(error) {
+  let err;
+  if (error.constructor === "DOMException") {
+    err = new DOMException(error.message, error.name);
+  } else {
+    err = new Error(error.message);
+    if ("code" in error) {
+      err.code = error.code;
+    }
+  }
+  if (error.details) {
+    err.details = error.details;
+  }
+  return err;
+}
+__name(deserializeError, "deserializeError");
+function createMessageListener({ listener: listener2, origin, handle, expectRequest }) {
+  if (isHandlePromise(handle)) {
+    const promise = handle;
+    handle = false;
+    promise.then((h) => handle = h);
+  }
+  return (e) => {
+    if (!(e.source === handle && e.origin === origin && (expectRequest && isValidRequest(e.data) || !expectRequest && isValidResponse(e.data)))) {
+      return;
+    }
+    listener2(e.data, e);
+  };
+}
+__name(createMessageListener, "createMessageListener");
+function destructureMethodName(fqMethodName) {
+  let [name5, ...rest] = fqMethodName.split(".");
+  const method = rest.pop();
+  name5 = [name5, ...rest].join(".");
+  return { name: name5, method };
+}
+__name(destructureMethodName, "destructureMethodName");
+function isHandlePromise(handle) {
+  try {
+    return typeof handle.then === "function";
+  } catch (e) {
+  }
+  return false;
+}
+__name(isHandlePromise, "isHandlePromise");
+
+// ../../node_modules/.pnpm/web-request-rpc@2.0.0/node_modules/web-request-rpc/Client.js
+var RPC_CLIENT_CALL_TIMEOUT = 3e4;
+var Client = class {
+  constructor() {
+    this.origin = null;
+    this._handle = null;
+    this._listener = null;
+    this._pending = /* @__PURE__ */ new Map();
+  }
+  connect(origin, options) {
+    return __async(this, null, function* () {
+      if (this._listener) {
+        throw new Error("Already connected.");
+      }
+      options = options || {};
+      const self2 = this;
+      self2.origin = parseUrl(origin).origin;
+      self2._handle = options.handle || window.opener || window.parent;
+      const pending = self2._pending;
+      self2._listener = createMessageListener({
+        origin: self2.origin,
+        handle: self2._handle,
+        expectRequest: false,
+        listener: (message) => {
+          if (!pending.has(message.id)) {
+            return;
+          }
+          const { resolve, reject, cancelTimeout } = pending.get(message.id);
+          cancelTimeout();
+          if ("result" in message) {
+            return resolve(message.result);
+          }
+          reject(deserializeError(message.error));
+        }
+      });
+      window.addEventListener("message", self2._listener);
+      return new Injector(self2);
+    });
+  }
+  send(_0, _1, _2) {
+    return __async(this, arguments, function* (qualifiedMethodName, parameters, {
+      timeout = RPC_CLIENT_CALL_TIMEOUT
+    }) {
+      if (!this._listener) {
+        throw new Error("RPC client not connected.");
+      }
+      const self2 = this;
+      const message = {
+        jsonrpc: "2.0",
+        id: uuidv4(),
+        method: qualifiedMethodName,
+        params: parameters
+      };
+      if (isHandlePromise(self2._handle)) {
+        const handle = yield self2._handle;
+        handle.postMessage(message, self2.origin);
+      } else {
+        self2._handle.postMessage(message, self2.origin);
+      }
+      return new Promise((resolve, reject) => {
+        const pending = self2._pending;
+        let cancelTimeout;
+        if (timeout > 0) {
+          const timeoutId = setTimeout(() => {
+            pending.delete(message.id);
+            reject(new Error("RPC call timed out."));
+          }, timeout);
+          cancelTimeout = /* @__PURE__ */ __name(() => {
+            pending.delete(message.id);
+            clearTimeout(timeoutId);
+          }, "cancelTimeout");
+        } else {
+          cancelTimeout = /* @__PURE__ */ __name(() => {
+            pending.delete(message.id);
+          }, "cancelTimeout");
+        }
+        pending.set(message.id, { resolve, reject, cancelTimeout });
+      });
+    });
+  }
+  close() {
+    if (this._listener) {
+      window.removeEventListener("message", this._listener);
+      this._handle = this.origin = this._listener = null;
+      for (const value of this._pending.values()) {
+        value.reject(new Error("RPC client closed."));
+      }
+      this._pending = /* @__PURE__ */ new Map();
+    }
+  }
+};
+__name(Client, "Client");
+var Injector = class {
+  constructor(client) {
+    this.client = client;
+    this._apis = /* @__PURE__ */ new Map();
+  }
+  define(name5, definition) {
+    if (!(name5 && typeof name5 === "string")) {
+      throw new TypeError("`name` must be a non-empty string.");
+    }
+    if (!(definition && typeof definition === "object" && Array.isArray(definition.functions))) {
+      throw new TypeError("`definition.function` must be an array of function names or function definition objects to be defined.");
+    }
+    const self2 = this;
+    const api = {};
+    definition.functions.forEach((fn) => {
+      if (typeof fn === "string") {
+        fn = { name: fn, options: {} };
+      }
+      api[fn.name] = function() {
+        return __async(this, arguments, function* () {
+          return self2.client.send(name5 + "." + fn.name, [...arguments], fn.options);
+        });
+      };
+    });
+    self2._apis[name5] = api;
+    return api;
+  }
+  get(name5, definition) {
+    const api = this._apis[name5];
+    if (!api) {
+      if (definition) {
+        return this.define(name5, definition);
+      }
+      throw new Error(`API "${name5}" has not been defined.`);
+    }
+    return this._apis[name5];
+  }
+};
+__name(Injector, "Injector");
+
+// ../../node_modules/.pnpm/web-request-rpc@2.0.0/node_modules/web-request-rpc/EventEmitter.js
+var EventEmitter = class {
+  constructor({ deserialize = /* @__PURE__ */ __name((e) => e, "deserialize"), waitUntil = /* @__PURE__ */ __name(() => __async(this, null, function* () {
+  }), "waitUntil") } = {}) {
+    this._listeners = [];
+    this._deserialize = deserialize;
+    this._waitUntil = waitUntil;
+  }
+  emit(event) {
+    return __async(this, null, function* () {
+      event = this._deserialize(event);
+      (this._listeners[event.type] || []).forEach((l) => l(event));
+      return this._waitUntil(event);
+    });
+  }
+  addEventListener(eventType, fn) {
+    if (!this._listeners[eventType]) {
+      this._listeners[eventType] = [fn];
+    } else {
+      this._listeners[eventType].push(fn);
+    }
+  }
+  removeEventListener(eventType, fn) {
+    const listeners = this._listeners[eventType];
+    if (!listeners) {
+      return;
+    }
+    const idx = listeners.indexOf(fn);
+    if (idx !== -1) {
+      listeners.splice(idx, 1);
+    }
+  }
+};
+__name(EventEmitter, "EventEmitter");
+
+// ../../node_modules/.pnpm/web-request-rpc@2.0.0/node_modules/web-request-rpc/Server.js
+var Server = class {
+  constructor() {
+    this.origin = null;
+    this._handle = null;
+    this._apis = /* @__PURE__ */ new Map();
+  }
+  define(name5, api) {
+    if (!(name5 && typeof name5 === "string")) {
+      throw new TypeError("`name` must be a non-empty string.");
+    }
+    if (!(api && api !== "object")) {
+      throw new TypeError("`api` must be an object.");
+    }
+    if (name5 in this._apis) {
+      throw new Error(`The "${name5}" API is already defined.`);
+    }
+    this._apis[name5] = api;
+  }
+  listen(origin, options) {
+    return __async(this, null, function* () {
+      if (this._listener) {
+        throw new Error("Already listening.");
+      }
+      options = options || {};
+      const self2 = this;
+      self2.origin = parseUrl(origin).origin;
+      self2._handle = options.handle || window.opener || window.parent;
+      const ignoreUnknownApi = options.ignoreUnknownApi === "true" || false;
+      self2._listener = createMessageListener({
+        origin: self2.origin,
+        handle: self2._handle,
+        expectRequest: true,
+        listener: (message) => {
+          const { name: name5, method } = destructureMethodName(message.method);
+          const api = self2._apis[name5];
+          if (method && method.startsWith("_")) {
+            return sendMethodNotFound(self2._handle, self2.origin, message);
+          }
+          if (!api && ignoreUnknownApi) {
+            return;
+          }
+          if (!api || typeof api[method] !== "function") {
+            return sendMethodNotFound(self2._handle, self2.origin, message);
+          }
+          const fn = api[method];
+          (() => __async(this, null, function* () {
+            const response = {
+              jsonrpc: "2.0",
+              id: message.id
+            };
+            try {
+              response.result = yield fn.apply(api, message.params);
+            } catch (e) {
+              response.error = serializeError(e);
+            }
+            if (self2._handle) {
+              if (isHandlePromise(self2._handle)) {
+                self2._handle.then((h) => h.postMessage(response, self2.origin));
+              } else {
+                self2._handle.postMessage(response, self2.origin);
+              }
+            }
+          }))();
+        }
+      });
+      window.addEventListener("message", self2._listener);
+    });
+  }
+  close() {
+    if (this._listener) {
+      window.removeEventListener("message", this._listener);
+      this._handle = this.origin = this._listener = null;
+    }
+  }
+};
+__name(Server, "Server");
+function sendMethodNotFound(handle, origin, message) {
+  const response = {
+    jsonrpc: "2.0",
+    id: message.id,
+    error: Object.assign({}, RPC_ERRORS.MethodNotFound)
+  };
+  if (isHandlePromise(handle)) {
+    return handle.then((h) => h.postMessage(response, origin));
+  } else {
+    return handle.postMessage(response, origin);
+  }
+}
+__name(sendMethodNotFound, "sendMethodNotFound");
+
+// ../../node_modules/.pnpm/web-request-rpc@2.0.0/node_modules/web-request-rpc/WebApp.js
+var WebApp = class {
+  constructor(relyingOrigin) {
+    this.relyingOrigin = parseUrl(relyingOrigin).origin;
+    this.client = null;
+    this.injector = null;
+    this.client = new Client();
+    this.server = new Server();
+    this._control = null;
+    this._connected = false;
+  }
+  connect() {
+    return __async(this, null, function* () {
+      this.injector = yield this.client.connect(this.relyingOrigin);
+      this._connected = true;
+      this._control = this.injector.define("core.control", {
+        functions: ["ready", "show", "hide"]
+      });
+      this.server.listen(this.relyingOrigin);
+      return this.injector;
+    });
+  }
+  ready() {
+    return __async(this, null, function* () {
+      if (!this._connected) {
+        throw new Error('WebApp not connected. Did you call ".connect()"?');
+      }
+      yield this._control.ready();
+      return this;
+    });
+  }
+  close() {
+    if (this._connected) {
+      this.server.close();
+      this.client.close();
+      this._connected = false;
+    }
+  }
+  show() {
+    return __async(this, null, function* () {
+      if (!this._connected) {
+        throw new Error('Cannot "show" yet; not connected. Did you call ".connect()"?');
+      }
+      return this._control.show();
+    });
+  }
+  hide() {
+    return __async(this, null, function* () {
+      if (!this._connected) {
+        throw new Error('Cannot "hide" yet; not connected. Did you call ".connect()?"');
+      }
+      return this._control.hide();
+    });
+  }
+};
+__name(WebApp, "WebApp");
+
+// ../../node_modules/.pnpm/web-request-rpc@2.0.0/node_modules/web-request-rpc/WebAppWindowDialog.js
+var WebAppWindowDialog = class {
+  constructor() {
+    this._closeEventListeners = /* @__PURE__ */ new Set();
+  }
+  addEventListener(name5, listener2) {
+    if (name5 !== "close") {
+      throw new Error(`Unknown event "${name5}".`);
+    }
+    if (typeof listener2 !== "function") {
+      throw new TypeError('"listener" must be a function.');
+    }
+    this._closeEventListeners.add(listener2);
+  }
+  removeEventListener(name5, listener2) {
+    if (name5 !== "close") {
+      throw new Error(`Unknown event "${name5}".`);
+    }
+    if (typeof listener2 !== "function") {
+      throw new TypeError('"listener" must be a function.');
+    }
+    this._closeEventListeners.delete(listener2);
+  }
+  show() {
+  }
+  close() {
+    for (const listener2 of this._closeEventListeners) {
+      listener2({});
+    }
+  }
+  destroy() {
+    this._closeEventListeners.clear();
+  }
+};
+__name(WebAppWindowDialog, "WebAppWindowDialog");
+
+// ../../node_modules/.pnpm/web-request-rpc@2.0.0/node_modules/web-request-rpc/WebAppWindowInlineDialog.js
+var WebAppWindowInlineDialog = class extends WebAppWindowDialog {
+  constructor({ url, handle, className }) {
+    super();
+    this.url = url;
+    this.handle = handle;
+    this.dialog = document.createElement("dialog");
+    applyStyle(this.dialog, {
+      position: "fixed",
+      top: 0,
+      left: 0,
+      width: "100%",
+      height: "100%",
+      "max-width": "100%",
+      "max-height": "100%",
+      display: "none",
+      margin: 0,
+      padding: 0,
+      border: "none",
+      background: "transparent",
+      color: "black",
+      "box-sizing": "border-box",
+      overflow: "hidden",
+      "z-index": 1e6
+    });
+    this.dialog.className = "web-app-window";
+    if (typeof className === "string") {
+      this.dialog.className = this.dialog.className + " " + className;
+    }
+    const style = document.createElement("style");
+    style.appendChild(document.createTextNode(`dialog.web-app-window::backdrop {
+        background-color: transparent;
+      }`));
+    this.container = document.createElement("div");
+    applyStyle(this.container, {
+      position: "relative",
+      width: "100%",
+      height: "100%",
+      margin: 0,
+      padding: 0,
+      display: "flex",
+      "flex-direction": "column"
+    });
+    this.container.className = "web-app-window-backdrop";
+    this.iframe = document.createElement("iframe");
+    this.iframe.src = url;
+    this.iframe.scrolling = "auto";
+    applyStyle(this.iframe, {
+      position: "fixed",
+      top: 0,
+      left: 0,
+      width: "100%",
+      height: "100%",
+      border: "none",
+      background: "transparent",
+      overflow: "hidden",
+      margin: 0,
+      padding: 0,
+      "flex-grow": 1
+    });
+    this.dialog.appendChild(style);
+    this.container.appendChild(this.iframe);
+    this.dialog.appendChild(this.container);
+    this.dialog.addEventListener("cancel", (e) => {
+      e.preventDefault();
+      this.hide();
+    });
+    document.body.appendChild(this.dialog);
+    this.handle = this.iframe.contentWindow;
+  }
+  show() {
+    this.dialog.style.display = "block";
+    if (this.dialog.showModal) {
+      this.dialog.showModal();
+    }
+  }
+  close() {
+    this.dialog.style.display = "none";
+    if (this.dialog.close) {
+      try {
+        this.dialog.close();
+      } catch (e) {
+        console.error(e);
+      }
+    }
+    super.close();
+  }
+  destroy() {
+    this.dialog.parentNode.removeChild(this.dialog);
+    super.destroy();
+  }
+};
+__name(WebAppWindowInlineDialog, "WebAppWindowInlineDialog");
+function applyStyle(element, style) {
+  for (const name5 in style) {
+    element.style[name5] = style[name5];
+  }
+}
+__name(applyStyle, "applyStyle");
+
+// ../../node_modules/.pnpm/web-request-rpc@2.0.0/node_modules/web-request-rpc/WebAppWindowPopupDialog.js
+var WebAppWindowPopupDialog = class extends WebAppWindowDialog {
+  constructor({ url, handle, bounds = { width: 500, height: 400 } }) {
+    super();
+    this.url = url;
+    this.handle = handle;
+    this._locationChanging = false;
+    if (!handle) {
+      this._openWindow({ url, name: "web-app-window", bounds });
+    }
+    this.destroyed = false;
+    this._removeListeners = () => {
+    };
+  }
+  show() {
+  }
+  close() {
+    this.destroy();
+  }
+  destroy() {
+    if (this.handle && !this.destroyed) {
+      this.handle.close();
+      super.close();
+      this.handle = null;
+      this.destroyed = true;
+      this._removeListeners();
+      super.destroy();
+    }
+  }
+  isClosed() {
+    return !this.handle || this.handle.closed;
+  }
+  _openWindow({ url, name: name5, bounds }) {
+    const { x, y } = bounds;
+    let { width = 500, height = 400 } = bounds;
+    width = Math.min(width, window.innerWidth);
+    height = Math.min(height, window.innerHeight);
+    const left = x !== void 0 ? x : window.screenX + (window.innerWidth - width) / 2;
+    const top = y !== void 0 ? y : window.screenY + (window.innerHeight - height) / 2;
+    const features = `popup=yes,menubar=no,location=no,resizable=no,scrollbars=no,status=no,width=${width},height=${height},left=${left},top=${top}`;
+    this._locationChanging = true;
+    this.handle = window.open(url, name5, features);
+    this._addListeners();
+  }
+  setLocation(url) {
+    this.url = url;
+    this._locationChanging = true;
+    this.handle.location.replace(url);
+  }
+  _addListeners() {
+    const destroyDialog = /* @__PURE__ */ __name(() => this.destroy(), "destroyDialog");
+    const loadDialog = /* @__PURE__ */ __name(() => {
+      this._locationChanging = false;
+    }, "loadDialog");
+    const unloadDialog = /* @__PURE__ */ __name(() => {
+      if (this._locationChanging) {
+        return;
+      }
+      this.destroy();
+    }, "unloadDialog");
+    this.handle.addEventListener("unload", unloadDialog);
+    this.handle.addEventListener("load", loadDialog);
+    window.addEventListener("beforeUnload", destroyDialog, { once: true });
+    const intervalId = setInterval(() => {
+      if (this.isClosed()) {
+        this.destroy();
+        clearInterval(intervalId);
+      }
+    }, 250);
+    this._removeListeners = () => {
+      clearInterval(intervalId);
+      this.handle.removeListener("unload", unloadDialog);
+      this.handle.removeListener("load", loadDialog);
+      window.removeEventListener("beforeUnload", destroyDialog);
+    };
+  }
+};
+__name(WebAppWindowPopupDialog, "WebAppWindowPopupDialog");
+
+// ../../node_modules/.pnpm/web-request-rpc@2.0.0/node_modules/web-request-rpc/WebAppWindow.js
+var LOAD_WINDOW_TIMEOUT = 6e4;
+var WebAppWindow = class {
+  constructor(url, {
+    timeout = LOAD_WINDOW_TIMEOUT,
+    dialog = null,
+    handle,
+    popup = false,
+    className = null,
+    customize = null,
+    bounds
+  } = {}) {
+    this.visible = false;
+    this.dialog = dialog;
+    this.handle = null;
+    this.popup = popup;
+    this.windowControl = null;
+    this._destroyed = false;
+    this._ready = false;
+    this._private = {};
+    this._timeoutId = null;
+    if (handle && handle._dialog) {
+      this.dialog = dialog = handle._dialog;
+    }
+    this._private._readyPromise = new Promise((resolve, reject) => {
+      this._timeoutId = setTimeout(() => reject(new DOMException("Loading Web application window timed out.", "TimeoutError")), timeout);
+      this._private._resolveReady = (value) => {
+        clearTimeout(this.timeoutId);
+        this._timeoutId = null;
+        resolve(value);
+      };
+      this._private._rejectReady = (err) => {
+        clearTimeout(this.timeoutId);
+        this._timeoutId = null;
+        reject(err);
+      };
+    });
+    this._private.isReady = () => __async(this, null, function* () {
+      return this._private._readyPromise;
+    });
+    this._private.destroy = () => {
+      if (this._timeoutId) {
+        this._private._rejectReady(new DOMException("Web application window closed before ready.", "AbortError"));
+      }
+      if (!this._destroyed) {
+        this.dialog.destroy();
+        this.dialog = null;
+        this._destroyed = true;
+      }
+    };
+    if (customize) {
+      if (!typeof customize === "function") {
+        throw new TypeError("`options.customize` must be a function.");
+      }
+    }
+    if (!this.dialog) {
+      if (this.popup) {
+        this.dialog = new WebAppWindowPopupDialog({ url, handle, bounds });
+      } else {
+        this.dialog = new WebAppWindowInlineDialog({ url, handle, className });
+      }
+    } else if (this.popup && bounds) {
+      if (bounds) {
+        const { top: y, left: x, width, height } = bounds;
+        if (x !== void 0 && y !== void 0) {
+          this.dialog.handle.moveTo(x, y);
+        }
+        if (width !== void 0 && height !== void 0) {
+          this.dialog.handle.resizeTo(width, height);
+        }
+      }
+    }
+    this.handle = this.dialog.handle;
+    if (customize) {
+      try {
+        customize({
+          dialog: this.dialog.dialog,
+          container: this.dialog.container,
+          iframe: this.dialog.iframe,
+          webAppWindow: this
+        });
+      } catch (e) {
+        console.error(e);
+      }
+    }
+  }
+  ready() {
+    this._ready = true;
+    this._private._resolveReady(true);
+  }
+  show() {
+    if (!this.visible) {
+      this.visible = true;
+      const body = document.querySelector("body");
+      this._bodyOverflowStyle = body.style.overflow;
+      body.style.overflow = "hidden";
+      if (!this._destroyed) {
+        this.dialog.show();
+      } else if (this.windowControl.show) {
+        this.windowControl.show();
+      }
+    }
+  }
+  hide() {
+    if (this.visible) {
+      this.visible = false;
+      const body = document.querySelector("body");
+      if (this._bodyOverflowStyle) {
+        body.style.overflow = this._bodyOverflowStyle;
+      } else {
+        body.style.overflow = "";
+      }
+      if (!this._destroyed) {
+        this.dialog.close();
+      } else if (this.windowControl.hide) {
+        this.windowControl.hide();
+      }
+    }
+  }
+};
+__name(WebAppWindow, "WebAppWindow");
+
+// ../../node_modules/.pnpm/web-request-rpc@2.0.0/node_modules/web-request-rpc/WebAppContext.js
+var WEB_APP_CONTEXT_LOAD_TIMEOUT = 1e4;
+var WebAppContext = class {
+  constructor() {
+    this.client = new Client();
+    this.server = new Server();
+    this.injector = null;
+    this.control = null;
+    this.loaded = false;
+    this.closed = false;
+  }
+  createWindow(_0) {
+    return __async(this, arguments, function* (url, {
+      timeout = WEB_APP_CONTEXT_LOAD_TIMEOUT,
+      iframe,
+      dialog = null,
+      popup = false,
+      handle,
+      windowControl,
+      className,
+      customize,
+      bounds
+    } = {}) {
+      if (this.loaded) {
+        throw new Error("AppContext already loaded.");
+      }
+      this.loaded = true;
+      this.control = new WebAppWindow(url, {
+        timeout,
+        dialog,
+        iframe,
+        popup,
+        handle,
+        windowControl,
+        className,
+        customize,
+        bounds
+      });
+      window.addEventListener("pagehide", () => this.close(), { once: true });
+      this.server.define("core.control", this.control);
+      const origin = parseUrl(url).origin;
+      this.server.listen(origin, {
+        handle: this.control.handle,
+        ignoreUnknownApi: true
+      });
+      yield this.control._private.isReady();
+      this.injector = yield this.client.connect(origin, {
+        handle: this.control.handle
+      });
+      return this.injector;
+    });
+  }
+  close() {
+    if (!this.closed) {
+      this.closed = true;
+      this.control._private.destroy();
+      this.server.close();
+      this.client.close();
+    }
+  }
+};
+__name(WebAppContext, "WebAppContext");
+
+// ../../node_modules/.pnpm/credential-handler-polyfill@3.0.0/node_modules/credential-handler-polyfill/CredentialRequestEvent.js
+var CredentialRequestEvent = class {
+  constructor({
+    credentialHandler,
+    credentialRequestOrigin,
+    credentialRequestOptions,
+    hintKey
+  }) {
+    this.type = "credentialrequest";
+    this._credentialHandler = credentialHandler;
+    this.credentialRequestOrigin = credentialRequestOrigin;
+    this.credentialRequestOptions = credentialRequestOptions;
+    this.hintKey = hintKey;
+  }
+  openWindow(url) {
+    return __async(this, null, function* () {
+      yield this._credentialHandler.show();
+      const appWindow = new WebAppWindow(url, {
+        className: "credential-handler"
+      });
+      appWindow.ready();
+      appWindow.show();
+      appWindow.handle._dialog = appWindow.dialog;
+      return appWindow.handle;
+    });
+  }
+  respondWith(handlerResponse) {
+    this._promise = handlerResponse;
+  }
+};
+__name(CredentialRequestEvent, "CredentialRequestEvent");
+
+// ../../node_modules/.pnpm/credential-handler-polyfill@3.0.0/node_modules/credential-handler-polyfill/CredentialStoreEvent.js
+var CredentialStoreEvent = class {
+  constructor({
+    credentialHandler,
+    credentialRequestOrigin,
+    credential,
+    hintKey
+  }) {
+    this.type = "credentialstore";
+    this._credentialHandler = credentialHandler;
+    this.credentialRequestOrigin = credentialRequestOrigin;
+    this.credential = credential;
+    this.hintKey = hintKey;
+  }
+  openWindow(url) {
+    return __async(this, null, function* () {
+      yield this._credentialHandler.show();
+      const appWindow = new WebAppWindow(url);
+      appWindow.ready();
+      appWindow.show();
+      appWindow.handle._dialog = appWindow.dialog;
+      return appWindow.handle;
+    });
+  }
+  respondWith(handlerResponse) {
+    this._promise = handlerResponse;
+  }
+};
+__name(CredentialStoreEvent, "CredentialStoreEvent");
+
+// ../../node_modules/.pnpm/credential-handler-polyfill@3.0.0/node_modules/credential-handler-polyfill/CredentialHandlerService.js
+var CredentialHandlerService = class {
+  constructor(credentialHandler) {
+    this._credentialHandler = credentialHandler;
+  }
+  request(credentialRequestEvent) {
+    return __async(this, null, function* () {
+      return yield this._credentialHandler._emitter.emit(new CredentialRequestEvent(Object.assign({ credentialHandler: this._credentialHandler }, credentialRequestEvent)));
+    });
+  }
+  store(credentialStoreEvent) {
+    return __async(this, null, function* () {
+      return yield this._credentialHandler._emitter.emit(new CredentialStoreEvent(Object.assign({ credentialHandler: this._credentialHandler }, credentialStoreEvent)));
+    });
+  }
+};
+__name(CredentialHandlerService, "CredentialHandlerService");
+
+// ../../node_modules/.pnpm/credential-handler-polyfill@3.0.0/node_modules/credential-handler-polyfill/CredentialHandler.js
+var EVENT_TYPES = ["credentialrequest", "credentialstore"];
+var CredentialHandler = class extends WebApp {
+  constructor(mediatorOrigin, inline = false) {
+    if (typeof mediatorOrigin !== "string") {
+      throw new TypeError('"mediatorOrigin" must be a string.');
+    }
+    super(mediatorOrigin, inline);
+    this._emitter = new EventEmitter({
+      waitUntil(event) {
+        return __async(this, null, function* () {
+          return event._promise || Promise.reject(new DOMException('No "credentialrequest" event handler found.', "NotFoundError"));
+        });
+      }
+    });
+  }
+  connect() {
+    return __async(this, null, function* () {
+      const injector = yield __superGet(CredentialHandler.prototype, this, "connect").call(this);
+      this.server.define("credentialHandler", new CredentialHandlerService(this));
+      yield this.ready();
+      return injector;
+    });
+  }
+  addEventListener(eventType, fn) {
+    if (!EVENT_TYPES.includes(eventType)) {
+      throw new DOMException(`Unsupported event type "${eventType}"`, "NotSupportedError");
+    }
+    return this._emitter.addEventListener(eventType, fn);
+  }
+  removeEventListener(eventType, fn) {
+    if (!EVENT_TYPES.includes(eventType)) {
+      throw new DOMException(`Unsupported event type "${eventType}"`, "NotSupportedError");
+    }
+    return this._emitter.removeEventListener(eventType, fn);
+  }
+};
+__name(CredentialHandler, "CredentialHandler");
+
+// ../../node_modules/.pnpm/credential-handler-polyfill@3.0.0/node_modules/credential-handler-polyfill/CredentialHints.js
+var CredentialHints = class {
+  constructor(url, injector) {
+    const remote = injector.get("credentialHints", {
+      functions: ["delete", "get", "keys", "has", "set", "clear"]
+    });
+    for (let methodName in remote) {
+      if (methodName !== "set") {
+        const method = remote[methodName].bind(this, url);
+        this[methodName] = function(...args) {
+          this._deprecateNotice();
+          return method(...args);
+        };
+      }
+    }
+    this._remoteSet = remote.set.bind(this, url);
+  }
+  set(hintKey, credentialHint) {
+    return __async(this, null, function* () {
+      this._deprecateNotice();
+      credentialHint.icons = credentialHint.icons || [];
+      const promises = credentialHint.icons.map((icon) => imageToDataUrl(icon.src).then((fetchedImage) => {
+        icon.fetchedImage = fetchedImage;
+      }));
+      yield Promise.all(promises);
+      return this._remoteSet(hintKey, credentialHint);
+    });
+  }
+  _deprecateNotice() {
+    console.warn("Credential hints are deprecated and no longer used.");
+  }
+};
+__name(CredentialHints, "CredentialHints");
+function imageToDataUrl(url) {
+  return new Promise((resolve) => {
+    const img = new Image();
+    img.crossOrigin = "Anonymous";
+    img.onload = () => {
+      let canvas = document.createElement("canvas");
+      const ctx = canvas.getContext("2d");
+      canvas.height = img.height;
+      canvas.width = img.width;
+      ctx.drawImage(img, 0, 0);
+      const dataUrl = canvas.toDataURL();
+      resolve(dataUrl);
+      canvas = null;
+    };
+    img.onerror = () => resolve(null);
+    img.src = url;
+  });
+}
+__name(imageToDataUrl, "imageToDataUrl");
+
+// ../../node_modules/.pnpm/credential-handler-polyfill@3.0.0/node_modules/credential-handler-polyfill/CredentialManager.js
+var CredentialManager = class {
+  constructor(url, injector) {
+    if (!(url && typeof url === "string")) {
+      throw new TypeError('"url" must be a non-empty string.');
+    }
+    this.hints = new CredentialHints(url, injector);
+  }
+  static requestPermission() {
+    return __async(this, null, function* () {
+      const status = yield navigator.credentialsPolyfill.permissions.request({ name: "credentialhandler" });
+      return status.state;
+    });
+  }
+};
+__name(CredentialManager, "CredentialManager");
+
+// ../../node_modules/.pnpm/credential-handler-polyfill@3.0.0/node_modules/credential-handler-polyfill/CredentialHandlerRegistration.js
+var CredentialHandlerRegistration = class {
+  constructor(url, injector) {
+    if (!(url && typeof url === "string")) {
+      throw new TypeError('"url" must be a non-empty string.');
+    }
+    this.credentialManager = new CredentialManager(url, injector);
+  }
+};
+__name(CredentialHandlerRegistration, "CredentialHandlerRegistration");
+
+// ../../node_modules/.pnpm/credential-handler-polyfill@3.0.0/node_modules/credential-handler-polyfill/CredentialHandlers.js
+var CredentialHandlers = class {
+  constructor(injector) {
+    this._init = (() => __async(this, null, function* () {
+      this._injector = yield injector;
+      this._remote = this._injector.get("credentialHandlers", {
+        functions: [
+          "register",
+          "unregister",
+          "getRegistration",
+          "hasRegistration"
+        ]
+      });
+    }))();
+  }
+  register(url) {
+    return __async(this, null, function* () {
+      this._deprecateNotice();
+      yield this._init;
+      url = yield this._remote.register("credential", url);
+      return new CredentialHandlerRegistration(url, this._injector);
+    });
+  }
+  unregister(url) {
+    return __async(this, null, function* () {
+      this._deprecateNotice();
+      yield this._init;
+      return this._remote.unregister("credential", url);
+    });
+  }
+  getRegistration(url) {
+    return __async(this, null, function* () {
+      this._deprecateNotice();
+      yield this._init;
+      url = yield this._remote.getRegistration("credential", url);
+      if (!url) {
+        return null;
+      }
+      return new CredentialHandlerRegistration(url, this._injector);
+    });
+  }
+  hasRegistration(url) {
+    return __async(this, null, function* () {
+      this._deprecateNotice();
+      yield this._init;
+      return yield this._remote.hasRegistration("credential", url);
+    });
+  }
+  _deprecateNotice() {
+    console.warn('Credential handler registration APIs are deprecated. The credential handler specified in "manifest.json" is now automatically registered when a user grants permission to install a credential handler via "CredentialManager.requestPermission()".');
+  }
+};
+__name(CredentialHandlers, "CredentialHandlers");
+
+// ../../node_modules/.pnpm/credential-handler-polyfill@3.0.0/node_modules/credential-handler-polyfill/WebCredential.js
+var WebCredential2 = class {
+  constructor(dataType, data, { recommendedHandlerOrigins = [] } = {}) {
+    if (typeof dataType !== "string") {
+      throw new TypeError('"dataType" must be a string.');
+    }
+    this.type = "web";
+    this.dataType = dataType;
+    this.data = data;
+    this.options = { recommendedHandlerOrigins };
+  }
+};
+__name(WebCredential2, "WebCredential");
+
+// ../../node_modules/.pnpm/credential-handler-polyfill@3.0.0/node_modules/credential-handler-polyfill/CredentialsContainer.js
+var CREDENTIAL_GET_TIMEOUT = 0;
+var CREDENTIAL_STORE_TIMEOUT = 0;
+var CredentialsContainer = class {
+  constructor(injector) {
+    this._nativeCredentialsContainer = {
+      get: navigator.credentials && navigator.credentials.get && navigator.credentials.get.bind(navigator.credentials),
+      store: navigator.credentials && navigator.credentials.store && navigator.credentials.store.bind(navigator.credentials)
+    };
+    this._init = (() => __async(this, null, function* () {
+      this._remote = (yield injector).get("credentialsContainer", {
+        functions: [
+          { name: "get", options: { timeout: CREDENTIAL_GET_TIMEOUT } },
+          { name: "store", options: { timeout: CREDENTIAL_STORE_TIMEOUT } }
+        ]
+      });
+    }))();
+  }
+  get() {
+    return __async(this, arguments, function* (options = {}) {
+      if (options.web) {
+        yield this._init;
+        const credential = yield this._remote.get(options);
+        if (!credential) {
+          return null;
+        }
+        return new WebCredential2(credential.dataType, credential.data);
+      }
+      if (this._nativeCredentialsContainer.get) {
+        return this._nativeCredentialsContainer.get(options);
+      }
+      throw new DOMException("Not implemented.", "NotSupportedError");
+    });
+  }
+  store(credential) {
+    return __async(this, null, function* () {
+      if (credential instanceof WebCredential2) {
+        yield this._init;
+        const result = yield this._remote.store(credential);
+        if (!result) {
+          return null;
+        }
+        return new WebCredential2(result.dataType, result.data);
+      }
+      if (this._nativeCredentialsContainer.store) {
+        return this._nativeCredentialsContainer.store(credential);
+      }
+      throw new DOMException("Not implemented.", "NotSupportedError");
+    });
+  }
+};
+__name(CredentialsContainer, "CredentialsContainer");
+
+// ../../node_modules/.pnpm/credential-handler-polyfill@3.0.0/node_modules/credential-handler-polyfill/PermissionManager.js
+var PERMISSION_REQUEST_TIMEOUT = 0;
+var PermissionManager = class {
+  constructor(injector) {
+    this._init = (() => __async(this, null, function* () {
+      this._remote = (yield injector).get("permissionManager", {
+        functions: [
+          "query",
+          { name: "request", options: { timeout: PERMISSION_REQUEST_TIMEOUT } },
+          "revoke"
+        ]
+      });
+    }))();
+  }
+  query(permissionDesc) {
+    return __async(this, null, function* () {
+      yield this._init;
+      return yield this._remote.query(permissionDesc);
+    });
+  }
+  request(permissionDesc) {
+    return __async(this, null, function* () {
+      yield this._init;
+      return yield this._remote.request(permissionDesc);
+    });
+  }
+  revoke(permissionDesc) {
+    return __async(this, null, function* () {
+      yield this._init;
+      return yield this._remote.revoke(permissionDesc);
+    });
+  }
+};
+__name(PermissionManager, "PermissionManager");
+
+// ../../node_modules/.pnpm/credential-handler-polyfill@3.0.0/node_modules/credential-handler-polyfill/index.js
+var DEFAULT_MEDIATOR_ORIGIN = "https://authn.io";
+var loaded;
+function loadOnce(options) {
+  return __async(this, null, function* () {
+    if (loaded) {
+      return loaded;
+    }
+    loaded = true;
+    return load2(options);
+  });
+}
+__name(loadOnce, "loadOnce");
+function load2() {
+  return __async(this, arguments, function* (options = {
+    mediatorOrigin: DEFAULT_MEDIATOR_ORIGIN
+  }) {
+    let mediatorUrl;
+    if (typeof options === "string") {
+      mediatorUrl = options;
+    } else if (options && typeof options === "object" && typeof options.mediatorOrigin === "string") {
+      mediatorUrl = `${options.mediatorOrigin}/mediator`;
+    } else {
+      throw new Error('"options.mediatorOrigin" must be a string expressing the origin of the mediator.');
+    }
+    const appContext = new WebAppContext();
+    const injector = appContext.createWindow(mediatorUrl, {
+      className: "credential-mediator",
+      timeout: 3e4
+    });
+    const style = document.createElement("style");
+    style.appendChild(document.createTextNode(`dialog.web-app-window.credential-mediator > .web-app-window-backdrop {
+      background-color: rgba(0, 0, 0, 0.25);
+    }`));
+    document.body.appendChild(style);
+    const polyfill = {};
+    polyfill.permissions = new PermissionManager(injector);
+    polyfill.CredentialHandlers = new CredentialHandlers(injector);
+    polyfill.CredentialHandler = CredentialHandler;
+    polyfill.CredentialManager = CredentialManager;
+    polyfill.credentials = new CredentialsContainer(injector);
+    polyfill.WebCredential = WebCredential2;
+    navigator.credentialsPolyfill = polyfill;
+    if ("credentials" in navigator) {
+      navigator.credentials.get = polyfill.credentials.get.bind(polyfill.credentials);
+      navigator.credentials.store = polyfill.credentials.store.bind(polyfill.credentials);
+    } else {
+      navigator.credentials = polyfill.credentials;
+    }
+    window.CredentialManager = CredentialManager;
+    window.WebCredential = WebCredential2;
+    return polyfill;
+  });
+}
+__name(load2, "load");
+
+// ../../node_modules/.pnpm/web-credential-handler@2.0.0/node_modules/web-credential-handler/CredentialEventProxy.js
+var PROXY_EVENT_TIMEOUT = 6e4;
+var CredentialEventProxy = class extends WebApp {
+  constructor() {
+    super(window.location.origin);
+  }
+  receive() {
+    return __async(this, null, function* () {
+      const self2 = this;
+      yield self2.connect();
+      return new Promise((resolveReceive, rejectReceive) => {
+        const timeoutId = setTimeout(() => {
+          rejectReceive(new Error("Timed out waiting to receive event."));
+        }, PROXY_EVENT_TIMEOUT);
+        self2.server.define("credentialEventProxy", {
+          send(event) {
+            return __async(this, null, function* () {
+              resolveReceive(event);
+              clearTimeout(timeoutId);
+              return new Promise((resolveSend, rejectSend) => {
+                event.respondWith = (promise) => {
+                  try {
+                    resolveSend(promise);
+                  } catch (e) {
+                    rejectSend(e);
+                  }
+                };
+              });
+            });
+          }
+        });
+        self2.ready();
+      });
+    });
+  }
+};
+__name(CredentialEventProxy, "CredentialEventProxy");
+
+// ../../node_modules/.pnpm/web-credential-handler@2.0.0/node_modules/web-credential-handler/index.js
+var DEFAULT_MEDIATOR = "https://authn.io";
+function installHandler() {
+  return __async(this, null, function* () {
+    const CredentialManager2 = navigator.credentialsPolyfill.CredentialManager;
+    const result = yield CredentialManager2.requestPermission();
+    if (result !== "granted") {
+      throw new Error("Permission denied.");
+    }
+  });
+}
+__name(installHandler, "installHandler");
+function activateHandler(_0) {
+  return __async(this, arguments, function* ({
+    mediatorOrigin = DEFAULT_MEDIATOR,
+    get: get2,
+    store
+  }) {
+    if (!(get2 || store)) {
+      throw new Error('"get" or "store" function(s) must be specified.');
+    }
+    const CredentialHandler2 = navigator.credentialsPolyfill.CredentialHandler;
+    const self2 = new CredentialHandler2(mediatorOrigin);
+    if (get2) {
+      if (typeof get2 !== "function") {
+        throw new TypeError('"get" must be a function.');
+      }
+      self2.addEventListener("credentialrequest", (event) => listener({ event, get: get2 }));
+    }
+    if (store) {
+      if (typeof store !== "function") {
+        throw new TypeError('"store" must be a function.');
+      }
+      self2.addEventListener("credentialstore", (event) => listener({ event, store }));
+    }
+    yield self2.connect();
+  });
+}
+__name(activateHandler, "activateHandler");
+function receiveCredentialEvent() {
+  return __async(this, null, function* () {
+    const proxy = new CredentialEventProxy();
+    return proxy.receive();
+  });
+}
+__name(receiveCredentialEvent, "receiveCredentialEvent");
+function listener({ event, get: get2, store }) {
+  event.respondWith(createResponse({ event, get: get2, store }));
+}
+__name(listener, "listener");
+function createResponse(_0) {
+  return __async(this, arguments, function* ({ event, get: get2, store }) {
+    const result = yield (get2 || store)({ event });
+    if (!(result && typeof result === "object")) {
+      throw new TypeError('Return value of "get" or "store" hook must be an object.');
+    }
+    if (result.type === "response") {
+      return { dataType: result.dataType, data: result.data };
+    }
+    if (result.type === "redirect") {
+      const appContext = new WebAppContext();
+      const handle = yield event.openWindow(result.url);
+      const windowReady = appContext.createWindow(result.url, {
+        handle,
+        popup: false,
+        timeout: 6e5
+      });
+      const injector = yield windowReady;
+      const proxy = injector.get("credentialEventProxy", {
+        functions: [{ name: "send", options: { timeout: 0 } }]
+      });
+      return proxy.send({
+        type: event.type,
+        credentialRequestOptions: event.credentialRequestOptions,
+        credentialRequestOrigin: event.credentialRequestOrigin,
+        credential: event.credential,
+        hintKey: event.hintKey
+      });
+    }
+    throw new Error('Return value of "get" or "store" must have a type of "response" or "redirect".');
+  });
+}
+__name(createResponse, "createResponse");
+
+// src/wallet/plugins/chapi/chapi.ts
+var getCHAPIPlugin = /* @__PURE__ */ __name(() => __async(void 0, null, function* () {
+  if (typeof window === "undefined") {
+    return {
+      pluginMethods: {
+        installChapiHandler: () => __async(void 0, null, function* () {
+          throw new Error("CHAPI is only available inside of a browser!");
+        }),
+        activateChapiHandler: () => __async(void 0, null, function* () {
+          throw new Error("CHAPI is only available inside of a browser!");
+        }),
+        receiveChapiEvent: () => __async(void 0, null, function* () {
+          throw new Error("CHAPI is only available inside of a browser!");
+        }),
+        storeCredentialViaChapiDidAuth: () => __async(void 0, null, function* () {
+          throw new Error("CHAPI is only available inside of a browser!");
+        }),
+        storePresentationViaChapi: () => __async(void 0, null, function* () {
+          throw new Error("CHAPI is only available inside of a browser!");
+        })
+      }
+    };
+  }
+  yield loadOnce();
+  return {
+    pluginMethods: {
+      installChapiHandler: () => __async(void 0, null, function* () {
+        return installHandler();
+      }),
+      activateChapiHandler: (_0, _1) => __async(void 0, [_0, _1], function* (_wallet, {
+        mediatorOrigin = `https://authn.io/mediator?${encodeURIComponent(window.location.origin)}`,
+        get: get2,
+        store
+      }) {
+        return activateHandler({ mediatorOrigin, get: get2, store });
+      }),
+      receiveChapiEvent: () => __async(void 0, null, function* () {
+        return receiveCredentialEvent();
+      }),
+      storeCredentialViaChapiDidAuth: (wallet, credential) => __async(void 0, null, function* () {
+        var _a, _b, _c;
+        const challenge = crypto.randomUUID();
+        const domain = window.location.origin;
+        const vpr = {
+          web: {
+            VerifiablePresentation: {
+              query: { type: "DIDAuthentication" },
+              challenge,
+              domain
+            }
+          }
+        };
+        const res = yield navigator.credentials.get(vpr);
+        if (!res)
+          return { success: false, reason: "did not auth" };
+        const verification = yield wallet.pluginMethods.verifyPresentation(res.data, {
+          challenge,
+          domain
+        });
+        if (verification.warnings.length > 0 || verification.errors.length > 0) {
+          return { success: false, reason: "auth failed verification" };
+        }
+        const subject = (_c = (_b = (_a = res.data) == null ? void 0 : _a.proof) == null ? void 0 : _b.verificationMethod) == null ? void 0 : _c.split("#")[0];
+        if (!Array.isArray(credential.credentialSubject)) {
+          credential.credentialSubject.id = subject;
+        }
+        const vp = yield wallet.pluginMethods.issuePresentation(yield wallet.pluginMethods.getTestVp(yield wallet.pluginMethods.issueCredential(credential)));
+        const success = yield wallet.pluginMethods.storePresentationViaChapi(vp);
+        if (success)
+          return { success: true };
+        return { success: false, reason: "did not store" };
+      }),
+      storePresentationViaChapi: (_wallet, presentation) => __async(void 0, null, function* () {
+        const wc = new WebCredential("VerifiablePresentation", presentation);
+        return window.navigator.credentials.store(wc);
+      })
+    }
+  };
+}), "getCHAPIPlugin");
 
 // src/wallet/plugins/vc-templates/templates.ts
 var VC_TEMPLATES = {
@@ -36176,9 +39322,9 @@ var VC_TEMPLATES = {
 };
 
 // src/wallet/plugins/vc-templates/vc-templates.ts
-var getVCTemplatesPlugin = /* @__PURE__ */ __name((wallet) => {
+var getVCTemplatesPlugin = /* @__PURE__ */ __name(() => {
   return {
-    pluginMethods: __spreadProps(__spreadValues({}, recycleDependents(wallet.pluginMethods)), {
+    pluginMethods: {
       newCredential: (_wallet, args = { type: "basic" }) => {
         var _a, _b;
         const did = args.did || ((_b = (_a = _wallet.pluginMethods).getSubjectDid) == null ? void 0 : _b.call(_a, "key"));
@@ -36206,7 +39352,7 @@ var getVCTemplatesPlugin = /* @__PURE__ */ __name((wallet) => {
           verifiableCredential: credential
         };
       })
-    })
+    }
   };
 }, "getVCTemplatesPlugin");
 
@@ -40879,14 +44025,20 @@ var verifyCredential2 = /* @__PURE__ */ __name((wallet) => {
 var emptyWallet = /* @__PURE__ */ __name((..._0) => __async(void 0, [..._0], function* ({ didkit } = {}) {
   const didkitWallet = yield (yield generateWallet()).addPlugin(yield getDidKitPlugin(didkit));
   const expirationWallet = yield didkitWallet.addPlugin(ExpirationPlugin(didkitWallet));
-  const wallet = yield expirationWallet.addPlugin(getVCTemplatesPlugin(expirationWallet));
+  const templatesWallet = yield expirationWallet.addPlugin(getVCTemplatesPlugin());
+  const wallet = yield templatesWallet.addPlugin(yield getCHAPIPlugin());
   return {
     _wallet: wallet,
     newCredential: wallet.pluginMethods.newCredential,
     newPresentation: wallet.pluginMethods.newPresentation,
     verifyCredential: verifyCredential2(wallet),
     verifyPresentation: wallet.pluginMethods.verifyPresentation,
-    resolveDid: wallet.pluginMethods.resolveDid
+    resolveDid: wallet.pluginMethods.resolveDid,
+    installChapiHandler: wallet.pluginMethods.installChapiHandler,
+    activateChapiHandler: wallet.pluginMethods.activateChapiHandler,
+    receiveChapiEvent: wallet.pluginMethods.receiveChapiEvent,
+    storePresentationViaChapi: wallet.pluginMethods.storePresentationViaChapi,
+    storeCredentialViaChapiDidAuth: wallet.pluginMethods.storeCredentialViaChapiDidAuth
   };
 }), "emptyWallet");
 
@@ -48889,75 +52041,75 @@ var PatchError = function(_super) {
 var JsonPatchError = PatchError;
 var deepClone = _deepClone;
 var objOps = {
-  add: function(obj, key2, document) {
+  add: function(obj, key2, document2) {
     obj[key2] = this.value;
-    return { newDocument: document };
+    return { newDocument: document2 };
   },
-  remove: function(obj, key2, document) {
+  remove: function(obj, key2, document2) {
     var removed = obj[key2];
     delete obj[key2];
-    return { newDocument: document, removed };
+    return { newDocument: document2, removed };
   },
-  replace: function(obj, key2, document) {
+  replace: function(obj, key2, document2) {
     var removed = obj[key2];
     obj[key2] = this.value;
-    return { newDocument: document, removed };
+    return { newDocument: document2, removed };
   },
-  move: function(obj, key2, document) {
-    var removed = getValueByPointer(document, this.path);
+  move: function(obj, key2, document2) {
+    var removed = getValueByPointer(document2, this.path);
     if (removed) {
       removed = _deepClone(removed);
     }
-    var originalValue = applyOperation(document, { op: "remove", path: this.from }).removed;
-    applyOperation(document, { op: "add", path: this.path, value: originalValue });
-    return { newDocument: document, removed };
+    var originalValue = applyOperation(document2, { op: "remove", path: this.from }).removed;
+    applyOperation(document2, { op: "add", path: this.path, value: originalValue });
+    return { newDocument: document2, removed };
   },
-  copy: function(obj, key2, document) {
-    var valueToCopy = getValueByPointer(document, this.from);
-    applyOperation(document, { op: "add", path: this.path, value: _deepClone(valueToCopy) });
-    return { newDocument: document };
+  copy: function(obj, key2, document2) {
+    var valueToCopy = getValueByPointer(document2, this.from);
+    applyOperation(document2, { op: "add", path: this.path, value: _deepClone(valueToCopy) });
+    return { newDocument: document2 };
   },
-  test: function(obj, key2, document) {
-    return { newDocument: document, test: _areEquals(obj[key2], this.value) };
+  test: function(obj, key2, document2) {
+    return { newDocument: document2, test: _areEquals(obj[key2], this.value) };
   },
-  _get: function(obj, key2, document) {
+  _get: function(obj, key2, document2) {
     this.value = obj[key2];
-    return { newDocument: document };
+    return { newDocument: document2 };
   }
 };
 var arrOps = {
-  add: function(arr, i, document) {
+  add: function(arr, i, document2) {
     if (isInteger2(i)) {
       arr.splice(i, 0, this.value);
     } else {
       arr[i] = this.value;
     }
-    return { newDocument: document, index: i };
+    return { newDocument: document2, index: i };
   },
-  remove: function(arr, i, document) {
+  remove: function(arr, i, document2) {
     var removedList = arr.splice(i, 1);
-    return { newDocument: document, removed: removedList[0] };
+    return { newDocument: document2, removed: removedList[0] };
   },
-  replace: function(arr, i, document) {
+  replace: function(arr, i, document2) {
     var removed = arr[i];
     arr[i] = this.value;
-    return { newDocument: document, removed };
+    return { newDocument: document2, removed };
   },
   move: objOps.move,
   copy: objOps.copy,
   test: objOps.test,
   _get: objOps._get
 };
-function getValueByPointer(document, pointer) {
+function getValueByPointer(document2, pointer) {
   if (pointer == "") {
-    return document;
+    return document2;
   }
   var getOriginalDestination = { op: "_get", path: pointer };
-  applyOperation(document, getOriginalDestination);
+  applyOperation(document2, getOriginalDestination);
   return getOriginalDestination.value;
 }
 __name(getValueByPointer, "getValueByPointer");
-function applyOperation(document, operation, validateOperation, mutateDocument, banPrototypeModifications, index) {
+function applyOperation(document2, operation, validateOperation, mutateDocument, banPrototypeModifications, index) {
   if (validateOperation === void 0) {
     validateOperation = false;
   }
@@ -48972,54 +52124,54 @@ function applyOperation(document, operation, validateOperation, mutateDocument,
   }
   if (validateOperation) {
     if (typeof validateOperation == "function") {
-      validateOperation(operation, 0, document, operation.path);
+      validateOperation(operation, 0, document2, operation.path);
     } else {
       validator(operation, 0);
     }
   }
   if (operation.path === "") {
-    var returnValue = { newDocument: document };
+    var returnValue = { newDocument: document2 };
     if (operation.op === "add") {
       returnValue.newDocument = operation.value;
       return returnValue;
     } else if (operation.op === "replace") {
       returnValue.newDocument = operation.value;
-      returnValue.removed = document;
+      returnValue.removed = document2;
       return returnValue;
     } else if (operation.op === "move" || operation.op === "copy") {
-      returnValue.newDocument = getValueByPointer(document, operation.from);
+      returnValue.newDocument = getValueByPointer(document2, operation.from);
       if (operation.op === "move") {
-        returnValue.removed = document;
+        returnValue.removed = document2;
       }
       return returnValue;
     } else if (operation.op === "test") {
-      returnValue.test = _areEquals(document, operation.value);
+      returnValue.test = _areEquals(document2, operation.value);
       if (returnValue.test === false) {
-        throw new JsonPatchError("Test operation failed", "TEST_OPERATION_FAILED", index, operation, document);
+        throw new JsonPatchError("Test operation failed", "TEST_OPERATION_FAILED", index, operation, document2);
       }
-      returnValue.newDocument = document;
+      returnValue.newDocument = document2;
       return returnValue;
     } else if (operation.op === "remove") {
-      returnValue.removed = document;
+      returnValue.removed = document2;
       returnValue.newDocument = null;
       return returnValue;
     } else if (operation.op === "_get") {
-      operation.value = document;
+      operation.value = document2;
       return returnValue;
     } else {
       if (validateOperation) {
-        throw new JsonPatchError("Operation `op` property is not one of operations defined in RFC-6902", "OPERATION_OP_INVALID", index, operation, document);
+        throw new JsonPatchError("Operation `op` property is not one of operations defined in RFC-6902", "OPERATION_OP_INVALID", index, operation, document2);
       } else {
         return returnValue;
       }
     }
   } else {
     if (!mutateDocument) {
-      document = _deepClone(document);
+      document2 = _deepClone(document2);
     }
     var path = operation.path || "";
     var keys = path.split("/");
-    var obj = document;
+    var obj = document2;
     var t = 1;
     var len = keys.length;
     var existingPathFragment = void 0;
@@ -49046,7 +52198,7 @@ function applyOperation(document, operation, validateOperation, mutateDocument,
             existingPathFragment = operation.path;
           }
           if (existingPathFragment !== void 0) {
-            validateFunction(operation, 0, document, existingPathFragment);
+            validateFunction(operation, 0, document2, existingPathFragment);
           }
         }
       }
@@ -49056,39 +52208,39 @@ function applyOperation(document, operation, validateOperation, mutateDocument,
           key2 = obj.length;
         } else {
           if (validateOperation && !isInteger2(key2)) {
-            throw new JsonPatchError("Expected an unsigned base-10 integer value, making the new referenced value the array element with the zero-based index", "OPERATION_PATH_ILLEGAL_ARRAY_INDEX", index, operation, document);
+            throw new JsonPatchError("Expected an unsigned base-10 integer value, making the new referenced value the array element with the zero-based index", "OPERATION_PATH_ILLEGAL_ARRAY_INDEX", index, operation, document2);
           } else if (isInteger2(key2)) {
             key2 = ~~key2;
           }
         }
         if (t >= len) {
           if (validateOperation && operation.op === "add" && key2 > obj.length) {
-            throw new JsonPatchError("The specified index MUST NOT be greater than the number of elements in the array", "OPERATION_VALUE_OUT_OF_BOUNDS", index, operation, document);
+            throw new JsonPatchError("The specified index MUST NOT be greater than the number of elements in the array", "OPERATION_VALUE_OUT_OF_BOUNDS", index, operation, document2);
           }
-          var returnValue = arrOps[operation.op].call(operation, obj, key2, document);
+          var returnValue = arrOps[operation.op].call(operation, obj, key2, document2);
           if (returnValue.test === false) {
-            throw new JsonPatchError("Test operation failed", "TEST_OPERATION_FAILED", index, operation, document);
+            throw new JsonPatchError("Test operation failed", "TEST_OPERATION_FAILED", index, operation, document2);
           }
           return returnValue;
         }
       } else {
         if (t >= len) {
-          var returnValue = objOps[operation.op].call(operation, obj, key2, document);
+          var returnValue = objOps[operation.op].call(operation, obj, key2, document2);
           if (returnValue.test === false) {
-            throw new JsonPatchError("Test operation failed", "TEST_OPERATION_FAILED", index, operation, document);
+            throw new JsonPatchError("Test operation failed", "TEST_OPERATION_FAILED", index, operation, document2);
           }
           return returnValue;
         }
       }
       obj = obj[key2];
       if (validateOperation && t < len && (!obj || typeof obj !== "object")) {
-        throw new JsonPatchError("Cannot perform operation at the desired path", "OPERATION_PATH_UNRESOLVABLE", index, operation, document);
+        throw new JsonPatchError("Cannot perform operation at the desired path", "OPERATION_PATH_UNRESOLVABLE", index, operation, document2);
       }
     }
   }
 }
 __name(applyOperation, "applyOperation");
-function applyPatch(document, patch, validateOperation, mutateDocument, banPrototypeModifications) {
+function applyPatch(document2, patch, validateOperation, mutateDocument, banPrototypeModifications) {
   if (mutateDocument === void 0) {
     mutateDocument = true;
   }
@@ -49101,72 +52253,72 @@ function applyPatch(document, patch, validateOperation, mutateDocument, banProto
     }
   }
   if (!mutateDocument) {
-    document = _deepClone(document);
+    document2 = _deepClone(document2);
   }
   var results = new Array(patch.length);
   for (var i = 0, length_1 = patch.length; i < length_1; i++) {
-    results[i] = applyOperation(document, patch[i], validateOperation, true, banPrototypeModifications, i);
-    document = results[i].newDocument;
+    results[i] = applyOperation(document2, patch[i], validateOperation, true, banPrototypeModifications, i);
+    document2 = results[i].newDocument;
   }
-  results.newDocument = document;
+  results.newDocument = document2;
   return results;
 }
 __name(applyPatch, "applyPatch");
-function applyReducer(document, operation, index) {
-  var operationResult = applyOperation(document, operation);
+function applyReducer(document2, operation, index) {
+  var operationResult = applyOperation(document2, operation);
   if (operationResult.test === false) {
-    throw new JsonPatchError("Test operation failed", "TEST_OPERATION_FAILED", index, operation, document);
+    throw new JsonPatchError("Test operation failed", "TEST_OPERATION_FAILED", index, operation, document2);
   }
   return operationResult.newDocument;
 }
 __name(applyReducer, "applyReducer");
-function validator(operation, index, document, existingPathFragment) {
+function validator(operation, index, document2, existingPathFragment) {
   if (typeof operation !== "object" || operation === null || Array.isArray(operation)) {
-    throw new JsonPatchError("Operation is not an object", "OPERATION_NOT_AN_OBJECT", index, operation, document);
+    throw new JsonPatchError("Operation is not an object", "OPERATION_NOT_AN_OBJECT", index, operation, document2);
   } else if (!objOps[operation.op]) {
-    throw new JsonPatchError("Operation `op` property is not one of operations defined in RFC-6902", "OPERATION_OP_INVALID", index, operation, document);
+    throw new JsonPatchError("Operation `op` property is not one of operations defined in RFC-6902", "OPERATION_OP_INVALID", index, operation, document2);
   } else if (typeof operation.path !== "string") {
-    throw new JsonPatchError("Operation `path` property is not a string", "OPERATION_PATH_INVALID", index, operation, document);
+    throw new JsonPatchError("Operation `path` property is not a string", "OPERATION_PATH_INVALID", index, operation, document2);
   } else if (operation.path.indexOf("/") !== 0 && operation.path.length > 0) {
-    throw new JsonPatchError('Operation `path` property must start with "/"', "OPERATION_PATH_INVALID", index, operation, document);
+    throw new JsonPatchError('Operation `path` property must start with "/"', "OPERATION_PATH_INVALID", index, operation, document2);
   } else if ((operation.op === "move" || operation.op === "copy") && typeof operation.from !== "string") {
-    throw new JsonPatchError("Operation `from` property is not present (applicable in `move` and `copy` operations)", "OPERATION_FROM_REQUIRED", index, operation, document);
+    throw new JsonPatchError("Operation `from` property is not present (applicable in `move` and `copy` operations)", "OPERATION_FROM_REQUIRED", index, operation, document2);
   } else if ((operation.op === "add" || operation.op === "replace" || operation.op === "test") && operation.value === void 0) {
-    throw new JsonPatchError("Operation `value` property is not present (applicable in `add`, `replace` and `test` operations)", "OPERATION_VALUE_REQUIRED", index, operation, document);
+    throw new JsonPatchError("Operation `value` property is not present (applicable in `add`, `replace` and `test` operations)", "OPERATION_VALUE_REQUIRED", index, operation, document2);
   } else if ((operation.op === "add" || operation.op === "replace" || operation.op === "test") && hasUndefined(operation.value)) {
-    throw new JsonPatchError("Operation `value` property is not present (applicable in `add`, `replace` and `test` operations)", "OPERATION_VALUE_CANNOT_CONTAIN_UNDEFINED", index, operation, document);
-  } else if (document) {
+    throw new JsonPatchError("Operation `value` property is not present (applicable in `add`, `replace` and `test` operations)", "OPERATION_VALUE_CANNOT_CONTAIN_UNDEFINED", index, operation, document2);
+  } else if (document2) {
     if (operation.op == "add") {
       var pathLen = operation.path.split("/").length;
       var existingPathLen = existingPathFragment.split("/").length;
       if (pathLen !== existingPathLen + 1 && pathLen !== existingPathLen) {
-        throw new JsonPatchError("Cannot perform an `add` operation at the desired path", "OPERATION_PATH_CANNOT_ADD", index, operation, document);
+        throw new JsonPatchError("Cannot perform an `add` operation at the desired path", "OPERATION_PATH_CANNOT_ADD", index, operation, document2);
       }
     } else if (operation.op === "replace" || operation.op === "remove" || operation.op === "_get") {
       if (operation.path !== existingPathFragment) {
-        throw new JsonPatchError("Cannot perform the operation at a path that does not exist", "OPERATION_PATH_UNRESOLVABLE", index, operation, document);
+        throw new JsonPatchError("Cannot perform the operation at a path that does not exist", "OPERATION_PATH_UNRESOLVABLE", index, operation, document2);
       }
     } else if (operation.op === "move" || operation.op === "copy") {
       var existingValue = { op: "_get", path: operation.from, value: void 0 };
-      var error = validate5([existingValue], document);
+      var error = validate5([existingValue], document2);
       if (error && error.name === "OPERATION_PATH_UNRESOLVABLE") {
-        throw new JsonPatchError("Cannot perform the operation from a path that does not exist", "OPERATION_FROM_UNRESOLVABLE", index, operation, document);
+        throw new JsonPatchError("Cannot perform the operation from a path that does not exist", "OPERATION_FROM_UNRESOLVABLE", index, operation, document2);
       }
     }
   }
 }
 __name(validator, "validator");
-function validate5(sequence, document, externalValidator) {
+function validate5(sequence, document2, externalValidator) {
   try {
     if (!Array.isArray(sequence)) {
       throw new JsonPatchError("Patch sequence must be an array", "SEQUENCE_NOT_AN_ARRAY");
     }
-    if (document) {
-      applyPatch(_deepClone(document), _deepClone(sequence), externalValidator || true);
+    if (document2) {
+      applyPatch(_deepClone(document2), _deepClone(sequence), externalValidator || true);
     } else {
       externalValidator = externalValidator || validator;
       for (var i = 0; i < sequence.length; i++) {
-        externalValidator(sequence[i], i, document, void 0);
+        externalValidator(sequence[i], i, document2, void 0);
       }
     }
   } catch (e) {
@@ -49394,11 +52546,11 @@ var fast_json_patch_default = Object.assign({}, core_exports, duplex_exports, {
   unescapePathComponent
 });
 
-// ../../node_modules/.pnpm/@ceramicnetwork+stream-tile@2.3.0/node_modules/@ceramicnetwork/stream-tile/lib/tile-document.js
+// ../../node_modules/.pnpm/@ceramicnetwork+stream-tile@2.3.0_@opentelemetry+api@1.1.0/node_modules/@ceramicnetwork/stream-tile/lib/tile-document.js
 var import_lodash3 = __toESM(require_lodash(), 1);
 var import_random3 = __toESM(require_random(), 1);
 
-// ../../node_modules/.pnpm/@ceramicnetwork+common@2.3.0/node_modules/@ceramicnetwork/common/lib/streamopts.js
+// ../../node_modules/.pnpm/@ceramicnetwork+common@2.3.0_@opentelemetry+api@1.1.0/node_modules/@ceramicnetwork/common/lib/streamopts.js
 var SyncOptions;
 (function(SyncOptions2) {
   SyncOptions2[SyncOptions2["PREFER_CACHE"] = 0] = "PREFER_CACHE";
@@ -49406,7 +52558,7 @@ var SyncOptions;
   SyncOptions2[SyncOptions2["NEVER_SYNC"] = 2] = "NEVER_SYNC";
 })(SyncOptions || (SyncOptions = {}));
 
-// ../../node_modules/.pnpm/@ceramicnetwork+common@2.3.0/node_modules/@ceramicnetwork/common/lib/stream.js
+// ../../node_modules/.pnpm/@ceramicnetwork+common@2.3.0_@opentelemetry+api@1.1.0/node_modules/@ceramicnetwork/common/lib/stream.js
 var import_lodash = __toESM(require_lodash(), 1);
 
 // ../../node_modules/.pnpm/tslib@2.4.0/node_modules/tslib/modules/index.js
@@ -51300,7 +54452,7 @@ function throttle(durationSelector, config2) {
 }
 __name(throttle, "throttle");
 
-// ../../node_modules/.pnpm/@ceramicnetwork+common@2.3.0/node_modules/@ceramicnetwork/common/lib/stream.js
+// ../../node_modules/.pnpm/@ceramicnetwork+common@2.3.0_@opentelemetry+api@1.1.0/node_modules/@ceramicnetwork/common/lib/stream.js
 var SignatureStatus;
 (function(SignatureStatus2) {
   SignatureStatus2[SignatureStatus2["GENESIS"] = 0] = "GENESIS";
@@ -51379,10 +54531,10 @@ function StreamStatic() {
 }
 __name(StreamStatic, "StreamStatic");
 
-// ../../node_modules/.pnpm/@ceramicnetwork+common@2.3.0/node_modules/@ceramicnetwork/common/lib/utils/http-utils.js
+// ../../node_modules/.pnpm/@ceramicnetwork+common@2.3.0_@opentelemetry+api@1.1.0/node_modules/@ceramicnetwork/common/lib/utils/http-utils.js
 var import_cross_fetch = __toESM(require("cross-fetch"), 1);
 
-// ../../node_modules/.pnpm/@ceramicnetwork+common@2.3.0/node_modules/@ceramicnetwork/common/lib/utils/abort-signal-utils.js
+// ../../node_modules/.pnpm/@ceramicnetwork+common@2.3.0_@opentelemetry+api@1.1.0/node_modules/@ceramicnetwork/common/lib/utils/abort-signal-utils.js
 function mergeAbortSignals(signals) {
   const controller = new AbortController();
   if (signals.length === 0) {
@@ -51432,7 +54584,7 @@ function abortable2(original, fn) {
 }
 __name(abortable2, "abortable");
 
-// ../../node_modules/.pnpm/@ceramicnetwork+common@2.3.0/node_modules/@ceramicnetwork/common/lib/utils/http-utils.js
+// ../../node_modules/.pnpm/@ceramicnetwork+common@2.3.0_@opentelemetry+api@1.1.0/node_modules/@ceramicnetwork/common/lib/utils/http-utils.js
 var DEFAULT_FETCH_TIMEOUT = 60 * 1e3 * 3;
 function fetchJson(_0) {
   return __async(this, arguments, function* (url, opts = {}) {
@@ -51457,10 +54609,10 @@ function fetchJson(_0) {
 }
 __name(fetchJson, "fetchJson");
 
-// ../../node_modules/.pnpm/@ceramicnetwork+common@2.3.0/node_modules/@ceramicnetwork/common/lib/utils/stream-utils.js
+// ../../node_modules/.pnpm/@ceramicnetwork+common@2.3.0_@opentelemetry+api@1.1.0/node_modules/@ceramicnetwork/common/lib/utils/stream-utils.js
 var import_lodash2 = __toESM(require_lodash(), 1);
 
-// ../../node_modules/.pnpm/@ceramicnetwork+common@2.3.0/node_modules/@ceramicnetwork/common/lib/utils/cid-utils.js
+// ../../node_modules/.pnpm/@ceramicnetwork+common@2.3.0_@opentelemetry+api@1.1.0/node_modules/@ceramicnetwork/common/lib/utils/cid-utils.js
 init_cid();
 function toCID(givenCid) {
   const cid = CID.asCID(givenCid);
@@ -51477,7 +54629,7 @@ function toCID(givenCid) {
 }
 __name(toCID, "toCID");
 
-// ../../node_modules/.pnpm/@ceramicnetwork+common@2.3.0/node_modules/@ceramicnetwork/common/lib/utils/stream-utils.js
+// ../../node_modules/.pnpm/@ceramicnetwork+common@2.3.0_@opentelemetry+api@1.1.0/node_modules/@ceramicnetwork/common/lib/utils/stream-utils.js
 var TILE_TYPE_ID = 0;
 var StreamUtils = class {
   static streamIdFromState(state) {
@@ -51657,7 +54809,7 @@ var StreamUtils = class {
 };
 __name(StreamUtils, "StreamUtils");
 
-// ../../node_modules/.pnpm/@ceramicnetwork+common@2.3.0/node_modules/@ceramicnetwork/common/lib/utils/accountid-utils.js
+// ../../node_modules/.pnpm/@ceramicnetwork+common@2.3.0_@opentelemetry+api@1.1.0/node_modules/@ceramicnetwork/common/lib/utils/accountid-utils.js
 function normalizeAccountId(accountId) {
   if (typeof accountId === "string" && accountId.includes("@")) {
     const [address, chainId] = accountId.split("@");
@@ -51670,7 +54822,7 @@ function normalizeAccountId(accountId) {
 }
 __name(normalizeAccountId, "normalizeAccountId");
 
-// ../../node_modules/.pnpm/@ceramicnetwork+common@2.3.0/node_modules/@ceramicnetwork/common/lib/stream-state-subject.js
+// ../../node_modules/.pnpm/@ceramicnetwork+common@2.3.0_@opentelemetry+api@1.1.0/node_modules/@ceramicnetwork/common/lib/stream-state-subject.js
 var StreamStateSubject = class extends BehaviorSubject {
   next(next) {
     const current = this.value;
@@ -51681,7 +54833,7 @@ var StreamStateSubject = class extends BehaviorSubject {
 };
 __name(StreamStateSubject, "StreamStateSubject");
 
-// ../../node_modules/.pnpm/@ceramicnetwork+stream-tile@2.3.0/node_modules/@ceramicnetwork/stream-tile/lib/tile-document.js
+// ../../node_modules/.pnpm/@ceramicnetwork+stream-tile@2.3.0_@opentelemetry+api@1.1.0/node_modules/@ceramicnetwork/stream-tile/lib/tile-document.js
 var __decorate4 = function(decorators, target, key2, desc) {
   var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key2) : desc, d;
   if (typeof Reflect === "object" && typeof Reflect.decorate === "function")
@@ -51917,7 +55069,7 @@ TileDocument = TileDocument_1 = __decorate4([
   StreamStatic()
 ], TileDocument);
 
-// ../../node_modules/.pnpm/@glazed+tile-loader@0.2.1/node_modules/@glazed/tile-loader/dist/index.js
+// ../../node_modules/.pnpm/@glazed+tile-loader@0.2.1_@opentelemetry+api@1.1.0/node_modules/@glazed/tile-loader/dist/index.js
 var import_dataloader = __toESM(require_dataloader(), 1);
 function _checkPrivateRedeclaration2(obj, privateCollection) {
   if (privateCollection.has(obj)) {
@@ -52076,7 +55228,7 @@ var TileLoader = class extends import_dataloader.default {
 };
 __name(TileLoader, "TileLoader");
 
-// ../../node_modules/.pnpm/@glazed+datamodel@0.3.1/node_modules/@glazed/datamodel/dist/index.js
+// ../../node_modules/.pnpm/@glazed+datamodel@0.3.1_@opentelemetry+api@1.1.0/node_modules/@glazed/datamodel/dist/index.js
 function _checkPrivateRedeclaration3(obj, privateCollection) {
   if (privateCollection.has(obj)) {
     throw new TypeError("Cannot initialize the same private elements twice on an object");
@@ -52196,7 +55348,7 @@ var DataModel = class {
 };
 __name(DataModel, "DataModel");
 
-// ../../node_modules/.pnpm/@glazed+did-datastore@0.3.2/node_modules/@glazed/did-datastore/dist/proxy.js
+// ../../node_modules/.pnpm/@glazed+did-datastore@0.3.2_@opentelemetry+api@1.1.0/node_modules/@glazed/did-datastore/dist/proxy.js
 function _checkPrivateRedeclaration4(obj, privateCollection) {
   if (privateCollection.has(obj)) {
     throw new TypeError("Cannot initialize the same private elements twice on an object");
@@ -52342,7 +55494,7 @@ var TileProxy = class {
 };
 __name(TileProxy, "TileProxy");
 
-// ../../node_modules/.pnpm/@glazed+did-datastore@0.3.2/node_modules/@glazed/did-datastore/dist/utils.js
+// ../../node_modules/.pnpm/@glazed+did-datastore@0.3.2_@opentelemetry+api@1.1.0/node_modules/@glazed/did-datastore/dist/utils.js
 var didRegex = /^did:([A-Za-z0-9]+):([A-Za-z0-9.\-:_]+)$/;
 function isDIDstring(did) {
   return didRegex.test(did);
@@ -52365,7 +55517,7 @@ function getIDXMetadata(did) {
 }
 __name(getIDXMetadata, "getIDXMetadata");
 
-// ../../node_modules/.pnpm/@glazed+did-datastore@0.3.2/node_modules/@glazed/did-datastore/dist/index.js
+// ../../node_modules/.pnpm/@glazed+did-datastore@0.3.2_@opentelemetry+api@1.1.0/node_modules/@glazed/did-datastore/dist/index.js
 function _checkPrivateRedeclaration5(obj, privateCollection) {
   if (privateCollection.has(obj)) {
     throw new TypeError("Cannot initialize the same private elements twice on an object");
@@ -52762,13 +55914,13 @@ var DIDDataStore = class {
 };
 __name(DIDDataStore, "DIDDataStore");
 
-// ../../node_modules/.pnpm/@ceramicnetwork+http-client@2.3.0/node_modules/@ceramicnetwork/http-client/lib/utils.js
+// ../../node_modules/.pnpm/@ceramicnetwork+http-client@2.3.0_@opentelemetry+api@1.1.0/node_modules/@ceramicnetwork/http-client/lib/utils.js
 function typeStreamID(streamId) {
   return typeof streamId === "string" ? StreamID.fromString(streamId) : streamId;
 }
 __name(typeStreamID, "typeStreamID");
 
-// ../../node_modules/.pnpm/@ceramicnetwork+http-client@2.3.0/node_modules/@ceramicnetwork/http-client/lib/document.js
+// ../../node_modules/.pnpm/@ceramicnetwork+http-client@2.3.0_@opentelemetry+api@1.1.0/node_modules/@ceramicnetwork/http-client/lib/document.js
 var Document = class extends Observable {
   constructor(initial, _apiUrl, syncInterval) {
     super((subscriber) => {
@@ -52867,7 +56019,7 @@ var Document = class extends Observable {
 };
 __name(Document, "Document");
 
-// ../../node_modules/.pnpm/@ceramicnetwork+stream-caip10-link@2.1.0/node_modules/@ceramicnetwork/stream-caip10-link/lib/caip10-link.js
+// ../../node_modules/.pnpm/@ceramicnetwork+stream-caip10-link@2.1.0_@opentelemetry+api@1.1.0/node_modules/@ceramicnetwork/stream-caip10-link/lib/caip10-link.js
 var import_lodash4 = __toESM(require_lodash(), 1);
 var __decorate5 = function(decorators, target, key2, desc) {
   var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key2) : desc, d;
@@ -52986,7 +56138,7 @@ Caip10Link = Caip10Link_1 = __decorate5([
   StreamStatic()
 ], Caip10Link);
 
-// ../../node_modules/.pnpm/@ceramicnetwork+stream-model@0.3.0/node_modules/@ceramicnetwork/stream-model/lib/model.js
+// ../../node_modules/.pnpm/@ceramicnetwork+stream-model@0.3.0_@opentelemetry+api@1.1.0/node_modules/@ceramicnetwork/stream-model/lib/model.js
 var import_random4 = __toESM(require_random(), 1);
 init_cid();
 init_digest();
@@ -53187,7 +56339,7 @@ Model = Model_1 = __decorate6([
   StreamStatic()
 ], Model);
 
-// ../../node_modules/.pnpm/@ceramicnetwork+stream-model-instance@0.3.0/node_modules/@ceramicnetwork/stream-model-instance/lib/model-instance-document.js
+// ../../node_modules/.pnpm/@ceramicnetwork+stream-model-instance@0.3.0_@opentelemetry+api@1.1.0/node_modules/@ceramicnetwork/stream-model-instance/lib/model-instance-document.js
 var import_random5 = __toESM(require_random(), 1);
 var __decorate7 = function(decorators, target, key2, desc) {
   var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key2) : desc, d;
@@ -53342,7 +56494,7 @@ ModelInstanceDocument = ModelInstanceDocument_1 = __decorate7([
   StreamStatic()
 ], ModelInstanceDocument);
 
-// ../../node_modules/.pnpm/@ceramicnetwork+http-client@2.3.0/node_modules/@ceramicnetwork/http-client/lib/remote-pin-api.js
+// ../../node_modules/.pnpm/@ceramicnetwork+http-client@2.3.0_@opentelemetry+api@1.1.0/node_modules/@ceramicnetwork/http-client/lib/remote-pin-api.js
 var RemotePinApi = class {
   constructor(_apiUrl) {
     this._apiUrl = _apiUrl;
@@ -53395,7 +56547,7 @@ var RemotePinApi = class {
 };
 __name(RemotePinApi, "RemotePinApi");
 
-// ../../node_modules/.pnpm/@ceramicnetwork+http-client@2.3.0/node_modules/@ceramicnetwork/http-client/lib/remote-index-api.js
+// ../../node_modules/.pnpm/@ceramicnetwork+http-client@2.3.0_@opentelemetry+api@1.1.0/node_modules/@ceramicnetwork/http-client/lib/remote-index-api.js
 var RemoteIndexApi = class {
   constructor(apiUrl) {
     this._fetchJson = fetchJson;
@@ -53423,7 +56575,7 @@ var RemoteIndexApi = class {
 };
 __name(RemoteIndexApi, "RemoteIndexApi");
 
-// ../../node_modules/.pnpm/@ceramicnetwork+http-client@2.3.0/node_modules/@ceramicnetwork/http-client/lib/ceramic-http-client.js
+// ../../node_modules/.pnpm/@ceramicnetwork+http-client@2.3.0_@opentelemetry+api@1.1.0/node_modules/@ceramicnetwork/http-client/lib/ceramic-http-client.js
 var API_PATH = "/api/v0/";
 var CERAMIC_HOST = "http://localhost:7007";
 var DEFAULT_CLIENT_CONFIG = {
@@ -53517,14 +56669,14 @@ var CeramicClient = class {
     return __async(this, arguments, function* (streamId, commit, opts = {}) {
       opts = __spreadValues(__spreadValues({}, DEFAULT_APPLY_COMMIT_OPTS), opts);
       const effectiveStreamId = typeStreamID(streamId);
-      const document = yield Document.applyCommit(this._apiUrl, effectiveStreamId, commit, opts, this._config.syncInterval);
+      const document2 = yield Document.applyCommit(this._apiUrl, effectiveStreamId, commit, opts, this._config.syncInterval);
       const fromCache = this._streamCache.get(effectiveStreamId.toString());
       if (fromCache) {
-        fromCache.next(document.state);
-        return this.buildStreamFromDocument(document);
+        fromCache.next(document2.state);
+        return this.buildStreamFromDocument(document2);
       } else {
-        this._streamCache.set(effectiveStreamId.toString(), document);
-        return this.buildStreamFromDocument(document);
+        this._streamCache.set(effectiveStreamId.toString(), document2);
+        return this.buildStreamFromDocument(document2);
       }
     });
   }
@@ -53691,6 +56843,11 @@ var getIDXPlugin = /* @__PURE__ */ __name((_0, _1) => __async(void 0, [_0, _1],
   };
 }), "getIDXPlugin");
 
+// ../learn-card-helpers/dist/helpers.esm.js
+var __defProp2 = Object.defineProperty;
+var __name2 = /* @__PURE__ */ __name((target, value) => __defProp2(target, "name", { value, configurable: true }), "__name");
+var isHex = /* @__PURE__ */ __name2((str) => /^[0-9a-f]+$/i.test(str), "isHex");
+
 // src/wallet/plugins/didkey/helpers.ts
 var ED25519_METHODS = ["key", "tz", "pkh:tz", "pkh:tezos", "pkh:sol", "pkh:solana"];
 var SECP256K1_METHODS = [
@@ -53707,7 +56864,6 @@ var SECP256K1_METHODS = [
   "pkh:eip155",
   "pkh:bip122"
 ];
-var isHex = /* @__PURE__ */ __name((str) => /^[0-9a-f]+$/i.test(str), "isHex");
 var getAlgorithmForDidMethod = /* @__PURE__ */ __name((didMethod) => {
   if (ED25519_METHODS.includes(didMethod))
     return "ed25519";
@@ -53758,50 +56914,50 @@ var getDidKeyPlugin = /* @__PURE__ */ __name((wallet, key2) => __async(void 0, n
 
 // src/wallet/plugins/vc/issueCredential.ts
 var issueCredential2 = /* @__PURE__ */ __name((initWallet) => {
-  return (wallet, credential) => __async(void 0, null, function* () {
+  return (_0, _1, ..._2) => __async(void 0, [_0, _1, ..._2], function* (wallet, credential, signingOptions = {}) {
     const kp = wallet.pluginMethods.getSubjectKeypair();
     if (!kp)
       throw new Error("Cannot issue credential: Could not get subject keypair");
-    const options = {
+    const options = __spreadValues({
       verificationMethod: yield initWallet.pluginMethods.keyToVerificationMethod("key", kp),
       proofPurpose: "assertionMethod"
-    };
+    }, signingOptions);
     return initWallet.pluginMethods.issueCredential(credential, options, kp);
   });
 }, "issueCredential");
 
 // src/wallet/plugins/vc/verifyCredential.ts
 var verifyCredential3 = /* @__PURE__ */ __name((initWallet) => {
-  return (_wallet, credential) => __async(void 0, null, function* () {
-    return initWallet.pluginMethods.verifyCredential(credential);
+  return (_0, _1, ..._2) => __async(void 0, [_0, _1, ..._2], function* (_wallet, credential, options = {}) {
+    return initWallet.pluginMethods.verifyCredential(credential, options);
   });
 }, "verifyCredential");
 
 // src/wallet/plugins/vc/issuePresentation.ts
 var issuePresentation2 = /* @__PURE__ */ __name((initWallet) => {
-  return (wallet, presentation) => __async(void 0, null, function* () {
+  return (_0, _1, ..._2) => __async(void 0, [_0, _1, ..._2], function* (wallet, presentation, signingOptions = {}) {
     const kp = wallet.pluginMethods.getSubjectKeypair();
     if (!kp)
       throw new Error("Cannot issue credential: Could not get subject keypair");
-    const options = {
+    const options = __spreadValues({
       verificationMethod: yield initWallet.pluginMethods.keyToVerificationMethod("key", kp),
       proofPurpose: "assertionMethod"
-    };
+    }, signingOptions);
     return initWallet.pluginMethods.issuePresentation(presentation, options, kp);
   });
 }, "issuePresentation");
 
 // src/wallet/plugins/vc/verifyPresentation.ts
 var verifyPresentation2 = /* @__PURE__ */ __name((initWallet) => {
-  return (_wallet, presentation) => __async(void 0, null, function* () {
-    return initWallet.pluginMethods.verifyPresentation(presentation);
+  return (_0, _1, ..._2) => __async(void 0, [_0, _1, ..._2], function* (_wallet, presentation, options = {}) {
+    return initWallet.pluginMethods.verifyPresentation(presentation, options);
   });
 }, "verifyPresentation");
 
 // src/wallet/plugins/vc/vc.ts
 var getVCPlugin = /* @__PURE__ */ __name((wallet) => {
   return {
-    pluginMethods: __spreadProps(__spreadValues({}, recycleDependents(wallet.pluginMethods)), {
+    pluginMethods: {
       issueCredential: issueCredential2(wallet),
       verifyCredential: verifyCredential3(wallet),
       issuePresentation: issuePresentation2(wallet),
@@ -53827,11 +56983,12 @@ var getVCPlugin = /* @__PURE__ */ __name((wallet) => {
           verifiableCredential: credential
         };
       })
-    })
+    }
   };
 }, "getVCPlugin");
 
 // src/wallet/plugins/EthereumPlugin/index.ts
+var import_buffer = __toESM(require_buffer2());
 var import_ethers2 = require("ethers");
 
 // src/wallet/plugins/EthereumPlugin/helpers.ts
@@ -53899,7 +57056,7 @@ var ERC20ABI = require_erc20_abi();
 var getEthereumPlugin = /* @__PURE__ */ __name((initWallet, config2) => {
   let { infuraProjectId, network = "mainnet" } = config2;
   const secpKeypair = initWallet.pluginMethods.getSubjectKeypair("secp256k1");
-  const privateKey = Buffer.from(secpKeypair.d, "base64").toString("hex");
+  const privateKey = import_buffer.Buffer.from(secpKeypair.d, "base64").toString("hex");
   let ethersWallet = new import_ethers2.ethers.Wallet(privateKey);
   const publicKey = ethersWallet.address;
   const getProvider = /* @__PURE__ */ __name(() => {
@@ -54638,11 +57795,11 @@ var Transformer = class {
   }
   _getDocument(_0) {
     return __async(this, arguments, function* ({ url }) {
-      const { document } = yield this.documentLoader(url);
-      if (typeof document === "string") {
-        return JSON.parse(document);
+      const { document: document2 } = yield this.documentLoader(url);
+      if (typeof document2 === "string") {
+        return JSON.parse(document2);
       }
-      return document;
+      return document2;
     });
   }
   _getTermType({ activeCtx, def }) {
@@ -57181,11 +60338,12 @@ var walletFromKey = /* @__PURE__ */ __name((_0, ..._1) => __async(void 0, [_0, .
   const didkitWallet = yield (yield generateWallet(defaultContents)).addPlugin(yield getDidKitPlugin(didkit));
   const didkeyWallet = yield didkitWallet.addPlugin(yield getDidKeyPlugin(didkitWallet, key2));
   const didkeyAndVCWallet = yield didkeyWallet.addPlugin(getVCPlugin(didkeyWallet));
-  const templateWallet = yield didkeyAndVCWallet.addPlugin(getVCTemplatesPlugin(didkeyAndVCWallet));
+  const templateWallet = yield didkeyAndVCWallet.addPlugin(getVCTemplatesPlugin());
   const idxWallet = yield templateWallet.addPlugin(yield getIDXPlugin(templateWallet, ceramicIdx));
   const expirationWallet = yield idxWallet.addPlugin(ExpirationPlugin(idxWallet));
   const ethWallet = yield expirationWallet.addPlugin(getEthereumPlugin(expirationWallet, ethereumConfig));
-  const wallet = yield ethWallet.addPlugin(getVpqrPlugin(ethWallet));
+  const vpqrWallet = yield ethWallet.addPlugin(getVpqrPlugin(ethWallet));
+  const wallet = yield vpqrWallet.addPlugin(yield getCHAPIPlugin());
   return {
     _wallet: wallet,
     did: (type = "key") => wallet.pluginMethods.getSubjectDid(type),
@@ -57220,7 +60378,12 @@ var walletFromKey = /* @__PURE__ */ __name((_0, ..._1) => __async(void 0, [_0, .
     transferTokens: wallet.pluginMethods.transferTokens,
     getCurrentNetwork: wallet.pluginMethods.getCurrentNetwork,
     changeNetwork: wallet.pluginMethods.changeNetwork,
-    addInfuraProjectId: wallet.pluginMethods.addInfuraProjectId
+    addInfuraProjectId: wallet.pluginMethods.addInfuraProjectId,
+    installChapiHandler: wallet.pluginMethods.installChapiHandler,
+    activateChapiHandler: wallet.pluginMethods.activateChapiHandler,
+    receiveChapiEvent: wallet.pluginMethods.receiveChapiEvent,
+    storePresentationViaChapi: wallet.pluginMethods.storePresentationViaChapi,
+    storeCredentialViaChapiDidAuth: wallet.pluginMethods.storeCredentialViaChapiDidAuth
   };
 }), "walletFromKey");
 
@@ -57235,6 +60398,47 @@ function initLearnCard() {
   });
 }
 __name(initLearnCard, "initLearnCard");
+/*!
+ * A CredentialHandlerRegistration provides a CredentialManager to enable Web
+ * apps to register Profiles that can be presented to websites.
+ *
+ * Copyright (c) 2017 Digital Bazaar, Inc. All rights reserved.
+ */
+/*!
+ * A CredentialRequestEvent is emitted when a request has been made for
+ * credentials.
+ *
+ * Copyright (c) 2017 Digital Bazaar, Inc. All rights reserved.
+ */
+/*!
+ * A CredentialStoreEvent is emitted when a request has been made to
+ * store a credential.
+ *
+ * Copyright (c) 2017 Digital Bazaar, Inc. All rights reserved.
+ */
+/*!
+ * A WebApp is a remote application that runs in a WebAppContext.
+ *
+ * Copyright (c) 2017 Digital Bazaar, Inc. All rights reserved.
+ */
+/*!
+ * A WebCredential is a Credential that can be retrieved from or stored by a
+ * "credential handler" that runs in a third party Web application.
+ *
+ * Copyright (c) 2017-2021 Digital Bazaar, Inc. All rights reserved.
+ */
+/*!
+ * Copyright (c) 2017 Digital Bazaar, Inc. All rights reserved.
+ */
+/*!
+ * Copyright (c) 2017-2018 Digital Bazaar, Inc. All rights reserved.
+ */
+/*!
+ * Copyright (c) 2017-2022 Digital Bazaar, Inc. All rights reserved.
+ */
+/*!
+ * Copyright (c) 2018-2022 Digital Bazaar, Inc. All rights reserved.
+ */
 /*!
  * Copyright (c) 2019-2022 Digital Bazaar, Inc. All rights reserved.
  */
@@ -57247,6 +60451,36 @@ __name(initLearnCard, "initLearnCard");
 /*!
  * Copyright (c) 2021 Digital Bazaar, Inc. All rights reserved.
  */
+/*!
+ * Copyright (c) 2022 Digital Bazaar, Inc. All rights reserved.
+ */
+/*!
+ * JSON-RPC for Web Request Polyfills.
+ *
+ * Copyright (c) 2017 Digital Bazaar, Inc. All rights reserved.
+ */
+/*!
+ * The buffer module from node.js, for the browser.
+ *
+ * @author   Feross Aboukhadijeh <https://feross.org>
+ * @license  MIT
+ */
+/*!
+ * The core CredentialHandler class.
+ *
+ * Copyright (c) 2017 Digital Bazaar, Inc. All rights reserved.
+ */
+/*!
+ * Utilities for Web Request RPC.
+ *
+ * Copyright (c) 2017 Digital Bazaar, Inc. All rights reserved.
+ */
+/*!
+ * Wrapper for native CredentialsContainer that uses remote Credential Mediator
+ * for WebCredential-related operations.
+ *
+ * Copyright (c) 2017-2018 Digital Bazaar, Inc. All rights reserved.
+ */
 /*!
  * https://github.com/Starcounter-Jack/JSON-Patch
  * (c) 2017-2021 Joachim Wester
@@ -57257,6 +60491,7 @@ __name(initLearnCard, "initLearnCard");
  * (c) 2017-2022 Joachim Wester
  * MIT licensed
  */
+/*! ieee754. BSD-3-Clause License. Feross Aboukhadijeh <https://feross.org/opensource> */
 /**
  * @module QRCode
  * @package @nuintun/qrcode