repocairn 0.1.6 → 0.1.7

package/node_modules/jose/dist/webapi/lib/jwe_decrypt.js

@@ -7,35 +7,75 @@ import { concat, decoder, encode } from './buffer_utils.js';
 import { validateCrit, validateAlgorithms, JWE_RECOGNIZED } from './options.js';
 import { prepareKey } from './key.js';
 import { jweAlgorithm, jweEncryption } from './jwe_algorithms.js';
-import { decompress } from './deflate.js';
-export function checkShared(jwe) {
-    const { ciphertext, protected: encodedProtected, unprotected } = jwe;
-    if (jwe.iv !== undefined && typeof jwe.iv !== 'string') {
+import { decompress, validateZip } from './deflate.js';
+export function snapshotSharedJWE(jwe) {
+    const { aad, ciphertext, iv, protected: encodedProtected, tag, unprotected } = jwe;
+    if (iv !== undefined && typeof iv !== 'string') {
         throw new JWEInvalid('JWE Initialization Vector incorrect type');
     }
     if (typeof ciphertext !== 'string') {
         throw new JWEInvalid('JWE Ciphertext missing or incorrect type');
     }
-    if (jwe.tag !== undefined && typeof jwe.tag !== 'string') {
+    if (tag !== undefined && typeof tag !== 'string') {
         throw new JWEInvalid('JWE Authentication Tag incorrect type');
     }
     if (encodedProtected !== undefined && typeof encodedProtected !== 'string') {
         throw new JWEInvalid('JWE Protected Header incorrect type');
     }
-    if (jwe.aad !== undefined && typeof jwe.aad !== 'string') {
+    if (aad !== undefined && (typeof aad !== 'string' || !aad)) {
         throw new JWEInvalid('JWE AAD incorrect type');
     }
     if (unprotected !== undefined && !isObject(unprotected)) {
         throw new JWEInvalid('JWE Shared Unprotected Header incorrect type');
     }
+    return {
+        aad,
+        ciphertext,
+        iv,
+        protected: encodedProtected,
+        tag,
+        unprotected: unprotected === undefined ? undefined : { ...unprotected },
+    };
+}
+export function snapshotRecipientJWE(recipient) {
+    let header;
+    let headerAlg;
+    try {
+        const { header: inputHeader } = recipient;
+        if (isObject(inputHeader)) {
+            headerAlg = inputHeader.alg;
+            const parameters = Object.keys(inputHeader);
+            if (!parameters.includes('alg'))
+                headerAlg = undefined;
+            header = Object.fromEntries(parameters.map((parameter) => [
+                parameter,
+                parameter === 'alg' ? headerAlg : inputHeader[parameter],
+            ]));
+        }
+        else {
+            header = inputHeader;
+        }
+    }
+    catch (error) {
+        return [undefined, headerAlg, error];
+    }
+    try {
+        const { encrypted_key: encryptedKey } = recipient;
+        return [{ encrypted_key: encryptedKey, header }, headerAlg];
+    }
+    catch (error) {
+        return [undefined, headerAlg, error];
+    }
 }
 export function checkRecipient(jwe) {
     const { encrypted_key: encryptedKey, header } = jwe;
     if (encryptedKey !== undefined && typeof encryptedKey !== 'string') {
         throw new JWEInvalid('JWE Encrypted Key incorrect type');
     }
-    if (header !== undefined && !isObject(header)) {
-        throw new JWEInvalid('JWE Per-Recipient Unprotected Header incorrect type');
+    if (header !== undefined) {
+        if (!isObject(header)) {
+            throw new JWEInvalid('JWE Per-Recipient Unprotected Header incorrect type');
+        }
     }
     if (jwe.protected === undefined && header === undefined && jwe.unprotected === undefined) {
         throw new JWEInvalid('JOSE Header missing');
@@ -44,7 +84,7 @@ export function checkRecipient(jwe) {
 export function shareJWE(jwe) {
     const { protected: encodedProtected, ciphertext, iv, tag, aad } = jwe;
     let parsedProt;
-    if (encodedProtected) {
+    if (encodedProtected !== undefined) {
         parsedProt = parseJoseHeader(encodedProtected, JWEInvalid, 'JWE Protected Header is invalid');
     }
     const protectedHeader = encodedProtected !== undefined ? encode(encodedProtected) : new Uint8Array();
@@ -84,13 +124,14 @@ export function prepareDecrypt(options) {
         options && validateAlgorithms('keyManagementAlgorithms', options.keyManagementAlgorithms),
         options &&
             validateAlgorithms('contentEncryptionAlgorithms', options.contentEncryptionAlgorithms),
-        options,
+        options?.crit,
+        options?.maxPBES2Count,
+        options?.maxDecompressedLength,
     ];
 }
 export async function decryptRecipient(jwe, token, shared, key) {
-    const [keyManagementAlgorithms, contentEncryptionAlgorithms, options] = shared;
-    const [parsedProt, ciphertext, iv, tag, additionalData] = token;
-    const { encrypted_key: encodedKey, header, unprotected } = jwe;
+    const [parsedProt] = token;
+    const { header, unprotected } = jwe;
     let joseHeader;
     if (header !== undefined || unprotected !== undefined) {
         if (!isDisjoint(parsedProt, header, unprotected)) {
@@ -101,13 +142,14 @@ export async function decryptRecipient(jwe, token, shared, key) {
     else {
         joseHeader = parsedProt ?? {};
     }
-    validateCrit(JWEInvalid, JWE_RECOGNIZED, options?.crit, parsedProt, joseHeader);
-    if (joseHeader.zip !== undefined && joseHeader.zip !== 'DEF') {
-        throw new JOSENotSupported('Unsupported JWE "zip" (Compression Algorithm) Header Parameter value.');
-    }
-    if (joseHeader.zip !== undefined && !parsedProt?.zip) {
-        throw new JWEInvalid('JWE "zip" (Compression Algorithm) Header Parameter MUST be in a protected header.');
-    }
+    return decryptRecipientCore(jwe, token, shared, key, joseHeader);
+}
+async function decryptRecipientCore(jwe, token, shared, key, joseHeader) {
+    const [keyManagementAlgorithms, contentEncryptionAlgorithms, crit, maxPBES2Count, maxDecompressedLength,] = shared;
+    const [parsedProt, ciphertext, iv, tag, additionalData] = token;
+    const { encrypted_key: encodedKey } = jwe;
+    validateCrit(JWEInvalid, JWE_RECOGNIZED, crit, parsedProt, joseHeader);
+    validateZip(joseHeader, parsedProt);
     const { alg, enc } = joseHeader;
     if (typeof alg !== 'string' || !alg) {
         throw new JWEInvalid('missing JWE Algorithm (alg) in JWE Header');
@@ -136,7 +178,12 @@ export async function decryptRecipient(jwe, token, shared, key) {
     const k = await prepareKey(alg === 'dir' ? encEntry : algEntry, key, 'decrypt');
     let cek;
     try {
-        cek = await decryptKeyManagement(alg, encEntry, k, encryptedKey, joseHeader, options);
+        cek = await decryptKeyManagement(alg, encEntry, k, encryptedKey, joseHeader, maxPBES2Count);
+        if (encodedKey !== undefined &&
+            cek instanceof Uint8Array &&
+            cek.byteLength << 3 !== encEntry.cekBits) {
+            cek = generateCek(encEntry);
+        }
     }
     catch (err) {
         if (err instanceof TypeError || err instanceof JWEInvalid || err instanceof JOSENotSupported) {
@@ -146,15 +193,15 @@ export async function decryptRecipient(jwe, token, shared, key) {
     }
     let plaintext = await decrypt(encEntry, cek, ciphertext, iv, tag, additionalData);
     if (joseHeader.zip === 'DEF') {
-        const maxDecompressedLength = options?.maxDecompressedLength ?? 250_000;
-        if (maxDecompressedLength === 0) {
+        const decompressionLimit = maxDecompressedLength ?? 250_000;
+        if (decompressionLimit === 0) {
             throw new JOSENotSupported('JWE "zip" (Compression Algorithm) Header Parameter is not supported.');
         }
-        if (maxDecompressedLength !== Infinity &&
-            (!Number.isSafeInteger(maxDecompressedLength) || maxDecompressedLength < 1)) {
+        if (decompressionLimit !== Infinity &&
+            (!Number.isSafeInteger(decompressionLimit) || decompressionLimit < 1)) {
             throw new TypeError('maxDecompressedLength must be 0, a positive safe integer, or Infinity');
         }
-        plaintext = await decompress(plaintext, maxDecompressedLength).catch((cause) => {
+        plaintext = await decompress(plaintext, decompressionLimit).catch((cause) => {
             if (cause instanceof JWEInvalid)
                 throw cause;
             throw new JWEInvalid('Failed to decompress plaintext', { cause });
@@ -176,11 +223,21 @@ export async function decryptCompact(jwe, shared, key) {
     if (length !== 5) {
         throw new JWEInvalid('Invalid Compact JWE');
     }
-    return decryptJWE({
+    const flattened = {
         ciphertext,
         iv: iv || undefined,
         protected: protectedHeader,
         tag: tag || undefined,
         encrypted_key: encryptedKey || undefined,
-    }, shared, key);
+    };
+    const parsedProt = parseJoseHeader(protectedHeader, JWEInvalid, 'JWE Protected Header is invalid');
+    const protectedBytes = encode(protectedHeader);
+    const token = [
+        parsedProt,
+        decodeBase64url(ciphertext, 'ciphertext', JWEInvalid),
+        iv ? decodeBase64url(iv, 'iv', JWEInvalid) : undefined,
+        tag ? decodeBase64url(tag, 'tag', JWEInvalid) : undefined,
+        protectedBytes,
+    ];
+    return decryptRecipientCore(flattened, token, shared, key, parsedProt);
 }

package/node_modules/jose/dist/webapi/lib/jwe_encrypt.js

@@ -1,33 +1,54 @@
 import { encode as b64u } from '../util/base64url.js';
 import { encrypt } from './content_encryption.js';
 import { encryptKeyManagement } from './key_management.js';
-import { JOSENotSupported, JWEInvalid } from '../util/errors.js';
-import { isDisjoint } from './type_checks.js';
+import { JWEInvalid } from '../util/errors.js';
+import { assertUint8Array, isDisjoint, isObject } from './type_checks.js';
 import { concat, encode } from './buffer_utils.js';
-import { validateCrit, JWE_RECOGNIZED } from './options.js';
+import { serializeJoseHeader, validateCrit, validateCritDuplicates, JWE_RECOGNIZED, } from './options.js';
 import { prepareKey } from './key.js';
 import { jweAlgorithm, jweEncryption } from './jwe_algorithms.js';
-import { compress } from './deflate.js';
+import { compress, validateZip } from './deflate.js';
+import { unprotected } from './helpers.js';
 export function checkDisjoint(protectedHeader, unprotectedHeader, sharedUnprotectedHeader) {
     if (!isDisjoint(protectedHeader, unprotectedHeader, sharedUnprotectedHeader)) {
         throw new JWEInvalid('JWE Protected, JWE Shared Unprotected and JWE Per-Recipient Header Parameter names must be disjoint');
     }
 }
 export function checkEncryptHeaders(input) {
-    const [, protectedHeader, unprotectedHeader, sharedUnprotectedHeader, , , , , crit] = input;
+    let [, protectedHeader, unprotectedHeader, sharedUnprotectedHeader, aad, cek, iv, keyManagementParameters, crit,] = input;
+    if (aad !== undefined) {
+        assertUint8Array(aad, 'JWE Additional Authenticated Data');
+    }
+    if (cek !== undefined) {
+        assertUint8Array(cek, 'JWE Content Encryption Key');
+    }
+    if (iv !== undefined) {
+        assertUint8Array(iv, 'JWE Initialization Vector');
+    }
+    if (protectedHeader !== undefined) {
+        protectedHeader = serializeJoseHeader(JWEInvalid, protectedHeader)[0];
+        input[1] = protectedHeader;
+    }
+    if (unprotectedHeader !== undefined) {
+        unprotectedHeader = serializeJoseHeader(JWEInvalid, unprotectedHeader)[0];
+        input[2] = unprotectedHeader;
+    }
+    if (sharedUnprotectedHeader !== undefined) {
+        sharedUnprotectedHeader = serializeJoseHeader(JWEInvalid, sharedUnprotectedHeader)[0];
+        input[3] = sharedUnprotectedHeader;
+    }
+    if (keyManagementParameters !== undefined && !isObject(keyManagementParameters)) {
+        throw new TypeError('JWE Key Management Parameters must be an object');
+    }
     checkDisjoint(protectedHeader, unprotectedHeader, sharedUnprotectedHeader);
     const joseHeader = {
         ...protectedHeader,
         ...unprotectedHeader,
         ...sharedUnprotectedHeader,
     };
+    validateCritDuplicates(JWEInvalid, protectedHeader);
     validateCrit(JWEInvalid, JWE_RECOGNIZED, crit, protectedHeader, joseHeader);
-    if (joseHeader.zip !== undefined && joseHeader.zip !== 'DEF') {
-        throw new JOSENotSupported('Unsupported JWE "zip" (Compression Algorithm) Header Parameter value.');
-    }
-    if (joseHeader.zip !== undefined && !protectedHeader?.zip) {
-        throw new JWEInvalid('JWE "zip" (Compression Algorithm) Header Parameter MUST be in a protected header.');
-    }
+    validateZip(joseHeader, protectedHeader);
     const { alg, enc } = joseHeader;
     if (typeof alg !== 'string' || !alg) {
         throw new JWEInvalid('JWE "alg" (Algorithm) Header Parameter missing or invalid');
@@ -109,6 +130,13 @@ export async function encryptJWE(input, checked, key) {
     }
     return jwe;
 }
-export async function createJWE(input, key) {
+export async function createJWE(input, key, options) {
+    if (!input[1] && !input[2] && !input[3]) {
+        throw new JWEInvalid('either setProtectedHeader, setUnprotectedHeader, or sharedUnprotectedHeader must be called before #encrypt()');
+    }
+    if (options !== undefined) {
+        input[8] = options?.crit;
+        input[9] = options ? unprotected in options : false;
+    }
     return encryptJWE(input, checkEncryptHeaders(input), key);
 }

package/node_modules/jose/dist/webapi/lib/jwk_metadata.js

@@ -0,0 +1,20 @@
+export function snapshotJwk(jwk) {
+    return { __proto__: null, ...jwk };
+}
+export function normalizeJwk(jwk) {
+    const normalized = snapshotJwk(jwk);
+    if (normalized.ext !== undefined && typeof normalized.ext !== 'boolean') {
+        throw new TypeError('"ext" (Extractable) Parameter must be a boolean');
+    }
+    if (normalized.key_ops !== undefined) {
+        const value = normalized.key_ops;
+        const keyOps = Array.isArray(value) ? [...value] : undefined;
+        if (!keyOps ||
+            keyOps.some((operation) => typeof operation !== 'string') ||
+            new Set(keyOps).size !== keyOps.length) {
+            throw new TypeError('"key_ops" (Key Operations) Parameter must be an array of unique strings');
+        }
+        normalized.key_ops = keyOps;
+    }
+    return normalized;
+}

package/node_modules/jose/dist/webapi/lib/jws_sign.js

@@ -4,15 +4,37 @@ import { jwsAlgorithm } from './jws_algorithms.js';
 import { isDisjoint } from './type_checks.js';
 import { JWSInvalid } from '../util/errors.js';
 import { concat, encode } from './buffer_utils.js';
-import { validateCrit, validateCritDuplicates, JWS_RECOGNIZED } from './options.js';
+import { serializeJoseHeader, validateB64, validateCrit, validateCritDuplicates, JWS_RECOGNIZED, } from './options.js';
 import { prepareKey } from './key.js';
-export function unencodedPayload(protectedHeader) {
-    return (protectedHeader?.b64 === false &&
-        Array.isArray(protectedHeader.crit) &&
-        protectedHeader.crit.includes('b64'));
+function serializeProtectedHeader(protectedHeader) {
+    if (protectedHeader === undefined)
+        return [undefined, ''];
+    const normalized = serializeJoseHeader(JWSInvalid, protectedHeader);
+    return [normalized[0], b64u(normalized[1])];
 }
-export async function createSignature(input, key) {
-    const { protectedHeader, unprotectedHeader } = input;
+function validateSignatureHeader(protectedHeader, joseHeader, crit) {
+    validateCritDuplicates(JWSInvalid, protectedHeader);
+    return validateB64(protectedHeader, validateCrit(JWSInvalid, JWS_RECOGNIZED, crit, protectedHeader, joseHeader));
+}
+function signatureAlgorithm(joseHeader) {
+    const alg = joseHeader.alg;
+    if (typeof alg !== 'string' || !alg) {
+        throw new JWSInvalid('JWS "alg" (Algorithm) Header Parameter missing or invalid');
+    }
+    return jwsAlgorithm(alg);
+}
+async function signSignature(protectedHeader, payload, entry, key) {
+    const data = concat(encode(protectedHeader), encode('.'), payload);
+    const k = await prepareKey(entry, key, 'sign');
+    return b64u(await sign(entry, k, data));
+}
+export async function createSignature(input, key, assertB64) {
+    let { protectedHeader, unprotectedHeader } = input;
+    let protectedHeaderString;
+    [protectedHeader, protectedHeaderString] = serializeProtectedHeader(protectedHeader);
+    if (unprotectedHeader !== undefined) {
+        unprotectedHeader = serializeJoseHeader(JWSInvalid, unprotectedHeader)[0];
+    }
     if (!protectedHeader && !unprotectedHeader) {
         throw new JWSInvalid('either setProtectedHeader or setUnprotectedHeader must be called before #sign()');
     }
@@ -20,20 +42,9 @@ export async function createSignature(input, key) {
         throw new JWSInvalid('JWS Protected and JWS Unprotected Header Parameter names must be disjoint');
     }
     const joseHeader = { ...protectedHeader, ...unprotectedHeader };
-    validateCritDuplicates(JWSInvalid, protectedHeader);
-    const extensions = validateCrit(JWSInvalid, JWS_RECOGNIZED, input.crit, protectedHeader, joseHeader);
-    let b64 = true;
-    if (extensions.includes('b64')) {
-        b64 = 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');
-    }
-    const entry = jwsAlgorithm(alg);
+    const b64 = validateSignatureHeader(protectedHeader, joseHeader, input.crit);
+    assertB64?.(b64);
+    const entry = signatureAlgorithm(joseHeader);
     let payloadS;
     let payloadB;
     if (b64) {
@@ -47,21 +58,8 @@ export async function createSignature(input, key) {
         payloadB = input.payload;
         payloadS = '';
     }
-    let protectedHeaderString;
-    let protectedHeaderBytes;
-    if (protectedHeader) {
-        protectedHeaderString = b64u(JSON.stringify(protectedHeader));
-        protectedHeaderBytes = encode(protectedHeaderString);
-    }
-    else {
-        protectedHeaderString = '';
-        protectedHeaderBytes = new Uint8Array();
-    }
-    const data = concat(protectedHeaderBytes, encode('.'), payloadB);
-    const k = await prepareKey(entry, key, 'sign');
-    const signature = await sign(entry, k, data);
     const jws = {
-        signature: b64u(signature),
+        signature: await signSignature(protectedHeaderString, payloadB, entry, key),
         payload: payloadS,
     };
     if (protectedHeader) {
@@ -70,5 +68,18 @@ export async function createSignature(input, key) {
     if (unprotectedHeader) {
         jws.header = unprotectedHeader;
     }
-    return jws;
+    return [jws, b64];
+}
+export async function createCompactSignature(payload, inputProtectedHeader, inputCrit, key, rejectUnencoded) {
+    const [protectedHeader, protectedHeaderString] = serializeProtectedHeader(inputProtectedHeader);
+    if (!protectedHeader) {
+        throw new JWSInvalid('either setProtectedHeader or setUnprotectedHeader must be called before #sign()');
+    }
+    const b64 = validateSignatureHeader(protectedHeader, protectedHeader, inputCrit);
+    if (!b64)
+        rejectUnencoded();
+    const entry = signatureAlgorithm(protectedHeader);
+    const encodedPayload = b64u(payload);
+    const signature = await signSignature(protectedHeaderString, encode(encodedPayload), entry, key);
+    return `${protectedHeaderString}.${encodedPayload}.${signature}`;
 }

package/node_modules/jose/dist/webapi/lib/jws_verify.js

@@ -3,9 +3,25 @@ import { jwsAlgorithm } from './jws_algorithms.js';
 import { JOSEAlgNotAllowed, JWSInvalid, JWSSignatureVerificationFailed } from '../util/errors.js';
 import { concat, decoder, encoder, encode } from './buffer_utils.js';
 import { decodeBase64url, encodeBase64url, parseJoseHeader } from './helpers.js';
-import { isDisjoint } from './type_checks.js';
-import { validateCrit, validateAlgorithms, JWS_RECOGNIZED } from './options.js';
+import { isDisjoint, isObject } from './type_checks.js';
+import { validateB64, validateCrit, validateAlgorithms, JWS_RECOGNIZED } from './options.js';
 import { prepareKey } from './key.js';
+export function snapshotJws(jws, sharedPayload) {
+    const encodedProtected = jws.protected;
+    const inputHeader = jws.header;
+    const header = isObject(inputHeader) ? { ...inputHeader } : inputHeader;
+    let payload = sharedPayload ? sharedPayload[0] : jws.payload;
+    if (!sharedPayload && payload instanceof Uint8Array) {
+        payload = new Uint8Array(payload);
+    }
+    const signature = jws.signature;
+    const snapshot = { payload, signature };
+    if (encodedProtected !== undefined)
+        snapshot.protected = encodedProtected;
+    if (inputHeader !== undefined)
+        snapshot.header = header;
+    return snapshot;
+}
 export function verifyResult(jws, verified) {
     const [payload, parsedProt, , key, resolvedKey] = verified;
     const result = { payload };
@@ -23,12 +39,24 @@ export function verifyResult(jws, verified) {
 export function prepareVerify(options) {
     return [options && validateAlgorithms('algorithms', options.algorithms), options?.crit];
 }
-export async function verifySignature(jws, shared, key) {
-    const { protected: encodedProtected, header, payload: inputPayload } = jws;
-    let parsedProt = {};
-    if (encodedProtected) {
-        parsedProt = parseJoseHeader(encodedProtected, JWSInvalid, 'JWS Protected Header is invalid');
+export function parseProtectedHeader(encodedProtected, parsedProtected = encodedProtected === undefined
+    ? {}
+    : parseJoseHeader(encodedProtected, JWSInvalid, 'JWS Protected Header is invalid')) {
+    return parsedProtected;
+}
+function validateJwsHeaders(parsedProt, joseHeader, shared) {
+    const b64 = validateB64(parsedProt, validateCrit(JWSInvalid, JWS_RECOGNIZED, shared[1], parsedProt, joseHeader));
+    const alg = joseHeader.alg;
+    if (typeof alg !== 'string' || !alg) {
+        throw new JWSInvalid('JWS "alg" (Algorithm) Header Parameter missing or invalid');
     }
+    if (shared[0] && !shared[0].has(alg)) {
+        throw new JOSEAlgNotAllowed('"alg" (Algorithm) Header Parameter value not allowed');
+    }
+    return [b64, alg];
+}
+export function parseJwsHeaders(encodedProtected, header, shared, parsedProtected) {
+    const parsedProt = parseProtectedHeader(encodedProtected, parsedProtected);
     let joseHeader;
     if (header !== undefined) {
         if (!isDisjoint(parsedProt, header)) {
@@ -39,58 +67,58 @@ export async function verifySignature(jws, shared, key) {
     else {
         joseHeader = parsedProt;
     }
-    const extensions = validateCrit(JWSInvalid, JWS_RECOGNIZED, shared[1], parsedProt, joseHeader);
-    let b64 = true;
-    if (extensions.includes('b64')) {
-        b64 = parsedProt.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');
-    }
-    if (shared[0] && !shared[0].has(alg)) {
-        throw new JOSEAlgNotAllowed('"alg" (Algorithm) Header Parameter value not allowed');
-    }
-    if (b64) {
-        if (typeof inputPayload !== 'string') {
-            throw new JWSInvalid('JWS Payload must be a string');
-        }
+    return [parsedProt, joseHeader, ...validateJwsHeaders(parsedProt, joseHeader, shared)];
+}
+export function encodeJsonUnencodedPayload(payload) {
+    const invalid = /[\p{Cs}\p{Cn}]/u.exec(payload)?.[0];
+    if (invalid !== undefined) {
+        throw new JWSInvalid(/\p{Cs}/u.test(invalid)
+            ? 'JWS Payload must be a well-formed Unicode string'
+            : 'JWS Payload must not contain unassigned Unicode code points');
+    }
+    return encoder.encode(payload);
+}
+function encodeCompactUnencodedPayload(payload) {
+    try {
+        return encode(payload);
     }
-    else if (typeof inputPayload !== 'string' && !(inputPayload instanceof Uint8Array)) {
-        throw new JWSInvalid('JWS Payload must be a string or an Uint8Array instance');
+    catch {
+        throw new JWSInvalid('JWS Compact Serialization payload must use only ASCII characters');
     }
+}
+async function verifyPrepared(jws, shared, key, encodedProtected, parsedProt, alg, signingPayload) {
     let resolvedKey = false;
     if (typeof key === 'function') {
         key = await key(parsedProt, jws);
         resolvedKey = true;
     }
+    const b64 = typeof signingPayload === 'string';
     const entry = jwsAlgorithm(alg);
-    const data = concat(encodedProtected !== undefined ? encode(encodedProtected) : new Uint8Array(), encode('.'), typeof inputPayload === 'string'
-        ? b64
-            ?
-                (shared[2] ??= encodeBase64url(inputPayload, 'payload', JWSInvalid))
-            : encoder.encode(inputPayload)
-        : inputPayload);
+    const data = concat(encodedProtected !== undefined ? encode(encodedProtected) : new Uint8Array(), encode('.'), b64
+        ?
+            (shared[2] ??= encodeBase64url(signingPayload, 'payload', JWSInvalid))
+        : signingPayload);
     const signature = decodeBase64url(jws.signature, 'signature', JWSInvalid);
     const k = await prepareKey(entry, key, 'verify');
-    const verified = await verify(entry, k, signature, data);
-    if (!verified) {
+    if (!(await verify(entry, k, signature, data))) {
         throw new JWSSignatureVerificationFailed();
     }
-    let payload;
+    const payload = b64 ? decodeBase64url(signingPayload, 'payload', JWSInvalid) : signingPayload;
+    return [payload, parsedProt, b64, k, resolvedKey];
+}
+export async function verifySignature(jws, shared, key, encodeUnencodedPayload, parsedProtected) {
+    const { protected: encodedProtected, header, payload: inputPayload } = jws;
+    const [parsedProt, , b64, alg] = parseJwsHeaders(encodedProtected, header, shared, parsedProtected);
     if (b64) {
-        payload = decodeBase64url(inputPayload, 'payload', JWSInvalid);
-    }
-    else if (typeof inputPayload === 'string') {
-        payload = encoder.encode(inputPayload);
+        if (typeof inputPayload !== 'string') {
+            throw new JWSInvalid('JWS Payload must be a string');
+        }
     }
-    else {
-        payload = inputPayload;
+    else if (typeof inputPayload !== 'string' && !(inputPayload instanceof Uint8Array)) {
+        throw new JWSInvalid('JWS Payload must be a string or an Uint8Array instance');
     }
-    return [payload, parsedProt, b64, k, resolvedKey];
+    const signingPayload = b64 || typeof inputPayload !== 'string' ? inputPayload : encodeUnencodedPayload(inputPayload);
+    return verifyPrepared(jws, shared, key, encodedProtected, parsedProt, alg, signingPayload);
 }
 export async function verifyCompact(jws, shared, key) {
     if (jws instanceof Uint8Array) {
@@ -103,5 +131,9 @@ export async function verifyCompact(jws, shared, key) {
     if (length !== 3) {
         throw new JWSInvalid('Invalid Compact JWS');
     }
-    return verifySignature({ payload, protected: protectedHeader, signature }, shared, key);
+    const compactJws = { payload, protected: protectedHeader, signature };
+    const parsedProt = parseProtectedHeader(protectedHeader);
+    const [b64, alg] = validateJwsHeaders(parsedProt, parsedProt, shared);
+    const signingPayload = b64 ? payload : encodeCompactUnencodedPayload(payload);
+    return verifyPrepared(compactJws, shared, key, protectedHeader, parsedProt, alg, signingPayload);
 }