jose 5.10.0 → 6.0.0

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

@@ -1,80 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-const node_crypto_1 = require("node:crypto");
-const check_iv_length_js_1 = require("../lib/check_iv_length.js");
-const check_cek_length_js_1 = require("./check_cek_length.js");
-const buffer_utils_js_1 = require("../lib/buffer_utils.js");
-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("../lib/invalid_key_input.js");
-const iv_js_1 = require("../lib/iv.js");
-const errors_js_1 = require("../util/errors.js");
-const ciphers_js_1 = require("./ciphers.js");
-const is_key_like_js_1 = require("./is_key_like.js");
-function cbcEncrypt(enc, plaintext, cek, iv, aad) {
-    const keySize = parseInt(enc.slice(1, 4), 10);
-    if ((0, is_key_object_js_1.default)(cek)) {
-        cek = cek.export();
-    }
-    const encKey = cek.subarray(keySize >> 3);
-    const macKey = cek.subarray(0, keySize >> 3);
-    const algorithm = `aes-${keySize}-cbc`;
-    if (!(0, ciphers_js_1.default)(algorithm)) {
-        throw new errors_js_1.JOSENotSupported(`alg ${enc} is not supported by your javascript runtime`);
-    }
-    const cipher = (0, node_crypto_1.createCipheriv)(algorithm, encKey, iv);
-    const ciphertext = (0, buffer_utils_js_1.concat)(cipher.update(plaintext), cipher.final());
-    const macSize = parseInt(enc.slice(-3), 10);
-    const tag = (0, cbc_tag_js_1.default)(aad, iv, ciphertext, macSize, macKey, keySize);
-    return { ciphertext, tag, iv };
-}
-function gcmEncrypt(enc, plaintext, cek, iv, aad) {
-    const keySize = parseInt(enc.slice(1, 4), 10);
-    const algorithm = `aes-${keySize}-gcm`;
-    if (!(0, ciphers_js_1.default)(algorithm)) {
-        throw new errors_js_1.JOSENotSupported(`alg ${enc} is not supported by your javascript runtime`);
-    }
-    const cipher = (0, node_crypto_1.createCipheriv)(algorithm, cek, iv, { authTagLength: 16 });
-    if (aad.byteLength) {
-        cipher.setAAD(aad, { plaintextLength: plaintext.length });
-    }
-    const ciphertext = cipher.update(plaintext);
-    cipher.final();
-    const tag = cipher.getAuthTag();
-    return { ciphertext, tag, iv };
-}
-const encrypt = (enc, plaintext, cek, iv, aad) => {
-    let key;
-    if ((0, webcrypto_js_1.isCryptoKey)(cek)) {
-        (0, crypto_key_js_1.checkEncCryptoKey)(cek, enc, 'encrypt');
-        key = node_crypto_1.KeyObject.from(cek);
-    }
-    else if (cek instanceof Uint8Array || (0, is_key_object_js_1.default)(cek)) {
-        key = cek;
-    }
-    else {
-        throw new TypeError((0, invalid_key_input_js_1.default)(cek, ...is_key_like_js_1.types, 'Uint8Array'));
-    }
-    (0, check_cek_length_js_1.default)(enc, key);
-    if (iv) {
-        (0, check_iv_length_js_1.default)(enc, iv);
-    }
-    else {
-        iv = (0, iv_js_1.default)(enc);
-    }
-    switch (enc) {
-        case 'A128CBC-HS256':
-        case 'A192CBC-HS384':
-        case 'A256CBC-HS512':
-            return cbcEncrypt(enc, plaintext, key, iv, aad);
-        case 'A128GCM':
-        case 'A192GCM':
-        case 'A256GCM':
-            return gcmEncrypt(enc, plaintext, key, iv, aad);
-        default:
-            throw new errors_js_1.JOSENotSupported('Unsupported JWE Content Encryption Algorithm');
-    }
-};
-exports.default = encrypt;

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

@@ -1,45 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-const http = require("node:http");
-const https = require("node:https");
-const node_events_1 = require("node:events");
-const errors_js_1 = require("../util/errors.js");
-const buffer_utils_js_1 = require("../lib/buffer_utils.js");
-const fetchJwks = async (url, timeout, options) => {
-    let get;
-    switch (url.protocol) {
-        case 'https:':
-            get = https.get;
-            break;
-        case 'http:':
-            get = http.get;
-            break;
-        default:
-            throw new TypeError('Unsupported URL protocol.');
-    }
-    const { agent, headers } = options;
-    const req = get(url.href, {
-        agent,
-        timeout,
-        headers,
-    });
-    const [response] = (await Promise.race([(0, node_events_1.once)(req, 'response'), (0, node_events_1.once)(req, 'timeout')]));
-    if (!response) {
-        req.destroy();
-        throw new errors_js_1.JWKSTimeout();
-    }
-    if (response.statusCode !== 200) {
-        throw new errors_js_1.JOSEError('Expected 200 OK from the JSON Web Key Set HTTP response');
-    }
-    const parts = [];
-    for await (const part of response) {
-        parts.push(part);
-    }
-    try {
-        return JSON.parse(buffer_utils_js_1.decoder.decode((0, buffer_utils_js_1.concat)(...parts)));
-    }
-    catch {
-        throw new errors_js_1.JOSEError('Failed to parse the JSON Web Key Set HTTP response as JSON');
-    }
-};
-exports.default = fetchJwks;

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

@@ -1,103 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.generateSecret = generateSecret;
-exports.generateKeyPair = generateKeyPair;
-const node_crypto_1 = require("node:crypto");
-const node_util_1 = require("node:util");
-const random_js_1 = require("./random.js");
-const errors_js_1 = require("../util/errors.js");
-const generate = (0, node_util_1.promisify)(node_crypto_1.generateKeyPair);
-async function generateSecret(alg, options) {
-    let length;
-    switch (alg) {
-        case 'HS256':
-        case 'HS384':
-        case 'HS512':
-        case 'A128CBC-HS256':
-        case 'A192CBC-HS384':
-        case 'A256CBC-HS512':
-            length = parseInt(alg.slice(-3), 10);
-            break;
-        case 'A128KW':
-        case 'A192KW':
-        case 'A256KW':
-        case 'A128GCMKW':
-        case 'A192GCMKW':
-        case 'A256GCMKW':
-        case 'A128GCM':
-        case 'A192GCM':
-        case 'A256GCM':
-            length = parseInt(alg.slice(1, 4), 10);
-            break;
-        default:
-            throw new errors_js_1.JOSENotSupported('Invalid or unsupported JWK "alg" (Algorithm) Parameter value');
-    }
-    return (0, node_crypto_1.createSecretKey)((0, random_js_1.default)(new Uint8Array(length >> 3)));
-}
-async function generateKeyPair(alg, options) {
-    switch (alg) {
-        case 'RS256':
-        case 'RS384':
-        case 'RS512':
-        case 'PS256':
-        case 'PS384':
-        case 'PS512':
-        case 'RSA-OAEP':
-        case 'RSA-OAEP-256':
-        case 'RSA-OAEP-384':
-        case 'RSA-OAEP-512':
-        case 'RSA1_5': {
-            const modulusLength = options?.modulusLength ?? 2048;
-            if (typeof modulusLength !== 'number' || modulusLength < 2048) {
-                throw new errors_js_1.JOSENotSupported('Invalid or unsupported modulusLength option provided, 2048 bits or larger keys must be used');
-            }
-            const keypair = await generate('rsa', {
-                modulusLength,
-                publicExponent: 0x10001,
-            });
-            return keypair;
-        }
-        case 'ES256':
-            return generate('ec', { namedCurve: 'P-256' });
-        case 'ES256K':
-            return generate('ec', { namedCurve: 'secp256k1' });
-        case 'ES384':
-            return generate('ec', { namedCurve: 'P-384' });
-        case 'ES512':
-            return generate('ec', { namedCurve: 'P-521' });
-        case 'Ed25519':
-            return generate('ed25519');
-        case 'EdDSA': {
-            switch (options?.crv) {
-                case undefined:
-                case 'Ed25519':
-                    return generate('ed25519');
-                case 'Ed448':
-                    return generate('ed448');
-                default:
-                    throw new errors_js_1.JOSENotSupported('Invalid or unsupported crv option provided, supported values are Ed25519 and Ed448');
-            }
-        }
-        case 'ECDH-ES':
-        case 'ECDH-ES+A128KW':
-        case 'ECDH-ES+A192KW':
-        case 'ECDH-ES+A256KW': {
-            const crv = options?.crv ?? 'P-256';
-            switch (crv) {
-                case undefined:
-                case 'P-256':
-                case 'P-384':
-                case 'P-521':
-                    return generate('ec', { namedCurve: crv });
-                case 'X25519':
-                    return generate('x25519');
-                case 'X448':
-                    return generate('x448');
-                default:
-                    throw new errors_js_1.JOSENotSupported('Invalid or unsupported crv option provided, supported values are P-256, P-384, P-521, X25519, and X448');
-            }
-        }
-        default:
-            throw new errors_js_1.JOSENotSupported('Invalid or unsupported JWK "alg" (Algorithm) Parameter value');
-    }
-}

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

@@ -1,61 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.weakMap = void 0;
-const node_crypto_1 = require("node: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("../lib/invalid_key_input.js");
-const is_key_like_js_1 = require("./is_key_like.js");
-const is_jwk_js_1 = require("../lib/is_jwk.js");
-exports.weakMap = new WeakMap();
-const namedCurveToJOSE = (namedCurve) => {
-    switch (namedCurve) {
-        case 'prime256v1':
-            return 'P-256';
-        case 'secp384r1':
-            return 'P-384';
-        case 'secp521r1':
-            return 'P-521';
-        case 'secp256k1':
-            return 'secp256k1';
-        default:
-            throw new errors_js_1.JOSENotSupported('Unsupported key curve for this operation');
-    }
-};
-const getNamedCurve = (kee, raw) => {
-    let key;
-    if ((0, webcrypto_js_1.isCryptoKey)(kee)) {
-        key = node_crypto_1.KeyObject.from(kee);
-    }
-    else if ((0, is_key_object_js_1.default)(kee)) {
-        key = kee;
-    }
-    else if ((0, is_jwk_js_1.isJWK)(kee)) {
-        return kee.crv;
-    }
-    else {
-        throw new TypeError((0, invalid_key_input_js_1.default)(kee, ...is_key_like_js_1.types));
-    }
-    if (key.type === 'secret') {
-        throw new TypeError('only "private" or "public" type keys can be used for this operation');
-    }
-    switch (key.asymmetricKeyType) {
-        case 'ed25519':
-        case 'ed448':
-            return `Ed${key.asymmetricKeyType.slice(2)}`;
-        case 'x25519':
-        case 'x448':
-            return `X${key.asymmetricKeyType.slice(1)}`;
-        case 'ec': {
-            const namedCurve = key.asymmetricKeyDetails.namedCurve;
-            if (raw) {
-                return namedCurve;
-            }
-            return namedCurveToJOSE(namedCurve);
-        }
-        default:
-            throw new TypeError('Invalid asymmetric key type for this operation');
-    }
-};
-exports.default = getNamedCurve;

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

@@ -1,31 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.default = getSignVerifyKey;
-const node_crypto_1 = require("node:crypto");
-const webcrypto_js_1 = require("./webcrypto.js");
-const crypto_key_js_1 = require("../lib/crypto_key.js");
-const invalid_key_input_js_1 = require("../lib/invalid_key_input.js");
-const is_key_like_js_1 = require("./is_key_like.js");
-const jwk = require("../lib/is_jwk.js");
-function getSignVerifyKey(alg, key, usage) {
-    if (key instanceof Uint8Array) {
-        if (!alg.startsWith('HS')) {
-            throw new TypeError((0, invalid_key_input_js_1.default)(key, ...is_key_like_js_1.types));
-        }
-        return (0, node_crypto_1.createSecretKey)(key);
-    }
-    if (key instanceof node_crypto_1.KeyObject) {
-        return key;
-    }
-    if ((0, webcrypto_js_1.isCryptoKey)(key)) {
-        (0, crypto_key_js_1.checkSigCryptoKey)(key, alg, usage);
-        return node_crypto_1.KeyObject.from(key);
-    }
-    if (jwk.isJWK(key)) {
-        if (alg.startsWith('HS')) {
-            return (0, node_crypto_1.createSecretKey)(Buffer.from(key.k, 'base64url'));
-        }
-        return key;
-    }
-    throw new TypeError((0, invalid_key_input_js_1.default)(key, ...is_key_like_js_1.types, 'Uint8Array', 'JSON Web Key'));
-}

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

@@ -1,16 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.default = hmacDigest;
-const errors_js_1 = require("../util/errors.js");
-function hmacDigest(alg) {
-    switch (alg) {
-        case 'HS256':
-            return 'sha256';
-        case 'HS384':
-            return 'sha384';
-        case 'HS512':
-            return 'sha512';
-        default:
-            throw new errors_js_1.JOSENotSupported(`alg ${alg} is not supported either by JOSE or your javascript runtime`);
-    }
-}

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

@@ -1,11 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.types = void 0;
-const webcrypto_js_1 = require("./webcrypto.js");
-const is_key_object_js_1 = require("./is_key_object.js");
-exports.default = (key) => (0, is_key_object_js_1.default)(key) || (0, webcrypto_js_1.isCryptoKey)(key);
-const types = ['KeyObject'];
-exports.types = types;
-if (globalThis.CryptoKey || webcrypto_js_1.default?.CryptoKey) {
-    types.push('CryptoKey');
-}

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

@@ -1,4 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-const util = require("node:util");
-exports.default = (obj) => util.types.isKeyObject(obj);

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

@@ -1,10 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-const node_crypto_1 = require("node:crypto");
-const parse = (key) => {
-    if (key.d) {
-        return (0, node_crypto_1.createPrivateKey)({ format: 'jwk', key });
-    }
-    return (0, node_crypto_1.createPublicKey)({ format: 'jwk', key });
-};
-exports.default = parse;

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

@@ -1,36 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-const node_crypto_1 = require("node:crypto");
-const base64url_js_1 = require("./base64url.js");
-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("../lib/invalid_key_input.js");
-const is_key_like_js_1 = require("./is_key_like.js");
-const keyToJWK = (key) => {
-    let keyObject;
-    if ((0, webcrypto_js_1.isCryptoKey)(key)) {
-        if (!key.extractable) {
-            throw new TypeError('CryptoKey is not extractable');
-        }
-        keyObject = node_crypto_1.KeyObject.from(key);
-    }
-    else if ((0, is_key_object_js_1.default)(key)) {
-        keyObject = key;
-    }
-    else if (key instanceof Uint8Array) {
-        return {
-            kty: 'oct',
-            k: (0, base64url_js_1.encode)(key),
-        };
-    }
-    else {
-        throw new TypeError((0, invalid_key_input_js_1.default)(key, ...is_key_like_js_1.types, 'Uint8Array'));
-    }
-    if (keyObject.type !== 'secret' &&
-        !['rsa', 'ec', 'ed25519', 'x25519', 'ed448', 'x448'].includes(keyObject.asymmetricKeyType)) {
-        throw new errors_js_1.JOSENotSupported('Unsupported key asymmetricKeyType');
-    }
-    return keyObject.export({ format: 'jwk' });
-};
-exports.default = keyToJWK;

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

@@ -1,111 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.default = keyForCrypto;
-const node_crypto_1 = require("node:crypto");
-const get_named_curve_js_1 = require("./get_named_curve.js");
-const errors_js_1 = require("../util/errors.js");
-const check_key_length_js_1 = require("./check_key_length.js");
-const ecCurveAlgMap = new Map([
-    ['ES256', 'P-256'],
-    ['ES256K', 'secp256k1'],
-    ['ES384', 'P-384'],
-    ['ES512', 'P-521'],
-]);
-function keyForCrypto(alg, key) {
-    let asymmetricKeyType;
-    let asymmetricKeyDetails;
-    let isJWK;
-    if (key instanceof node_crypto_1.KeyObject) {
-        asymmetricKeyType = key.asymmetricKeyType;
-        asymmetricKeyDetails = key.asymmetricKeyDetails;
-    }
-    else {
-        isJWK = true;
-        switch (key.kty) {
-            case 'RSA':
-                asymmetricKeyType = 'rsa';
-                break;
-            case 'EC':
-                asymmetricKeyType = 'ec';
-                break;
-            case 'OKP': {
-                if (key.crv === 'Ed25519') {
-                    asymmetricKeyType = 'ed25519';
-                    break;
-                }
-                if (key.crv === 'Ed448') {
-                    asymmetricKeyType = 'ed448';
-                    break;
-                }
-                throw new TypeError('Invalid key for this operation, its crv must be Ed25519 or Ed448');
-            }
-            default:
-                throw new TypeError('Invalid key for this operation, its kty must be RSA, OKP, or EC');
-        }
-    }
-    let options;
-    switch (alg) {
-        case 'Ed25519':
-            if (asymmetricKeyType !== 'ed25519') {
-                throw new TypeError(`Invalid key for this operation, its asymmetricKeyType must be ed25519`);
-            }
-            break;
-        case 'EdDSA':
-            if (!['ed25519', 'ed448'].includes(asymmetricKeyType)) {
-                throw new TypeError('Invalid key for this operation, its asymmetricKeyType must be ed25519 or ed448');
-            }
-            break;
-        case 'RS256':
-        case 'RS384':
-        case 'RS512':
-            if (asymmetricKeyType !== 'rsa') {
-                throw new TypeError('Invalid key for this operation, its asymmetricKeyType must be rsa');
-            }
-            (0, check_key_length_js_1.default)(key, alg);
-            break;
-        case 'PS256':
-        case 'PS384':
-        case 'PS512':
-            if (asymmetricKeyType === 'rsa-pss') {
-                const { hashAlgorithm, mgf1HashAlgorithm, saltLength } = asymmetricKeyDetails;
-                const length = parseInt(alg.slice(-3), 10);
-                if (hashAlgorithm !== undefined &&
-                    (hashAlgorithm !== `sha${length}` || mgf1HashAlgorithm !== hashAlgorithm)) {
-                    throw new TypeError(`Invalid key for this operation, its RSA-PSS parameters do not meet the requirements of "alg" ${alg}`);
-                }
-                if (saltLength !== undefined && saltLength > length >> 3) {
-                    throw new TypeError(`Invalid key for this operation, its RSA-PSS parameter saltLength does not meet the requirements of "alg" ${alg}`);
-                }
-            }
-            else if (asymmetricKeyType !== 'rsa') {
-                throw new TypeError('Invalid key for this operation, its asymmetricKeyType must be rsa or rsa-pss');
-            }
-            (0, check_key_length_js_1.default)(key, alg);
-            options = {
-                padding: node_crypto_1.constants.RSA_PKCS1_PSS_PADDING,
-                saltLength: node_crypto_1.constants.RSA_PSS_SALTLEN_DIGEST,
-            };
-            break;
-        case 'ES256':
-        case 'ES256K':
-        case 'ES384':
-        case 'ES512': {
-            if (asymmetricKeyType !== 'ec') {
-                throw new TypeError('Invalid key for this operation, its asymmetricKeyType must be ec');
-            }
-            const actual = (0, get_named_curve_js_1.default)(key);
-            const expected = ecCurveAlgMap.get(alg);
-            if (actual !== expected) {
-                throw new TypeError(`Invalid key curve for the algorithm, its curve must be ${expected}, got ${actual}`);
-            }
-            options = { dsaEncoding: 'ieee-p1363' };
-            break;
-        }
-        default:
-            throw new errors_js_1.JOSENotSupported(`alg ${alg} is not supported either by JOSE or your javascript runtime`);
-    }
-    if (isJWK) {
-        return { format: 'jwk', key, ...options };
-    }
-    return options ? { ...options, key } : key;
-}

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

@@ -1,3 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.default = {};

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

@@ -1,48 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.decrypt = exports.encrypt = void 0;
-const node_util_1 = require("node:util");
-const node_crypto_1 = require("node:crypto");
-const random_js_1 = require("./random.js");
-const buffer_utils_js_1 = require("../lib/buffer_utils.js");
-const base64url_js_1 = require("./base64url.js");
-const aeskw_js_1 = require("./aeskw.js");
-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("../lib/invalid_key_input.js");
-const is_key_like_js_1 = require("./is_key_like.js");
-const pbkdf2 = (0, node_util_1.promisify)(node_crypto_1.pbkdf2);
-function getPassword(key, alg) {
-    if ((0, is_key_object_js_1.default)(key)) {
-        return key.export();
-    }
-    if (key instanceof Uint8Array) {
-        return key;
-    }
-    if ((0, webcrypto_js_1.isCryptoKey)(key)) {
-        (0, crypto_key_js_1.checkEncCryptoKey)(key, alg, 'deriveBits', 'deriveKey');
-        return node_crypto_1.KeyObject.from(key).export();
-    }
-    throw new TypeError((0, invalid_key_input_js_1.default)(key, ...is_key_like_js_1.types, 'Uint8Array'));
-}
-const encrypt = async (alg, key, cek, p2c = 2048, p2s = (0, random_js_1.default)(new Uint8Array(16))) => {
-    (0, check_p2s_js_1.default)(p2s);
-    const salt = (0, buffer_utils_js_1.p2s)(alg, p2s);
-    const keylen = parseInt(alg.slice(13, 16), 10) >> 3;
-    const password = getPassword(key, alg);
-    const derivedKey = await pbkdf2(password, salt, p2c, keylen, `sha${alg.slice(8, 11)}`);
-    const encryptedKey = await (0, aeskw_js_1.wrap)(alg.slice(-6), derivedKey, cek);
-    return { encryptedKey, p2c, p2s: (0, base64url_js_1.encode)(p2s) };
-};
-exports.encrypt = encrypt;
-const decrypt = async (alg, key, encryptedKey, p2c, p2s) => {
-    (0, check_p2s_js_1.default)(p2s);
-    const salt = (0, buffer_utils_js_1.p2s)(alg, p2s);
-    const keylen = parseInt(alg.slice(13, 16), 10) >> 3;
-    const password = getPassword(key, alg);
-    const derivedKey = await pbkdf2(password, salt, p2c, keylen, `sha${alg.slice(8, 11)}`);
-    return (0, aeskw_js_1.unwrap)(alg.slice(-6), derivedKey, encryptedKey);
-};
-exports.decrypt = decrypt;

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

@@ -1,5 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.default = void 0;
-var node_crypto_1 = require("node:crypto");
-Object.defineProperty(exports, "default", { enumerable: true, get: function () { return node_crypto_1.randomFillSync; } });

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

@@ -1,71 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.decrypt = exports.encrypt = void 0;
-const node_crypto_1 = require("node:crypto");
-const node_util_1 = require("node:util");
-const check_key_length_js_1 = require("./check_key_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("../lib/invalid_key_input.js");
-const is_key_like_js_1 = require("./is_key_like.js");
-const checkKey = (key, alg) => {
-    if (key.asymmetricKeyType !== 'rsa') {
-        throw new TypeError('Invalid key for this operation, its asymmetricKeyType must be rsa');
-    }
-    (0, check_key_length_js_1.default)(key, alg);
-};
-const RSA1_5 = (0, node_util_1.deprecate)(() => node_crypto_1.constants.RSA_PKCS1_PADDING, 'The RSA1_5 "alg" (JWE Algorithm) is deprecated and will be removed in the next major revision.');
-const resolvePadding = (alg) => {
-    switch (alg) {
-        case 'RSA-OAEP':
-        case 'RSA-OAEP-256':
-        case 'RSA-OAEP-384':
-        case 'RSA-OAEP-512':
-            return node_crypto_1.constants.RSA_PKCS1_OAEP_PADDING;
-        case 'RSA1_5':
-            return RSA1_5();
-        default:
-            return undefined;
-    }
-};
-const resolveOaepHash = (alg) => {
-    switch (alg) {
-        case 'RSA-OAEP':
-            return 'sha1';
-        case 'RSA-OAEP-256':
-            return 'sha256';
-        case 'RSA-OAEP-384':
-            return 'sha384';
-        case 'RSA-OAEP-512':
-            return 'sha512';
-        default:
-            return undefined;
-    }
-};
-function ensureKeyObject(key, alg, ...usages) {
-    if ((0, is_key_object_js_1.default)(key)) {
-        return key;
-    }
-    if ((0, webcrypto_js_1.isCryptoKey)(key)) {
-        (0, crypto_key_js_1.checkEncCryptoKey)(key, alg, ...usages);
-        return node_crypto_1.KeyObject.from(key);
-    }
-    throw new TypeError((0, invalid_key_input_js_1.default)(key, ...is_key_like_js_1.types));
-}
-const encrypt = (alg, key, cek) => {
-    const padding = resolvePadding(alg);
-    const oaepHash = resolveOaepHash(alg);
-    const keyObject = ensureKeyObject(key, alg, 'wrapKey', 'encrypt');
-    checkKey(keyObject, alg);
-    return (0, node_crypto_1.publicEncrypt)({ key: keyObject, oaepHash, padding }, cek);
-};
-exports.encrypt = encrypt;
-const decrypt = (alg, key, encryptedKey) => {
-    const padding = resolvePadding(alg);
-    const oaepHash = resolveOaepHash(alg);
-    const keyObject = ensureKeyObject(key, alg, 'unwrapKey', 'decrypt');
-    checkKey(keyObject, alg);
-    return (0, node_crypto_1.privateDecrypt)({ key: keyObject, oaepHash, padding }, encryptedKey);
-};
-exports.decrypt = decrypt;

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

@@ -1,3 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.default = 'node:crypto';