@psnext/slingcli 3.0.20260827-1 → 3.3.20260911-1

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

@@ -1,16 +1,16 @@
 /**
- * Decodes a Base64URL encoded input.
+ * Decodes base64url text or its UTF-8 bytes.
  *
- * @param input Base64URL encoded input, as a string or its UTF-8 bytes.
+ * @param input Base64url-encoded string or its UTF-8 bytes.
  * @returns The decoded bytes.
- * @throws {!TypeError} When the input is not correctly Base64URL encoded. Standard Base64 input
- *   (i.e. containing `+` or `/`) is rejected.
+ * @throws {TypeError} If the input is not valid base64url. Standard Base64 `+` and `/` are
+ *   rejected.
  */
 export declare function decode(input: Uint8Array | string): Uint8Array;
 /**
- * Encodes an input using Base64URL with no padding.
+ * Encodes unpadded base64url; strings are first encoded as UTF-8.
  *
- * @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.
+ * @param input Bytes or a string to encode. Strings are first encoded as UTF-8.
+ * @returns The unpadded base64url representation of the input.
  */
 export declare function encode(input: Uint8Array | string): string;

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

@@ -1,10 +1,8 @@
-import type * as types from '../types.d.ts';
+import type * as t 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()`.
+ * Decodes the Claims Set of a JWT in Compact JWS serialization without checking its signature or
+ * validating claim types and values.
  *
- * @param jwt JWT token in compact JWS serialization.
+ * @returns The parsed JWT Claims Set.
  */
-export declare function decodeJwt<PayloadType = types.JWTPayload>(jwt: string): PayloadType & types.JWTPayload & ([PayloadType] extends [object] ? unknown : unknown extends PayloadType ? unknown : never);
+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,9 +1,10 @@
-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 returned by {@link decodeProtectedHeader}. */
+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 without authenticating the token.
  *
- * @param token JWE/JWS/JWT token in any JOSE serialization.
+ * @param token Compact token or JSON serialization object with a `protected` member.
+ * @returns The parsed Protected Header.
  */
 export declare function decodeProtectedHeader(token: string | object): ProtectedHeaderParameters;

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

@@ -1,193 +1,155 @@
-import type * as types from '../types.d.ts';
-/**
- * Every stable error code used by this module. {@link AnyJOSEError} pairs each subclass with the one
- * it is thrown with, making that union a discriminated one.
- */
+import type * as t from '../types.d.ts';
+/** Stable error codes used by this module. */
 export type JOSEErrorCode = 'ERR_JOSE_ALG_NOT_ALLOWED' | 'ERR_JOSE_GENERIC' | 'ERR_JOSE_NOT_SUPPORTED' | 'ERR_JWE_DECRYPTION_FAILED' | 'ERR_JWE_INVALID' | 'ERR_JWK_INVALID' | 'ERR_JWKS_INVALID' | 'ERR_JWKS_MULTIPLE_MATCHING_KEYS' | 'ERR_JWKS_NO_MATCHING_KEY' | 'ERR_JWKS_TIMEOUT' | 'ERR_JWS_INVALID' | 'ERR_JWS_SIGNATURE_VERIFICATION_FAILED' | 'ERR_JWT_CLAIM_VALIDATION_FAILED' | 'ERR_JWT_EXPIRED' | 'ERR_JWT_INVALID';
-/**
- * The shape shared by the two errors thrown during JWT Claims Set validation.
- *
- * > Note: {@link JWTExpired} does not extend {@link JWTClaimValidationFailed}, so `instanceof
- * > JWTClaimValidationFailed` is `false` for an expired JWT. Use {@link JWTClaimValidationError} or
- * > the {@link JOSEError.code code} discriminant to handle both.
- */
+/** Shared details of JWT claim or header validation failures. */
 export interface JWTClaimValidationFailure {
-    /** The Claim for which the validation failed. */
+    /** Claim or header that failed validation. */
     claim: string;
     /** Reason code for the validation failure. */
     reason: JWTClaimValidationReason;
-    /** The parsed JWT Claims Set (aka payload). */
-    payload: types.JWTPayload;
+    /** The parsed JWT Claims Set; validation of other claims may be incomplete. */
+    payload: t.JWTPayload;
 }
 /** Reason codes produced by JWT Claims Set validation. */
 export type JWTClaimValidationReason = 'check_failed' | 'invalid' | 'mismatch' | 'missing' | 'unspecified' | (string & {});
-/** A generic Error that all other JOSE specific Error subclasses extend. */
+/** Base class for JOSE errors. */
 export declare class JOSEError extends Error {
-    /** A unique error code for the particular error subclass. */
+    /** Stable code identifying the error class. */
     static code: JOSEErrorCode | (string & {});
-    /**
-     * A unique error code for {@link JOSEError}. Each subclass sets its own; see {@link AnyJOSEError}
-     * to switch over them as a discriminated union.
-     */
+    /** Stable code identifying the error class. Use {@link AnyJOSEError} to narrow subclasses by code. */
     code: JOSEErrorCode | (string & {});
     constructor(message?: string, options?: {
         cause?: unknown;
     });
 }
-/** An error subclass thrown when a JWT Claim Set member validation fails. */
+/**
+ * Thrown when JWT claim or header validation fails. Expiration is reported separately as
+ * {@link JWTExpired}.
+ */
 export declare class JWTClaimValidationFailed extends JOSEError implements JWTClaimValidationFailure {
     static code: JOSEErrorCode | (string & {});
-    /** A unique error code for {@link JWTClaimValidationFailed}. */
     code: JOSEErrorCode | (string & {});
-    /** The {@link JWTClaimValidationFailure} carried by every instance of this error. */
+    /** The {@link JWTClaimValidationFailure} details carried by this error. */
     cause: JWTClaimValidationFailure;
-    /** The Claim for which the validation failed. */
+    /** Claim or header that failed validation. */
     claim: string;
     /** Reason code for the validation failure. */
     reason: JWTClaimValidationReason;
     /**
-     * The parsed JWT Claims Set (aka payload). Other JWT claims may or may not have been verified at
-     * this point. The JSON Web Signature (JWS) or a JSON Web Encryption (JWE) structures' integrity
-     * has however been verified. Claims Set verification happens after the JWS Signature or JWE
-     * Decryption processes.
+     * The parsed JWT Claims Set; validation of other claims may be incomplete. With
+     * {@link jwt/verify.jwtVerify jwtVerify} and {@link jwt/decrypt.jwtDecrypt jwtDecrypt}, token
+     * authentication precedes claim validation. {@link jwt/unsecured.UnsecuredJWT.decode} does not
+     * authenticate tokens.
      */
-    payload: types.JWTPayload;
-    constructor(message: string, payload: types.JWTPayload, claim?: string, reason?: JWTClaimValidationReason);
+    payload: t.JWTPayload;
+    constructor(message: string, payload: t.JWTPayload, claim?: string, reason?: JWTClaimValidationReason);
 }
-/** An error subclass thrown when a JWT is expired. */
+/** Thrown when a JWT has expired or exceeds the configured maximum token age. */
 export declare class JWTExpired extends JOSEError implements JWTClaimValidationFailure {
     static code: JOSEErrorCode | (string & {});
-    /** A unique error code for {@link JWTExpired}. */
     code: JOSEErrorCode | (string & {});
-    /** The {@link JWTClaimValidationFailure} carried by every instance of this error. */
+    /** The {@link JWTClaimValidationFailure} details carried by this error. */
     cause: JWTClaimValidationFailure;
-    /** The Claim for which the validation failed. */
+    /** Claim or header that failed validation. */
     claim: string;
     /** Reason code for the validation failure. */
     reason: JWTClaimValidationReason;
     /**
-     * The parsed JWT Claims Set (aka payload). Other JWT claims may or may not have been verified at
-     * this point. The JSON Web Signature (JWS) or a JSON Web Encryption (JWE) structures' integrity
-     * has however been verified. Claims Set verification happens after the JWS Signature or JWE
-     * Decryption processes.
+     * The parsed JWT Claims Set; validation of other claims may be incomplete. With
+     * {@link jwt/verify.jwtVerify jwtVerify} and {@link jwt/decrypt.jwtDecrypt jwtDecrypt}, token
+     * authentication precedes claim validation. {@link jwt/unsecured.UnsecuredJWT.decode} does not
+     * authenticate tokens.
      */
-    payload: types.JWTPayload;
-    constructor(message: string, payload: types.JWTPayload, claim?: string, reason?: JWTClaimValidationReason);
+    payload: t.JWTPayload;
+    constructor(message: string, payload: t.JWTPayload, claim?: string, reason?: JWTClaimValidationReason);
 }
-/** An error subclass thrown when a JOSE Algorithm is not allowed per developer preference. */
+/** Thrown when an algorithm is disallowed by configuration. */
 export declare class JOSEAlgNotAllowed extends JOSEError {
     static code: JOSEErrorCode | (string & {});
-    /** A unique error code for {@link JOSEAlgNotAllowed}. */
     code: JOSEErrorCode | (string & {});
 }
-/**
- * An error subclass thrown when a particular feature or algorithm is not supported by this
- * implementation or JOSE in general.
- */
+/** Thrown when a feature or algorithm is unsupported. */
 export declare class JOSENotSupported extends JOSEError {
     static code: JOSEErrorCode | (string & {});
-    /** A unique error code for {@link JOSENotSupported}. */
     code: JOSEErrorCode | (string & {});
 }
-/** An error subclass thrown when a JWE ciphertext decryption fails. */
+/** Thrown when JWE ciphertext decryption or authentication fails. */
 export declare class JWEDecryptionFailed extends JOSEError {
     static code: JOSEErrorCode | (string & {});
-    /** A unique error code for {@link JWEDecryptionFailed}. */
     code: JOSEErrorCode | (string & {});
     constructor(message?: string, options?: {
         cause?: unknown;
     });
 }
-/** An error subclass thrown when a JWE is invalid. */
+/** Thrown when a JWE is invalid. */
 export declare class JWEInvalid extends JOSEError {
     static code: JOSEErrorCode | (string & {});
-    /** A unique error code for {@link JWEInvalid}. */
     code: JOSEErrorCode | (string & {});
 }
-/** An error subclass thrown when a JWS is invalid. */
+/** Thrown when a JWS is invalid. */
 export declare class JWSInvalid extends JOSEError {
     static code: JOSEErrorCode | (string & {});
-    /** A unique error code for {@link JWSInvalid}. */
     code: JOSEErrorCode | (string & {});
 }
-/** An error subclass thrown when a JWT is invalid. */
+/** Thrown when a JWT is invalid. */
 export declare class JWTInvalid extends JOSEError {
     static code: JOSEErrorCode | (string & {});
-    /** A unique error code for {@link JWTInvalid}. */
     code: JOSEErrorCode | (string & {});
 }
-/** An error subclass thrown when a JWK is invalid. */
+/** Thrown when a JWK is invalid. */
 export declare class JWKInvalid extends JOSEError {
     static code: JOSEErrorCode | (string & {});
-    /** A unique error code for {@link JWKInvalid}. */
     code: JOSEErrorCode | (string & {});
 }
-/** An error subclass thrown when a JWKS is invalid. */
+/** Thrown when a JWKS is invalid. */
 export declare class JWKSInvalid extends JOSEError {
     static code: JOSEErrorCode | (string & {});
-    /** A unique error code for {@link JWKSInvalid}. */
     code: JOSEErrorCode | (string & {});
 }
-/** An error subclass thrown when no keys match from a JWKS. */
+/** Thrown when no keys match in a JWKS. */
 export declare class JWKSNoMatchingKey extends JOSEError {
     static code: JOSEErrorCode | (string & {});
-    /** A unique error code for {@link JWKSNoMatchingKey}. */
     code: JOSEErrorCode | (string & {});
     constructor(message?: string, options?: {
         cause?: unknown;
     });
 }
-/** An error subclass thrown when multiple keys match from a JWKS. */
+/** Thrown when multiple keys match in a JWKS. */
 export declare class JWKSMultipleMatchingKeys extends JOSEError {
     /**
-     * Iterates the public keys that matched the JWS JOSE Header, so that verification can be
-     * attempted with each in turn. See the {@link jwks/remote.createRemoteJWKSet createRemoteJWKSet}
-     * and {@link jwks/local.createLocalJWKSet createLocalJWKSet} examples. Instances thrown by this
-     * module always iterate the matched keys; an instance constructed by other code iterates
-     * nothing.
+     * Yields public keys matching the JWS Header so verification can be attempted with each. See the
+     * {@link jwks/remote.createRemoteJWKSet createRemoteJWKSet} and
+     * {@link jwks/local.createLocalJWKSet createLocalJWKSet} examples. Empty on manually constructed
+     * errors.
      */
-    [Symbol.asyncIterator]: () => AsyncIterableIterator<types.CryptoKey>;
+    [Symbol.asyncIterator]: () => AsyncIterableIterator<t.CryptoKey>;
     static code: JOSEErrorCode | (string & {});
-    /** A unique error code for {@link JWKSMultipleMatchingKeys}. */
     code: JOSEErrorCode | (string & {});
     constructor(message?: string, options?: {
         cause?: unknown;
     });
 }
-/** Timeout was reached when retrieving the JWKS response. */
+/** Thrown when fetching a remote JWKS times out. */
 export declare class JWKSTimeout extends JOSEError {
     static code: JOSEErrorCode | (string & {});
-    /** A unique error code for {@link JWKSTimeout}. */
     code: JOSEErrorCode | (string & {});
     constructor(message?: string, options?: {
         cause?: unknown;
     });
 }
-/** An error subclass thrown when JWS signature verification fails. */
+/** Thrown when JWS signature verification fails. */
 export declare class JWSSignatureVerificationFailed extends JOSEError {
     static code: JOSEErrorCode | (string & {});
-    /** A unique error code for {@link JWSSignatureVerificationFailed}. */
     code: JOSEErrorCode | (string & {});
     constructor(message?: string, options?: {
         cause?: unknown;
     });
 }
-/**
- * Union of the errors thrown during JWT Claims Set validation. {@link JWTExpired} does not extend
- * {@link JWTClaimValidationFailed}, so a single `instanceof` check cannot cover both. Use this type
- * — together with the {@link JOSEError.code code} discriminant — when handling either.
- */
+/** Errors thrown during JWT Claims Set validation. */
 export type JWTClaimValidationError = JWTClaimValidationFailed | JWTExpired;
 /**
- * Union of every {@link JOSEError} subclass this module throws, each paired with the single
- * {@link JOSEErrorCode} it is thrown with. That pairing lives here rather than on the classes, so
- * that `code` stays assignable, writable, and overridable on them exactly as before, while a value
- * of this type can still be switched over as a discriminated union.
- *
- * > Note: The base {@link JOSEError} is deliberately not a member — its `code` spans every value, which
- * > would defeat the discriminant. A small number of JSON Web Key Set HTTP failures are thrown as the
- * > base class itself, so `instanceof JOSEError` remains the catch-all; this union is for handling a
- * > value already known to be one of the specific errors.
+ * Discriminated union of specific {@link JOSEError} subclasses, narrowed by `code`. Excludes base
+ * {@link JOSEError} instances; use `instanceof JOSEError` to catch all module errors.
  */
 export type AnyJOSEError = (JOSEAlgNotAllowed & {
     code: 'ERR_JOSE_ALG_NOT_ALLOWED';

package/node_modules/jose/dist/webapi/index.js

@@ -1,32 +1,70 @@
-export { compactDecrypt } from './jwe/compact/decrypt.js';
-export { flattenedDecrypt } from './jwe/flattened/decrypt.js';
-export { generalDecrypt } from './jwe/general/decrypt.js';
-export { GeneralEncrypt } from './jwe/general/encrypt.js';
-export { compactVerify } from './jws/compact/verify.js';
-export { flattenedVerify } from './jws/flattened/verify.js';
-export { generalVerify } from './jws/general/verify.js';
-export { jwtVerify } from './jwt/verify.js';
-export { jwtDecrypt } 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 { 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 { UnsecuredJWT } from './jwt/unsecured.js';
-export { exportPKCS8, exportSPKI, exportJWK } from './key/export.js';
-export { importSPKI, importPKCS8, importX509, importJWK } from './key/import.js';
-export { decodeProtectedHeader } from './util/decode_protected_header.js';
-export { decodeJwt } from './util/decode_jwt.js';
-import * as errors from './util/errors.js';
-export { errors };
-export { generateKeyPair } from './key/generate_key_pair.js';
-export { generateSecret } from './key/generate_secret.js';
-import * as base64url from './util/base64url.js';
-export { base64url };
-export const cryptoRuntime = 'WebCryptoAPI';
+import { compactDecrypt } from "./jwe/compact/decrypt.js";
+import { flattenedDecrypt } from "./jwe/flattened/decrypt.js";
+import { generalDecrypt } from "./jwe/general/decrypt.js";
+import { GeneralEncrypt } from "./jwe/general/encrypt.js";
+import { compactVerify } from "./jws/compact/verify.js";
+import { flattenedVerify } from "./jws/flattened/verify.js";
+import { generalVerify } from "./jws/general/verify.js";
+import { jwtVerify } from "./jwt/verify.js";
+import { jwtDecrypt } from "./jwt/decrypt.js";
+import { CompactEncrypt } from "./jwe/compact/encrypt.js";
+import { FlattenedEncrypt } from "./jwe/flattened/encrypt.js";
+import { CompactSign } from "./jws/compact/sign.js";
+import { FlattenedSign } from "./jws/flattened/sign.js";
+import { GeneralSign } from "./jws/general/sign.js";
+import { SignJWT } from "./jwt/sign.js";
+import { EncryptJWT } from "./jwt/encrypt.js";
+import { calculateJwkThumbprint, calculateJwkThumbprintUri } from "./jwk/thumbprint.js";
+import { EmbeddedJWK } from "./jwk/embedded.js";
+import { createLocalJWKSet } from "./jwks/local.js";
+import { createRemoteJWKSet, jwksCache, customFetch } from "./jwks/remote.js";
+import { UnsecuredJWT } from "./jwt/unsecured.js";
+import { exportPKCS8, exportSPKI, exportJWK } from "./key/export.js";
+import { importSPKI, importPKCS8, importX509, importJWK } from "./key/import.js";
+import { decodeProtectedHeader } from "./util/decode_protected_header.js";
+import { decodeJwt } from "./util/decode_jwt.js";
+import * as errors from "./util/errors.js";
+import { generateKeyPair } from "./key/generate_key_pair.js";
+import { generateSecret } from "./key/generate_secret.js";
+import * as base64url from "./util/base64url.js";
+const cryptoRuntime = "WebCryptoAPI";
+export {
+  CompactEncrypt,
+  CompactSign,
+  EmbeddedJWK,
+  EncryptJWT,
+  FlattenedEncrypt,
+  FlattenedSign,
+  GeneralEncrypt,
+  GeneralSign,
+  SignJWT,
+  UnsecuredJWT,
+  base64url,
+  calculateJwkThumbprint,
+  calculateJwkThumbprintUri,
+  compactDecrypt,
+  compactVerify,
+  createLocalJWKSet,
+  createRemoteJWKSet,
+  cryptoRuntime,
+  customFetch,
+  decodeJwt,
+  decodeProtectedHeader,
+  errors,
+  exportJWK,
+  exportPKCS8,
+  exportSPKI,
+  flattenedDecrypt,
+  flattenedVerify,
+  generalDecrypt,
+  generalVerify,
+  generateKeyPair,
+  generateSecret,
+  importJWK,
+  importPKCS8,
+  importSPKI,
+  importX509,
+  jwksCache,
+  jwtDecrypt,
+  jwtVerify
+};

package/node_modules/jose/dist/webapi/jwe/compact/decrypt.js

@@ -1,9 +1,7 @@
-import { prepareDecrypt, decryptCompact } from '../../lib/jwe_decrypt.js';
-export async function compactDecrypt(jwe, key, options) {
-    const decrypted = await decryptCompact(jwe, prepareDecrypt(options), key);
-    const result = { plaintext: decrypted[0], protectedHeader: decrypted[1] };
-    if (typeof key === 'function') {
-        return { ...result, key: decrypted[2] };
-    }
-    return result;
+import { prepareDecrypt, decryptCompact } from "../../lib/jwe_decrypt.js";
+async function compactDecrypt(jwe, key, options) {
+  return decryptCompact(jwe, prepareDecrypt(options), key);
 }
+export {
+  compactDecrypt
+};

package/node_modules/jose/dist/webapi/jwe/compact/encrypt.js

@@ -1,49 +1,26 @@
-import { assertNotSet } from '../../lib/helpers.js';
-import { assertUint8Array } from '../../lib/type_checks.js';
-import { createJWE } from '../../lib/jwe_encrypt.js';
-export class CompactEncrypt {
-    #plaintext;
-    #protectedHeader;
-    #cek;
-    #iv;
-    #keyManagementParameters;
-    constructor(plaintext) {
-        assertUint8Array(plaintext, 'plaintext');
-        this.#plaintext = plaintext;
-    }
-    setContentEncryptionKey(cek) {
-        assertNotSet(this.#cek, 'setContentEncryptionKey');
-        this.#cek = cek;
-        return this;
-    }
-    setInitializationVector(iv) {
-        assertNotSet(this.#iv, 'setInitializationVector');
-        this.#iv = iv;
-        return this;
-    }
-    setProtectedHeader(protectedHeader) {
-        assertNotSet(this.#protectedHeader, 'setProtectedHeader');
-        this.#protectedHeader = protectedHeader;
-        return this;
-    }
-    setKeyManagementParameters(parameters) {
-        assertNotSet(this.#keyManagementParameters, 'setKeyManagementParameters');
-        this.#keyManagementParameters = parameters;
-        return this;
-    }
-    async encrypt(key, options) {
-        const jwe = await createJWE([
-            this.#plaintext,
-            this.#protectedHeader,
-            undefined,
-            undefined,
-            undefined,
-            this.#cek,
-            this.#iv,
-            this.#keyManagementParameters,
-            undefined,
-            false,
-        ], key, options);
-        return [jwe.protected, jwe.encrypted_key, jwe.iv, jwe.ciphertext, jwe.tag].join('.');
-    }
+import { assertNotSet, assertUint8Array } from "../../lib/validate.js";
+import { compactJWE, createJWE } from "../../lib/jwe_encrypt.js";
+class CompactEncrypt {
+  #input;
+  constructor(plaintext) {
+    assertUint8Array(plaintext, "plaintext"), this.#input = [plaintext];
+  }
+  setContentEncryptionKey(cek) {
+    return assertNotSet(this.#input[5], "setContentEncryptionKey"), this.#input[5] = cek, this;
+  }
+  setInitializationVector(iv) {
+    return assertNotSet(this.#input[6], "setInitializationVector"), this.#input[6] = iv, this;
+  }
+  setProtectedHeader(protectedHeader) {
+    return assertNotSet(this.#input[1], "setProtectedHeader"), this.#input[1] = protectedHeader, this;
+  }
+  setKeyManagementParameters(parameters) {
+    return assertNotSet(this.#input[7], "setKeyManagementParameters"), this.#input[7] = parameters, this;
+  }
+  async encrypt(key, options) {
+    return compactJWE(await createJWE([...this.#input], key, options));
+  }
 }
+export {
+  CompactEncrypt
+};

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

@@ -1,15 +1,15 @@
-import { JWEInvalid } from '../../util/errors.js';
-import { isObject } from '../../lib/type_checks.js';
-import { prepareDecrypt, decryptJWE, decryptResult, checkRecipient, snapshotSharedJWE, snapshotRecipientJWE, } from '../../lib/jwe_decrypt.js';
-export async function flattenedDecrypt(jwe, key, options) {
-    if (!isObject(jwe)) {
-        throw new JWEInvalid('Flattened JWE must be an object');
-    }
-    const shared = snapshotSharedJWE(jwe);
-    const [recipient, , error] = snapshotRecipientJWE(jwe);
-    if (!recipient)
-        throw error;
-    const snapshot = { ...shared, ...recipient };
-    checkRecipient(snapshot);
-    return decryptResult(snapshot, await decryptJWE(snapshot, prepareDecrypt(options), key));
+import { JWEInvalid } from "../../util/errors.js";
+import { isObject } from "../../lib/validate.js";
+import { prepareDecrypt, decryptJWE, checkRecipient, snapshotSharedJWE, snapshotRecipientJWE } from "../../lib/jwe_decrypt.js";
+async function flattenedDecrypt(jwe, key, options) {
+  if (!isObject(jwe))
+    throw new JWEInvalid("Flattened JWE must be an object");
+  const shared = snapshotSharedJWE(jwe), [recipient, , error] = snapshotRecipientJWE(jwe);
+  if (!recipient)
+    throw error;
+  const snapshot = { ...shared, ...recipient };
+  return checkRecipient(snapshot), decryptJWE(snapshot, prepareDecrypt(options), key);
 }
+export {
+  flattenedDecrypt
+};

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

@@ -1,65 +1,35 @@
-import { assertNotSet } from '../../lib/helpers.js';
-import { createJWE } from '../../lib/jwe_encrypt.js';
-import { assertUint8Array } from '../../lib/type_checks.js';
-export class FlattenedEncrypt {
-    #plaintext;
-    #protectedHeader;
-    #sharedUnprotectedHeader;
-    #unprotectedHeader;
-    #aad;
-    #cek;
-    #iv;
-    #keyManagementParameters;
-    constructor(plaintext) {
-        assertUint8Array(plaintext, 'plaintext');
-        this.#plaintext = plaintext;
-    }
-    setKeyManagementParameters(parameters) {
-        assertNotSet(this.#keyManagementParameters, 'setKeyManagementParameters');
-        this.#keyManagementParameters = parameters;
-        return this;
-    }
-    setProtectedHeader(protectedHeader) {
-        assertNotSet(this.#protectedHeader, 'setProtectedHeader');
-        this.#protectedHeader = protectedHeader;
-        return this;
-    }
-    setSharedUnprotectedHeader(sharedUnprotectedHeader) {
-        assertNotSet(this.#sharedUnprotectedHeader, 'setSharedUnprotectedHeader');
-        this.#sharedUnprotectedHeader = sharedUnprotectedHeader;
-        return this;
-    }
-    setUnprotectedHeader(unprotectedHeader) {
-        assertNotSet(this.#unprotectedHeader, 'setUnprotectedHeader');
-        this.#unprotectedHeader = unprotectedHeader;
-        return this;
-    }
-    setAdditionalAuthenticatedData(aad) {
-        this.#aad = aad;
-        return this;
-    }
-    setContentEncryptionKey(cek) {
-        assertNotSet(this.#cek, 'setContentEncryptionKey');
-        this.#cek = cek;
-        return this;
-    }
-    setInitializationVector(iv) {
-        assertNotSet(this.#iv, 'setInitializationVector');
-        this.#iv = iv;
-        return this;
-    }
-    async encrypt(key, options) {
-        return createJWE([
-            this.#plaintext,
-            this.#protectedHeader,
-            this.#unprotectedHeader,
-            this.#sharedUnprotectedHeader,
-            this.#aad,
-            this.#cek,
-            this.#iv,
-            this.#keyManagementParameters,
-            undefined,
-            false,
-        ], key, options);
-    }
+import { assertNotSet, assertUint8Array } from "../../lib/validate.js";
+import { createJWE } from "../../lib/jwe_encrypt.js";
+class FlattenedEncrypt {
+  #input;
+  constructor(plaintext) {
+    assertUint8Array(plaintext, "plaintext"), this.#input = [plaintext];
+  }
+  setKeyManagementParameters(parameters) {
+    return assertNotSet(this.#input[7], "setKeyManagementParameters"), this.#input[7] = parameters, this;
+  }
+  setProtectedHeader(protectedHeader) {
+    return assertNotSet(this.#input[1], "setProtectedHeader"), this.#input[1] = protectedHeader, this;
+  }
+  setSharedUnprotectedHeader(sharedUnprotectedHeader) {
+    return assertNotSet(this.#input[3], "setSharedUnprotectedHeader"), this.#input[3] = sharedUnprotectedHeader, this;
+  }
+  setUnprotectedHeader(unprotectedHeader) {
+    return assertNotSet(this.#input[2], "setUnprotectedHeader"), this.#input[2] = unprotectedHeader, this;
+  }
+  setAdditionalAuthenticatedData(aad) {
+    return this.#input[4] = aad, this;
+  }
+  setContentEncryptionKey(cek) {
+    return assertNotSet(this.#input[5], "setContentEncryptionKey"), this.#input[5] = cek, this;
+  }
+  setInitializationVector(iv) {
+    return assertNotSet(this.#input[6], "setInitializationVector"), this.#input[6] = iv, this;
+  }
+  async encrypt(key, options) {
+    return createJWE([...this.#input], key, options);
+  }
 }
+export {
+  FlattenedEncrypt
+};