@undefineds.co/xpod 0.4.15 → 0.4.17

package/node_modules/jose/dist/browser/runtime/asn1.js

@@ -1,205 +0,0 @@
-import crypto, { isCryptoKey } from './webcrypto.js';
-import invalidKeyInput from '../lib/invalid_key_input.js';
-import { encodeBase64, decodeBase64 } from './base64url.js';
-import formatPEM from '../lib/format_pem.js';
-import { JOSENotSupported } from '../util/errors.js';
-import { types } from './is_key_like.js';
-const genericExport = async (keyType, keyFormat, key) => {
-    if (!isCryptoKey(key)) {
-        throw new TypeError(invalidKeyInput(key, ...types));
-    }
-    if (!key.extractable) {
-        throw new TypeError('CryptoKey is not extractable');
-    }
-    if (key.type !== keyType) {
-        throw new TypeError(`key is not a ${keyType} key`);
-    }
-    return formatPEM(encodeBase64(new Uint8Array(await crypto.subtle.exportKey(keyFormat, key))), `${keyType.toUpperCase()} KEY`);
-};
-export const toSPKI = (key) => {
-    return genericExport('public', 'spki', key);
-};
-export const toPKCS8 = (key) => {
-    return genericExport('private', 'pkcs8', key);
-};
-const findOid = (keyData, oid, from = 0) => {
-    if (from === 0) {
-        oid.unshift(oid.length);
-        oid.unshift(0x06);
-    }
-    const i = keyData.indexOf(oid[0], from);
-    if (i === -1)
-        return false;
-    const sub = keyData.subarray(i, i + oid.length);
-    if (sub.length !== oid.length)
-        return false;
-    return sub.every((value, index) => value === oid[index]) || findOid(keyData, oid, i + 1);
-};
-const getNamedCurve = (keyData) => {
-    switch (true) {
-        case findOid(keyData, [0x2a, 0x86, 0x48, 0xce, 0x3d, 0x03, 0x01, 0x07]):
-            return 'P-256';
-        case findOid(keyData, [0x2b, 0x81, 0x04, 0x00, 0x22]):
-            return 'P-384';
-        case findOid(keyData, [0x2b, 0x81, 0x04, 0x00, 0x23]):
-            return 'P-521';
-        case findOid(keyData, [0x2b, 0x65, 0x6e]):
-            return 'X25519';
-        case findOid(keyData, [0x2b, 0x65, 0x6f]):
-            return 'X448';
-        case findOid(keyData, [0x2b, 0x65, 0x70]):
-            return 'Ed25519';
-        case findOid(keyData, [0x2b, 0x65, 0x71]):
-            return 'Ed448';
-        default:
-            throw new JOSENotSupported('Invalid or unsupported EC Key Curve or OKP Key Sub Type');
-    }
-};
-const genericImport = async (replace, keyFormat, pem, alg, options) => {
-    let algorithm;
-    let keyUsages;
-    const keyData = new Uint8Array(atob(pem.replace(replace, ''))
-        .split('')
-        .map((c) => c.charCodeAt(0)));
-    const isPublic = keyFormat === 'spki';
-    switch (alg) {
-        case 'PS256':
-        case 'PS384':
-        case 'PS512':
-            algorithm = { name: 'RSA-PSS', hash: `SHA-${alg.slice(-3)}` };
-            keyUsages = isPublic ? ['verify'] : ['sign'];
-            break;
-        case 'RS256':
-        case 'RS384':
-        case 'RS512':
-            algorithm = { name: 'RSASSA-PKCS1-v1_5', hash: `SHA-${alg.slice(-3)}` };
-            keyUsages = isPublic ? ['verify'] : ['sign'];
-            break;
-        case 'RSA-OAEP':
-        case 'RSA-OAEP-256':
-        case 'RSA-OAEP-384':
-        case 'RSA-OAEP-512':
-            algorithm = {
-                name: 'RSA-OAEP',
-                hash: `SHA-${parseInt(alg.slice(-3), 10) || 1}`,
-            };
-            keyUsages = isPublic ? ['encrypt', 'wrapKey'] : ['decrypt', 'unwrapKey'];
-            break;
-        case 'ES256':
-            algorithm = { name: 'ECDSA', namedCurve: 'P-256' };
-            keyUsages = isPublic ? ['verify'] : ['sign'];
-            break;
-        case 'ES384':
-            algorithm = { name: 'ECDSA', namedCurve: 'P-384' };
-            keyUsages = isPublic ? ['verify'] : ['sign'];
-            break;
-        case 'ES512':
-            algorithm = { name: 'ECDSA', namedCurve: 'P-521' };
-            keyUsages = isPublic ? ['verify'] : ['sign'];
-            break;
-        case 'ECDH-ES':
-        case 'ECDH-ES+A128KW':
-        case 'ECDH-ES+A192KW':
-        case 'ECDH-ES+A256KW': {
-            const namedCurve = getNamedCurve(keyData);
-            algorithm = namedCurve.startsWith('P-') ? { name: 'ECDH', namedCurve } : { name: namedCurve };
-            keyUsages = isPublic ? [] : ['deriveBits'];
-            break;
-        }
-        case 'Ed25519':
-            algorithm = { name: 'Ed25519' };
-            keyUsages = isPublic ? ['verify'] : ['sign'];
-            break;
-        case 'EdDSA':
-            algorithm = { name: getNamedCurve(keyData) };
-            keyUsages = isPublic ? ['verify'] : ['sign'];
-            break;
-        default:
-            throw new JOSENotSupported('Invalid or unsupported "alg" (Algorithm) value');
-    }
-    return crypto.subtle.importKey(keyFormat, keyData, algorithm, options?.extractable ?? false, keyUsages);
-};
-export const fromPKCS8 = (pem, alg, options) => {
-    return genericImport(/(?:-----(?:BEGIN|END) PRIVATE KEY-----|\s)/g, 'pkcs8', pem, alg, options);
-};
-export const fromSPKI = (pem, alg, options) => {
-    return genericImport(/(?:-----(?:BEGIN|END) PUBLIC KEY-----|\s)/g, 'spki', pem, alg, options);
-};
-function getElement(seq) {
-    const result = [];
-    let next = 0;
-    while (next < seq.length) {
-        const nextPart = parseElement(seq.subarray(next));
-        result.push(nextPart);
-        next += nextPart.byteLength;
-    }
-    return result;
-}
-function parseElement(bytes) {
-    let position = 0;
-    let tag = bytes[0] & 0x1f;
-    position++;
-    if (tag === 0x1f) {
-        tag = 0;
-        while (bytes[position] >= 0x80) {
-            tag = tag * 128 + bytes[position] - 0x80;
-            position++;
-        }
-        tag = tag * 128 + bytes[position] - 0x80;
-        position++;
-    }
-    let length = 0;
-    if (bytes[position] < 0x80) {
-        length = bytes[position];
-        position++;
-    }
-    else if (length === 0x80) {
-        length = 0;
-        while (bytes[position + length] !== 0 || bytes[position + length + 1] !== 0) {
-            if (length > bytes.byteLength) {
-                throw new TypeError('invalid indefinite form length');
-            }
-            length++;
-        }
-        const byteLength = position + length + 2;
-        return {
-            byteLength,
-            contents: bytes.subarray(position, position + length),
-            raw: bytes.subarray(0, byteLength),
-        };
-    }
-    else {
-        const numberOfDigits = bytes[position] & 0x7f;
-        position++;
-        length = 0;
-        for (let i = 0; i < numberOfDigits; i++) {
-            length = length * 256 + bytes[position];
-            position++;
-        }
-    }
-    const byteLength = position + length;
-    return {
-        byteLength,
-        contents: bytes.subarray(position, byteLength),
-        raw: bytes.subarray(0, byteLength),
-    };
-}
-function spkiFromX509(buf) {
-    const tbsCertificate = getElement(getElement(parseElement(buf).contents)[0].contents);
-    return encodeBase64(tbsCertificate[tbsCertificate[0].raw[0] === 0xa0 ? 6 : 5].raw);
-}
-function getSPKI(x509) {
-    const pem = x509.replace(/(?:-----(?:BEGIN|END) CERTIFICATE-----|\s)/g, '');
-    const raw = decodeBase64(pem);
-    return formatPEM(spkiFromX509(raw), 'PUBLIC KEY');
-}
-export const fromX509 = (pem, alg, options) => {
-    let spki;
-    try {
-        spki = getSPKI(pem);
-    }
-    catch (cause) {
-        throw new TypeError('Failed to parse the X.509 certificate', { cause });
-    }
-    return fromSPKI(spki, alg, options);
-};

package/node_modules/jose/dist/browser/runtime/base64url.js

@@ -1,37 +0,0 @@
-import { encoder, decoder } from '../lib/buffer_utils.js';
-export const encodeBase64 = (input) => {
-    let unencoded = input;
-    if (typeof unencoded === 'string') {
-        unencoded = encoder.encode(unencoded);
-    }
-    const CHUNK_SIZE = 0x8000;
-    const arr = [];
-    for (let i = 0; i < unencoded.length; i += CHUNK_SIZE) {
-        arr.push(String.fromCharCode.apply(null, unencoded.subarray(i, i + CHUNK_SIZE)));
-    }
-    return btoa(arr.join(''));
-};
-export const encode = (input) => {
-    return encodeBase64(input).replace(/=/g, '').replace(/\+/g, '-').replace(/\//g, '_');
-};
-export const decodeBase64 = (encoded) => {
-    const binary = atob(encoded);
-    const bytes = new Uint8Array(binary.length);
-    for (let i = 0; i < binary.length; i++) {
-        bytes[i] = binary.charCodeAt(i);
-    }
-    return bytes;
-};
-export const decode = (input) => {
-    let encoded = input;
-    if (encoded instanceof Uint8Array) {
-        encoded = decoder.decode(encoded);
-    }
-    encoded = encoded.replace(/-/g, '+').replace(/_/g, '/').replace(/\s/g, '');
-    try {
-        return decodeBase64(encoded);
-    }
-    catch {
-        throw new TypeError('The input to be decoded is not correctly encoded.');
-    }
-};

package/node_modules/jose/dist/browser/runtime/bogus.js

@@ -1,6 +0,0 @@
-const bogusWebCrypto = [
-    { hash: 'SHA-256', name: 'HMAC' },
-    true,
-    ['sign'],
-];
-export default bogusWebCrypto;

package/node_modules/jose/dist/browser/runtime/check_cek_length.js

@@ -1,8 +0,0 @@
-import { JWEInvalid } from '../util/errors.js';
-const checkCekLength = (cek, expected) => {
-    const actual = cek.byteLength << 3;
-    if (actual !== expected) {
-        throw new JWEInvalid(`Invalid Content Encryption Key length. Expected ${expected} bits, got ${actual} bits`);
-    }
-};
-export default checkCekLength;

package/node_modules/jose/dist/browser/runtime/check_key_length.js

@@ -1,8 +0,0 @@
-export default (alg, key) => {
-    if (alg.startsWith('RS') || alg.startsWith('PS')) {
-        const { modulusLength } = key.algorithm;
-        if (typeof modulusLength !== 'number' || modulusLength < 2048) {
-            throw new TypeError(`${alg} requires key modulusLength to be 2048 bits or larger`);
-        }
-    }
-};

package/node_modules/jose/dist/browser/runtime/decrypt.js

@@ -1,91 +0,0 @@
-import { concat, uint64be } from '../lib/buffer_utils.js';
-import checkIvLength from '../lib/check_iv_length.js';
-import checkCekLength from './check_cek_length.js';
-import timingSafeEqual from './timing_safe_equal.js';
-import { JOSENotSupported, JWEDecryptionFailed, JWEInvalid } from '../util/errors.js';
-import crypto, { isCryptoKey } from './webcrypto.js';
-import { checkEncCryptoKey } from '../lib/crypto_key.js';
-import invalidKeyInput from '../lib/invalid_key_input.js';
-import { types } from './is_key_like.js';
-async function cbcDecrypt(enc, cek, ciphertext, iv, tag, aad) {
-    if (!(cek instanceof Uint8Array)) {
-        throw new TypeError(invalidKeyInput(cek, 'Uint8Array'));
-    }
-    const keySize = parseInt(enc.slice(1, 4), 10);
-    const encKey = await crypto.subtle.importKey('raw', cek.subarray(keySize >> 3), 'AES-CBC', false, ['decrypt']);
-    const macKey = await crypto.subtle.importKey('raw', cek.subarray(0, keySize >> 3), {
-        hash: `SHA-${keySize << 1}`,
-        name: 'HMAC',
-    }, false, ['sign']);
-    const macData = concat(aad, iv, ciphertext, uint64be(aad.length << 3));
-    const expectedTag = new Uint8Array((await crypto.subtle.sign('HMAC', macKey, macData)).slice(0, keySize >> 3));
-    let macCheckPassed;
-    try {
-        macCheckPassed = timingSafeEqual(tag, expectedTag);
-    }
-    catch {
-    }
-    if (!macCheckPassed) {
-        throw new JWEDecryptionFailed();
-    }
-    let plaintext;
-    try {
-        plaintext = new Uint8Array(await crypto.subtle.decrypt({ iv, name: 'AES-CBC' }, encKey, ciphertext));
-    }
-    catch {
-    }
-    if (!plaintext) {
-        throw new JWEDecryptionFailed();
-    }
-    return plaintext;
-}
-async function gcmDecrypt(enc, cek, ciphertext, iv, tag, aad) {
-    let encKey;
-    if (cek instanceof Uint8Array) {
-        encKey = await crypto.subtle.importKey('raw', cek, 'AES-GCM', false, ['decrypt']);
-    }
-    else {
-        checkEncCryptoKey(cek, enc, 'decrypt');
-        encKey = cek;
-    }
-    try {
-        return new Uint8Array(await crypto.subtle.decrypt({
-            additionalData: aad,
-            iv,
-            name: 'AES-GCM',
-            tagLength: 128,
-        }, encKey, concat(ciphertext, tag)));
-    }
-    catch {
-        throw new JWEDecryptionFailed();
-    }
-}
-const decrypt = async (enc, cek, ciphertext, iv, tag, aad) => {
-    if (!isCryptoKey(cek) && !(cek instanceof Uint8Array)) {
-        throw new TypeError(invalidKeyInput(cek, ...types, 'Uint8Array'));
-    }
-    if (!iv) {
-        throw new JWEInvalid('JWE Initialization Vector missing');
-    }
-    if (!tag) {
-        throw new JWEInvalid('JWE Authentication Tag missing');
-    }
-    checkIvLength(enc, iv);
-    switch (enc) {
-        case 'A128CBC-HS256':
-        case 'A192CBC-HS384':
-        case 'A256CBC-HS512':
-            if (cek instanceof Uint8Array)
-                checkCekLength(cek, parseInt(enc.slice(-3), 10));
-            return cbcDecrypt(enc, cek, ciphertext, iv, tag, aad);
-        case 'A128GCM':
-        case 'A192GCM':
-        case 'A256GCM':
-            if (cek instanceof Uint8Array)
-                checkCekLength(cek, parseInt(enc.slice(1, 4), 10));
-            return gcmDecrypt(enc, cek, ciphertext, iv, tag, aad);
-        default:
-            throw new JOSENotSupported('Unsupported JWE Content Encryption Algorithm');
-    }
-};
-export default decrypt;

package/node_modules/jose/dist/browser/runtime/digest.js

@@ -1,6 +0,0 @@
-import crypto from './webcrypto.js';
-const digest = async (algorithm, data) => {
-    const subtleDigest = `SHA-${algorithm.slice(-3)}`;
-    return new Uint8Array(await crypto.subtle.digest(subtleDigest, data));
-};
-export default digest;

package/node_modules/jose/dist/browser/runtime/ecdhes.js

@@ -1,47 +0,0 @@
-import { encoder, concat, uint32be, lengthAndInput, concatKdf } from '../lib/buffer_utils.js';
-import crypto, { isCryptoKey } from './webcrypto.js';
-import { checkEncCryptoKey } from '../lib/crypto_key.js';
-import invalidKeyInput from '../lib/invalid_key_input.js';
-import { types } from './is_key_like.js';
-export async function deriveKey(publicKey, privateKey, algorithm, keyLength, apu = new Uint8Array(0), apv = new Uint8Array(0)) {
-    if (!isCryptoKey(publicKey)) {
-        throw new TypeError(invalidKeyInput(publicKey, ...types));
-    }
-    checkEncCryptoKey(publicKey, 'ECDH');
-    if (!isCryptoKey(privateKey)) {
-        throw new TypeError(invalidKeyInput(privateKey, ...types));
-    }
-    checkEncCryptoKey(privateKey, 'ECDH', 'deriveBits');
-    const value = concat(lengthAndInput(encoder.encode(algorithm)), lengthAndInput(apu), lengthAndInput(apv), uint32be(keyLength));
-    let length;
-    if (publicKey.algorithm.name === 'X25519') {
-        length = 256;
-    }
-    else if (publicKey.algorithm.name === 'X448') {
-        length = 448;
-    }
-    else {
-        length =
-            Math.ceil(parseInt(publicKey.algorithm.namedCurve.substr(-3), 10) / 8) <<
-                3;
-    }
-    const sharedSecret = new Uint8Array(await crypto.subtle.deriveBits({
-        name: publicKey.algorithm.name,
-        public: publicKey,
-    }, privateKey, length));
-    return concatKdf(sharedSecret, keyLength, value);
-}
-export async function generateEpk(key) {
-    if (!isCryptoKey(key)) {
-        throw new TypeError(invalidKeyInput(key, ...types));
-    }
-    return crypto.subtle.generateKey(key.algorithm, true, ['deriveBits']);
-}
-export function ecdhAllowed(key) {
-    if (!isCryptoKey(key)) {
-        throw new TypeError(invalidKeyInput(key, ...types));
-    }
-    return (['P-256', 'P-384', 'P-521'].includes(key.algorithm.namedCurve) ||
-        key.algorithm.name === 'X25519' ||
-        key.algorithm.name === 'X448');
-}

package/node_modules/jose/dist/browser/runtime/encrypt.js

@@ -1,76 +0,0 @@
-import { concat, uint64be } from '../lib/buffer_utils.js';
-import checkIvLength from '../lib/check_iv_length.js';
-import checkCekLength from './check_cek_length.js';
-import crypto, { isCryptoKey } from './webcrypto.js';
-import { checkEncCryptoKey } from '../lib/crypto_key.js';
-import invalidKeyInput from '../lib/invalid_key_input.js';
-import generateIv from '../lib/iv.js';
-import { JOSENotSupported } from '../util/errors.js';
-import { types } from './is_key_like.js';
-async function cbcEncrypt(enc, plaintext, cek, iv, aad) {
-    if (!(cek instanceof Uint8Array)) {
-        throw new TypeError(invalidKeyInput(cek, 'Uint8Array'));
-    }
-    const keySize = parseInt(enc.slice(1, 4), 10);
-    const encKey = await crypto.subtle.importKey('raw', cek.subarray(keySize >> 3), 'AES-CBC', false, ['encrypt']);
-    const macKey = await crypto.subtle.importKey('raw', cek.subarray(0, keySize >> 3), {
-        hash: `SHA-${keySize << 1}`,
-        name: 'HMAC',
-    }, false, ['sign']);
-    const ciphertext = new Uint8Array(await crypto.subtle.encrypt({
-        iv,
-        name: 'AES-CBC',
-    }, encKey, plaintext));
-    const macData = concat(aad, iv, ciphertext, uint64be(aad.length << 3));
-    const tag = new Uint8Array((await crypto.subtle.sign('HMAC', macKey, macData)).slice(0, keySize >> 3));
-    return { ciphertext, tag, iv };
-}
-async function gcmEncrypt(enc, plaintext, cek, iv, aad) {
-    let encKey;
-    if (cek instanceof Uint8Array) {
-        encKey = await crypto.subtle.importKey('raw', cek, 'AES-GCM', false, ['encrypt']);
-    }
-    else {
-        checkEncCryptoKey(cek, enc, 'encrypt');
-        encKey = cek;
-    }
-    const encrypted = new Uint8Array(await crypto.subtle.encrypt({
-        additionalData: aad,
-        iv,
-        name: 'AES-GCM',
-        tagLength: 128,
-    }, encKey, plaintext));
-    const tag = encrypted.slice(-16);
-    const ciphertext = encrypted.slice(0, -16);
-    return { ciphertext, tag, iv };
-}
-const encrypt = async (enc, plaintext, cek, iv, aad) => {
-    if (!isCryptoKey(cek) && !(cek instanceof Uint8Array)) {
-        throw new TypeError(invalidKeyInput(cek, ...types, 'Uint8Array'));
-    }
-    if (iv) {
-        checkIvLength(enc, iv);
-    }
-    else {
-        iv = generateIv(enc);
-    }
-    switch (enc) {
-        case 'A128CBC-HS256':
-        case 'A192CBC-HS384':
-        case 'A256CBC-HS512':
-            if (cek instanceof Uint8Array) {
-                checkCekLength(cek, parseInt(enc.slice(-3), 10));
-            }
-            return cbcEncrypt(enc, plaintext, cek, iv, aad);
-        case 'A128GCM':
-        case 'A192GCM':
-        case 'A256GCM':
-            if (cek instanceof Uint8Array) {
-                checkCekLength(cek, parseInt(enc.slice(1, 4), 10));
-            }
-            return gcmEncrypt(enc, plaintext, cek, iv, aad);
-        default:
-            throw new JOSENotSupported('Unsupported JWE Content Encryption Algorithm');
-    }
-};
-export default encrypt;

package/node_modules/jose/dist/browser/runtime/fetch_jwks.js

@@ -1,34 +0,0 @@
-import { JOSEError, JWKSTimeout } from '../util/errors.js';
-const fetchJwks = async (url, timeout, options) => {
-    let controller;
-    let id;
-    let timedOut = false;
-    if (typeof AbortController === 'function') {
-        controller = new AbortController();
-        id = setTimeout(() => {
-            timedOut = true;
-            controller.abort();
-        }, timeout);
-    }
-    const response = await fetch(url.href, {
-        signal: controller ? controller.signal : undefined,
-        redirect: 'manual',
-        headers: options.headers,
-    }).catch((err) => {
-        if (timedOut)
-            throw new JWKSTimeout();
-        throw err;
-    });
-    if (id !== undefined)
-        clearTimeout(id);
-    if (response.status !== 200) {
-        throw new JOSEError('Expected 200 OK from the JSON Web Key Set HTTP response');
-    }
-    try {
-        return await response.json();
-    }
-    catch {
-        throw new JOSEError('Failed to parse the JSON Web Key Set HTTP response as JSON');
-    }
-};
-export default fetchJwks;

package/node_modules/jose/dist/browser/runtime/generate.js

@@ -1,143 +0,0 @@
-import crypto from './webcrypto.js';
-import { JOSENotSupported } from '../util/errors.js';
-import random from './random.js';
-export async function generateSecret(alg, options) {
-    let length;
-    let algorithm;
-    let keyUsages;
-    switch (alg) {
-        case 'HS256':
-        case 'HS384':
-        case 'HS512':
-            length = parseInt(alg.slice(-3), 10);
-            algorithm = { name: 'HMAC', hash: `SHA-${length}`, length };
-            keyUsages = ['sign', 'verify'];
-            break;
-        case 'A128CBC-HS256':
-        case 'A192CBC-HS384':
-        case 'A256CBC-HS512':
-            length = parseInt(alg.slice(-3), 10);
-            return random(new Uint8Array(length >> 3));
-        case 'A128KW':
-        case 'A192KW':
-        case 'A256KW':
-            length = parseInt(alg.slice(1, 4), 10);
-            algorithm = { name: 'AES-KW', length };
-            keyUsages = ['wrapKey', 'unwrapKey'];
-            break;
-        case 'A128GCMKW':
-        case 'A192GCMKW':
-        case 'A256GCMKW':
-        case 'A128GCM':
-        case 'A192GCM':
-        case 'A256GCM':
-            length = parseInt(alg.slice(1, 4), 10);
-            algorithm = { name: 'AES-GCM', length };
-            keyUsages = ['encrypt', 'decrypt'];
-            break;
-        default:
-            throw new JOSENotSupported('Invalid or unsupported JWK "alg" (Algorithm) Parameter value');
-    }
-    return crypto.subtle.generateKey(algorithm, options?.extractable ?? false, keyUsages);
-}
-function getModulusLengthOption(options) {
-    const modulusLength = options?.modulusLength ?? 2048;
-    if (typeof modulusLength !== 'number' || modulusLength < 2048) {
-        throw new JOSENotSupported('Invalid or unsupported modulusLength option provided, 2048 bits or larger keys must be used');
-    }
-    return modulusLength;
-}
-export async function generateKeyPair(alg, options) {
-    let algorithm;
-    let keyUsages;
-    switch (alg) {
-        case 'PS256':
-        case 'PS384':
-        case 'PS512':
-            algorithm = {
-                name: 'RSA-PSS',
-                hash: `SHA-${alg.slice(-3)}`,
-                publicExponent: new Uint8Array([0x01, 0x00, 0x01]),
-                modulusLength: getModulusLengthOption(options),
-            };
-            keyUsages = ['sign', 'verify'];
-            break;
-        case 'RS256':
-        case 'RS384':
-        case 'RS512':
-            algorithm = {
-                name: 'RSASSA-PKCS1-v1_5',
-                hash: `SHA-${alg.slice(-3)}`,
-                publicExponent: new Uint8Array([0x01, 0x00, 0x01]),
-                modulusLength: getModulusLengthOption(options),
-            };
-            keyUsages = ['sign', 'verify'];
-            break;
-        case 'RSA-OAEP':
-        case 'RSA-OAEP-256':
-        case 'RSA-OAEP-384':
-        case 'RSA-OAEP-512':
-            algorithm = {
-                name: 'RSA-OAEP',
-                hash: `SHA-${parseInt(alg.slice(-3), 10) || 1}`,
-                publicExponent: new Uint8Array([0x01, 0x00, 0x01]),
-                modulusLength: getModulusLengthOption(options),
-            };
-            keyUsages = ['decrypt', 'unwrapKey', 'encrypt', 'wrapKey'];
-            break;
-        case 'ES256':
-            algorithm = { name: 'ECDSA', namedCurve: 'P-256' };
-            keyUsages = ['sign', 'verify'];
-            break;
-        case 'ES384':
-            algorithm = { name: 'ECDSA', namedCurve: 'P-384' };
-            keyUsages = ['sign', 'verify'];
-            break;
-        case 'ES512':
-            algorithm = { name: 'ECDSA', namedCurve: 'P-521' };
-            keyUsages = ['sign', 'verify'];
-            break;
-        case 'Ed25519':
-            algorithm = { name: 'Ed25519' };
-            keyUsages = ['sign', 'verify'];
-            break;
-        case 'EdDSA': {
-            keyUsages = ['sign', 'verify'];
-            const crv = options?.crv ?? 'Ed25519';
-            switch (crv) {
-                case 'Ed25519':
-                case 'Ed448':
-                    algorithm = { name: crv };
-                    break;
-                default:
-                    throw new JOSENotSupported('Invalid or unsupported crv option provided');
-            }
-            break;
-        }
-        case 'ECDH-ES':
-        case 'ECDH-ES+A128KW':
-        case 'ECDH-ES+A192KW':
-        case 'ECDH-ES+A256KW': {
-            keyUsages = ['deriveKey', 'deriveBits'];
-            const crv = options?.crv ?? 'P-256';
-            switch (crv) {
-                case 'P-256':
-                case 'P-384':
-                case 'P-521': {
-                    algorithm = { name: 'ECDH', namedCurve: crv };
-                    break;
-                }
-                case 'X25519':
-                case 'X448':
-                    algorithm = { name: crv };
-                    break;
-                default:
-                    throw new JOSENotSupported('Invalid or unsupported crv option provided, supported values are P-256, P-384, P-521, X25519, and X448');
-            }
-            break;
-        }
-        default:
-            throw new JOSENotSupported('Invalid or unsupported JWK "alg" (Algorithm) Parameter value');
-    }
-    return crypto.subtle.generateKey(algorithm, options?.extractable ?? false, keyUsages);
-}