@openclaw/msteams 2026.5.27 → 2026.5.28-beta.2

package/node_modules/jose/README.md

@@ -1,16 +1,6 @@
 # jose
 
-`jose` is a JavaScript module for JSON Object Signing and Encryption, providing support for JSON Web Tokens (JWT), JSON Web Signature (JWS), JSON Web Encryption (JWE), JSON Web Key (JWK), JSON Web Key Set (JWKS), and more. The module is designed to work across various Web-interoperable runtimes including Node.js, browsers, Cloudflare Workers, Deno, Bun, and others.
-
-## Sponsor
-
-<picture>
-  <source media="(prefers-color-scheme: dark)" srcset="https://raw.githubusercontent.com/panva/jose/HEAD/sponsor/Auth0byOkta_dark.png">
-  <source media="(prefers-color-scheme: light)" srcset="https://raw.githubusercontent.com/panva/jose/HEAD/sponsor/Auth0byOkta_light.png">
-  <img height="65" align="left" alt="Auth0 by Okta" src="https://raw.githubusercontent.com/panva/jose/HEAD/sponsor/Auth0byOkta_light.png">
-</picture>
-
-If you want to quickly add JWT authentication to JavaScript apps, feel free to check out Auth0's JavaScript SDK and free plan. [Create an Auth0 account; it's free!][sponsor-auth0]<br><br>
+`jose` is JavaScript module for JSON Object Signing and Encryption, providing support for JSON Web Tokens (JWT), JSON Web Signature (JWS), JSON Web Encryption (JWE), JSON Web Key (JWK), JSON Web Key Set (JWKS), and more. The module is designed to work across various Web-interoperable runtimes including Node.js, browsers, Cloudflare Workers, Deno, Bun, and others.
 
 ## [💗 Help the project](https://github.com/sponsors/panva)
 
@@ -18,114 +8,93 @@ Support from the community to continue maintaining and improving this module is
 
 ## Dependencies: 0
 
-`jose` has no dependencies and it exports tree-shakeable ESM[^cjs].
+`jose` has no dependencies and it exports tree-shakeable ESM. CJS is also supported.
 
 ## Documentation
 
-`jose` is distributed via [npmjs.com](https://www.npmjs.com/package/jose), [jsr.io](https://jsr.io/@panva/jose), [jsdelivr.com](https://www.jsdelivr.com/package/npm/jose), and [github.com](https://github.com/panva/jose).
-
-**`example`** ESM import[^cjs]
+`jose` is distributed via [npmjs.com](https://www.npmjs.com/package/jose), [deno.land/x](https://deno.land/x/jose), [cdnjs.com](https://cdnjs.com/libraries/jose), [jsdelivr.com](https://www.jsdelivr.com/package/npm/jose), and [github.com](https://github.com/panva/jose).
 
+**`example`** ESM import
 ```js
 import * as jose from 'jose'
 ```
 
+**`example`** CJS require
+```js
+const jose = require('jose')
+```
+
 ### JSON Web Tokens (JWT)
 
 The `jose` module supports JSON Web Tokens (JWT) and provides functionality for signing and verifying tokens, as well as their JWT Claims Set validation.
 
-- [JWT Claims Set Validation & Signature Verification](docs/jwt/verify/functions/jwtVerify.md) using the `jwtVerify` function
-  - [Using a remote JSON Web Key Set (JWKS)](docs/jwks/remote/functions/createRemoteJWKSet.md)
-  - [Using a local JSON Web Key Set (JWKS)](docs/jwks/local/functions/createLocalJWKSet.md)
-- [Signing](docs/jwt/sign/classes/SignJWT.md) using the `SignJWT` class
+- [Signing](docs/classes/jwt_sign.SignJWT.md) using the `SignJWT` class
+- [Verification & JWT Claims Set Validation](docs/functions/jwt_verify.jwtVerify.md) using the `jwtVerify` function
+  - [Using a remote JWKS](docs/functions/jwks_remote.createRemoteJWKSet.md)
+  - [Using a local JWKS](docs/functions/jwks_local.createLocalJWKSet.md)
 - Utility functions
-  - [Decoding Token's Protected Header](docs/util/decode_protected_header/functions/decodeProtectedHeader.md)
-  - [Decoding JWT Claims Set](docs/util/decode_jwt/functions/decodeJwt.md) prior to its validation
+  - [Decoding Token's Protected Header](docs/functions/util_decode_protected_header.decodeProtectedHeader.md)
+  - [Decoding JWT Claims Set](docs/functions/util_decode_jwt.decodeJwt.md) prior to its validation
 
 ### Encrypted JSON Web Tokens
 
 The `jose` module supports encrypted JSON Web Tokens and provides functionality for encrypting and decrypting tokens, as well as their JWT Claims Set validation.
 
-- [Decryption & JWT Claims Set Validation](docs/jwt/decrypt/functions/jwtDecrypt.md) using the `jwtDecrypt` function
-- [Encryption](docs/jwt/encrypt/classes/EncryptJWT.md) using the `EncryptJWT` class
+- [Encryption](docs/classes/jwt_encrypt.EncryptJWT.md) using the `EncryptJWT` class
+- [Decryption & JWT Claims Set Validation](docs/functions/jwt_decrypt.jwtDecrypt.md) using the `jwtDecrypt` function
 - Utility functions
-  - [Decoding Token's Protected Header](docs/util/decode_protected_header/functions/decodeProtectedHeader.md)
+  - [Decoding Token's Protected Header](docs/functions/util_decode_protected_header.decodeProtectedHeader.md)
 
 ### Key Utilities
 
 The `jose` module supports importing, exporting, and generating keys and secrets in various formats, including PEM formats like SPKI, X.509 certificate, and PKCS #8, as well as JSON Web Key (JWK).
 
 - Key Import Functions
-  - [JWK Import](docs/key/import/functions/importJWK.md)
-  - [Public Key Import (SPKI)](docs/key/import/functions/importSPKI.md)
-  - [Public Key Import (X.509 Certificate)](docs/key/import/functions/importX509.md)
-  - [Private Key Import (PKCS #8)](docs/key/import/functions/importPKCS8.md)
+  - [JWK Import](docs/functions/key_import.importJWK.md)
+  - [Public Key Import (SPKI)](docs/functions/key_import.importSPKI.md)
+  - [Public Key Import (X.509 Certificate)](docs/functions/key_import.importX509.md)
+  - [Private Key Import (PKCS #8)](docs/functions/key_import.importPKCS8.md)
 - Key and Secret Generation Functions
-  - [Asymmetric Key Pair Generation](docs/key/generate_key_pair/functions/generateKeyPair.md)
-  - [Symmetric Secret Generation](docs/key/generate_secret/functions/generateSecret.md)
+  - [Asymmetric Key Pair Generation](docs/functions/key_generate_key_pair.generateKeyPair.md)
+  - [Symmetric Secret Generation](docs/functions/key_generate_secret.generateSecret.md)
 - Key Export Functions
-  - [JWK Export](docs/key/export/functions/exportJWK.md)
-  - [Private Key Export](docs/key/export/functions/exportPKCS8.md)
-  - [Public Key Export](docs/key/export/functions/exportSPKI.md)
+  - [JWK Export](docs/functions/key_export.exportJWK.md)
+  - [Private Key Export](docs/functions/key_export.exportPKCS8.md)
+  - [Public Key Export](docs/functions/key_export.exportSPKI.md)
 
 ### JSON Web Signature (JWS)
 
 The `jose` module supports signing and verification of JWS messages with arbitrary payloads in Compact, Flattened JSON, and General JSON serialization syntaxes.
 
-- Signing - [Compact](docs/jws/compact/sign/classes/CompactSign.md), [Flattened JSON](docs/jws/flattened/sign/classes/FlattenedSign.md), [General JSON](docs/jws/general/sign/classes/GeneralSign.md)
-- Verification - [Compact](docs/jws/compact/verify/functions/compactVerify.md), [Flattened JSON](docs/jws/flattened/verify/functions/flattenedVerify.md), [General JSON](docs/jws/general/verify/functions/generalVerify.md)
-  - [Using a remote JSON Web Key Set (JWKS)](docs/jwks/remote/functions/createRemoteJWKSet.md)
-  - [Using a local JSON Web Key Set (JWKS)](docs/jwks/local/functions/createLocalJWKSet.md)
+- Signing - [Compact](docs/classes/jws_compact_sign.CompactSign.md), [Flattened JSON](docs/classes/jws_flattened_sign.FlattenedSign.md), [General JSON](docs/classes/jws_general_sign.GeneralSign.md)
+- Verification - [Compact](docs/functions/jws_compact_verify.compactVerify.md), [Flattened JSON](docs/functions/jws_flattened_verify.flattenedVerify.md), [General JSON](docs/functions/jws_general_verify.generalVerify.md)
+  - [Verify using a remote JWKS](docs/functions/jwks_remote.createRemoteJWKSet.md)
+  - [Verify using a local JWKS](docs/functions/jwks_local.createLocalJWKSet.md)
 - Utility functions
-  - [Decoding Token's Protected Header](docs/util/decode_protected_header/functions/decodeProtectedHeader.md)
+  - [Decoding Token's Protected Header](docs/functions/util_decode_protected_header.decodeProtectedHeader.md)
 
 ### JSON Web Encryption (JWE)
 
 The `jose` module supports encryption and decryption of JWE messages with arbitrary plaintext in Compact, Flattened JSON, and General JSON serialization syntaxes.
 
-- Encryption - [Compact](docs/jwe/compact/encrypt/classes/CompactEncrypt.md), [Flattened JSON](docs/jwe/flattened/encrypt/classes/FlattenedEncrypt.md), [General JSON](docs/jwe/general/encrypt/classes/GeneralEncrypt.md)
-- Decryption - [Compact](docs/jwe/compact/decrypt/functions/compactDecrypt.md), [Flattened JSON](docs/jwe/flattened/decrypt/functions/flattenedDecrypt.md), [General JSON](docs/jwe/general/decrypt/functions/generalDecrypt.md)
+- Encryption - [Compact](docs/classes/jwe_compact_encrypt.CompactEncrypt.md), [Flattened JSON](docs/classes/jwe_flattened_encrypt.FlattenedEncrypt.md), [General JSON](docs/classes/jwe_general_encrypt.GeneralEncrypt.md)
+- Decryption - [Compact](docs/functions/jwe_compact_decrypt.compactDecrypt.md), [Flattened JSON](docs/functions/jwe_flattened_decrypt.flattenedDecrypt.md), [General JSON](docs/functions/jwe_general_decrypt.generalDecrypt.md)
 - Utility functions
-  - [Decoding Token's Protected Header](docs/util/decode_protected_header/functions/decodeProtectedHeader.md)
+  - [Decoding Token's Protected Header](docs/functions/util_decode_protected_header.decodeProtectedHeader.md)
 
 ### Other
 
 The following are additional features and utilities provided by the `jose` module:
 
-- [Calculating JWK Thumbprint](docs/jwk/thumbprint/functions/calculateJwkThumbprint.md)
-- [Calculating JWK Thumbprint URI](docs/jwk/thumbprint/functions/calculateJwkThumbprintUri.md)
-- [Verification using a JWK Embedded in a JWS Header](docs/jwk/embedded/functions/EmbeddedJWK.md)
-- [Unsecured JWT](docs/jwt/unsecured/classes/UnsecuredJWT.md)
-- [JOSE Errors](docs/util/errors/README.md)
-
-## Supported Runtimes
-
-The `jose` module is compatible with JavaScript runtimes that support the utilized Web API globals and standard built-in objects or are Node.js.
-
-The following runtimes are supported _(this is not an exhaustive list)_:
-
-- [Bun](https://github.com/panva/jose/issues/471)
-- [Browsers](https://github.com/panva/jose/issues/263)
-- [Cloudflare Workers](https://github.com/panva/jose/issues/265)
-- [Deno](https://github.com/panva/jose/issues/266)
-- [Electron](https://github.com/panva/jose/issues/264)
-- [Node.js](https://github.com/panva/jose/issues/262)
-
-Please note that certain algorithms may not be available depending on the runtime used. You can find a list of available algorithms for each runtime in the specific issue links provided above.
-
-## Supported Versions
-
-| Version                                         | Security Fixes 🔑 | Other Bug Fixes 🐞 | New Features ⭐ | Runtime and Module type         |
-| ----------------------------------------------- | ----------------- | ------------------ | --------------- | ------------------------------- |
-| [v6.x](https://github.com/panva/jose/tree/v6.x) | [Security Policy] | ✅                 | ✅              | Universal[^universal] ESM[^cjs] |
-| [v5.x](https://github.com/panva/jose/tree/v5.x) | [Security Policy] | ❌                 | ❌              | Universal[^universal] CJS + ESM |
-| [v4.x](https://github.com/panva/jose/tree/v4.x) | [Security Policy] | ❌                 | ❌              | Universal[^universal] CJS + ESM |
-| [v2.x](https://github.com/panva/jose/tree/v2.x) | [Security Policy] | ❌                 | ❌              | Node.js CJS                     |
+- [Calculating JWK Thumbprint](docs/functions/jwk_thumbprint.calculateJwkThumbprint.md)
+- [Calculating JWK Thumbprint URI](docs/functions/jwk_thumbprint.calculateJwkThumbprintUri.md)
+- [Verification using a JWK Embedded in a JWS Header](docs/functions/jwk_embedded.EmbeddedJWK.md)
+- [Unsecured JWT](docs/classes/jwt_unsecured.UnsecuredJWT.md)
+- [JOSE Errors](docs/modules/util_errors.md)
 
-## Specifications
+## Implemented specifications
 
-<details>
-<summary>Details</summary>
+The `jose` module implements the following specifications:
 
 - JSON Web Signature (JWS) - [RFC7515](https://www.rfc-editor.org/rfc/rfc7515)
 - JSON Web Encryption (JWE) - [RFC7516](https://www.rfc-editor.org/rfc/rfc7516)
@@ -136,18 +105,28 @@ Please note that certain algorithms may not be available depending on the runtim
 - JSON Web Key Thumbprint URI - [RFC9278](https://www.rfc-editor.org/rfc/rfc9278)
 - JWS Unencoded Payload Option - [RFC7797](https://www.rfc-editor.org/rfc/rfc7797)
 - CFRG Elliptic Curve ECDH and Signatures - [RFC8037](https://www.rfc-editor.org/rfc/rfc8037)
-- Fully-Specified Algorithms for JOSE - [RFC9864](https://www.rfc-editor.org/rfc/rfc9864.html)
-- ML-DSA for JOSE - [draft-ietf-cose-dilithium-10](https://www.ietf.org/archive/id/draft-ietf-cose-dilithium-10.html)
+- secp256k1 EC Key curve support - [RFC8812](https://www.rfc-editor.org/rfc/rfc8812)
 
-The algorithm implementations in `jose` have been tested using test vectors from their respective specifications as well as [RFC7520](https://www.rfc-editor.org/rfc/rfc7520).
+The algorithm implementations have been tested using test vectors from their respective specifications as well as [RFC7520](https://www.rfc-editor.org/rfc/rfc7520).
 
-</details>
+## Supported Runtimes
 
-[sponsor-auth0]: https://a0.to/signup/panva
-[WebCryptoAPI]: https://w3c.github.io/webcrypto/
-[Fetch API]: https://developer.mozilla.org/en-US/docs/Web/API/Fetch_API
-[Security Policy]: https://github.com/panva/jose/security/policy
+The `jose` module is compatible with JavaScript runtimes that support the utilized Web API globals and standard built-in objects or are Node.js.
 
-[^cjs]: CJS style `let jose = require('jose')` is possible in Node.js versions where the `require(esm)` feature is enabled by default (^20.19.0 || ^22.12.0 || >= 23.0.0).
+The following runtimes are supported _(this is not an exhaustive list)_:
+- [Bun](https://github.com/panva/jose/issues/471)
+- [Browsers](https://github.com/panva/jose/issues/263)
+- [Cloudflare Workers](https://github.com/panva/jose/issues/265)
+- [Deno](https://github.com/panva/jose/issues/266)
+- [Electron](https://github.com/panva/jose/issues/264)
+- [Node.js](https://github.com/panva/jose/issues/262)
+- [Vercel's Edge Runtime](https://github.com/panva/jose/issues/301)
+
+Please note that certain algorithms may not be available depending on the runtime used. You can find a list of available algorithms for each runtime in the specific issue links provided above.
+
+## Supported Versions
 
-[^universal]: Assumes runtime support of [WebCryptoAPI][] and [Fetch API][]
+| Version | Security Fixes 🔑 | Other Bug Fixes 🐞 | New Features ⭐ |
+| ------- | --------- | -------- | -------- |
+| [v4.x](https://github.com/panva/jose/tree/v4.x) | ✅ | ✅ | ✅ |
+| [v2.x](https://github.com/panva/jose/tree/v2.x) | ✅ | ❌ | ❌ |

package/node_modules/jose/dist/types/index.d.ts

@@ -1,55 +1,48 @@
-export { compactDecrypt } from './jwe/compact/decrypt.js';
-export type { CompactDecryptGetKey } from './jwe/compact/decrypt.js';
-export { flattenedDecrypt } from './jwe/flattened/decrypt.js';
-export type { FlattenedDecryptGetKey } from './jwe/flattened/decrypt.js';
-export { generalDecrypt } from './jwe/general/decrypt.js';
-export type { GeneralDecryptGetKey } from './jwe/general/decrypt.js';
-export { GeneralEncrypt } from './jwe/general/encrypt.js';
-export type { Recipient } from './jwe/general/encrypt.js';
-export { compactVerify } from './jws/compact/verify.js';
-export type { CompactVerifyGetKey } from './jws/compact/verify.js';
-export { flattenedVerify } from './jws/flattened/verify.js';
-export type { FlattenedVerifyGetKey } from './jws/flattened/verify.js';
-export { generalVerify } from './jws/general/verify.js';
-export type { GeneralVerifyGetKey } from './jws/general/verify.js';
-export { jwtVerify } from './jwt/verify.js';
-export type { JWTVerifyOptions, JWTVerifyGetKey } from './jwt/verify.js';
-export { jwtDecrypt } from './jwt/decrypt.js';
-export type { JWTDecryptOptions, JWTDecryptGetKey } from './jwt/decrypt.js';
-export { CompactEncrypt } from './jwe/compact/encrypt.js';
-export { FlattenedEncrypt } from './jwe/flattened/encrypt.js';
-export { CompactSign } from './jws/compact/sign.js';
-export { FlattenedSign } from './jws/flattened/sign.js';
-export { GeneralSign } from './jws/general/sign.js';
-export type { Signature } from './jws/general/sign.js';
-export { SignJWT } from './jwt/sign.js';
-export { EncryptJWT } from './jwt/encrypt.js';
-export { calculateJwkThumbprint, calculateJwkThumbprintUri } from './jwk/thumbprint.js';
-export { EmbeddedJWK } from './jwk/embedded.js';
-export { createLocalJWKSet } from './jwks/local.js';
-export { createRemoteJWKSet, jwksCache, customFetch } from './jwks/remote.js';
-export type { RemoteJWKSetOptions, JWKSCacheInput, ExportedJWKSCache, FetchImplementation, } from './jwks/remote.js';
-export { UnsecuredJWT } from './jwt/unsecured.js';
-export type { UnsecuredResult } from './jwt/unsecured.js';
-export { exportPKCS8, exportSPKI, exportJWK } from './key/export.js';
-export { importSPKI, importPKCS8, importX509, importJWK } from './key/import.js';
-export type { KeyImportOptions } from './key/import.js';
-export { decodeProtectedHeader } from './util/decode_protected_header.js';
-export { decodeJwt } from './util/decode_jwt.js';
-export type { ProtectedHeaderParameters } from './util/decode_protected_header.js';
-import * as errors from './util/errors.js';
-export { errors };
-export { generateKeyPair } from './key/generate_key_pair.js';
-export type { GenerateKeyPairResult, GenerateKeyPairOptions } from './key/generate_key_pair.js';
-export { generateSecret } from './key/generate_secret.js';
-export type { GenerateSecretOptions } from './key/generate_secret.js';
-import * as base64url from './util/base64url.js';
-export { base64url };
-export type { CompactDecryptResult, CompactJWEHeaderParameters, CompactJWSHeaderParameters, CompactVerifyResult, CritOption, CryptoKey, DecryptOptions, EncryptOptions, FlattenedDecryptResult, FlattenedJWE, FlattenedJWS, FlattenedJWSInput, FlattenedVerifyResult, GeneralDecryptResult, GeneralJWE, GeneralJWS, GeneralJWSInput, GeneralVerifyResult, GetKeyFunction, JoseHeaderParameters, JSONWebKeySet, JWEHeaderParameters, JWEKeyManagementHeaderParameters, JWK_EC_Private, JWK_EC_Public, JWK_oct, JWK_OKP_Private, JWK_OKP_Public, JWK_RSA_Private, JWK_RSA_Public, JWK, JWKParameters, JWSHeaderParameters, JWTClaimVerificationOptions, JWTDecryptResult, JWTHeaderParameters, JWTPayload, JWTVerifyResult, KeyObject, ProduceJWT, ResolvedKey, SignOptions, VerifyOptions, } from './types.d.ts';
-/**
- * In prior releases this indicated whether a Node.js-specific build was loaded, this is now fixed
- * to `"WebCryptoAPI"`
- *
- * @deprecated
- */
-export declare const cryptoRuntime = "WebCryptoAPI";
+export { compactDecrypt } from './jwe/compact/decrypt';
+export type { CompactDecryptGetKey } from './jwe/compact/decrypt';
+export { flattenedDecrypt } from './jwe/flattened/decrypt';
+export type { FlattenedDecryptGetKey } from './jwe/flattened/decrypt';
+export { generalDecrypt } from './jwe/general/decrypt';
+export type { GeneralDecryptGetKey } from './jwe/general/decrypt';
+export { GeneralEncrypt } from './jwe/general/encrypt';
+export type { Recipient } from './jwe/general/encrypt';
+export { compactVerify } from './jws/compact/verify';
+export type { CompactVerifyGetKey } from './jws/compact/verify';
+export { flattenedVerify } from './jws/flattened/verify';
+export type { FlattenedVerifyGetKey } from './jws/flattened/verify';
+export { generalVerify } from './jws/general/verify';
+export type { GeneralVerifyGetKey } from './jws/general/verify';
+export { jwtVerify } from './jwt/verify';
+export type { JWTVerifyOptions, JWTVerifyGetKey } from './jwt/verify';
+export { jwtDecrypt } from './jwt/decrypt';
+export type { JWTDecryptOptions, JWTDecryptGetKey } from './jwt/decrypt';
+export type { ProduceJWT } from './jwt/produce';
+export { CompactEncrypt } from './jwe/compact/encrypt';
+export { FlattenedEncrypt } from './jwe/flattened/encrypt';
+export { CompactSign } from './jws/compact/sign';
+export { FlattenedSign } from './jws/flattened/sign';
+export { GeneralSign } from './jws/general/sign';
+export type { Signature } from './jws/general/sign';
+export { SignJWT } from './jwt/sign';
+export { EncryptJWT } from './jwt/encrypt';
+export { calculateJwkThumbprint, calculateJwkThumbprintUri } from './jwk/thumbprint';
+export { EmbeddedJWK } from './jwk/embedded';
+export { createLocalJWKSet } from './jwks/local';
+export { createRemoteJWKSet } from './jwks/remote';
+export type { RemoteJWKSetOptions } from './jwks/remote';
+export { UnsecuredJWT } from './jwt/unsecured';
+export type { UnsecuredResult } from './jwt/unsecured';
+export { exportPKCS8, exportSPKI, exportJWK } from './key/export';
+export { importSPKI, importPKCS8, importX509, importJWK } from './key/import';
+export type { PEMImportOptions } from './key/import';
+export { decodeProtectedHeader } from './util/decode_protected_header';
+export { decodeJwt } from './util/decode_jwt';
+export type { ProtectedHeaderParameters } from './util/decode_protected_header';
+export * as errors from './util/errors';
+export { generateKeyPair } from './key/generate_key_pair';
+export type { GenerateKeyPairResult, GenerateKeyPairOptions } from './key/generate_key_pair';
+export { generateSecret } from './key/generate_secret';
+export type { GenerateSecretOptions } from './key/generate_secret';
+export * as base64url from './util/base64url';
+export type { KeyLike, JWK, FlattenedJWSInput, GeneralJWSInput, FlattenedJWS, GeneralJWS, JoseHeaderParameters, JWSHeaderParameters, JWEKeyManagementHeaderParameters, FlattenedJWE, GeneralJWE, JWEHeaderParameters, CritOption, DeflateOption, DecryptOptions, EncryptOptions, JWTClaimVerificationOptions, VerifyOptions, SignOptions, JWTPayload, DeflateFunction, InflateFunction, FlattenedDecryptResult, GeneralDecryptResult, CompactDecryptResult, FlattenedVerifyResult, GeneralVerifyResult, CompactVerifyResult, JWTVerifyResult, JWTDecryptResult, ResolvedKey, CompactJWEHeaderParameters, CompactJWSHeaderParameters, JWTHeaderParameters, JSONWebKeySet, CryptoRuntime, GetKeyFunction, } from './types';
+export { default as cryptoRuntime } from './util/runtime';

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

@@ -1,31 +1,23 @@
-/**
- * Decrypting JSON Web Encryption (JWE) in Compact Serialization
- *
- * @module
- */
-import type * as types from '../../types.d.ts';
+import type { KeyLike, DecryptOptions, CompactJWEHeaderParameters, GetKeyFunction, FlattenedJWE, CompactDecryptResult, ResolvedKey } from '../../types';
 /**
  * Interface for Compact JWE Decryption dynamic key resolution. No token components have been
  * verified at the time of this function call.
  */
-export interface CompactDecryptGetKey extends types.GetKeyFunction<types.CompactJWEHeaderParameters, types.FlattenedJWE> {
+export interface CompactDecryptGetKey extends GetKeyFunction<CompactJWEHeaderParameters, FlattenedJWE> {
 }
 /**
  * Decrypts a Compact JWE.
  *
- * This function is exported (as a named export) from the main `'jose'` module entry point as well
- * as from its subpath export `'jose/jwe/compact/decrypt'`.
- *
  * @param jwe Compact JWE.
  * @param key Private Key or Secret to decrypt the JWE with. See
  *   {@link https://github.com/panva/jose/issues/210#jwe-alg Algorithm Key Requirements}.
  * @param options JWE Decryption options.
  */
-export declare function compactDecrypt(jwe: string | Uint8Array, key: types.CryptoKey | types.KeyObject | types.JWK | Uint8Array, options?: types.DecryptOptions): Promise<types.CompactDecryptResult>;
+export declare function compactDecrypt(jwe: string | Uint8Array, key: KeyLike | Uint8Array, options?: DecryptOptions): Promise<CompactDecryptResult>;
 /**
  * @param jwe Compact JWE.
  * @param getKey Function resolving Private Key or Secret to decrypt the JWE with. See
  *   {@link https://github.com/panva/jose/issues/210#jwe-alg Algorithm Key Requirements}.
  * @param options JWE Decryption options.
  */
-export declare function compactDecrypt(jwe: string | Uint8Array, getKey: CompactDecryptGetKey, options?: types.DecryptOptions): Promise<types.CompactDecryptResult & types.ResolvedKey>;
+export declare function compactDecrypt<T extends KeyLike = KeyLike>(jwe: string | Uint8Array, getKey: CompactDecryptGetKey, options?: DecryptOptions): Promise<CompactDecryptResult & ResolvedKey<T>>;

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

@@ -1,23 +1,11 @@
-/**
- * Encrypting JSON Web Encryption (JWE) in Compact Serialization
- *
- * @module
- */
-import type * as types from '../../types.d.ts';
+import type { KeyLike, JWEKeyManagementHeaderParameters, CompactJWEHeaderParameters, EncryptOptions } from '../../types';
 /**
  * The CompactEncrypt class is used to build and encrypt Compact JWE strings.
  *
- * This class is exported (as a named export) from the main `'jose'` module entry point as well as
- * from its subpath export `'jose/jwe/compact/encrypt'`.
- *
  */
 export declare class CompactEncrypt {
-    #private;
-    /**
-     * {@link CompactEncrypt} constructor
-     *
-     * @param plaintext Binary representation of the plaintext to encrypt.
-     */
+    private _flattened;
+    /** @param plaintext Binary representation of the plaintext to encrypt. */
     constructor(plaintext: Uint8Array);
     /**
      * Sets a content encryption key to use, by default a random suitable one is generated for the JWE
@@ -44,16 +32,15 @@ export declare class CompactEncrypt {
      *
      * @param protectedHeader JWE Protected Header object.
      */
-    setProtectedHeader(protectedHeader: types.CompactJWEHeaderParameters): this;
+    setProtectedHeader(protectedHeader: CompactJWEHeaderParameters): this;
     /**
-     * Sets the JWE Key Management parameters to be used when encrypting.
-     *
-     * (ECDH-ES) Use of this method is needed for ECDH based algorithms to set the "apu" (Agreement
-     * PartyUInfo) or "apv" (Agreement PartyVInfo) parameters.
+     * Sets the JWE Key Management parameters to be used when encrypting the Content Encryption Key.
+     * You do not need to invoke this method, it is only really intended for test and vector
+     * validation purposes.
      *
      * @param parameters JWE Key Management parameters.
      */
-    setKeyManagementParameters(parameters: types.JWEKeyManagementHeaderParameters): this;
+    setKeyManagementParameters(parameters: JWEKeyManagementHeaderParameters): this;
     /**
      * Encrypts and resolves the value of the Compact JWE string.
      *
@@ -61,5 +48,5 @@ export declare class CompactEncrypt {
      *   {@link https://github.com/panva/jose/issues/210#jwe-alg Algorithm Key Requirements}.
      * @param options JWE Encryption options.
      */
-    encrypt(key: types.CryptoKey | types.KeyObject | types.JWK | Uint8Array, options?: types.EncryptOptions): Promise<string>;
+    encrypt(key: KeyLike | Uint8Array, options?: EncryptOptions): Promise<string>;
 }

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

@@ -1,31 +1,23 @@
-/**
- * Decrypting JSON Web Encryption (JWE) in Flattened JSON Serialization
- *
- * @module
- */
-import type * as types from '../../types.d.ts';
+import type { FlattenedDecryptResult, KeyLike, FlattenedJWE, JWEHeaderParameters, DecryptOptions, GetKeyFunction, ResolvedKey } from '../../types';
 /**
  * Interface for Flattened JWE Decryption dynamic key resolution. No token components have been
  * verified at the time of this function call.
  */
-export interface FlattenedDecryptGetKey extends types.GetKeyFunction<types.JWEHeaderParameters | undefined, types.FlattenedJWE> {
+export interface FlattenedDecryptGetKey extends GetKeyFunction<JWEHeaderParameters | undefined, FlattenedJWE> {
 }
 /**
  * Decrypts a Flattened JWE.
  *
- * This function is exported (as a named export) from the main `'jose'` module entry point as well
- * as from its subpath export `'jose/jwe/flattened/decrypt'`.
- *
  * @param jwe Flattened JWE.
  * @param key Private Key or Secret to decrypt the JWE with. See
  *   {@link https://github.com/panva/jose/issues/210#jwe-alg Algorithm Key Requirements}.
  * @param options JWE Decryption options.
  */
-export declare function flattenedDecrypt(jwe: types.FlattenedJWE, key: types.CryptoKey | types.KeyObject | types.JWK | Uint8Array, options?: types.DecryptOptions): Promise<types.FlattenedDecryptResult>;
+export declare function flattenedDecrypt(jwe: FlattenedJWE, key: KeyLike | Uint8Array, options?: DecryptOptions): Promise<FlattenedDecryptResult>;
 /**
  * @param jwe Flattened JWE.
  * @param getKey Function resolving Private Key or Secret to decrypt the JWE with. See
  *   {@link https://github.com/panva/jose/issues/210#jwe-alg Algorithm Key Requirements}.
  * @param options JWE Decryption options.
  */
-export declare function flattenedDecrypt(jwe: types.FlattenedJWE, getKey: FlattenedDecryptGetKey, options?: types.DecryptOptions): Promise<types.FlattenedDecryptResult & types.ResolvedKey>;
+export declare function flattenedDecrypt<T extends KeyLike = KeyLike>(jwe: FlattenedJWE, getKey: FlattenedDecryptGetKey, options?: DecryptOptions): Promise<FlattenedDecryptResult & ResolvedKey<T>>;

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

@@ -1,51 +1,48 @@
-/**
- * Encrypting JSON Web Encryption (JWE) in Flattened JSON Serialization
- *
- * @module
- */
-import type * as types from '../../types.d.ts';
+import type { KeyLike, FlattenedJWE, JWEHeaderParameters, JWEKeyManagementHeaderParameters, EncryptOptions } from '../../types';
+/** @private */
+export declare const unprotected: unique symbol;
 /**
  * The FlattenedEncrypt class is used to build and encrypt Flattened JWE objects.
  *
- * This class is exported (as a named export) from the main `'jose'` module entry point as well as
- * from its subpath export `'jose/jwe/flattened/encrypt'`.
- *
  */
 export declare class FlattenedEncrypt {
-    #private;
-    /**
-     * {@link FlattenedEncrypt} constructor
-     *
-     * @param plaintext Binary representation of the plaintext to encrypt.
-     */
+    private _plaintext;
+    private _protectedHeader;
+    private _sharedUnprotectedHeader;
+    private _unprotectedHeader;
+    private _aad;
+    private _cek;
+    private _iv;
+    private _keyManagementParameters;
+    /** @param plaintext Binary representation of the plaintext to encrypt. */
     constructor(plaintext: Uint8Array);
     /**
-     * Sets the JWE Key Management parameters to be used when encrypting.
-     *
-     * (ECDH-ES) Use of this method is needed for ECDH based algorithms to set the "apu" (Agreement
-     * PartyUInfo) or "apv" (Agreement PartyVInfo) parameters.
+     * Sets the JWE Key Management parameters to be used when encrypting. Use of this is method is
+     * really only needed for ECDH based algorithms when utilizing the Agreement PartyUInfo or
+     * Agreement PartyVInfo parameters. Other parameters will always be randomly generated when needed
+     * and missing.
      *
      * @param parameters JWE Key Management parameters.
      */
-    setKeyManagementParameters(parameters: types.JWEKeyManagementHeaderParameters): this;
+    setKeyManagementParameters(parameters: JWEKeyManagementHeaderParameters): this;
     /**
      * Sets the JWE Protected Header on the FlattenedEncrypt object.
      *
      * @param protectedHeader JWE Protected Header.
      */
-    setProtectedHeader(protectedHeader: types.JWEHeaderParameters): this;
+    setProtectedHeader(protectedHeader: JWEHeaderParameters): this;
     /**
      * Sets the JWE Shared Unprotected Header on the FlattenedEncrypt object.
      *
      * @param sharedUnprotectedHeader JWE Shared Unprotected Header.
      */
-    setSharedUnprotectedHeader(sharedUnprotectedHeader: types.JWEHeaderParameters): this;
+    setSharedUnprotectedHeader(sharedUnprotectedHeader: JWEHeaderParameters): this;
     /**
      * Sets the JWE Per-Recipient Unprotected Header on the FlattenedEncrypt object.
      *
      * @param unprotectedHeader JWE Per-Recipient Unprotected Header.
      */
-    setUnprotectedHeader(unprotectedHeader: types.JWEHeaderParameters): this;
+    setUnprotectedHeader(unprotectedHeader: JWEHeaderParameters): this;
     /**
      * Sets the Additional Authenticated Data on the FlattenedEncrypt object.
      *
@@ -79,5 +76,5 @@ export declare class FlattenedEncrypt {
      *   {@link https://github.com/panva/jose/issues/210#jwe-alg Algorithm Key Requirements}.
      * @param options JWE Encryption options.
      */
-    encrypt(key: types.CryptoKey | types.KeyObject | types.JWK | Uint8Array, options?: types.EncryptOptions): Promise<types.FlattenedJWE>;
+    encrypt(key: KeyLike | Uint8Array, options?: EncryptOptions): Promise<FlattenedJWE>;
 }

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

@@ -1,38 +1,23 @@
-/**
- * Decrypting JSON Web Encryption (JWE) in General JSON Serialization
- *
- * @module
- */
-import type * as types from '../../types.d.ts';
+import type { KeyLike, DecryptOptions, JWEHeaderParameters, GetKeyFunction, FlattenedJWE, GeneralJWE, GeneralDecryptResult, ResolvedKey } from '../../types';
 /**
  * Interface for General JWE Decryption dynamic key resolution. No token components have been
  * verified at the time of this function call.
  */
-export interface GeneralDecryptGetKey extends types.GetKeyFunction<types.JWEHeaderParameters, types.FlattenedJWE> {
+export interface GeneralDecryptGetKey extends GetKeyFunction<JWEHeaderParameters, FlattenedJWE> {
 }
 /**
  * Decrypts a General JWE.
  *
- * This function is exported (as a named export) from the main `'jose'` module entry point as well
- * as from its subpath export `'jose/jwe/general/decrypt'`.
- *
- * > [!NOTE]\
- * > The function iterates over the `recipients` array in the General JWE and returns the decryption
- * > result of the first recipient entry that can be successfully decrypted. The result only contains
- * > the plaintext and headers of that successfully decrypted recipient entry. Other recipient entries
- * > in the General JWE are not validated, and their headers are not included in the returned result.
- * > Recipients of a General JWE should only rely on the returned (decrypted) data.
- *
  * @param jwe General JWE.
  * @param key Private Key or Secret to decrypt the JWE with. See
  *   {@link https://github.com/panva/jose/issues/210#jwe-alg Algorithm Key Requirements}.
  * @param options JWE Decryption options.
  */
-export declare function generalDecrypt(jwe: types.GeneralJWE, key: types.CryptoKey | types.KeyObject | types.JWK | Uint8Array, options?: types.DecryptOptions): Promise<types.GeneralDecryptResult>;
+export declare function generalDecrypt(jwe: GeneralJWE, key: KeyLike | Uint8Array, options?: DecryptOptions): Promise<GeneralDecryptResult>;
 /**
  * @param jwe General JWE.
  * @param getKey Function resolving Private Key or Secret to decrypt the JWE with. See
  *   {@link https://github.com/panva/jose/issues/210#jwe-alg Algorithm Key Requirements}.
  * @param options JWE Decryption options.
  */
-export declare function generalDecrypt(jwe: types.GeneralJWE, getKey: GeneralDecryptGetKey, options?: types.DecryptOptions): Promise<types.GeneralDecryptResult & types.ResolvedKey>;
+export declare function generalDecrypt<T extends KeyLike = KeyLike>(jwe: GeneralJWE, getKey: GeneralDecryptGetKey, options?: DecryptOptions): Promise<GeneralDecryptResult & ResolvedKey<T>>;