jose 5.9.6 → 6.0.0

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

@@ -1,51 +0,0 @@
-import digest from '../runtime/digest.js';
-export const encoder = new TextEncoder();
-export const decoder = new TextDecoder();
-const MAX_INT32 = 2 ** 32;
-export function concat(...buffers) {
-    const size = buffers.reduce((acc, { length }) => acc + length, 0);
-    const buf = new Uint8Array(size);
-    let i = 0;
-    for (const buffer of buffers) {
-        buf.set(buffer, i);
-        i += buffer.length;
-    }
-    return buf;
-}
-export function p2s(alg, p2sInput) {
-    return concat(encoder.encode(alg), new Uint8Array([0]), p2sInput);
-}
-function writeUInt32BE(buf, value, offset) {
-    if (value < 0 || value >= MAX_INT32) {
-        throw new RangeError(`value must be >= 0 and <= ${MAX_INT32 - 1}. Received ${value}`);
-    }
-    buf.set([value >>> 24, value >>> 16, value >>> 8, value & 0xff], offset);
-}
-export function uint64be(value) {
-    const high = Math.floor(value / MAX_INT32);
-    const low = value % MAX_INT32;
-    const buf = new Uint8Array(8);
-    writeUInt32BE(buf, high, 0);
-    writeUInt32BE(buf, low, 4);
-    return buf;
-}
-export function uint32be(value) {
-    const buf = new Uint8Array(4);
-    writeUInt32BE(buf, value);
-    return buf;
-}
-export function lengthAndInput(input) {
-    return concat(uint32be(input.length), input);
-}
-export async function concatKdf(secret, bits, value) {
-    const iterations = Math.ceil((bits >> 3) / 32);
-    const res = new Uint8Array(iterations * 32);
-    for (let iter = 0; iter < iterations; iter++) {
-        const buf = new Uint8Array(4 + secret.length + value.length);
-        buf.set(uint32be(iter + 1));
-        buf.set(secret, 4);
-        buf.set(value, 4 + secret.length);
-        res.set(await digest('sha256', buf), iter * 32);
-    }
-    return res.slice(0, bits >> 3);
-}

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

@@ -1,20 +0,0 @@
-import { JOSENotSupported } from '../util/errors.js';
-import random from '../runtime/random.js';
-export function bitLength(alg) {
-    switch (alg) {
-        case 'A128GCM':
-            return 128;
-        case 'A192GCM':
-            return 192;
-        case 'A256GCM':
-        case 'A128CBC-HS256':
-            return 256;
-        case 'A192CBC-HS384':
-            return 384;
-        case 'A256CBC-HS512':
-            return 512;
-        default:
-            throw new JOSENotSupported(`Unsupported JWE Algorithm: ${alg}`);
-    }
-}
-export default (alg) => random(new Uint8Array(bitLength(alg) >> 3));

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

@@ -1,8 +0,0 @@
-import { JWEInvalid } from '../util/errors.js';
-import { bitLength } from './iv.js';
-const checkIvLength = (enc, iv) => {
-    if (iv.length << 3 !== bitLength(enc)) {
-        throw new JWEInvalid('Invalid Initialization Vector length');
-    }
-};
-export default checkIvLength;

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

@@ -1,77 +0,0 @@
-import { withAlg as invalidKeyInput } from './invalid_key_input.js';
-import isKeyLike, { types } from '../runtime/is_key_like.js';
-import * as jwk from './is_jwk.js';
-const tag = (key) => key?.[Symbol.toStringTag];
-const jwkMatchesOp = (alg, key, usage) => {
-    if (key.use !== undefined && key.use !== 'sig') {
-        throw new TypeError('Invalid key for this operation, when present its use must be sig');
-    }
-    if (key.key_ops !== undefined && key.key_ops.includes?.(usage) !== true) {
-        throw new TypeError(`Invalid key for this operation, when present its key_ops must include ${usage}`);
-    }
-    if (key.alg !== undefined && key.alg !== alg) {
-        throw new TypeError(`Invalid key for this operation, when present its alg must be ${alg}`);
-    }
-    return true;
-};
-const symmetricTypeCheck = (alg, key, usage, allowJwk) => {
-    if (key instanceof Uint8Array)
-        return;
-    if (allowJwk && jwk.isJWK(key)) {
-        if (jwk.isSecretJWK(key) && jwkMatchesOp(alg, key, usage))
-            return;
-        throw new TypeError(`JSON Web Key for symmetric algorithms must have JWK "kty" (Key Type) equal to "oct" and the JWK "k" (Key Value) present`);
-    }
-    if (!isKeyLike(key)) {
-        throw new TypeError(invalidKeyInput(alg, key, ...types, 'Uint8Array', allowJwk ? 'JSON Web Key' : null));
-    }
-    if (key.type !== 'secret') {
-        throw new TypeError(`${tag(key)} instances for symmetric algorithms must be of type "secret"`);
-    }
-};
-const asymmetricTypeCheck = (alg, key, usage, allowJwk) => {
-    if (allowJwk && jwk.isJWK(key)) {
-        switch (usage) {
-            case 'sign':
-                if (jwk.isPrivateJWK(key) && jwkMatchesOp(alg, key, usage))
-                    return;
-                throw new TypeError(`JSON Web Key for this operation be a private JWK`);
-            case 'verify':
-                if (jwk.isPublicJWK(key) && jwkMatchesOp(alg, key, usage))
-                    return;
-                throw new TypeError(`JSON Web Key for this operation be a public JWK`);
-        }
-    }
-    if (!isKeyLike(key)) {
-        throw new TypeError(invalidKeyInput(alg, key, ...types, allowJwk ? 'JSON Web Key' : null));
-    }
-    if (key.type === 'secret') {
-        throw new TypeError(`${tag(key)} instances for asymmetric algorithms must not be of type "secret"`);
-    }
-    if (usage === 'sign' && key.type === 'public') {
-        throw new TypeError(`${tag(key)} instances for asymmetric algorithm signing must be of type "private"`);
-    }
-    if (usage === 'decrypt' && key.type === 'public') {
-        throw new TypeError(`${tag(key)} instances for asymmetric algorithm decryption must be of type "private"`);
-    }
-    if (key.algorithm && usage === 'verify' && key.type === 'private') {
-        throw new TypeError(`${tag(key)} instances for asymmetric algorithm verifying must be of type "public"`);
-    }
-    if (key.algorithm && usage === 'encrypt' && key.type === 'private') {
-        throw new TypeError(`${tag(key)} instances for asymmetric algorithm encryption must be of type "public"`);
-    }
-};
-function checkKeyType(allowJwk, alg, key, usage) {
-    const symmetric = alg.startsWith('HS') ||
-        alg === 'dir' ||
-        alg.startsWith('PBES2') ||
-        /^A\d{3}(?:GCM)?KW$/.test(alg);
-    if (symmetric) {
-        symmetricTypeCheck(alg, key, usage, allowJwk);
-    }
-    else {
-        asymmetricTypeCheck(alg, key, usage, allowJwk);
-    }
-}
-export default checkKeyType.bind(undefined, false);
-export const checkKeyTypeWithJwk = checkKeyType.bind(undefined, true);

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

@@ -1,6 +0,0 @@
-import { JWEInvalid } from '../util/errors.js';
-export default function checkP2s(p2s) {
-    if (!(p2s instanceof Uint8Array) || p2s.length < 8) {
-        throw new JWEInvalid('PBES2 Salt Input must be 8 or more octets');
-    }
-}

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

@@ -1 +0,0 @@
-export default (date) => Math.floor(date.getTime() / 1000);

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

@@ -1,31 +0,0 @@
-function message(msg, actual, ...types) {
-    types = types.filter(Boolean);
-    if (types.length > 2) {
-        const last = types.pop();
-        msg += `one of type ${types.join(', ')}, or ${last}.`;
-    }
-    else if (types.length === 2) {
-        msg += `one of type ${types[0]} or ${types[1]}.`;
-    }
-    else {
-        msg += `of type ${types[0]}.`;
-    }
-    if (actual == null) {
-        msg += ` Received ${actual}`;
-    }
-    else if (typeof actual === 'function' && actual.name) {
-        msg += ` Received function ${actual.name}`;
-    }
-    else if (typeof actual === 'object' && actual != null) {
-        if (actual.constructor?.name) {
-            msg += ` Received an instance of ${actual.constructor.name}`;
-        }
-    }
-    return msg;
-}
-export default (actual, ...types) => {
-    return message('Key must be ', actual, ...types);
-};
-export function withAlg(alg, actual, ...types) {
-    return message(`Key for the ${alg} algorithm must be `, actual, ...types);
-}

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

@@ -1,13 +0,0 @@
-import isObject from './is_object.js';
-export function isJWK(key) {
-    return isObject(key) && typeof key.kty === 'string';
-}
-export function isPrivateJWK(key) {
-    return key.kty !== 'oct' && typeof key.d === 'string';
-}
-export function isPublicJWK(key) {
-    return key.kty !== 'oct' && typeof key.d === 'undefined';
-}
-export function isSecretJWK(key) {
-    return isJWK(key) && key.kty === 'oct' && typeof key.k === 'string';
-}

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

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

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

@@ -1,104 +0,0 @@
-import { JWTClaimValidationFailed, JWTExpired, JWTInvalid } from '../util/errors.js';
-import { decoder } from './buffer_utils.js';
-import epoch from './epoch.js';
-import secs from './secs.js';
-import isObject from './is_object.js';
-const normalizeTyp = (value) => value.toLowerCase().replace(/^application\//, '');
-const checkAudiencePresence = (audPayload, audOption) => {
-    if (typeof audPayload === 'string') {
-        return audOption.includes(audPayload);
-    }
-    if (Array.isArray(audPayload)) {
-        return audOption.some(Set.prototype.has.bind(new Set(audPayload)));
-    }
-    return false;
-};
-export default (protectedHeader, encodedPayload, options = {}) => {
-    let payload;
-    try {
-        payload = JSON.parse(decoder.decode(encodedPayload));
-    }
-    catch {
-    }
-    if (!isObject(payload)) {
-        throw new JWTInvalid('JWT Claims Set must be a top-level JSON object');
-    }
-    const { typ } = options;
-    if (typ &&
-        (typeof protectedHeader.typ !== 'string' ||
-            normalizeTyp(protectedHeader.typ) !== normalizeTyp(typ))) {
-        throw new JWTClaimValidationFailed('unexpected "typ" JWT header value', payload, 'typ', 'check_failed');
-    }
-    const { requiredClaims = [], issuer, subject, audience, maxTokenAge } = options;
-    const presenceCheck = [...requiredClaims];
-    if (maxTokenAge !== undefined)
-        presenceCheck.push('iat');
-    if (audience !== undefined)
-        presenceCheck.push('aud');
-    if (subject !== undefined)
-        presenceCheck.push('sub');
-    if (issuer !== undefined)
-        presenceCheck.push('iss');
-    for (const claim of new Set(presenceCheck.reverse())) {
-        if (!(claim in payload)) {
-            throw new JWTClaimValidationFailed(`missing required "${claim}" claim`, payload, claim, 'missing');
-        }
-    }
-    if (issuer &&
-        !(Array.isArray(issuer) ? issuer : [issuer]).includes(payload.iss)) {
-        throw new JWTClaimValidationFailed('unexpected "iss" claim value', payload, 'iss', 'check_failed');
-    }
-    if (subject && payload.sub !== subject) {
-        throw new JWTClaimValidationFailed('unexpected "sub" claim value', payload, 'sub', 'check_failed');
-    }
-    if (audience &&
-        !checkAudiencePresence(payload.aud, typeof audience === 'string' ? [audience] : audience)) {
-        throw new JWTClaimValidationFailed('unexpected "aud" claim value', payload, 'aud', 'check_failed');
-    }
-    let tolerance;
-    switch (typeof options.clockTolerance) {
-        case 'string':
-            tolerance = secs(options.clockTolerance);
-            break;
-        case 'number':
-            tolerance = options.clockTolerance;
-            break;
-        case 'undefined':
-            tolerance = 0;
-            break;
-        default:
-            throw new TypeError('Invalid clockTolerance option type');
-    }
-    const { currentDate } = options;
-    const now = epoch(currentDate || new Date());
-    if ((payload.iat !== undefined || maxTokenAge) && typeof payload.iat !== 'number') {
-        throw new JWTClaimValidationFailed('"iat" claim must be a number', payload, 'iat', 'invalid');
-    }
-    if (payload.nbf !== undefined) {
-        if (typeof payload.nbf !== 'number') {
-            throw new JWTClaimValidationFailed('"nbf" claim must be a number', payload, 'nbf', 'invalid');
-        }
-        if (payload.nbf > now + tolerance) {
-            throw new JWTClaimValidationFailed('"nbf" claim timestamp check failed', payload, 'nbf', 'check_failed');
-        }
-    }
-    if (payload.exp !== undefined) {
-        if (typeof payload.exp !== 'number') {
-            throw new JWTClaimValidationFailed('"exp" claim must be a number', payload, 'exp', 'invalid');
-        }
-        if (payload.exp <= now - tolerance) {
-            throw new JWTExpired('"exp" claim timestamp check failed', payload, 'exp', 'check_failed');
-        }
-    }
-    if (maxTokenAge) {
-        const age = now - payload.iat;
-        const max = typeof maxTokenAge === 'number' ? maxTokenAge : secs(maxTokenAge);
-        if (age - tolerance > max) {
-            throw new JWTExpired('"iat" claim timestamp check failed (too far in the past)', payload, 'iat', 'check_failed');
-        }
-        if (age < 0 - tolerance) {
-            throw new JWTClaimValidationFailed('"iat" claim timestamp check failed (it should be in the past)', payload, 'iat', 'check_failed');
-        }
-    }
-    return payload;
-};

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

@@ -1 +0,0 @@
-export const unprotected = Symbol();

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

@@ -1,55 +0,0 @@
-const minute = 60;
-const hour = minute * 60;
-const day = hour * 24;
-const week = day * 7;
-const year = day * 365.25;
-const REGEX = /^(\+|\-)? ?(\d+|\d+\.\d+) ?(seconds?|secs?|s|minutes?|mins?|m|hours?|hrs?|h|days?|d|weeks?|w|years?|yrs?|y)(?: (ago|from now))?$/i;
-export default (str) => {
-    const matched = REGEX.exec(str);
-    if (!matched || (matched[4] && matched[1])) {
-        throw new TypeError('Invalid time period format');
-    }
-    const value = parseFloat(matched[2]);
-    const unit = matched[3].toLowerCase();
-    let numericDate;
-    switch (unit) {
-        case 'sec':
-        case 'secs':
-        case 'second':
-        case 'seconds':
-        case 's':
-            numericDate = Math.round(value);
-            break;
-        case 'minute':
-        case 'minutes':
-        case 'min':
-        case 'mins':
-        case 'm':
-            numericDate = Math.round(value * minute);
-            break;
-        case 'hour':
-        case 'hours':
-        case 'hr':
-        case 'hrs':
-        case 'h':
-            numericDate = Math.round(value * hour);
-            break;
-        case 'day':
-        case 'days':
-        case 'd':
-            numericDate = Math.round(value * day);
-            break;
-        case 'week':
-        case 'weeks':
-        case 'w':
-            numericDate = Math.round(value * week);
-            break;
-        default:
-            numericDate = Math.round(value * year);
-            break;
-    }
-    if (matched[1] === '-' || matched[4] === 'ago') {
-        return -numericDate;
-    }
-    return numericDate;
-};

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

@@ -1,11 +0,0 @@
-const validateAlgorithms = (option, algorithms) => {
-    if (algorithms !== undefined &&
-        (!Array.isArray(algorithms) || algorithms.some((s) => typeof s !== 'string'))) {
-        throw new TypeError(`"${option}" option must be an array of strings`);
-    }
-    if (!algorithms) {
-        return undefined;
-    }
-    return new Set(algorithms);
-};
-export default validateAlgorithms;

package/dist/node/esm/package.json

@@ -1 +0,0 @@
-{"type":"module","sideEffects":false}

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

@@ -1,50 +0,0 @@
-import { Buffer } from 'node:buffer';
-import { KeyObject, createDecipheriv, createCipheriv, createSecretKey } from 'node:crypto';
-import { JOSENotSupported } from '../util/errors.js';
-import { concat } from '../lib/buffer_utils.js';
-import { isCryptoKey } from './webcrypto.js';
-import { checkEncCryptoKey } from '../lib/crypto_key.js';
-import isKeyObject from './is_key_object.js';
-import invalidKeyInput from '../lib/invalid_key_input.js';
-import supported from './ciphers.js';
-import { types } from './is_key_like.js';
-function checkKeySize(key, alg) {
-    if (key.symmetricKeySize << 3 !== parseInt(alg.slice(1, 4), 10)) {
-        throw new TypeError(`Invalid key size for alg: ${alg}`);
-    }
-}
-function ensureKeyObject(key, alg, usage) {
-    if (isKeyObject(key)) {
-        return key;
-    }
-    if (key instanceof Uint8Array) {
-        return createSecretKey(key);
-    }
-    if (isCryptoKey(key)) {
-        checkEncCryptoKey(key, alg, usage);
-        return KeyObject.from(key);
-    }
-    throw new TypeError(invalidKeyInput(key, ...types, 'Uint8Array'));
-}
-export const wrap = (alg, key, cek) => {
-    const size = parseInt(alg.slice(1, 4), 10);
-    const algorithm = `aes${size}-wrap`;
-    if (!supported(algorithm)) {
-        throw new JOSENotSupported(`alg ${alg} is not supported either by JOSE or your javascript runtime`);
-    }
-    const keyObject = ensureKeyObject(key, alg, 'wrapKey');
-    checkKeySize(keyObject, alg);
-    const cipher = createCipheriv(algorithm, keyObject, Buffer.alloc(8, 0xa6));
-    return concat(cipher.update(cek), cipher.final());
-};
-export const unwrap = (alg, key, encryptedKey) => {
-    const size = parseInt(alg.slice(1, 4), 10);
-    const algorithm = `aes${size}-wrap`;
-    if (!supported(algorithm)) {
-        throw new JOSENotSupported(`alg ${alg} is not supported either by JOSE or your javascript runtime`);
-    }
-    const keyObject = ensureKeyObject(key, alg, 'unwrapKey');
-    checkKeySize(keyObject, alg);
-    const cipher = createDecipheriv(algorithm, keyObject, Buffer.alloc(8, 0xa6));
-    return concat(cipher.update(encryptedKey), cipher.final());
-};

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

@@ -1,46 +0,0 @@
-import { createPrivateKey, createPublicKey, KeyObject } from 'node:crypto';
-import { Buffer } from 'node:buffer';
-import { isCryptoKey } from './webcrypto.js';
-import isKeyObject from './is_key_object.js';
-import invalidKeyInput from '../lib/invalid_key_input.js';
-import { types } from './is_key_like.js';
-const genericExport = (keyType, keyFormat, key) => {
-    let keyObject;
-    if (isCryptoKey(key)) {
-        if (!key.extractable) {
-            throw new TypeError('CryptoKey is not extractable');
-        }
-        keyObject = KeyObject.from(key);
-    }
-    else if (isKeyObject(key)) {
-        keyObject = key;
-    }
-    else {
-        throw new TypeError(invalidKeyInput(key, ...types));
-    }
-    if (keyObject.type !== keyType) {
-        throw new TypeError(`key is not a ${keyType} key`);
-    }
-    return keyObject.export({ format: 'pem', type: keyFormat });
-};
-export const toSPKI = (key) => {
-    return genericExport('public', 'spki', key);
-};
-export const toPKCS8 = (key) => {
-    return genericExport('private', 'pkcs8', key);
-};
-export const fromPKCS8 = (pem) => createPrivateKey({
-    key: Buffer.from(pem.replace(/(?:-----(?:BEGIN|END) PRIVATE KEY-----|\s)/g, ''), 'base64'),
-    type: 'pkcs8',
-    format: 'der',
-});
-export const fromSPKI = (pem) => createPublicKey({
-    key: Buffer.from(pem.replace(/(?:-----(?:BEGIN|END) PUBLIC KEY-----|\s)/g, ''), 'base64'),
-    type: 'spki',
-    format: 'der',
-});
-export const fromX509 = (pem) => createPublicKey({
-    key: pem,
-    type: 'spki',
-    format: 'pem',
-});

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

@@ -1,14 +0,0 @@
-import { Buffer } from 'node:buffer';
-import { decoder } from '../lib/buffer_utils.js';
-function normalize(input) {
-    let encoded = input;
-    if (encoded instanceof Uint8Array) {
-        encoded = decoder.decode(encoded);
-    }
-    return encoded;
-}
-const encode = (input) => Buffer.from(input).toString('base64url');
-export const decodeBase64 = (input) => new Uint8Array(Buffer.from(input, 'base64'));
-export const encodeBase64 = (input) => Buffer.from(input).toString('base64');
-export { encode };
-export const decode = (input) => new Uint8Array(Buffer.from(normalize(input), 'base64url'));

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

@@ -1,8 +0,0 @@
-import { createHmac } from 'node:crypto';
-import { concat, uint64be } from '../lib/buffer_utils.js';
-export default function cbcTag(aad, iv, ciphertext, macSize, macKey, keySize) {
-    const macData = concat(aad, iv, ciphertext, uint64be(aad.length << 3));
-    const hmac = createHmac(`sha${macSize}`, macKey);
-    hmac.update(macData);
-    return hmac.digest().slice(0, keySize >> 3);
-}

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

@@ -1,35 +0,0 @@
-import { JWEInvalid, JOSENotSupported } from '../util/errors.js';
-import isKeyObject from './is_key_object.js';
-const checkCekLength = (enc, cek) => {
-    let expected;
-    switch (enc) {
-        case 'A128CBC-HS256':
-        case 'A192CBC-HS384':
-        case 'A256CBC-HS512':
-            expected = parseInt(enc.slice(-3), 10);
-            break;
-        case 'A128GCM':
-        case 'A192GCM':
-        case 'A256GCM':
-            expected = parseInt(enc.slice(1, 4), 10);
-            break;
-        default:
-            throw new JOSENotSupported(`Content Encryption Algorithm ${enc} is not supported either by JOSE or your javascript runtime`);
-    }
-    if (cek instanceof Uint8Array) {
-        const actual = cek.byteLength << 3;
-        if (actual !== expected) {
-            throw new JWEInvalid(`Invalid Content Encryption Key length. Expected ${expected} bits, got ${actual} bits`);
-        }
-        return;
-    }
-    if (isKeyObject(cek) && cek.type === 'secret') {
-        const actual = cek.symmetricKeySize << 3;
-        if (actual !== expected) {
-            throw new JWEInvalid(`Invalid Content Encryption Key length. Expected ${expected} bits, got ${actual} bits`);
-        }
-        return;
-    }
-    throw new TypeError('Invalid Content Encryption Key type');
-};
-export default checkCekLength;

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

@@ -1,16 +0,0 @@
-import { KeyObject } from 'node:crypto';
-export default (key, alg) => {
-    let modulusLength;
-    try {
-        if (key instanceof KeyObject) {
-            modulusLength = key.asymmetricKeyDetails?.modulusLength;
-        }
-        else {
-            modulusLength = Buffer.from(key.n, 'base64url').byteLength << 3;
-        }
-    }
-    catch { }
-    if (typeof modulusLength !== 'number' || modulusLength < 2048) {
-        throw new TypeError(`${alg} requires key modulusLength to be 2048 bits or larger`);
-    }
-};

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

@@ -1,6 +0,0 @@
-import { getCiphers } from 'node:crypto';
-let ciphers;
-export default (algorithm) => {
-    ciphers ||= new Set(getCiphers());
-    return ciphers.has(algorithm);
-};