jose 6.2.6 → 6.2.8

package/dist/webapi/lib/key_management.js

@@ -6,75 +6,38 @@ import { JOSENotSupported, JWEInvalid } from '../util/errors.js';
 import { decodeBase64url, digest } from './helpers.js';
 import { generateCek, encrypt, decrypt } from './content_encryption.js';
 import { isObject } from './type_checks.js';
-import { checkCryptoKey, checkUsage } from './crypto_key.js';
-import { checkModulusLength } from './signing.js';
+import { checkCryptoKey, checkModulusLength, checkUsage } from './crypto_key.js';
 import { concat, encode, uint32be } from './buffer_utils.js';
 import { assertCryptoKey } from './is_key_like.js';
 function checkEcdhCryptoKey(key, usage) {
-    switch (key.algorithm.name) {
-        case 'ECDH':
-        case 'X25519':
-            break;
-        default:
-            throw new TypeError('CryptoKey does not support this operation, its algorithm.name must be ECDH or X25519');
+    if (key.algorithm.name !== 'ECDH' && key.algorithm.name !== 'X25519') {
+        throw new TypeError('CryptoKey does not support this operation, its algorithm.name must be ECDH or X25519');
     }
     checkUsage(key, usage);
 }
-function checkKeySize(key, alg) {
-    if (key.algorithm.length !== parseInt(alg.slice(1, 4), 10)) {
-        throw new TypeError(`Invalid key size for alg: ${alg}`);
-    }
-}
-function aeskwCryptoKey(key, alg, usage) {
-    if (key instanceof Uint8Array) {
-        return crypto.subtle.importKey('raw', key, 'AES-KW', true, [usage]);
-    }
-    checkCryptoKey(key, jweAlgorithm(alg).subtle, usage);
-    return key;
+async function aeskwCryptoKey(key, alg, usage) {
+    const expected = jweAlgorithm(alg).subtle;
+    const cryptoKey = key instanceof Uint8Array
+        ? await crypto.subtle.importKey('raw', key, 'AES-KW', true, [
+            usage,
+        ])
+        : key;
+    checkCryptoKey(cryptoKey, expected, usage);
+    return cryptoKey;
 }
 async function aeskwWrap(alg, key, cek) {
     const cryptoKey = await aeskwCryptoKey(key, alg, 'wrapKey');
-    checkKeySize(cryptoKey, alg);
     const cryptoKeyCek = await crypto.subtle.importKey('raw', cek, { hash: 'SHA-256', name: 'HMAC' }, true, ['sign']);
     return new Uint8Array(await crypto.subtle.wrapKey('raw', cryptoKeyCek, cryptoKey, 'AES-KW'));
 }
 async function aeskwUnwrap(alg, key, encryptedKey) {
     const cryptoKey = await aeskwCryptoKey(key, alg, 'unwrapKey');
-    checkKeySize(cryptoKey, alg);
     const cryptoKeyCek = await crypto.subtle.unwrapKey('raw', encryptedKey, cryptoKey, 'AES-KW', { hash: 'SHA-256', name: 'HMAC' }, true, ['sign']);
     return new Uint8Array(await crypto.subtle.exportKey('raw', cryptoKeyCek));
 }
-async function aesGcmKwWrap(gcm, key, cek, iv) {
-    const wrapped = await encrypt(gcm, cek, key, iv, new Uint8Array());
-    return {
-        encryptedKey: wrapped.ciphertext,
-        iv: b64u(wrapped.iv),
-        tag: b64u(wrapped.tag),
-    };
-}
-async function aesGcmKwUnwrap(gcm, key, encryptedKey, iv, tag) {
-    return decrypt(gcm, key, encryptedKey, iv, tag, new Uint8Array());
-}
-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`);
-    }
-};
-async function rsaesEncrypt(alg, key, cek) {
-    checkCryptoKey(key, jweAlgorithm(alg).subtle, 'encrypt');
-    checkModulusLength(alg, key);
-    return new Uint8Array(await crypto.subtle.encrypt(subtleAlgorithm(alg), key, cek));
-}
-async function rsaesDecrypt(alg, key, encryptedKey) {
-    checkCryptoKey(key, jweAlgorithm(alg).subtle, 'decrypt');
+function checkRsaKey(alg, key, usage) {
+    checkCryptoKey(key, jweAlgorithm(alg).subtle, usage);
     checkModulusLength(alg, key);
-    return new Uint8Array(await crypto.subtle.decrypt(subtleAlgorithm(alg), key, encryptedKey));
 }
 function pbes2CryptoKey(key, alg) {
     if (key instanceof Uint8Array) {
@@ -85,7 +48,6 @@ function pbes2CryptoKey(key, alg) {
     checkCryptoKey(key, jweAlgorithm(alg).subtle, 'deriveBits');
     return key;
 }
-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');
@@ -93,7 +55,7 @@ async function deriveKey(p2s, alg, p2c, key) {
     if (!Number.isSafeInteger(p2c) || Math.sign(p2c) !== 1) {
         throw new JWEInvalid('PBES2 Count Input must be a positive integer');
     }
-    const salt = concatSalt(alg, p2s);
+    const salt = concat(encode(alg), Uint8Array.of(0), p2s);
     const keylen = parseInt(alg.slice(13, 16), 10);
     const subtleAlg = {
         hash: `SHA-${alg.slice(8, 11)}`,
@@ -104,15 +66,6 @@ async function deriveKey(p2s, alg, p2c, key) {
     const cryptoKey = await pbes2CryptoKey(key, alg);
     return new Uint8Array(await crypto.subtle.deriveBits(subtleAlg, cryptoKey, keylen));
 }
-async function pbes2kwWrap(alg, key, cek, p2c = 2048, p2s = crypto.getRandomValues(new Uint8Array(16))) {
-    const derived = await deriveKey(p2s, alg, p2c, key);
-    const encryptedKey = await aeskwWrap(alg.slice(-6), derived, cek);
-    return { encryptedKey, p2c, p2s: b64u(p2s) };
-}
-async function pbes2kwUnwrap(alg, key, encryptedKey, p2c, p2s) {
-    const derived = await deriveKey(p2s, alg, p2c, key);
-    return aeskwUnwrap(alg.slice(-6), derived, encryptedKey);
-}
 function lengthAndInput(input) {
     return concat(uint32be(input.length), input);
 }
@@ -122,11 +75,7 @@ async function concatKdf(Z, L, OtherInfo) {
     const reps = Math.ceil(dkLen / hashLen);
     const dk = new Uint8Array(reps * hashLen);
     for (let i = 1; i <= reps; i++) {
-        const hashInput = new Uint8Array(4 + Z.length + OtherInfo.length);
-        hashInput.set(uint32be(i), 0);
-        hashInput.set(Z, 4);
-        hashInput.set(OtherInfo, 4 + Z.length);
-        const hashResult = await digest('sha256', hashInput);
+        const hashResult = await digest('sha256', concat(uint32be(i), Z, OtherInfo));
         dk.set(hashResult, (i - 1) * hashLen);
     }
     return dk.slice(0, dkLen);
@@ -134,58 +83,47 @@ async function concatKdf(Z, L, OtherInfo) {
 async function ecdhesDeriveKey(publicKey, privateKey, algorithm, keyLength, apu = new Uint8Array(), apv = new Uint8Array()) {
     checkEcdhCryptoKey(publicKey);
     checkEcdhCryptoKey(privateKey, 'deriveBits');
-    const algorithmID = lengthAndInput(encode(algorithm));
-    const partyUInfo = lengthAndInput(apu);
-    const partyVInfo = lengthAndInput(apv);
-    const suppPubInfo = uint32be(keyLength);
-    const suppPrivInfo = new Uint8Array();
-    const otherInfo = concat(algorithmID, partyUInfo, partyVInfo, suppPubInfo, suppPrivInfo);
+    const otherInfo = concat(lengthAndInput(encode(algorithm)), lengthAndInput(apu), lengthAndInput(apv), uint32be(keyLength));
     const Z = new Uint8Array(await crypto.subtle.deriveBits({
         name: publicKey.algorithm.name,
         public: publicKey,
-    }, privateKey, getEcdhBitLength(publicKey)));
+    }, privateKey, publicKey.algorithm.name === 'X25519'
+        ? 256
+        : Math.ceil(parseInt(publicKey.algorithm.namedCurve.slice(-3), 10) / 8) << 3));
     return concatKdf(Z, keyLength, otherInfo);
 }
-function getEcdhBitLength(publicKey) {
-    if (publicKey.algorithm.name === 'X25519') {
-        return 256;
-    }
-    return (Math.ceil(parseInt(publicKey.algorithm.namedCurve.slice(-3), 10) / 8) << 3);
-}
-function ecdhesAllowed(key) {
-    switch (key.algorithm.namedCurve) {
-        case 'P-256':
-        case 'P-384':
-        case 'P-521':
-            return true;
-        default:
-            return key.algorithm.name === 'X25519';
+function assertEcdhKey(key) {
+    assertCryptoKey(key);
+    const curve = key.algorithm.namedCurve;
+    if (curve !== 'P-256' &&
+        curve !== 'P-384' &&
+        curve !== 'P-521' &&
+        key.algorithm.name !== 'X25519') {
+        throw new JOSENotSupported('ECDH with the provided key is not allowed or not supported by your javascript runtime');
     }
 }
-const unsupportedAlgHeader = 'Invalid or unsupported "alg" (JWE Algorithm) header value';
 function assertEncryptedKey(encryptedKey) {
     if (encryptedKey === undefined)
         throw new JWEInvalid('JWE Encrypted Key missing');
 }
+function assertNoEncryptedKey(encryptedKey) {
+    if (encryptedKey !== undefined)
+        throw new JWEInvalid('Encountered unexpected JWE Encrypted Key');
+}
 export async function decryptKeyManagement(alg, enc, key, encryptedKey, joseHeader, options) {
-    switch (alg) {
-        case 'dir': {
-            if (encryptedKey !== undefined)
-                throw new JWEInvalid('Encountered unexpected JWE Encrypted Key');
-            return key;
-        }
-        case 'ECDH-ES':
-            if (encryptedKey !== undefined)
-                throw new JWEInvalid('Encountered unexpected JWE Encrypted Key');
-        case 'ECDH-ES+A128KW':
-        case 'ECDH-ES+A192KW':
-        case 'ECDH-ES+A256KW': {
+    const entry = jweAlgorithm(alg);
+    if (alg === 'dir') {
+        assertNoEncryptedKey(encryptedKey);
+        return key;
+    }
+    switch (entry.subtle.name) {
+        case 'ECDH': {
+            if (alg === 'ECDH-ES')
+                assertNoEncryptedKey(encryptedKey);
             if (!isObject(joseHeader.epk))
                 throw new JWEInvalid(`JOSE Header "epk" (Ephemeral Public Key) missing or invalid`);
-            assertCryptoKey(key);
-            if (!ecdhesAllowed(key))
-                throw new JOSENotSupported('ECDH with the provided key is not allowed or not supported by your javascript runtime');
-            const epk = await jwkToKey(jweAlgorithm(alg), joseHeader.epk);
+            assertEcdhKey(key);
+            const epk = await jwkToKey(entry, joseHeader.epk);
             let partyUInfo;
             let partyVInfo;
             if (joseHeader.apu !== undefined) {
@@ -204,17 +142,13 @@ export async function decryptKeyManagement(alg, enc, key, encryptedKey, joseHead
             assertEncryptedKey(encryptedKey);
             return aeskwUnwrap(alg.slice(-6), sharedSecret, encryptedKey);
         }
-        case 'RSA-OAEP':
-        case 'RSA-OAEP-256':
-        case 'RSA-OAEP-384':
-        case 'RSA-OAEP-512': {
+        case 'RSA-OAEP': {
             assertEncryptedKey(encryptedKey);
             assertCryptoKey(key);
-            return rsaesDecrypt(alg, key, encryptedKey);
+            checkRsaKey(alg, key, 'decrypt');
+            return new Uint8Array(await crypto.subtle.decrypt('RSA-OAEP', key, encryptedKey));
         }
-        case 'PBES2-HS256+A128KW':
-        case 'PBES2-HS384+A192KW':
-        case 'PBES2-HS512+A256KW': {
+        case 'PBKDF2': {
             assertEncryptedKey(encryptedKey);
             if (typeof joseHeader.p2c !== 'number')
                 throw new JWEInvalid(`JOSE Header "p2c" (PBES2 Count) missing or invalid`);
@@ -223,19 +157,15 @@ export async function decryptKeyManagement(alg, enc, key, encryptedKey, joseHead
                 throw new JWEInvalid(`JOSE Header "p2c" (PBES2 Count) out is of acceptable bounds`);
             if (typeof joseHeader.p2s !== 'string')
                 throw new JWEInvalid(`JOSE Header "p2s" (PBES2 Salt) missing or invalid`);
-            let p2s;
-            p2s = decodeBase64url(joseHeader.p2s, 'p2s', JWEInvalid);
-            return pbes2kwUnwrap(alg, key, encryptedKey, joseHeader.p2c, p2s);
+            const p2s = decodeBase64url(joseHeader.p2s, 'p2s', JWEInvalid);
+            const derived = await deriveKey(p2s, alg, joseHeader.p2c, key);
+            return aeskwUnwrap(alg.slice(-6), derived, encryptedKey);
         }
-        case 'A128KW':
-        case 'A192KW':
-        case 'A256KW': {
+        case 'AES-KW': {
             assertEncryptedKey(encryptedKey);
             return aeskwUnwrap(alg, key, encryptedKey);
         }
-        case 'A128GCMKW':
-        case 'A192GCMKW':
-        case 'A256GCMKW': {
+        case 'AES-GCM': {
             assertEncryptedKey(encryptedKey);
             if (typeof joseHeader.iv !== 'string')
                 throw new JWEInvalid(`JOSE Header "iv" (Initialization Vector) missing or invalid`);
@@ -245,10 +175,7 @@ export async function decryptKeyManagement(alg, enc, key, encryptedKey, joseHead
             iv = decodeBase64url(joseHeader.iv, 'iv', JWEInvalid);
             let tag;
             tag = decodeBase64url(joseHeader.tag, 'tag', JWEInvalid);
-            return aesGcmKwUnwrap(jweEncryption(jweAlgorithm(alg).gcmkw), key, encryptedKey, iv, tag);
-        }
-        default: {
-            throw new JOSENotSupported(unsupportedAlgHeader);
+            return decrypt(jweEncryption(alg.slice(0, -2)), key, encryptedKey, iv, tag, new Uint8Array());
         }
     }
 }
@@ -256,23 +183,16 @@ export async function encryptKeyManagement(alg, enc, key, providedCek, providedP
     let encryptedKey;
     let parameters;
     let cek;
-    switch (alg) {
-        case 'dir': {
-            cek = key;
-            break;
-        }
-        case 'ECDH-ES':
-        case 'ECDH-ES+A128KW':
-        case 'ECDH-ES+A192KW':
-        case 'ECDH-ES+A256KW': {
-            assertCryptoKey(key);
-            if (!ecdhesAllowed(key)) {
-                throw new JOSENotSupported('ECDH with the provided key is not allowed or not supported by your javascript runtime');
-            }
+    const entry = jweAlgorithm(alg);
+    if (alg === 'dir')
+        return [key, undefined, undefined];
+    switch (entry.subtle.name) {
+        case 'ECDH': {
+            assertEcdhKey(key);
             const { apu, apv } = providedParameters;
             let ephemeralKey;
             if (providedParameters.epk) {
-                ephemeralKey = (await prepareKey(jweAlgorithm(alg), providedParameters.epk, 'decrypt'));
+                ephemeralKey = (await prepareKey(entry, providedParameters.epk, 'decrypt'));
             }
             else {
                 ephemeralKey = (await crypto.subtle.generateKey(key.algorithm, true, ['deriveBits'])).privateKey;
@@ -303,41 +223,34 @@ export async function encryptKeyManagement(alg, enc, key, providedCek, providedP
             encryptedKey = await aeskwWrap(kwAlg, sharedSecret, cek);
             break;
         }
-        case 'RSA-OAEP':
-        case 'RSA-OAEP-256':
-        case 'RSA-OAEP-384':
-        case 'RSA-OAEP-512': {
+        case 'RSA-OAEP': {
             cek = providedCek || generateCek(enc);
             assertCryptoKey(key);
-            encryptedKey = await rsaesEncrypt(alg, key, cek);
+            checkRsaKey(alg, key, 'encrypt');
+            encryptedKey = new Uint8Array(await crypto.subtle.encrypt('RSA-OAEP', key, cek));
             break;
         }
-        case 'PBES2-HS256+A128KW':
-        case 'PBES2-HS384+A192KW':
-        case 'PBES2-HS512+A256KW': {
+        case 'PBKDF2': {
             cek = providedCek || generateCek(enc);
-            const { p2c, p2s } = providedParameters;
-            ({ encryptedKey, ...parameters } = await pbes2kwWrap(alg, key, cek, p2c, p2s));
+            const { p2c = 2048, p2s = crypto.getRandomValues(new Uint8Array(16)) } = providedParameters;
+            const derived = await deriveKey(p2s, alg, p2c, key);
+            encryptedKey = await aeskwWrap(alg.slice(-6), derived, cek);
+            parameters = { p2c, p2s: b64u(p2s) };
             break;
         }
-        case 'A128KW':
-        case 'A192KW':
-        case 'A256KW': {
+        case 'AES-KW': {
             cek = providedCek || generateCek(enc);
             encryptedKey = await aeskwWrap(alg, key, cek);
             break;
         }
-        case 'A128GCMKW':
-        case 'A192GCMKW':
-        case 'A256GCMKW': {
+        case 'AES-GCM': {
             cek = providedCek || generateCek(enc);
             const { iv } = providedParameters;
-            ({ encryptedKey, ...parameters } = await aesGcmKwWrap(jweEncryption(jweAlgorithm(alg).gcmkw), key, cek, iv));
+            const wrapped = await encrypt(jweEncryption(alg.slice(0, -2)), cek, key, iv, new Uint8Array());
+            encryptedKey = wrapped.ciphertext;
+            parameters = { iv: b64u(wrapped.iv), tag: b64u(wrapped.tag) };
             break;
         }
-        default: {
-            throw new JOSENotSupported(unsupportedAlgHeader);
-        }
     }
-    return { cek, encryptedKey, parameters };
+    return [cek, encryptedKey, parameters];
 }

package/dist/webapi/lib/options.js

@@ -1,6 +1,6 @@
 import { JOSENotSupported, JWEInvalid, JWSInvalid } from '../util/errors.js';
-export const JWS_RECOGNIZED = new Map([['b64', true]]);
-export const JWE_RECOGNIZED = new Map();
+export const JWS_RECOGNIZED = { __proto__: null, b64: true };
+export const JWE_RECOGNIZED = { __proto__: null };
 export function validateAlgorithms(option, algorithms) {
     if (algorithms !== undefined &&
         (!Array.isArray(algorithms) || algorithms.some((s) => typeof s !== 'string'))) {
@@ -22,30 +22,27 @@ export function validateCrit(Err, recognizedDefault, recognizedOption, protected
         throw new Err('"crit" (Critical) Header Parameter MUST be integrity protected');
     }
     if (!protectedHeader || protectedHeader.crit === undefined) {
-        return new Set();
+        return [];
     }
     if (!Array.isArray(protectedHeader.crit) ||
         protectedHeader.crit.length === 0 ||
         protectedHeader.crit.some((input) => typeof input !== 'string' || input.length === 0)) {
         throw new Err('"crit" (Critical) Header Parameter MUST be an array of non-empty strings when present');
     }
-    let recognized;
-    if (recognizedOption !== undefined) {
-        recognized = new Map([...Object.entries(recognizedOption), ...recognizedDefault.entries()]);
-    }
-    else {
-        recognized = recognizedDefault;
-    }
+    const recognized = recognizedOption === undefined
+        ? recognizedDefault
+        : { __proto__: null, ...recognizedOption, ...recognizedDefault };
     for (const parameter of protectedHeader.crit) {
-        if (!recognized.has(parameter)) {
+        if (!(parameter in recognized)) {
             throw new JOSENotSupported(`Extension Header Parameter "${parameter}" is not recognized`);
         }
-        if (joseHeader[parameter] === undefined) {
+        if (!Object.hasOwn(joseHeader, parameter) || joseHeader[parameter] === undefined) {
             throw new Err(`Extension Header Parameter "${parameter}" is missing`);
         }
-        if (recognized.get(parameter) && protectedHeader[parameter] === undefined) {
+        if (recognized[parameter] &&
+            (!Object.hasOwn(protectedHeader, parameter) || protectedHeader[parameter] === undefined)) {
             throw new Err(`Extension Header Parameter "${parameter}" MUST be integrity protected`);
         }
     }
-    return new Set(protectedHeader.crit);
+    return protectedHeader.crit;
 }

package/dist/webapi/lib/signing.js

@@ -1,34 +1,24 @@
-import { checkCryptoKey } from './crypto_key.js';
-export function checkModulusLength(alg, key) {
-    const { modulusLength } = key.algorithm;
-    if (typeof modulusLength !== 'number' || modulusLength < 2048) {
-        throw new TypeError(`${alg} requires key modulusLength to be 2048 bits or larger`);
-    }
-}
-function checkSigCryptoKey(entry, key, usage) {
-    checkCryptoKey(key, entry.subtle, usage);
-    if (entry.minModulusLength) {
-        checkModulusLength(entry.alg, key);
-    }
-}
+import { checkCryptoKey, checkModulusLength } from './crypto_key.js';
 async function getSigKey(entry, key, usage) {
     if (key instanceof Uint8Array) {
         return crypto.subtle.importKey('raw', key, entry.subtle, false, [
             usage,
         ]);
     }
-    checkSigCryptoKey(entry, key, usage);
+    checkCryptoKey(key, entry.subtle, usage);
+    if (entry.minRsaBits)
+        checkModulusLength(entry.alg, key);
     return key;
 }
 export async function sign(entry, key, data) {
     const cryptoKey = await getSigKey(entry, key, 'sign');
-    const signature = await crypto.subtle.sign(entry.operation, cryptoKey, data);
+    const signature = await crypto.subtle.sign(entry.signing, cryptoKey, data);
     return new Uint8Array(signature);
 }
 export async function verify(entry, key, signature, data) {
     const cryptoKey = await getSigKey(entry, key, 'verify');
     try {
-        return await crypto.subtle.verify(entry.operation, cryptoKey, signature, data);
+        return await crypto.subtle.verify(entry.signing, cryptoKey, signature, data);
     }
     catch {
         return false;

package/dist/webapi/lib/type_checks.js

@@ -1,34 +1,29 @@
-const isObjectLike = (value) => typeof value === 'object' && value !== null;
 export function isObject(input) {
-    if (!isObjectLike(input) || Object.prototype.toString.call(input) !== '[object Object]') {
+    if (typeof input !== 'object' ||
+        input === null ||
+        Object.prototype.toString.call(input) !== '[object Object]') {
         return false;
     }
-    if (Object.getPrototypeOf(input) === null) {
+    const prototype = Object.getPrototypeOf(input);
+    if (prototype === null) {
         return true;
     }
-    let proto = input;
+    let proto = prototype;
     while (Object.getPrototypeOf(proto) !== null) {
         proto = Object.getPrototypeOf(proto);
     }
-    return Object.getPrototypeOf(input) === proto;
+    return prototype === proto;
 }
 export function isDisjoint(...headers) {
-    const sources = headers.filter(Boolean);
-    if (sources.length === 0 || sources.length === 1) {
-        return true;
-    }
-    let acc;
-    for (const header of sources) {
-        const parameters = Object.keys(header);
-        if (!acc || acc.size === 0) {
-            acc = new Set(parameters);
+    const parameters = new Set();
+    for (const header of headers) {
+        if (!header)
             continue;
-        }
-        for (const parameter of parameters) {
-            if (acc.has(parameter)) {
+        for (const parameter of Object.keys(header)) {
+            if (parameters.has(parameter)) {
                 return false;
             }
-            acc.add(parameter);
+            parameters.add(parameter);
         }
     }
     return true;

package/dist/webapi/util/base64url.js

@@ -1,5 +1,6 @@
 import { encoder, decoder } from '../lib/buffer_utils.js';
 import { encodeBase64, decodeBase64 } from '../lib/base64.js';
+const invalid = 'The input to be decoded is not correctly encoded.';
 export function decode(input) {
     if (Uint8Array.fromBase64) {
         try {
@@ -8,7 +9,7 @@ export function decode(input) {
             });
         }
         catch (cause) {
-            throw new TypeError('The input to be decoded is not correctly encoded.', { cause });
+            throw new TypeError(invalid, { cause });
         }
     }
     let encoded = input;
@@ -16,14 +17,14 @@ export function decode(input) {
         encoded = decoder.decode(encoded);
     }
     if (encoded.includes('+') || encoded.includes('/')) {
-        throw new TypeError('The input to be decoded is not correctly encoded.');
+        throw new TypeError(invalid);
     }
     encoded = encoded.replace(/-/g, '+').replace(/_/g, '/');
     try {
         return decodeBase64(encoded);
     }
     catch {
-        throw new TypeError('The input to be decoded is not correctly encoded.');
+        throw new TypeError(invalid);
     }
 }
 export function encode(input) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "jose",
-  "version": "6.2.6",
+  "version": "6.2.8",
   "description": "JWA, JWS, JWE, JWT, JWK, JWKS for Node.js, Browser, Cloudflare Workers, Deno, Bun, and other Web-interoperable runtimes",
   "keywords": [
     "akp",