@agnostack/verifyd 2.5.0-alpha.4 → 2.5.0-beta.2

package/dist/umd/index.js

@@ -276,477 +276,442 @@
   };
   // #endregion lib-utils-js
 
-  class WebCrypto {
-    constructor({ crypto: _crypto, util: _util } = {}) {
-      this._crypto = _crypto ?? {};
-      this._util = _util ?? {};
-    }
-
-    get subtle() {
-      return this._crypto?.subtle
-    }
+  /******************************************************************************
+  Copyright (c) Microsoft Corporation.
+
+  Permission to use, copy, modify, and/or distribute this software for any
+  purpose with or without fee is hereby granted.
+
+  THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH
+  REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
+  AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,
+  INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
+  LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR
+  OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
+  PERFORMANCE OF THIS SOFTWARE.
+  ***************************************************************************** */
+
+  function __awaiter(thisArg, _arguments, P, generator) {
+      function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+      return new (P || (P = Promise))(function (resolve, reject) {
+          function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+          function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+          function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+          step((generator = generator.apply(thisArg, _arguments || [])).next());
+      });
+  }
+
+  typeof SuppressedError === "function" ? SuppressedError : function (error, suppressed, message) {
+      var e = new Error(message);
+      return e.name = "SuppressedError", e.error = error, e.suppressed = suppressed, e;
+  };
 
-    async getWebCrypto() {
-      if (!this._crypto?.subtle) {
-        // 1. Try globalThis.crypto (available in all browsers and Node 18+)
-        if ((typeof globalThis !== 'undefined') && globalThis.crypto?.subtle) {
-          this._crypto = globalThis.crypto;
-        }
+  class WebCrypto {
+      constructor({ crypto: _crypto, util: _util, encoding } = {}) {
+          this._crypto = _crypto !== null && _crypto !== void 0 ? _crypto : {};
+          this._util = _util !== null && _util !== void 0 ? _util : {};
+          this._encoding = encoding;
       }
-
-      // 2. If still no subtle, fall back to polyfills (Node.js < 18, unusual environments)
-      // NOTE: Module names are assigned to variables to prevent bundlers (esbuild, webpack, etc.)
-      // from statically resolving these optional dynamic imports at bundle time.
-      if (!this._crypto?.subtle) {
-        const cryptoPolyfill = 'isomorphic-webcrypto';
-        const nodeCrypto = 'crypto';
-        try {
-          this._crypto = (await import(cryptoPolyfill)).default;
-        } catch (_ignore) {
-          console.info('Failed to import isomorphic-webcrypto, retrying w/ node crypto');
-          try {
-            this._crypto = (await import(nodeCrypto)).default;
-          } catch (error) {
-            // eslint-disable-next-line max-len
-            console.error(`Failed to import node crypto, ensure 'isomorphic-webcrypto' (or node 'crypto') is installed and/or pass in implementation via 'new WebCrypto({ crypto })'`);
-            throw error
-          }
-        }
+      get subtle() {
+          var _a;
+          return (_a = this._crypto) === null || _a === void 0 ? void 0 : _a.subtle;
       }
-
-      if (!this._crypto?.subtle) {
-        throw new CryptoError('Invalid crypto, missing subtle')
+      // eslint-disable-next-line @typescript-eslint/no-explicit-any
+      getWebCrypto() {
+          return __awaiter(this, void 0, void 0, function* () {
+              var _a, _b, _c, _d;
+              if (!((_a = this._crypto) === null || _a === void 0 ? void 0 : _a.subtle)) {
+                  // 1. Try globalThis.crypto (available in all browsers and Node 18+)
+                  if ((typeof globalThis !== 'undefined') && ((_b = globalThis.crypto) === null || _b === void 0 ? void 0 : _b.subtle)) {
+                      this._crypto = globalThis.crypto;
+                  }
+              }
+              // 2. If still no subtle, fall back to polyfills (Node.js < 18, unusual environments)
+              // NOTE: Module names are assigned to variables to prevent bundlers (esbuild, webpack, etc.)
+              // from statically resolving these optional dynamic imports at bundle time.
+              if (!((_c = this._crypto) === null || _c === void 0 ? void 0 : _c.subtle)) {
+                  const cryptoPolyfill = 'isomorphic-webcrypto';
+                  const nodeCrypto = 'crypto';
+                  try {
+                      this._crypto = (yield import(cryptoPolyfill)).default;
+                  }
+                  catch (_ignore) {
+                      console.info('Failed to import isomorphic-webcrypto, retrying w/ node crypto');
+                      try {
+                          this._crypto = (yield import(nodeCrypto)).default;
+                      }
+                      catch (error) {
+                          // eslint-disable-next-line max-len
+                          console.error(`Failed to import node crypto, ensure 'isomorphic-webcrypto' (or node 'crypto') is installed and/or pass in implementation via 'new WebCrypto({ crypto })'`);
+                          throw error;
+                      }
+                  }
+              }
+              if (!((_d = this._crypto) === null || _d === void 0 ? void 0 : _d.subtle)) {
+                  throw new CryptoError('Invalid crypto, missing subtle');
+              }
+              return this._crypto;
+          });
       }
-
-      return this._crypto
-    }
-
-    async getTextDecoder() {
-      if (this._util?.TextDecoder) {
-        return this._util.TextDecoder
+      getTextDecoder() {
+          return __awaiter(this, void 0, void 0, function* () {
+              var _a;
+              if ((_a = this._util) === null || _a === void 0 ? void 0 : _a.TextDecoder) {
+                  return this._util.TextDecoder;
+              }
+              if ((typeof globalThis !== 'undefined') && (typeof globalThis.TextDecoder === 'function')) {
+                  return globalThis.TextDecoder;
+              }
+              if ((typeof window !== 'undefined') && (typeof window.TextDecoder === 'function')) {
+                  return window.TextDecoder;
+              }
+              // NOTE: Module name assigned to variable to prevent bundlers (esbuild, webpack, etc.)
+              // from statically resolving this optional dynamic import at bundle time.
+              const nodeUtil = 'util';
+              try {
+                  const TextDecoder = (yield import(nodeUtil)).TextDecoder;
+                  this._util.TextDecoder = TextDecoder;
+                  return TextDecoder;
+              }
+              catch (error) {
+                  console.error(`Failed to import 'utils.TextDecoder', ensure 'util' is available and/or pass in implementation via 'new WebCrypto({ util })'`);
+                  throw error;
+              }
+          });
       }
-
-      if ((typeof globalThis !== 'undefined') && (typeof globalThis.TextDecoder === 'function')) {
-        return globalThis.TextDecoder
+      getTextEncoder() {
+          return __awaiter(this, void 0, void 0, function* () {
+              var _a;
+              if ((_a = this._util) === null || _a === void 0 ? void 0 : _a.TextEncoder) {
+                  return this._util.TextEncoder;
+              }
+              if ((typeof globalThis !== 'undefined') && (typeof globalThis.TextEncoder === 'function')) {
+                  return globalThis.TextEncoder;
+              }
+              if ((typeof window !== 'undefined') && (typeof window.TextEncoder === 'function')) {
+                  return window.TextEncoder;
+              }
+              // NOTE: Module name assigned to variable to prevent bundlers (esbuild, webpack, etc.)
+              // from statically resolving this optional dynamic import at bundle time.
+              const nodeUtil = 'util';
+              try {
+                  const TextEncoder = (yield import(nodeUtil)).TextEncoder;
+                  this._util.TextEncoder = TextEncoder;
+                  return TextEncoder;
+              }
+              catch (error) {
+                  console.error(`Failed to import 'utils.TextEncoder', ensure 'util' is available and/or pass in implementation via 'new WebCrypto({ util })'`);
+                  throw error;
+              }
+          });
       }
-
-      if ((typeof window !== 'undefined') && (typeof window.TextDecoder === 'function')) {
-        return window.TextDecoder
+      timingSafeEqual(value1, value2) {
+          if ((value1 == undefined) ||
+              (value2 == undefined) ||
+              (value1.length !== value2.length)) {
+              return false;
+          }
+          let result = 0;
+          // eslint-disable-next-line no-plusplus
+          for (let i = 0; i < value1.length; i++) {
+              // eslint-disable-next-line no-bitwise
+              result |= value1[i] ^ value2[i];
+          }
+          return (result === 0);
       }
-
-      // NOTE: Module name assigned to variable to prevent bundlers (esbuild, webpack, etc.)
-      // from statically resolving this optional dynamic import at bundle time.
-      const nodeUtil = 'util';
-      try {
-        const TextDecoder = (await import(nodeUtil)).TextDecoder;
-        this._util.TextDecoder = TextDecoder;
-
-        return TextDecoder
-      } catch (error) {
-        console.error(`Failed to import 'utils.TextDecoder', ensure 'util' is available and/or pass in implementation via 'new WebCrypto({ util })'`);
-        throw error
+      stringToHex(stringValue) {
+          return (Array.from(ensureString(stringValue), (char) => (char.charCodeAt(0).toString(16).padStart(2, '0'))).join(''));
       }
-    }
-
-    async getTextEncoder() {
-      if (this._util?.TextEncoder) {
-        return this._util.TextEncoder
+      hexToString(hexValue) {
+          var _a;
+          if (!isString(hexValue)) {
+              throw new CryptoError('hexValue must be a string');
+          }
+          if (!/^(?:[0-9a-f]{2})+$/.test(hexValue)) {
+              throw new CryptoError('hexValue must be a valid hex string');
+          }
+          return ensureArray((_a = hexValue.match(/.{1,2}/g)) !== null && _a !== void 0 ? _a : [])
+              .map((byte) => String.fromCharCode(parseInt(byte, 16)))
+              .join('');
       }
-
-      if ((typeof globalThis !== 'undefined') && (typeof globalThis.TextEncoder === 'function')) {
-        return globalThis.TextEncoder
+      arrayBufferToString(arrayBuffer) {
+          return __awaiter(this, void 0, void 0, function* () {
+              const uint8Array = new Uint8Array(arrayBuffer);
+              const Decoder = yield this.getTextDecoder();
+              return new Decoder().decode(uint8Array);
+          });
       }
-
-      if ((typeof window !== 'undefined') && (typeof window.TextEncoder === 'function')) {
-        return window.TextEncoder
+      arrayToArrayBuffer(array) {
+          // Defensive `ArrayBuffer.from` check is vestigial (no such standard method),
+          // but preserved to keep this conversion behavior-identical to the .js source.
+          return (
+          // eslint-disable-next-line @typescript-eslint/no-explicit-any
+          (ArrayBuffer.from != undefined)
+              // eslint-disable-next-line @typescript-eslint/no-explicit-any
+              ? ArrayBuffer.from(array)
+              : new Uint8Array(array).buffer);
       }
-
-      // NOTE: Module name assigned to variable to prevent bundlers (esbuild, webpack, etc.)
-      // from statically resolving this optional dynamic import at bundle time.
-      const nodeUtil = 'util';
-      try {
-        const TextEncoder = (await import(nodeUtil)).TextEncoder;
-        this._util.TextEncoder = TextEncoder;
-
-        return TextEncoder
-      } catch (error) {
-        console.error(`Failed to import 'utils.TextEncoder', ensure 'util' is available and/or pass in implementation via 'new WebCrypto({ util })'`);
-        throw error
+      ensureArrayBuffer(arrayOrArrayBuffer) {
+          return ((arrayOrArrayBuffer instanceof ArrayBuffer)
+              ? arrayOrArrayBuffer
+              : this.arrayToArrayBuffer(arrayOrArrayBuffer));
       }
-    }
-
-    timingSafeEqual(value1, value2) {
-      if (
-        (value1 == undefined) ||
-        (value2 == undefined) ||
-        (value1.length !== value2.length)
-      ) {
-        return false
+      getKeyOperations(keyType) {
+          switch (keyType) {
+              case 'paired':
+              case 'private':
+              case 'privateKey': {
+                  return ['deriveKey'];
+              }
+              case 'secret':
+              case 'secretKey':
+              case 'sharedSecret': {
+                  return ['encrypt', 'decrypt'];
+              }
+              case 'hmac': {
+                  return ['sign', 'verify'];
+              }
+              default: {
+                  return [];
+              }
+          }
       }
-
-      let result = 0;
-      // eslint-disable-next-line no-plusplus
-      for (let i = 0; i < value1.length; i++) {
-        // eslint-disable-next-line no-bitwise
-        result |= value1[i] ^ value2[i];
+      getKeyAlgorythm(keyType) {
+          switch (keyType) {
+              case 'derivedKey':
+              case 'derived':
+              case 'secret':
+              case 'secretKey':
+              case 'sharedSecret': {
+                  return {
+                      name: 'AES-GCM',
+                  };
+              }
+              case 'hmac': {
+                  return {
+                      name: 'HMAC',
+                      hash: { name: 'SHA-256' },
+                  };
+              }
+              default: {
+                  return {
+                      name: 'ECDH',
+                      namedCurve: 'P-256',
+                  };
+              }
+          }
       }
-
-      return (result === 0)
-    }
-
-    stringToHex(stringValue) {
-      return (
-        Array.from(ensureString(stringValue), (char) => (
-          char.charCodeAt(0).toString(16).padStart(2, '0')
-        )).join('')
-      )
-    }
-
-    hexToString(hexValue) {
-      if (!isString(hexValue)) {
-        throw new CryptoError('hexValue must be a string')
+      generateKeyPair() {
+          return __awaiter(this, void 0, void 0, function* () {
+              const crypto = yield this.getWebCrypto();
+              const keyPair = yield crypto.subtle.generateKey(this.getKeyAlgorythm('paired'), true, this.getKeyOperations('paired'));
+              return keyPair;
+          });
       }
-
-      if (!/^(?:[0-9a-f]{2})+$/.test(hexValue)) {
-        throw new CryptoError('hexValue must be a valid hex string')
+      generateSharedSecret() {
+          return __awaiter(this, void 0, void 0, function* () {
+              const crypto = yield this.getWebCrypto();
+              const keyPair = yield crypto.subtle.generateKey(this.getKeyAlgorythm('sharedSecret'), true, this.getKeyOperations('sharedSecret'));
+              return keyPair;
+          });
       }
-
-      return ensureArray(hexValue.match(/.{1,2}/g))
-      .map((byte) => String.fromCharCode(parseInt(byte, 16)))
-      .join('')
-    }
-
-    async arrayBufferToString(arrayBuffer) {
-      const uint8Array = new Uint8Array(arrayBuffer);
-      const Decoder = await this.getTextDecoder();
-      return new Decoder().decode(uint8Array)
-    }
-
-    arrayToArrayBuffer(array) {
-      return (
-        (ArrayBuffer.from != undefined)
-          ? ArrayBuffer.from(array)
-          : new Uint8Array(array).buffer
-      )
-    }
-
-    ensureArrayBuffer(arrayOrArrayBuffer) {
-      return (
-        (arrayOrArrayBuffer instanceof ArrayBuffer)
-          ? arrayOrArrayBuffer
-          : this.arrayToArrayBuffer(arrayOrArrayBuffer)
-      )
-    }
-
-    getKeyOperations(keyType) {
-      switch (keyType) {
-        case 'paired':
-        case 'private':
-        case 'privateKey': {
-          return ['deriveKey']
-        }
-
-        case 'secret':
-        case 'secretKey':
-        case 'sharedSecret': {
-          return ['encrypt', 'decrypt']
-        }
-
-        case 'hmac': {
-          return ['sign', 'verify']
-        }
-
-        default: {
-          return []
-        }
+      importRawKey(keyType_1, rawBytes_1) {
+          return __awaiter(this, arguments, void 0, function* (keyType, rawBytes, { extractable = true } = {}) {
+              const crypto = yield this.getWebCrypto();
+              return crypto.subtle.importKey('raw', rawBytes, this.getKeyAlgorythm(keyType), extractable, this.getKeyOperations(keyType));
+          });
       }
-    }
-
-    getKeyAlgorythm(keyType) {
-      switch (keyType) {
-        case 'derivedKey':
-        case 'derived':
-        case 'secret':
-        case 'secretKey':
-        case 'sharedSecret': {
-          return {
-            name: 'AES-GCM',
-          }
-        }
-
-        case 'hmac': {
-          return {
-            name: 'HMAC',
-            hash: { name: 'SHA-256' },
-          }
-        }
-
-        default: {
-          return {
-            name: 'ECDH',
-            namedCurve: 'P-256',
-          }
-        }
+      generateHMAC(message, derivedKey) {
+          return __awaiter(this, void 0, void 0, function* () {
+              if (!message || !derivedKey) {
+                  return undefined;
+              }
+              const crypto = yield this.getWebCrypto();
+              const Encoder = yield this.getTextEncoder();
+              const signature = yield crypto.subtle.sign('HMAC', derivedKey, new Encoder().encode(message));
+              return this.stringToHex(yield this.arrayBufferToString(signature));
+          });
       }
-    }
-
-    async generateKeyPair() {
-      const crypto = await this.getWebCrypto();
-      const keyPair = await crypto.subtle.generateKey(
-        this.getKeyAlgorythm('paired'),
-        true,
-        this.getKeyOperations('paired')
-      );
-
-      return keyPair
-    }
-
-    async generateSharedSecret() {
-      const crypto = await this.getWebCrypto();
-      const keyPair = await crypto.subtle.generateKey(
-        this.getKeyAlgorythm('sharedSecret'),
-        true,
-        this.getKeyOperations('sharedSecret')
-      );
-
-      return keyPair
-    }
-
-    async importRawKey(keyType, rawBytes, { extractable = true } = {}) {
-      const crypto = await this.getWebCrypto();
-
-      return crypto.subtle.importKey(
-        'raw',
-        rawBytes,
-        this.getKeyAlgorythm(keyType),
-        extractable,
-        this.getKeyOperations(keyType)
-      )
-    }
-
-    async generateHMAC(message, derivedKey) {
-      if (!message || !derivedKey) {
-        return undefined
-      } 
-
-      const crypto = await this.getWebCrypto();
-      const Encoder = await this.getTextEncoder();
-
-      const signature = await crypto.subtle.sign(
-        'HMAC',
-        derivedKey,
-        new Encoder().encode(message)
-      );
-
-      return this.stringToHex(
-        this.arrayBufferToString(signature)
-      )
-    }
-
-    async verifyHMAC(message, derivedKey, verifiableHMAC) {
-      const calculatedHMAC = await this.generateHMAC(message, derivedKey);
-
-      return this.timingSafeEqual(calculatedHMAC, verifiableHMAC)
-    }
-
-    async createSignedToken(message, hmacKey, ttlSeconds) {
-      const expiry = Math.floor(Date.now() / 1000) + ttlSeconds;
-      const hmacHex = await this.generateHMAC(`${message}:${expiry}`, hmacKey);
-
-      return `${expiry}.${hmacHex}`
-    }
-
-    async verifySignedToken(token, message, hmacKey) {
-      if (!token || typeof token !== 'string') {
-        return false
+      verifyHMAC(message, derivedKey, verifiableHMAC) {
+          return __awaiter(this, void 0, void 0, function* () {
+              const calculatedHMAC = yield this.generateHMAC(message, derivedKey);
+              return this.timingSafeEqual(calculatedHMAC, verifiableHMAC);
+          });
       }
-
-      const dotIndex = token.indexOf('.');
-      if (dotIndex === -1) {
-        return false
+      createSignedToken(message, hmacKey, ttlSeconds) {
+          return __awaiter(this, void 0, void 0, function* () {
+              const expiry = Math.floor(Date.now() / 1000) + ttlSeconds;
+              const hmacHex = yield this.generateHMAC(`${message}:${expiry}`, hmacKey);
+              return `${expiry}.${hmacHex}`;
+          });
       }
-
-      const expiryStr = token.substring(0, dotIndex);
-      const signature = token.substring(dotIndex + 1);
-
-      const expiry = parseInt(expiryStr, 10);
-      if (isNaN(expiry) || expiry <= Math.floor(Date.now() / 1000)) {
-        return false
+      verifySignedToken(token, message, hmacKey) {
+          return __awaiter(this, void 0, void 0, function* () {
+              if (!token || typeof token !== 'string') {
+                  return false;
+              }
+              const dotIndex = token.indexOf('.');
+              if (dotIndex === -1) {
+                  return false;
+              }
+              const expiryStr = token.substring(0, dotIndex);
+              const signature = token.substring(dotIndex + 1);
+              const expiry = parseInt(expiryStr, 10);
+              if (isNaN(expiry) || expiry <= Math.floor(Date.now() / 1000)) {
+                  return false;
+              }
+              return this.verifyHMAC(`${message}:${expiryStr}`, hmacKey, signature);
+          });
       }
-
-      return this.verifyHMAC(`${message}:${expiryStr}`, hmacKey, signature)
-    }
-
-    // NOTE: intentionally separated out as async to be able to .catch
-    async getStorableKey(key) {
-      const crypto = await this.getWebCrypto();
-
-      const exportedJWK = await crypto.subtle.exportKey('jwk', key);
-      return this.stringToHex(JSON.stringify(exportedJWK))
-    }
-
-    // NOTE: intentionally separated out as async to be able to .catch
-    async parseStorableHex(storableHex) {
-      return JSON.parse(this.hexToString(storableHex) || '{}')
-    }
-
-    async restoreStorableKey(keyType, storableHex) {
-      // eslint-disable-next-line eqeqeq
-      if (storableHex == undefined) {
-        return undefined
+      // NOTE: intentionally separated out as async to be able to .catch
+      getStorableKey(key) {
+          return __awaiter(this, void 0, void 0, function* () {
+              const crypto = yield this.getWebCrypto();
+              const exportedJWK = yield crypto.subtle.exportKey('jwk', key);
+              return this.stringToHex(JSON.stringify(exportedJWK));
+          });
       }
-      const crypto = await this.getWebCrypto();
-
-      const exportedJWK = await this.parseStorableHex(storableHex).catch((ignore) => {
-        console.error('Failed to parse storable hex value', ignore);
-        return undefined
-      });
-      if (objectEmpty(exportedJWK)) {
-        return undefined
+      // NOTE: intentionally separated out as async to be able to .catch
+      parseStorableHex(storableHex) {
+          return __awaiter(this, void 0, void 0, function* () {
+              return JSON.parse(this.hexToString(storableHex) || '{}');
+          });
       }
-
-      return crypto.subtle.importKey(
-        'jwk',
-        exportedJWK,
-        this.getKeyAlgorythm(keyType),
-        true,
-        this.getKeyOperations(keyType)
-      )
-    }
-
-    async getStorableKeyPair(keyPair) {
-      const storableKeys = {};
-
-      // eslint-disable-next-line no-restricted-syntax
-      for (const [keyType, key] of Object.entries(keyPair)) {
-        // eslint-disable-next-line no-await-in-loop
-        storableKeys[keyType] = await this.getStorableKey(key);
+      restoreStorableKey(keyType, storableHex) {
+          return __awaiter(this, void 0, void 0, function* () {
+              // eslint-disable-next-line eqeqeq
+              if (storableHex == undefined) {
+                  return undefined;
+              }
+              const crypto = yield this.getWebCrypto();
+              const exportedJWK = yield this.parseStorableHex(storableHex).catch((ignore) => {
+                  console.error('Failed to parse storable hex value', ignore);
+                  return undefined;
+              });
+              if (objectEmpty(exportedJWK)) {
+                  return undefined;
+              }
+              return crypto.subtle.importKey('jwk', exportedJWK, this.getKeyAlgorythm(keyType), true, this.getKeyOperations(keyType));
+          });
       }
-
-      return storableKeys
-    }
-
-    async restoreStorableKeyPair(keyPair) {
-      const restoredKeys = {};
-
-      // eslint-disable-next-line no-restricted-syntax
-      for (const [keyType, key] of Object.entries(keyPair)) {
-        // eslint-disable-next-line no-await-in-loop
-        restoredKeys[keyType] = await this.restoreStorableKey(keyType, key);
+      getStorableKeyPair(keyPair) {
+          return __awaiter(this, void 0, void 0, function* () {
+              const storableKeys = {};
+              // eslint-disable-next-line no-restricted-syntax
+              for (const [keyType, key] of Object.entries(keyPair)) {
+                  // eslint-disable-next-line no-await-in-loop
+                  storableKeys[keyType] = yield this.getStorableKey(key);
+              }
+              return storableKeys;
+          });
       }
-
-      return restoredKeys
-    }
-
-    async deriveSharedKey({ publicKey, privateKey }) {
-      if (!publicKey || !privateKey) {
-        return undefined
+      restoreStorableKeyPair(keyPair) {
+          return __awaiter(this, void 0, void 0, function* () {
+              const restoredKeys = {};
+              // eslint-disable-next-line no-restricted-syntax
+              for (const [keyType, key] of Object.entries(keyPair)) {
+                  // eslint-disable-next-line no-await-in-loop
+                  restoredKeys[keyType] = yield this.restoreStorableKey(keyType, key);
+              }
+              return restoredKeys;
+          });
       }
-
-      const crypto = await this.getWebCrypto();
-      const derivedKey = await crypto.subtle.deriveKey(
-        {
-          name: 'ECDH',
-          public: publicKey,
-        },
-        privateKey,
-        {
-          name: 'AES-GCM',
-          length: 256,
-        },
-        true,
-        ['encrypt', 'decrypt']
-      );
-      return derivedKey
-    }
-
-    async deriveHMACKey({ publicKey, privateKey }) {
-      if (!publicKey || !privateKey) {
-        return undefined
+      deriveSharedKey(_a) {
+          return __awaiter(this, arguments, void 0, function* ({ publicKey, privateKey }) {
+              if (!publicKey || !privateKey) {
+                  return undefined;
+              }
+              const crypto = yield this.getWebCrypto();
+              const derivedKey = yield crypto.subtle.deriveKey({
+                  name: 'ECDH',
+                  public: publicKey,
+              }, privateKey, {
+                  name: 'AES-GCM',
+                  length: 256,
+              }, true, ['encrypt', 'decrypt']);
+              return derivedKey;
+          });
       }
-
-      const crypto = await this.getWebCrypto();
-      const derivedKey = await crypto.subtle.deriveKey(
-        {
-          name: 'ECDH',
-          public: publicKey,
-        },
-        privateKey,
-        {
-          name: 'HMAC',
-          hash: { name: 'SHA-256' },
-          length: 256,  // Adjusted key length, e.g., 128 bits
-        },
-        true,
-        ['sign', 'verify']
-      );
-      return derivedKey
-    }
-
-    async getVerificationKeys({ publicKey, privateKey }) {
-      if (!publicKey || !privateKey) {
-        return {}
+      deriveHMACKey(_a) {
+          return __awaiter(this, arguments, void 0, function* ({ publicKey, privateKey }) {
+              if (!publicKey || !privateKey) {
+                  return undefined;
+              }
+              const crypto = yield this.getWebCrypto();
+              const derivedKey = yield crypto.subtle.deriveKey({
+                  name: 'ECDH',
+                  public: publicKey,
+              }, privateKey, {
+                  name: 'HMAC',
+                  hash: { name: 'SHA-256' },
+                  length: 256, // Adjusted key length, e.g., 128 bits
+              }, true, ['sign', 'verify']);
+              return derivedKey;
+          });
       }
-
-      const sharedKeyPair = await this.restoreStorableKeyPair({ publicKey, privateKey });
-      const derivedHMACKey = await this.deriveHMACKey(sharedKeyPair);
-      const derivedSecretKey = await this.deriveSharedKey(sharedKeyPair);
-
-      return {
-        derivedSecretKey,
-        derivedHMACKey,
+      getVerificationKeys(_a) {
+          return __awaiter(this, arguments, void 0, function* ({ publicKey, privateKey }) {
+              if (!publicKey || !privateKey) {
+                  return {};
+              }
+              const sharedKeyPair = yield this.restoreStorableKeyPair({ publicKey, privateKey });
+              const derivedHMACKey = yield this.deriveHMACKey(sharedKeyPair);
+              const derivedSecretKey = yield this.deriveSharedKey(sharedKeyPair);
+              return {
+                  derivedSecretKey,
+                  derivedHMACKey,
+              };
+          });
       }
-    }
-
-    async encryptMessage(decryptedMessage, derivedKey) {
-      if (!decryptedMessage || !derivedKey) {
-        return undefined
+      encryptMessage(decryptedMessage, derivedKey) {
+          return __awaiter(this, void 0, void 0, function* () {
+              if (!decryptedMessage || !derivedKey) {
+                  return undefined;
+              }
+              const crypto = yield this.getWebCrypto();
+              const iv = crypto.getRandomValues(new Uint8Array(12));
+              const Encoder = yield this.getTextEncoder();
+              const encodedMessage = new Encoder().encode(decryptedMessage);
+              const ciphertext = yield crypto.subtle.encrypt({
+                  name: 'AES-GCM',
+                  iv,
+              }, derivedKey, encodedMessage);
+              const encryptedMessage = new Uint8Array([
+                  ...iv,
+                  ...new Uint8Array(ciphertext)
+              ]);
+              if (this._encoding === 'base64') {
+                  // btoa is universal in browsers + Node 16+; no polyfill needed.
+                  // String.fromCharCode + spread is safe for the small payloads we produce
+                  // (IV + ciphertext + tag — typically < 100KB even for large messages).
+                  return btoa(String.fromCharCode(...encryptedMessage));
+              }
+              return Array.from(encryptedMessage);
+          });
       }
-
-      const crypto = await this.getWebCrypto();
-      const iv = crypto.getRandomValues(new Uint8Array(12));
-      const Encoder = await this.getTextEncoder();
-      const encodedMessage = new Encoder().encode(decryptedMessage);
-      const ciphertext = await crypto.subtle.encrypt(
-        {
-          name: 'AES-GCM',
-          iv,
-        },
-        derivedKey,
-        encodedMessage
-      );
-
-      const encryptedMessage = new Uint8Array([
-        ...iv,
-        ...new Uint8Array(ciphertext)
-      ]);
-      return Array.from(encryptedMessage)
-    }
-
-    async decryptMessage(encryptedMessage, derivedKey) {
-      if (!encryptedMessage || !derivedKey) {
-        return undefined
+      decryptMessage(encryptedMessage, derivedKey) {
+          return __awaiter(this, void 0, void 0, function* () {
+              if (!encryptedMessage || !derivedKey) {
+                  return undefined;
+              }
+              const crypto = yield this.getWebCrypto();
+              // When encoding === 'base64', the input is a base64 string from a matching
+              // encryptMessage call on a peer instance with the same option. Otherwise,
+              // accept number[] / ArrayBuffer (existing behavior).
+              const encryptedArrayBuffer = (this._encoding === 'base64')
+                  ? Uint8Array.from(atob(encryptedMessage), (c) => c.charCodeAt(0)).buffer
+                  : this.ensureArrayBuffer(encryptedMessage);
+              const iv = encryptedArrayBuffer.slice(0, 12);
+              const ciphertext = encryptedArrayBuffer.slice(12);
+              const decryptedArrayBuffer = yield crypto.subtle.decrypt({
+                  name: 'AES-GCM',
+                  iv,
+              }, derivedKey, ciphertext);
+              const Decoder = yield this.getTextDecoder();
+              const decryptedMessage = new Decoder().decode(decryptedArrayBuffer);
+              return decryptedMessage;
+          });
       }
-
-      const crypto = await this.getWebCrypto();
-      // NOTE: this presumed an array or arrayBuffer coming in as encryptedMessage (will fail w/ IV error if its a string)
-      const encryptedArrayBuffer = this.ensureArrayBuffer(encryptedMessage);
-      const iv = encryptedArrayBuffer.slice(0, 12);
-      const ciphertext = encryptedArrayBuffer.slice(12);
-
-      const decryptedArrayBuffer = await crypto.subtle.decrypt(
-        {
-          name: 'AES-GCM',
-          iv,
-        },
-        derivedKey,
-        ciphertext
-      );
-
-      const Decoder = await this.getTextDecoder();
-      const decryptedMessage = new Decoder().decode(decryptedArrayBuffer);
-      return decryptedMessage
-    }
   }
 
   const getAuthorizationHelpers = async (sharedSecret, { crypto: _crypto, util: _util } = {}) => {
@@ -994,36 +959,6 @@
     })
   );
 
-  /******************************************************************************
-  Copyright (c) Microsoft Corporation.
-
-  Permission to use, copy, modify, and/or distribute this software for any
-  purpose with or without fee is hereby granted.
-
-  THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH
-  REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
-  AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,
-  INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
-  LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR
-  OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
-  PERFORMANCE OF THIS SOFTWARE.
-  ***************************************************************************** */
-
-  function __awaiter(thisArg, _arguments, P, generator) {
-      function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
-      return new (P || (P = Promise))(function (resolve, reject) {
-          function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-          function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-          function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
-          step((generator = generator.apply(thisArg, _arguments || [])).next());
-      });
-  }
-
-  typeof SuppressedError === "function" ? SuppressedError : function (error, suppressed, message) {
-      var e = new Error(message);
-      return e.name = "SuppressedError", e.error = error, e.suppressed = suppressed, e;
-  };
-
   const generateStorableKeyPairs = (...args_1) => __awaiter(void 0, [...args_1], void 0, function* ({ crypto: _crypto, util: _util } = {}) {
       const webCrypto = new WebCrypto({ crypto: _crypto, util: _util });
       const sharedKeyPair = yield webCrypto.generateKeyPair();
@@ -1068,7 +1003,7 @@
                       publicKey: ephemeralPublicKey,
                       privateKey: keyPairs.shared.privateKey,
                   });
-                  if (!verificationKeys) {
+                  if (!(verificationKeys === null || verificationKeys === void 0 ? void 0 : verificationKeys.derivedHMACKey) || !verificationKeys.derivedSecretKey) {
                       throw new VerificationError('Invalid or missing verification', { code: 412 });
                   }
                   const verificationPayload = objectToSortedString(Object.assign({ method: getRequestMethod(rawBody, req.method), timestamp: customAuthTimestamp, body: requestBody }, normalizeURIParts(uri)));