jose 6.2.10 → 6.2.12

package/dist/webapi/lib/options.js

@@ -1,74 +0,0 @@
-import { JOSENotSupported, JWEInvalid, JWSInvalid } from '../util/errors.js';
-import { isObject } from './type_checks.js';
-export const JWS_RECOGNIZED = { __proto__: null, b64: true };
-export const JWE_RECOGNIZED = { __proto__: null };
-export function validateAlgorithms(option, algorithms) {
-    if (algorithms !== undefined &&
-        (!Array.isArray(algorithms) || algorithms.some((s) => typeof s !== 'string'))) {
-        throw new TypeError(`"${option}" option must be an array of strings`);
-    }
-    if (!algorithms) {
-        return undefined;
-    }
-    return new Set(algorithms);
-}
-export function validateCritDuplicates(Err, protectedHeader) {
-    const { crit } = protectedHeader ?? {};
-    if (Array.isArray(crit) && new Set(crit).size !== crit.length) {
-        throw new Err('"crit" (Critical) Header Parameter MUST NOT contain duplicate values');
-    }
-}
-export 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 [];
-    }
-    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');
-    }
-    const recognized = recognizedOption === undefined
-        ? recognizedDefault
-        : { __proto__: null, ...recognizedOption, ...recognizedDefault };
-    for (const parameter of protectedHeader.crit) {
-        if (!(parameter in recognized)) {
-            throw new JOSENotSupported(`Extension Header Parameter "${parameter}" is not recognized`);
-        }
-        if (!Object.hasOwn(joseHeader, parameter) || joseHeader[parameter] === undefined) {
-            throw new Err(`Extension Header Parameter "${parameter}" is missing`);
-        }
-        if (recognized[parameter] &&
-            (!Object.hasOwn(protectedHeader, parameter) || protectedHeader[parameter] === undefined)) {
-            throw new Err(`Extension Header Parameter "${parameter}" MUST be integrity protected`);
-        }
-    }
-    return protectedHeader.crit;
-}
-export function validateB64(protectedHeader, extensions) {
-    if (extensions.includes('b64')) {
-        const b64 = protectedHeader.b64;
-        if (typeof b64 !== 'boolean') {
-            throw new JWSInvalid('The "b64" (base64url-encode payload) Header Parameter must be a boolean');
-        }
-        return b64;
-    }
-    return true;
-}
-export function serializeJoseHeader(Err, header) {
-    let serialized;
-    let parsed;
-    try {
-        serialized = JSON.stringify(header);
-        parsed = JSON.parse(serialized);
-    }
-    catch (cause) {
-        throw new Err('JOSE Header is not valid JSON', { cause });
-    }
-    if (!isObject(parsed)) {
-        throw new Err('JOSE Header is not a JSON object');
-    }
-    return [parsed, serialized];
-}

package/dist/webapi/lib/signing.js

@@ -1,26 +0,0 @@
-import { checkCryptoKey, checkModulusLength } from './crypto_key.js';
-async function getSigKey(entry, key, usage) {
-    if (key instanceof Uint8Array) {
-        return crypto.subtle.importKey('raw', key, entry.subtle, false, [
-            usage,
-        ]);
-    }
-    checkCryptoKey(key, entry.subtle, usage);
-    if (entry.minRsaBits)
-        checkModulusLength(entry.alg, key);
-    return key;
-}
-export async function sign(entry, key, data) {
-    const cryptoKey = await getSigKey(entry, key, 'sign');
-    const signature = await crypto.subtle.sign(entry.signing, cryptoKey, data);
-    return new Uint8Array(signature);
-}
-export async function verify(entry, key, signature, data) {
-    const cryptoKey = await getSigKey(entry, key, 'verify');
-    try {
-        return await crypto.subtle.verify(entry.signing, cryptoKey, signature, data);
-    }
-    catch {
-        return false;
-    }
-}

package/dist/webapi/lib/type_checks.js

@@ -1,33 +0,0 @@
-export function assertUint8Array(input, label) {
-    if (!(input instanceof Uint8Array)) {
-        throw new TypeError(`${label} must be an instance of Uint8Array`);
-    }
-}
-export function isObject(input) {
-    if (typeof input !== 'object' ||
-        input === null ||
-        Object.prototype.toString.call(input) !== '[object Object]') {
-        return false;
-    }
-    const prototype = Object.getPrototypeOf(input);
-    return prototype === null || Object.getPrototypeOf(prototype) === null;
-}
-export function isJwkSet(input) {
-    return (isObject(input) &&
-        Array.isArray(input.keys) &&
-        Array.from(input.keys).every(isObject));
-}
-export function isDisjoint(...headers) {
-    const parameters = new Set();
-    for (const header of headers) {
-        if (!header)
-            continue;
-        for (const parameter of Object.keys(header)) {
-            if (parameters.has(parameter)) {
-                return false;
-            }
-            parameters.add(parameter);
-        }
-    }
-    return true;
-}