@enbox/crypto 0.0.1

package/dist/types/algorithms/eddsa.d.ts

@@ -0,0 +1,151 @@
+import type { Jwk } from '../jose/jwk.js';
+import type { Signer } from '../types/signer.js';
+import type { AsymmetricKeyGenerator } from '../types/key-generator.js';
+import type { SignParams, VerifyParams, GenerateKeyParams, GetPublicKeyParams, ComputePublicKeyParams } from '../types/params-direct.js';
+import { CryptoAlgorithm } from './crypto-algorithm.js';
+/**
+ * The `EdDsaGenerateKeyParams` interface defines the algorithm-specific parameters that should be
+ * passed into the `generateKey()` method when using the EdDSA algorithm.
+ */
+export interface EdDsaGenerateKeyParams extends GenerateKeyParams {
+    /**
+     * A string defining the type of key to generate. The value must be one of the following:
+     * - `"Ed25519"`: EdDSA using the Ed25519 curve.
+     */
+    algorithm: 'Ed25519';
+}
+/**
+ * The `EdDsaAlgorithm` class provides a concrete implementation for cryptographic operations using
+ * the Edwards-curve Digital Signature Algorithm (EdDSA). This class implements both
+ * {@link Signer | `Signer`} and { @link AsymmetricKeyGenerator | `AsymmetricKeyGenerator`}
+ * interfaces, providing private key generation, public key derivation, and creation/verification
+ * of signatures.
+ *
+ * This class is typically accessed through implementations that extend the
+ * {@link CryptoApi | `CryptoApi`} interface.
+ */
+export declare class EdDsaAlgorithm extends CryptoAlgorithm implements AsymmetricKeyGenerator<EdDsaGenerateKeyParams, Jwk, GetPublicKeyParams>, Signer<SignParams, VerifyParams> {
+    /**
+     * Derives the public key in JWK format from a given private key.
+     *
+     * @remarks
+     * This method takes a private key in JWK format and derives its corresponding public key,
+     * also in JWK format. The process ensures that the derived public key correctly corresponds to
+     * the given private key.
+     *
+     * @example
+     * ```ts
+     * const eddsa = new EdDsaAlgorithm();
+     * const privateKey = { ... }; // A Jwk object representing a private key
+     * const publicKey = await eddsa.computePublicKey({ key: privateKey });
+     * ```
+     *
+     * @param params - The parameters for the public key derivation.
+     * @param params.key - The private key in JWK format from which to derive the public key.
+     *
+     * @returns A Promise that resolves to the derived public key in JWK format.
+     */
+    computePublicKey({ key }: ComputePublicKeyParams): Promise<Jwk>;
+    /**
+     * Generates a new private key with the specified algorithm in JSON Web Key (JWK) format.
+     *
+     * @example
+     * ```ts
+     * const eddsa = new EdDsaAlgorithm();
+     * const privateKey = await eddsa.generateKey({ algorithm: 'Ed25519' });
+     * ```
+     *
+     * @param params - The parameters for key generation.
+     * @param params.algorithm - The algorithm to use for key generation.
+     *
+     * @returns A Promise that resolves to the generated private key in JWK format.
+     */
+    generateKey({ algorithm }: EdDsaGenerateKeyParams): Promise<Jwk>;
+    /**
+     * Retrieves the public key properties from a given private key in JWK format.
+     *
+     * @remarks
+     * This method extracts the public key portion from an EdDSA private key in JWK format. It does
+     * so by removing the private key property 'd' and making a shallow copy, effectively yielding the
+     * public key.
+     *
+     * Note: This method offers a significant performance advantage, being about 100 times faster
+     * than `computePublicKey()`. However, it does not mathematically validate the private key, nor
+     * does it derive the public key from the private key. It simply extracts existing public key
+     * properties from the private key object. This makes it suitable for scenarios where speed is
+     * critical and the private key's integrity is already assured.
+     *
+     * @example
+     * ```ts
+     * const eddsa = new EdDsaAlgorithm();
+     * const privateKey = { ... }; // A Jwk object representing a private key
+     * const publicKey = await eddsa.getPublicKey({ key: privateKey });
+     * ```
+     *
+     * @param params - The parameters for retrieving the public key properties.
+     * @param params.key - The private key in JWK format.
+     *
+     * @returns A Promise that resolves to the public key in JWK format.
+     */
+    getPublicKey({ key }: GetPublicKeyParams): Promise<Jwk>;
+    /**
+     * Generates an EdDSA signature of given data using a private key.
+     *
+     * @remarks
+     * This method uses the signature algorithm determined by the given `algorithm` to sign the
+     * provided data.
+     *
+     * The signature can later be verified by parties with access to the corresponding
+     * public key, ensuring that the data has not been tampered with and was indeed signed by the
+     * holder of the private key.
+     *
+     * @example
+     * ```ts
+     * const eddsa = new EdDsaAlgorithm();
+     * const data = new TextEncoder().encode('Message');
+     * const privateKey = { ... }; // A Jwk object representing a private key
+     * const signature = await eddsa.sign({
+     *   key: privateKey,
+     *   data
+     * });
+     * ```
+     *
+     * @param params - The parameters for the signing operation.
+     * @param params.key - The private key to use for signing, represented in JWK format.
+     * @param params.data - The data to sign.
+     *
+     * @returns A Promise resolving to the digital signature as a `Uint8Array`.
+     */
+    sign({ key, data }: SignParams): Promise<Uint8Array>;
+    /**
+     * Verifies an EdDSA signature associated with the provided data using the provided key.
+     *
+     * @remarks
+     * This method uses the signature algorithm determined by the `crv` property of the provided key
+     * to check the validity of a digital signature against the original data. It confirms whether the
+     * signature was created by the holder of the corresponding private key and that the data has not
+     * been tampered with.
+     *s
+     * @example
+     * ```ts
+     * const eddsa = new EdDsaAlgorithm();
+     * const publicKey = { ... }; // Public key in JWK format corresponding to the private key that signed the data
+     * const signature = new Uint8Array([...]); // Signature to verify
+     * const data = new TextEncoder().encode('Message');
+     * const isValid = await eddsa.verify({
+     *   key: publicKey,
+     *   signature,
+     *   data
+     * });
+     * ```
+     *
+     * @param params - The parameters for the verification operation.
+     * @param params.key - The key to use for verification.
+     * @param params.signature - The signature to verify.
+     * @param params.data - The data to verify.
+     *
+     * @returns A Promise resolving to a boolean indicating whether the signature is valid.
+     */
+    verify({ key, signature, data }: VerifyParams): Promise<boolean>;
+}
+//# sourceMappingURL=eddsa.d.ts.map

package/dist/types/algorithms/eddsa.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"eddsa.d.ts","sourceRoot":"","sources":["../../../src/algorithms/eddsa.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,GAAG,EAAE,MAAM,gBAAgB,CAAC;AAC1C,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,oBAAoB,CAAC;AACjD,OAAO,KAAK,EAAE,sBAAsB,EAAE,MAAM,2BAA2B,CAAC;AACxE,OAAO,KAAK,EACV,UAAU,EACV,YAAY,EACZ,iBAAiB,EACjB,kBAAkB,EAClB,sBAAsB,EACvB,MAAM,2BAA2B,CAAC;AAGnC,OAAO,EAAE,eAAe,EAAE,MAAM,uBAAuB,CAAC;AAGxD;;;GAGG;AACH,MAAM,WAAW,sBAAuB,SAAQ,iBAAiB;IAC/D;;;OAGG;IACH,SAAS,EAAE,SAAS,CAAC;CACtB;AAED;;;;;;;;;GASG;AACH,qBAAa,cAAe,SAAQ,eAClC,YAAW,sBAAsB,CAAC,sBAAsB,EAAE,GAAG,EAAE,kBAAkB,CAAC,EACvE,MAAM,CAAC,UAAU,EAAE,YAAY,CAAC;IAE3C;;;;;;;;;;;;;;;;;;;OAmBG;IACU,gBAAgB,CAAC,EAAE,GAAG,EAAE,EACnC,sBAAsB,GACrB,OAAO,CAAC,GAAG,CAAC;IAiBf;;;;;;;;;;;;;OAaG;IACG,WAAW,CAAC,EAAE,SAAS,EAAE,EAC7B,sBAAsB,GACrB,OAAO,CAAC,GAAG,CAAC;IAWf;;;;;;;;;;;;;;;;;;;;;;;;;OAyBG;IACU,YAAY,CAAC,EAAE,GAAG,EAAE,EAC/B,kBAAkB,GACjB,OAAO,CAAC,GAAG,CAAC;IAiBf;;;;;;;;;;;;;;;;;;;;;;;;;;;OA2BG;IACU,IAAI,CAAC,EAAE,GAAG,EAAE,IAAI,EAAE,EAC7B,UAAU,GACT,OAAO,CAAC,UAAU,CAAC;IAetB;;;;;;;;;;;;;;;;;;;;;;;;;;;;OA4BG;IACU,MAAM,CAAC,EAAE,GAAG,EAAE,SAAS,EAAE,IAAI,EAAE,EAC1C,YAAY,GACX,OAAO,CAAC,OAAO,CAAC;CAcpB"}

package/dist/types/algorithms/sha-2.d.ts

@@ -0,0 +1,51 @@
+import type { Hasher } from '../types/hasher.js';
+import type { DigestParams } from '../types/params-direct.js';
+import { CryptoAlgorithm } from './crypto-algorithm.js';
+/**
+ * The `Sha2DigestParams` interface defines the algorithm-specific parameters that should be
+ * passed into the `digest()` method when using the SHA-2 algorithm.
+ */
+export interface Sha2DigestParams extends DigestParams {
+    /**
+     * A string defining the name of hash function to use. The value must be one of the following:
+     * - `"SHA-256"`: Generates a 256-bit digest.
+     */
+    algorithm: 'SHA-256';
+}
+/**
+ * The `Sha2Algorithm` class is an implementation of the {@link Hasher | `Hasher`} interface for the
+ * SHA-2 family of cryptographic hash functions. The `digest` method takes the algorithm identifier
+ * of the hash function and arbitrary data as input and returns the hash digest of the data.
+ *
+ * This class is typically accessed through implementations that extend the
+ * {@link CryptoApi | `CryptoApi`} interface.
+ */
+export declare class Sha2Algorithm extends CryptoAlgorithm implements Hasher<Sha2DigestParams> {
+    /**
+     * Generates a hash digest of the provided data.
+     *
+     * @remarks
+     * A digest is the output of the hash function. It's a fixed-size string of bytes
+     * that uniquely represents the data input into the hash function. The digest is often used for
+     * data integrity checks, as any alteration in the input data results in a significantly
+     * different digest.
+     *
+     * It takes the algorithm identifier of the hash function and data to digest as input and returns
+     * the digest of the data.
+     *
+     * @example
+     * ```ts
+     * const sha2 = new Sha2Algorithm();
+     * const data = new TextEncoder().encode('Messsage');
+     * const digest = await sha2.digest({ data });
+     * ```
+     *
+     * @param params - The parameters for the digest operation.
+     * @param params.algorithm - The name of hash function to use.
+     * @param params.data - The data to digest.
+     *
+     * @returns A Promise which will be fulfilled with the hash digest.
+     */
+    digest({ algorithm, data }: Sha2DigestParams): Promise<Uint8Array>;
+}
+//# sourceMappingURL=sha-2.d.ts.map

package/dist/types/algorithms/sha-2.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"sha-2.d.ts","sourceRoot":"","sources":["../../../src/algorithms/sha-2.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,oBAAoB,CAAC;AACjD,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,2BAA2B,CAAC;AAG9D,OAAO,EAAE,eAAe,EAAE,MAAM,uBAAuB,CAAC;AAExD;;;GAGG;AACH,MAAM,WAAW,gBAAiB,SAAQ,YAAY;IACpD;;;OAGG;IACH,SAAS,EAAE,SAAS,CAAC;CACtB;AAED;;;;;;;GAOG;AACH,qBAAa,aAAc,SAAQ,eACjC,YAAW,MAAM,CAAC,gBAAgB,CAAC;IAEnC;;;;;;;;;;;;;;;;;;;;;;;;OAwBG;IACU,MAAM,CAAC,EAAE,SAAS,EAAE,IAAI,EAAE,EAAE,gBAAgB,GAAG,OAAO,CAAC,UAAU,CAAC;CAUhF"}

package/dist/types/index.d.ts

@@ -0,0 +1,39 @@
+export * from './local-key-manager.js';
+export * from './utils.js';
+export * from './algorithms/aes-ctr.js';
+export * from './algorithms/aes-gcm.js';
+export * from './algorithms/crypto-algorithm.js';
+export * from './algorithms/ecdsa.js';
+export * from './algorithms/eddsa.js';
+export * from './algorithms/sha-2.js';
+export * from './jose/jwe.js';
+export * from './jose/jwk.js';
+export * from './jose/jws.js';
+export * from './jose/jwt.js';
+export * from './jose/utils.js';
+export * from './primitives/aes-ctr.js';
+export * from './primitives/aes-gcm.js';
+export * from './primitives/concat-kdf.js';
+export * from './primitives/ed25519.js';
+export * from './primitives/secp256r1.js';
+export * from './primitives/pbkdf2.js';
+export * from './primitives/secp256k1.js';
+export * from './primitives/sha256.js';
+export * from './primitives/x25519.js';
+export * from './primitives/xchacha20.js';
+export * from './primitives/xchacha20-poly1305.js';
+export type * from './types/cipher.js';
+export type * from './types/crypto-api.js';
+export type * from './types/hasher.js';
+export type * from './types/identifier.js';
+export type * from './types/key-compressor.js';
+export type * from './types/key-converter.js';
+export type * from './types/key-deriver.js';
+export type * from './types/key-generator.js';
+export type * from './types/key-io.js';
+export type * from './types/key-wrapper.js';
+export type * from './types/params-direct.js';
+export type * from './types/params-enclosed.js';
+export type * from './types/params-kms.js';
+export type * from './types/signer.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/types/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/index.ts"],"names":[],"mappings":"AAAA,cAAc,wBAAwB,CAAC;AACvC,cAAc,YAAY,CAAC;AAE3B,cAAc,yBAAyB,CAAC;AACxC,cAAc,yBAAyB,CAAC;AACxC,cAAc,kCAAkC,CAAC;AACjD,cAAc,uBAAuB,CAAC;AACtC,cAAc,uBAAuB,CAAC;AACtC,cAAc,uBAAuB,CAAC;AAEtC,cAAc,eAAe,CAAC;AAC9B,cAAc,eAAe,CAAC;AAC9B,cAAc,eAAe,CAAC;AAC9B,cAAc,eAAe,CAAC;AAC9B,cAAc,iBAAiB,CAAC;AAEhC,cAAc,yBAAyB,CAAC;AACxC,cAAc,yBAAyB,CAAC;AACxC,cAAc,4BAA4B,CAAC;AAC3C,cAAc,yBAAyB,CAAC;AACxC,cAAc,2BAA2B,CAAC;AAC1C,cAAc,wBAAwB,CAAC;AACvC,cAAc,2BAA2B,CAAC;AAC1C,cAAc,wBAAwB,CAAC;AACvC,cAAc,wBAAwB,CAAC;AACvC,cAAc,2BAA2B,CAAC;AAC1C,cAAc,oCAAoC,CAAC;AAEnD,mBAAmB,mBAAmB,CAAC;AACvC,mBAAmB,uBAAuB,CAAC;AAC3C,mBAAmB,mBAAmB,CAAC;AACvC,mBAAmB,uBAAuB,CAAC;AAC3C,mBAAmB,2BAA2B,CAAC;AAC/C,mBAAmB,0BAA0B,CAAC;AAC9C,mBAAmB,wBAAwB,CAAC;AAC5C,mBAAmB,0BAA0B,CAAC;AAC9C,mBAAmB,mBAAmB,CAAC;AACvC,mBAAmB,wBAAwB,CAAC;AAC5C,mBAAmB,0BAA0B,CAAC;AAC9C,mBAAmB,4BAA4B,CAAC;AAChD,mBAAmB,uBAAuB,CAAC;AAC3C,mBAAmB,mBAAmB,CAAC"}

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

@@ -0,0 +1,135 @@
+import type { JoseHeaderParams } from './jws.js';
+/**
+ * JSON Web Encryption (JWE) Header Parameters
+ *
+ * The Header Parameter names for use in JWEs are registered in the IANA "JSON Web Signature and
+ * Encryption Header Parameters" registry.
+ *
+ * @see {@link https://datatracker.ietf.org/doc/html/rfc7516#section-4.1 | RFC 7516, Section 4.1}
+ */
+export interface JweHeaderParams extends JoseHeaderParams {
+    /**
+     * Algorithm Header Parameter
+     *
+     * Identifies the cryptographic algorithm used to encrypt or determine the value of the Content
+     * Encryption Key (CEK). The encrypted content is not usable if the "alg" value does not represent
+     * a supported algorithm, or if the recipient does not have a key that can be used with that
+     * algorithm.
+     *
+     * "alg" values should either be registered in the IANA "JSON Web Signature and Encryption
+     * Algorithms" registry or be a value that contains a Collision-Resistant Name. The "alg" value is
+     * a case-sensitive ASCII string.  This Header Parameter MUST be present and MUST be understood
+     * and processed by implementations.
+     *
+     * @see {@link https://datatracker.ietf.org/doc/html/rfc7516#section-4.1.1 | RFC 7516, Section 4.1.1}
+     */
+    alg: 'A128KW' | 'A192KW' | 'A256KW' | 'dir' | 'ECDH-ES' | 'ECDH-ES+A128KW' | 'ECDH-ES+A192KW' | 'ECDH-ES+A256KW' | 'A128GCMKW' | 'A192GCMKW' | 'A256GCMKW' | 'PBES2-HS256+A128KW' | 'PBES2-HS384+A192KW' | 'PBES2-HS512+A256KW' | 'PBES2-HS512+XC20PKW' | string;
+    /**
+     * Agreement PartyUInfo Header Parameter
+     *
+     * The "apu" (agreement PartyUInfo) value is a base64url-encoded octet sequence containing
+     * information about the producer of the JWE.  This information is used by the recipient to
+     * determine the key agreement algorithm and key encryption algorithm to use to decrypt the JWE.
+     *
+     * Note: This parameter is intended only for use when the recipient is a key agreement algorithm
+     * that uses public key cryptography.
+     */
+    apu?: Uint8Array;
+    /**
+     * Agreement PartyVInfo Header Parameter
+     *
+     * The "apv" (agreement PartyVInfo) value is a base64url-encoded octet sequence containing
+     * information about the recipient of the JWE.  This information is used by the recipient to
+     * determine the key agreement algorithm and key encryption algorithm to use to decrypt the JWE.
+     *
+     * Note: This parameter is intended only for use when the recipient is a key agreement algorithm
+     * that uses public key cryptography.
+     */
+    apv?: Uint8Array;
+    /**
+     * Critical Header Parameter
+     *
+     * Indicates that extensions to JOSE RFCs are being used that MUST be understood and processed.
+     */
+    crit?: string[];
+    /**
+     * Encryption Algorithm Header Parameter
+     *
+     * Identifies the content encryption algorithm used to encrypt and integrity-protect (also
+     * known as "authenticated encryption") the plaintext and to integrity-protect the Additional
+     * Authenticated Data (AAD), if any.  This algorithm MUST be an AEAD algorithm with a specified
+     * key length.
+     *
+     * The encrypted content is not usable if the "enc" value does not represent a supported
+     * algorithm.  "enc" values should either be registered in the IANA "JSON Web Signature and
+     * Encryption Algorithms" registry or be a value that contains a Collision-Resistant Name. The
+     * "enc" value is a case-sensitive ASCII string containing a StringOrURI value. This Header
+     * Parameter MUST be present and MUST be understood and processed by implementations.
+     *
+     * @see {@link https://datatracker.ietf.org/doc/html/rfc7516#section-4.1.2 | RFC 7516, Section 4.1.2}
+     */
+    enc: 'A128CBC-HS256' | 'A192CBC-HS384' | 'A256CBC-HS512' | 'A128GCM' | 'A192GCM' | 'A256GCM' | 'XC20P' | string;
+    /**
+     * Ephemeral Public Key Header Parameter
+     *
+     * The "epk" (ephemeral public key) value created by the originator for the use in key agreement
+     * algorithms.  It is the ephemeral public key that corresponds to the key used to encrypt the
+     * JWE.  This value is represented as a JSON Web Key (JWK).
+     *
+     * Note: This parameter is intended only for use when the recipient is a key agreement algorithm
+     * that uses public key cryptography.
+     */
+    epk?: Uint8Array;
+    /**
+     * Initialization Vector Header Parameter
+     *
+     * The "iv" (initialization vector) value is a base64url-encoded octet sequence used by the
+     * specified "enc" algorithm.  The length of this Initialization Vector value MUST be exactly
+     * equal to the value that would be produced by the "enc" algorithm.
+     *
+     * Note: With symmetric encryption algorithms such as AES GCM, this Header Parameter MUST
+     * be present and MUST be understood and processed by implementations.
+     */
+    iv?: Uint8Array;
+    /**
+     * PBES2 Count Header Parameter
+     *
+     * The "p2c" (PBES2 count) value is an integer indicating the number of iterations of the PBKDF2
+     * algorithm performed during key derivation.
+     *
+     * Note: The iteration count adds computational expense, ideally compounded by the possible range
+     * of keys introduced by the salt.  A minimum iteration count of 1000 is RECOMMENDED.
+     */
+    p2c?: number;
+    /**
+     * PBES2 Salt Input Header Parameter
+     *
+     * The "p2s" (PBES2 salt) value is a base64url-encoded octet sequence used as the salt value
+     * input to the PBKDF2 algorithm during key derivation.
+     *
+     * The salt value used is (UTF8(Alg) || 0x00 || Salt Input), where Alg is the "alg" (algorithm)
+     * Header Parameter value.
+     *
+     * Note: The salt value is used to ensure that each key derived from the master key is
+     * independent of every other key. A suitable source of salt value is a sequence of
+     * cryptographically random bytes containing 8 or more octets.
+     */
+    p2s?: string;
+    /**
+     * Authentication Tag Header Parameter
+     *
+     * The "tag" value is a base64url-encoded octet sequence containing the value of the
+     * Authentication Tag output by the specified "enc" algorithm.  The length of this
+     * Authentication Tag value MUST be exactly equal to the value that would be produced by the
+     * "enc" algorithm.
+     *
+     * Note: With authenticated encryption algorithms such as AES GCM, this Header Parameter MUST
+     * be present and MUST be understood and processed by implementations.
+     */
+    tag?: Uint8Array;
+    /**
+     * Additional Public or Private Header Parameter names.
+     */
+    [key: string]: unknown;
+}
+//# sourceMappingURL=jwe.d.ts.map

package/dist/types/jose/jwe.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"jwe.d.ts","sourceRoot":"","sources":["../../../src/jose/jwe.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,UAAU,CAAC;AAEjD;;;;;;;GAOG;AACH,MAAM,WAAW,eAAgB,SAAQ,gBAAgB;IACvD;;;;;;;;;;;;;;OAcG;IACH,GAAG,EAEC,QAAQ,GAER,QAAQ,GAER,QAAQ,GAER,KAAK,GAEL,SAAS,GAET,gBAAgB,GAEhB,gBAAgB,GAEhB,gBAAgB,GAEhB,WAAW,GAEX,WAAW,GAEX,WAAW,GAEX,oBAAoB,GAEpB,oBAAoB,GAEpB,oBAAoB,GAEpB,qBAAqB,GAErB,MAAM,CAAC;IAEX;;;;;;;;;OASG;IACH,GAAG,CAAC,EAAE,UAAU,CAAC;IAEjB;;;;;;;;;OASG;IACH,GAAG,CAAC,EAAE,UAAU,CAAC;IAEjB;;;;OAIG;IACH,IAAI,CAAC,EAAE,MAAM,EAAE,CAAA;IAEf;;;;;;;;;;;;;;;OAeG;IACH,GAAG,EAGC,eAAe,GAGf,eAAe,GAGf,eAAe,GAEf,SAAS,GAET,SAAS,GAET,SAAS,GAET,OAAO,GAEP,MAAM,CAAC;IAEX;;;;;;;;;OASG;IACH,GAAG,CAAC,EAAE,UAAU,CAAC;IAEjB;;;;;;;;;OASG;IACH,EAAE,CAAC,EAAE,UAAU,CAAC;IAEhB;;;;;;;;OAQG;IACH,GAAG,CAAC,EAAE,MAAM,CAAC;IAEb;;;;;;;;;;;;OAYG;IACH,GAAG,CAAC,EAAE,MAAM,CAAC;IAEb;;;;;;;;;;OAUG;IACH,GAAG,CAAC,EAAE,UAAU,CAAC;IAEjB;;OAEG;IACH,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAA;CACvB"}