@windrun-huaiin/backend-core 12.0.0 → 13.0.0

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

@@ -0,0 +1,38 @@
+'use strict';
+
+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);
+}
+
+module.exports = validateCrit;

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

@@ -0,0 +1,36 @@
+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

@@ -0,0 +1,15 @@
+'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

@@ -0,0 +1,13 @@
+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

@@ -0,0 +1,21 @@
+'use strict';
+
+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`);
+    }
+};
+
+module.exports = checkKeyLength;

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

@@ -0,0 +1,19 @@
+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

@@ -0,0 +1,28 @@
+'use strict';
+
+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`);
+    }
+}
+
+module.exports = dsaDigest;

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

@@ -0,0 +1,26 @@
+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

@@ -0,0 +1,58 @@
+'use strict';
+
+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(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');
+    }
+};
+
+module.exports = getNamedCurve;

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

@@ -0,0 +1,56 @@
+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

@@ -0,0 +1,33 @@
+'use strict';
+
+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'));
+}
+
+module.exports = getSignVerifyKey;

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

@@ -0,0 +1,31 @@
+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

@@ -0,0 +1,18 @@
+'use strict';
+
+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`);
+    }
+}
+
+module.exports = hmacDigest;

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

@@ -0,0 +1,16 @@
+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

@@ -0,0 +1,15 @@
+'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(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

@@ -0,0 +1,10 @@
+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

@@ -0,0 +1,26 @@
+'use strict';
+
+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);
+
+module.exports = isKeyObject;

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

@@ -0,0 +1,5 @@
+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

@@ -0,0 +1,12 @@
+'use strict';
+
+var crypto = require('node:crypto');
+
+const parse = (key) => {
+    if (key.d) {
+        return crypto.createPrivateKey({ format: 'jwk', key });
+    }
+    return crypto.createPublicKey({ format: 'jwk', key });
+};
+
+module.exports = parse;

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

@@ -0,0 +1,10 @@
+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

@@ -0,0 +1,113 @@
+'use strict';
+
+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(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(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(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;
+}
+
+module.exports = keyForCrypto;