nuxt-ignis 0.5.1 → 0.5.2

package/.output/server/node_modules/ipx/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ipx",
-  "version": "2.1.1",
+  "version": "3.1.1",
   "repository": "unjs/ipx",
   "description": "High performance, secure and easy-to-use image optimizer.",
   "license": "MIT",
@@ -28,45 +28,44 @@
     "build": "unbuild",
     "dev": "listhen -w playground",
     "ipx": "jiti ./src/cli.ts",
-    "lint": "eslint --ext .ts . && prettier -c src test",
-    "lint:fix": "eslint --ext .ts . --fix && prettier -w src test",
+    "lint": "eslint . && prettier -c src test",
+    "lint:fix": "eslint . --fix && prettier -w src test",
     "prepack": "pnpm build",
     "release": "pnpm test && changelogen --release --push && npm publish",
-    "prerelease": "pnpm test && pnpm build && changelogen --release --prerelease --push --publish --publishTag next-2",
     "start": "node bin/ipx.js",
     "test": "pnpm lint && vitest run --coverage"
   },
   "dependencies": {
-    "@fastify/accept-negotiator": "^1.1.0",
-    "citty": "^0.1.5",
-    "consola": "^3.2.3",
+    "@fastify/accept-negotiator": "^2.0.1",
+    "citty": "^0.1.6",
+    "consola": "^3.4.2",
     "defu": "^6.1.4",
-    "destr": "^2.0.2",
+    "destr": "^2.0.5",
     "etag": "^1.8.1",
-    "h3": "^1.10.0",
-    "image-meta": "^0.2.0",
-    "listhen": "^1.5.6",
-    "ofetch": "^1.3.3",
-    "pathe": "^1.1.2",
-    "sharp": "^0.32.6",
-    "svgo": "^3.2.0",
-    "ufo": "^1.3.2",
-    "unstorage": "^1.10.1",
-    "xss": "^1.0.14"
+    "h3": "^1.15.3",
+    "image-meta": "^0.2.1",
+    "listhen": "^1.9.0",
+    "ofetch": "^1.4.1",
+    "pathe": "^2.0.3",
+    "sharp": "^0.34.3",
+    "svgo": "^4.0.0",
+    "ufo": "^1.6.1",
+    "unstorage": "^1.16.1",
+    "xss": "^1.0.15"
   },
   "devDependencies": {
-    "@types/etag": "^1.8.3",
+    "@types/etag": "^1.8.4",
     "@types/is-valid-path": "^0.1.2",
-    "@vitest/coverage-v8": "^1.1.3",
-    "changelogen": "^0.5.5",
-    "eslint": "^8.56.0",
-    "eslint-config-unjs": "^0.2.1",
-    "jiti": "^1.21.0",
-    "prettier": "^3.1.1",
-    "serve-handler": "^6.1.5",
-    "typescript": "^5.3.3",
-    "unbuild": "^2.0.0",
-    "vitest": "^1.1.3"
+    "@vitest/coverage-v8": "^3.2.4",
+    "changelogen": "^0.6.2",
+    "eslint": "^9.31.0",
+    "eslint-config-unjs": "^0.5.0",
+    "jiti": "^2.4.2",
+    "prettier": "^3.6.2",
+    "serve-handler": "^6.1.6",
+    "typescript": "^5.8.3",
+    "unbuild": "^3.5.0",
+    "vitest": "^3.2.4"
   },
-  "packageManager": "pnpm@8.10.5"
+  "packageManager": "pnpm@10.13.1"
 }

package/.output/server/node_modules/jose/dist/webapi/jwe/flattened/decrypt.js

@@ -1,15 +1,15 @@
 import { decode as b64u } from '../../util/base64url.js';
-import decrypt from '../../lib/decrypt.js';
+import { decrypt } from '../../lib/decrypt.js';
 import { JOSEAlgNotAllowed, JOSENotSupported, JWEInvalid } from '../../util/errors.js';
-import isDisjoint from '../../lib/is_disjoint.js';
-import isObject from '../../lib/is_object.js';
-import decryptKeyManagement from '../../lib/decrypt_key_management.js';
-import { encoder, decoder, concat } from '../../lib/buffer_utils.js';
-import generateCek from '../../lib/cek.js';
-import validateCrit from '../../lib/validate_crit.js';
-import validateAlgorithms from '../../lib/validate_algorithms.js';
-import normalizeKey from '../../lib/normalize_key.js';
-import checkKeyType from '../../lib/check_key_type.js';
+import { isDisjoint } from '../../lib/is_disjoint.js';
+import { isObject } from '../../lib/is_object.js';
+import { decryptKeyManagement } from '../../lib/decrypt_key_management.js';
+import { decoder, concat, encode } from '../../lib/buffer_utils.js';
+import { generateCek } from '../../lib/cek.js';
+import { validateCrit } from '../../lib/validate_crit.js';
+import { validateAlgorithms } from '../../lib/validate_algorithms.js';
+import { normalizeKey } from '../../lib/normalize_key.js';
+import { checkKeyType } from '../../lib/check_key_type.js';
 export async function flattenedDecrypt(jwe, key, options) {
     if (!isObject(jwe)) {
         throw new JWEInvalid('Flattened JWE must be an object');
@@ -124,10 +124,10 @@ export async function flattenedDecrypt(jwe, key, options) {
             throw new JWEInvalid('Failed to base64url decode the tag');
         }
     }
-    const protectedHeader = encoder.encode(jwe.protected ?? '');
+    const protectedHeader = jwe.protected !== undefined ? encode(jwe.protected) : new Uint8Array();
     let additionalData;
     if (jwe.aad !== undefined) {
-        additionalData = concat(protectedHeader, encoder.encode('.'), encoder.encode(jwe.aad));
+        additionalData = concat(protectedHeader, encode('.'), encode(jwe.aad));
     }
     else {
         additionalData = protectedHeader;

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

@@ -1,13 +1,13 @@
 import { encode as b64u } from '../../util/base64url.js';
 import { unprotected } from '../../lib/private_symbols.js';
-import encrypt from '../../lib/encrypt.js';
-import encryptKeyManagement from '../../lib/encrypt_key_management.js';
+import { encrypt } from '../../lib/encrypt.js';
+import { encryptKeyManagement } from '../../lib/encrypt_key_management.js';
 import { JOSENotSupported, JWEInvalid } from '../../util/errors.js';
-import isDisjoint from '../../lib/is_disjoint.js';
-import { encoder, decoder, concat } 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 { isDisjoint } from '../../lib/is_disjoint.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';
 export class FlattenedEncrypt {
     #plaintext;
     #protectedHeader;
@@ -120,20 +120,24 @@ export class FlattenedEncrypt {
             }
         }
         let additionalData;
-        let protectedHeader;
+        let protectedHeaderS;
+        let protectedHeaderB;
         let aadMember;
         if (this.#protectedHeader) {
-            protectedHeader = encoder.encode(b64u(JSON.stringify(this.#protectedHeader)));
+            protectedHeaderS = b64u(JSON.stringify(this.#protectedHeader));
+            protectedHeaderB = encode(protectedHeaderS);
         }
         else {
-            protectedHeader = encoder.encode('');
+            protectedHeaderS = '';
+            protectedHeaderB = new Uint8Array();
         }
         if (this.#aad) {
             aadMember = b64u(this.#aad);
-            additionalData = concat(protectedHeader, encoder.encode('.'), encoder.encode(aadMember));
+            const aadMemberBytes = encode(aadMember);
+            additionalData = concat(protectedHeaderB, encode('.'), aadMemberBytes);
         }
         else {
-            additionalData = protectedHeader;
+            additionalData = protectedHeaderB;
         }
         const { ciphertext, tag, iv } = await encrypt(enc, this.#plaintext, cek, this.#iv, additionalData);
         const jwe = {
@@ -152,7 +156,7 @@ export class FlattenedEncrypt {
             jwe.aad = aadMember;
         }
         if (this.#protectedHeader) {
-            jwe.protected = decoder.decode(protectedHeader);
+            jwe.protected = protectedHeaderS;
         }
         if (this.#sharedUnprotectedHeader) {
             jwe.unprotected = this.#sharedUnprotectedHeader;

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

@@ -1,6 +1,6 @@
 import { flattenedDecrypt } from '../flattened/decrypt.js';
 import { JWEDecryptionFailed, JWEInvalid } from '../../util/errors.js';
-import isObject from '../../lib/is_object.js';
+import { isObject } from '../../lib/is_object.js';
 export async function generalDecrypt(jwe, key, options) {
     if (!isObject(jwe)) {
         throw new JWEInvalid('General JWE must be an object');

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

@@ -1,16 +1,17 @@
 import { FlattenedEncrypt } from '../flattened/encrypt.js';
 import { unprotected } from '../../lib/private_symbols.js';
 import { JOSENotSupported, JWEInvalid } from '../../util/errors.js';
-import generateCek from '../../lib/cek.js';
-import isDisjoint from '../../lib/is_disjoint.js';
-import encryptKeyManagement from '../../lib/encrypt_key_management.js';
+import { generateCek } from '../../lib/cek.js';
+import { isDisjoint } from '../../lib/is_disjoint.js';
+import { encryptKeyManagement } from '../../lib/encrypt_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 { validateCrit } from '../../lib/validate_crit.js';
+import { normalizeKey } from '../../lib/normalize_key.js';
+import { checkKeyType } from '../../lib/check_key_type.js';
 class IndividualRecipient {
     #parent;
     unprotectedHeader;
+    keyManagementParameters;
     key;
     options;
     constructor(enc, key, options) {
@@ -25,6 +26,13 @@ class IndividualRecipient {
         this.unprotectedHeader = unprotectedHeader;
         return this;
     }
+    setKeyManagementParameters(parameters) {
+        if (this.keyManagementParameters) {
+            throw new TypeError('setKeyManagementParameters can only be called once');
+        }
+        this.keyManagementParameters = parameters;
+        return this;
+    }
     addRecipient(...args) {
         return this.#parent.addRecipient(...args);
     }
@@ -132,20 +140,12 @@ export class GeneralEncrypt {
         const cek = generateCek(enc);
         const jwe = {
             ciphertext: '',
-            iv: '',
             recipients: [],
-            tag: '',
         };
         for (let i = 0; i < this.#recipients.length; i++) {
             const recipient = this.#recipients[i];
             const target = {};
             jwe.recipients.push(target);
-            const joseHeader = {
-                ...this.#protectedHeader,
-                ...this.#unprotectedHeader,
-                ...recipient.unprotectedHeader,
-            };
-            const p2c = joseHeader.alg.startsWith('PBES2') ? 2048 + i : undefined;
             if (i === 0) {
                 const flattened = await new FlattenedEncrypt(this.#plaintext)
                     .setAdditionalAuthenticatedData(this.#aad)
@@ -153,7 +153,7 @@ export class GeneralEncrypt {
                     .setProtectedHeader(this.#protectedHeader)
                     .setSharedUnprotectedHeader(this.#unprotectedHeader)
                     .setUnprotectedHeader(recipient.unprotectedHeader)
-                    .setKeyManagementParameters({ p2c })
+                    .setKeyManagementParameters(recipient.keyManagementParameters)
                     .encrypt(recipient.key, {
                     ...recipient.options,
                     [unprotected]: true,
@@ -177,7 +177,7 @@ export class GeneralEncrypt {
                 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, { p2c });
+            const { encryptedKey, parameters } = await encryptKeyManagement(alg, enc, k, cek, recipient.keyManagementParameters);
             target.encrypted_key = b64u(encryptedKey);
             if (recipient.unprotectedHeader || parameters)
                 target.header = { ...recipient.unprotectedHeader, ...parameters };

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

@@ -1,5 +1,5 @@
 import { importJWK } from '../key/import.js';
-import isObject from '../lib/is_object.js';
+import { isObject } from '../lib/is_object.js';
 import { JWSInvalid } from '../util/errors.js';
 export async function EmbeddedJWK(protectedHeader, token) {
     const joseHeader = {

package/.output/server/node_modules/jose/dist/webapi/jwk/thumbprint.js

@@ -1,11 +1,11 @@
-import digest from '../lib/digest.js';
+import { digest } from '../lib/digest.js';
 import { encode as b64u } from '../util/base64url.js';
 import { JOSENotSupported, JWKInvalid } from '../util/errors.js';
-import { encoder } from '../lib/buffer_utils.js';
-import isKeyLike from '../lib/is_key_like.js';
+import { encode } from '../lib/buffer_utils.js';
+import { isKeyLike } from '../lib/is_key_like.js';
 import { isJWK } from '../lib/is_jwk.js';
 import { exportJWK } from '../key/export.js';
-import invalidKeyInput from '../lib/invalid_key_input.js';
+import { invalidKeyInput } from '../lib/invalid_key_input.js';
 const check = (value, description) => {
     if (typeof value !== 'string' || !value) {
         throw new JWKInvalid(`${description} missing or invalid`);
@@ -58,7 +58,7 @@ export async function calculateJwkThumbprint(key, digestAlgorithm) {
         default:
             throw new JOSENotSupported('"kty" (Key Type) Parameter missing or unsupported');
     }
-    const data = encoder.encode(JSON.stringify(components));
+    const data = encode(JSON.stringify(components));
     return b64u(await digest(digestAlgorithm, data));
 }
 export async function calculateJwkThumbprintUri(key, digestAlgorithm) {

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

@@ -1,6 +1,6 @@
 import { importJWK } from '../key/import.js';
 import { JWKSInvalid, JOSENotSupported, JWKSNoMatchingKey, JWKSMultipleMatchingKeys, } from '../util/errors.js';
-import isObject from '../lib/is_object.js';
+import { isObject } from '../lib/is_object.js';
 function getKtyFromAlg(alg) {
     switch (typeof alg === 'string' && alg.slice(0, 2)) {
         case 'RS':

package/.output/server/node_modules/jose/dist/webapi/jwks/remote.js

@@ -1,6 +1,6 @@
 import { JOSEError, JWKSNoMatchingKey, JWKSTimeout } from '../util/errors.js';
 import { createLocalJWKSet } from './local.js';
-import isObject from '../lib/is_object.js';
+import { isObject } from '../lib/is_object.js';
 function isCloudflareWorkers() {
     return (typeof WebSocketPair !== 'undefined' ||
         (typeof navigator !== 'undefined' && navigator.userAgent === 'Cloudflare-Workers') ||
@@ -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.1.0';
+    const VERSION = 'v6.1.2';
     USER_AGENT = `${NAME}/${VERSION}`;
 }
 export const customFetch = Symbol();

package/.output/server/node_modules/jose/dist/webapi/jws/flattened/sign.js

@@ -1,11 +1,11 @@
 import { encode as b64u } from '../../util/base64url.js';
-import sign from '../../lib/sign.js';
-import isDisjoint from '../../lib/is_disjoint.js';
+import { sign } from '../../lib/sign.js';
+import { isDisjoint } from '../../lib/is_disjoint.js';
 import { JWSInvalid } from '../../util/errors.js';
-import { encoder, decoder, concat } 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 { 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';
 export class FlattenedSign {
     #payload;
     #protectedHeader;
@@ -54,32 +54,38 @@ export class FlattenedSign {
             throw new JWSInvalid('JWS "alg" (Algorithm) Header Parameter missing or invalid');
         }
         checkKeyType(alg, key, 'sign');
-        let payload = this.#payload;
+        let payloadS;
+        let payloadB;
         if (b64) {
-            payload = encoder.encode(b64u(payload));
+            payloadS = b64u(this.#payload);
+            payloadB = encode(payloadS);
         }
-        let protectedHeader;
+        else {
+            payloadB = this.#payload;
+            payloadS = '';
+        }
+        let protectedHeaderString;
+        let protectedHeaderBytes;
         if (this.#protectedHeader) {
-            protectedHeader = encoder.encode(b64u(JSON.stringify(this.#protectedHeader)));
+            protectedHeaderString = b64u(JSON.stringify(this.#protectedHeader));
+            protectedHeaderBytes = encode(protectedHeaderString);
         }
         else {
-            protectedHeader = encoder.encode('');
+            protectedHeaderString = '';
+            protectedHeaderBytes = new Uint8Array();
         }
-        const data = concat(protectedHeader, encoder.encode('.'), payload);
+        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: '',
+            payload: payloadS,
         };
-        if (b64) {
-            jws.payload = decoder.decode(payload);
-        }
         if (this.#unprotectedHeader) {
             jws.header = this.#unprotectedHeader;
         }
         if (this.#protectedHeader) {
-            jws.protected = decoder.decode(protectedHeader);
+            jws.protected = protectedHeaderString;
         }
         return jws;
     }

package/.output/server/node_modules/jose/dist/webapi/jws/flattened/verify.js

@@ -1,13 +1,13 @@
 import { decode as b64u } from '../../util/base64url.js';
-import verify from '../../lib/verify.js';
+import { verify } from '../../lib/verify.js';
 import { JOSEAlgNotAllowed, JWSInvalid, JWSSignatureVerificationFailed } from '../../util/errors.js';
-import { concat, encoder, decoder } from '../../lib/buffer_utils.js';
-import isDisjoint from '../../lib/is_disjoint.js';
-import isObject from '../../lib/is_object.js';
-import checkKeyType from '../../lib/check_key_type.js';
-import validateCrit from '../../lib/validate_crit.js';
-import validateAlgorithms from '../../lib/validate_algorithms.js';
-import normalizeKey from '../../lib/normalize_key.js';
+import { concat, encoder, decoder, encode } from '../../lib/buffer_utils.js';
+import { isDisjoint } from '../../lib/is_disjoint.js';
+import { isObject } from '../../lib/is_object.js';
+import { checkKeyType } from '../../lib/check_key_type.js';
+import { validateCrit } from '../../lib/validate_crit.js';
+import { validateAlgorithms } from '../../lib/validate_algorithms.js';
+import { normalizeKey } from '../../lib/normalize_key.js';
 export async function flattenedVerify(jws, key, options) {
     if (!isObject(jws)) {
         throw new JWSInvalid('Flattened JWS must be an object');
@@ -74,7 +74,11 @@ export async function flattenedVerify(jws, key, options) {
         resolvedKey = true;
     }
     checkKeyType(alg, key, 'verify');
-    const data = concat(encoder.encode(jws.protected ?? ''), encoder.encode('.'), typeof jws.payload === 'string' ? encoder.encode(jws.payload) : jws.payload);
+    const data = concat(jws.protected !== undefined ? encode(jws.protected) : new Uint8Array(), encode('.'), typeof jws.payload === 'string'
+        ? b64
+            ? encode(jws.payload)
+            : encoder.encode(jws.payload)
+        : jws.payload);
     let signature;
     try {
         signature = b64u(jws.signature);

package/.output/server/node_modules/jose/dist/webapi/jws/general/verify.js

@@ -1,6 +1,6 @@
 import { flattenedVerify } from '../flattened/verify.js';
 import { JWSInvalid, JWSSignatureVerificationFailed } from '../../util/errors.js';
-import isObject from '../../lib/is_object.js';
+import { isObject } from '../../lib/is_object.js';
 export async function generalVerify(jws, key, options) {
     if (!isObject(jws)) {
         throw new JWSInvalid('General JWS must be an object');

package/.output/server/node_modules/jose/dist/webapi/key/export.js

@@ -1,5 +1,5 @@
 import { toSPKI as exportPublic, toPKCS8 as exportPrivate } from '../lib/asn1.js';
-import keyToJWK from '../lib/key_to_jwk.js';
+import { keyToJWK } from '../lib/key_to_jwk.js';
 export async function exportSPKI(key) {
     return exportPublic(key);
 }

package/.output/server/node_modules/jose/dist/webapi/key/generate_key_pair.js

@@ -16,7 +16,7 @@ export async function generateKeyPair(alg, options) {
             algorithm = {
                 name: 'RSA-PSS',
                 hash: `SHA-${alg.slice(-3)}`,
-                publicExponent: new Uint8Array([0x01, 0x00, 0x01]),
+                publicExponent: Uint8Array.of(0x01, 0x00, 0x01),
                 modulusLength: getModulusLengthOption(options),
             };
             keyUsages = ['sign', 'verify'];
@@ -27,7 +27,7 @@ export async function generateKeyPair(alg, options) {
             algorithm = {
                 name: 'RSASSA-PKCS1-v1_5',
                 hash: `SHA-${alg.slice(-3)}`,
-                publicExponent: new Uint8Array([0x01, 0x00, 0x01]),
+                publicExponent: Uint8Array.of(0x01, 0x00, 0x01),
                 modulusLength: getModulusLengthOption(options),
             };
             keyUsages = ['sign', 'verify'];
@@ -39,7 +39,7 @@ export async function generateKeyPair(alg, options) {
             algorithm = {
                 name: 'RSA-OAEP',
                 hash: `SHA-${parseInt(alg.slice(-3), 10) || 1}`,
-                publicExponent: new Uint8Array([0x01, 0x00, 0x01]),
+                publicExponent: Uint8Array.of(0x01, 0x00, 0x01),
                 modulusLength: getModulusLengthOption(options),
             };
             keyUsages = ['decrypt', 'unwrapKey', 'encrypt', 'wrapKey'];

package/.output/server/node_modules/jose/dist/webapi/key/import.js

@@ -1,8 +1,8 @@
 import { decode as decodeBase64URL } from '../util/base64url.js';
 import { fromSPKI, fromPKCS8, fromX509 } from '../lib/asn1.js';
-import toCryptoKey from '../lib/jwk_to_key.js';
+import { jwkToKey } from '../lib/jwk_to_key.js';
 import { JOSENotSupported } from '../util/errors.js';
-import isObject from '../lib/is_object.js';
+import { isObject } from '../lib/is_object.js';
 export async function importSPKI(spki, alg, options) {
     if (typeof spki !== 'string' || spki.indexOf('-----BEGIN PUBLIC KEY-----') !== 0) {
         throw new TypeError('"spki" must be SPKI formatted string');
@@ -38,7 +38,7 @@ export async function importJWK(jwk, alg, options) {
             if ('oth' in jwk && jwk.oth !== undefined) {
                 throw new JOSENotSupported('RSA JWK "oth" (Other Primes Info) Parameter value is not supported');
             }
-            return toCryptoKey({ ...jwk, alg, ext });
+            return jwkToKey({ ...jwk, alg, ext });
         case 'AKP': {
             if (typeof jwk.alg !== 'string' || !jwk.alg) {
                 throw new TypeError('missing "alg" (Algorithm) Parameter value');
@@ -46,11 +46,11 @@ export async function importJWK(jwk, alg, options) {
             if (alg !== undefined && alg !== jwk.alg) {
                 throw new TypeError('JWK alg and alg option value mismatch');
             }
-            return toCryptoKey({ ...jwk, ext });
+            return jwkToKey({ ...jwk, ext });
         }
         case 'EC':
         case 'OKP':
-            return toCryptoKey({ ...jwk, alg, ext });
+            return jwkToKey({ ...jwk, alg, ext });
         default:
             throw new JOSENotSupported('Unsupported "kty" (Key Type) Parameter value');
     }

package/.output/server/node_modules/jose/dist/webapi/lib/aesgcmkw.js

@@ -1,9 +1,9 @@
-import encrypt from './encrypt.js';
-import decrypt from './decrypt.js';
+import { encrypt } from './encrypt.js';
+import { decrypt } from './decrypt.js';
 import { encode as b64u } from '../util/base64url.js';
 export async function wrap(alg, key, cek, iv) {
     const jweAlgorithm = alg.slice(0, 7);
-    const wrapped = await encrypt(jweAlgorithm, cek, key, iv, new Uint8Array(0));
+    const wrapped = await encrypt(jweAlgorithm, cek, key, iv, new Uint8Array());
     return {
         encryptedKey: wrapped.ciphertext,
         iv: b64u(wrapped.iv),
@@ -12,5 +12,5 @@ export async function wrap(alg, key, cek, iv) {
 }
 export async function unwrap(alg, key, encryptedKey, iv, tag) {
     const jweAlgorithm = alg.slice(0, 7);
-    return decrypt(jweAlgorithm, key, encryptedKey, iv, tag, new Uint8Array(0));
+    return decrypt(jweAlgorithm, key, encryptedKey, iv, tag, new Uint8Array());
 }

package/.output/server/node_modules/jose/dist/webapi/lib/asn1.js

@@ -1,4 +1,4 @@
-import invalidKeyInput from './invalid_key_input.js';
+import { invalidKeyInput } from './invalid_key_input.js';
 import { encodeBase64, decodeBase64 } from '../lib/base64.js';
 import { JOSENotSupported } from '../util/errors.js';
 import { isCryptoKey, isKeyObject } from './is_key_like.js';
@@ -24,12 +24,8 @@ const genericExport = async (keyType, keyFormat, 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);
-};
+export const toSPKI = (key) => genericExport('public', 'spki', key);
+export const toPKCS8 = (key) => genericExport('private', 'pkcs8', key);
 const bytesEqual = (a, b) => {
     if (a.byteLength !== b.length)
         return false;

package/.output/server/node_modules/jose/dist/webapi/lib/buffer_utils.js

@@ -30,3 +30,14 @@ export function uint32be(value) {
     writeUInt32BE(buf, value);
     return buf;
 }
+export function encode(string) {
+    const bytes = new Uint8Array(string.length);
+    for (let i = 0; i < string.length; i++) {
+        const code = string.charCodeAt(i);
+        if (code > 127) {
+            throw new TypeError('non-ASCII string encountered in encode()');
+        }
+        bytes[i] = code;
+    }
+    return bytes;
+}

package/.output/server/node_modules/jose/dist/webapi/lib/cek.js

@@ -1,5 +1,5 @@
 import { JOSENotSupported } from '../util/errors.js';
-export function bitLength(alg) {
+export function cekLength(alg) {
     switch (alg) {
         case 'A128GCM':
             return 128;
@@ -16,4 +16,4 @@ export function bitLength(alg) {
             throw new JOSENotSupported(`Unsupported JWE Algorithm: ${alg}`);
     }
 }
-export default (alg) => crypto.getRandomValues(new Uint8Array(bitLength(alg) >> 3));
+export const generateCek = (alg) => crypto.getRandomValues(new Uint8Array(cekLength(alg) >> 3));

package/.output/server/node_modules/jose/dist/webapi/lib/check_cek_length.js

@@ -1,7 +1,7 @@
 import { JWEInvalid } from '../util/errors.js';
-export default (cek, expected) => {
+export function 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`);
     }
-};
+}

package/.output/server/node_modules/jose/dist/webapi/lib/check_iv_length.js

@@ -1,7 +1,7 @@
 import { JWEInvalid } from '../util/errors.js';
 import { bitLength } from './iv.js';
-export default (enc, iv) => {
+export function checkIvLength(enc, iv) {
     if (iv.length << 3 !== bitLength(enc)) {
         throw new JWEInvalid('Invalid Initialization Vector length');
     }
-};
+}

package/.output/server/node_modules/jose/dist/webapi/lib/check_key_length.js

@@ -1,8 +1,8 @@
-export default (alg, key) => {
+export function checkKeyLength(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`);
         }
     }
-};
+}