@windrun-huaiin/backend-core 14.6.0 → 15.1.0

package/dist/node_modules/.pnpm/jose@5.10.0/node_modules/jose/dist/node/esm/lib/validate_algorithms.mjs

@@ -1,12 +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 { validateAlgorithms as default };

package/dist/node_modules/.pnpm/jose@5.10.0/node_modules/jose/dist/node/esm/lib/validate_crit.js

@@ -1,40 +0,0 @@
-'use strict';
-
-Object.defineProperty(exports, '__esModule', { value: true });
-
-var errors = require('../util/errors.js');
-
-function validateCrit(Err, recognizedDefault, recognizedOption, protectedHeader, joseHeader) {
-    if (joseHeader.crit !== undefined && protectedHeader?.crit === undefined) {
-        throw new Err('"crit" (Critical) Header Parameter MUST be integrity protected');
-    }
-    if (!protectedHeader || protectedHeader.crit === undefined) {
-        return new Set();
-    }
-    if (!Array.isArray(protectedHeader.crit) ||
-        protectedHeader.crit.length === 0 ||
-        protectedHeader.crit.some((input) => typeof input !== 'string' || input.length === 0)) {
-        throw new Err('"crit" (Critical) Header Parameter MUST be an array of non-empty strings when present');
-    }
-    let recognized;
-    if (recognizedOption !== undefined) {
-        recognized = new Map([...Object.entries(recognizedOption), ...recognizedDefault.entries()]);
-    }
-    else {
-        recognized = recognizedDefault;
-    }
-    for (const parameter of protectedHeader.crit) {
-        if (!recognized.has(parameter)) {
-            throw new errors.JOSENotSupported(`Extension Header Parameter "${parameter}" is not recognized`);
-        }
-        if (joseHeader[parameter] === undefined) {
-            throw new Err(`Extension Header Parameter "${parameter}" is missing`);
-        }
-        if (recognized.get(parameter) && protectedHeader[parameter] === undefined) {
-            throw new Err(`Extension Header Parameter "${parameter}" MUST be integrity protected`);
-        }
-    }
-    return new Set(protectedHeader.crit);
-}
-
-exports.default = validateCrit;

package/dist/node_modules/.pnpm/jose@5.10.0/node_modules/jose/dist/node/esm/lib/validate_crit.mjs

@@ -1,36 +0,0 @@
-import { JOSENotSupported } from '../util/errors.mjs';
-
-function validateCrit(Err, recognizedDefault, recognizedOption, protectedHeader, joseHeader) {
-    if (joseHeader.crit !== undefined && protectedHeader?.crit === undefined) {
-        throw new Err('"crit" (Critical) Header Parameter MUST be integrity protected');
-    }
-    if (!protectedHeader || protectedHeader.crit === undefined) {
-        return new Set();
-    }
-    if (!Array.isArray(protectedHeader.crit) ||
-        protectedHeader.crit.length === 0 ||
-        protectedHeader.crit.some((input) => typeof input !== 'string' || input.length === 0)) {
-        throw new Err('"crit" (Critical) Header Parameter MUST be an array of non-empty strings when present');
-    }
-    let recognized;
-    if (recognizedOption !== undefined) {
-        recognized = new Map([...Object.entries(recognizedOption), ...recognizedDefault.entries()]);
-    }
-    else {
-        recognized = recognizedDefault;
-    }
-    for (const parameter of protectedHeader.crit) {
-        if (!recognized.has(parameter)) {
-            throw new JOSENotSupported(`Extension Header Parameter "${parameter}" is not recognized`);
-        }
-        if (joseHeader[parameter] === undefined) {
-            throw new Err(`Extension Header Parameter "${parameter}" is missing`);
-        }
-        if (recognized.get(parameter) && protectedHeader[parameter] === undefined) {
-            throw new Err(`Extension Header Parameter "${parameter}" MUST be integrity protected`);
-        }
-    }
-    return new Set(protectedHeader.crit);
-}
-
-export { validateCrit as default };

package/dist/node_modules/.pnpm/jose@5.10.0/node_modules/jose/dist/node/esm/runtime/base64url.js

@@ -1,15 +0,0 @@
-'use strict';
-
-var node_buffer = require('node:buffer');
-var buffer_utils = require('../lib/buffer_utils.js');
-
-function normalize(input) {
-    let encoded = input;
-    if (encoded instanceof Uint8Array) {
-        encoded = buffer_utils.decoder.decode(encoded);
-    }
-    return encoded;
-}
-const decode = (input) => new Uint8Array(node_buffer.Buffer.from(normalize(input), 'base64url'));
-
-exports.decode = decode;

package/dist/node_modules/.pnpm/jose@5.10.0/node_modules/jose/dist/node/esm/runtime/base64url.mjs

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

package/dist/node_modules/.pnpm/jose@5.10.0/node_modules/jose/dist/node/esm/runtime/check_key_length.js

@@ -1,23 +0,0 @@
-'use strict';
-
-Object.defineProperty(exports, '__esModule', { value: true });
-
-var crypto = require('node:crypto');
-
-var checkKeyLength = (key, alg) => {
-    let modulusLength;
-    try {
-        if (key instanceof crypto.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`);
-    }
-};
-
-exports.default = checkKeyLength;

package/dist/node_modules/.pnpm/jose@5.10.0/node_modules/jose/dist/node/esm/runtime/check_key_length.mjs

@@ -1,19 +0,0 @@
-import { KeyObject } from 'node:crypto';
-
-var checkKeyLength = (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`);
-    }
-};
-
-export { checkKeyLength as default };

package/dist/node_modules/.pnpm/jose@5.10.0/node_modules/jose/dist/node/esm/runtime/dsa_digest.js

@@ -1,30 +0,0 @@
-'use strict';
-
-Object.defineProperty(exports, '__esModule', { value: true });
-
-var errors = require('../util/errors.js');
-
-function dsaDigest(alg) {
-    switch (alg) {
-        case 'PS256':
-        case 'RS256':
-        case 'ES256':
-        case 'ES256K':
-            return 'sha256';
-        case 'PS384':
-        case 'RS384':
-        case 'ES384':
-            return 'sha384';
-        case 'PS512':
-        case 'RS512':
-        case 'ES512':
-            return 'sha512';
-        case 'Ed25519':
-        case 'EdDSA':
-            return undefined;
-        default:
-            throw new errors.JOSENotSupported(`alg ${alg} is not supported either by JOSE or your javascript runtime`);
-    }
-}
-
-exports.default = dsaDigest;

package/dist/node_modules/.pnpm/jose@5.10.0/node_modules/jose/dist/node/esm/runtime/dsa_digest.mjs

@@ -1,26 +0,0 @@
-import { JOSENotSupported } from '../util/errors.mjs';
-
-function dsaDigest(alg) {
-    switch (alg) {
-        case 'PS256':
-        case 'RS256':
-        case 'ES256':
-        case 'ES256K':
-            return 'sha256';
-        case 'PS384':
-        case 'RS384':
-        case 'ES384':
-            return 'sha384';
-        case 'PS512':
-        case 'RS512':
-        case 'ES512':
-            return 'sha512';
-        case 'Ed25519':
-        case 'EdDSA':
-            return undefined;
-        default:
-            throw new JOSENotSupported(`alg ${alg} is not supported either by JOSE or your javascript runtime`);
-    }
-}
-
-export { dsaDigest as default };

package/dist/node_modules/.pnpm/jose@5.10.0/node_modules/jose/dist/node/esm/runtime/get_named_curve.js

@@ -1,60 +0,0 @@
-'use strict';
-
-Object.defineProperty(exports, '__esModule', { value: true });
-
-var crypto = require('node:crypto');
-var errors = require('../util/errors.js');
-var webcrypto = require('./webcrypto.js');
-var is_key_object = require('./is_key_object.js');
-var invalid_key_input = require('../lib/invalid_key_input.js');
-var is_key_like = require('./is_key_like.js');
-var is_jwk = require('../lib/is_jwk.js');
-
-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.JOSENotSupported('Unsupported key curve for this operation');
-    }
-};
-const getNamedCurve = (kee, raw) => {
-    let key;
-    if (webcrypto.isCryptoKey(kee)) {
-        key = crypto.KeyObject.from(kee);
-    }
-    else if (is_key_object.default(kee)) {
-        key = kee;
-    }
-    else if (is_jwk.isJWK(kee)) {
-        return kee.crv;
-    }
-    else {
-        throw new TypeError(invalid_key_input.default(kee, ...is_key_like.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;
-            return namedCurveToJOSE(namedCurve);
-        }
-        default:
-            throw new TypeError('Invalid asymmetric key type for this operation');
-    }
-};
-
-exports.default = getNamedCurve;

package/dist/node_modules/.pnpm/jose@5.10.0/node_modules/jose/dist/node/esm/runtime/get_named_curve.mjs

@@ -1,56 +0,0 @@
-import { KeyObject } from 'node:crypto';
-import { JOSENotSupported } from '../util/errors.mjs';
-import { isCryptoKey } from './webcrypto.mjs';
-import isKeyObject from './is_key_object.mjs';
-import invalidKeyInput from '../lib/invalid_key_input.mjs';
-import { types } from './is_key_like.mjs';
-import { isJWK } from '../lib/is_jwk.mjs';
-
-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 JOSENotSupported('Unsupported key curve for this operation');
-    }
-};
-const getNamedCurve = (kee, raw) => {
-    let key;
-    if (isCryptoKey(kee)) {
-        key = KeyObject.from(kee);
-    }
-    else if (isKeyObject(kee)) {
-        key = kee;
-    }
-    else if (isJWK(kee)) {
-        return kee.crv;
-    }
-    else {
-        throw new TypeError(invalidKeyInput(kee, ...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;
-            return namedCurveToJOSE(namedCurve);
-        }
-        default:
-            throw new TypeError('Invalid asymmetric key type for this operation');
-    }
-};
-
-export { getNamedCurve as default };

package/dist/node_modules/.pnpm/jose@5.10.0/node_modules/jose/dist/node/esm/runtime/get_sign_verify_key.js

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

package/dist/node_modules/.pnpm/jose@5.10.0/node_modules/jose/dist/node/esm/runtime/get_sign_verify_key.mjs

@@ -1,31 +0,0 @@
-import { createSecretKey, KeyObject } from 'node:crypto';
-import { isCryptoKey } from './webcrypto.mjs';
-import { checkSigCryptoKey } from '../lib/crypto_key.mjs';
-import invalidKeyInput from '../lib/invalid_key_input.mjs';
-import { types } from './is_key_like.mjs';
-import { isJWK } from '../lib/is_jwk.mjs';
-
-function getSignVerifyKey(alg, key, usage) {
-    if (key instanceof Uint8Array) {
-        if (!alg.startsWith('HS')) {
-            throw new TypeError(invalidKeyInput(key, ...types));
-        }
-        return createSecretKey(key);
-    }
-    if (key instanceof KeyObject) {
-        return key;
-    }
-    if (isCryptoKey(key)) {
-        checkSigCryptoKey(key, alg, usage);
-        return KeyObject.from(key);
-    }
-    if (isJWK(key)) {
-        if (alg.startsWith('HS')) {
-            return createSecretKey(Buffer.from(key.k, 'base64url'));
-        }
-        return key;
-    }
-    throw new TypeError(invalidKeyInput(key, ...types, 'Uint8Array', 'JSON Web Key'));
-}
-
-export { getSignVerifyKey as default };

package/dist/node_modules/.pnpm/jose@5.10.0/node_modules/jose/dist/node/esm/runtime/hmac_digest.js

@@ -1,20 +0,0 @@
-'use strict';
-
-Object.defineProperty(exports, '__esModule', { value: true });
-
-var errors = 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.JOSENotSupported(`alg ${alg} is not supported either by JOSE or your javascript runtime`);
-    }
-}
-
-exports.default = hmacDigest;

package/dist/node_modules/.pnpm/jose@5.10.0/node_modules/jose/dist/node/esm/runtime/hmac_digest.mjs

@@ -1,16 +0,0 @@
-import { JOSENotSupported } from '../util/errors.mjs';
-
-function hmacDigest(alg) {
-    switch (alg) {
-        case 'HS256':
-            return 'sha256';
-        case 'HS384':
-            return 'sha384';
-        case 'HS512':
-            return 'sha512';
-        default:
-            throw new JOSENotSupported(`alg ${alg} is not supported either by JOSE or your javascript runtime`);
-    }
-}
-
-export { hmacDigest as default };

package/dist/node_modules/.pnpm/jose@5.10.0/node_modules/jose/dist/node/esm/runtime/is_key_like.js

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

package/dist/node_modules/.pnpm/jose@5.10.0/node_modules/jose/dist/node/esm/runtime/is_key_like.mjs

@@ -1,10 +0,0 @@
-import webcrypto, { isCryptoKey } from './webcrypto.mjs';
-import isKeyObject from './is_key_object.mjs';
-
-var isKeyLike = (key) => isKeyObject(key) || isCryptoKey(key);
-const types = ['KeyObject'];
-if (globalThis.CryptoKey || webcrypto?.CryptoKey) {
-    types.push('CryptoKey');
-}
-
-export { isKeyLike as default, types };

package/dist/node_modules/.pnpm/jose@5.10.0/node_modules/jose/dist/node/esm/runtime/is_key_object.js

@@ -1,28 +0,0 @@
-'use strict';
-
-Object.defineProperty(exports, '__esModule', { value: true });
-
-var util = require('node:util');
-
-function _interopNamespaceDefault(e) {
-	var n = Object.create(null);
-	if (e) {
-		Object.keys(e).forEach(function (k) {
-			if (k !== 'default') {
-				var d = Object.getOwnPropertyDescriptor(e, k);
-				Object.defineProperty(n, k, d.get ? d : {
-					enumerable: true,
-					get: function () { return e[k]; }
-				});
-			}
-		});
-	}
-	n.default = e;
-	return Object.freeze(n);
-}
-
-var util__namespace = /*#__PURE__*/_interopNamespaceDefault(util);
-
-var isKeyObject = (obj) => util__namespace.types.isKeyObject(obj);
-
-exports.default = isKeyObject;

package/dist/node_modules/.pnpm/jose@5.10.0/node_modules/jose/dist/node/esm/runtime/is_key_object.mjs

@@ -1,5 +0,0 @@
-import * as util from 'node:util';
-
-var isKeyObject = (obj) => util.types.isKeyObject(obj);
-
-export { isKeyObject as default };

package/dist/node_modules/.pnpm/jose@5.10.0/node_modules/jose/dist/node/esm/runtime/jwk_to_key.js

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

package/dist/node_modules/.pnpm/jose@5.10.0/node_modules/jose/dist/node/esm/runtime/jwk_to_key.mjs

@@ -1,10 +0,0 @@
-import { createPrivateKey, createPublicKey } from 'node:crypto';
-
-const parse = (key) => {
-    if (key.d) {
-        return createPrivateKey({ format: 'jwk', key });
-    }
-    return createPublicKey({ format: 'jwk', key });
-};
-
-export { parse as default };

package/dist/node_modules/.pnpm/jose@5.10.0/node_modules/jose/dist/node/esm/runtime/node_key.js

@@ -1,115 +0,0 @@
-'use strict';
-
-Object.defineProperty(exports, '__esModule', { value: true });
-
-var crypto = require('node:crypto');
-var get_named_curve = require('./get_named_curve.js');
-var errors = require('../util/errors.js');
-var check_key_length = 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 crypto.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');
-            }
-            check_key_length.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');
-            }
-            check_key_length.default(key, alg);
-            options = {
-                padding: crypto.constants.RSA_PKCS1_PSS_PADDING,
-                saltLength: crypto.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 = get_named_curve.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.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;
-}
-
-exports.default = keyForCrypto;