jose 4.0.4 → 4.1.3

package/dist/browser/runtime/subtle_dsa.js

@@ -1,45 +1,26 @@
-import { isCloudflareWorkers, isNodeJs } from './global.js';
+import { isCloudflareWorkers, isNodeJs } from './env.js';
 import { JOSENotSupported } from '../util/errors.js';
-export default function subtleDsa(alg, crv) {
+export default function subtleDsa(alg, namedCurve) {
+    const length = parseInt(alg.substr(-3), 10);
     switch (alg) {
         case 'HS256':
-            return { hash: { name: 'SHA-256' }, name: 'HMAC' };
         case 'HS384':
-            return { hash: { name: 'SHA-384' }, name: 'HMAC' };
         case 'HS512':
-            return { hash: { name: 'SHA-512' }, name: 'HMAC' };
+            return { hash: `SHA-${length}`, name: 'HMAC' };
         case 'PS256':
-            return {
-                hash: { name: 'SHA-256' },
-                name: 'RSA-PSS',
-                saltLength: 256 >> 3,
-            };
         case 'PS384':
-            return {
-                hash: { name: 'SHA-384' },
-                name: 'RSA-PSS',
-                saltLength: 384 >> 3,
-            };
         case 'PS512':
-            return {
-                hash: { name: 'SHA-512' },
-                name: 'RSA-PSS',
-                saltLength: 512 >> 3,
-            };
+            return { hash: `SHA-${length}`, name: 'RSA-PSS', saltLength: length >> 3 };
         case 'RS256':
-            return { hash: { name: 'SHA-256' }, name: 'RSASSA-PKCS1-v1_5' };
         case 'RS384':
-            return { hash: { name: 'SHA-384' }, name: 'RSASSA-PKCS1-v1_5' };
         case 'RS512':
-            return { hash: { name: 'SHA-512' }, name: 'RSASSA-PKCS1-v1_5' };
+            return { hash: `SHA-${length}`, name: 'RSASSA-PKCS1-v1_5' };
         case 'ES256':
-            return { hash: { name: 'SHA-256' }, name: 'ECDSA', namedCurve: 'P-256' };
         case 'ES384':
-            return { hash: { name: 'SHA-384' }, name: 'ECDSA', namedCurve: 'P-384' };
         case 'ES512':
-            return { hash: { name: 'SHA-512' }, name: 'ECDSA', namedCurve: 'P-521' };
+            return { hash: `SHA-${length}`, name: 'ECDSA', namedCurve };
         case (isCloudflareWorkers() || isNodeJs()) && 'EdDSA':
-            return { name: crv, namedCurve: crv };
+            return { name: namedCurve, namedCurve };
         default:
             throw new JOSENotSupported(`alg ${alg} is not supported either by JOSE or your javascript runtime`);
     }

package/dist/browser/runtime/webcrypto.js

@@ -1,8 +1,12 @@
-import globalThis from './global.js';
-export default globalThis.crypto;
+export default crypto;
 export function isCryptoKey(key) {
-    if (typeof globalThis.CryptoKey === 'undefined') {
+    try {
+        return (key != null &&
+            typeof key.extractable === 'boolean' &&
+            typeof key.algorithm.name === 'string' &&
+            typeof key.type === 'string');
+    }
+    catch (_a) {
         return false;
     }
-    return key != null && key instanceof globalThis.CryptoKey;
 }

package/dist/node/cjs/{runtime → lib}/aesgcmkw.js

@@ -1,19 +1,19 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.unwrap = exports.wrap = void 0;
-const encrypt_js_1 = require("./encrypt.js");
-const decrypt_js_1 = require("./decrypt.js");
-const iv_js_1 = require("../lib/iv.js");
-const base64url_js_1 = require("./base64url.js");
-const wrap = async (alg, key, cek, iv) => {
+const encrypt_js_1 = require("../runtime/encrypt.js");
+const decrypt_js_1 = require("../runtime/decrypt.js");
+const iv_js_1 = require("./iv.js");
+const base64url_js_1 = require("../runtime/base64url.js");
+async function wrap(alg, key, cek, iv) {
     const jweAlgorithm = alg.substr(0, 7);
     iv || (iv = (0, iv_js_1.default)(jweAlgorithm));
     const { ciphertext: encryptedKey, tag } = await (0, encrypt_js_1.default)(jweAlgorithm, cek, key, iv, new Uint8Array(0));
     return { encryptedKey, iv: (0, base64url_js_1.encode)(iv), tag: (0, base64url_js_1.encode)(tag) };
-};
+}
 exports.wrap = wrap;
-const unwrap = async (alg, key, encryptedKey, iv, tag) => {
+async function unwrap(alg, key, encryptedKey, iv, tag) {
     const jweAlgorithm = alg.substr(0, 7);
     return (0, decrypt_js_1.default)(jweAlgorithm, key, encryptedKey, iv, tag, new Uint8Array(0));
-};
+}
 exports.unwrap = unwrap;

package/dist/node/cjs/lib/check_key_type.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-const invalid_key_input_js_1 = require("../runtime/invalid_key_input.js");
+const invalid_key_input_js_1 = require("./invalid_key_input.js");
 const is_key_like_js_1 = require("../runtime/is_key_like.js");
 const symmetricTypeCheck = (key) => {
     if (key instanceof Uint8Array)

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

@@ -1,9 +1,15 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.checkEncCryptoKey = exports.checkSigCryptoKey = void 0;
-const global_js_1 = require("../runtime/global.js");
+const env_js_1 = require("../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) {
@@ -13,6 +19,8 @@ function getNamedCurve(alg) {
             return 'P-384';
         case 'ES512':
             return 'P-521';
+        default:
+            throw new Error('unreachable');
     }
 }
 function checkUsage(key, usages) {
@@ -36,65 +44,55 @@ 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 (0, global_js_1.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.`);
-            }
+        case (0, env_js_1.isNodeJs)() && 'EdDSA': {
+            if (key.algorithm.name !== 'NODE-ED25519' && key.algorithm.name !== 'NODE-ED448')
+                throw unusable('NODE-ED25519 or NODE-ED448');
             break;
         }
-        case (0, global_js_1.isCloudflareWorkers)() && 'EdDSA': {
-            if (key.algorithm.name !== 'NODE-ED25519') {
-                throw new TypeError(`CryptoKey does not support this operation, its algorithm.name must be NODE-ED25519.`);
-            }
+        case (0, env_js_1.isCloudflareWorkers)() && 'EdDSA': {
+            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:
@@ -108,53 +106,45 @@ 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/cjs/lib/decrypt_key_management.js

@@ -4,13 +4,13 @@ const aeskw_js_1 = require("../runtime/aeskw.js");
 const ECDH = require("../runtime/ecdhes.js");
 const pbes2kw_js_1 = require("../runtime/pbes2kw.js");
 const rsaes_js_1 = require("../runtime/rsaes.js");
-const aesgcmkw_js_1 = require("../runtime/aesgcmkw.js");
 const base64url_js_1 = require("../runtime/base64url.js");
 const errors_js_1 = require("../util/errors.js");
 const cek_js_1 = require("../lib/cek.js");
 const import_js_1 = require("../key/import.js");
 const check_key_type_js_1 = require("./check_key_type.js");
 const is_object_js_1 = require("./is_object.js");
+const aesgcmkw_js_1 = require("./aesgcmkw.js");
 async function decryptKeyManagement(alg, key, encryptedKey, joseHeader) {
     (0, check_key_type_js_1.default)(alg, key, 'decrypt');
     switch (alg) {

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

@@ -4,12 +4,12 @@ const aeskw_js_1 = require("../runtime/aeskw.js");
 const ECDH = require("../runtime/ecdhes.js");
 const pbes2kw_js_1 = require("../runtime/pbes2kw.js");
 const rsaes_js_1 = require("../runtime/rsaes.js");
-const aesgcmkw_js_1 = require("../runtime/aesgcmkw.js");
 const base64url_js_1 = require("../runtime/base64url.js");
 const cek_js_1 = require("../lib/cek.js");
 const errors_js_1 = require("../util/errors.js");
 const export_js_1 = require("../key/export.js");
 const check_key_type_js_1 = require("./check_key_type.js");
+const aesgcmkw_js_1 = require("./aesgcmkw.js");
 async function encryptKeyManagement(alg, enc, key, providedCek, providedParameters = {}) {
     let encryptedKey;
     let parameters;

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

@@ -1,6 +1,5 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-const util_1 = require("util");
 exports.default = (actual, ...types) => {
     let msg = 'Key must be ';
     if (types.length > 2) {
@@ -23,16 +22,6 @@ exports.default = (actual, ...types) => {
         if (actual.constructor && actual.constructor.name) {
             msg += ` Received an instance of ${actual.constructor.name}`;
         }
-        else {
-            const inspected = (0, util_1.inspect)(actual, { depth: -1 });
-            msg += ` Received ${inspected}`;
-        }
-    }
-    else {
-        let inspected = (0, util_1.inspect)(actual, { colors: false });
-        if (inspected.length > 25)
-            inspected = `${inspected.slice(0, 25)}...`;
-        msg += ` Received type ${typeof actual} (${inspected})`;
     }
     return msg;
 };

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

@@ -9,7 +9,7 @@ const secret_key_js_1 = require("./secret_key.js");
 const webcrypto_js_1 = require("./webcrypto.js");
 const crypto_key_js_1 = require("../lib/crypto_key.js");
 const is_key_object_js_1 = require("./is_key_object.js");
-const invalid_key_input_js_1 = require("./invalid_key_input.js");
+const invalid_key_input_js_1 = require("../lib/invalid_key_input.js");
 const ciphers_js_1 = require("./ciphers.js");
 function checkKeySize(key, alg) {
     if (key.symmetricKeySize << 3 !== parseInt(alg.substr(1, 3), 10)) {

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

@@ -5,7 +5,7 @@ const crypto_1 = require("crypto");
 const buffer_1 = require("buffer");
 const webcrypto_js_1 = require("./webcrypto.js");
 const is_key_object_js_1 = require("./is_key_object.js");
-const invalid_key_input_js_1 = require("./invalid_key_input.js");
+const invalid_key_input_js_1 = require("../lib/invalid_key_input.js");
 const genericExport = (keyType, keyFormat, key) => {
     let keyObject;
     if ((0, webcrypto_js_1.isCryptoKey)(key)) {

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

@@ -10,7 +10,7 @@ const cbc_tag_js_1 = require("./cbc_tag.js");
 const webcrypto_js_1 = require("./webcrypto.js");
 const crypto_key_js_1 = require("../lib/crypto_key.js");
 const is_key_object_js_1 = require("./is_key_object.js");
-const invalid_key_input_js_1 = require("./invalid_key_input.js");
+const invalid_key_input_js_1 = require("../lib/invalid_key_input.js");
 const ciphers_js_1 = require("./ciphers.js");
 async function cbcDecrypt(enc, cek, ciphertext, iv, tag, aad) {
     const keySize = parseInt(enc.substr(1, 3), 10);

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

@@ -10,7 +10,7 @@ const errors_js_1 = require("../util/errors.js");
 const webcrypto_js_1 = require("./webcrypto.js");
 const crypto_key_js_1 = require("../lib/crypto_key.js");
 const is_key_object_js_1 = require("./is_key_object.js");
-const invalid_key_input_js_1 = require("./invalid_key_input.js");
+const invalid_key_input_js_1 = require("../lib/invalid_key_input.js");
 const generateKeyPair = (0, util_1.promisify)(crypto_1.generateKeyPair);
 const deriveKey = async (publicKee, privateKee, algorithm, keyLength, apu = new Uint8Array(0), apv = new Uint8Array(0)) => {
     let publicKey;

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

@@ -8,7 +8,7 @@ const cbc_tag_js_1 = require("./cbc_tag.js");
 const webcrypto_js_1 = require("./webcrypto.js");
 const crypto_key_js_1 = require("../lib/crypto_key.js");
 const is_key_object_js_1 = require("./is_key_object.js");
-const invalid_key_input_js_1 = require("./invalid_key_input.js");
+const invalid_key_input_js_1 = require("../lib/invalid_key_input.js");
 const errors_js_1 = require("../util/errors.js");
 const ciphers_js_1 = require("./ciphers.js");
 async function cbcEncrypt(enc, plaintext, cek, iv, aad) {

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

@@ -6,7 +6,7 @@ const crypto_1 = require("crypto");
 const errors_js_1 = require("../util/errors.js");
 const webcrypto_js_1 = require("./webcrypto.js");
 const is_key_object_js_1 = require("./is_key_object.js");
-const invalid_key_input_js_1 = require("./invalid_key_input.js");
+const invalid_key_input_js_1 = require("../lib/invalid_key_input.js");
 const p256 = buffer_1.Buffer.from([42, 134, 72, 206, 61, 3, 1, 7]);
 const p384 = buffer_1.Buffer.from([43, 129, 4, 0, 34]);
 const p521 = buffer_1.Buffer.from([43, 129, 4, 0, 35]);

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

@@ -4,7 +4,7 @@ const crypto_1 = require("crypto");
 const webcrypto_js_1 = require("./webcrypto.js");
 const crypto_key_js_1 = require("../lib/crypto_key.js");
 const secret_key_js_1 = require("./secret_key.js");
-const invalid_key_input_js_1 = require("./invalid_key_input.js");
+const invalid_key_input_js_1 = require("../lib/invalid_key_input.js");
 function getSignVerifyKey(alg, key, usage) {
     if (key instanceof Uint8Array) {
         if (!alg.startsWith('HS')) {

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

@@ -7,7 +7,7 @@ const errors_js_1 = require("../util/errors.js");
 const get_named_curve_js_1 = require("./get_named_curve.js");
 const webcrypto_js_1 = require("./webcrypto.js");
 const is_key_object_js_1 = require("./is_key_object.js");
-const invalid_key_input_js_1 = require("./invalid_key_input.js");
+const invalid_key_input_js_1 = require("../lib/invalid_key_input.js");
 const [major, minor] = process.version
     .substr(1)
     .split('.')

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

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

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

@@ -11,7 +11,7 @@ const check_p2s_js_1 = require("../lib/check_p2s.js");
 const webcrypto_js_1 = require("./webcrypto.js");
 const crypto_key_js_1 = require("../lib/crypto_key.js");
 const is_key_object_js_1 = require("./is_key_object.js");
-const invalid_key_input_js_1 = require("./invalid_key_input.js");
+const invalid_key_input_js_1 = require("../lib/invalid_key_input.js");
 const pbkdf2 = (0, util_1.promisify)(crypto_1.pbkdf2);
 function getPassword(key, alg) {
     if ((0, is_key_object_js_1.default)(key)) {

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

@@ -6,7 +6,7 @@ const check_modulus_length_js_1 = require("./check_modulus_length.js");
 const webcrypto_js_1 = require("./webcrypto.js");
 const crypto_key_js_1 = require("../lib/crypto_key.js");
 const is_key_object_js_1 = require("./is_key_object.js");
-const invalid_key_input_js_1 = require("./invalid_key_input.js");
+const invalid_key_input_js_1 = require("../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/node/esm/{runtime → lib}/aesgcmkw.js

@@ -1,14 +1,14 @@
-import encrypt from './encrypt.js';
-import decrypt from './decrypt.js';
-import generateIv from '../lib/iv.js';
-import { encode as base64url } from './base64url.js';
-export const wrap = async (alg, key, cek, iv) => {
+import encrypt from '../runtime/encrypt.js';
+import decrypt from '../runtime/decrypt.js';
+import generateIv from './iv.js';
+import { encode as base64url } from '../runtime/base64url.js';
+export async function wrap(alg, key, cek, iv) {
     const jweAlgorithm = alg.substr(0, 7);
     iv || (iv = generateIv(jweAlgorithm));
     const { ciphertext: encryptedKey, tag } = await encrypt(jweAlgorithm, cek, key, iv, new Uint8Array(0));
     return { encryptedKey, iv: base64url(iv), tag: base64url(tag) };
-};
-export const unwrap = async (alg, key, encryptedKey, iv, tag) => {
+}
+export async function unwrap(alg, key, encryptedKey, iv, tag) {
     const jweAlgorithm = alg.substr(0, 7);
     return decrypt(jweAlgorithm, key, encryptedKey, iv, tag, new Uint8Array(0));
-};
+}

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

@@ -1,4 +1,4 @@
-import invalidKeyInput from '../runtime/invalid_key_input.js';
+import invalidKeyInput from './invalid_key_input.js';
 import isKeyLike, { types } from '../runtime/is_key_like.js';
 const symmetricTypeCheck = (key) => {
     if (key instanceof Uint8Array)