@psnext/slingcli 3.0.20260820-2 → 3.1.20260904-1

package/node_modules/jose/dist/types/key/generate_secret.d.ts

@@ -1,18 +1,12 @@
-import type * as types from '../types.d.ts';
+import type * as t from '../types.d.ts';
 /**
  * JWA Algorithm Identifiers that {@link generateSecret} is able to generate a secret for, subject to
  * runtime support.
  */
 export type GenerateSecretAlgorithm = 'HS256' | 'HS384' | 'HS512' | 'A128CBC-HS256' | 'A192CBC-HS384' | 'A256CBC-HS512' | 'A128KW' | 'A192KW' | 'A256KW' | 'A128GCMKW' | 'A192GCMKW' | 'A256GCMKW' | 'A128GCM' | 'A192GCM' | 'A256GCM' | (string & {});
-/**
- * Resolves what {@link generateSecret} returns for a given JWA Algorithm Identifier. The
- * AES_CBC_HMAC_SHA2 content encryption algorithms have no {@link !CryptoKey} representation, so they
- * yield a {@link !Uint8Array}; every other supported identifier yields a
- * {@link types.CryptoKey CryptoKey}. When the identifier is not statically known this resolves to
- * their union.
- */
-export type GeneratedSecret<Alg extends string> = Alg extends 'A128CBC-HS256' | 'A192CBC-HS384' | 'A256CBC-HS512' ? Uint8Array : string extends Alg ? types.CryptoKey | Uint8Array : types.CryptoKey;
-/** Secret generation function options. */
+/** Maps a JWA algorithm identifier to the value returned by {@link generateSecret}. */
+export type GeneratedSecret<Alg extends string> = Alg extends 'A128CBC-HS256' | 'A192CBC-HS384' | 'A256CBC-HS512' ? Uint8Array : string extends Alg ? t.CryptoKey | Uint8Array : t.CryptoKey;
+/** Secret generation options. */
 export interface GenerateSecretOptions {
     /**
      * The value to use as {@link !SubtleCrypto.generateKey} `extractable` argument. Default is false.
@@ -32,6 +26,5 @@ export interface GenerateSecretOptions {
  *
  * @param alg JWA Algorithm Identifier to be used with the generated secret. See
  *   {@link https://github.com/panva/jose/issues/210 Algorithm Key Requirements}.
- * @param options Additional options passed down to the secret generation.
  */
 export declare function generateSecret<Alg extends GenerateSecretAlgorithm>(alg: Alg, options?: GenerateSecretOptions): Promise<GeneratedSecret<Alg>>;

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

@@ -1,17 +1,11 @@
-import type * as types from '../types.d.ts';
-/**
- * Resolves what {@link importJWK} returns for a given JWK type. The "kty" (Key Type) Parameter fully
- * determines the outcome at runtime: `"oct"` yields a {@link !Uint8Array} secret, every other
- * supported key type yields a {@link types.CryptoKey CryptoKey}. When "kty" is not statically known
- * — the usual case for a JWK parsed from JSON, or for a value typed as {@link types.JWK JWK} — this
- * resolves to their union.
- */
-export type ImportedJWK<JWKType extends types.JWK> = JWKType extends {
+import type * as t from '../types.d.ts';
+/** Maps a JWK key type to the value returned by {@link importJWK}. */
+export type ImportedJWK<JWKType extends t.JWK> = JWKType extends {
     kty: 'oct';
 } ? Uint8Array : JWKType extends {
     kty: 'AKP' | 'EC' | 'OKP' | 'RSA';
-} ? types.CryptoKey : types.CryptoKey | Uint8Array;
-/** Key Import Function options. */
+} ? t.CryptoKey : t.CryptoKey | Uint8Array;
+/** Key import options. */
 export interface KeyImportOptions {
     /**
      * The value to use as {@link !SubtleCrypto.importKey} `extractable` argument. Default is false for
@@ -30,7 +24,7 @@ export interface KeyImportOptions {
  * @param alg JSON Web Algorithm identifier to be used with the imported key. See
  *   {@link https://github.com/panva/jose/issues/210 Algorithm Key Requirements}.
  */
-export declare function importSPKI(spki: string, alg: string, options?: KeyImportOptions): Promise<types.CryptoKey>;
+export declare function importSPKI(spki: string, alg: string, options?: KeyImportOptions): Promise<t.CryptoKey>;
 /**
  * Imports the SPKI from an X.509 string certificate as a {@link !CryptoKey}.
  *
@@ -42,7 +36,7 @@ export declare function importSPKI(spki: string, alg: string, options?: KeyImpor
  * @param alg JSON Web Algorithm identifier to be used with the imported key. See
  *   {@link https://github.com/panva/jose/issues/210 Algorithm Key Requirements}.
  */
-export declare function importX509(x509: string, alg: string, options?: KeyImportOptions): Promise<types.CryptoKey>;
+export declare function importX509(x509: string, alg: string, options?: KeyImportOptions): Promise<t.CryptoKey>;
 /**
  * Imports a PEM-encoded PKCS#8 string as a {@link !CryptoKey}.
  *
@@ -54,10 +48,9 @@ export declare function importX509(x509: string, alg: string, options?: KeyImpor
  * @param alg JSON Web Algorithm identifier to be used with the imported key. See
  *   {@link https://github.com/panva/jose/issues/210 Algorithm Key Requirements}.
  */
-export declare function importPKCS8(pkcs8: string, alg: string, options?: KeyImportOptions): Promise<types.CryptoKey>;
+export declare function importPKCS8(pkcs8: string, alg: string, options?: KeyImportOptions): Promise<t.CryptoKey>;
 /**
- * Imports a JWK to a {@link !CryptoKey}. Either the JWK "alg" (Algorithm) Parameter, or the optional
- * "alg" argument, must be present for asymmetric JSON Web Key imports.
+ * Imports a JWK as a {@link !CryptoKey} or {@link !Uint8Array}.
  *
  * > Note: The JSON Web Key parameters "key_ops" and "ext" are also used in the {@link !CryptoKey} import
  * > process.
@@ -70,4 +63,4 @@ export declare function importPKCS8(pkcs8: string, alg: string, options?: KeyImp
  *   property on the JWK. See
  *   {@link https://github.com/panva/jose/issues/210 Algorithm Key Requirements}.
  */
-export declare function importJWK<JWKType extends types.JWK>(jwk: JWKType, alg?: string, options?: KeyImportOptions): Promise<ImportedJWK<JWKType>>;
+export declare function importJWK<JWKType extends t.JWK>(jwk: JWKType, alg?: string, options?: KeyImportOptions): Promise<ImportedJWK<JWKType>>;

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

@@ -92,7 +92,7 @@ export type JWKParameters = {
   kid?: string
 }
 
-/** Convenience interface for Public OKP JSON Web Keys */
+/** Convenience interface for public OKP JSON Web Keys. */
 export interface JWK_OKP_Public extends JWKParameters {
   /** OKP JWK "crv" (The Subtype of Key Pair) Parameter */
   crv: string
@@ -100,13 +100,13 @@ export interface JWK_OKP_Public extends JWKParameters {
   x: string
 }
 
-/** Convenience interface for Private OKP JSON Web Keys */
+/** Convenience interface for private OKP JSON Web Keys. */
 export interface JWK_OKP_Private extends JWK_OKP_Public {
   /** OKP JWK "d" (The Private Key) Parameter */
   d: string
 }
 
-/** Convenience interface for Public AKP JSON Web Keys */
+/** Convenience interface for public AKP JSON Web Keys. */
 export interface JWK_AKP_Public extends JWKParameters {
   /** JWK "alg" (Algorithm) Parameter */
   alg: string
@@ -114,13 +114,13 @@ export interface JWK_AKP_Public extends JWKParameters {
   pub: string
 }
 
-/** Convenience interface for Private AKP JSON Web Keys */
+/** Convenience interface for private AKP JSON Web Keys. */
 export interface JWK_AKP_Private extends JWK_AKP_Public {
   /** AKP JWK "priv" (The Private Key) Parameter */
   priv: string
 }
 
-/** Convenience interface for Public EC JSON Web Keys */
+/** Convenience interface for public EC JSON Web Keys. */
 export interface JWK_EC_Public extends JWKParameters {
   /** EC JWK "crv" (Curve) Parameter */
   crv: string
@@ -130,13 +130,13 @@ export interface JWK_EC_Public extends JWKParameters {
   y: string
 }
 
-/** Convenience interface for Private EC JSON Web Keys */
+/** Convenience interface for private EC JSON Web Keys. */
 export interface JWK_EC_Private extends JWK_EC_Public {
   /** EC JWK "d" (ECC Private Key) Parameter */
   d: string
 }
 
-/** Convenience interface for Public RSA JSON Web Keys */
+/** Convenience interface for public RSA JSON Web Keys. */
 export interface JWK_RSA_Public extends JWKParameters {
   /** RSA JWK "e" (Exponent) Parameter */
   e: string
@@ -144,7 +144,7 @@ export interface JWK_RSA_Public extends JWKParameters {
   n: string
 }
 
-/** Convenience interface for Private RSA JSON Web Keys */
+/** Convenience interface for private RSA JSON Web Keys. */
 export interface JWK_RSA_Private extends JWK_RSA_Public {
   /** RSA JWK "d" (Private Exponent) Parameter */
   d: string
@@ -160,7 +160,7 @@ export interface JWK_RSA_Private extends JWK_RSA_Public {
   qi: string
 }
 
-/** Convenience interface for oct JSON Web Keys */
+/** Convenience interface for "oct" JSON Web Keys. */
 export interface JWK_oct extends JWKParameters {
   /** Oct JWK "k" (Key Value) Parameter */
   k: string
@@ -234,11 +234,7 @@ export type JWK = {
   pub?: string
   /** AKP JWK "priv" (Private key) Parameter */
   priv?: string
-  /**
-   * RSA JWK "oth" (Other Primes Info) Parameter
-   *
-   * > Note: Multi-prime RSA keys are not supported; importing a JWK with this parameter present throws.
-   */
+  /** RSA JWK "oth" (Other Primes Info) Parameter */
   oth?: Array<{
     /** The Factor CRT Exponent */
     d?: string
@@ -249,11 +245,7 @@ export type JWK = {
   }>
 }
 
-/**
- * Discriminated union of the JSON Web Key shapes supported by this module. Unlike {@link JWK}, each
- * member requires and fixes the "kty" (Key Type) Parameter to its key type so that the union can be
- * narrowed on it.
- */
+/** Discriminated union of the supported JSON Web Key shapes. */
 // The "kty" is intersected into each arm one at a time rather than distributed over a parenthesised
 // union - `X & (A | B)` means the same thing, but typedoc renders it without the parentheses, which
 // reads as though the second arm carried no "kty" at all.
@@ -271,28 +263,18 @@ export type AnyJWK =
 /** Key or secret input accepted by all sign, verify, encrypt, and decrypt operations. */
 export type KeyInput = CryptoKey | KeyObject | JWK | Uint8Array
 
-export interface GenericGetKeyFunction<IProtectedHeader, IToken, ReturnKeyTypes> {
+/** Dynamic key resolver for consuming operations. */
+export interface GetKeyFunction<IProtectedHeader, IToken, KeyTypes extends KeyInput = KeyInput> {
   /**
    * Dynamic key resolution function. No token components have been verified at the time of this
    * function call. If a suitable key for the token cannot be matched, throw an error instead.
    *
-   * @param protectedHeader JWE or JWS Protected Header.
    * @param token The consumed JWE or JWS token.
    */
-  (protectedHeader: IProtectedHeader, token: IToken): Promise<ReturnKeyTypes> | ReturnKeyTypes
+  (protectedHeader: IProtectedHeader, token: IToken): Promise<KeyTypes> | KeyTypes
 }
 
-/** Interface for consuming operations dynamic key resolution. */
-export interface GetKeyFunction<
-  IProtectedHeader,
-  IToken,
-  KeyTypes extends KeyInput = KeyInput,
-> extends GenericGetKeyFunction<IProtectedHeader, IToken, KeyTypes> {}
-
-/**
- * Flattened JWS definition for verify function inputs, allows payload as {@link !Uint8Array} for
- * detached signature validation.
- */
+/** Flattened JWS verification input. */
 export interface FlattenedJWSInput {
   /**
    * The "header" member MUST be present and contain the value JWS Unprotected Header when the JWS
@@ -319,10 +301,7 @@ export interface FlattenedJWSInput {
   signature: string
 }
 
-/**
- * General JWS definition for verify function inputs, allows payload as {@link !Uint8Array} for
- * detached signature validation.
- */
+/** General JWS verification input. */
 export interface GeneralJWSInput {
   /**
    * The "payload" member MUST be present and contain the value BASE64URL(JWS Payload). When when
@@ -338,25 +317,19 @@ export interface GeneralJWSInput {
   signatures: Omit<FlattenedJWSInput, 'payload'>[]
 }
 
-/**
- * Flattened JWS JSON Serialization Syntax token. Payload is returned as an empty string when JWS
- * Unencoded Payload ({@link https://www.rfc-editor.org/info/rfc7797/ RFC7797}) is used.
- */
+/** Flattened JWS JSON Serialization token. */
 export interface FlattenedJWS extends Partial<FlattenedJWSInput> {
   payload: string
   signature: string
 }
 
-/**
- * General JWS JSON Serialization Syntax token. Payload is returned as an empty string when JWS
- * Unencoded Payload ({@link https://www.rfc-editor.org/info/rfc7797/ RFC7797}) is used.
- */
+/** General JWS JSON Serialization token. */
 export interface GeneralJWS {
   payload: string
   signatures: Omit<FlattenedJWSInput, 'payload'>[]
 }
 
-/** Header Parameters common to JWE and JWS */
+/** Header Parameters common to JWE and JWS. */
 export interface JoseHeaderParameters {
   /** "kid" (Key ID) Header Parameter */
   kid?: string
@@ -386,7 +359,7 @@ export interface JoseHeaderParameters {
   cty?: string
 }
 
-/** Recognized JWS Header Parameters, any other Header Members may also be present. */
+/** Recognized JWS Header Parameters; additional members may also be present. */
 export interface JWSHeaderParameters extends JoseHeaderParameters {
   /** JWS "alg" (Algorithm) Header Parameter */
   alg?: JWSAlgorithm
@@ -441,7 +414,7 @@ export interface JWEKeyManagementHeaderParameters {
   epk?: CryptoKey | KeyObject
 }
 
-/** Flattened JWE JSON Serialization Syntax token. */
+/** Flattened JWE JSON Serialization token. */
 export interface FlattenedJWE {
   /**
    * The "aad" member MUST be present and contain the value BASE64URL(JWE AAD)) when the JWE AAD
@@ -495,12 +468,12 @@ export interface FlattenedJWE {
   unprotected?: JWEHeaderParameters
 }
 
-/** General JWE JSON Serialization Syntax token. */
+/** General JWE JSON Serialization token. */
 export interface GeneralJWE extends Omit<FlattenedJWE, 'encrypted_key' | 'header'> {
   recipients: Pick<FlattenedJWE, 'encrypted_key' | 'header'>[]
 }
 
-/** Recognized JWE Header Parameters, any other Header members may also be present. */
+/** Recognized JWE Header Parameters; additional members may also be present. */
 export interface JWEHeaderParameters extends JoseHeaderParameters {
   /** JWE "alg" (Algorithm) Header Parameter */
   alg?: JWEKeyManagementAlgorithm
@@ -522,7 +495,7 @@ export interface JWEHeaderParameters extends JoseHeaderParameters {
   [propName: string]: unknown
 }
 
-/** Shared Interface with a "crit" property for all sign, verify, encrypt and decrypt operations. */
+/** Shared "crit" option for signing, verification, encryption, and decryption. */
 export interface CritOption {
   /**
    * An object with keys representing recognized "crit" (Critical) Header Parameter names. The value
@@ -559,7 +532,8 @@ export interface DecryptOptions extends CritOption {
   /**
    * (PBES2 Key Management Algorithms only) Maximum allowed "p2c" (PBES2 Count) Header Parameter
    * value. The PBKDF2 iteration count defines the algorithm's computational expense. By default
-   * this value is set to 10000.
+   * this value is set to 10000. The value must be a positive safe integer or `Infinity`. Set it to
+   * `Infinity` to disable the limit.
    */
   maxPBES2Count?: number
 
@@ -644,7 +618,7 @@ export interface VerifyOptions extends CritOption {
 /** JWS Signing options. */
 export interface SignOptions extends CritOption {}
 
-/** Recognized JWT Claims Set members, any other members may also be present. */
+/** Recognized JWT Claims Set members; additional members may also be present. */
 export interface JWTPayload {
   /** JWT Issuer */
   iss?: string
@@ -671,7 +645,7 @@ export interface JWTPayload {
   [propName: string]: unknown
 }
 
-/** Flattened JWE JSON Serialization Syntax decryption result */
+/** Flattened JWE JSON Serialization decryption result. */
 export interface FlattenedDecryptResult {
   /** JWE AAD. */
   additionalAuthenticatedData?: Uint8Array
@@ -689,10 +663,10 @@ export interface FlattenedDecryptResult {
   unprotectedHeader?: JWEHeaderParameters
 }
 
-/** General JWE JSON Serialization Syntax decryption result */
+/** General JWE JSON Serialization decryption result. */
 export interface GeneralDecryptResult extends FlattenedDecryptResult {}
 
-/** Compact JWE decryption result */
+/** Compact JWE decryption result. */
 export interface CompactDecryptResult {
   /** Plaintext. */
   plaintext: Uint8Array
@@ -701,7 +675,7 @@ export interface CompactDecryptResult {
   protectedHeader: CompactJWEHeaderParameters
 }
 
-/** Flattened JWS JSON Serialization Syntax verification result */
+/** Flattened JWS JSON Serialization verification result. */
 export interface FlattenedVerifyResult {
   /** JWS Payload. */
   payload: Uint8Array
@@ -713,10 +687,10 @@ export interface FlattenedVerifyResult {
   unprotectedHeader?: JWSHeaderParameters
 }
 
-/** General JWS JSON Serialization Syntax verification result */
+/** General JWS JSON Serialization verification result. */
 export interface GeneralVerifyResult extends FlattenedVerifyResult {}
 
-/** Compact JWS verification result */
+/** Compact JWS verification result. */
 export interface CompactVerifyResult {
   /** JWS Payload. */
   payload: Uint8Array
@@ -725,7 +699,7 @@ export interface CompactVerifyResult {
   protectedHeader: CompactJWSHeaderParameters
 }
 
-/** Signed JSON Web Token (JWT) verification result */
+/** Signed JSON Web Token (JWT) verification result. */
 export interface JWTVerifyResult<PayloadType = JWTPayload> {
   /** JWT Claims Set. */
   payload: PayloadType &
@@ -736,7 +710,7 @@ export interface JWTVerifyResult<PayloadType = JWTPayload> {
   protectedHeader: JWTHeaderParameters
 }
 
-/** Encrypted JSON Web Token (JWT) decryption result */
+/** Encrypted JSON Web Token (JWT) decryption result. */
 export interface JWTDecryptResult<PayloadType = JWTPayload> {
   /** JWT Claims Set. */
   payload: PayloadType &
@@ -747,60 +721,46 @@ export interface JWTDecryptResult<PayloadType = JWTPayload> {
   protectedHeader: CompactJWEHeaderParameters
 }
 
-/** When key resolver functions are used this becomes part of successful resolves */
+/** Key resolver result metadata. */
 export interface ResolvedKey<KeyType extends CryptoKey | Uint8Array = CryptoKey | Uint8Array> {
   /** Key resolved from the key resolver function. */
   key: KeyType
 }
 
-/** Recognized Compact JWS Header Parameters, any other Header Members may also be present. */
+/** Recognized Compact JWS Header Parameters; additional members may also be present. */
 export interface CompactJWSHeaderParameters extends JWSHeaderParameters {
   alg: JWSAlgorithm
 }
 
-/** Recognized Signed JWT Header Parameters, any other Header Members may also be present. */
+/** Recognized signed JWT Header Parameters; additional members may also be present. */
 export interface JWTHeaderParameters extends CompactJWSHeaderParameters {
   b64?: boolean
 }
 
-/** Recognized Compact JWE Header Parameters, any other Header Members may also be present. */
+/** Recognized Compact JWE Header Parameters; additional members may also be present. */
 export interface CompactJWEHeaderParameters extends JWEHeaderParameters {
   alg: JWEKeyManagementAlgorithm
   enc: JWEContentEncryptionAlgorithm
 }
 
-/** JSON Web Key Set */
+/** JSON Web Key Set. */
 export interface JSONWebKeySet {
   keys: JWK[]
 }
 
-/**
- * {@link !KeyObject} is a representation of a key/secret available in the Node.js runtime. You may
- * use the Node.js runtime APIs {@link !createPublicKey}, {@link !createPrivateKey}, and
- * {@link !createSecretKey} to obtain a {@link !KeyObject} from your existing key material.
- */
+/** Node.js {@link !KeyObject} representation accepted as key input. */
 export interface KeyObject {
   type: string
 }
 
-/**
- * {@link !CryptoKey} is a representation of a key/secret available in all supported runtimes. In
- * addition to the {@link key/import Key Import Functions} you may use the
- * {@link !SubtleCrypto.importKey} API to obtain a {@link !CryptoKey} from your existing key
- * material.
- */
+/** Web Cryptography API {@link !CryptoKey} representation accepted as key input. */
 export type CryptoKey = typeof globalThis extends {
   crypto: { subtle: { generateKey(...args: any[]): Promise<infer R> } }
 }
   ? Extract<R, { type: string }>
   : CryptoKeyStructuralFallback
 
-/**
- * Used as {@link CryptoKey} when the host runtime's `crypto` global is not exposed on `typeof
- * globalThis`, including when it is absent from ambient types or declared with `const` or `let`. It
- * remains structurally compatible with host {@link !CryptoKey} declarations so values flow freely to
- * and from {@link !SubtleCrypto} APIs.
- */
+/** Structural fallback used when a host {@link !CryptoKey} type cannot be inferred. */
 export interface CryptoKeyStructuralFallback {
   readonly algorithm: { name: string }
   readonly extractable: boolean
@@ -808,7 +768,7 @@ export interface CryptoKeyStructuralFallback {
   readonly usages: string[]
 }
 
-/** Generic interface for JWT producing classes. */
+/** Shared fluent API for JWT-producing classes. */
 export interface ProduceJWT {
   /**
    * Set the "iss" (Issuer) Claim.

package/node_modules/jose/dist/types/util/base64url.d.ts

@@ -1,5 +1,5 @@
 /**
- * Decodes a Base64URL encoded input.
+ * Decodes a base64url-encoded input.
  *
  * @param input Base64URL encoded input, as a string or its UTF-8 bytes.
  * @returns The decoded bytes.
@@ -8,7 +8,7 @@
  */
 export declare function decode(input: Uint8Array | string): Uint8Array;
 /**
- * Encodes an input using Base64URL with no padding.
+ * Encodes input using unpadded base64url.
  *
  * @param input Input to encode, as a string or as bytes. Strings are encoded as UTF-8 first.
  * @returns The Base64URL encoded, unpadded, representation of the input.

package/node_modules/jose/dist/types/util/decode_jwt.d.ts

@@ -1,10 +1,3 @@
-import type * as types from '../types.d.ts';
-/**
- * Decodes a signed JSON Web Token payload. This does not validate the JWT Claims Set types or
- * values. This does not validate the JWS Signature. For a proper Signed JWT Claims Set validation
- * and JWS signature verification use `jose.jwtVerify()`. For an encrypted JWT Claims Set validation
- * and JWE decryption use `jose.jwtDecrypt()`.
- *
- * @param jwt JWT token in compact JWS serialization.
- */
-export declare function decodeJwt<PayloadType = types.JWTPayload>(jwt: string): PayloadType & types.JWTPayload & ([PayloadType] extends [object] ? unknown : unknown extends PayloadType ? unknown : never);
+import type * as t from '../types.d.ts';
+/** Decodes the Claims Set of a JWS-formatted JSON Web Token without verifying the signature. */
+export declare function decodeJwt<PayloadType = t.JWTPayload>(jwt: string): PayloadType & t.JWTPayload & ([PayloadType] extends [object] ? unknown : unknown extends PayloadType ? unknown : never);

package/node_modules/jose/dist/types/util/decode_protected_header.d.ts

@@ -1,8 +1,8 @@
-import type * as types from '../types.d.ts';
-/** JWE and JWS Header Parameters */
-export type ProtectedHeaderParameters = types.JWSHeaderParameters & types.JWEHeaderParameters;
+import type * as t from '../types.d.ts';
+/** JWE and JWS Header Parameters. */
+export type ProtectedHeaderParameters = t.JWSHeaderParameters & t.JWEHeaderParameters;
 /**
- * Decodes the Protected Header of a JWE/JWS/JWT token utilizing any JOSE serialization.
+ * Decodes the Protected Header of a JWE, JWS, or JWT in any JOSE serialization.
  *
  * @param token JWE/JWS/JWT token in any JOSE serialization.
  */