@enbox/crypto 0.0.1

package/dist/types/primitives/ed25519.d.ts

@@ -0,0 +1,359 @@
+import type { Jwk } from '../jose/jwk.js';
+import type { ComputePublicKeyParams, GetPublicKeyParams, SignParams, VerifyParams } from '../types/params-direct.js';
+/**
+ * The `Ed25519` class provides a comprehensive suite of utilities for working with the Ed25519
+ * elliptic curve, widely used in modern cryptographic applications. This class includes methods for
+ * key generation, conversion, signing, verification, and public key derivation.
+ *
+ * The class supports conversions between raw byte formats and JSON Web Key (JWK) formats. It
+ * follows the guidelines and specifications outlined in RFC8032 for EdDSA (Edwards-curve Digital
+ * Signature Algorithm) operations.
+ *
+ * Key Features:
+ * - Key Generation: Generate Ed25519 private keys in JWK format.
+ * - Key Conversion: Transform keys between raw byte arrays and JWK formats.
+ * - Public Key Derivation: Derive public keys from private keys.
+ * - Signing and Verification: Sign data and verify signatures with Ed25519 keys.
+ * - Key Validation: Validate the mathematical correctness of Ed25519 keys.
+ *
+ * The methods in this class are asynchronous, returning Promises to accommodate various
+ * JavaScript environments, and use `Uint8Array` for binary data handling.
+ *
+ * @example
+ * ```ts
+ * // Key Generation
+ * const privateKey = await Ed25519.generateKey();
+ *
+ * // Public Key Derivation
+ * const publicKey = await Ed25519.computePublicKey({ key: privateKey });
+ * console.log(publicKey === await Ed25519.getPublicKey({ key: privateKey })); // Output: true
+ *
+ * // EdDSA Signing
+ * const signature = await Ed25519.sign({
+ *   key: privateKey,
+ *   data: new TextEncoder().encode('Message')
+ * });
+ *
+ * // EdDSA Signature Verification
+ * const isValid = await Ed25519.verify({
+ *   key: publicKey,
+ *   signature: signature,
+ *   data: new TextEncoder().encode('Message')
+ * });
+ *
+ * // Key Conversion
+ * const privateKeyBytes = await Ed25519.privateKeyToBytes({ privateKey });
+ * const publicKeyBytes = await Ed25519.publicKeyToBytes({ publicKey });
+ *
+ * // Key Validation
+ * const isPublicKeyValid = await Ed25519.validatePublicKey({ publicKeyBytes });
+ * ```
+ */
+export declare class Ed25519 {
+    /**
+     * Converts a raw private key in bytes to its corresponding JSON Web Key (JWK) format.
+     *
+     * @remarks
+     * This method accepts a private key as a byte array (Uint8Array) for the Curve25519 curve in
+     * Twisted Edwards form and transforms it into a JWK object. The process involves first deriving
+     * the public key from the private key, then encoding both the private and public keys into
+     * base64url format.
+     *
+     * The resulting JWK object includes the following properties:
+     * - `kty`: Key Type, set to 'OKP' for Octet Key Pair.
+     * - `crv`: Curve Name, set to 'Ed25519'.
+     * - `d`: The private key component, base64url-encoded.
+     * - `x`: The computed public key, base64url-encoded.
+     *
+     * @example
+     * ```ts
+     * const privateKeyBytes = new Uint8Array([...]); // Replace with actual private key bytes
+     * const privateKey = await Ed25519.bytesToPrivateKey({ privateKeyBytes });
+     * ```
+     *
+     * @param params - The parameters for the private key conversion.
+     * @param params.privateKeyBytes - The raw private key as a Uint8Array.
+     *
+     * @returns A Promise that resolves to the private key in JWK format.
+     */
+    static bytesToPrivateKey({ privateKeyBytes }: {
+        privateKeyBytes: Uint8Array;
+    }): Promise<Jwk>;
+    /**
+     * Converts a raw private key in bytes to its corresponding JSON Web Key (JWK) format.
+     *
+     * @remarks
+     * This method accepts a public key as a byte array (Uint8Array) for the Curve25519 curve in
+     * Twisted Edwards form and transforms it into a JWK object. The process involves encoding the
+     * public key bytes into base64url format.
+     *
+     * The resulting JWK object includes the following properties:
+     * - `kty`: Key Type, set to 'OKP' for Octet Key Pair.
+     * - `crv`: Curve Name, set to 'X25519'.
+     * - `x`: The public key, base64url-encoded.
+     *
+     * @example
+     * ```ts
+     * const publicKeyBytes = new Uint8Array([...]); // Replace with actual public key bytes
+     * const publicKey = await X25519.bytesToPublicKey({ publicKeyBytes });
+     * ```
+     *
+     * @param params - The parameters for the public key conversion.
+     * @param params.publicKeyBytes - The raw public key as a `Uint8Array`.
+     *
+     * @returns A Promise that resolves to the public key in JWK format.
+     */
+    static bytesToPublicKey({ publicKeyBytes }: {
+        publicKeyBytes: Uint8Array;
+    }): Promise<Jwk>;
+    /**
+     * Derives the public key in JWK format from a given Ed25519 private key.
+     *
+     * @remarks
+     * This method takes a private key in JWK format and derives its corresponding public key,
+     * also in JWK format.  The derivation process involves converting the private key to a
+     * raw byte array and then computing the corresponding public key on the Curve25519 curve in
+     * Twisted Edwards form. The public key is then encoded into base64url format to construct
+     * a JWK representation.
+     *
+     * @example
+     * ```ts
+     * const privateKey = { ... }; // A Jwk object representing an Ed25519 private key
+     * const publicKey = await Ed25519.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 computed public key in JWK format.
+     */
+    static computePublicKey({ key }: ComputePublicKeyParams): Promise<Jwk>;
+    /**
+     * Converts an Ed25519 private key to its X25519 counterpart.
+     *
+     * @remarks
+     * This method enables the use of the same key pair for both digital signature (Ed25519)
+     * and key exchange (X25519) operations. It takes an Ed25519 private key and converts it
+     * to the corresponding X25519 format, facilitating interoperability between signing
+     * and encryption protocols.
+     *
+     * @example
+     * ```ts
+     * const ed25519PrivateKey = { ... }; // An Ed25519 private key in JWK format
+     * const x25519PrivateKey = await Ed25519.convertPrivateKeyToX25519({
+     *   privateKey: ed25519PrivateKey
+     * });
+     * ```
+     *
+     * @param params - The parameters for the private key conversion.
+     * @param params.privateKey - The Ed25519 private key to convert, in JWK format.
+     *
+     * @returns A Promise that resolves to the X25519 private key in JWK format.
+     */
+    static convertPrivateKeyToX25519({ privateKey }: {
+        privateKey: Jwk;
+    }): Promise<Jwk>;
+    /**
+     * Converts an Ed25519 public key to its X25519 counterpart.
+     *
+     * @remarks
+     * This method enables the use of the same key pair for both digital signature (Ed25519)
+     * and key exchange (X25519) operations. It takes an Ed25519 public key and converts it
+     * to the corresponding X25519 format, facilitating interoperability between signing
+     * and encryption protocols.
+     *
+     * @example
+     * ```ts
+     * const ed25519PublicKey = { ... }; // An Ed25519 public key in JWK format
+     * const x25519PublicKey = await Ed25519.convertPublicKeyToX25519({
+     *   publicKey: ed25519PublicKey
+     * });
+     * ```
+     *
+     * @param params - The parameters for the public key conversion.
+     * @param params.publicKey - The Ed25519 public key to convert, in JWK format.
+     *
+     * @returns A Promise that resolves to the X25519 public key in JWK format.
+     */
+    static convertPublicKeyToX25519({ publicKey }: {
+        publicKey: Jwk;
+    }): Promise<Jwk>;
+    /**
+     * Generates an Ed25519 private key in JSON Web Key (JWK) format.
+     *
+     * @remarks
+     * This method creates a new private key suitable for use with the Curve25519 elliptic curve in
+     * Twisted Edwards form. The key generation process involves using cryptographically secure
+     * random number generation to ensure the uniqueness and security of the key. The resulting
+     * private key adheres to the JWK format making it compatible with common cryptographic
+     * standards and easy to use in various cryptographic processes.
+     *
+     * The generated private key in JWK format includes the following components:
+     * - `kty`: Key Type, set to 'OKP' for Octet Key Pair.
+     * - `crv`: Curve Name, set to 'Ed25519'.
+     * - `d`: The private key component, base64url-encoded.
+     * - `x`: The derived public key, base64url-encoded.
+     *
+     * @example
+     * ```ts
+     * const privateKey = await Ed25519.generateKey();
+     * ```
+     *
+     * @returns A Promise that resolves to the generated private key in JWK format.
+     */
+    static generateKey(): 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 Ed25519 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. The method sets the 'kid' (key ID) property using the JWK thumbprint if it is not
+     * already defined. This approach is used under the assumption that a private key in JWK format
+     * always contains the corresponding public key properties.
+     *
+     * 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 privateKey = { ... }; // A Jwk object representing an Ed25519 private key
+     * const publicKey = await Ed25519.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.
+     */
+    static getPublicKey({ key }: GetPublicKeyParams): Promise<Jwk>;
+    /**
+     * Converts a private key from JSON Web Key (JWK) format to a raw byte array (Uint8Array).
+     *
+     * @remarks
+     * This method accepts a private key in JWK format and extracts its raw byte representation.
+     *
+     * This method accepts a public key in JWK format and converts it into its raw binary
+     * form. The conversion process involves decoding the 'd' parameter of the JWK
+     * from base64url format into a byte array.
+     *
+     * @example
+     * ```ts
+     * const privateKey = { ... }; // An Ed25519 private key in JWK format
+     * const privateKeyBytes = await Ed25519.privateKeyToBytes({ privateKey });
+     * ```
+     *
+     * @param params - The parameters for the private key conversion.
+     * @param params.privateKey - The private key in JWK format.
+     *
+     * @returns A Promise that resolves to the private key as a Uint8Array.
+     */
+    static privateKeyToBytes({ privateKey }: {
+        privateKey: Jwk;
+    }): Promise<Uint8Array>;
+    /**
+     * Converts a public key from JSON Web Key (JWK) format to a raw byte array (Uint8Array).
+     *
+     * @remarks
+     * This method accepts a public key in JWK format and converts it into its raw binary form.
+     * The conversion process involves decoding the 'x' parameter of the JWK (which represent the
+     * x coordinate of the elliptic curve point) from base64url format into a byte array.
+     *
+     * @example
+     * ```ts
+     * const publicKey = { ... }; // An Ed25519 public key in JWK format
+     * const publicKeyBytes = await Ed25519.publicKeyToBytes({ publicKey });
+     * ```
+     *
+     * @param params - The parameters for the public key conversion.
+     * @param params.publicKey - The public key in JWK format.
+     *
+     * @returns A Promise that resolves to the public key as a Uint8Array.
+     */
+    static publicKeyToBytes({ publicKey }: {
+        publicKey: Jwk;
+    }): Promise<Uint8Array>;
+    /**
+     * Generates an RFC8032-compliant EdDSA signature of given data using an Ed25519 private key.
+     *
+     * @remarks
+     * This method signs the provided data with a specified private key using the EdDSA
+     * (Edwards-curve Digital Signature Algorithm) as defined in RFC8032. It
+     * involves converting the private key from JWK format to a byte array and then employing
+     * the Ed25519 algorithm to sign the data. The output is a digital signature in the form
+     * of a Uint8Array, uniquely corresponding to both the data and the private key used for
+     * signing.
+     *
+     * @example
+     * ```ts
+     * const data = new TextEncoder().encode('Messsage'); // Data to be signed
+     * const privateKey = { ... }; // A Jwk object representing an Ed25519 private key
+     * const signature = await Ed25519.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, represented as a Uint8Array.
+     *
+     * @returns A Promise that resolves to the signature as a Uint8Array.
+     */
+    static sign({ key, data }: SignParams): Promise<Uint8Array>;
+    /**
+     * Validates a given public key to confirm its mathematical correctness on the Edwards curve.
+     *
+     * @remarks
+     * This method decodes the Edwards points from the key bytes and asserts their validity on the
+     * Curve25519 curve in Twisted Edwards form. If the points are not valid, the method returns
+     * false. If the points are valid, the method returns true.
+     *
+     * Note that this validation strictly pertains to the key's format and numerical validity; it does
+     * not assess whether the key corresponds to a known entity or its security status (e.g., whether
+     * it has been compromised).
+     *
+     * @example
+     * ```ts
+     * const publicKeyBytes = new Uint8Array([...]); // A public key in byte format
+     * const isValid = await Ed25519.validatePublicKey({ publicKeyBytes });
+     * console.log(isValid); // true if the key is valid on the Edwards curve, false otherwise
+     * ```
+     *
+     * @param params - The parameters for the public key validation.
+     * @param params.publicKeyBytes - The public key to validate, represented as a Uint8Array.
+     *
+     * @returns A Promise that resolves to a boolean indicating whether the key
+     *          corresponds to a valid point on the Edwards curve.
+     */
+    static validatePublicKey({ publicKeyBytes }: {
+        publicKeyBytes: Uint8Array;
+    }): Promise<boolean>;
+    /**
+     * Verifies an RFC8032-compliant EdDSA signature against given data using an Ed25519 public key.
+     *
+     * @remarks
+     * This method validates a digital signature to ensure its authenticity and integrity.
+     * It uses the EdDSA (Edwards-curve Digital Signature Algorithm) as specified in RFC8032.
+     * The verification process involves converting the public key from JWK format to a raw
+     * byte array and using the Ed25519 algorithm to validate the signature against the provided data.
+     *
+     * @example
+     * ```ts
+     * const data = new TextEncoder().encode('Messsage'); // Data that was signed
+     * const publicKey = { ... }; // A Jwk object representing an Ed25519 public key
+     * const signature = new Uint8Array([...]); // Signature to verify
+     * const isValid = await Ed25519.verify({ key: publicKey, signature, data });
+     * console.log(isValid); // true if the signature is valid, false otherwise
+     * ```
+     *
+     * @param params - The parameters for the signature verification.
+     * @param params.key - The public key in JWK format used for verification.
+     * @param params.signature - The signature to verify, represented as a Uint8Array.
+     * @param params.data - The data that was signed, represented as a Uint8Array.
+     *
+     * @returns A Promise that resolves to a boolean indicating whether the signature is valid.
+     */
+    static verify({ key, signature, data }: VerifyParams): Promise<boolean>;
+}
+//# sourceMappingURL=ed25519.d.ts.map

package/dist/types/primitives/ed25519.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ed25519.d.ts","sourceRoot":"","sources":["../../../src/primitives/ed25519.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,GAAG,EAAE,MAAM,gBAAgB,CAAC;AAC1C,OAAO,KAAK,EAAE,sBAAsB,EAAE,kBAAkB,EAAE,UAAU,EAAE,YAAY,EAAE,MAAM,2BAA2B,CAAC;AAItH;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAgDG;AACH,qBAAa,OAAO;IAClB;;;;;;;;;;;;;;;;;;;;;;;;;OAyBG;WACiB,iBAAiB,CAAC,EAAE,eAAe,EAAE,EAAE;QACzD,eAAe,EAAE,UAAU,CAAC;KAC7B,GAAG,OAAO,CAAC,GAAG,CAAC;IAkBhB;;;;;;;;;;;;;;;;;;;;;;;OAuBG;WACiB,gBAAgB,CAAC,EAAE,cAAc,EAAE,EAAE;QACvD,cAAc,EAAE,UAAU,CAAC;KAC5B,GAAG,OAAO,CAAC,GAAG,CAAC;IAchB;;;;;;;;;;;;;;;;;;;;OAoBG;WACiB,gBAAgB,CAAC,EAAE,GAAG,EAAE,EAC1C,sBAAsB,GACrB,OAAO,CAAC,GAAG,CAAC;IAoBf;;;;;;;;;;;;;;;;;;;;;OAqBG;WACiB,yBAAyB,CAAC,EAAE,UAAU,EAAE,EAAE;QAC5D,UAAU,EAAE,GAAG,CAAC;KACjB,GAAG,OAAO,CAAC,GAAG,CAAC;IAwBhB;;;;;;;;;;;;;;;;;;;;;OAqBG;WACiB,wBAAwB,CAAC,EAAE,SAAS,EAAE,EAAE;QAC1D,SAAS,EAAE,GAAG,CAAC;KAChB,GAAG,OAAO,CAAC,GAAG,CAAC;IA0BhB;;;;;;;;;;;;;;;;;;;;;;OAsBG;WACiB,WAAW,IAAI,OAAO,CAAC,GAAG,CAAC;IAa/C;;;;;;;;;;;;;;;;;;;;;;;;;;OA0BG;WACiB,YAAY,CAAC,EAAE,GAAG,EAAE,EACtC,kBAAkB,GACjB,OAAO,CAAC,GAAG,CAAC;IAef;;;;;;;;;;;;;;;;;;;;OAoBG;WACiB,iBAAiB,CAAC,EAAE,UAAU,EAAE,EAAE;QACpD,UAAU,EAAE,GAAG,CAAC;KACjB,GAAG,OAAO,CAAC,UAAU,CAAC;IAYvB;;;;;;;;;;;;;;;;;;OAkBG;WACiB,gBAAgB,CAAC,EAAE,SAAS,EAAE,EAAE;QAClD,SAAS,EAAE,GAAG,CAAC;KAChB,GAAG,OAAO,CAAC,UAAU,CAAC;IAYvB;;;;;;;;;;;;;;;;;;;;;;;OAuBG;WACiB,IAAI,CAAC,EAAE,GAAG,EAAE,IAAI,EAAE,EACpC,UAAU,GACT,OAAO,CAAC,UAAU,CAAC;IAUtB;;;;;;;;;;;;;;;;;;;;;;;;OAwBG;WACiB,iBAAiB,CAAC,EAAE,cAAc,EAAE,EAAE;QACxD,cAAc,EAAE,UAAU,CAAC;KAC5B,GAAG,OAAO,CAAC,OAAO,CAAC;IAepB;;;;;;;;;;;;;;;;;;;;;;;;OAwBG;WACiB,MAAM,CAAC,EAAE,GAAG,EAAE,SAAS,EAAE,IAAI,EAAE,EACjD,YAAY,GACX,OAAO,CAAC,OAAO,CAAC;CASpB"}

package/dist/types/primitives/pbkdf2.d.ts

@@ -0,0 +1,94 @@
+/**
+ * The object that should be passed into `Pbkdf2.deriveKey()`, when using the PBKDF2 algorithm.
+ */
+export type Pbkdf2DeriveKeyParams = {
+    /**
+     * A string representing the digest algorithm to use. This may be one of:
+     * - 'SHA-256'
+     * - 'SHA-384'
+     * - 'SHA-512'
+     */
+    hash: 'SHA-256' | 'SHA-384' | 'SHA-512';
+    /**
+     * The password from which to derive the key, represented as a Uint8Array.
+     */
+    password: Uint8Array;
+    /**
+     * The salt value to use in the derivation process, as a Uint8Array. This should be a random or
+     * pseudo-random value of at least 16 bytes. Unlike the `password`, `salt` does not need to be
+     * kept secret.
+     */
+    salt: Uint8Array;
+    /**
+     * A `Number` representing the number of iterations the hash function will be executed in
+     * `deriveKey()`. This impacts the computational cost of the `deriveKey()` operation, making it
+     * more resistant to dictionary attacks. The higher the number, the more secure, but also slower,
+     * the operation. Choose a value that balances security needs and performance for your
+     * application.
+     */
+    iterations: number;
+    /**
+     * The desired length of the derived key in bits. To be compatible with all browsers, the number
+     * should be a multiple of 8.
+     */
+    length: number;
+};
+/**
+ * The `Pbkdf2` class provides a secure way to derive cryptographic keys from a password
+ * using the PBKDF2 (Password-Based Key Derivation Function 2) algorithm.
+ *
+ * The PBKDF2 algorithm is widely used for generating keys from passwords, as it applies
+ * a pseudorandom function to the input password along with a salt value and iterates the
+ * process multiple times to increase the key's resistance to brute-force attacks.
+ *
+ * This class offers a single static method `deriveKey` to perform key derivation.
+ *
+ * @example
+ * ```ts
+ * // Key Derivation
+ * const derivedKey = await Pbkdf2.deriveKey({
+ *   hash: 'SHA-256', // The hash function to use ('SHA-256', 'SHA-384', 'SHA-512')
+ *   password: new TextEncoder().encode('password'), // The password as a Uint8Array
+ *   salt: new Uint8Array([...]), // The salt value
+ *   iterations: 1000, // The number of iterations
+ *   length: 256 // The length of the derived key in bits
+ * });
+ * ```
+ *
+ * @remarks
+ * This class relies on the availability of the Web Crypto API.
+ */
+export declare class Pbkdf2 {
+    /**
+     * Derives a cryptographic key from a password using the PBKDF2 algorithm.
+     *
+     * @remarks
+     * This method applies the PBKDF2 algorithm to the provided password along with
+     * a salt value and iterates the process a specified number of times. It uses
+     * a cryptographic hash function to enhance security and produce a key of the
+     * desired length. The method is capable of utilizing either the Web Crypto API
+     * or the Node.js Crypto module, depending on the environment's support.
+     *
+     * @example
+     * ```ts
+     * const derivedKey = await Pbkdf2.deriveKey({
+     *   hash: 'SHA-256',
+     *   password: new TextEncoder().encode('password'),
+     *   salt: new Uint8Array([...]),
+     *   iterations: 1000,
+     *   length: 256
+     * });
+     * ```
+     *
+     * @param params - The parameters for key derivation.
+     * @param params.hash - The hash function to use, such as 'SHA-256', 'SHA-384', or 'SHA-512'.
+     * @param params.password - The password from which to derive the key, represented as a Uint8Array.
+     * @param params.salt - The salt value to use in the derivation process, as a Uint8Array.
+     * @param params.iterations - The number of iterations to apply in the PBKDF2 algorithm.
+     * @param params.length - The desired length of the derived key in bits.
+     *
+     * @returns A Promise that resolves to the derived key as a Uint8Array.
+     */
+    static deriveKey({ hash, password, salt, iterations, length }: Pbkdf2DeriveKeyParams): Promise<Uint8Array>;
+}
+//# sourceMappingURL=pbkdf2.d.ts.map

package/dist/types/primitives/pbkdf2.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"pbkdf2.d.ts","sourceRoot":"","sources":["../../../src/primitives/pbkdf2.ts"],"names":[],"mappings":"AAEA;;GAEG;AACH,MAAM,MAAM,qBAAqB,GAAG;IAClC;;;;;OAKG;IACH,IAAI,EAAE,SAAS,GAAG,SAAS,GAAG,SAAS,CAAC;IAExC;;OAEG;IACH,QAAQ,EAAE,UAAU,CAAC;IAErB;;;;OAIG;IACH,IAAI,EAAE,UAAU,CAAC;IAEjB;;;;;;OAMG;IACH,UAAU,EAAE,MAAM,CAAC;IAEnB;;;OAGG;IACH,MAAM,EAAE,MAAM,CAAC;CAChB,CAAC;AAEF;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AACH,qBAAa,MAAM;IACjB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OA6BG;WACiB,SAAS,CAAC,EAAE,IAAI,EAAE,QAAQ,EAAE,IAAI,EAAE,UAAU,EAAE,MAAM,EAAE,EACxE,qBAAqB,GACpB,OAAO,CAAC,UAAU,CAAC;CAqBvB"}