jose 5.9.6 → 6.0.0

package/dist/{browser/runtime → webapi/lib}/encrypt.js

@@ -1,12 +1,11 @@
-import { concat, uint64be } from '../lib/buffer_utils.js';
-import checkIvLength from '../lib/check_iv_length.js';
+import { concat, uint64be } from './buffer_utils.js';
+import checkIvLength from './check_iv_length.js';
 import checkCekLength from './check_cek_length.js';
-import crypto, { isCryptoKey } from './webcrypto.js';
-import { checkEncCryptoKey } from '../lib/crypto_key.js';
-import invalidKeyInput from '../lib/invalid_key_input.js';
-import generateIv from '../lib/iv.js';
+import { checkEncCryptoKey } from './crypto_key.js';
+import invalidKeyInput from './invalid_key_input.js';
+import generateIv from './iv.js';
 import { JOSENotSupported } from '../util/errors.js';
-import { types } from './is_key_like.js';
+import { isCryptoKey } from './is_key_like.js';
 async function cbcEncrypt(enc, plaintext, cek, iv, aad) {
     if (!(cek instanceof Uint8Array)) {
         throw new TypeError(invalidKeyInput(cek, 'Uint8Array'));
@@ -44,9 +43,9 @@ async function gcmEncrypt(enc, plaintext, cek, iv, aad) {
     const ciphertext = encrypted.slice(0, -16);
     return { ciphertext, tag, iv };
 }
-const encrypt = async (enc, plaintext, cek, iv, aad) => {
+export default async (enc, plaintext, cek, iv, aad) => {
     if (!isCryptoKey(cek) && !(cek instanceof Uint8Array)) {
-        throw new TypeError(invalidKeyInput(cek, ...types, 'Uint8Array'));
+        throw new TypeError(invalidKeyInput(cek, 'CryptoKey', 'KeyObject', 'Uint8Array', 'JSON Web Key'));
     }
     if (iv) {
         checkIvLength(enc, iv);
@@ -73,4 +72,3 @@ const encrypt = async (enc, plaintext, cek, iv, aad) => {
             throw new JOSENotSupported('Unsupported JWE Content Encryption Algorithm');
     }
 };
-export default encrypt;

package/dist/{node/esm → webapi}/lib/encrypt_key_management.js

@@ -1,20 +1,18 @@
-import { wrap as aesKw } from '../runtime/aeskw.js';
-import * as ECDH from '../runtime/ecdhes.js';
-import { encrypt as pbes2Kw } from '../runtime/pbes2kw.js';
-import { encrypt as rsaEs } from '../runtime/rsaes.js';
-import { encode as base64url } from '../runtime/base64url.js';
-import normalize from '../runtime/normalize_key.js';
+import * as aeskw from './aeskw.js';
+import * as ecdhes from './ecdhes.js';
+import * as pbes2kw from './pbes2kw.js';
+import * as rsaes from './rsaes.js';
+import * as base64url from '../lib/base64url.js';
+import normalizeKey from './normalize_key.js';
 import generateCek, { bitLength as cekLength } from '../lib/cek.js';
 import { JOSENotSupported } from '../util/errors.js';
 import { exportJWK } from '../key/export.js';
-import checkKeyType from './check_key_type.js';
 import { wrap as aesGcmKw } from './aesgcmkw.js';
-async function encryptKeyManagement(alg, enc, key, providedCek, providedParameters = {}) {
+import { assertCryptoKey } from './is_key_like.js';
+export default async (alg, enc, key, providedCek, providedParameters = {}) => {
     let encryptedKey;
     let parameters;
     let cek;
-    checkKeyType(alg, key, 'encrypt');
-    key = (await normalize.normalizePublicKey?.(key, alg)) || key;
     switch (alg) {
         case 'dir': {
             cek = key;
@@ -24,37 +22,43 @@ async function encryptKeyManagement(alg, enc, key, providedCek, providedParamete
         case 'ECDH-ES+A128KW':
         case 'ECDH-ES+A192KW':
         case 'ECDH-ES+A256KW': {
-            if (!ECDH.ecdhAllowed(key)) {
+            assertCryptoKey(key);
+            if (!ecdhes.allowed(key)) {
                 throw new JOSENotSupported('ECDH with the provided key is not allowed or not supported by your javascript runtime');
             }
             const { apu, apv } = providedParameters;
-            let { epk: ephemeralKey } = providedParameters;
-            ephemeralKey ||= (await ECDH.generateEpk(key)).privateKey;
+            let ephemeralKey;
+            if (providedParameters.epk) {
+                ephemeralKey = (await normalizeKey(providedParameters.epk, alg));
+            }
+            else {
+                ephemeralKey = (await crypto.subtle.generateKey(key.algorithm, true, ['deriveBits'])).privateKey;
+            }
             const { x, y, crv, kty } = await exportJWK(ephemeralKey);
-            const sharedSecret = await ECDH.deriveKey(key, ephemeralKey, alg === 'ECDH-ES' ? enc : alg, alg === 'ECDH-ES' ? cekLength(enc) : parseInt(alg.slice(-5, -2), 10), apu, apv);
+            const sharedSecret = await ecdhes.deriveKey(key, ephemeralKey, alg === 'ECDH-ES' ? enc : alg, alg === 'ECDH-ES' ? cekLength(enc) : parseInt(alg.slice(-5, -2), 10), apu, apv);
             parameters = { epk: { x, crv, kty } };
             if (kty === 'EC')
                 parameters.epk.y = y;
             if (apu)
-                parameters.apu = base64url(apu);
+                parameters.apu = base64url.encode(apu);
             if (apv)
-                parameters.apv = base64url(apv);
+                parameters.apv = base64url.encode(apv);
             if (alg === 'ECDH-ES') {
                 cek = sharedSecret;
                 break;
             }
             cek = providedCek || generateCek(enc);
             const kwAlg = alg.slice(-6);
-            encryptedKey = await aesKw(kwAlg, sharedSecret, cek);
+            encryptedKey = await aeskw.wrap(kwAlg, sharedSecret, cek);
             break;
         }
-        case 'RSA1_5':
         case 'RSA-OAEP':
         case 'RSA-OAEP-256':
         case 'RSA-OAEP-384':
         case 'RSA-OAEP-512': {
             cek = providedCek || generateCek(enc);
-            encryptedKey = await rsaEs(alg, key, cek);
+            assertCryptoKey(key);
+            encryptedKey = await rsaes.encrypt(alg, key, cek);
             break;
         }
         case 'PBES2-HS256+A128KW':
@@ -62,14 +66,14 @@ async function encryptKeyManagement(alg, enc, key, providedCek, providedParamete
         case 'PBES2-HS512+A256KW': {
             cek = providedCek || generateCek(enc);
             const { p2c, p2s } = providedParameters;
-            ({ encryptedKey, ...parameters } = await pbes2Kw(alg, key, cek, p2c, p2s));
+            ({ encryptedKey, ...parameters } = await pbes2kw.wrap(alg, key, cek, p2c, p2s));
             break;
         }
         case 'A128KW':
         case 'A192KW':
         case 'A256KW': {
             cek = providedCek || generateCek(enc);
-            encryptedKey = await aesKw(alg, key, cek);
+            encryptedKey = await aeskw.wrap(alg, key, cek);
             break;
         }
         case 'A128GCMKW':
@@ -85,5 +89,4 @@ async function encryptKeyManagement(alg, enc, key, providedCek, providedParamete
         }
     }
     return { cek, encryptedKey, parameters };
-}
-export default encryptKeyManagement;
+};

package/dist/webapi/lib/get_sign_verify_key.js

@@ -0,0 +1,12 @@
+import { checkSigCryptoKey } from './crypto_key.js';
+import invalidKeyInput from './invalid_key_input.js';
+export default async (alg, key, usage) => {
+    if (key instanceof Uint8Array) {
+        if (!alg.startsWith('HS')) {
+            throw new TypeError(invalidKeyInput(key, 'CryptoKey', 'KeyObject', 'JSON Web Key'));
+        }
+        return crypto.subtle.importKey('raw', key, { hash: `SHA-${alg.slice(-3)}`, name: 'HMAC' }, false, [usage]);
+    }
+    checkSigCryptoKey(key, alg, usage);
+    return key;
+};

package/dist/{node/esm → webapi}/lib/is_disjoint.js

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

package/dist/{browser → webapi}/lib/is_jwk.js

@@ -9,5 +9,5 @@ export function isPublicJWK(key) {
     return key.kty !== 'oct' && typeof key.d === 'undefined';
 }
 export function isSecretJWK(key) {
-    return isJWK(key) && key.kty === 'oct' && typeof key.k === 'string';
+    return key.kty === 'oct' && typeof key.k === 'string';
 }

package/dist/webapi/lib/is_key_like.js

@@ -0,0 +1,14 @@
+export function assertCryptoKey(key) {
+    if (!isCryptoKey(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);
+};

package/dist/{browser → webapi}/lib/is_object.js

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

package/dist/{node/esm → webapi}/lib/iv.js

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

package/dist/{browser/runtime → webapi/lib}/jwk_to_key.js

@@ -1,4 +1,3 @@
-import crypto from './webcrypto.js';
 import { JOSENotSupported } from '../util/errors.js';
 function subtleMapping(jwk) {
     let algorithm;
@@ -61,8 +60,9 @@ function subtleMapping(jwk) {
         }
         case 'OKP': {
             switch (jwk.alg) {
+                case 'Ed25519':
                 case 'EdDSA':
-                    algorithm = { name: jwk.crv };
+                    algorithm = { name: 'Ed25519' };
                     keyUsages = jwk.d ? ['sign'] : ['verify'];
                     break;
                 case 'ECDH-ES':
@@ -82,19 +82,13 @@ function subtleMapping(jwk) {
     }
     return { algorithm, keyUsages };
 }
-const parse = async (jwk) => {
+export default async (jwk) => {
     if (!jwk.alg) {
         throw new TypeError('"alg" argument is required when "jwk.alg" is not present');
     }
     const { algorithm, keyUsages } = subtleMapping(jwk);
-    const rest = [
-        algorithm,
-        jwk.ext ?? false,
-        jwk.key_ops ?? keyUsages,
-    ];
     const keyData = { ...jwk };
     delete keyData.alg;
     delete keyData.use;
-    return crypto.subtle.importKey('jwk', keyData, ...rest);
+    return crypto.subtle.importKey('jwk', keyData, algorithm, jwk.ext ?? (jwk.d ? false : true), jwk.key_ops ?? keyUsages);
 };
-export default parse;

package/dist/webapi/lib/key_to_jwk.js

@@ -0,0 +1,27 @@
+import invalidKeyInput from './invalid_key_input.js';
+import { encode as base64url } from './base64url.js';
+import { isCryptoKey, isKeyObject } from './is_key_like.js';
+export default async function keyToJWK(key) {
+    if (isKeyObject(key)) {
+        if (key.type === 'secret') {
+            key = key.export();
+        }
+        else {
+            return key.export({ format: 'jwk' });
+        }
+    }
+    if (key instanceof Uint8Array) {
+        return {
+            kty: 'oct',
+            k: base64url(key),
+        };
+    }
+    if (!isCryptoKey(key)) {
+        throw new TypeError(invalidKeyInput(key, 'CryptoKey', 'KeyObject', 'Uint8Array'));
+    }
+    if (!key.extractable) {
+        throw new TypeError('non-extractable CryptoKey cannot be exported as a JWK');
+    }
+    const { ext, key_ops, alg, use, ...jwk } = await crypto.subtle.exportKey('jwk', key);
+    return jwk;
+}

package/dist/webapi/lib/normalize_key.js

@@ -0,0 +1,164 @@
+import { isJWK } from './is_jwk.js';
+import { decode } from './base64url.js';
+import importJWK from './jwk_to_key.js';
+import { isCryptoKey, isKeyObject } from './is_key_like.js';
+let cache;
+const handleJWK = async (key, jwk, alg, freeze = false) => {
+    cache ||= new WeakMap();
+    let cached = cache.get(key);
+    if (cached?.[alg]) {
+        return cached[alg];
+    }
+    const cryptoKey = await importJWK({ ...jwk, alg });
+    if (freeze)
+        Object.freeze(key);
+    if (!cached) {
+        cache.set(key, { [alg]: cryptoKey });
+    }
+    else {
+        cached[alg] = cryptoKey;
+    }
+    return cryptoKey;
+};
+const handleKeyObject = (keyObject, alg) => {
+    cache ||= new WeakMap();
+    let cached = cache.get(keyObject);
+    if (cached?.[alg]) {
+        return cached[alg];
+    }
+    const isPublic = keyObject.type === 'public';
+    const extractable = isPublic ? true : false;
+    let cryptoKey;
+    if (keyObject.asymmetricKeyType === 'x25519') {
+        switch (alg) {
+            case 'ECDH-ES':
+            case 'ECDH-ES+A128KW':
+            case 'ECDH-ES+A192KW':
+            case 'ECDH-ES+A256KW':
+                break;
+            default:
+                throw new TypeError('given KeyObject instance cannot be used for this algorithm');
+        }
+        cryptoKey = keyObject.toCryptoKey(keyObject.asymmetricKeyType, extractable, isPublic ? [] : ['deriveBits']);
+    }
+    if (keyObject.asymmetricKeyType === 'ed25519') {
+        if (alg !== 'EdDSA' && alg !== 'Ed25519') {
+            throw new TypeError('given KeyObject instance cannot be used for this algorithm');
+        }
+        cryptoKey = keyObject.toCryptoKey(keyObject.asymmetricKeyType, extractable, [
+            isPublic ? 'verify' : 'sign',
+        ]);
+    }
+    if (keyObject.asymmetricKeyType === 'rsa') {
+        let hash;
+        switch (alg) {
+            case 'RSA-OAEP':
+                hash = 'SHA-1';
+                break;
+            case 'RS256':
+            case 'PS256':
+            case 'RSA-OAEP-256':
+                hash = 'SHA-256';
+                break;
+            case 'RS384':
+            case 'PS384':
+            case 'RSA-OAEP-384':
+                hash = 'SHA-384';
+                break;
+            case 'RS512':
+            case 'PS512':
+            case 'RSA-OAEP-512':
+                hash = 'SHA-512';
+                break;
+            default:
+                throw new TypeError('given KeyObject instance cannot be used for this algorithm');
+        }
+        if (alg.startsWith('RSA-OAEP')) {
+            return keyObject.toCryptoKey({
+                name: 'RSA-OAEP',
+                hash,
+            }, extractable, isPublic ? ['encrypt'] : ['decrypt']);
+        }
+        cryptoKey = keyObject.toCryptoKey({
+            name: alg.startsWith('PS') ? 'RSA-PSS' : 'RSASSA-PKCS1-v1_5',
+            hash,
+        }, extractable, [isPublic ? 'verify' : 'sign']);
+    }
+    if (keyObject.asymmetricKeyType === 'ec') {
+        const nist = new Map([
+            ['prime256v1', 'P-256'],
+            ['secp384r1', 'P-384'],
+            ['secp521r1', 'P-521'],
+        ]);
+        const namedCurve = nist.get(keyObject.asymmetricKeyDetails?.namedCurve);
+        if (!namedCurve) {
+            throw new TypeError('given KeyObject instance cannot be used for this algorithm');
+        }
+        if (alg === 'ES256' && namedCurve === 'P-256') {
+            cryptoKey = keyObject.toCryptoKey({
+                name: 'ECDSA',
+                namedCurve,
+            }, extractable, [isPublic ? 'verify' : 'sign']);
+        }
+        if (alg === 'ES384' && namedCurve === 'P-384') {
+            cryptoKey = keyObject.toCryptoKey({
+                name: 'ECDSA',
+                namedCurve,
+            }, extractable, [isPublic ? 'verify' : 'sign']);
+        }
+        if (alg === 'ES512' && namedCurve === 'P-521') {
+            cryptoKey = keyObject.toCryptoKey({
+                name: 'ECDSA',
+                namedCurve,
+            }, extractable, [isPublic ? 'verify' : 'sign']);
+        }
+        if (alg.startsWith('ECDH-ES')) {
+            cryptoKey = keyObject.toCryptoKey({
+                name: 'ECDH',
+                namedCurve,
+            }, extractable, isPublic ? [] : ['deriveBits']);
+        }
+    }
+    if (!cryptoKey) {
+        throw new TypeError('given KeyObject instance cannot be used for this algorithm');
+    }
+    if (!cached) {
+        cache.set(keyObject, { [alg]: cryptoKey });
+    }
+    else {
+        cached[alg] = cryptoKey;
+    }
+    return cryptoKey;
+};
+export default async (key, alg) => {
+    if (key instanceof Uint8Array) {
+        return key;
+    }
+    if (isCryptoKey(key)) {
+        return key;
+    }
+    if (isKeyObject(key)) {
+        if (key.type === 'secret') {
+            return key.export();
+        }
+        if ('toCryptoKey' in key && typeof key.toCryptoKey === 'function') {
+            try {
+                return handleKeyObject(key, alg);
+            }
+            catch (err) {
+                if (err instanceof TypeError) {
+                    throw err;
+                }
+            }
+        }
+        let jwk = key.export({ format: 'jwk' });
+        return handleJWK(key, jwk, alg);
+    }
+    if (isJWK(key)) {
+        if (key.k) {
+            return decode(key.k);
+        }
+        return handleJWK(key, key, alg, true);
+    }
+    throw new Error('unreachable');
+};

package/dist/webapi/lib/pbes2kw.js

@@ -0,0 +1,37 @@
+import { encode as base64url } from './base64url.js';
+import * as aeskw from './aeskw.js';
+import { checkEncCryptoKey } from './crypto_key.js';
+import { concat, encoder } 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']);
+    }
+    checkEncCryptoKey(key, alg, 'deriveBits');
+    return key;
+}
+const concatSalt = (alg, p2sInput) => concat(encoder.encode(alg), new Uint8Array([0]), 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');
+    }
+    const salt = concatSalt(alg, p2s);
+    const keylen = parseInt(alg.slice(13, 16), 10);
+    const subtleAlg = {
+        hash: `SHA-${alg.slice(8, 11)}`,
+        iterations: p2c,
+        name: 'PBKDF2',
+        salt,
+    };
+    const cryptoKey = await getCryptoKey(key, alg);
+    return new Uint8Array(await crypto.subtle.deriveBits(subtleAlg, cryptoKey, keylen));
+}
+export async function wrap(alg, key, cek, p2c = 2048, p2s = crypto.getRandomValues(new Uint8Array(16))) {
+    const derived = await deriveKey(p2s, alg, p2c, key);
+    const encryptedKey = await aeskw.wrap(alg.slice(-6), derived, cek);
+    return { encryptedKey, p2c, p2s: base64url(p2s) };
+}
+export async function unwrap(alg, key, encryptedKey, p2c, p2s) {
+    const derived = await deriveKey(p2s, alg, p2c, key);
+    return aeskw.unwrap(alg.slice(-6), derived, encryptedKey);
+}

package/dist/webapi/lib/rsaes.js

@@ -0,0 +1,24 @@
+import { checkEncCryptoKey } from './crypto_key.js';
+import checkKeyLength from './check_key_length.js';
+import { JOSENotSupported } from '../util/errors.js';
+const subtleAlgorithm = (alg) => {
+    switch (alg) {
+        case 'RSA-OAEP':
+        case 'RSA-OAEP-256':
+        case 'RSA-OAEP-384':
+        case 'RSA-OAEP-512':
+            return 'RSA-OAEP';
+        default:
+            throw new JOSENotSupported(`alg ${alg} is not supported either by JOSE or your javascript runtime`);
+    }
+};
+export async function encrypt(alg, key, cek) {
+    checkEncCryptoKey(key, alg, 'encrypt');
+    checkKeyLength(alg, key);
+    return new Uint8Array(await crypto.subtle.encrypt(subtleAlgorithm(alg), key, cek));
+}
+export async function decrypt(alg, key, encryptedKey) {
+    checkEncCryptoKey(key, alg, 'decrypt');
+    checkKeyLength(alg, key);
+    return new Uint8Array(await crypto.subtle.decrypt(subtleAlgorithm(alg), key, encryptedKey));
+}

package/dist/{browser/runtime → webapi/lib}/sign.js

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

package/dist/{browser/runtime → webapi/lib}/subtle_dsa.js

@@ -1,5 +1,5 @@
 import { JOSENotSupported } from '../util/errors.js';
-export default function subtleDsa(alg, algorithm) {
+export default (alg, algorithm) => {
     const hash = `SHA-${alg.slice(-3)}`;
     switch (alg) {
         case 'HS256':
@@ -9,7 +9,7 @@ export default function subtleDsa(alg, algorithm) {
         case 'PS256':
         case 'PS384':
         case 'PS512':
-            return { hash, name: 'RSA-PSS', saltLength: alg.slice(-3) >> 3 };
+            return { hash, name: 'RSA-PSS', saltLength: parseInt(alg.slice(-3), 10) >> 3 };
         case 'RS256':
         case 'RS384':
         case 'RS512':
@@ -18,9 +18,10 @@ export default function subtleDsa(alg, algorithm) {
         case 'ES384':
         case 'ES512':
             return { hash, name: 'ECDSA', namedCurve: algorithm.namedCurve };
+        case 'Ed25519':
         case 'EdDSA':
-            return { name: algorithm.name };
+            return { name: 'Ed25519' };
         default:
             throw new JOSENotSupported(`alg ${alg} is not supported either by JOSE or your javascript runtime`);
     }
-}
+};

package/dist/{browser → webapi}/lib/validate_algorithms.js

@@ -1,4 +1,4 @@
-const validateAlgorithms = (option, algorithms) => {
+export default (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`);
@@ -8,4 +8,3 @@ const validateAlgorithms = (option, algorithms) => {
     }
     return new Set(algorithms);
 };
-export default validateAlgorithms;

package/dist/{node/esm → webapi}/lib/validate_crit.js

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

package/dist/{browser/runtime → webapi/lib}/verify.js

@@ -1,8 +1,7 @@
 import subtleAlgorithm from './subtle_dsa.js';
-import crypto from './webcrypto.js';
 import checkKeyLength from './check_key_length.js';
 import getVerifyKey from './get_sign_verify_key.js';
-const verify = async (alg, key, signature, data) => {
+export default async (alg, key, signature, data) => {
     const cryptoKey = await getVerifyKey(alg, key, 'verify');
     checkKeyLength(alg, cryptoKey);
     const algorithm = subtleAlgorithm(alg, cryptoKey.algorithm);
@@ -13,4 +12,3 @@ const verify = async (alg, key, signature, data) => {
         return false;
     }
 };
-export default verify;

package/dist/{node/esm → webapi}/util/base64url.js

@@ -1,3 +1,3 @@
-import * as base64url from '../runtime/base64url.js';
+import * as base64url from '../lib/base64url.js';
 export const encode = base64url.encode;
 export const decode = base64url.decode;