@learncard/core 1.0.0 → 1.1.1

package/dist/core.esm.js

@@ -26471,17 +26471,17 @@ var require_decode_uri_component = __commonJS({
         "%FE%FF": "\uFFFD\uFFFD",
         "%FF%FE": "\uFFFD\uFFFD"
       };
-      var match = multiMatcher.exec(input);
-      while (match) {
+      var match2 = multiMatcher.exec(input);
+      while (match2) {
         try {
-          replaceMap[match[0]] = decodeURIComponent(match[0]);
+          replaceMap[match2[0]] = decodeURIComponent(match2[0]);
         } catch (err) {
-          var result = decode9(match[0]);
-          if (result !== match[0]) {
-            replaceMap[match[0]] = result;
+          var result = decode9(match2[0]);
+          if (result !== match2[0]) {
+            replaceMap[match2[0]] = result;
           }
         }
-        match = multiMatcher.exec(input);
+        match2 = multiMatcher.exec(input);
       }
       replaceMap["%C2"] = "\uFFFD";
       var entries = Object.keys(replaceMap);
@@ -26909,19 +26909,6 @@ var require_query_string = __commonJS({
   }
 });
 
-// ../../node_modules/.pnpm/hex-lite@1.5.0/node_modules/hex-lite/dist/hex-lite.mjs
-function toUint8Array(str) {
-  var s = 0, sl = str.length, bytes = [];
-  if (sl % 2) {
-    throw new Error("invalid hex:" + str);
-  }
-  for (; s < sl; s += 2) {
-    bytes.push(parseInt(str.substr(s, 2), 16));
-  }
-  return new Uint8Array(bytes);
-}
-__name(toUint8Array, "toUint8Array");
-
 // src/didkit/pkg/didkit_wasm.js
 var wasm;
 var cachedTextDecoder = new TextDecoder("utf-8", { ignoreBOM: true, fatal: true });
@@ -32110,14 +32097,14 @@ var ProviderCrypto = class {
       return this.onExportKey.apply(this, args);
     });
   }
-  checkExportKey(format, key2, ...args) {
-    this.checkKeyFormat(format);
+  checkExportKey(format2, key2, ...args) {
+    this.checkKeyFormat(format2);
     this.checkCryptoKey(key2);
     if (!key2.extractable) {
       throw new CryptoError("key: Is not extractable");
     }
   }
-  onExportKey(format, key2, ...args) {
+  onExportKey(format2, key2, ...args) {
     return __async(this, null, function* () {
       throw new UnsupportedOperationError("exportKey");
     });
@@ -32128,16 +32115,16 @@ var ProviderCrypto = class {
       return this.onImportKey.apply(this, args);
     });
   }
-  checkImportKey(format, keyData, algorithm, extractable, keyUsages, ...args) {
-    this.checkKeyFormat(format);
-    this.checkKeyData(format, keyData);
+  checkImportKey(format2, keyData, algorithm, extractable, keyUsages, ...args) {
+    this.checkKeyFormat(format2);
+    this.checkKeyData(format2, keyData);
     this.checkAlgorithmName(algorithm);
     this.checkImportParams(algorithm);
     if (Array.isArray(this.usages)) {
       this.checkKeyUsages(keyUsages, this.usages);
     }
   }
-  onImportKey(format, keyData, algorithm, extractable, keyUsages, ...args) {
+  onImportKey(format2, keyData, algorithm, extractable, keyUsages, ...args) {
     return __async(this, null, function* () {
       throw new UnsupportedOperationError("importKey");
     });
@@ -32179,8 +32166,8 @@ var ProviderCrypto = class {
   }
   checkImportParams(algorithm) {
   }
-  checkKeyFormat(format) {
-    switch (format) {
+  checkKeyFormat(format2) {
+    switch (format2) {
       case "raw":
       case "pkcs8":
       case "spki":
@@ -32190,11 +32177,11 @@ var ProviderCrypto = class {
         throw new TypeError("format: Is invalid value. Must be 'jwk', 'raw', 'spki', or 'pkcs8'");
     }
   }
-  checkKeyData(format, keyData) {
+  checkKeyData(format2, keyData) {
     if (!keyData) {
       throw new TypeError("keyData: Cannot be empty on empty on key importing");
     }
-    if (format === "jwk") {
+    if (format2 === "jwk") {
       if (!isJWK(keyData)) {
         throw new TypeError("keyData: Is not JsonWebToken");
       }
@@ -33121,8 +33108,8 @@ var Pbkdf2Provider = class extends ProviderCrypto {
       throw new TypeError("iterations: Is less than 1");
     }
   }
-  checkImportKey(format, keyData, algorithm, extractable, keyUsages, ...args) {
-    super.checkImportKey(format, keyData, algorithm, extractable, keyUsages);
+  checkImportKey(format2, keyData, algorithm, extractable, keyUsages, ...args) {
+    super.checkImportKey(format2, keyData, algorithm, extractable, keyUsages);
     if (extractable) {
       throw new SyntaxError("extractable: Must be 'false'");
     }
@@ -33148,8 +33135,8 @@ var HkdfProvider = class extends ProviderCrypto {
       throw new TypeError("salt: Is not of type '(ArrayBuffer or ArrayBufferView)'");
     }
   }
-  checkImportKey(format, keyData, algorithm, extractable, keyUsages, ...args) {
-    super.checkImportKey(format, keyData, algorithm, extractable, keyUsages);
+  checkImportKey(format2, keyData, algorithm, extractable, keyUsages, ...args) {
+    super.checkImportKey(format2, keyData, algorithm, extractable, keyUsages);
     if (extractable) {
       throw new SyntaxError("extractable: Must be 'false'");
     }
@@ -33348,34 +33335,34 @@ var SubtleCrypto = class {
   exportKey(...args) {
     return __async(this, null, function* () {
       this.checkRequiredArguments(args, 2, "exportKey");
-      const [format, key2, ...params] = args;
+      const [format2, key2, ...params] = args;
       this.checkCryptoKey(key2);
       const provider = this.getProvider(key2.algorithm.name);
-      const result = yield provider.exportKey(format, key2, ...params);
+      const result = yield provider.exportKey(format2, key2, ...params);
       return result;
     });
   }
   importKey(...args) {
     return __async(this, null, function* () {
       this.checkRequiredArguments(args, 5, "importKey");
-      const [format, keyData, algorithm, extractable, keyUsages, ...params] = args;
+      const [format2, keyData, algorithm, extractable, keyUsages, ...params] = args;
       const preparedAlgorithm = this.prepareAlgorithm(algorithm);
       const provider = this.getProvider(preparedAlgorithm.name);
-      if (["pkcs8", "spki", "raw"].indexOf(format) !== -1) {
+      if (["pkcs8", "spki", "raw"].indexOf(format2) !== -1) {
         const preparedData = import_pvtsutils4.BufferSourceConverter.toArrayBuffer(keyData);
-        return provider.importKey(format, preparedData, __spreadProps(__spreadValues({}, preparedAlgorithm), { name: provider.name }), extractable, keyUsages, ...params);
+        return provider.importKey(format2, preparedData, __spreadProps(__spreadValues({}, preparedAlgorithm), { name: provider.name }), extractable, keyUsages, ...params);
       } else {
         if (!keyData.kty) {
           throw new TypeError("keyData: Is not JSON");
         }
       }
-      return provider.importKey(format, keyData, __spreadProps(__spreadValues({}, preparedAlgorithm), { name: provider.name }), extractable, keyUsages, ...params);
+      return provider.importKey(format2, keyData, __spreadProps(__spreadValues({}, preparedAlgorithm), { name: provider.name }), extractable, keyUsages, ...params);
     });
   }
-  wrapKey(format, key2, wrappingKey, wrapAlgorithm, ...args) {
+  wrapKey(format2, key2, wrappingKey, wrapAlgorithm, ...args) {
     return __async(this, null, function* () {
-      let keyData = yield this.exportKey(format, key2, ...args);
-      if (format === "jwk") {
+      let keyData = yield this.exportKey(format2, key2, ...args);
+      if (format2 === "jwk") {
         const json = JSON.stringify(keyData);
         keyData = import_pvtsutils4.Convert.FromUtf8String(json);
       }
@@ -33385,13 +33372,13 @@ var SubtleCrypto = class {
       return provider.encrypt(__spreadProps(__spreadValues({}, preparedAlgorithm), { name: provider.name }), wrappingKey, preparedData, { keyUsage: false }, ...args);
     });
   }
-  unwrapKey(format, wrappedKey, unwrappingKey, unwrapAlgorithm, unwrappedKeyAlgorithm, extractable, keyUsages, ...args) {
+  unwrapKey(format2, wrappedKey, unwrappingKey, unwrapAlgorithm, unwrappedKeyAlgorithm, extractable, keyUsages, ...args) {
     return __async(this, null, function* () {
       const preparedAlgorithm = this.prepareAlgorithm(unwrapAlgorithm);
       const preparedData = import_pvtsutils4.BufferSourceConverter.toArrayBuffer(wrappedKey);
       const provider = this.getProvider(preparedAlgorithm.name);
       let keyData = yield provider.decrypt(__spreadProps(__spreadValues({}, preparedAlgorithm), { name: provider.name }), unwrappingKey, preparedData, { keyUsage: false }, ...args);
-      if (format === "jwk") {
+      if (format2 === "jwk") {
         try {
           keyData = JSON.parse(import_pvtsutils4.Convert.ToUtf8String(keyData));
         } catch (e) {
@@ -33400,7 +33387,7 @@ var SubtleCrypto = class {
           throw error;
         }
       }
-      return this.importKey(format, keyData, unwrappedKeyAlgorithm, extractable, keyUsages, ...args);
+      return this.importKey(format2, keyData, unwrappedKeyAlgorithm, extractable, keyUsages, ...args);
     });
   }
   checkRequiredArguments(args, size, methodName) {
@@ -33534,12 +33521,12 @@ var AesCrypto = class {
       return key2;
     });
   }
-  static exportKey(format, key2) {
+  static exportKey(format2, key2) {
     return __async(this, null, function* () {
       if (!(key2 instanceof AesCryptoKey)) {
         throw new Error("key: Is not AesCryptoKey");
       }
-      switch (format.toLowerCase()) {
+      switch (format2.toLowerCase()) {
         case "jwk":
           return JsonSerializer.toJSON(key2);
         case "raw":
@@ -33549,10 +33536,10 @@ var AesCrypto = class {
       }
     });
   }
-  static importKey(format, keyData, algorithm, extractable, keyUsages) {
+  static importKey(format2, keyData, algorithm, extractable, keyUsages) {
     return __async(this, null, function* () {
       let key2;
-      switch (format.toLowerCase()) {
+      switch (format2.toLowerCase()) {
         case "jwk":
           key2 = JsonParser.fromJSON(keyData, { targetSchema: AesCryptoKey });
           break;
@@ -33736,14 +33723,14 @@ var AesCbcProvider2 = class extends AesCbcProvider {
       return AesCrypto.decrypt(algorithm, getCryptoKey(key2), new Uint8Array(data));
     });
   }
-  onExportKey(format, key2) {
+  onExportKey(format2, key2) {
     return __async(this, null, function* () {
-      return AesCrypto.exportKey(format, getCryptoKey(key2));
+      return AesCrypto.exportKey(format2, getCryptoKey(key2));
     });
   }
-  onImportKey(format, keyData, algorithm, extractable, keyUsages) {
+  onImportKey(format2, keyData, algorithm, extractable, keyUsages) {
     return __async(this, null, function* () {
-      const key2 = yield AesCrypto.importKey(format, keyData, { name: algorithm.name }, extractable, keyUsages);
+      const key2 = yield AesCrypto.importKey(format2, keyData, { name: algorithm.name }, extractable, keyUsages);
       return setCryptoKey(key2);
     });
   }
@@ -33867,14 +33854,14 @@ var AesCmacProvider2 = class extends AesCmacProvider {
       return Buffer.from(signature2).compare(Buffer.from(signature22)) === 0;
     });
   }
-  onExportKey(format, key2) {
+  onExportKey(format2, key2) {
     return __async(this, null, function* () {
-      return AesCrypto.exportKey(format, getCryptoKey(key2));
+      return AesCrypto.exportKey(format2, getCryptoKey(key2));
     });
   }
-  onImportKey(format, keyData, algorithm, extractable, keyUsages) {
+  onImportKey(format2, keyData, algorithm, extractable, keyUsages) {
     return __async(this, null, function* () {
-      const res = yield AesCrypto.importKey(format, keyData, { name: algorithm.name }, extractable, keyUsages);
+      const res = yield AesCrypto.importKey(format2, keyData, { name: algorithm.name }, extractable, keyUsages);
       return setCryptoKey(res);
     });
   }
@@ -33906,14 +33893,14 @@ var AesCtrProvider2 = class extends AesCtrProvider {
       return AesCrypto.decrypt(algorithm, getCryptoKey(key2), new Uint8Array(data));
     });
   }
-  onExportKey(format, key2) {
+  onExportKey(format2, key2) {
     return __async(this, null, function* () {
-      return AesCrypto.exportKey(format, getCryptoKey(key2));
+      return AesCrypto.exportKey(format2, getCryptoKey(key2));
     });
   }
-  onImportKey(format, keyData, algorithm, extractable, keyUsages) {
+  onImportKey(format2, keyData, algorithm, extractable, keyUsages) {
     return __async(this, null, function* () {
-      const res = yield AesCrypto.importKey(format, keyData, { name: algorithm.name }, extractable, keyUsages);
+      const res = yield AesCrypto.importKey(format2, keyData, { name: algorithm.name }, extractable, keyUsages);
       return setCryptoKey(res);
     });
   }
@@ -33945,14 +33932,14 @@ var AesGcmProvider2 = class extends AesGcmProvider {
       return AesCrypto.decrypt(algorithm, getCryptoKey(key2), new Uint8Array(data));
     });
   }
-  onExportKey(format, key2) {
+  onExportKey(format2, key2) {
     return __async(this, null, function* () {
-      return AesCrypto.exportKey(format, getCryptoKey(key2));
+      return AesCrypto.exportKey(format2, getCryptoKey(key2));
     });
   }
-  onImportKey(format, keyData, algorithm, extractable, keyUsages) {
+  onImportKey(format2, keyData, algorithm, extractable, keyUsages) {
     return __async(this, null, function* () {
-      const res = yield AesCrypto.importKey(format, keyData, { name: algorithm.name }, extractable, keyUsages);
+      const res = yield AesCrypto.importKey(format2, keyData, { name: algorithm.name }, extractable, keyUsages);
       return setCryptoKey(res);
     });
   }
@@ -33974,14 +33961,14 @@ var AesKwProvider2 = class extends AesKwProvider {
       return setCryptoKey(res);
     });
   }
-  onExportKey(format, key2) {
+  onExportKey(format2, key2) {
     return __async(this, null, function* () {
-      return AesCrypto.exportKey(format, getCryptoKey(key2));
+      return AesCrypto.exportKey(format2, getCryptoKey(key2));
     });
   }
-  onImportKey(format, keyData, algorithm, extractable, keyUsages) {
+  onImportKey(format2, keyData, algorithm, extractable, keyUsages) {
     return __async(this, null, function* () {
-      const res = yield AesCrypto.importKey(format, keyData, { name: algorithm.name }, extractable, keyUsages);
+      const res = yield AesCrypto.importKey(format2, keyData, { name: algorithm.name }, extractable, keyUsages);
       return setCryptoKey(res);
     });
   }
@@ -34023,14 +34010,14 @@ var AesEcbProvider2 = class extends AesEcbProvider {
       return AesCrypto.decrypt(algorithm, getCryptoKey(key2), new Uint8Array(data));
     });
   }
-  onExportKey(format, key2) {
+  onExportKey(format2, key2) {
     return __async(this, null, function* () {
-      return AesCrypto.exportKey(format, getCryptoKey(key2));
+      return AesCrypto.exportKey(format2, getCryptoKey(key2));
     });
   }
-  onImportKey(format, keyData, algorithm, extractable, keyUsages) {
+  onImportKey(format2, keyData, algorithm, extractable, keyUsages) {
     return __async(this, null, function* () {
-      const res = yield AesCrypto.importKey(format, keyData, { name: algorithm.name }, extractable, keyUsages);
+      const res = yield AesCrypto.importKey(format2, keyData, { name: algorithm.name }, extractable, keyUsages);
       return setCryptoKey(res);
     });
   }
@@ -34071,9 +34058,9 @@ var DesCrypto = class {
       return key2;
     });
   }
-  static exportKey(format, key2) {
+  static exportKey(format2, key2) {
     return __async(this, null, function* () {
-      switch (format.toLowerCase()) {
+      switch (format2.toLowerCase()) {
         case "jwk":
           return JsonSerializer.toJSON(key2);
         case "raw":
@@ -34083,10 +34070,10 @@ var DesCrypto = class {
       }
     });
   }
-  static importKey(format, keyData, algorithm, extractable, keyUsages) {
+  static importKey(format2, keyData, algorithm, extractable, keyUsages) {
     return __async(this, null, function* () {
       let key2;
-      switch (format.toLowerCase()) {
+      switch (format2.toLowerCase()) {
         case "jwk":
           key2 = JsonParser.fromJSON(keyData, { targetSchema: DesCryptoKey });
           break;
@@ -34192,14 +34179,14 @@ var DesCbcProvider = class extends DesProvider {
       return DesCrypto.decrypt(algorithm, getCryptoKey(key2), new Uint8Array(data));
     });
   }
-  onExportKey(format, key2) {
+  onExportKey(format2, key2) {
     return __async(this, null, function* () {
-      return DesCrypto.exportKey(format, getCryptoKey(key2));
+      return DesCrypto.exportKey(format2, getCryptoKey(key2));
     });
   }
-  onImportKey(format, keyData, algorithm, extractable, keyUsages) {
+  onImportKey(format2, keyData, algorithm, extractable, keyUsages) {
     return __async(this, null, function* () {
-      const key2 = yield DesCrypto.importKey(format, keyData, { name: this.name, length: this.keySizeBits }, extractable, keyUsages);
+      const key2 = yield DesCrypto.importKey(format2, keyData, { name: this.name, length: this.keySizeBits }, extractable, keyUsages);
       if (key2.data.length !== this.keySizeBits >> 3) {
         throw new OperationError("keyData: Wrong key size");
       }
@@ -34240,14 +34227,14 @@ var DesEde3CbcProvider = class extends DesProvider {
       return DesCrypto.decrypt(algorithm, getCryptoKey(key2), new Uint8Array(data));
     });
   }
-  onExportKey(format, key2) {
+  onExportKey(format2, key2) {
     return __async(this, null, function* () {
-      return DesCrypto.exportKey(format, getCryptoKey(key2));
+      return DesCrypto.exportKey(format2, getCryptoKey(key2));
     });
   }
-  onImportKey(format, keyData, algorithm, extractable, keyUsages) {
+  onImportKey(format2, keyData, algorithm, extractable, keyUsages) {
     return __async(this, null, function* () {
-      const key2 = yield DesCrypto.importKey(format, keyData, { name: this.name, length: this.keySizeBits }, extractable, keyUsages);
+      const key2 = yield DesCrypto.importKey(format2, keyData, { name: this.name, length: this.keySizeBits }, extractable, keyUsages);
       if (key2.data.length !== this.keySizeBits >> 3) {
         throw new OperationError("keyData: Wrong key size");
       }
@@ -34373,9 +34360,9 @@ var RsaCrypto = class {
       return res;
     });
   }
-  static exportKey(format, key2) {
+  static exportKey(format2, key2) {
     return __async(this, null, function* () {
-      switch (format.toLowerCase()) {
+      switch (format2.toLowerCase()) {
         case "jwk":
           return JsonSerializer.toJSON(key2);
         case "pkcs8":
@@ -34386,9 +34373,9 @@ var RsaCrypto = class {
       }
     });
   }
-  static importKey(format, keyData, algorithm, extractable, keyUsages) {
+  static importKey(format2, keyData, algorithm, extractable, keyUsages) {
     return __async(this, null, function* () {
-      switch (format.toLowerCase()) {
+      switch (format2.toLowerCase()) {
         case "jwk": {
           const jwk = keyData;
           if (jwk.d) {
@@ -34604,14 +34591,14 @@ var RsaSsaProvider2 = class extends RsaSsaProvider {
       return RsaCrypto.verify(algorithm, getCryptoKey(key2), new Uint8Array(signature2), new Uint8Array(data));
     });
   }
-  onExportKey(format, key2) {
+  onExportKey(format2, key2) {
     return __async(this, null, function* () {
-      return RsaCrypto.exportKey(format, getCryptoKey(key2));
+      return RsaCrypto.exportKey(format2, getCryptoKey(key2));
     });
   }
-  onImportKey(format, keyData, algorithm, extractable, keyUsages) {
+  onImportKey(format2, keyData, algorithm, extractable, keyUsages) {
     return __async(this, null, function* () {
-      const key2 = yield RsaCrypto.importKey(format, keyData, __spreadProps(__spreadValues({}, algorithm), { name: this.name }), extractable, keyUsages);
+      const key2 = yield RsaCrypto.importKey(format2, keyData, __spreadProps(__spreadValues({}, algorithm), { name: this.name }), extractable, keyUsages);
       return setCryptoKey(key2);
     });
   }
@@ -34660,14 +34647,14 @@ var RsaPssProvider2 = class extends RsaPssProvider {
       return RsaCrypto.verify(algorithm, getCryptoKey(key2), new Uint8Array(signature2), new Uint8Array(data));
     });
   }
-  onExportKey(format, key2) {
+  onExportKey(format2, key2) {
     return __async(this, null, function* () {
-      return RsaCrypto.exportKey(format, getCryptoKey(key2));
+      return RsaCrypto.exportKey(format2, getCryptoKey(key2));
     });
   }
-  onImportKey(format, keyData, algorithm, extractable, keyUsages) {
+  onImportKey(format2, keyData, algorithm, extractable, keyUsages) {
     return __async(this, null, function* () {
-      const key2 = yield RsaCrypto.importKey(format, keyData, __spreadProps(__spreadValues({}, algorithm), { name: this.name }), extractable, keyUsages);
+      const key2 = yield RsaCrypto.importKey(format2, keyData, __spreadProps(__spreadValues({}, algorithm), { name: this.name }), extractable, keyUsages);
       return setCryptoKey(key2);
     });
   }
@@ -34831,14 +34818,14 @@ ${internalKey.data.toString("base64")}
       return new Uint8Array(pkcs0).buffer;
     });
   }
-  onExportKey(format, key2) {
+  onExportKey(format2, key2) {
     return __async(this, null, function* () {
-      return RsaCrypto.exportKey(format, getCryptoKey(key2));
+      return RsaCrypto.exportKey(format2, getCryptoKey(key2));
     });
   }
-  onImportKey(format, keyData, algorithm, extractable, keyUsages) {
+  onImportKey(format2, keyData, algorithm, extractable, keyUsages) {
     return __async(this, null, function* () {
-      const key2 = yield RsaCrypto.importKey(format, keyData, __spreadProps(__spreadValues({}, algorithm), { name: this.name }), extractable, keyUsages);
+      const key2 = yield RsaCrypto.importKey(format2, keyData, __spreadProps(__spreadValues({}, algorithm), { name: this.name }), extractable, keyUsages);
       return setCryptoKey(key2);
     });
   }
@@ -34923,14 +34910,14 @@ var RsaEsProvider = class extends ProviderCrypto {
       return new Uint8Array(dec).buffer;
     });
   }
-  onExportKey(format, key2) {
+  onExportKey(format2, key2) {
     return __async(this, null, function* () {
-      return RsaCrypto.exportKey(format, getCryptoKey(key2));
+      return RsaCrypto.exportKey(format2, getCryptoKey(key2));
     });
   }
-  onImportKey(format, keyData, algorithm, extractable, keyUsages) {
+  onImportKey(format2, keyData, algorithm, extractable, keyUsages) {
     return __async(this, null, function* () {
-      const key2 = yield RsaCrypto.importKey(format, keyData, __spreadProps(__spreadValues({}, algorithm), { name: this.name }), extractable, keyUsages);
+      const key2 = yield RsaCrypto.importKey(format2, keyData, __spreadProps(__spreadValues({}, algorithm), { name: this.name }), extractable, keyUsages);
       return setCryptoKey(key2);
     });
   }
@@ -35240,9 +35227,9 @@ ${key2.data.toString("base64")}
       return new Uint8Array(bits).buffer.slice(0, length2 >> 3);
     });
   }
-  static exportKey(format, key2) {
+  static exportKey(format2, key2) {
     return __async(this, null, function* () {
-      switch (format.toLowerCase()) {
+      switch (format2.toLowerCase()) {
         case "jwk":
           return JsonSerializer.toJSON(key2);
         case "pkcs8":
@@ -35257,9 +35244,9 @@ ${key2.data.toString("base64")}
       }
     });
   }
-  static importKey(format, keyData, algorithm, extractable, keyUsages) {
+  static importKey(format2, keyData, algorithm, extractable, keyUsages) {
     return __async(this, null, function* () {
-      switch (format.toLowerCase()) {
+      switch (format2.toLowerCase()) {
         case "jwk": {
           const jwk = keyData;
           if (jwk.d) {
@@ -35389,14 +35376,14 @@ var EcdsaProvider2 = class extends EcdsaProvider {
       return EcCrypto.verify(algorithm, getCryptoKey(key2), new Uint8Array(signature2), new Uint8Array(data));
     });
   }
-  onExportKey(format, key2) {
+  onExportKey(format2, key2) {
     return __async(this, null, function* () {
-      return EcCrypto.exportKey(format, getCryptoKey(key2));
+      return EcCrypto.exportKey(format2, getCryptoKey(key2));
     });
   }
-  onImportKey(format, keyData, algorithm, extractable, keyUsages) {
+  onImportKey(format2, keyData, algorithm, extractable, keyUsages) {
     return __async(this, null, function* () {
-      const key2 = yield EcCrypto.importKey(format, keyData, __spreadProps(__spreadValues({}, algorithm), { name: this.name }), extractable, keyUsages);
+      const key2 = yield EcCrypto.importKey(format2, keyData, __spreadProps(__spreadValues({}, algorithm), { name: this.name }), extractable, keyUsages);
       return setCryptoKey(key2);
     });
   }
@@ -35425,14 +35412,14 @@ var EcdhProvider2 = class extends EcdhProvider {
       };
     });
   }
-  onExportKey(format, key2) {
+  onExportKey(format2, key2) {
     return __async(this, null, function* () {
-      return EcCrypto.exportKey(format, getCryptoKey(key2));
+      return EcCrypto.exportKey(format2, getCryptoKey(key2));
     });
   }
-  onImportKey(format, keyData, algorithm, extractable, keyUsages) {
+  onImportKey(format2, keyData, algorithm, extractable, keyUsages) {
     return __async(this, null, function* () {
-      const key2 = yield EcCrypto.importKey(format, keyData, __spreadProps(__spreadValues({}, algorithm), { name: this.name }), extractable, keyUsages);
+      const key2 = yield EcCrypto.importKey(format2, keyData, __spreadProps(__spreadValues({}, algorithm), { name: this.name }), extractable, keyUsages);
       return setCryptoKey(key2);
     });
   }
@@ -35615,9 +35602,9 @@ ${key2.data.toString("base64")}
       return new Uint8Array(bits).buffer.slice(0, length2 >> 3);
     });
   }
-  static exportKey(format, key2) {
+  static exportKey(format2, key2) {
     return __async(this, null, function* () {
-      switch (format.toLowerCase()) {
+      switch (format2.toLowerCase()) {
         case "jwk":
           return JsonSerializer.toJSON(key2);
         case "pkcs8":
@@ -35632,9 +35619,9 @@ ${key2.data.toString("base64")}
       }
     });
   }
-  static importKey(format, keyData, algorithm, extractable, keyUsages) {
+  static importKey(format2, keyData, algorithm, extractable, keyUsages) {
     return __async(this, null, function* () {
-      switch (format.toLowerCase()) {
+      switch (format2.toLowerCase()) {
         case "jwk": {
           const jwk = keyData;
           if (jwk.d) {
@@ -35715,14 +35702,14 @@ var EdDsaProvider2 = class extends EdDsaProvider {
       return EdCrypto.verify(algorithm, getCryptoKey(key2), new Uint8Array(signature2), new Uint8Array(data));
     });
   }
-  onExportKey(format, key2) {
+  onExportKey(format2, key2) {
     return __async(this, null, function* () {
-      return EdCrypto.exportKey(format, getCryptoKey(key2));
+      return EdCrypto.exportKey(format2, getCryptoKey(key2));
     });
   }
-  onImportKey(format, keyData, algorithm, extractable, keyUsages) {
+  onImportKey(format2, keyData, algorithm, extractable, keyUsages) {
     return __async(this, null, function* () {
-      const key2 = yield EdCrypto.importKey(format, keyData, __spreadProps(__spreadValues({}, algorithm), { name: this.name }), extractable, keyUsages);
+      const key2 = yield EdCrypto.importKey(format2, keyData, __spreadProps(__spreadValues({}, algorithm), { name: this.name }), extractable, keyUsages);
       return setCryptoKey(key2);
     });
   }
@@ -35747,14 +35734,14 @@ var EcdhEsProvider2 = class extends EcdhEsProvider {
       return bits;
     });
   }
-  onExportKey(format, key2) {
+  onExportKey(format2, key2) {
     return __async(this, null, function* () {
-      return EdCrypto.exportKey(format, getCryptoKey(key2));
+      return EdCrypto.exportKey(format2, getCryptoKey(key2));
     });
   }
-  onImportKey(format, keyData, algorithm, extractable, keyUsages) {
+  onImportKey(format2, keyData, algorithm, extractable, keyUsages) {
     return __async(this, null, function* () {
-      const key2 = yield EdCrypto.importKey(format, keyData, __spreadProps(__spreadValues({}, algorithm), { name: this.name }), extractable, keyUsages);
+      const key2 = yield EdCrypto.importKey(format2, keyData, __spreadProps(__spreadValues({}, algorithm), { name: this.name }), extractable, keyUsages);
       return setCryptoKey(key2);
     });
   }
@@ -35779,9 +35766,9 @@ var Pbkdf2Provider2 = class extends Pbkdf2Provider {
       });
     });
   }
-  onImportKey(format, keyData, algorithm, extractable, keyUsages) {
+  onImportKey(format2, keyData, algorithm, extractable, keyUsages) {
     return __async(this, null, function* () {
-      if (format === "raw") {
+      if (format2 === "raw") {
         const key2 = new PbkdfCryptoKey();
         key2.data = Buffer.from(keyData);
         key2.algorithm = { name: this.name };
@@ -35841,10 +35828,10 @@ var HmacProvider2 = class extends HmacProvider {
       return hmac2.compare(Buffer.from(signature2)) === 0;
     });
   }
-  onImportKey(format, keyData, algorithm, extractable, keyUsages) {
+  onImportKey(format2, keyData, algorithm, extractable, keyUsages) {
     return __async(this, null, function* () {
       let key2;
-      switch (format.toLowerCase()) {
+      switch (format2.toLowerCase()) {
         case "jwk":
           key2 = JsonParser.fromJSON(keyData, { targetSchema: HmacCryptoKey });
           break;
@@ -35865,9 +35852,9 @@ var HmacProvider2 = class extends HmacProvider {
       return setCryptoKey(key2);
     });
   }
-  onExportKey(format, key2) {
+  onExportKey(format2, key2) {
     return __async(this, null, function* () {
-      switch (format.toLowerCase()) {
+      switch (format2.toLowerCase()) {
         case "jwk":
           return JsonSerializer.toJSON(getCryptoKey(key2));
         case "raw":
@@ -35889,9 +35876,9 @@ var HkdfCryptoKey = class extends CryptoKey2 {
 };
 __name(HkdfCryptoKey, "HkdfCryptoKey");
 var HkdfProvider2 = class extends HkdfProvider {
-  onImportKey(format, keyData, algorithm, extractable, keyUsages) {
+  onImportKey(format2, keyData, algorithm, extractable, keyUsages) {
     return __async(this, null, function* () {
-      if (format.toLowerCase() !== "raw") {
+      if (format2.toLowerCase() !== "raw") {
         throw new OperationError("Operation not supported");
       }
       const key2 = new HkdfCryptoKey();
@@ -36022,7 +36009,6 @@ if (isNodejs()) {
 } else {
   crypto3 = window.crypto;
 }
-var crypto_default = crypto3;
 
 // src/wallet/base/wallet.ts
 var addPluginToWallet = /* @__PURE__ */ __name((wallet, plugin) => __async(void 0, null, function* () {
@@ -36041,11 +36027,10 @@ var removeFromWallet = /* @__PURE__ */ __name((wallet, contentId) => __async(voi
 var bindMethods = /* @__PURE__ */ __name((wallet, pluginMethods) => Object.fromEntries(Object.entries(pluginMethods).map(([key2, method]) => [key2, method.bind(wallet, wallet)])), "bindMethods");
 var generateWallet = /* @__PURE__ */ __name((..._0) => __async(void 0, [..._0], function* (contents = [], _wallet = {}) {
   const { plugins = [] } = _wallet;
-  const { pluginMethods, pluginConstants } = plugins.reduce(({ pluginMethods: pluginMethods2, pluginConstants: pluginConstants2 }, plugin) => {
-    const newPluginMethods = __spreadValues(__spreadValues({}, pluginMethods2), plugin.pluginMethods);
-    const newPluginConstants = __spreadValues(__spreadValues({}, pluginConstants2), plugin.pluginConstants);
-    return { pluginMethods: newPluginMethods, pluginConstants: newPluginConstants };
-  }, { pluginMethods: {}, pluginConstants: {} });
+  const pluginMethods = plugins.reduce((cumulativePluginMethods, plugin) => {
+    const newPluginMethods = __spreadValues(__spreadValues({}, cumulativePluginMethods), plugin.pluginMethods);
+    return newPluginMethods;
+  }, {});
   const wallet = {
     contents: [...contents],
     add: function(content) {
@@ -36057,7 +36042,6 @@ var generateWallet = /* @__PURE__ */ __name((..._0) => __async(void 0, [..._0],
     status: "UNLOCKED" /* Unlocked */,
     plugins,
     pluginMethods,
-    pluginConstants,
     addPlugin: function(plugin) {
       return addPluginToWallet(this, plugin);
     }
@@ -39550,7 +39534,7 @@ var ChainId = /* @__PURE__ */ function() {
     }
     return new ChainId2(getParams(id, this.spec)).toJSON();
   }, "parse");
-  ChainId2.format = /* @__PURE__ */ __name(function format(params) {
+  ChainId2.format = /* @__PURE__ */ __name(function format2(params) {
     return joinParams(params, this.spec);
   }, "format");
   var _proto = ChainId2.prototype;
@@ -39589,7 +39573,7 @@ var AccountId = /* @__PURE__ */ function() {
       address
     }).toJSON();
   }, "parse");
-  AccountId2.format = /* @__PURE__ */ __name(function format(params) {
+  AccountId2.format = /* @__PURE__ */ __name(function format2(params) {
     var chainId = new ChainId(params.chainId);
     var splitParams2 = _extends({}, chainId.toJSON(), {
       address: params.address
@@ -39624,7 +39608,7 @@ var AssetName = /* @__PURE__ */ function() {
     }
     return new AssetName2(getParams(id, this.spec)).toJSON();
   }, "parse");
-  AssetName2.format = /* @__PURE__ */ __name(function format(params) {
+  AssetName2.format = /* @__PURE__ */ __name(function format2(params) {
     return joinParams(params, this.spec);
   }, "format");
   var _proto = AssetName2.prototype;
@@ -39655,7 +39639,7 @@ var AssetType = /* @__PURE__ */ function() {
     }
     return new AssetType2(getParams(id, this.spec)).toJSON();
   }, "parse");
-  AssetType2.format = /* @__PURE__ */ __name(function format(params) {
+  AssetType2.format = /* @__PURE__ */ __name(function format2(params) {
     return joinParams(params, this.spec);
   }, "format");
   var _proto = AssetType2.prototype;
@@ -39687,7 +39671,7 @@ var AssetId = /* @__PURE__ */ function() {
     }
     return new AssetId2(getParams(id, this.spec)).toJSON();
   }, "parse");
-  AssetId2.format = /* @__PURE__ */ __name(function format(params) {
+  AssetId2.format = /* @__PURE__ */ __name(function format2(params) {
     return joinParams(params, this.spec);
   }, "format");
   var _proto = AssetId2.prototype;
@@ -43332,6 +43316,19 @@ var DID = class {
 };
 __name(DID, "DID");
 
+// ../../node_modules/.pnpm/hex-lite@1.5.0/node_modules/hex-lite/dist/hex-lite.mjs
+function toUint8Array(str) {
+  var s = 0, sl = str.length, bytes = [];
+  if (sl % 2) {
+    throw new Error("invalid hex:" + str);
+  }
+  for (; s < sl; s += 2) {
+    bytes.push(parseInt(str.substr(s, 2), 16));
+  }
+  return new Uint8Array(bytes);
+}
+__name(toUint8Array, "toUint8Array");
+
 // src/wallet/plugins/idx/idx.ts
 var import_key_did_resolver = __toESM(require_lib());
 
@@ -48356,13 +48353,11 @@ __name(CeramicClient, "CeramicClient");
 
 // src/wallet/plugins/idx/idx.ts
 var getCeramicClientFromWalletSuite = /* @__PURE__ */ __name((wallet, ceramicEndpoint) => __async(void 0, null, function* () {
-  var _a2, _b;
   const client = new CeramicClient(ceramicEndpoint);
   const resolver = __spreadValues({}, import_key_did_resolver.default.getResolver());
   const did = new DID({ resolver });
   client.did = did;
-  const contents = JSON.parse(JSON.stringify(wallet.contents));
-  const key2 = (_b = (_a2 = contents == null ? void 0 : contents.find((c) => (c == null ? void 0 : c.name) === "DID Key Secret")) == null ? void 0 : _a2.value) != null ? _b : "";
+  const key2 = wallet.pluginMethods.getKey();
   const ceramicProvider = new Ed25519Provider(toUint8Array(key2));
   client.did.setProvider(ceramicProvider);
   yield client.did.authenticate();
@@ -48432,81 +48427,36 @@ var getIDXPlugin = /* @__PURE__ */ __name((_0, _1) => __async(void 0, [_0, _1],
       addVerifiableCredentialInIdx: (_02, _12) => __async(void 0, [_02, _12], function* (_wallet, { title, id }) {
         return addCredentialStreamIdToIndex({ title, id });
       })
-    },
-    pluginConstants: {}
+    }
   };
 }), "getIDXPlugin");
 
-// src/wallet/plugins/didkey/generateContentFromSeed.ts
-var seedToId = /* @__PURE__ */ __name((seed) => __async(void 0, null, function* () {
-  const buffer2 = yield crypto_default.subtle.digest("SHA-256", seed);
-  return `urn:digest:${Buffer.from(new Uint8Array(buffer2)).toString("hex")}`;
-}), "seedToId");
-var generateContentFromSeed = /* @__PURE__ */ __name((seed) => __async(void 0, null, function* () {
-  const privateKeyJwk = JSON.parse(generateEd25519KeyFromBytes(seed));
-  const controller = keyToDID("key", JSON.stringify(privateKeyJwk));
-  const _a2 = privateKeyJwk, { d } = _a2, publicKeyJwk = __objRest(_a2, ["d"]);
-  const signingKey = {
-    controller,
-    id: `${controller}#${controller.split(":").at(-1)}`,
-    privateKeyJwk,
-    publicKeyJwk,
-    type: "JsonWebKey2020"
-  };
-  const seedId = yield seedToId(seed);
-  const secret = {
-    "@context": ["http://w3id.org/wallet/v1"],
-    id: seedId,
-    name: "DID Key Secret",
-    image: "https://via.placeholder.com/150",
-    description: "Used to generate a DID with a signing and encryption key.",
-    tags: ["inception"],
-    type: "Entropy",
-    value: Buffer.from(seed).toString("hex")
-  };
-  const key0 = __spreadProps(__spreadValues({}, signingKey), {
-    "@context": ["http://w3id.org/wallet/v1"],
-    name: "Signing Key",
-    image: "https://via.placeholder.com/150",
-    description: "Used to produce digital signatures.",
-    tags: ["inception"],
-    generatedFrom: [secret.id]
-  });
-  return [secret, key0];
-}), "generateContentFromSeed");
-
 // src/wallet/plugins/didkey/index.ts
-var DidKeyPlugin = {
-  pluginMethods: {
-    getSubjectDid: (wallet) => {
-      var _a2, _b;
-      return (_b = (_a2 = wallet.contents.find((content) => content.name === "Signing Key")) == null ? void 0 : _a2.controller) != null ? _b : "";
-    },
-    getSubjectKeypair: (wallet) => {
-      var _a2;
-      return (_a2 = wallet.contents.find((content) => content.name === "Signing Key")) == null ? void 0 : _a2.privateKeyJwk;
+var getDidKeyPlugin = /* @__PURE__ */ __name((key2) => __async(void 0, null, function* () {
+  const keypair = JSON.parse(generateEd25519KeyFromBytes(toUint8Array(key2.padStart(64, "0"))));
+  const did = keyToDID("key", JSON.stringify(keypair));
+  return {
+    pluginMethods: {
+      getSubjectDid: () => did,
+      getSubjectKeypair: () => keypair,
+      getKey: () => key2.padStart(64, "0")
     }
-  },
-  pluginConstants: {
-    generateContentFromSeed
-  }
-};
+  };
+}), "getDidKeyPlugin");
 
 // src/wallet/plugins/expiration/index.ts
 var ExpirationPlugin = /* @__PURE__ */ __name((wallet) => ({
   pluginMethods: {
     verifyCredential: (_wallet, credential) => __async(void 0, null, function* () {
       const verificationCheck = yield wallet.pluginMethods.verifyCredential(credential);
-      if (credential.expirationDate) {
+      if (credential.expirationDate && new Date() > new Date(credential.expirationDate)) {
+        verificationCheck.errors.push("expiration error: Credential is expired");
+      } else {
         verificationCheck.checks.push("expiration");
-        if (new Date() > new Date(credential.expirationDate)) {
-          verificationCheck.errors.push("expiration error: Credential is expired");
-        }
       }
       return verificationCheck;
     })
-  },
-  pluginConstants: {}
+  }
 }), "ExpirationPlugin");
 
 // src/wallet/plugins/vc/issueCredential.ts
@@ -48578,8 +48528,7 @@ var getVCPlugin = /* @__PURE__ */ __name((wallet) => __async(void 0, null, funct
           credentialSubject: { id: subject }
         };
       }
-    }),
-    pluginConstants: {}
+    })
   };
 }), "getVCPlugin");
 
@@ -48591,7 +48540,1581 @@ var VerificationStatus = /* @__PURE__ */ ((VerificationStatus2) => {
   return VerificationStatus2;
 })(VerificationStatus || {});
 
+// ../../node_modules/.pnpm/date-fns@2.28.0/node_modules/date-fns/esm/_lib/toInteger/index.js
+function toInteger(dirtyNumber) {
+  if (dirtyNumber === null || dirtyNumber === true || dirtyNumber === false) {
+    return NaN;
+  }
+  var number = Number(dirtyNumber);
+  if (isNaN(number)) {
+    return number;
+  }
+  return number < 0 ? Math.ceil(number) : Math.floor(number);
+}
+__name(toInteger, "toInteger");
+
+// ../../node_modules/.pnpm/date-fns@2.28.0/node_modules/date-fns/esm/_lib/requiredArgs/index.js
+function requiredArgs(required, args) {
+  if (args.length < required) {
+    throw new TypeError(required + " argument" + (required > 1 ? "s" : "") + " required, but only " + args.length + " present");
+  }
+}
+__name(requiredArgs, "requiredArgs");
+
+// ../../node_modules/.pnpm/date-fns@2.28.0/node_modules/date-fns/esm/toDate/index.js
+function toDate(argument) {
+  requiredArgs(1, arguments);
+  var argStr = Object.prototype.toString.call(argument);
+  if (argument instanceof Date || typeof argument === "object" && argStr === "[object Date]") {
+    return new Date(argument.getTime());
+  } else if (typeof argument === "number" || argStr === "[object Number]") {
+    return new Date(argument);
+  } else {
+    if ((typeof argument === "string" || argStr === "[object String]") && typeof console !== "undefined") {
+      console.warn("Starting with v2.0.0-beta.1 date-fns doesn't accept strings as date arguments. Please use `parseISO` to parse strings. See: https://git.io/fjule");
+      console.warn(new Error().stack);
+    }
+    return new Date(NaN);
+  }
+}
+__name(toDate, "toDate");
+
+// ../../node_modules/.pnpm/date-fns@2.28.0/node_modules/date-fns/esm/addMilliseconds/index.js
+function addMilliseconds(dirtyDate, dirtyAmount) {
+  requiredArgs(2, arguments);
+  var timestamp = toDate(dirtyDate).getTime();
+  var amount = toInteger(dirtyAmount);
+  return new Date(timestamp + amount);
+}
+__name(addMilliseconds, "addMilliseconds");
+
+// ../../node_modules/.pnpm/date-fns@2.28.0/node_modules/date-fns/esm/_lib/getTimezoneOffsetInMilliseconds/index.js
+function getTimezoneOffsetInMilliseconds(date) {
+  var utcDate = new Date(Date.UTC(date.getFullYear(), date.getMonth(), date.getDate(), date.getHours(), date.getMinutes(), date.getSeconds(), date.getMilliseconds()));
+  utcDate.setUTCFullYear(date.getFullYear());
+  return date.getTime() - utcDate.getTime();
+}
+__name(getTimezoneOffsetInMilliseconds, "getTimezoneOffsetInMilliseconds");
+
+// ../../node_modules/.pnpm/date-fns@2.28.0/node_modules/date-fns/esm/isDate/index.js
+function isDate(value) {
+  requiredArgs(1, arguments);
+  return value instanceof Date || typeof value === "object" && Object.prototype.toString.call(value) === "[object Date]";
+}
+__name(isDate, "isDate");
+
+// ../../node_modules/.pnpm/date-fns@2.28.0/node_modules/date-fns/esm/isValid/index.js
+function isValid(dirtyDate) {
+  requiredArgs(1, arguments);
+  if (!isDate(dirtyDate) && typeof dirtyDate !== "number") {
+    return false;
+  }
+  var date = toDate(dirtyDate);
+  return !isNaN(Number(date));
+}
+__name(isValid, "isValid");
+
+// ../../node_modules/.pnpm/date-fns@2.28.0/node_modules/date-fns/esm/locale/en-US/_lib/formatDistance/index.js
+var formatDistanceLocale = {
+  lessThanXSeconds: {
+    one: "less than a second",
+    other: "less than {{count}} seconds"
+  },
+  xSeconds: {
+    one: "1 second",
+    other: "{{count}} seconds"
+  },
+  halfAMinute: "half a minute",
+  lessThanXMinutes: {
+    one: "less than a minute",
+    other: "less than {{count}} minutes"
+  },
+  xMinutes: {
+    one: "1 minute",
+    other: "{{count}} minutes"
+  },
+  aboutXHours: {
+    one: "about 1 hour",
+    other: "about {{count}} hours"
+  },
+  xHours: {
+    one: "1 hour",
+    other: "{{count}} hours"
+  },
+  xDays: {
+    one: "1 day",
+    other: "{{count}} days"
+  },
+  aboutXWeeks: {
+    one: "about 1 week",
+    other: "about {{count}} weeks"
+  },
+  xWeeks: {
+    one: "1 week",
+    other: "{{count}} weeks"
+  },
+  aboutXMonths: {
+    one: "about 1 month",
+    other: "about {{count}} months"
+  },
+  xMonths: {
+    one: "1 month",
+    other: "{{count}} months"
+  },
+  aboutXYears: {
+    one: "about 1 year",
+    other: "about {{count}} years"
+  },
+  xYears: {
+    one: "1 year",
+    other: "{{count}} years"
+  },
+  overXYears: {
+    one: "over 1 year",
+    other: "over {{count}} years"
+  },
+  almostXYears: {
+    one: "almost 1 year",
+    other: "almost {{count}} years"
+  }
+};
+var formatDistance = /* @__PURE__ */ __name(function(token, count, options) {
+  var result;
+  var tokenValue = formatDistanceLocale[token];
+  if (typeof tokenValue === "string") {
+    result = tokenValue;
+  } else if (count === 1) {
+    result = tokenValue.one;
+  } else {
+    result = tokenValue.other.replace("{{count}}", count.toString());
+  }
+  if (options !== null && options !== void 0 && options.addSuffix) {
+    if (options.comparison && options.comparison > 0) {
+      return "in " + result;
+    } else {
+      return result + " ago";
+    }
+  }
+  return result;
+}, "formatDistance");
+var formatDistance_default = formatDistance;
+
+// ../../node_modules/.pnpm/date-fns@2.28.0/node_modules/date-fns/esm/locale/_lib/buildFormatLongFn/index.js
+function buildFormatLongFn(args) {
+  return function() {
+    var options = arguments.length > 0 && arguments[0] !== void 0 ? arguments[0] : {};
+    var width = options.width ? String(options.width) : args.defaultWidth;
+    var format2 = args.formats[width] || args.formats[args.defaultWidth];
+    return format2;
+  };
+}
+__name(buildFormatLongFn, "buildFormatLongFn");
+
+// ../../node_modules/.pnpm/date-fns@2.28.0/node_modules/date-fns/esm/locale/en-US/_lib/formatLong/index.js
+var dateFormats = {
+  full: "EEEE, MMMM do, y",
+  long: "MMMM do, y",
+  medium: "MMM d, y",
+  short: "MM/dd/yyyy"
+};
+var timeFormats = {
+  full: "h:mm:ss a zzzz",
+  long: "h:mm:ss a z",
+  medium: "h:mm:ss a",
+  short: "h:mm a"
+};
+var dateTimeFormats = {
+  full: "{{date}} 'at' {{time}}",
+  long: "{{date}} 'at' {{time}}",
+  medium: "{{date}}, {{time}}",
+  short: "{{date}}, {{time}}"
+};
+var formatLong = {
+  date: buildFormatLongFn({
+    formats: dateFormats,
+    defaultWidth: "full"
+  }),
+  time: buildFormatLongFn({
+    formats: timeFormats,
+    defaultWidth: "full"
+  }),
+  dateTime: buildFormatLongFn({
+    formats: dateTimeFormats,
+    defaultWidth: "full"
+  })
+};
+var formatLong_default = formatLong;
+
+// ../../node_modules/.pnpm/date-fns@2.28.0/node_modules/date-fns/esm/locale/en-US/_lib/formatRelative/index.js
+var formatRelativeLocale = {
+  lastWeek: "'last' eeee 'at' p",
+  yesterday: "'yesterday at' p",
+  today: "'today at' p",
+  tomorrow: "'tomorrow at' p",
+  nextWeek: "eeee 'at' p",
+  other: "P"
+};
+var formatRelative = /* @__PURE__ */ __name(function(token, _date, _baseDate, _options) {
+  return formatRelativeLocale[token];
+}, "formatRelative");
+var formatRelative_default = formatRelative;
+
+// ../../node_modules/.pnpm/date-fns@2.28.0/node_modules/date-fns/esm/locale/_lib/buildLocalizeFn/index.js
+function buildLocalizeFn(args) {
+  return function(dirtyIndex, dirtyOptions) {
+    var options = dirtyOptions || {};
+    var context2 = options.context ? String(options.context) : "standalone";
+    var valuesArray;
+    if (context2 === "formatting" && args.formattingValues) {
+      var defaultWidth = args.defaultFormattingWidth || args.defaultWidth;
+      var width = options.width ? String(options.width) : defaultWidth;
+      valuesArray = args.formattingValues[width] || args.formattingValues[defaultWidth];
+    } else {
+      var _defaultWidth = args.defaultWidth;
+      var _width = options.width ? String(options.width) : args.defaultWidth;
+      valuesArray = args.values[_width] || args.values[_defaultWidth];
+    }
+    var index = args.argumentCallback ? args.argumentCallback(dirtyIndex) : dirtyIndex;
+    return valuesArray[index];
+  };
+}
+__name(buildLocalizeFn, "buildLocalizeFn");
+
+// ../../node_modules/.pnpm/date-fns@2.28.0/node_modules/date-fns/esm/locale/en-US/_lib/localize/index.js
+var eraValues = {
+  narrow: ["B", "A"],
+  abbreviated: ["BC", "AD"],
+  wide: ["Before Christ", "Anno Domini"]
+};
+var quarterValues = {
+  narrow: ["1", "2", "3", "4"],
+  abbreviated: ["Q1", "Q2", "Q3", "Q4"],
+  wide: ["1st quarter", "2nd quarter", "3rd quarter", "4th quarter"]
+};
+var monthValues = {
+  narrow: ["J", "F", "M", "A", "M", "J", "J", "A", "S", "O", "N", "D"],
+  abbreviated: ["Jan", "Feb", "Mar", "Apr", "May", "Jun", "Jul", "Aug", "Sep", "Oct", "Nov", "Dec"],
+  wide: ["January", "February", "March", "April", "May", "June", "July", "August", "September", "October", "November", "December"]
+};
+var dayValues = {
+  narrow: ["S", "M", "T", "W", "T", "F", "S"],
+  short: ["Su", "Mo", "Tu", "We", "Th", "Fr", "Sa"],
+  abbreviated: ["Sun", "Mon", "Tue", "Wed", "Thu", "Fri", "Sat"],
+  wide: ["Sunday", "Monday", "Tuesday", "Wednesday", "Thursday", "Friday", "Saturday"]
+};
+var dayPeriodValues = {
+  narrow: {
+    am: "a",
+    pm: "p",
+    midnight: "mi",
+    noon: "n",
+    morning: "morning",
+    afternoon: "afternoon",
+    evening: "evening",
+    night: "night"
+  },
+  abbreviated: {
+    am: "AM",
+    pm: "PM",
+    midnight: "midnight",
+    noon: "noon",
+    morning: "morning",
+    afternoon: "afternoon",
+    evening: "evening",
+    night: "night"
+  },
+  wide: {
+    am: "a.m.",
+    pm: "p.m.",
+    midnight: "midnight",
+    noon: "noon",
+    morning: "morning",
+    afternoon: "afternoon",
+    evening: "evening",
+    night: "night"
+  }
+};
+var formattingDayPeriodValues = {
+  narrow: {
+    am: "a",
+    pm: "p",
+    midnight: "mi",
+    noon: "n",
+    morning: "in the morning",
+    afternoon: "in the afternoon",
+    evening: "in the evening",
+    night: "at night"
+  },
+  abbreviated: {
+    am: "AM",
+    pm: "PM",
+    midnight: "midnight",
+    noon: "noon",
+    morning: "in the morning",
+    afternoon: "in the afternoon",
+    evening: "in the evening",
+    night: "at night"
+  },
+  wide: {
+    am: "a.m.",
+    pm: "p.m.",
+    midnight: "midnight",
+    noon: "noon",
+    morning: "in the morning",
+    afternoon: "in the afternoon",
+    evening: "in the evening",
+    night: "at night"
+  }
+};
+var ordinalNumber = /* @__PURE__ */ __name(function(dirtyNumber, _options) {
+  var number = Number(dirtyNumber);
+  var rem100 = number % 100;
+  if (rem100 > 20 || rem100 < 10) {
+    switch (rem100 % 10) {
+      case 1:
+        return number + "st";
+      case 2:
+        return number + "nd";
+      case 3:
+        return number + "rd";
+    }
+  }
+  return number + "th";
+}, "ordinalNumber");
+var localize = {
+  ordinalNumber,
+  era: buildLocalizeFn({
+    values: eraValues,
+    defaultWidth: "wide"
+  }),
+  quarter: buildLocalizeFn({
+    values: quarterValues,
+    defaultWidth: "wide",
+    argumentCallback: function(quarter) {
+      return quarter - 1;
+    }
+  }),
+  month: buildLocalizeFn({
+    values: monthValues,
+    defaultWidth: "wide"
+  }),
+  day: buildLocalizeFn({
+    values: dayValues,
+    defaultWidth: "wide"
+  }),
+  dayPeriod: buildLocalizeFn({
+    values: dayPeriodValues,
+    defaultWidth: "wide",
+    formattingValues: formattingDayPeriodValues,
+    defaultFormattingWidth: "wide"
+  })
+};
+var localize_default = localize;
+
+// ../../node_modules/.pnpm/date-fns@2.28.0/node_modules/date-fns/esm/locale/_lib/buildMatchFn/index.js
+function buildMatchFn(args) {
+  return function(string2) {
+    var options = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : {};
+    var width = options.width;
+    var matchPattern = width && args.matchPatterns[width] || args.matchPatterns[args.defaultMatchWidth];
+    var matchResult = string2.match(matchPattern);
+    if (!matchResult) {
+      return null;
+    }
+    var matchedString = matchResult[0];
+    var parsePatterns = width && args.parsePatterns[width] || args.parsePatterns[args.defaultParseWidth];
+    var key2 = Array.isArray(parsePatterns) ? findIndex(parsePatterns, function(pattern) {
+      return pattern.test(matchedString);
+    }) : findKey(parsePatterns, function(pattern) {
+      return pattern.test(matchedString);
+    });
+    var value;
+    value = args.valueCallback ? args.valueCallback(key2) : key2;
+    value = options.valueCallback ? options.valueCallback(value) : value;
+    var rest = string2.slice(matchedString.length);
+    return {
+      value,
+      rest
+    };
+  };
+}
+__name(buildMatchFn, "buildMatchFn");
+function findKey(object, predicate) {
+  for (var key2 in object) {
+    if (object.hasOwnProperty(key2) && predicate(object[key2])) {
+      return key2;
+    }
+  }
+  return void 0;
+}
+__name(findKey, "findKey");
+function findIndex(array, predicate) {
+  for (var key2 = 0; key2 < array.length; key2++) {
+    if (predicate(array[key2])) {
+      return key2;
+    }
+  }
+  return void 0;
+}
+__name(findIndex, "findIndex");
+
+// ../../node_modules/.pnpm/date-fns@2.28.0/node_modules/date-fns/esm/locale/_lib/buildMatchPatternFn/index.js
+function buildMatchPatternFn(args) {
+  return function(string2) {
+    var options = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : {};
+    var matchResult = string2.match(args.matchPattern);
+    if (!matchResult)
+      return null;
+    var matchedString = matchResult[0];
+    var parseResult = string2.match(args.parsePattern);
+    if (!parseResult)
+      return null;
+    var value = args.valueCallback ? args.valueCallback(parseResult[0]) : parseResult[0];
+    value = options.valueCallback ? options.valueCallback(value) : value;
+    var rest = string2.slice(matchedString.length);
+    return {
+      value,
+      rest
+    };
+  };
+}
+__name(buildMatchPatternFn, "buildMatchPatternFn");
+
+// ../../node_modules/.pnpm/date-fns@2.28.0/node_modules/date-fns/esm/locale/en-US/_lib/match/index.js
+var matchOrdinalNumberPattern = /^(\d+)(th|st|nd|rd)?/i;
+var parseOrdinalNumberPattern = /\d+/i;
+var matchEraPatterns = {
+  narrow: /^(b|a)/i,
+  abbreviated: /^(b\.?\s?c\.?|b\.?\s?c\.?\s?e\.?|a\.?\s?d\.?|c\.?\s?e\.?)/i,
+  wide: /^(before christ|before common era|anno domini|common era)/i
+};
+var parseEraPatterns = {
+  any: [/^b/i, /^(a|c)/i]
+};
+var matchQuarterPatterns = {
+  narrow: /^[1234]/i,
+  abbreviated: /^q[1234]/i,
+  wide: /^[1234](th|st|nd|rd)? quarter/i
+};
+var parseQuarterPatterns = {
+  any: [/1/i, /2/i, /3/i, /4/i]
+};
+var matchMonthPatterns = {
+  narrow: /^[jfmasond]/i,
+  abbreviated: /^(jan|feb|mar|apr|may|jun|jul|aug|sep|oct|nov|dec)/i,
+  wide: /^(january|february|march|april|may|june|july|august|september|october|november|december)/i
+};
+var parseMonthPatterns = {
+  narrow: [/^j/i, /^f/i, /^m/i, /^a/i, /^m/i, /^j/i, /^j/i, /^a/i, /^s/i, /^o/i, /^n/i, /^d/i],
+  any: [/^ja/i, /^f/i, /^mar/i, /^ap/i, /^may/i, /^jun/i, /^jul/i, /^au/i, /^s/i, /^o/i, /^n/i, /^d/i]
+};
+var matchDayPatterns = {
+  narrow: /^[smtwf]/i,
+  short: /^(su|mo|tu|we|th|fr|sa)/i,
+  abbreviated: /^(sun|mon|tue|wed|thu|fri|sat)/i,
+  wide: /^(sunday|monday|tuesday|wednesday|thursday|friday|saturday)/i
+};
+var parseDayPatterns = {
+  narrow: [/^s/i, /^m/i, /^t/i, /^w/i, /^t/i, /^f/i, /^s/i],
+  any: [/^su/i, /^m/i, /^tu/i, /^w/i, /^th/i, /^f/i, /^sa/i]
+};
+var matchDayPeriodPatterns = {
+  narrow: /^(a|p|mi|n|(in the|at) (morning|afternoon|evening|night))/i,
+  any: /^([ap]\.?\s?m\.?|midnight|noon|(in the|at) (morning|afternoon|evening|night))/i
+};
+var parseDayPeriodPatterns = {
+  any: {
+    am: /^a/i,
+    pm: /^p/i,
+    midnight: /^mi/i,
+    noon: /^no/i,
+    morning: /morning/i,
+    afternoon: /afternoon/i,
+    evening: /evening/i,
+    night: /night/i
+  }
+};
+var match = {
+  ordinalNumber: buildMatchPatternFn({
+    matchPattern: matchOrdinalNumberPattern,
+    parsePattern: parseOrdinalNumberPattern,
+    valueCallback: function(value) {
+      return parseInt(value, 10);
+    }
+  }),
+  era: buildMatchFn({
+    matchPatterns: matchEraPatterns,
+    defaultMatchWidth: "wide",
+    parsePatterns: parseEraPatterns,
+    defaultParseWidth: "any"
+  }),
+  quarter: buildMatchFn({
+    matchPatterns: matchQuarterPatterns,
+    defaultMatchWidth: "wide",
+    parsePatterns: parseQuarterPatterns,
+    defaultParseWidth: "any",
+    valueCallback: function(index) {
+      return index + 1;
+    }
+  }),
+  month: buildMatchFn({
+    matchPatterns: matchMonthPatterns,
+    defaultMatchWidth: "wide",
+    parsePatterns: parseMonthPatterns,
+    defaultParseWidth: "any"
+  }),
+  day: buildMatchFn({
+    matchPatterns: matchDayPatterns,
+    defaultMatchWidth: "wide",
+    parsePatterns: parseDayPatterns,
+    defaultParseWidth: "any"
+  }),
+  dayPeriod: buildMatchFn({
+    matchPatterns: matchDayPeriodPatterns,
+    defaultMatchWidth: "any",
+    parsePatterns: parseDayPeriodPatterns,
+    defaultParseWidth: "any"
+  })
+};
+var match_default = match;
+
+// ../../node_modules/.pnpm/date-fns@2.28.0/node_modules/date-fns/esm/locale/en-US/index.js
+var locale = {
+  code: "en-US",
+  formatDistance: formatDistance_default,
+  formatLong: formatLong_default,
+  formatRelative: formatRelative_default,
+  localize: localize_default,
+  match: match_default,
+  options: {
+    weekStartsOn: 0,
+    firstWeekContainsDate: 1
+  }
+};
+var en_US_default = locale;
+
+// ../../node_modules/.pnpm/date-fns@2.28.0/node_modules/date-fns/esm/subMilliseconds/index.js
+function subMilliseconds(dirtyDate, dirtyAmount) {
+  requiredArgs(2, arguments);
+  var amount = toInteger(dirtyAmount);
+  return addMilliseconds(dirtyDate, -amount);
+}
+__name(subMilliseconds, "subMilliseconds");
+
+// ../../node_modules/.pnpm/date-fns@2.28.0/node_modules/date-fns/esm/_lib/getUTCDayOfYear/index.js
+var MILLISECONDS_IN_DAY = 864e5;
+function getUTCDayOfYear(dirtyDate) {
+  requiredArgs(1, arguments);
+  var date = toDate(dirtyDate);
+  var timestamp = date.getTime();
+  date.setUTCMonth(0, 1);
+  date.setUTCHours(0, 0, 0, 0);
+  var startOfYearTimestamp = date.getTime();
+  var difference = timestamp - startOfYearTimestamp;
+  return Math.floor(difference / MILLISECONDS_IN_DAY) + 1;
+}
+__name(getUTCDayOfYear, "getUTCDayOfYear");
+
+// ../../node_modules/.pnpm/date-fns@2.28.0/node_modules/date-fns/esm/_lib/startOfUTCISOWeek/index.js
+function startOfUTCISOWeek(dirtyDate) {
+  requiredArgs(1, arguments);
+  var weekStartsOn = 1;
+  var date = toDate(dirtyDate);
+  var day = date.getUTCDay();
+  var diff = (day < weekStartsOn ? 7 : 0) + day - weekStartsOn;
+  date.setUTCDate(date.getUTCDate() - diff);
+  date.setUTCHours(0, 0, 0, 0);
+  return date;
+}
+__name(startOfUTCISOWeek, "startOfUTCISOWeek");
+
+// ../../node_modules/.pnpm/date-fns@2.28.0/node_modules/date-fns/esm/_lib/getUTCISOWeekYear/index.js
+function getUTCISOWeekYear(dirtyDate) {
+  requiredArgs(1, arguments);
+  var date = toDate(dirtyDate);
+  var year = date.getUTCFullYear();
+  var fourthOfJanuaryOfNextYear = new Date(0);
+  fourthOfJanuaryOfNextYear.setUTCFullYear(year + 1, 0, 4);
+  fourthOfJanuaryOfNextYear.setUTCHours(0, 0, 0, 0);
+  var startOfNextYear = startOfUTCISOWeek(fourthOfJanuaryOfNextYear);
+  var fourthOfJanuaryOfThisYear = new Date(0);
+  fourthOfJanuaryOfThisYear.setUTCFullYear(year, 0, 4);
+  fourthOfJanuaryOfThisYear.setUTCHours(0, 0, 0, 0);
+  var startOfThisYear = startOfUTCISOWeek(fourthOfJanuaryOfThisYear);
+  if (date.getTime() >= startOfNextYear.getTime()) {
+    return year + 1;
+  } else if (date.getTime() >= startOfThisYear.getTime()) {
+    return year;
+  } else {
+    return year - 1;
+  }
+}
+__name(getUTCISOWeekYear, "getUTCISOWeekYear");
+
+// ../../node_modules/.pnpm/date-fns@2.28.0/node_modules/date-fns/esm/_lib/startOfUTCISOWeekYear/index.js
+function startOfUTCISOWeekYear(dirtyDate) {
+  requiredArgs(1, arguments);
+  var year = getUTCISOWeekYear(dirtyDate);
+  var fourthOfJanuary = new Date(0);
+  fourthOfJanuary.setUTCFullYear(year, 0, 4);
+  fourthOfJanuary.setUTCHours(0, 0, 0, 0);
+  var date = startOfUTCISOWeek(fourthOfJanuary);
+  return date;
+}
+__name(startOfUTCISOWeekYear, "startOfUTCISOWeekYear");
+
+// ../../node_modules/.pnpm/date-fns@2.28.0/node_modules/date-fns/esm/_lib/getUTCISOWeek/index.js
+var MILLISECONDS_IN_WEEK = 6048e5;
+function getUTCISOWeek(dirtyDate) {
+  requiredArgs(1, arguments);
+  var date = toDate(dirtyDate);
+  var diff = startOfUTCISOWeek(date).getTime() - startOfUTCISOWeekYear(date).getTime();
+  return Math.round(diff / MILLISECONDS_IN_WEEK) + 1;
+}
+__name(getUTCISOWeek, "getUTCISOWeek");
+
+// ../../node_modules/.pnpm/date-fns@2.28.0/node_modules/date-fns/esm/_lib/startOfUTCWeek/index.js
+function startOfUTCWeek(dirtyDate, dirtyOptions) {
+  requiredArgs(1, arguments);
+  var options = dirtyOptions || {};
+  var locale2 = options.locale;
+  var localeWeekStartsOn = locale2 && locale2.options && locale2.options.weekStartsOn;
+  var defaultWeekStartsOn = localeWeekStartsOn == null ? 0 : toInteger(localeWeekStartsOn);
+  var weekStartsOn = options.weekStartsOn == null ? defaultWeekStartsOn : toInteger(options.weekStartsOn);
+  if (!(weekStartsOn >= 0 && weekStartsOn <= 6)) {
+    throw new RangeError("weekStartsOn must be between 0 and 6 inclusively");
+  }
+  var date = toDate(dirtyDate);
+  var day = date.getUTCDay();
+  var diff = (day < weekStartsOn ? 7 : 0) + day - weekStartsOn;
+  date.setUTCDate(date.getUTCDate() - diff);
+  date.setUTCHours(0, 0, 0, 0);
+  return date;
+}
+__name(startOfUTCWeek, "startOfUTCWeek");
+
+// ../../node_modules/.pnpm/date-fns@2.28.0/node_modules/date-fns/esm/_lib/getUTCWeekYear/index.js
+function getUTCWeekYear(dirtyDate, dirtyOptions) {
+  requiredArgs(1, arguments);
+  var date = toDate(dirtyDate);
+  var year = date.getUTCFullYear();
+  var options = dirtyOptions || {};
+  var locale2 = options.locale;
+  var localeFirstWeekContainsDate = locale2 && locale2.options && locale2.options.firstWeekContainsDate;
+  var defaultFirstWeekContainsDate = localeFirstWeekContainsDate == null ? 1 : toInteger(localeFirstWeekContainsDate);
+  var firstWeekContainsDate = options.firstWeekContainsDate == null ? defaultFirstWeekContainsDate : toInteger(options.firstWeekContainsDate);
+  if (!(firstWeekContainsDate >= 1 && firstWeekContainsDate <= 7)) {
+    throw new RangeError("firstWeekContainsDate must be between 1 and 7 inclusively");
+  }
+  var firstWeekOfNextYear = new Date(0);
+  firstWeekOfNextYear.setUTCFullYear(year + 1, 0, firstWeekContainsDate);
+  firstWeekOfNextYear.setUTCHours(0, 0, 0, 0);
+  var startOfNextYear = startOfUTCWeek(firstWeekOfNextYear, dirtyOptions);
+  var firstWeekOfThisYear = new Date(0);
+  firstWeekOfThisYear.setUTCFullYear(year, 0, firstWeekContainsDate);
+  firstWeekOfThisYear.setUTCHours(0, 0, 0, 0);
+  var startOfThisYear = startOfUTCWeek(firstWeekOfThisYear, dirtyOptions);
+  if (date.getTime() >= startOfNextYear.getTime()) {
+    return year + 1;
+  } else if (date.getTime() >= startOfThisYear.getTime()) {
+    return year;
+  } else {
+    return year - 1;
+  }
+}
+__name(getUTCWeekYear, "getUTCWeekYear");
+
+// ../../node_modules/.pnpm/date-fns@2.28.0/node_modules/date-fns/esm/_lib/startOfUTCWeekYear/index.js
+function startOfUTCWeekYear(dirtyDate, dirtyOptions) {
+  requiredArgs(1, arguments);
+  var options = dirtyOptions || {};
+  var locale2 = options.locale;
+  var localeFirstWeekContainsDate = locale2 && locale2.options && locale2.options.firstWeekContainsDate;
+  var defaultFirstWeekContainsDate = localeFirstWeekContainsDate == null ? 1 : toInteger(localeFirstWeekContainsDate);
+  var firstWeekContainsDate = options.firstWeekContainsDate == null ? defaultFirstWeekContainsDate : toInteger(options.firstWeekContainsDate);
+  var year = getUTCWeekYear(dirtyDate, dirtyOptions);
+  var firstWeek = new Date(0);
+  firstWeek.setUTCFullYear(year, 0, firstWeekContainsDate);
+  firstWeek.setUTCHours(0, 0, 0, 0);
+  var date = startOfUTCWeek(firstWeek, dirtyOptions);
+  return date;
+}
+__name(startOfUTCWeekYear, "startOfUTCWeekYear");
+
+// ../../node_modules/.pnpm/date-fns@2.28.0/node_modules/date-fns/esm/_lib/getUTCWeek/index.js
+var MILLISECONDS_IN_WEEK2 = 6048e5;
+function getUTCWeek(dirtyDate, options) {
+  requiredArgs(1, arguments);
+  var date = toDate(dirtyDate);
+  var diff = startOfUTCWeek(date, options).getTime() - startOfUTCWeekYear(date, options).getTime();
+  return Math.round(diff / MILLISECONDS_IN_WEEK2) + 1;
+}
+__name(getUTCWeek, "getUTCWeek");
+
+// ../../node_modules/.pnpm/date-fns@2.28.0/node_modules/date-fns/esm/_lib/addLeadingZeros/index.js
+function addLeadingZeros(number, targetLength) {
+  var sign5 = number < 0 ? "-" : "";
+  var output = Math.abs(number).toString();
+  while (output.length < targetLength) {
+    output = "0" + output;
+  }
+  return sign5 + output;
+}
+__name(addLeadingZeros, "addLeadingZeros");
+
+// ../../node_modules/.pnpm/date-fns@2.28.0/node_modules/date-fns/esm/_lib/format/lightFormatters/index.js
+var formatters = {
+  y: function(date, token) {
+    var signedYear = date.getUTCFullYear();
+    var year = signedYear > 0 ? signedYear : 1 - signedYear;
+    return addLeadingZeros(token === "yy" ? year % 100 : year, token.length);
+  },
+  M: function(date, token) {
+    var month = date.getUTCMonth();
+    return token === "M" ? String(month + 1) : addLeadingZeros(month + 1, 2);
+  },
+  d: function(date, token) {
+    return addLeadingZeros(date.getUTCDate(), token.length);
+  },
+  a: function(date, token) {
+    var dayPeriodEnumValue = date.getUTCHours() / 12 >= 1 ? "pm" : "am";
+    switch (token) {
+      case "a":
+      case "aa":
+        return dayPeriodEnumValue.toUpperCase();
+      case "aaa":
+        return dayPeriodEnumValue;
+      case "aaaaa":
+        return dayPeriodEnumValue[0];
+      case "aaaa":
+      default:
+        return dayPeriodEnumValue === "am" ? "a.m." : "p.m.";
+    }
+  },
+  h: function(date, token) {
+    return addLeadingZeros(date.getUTCHours() % 12 || 12, token.length);
+  },
+  H: function(date, token) {
+    return addLeadingZeros(date.getUTCHours(), token.length);
+  },
+  m: function(date, token) {
+    return addLeadingZeros(date.getUTCMinutes(), token.length);
+  },
+  s: function(date, token) {
+    return addLeadingZeros(date.getUTCSeconds(), token.length);
+  },
+  S: function(date, token) {
+    var numberOfDigits = token.length;
+    var milliseconds = date.getUTCMilliseconds();
+    var fractionalSeconds = Math.floor(milliseconds * Math.pow(10, numberOfDigits - 3));
+    return addLeadingZeros(fractionalSeconds, token.length);
+  }
+};
+var lightFormatters_default = formatters;
+
+// ../../node_modules/.pnpm/date-fns@2.28.0/node_modules/date-fns/esm/_lib/format/formatters/index.js
+var dayPeriodEnum = {
+  am: "am",
+  pm: "pm",
+  midnight: "midnight",
+  noon: "noon",
+  morning: "morning",
+  afternoon: "afternoon",
+  evening: "evening",
+  night: "night"
+};
+var formatters2 = {
+  G: function(date, token, localize2) {
+    var era = date.getUTCFullYear() > 0 ? 1 : 0;
+    switch (token) {
+      case "G":
+      case "GG":
+      case "GGG":
+        return localize2.era(era, {
+          width: "abbreviated"
+        });
+      case "GGGGG":
+        return localize2.era(era, {
+          width: "narrow"
+        });
+      case "GGGG":
+      default:
+        return localize2.era(era, {
+          width: "wide"
+        });
+    }
+  },
+  y: function(date, token, localize2) {
+    if (token === "yo") {
+      var signedYear = date.getUTCFullYear();
+      var year = signedYear > 0 ? signedYear : 1 - signedYear;
+      return localize2.ordinalNumber(year, {
+        unit: "year"
+      });
+    }
+    return lightFormatters_default.y(date, token);
+  },
+  Y: function(date, token, localize2, options) {
+    var signedWeekYear = getUTCWeekYear(date, options);
+    var weekYear = signedWeekYear > 0 ? signedWeekYear : 1 - signedWeekYear;
+    if (token === "YY") {
+      var twoDigitYear = weekYear % 100;
+      return addLeadingZeros(twoDigitYear, 2);
+    }
+    if (token === "Yo") {
+      return localize2.ordinalNumber(weekYear, {
+        unit: "year"
+      });
+    }
+    return addLeadingZeros(weekYear, token.length);
+  },
+  R: function(date, token) {
+    var isoWeekYear = getUTCISOWeekYear(date);
+    return addLeadingZeros(isoWeekYear, token.length);
+  },
+  u: function(date, token) {
+    var year = date.getUTCFullYear();
+    return addLeadingZeros(year, token.length);
+  },
+  Q: function(date, token, localize2) {
+    var quarter = Math.ceil((date.getUTCMonth() + 1) / 3);
+    switch (token) {
+      case "Q":
+        return String(quarter);
+      case "QQ":
+        return addLeadingZeros(quarter, 2);
+      case "Qo":
+        return localize2.ordinalNumber(quarter, {
+          unit: "quarter"
+        });
+      case "QQQ":
+        return localize2.quarter(quarter, {
+          width: "abbreviated",
+          context: "formatting"
+        });
+      case "QQQQQ":
+        return localize2.quarter(quarter, {
+          width: "narrow",
+          context: "formatting"
+        });
+      case "QQQQ":
+      default:
+        return localize2.quarter(quarter, {
+          width: "wide",
+          context: "formatting"
+        });
+    }
+  },
+  q: function(date, token, localize2) {
+    var quarter = Math.ceil((date.getUTCMonth() + 1) / 3);
+    switch (token) {
+      case "q":
+        return String(quarter);
+      case "qq":
+        return addLeadingZeros(quarter, 2);
+      case "qo":
+        return localize2.ordinalNumber(quarter, {
+          unit: "quarter"
+        });
+      case "qqq":
+        return localize2.quarter(quarter, {
+          width: "abbreviated",
+          context: "standalone"
+        });
+      case "qqqqq":
+        return localize2.quarter(quarter, {
+          width: "narrow",
+          context: "standalone"
+        });
+      case "qqqq":
+      default:
+        return localize2.quarter(quarter, {
+          width: "wide",
+          context: "standalone"
+        });
+    }
+  },
+  M: function(date, token, localize2) {
+    var month = date.getUTCMonth();
+    switch (token) {
+      case "M":
+      case "MM":
+        return lightFormatters_default.M(date, token);
+      case "Mo":
+        return localize2.ordinalNumber(month + 1, {
+          unit: "month"
+        });
+      case "MMM":
+        return localize2.month(month, {
+          width: "abbreviated",
+          context: "formatting"
+        });
+      case "MMMMM":
+        return localize2.month(month, {
+          width: "narrow",
+          context: "formatting"
+        });
+      case "MMMM":
+      default:
+        return localize2.month(month, {
+          width: "wide",
+          context: "formatting"
+        });
+    }
+  },
+  L: function(date, token, localize2) {
+    var month = date.getUTCMonth();
+    switch (token) {
+      case "L":
+        return String(month + 1);
+      case "LL":
+        return addLeadingZeros(month + 1, 2);
+      case "Lo":
+        return localize2.ordinalNumber(month + 1, {
+          unit: "month"
+        });
+      case "LLL":
+        return localize2.month(month, {
+          width: "abbreviated",
+          context: "standalone"
+        });
+      case "LLLLL":
+        return localize2.month(month, {
+          width: "narrow",
+          context: "standalone"
+        });
+      case "LLLL":
+      default:
+        return localize2.month(month, {
+          width: "wide",
+          context: "standalone"
+        });
+    }
+  },
+  w: function(date, token, localize2, options) {
+    var week = getUTCWeek(date, options);
+    if (token === "wo") {
+      return localize2.ordinalNumber(week, {
+        unit: "week"
+      });
+    }
+    return addLeadingZeros(week, token.length);
+  },
+  I: function(date, token, localize2) {
+    var isoWeek = getUTCISOWeek(date);
+    if (token === "Io") {
+      return localize2.ordinalNumber(isoWeek, {
+        unit: "week"
+      });
+    }
+    return addLeadingZeros(isoWeek, token.length);
+  },
+  d: function(date, token, localize2) {
+    if (token === "do") {
+      return localize2.ordinalNumber(date.getUTCDate(), {
+        unit: "date"
+      });
+    }
+    return lightFormatters_default.d(date, token);
+  },
+  D: function(date, token, localize2) {
+    var dayOfYear = getUTCDayOfYear(date);
+    if (token === "Do") {
+      return localize2.ordinalNumber(dayOfYear, {
+        unit: "dayOfYear"
+      });
+    }
+    return addLeadingZeros(dayOfYear, token.length);
+  },
+  E: function(date, token, localize2) {
+    var dayOfWeek = date.getUTCDay();
+    switch (token) {
+      case "E":
+      case "EE":
+      case "EEE":
+        return localize2.day(dayOfWeek, {
+          width: "abbreviated",
+          context: "formatting"
+        });
+      case "EEEEE":
+        return localize2.day(dayOfWeek, {
+          width: "narrow",
+          context: "formatting"
+        });
+      case "EEEEEE":
+        return localize2.day(dayOfWeek, {
+          width: "short",
+          context: "formatting"
+        });
+      case "EEEE":
+      default:
+        return localize2.day(dayOfWeek, {
+          width: "wide",
+          context: "formatting"
+        });
+    }
+  },
+  e: function(date, token, localize2, options) {
+    var dayOfWeek = date.getUTCDay();
+    var localDayOfWeek = (dayOfWeek - options.weekStartsOn + 8) % 7 || 7;
+    switch (token) {
+      case "e":
+        return String(localDayOfWeek);
+      case "ee":
+        return addLeadingZeros(localDayOfWeek, 2);
+      case "eo":
+        return localize2.ordinalNumber(localDayOfWeek, {
+          unit: "day"
+        });
+      case "eee":
+        return localize2.day(dayOfWeek, {
+          width: "abbreviated",
+          context: "formatting"
+        });
+      case "eeeee":
+        return localize2.day(dayOfWeek, {
+          width: "narrow",
+          context: "formatting"
+        });
+      case "eeeeee":
+        return localize2.day(dayOfWeek, {
+          width: "short",
+          context: "formatting"
+        });
+      case "eeee":
+      default:
+        return localize2.day(dayOfWeek, {
+          width: "wide",
+          context: "formatting"
+        });
+    }
+  },
+  c: function(date, token, localize2, options) {
+    var dayOfWeek = date.getUTCDay();
+    var localDayOfWeek = (dayOfWeek - options.weekStartsOn + 8) % 7 || 7;
+    switch (token) {
+      case "c":
+        return String(localDayOfWeek);
+      case "cc":
+        return addLeadingZeros(localDayOfWeek, token.length);
+      case "co":
+        return localize2.ordinalNumber(localDayOfWeek, {
+          unit: "day"
+        });
+      case "ccc":
+        return localize2.day(dayOfWeek, {
+          width: "abbreviated",
+          context: "standalone"
+        });
+      case "ccccc":
+        return localize2.day(dayOfWeek, {
+          width: "narrow",
+          context: "standalone"
+        });
+      case "cccccc":
+        return localize2.day(dayOfWeek, {
+          width: "short",
+          context: "standalone"
+        });
+      case "cccc":
+      default:
+        return localize2.day(dayOfWeek, {
+          width: "wide",
+          context: "standalone"
+        });
+    }
+  },
+  i: function(date, token, localize2) {
+    var dayOfWeek = date.getUTCDay();
+    var isoDayOfWeek = dayOfWeek === 0 ? 7 : dayOfWeek;
+    switch (token) {
+      case "i":
+        return String(isoDayOfWeek);
+      case "ii":
+        return addLeadingZeros(isoDayOfWeek, token.length);
+      case "io":
+        return localize2.ordinalNumber(isoDayOfWeek, {
+          unit: "day"
+        });
+      case "iii":
+        return localize2.day(dayOfWeek, {
+          width: "abbreviated",
+          context: "formatting"
+        });
+      case "iiiii":
+        return localize2.day(dayOfWeek, {
+          width: "narrow",
+          context: "formatting"
+        });
+      case "iiiiii":
+        return localize2.day(dayOfWeek, {
+          width: "short",
+          context: "formatting"
+        });
+      case "iiii":
+      default:
+        return localize2.day(dayOfWeek, {
+          width: "wide",
+          context: "formatting"
+        });
+    }
+  },
+  a: function(date, token, localize2) {
+    var hours = date.getUTCHours();
+    var dayPeriodEnumValue = hours / 12 >= 1 ? "pm" : "am";
+    switch (token) {
+      case "a":
+      case "aa":
+        return localize2.dayPeriod(dayPeriodEnumValue, {
+          width: "abbreviated",
+          context: "formatting"
+        });
+      case "aaa":
+        return localize2.dayPeriod(dayPeriodEnumValue, {
+          width: "abbreviated",
+          context: "formatting"
+        }).toLowerCase();
+      case "aaaaa":
+        return localize2.dayPeriod(dayPeriodEnumValue, {
+          width: "narrow",
+          context: "formatting"
+        });
+      case "aaaa":
+      default:
+        return localize2.dayPeriod(dayPeriodEnumValue, {
+          width: "wide",
+          context: "formatting"
+        });
+    }
+  },
+  b: function(date, token, localize2) {
+    var hours = date.getUTCHours();
+    var dayPeriodEnumValue;
+    if (hours === 12) {
+      dayPeriodEnumValue = dayPeriodEnum.noon;
+    } else if (hours === 0) {
+      dayPeriodEnumValue = dayPeriodEnum.midnight;
+    } else {
+      dayPeriodEnumValue = hours / 12 >= 1 ? "pm" : "am";
+    }
+    switch (token) {
+      case "b":
+      case "bb":
+        return localize2.dayPeriod(dayPeriodEnumValue, {
+          width: "abbreviated",
+          context: "formatting"
+        });
+      case "bbb":
+        return localize2.dayPeriod(dayPeriodEnumValue, {
+          width: "abbreviated",
+          context: "formatting"
+        }).toLowerCase();
+      case "bbbbb":
+        return localize2.dayPeriod(dayPeriodEnumValue, {
+          width: "narrow",
+          context: "formatting"
+        });
+      case "bbbb":
+      default:
+        return localize2.dayPeriod(dayPeriodEnumValue, {
+          width: "wide",
+          context: "formatting"
+        });
+    }
+  },
+  B: function(date, token, localize2) {
+    var hours = date.getUTCHours();
+    var dayPeriodEnumValue;
+    if (hours >= 17) {
+      dayPeriodEnumValue = dayPeriodEnum.evening;
+    } else if (hours >= 12) {
+      dayPeriodEnumValue = dayPeriodEnum.afternoon;
+    } else if (hours >= 4) {
+      dayPeriodEnumValue = dayPeriodEnum.morning;
+    } else {
+      dayPeriodEnumValue = dayPeriodEnum.night;
+    }
+    switch (token) {
+      case "B":
+      case "BB":
+      case "BBB":
+        return localize2.dayPeriod(dayPeriodEnumValue, {
+          width: "abbreviated",
+          context: "formatting"
+        });
+      case "BBBBB":
+        return localize2.dayPeriod(dayPeriodEnumValue, {
+          width: "narrow",
+          context: "formatting"
+        });
+      case "BBBB":
+      default:
+        return localize2.dayPeriod(dayPeriodEnumValue, {
+          width: "wide",
+          context: "formatting"
+        });
+    }
+  },
+  h: function(date, token, localize2) {
+    if (token === "ho") {
+      var hours = date.getUTCHours() % 12;
+      if (hours === 0)
+        hours = 12;
+      return localize2.ordinalNumber(hours, {
+        unit: "hour"
+      });
+    }
+    return lightFormatters_default.h(date, token);
+  },
+  H: function(date, token, localize2) {
+    if (token === "Ho") {
+      return localize2.ordinalNumber(date.getUTCHours(), {
+        unit: "hour"
+      });
+    }
+    return lightFormatters_default.H(date, token);
+  },
+  K: function(date, token, localize2) {
+    var hours = date.getUTCHours() % 12;
+    if (token === "Ko") {
+      return localize2.ordinalNumber(hours, {
+        unit: "hour"
+      });
+    }
+    return addLeadingZeros(hours, token.length);
+  },
+  k: function(date, token, localize2) {
+    var hours = date.getUTCHours();
+    if (hours === 0)
+      hours = 24;
+    if (token === "ko") {
+      return localize2.ordinalNumber(hours, {
+        unit: "hour"
+      });
+    }
+    return addLeadingZeros(hours, token.length);
+  },
+  m: function(date, token, localize2) {
+    if (token === "mo") {
+      return localize2.ordinalNumber(date.getUTCMinutes(), {
+        unit: "minute"
+      });
+    }
+    return lightFormatters_default.m(date, token);
+  },
+  s: function(date, token, localize2) {
+    if (token === "so") {
+      return localize2.ordinalNumber(date.getUTCSeconds(), {
+        unit: "second"
+      });
+    }
+    return lightFormatters_default.s(date, token);
+  },
+  S: function(date, token) {
+    return lightFormatters_default.S(date, token);
+  },
+  X: function(date, token, _localize, options) {
+    var originalDate = options._originalDate || date;
+    var timezoneOffset = originalDate.getTimezoneOffset();
+    if (timezoneOffset === 0) {
+      return "Z";
+    }
+    switch (token) {
+      case "X":
+        return formatTimezoneWithOptionalMinutes(timezoneOffset);
+      case "XXXX":
+      case "XX":
+        return formatTimezone(timezoneOffset);
+      case "XXXXX":
+      case "XXX":
+      default:
+        return formatTimezone(timezoneOffset, ":");
+    }
+  },
+  x: function(date, token, _localize, options) {
+    var originalDate = options._originalDate || date;
+    var timezoneOffset = originalDate.getTimezoneOffset();
+    switch (token) {
+      case "x":
+        return formatTimezoneWithOptionalMinutes(timezoneOffset);
+      case "xxxx":
+      case "xx":
+        return formatTimezone(timezoneOffset);
+      case "xxxxx":
+      case "xxx":
+      default:
+        return formatTimezone(timezoneOffset, ":");
+    }
+  },
+  O: function(date, token, _localize, options) {
+    var originalDate = options._originalDate || date;
+    var timezoneOffset = originalDate.getTimezoneOffset();
+    switch (token) {
+      case "O":
+      case "OO":
+      case "OOO":
+        return "GMT" + formatTimezoneShort(timezoneOffset, ":");
+      case "OOOO":
+      default:
+        return "GMT" + formatTimezone(timezoneOffset, ":");
+    }
+  },
+  z: function(date, token, _localize, options) {
+    var originalDate = options._originalDate || date;
+    var timezoneOffset = originalDate.getTimezoneOffset();
+    switch (token) {
+      case "z":
+      case "zz":
+      case "zzz":
+        return "GMT" + formatTimezoneShort(timezoneOffset, ":");
+      case "zzzz":
+      default:
+        return "GMT" + formatTimezone(timezoneOffset, ":");
+    }
+  },
+  t: function(date, token, _localize, options) {
+    var originalDate = options._originalDate || date;
+    var timestamp = Math.floor(originalDate.getTime() / 1e3);
+    return addLeadingZeros(timestamp, token.length);
+  },
+  T: function(date, token, _localize, options) {
+    var originalDate = options._originalDate || date;
+    var timestamp = originalDate.getTime();
+    return addLeadingZeros(timestamp, token.length);
+  }
+};
+function formatTimezoneShort(offset, dirtyDelimiter) {
+  var sign5 = offset > 0 ? "-" : "+";
+  var absOffset = Math.abs(offset);
+  var hours = Math.floor(absOffset / 60);
+  var minutes = absOffset % 60;
+  if (minutes === 0) {
+    return sign5 + String(hours);
+  }
+  var delimiter = dirtyDelimiter || "";
+  return sign5 + String(hours) + delimiter + addLeadingZeros(minutes, 2);
+}
+__name(formatTimezoneShort, "formatTimezoneShort");
+function formatTimezoneWithOptionalMinutes(offset, dirtyDelimiter) {
+  if (offset % 60 === 0) {
+    var sign5 = offset > 0 ? "-" : "+";
+    return sign5 + addLeadingZeros(Math.abs(offset) / 60, 2);
+  }
+  return formatTimezone(offset, dirtyDelimiter);
+}
+__name(formatTimezoneWithOptionalMinutes, "formatTimezoneWithOptionalMinutes");
+function formatTimezone(offset, dirtyDelimiter) {
+  var delimiter = dirtyDelimiter || "";
+  var sign5 = offset > 0 ? "-" : "+";
+  var absOffset = Math.abs(offset);
+  var hours = addLeadingZeros(Math.floor(absOffset / 60), 2);
+  var minutes = addLeadingZeros(absOffset % 60, 2);
+  return sign5 + hours + delimiter + minutes;
+}
+__name(formatTimezone, "formatTimezone");
+var formatters_default = formatters2;
+
+// ../../node_modules/.pnpm/date-fns@2.28.0/node_modules/date-fns/esm/_lib/format/longFormatters/index.js
+function dateLongFormatter(pattern, formatLong2) {
+  switch (pattern) {
+    case "P":
+      return formatLong2.date({
+        width: "short"
+      });
+    case "PP":
+      return formatLong2.date({
+        width: "medium"
+      });
+    case "PPP":
+      return formatLong2.date({
+        width: "long"
+      });
+    case "PPPP":
+    default:
+      return formatLong2.date({
+        width: "full"
+      });
+  }
+}
+__name(dateLongFormatter, "dateLongFormatter");
+function timeLongFormatter(pattern, formatLong2) {
+  switch (pattern) {
+    case "p":
+      return formatLong2.time({
+        width: "short"
+      });
+    case "pp":
+      return formatLong2.time({
+        width: "medium"
+      });
+    case "ppp":
+      return formatLong2.time({
+        width: "long"
+      });
+    case "pppp":
+    default:
+      return formatLong2.time({
+        width: "full"
+      });
+  }
+}
+__name(timeLongFormatter, "timeLongFormatter");
+function dateTimeLongFormatter(pattern, formatLong2) {
+  var matchResult = pattern.match(/(P+)(p+)?/) || [];
+  var datePattern = matchResult[1];
+  var timePattern = matchResult[2];
+  if (!timePattern) {
+    return dateLongFormatter(pattern, formatLong2);
+  }
+  var dateTimeFormat;
+  switch (datePattern) {
+    case "P":
+      dateTimeFormat = formatLong2.dateTime({
+        width: "short"
+      });
+      break;
+    case "PP":
+      dateTimeFormat = formatLong2.dateTime({
+        width: "medium"
+      });
+      break;
+    case "PPP":
+      dateTimeFormat = formatLong2.dateTime({
+        width: "long"
+      });
+      break;
+    case "PPPP":
+    default:
+      dateTimeFormat = formatLong2.dateTime({
+        width: "full"
+      });
+      break;
+  }
+  return dateTimeFormat.replace("{{date}}", dateLongFormatter(datePattern, formatLong2)).replace("{{time}}", timeLongFormatter(timePattern, formatLong2));
+}
+__name(dateTimeLongFormatter, "dateTimeLongFormatter");
+var longFormatters = {
+  p: timeLongFormatter,
+  P: dateTimeLongFormatter
+};
+var longFormatters_default = longFormatters;
+
+// ../../node_modules/.pnpm/date-fns@2.28.0/node_modules/date-fns/esm/_lib/protectedTokens/index.js
+var protectedDayOfYearTokens = ["D", "DD"];
+var protectedWeekYearTokens = ["YY", "YYYY"];
+function isProtectedDayOfYearToken(token) {
+  return protectedDayOfYearTokens.indexOf(token) !== -1;
+}
+__name(isProtectedDayOfYearToken, "isProtectedDayOfYearToken");
+function isProtectedWeekYearToken(token) {
+  return protectedWeekYearTokens.indexOf(token) !== -1;
+}
+__name(isProtectedWeekYearToken, "isProtectedWeekYearToken");
+function throwProtectedError(token, format2, input) {
+  if (token === "YYYY") {
+    throw new RangeError("Use `yyyy` instead of `YYYY` (in `".concat(format2, "`) for formatting years to the input `").concat(input, "`; see: https://git.io/fxCyr"));
+  } else if (token === "YY") {
+    throw new RangeError("Use `yy` instead of `YY` (in `".concat(format2, "`) for formatting years to the input `").concat(input, "`; see: https://git.io/fxCyr"));
+  } else if (token === "D") {
+    throw new RangeError("Use `d` instead of `D` (in `".concat(format2, "`) for formatting days of the month to the input `").concat(input, "`; see: https://git.io/fxCyr"));
+  } else if (token === "DD") {
+    throw new RangeError("Use `dd` instead of `DD` (in `".concat(format2, "`) for formatting days of the month to the input `").concat(input, "`; see: https://git.io/fxCyr"));
+  }
+}
+__name(throwProtectedError, "throwProtectedError");
+
+// ../../node_modules/.pnpm/date-fns@2.28.0/node_modules/date-fns/esm/format/index.js
+var formattingTokensRegExp = /[yYQqMLwIdDecihHKkms]o|(\w)\1*|''|'(''|[^'])+('|$)|./g;
+var longFormattingTokensRegExp = /P+p+|P+|p+|''|'(''|[^'])+('|$)|./g;
+var escapedStringRegExp = /^'([^]*?)'?$/;
+var doubleQuoteRegExp = /''/g;
+var unescapedLatinCharacterRegExp = /[a-zA-Z]/;
+function format(dirtyDate, dirtyFormatStr, dirtyOptions) {
+  requiredArgs(2, arguments);
+  var formatStr = String(dirtyFormatStr);
+  var options = dirtyOptions || {};
+  var locale2 = options.locale || en_US_default;
+  var localeFirstWeekContainsDate = locale2.options && locale2.options.firstWeekContainsDate;
+  var defaultFirstWeekContainsDate = localeFirstWeekContainsDate == null ? 1 : toInteger(localeFirstWeekContainsDate);
+  var firstWeekContainsDate = options.firstWeekContainsDate == null ? defaultFirstWeekContainsDate : toInteger(options.firstWeekContainsDate);
+  if (!(firstWeekContainsDate >= 1 && firstWeekContainsDate <= 7)) {
+    throw new RangeError("firstWeekContainsDate must be between 1 and 7 inclusively");
+  }
+  var localeWeekStartsOn = locale2.options && locale2.options.weekStartsOn;
+  var defaultWeekStartsOn = localeWeekStartsOn == null ? 0 : toInteger(localeWeekStartsOn);
+  var weekStartsOn = options.weekStartsOn == null ? defaultWeekStartsOn : toInteger(options.weekStartsOn);
+  if (!(weekStartsOn >= 0 && weekStartsOn <= 6)) {
+    throw new RangeError("weekStartsOn must be between 0 and 6 inclusively");
+  }
+  if (!locale2.localize) {
+    throw new RangeError("locale must contain localize property");
+  }
+  if (!locale2.formatLong) {
+    throw new RangeError("locale must contain formatLong property");
+  }
+  var originalDate = toDate(dirtyDate);
+  if (!isValid(originalDate)) {
+    throw new RangeError("Invalid time value");
+  }
+  var timezoneOffset = getTimezoneOffsetInMilliseconds(originalDate);
+  var utcDate = subMilliseconds(originalDate, timezoneOffset);
+  var formatterOptions = {
+    firstWeekContainsDate,
+    weekStartsOn,
+    locale: locale2,
+    _originalDate: originalDate
+  };
+  var result = formatStr.match(longFormattingTokensRegExp).map(function(substring) {
+    var firstCharacter = substring[0];
+    if (firstCharacter === "p" || firstCharacter === "P") {
+      var longFormatter = longFormatters_default[firstCharacter];
+      return longFormatter(substring, locale2.formatLong, formatterOptions);
+    }
+    return substring;
+  }).join("").match(formattingTokensRegExp).map(function(substring) {
+    if (substring === "''") {
+      return "'";
+    }
+    var firstCharacter = substring[0];
+    if (firstCharacter === "'") {
+      return cleanEscapedString(substring);
+    }
+    var formatter = formatters_default[firstCharacter];
+    if (formatter) {
+      if (!options.useAdditionalWeekYearTokens && isProtectedWeekYearToken(substring)) {
+        throwProtectedError(substring, dirtyFormatStr, dirtyDate);
+      }
+      if (!options.useAdditionalDayOfYearTokens && isProtectedDayOfYearToken(substring)) {
+        throwProtectedError(substring, dirtyFormatStr, dirtyDate);
+      }
+      return formatter(utcDate, substring, locale2.localize, formatterOptions);
+    }
+    if (firstCharacter.match(unescapedLatinCharacterRegExp)) {
+      throw new RangeError("Format string contains an unescaped latin alphabet character `" + firstCharacter + "`");
+    }
+    return substring;
+  }).join("");
+  return result;
+}
+__name(format, "format");
+function cleanEscapedString(input) {
+  return input.match(escapedStringRegExp)[1].replace(doubleQuoteRegExp, "'");
+}
+__name(cleanEscapedString, "cleanEscapedString");
+
 // src/wallet/verify.ts
+var transformErrorMessage = /* @__PURE__ */ __name((error, credential) => {
+  if (error.startsWith("expiration")) {
+    return credential.expirationDate ? `Invalid \u2022 Expired ${format(new Date(credential.expirationDate), "dd MMM yyyy").toUpperCase()}` : "Invalid \u2022 Expired";
+  }
+  return error;
+}, "transformErrorMessage");
+var transformCheckMessage = /* @__PURE__ */ __name((check, credential) => {
+  return {
+    proof: "Valid",
+    expiration: credential.expirationDate ? `Valid \u2022 Expires ${format(new Date(credential.expirationDate), "dd MMM yyyy").toUpperCase()}` : "Valid \u2022 Does Not Expire"
+  }[check] || check;
+}, "transformCheckMessage");
 var verifyCredential3 = /* @__PURE__ */ __name((wallet) => {
   return (credential) => __async(void 0, null, function* () {
     const rawVerificationCheck = yield wallet.pluginMethods.verifyCredential(credential);
@@ -48600,7 +50123,7 @@ var verifyCredential3 = /* @__PURE__ */ __name((wallet) => {
       verificationItems.push({
         status: VerificationStatus.Failed,
         check: "hmm",
-        details: error
+        details: transformErrorMessage(error, credential)
       });
     });
     rawVerificationCheck.warnings.forEach((warning) => {
@@ -48614,7 +50137,7 @@ var verifyCredential3 = /* @__PURE__ */ __name((wallet) => {
       verificationItems.push({
         status: VerificationStatus.Success,
         check,
-        message: check === "proof" ? "Valid" : check
+        message: transformCheckMessage(check, credential)
       });
     });
     return verificationItems;
@@ -48639,9 +50162,13 @@ var defaultCeramicIDXArgs = {
 };
 
 // src/wallet/init.ts
-var createWallet = /* @__PURE__ */ __name((_0, ..._1) => __async(void 0, [_0, ..._1], function* (defaultContents, { ceramicIdx = defaultCeramicIDXArgs, didkit } = {}) {
+var walletFromKey = /* @__PURE__ */ __name((_0, ..._1) => __async(void 0, [_0, ..._1], function* (key2, {
+  ceramicIdx = defaultCeramicIDXArgs,
+  didkit,
+  defaultContents = []
+} = {}) {
   yield didkit_default(didkit);
-  const didkeyWallet = yield (yield generateWallet(defaultContents)).addPlugin(DidKeyPlugin);
+  const didkeyWallet = yield (yield generateWallet(defaultContents)).addPlugin(yield getDidKeyPlugin(key2));
   const didkeyAndVCWallet = yield didkeyWallet.addPlugin(yield getVCPlugin(didkeyWallet));
   const idxWallet = yield didkeyAndVCWallet.addPlugin(yield getIDXPlugin(didkeyAndVCWallet, ceramicIdx));
   const wallet = yield idxWallet.addPlugin(ExpirationPlugin(idxWallet));
@@ -48666,14 +50193,8 @@ var createWallet = /* @__PURE__ */ __name((_0, ..._1) => __async(void 0, [_0, ..
     readFromCeramic: wallet.pluginMethods.readContentFromCeramic,
     getTestVc: wallet.pluginMethods.getTestVc
   };
-}), "createWallet");
-var walletFromKey = /* @__PURE__ */ __name((_0, ..._1) => __async(void 0, [_0, ..._1], function* (key2, { ceramicIdx = defaultCeramicIDXArgs, didkit } = {}) {
-  yield didkit_default(didkit);
-  const didDocuments = yield DidKeyPlugin.pluginConstants.generateContentFromSeed(toUint8Array(key2.padStart(64, "0")));
-  return createWallet(didDocuments, { ceramicIdx, didkit });
 }), "walletFromKey");
 export {
-  createWallet,
   walletFromKey
 };
 /*!