jose 3.19.0 → 3.20.3

package/dist/node/esm/lib/decrypt_key_management.js

@@ -8,81 +8,81 @@ import { JOSENotSupported, JWEInvalid } from '../util/errors.js';
 import { bitLengths as cekLengths } from '../lib/cek.js';
 import { importJWK } from '../key/import.js';
 import checkKeyType from './check_key_type.js';
-function assertEnryptedKey(encryptedKey) {
-    if (!encryptedKey) {
-        throw new JWEInvalid('JWE Encrypted Key missing');
-    }
-}
-function assertHeaderParameter(joseHeader, parameter, name) {
-    if (joseHeader[parameter] === undefined) {
-        throw new JWEInvalid(`JOSE Header ${name} (${parameter}) missing`);
-    }
-}
+import isObject from './is_object.js';
 async function decryptKeyManagement(alg, key, encryptedKey, joseHeader) {
     checkKeyType(alg, key, 'decrypt');
     switch (alg) {
         case 'dir': {
-            if (encryptedKey !== undefined) {
+            if (encryptedKey !== undefined)
                 throw new JWEInvalid('Encountered unexpected JWE Encrypted Key');
-            }
             return key;
         }
         case 'ECDH-ES':
-            if (encryptedKey !== undefined) {
+            if (encryptedKey !== undefined)
                 throw new JWEInvalid('Encountered unexpected JWE Encrypted Key');
-            }
         case 'ECDH-ES+A128KW':
         case 'ECDH-ES+A192KW':
         case 'ECDH-ES+A256KW': {
-            assertHeaderParameter(joseHeader, 'epk', 'Ephemeral Public Key');
-            if (!ECDH.ecdhAllowed(key)) {
+            if (!isObject(joseHeader.epk))
+                throw new JWEInvalid(`JOSE Header "epk" (Ephemeral Public Key) missing or invalid`);
+            if (!ECDH.ecdhAllowed(key))
                 throw new JOSENotSupported('ECDH-ES with the provided key is not allowed or not supported by your javascript runtime');
-            }
             const epk = await importJWK(joseHeader.epk, alg);
             let partyUInfo;
             let partyVInfo;
-            if (joseHeader.apu !== undefined)
+            if (joseHeader.apu !== undefined) {
+                if (typeof joseHeader.apu !== 'string')
+                    throw new JWEInvalid(`JOSE Header "apu" (Agreement PartyUInfo) invalid`);
                 partyUInfo = base64url(joseHeader.apu);
-            if (joseHeader.apv !== undefined)
+            }
+            if (joseHeader.apv !== undefined) {
+                if (typeof joseHeader.apv !== 'string')
+                    throw new JWEInvalid(`JOSE Header "apv" (Agreement PartyVInfo) invalid`);
                 partyVInfo = base64url(joseHeader.apv);
+            }
             const sharedSecret = await ECDH.deriveKey(epk, key, alg === 'ECDH-ES' ? joseHeader.enc : alg, parseInt(alg.substr(-5, 3), 10) || cekLengths.get(joseHeader.enc), partyUInfo, partyVInfo);
-            if (alg === 'ECDH-ES') {
+            if (alg === 'ECDH-ES')
                 return sharedSecret;
-            }
-            assertEnryptedKey(encryptedKey);
-            const kwAlg = alg.substr(-6);
-            return aesKw(kwAlg, sharedSecret, encryptedKey);
+            if (encryptedKey === undefined)
+                throw new JWEInvalid('JWE Encrypted Key missing');
+            return aesKw(alg.substr(-6), sharedSecret, encryptedKey);
         }
         case 'RSA1_5':
         case 'RSA-OAEP':
         case 'RSA-OAEP-256':
         case 'RSA-OAEP-384':
         case 'RSA-OAEP-512': {
-            assertEnryptedKey(encryptedKey);
+            if (encryptedKey === undefined)
+                throw new JWEInvalid('JWE Encrypted Key missing');
             return rsaEs(alg, key, encryptedKey);
         }
         case 'PBES2-HS256+A128KW':
         case 'PBES2-HS384+A192KW':
         case 'PBES2-HS512+A256KW': {
-            assertEnryptedKey(encryptedKey);
-            assertHeaderParameter(joseHeader, 'p2c', 'PBES2 Count');
-            assertHeaderParameter(joseHeader, 'p2s', 'PBES2 Salt');
-            const { p2c } = joseHeader;
-            const p2s = base64url(joseHeader.p2s);
-            return pbes2Kw(alg, key, encryptedKey, p2c, p2s);
+            if (encryptedKey === undefined)
+                throw new JWEInvalid('JWE Encrypted Key missing');
+            if (typeof joseHeader.p2c !== 'number')
+                throw new JWEInvalid(`JOSE Header "p2c" (PBES2 Count) missing or invalid`);
+            if (typeof joseHeader.p2s !== 'string')
+                throw new JWEInvalid(`JOSE Header "p2s" (PBES2 Salt) missing or invalid`);
+            return pbes2Kw(alg, key, encryptedKey, joseHeader.p2c, base64url(joseHeader.p2s));
         }
         case 'A128KW':
         case 'A192KW':
         case 'A256KW': {
-            assertEnryptedKey(encryptedKey);
+            if (encryptedKey === undefined)
+                throw new JWEInvalid('JWE Encrypted Key missing');
             return aesKw(alg, key, encryptedKey);
         }
         case 'A128GCMKW':
         case 'A192GCMKW':
         case 'A256GCMKW': {
-            assertEnryptedKey(encryptedKey);
-            assertHeaderParameter(joseHeader, 'iv', 'Initialization Vector');
-            assertHeaderParameter(joseHeader, 'tag', 'Authentication Tag');
+            if (encryptedKey === undefined)
+                throw new JWEInvalid('JWE Encrypted Key missing');
+            if (typeof joseHeader.iv !== 'string')
+                throw new JWEInvalid(`JOSE Header "iv" (Initialization Vector) missing or invalid`);
+            if (typeof joseHeader.tag !== 'string')
+                throw new JWEInvalid(`JOSE Header "tag" (Authentication Tag) missing or invalid`);
             const iv = base64url(joseHeader.iv);
             const tag = base64url(joseHeader.tag);
             return aesGcmKw(alg, key, encryptedKey, iv, tag);

package/dist/node/esm/lib/encrypt_key_management.js

@@ -1,15 +1,13 @@
-import random from '../runtime/random.js';
 import { wrap as aesKw } from '../runtime/aeskw.js';
 import * as ECDH from '../runtime/ecdhes.js';
 import { encrypt as pbes2Kw } from '../runtime/pbes2kw.js';
 import { encrypt as rsaEs } from '../runtime/rsaes.js';
 import { wrap as aesGcmKw } from '../runtime/aesgcmkw.js';
 import { encode as base64url } from '../runtime/base64url.js';
-import cekFactory, { bitLengths as cekLengths } from '../lib/cek.js';
+import generateCek, { bitLengths as cekLengths } from '../lib/cek.js';
 import { JOSENotSupported } from '../util/errors.js';
-import { fromKeyLike } from '../jwk/from_key_like.js';
+import { exportJWK } from '../key/export.js';
 import checkKeyType from './check_key_type.js';
-const generateCek = cekFactory(random);
 async function encryptKeyManagement(alg, enc, key, providedCek, providedParameters = {}) {
     let encryptedKey;
     let parameters;
@@ -30,7 +28,7 @@ async function encryptKeyManagement(alg, enc, key, providedCek, providedParamete
             const { apu, apv } = providedParameters;
             let { epk: ephemeralKey } = providedParameters;
             ephemeralKey || (ephemeralKey = await ECDH.generateEpk(key));
-            const { x, y, crv, kty } = await fromKeyLike(ephemeralKey);
+            const { x, y, crv, kty } = await exportJWK(ephemeralKey);
             const sharedSecret = await ECDH.deriveKey(key, ephemeralKey, alg === 'ECDH-ES' ? enc : alg, parseInt(alg.substr(-5, 3), 10) || cekLengths.get(enc), apu, apv);
             parameters = { epk: { x, y, crv, kty } };
             if (apu)

package/dist/node/esm/lib/iv.js

@@ -1,4 +1,5 @@
 import { JOSENotSupported } from '../util/errors.js';
+import random from '../runtime/random.js';
 const bitLengths = new Map([
     ['A128CBC-HS256', 128],
     ['A128GCM', 96],
@@ -10,12 +11,12 @@ const bitLengths = new Map([
     ['A256GCM', 96],
     ['A256GCMKW', 96],
 ]);
-const factory = (random) => (alg) => {
+const generateIv = (alg) => {
     const bitLength = bitLengths.get(alg);
     if (!bitLength) {
         throw new JOSENotSupported(`Unsupported JWE Algorithm: ${alg}`);
     }
     return random(new Uint8Array(bitLength >> 3));
 };
-export default factory;
+export default generateIv;
 export { bitLengths };

package/dist/node/esm/runtime/aesgcmkw.js

@@ -1,9 +1,7 @@
 import encrypt from './encrypt.js';
 import decrypt from './decrypt.js';
-import ivFactory from '../lib/iv.js';
-import random from './random.js';
+import generateIv from '../lib/iv.js';
 import { encode as base64url } from './base64url.js';
-const generateIv = ivFactory(random);
 export const wrap = async (alg, key, cek, iv) => {
     const jweAlgorithm = alg.substr(0, 7);
     iv || (iv = generateIv(jweAlgorithm));

package/dist/node/esm/runtime/fetch_jwks.js

@@ -1,7 +1,7 @@
 import { get as http } from 'http';
 import { get as https } from 'https';
 import { once } from 'events';
-import { JOSEError } from '../util/errors.js';
+import { JOSEError, JWKSTimeout } from '../util/errors.js';
 import { concat, decoder } from '../lib/buffer_utils.js';
 const protocols = {
     'https:': https,
@@ -16,7 +16,11 @@ const fetchJwks = async (url, timeout, options) => {
         agent,
         timeout,
     });
-    const [response] = await once(req, 'response');
+    const [response] = (await Promise.race([once(req, 'response'), once(req, 'timeout')]));
+    if (!response) {
+        req.destroy();
+        throw new JWKSTimeout();
+    }
     if (response.statusCode !== 200) {
         throw new JOSEError('Expected 200 OK from the JSON Web Key Set HTTP response');
     }

package/dist/node/esm/runtime/is_key_like.js

@@ -0,0 +1,8 @@
+import { isCryptoKey } from './webcrypto.js';
+import isKeyObject from './is_key_object.js';
+export default (key) => isKeyObject(key) || isCryptoKey(key);
+const types = ['KeyObject'];
+if (parseInt(process.versions.node) >= 16) {
+    types.push('CryptoKey');
+}
+export { types };

package/dist/node/esm/runtime/random.js

@@ -1,2 +1 @@
-import { randomFillSync } from 'crypto';
-export default randomFillSync;
+export { randomFillSync as default } from 'crypto';

package/dist/node/esm/util/errors.js

@@ -1,108 +1,147 @@
 export class JOSEError extends Error {
     constructor(message) {
+        var _a;
         super(message);
-        this.code = JOSEError.code;
+        this.code = 'ERR_JOSE_GENERIC';
         this.name = this.constructor.name;
-        if (Error.captureStackTrace) {
-            Error.captureStackTrace(this, this.constructor);
-        }
+        (_a = Error.captureStackTrace) === null || _a === void 0 ? void 0 : _a.call(Error, this, this.constructor);
+    }
+    static get code() {
+        return 'ERR_JOSE_GENERIC';
     }
 }
-JOSEError.code = 'ERR_JOSE_GENERIC';
 export class JWTClaimValidationFailed extends JOSEError {
     constructor(message, claim = 'unspecified', reason = 'unspecified') {
         super(message);
-        this.code = JWTClaimValidationFailed.code;
+        this.code = 'ERR_JWT_CLAIM_VALIDATION_FAILED';
         this.claim = claim;
         this.reason = reason;
     }
+    static get code() {
+        return 'ERR_JWT_CLAIM_VALIDATION_FAILED';
+    }
+}
+export class JWTExpired extends JOSEError {
+    constructor(message, claim = 'unspecified', reason = 'unspecified') {
+        super(message);
+        this.code = 'ERR_JWT_EXPIRED';
+        this.claim = claim;
+        this.reason = reason;
+    }
+    static get code() {
+        return 'ERR_JWT_EXPIRED';
+    }
 }
-JWTClaimValidationFailed.code = 'ERR_JWT_CLAIM_VALIDATION_FAILED';
 export class JOSEAlgNotAllowed extends JOSEError {
     constructor() {
         super(...arguments);
-        this.code = JOSEAlgNotAllowed.code;
+        this.code = 'ERR_JOSE_ALG_NOT_ALLOWED';
+    }
+    static get code() {
+        return 'ERR_JOSE_ALG_NOT_ALLOWED';
     }
 }
-JOSEAlgNotAllowed.code = 'ERR_JOSE_ALG_NOT_ALLOWED';
 export class JOSENotSupported extends JOSEError {
     constructor() {
         super(...arguments);
-        this.code = JOSENotSupported.code;
+        this.code = 'ERR_JOSE_NOT_SUPPORTED';
+    }
+    static get code() {
+        return 'ERR_JOSE_NOT_SUPPORTED';
     }
 }
-JOSENotSupported.code = 'ERR_JOSE_NOT_SUPPORTED';
 export class JWEDecryptionFailed extends JOSEError {
     constructor() {
         super(...arguments);
-        this.code = JWEDecryptionFailed.code;
+        this.code = 'ERR_JWE_DECRYPTION_FAILED';
         this.message = 'decryption operation failed';
     }
+    static get code() {
+        return 'ERR_JWE_DECRYPTION_FAILED';
+    }
 }
-JWEDecryptionFailed.code = 'ERR_JWE_DECRYPTION_FAILED';
 export class JWEInvalid extends JOSEError {
     constructor() {
         super(...arguments);
-        this.code = JWEInvalid.code;
+        this.code = 'ERR_JWE_INVALID';
+    }
+    static get code() {
+        return 'ERR_JWE_INVALID';
     }
 }
-JWEInvalid.code = 'ERR_JWE_INVALID';
 export class JWSInvalid extends JOSEError {
     constructor() {
         super(...arguments);
-        this.code = JWSInvalid.code;
+        this.code = 'ERR_JWS_INVALID';
+    }
+    static get code() {
+        return 'ERR_JWS_INVALID';
     }
 }
-JWSInvalid.code = 'ERR_JWS_INVALID';
 export class JWTInvalid extends JOSEError {
     constructor() {
         super(...arguments);
-        this.code = JWTInvalid.code;
+        this.code = 'ERR_JWT_INVALID';
+    }
+    static get code() {
+        return 'ERR_JWT_INVALID';
     }
 }
-JWTInvalid.code = 'ERR_JWT_INVALID';
 export class JWKInvalid extends JOSEError {
     constructor() {
         super(...arguments);
-        this.code = JWKInvalid.code;
+        this.code = 'ERR_JWK_INVALID';
+    }
+    static get code() {
+        return 'ERR_JWK_INVALID';
     }
 }
-JWKInvalid.code = 'ERR_JWK_INVALID';
 export class JWKSInvalid extends JOSEError {
     constructor() {
         super(...arguments);
-        this.code = JWKSInvalid.code;
+        this.code = 'ERR_JWKS_INVALID';
+    }
+    static get code() {
+        return 'ERR_JWKS_INVALID';
     }
 }
-JWKSInvalid.code = 'ERR_JWKS_INVALID';
 export class JWKSNoMatchingKey extends JOSEError {
     constructor() {
         super(...arguments);
-        this.code = JWKSNoMatchingKey.code;
+        this.code = 'ERR_JWKS_NO_MATCHING_KEY';
         this.message = 'no applicable key found in the JSON Web Key Set';
     }
+    static get code() {
+        return 'ERR_JWKS_NO_MATCHING_KEY';
+    }
 }
-JWKSNoMatchingKey.code = 'ERR_JWKS_NO_MATCHING_KEY';
 export class JWKSMultipleMatchingKeys extends JOSEError {
     constructor() {
         super(...arguments);
-        this.code = JWKSMultipleMatchingKeys.code;
+        this.code = 'ERR_JWKS_MULTIPLE_MATCHING_KEYS';
         this.message = 'multiple matching keys found in the JSON Web Key Set';
     }
+    static get code() {
+        return 'ERR_JWKS_MULTIPLE_MATCHING_KEYS';
+    }
 }
-JWKSMultipleMatchingKeys.code = 'ERR_JWKS_MULTIPLE_MATCHING_KEYS';
-export class JWSSignatureVerificationFailed extends JOSEError {
+export class JWKSTimeout extends JOSEError {
     constructor() {
         super(...arguments);
-        this.code = JWSSignatureVerificationFailed.code;
-        this.message = 'signature verification failed';
+        this.code = 'ERR_JWKS_TIMEOUT';
+        this.message = 'request timed out';
+    }
+    static get code() {
+        return 'ERR_JWKS_TIMEOUT';
     }
 }
-JWSSignatureVerificationFailed.code = 'ERR_JWS_SIGNATURE_VERIFICATION_FAILED';
-export class JWTExpired extends JWTClaimValidationFailed {
+export class JWSSignatureVerificationFailed extends JOSEError {
     constructor() {
         super(...arguments);
-        this.code = JWTExpired.code;
+        this.code = 'ERR_JWS_SIGNATURE_VERIFICATION_FAILED';
+        this.message = 'signature verification failed';
+    }
+    static get code() {
+        return 'ERR_JWS_SIGNATURE_VERIFICATION_FAILED';
     }
 }
-JWTExpired.code = 'ERR_JWT_EXPIRED';

package/dist/types/jwe/compact/decrypt.d.ts

@@ -1,7 +1,7 @@
 import type { KeyLike, DecryptOptions, JWEHeaderParameters, GetKeyFunction, FlattenedJWE, CompactDecryptResult, ResolvedKey } from '../../types';
 export interface CompactDecryptGetKey extends GetKeyFunction<JWEHeaderParameters, FlattenedJWE> {
 }
-declare function compactDecrypt(jwe: string | Uint8Array, key: KeyLike, options?: DecryptOptions): Promise<CompactDecryptResult>;
+declare function compactDecrypt(jwe: string | Uint8Array, key: KeyLike | Uint8Array, options?: DecryptOptions): Promise<CompactDecryptResult>;
 declare function compactDecrypt(jwe: string | Uint8Array, getKey: CompactDecryptGetKey, options?: DecryptOptions): Promise<CompactDecryptResult & ResolvedKey>;
 export { compactDecrypt };
 export default compactDecrypt;

package/dist/types/jwe/compact/encrypt.d.ts

@@ -6,7 +6,7 @@ declare class CompactEncrypt {
     setInitializationVector(iv: Uint8Array): this;
     setProtectedHeader(protectedHeader: JWEHeaderParameters): this;
     setKeyManagementParameters(parameters: JWEKeyManagementHeaderParameters): this;
-    encrypt(key: KeyLike, options?: EncryptOptions): Promise<string>;
+    encrypt(key: KeyLike | Uint8Array, options?: EncryptOptions): Promise<string>;
 }
 export { CompactEncrypt };
 export default CompactEncrypt;

package/dist/types/jwe/flattened/decrypt.d.ts

@@ -1,7 +1,7 @@
 import type { FlattenedDecryptResult, KeyLike, FlattenedJWE, JWEHeaderParameters, DecryptOptions, GetKeyFunction, ResolvedKey } from '../../types';
 export interface FlattenedDecryptGetKey extends GetKeyFunction<JWEHeaderParameters | undefined, FlattenedJWE> {
 }
-declare function flattenedDecrypt(jwe: FlattenedJWE, key: KeyLike, options?: DecryptOptions): Promise<FlattenedDecryptResult>;
+declare function flattenedDecrypt(jwe: FlattenedJWE, key: KeyLike | Uint8Array, options?: DecryptOptions): Promise<FlattenedDecryptResult>;
 declare function flattenedDecrypt(jwe: FlattenedJWE, getKey: FlattenedDecryptGetKey, options?: DecryptOptions): Promise<FlattenedDecryptResult & ResolvedKey>;
 export { flattenedDecrypt };
 export default flattenedDecrypt;

package/dist/types/jwe/flattened/encrypt.d.ts

@@ -16,7 +16,7 @@ declare class FlattenedEncrypt {
     setAdditionalAuthenticatedData(aad: Uint8Array): this;
     setContentEncryptionKey(cek: Uint8Array): this;
     setInitializationVector(iv: Uint8Array): this;
-    encrypt(key: KeyLike, options?: EncryptOptions): Promise<FlattenedJWE>;
+    encrypt(key: KeyLike | Uint8Array, options?: EncryptOptions): Promise<FlattenedJWE>;
 }
 export { FlattenedEncrypt };
 export default FlattenedEncrypt;

package/dist/types/jwe/general/decrypt.d.ts

@@ -1,7 +1,7 @@
 import type { KeyLike, DecryptOptions, JWEHeaderParameters, GetKeyFunction, FlattenedJWE, GeneralJWE, GeneralDecryptResult, ResolvedKey } from '../../types';
 export interface GeneralDecryptGetKey extends GetKeyFunction<JWEHeaderParameters, FlattenedJWE> {
 }
-declare function generalDecrypt(jwe: GeneralJWE, key: KeyLike, options?: DecryptOptions): Promise<GeneralDecryptResult>;
+declare function generalDecrypt(jwe: GeneralJWE, key: KeyLike | Uint8Array, options?: DecryptOptions): Promise<GeneralDecryptResult>;
 declare function generalDecrypt(jwe: GeneralJWE, getKey: GeneralDecryptGetKey, options?: DecryptOptions): Promise<GeneralDecryptResult & ResolvedKey>;
 export { generalDecrypt };
 export default generalDecrypt;

package/dist/types/jwk/embedded.d.ts

@@ -1,5 +1,4 @@
-/// <reference types="node" />
-import type { KeyObject, FlattenedJWSInput, JWSHeaderParameters } from '../types';
-declare function EmbeddedJWK(protectedHeader: JWSHeaderParameters, token: FlattenedJWSInput): Promise<CryptoKey | KeyObject>;
+import type { FlattenedJWSInput, JWSHeaderParameters } from '../types';
+declare function EmbeddedJWK(protectedHeader: JWSHeaderParameters, token: FlattenedJWSInput): Promise<import("../types.d").KeyLike>;
 export { EmbeddedJWK };
 export default EmbeddedJWK;

package/dist/types/jwk/from_key_like.d.ts

@@ -1,5 +1,5 @@
 import type { JWK, KeyLike } from '../types';
-declare function fromKeyLike(key: KeyLike): Promise<JWK>;
+declare function fromKeyLike(key: KeyLike | Uint8Array): Promise<JWK>;
 export { fromKeyLike };
 export default fromKeyLike;
 export type { KeyLike, JWK };

package/dist/types/jwk/parse.d.ts

@@ -1,5 +1,5 @@
 import type { JWK, KeyLike } from '../types';
-declare function parseJwk(jwk: JWK, alg?: string, octAsKeyObject?: boolean): Promise<KeyLike>;
+declare function parseJwk(jwk: JWK, alg?: string, octAsKeyObject?: boolean): Promise<KeyLike | Uint8Array>;
 export { parseJwk };
 export default parseJwk;
 export type { KeyLike, JWK };

package/dist/types/jws/compact/sign.d.ts

@@ -3,7 +3,7 @@ declare class CompactSign {
     private _flattened;
     constructor(payload: Uint8Array);
     setProtectedHeader(protectedHeader: JWSHeaderParameters): this;
-    sign(key: KeyLike, options?: SignOptions): Promise<string>;
+    sign(key: KeyLike | Uint8Array, options?: SignOptions): Promise<string>;
 }
 export { CompactSign };
 export default CompactSign;

package/dist/types/jws/compact/verify.d.ts

@@ -1,7 +1,7 @@
 import type { CompactVerifyResult, FlattenedJWSInput, GetKeyFunction, JWSHeaderParameters, KeyLike, VerifyOptions, ResolvedKey } from '../../types';
 export interface CompactVerifyGetKey extends GetKeyFunction<JWSHeaderParameters, FlattenedJWSInput> {
 }
-declare function compactVerify(jws: string | Uint8Array, key: KeyLike, options?: VerifyOptions): Promise<CompactVerifyResult>;
+declare function compactVerify(jws: string | Uint8Array, key: KeyLike | Uint8Array, options?: VerifyOptions): Promise<CompactVerifyResult>;
 declare function compactVerify(jws: string | Uint8Array, getKey: CompactVerifyGetKey, options?: VerifyOptions): Promise<CompactVerifyResult & ResolvedKey>;
 export { compactVerify };
 export default compactVerify;

package/dist/types/jws/flattened/sign.d.ts

@@ -6,7 +6,7 @@ declare class FlattenedSign {
     constructor(payload: Uint8Array);
     setProtectedHeader(protectedHeader: JWSHeaderParameters): this;
     setUnprotectedHeader(unprotectedHeader: JWSHeaderParameters): this;
-    sign(key: KeyLike, options?: SignOptions): Promise<FlattenedJWS>;
+    sign(key: KeyLike | Uint8Array, options?: SignOptions): Promise<FlattenedJWS>;
 }
 export { FlattenedSign };
 export default FlattenedSign;

package/dist/types/jws/flattened/verify.d.ts

@@ -1,7 +1,7 @@
 import type { FlattenedVerifyResult, KeyLike, FlattenedJWSInput, JWSHeaderParameters, VerifyOptions, GetKeyFunction, ResolvedKey } from '../../types';
 export interface FlattenedVerifyGetKey extends GetKeyFunction<JWSHeaderParameters | undefined, FlattenedJWSInput> {
 }
-declare function flattenedVerify(jws: FlattenedJWSInput, key: KeyLike, options?: VerifyOptions): Promise<FlattenedVerifyResult>;
+declare function flattenedVerify(jws: FlattenedJWSInput, key: KeyLike | Uint8Array, options?: VerifyOptions): Promise<FlattenedVerifyResult>;
 declare function flattenedVerify(jws: FlattenedJWSInput, getKey: FlattenedVerifyGetKey, options?: VerifyOptions): Promise<FlattenedVerifyResult & ResolvedKey>;
 export { flattenedVerify };
 export default flattenedVerify;

package/dist/types/jws/general/sign.d.ts

@@ -7,7 +7,7 @@ declare class GeneralSign {
     private _payload;
     private _signatures;
     constructor(payload: Uint8Array);
-    addSignature(key: KeyLike, options?: SignOptions): Signature;
+    addSignature(key: KeyLike | Uint8Array, options?: SignOptions): Signature;
     sign(): Promise<GeneralJWS>;
 }
 export { GeneralSign };

package/dist/types/jws/general/verify.d.ts

@@ -1,7 +1,7 @@
 import type { GeneralJWSInput, GeneralVerifyResult, FlattenedJWSInput, GetKeyFunction, JWSHeaderParameters, KeyLike, VerifyOptions, ResolvedKey } from '../../types';
 export interface GeneralVerifyGetKey extends GetKeyFunction<JWSHeaderParameters, FlattenedJWSInput> {
 }
-declare function generalVerify(jws: GeneralJWSInput, key: KeyLike, options?: VerifyOptions): Promise<GeneralVerifyResult>;
+declare function generalVerify(jws: GeneralJWSInput, key: KeyLike | Uint8Array, options?: VerifyOptions): Promise<GeneralVerifyResult>;
 declare function generalVerify(jws: GeneralJWSInput, getKey: GeneralVerifyGetKey, options?: VerifyOptions): Promise<GeneralVerifyResult & ResolvedKey>;
 export { generalVerify };
 export default generalVerify;

package/dist/types/jwt/decrypt.d.ts

@@ -3,7 +3,7 @@ interface JWTDecryptOptions extends DecryptOptions, JWTClaimVerificationOptions
 }
 export interface JWTDecryptGetKey extends GetKeyFunction<JWEHeaderParameters, FlattenedJWE> {
 }
-declare function jwtDecrypt(jwt: string | Uint8Array, key: KeyLike, options?: JWTDecryptOptions): Promise<JWTDecryptResult>;
+declare function jwtDecrypt(jwt: string | Uint8Array, key: KeyLike | Uint8Array, options?: JWTDecryptOptions): Promise<JWTDecryptResult>;
 declare function jwtDecrypt(jwt: string | Uint8Array, getKey: JWTDecryptGetKey, options?: JWTDecryptOptions): Promise<JWTDecryptResult & ResolvedKey>;
 export { jwtDecrypt };
 export default jwtDecrypt;

package/dist/types/jwt/encrypt.d.ts

@@ -1,5 +1,5 @@
 import type { EncryptOptions, JWEHeaderParameters, JWEKeyManagementHeaderParameters, JWTPayload, KeyLike } from '../types';
-import ProduceJWT from '../lib/jwt_producer';
+import { ProduceJWT } from './produce';
 declare class EncryptJWT extends ProduceJWT {
     private _cek;
     private _iv;
@@ -15,7 +15,7 @@ declare class EncryptJWT extends ProduceJWT {
     replicateIssuerAsHeader(): this;
     replicateSubjectAsHeader(): this;
     replicateAudienceAsHeader(): this;
-    encrypt(key: KeyLike, options?: EncryptOptions): Promise<string>;
+    encrypt(key: KeyLike | Uint8Array, options?: EncryptOptions): Promise<string>;
 }
 export { EncryptJWT };
 export default EncryptJWT;

package/dist/types/{lib/jwt_producer.d.ts → jwt/produce.d.ts}

@@ -1,5 +1,5 @@
 import type { JWTPayload } from '../types';
-export default class ProduceJWT {
+export declare class ProduceJWT {
     protected _payload: JWTPayload;
     constructor(payload: JWTPayload);
     setIssuer(issuer: string): this;

package/dist/types/jwt/sign.d.ts

@@ -1,9 +1,9 @@
 import type { JWSHeaderParameters, JWTPayload, KeyLike, SignOptions } from '../types';
-import ProduceJWT from '../lib/jwt_producer';
+import { ProduceJWT } from './produce';
 declare class SignJWT extends ProduceJWT {
     private _protectedHeader;
     setProtectedHeader(protectedHeader: JWSHeaderParameters): this;
-    sign(key: KeyLike, options?: SignOptions): Promise<string>;
+    sign(key: KeyLike | Uint8Array, options?: SignOptions): Promise<string>;
 }
 export { SignJWT };
 export default SignJWT;

package/dist/types/jwt/unsecured.d.ts

@@ -1,5 +1,5 @@
 import type { JWSHeaderParameters, JWTClaimVerificationOptions, JWTPayload } from '../types';
-import ProduceJWT from '../lib/jwt_producer';
+import { ProduceJWT } from './produce';
 interface UnsecuredResult {
     payload: JWTPayload;
     header: JWSHeaderParameters;

package/dist/types/jwt/verify.d.ts

@@ -3,7 +3,7 @@ interface JWTVerifyOptions extends VerifyOptions, JWTClaimVerificationOptions {
 }
 export interface JWTVerifyGetKey extends GetKeyFunction<JWSHeaderParameters, FlattenedJWSInput> {
 }
-declare function jwtVerify(jwt: string | Uint8Array, key: KeyLike, options?: JWTVerifyOptions): Promise<JWTVerifyResult>;
+declare function jwtVerify(jwt: string | Uint8Array, key: KeyLike | Uint8Array, options?: JWTVerifyOptions): Promise<JWTVerifyResult>;
 declare function jwtVerify(jwt: string | Uint8Array, getKey: JWTVerifyGetKey, options?: JWTVerifyOptions): Promise<JWTVerifyResult & ResolvedKey>;
 export { jwtVerify };
 export default jwtVerify;

package/dist/types/key/export.d.ts

@@ -1,5 +1,5 @@
 import type { JWK, KeyLike } from '../types';
-export declare function exportSPKI(key: Exclude<KeyLike, Uint8Array>): Promise<string>;
-export declare function exportPKCS8(key: Exclude<KeyLike, Uint8Array>): Promise<string>;
-export declare function exportJWK(key: KeyLike): Promise<JWK>;
+export declare function exportSPKI(key: KeyLike): Promise<string>;
+export declare function exportPKCS8(key: KeyLike): Promise<string>;
+export declare function exportJWK(key: KeyLike | Uint8Array): Promise<JWK>;
 export type { KeyLike, JWK };

package/dist/types/key/import.d.ts

@@ -2,8 +2,8 @@ import type { JWK, KeyLike } from '../types';
 export interface PEMImportOptions {
     extractable?: boolean;
 }
-export declare function importSPKI(spki: string, alg: string, options?: PEMImportOptions): Promise<Exclude<KeyLike, Uint8Array>>;
-export declare function importX509(x509: string, alg: string, options?: PEMImportOptions): Promise<Exclude<KeyLike, Uint8Array>>;
-export declare function importPKCS8(pkcs8: string, alg: string, options?: PEMImportOptions): Promise<Exclude<KeyLike, Uint8Array>>;
-export declare function importJWK(jwk: JWK, alg?: string, octAsKeyObject?: boolean): Promise<KeyLike>;
+export declare function importSPKI(spki: string, alg: string, options?: PEMImportOptions): Promise<KeyLike>;
+export declare function importX509(x509: string, alg: string, options?: PEMImportOptions): Promise<KeyLike>;
+export declare function importPKCS8(pkcs8: string, alg: string, options?: PEMImportOptions): Promise<KeyLike>;
+export declare function importJWK(jwk: JWK, alg?: string, octAsKeyObject?: boolean): Promise<KeyLike | Uint8Array>;
 export type { KeyLike, JWK };