jose 4.0.4 → 4.1.3

package/dist/node/esm/lib/crypto_key.js

@@ -1,6 +1,12 @@
-import { isCloudflareWorkers, isNodeJs } from '../runtime/global.js';
+import { isCloudflareWorkers, isNodeJs } from '../runtime/env.js';
+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;
+}
 function getHashLength(hash) {
-    return parseInt(hash === null || hash === void 0 ? void 0 : hash.name.substr(4), 10);
+    return parseInt(hash.name.substr(4), 10);
 }
 function getNamedCurve(alg) {
     switch (alg) {
@@ -10,6 +16,8 @@ function getNamedCurve(alg) {
             return 'P-384';
         case 'ES512':
             return 'P-521';
+        default:
+            throw new Error('unreachable');
     }
 }
 function checkUsage(key, usages) {
@@ -33,65 +41,55 @@ export function checkSigCryptoKey(key, alg, ...usages) {
         case 'HS256':
         case 'HS384':
         case 'HS512': {
-            if (key.algorithm.name !== 'HMAC') {
-                throw new TypeError(`CryptoKey does not support this operation, its algorithm.name must be HMAC.`);
-            }
+            if (!isAlgorithm(key.algorithm, 'HMAC'))
+                throw unusable('HMAC');
             const expected = parseInt(alg.substr(2), 10);
             const actual = getHashLength(key.algorithm.hash);
-            if (actual !== expected) {
-                throw new TypeError(`CryptoKey does not support this operation, its algorithm.hash must be SHA-${expected}.`);
-            }
+            if (actual !== expected)
+                throw unusable(`SHA-${expected}`, 'algorithm.hash');
             break;
         }
         case 'RS256':
         case 'RS384':
         case 'RS512': {
-            if (key.algorithm.name !== 'RSASSA-PKCS1-v1_5') {
-                throw new TypeError(`CryptoKey does not support this operation, its algorithm.name must be RSASSA-PKCS1-v1_5.`);
-            }
+            if (!isAlgorithm(key.algorithm, 'RSASSA-PKCS1-v1_5'))
+                throw unusable('RSASSA-PKCS1-v1_5');
             const expected = parseInt(alg.substr(2), 10);
             const actual = getHashLength(key.algorithm.hash);
-            if (actual !== expected) {
-                throw new TypeError(`CryptoKey does not support this operation, its algorithm.hash must be SHA-${expected}.`);
-            }
+            if (actual !== expected)
+                throw unusable(`SHA-${expected}`, 'algorithm.hash');
             break;
         }
         case 'PS256':
         case 'PS384':
         case 'PS512': {
-            if (key.algorithm.name !== 'RSA-PSS') {
-                throw new TypeError(`CryptoKey does not support this operation, its algorithm.name must be RSA-PSS.`);
-            }
+            if (!isAlgorithm(key.algorithm, 'RSA-PSS'))
+                throw unusable('RSA-PSS');
             const expected = parseInt(alg.substr(2), 10);
             const actual = getHashLength(key.algorithm.hash);
-            if (actual !== expected) {
-                throw new TypeError(`CryptoKey does not support this operation, its algorithm.hash must be SHA-${expected}.`);
-            }
+            if (actual !== expected)
+                throw unusable(`SHA-${expected}`, 'algorithm.hash');
             break;
         }
         case isNodeJs() && 'EdDSA': {
-            if (key.algorithm.name !== 'NODE-ED25519' && key.algorithm.name !== 'NODE-ED448') {
-                throw new TypeError(`CryptoKey does not support this operation, its algorithm.name must be NODE-ED25519 or NODE-ED448.`);
-            }
+            if (key.algorithm.name !== 'NODE-ED25519' && key.algorithm.name !== 'NODE-ED448')
+                throw unusable('NODE-ED25519 or NODE-ED448');
             break;
         }
         case isCloudflareWorkers() && 'EdDSA': {
-            if (key.algorithm.name !== 'NODE-ED25519') {
-                throw new TypeError(`CryptoKey does not support this operation, its algorithm.name must be NODE-ED25519.`);
-            }
+            if (!isAlgorithm(key.algorithm, 'NODE-ED25519'))
+                throw unusable('NODE-ED25519');
             break;
         }
         case 'ES256':
         case 'ES384':
         case 'ES512': {
-            if (key.algorithm.name !== 'ECDSA') {
-                throw new TypeError(`CryptoKey does not support this operation, its algorithm.name must be ECDSA.`);
-            }
+            if (!isAlgorithm(key.algorithm, 'ECDSA'))
+                throw unusable('ECDSA');
             const expected = getNamedCurve(alg);
             const actual = key.algorithm.namedCurve;
-            if (actual !== expected) {
-                throw new TypeError(`CryptoKey does not support this operation, its algorithm.namedCurve must be ${expected}.`);
-            }
+            if (actual !== expected)
+                throw unusable(expected, 'algorithm.namedCurve');
             break;
         }
         default:
@@ -104,53 +102,45 @@ export function checkEncCryptoKey(key, alg, ...usages) {
         case 'A128GCM':
         case 'A192GCM':
         case 'A256GCM': {
-            if (key.algorithm.name !== 'AES-GCM') {
-                throw new TypeError(`CryptoKey does not support this operation, its algorithm.name must be AES-GCM.`);
-            }
+            if (!isAlgorithm(key.algorithm, 'AES-GCM'))
+                throw unusable('AES-GCM');
             const expected = parseInt(alg.substr(1, 3), 10);
             const actual = key.algorithm.length;
-            if (actual !== expected) {
-                throw new TypeError(`CryptoKey does not support this operation, its algorithm.length must be ${expected}.`);
-            }
+            if (actual !== expected)
+                throw unusable(expected, 'algorithm.length');
             break;
         }
         case 'A128KW':
         case 'A192KW':
         case 'A256KW': {
-            if (key.algorithm.name !== 'AES-KW') {
-                throw new TypeError(`CryptoKey does not support this operation, its algorithm.name must be AES-KW.`);
-            }
+            if (!isAlgorithm(key.algorithm, 'AES-KW'))
+                throw unusable('AES-KW');
             const expected = parseInt(alg.substr(1, 3), 10);
             const actual = key.algorithm.length;
-            if (actual !== expected) {
-                throw new TypeError(`CryptoKey does not support this operation, its algorithm.length must be ${expected}.`);
-            }
+            if (actual !== expected)
+                throw unusable(expected, 'algorithm.length');
             break;
         }
         case 'ECDH-ES':
-            if (key.algorithm.name !== 'ECDH') {
-                throw new TypeError(`CryptoKey does not support this operation, its algorithm.name must be ECDH.`);
-            }
+            if (!isAlgorithm(key.algorithm, 'ECDH'))
+                throw unusable('ECDH');
             break;
         case 'PBES2-HS256+A128KW':
         case 'PBES2-HS384+A192KW':
         case 'PBES2-HS512+A256KW':
-            if (key.algorithm.name !== 'PBKDF2') {
-                throw new TypeError(`CryptoKey does not support this operation, its algorithm.name must be PBKDF2.`);
-            }
+            if (!isAlgorithm(key.algorithm, 'PBKDF2'))
+                throw unusable('PBKDF2');
             break;
         case 'RSA-OAEP':
         case 'RSA-OAEP-256':
         case 'RSA-OAEP-384':
         case 'RSA-OAEP-512': {
-            if (key.algorithm.name !== 'RSA-OAEP') {
-                throw new TypeError(`CryptoKey does not support this operation, its algorithm.name must be RSA-OAEP.`);
-            }
+            if (!isAlgorithm(key.algorithm, 'RSA-OAEP'))
+                throw unusable('RSA-OAEP');
             const expected = parseInt(alg.substr(9), 10) || 1;
             const actual = getHashLength(key.algorithm.hash);
-            if (actual !== expected) {
-                throw new TypeError(`CryptoKey does not support this operation, its algorithm.hash must be SHA-${expected}.`);
-            }
+            if (actual !== expected)
+                throw unusable(`SHA-${expected}`, 'algorithm.hash');
             break;
         }
         default:

package/dist/node/esm/lib/decrypt_key_management.js

@@ -2,13 +2,13 @@ import { unwrap as aesKw } from '../runtime/aeskw.js';
 import * as ECDH from '../runtime/ecdhes.js';
 import { decrypt as pbes2Kw } from '../runtime/pbes2kw.js';
 import { decrypt as rsaEs } from '../runtime/rsaes.js';
-import { unwrap as aesGcmKw } from '../runtime/aesgcmkw.js';
 import { decode as base64url } from '../runtime/base64url.js';
 import { JOSENotSupported, JWEInvalid } from '../util/errors.js';
 import { bitLength as cekLength } from '../lib/cek.js';
 import { importJWK } from '../key/import.js';
 import checkKeyType from './check_key_type.js';
 import isObject from './is_object.js';
+import { unwrap as aesGcmKw } from './aesgcmkw.js';
 async function decryptKeyManagement(alg, key, encryptedKey, joseHeader) {
     checkKeyType(alg, key, 'decrypt');
     switch (alg) {

package/dist/node/esm/lib/encrypt_key_management.js

@@ -2,12 +2,12 @@ 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 { wrap as aesGcmKw } from '../runtime/aesgcmkw.js';
 import { encode as base64url } from '../runtime/base64url.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 = {}) {
     let encryptedKey;
     let parameters;

package/dist/node/esm/{runtime → lib}/invalid_key_input.js

@@ -1,4 +1,3 @@
-import { inspect } from 'util';
 export default (actual, ...types) => {
     let msg = 'Key must be ';
     if (types.length > 2) {
@@ -21,16 +20,6 @@ export default (actual, ...types) => {
         if (actual.constructor && actual.constructor.name) {
             msg += ` Received an instance of ${actual.constructor.name}`;
         }
-        else {
-            const inspected = inspect(actual, { depth: -1 });
-            msg += ` Received ${inspected}`;
-        }
-    }
-    else {
-        let inspected = inspect(actual, { colors: false });
-        if (inspected.length > 25)
-            inspected = `${inspected.slice(0, 25)}...`;
-        msg += ` Received type ${typeof actual} (${inspected})`;
     }
     return msg;
 };

package/dist/node/esm/runtime/aeskw.js

@@ -6,7 +6,7 @@ import getSecretKey from './secret_key.js';
 import { isCryptoKey } from './webcrypto.js';
 import { checkEncCryptoKey } from '../lib/crypto_key.js';
 import isKeyObject from './is_key_object.js';
-import invalidKeyInput from './invalid_key_input.js';
+import invalidKeyInput from '../lib/invalid_key_input.js';
 import supported from './ciphers.js';
 function checkKeySize(key, alg) {
     if (key.symmetricKeySize << 3 !== parseInt(alg.substr(1, 3), 10)) {

package/dist/node/esm/runtime/asn1.js

@@ -2,7 +2,7 @@ import { createPrivateKey, createPublicKey, KeyObject } from 'crypto';
 import { Buffer } from 'buffer';
 import { isCryptoKey } from './webcrypto.js';
 import isKeyObject from './is_key_object.js';
-import invalidKeyInput from './invalid_key_input.js';
+import invalidKeyInput from '../lib/invalid_key_input.js';
 const genericExport = (keyType, keyFormat, key) => {
     let keyObject;
     if (isCryptoKey(key)) {

package/dist/node/esm/runtime/decrypt.js

@@ -8,7 +8,7 @@ import cbcTag from './cbc_tag.js';
 import { isCryptoKey } from './webcrypto.js';
 import { checkEncCryptoKey } from '../lib/crypto_key.js';
 import isKeyObject from './is_key_object.js';
-import invalidKeyInput from './invalid_key_input.js';
+import invalidKeyInput from '../lib/invalid_key_input.js';
 import supported from './ciphers.js';
 async function cbcDecrypt(enc, cek, ciphertext, iv, tag, aad) {
     const keySize = parseInt(enc.substr(1, 3), 10);

package/dist/node/esm/runtime/ecdhes.js

@@ -7,7 +7,7 @@ import { JOSENotSupported } from '../util/errors.js';
 import { isCryptoKey } from './webcrypto.js';
 import { checkEncCryptoKey } from '../lib/crypto_key.js';
 import isKeyObject from './is_key_object.js';
-import invalidKeyInput from './invalid_key_input.js';
+import invalidKeyInput from '../lib/invalid_key_input.js';
 const generateKeyPair = promisify(generateKeyPairCb);
 export const deriveKey = async (publicKee, privateKee, algorithm, keyLength, apu = new Uint8Array(0), apv = new Uint8Array(0)) => {
     let publicKey;

package/dist/node/esm/runtime/encrypt.js

@@ -6,7 +6,7 @@ import cbcTag from './cbc_tag.js';
 import { isCryptoKey } from './webcrypto.js';
 import { checkEncCryptoKey } from '../lib/crypto_key.js';
 import isKeyObject from './is_key_object.js';
-import invalidKeyInput from './invalid_key_input.js';
+import invalidKeyInput from '../lib/invalid_key_input.js';
 import { JOSENotSupported } from '../util/errors.js';
 import supported from './ciphers.js';
 async function cbcEncrypt(enc, plaintext, cek, iv, aad) {

package/dist/node/esm/runtime/get_named_curve.js

@@ -3,7 +3,7 @@ import { createPublicKey, KeyObject } from 'crypto';
 import { JOSENotSupported } from '../util/errors.js';
 import { isCryptoKey } from './webcrypto.js';
 import isKeyObject from './is_key_object.js';
-import invalidKeyInput from './invalid_key_input.js';
+import invalidKeyInput from '../lib/invalid_key_input.js';
 const p256 = Buffer.from([42, 134, 72, 206, 61, 3, 1, 7]);
 const p384 = Buffer.from([43, 129, 4, 0, 34]);
 const p521 = Buffer.from([43, 129, 4, 0, 35]);

package/dist/node/esm/runtime/get_sign_verify_key.js

@@ -2,7 +2,7 @@ import { KeyObject } from 'crypto';
 import { isCryptoKey } from './webcrypto.js';
 import { checkSigCryptoKey } from '../lib/crypto_key.js';
 import getSecretKey from './secret_key.js';
-import invalidKeyInput from './invalid_key_input.js';
+import invalidKeyInput from '../lib/invalid_key_input.js';
 export default function getSignVerifyKey(alg, key, usage) {
     if (key instanceof Uint8Array) {
         if (!alg.startsWith('HS')) {

package/dist/node/esm/runtime/key_to_jwk.js

@@ -5,7 +5,7 @@ import { JOSENotSupported } from '../util/errors.js';
 import getNamedCurve from './get_named_curve.js';
 import { isCryptoKey } from './webcrypto.js';
 import isKeyObject from './is_key_object.js';
-import invalidKeyInput from './invalid_key_input.js';
+import invalidKeyInput from '../lib/invalid_key_input.js';
 const [major, minor] = process.version
     .substr(1)
     .split('.')

package/dist/node/esm/runtime/node_key.js

@@ -7,6 +7,10 @@ const [major, minor] = process.version
     .split('.')
     .map((str) => parseInt(str, 10));
 const rsaPssParams = major >= 17 || (major === 16 && minor >= 9);
+const PSS = {
+    padding: constants.RSA_PKCS1_PSS_PADDING,
+    saltLength: constants.RSA_PSS_SALTLEN_DIGEST,
+};
 const ecCurveAlgMap = new Map([
     ['ES256', 'P-256'],
     ['ES256K', 'secp256k1'],
@@ -46,11 +50,7 @@ export default function keyForCrypto(alg, key) {
                 throw new TypeError('Invalid key for this operation, its asymmetricKeyType must be rsa or rsa-pss');
             }
             checkModulusLength(key, alg);
-            return {
-                key,
-                padding: constants.RSA_PKCS1_PSS_PADDING,
-                saltLength: constants.RSA_PSS_SALTLEN_DIGEST,
-            };
+            return { key, ...PSS };
         case !rsaPssParams && 'PS256':
         case !rsaPssParams && 'PS384':
         case !rsaPssParams && 'PS512':
@@ -58,11 +58,7 @@ export default function keyForCrypto(alg, key) {
                 throw new TypeError('Invalid key for this operation, its asymmetricKeyType must be rsa');
             }
             checkModulusLength(key, alg);
-            return {
-                key,
-                padding: constants.RSA_PKCS1_PSS_PADDING,
-                saltLength: constants.RSA_PSS_SALTLEN_DIGEST,
-            };
+            return { key, ...PSS };
         case 'ES256':
         case 'ES256K':
         case 'ES384':

package/dist/node/esm/runtime/pbes2kw.js

@@ -8,7 +8,7 @@ import checkP2s from '../lib/check_p2s.js';
 import { isCryptoKey } from './webcrypto.js';
 import { checkEncCryptoKey } from '../lib/crypto_key.js';
 import isKeyObject from './is_key_object.js';
-import invalidKeyInput from './invalid_key_input.js';
+import invalidKeyInput from '../lib/invalid_key_input.js';
 const pbkdf2 = promisify(pbkdf2cb);
 function getPassword(key, alg) {
     if (isKeyObject(key)) {

package/dist/node/esm/runtime/rsaes.js

@@ -3,7 +3,7 @@ import checkModulusLength from './check_modulus_length.js';
 import { isCryptoKey } from './webcrypto.js';
 import { checkEncCryptoKey } from '../lib/crypto_key.js';
 import isKeyObject from './is_key_object.js';
-import invalidKeyInput from './invalid_key_input.js';
+import invalidKeyInput from '../lib/invalid_key_input.js';
 const checkKey = (key, alg) => {
     if (key.asymmetricKeyType !== 'rsa') {
         throw new TypeError('Invalid key for this operation, its asymmetricKeyType must be rsa');

package/dist/types/jwks/remote.d.ts

@@ -4,4 +4,8 @@ export interface RemoteJWKSetOptions {
     cooldownDuration?: number;
     agent?: any;
 }
+interface URL {
+    href: string;
+}
 export declare function createRemoteJWKSet(url: URL, options?: RemoteJWKSetOptions): GetKeyFunction<JWSHeaderParameters, FlattenedJWSInput>;
+export {};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "jose",
-  "version": "4.0.4",
+  "version": "4.1.3",
   "description": "'JSON Web Almost Everything' - JWA, JWS, JWE, JWT, JWK, JWKS with no dependencies using runtime's native crypto",
   "keywords": [
     "browser",
@@ -68,6 +68,9 @@
     "dist/**/package.json",
     "dist/**/*.js",
     "dist/types/**/*.d.ts",
+    "!dist/**/*.bundle.js",
+    "!dist/**/*.umd.js",
+    "!dist/**/*.min.js",
     "!dist/node/webcrypto/**/*",
     "!dist/types/runtime/*",
     "!dist/types/lib/*"

package/dist/browser/runtime/global.js

@@ -1,27 +0,0 @@
-function getGlobal() {
-    if (typeof globalThis !== 'undefined')
-        return globalThis;
-    if (typeof self !== 'undefined')
-        return self;
-    if (typeof window !== 'undefined')
-        return window;
-    throw new Error('unable to locate global object');
-}
-export default getGlobal();
-export function isCloudflareWorkers() {
-    try {
-        return getGlobal().WebSocketPair !== undefined;
-    }
-    catch (_a) {
-        return false;
-    }
-}
-export function isNodeJs() {
-    var _a, _b;
-    try {
-        return ((_b = (_a = getGlobal().process) === null || _a === void 0 ? void 0 : _a.versions) === null || _b === void 0 ? void 0 : _b.node) !== undefined;
-    }
-    catch (_c) {
-        return false;
-    }
-}