jose 6.1.0 → 6.1.1

package/dist/webapi/lib/cek.js

@@ -1,5 +1,5 @@
 import { JOSENotSupported } from '../util/errors.js';
-export function bitLength(alg) {
+export function cekLength(alg) {
     switch (alg) {
         case 'A128GCM':
             return 128;
@@ -16,4 +16,4 @@ export function bitLength(alg) {
             throw new JOSENotSupported(`Unsupported JWE Algorithm: ${alg}`);
     }
 }
-export default (alg) => crypto.getRandomValues(new Uint8Array(bitLength(alg) >> 3));
+export const generateCek = (alg) => crypto.getRandomValues(new Uint8Array(cekLength(alg) >> 3));

package/dist/webapi/lib/check_cek_length.js

@@ -1,7 +1,7 @@
 import { JWEInvalid } from '../util/errors.js';
-export default (cek, expected) => {
+export function checkCekLength(cek, expected) {
     const actual = cek.byteLength << 3;
     if (actual !== expected) {
         throw new JWEInvalid(`Invalid Content Encryption Key length. Expected ${expected} bits, got ${actual} bits`);
     }
-};
+}

package/dist/webapi/lib/check_iv_length.js

@@ -1,7 +1,7 @@
 import { JWEInvalid } from '../util/errors.js';
 import { bitLength } from './iv.js';
-export default (enc, iv) => {
+export function checkIvLength(enc, iv) {
     if (iv.length << 3 !== bitLength(enc)) {
         throw new JWEInvalid('Invalid Initialization Vector length');
     }
-};
+}

package/dist/webapi/lib/check_key_length.js

@@ -1,8 +1,8 @@
-export default (alg, key) => {
+export function checkKeyLength(alg, key) {
     if (alg.startsWith('RS') || alg.startsWith('PS')) {
         const { modulusLength } = key.algorithm;
         if (typeof modulusLength !== 'number' || modulusLength < 2048) {
             throw new TypeError(`${alg} requires key modulusLength to be 2048 bits or larger`);
         }
     }
-};
+}

package/dist/webapi/lib/check_key_type.js

@@ -1,5 +1,5 @@
 import { withAlg as invalidKeyInput } from './invalid_key_input.js';
-import isKeyLike from './is_key_like.js';
+import { isKeyLike } from './is_key_like.js';
 import * as jwk from './is_jwk.js';
 const tag = (key) => key?.[Symbol.toStringTag];
 const jwkMatchesOp = (alg, key, usage) => {
@@ -96,8 +96,6 @@ const asymmetricTypeCheck = (alg, key, usage) => {
                 throw new TypeError(`${tag(key)} instances for asymmetric algorithm signing must be of type "private"`);
             case 'decrypt':
                 throw new TypeError(`${tag(key)} instances for asymmetric algorithm decryption must be of type "private"`);
-            default:
-                break;
         }
     }
     if (key.type === 'private') {
@@ -106,21 +104,19 @@ const asymmetricTypeCheck = (alg, key, usage) => {
                 throw new TypeError(`${tag(key)} instances for asymmetric algorithm verifying must be of type "public"`);
             case 'encrypt':
                 throw new TypeError(`${tag(key)} instances for asymmetric algorithm encryption must be of type "public"`);
-            default:
-                break;
         }
     }
 };
-export default (alg, key, usage) => {
-    const symmetric = alg.startsWith('HS') ||
-        alg === 'dir' ||
-        alg.startsWith('PBES2') ||
-        /^A(?:128|192|256)(?:GCM)?(?:KW)?$/.test(alg) ||
-        /^A(?:128|192|256)CBC-HS(?:256|384|512)$/.test(alg);
-    if (symmetric) {
-        symmetricTypeCheck(alg, key, usage);
+export function checkKeyType(alg, key, usage) {
+    switch (alg.substring(0, 2)) {
+        case 'A1':
+        case 'A2':
+        case 'di':
+        case 'HS':
+        case 'PB':
+            symmetricTypeCheck(alg, key, usage);
+            break;
+        default:
+            asymmetricTypeCheck(alg, key, usage);
     }
-    else {
-        asymmetricTypeCheck(alg, key, usage);
-    }
-};
+}

package/dist/webapi/lib/crypto_key.js

@@ -1,9 +1,5 @@
-function unusable(name, prop = 'algorithm.name') {
-    return new TypeError(`CryptoKey does not support this operation, its ${prop} must be ${name}`);
-}
-function isAlgorithm(algorithm, name) {
-    return algorithm.name === name;
-}
+const unusable = (name, prop = 'algorithm.name') => new TypeError(`CryptoKey does not support this operation, its ${prop} must be ${name}`);
+const isAlgorithm = (algorithm, name) => algorithm.name === name;
 function getHashLength(hash) {
     return parseInt(hash.name.slice(4), 10);
 }

package/dist/webapi/lib/decrypt.js

@@ -1,9 +1,9 @@
 import { concat, uint64be } from './buffer_utils.js';
-import checkIvLength from './check_iv_length.js';
-import checkCekLength from './check_cek_length.js';
+import { checkIvLength } from './check_iv_length.js';
+import { checkCekLength } from './check_cek_length.js';
 import { JOSENotSupported, JWEDecryptionFailed, JWEInvalid } from '../util/errors.js';
 import { checkEncCryptoKey } from './crypto_key.js';
-import invalidKeyInput from './invalid_key_input.js';
+import { invalidKeyInput } from './invalid_key_input.js';
 import { isCryptoKey } from './is_key_like.js';
 async function timingSafeEqual(a, b) {
     if (!(a instanceof Uint8Array)) {
@@ -46,7 +46,7 @@ async function cbcDecrypt(enc, cek, ciphertext, iv, tag, aad) {
     }
     let plaintext;
     try {
-        plaintext = new Uint8Array(await crypto.subtle.decrypt({ iv, name: 'AES-CBC' }, encKey, ciphertext));
+        plaintext = new Uint8Array(await crypto.subtle.decrypt({ iv: iv, name: 'AES-CBC' }, encKey, ciphertext));
     }
     catch {
     }
@@ -67,7 +67,7 @@ async function gcmDecrypt(enc, cek, ciphertext, iv, tag, aad) {
     try {
         return new Uint8Array(await crypto.subtle.decrypt({
             additionalData: aad,
-            iv,
+            iv: iv,
             name: 'AES-GCM',
             tagLength: 128,
         }, encKey, concat(ciphertext, tag)));
@@ -76,7 +76,7 @@ async function gcmDecrypt(enc, cek, ciphertext, iv, tag, aad) {
         throw new JWEDecryptionFailed();
     }
 }
-export default async (enc, cek, ciphertext, iv, tag, aad) => {
+export async function decrypt(enc, cek, ciphertext, iv, tag, aad) {
     if (!isCryptoKey(cek) && !(cek instanceof Uint8Array)) {
         throw new TypeError(invalidKeyInput(cek, 'CryptoKey', 'KeyObject', 'Uint8Array', 'JSON Web Key'));
     }
@@ -103,4 +103,4 @@ export default async (enc, cek, ciphertext, iv, tag, aad) => {
         default:
             throw new JOSENotSupported('Unsupported JWE Content Encryption Algorithm');
     }
-};
+}

package/dist/webapi/lib/decrypt_key_management.js

@@ -4,12 +4,12 @@ import * as pbes2kw from './pbes2kw.js';
 import * as rsaes from './rsaes.js';
 import { decode as b64u } from '../util/base64url.js';
 import { JOSENotSupported, JWEInvalid } from '../util/errors.js';
-import { bitLength as cekLength } from '../lib/cek.js';
+import { cekLength } from '../lib/cek.js';
 import { importJWK } from '../key/import.js';
-import isObject from './is_object.js';
+import { isObject } from './is_object.js';
 import { unwrap as aesGcmKw } from './aesgcmkw.js';
 import { assertCryptoKey } from './is_key_like.js';
-export default async (alg, key, encryptedKey, joseHeader, options) => {
+export async function decryptKeyManagement(alg, key, encryptedKey, joseHeader, options) {
     switch (alg) {
         case 'dir': {
             if (encryptedKey !== undefined)
@@ -124,4 +124,4 @@ export default async (alg, key, encryptedKey, joseHeader, options) => {
             throw new JOSENotSupported('Invalid or unsupported "alg" (JWE Algorithm) header value');
         }
     }
-};
+}

package/dist/webapi/lib/digest.js

@@ -1,4 +1,4 @@
-export default async (algorithm, data) => {
+export async function digest(algorithm, data) {
     const subtleDigest = `SHA-${algorithm.slice(-3)}`;
     return new Uint8Array(await crypto.subtle.digest(subtleDigest, data));
-};
+}

package/dist/webapi/lib/ecdhes.js

@@ -1,6 +1,6 @@
-import { encoder, concat, uint32be } from './buffer_utils.js';
+import { encode, concat, uint32be } from './buffer_utils.js';
 import { checkEncCryptoKey } from './crypto_key.js';
-import digest from './digest.js';
+import { digest } from './digest.js';
 function lengthAndInput(input) {
     return concat(uint32be(input.length), input);
 }
@@ -19,14 +19,14 @@ async function concatKdf(Z, L, OtherInfo) {
     }
     return dk.slice(0, dkLen);
 }
-export async function deriveKey(publicKey, privateKey, algorithm, keyLength, apu = new Uint8Array(0), apv = new Uint8Array(0)) {
+export async function deriveKey(publicKey, privateKey, algorithm, keyLength, apu = new Uint8Array(), apv = new Uint8Array()) {
     checkEncCryptoKey(publicKey, 'ECDH');
     checkEncCryptoKey(privateKey, 'ECDH', 'deriveBits');
-    const algorithmID = lengthAndInput(encoder.encode(algorithm));
+    const algorithmID = lengthAndInput(encode(algorithm));
     const partyUInfo = lengthAndInput(apu);
     const partyVInfo = lengthAndInput(apv);
     const suppPubInfo = uint32be(keyLength);
-    const suppPrivInfo = new Uint8Array(0);
+    const suppPrivInfo = new Uint8Array();
     const otherInfo = concat(algorithmID, partyUInfo, partyVInfo, suppPubInfo, suppPrivInfo);
     const Z = new Uint8Array(await crypto.subtle.deriveBits({
         name: publicKey.algorithm.name,

package/dist/webapi/lib/encrypt.js

@@ -1,9 +1,9 @@
 import { concat, uint64be } from './buffer_utils.js';
-import checkIvLength from './check_iv_length.js';
-import checkCekLength from './check_cek_length.js';
+import { checkIvLength } from './check_iv_length.js';
+import { checkCekLength } from './check_cek_length.js';
 import { checkEncCryptoKey } from './crypto_key.js';
-import invalidKeyInput from './invalid_key_input.js';
-import generateIv from './iv.js';
+import { invalidKeyInput } from './invalid_key_input.js';
+import { generateIv } from './iv.js';
 import { JOSENotSupported } from '../util/errors.js';
 import { isCryptoKey } from './is_key_like.js';
 async function cbcEncrypt(enc, plaintext, cek, iv, aad) {
@@ -17,7 +17,7 @@ async function cbcEncrypt(enc, plaintext, cek, iv, aad) {
         name: 'HMAC',
     }, false, ['sign']);
     const ciphertext = new Uint8Array(await crypto.subtle.encrypt({
-        iv,
+        iv: iv,
         name: 'AES-CBC',
     }, encKey, plaintext));
     const macData = concat(aad, iv, ciphertext, uint64be(aad.length << 3));
@@ -35,7 +35,7 @@ async function gcmEncrypt(enc, plaintext, cek, iv, aad) {
     }
     const encrypted = new Uint8Array(await crypto.subtle.encrypt({
         additionalData: aad,
-        iv,
+        iv: iv,
         name: 'AES-GCM',
         tagLength: 128,
     }, encKey, plaintext));
@@ -43,7 +43,7 @@ async function gcmEncrypt(enc, plaintext, cek, iv, aad) {
     const ciphertext = encrypted.slice(0, -16);
     return { ciphertext, tag, iv };
 }
-export default async (enc, plaintext, cek, iv, aad) => {
+export async function encrypt(enc, plaintext, cek, iv, aad) {
     if (!isCryptoKey(cek) && !(cek instanceof Uint8Array)) {
         throw new TypeError(invalidKeyInput(cek, 'CryptoKey', 'KeyObject', 'Uint8Array', 'JSON Web Key'));
     }
@@ -71,4 +71,4 @@ export default async (enc, plaintext, cek, iv, aad) => {
         default:
             throw new JOSENotSupported('Unsupported JWE Content Encryption Algorithm');
     }
-};
+}

package/dist/webapi/lib/encrypt_key_management.js

@@ -3,13 +3,13 @@ import * as ecdhes from './ecdhes.js';
 import * as pbes2kw from './pbes2kw.js';
 import * as rsaes from './rsaes.js';
 import { encode as b64u } from '../util/base64url.js';
-import normalizeKey from './normalize_key.js';
-import generateCek, { bitLength as cekLength } from '../lib/cek.js';
+import { normalizeKey } from './normalize_key.js';
+import { generateCek, cekLength } from '../lib/cek.js';
 import { JOSENotSupported } from '../util/errors.js';
 import { exportJWK } from '../key/export.js';
 import { wrap as aesGcmKw } from './aesgcmkw.js';
 import { assertCryptoKey } from './is_key_like.js';
-export default async (alg, enc, key, providedCek, providedParameters = {}) => {
+export async function encryptKeyManagement(alg, enc, key, providedCek, providedParameters = {}) {
     let encryptedKey;
     let parameters;
     let cek;
@@ -89,4 +89,4 @@ export default async (alg, enc, key, providedCek, providedParameters = {}) => {
         }
     }
     return { cek, encryptedKey, parameters };
-};
+}

package/dist/webapi/lib/get_sign_verify_key.js

@@ -1,6 +1,6 @@
 import { checkSigCryptoKey } from './crypto_key.js';
-import invalidKeyInput from './invalid_key_input.js';
-export default async (alg, key, usage) => {
+import { invalidKeyInput } from './invalid_key_input.js';
+export async function getSigKey(alg, key, usage) {
     if (key instanceof Uint8Array) {
         if (!alg.startsWith('HS')) {
             throw new TypeError(invalidKeyInput(key, 'CryptoKey', 'KeyObject', 'JSON Web Key'));
@@ -9,4 +9,4 @@ export default async (alg, key, usage) => {
     }
     checkSigCryptoKey(key, alg, usage);
     return key;
-};
+}

package/dist/webapi/lib/invalid_key_input.js

@@ -23,9 +23,5 @@ function message(msg, actual, ...types) {
     }
     return msg;
 }
-export default (actual, ...types) => {
-    return message('Key must be ', actual, ...types);
-};
-export function withAlg(alg, actual, ...types) {
-    return message(`Key for the ${alg} algorithm must be `, actual, ...types);
-}
+export const invalidKeyInput = (actual, ...types) => message('Key must be ', actual, ...types);
+export const withAlg = (alg, actual, ...types) => message(`Key for the ${alg} algorithm must be `, actual, ...types);

package/dist/webapi/lib/is_disjoint.js

@@ -1,4 +1,4 @@
-export default (...headers) => {
+export function isDisjoint(...headers) {
     const sources = headers.filter(Boolean);
     if (sources.length === 0 || sources.length === 1) {
         return true;
@@ -18,4 +18,4 @@ export default (...headers) => {
         }
     }
     return true;
-};
+}

package/dist/webapi/lib/is_jwk.js

@@ -1,14 +1,6 @@
-import isObject from './is_object.js';
-export function isJWK(key) {
-    return isObject(key) && typeof key.kty === 'string';
-}
-export function isPrivateJWK(key) {
-    return (key.kty !== 'oct' &&
-        ((key.kty === 'AKP' && typeof key.priv === 'string') || typeof key.d === 'string'));
-}
-export function isPublicJWK(key) {
-    return key.kty !== 'oct' && typeof key.d === 'undefined' && typeof key.priv === 'undefined';
-}
-export function isSecretJWK(key) {
-    return key.kty === 'oct' && typeof key.k === 'string';
-}
+import { isObject } from './is_object.js';
+export const isJWK = (key) => isObject(key) && typeof key.kty === 'string';
+export const isPrivateJWK = (key) => key.kty !== 'oct' &&
+    ((key.kty === 'AKP' && typeof key.priv === 'string') || typeof key.d === 'string');
+export const isPublicJWK = (key) => key.kty !== 'oct' && key.d === undefined && key.priv === undefined;
+export const isSecretJWK = (key) => key.kty === 'oct' && typeof key.k === 'string';

package/dist/webapi/lib/is_key_like.js

@@ -3,12 +3,6 @@ export function assertCryptoKey(key) {
         throw new Error('CryptoKey instance expected');
     }
 }
-export function isCryptoKey(key) {
-    return key?.[Symbol.toStringTag] === 'CryptoKey';
-}
-export function isKeyObject(key) {
-    return key?.[Symbol.toStringTag] === 'KeyObject';
-}
-export default (key) => {
-    return isCryptoKey(key) || isKeyObject(key);
-};
+export const isCryptoKey = (key) => key?.[Symbol.toStringTag] === 'CryptoKey';
+export const isKeyObject = (key) => key?.[Symbol.toStringTag] === 'KeyObject';
+export const isKeyLike = (key) => isCryptoKey(key) || isKeyObject(key);

package/dist/webapi/lib/is_object.js

@@ -1,7 +1,5 @@
-function isObjectLike(value) {
-    return typeof value === 'object' && value !== null;
-}
-export default (input) => {
+const isObjectLike = (value) => typeof value === 'object' && value !== null;
+export function isObject(input) {
     if (!isObjectLike(input) || Object.prototype.toString.call(input) !== '[object Object]') {
         return false;
     }
@@ -13,4 +11,4 @@ export default (input) => {
         proto = Object.getPrototypeOf(proto);
     }
     return Object.getPrototypeOf(input) === proto;
-};
+}

package/dist/webapi/lib/iv.js

@@ -16,4 +16,4 @@ export function bitLength(alg) {
             throw new JOSENotSupported(`Unsupported JWE Algorithm: ${alg}`);
     }
 }
-export default (alg) => crypto.getRandomValues(new Uint8Array(bitLength(alg) >> 3));
+export const generateIv = (alg) => crypto.getRandomValues(new Uint8Array(bitLength(alg) >> 3));

package/dist/webapi/lib/jwk_to_key.js

@@ -95,7 +95,7 @@ function subtleMapping(jwk) {
     }
     return { algorithm, keyUsages };
 }
-export default async (jwk) => {
+export async function jwkToKey(jwk) {
     if (!jwk.alg) {
         throw new TypeError('"alg" argument is required when "jwk.alg" is not present');
     }
@@ -106,4 +106,4 @@ export default async (jwk) => {
     }
     delete keyData.use;
     return crypto.subtle.importKey('jwk', keyData, algorithm, jwk.ext ?? (jwk.d || jwk.priv ? false : true), jwk.key_ops ?? keyUsages);
-};
+}

package/dist/webapi/lib/jwt_claims_set.js

@@ -1,9 +1,62 @@
 import { JWTClaimValidationFailed, JWTExpired, JWTInvalid } from '../util/errors.js';
-import { decoder } from './buffer_utils.js';
-import epoch from './epoch.js';
-import secs from './secs.js';
-import isObject from './is_object.js';
-import { encoder } from './buffer_utils.js';
+import { encoder, decoder } from './buffer_utils.js';
+import { isObject } from './is_object.js';
+const epoch = (date) => Math.floor(date.getTime() / 1000);
+const minute = 60;
+const hour = minute * 60;
+const day = hour * 24;
+const week = day * 7;
+const year = day * 365.25;
+const REGEX = /^(\+|\-)? ?(\d+|\d+\.\d+) ?(seconds?|secs?|s|minutes?|mins?|m|hours?|hrs?|h|days?|d|weeks?|w|years?|yrs?|y)(?: (ago|from now))?$/i;
+export function secs(str) {
+    const matched = REGEX.exec(str);
+    if (!matched || (matched[4] && matched[1])) {
+        throw new TypeError('Invalid time period format');
+    }
+    const value = parseFloat(matched[2]);
+    const unit = matched[3].toLowerCase();
+    let numericDate;
+    switch (unit) {
+        case 'sec':
+        case 'secs':
+        case 'second':
+        case 'seconds':
+        case 's':
+            numericDate = Math.round(value);
+            break;
+        case 'minute':
+        case 'minutes':
+        case 'min':
+        case 'mins':
+        case 'm':
+            numericDate = Math.round(value * minute);
+            break;
+        case 'hour':
+        case 'hours':
+        case 'hr':
+        case 'hrs':
+        case 'h':
+            numericDate = Math.round(value * hour);
+            break;
+        case 'day':
+        case 'days':
+        case 'd':
+            numericDate = Math.round(value * day);
+            break;
+        case 'week':
+        case 'weeks':
+        case 'w':
+            numericDate = Math.round(value * week);
+            break;
+        default:
+            numericDate = Math.round(value * year);
+            break;
+    }
+    if (matched[1] === '-' || matched[4] === 'ago') {
+        return -numericDate;
+    }
+    return numericDate;
+}
 function validateInput(label, input) {
     if (!Number.isFinite(input)) {
         throw new TypeError(`Invalid ${label} input`);
@@ -169,7 +222,7 @@ export class JWTClaimsBuilder {
         }
     }
     set iat(value) {
-        if (typeof value === 'undefined') {
+        if (value === undefined) {
             this.#payload.iat = epoch(new Date());
         }
         else if (value instanceof Date) {

package/dist/webapi/lib/key_to_jwk.js

@@ -1,7 +1,7 @@
-import invalidKeyInput from './invalid_key_input.js';
+import { invalidKeyInput } from './invalid_key_input.js';
 import { encode as b64u } from '../util/base64url.js';
 import { isCryptoKey, isKeyObject } from './is_key_like.js';
-export default async function keyToJWK(key) {
+export async function keyToJWK(key) {
     if (isKeyObject(key)) {
         if (key.type === 'secret') {
             key = key.export();

package/dist/webapi/lib/normalize_key.js

@@ -1,6 +1,6 @@
 import { isJWK } from './is_jwk.js';
 import { decode } from '../util/base64url.js';
-import importJWK from './jwk_to_key.js';
+import { jwkToKey } from './jwk_to_key.js';
 import { isCryptoKey, isKeyObject } from './is_key_like.js';
 let cache;
 const handleJWK = async (key, jwk, alg, freeze = false) => {
@@ -9,7 +9,7 @@ const handleJWK = async (key, jwk, alg, freeze = false) => {
     if (cached?.[alg]) {
         return cached[alg];
     }
-    const cryptoKey = await importJWK({ ...jwk, alg });
+    const cryptoKey = await jwkToKey({ ...jwk, alg });
     if (freeze)
         Object.freeze(key);
     if (!cached) {
@@ -142,7 +142,7 @@ const handleKeyObject = (keyObject, alg) => {
     }
     return cryptoKey;
 };
-export default async (key, alg) => {
+export async function normalizeKey(key, alg) {
     if (key instanceof Uint8Array) {
         return key;
     }
@@ -173,4 +173,4 @@ export default async (key, alg) => {
         return handleJWK(key, key, alg, true);
     }
     throw new Error('unreachable');
-};
+}

package/dist/webapi/lib/pbes2kw.js

@@ -1,16 +1,18 @@
 import { encode as b64u } from '../util/base64url.js';
 import * as aeskw from './aeskw.js';
 import { checkEncCryptoKey } from './crypto_key.js';
-import { concat, encoder } from './buffer_utils.js';
+import { concat, encode } from './buffer_utils.js';
 import { JWEInvalid } from '../util/errors.js';
 function getCryptoKey(key, alg) {
     if (key instanceof Uint8Array) {
-        return crypto.subtle.importKey('raw', key, 'PBKDF2', false, ['deriveBits']);
+        return crypto.subtle.importKey('raw', key, 'PBKDF2', false, [
+            'deriveBits',
+        ]);
     }
     checkEncCryptoKey(key, alg, 'deriveBits');
     return key;
 }
-const concatSalt = (alg, p2sInput) => concat(encoder.encode(alg), new Uint8Array([0]), p2sInput);
+const concatSalt = (alg, p2sInput) => concat(encode(alg), Uint8Array.of(0x00), p2sInput);
 async function deriveKey(p2s, alg, p2c, key) {
     if (!(p2s instanceof Uint8Array) || p2s.length < 8) {
         throw new JWEInvalid('PBES2 Salt Input must be 8 or more octets');

package/dist/webapi/lib/rsaes.js

@@ -1,5 +1,5 @@
 import { checkEncCryptoKey } from './crypto_key.js';
-import checkKeyLength from './check_key_length.js';
+import { checkKeyLength } from './check_key_length.js';
 import { JOSENotSupported } from '../util/errors.js';
 const subtleAlgorithm = (alg) => {
     switch (alg) {

package/dist/webapi/lib/sign.js

@@ -1,9 +1,9 @@
-import subtleAlgorithm from './subtle_dsa.js';
-import checkKeyLength from './check_key_length.js';
-import getSignKey from './get_sign_verify_key.js';
-export default async (alg, key, data) => {
-    const cryptoKey = await getSignKey(alg, key, 'sign');
+import { subtleAlgorithm } from './subtle_dsa.js';
+import { checkKeyLength } from './check_key_length.js';
+import { getSigKey } from './get_sign_verify_key.js';
+export async function sign(alg, key, data) {
+    const cryptoKey = await getSigKey(alg, key, 'sign');
     checkKeyLength(alg, cryptoKey);
     const signature = await crypto.subtle.sign(subtleAlgorithm(alg, cryptoKey.algorithm), cryptoKey, data);
     return new Uint8Array(signature);
-};
+}

package/dist/webapi/lib/subtle_dsa.js

@@ -1,5 +1,5 @@
 import { JOSENotSupported } from '../util/errors.js';
-export default (alg, algorithm) => {
+export function subtleAlgorithm(alg, algorithm) {
     const hash = `SHA-${alg.slice(-3)}`;
     switch (alg) {
         case 'HS256':
@@ -28,4 +28,4 @@ export default (alg, algorithm) => {
         default:
             throw new JOSENotSupported(`alg ${alg} is not supported either by JOSE or your javascript runtime`);
     }
-};
+}

package/dist/webapi/lib/validate_algorithms.js

@@ -1,4 +1,4 @@
-export default (option, algorithms) => {
+export function validateAlgorithms(option, algorithms) {
     if (algorithms !== undefined &&
         (!Array.isArray(algorithms) || algorithms.some((s) => typeof s !== 'string'))) {
         throw new TypeError(`"${option}" option must be an array of strings`);
@@ -7,4 +7,4 @@ export default (option, algorithms) => {
         return undefined;
     }
     return new Set(algorithms);
-};
+}

package/dist/webapi/lib/validate_crit.js

@@ -1,5 +1,5 @@
 import { JOSENotSupported, JWEInvalid, JWSInvalid } from '../util/errors.js';
-export default (Err, recognizedDefault, recognizedOption, protectedHeader, joseHeader) => {
+export function validateCrit(Err, recognizedDefault, recognizedOption, protectedHeader, joseHeader) {
     if (joseHeader.crit !== undefined && protectedHeader?.crit === undefined) {
         throw new Err('"crit" (Critical) Header Parameter MUST be integrity protected');
     }
@@ -30,4 +30,4 @@ export default (Err, recognizedDefault, recognizedOption, protectedHeader, joseH
         }
     }
     return new Set(protectedHeader.crit);
-};
+}

package/dist/webapi/lib/verify.js

@@ -1,8 +1,8 @@
-import subtleAlgorithm from './subtle_dsa.js';
-import checkKeyLength from './check_key_length.js';
-import getVerifyKey from './get_sign_verify_key.js';
-export default async (alg, key, signature, data) => {
-    const cryptoKey = await getVerifyKey(alg, key, 'verify');
+import { subtleAlgorithm } from './subtle_dsa.js';
+import { checkKeyLength } from './check_key_length.js';
+import { getSigKey } from './get_sign_verify_key.js';
+export async function verify(alg, key, signature, data) {
+    const cryptoKey = await getSigKey(alg, key, 'verify');
     checkKeyLength(alg, cryptoKey);
     const algorithm = subtleAlgorithm(alg, cryptoKey.algorithm);
     try {
@@ -11,4 +11,4 @@ export default async (alg, key, signature, data) => {
     catch {
         return false;
     }
-};
+}

package/dist/webapi/util/base64url.js

@@ -10,7 +10,7 @@ export function decode(input) {
     if (encoded instanceof Uint8Array) {
         encoded = decoder.decode(encoded);
     }
-    encoded = encoded.replace(/-/g, '+').replace(/_/g, '/').replace(/\s/g, '');
+    encoded = encoded.replace(/-/g, '+').replace(/_/g, '/');
     try {
         return decodeBase64(encoded);
     }