@enbox/agent 0.0.1

package/dist/esm/prototyping/crypto/algorithms/pbkdf2.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"pbkdf2.js","sourceRoot":"","sources":["../../../../../src/prototyping/crypto/algorithms/pbkdf2.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;AAAA,OAAO,EAAE,eAAe,EAAE,MAAM,eAAe,CAAC;AAMhD,OAAO,EAAE,MAAM,EAAE,MAAM,yBAAyB,CAAC;AAgBjD,MAAM,OAAO,eAAgB,SAAQ,eAAe;IAGrC,cAAc,CAAC,EAC6B;YAD7B,EAAE,SAAS,OACkB,EADb,MAAM,cAAtB,aAAwB,CAAF;;YAGhD,oEAAoE;YACpE,MAAM,CAAC,EAAE,YAAY,CAAC,GAAG,SAAS,CAAC,KAAK,CAAC,MAAM,CAAC,CAAC;YAEjD,kEAAkE;YAClE,MAAM,IAAI,GAAG;gBACX,OAAO,EAAG,SAAkB;gBAC5B,OAAO,EAAG,SAAkB;gBAC5B,OAAO,EAAG,SAAkB;aAC7B,CAAC,YAAY,CAAE,CAAC;YAEjB,kDAAkD;YAClD,MAAM,eAAe,GAAG,MAAM,MAAM,CAAC,cAAc,iCAAM,MAAM,KAAE,IAAI,IAAG,CAAC;YAEzE,OAAO,eAAe,CAAC;;KACxB;CACF"}

package/dist/esm/prototyping/crypto/crypto-error.js

@@ -0,0 +1,41 @@
+/**
+ * A custom error class for Crypto-related errors.
+ */
+export class CryptoError extends Error {
+    /**
+     * Constructs an instance of CryptoError, a custom error class for handling Crypto-related errors.
+     *
+     * @param code - A {@link CryptoErrorCode} representing the specific type of error encountered.
+     * @param message - A human-readable description of the error.
+     */
+    constructor(code, message) {
+        super(message);
+        this.code = code;
+        this.name = 'CryptoError';
+        // Ensures that instanceof works properly, the correct prototype chain when using inheritance,
+        // and that V8 stack traces (like Chrome, Edge, and Node.js) are more readable and relevant.
+        Object.setPrototypeOf(this, new.target.prototype);
+        // Captures the stack trace in V8 engines (like Chrome, Edge, and Node.js).
+        // In non-V8 environments, the stack trace will still be captured.
+        if (Error.captureStackTrace) {
+            Error.captureStackTrace(this, CryptoError);
+        }
+    }
+}
+/**
+ * An enumeration of possible Crypto error codes.
+ */
+export var CryptoErrorCode;
+(function (CryptoErrorCode) {
+    /** The supplied algorithm identifier is not supported by the implementation. */
+    CryptoErrorCode["AlgorithmNotSupported"] = "algorithmNotSupported";
+    /** The encoding operation (either encoding or decoding) failed. */
+    CryptoErrorCode["EncodingError"] = "encodingError";
+    /** The JWE supplied does not conform to valid syntax. */
+    CryptoErrorCode["InvalidJwe"] = "invalidJwe";
+    /** The JWK supplied does not conform to valid syntax. */
+    CryptoErrorCode["InvalidJwk"] = "invalidJwk";
+    /** The requested operation is not supported by the implementation. */
+    CryptoErrorCode["OperationNotSupported"] = "operationNotSupported";
+})(CryptoErrorCode || (CryptoErrorCode = {}));
+//# sourceMappingURL=crypto-error.js.map

package/dist/esm/prototyping/crypto/crypto-error.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"crypto-error.js","sourceRoot":"","sources":["../../../../src/prototyping/crypto/crypto-error.ts"],"names":[],"mappings":"AAAA;;GAEG;AACH,MAAM,OAAO,WAAY,SAAQ,KAAK;IACpC;;;;;OAKG;IACH,YAAmB,IAAqB,EAAE,OAAe;QACvD,KAAK,CAAC,OAAO,CAAC,CAAC;QADE,SAAI,GAAJ,IAAI,CAAiB;QAEtC,IAAI,CAAC,IAAI,GAAG,aAAa,CAAC;QAE1B,8FAA8F;QAC9F,4FAA4F;QAC5F,MAAM,CAAC,cAAc,CAAC,IAAI,EAAE,GAAG,CAAC,MAAM,CAAC,SAAS,CAAC,CAAC;QAElD,2EAA2E;QAC3E,kEAAkE;QAClE,IAAI,KAAK,CAAC,iBAAiB,EAAE;YAC3B,KAAK,CAAC,iBAAiB,CAAC,IAAI,EAAE,WAAW,CAAC,CAAC;SAC5C;IACH,CAAC;CACF;AAED;;GAEG;AACH,MAAM,CAAN,IAAY,eAeX;AAfD,WAAY,eAAe;IACzB,gFAAgF;IAChF,kEAA+C,CAAA;IAE/C,mEAAmE;IACnE,kDAA+B,CAAA;IAE/B,yDAAyD;IACzD,4CAAyB,CAAA;IAEzB,yDAAyD;IACzD,4CAAyB,CAAA;IAEzB,sEAAsE;IACtE,kEAA+C,CAAA;AACjD,CAAC,EAfW,eAAe,KAAf,eAAe,QAe1B"}

package/dist/esm/prototyping/crypto/dsa.js

@@ -0,0 +1,236 @@
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+import { Sha2Algorithm, computeJwkThumbprint } from '@enbox/crypto';
+import { EcdsaAlgorithm } from './algorithms/ecdsa.js';
+import { EdDsaAlgorithm } from './algorithms/eddsa.js';
+import { CryptoError, CryptoErrorCode } from './crypto-error.js';
+/**
+ * `supportedAlgorithms` is an object mapping algorithm names to their respective implementations
+ * Each entry in this map specifies the algorithm name and its associated properties, including the
+ * implementation class and any relevant names or identifiers for the algorithm. This structure
+ * allows for easy retrieval and instantiation of algorithm implementations based on the algorithm
+ * name or key specification. It facilitates the support of multiple algorithms within the
+ * `LocalKeyManager` class.
+ */
+const supportedAlgorithms = {
+    'Ed25519': {
+        implementation: EdDsaAlgorithm,
+        names: ['Ed25519'],
+        operations: ['bytesToPrivateKey', 'bytesToPublicKey', 'generateKey', 'sign', 'verify'],
+    },
+    'secp256k1': {
+        implementation: EcdsaAlgorithm,
+        names: ['ES256K', 'secp256k1'],
+        operations: ['bytesToPrivateKey', 'bytesToPublicKey', 'generateKey', 'sign', 'verify'],
+    },
+    'secp256r1': {
+        implementation: EcdsaAlgorithm,
+        names: ['ES256', 'secp256r1'],
+        operations: ['bytesToPrivateKey', 'bytesToPublicKey', 'generateKey', 'sign', 'verify'],
+    },
+    'SHA-256': {
+        implementation: Sha2Algorithm,
+        names: ['SHA-256'],
+        operations: ['digest'],
+    }
+};
+export class Dsa {
+    constructor() {
+        /**
+         * A private map that stores instances of cryptographic algorithm implementations. Each key in
+         * this map is an `AlgorithmConstructor`, and its corresponding value is an instance of a class
+         * that implements a specific cryptographic algorithm. This map is used to cache and reuse
+         * instances for performance optimization, ensuring that each algorithm is instantiated only once.
+         */
+        this._algorithmInstances = new Map();
+    }
+    bytesToPrivateKey({ algorithm: algorithmIdentifier, privateKeyBytes }) {
+        return __awaiter(this, void 0, void 0, function* () {
+            // Determine the algorithm name based on the given algorithm identifier.
+            const algorithm = this.getAlgorithmName({ algorithm: algorithmIdentifier });
+            // Get the key converter based on the algorithm name.
+            const keyConverter = this.getAlgorithm({ algorithm });
+            // Convert the byte array to a JWK.
+            const privateKey = yield keyConverter.bytesToPrivateKey({ algorithm: algorithmIdentifier, privateKeyBytes });
+            return privateKey;
+        });
+    }
+    bytesToPublicKey({ algorithm: algorithmIdentifier, publicKeyBytes }) {
+        return __awaiter(this, void 0, void 0, function* () {
+            // Determine the algorithm name based on the given algorithm identifier.
+            const algorithm = this.getAlgorithmName({ algorithm: algorithmIdentifier });
+            // Get the key converter based on the algorithm name.
+            const keyConverter = this.getAlgorithm({ algorithm });
+            // Convert the byte array to a JWK.
+            const publicKey = yield keyConverter.bytesToPublicKey({ algorithm: algorithmIdentifier, publicKeyBytes });
+            return publicKey;
+        });
+    }
+    /**
+     * 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 Dsa = new AgentDsa();
+     * const data = new Uint8Array([...]);
+     * const digest = await Dsa.digest({ algorithm: 'SHA-256', 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 }) {
+        return __awaiter(this, void 0, void 0, function* () {
+            // Get the hash function implementation based on the specified `algorithm` parameter.
+            const hasher = this.getAlgorithm({ algorithm });
+            // Compute the hash.
+            const hash = yield hasher.digest({ algorithm, data });
+            return hash;
+        });
+    }
+    generateKey(params) {
+        var _a;
+        return __awaiter(this, void 0, void 0, function* () {
+            // Determine the algorithm name based on the given algorithm identifier.
+            const algorithm = this.getAlgorithmName({ algorithm: params.algorithm });
+            // Get the key generator implementation based on the algorithm.
+            const keyGenerator = this.getAlgorithm({ algorithm });
+            // Generate the key.
+            const privateKey = yield keyGenerator.generateKey({ algorithm: params.algorithm });
+            // If the key ID is undefined, set it to the JWK thumbprint.
+            (_a = privateKey.kid) !== null && _a !== void 0 ? _a : (privateKey.kid = yield computeJwkThumbprint({ jwk: privateKey }));
+            return privateKey;
+        });
+    }
+    // ! TODO: Remove this once the `Dsa` interface is updated in @enbox/crypto to remove KMS-specific methods.
+    getKeyUri(_params) {
+        return __awaiter(this, void 0, void 0, function* () {
+            throw new Error('Method not implemented.');
+        });
+    }
+    getPublicKey({ key }) {
+        return __awaiter(this, void 0, void 0, function* () {
+            // Determine the algorithm name based on the JWK's `alg` and `crv` properties.
+            const algorithm = this.getAlgorithmName({ key });
+            // Get the key generator based on the algorithm name.
+            const keyGenerator = this.getAlgorithm({ algorithm });
+            // Get the public key properties from the private JWK.
+            const publicKey = yield keyGenerator.getPublicKey({ key });
+            return publicKey;
+        });
+    }
+    privateKeyToBytes({ privateKey }) {
+        return __awaiter(this, void 0, void 0, function* () {
+            // Determine the algorithm name based on the JWK's `alg` property.
+            const algorithm = this.getAlgorithmName({ key: privateKey });
+            // Get the key converter based on the algorithm name.
+            const keyConverter = this.getAlgorithm({ algorithm });
+            // Convert the JWK to a byte array.
+            const privateKeyBytes = yield keyConverter.privateKeyToBytes({ privateKey });
+            return privateKeyBytes;
+        });
+    }
+    publicKeyToBytes({ publicKey }) {
+        return __awaiter(this, void 0, void 0, function* () {
+            // Determine the algorithm name based on the JWK's `alg` property.
+            const algorithm = this.getAlgorithmName({ key: publicKey });
+            // Get the key converter based on the algorithm name.
+            const keyConverter = this.getAlgorithm({ algorithm });
+            // Convert the JWK to a byte array.
+            const publicKeyBytes = yield keyConverter.publicKeyToBytes({ publicKey });
+            return publicKeyBytes;
+        });
+    }
+    sign({ key, data }) {
+        return __awaiter(this, void 0, void 0, function* () {
+            // Determine the algorithm name based on the JWK's `alg` and `crv` properties.
+            const algorithm = this.getAlgorithmName({ key });
+            // Get the signature algorithm based on the algorithm name.
+            const signer = this.getAlgorithm({ algorithm });
+            // Sign the data.
+            const signature = signer.sign({ data, key });
+            return signature;
+        });
+    }
+    verify({ key, signature, data }) {
+        return __awaiter(this, void 0, void 0, function* () {
+            // Determine the algorithm name based on the JWK's `alg` and `crv` properties.
+            const algorithm = this.getAlgorithmName({ key });
+            // Get the signature algorithm based on the algorithm name.
+            const signer = this.getAlgorithm({ algorithm });
+            // Verify the signature.
+            const isSignatureValid = signer.verify({ key, signature, data });
+            return isSignatureValid;
+        });
+    }
+    /**
+     * Retrieves an algorithm implementation instance based on the provided algorithm name.
+     *
+     * @remarks
+     * This method checks if the requested algorithm is supported and returns a cached instance
+     * if available. If an instance does not exist, it creates and caches a new one. This approach
+     * optimizes performance by reusing algorithm instances across cryptographic operations.
+     *
+     * @example
+     * ```ts
+     * const signer = this.getAlgorithm({ algorithm: 'Ed25519' });
+     * ```
+     *
+     * @param params - The parameters for retrieving the algorithm implementation.
+     * @param params.algorithm - The name of the algorithm to retrieve.
+     *
+     * @returns An instance of the requested algorithm implementation.
+     *
+     * @throws Error if the requested algorithm is not supported.
+     */
+    getAlgorithm({ algorithm }) {
+        var _a;
+        // Check if algorithm is supported.
+        const AlgorithmImplementation = (_a = supportedAlgorithms[algorithm]) === null || _a === void 0 ? void 0 : _a['implementation'];
+        if (!AlgorithmImplementation) {
+            throw new CryptoError(CryptoErrorCode.AlgorithmNotSupported, `Algorithm not supported: ${algorithm}`);
+        }
+        // Check if instance already exists for the `AlgorithmImplementation`.
+        if (!this._algorithmInstances.has(AlgorithmImplementation)) {
+            // If not, create a new instance and store it in the cache
+            this._algorithmInstances.set(AlgorithmImplementation, new AlgorithmImplementation());
+        }
+        // Return the cached instance
+        return this._algorithmInstances.get(AlgorithmImplementation);
+    }
+    getAlgorithmName({ algorithm, key }) {
+        var _a;
+        const algProperty = (_a = key === null || key === void 0 ? void 0 : key.alg) !== null && _a !== void 0 ? _a : algorithm;
+        const crvProperty = key === null || key === void 0 ? void 0 : key.crv;
+        for (const algorithmIdentifier of Object.keys(supportedAlgorithms)) {
+            const algorithmNames = supportedAlgorithms[algorithmIdentifier].names;
+            if (algProperty && algorithmNames.includes(algProperty)) {
+                return algorithmIdentifier;
+            }
+            else if (crvProperty && algorithmNames.includes(crvProperty)) {
+                return algorithmIdentifier;
+            }
+        }
+        throw new CryptoError(CryptoErrorCode.AlgorithmNotSupported, `Algorithm not supported based on provided input: alg=${algProperty}, crv=${crvProperty}. ` +
+            'Please check the documentation for the list of supported algorithms.');
+    }
+}
+//# sourceMappingURL=dsa.js.map

package/dist/esm/prototyping/crypto/dsa.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"dsa.js","sourceRoot":"","sources":["../../../../src/prototyping/crypto/dsa.ts"],"names":[],"mappings":"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"}

package/dist/esm/prototyping/crypto/jose/jwe-compact.js

@@ -0,0 +1,130 @@
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+import { LocalKeyManager } from '@enbox/crypto';
+import { isValidJweHeader } from './jwe.js';
+import { FlattenedJwe } from './jwe-flattened.js';
+import { AgentCryptoApi } from '../../../crypto-api.js';
+import { CryptoError, CryptoErrorCode } from '../crypto-error.js';
+/**
+ * The `CompactJwe` class facilitates encryption and decryption processes using the JSON Web
+ * Encryption (JWE) Compact Serialization format. This class adheres to the specifications
+ * outlined in {@link https://datatracker.ietf.org/doc/html/rfc7516 | RFC 7516}, enabling secure
+ * data encapsulation through various cryptographic algorithms.
+ *
+ * Compact Serialization is a space-efficient representation of JWE, suitable for contexts
+ * where verbose data structures are impractical, such as HTTP headers. It provides mechanisms to
+ * encrypt content and protect its integrity with authenticated encryption, ensuring
+ * confidentiality, authenticity, and non-repudiation.
+ *
+ * This class supports the following operations:
+ * - Decrypting data from a compact serialized JWE string.
+ * - Encrypting data and producing a compact serialized JWE string.
+ *
+ * Usage involves specifying the cryptographic details, such as keys and algorithms, and the class
+ * handles the complexities of the JWE processing, including parsing, validating, and applying the
+ * cryptographic operations defined in the JWE specification.
+ *
+ * @example
+ * ```ts
+ *  // Example usage of encrypt method
+ * const plaintext = new TextEncoder().encode("Secret Message");
+ * const key = { kty: "oct", k: "your-secret-key" }; // Example symmetric key
+ * const protectedHeader = { alg: "dir", enc: "A256GCM" };
+ * const encryptedJweString = await CompactJwe.encrypt({
+ *   plaintext,
+ *   protectedHeader,
+ *   key,
+ * });
+ * console.log(encryptedJweString); // Outputs the JWE string in Compact Serialization format
+ * ```
+ *
+ * @example
+ * ```ts
+ * // Example usage of decrypt method
+ * const jweString = "eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9..."; // A JWE in Compact Serialization
+ * const decryptionKey = { kty: "oct", k: "your-secret-key" }; // The key must match the one used for encryption
+ * const { plaintext, protectedHeader } = await CompactJwe.decrypt({
+ *   jwe: jweString,
+ *   key: decryptionKey,
+ * });
+ * console.log(new TextDecoder().decode(plaintext)); // Outputs the decrypted message
+ * ```
+ */
+export class CompactJwe {
+    /**
+     * Decrypts a JWE string in Compact Serialization format, extracting the plaintext and
+     * reconstructing the JWE Protected Header.
+     *
+     * This method parses the compact JWE, validates its structure, and applies the appropriate
+     * decryption algorithm as specified in the JWE Protected Header. It returns the decrypted
+     * plaintext along with the reconstructed protected header, ensuring the data's authenticity
+     * and integrity.
+     *
+     * @param params - The decryption parameters including the JWE string, cryptographic key, and
+     *                 optional instances of Key Manager and Crypto API.
+     * @returns A promise resolving to the decrypted content and the JWE Protected Header.
+     * @throws {@link CryptoError} if the JWE format is invalid or decryption fails.
+     */
+    static decrypt({ jwe, key, keyManager = new LocalKeyManager(), crypto = new AgentCryptoApi(), options = {} }) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (typeof jwe !== 'string') {
+                throw new CryptoError(CryptoErrorCode.InvalidJwe, 'Invalid JWE format. JWE must be a string.');
+            }
+            // Split the JWE into its constituent parts.
+            const { 0: protectedHeader, 1: encryptedKey, 2: initializationVector, 3: ciphertext, 4: authenticationTag, length, } = jwe.split('.');
+            // Ensure that the JWE has the required number of parts.
+            if (length !== 5) {
+                throw new CryptoError(CryptoErrorCode.InvalidJwe, 'Invalid JWE format. JWE must have 5 parts.');
+            }
+            // Decrypt the JWE using the provided Key URI.
+            const flattenedJwe = yield FlattenedJwe.decrypt({
+                jwe: {
+                    ciphertext,
+                    encrypted_key: encryptedKey || undefined,
+                    iv: initializationVector || undefined,
+                    protected: protectedHeader,
+                    tag: authenticationTag || undefined,
+                },
+                key,
+                keyManager,
+                crypto,
+                options
+            });
+            if (!isValidJweHeader(flattenedJwe.protectedHeader)) {
+                throw new CryptoError(CryptoErrorCode.InvalidJwe, 'Decrypt operation failed due to missing or malformed JWE Protected Header');
+            }
+            return { plaintext: flattenedJwe.plaintext, protectedHeader: flattenedJwe.protectedHeader };
+        });
+    }
+    /**
+     * Encrypts plaintext to a JWE string in Compact Serialization format, encapsulating the content
+     * with the specified cryptographic protections.
+     *
+     * It constructs the JWE by encrypting the plaintext, then serializing the output to the
+     * compact format, which includes concatenating various components like the protected header,
+     * encrypted key, initialization vector, ciphertext, and authentication tag.
+     *
+     * @param params - The encryption parameters, including plaintext, JWE Protected Header,
+     *                 cryptographic key, and optional Key Manager and Crypto API instances.
+     * @returns A promise that resolves to a string representing the JWE in Compact Serialization
+     *          format.
+     * @throws {@link CryptoError} if encryption fails or the input parameters are invalid.
+     */
+    static encrypt({ plaintext, protectedHeader, key, keyManager = new LocalKeyManager(), crypto = new AgentCryptoApi(), options = {} }) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const jwe = yield FlattenedJwe.encrypt({ plaintext, protectedHeader, key, keyManager, crypto, options });
+            // Create the Compact Serialization, which is the string BASE64URL(UTF8(JWE Protected Header))
+            // || '.' || BASE64URL(JWE Encrypted Key) || '.' || BASE64URL(JWE Initialization Vector)
+            // || '.' || BASE64URL(JWE Ciphertext) || '.' || BASE64URL(JWE Authentication Tag).
+            return [jwe.protected, jwe.encrypted_key, jwe.iv, jwe.ciphertext, jwe.tag].join('.');
+        });
+    }
+}
+//# sourceMappingURL=jwe-compact.js.map

package/dist/esm/prototyping/crypto/jose/jwe-compact.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"jwe-compact.js","sourceRoot":"","sources":["../../../../../src/prototyping/crypto/jose/jwe-compact.ts"],"names":[],"mappings":";;;;;;;;;AAEA,OAAO,EAAE,eAAe,EAAE,MAAM,eAAe,CAAC;AAMhD,OAAO,EAAE,gBAAgB,EAAE,MAAM,UAAU,CAAC;AAC5C,OAAO,EAAE,YAAY,EAAE,MAAM,oBAAoB,CAAC;AAClD,OAAO,EAAE,cAAc,EAAE,MAAM,wBAAwB,CAAC;AACxD,OAAO,EAAE,WAAW,EAAE,eAAe,EAAE,MAAM,oBAAoB,CAAC;AAoElE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4CG;AACH,MAAM,OAAO,UAAU;IACrB;;;;;;;;;;;;;OAaG;IACI,MAAM,CAAO,OAAO,CAGzB,EACA,GAAG,EACH,GAAG,EACH,UAAU,GAAG,IAAI,eAAe,EAAE,EAClC,MAAM,GAAG,IAAI,cAAc,EAAE,EAC7B,OAAO,GAAG,EAAE,EACkC;;YAE9C,IAAI,OAAO,GAAG,KAAK,QAAQ,EAAE;gBAC3B,MAAM,IAAI,WAAW,CAAC,eAAe,CAAC,UAAU,EAAE,2CAA2C,CAAC,CAAC;aAChG;YAED,4CAA4C;YAC5C,MAAM,EACJ,CAAC,EAAE,eAAe,EAClB,CAAC,EAAE,YAAY,EACf,CAAC,EAAE,oBAAoB,EACvB,CAAC,EAAE,UAAU,EACb,CAAC,EAAE,iBAAiB,EACpB,MAAM,GACP,GAAG,GAAG,CAAC,KAAK,CAAC,GAAG,CAAC,CAAC;YAEnB,wDAAwD;YACxD,IAAI,MAAM,KAAK,CAAC,EAAE;gBAChB,MAAM,IAAI,WAAW,CAAC,eAAe,CAAC,UAAU,EAAE,4CAA4C,CAAC,CAAC;aACjG;YAED,8CAA8C;YAC9C,MAAM,YAAY,GAAG,MAAM,YAAY,CAAC,OAAO,CAAC;gBAC9C,GAAG,EAAE;oBACH,UAAU;oBACV,aAAa,EAAG,YAAY,IAAI,SAAS;oBACzC,EAAE,EAAc,oBAAoB,IAAI,SAAS;oBACjD,SAAS,EAAO,eAAe;oBAC/B,GAAG,EAAa,iBAAiB,IAAI,SAAS;iBAC/C;gBACD,GAAG;gBACH,UAAU;gBACV,MAAM;gBACN,OAAO;aACR,CAAC,CAAC;YAEH,IAAI,CAAC,gBAAgB,CAAC,YAAY,CAAC,eAAe,CAAC,EAAE;gBACnD,MAAM,IAAI,WAAW,CAAC,eAAe,CAAC,UAAU,EAAE,2EAA2E,CAAC,CAAC;aAChI;YAED,OAAO,EAAE,SAAS,EAAE,YAAY,CAAC,SAAS,EAAE,eAAe,EAAE,YAAY,CAAC,eAAe,EAAE,CAAC;QAC9F,CAAC;KAAA;IAED;;;;;;;;;;;;;OAaG;IACI,MAAM,CAAO,OAAO,CAGzB,EACA,SAAS,EACT,eAAe,EACf,GAAG,EACH,UAAU,GAAG,IAAI,eAAe,EAAE,EAClC,MAAM,GAAG,IAAI,cAAc,EAAE,EAC7B,OAAO,GAAG,EAAE,EACkC;;YAE9C,MAAM,GAAG,GAAG,MAAM,YAAY,CAAC,OAAO,CAAC,EAAE,SAAS,EAAE,eAAe,EAAE,GAAG,EAAE,UAAU,EAAE,MAAM,EAAE,OAAO,EAAE,CAAC,CAAC;YAEzG,8FAA8F;YAC9F,wFAAwF;YACxF,mFAAmF;YACnF,OAAO,CAAC,GAAG,CAAC,SAAS,EAAE,GAAG,CAAC,aAAa,EAAE,GAAG,CAAC,EAAE,EAAE,GAAG,CAAC,UAAU,EAAE,GAAG,CAAC,GAAG,CAAC,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC;QACvF,CAAC;KAAA;CACF"}