repocairn 0.1.2 → 0.1.4

package/node_modules/jose/dist/webapi/jwe/flattened/encrypt.js

@@ -1,14 +1,7 @@
-import { encode as b64u } from '../../util/base64url.js';
 import { unprotected, assertNotSet } from '../../lib/helpers.js';
-import { encrypt } from '../../lib/content_encryption.js';
-import { encryptKeyManagement } from '../../lib/key_management.js';
-import { JOSENotSupported, JWEInvalid } from '../../util/errors.js';
-import { isDisjoint } from '../../lib/type_checks.js';
-import { concat, encode } from '../../lib/buffer_utils.js';
-import { validateCrit } from '../../lib/validate_crit.js';
-import { normalizeKey } from '../../lib/normalize_key.js';
-import { checkKeyType } from '../../lib/check_key_type.js';
-import { compress } from '../../lib/deflate.js';
+import { JWEInvalid } from '../../util/errors.js';
+import { createJWE } from '../../lib/jwe_encrypt.js';
+import { validateCritDuplicates } from '../../lib/options.js';
 export class FlattenedEncrypt {
     #plaintext;
     #protectedHeader;
@@ -62,106 +55,18 @@ export class FlattenedEncrypt {
         if (!this.#protectedHeader && !this.#unprotectedHeader && !this.#sharedUnprotectedHeader) {
             throw new JWEInvalid('either setProtectedHeader, setUnprotectedHeader, or sharedUnprotectedHeader must be called before #encrypt()');
         }
-        if (!isDisjoint(this.#protectedHeader, this.#unprotectedHeader, this.#sharedUnprotectedHeader)) {
-            throw new JWEInvalid('JWE Protected, JWE Shared Unprotected and JWE Per-Recipient Header Parameter names must be disjoint');
-        }
-        const joseHeader = {
-            ...this.#protectedHeader,
-            ...this.#unprotectedHeader,
-            ...this.#sharedUnprotectedHeader,
-        };
-        validateCrit(JWEInvalid, new Map(), options?.crit, this.#protectedHeader, joseHeader);
-        if (joseHeader.zip !== undefined && joseHeader.zip !== 'DEF') {
-            throw new JOSENotSupported('Unsupported JWE "zip" (Compression Algorithm) Header Parameter value.');
-        }
-        if (joseHeader.zip !== undefined && !this.#protectedHeader?.zip) {
-            throw new JWEInvalid('JWE "zip" (Compression Algorithm) Header Parameter MUST be in a protected header.');
-        }
-        const { alg, enc } = joseHeader;
-        if (typeof alg !== 'string' || !alg) {
-            throw new JWEInvalid('JWE "alg" (Algorithm) Header Parameter missing or invalid');
-        }
-        if (typeof enc !== 'string' || !enc) {
-            throw new JWEInvalid('JWE "enc" (Encryption Algorithm) Header Parameter missing or invalid');
-        }
-        let encryptedKey;
-        if (this.#cek && (alg === 'dir' || alg === 'ECDH-ES')) {
-            throw new TypeError(`setContentEncryptionKey cannot be called with JWE "alg" (Algorithm) Header ${alg}`);
-        }
-        checkKeyType(alg === 'dir' ? enc : alg, key, 'encrypt');
-        let cek;
-        {
-            let parameters;
-            const k = await normalizeKey(key, alg);
-            ({ cek, encryptedKey, parameters } = await encryptKeyManagement(alg, enc, k, this.#cek, this.#keyManagementParameters));
-            if (parameters) {
-                if (options && unprotected in options) {
-                    if (!this.#unprotectedHeader) {
-                        this.setUnprotectedHeader(parameters);
-                    }
-                    else {
-                        this.#unprotectedHeader = { ...this.#unprotectedHeader, ...parameters };
-                    }
-                }
-                else if (!this.#protectedHeader) {
-                    this.setProtectedHeader(parameters);
-                }
-                else {
-                    this.#protectedHeader = { ...this.#protectedHeader, ...parameters };
-                }
-            }
-        }
-        let additionalData;
-        let protectedHeaderS;
-        let protectedHeaderB;
-        let aadMember;
-        if (this.#protectedHeader) {
-            protectedHeaderS = b64u(JSON.stringify(this.#protectedHeader));
-            protectedHeaderB = encode(protectedHeaderS);
-        }
-        else {
-            protectedHeaderS = '';
-            protectedHeaderB = new Uint8Array();
-        }
-        if (this.#aad) {
-            aadMember = b64u(this.#aad);
-            const aadMemberBytes = encode(aadMember);
-            additionalData = concat(protectedHeaderB, encode('.'), aadMemberBytes);
-        }
-        else {
-            additionalData = protectedHeaderB;
-        }
-        let plaintext = this.#plaintext;
-        if (joseHeader.zip === 'DEF') {
-            plaintext = await compress(plaintext).catch((cause) => {
-                throw new JWEInvalid('Failed to compress plaintext', { cause });
-            });
-        }
-        const { ciphertext, tag, iv } = await encrypt(enc, plaintext, cek, this.#iv, additionalData);
-        const jwe = {
-            ciphertext: b64u(ciphertext),
-        };
-        if (iv) {
-            jwe.iv = b64u(iv);
-        }
-        if (tag) {
-            jwe.tag = b64u(tag);
-        }
-        if (encryptedKey) {
-            jwe.encrypted_key = b64u(encryptedKey);
-        }
-        if (aadMember) {
-            jwe.aad = aadMember;
-        }
-        if (this.#protectedHeader) {
-            jwe.protected = protectedHeaderS;
-        }
-        if (this.#sharedUnprotectedHeader) {
-            jwe.unprotected = this.#sharedUnprotectedHeader;
-        }
-        if (this.#unprotectedHeader) {
-            jwe.header = this.#unprotectedHeader;
-        }
-        return jwe;
+        validateCritDuplicates(JWEInvalid, this.#protectedHeader);
+        return createJWE([
+            this.#plaintext,
+            this.#protectedHeader,
+            this.#unprotectedHeader,
+            this.#sharedUnprotectedHeader,
+            this.#aad,
+            this.#cek,
+            this.#iv,
+            this.#keyManagementParameters,
+            options?.crit,
+            options ? unprotected in options : false,
+        ], key);
     }
 }

package/node_modules/jose/dist/webapi/jwe/general/decrypt.js

@@ -1,4 +1,4 @@
-import { flattenedDecrypt } from '../flattened/decrypt.js';
+import { prepareDecrypt, shareJWE, decryptRecipient, decryptResult, checkShared, checkRecipient, } from '../../lib/jwe_decrypt.js';
 import { JWEDecryptionFailed, JWEInvalid } from '../../util/errors.js';
 import { isObject } from '../../lib/type_checks.js';
 export async function generalDecrypt(jwe, key, options) {
@@ -11,9 +11,27 @@ export async function generalDecrypt(jwe, key, options) {
     if (!jwe.recipients.length) {
         throw new JWEInvalid('JWE Recipients has no members');
     }
+    let shared;
+    let token;
+    try {
+        checkShared(jwe);
+        shared = prepareDecrypt(options);
+        token = shareJWE(jwe);
+    }
+    catch {
+        throw new JWEDecryptionFailed();
+    }
+    if (jwe.recipients.length > 1) {
+        for (const { header } of jwe.recipients) {
+            const alg = token[0]?.alg ?? header?.alg ?? jwe.unprotected?.alg;
+            if (alg === 'dir' || alg === 'ECDH-ES') {
+                throw new JWEInvalid(`"${alg}" alg may only have a single recipient`);
+            }
+        }
+    }
     for (const recipient of jwe.recipients) {
         try {
-            return await flattenedDecrypt({
+            const flattened = {
                 aad: jwe.aad,
                 ciphertext: jwe.ciphertext,
                 encrypted_key: recipient.encrypted_key,
@@ -22,7 +40,9 @@ export async function generalDecrypt(jwe, key, options) {
                 protected: jwe.protected,
                 tag: jwe.tag,
                 unprotected: jwe.unprotected,
-            }, key, options);
+            };
+            checkRecipient(flattened);
+            return decryptResult(flattened, await decryptRecipient(flattened, token, shared, key));
         }
         catch {
         }

package/node_modules/jose/dist/webapi/jwe/general/encrypt.js

@@ -1,32 +1,28 @@
 import { FlattenedEncrypt } from '../flattened/encrypt.js';
-import { unprotected, assertNotSet } from '../../lib/helpers.js';
-import { JOSENotSupported, JWEInvalid } from '../../util/errors.js';
+import { assertNotSet } from '../../lib/helpers.js';
+import { JWEInvalid } from '../../util/errors.js';
 import { generateCek } from '../../lib/content_encryption.js';
-import { isDisjoint } from '../../lib/type_checks.js';
 import { encryptKeyManagement } from '../../lib/key_management.js';
 import { encode as b64u } from '../../util/base64url.js';
-import { validateCrit } from '../../lib/validate_crit.js';
-import { normalizeKey } from '../../lib/normalize_key.js';
-import { checkKeyType } from '../../lib/check_key_type.js';
+import { validateCritDuplicates } from '../../lib/options.js';
+import { checkDisjoint, checkEncryptHeaders, encryptJWE } from '../../lib/jwe_encrypt.js';
+import { prepareKey } from '../../lib/key.js';
+import { jweAlgorithm } from '../../lib/jwe_algorithms.js';
 class IndividualRecipient {
     #parent;
-    unprotectedHeader;
-    keyManagementParameters;
-    key;
-    options;
-    constructor(enc, key, options) {
+    state;
+    constructor(enc, key, crit) {
         this.#parent = enc;
-        this.key = key;
-        this.options = options;
+        this.state = [undefined, undefined, key, crit];
     }
     setUnprotectedHeader(unprotectedHeader) {
-        assertNotSet(this.unprotectedHeader, 'setUnprotectedHeader');
-        this.unprotectedHeader = unprotectedHeader;
+        assertNotSet(this.state[0], 'setUnprotectedHeader');
+        this.state[0] = unprotectedHeader;
         return this;
     }
     setKeyManagementParameters(parameters) {
-        assertNotSet(this.keyManagementParameters, 'setKeyManagementParameters');
-        this.keyManagementParameters = parameters;
+        assertNotSet(this.state[1], 'setKeyManagementParameters');
+        this.state[1] = parameters;
         return this;
     }
     addRecipient(...args) {
@@ -39,6 +35,17 @@ class IndividualRecipient {
         return this.#parent;
     }
 }
+function copyOptionalMembers(flattened, jwe, recipient) {
+    const { aad, protected: protectedHeader, unprotected, header } = flattened;
+    if (aad)
+        jwe.aad = aad;
+    if (protectedHeader)
+        jwe.protected = protectedHeader;
+    if (unprotected)
+        jwe.unprotected = unprotected;
+    if (header)
+        recipient.header = header;
+}
 export class GeneralEncrypt {
     #plaintext;
     #recipients = [];
@@ -49,7 +56,7 @@ export class GeneralEncrypt {
         this.#plaintext = plaintext;
     }
     addRecipient(key, options) {
-        const recipient = new IndividualRecipient(this, key, { crit: options?.crit });
+        const recipient = new IndividualRecipient(this, key, options?.crit);
         this.#recipients.push(recipient);
         return recipient;
     }
@@ -71,111 +78,92 @@ export class GeneralEncrypt {
         if (!this.#recipients.length) {
             throw new JWEInvalid('at least one recipient must be added');
         }
+        if (!(this.#plaintext instanceof Uint8Array)) {
+            throw new TypeError('plaintext must be an instance of Uint8Array');
+        }
         if (this.#recipients.length === 1) {
             const [recipient] = this.#recipients;
+            const [unprotectedHeader, keyManagementParameters, key, crit] = recipient.state;
             const flattened = await new FlattenedEncrypt(this.#plaintext)
                 .setAdditionalAuthenticatedData(this.#aad)
                 .setProtectedHeader(this.#protectedHeader)
                 .setSharedUnprotectedHeader(this.#unprotectedHeader)
-                .setUnprotectedHeader(recipient.unprotectedHeader)
-                .encrypt(recipient.key, { ...recipient.options });
+                .setUnprotectedHeader(unprotectedHeader)
+                .setKeyManagementParameters(keyManagementParameters)
+                .encrypt(key, { crit });
             const jwe = {
                 ciphertext: flattened.ciphertext,
                 iv: flattened.iv,
                 recipients: [{}],
                 tag: flattened.tag,
             };
-            if (flattened.aad)
-                jwe.aad = flattened.aad;
-            if (flattened.protected)
-                jwe.protected = flattened.protected;
-            if (flattened.unprotected)
-                jwe.unprotected = flattened.unprotected;
             if (flattened.encrypted_key)
                 jwe.recipients[0].encrypted_key = flattened.encrypted_key;
-            if (flattened.header)
-                jwe.recipients[0].header = flattened.header;
+            copyOptionalMembers(flattened, jwe, jwe.recipients[0]);
             return jwe;
         }
+        validateCritDuplicates(JWEInvalid, this.#protectedHeader);
         let enc;
+        const inputs = [];
+        const checked = [];
         for (let i = 0; i < this.#recipients.length; i++) {
             const recipient = this.#recipients[i];
-            if (!isDisjoint(this.#protectedHeader, this.#unprotectedHeader, recipient.unprotectedHeader)) {
-                throw new JWEInvalid('JWE Protected, JWE Shared Unprotected and JWE Per-Recipient Header Parameter names must be disjoint');
-            }
-            const joseHeader = {
-                ...this.#protectedHeader,
-                ...this.#unprotectedHeader,
-                ...recipient.unprotectedHeader,
-            };
-            const { alg } = joseHeader;
-            if (typeof alg !== 'string' || !alg) {
-                throw new JWEInvalid('JWE "alg" (Algorithm) Header Parameter missing or invalid');
-            }
-            if (alg === 'dir' || alg === 'ECDH-ES') {
-                throw new JWEInvalid('"dir" and "ECDH-ES" alg may only be used with a single recipient');
-            }
-            if (typeof joseHeader.enc !== 'string' || !joseHeader.enc) {
-                throw new JWEInvalid('JWE "enc" (Encryption Algorithm) Header Parameter missing or invalid');
+            const [unprotectedHeader, keyManagementParameters, , crit] = recipient.state;
+            const input = [
+                this.#plaintext,
+                this.#protectedHeader,
+                unprotectedHeader,
+                this.#unprotectedHeader,
+                this.#aad,
+                undefined,
+                undefined,
+                keyManagementParameters,
+                crit,
+                true,
+            ];
+            const headers = checkEncryptHeaders(input);
+            inputs.push(input);
+            checked.push(headers);
+            if (headers[1] === 'dir' || headers[1] === 'ECDH-ES') {
+                throw new JWEInvalid(`"${headers[1]}" alg may only have a single recipient`);
             }
             if (!enc) {
-                enc = joseHeader.enc;
+                enc = headers[2];
             }
-            else if (enc !== joseHeader.enc) {
+            else if (enc !== headers[2]) {
                 throw new JWEInvalid('JWE "enc" (Encryption Algorithm) Header Parameter must be the same for all recipients');
             }
-            validateCrit(JWEInvalid, new Map(), recipient.options.crit, this.#protectedHeader, joseHeader);
-            if (joseHeader.zip !== undefined && joseHeader.zip !== 'DEF') {
-                throw new JOSENotSupported('Unsupported JWE "zip" (Compression Algorithm) Header Parameter value.');
-            }
-            if (joseHeader.zip !== undefined && !this.#protectedHeader?.zip) {
-                throw new JWEInvalid('JWE "zip" (Compression Algorithm) Header Parameter MUST be in a protected header.');
-            }
         }
-        const cek = generateCek(enc);
+        const cek = generateCek(checked[0][3]);
         const jwe = {
             ciphertext: '',
             recipients: [],
         };
         for (let i = 0; i < this.#recipients.length; i++) {
             const recipient = this.#recipients[i];
+            const [unprotectedHeader, keyManagementParameters, key] = recipient.state;
             const target = {};
             jwe.recipients.push(target);
             if (i === 0) {
-                const flattened = await new FlattenedEncrypt(this.#plaintext)
-                    .setAdditionalAuthenticatedData(this.#aad)
-                    .setContentEncryptionKey(cek)
-                    .setProtectedHeader(this.#protectedHeader)
-                    .setSharedUnprotectedHeader(this.#unprotectedHeader)
-                    .setUnprotectedHeader(recipient.unprotectedHeader)
-                    .setKeyManagementParameters(recipient.keyManagementParameters)
-                    .encrypt(recipient.key, {
-                    ...recipient.options,
-                    [unprotected]: true,
-                });
+                inputs[0][5] = cek;
+                const flattened = await encryptJWE(inputs[0], checked[0], key);
                 jwe.ciphertext = flattened.ciphertext;
                 jwe.iv = flattened.iv;
                 jwe.tag = flattened.tag;
-                if (flattened.aad)
-                    jwe.aad = flattened.aad;
-                if (flattened.protected)
-                    jwe.protected = flattened.protected;
-                if (flattened.unprotected)
-                    jwe.unprotected = flattened.unprotected;
                 target.encrypted_key = flattened.encrypted_key;
-                if (flattened.header)
-                    target.header = flattened.header;
+                copyOptionalMembers(flattened, jwe, target);
                 continue;
             }
-            const alg = recipient.unprotectedHeader?.alg ||
-                this.#protectedHeader?.alg ||
-                this.#unprotectedHeader?.alg;
-            checkKeyType(alg === 'dir' ? enc : alg, recipient.key, 'encrypt');
-            const k = await normalizeKey(recipient.key, alg);
-            const { encryptedKey, parameters } = await encryptKeyManagement(alg, enc, k, cek, recipient.keyManagementParameters);
+            const [, alg, , encEntry] = checked[i];
+            const k = await prepareKey(jweAlgorithm(alg), key, 'encrypt');
+            const [, encryptedKey, parameters] = await encryptKeyManagement(alg, encEntry, k, cek, keyManagementParameters);
             target.encrypted_key = b64u(encryptedKey);
-            if (recipient.unprotectedHeader || parameters)
-                target.header = { ...recipient.unprotectedHeader, ...parameters };
+            if (unprotectedHeader || parameters) {
+                const header = { ...unprotectedHeader, ...parameters };
+                if (parameters)
+                    checkDisjoint(this.#protectedHeader, header, this.#unprotectedHeader);
+                target.header = header;
+            }
         }
         return jwe;
     }

package/node_modules/jose/dist/webapi/jwk/embedded.js

@@ -1,4 +1,5 @@
-import { importJWK } from '../key/import.js';
+import { jwkToKey } from '../lib/jwk_to_key.js';
+import { jwsAlgorithm } from '../lib/jws_algorithms.js';
 import { isObject } from '../lib/type_checks.js';
 import { JWSInvalid } from '../util/errors.js';
 export async function EmbeddedJWK(protectedHeader, token) {
@@ -9,8 +10,9 @@ export async function EmbeddedJWK(protectedHeader, token) {
     if (!isObject(joseHeader.jwk)) {
         throw new JWSInvalid('"jwk" (JSON Web Key) Header Parameter must be a JSON object');
     }
-    const key = await importJWK({ ...joseHeader.jwk, ext: true }, joseHeader.alg);
-    if (key instanceof Uint8Array || key.type !== 'public') {
+    const entry = jwsAlgorithm(joseHeader.alg);
+    const key = await jwkToKey(entry, { ...joseHeader.jwk, ext: true });
+    if (key.type !== 'public') {
         throw new JWSInvalid('"jwk" (JSON Web Key) Header Parameter must be a public key');
     }
     return key;

package/node_modules/jose/dist/webapi/jwks/local.js

@@ -1,31 +1,22 @@
-import { importJWK } from '../key/import.js';
+import { jwkToKey } from '../lib/jwk_to_key.js';
+import { JWS } from '../lib/jws_algorithms.js';
 import { JWKSInvalid, JOSENotSupported, JWKSNoMatchingKey, JWKSMultipleMatchingKeys, } from '../util/errors.js';
 import { isObject } from '../lib/type_checks.js';
-function getKtyFromAlg(alg) {
-    switch (typeof alg === 'string' && alg.slice(0, 2)) {
-        case 'RS':
-        case 'PS':
-            return 'RSA';
-        case 'ES':
-            return 'EC';
-        case 'Ed':
-            return 'OKP';
-        case 'ML':
-            return 'AKP';
-        default:
-            throw new JOSENotSupported('Unsupported "alg" value for a JSON Web Key Set');
+function signatureAlgorithm(alg) {
+    const entry = typeof alg === 'string' ? JWS[alg] : undefined;
+    if (!entry || entry.secret) {
+        throw new JOSENotSupported('Unsupported "alg" value for a JSON Web Key Set');
     }
+    return entry;
 }
 function isJWKSLike(jwks) {
-    return (jwks &&
-        typeof jwks === 'object' &&
-        Array.isArray(jwks.keys) &&
-        jwks.keys.every(isJWKLike));
-}
-function isJWKLike(key) {
-    return isObject(key);
+    if (!jwks || typeof jwks !== 'object') {
+        return false;
+    }
+    const { keys } = jwks;
+    return Array.isArray(keys) && keys.every((isObject));
 }
-class LocalJWKSet {
+class LocalJWKSetImpl {
     #jwks;
     #cached = new WeakMap();
     constructor(jwks) {
@@ -39,40 +30,13 @@ class LocalJWKSet {
     }
     async getKey(protectedHeader, token) {
         const { alg, kid } = { ...protectedHeader, ...token?.header };
-        const kty = getKtyFromAlg(alg);
-        const candidates = this.#jwks.keys.filter((jwk) => {
-            let candidate = kty === jwk.kty;
-            if (candidate && typeof kid === 'string') {
-                candidate = kid === jwk.kid;
-            }
-            if (candidate && (typeof jwk.alg === 'string' || kty === 'AKP')) {
-                candidate = alg === jwk.alg;
-            }
-            if (candidate && typeof jwk.use === 'string') {
-                candidate = jwk.use === 'sig';
-            }
-            if (candidate && Array.isArray(jwk.key_ops)) {
-                candidate = jwk.key_ops.includes('verify');
-            }
-            if (candidate) {
-                switch (alg) {
-                    case 'ES256':
-                        candidate = jwk.crv === 'P-256';
-                        break;
-                    case 'ES384':
-                        candidate = jwk.crv === 'P-384';
-                        break;
-                    case 'ES512':
-                        candidate = jwk.crv === 'P-521';
-                        break;
-                    case 'Ed25519':
-                    case 'EdDSA':
-                        candidate = jwk.crv === 'Ed25519';
-                        break;
-                }
-            }
-            return candidate;
-        });
+        const entry = signatureAlgorithm(alg);
+        const candidates = this.#jwks.keys.filter((jwk) => entry.kty.includes(jwk.kty) &&
+            (typeof kid !== 'string' || kid === jwk.kid) &&
+            (!(typeof jwk.alg === 'string' || jwk.kty === 'AKP') || alg === jwk.alg) &&
+            (typeof jwk.use !== 'string' || jwk.use === 'sig') &&
+            (!Array.isArray(jwk.key_ops) || jwk.key_ops.includes('verify')) &&
+            (!entry.crv || jwk.crv === entry.crv));
         const { 0: jwk, length } = candidates;
         if (length === 0) {
             throw new JWKSNoMatchingKey();
@@ -83,37 +47,32 @@ class LocalJWKSet {
             error[Symbol.asyncIterator] = async function* () {
                 for (const jwk of candidates) {
                     try {
-                        yield await importWithAlgCache(_cached, jwk, alg);
+                        yield await importWithAlgCache(_cached, jwk, entry);
                     }
                     catch { }
                 }
             };
             throw error;
         }
-        return importWithAlgCache(this.#cached, jwk, alg);
+        return importWithAlgCache(this.#cached, jwk, entry);
     }
 }
-async function importWithAlgCache(cache, jwk, alg) {
-    const cached = cache.get(jwk) || cache.set(jwk, {}).get(jwk);
-    if (cached[alg] === undefined) {
-        const key = await importJWK({ ...jwk, ext: true }, alg);
-        if (key instanceof Uint8Array || key.type !== 'public') {
+async function importWithAlgCache(cache, jwk, entry) {
+    const cached = cache.get(jwk) || cache.set(jwk, { __proto__: null }).get(jwk);
+    if (cached[entry.alg] === undefined) {
+        const key = await jwkToKey(entry, { ...jwk, alg: entry.alg, ext: true });
+        if (key.type !== 'public') {
             throw new JWKSInvalid('JSON Web Key Set members must be public keys');
         }
-        cached[alg] = key;
+        cached[entry.alg] = key;
     }
-    return cached[alg];
+    return cached[entry.alg];
 }
 export function createLocalJWKSet(jwks) {
-    const set = new LocalJWKSet(jwks);
+    const set = new LocalJWKSetImpl(jwks);
     const localJWKSet = async (protectedHeader, token) => set.getKey(protectedHeader, token);
-    Object.defineProperties(localJWKSet, {
-        jwks: {
-            value: () => structuredClone(set.jwks()),
-            enumerable: false,
-            configurable: false,
-            writable: false,
-        },
+    Object.defineProperty(localJWKSet, 'jwks', {
+        value: () => structuredClone(set.jwks()),
     });
     return localJWKSet;
 }