@zuplo/cli 6.73.26 → 6.73.28

package/node_modules/@modelcontextprotocol/sdk/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({
+            plaintext: this.#plaintext,
+            protectedHeader: this.#protectedHeader,
+            unprotectedHeader: this.#unprotectedHeader,
+            sharedUnprotectedHeader: this.#sharedUnprotectedHeader,
+            aad: this.#aad,
+            cek: this.#cek,
+            iv: this.#iv,
+            keyManagementParameters: this.#keyManagementParameters,
+            crit: options?.crit,
+            unprotectedParameters: options ? unprotected in options : false,
+        }, key);
     }
 }

package/node_modules/@modelcontextprotocol/sdk/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,19 @@ 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();
+    }
     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 +32,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/@modelcontextprotocol/sdk/node_modules/jose/dist/webapi/jwe/general/encrypt.js

@@ -1,13 +1,13 @@
 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 { checkEncryptHeaders, encryptJWE } from '../../lib/jwe_encrypt.js';
+import { prepareKey } from '../../lib/key.js';
+import { jweAlgorithm } from '../../lib/jwe_algorithms.js';
 class IndividualRecipient {
     #parent;
     unprotectedHeader;
@@ -71,6 +71,9 @@ 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 flattened = await new FlattenedEncrypt(this.#plaintext)
@@ -78,6 +81,7 @@ export class GeneralEncrypt {
                 .setProtectedHeader(this.#protectedHeader)
                 .setSharedUnprotectedHeader(this.#unprotectedHeader)
                 .setUnprotectedHeader(recipient.unprotectedHeader)
+                .setKeyManagementParameters(recipient.keyManagementParameters)
                 .encrypt(recipient.key, { ...recipient.options });
             const jwe = {
                 ciphertext: flattened.ciphertext,
@@ -97,42 +101,36 @@ export class GeneralEncrypt {
                 jwe.recipients[0].header = flattened.header;
             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 input = {
+                plaintext: this.#plaintext,
+                protectedHeader: this.#protectedHeader,
+                unprotectedHeader: recipient.unprotectedHeader,
+                sharedUnprotectedHeader: this.#unprotectedHeader,
+                aad: this.#aad,
+                keyManagementParameters: recipient.keyManagementParameters,
+                crit: recipient.options.crit,
+                unprotectedParameters: true,
             };
-            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') {
+            const headers = checkEncryptHeaders(input);
+            inputs.push(input);
+            checked.push(headers);
+            if (headers.alg === 'dir' || headers.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');
-            }
             if (!enc) {
-                enc = joseHeader.enc;
+                enc = headers.enc;
             }
-            else if (enc !== joseHeader.enc) {
+            else if (enc !== headers.enc) {
                 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].encEntry);
         const jwe = {
             ciphertext: '',
             recipients: [],
@@ -142,17 +140,7 @@ export class GeneralEncrypt {
             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,
-                });
+                const flattened = await encryptJWE({ ...inputs[0], cek }, checked[0], recipient.key);
                 jwe.ciphertext = flattened.ciphertext;
                 jwe.iv = flattened.iv;
                 jwe.tag = flattened.tag;
@@ -167,12 +155,9 @@ export class GeneralEncrypt {
                     target.header = flattened.header;
                 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 } = checked[i];
+            const k = await prepareKey(jweAlgorithm(alg), recipient.key, 'encrypt');
+            const { encryptedKey, parameters } = await encryptKeyManagement(alg, checked[i].encEntry, k, cek, recipient.keyManagementParameters);
             target.encrypted_key = b64u(encryptedKey);
             if (recipient.unprotectedHeader || parameters)
                 target.header = { ...recipient.unprotectedHeader, ...parameters };

package/node_modules/@modelcontextprotocol/sdk/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/@modelcontextprotocol/sdk/node_modules/jose/dist/webapi/jwks/local.js

@@ -1,31 +1,25 @@
-import { importJWK } from '../key/import.js';
+import { jwkToKey } from '../lib/jwk_to_key.js';
+import { maybeJWSAlgorithm } 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' ? maybeJWSAlgorithm(alg) : undefined;
+    if (!entry || entry.symmetric) {
+        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));
+    if (!jwks || typeof jwks !== 'object') {
+        return false;
+    }
+    const { keys } = jwks;
+    return Array.isArray(keys) && keys.every(isJWKLike);
 }
 function isJWKLike(key) {
     return isObject(key);
 }
-class LocalJWKSet {
+class LocalJWKSetImpl {
     #jwks;
     #cached = new WeakMap();
     constructor(jwks) {
@@ -39,13 +33,13 @@ class LocalJWKSet {
     }
     async getKey(protectedHeader, token) {
         const { alg, kid } = { ...protectedHeader, ...token?.header };
-        const kty = getKtyFromAlg(alg);
+        const entry = signatureAlgorithm(alg);
         const candidates = this.#jwks.keys.filter((jwk) => {
-            let candidate = kty === jwk.kty;
+            let candidate = entry.kty.includes(jwk.kty);
             if (candidate && typeof kid === 'string') {
                 candidate = kid === jwk.kid;
             }
-            if (candidate && (typeof jwk.alg === 'string' || kty === 'AKP')) {
+            if (candidate && (typeof jwk.alg === 'string' || jwk.kty === 'AKP')) {
                 candidate = alg === jwk.alg;
             }
             if (candidate && typeof jwk.use === 'string') {
@@ -54,22 +48,8 @@ class LocalJWKSet {
             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;
-                }
+            if (candidate && entry.crv) {
+                candidate = jwk.crv === entry.crv;
             }
             return candidate;
         });
@@ -83,29 +63,29 @@ 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) {
+async function importWithAlgCache(cache, jwk, entry) {
     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') {
+    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: {

package/node_modules/@modelcontextprotocol/sdk/node_modules/jose/dist/webapi/jwks/remote.js

@@ -9,7 +9,7 @@ function isCloudflareWorkers() {
 let USER_AGENT;
 if (typeof navigator === 'undefined' || !navigator.userAgent?.startsWith?.('Mozilla/5.0 ')) {
     const NAME = 'jose';
-    const VERSION = 'v6.2.4';
+    const VERSION = 'v6.2.5';
     USER_AGENT = `${NAME}/${VERSION}`;
 }
 export const customFetch = Symbol();
@@ -51,7 +51,7 @@ function isFreshJwksCache(input, cacheMaxAge) {
     }
     return true;
 }
-class RemoteJWKSet {
+class RemoteJWKSetImpl {
     #url;
     #timeoutDuration;
     #cooldownDuration;
@@ -144,7 +144,7 @@ class RemoteJWKSet {
     }
 }
 export function createRemoteJWKSet(url, options) {
-    const set = new RemoteJWKSet(url, options);
+    const set = new RemoteJWKSetImpl(url, options);
     const remoteJWKSet = async (protectedHeader, token) => set.getKey(protectedHeader, token);
     Object.defineProperties(remoteJWKSet, {
         coolingDown: {

package/node_modules/@modelcontextprotocol/sdk/node_modules/jose/dist/webapi/jws/compact/sign.js

@@ -1,18 +1,21 @@
 import { FlattenedSign } from '../flattened/sign.js';
+import { unencodedPayload } from '../../lib/jws_sign.js';
 export class CompactSign {
     #flattened;
+    #protectedHeader;
     constructor(payload) {
         this.#flattened = new FlattenedSign(payload);
     }
     setProtectedHeader(protectedHeader) {
         this.#flattened.setProtectedHeader(protectedHeader);
+        this.#protectedHeader = protectedHeader;
         return this;
     }
     async sign(key, options) {
-        const jws = await this.#flattened.sign(key, options);
-        if (jws.payload === undefined) {
+        if (unencodedPayload(this.#protectedHeader)) {
             throw new TypeError('use the flattened module for creating JWS with b64: false');
         }
+        const jws = await this.#flattened.sign(key, options);
         return `${jws.protected}.${jws.payload}.${jws.signature}`;
     }
 }

package/node_modules/@modelcontextprotocol/sdk/node_modules/jose/dist/webapi/jws/compact/verify.js

@@ -1,19 +1,7 @@
-import { flattenedVerify } from '../flattened/verify.js';
-import { JWSInvalid } from '../../util/errors.js';
-import { decoder } from '../../lib/buffer_utils.js';
+import { prepareVerify, verifyCompact } from '../../lib/jws_verify.js';
 export async function compactVerify(jws, key, options) {
-    if (jws instanceof Uint8Array) {
-        jws = decoder.decode(jws);
-    }
-    if (typeof jws !== 'string') {
-        throw new JWSInvalid('Compact JWS must be a string or Uint8Array');
-    }
-    const { 0: protectedHeader, 1: payload, 2: signature, length } = jws.split('.');
-    if (length !== 3) {
-        throw new JWSInvalid('Invalid Compact JWS');
-    }
-    const verified = await flattenedVerify({ payload, protected: protectedHeader, signature }, key, options);
-    const result = { payload: verified.payload, protectedHeader: verified.protectedHeader };
+    const verified = await verifyCompact(jws, prepareVerify(options), key);
+    const result = { payload: verified.payload, protectedHeader: verified.parsedProt };
     if (typeof key === 'function') {
         return { ...result, key: verified.key };
     }

package/node_modules/@modelcontextprotocol/sdk/node_modules/jose/dist/webapi/jws/flattened/sign.js

@@ -1,11 +1,5 @@
-import { encode as b64u } from '../../util/base64url.js';
-import { sign } from '../../lib/signing.js';
-import { isDisjoint } from '../../lib/type_checks.js';
 import { JWSInvalid } from '../../util/errors.js';
-import { concat, encode } from '../../lib/buffer_utils.js';
-import { checkKeyType } from '../../lib/check_key_type.js';
-import { validateCrit } from '../../lib/validate_crit.js';
-import { normalizeKey } from '../../lib/normalize_key.js';
+import { createSignature } from '../../lib/jws_sign.js';
 import { assertNotSet } from '../../lib/helpers.js';
 export class FlattenedSign {
     #payload;
@@ -31,59 +25,15 @@ export class FlattenedSign {
         if (!this.#protectedHeader && !this.#unprotectedHeader) {
             throw new JWSInvalid('either setProtectedHeader or setUnprotectedHeader must be called before #sign()');
         }
-        if (!isDisjoint(this.#protectedHeader, this.#unprotectedHeader)) {
-            throw new JWSInvalid('JWS Protected and JWS Unprotected Header Parameter names must be disjoint');
-        }
-        const joseHeader = {
-            ...this.#protectedHeader,
-            ...this.#unprotectedHeader,
-        };
-        const extensions = validateCrit(JWSInvalid, new Map([['b64', true]]), options?.crit, this.#protectedHeader, joseHeader);
-        let b64 = true;
-        if (extensions.has('b64')) {
-            b64 = this.#protectedHeader.b64;
-            if (typeof b64 !== 'boolean') {
-                throw new JWSInvalid('The "b64" (base64url-encode payload) Header Parameter must be a boolean');
-            }
-        }
-        const { alg } = joseHeader;
-        if (typeof alg !== 'string' || !alg) {
-            throw new JWSInvalid('JWS "alg" (Algorithm) Header Parameter missing or invalid');
-        }
-        checkKeyType(alg, key, 'sign');
-        let payloadS;
-        let payloadB;
-        if (b64) {
-            payloadS = b64u(this.#payload);
-            payloadB = encode(payloadS);
-        }
-        else {
-            payloadB = this.#payload;
-            payloadS = '';
-        }
-        let protectedHeaderString;
-        let protectedHeaderBytes;
-        if (this.#protectedHeader) {
-            protectedHeaderString = b64u(JSON.stringify(this.#protectedHeader));
-            protectedHeaderBytes = encode(protectedHeaderString);
-        }
-        else {
-            protectedHeaderString = '';
-            protectedHeaderBytes = new Uint8Array();
-        }
-        const data = concat(protectedHeaderBytes, encode('.'), payloadB);
-        const k = await normalizeKey(key, alg);
-        const signature = await sign(alg, k, data);
-        const jws = {
-            signature: b64u(signature),
-            payload: payloadS,
-        };
+        const jws = await createSignature({
+            payload: this.#payload,
+            protectedHeader: this.#protectedHeader,
+            unprotectedHeader: this.#unprotectedHeader,
+            crit: options?.crit,
+        }, key);
         if (this.#unprotectedHeader) {
             jws.header = this.#unprotectedHeader;
         }
-        if (this.#protectedHeader) {
-            jws.protected = protectedHeaderString;
-        }
         return jws;
     }
 }