@elaraai/east-web-std 1.0.85

package/dist/src/crypto.d.ts

@@ -0,0 +1,224 @@
+/**
+ * Copyright (c) 2025 Elara AI Pty Ltd
+ * Dual-licensed under AGPL-3.0 and commercial license. See LICENSE for details.
+ */
+import { StringType, IntegerType, BlobType } from "@elaraai/east";
+import type { PlatformFunction } from "@elaraai/east/internal";
+/**
+ * Generates cryptographically secure random bytes.
+ *
+ * Produces random bytes using a cryptographically secure pseudo-random number generator (CSPRNG).
+ * Suitable for generating encryption keys, initialization vectors, tokens, and other security-sensitive
+ * random data.
+ *
+ * This is a platform function for the East language, enabling secure random generation
+ * in East programs running in a browser, from the web-standard `crypto.getRandomValues`.
+ *
+ * @param length - The number of random bytes to generate (from 0 to 2^31 - 1)
+ * @returns Random bytes as a Blob (Uint8Array)
+ *
+ * @throws {EastError} When random generation fails:
+ * - Negative length, or more than 2^31 - 1 bytes
+ * - The host's entropy source is unavailable
+ *
+ * @example
+ * ```ts
+ * const generateToken = East.function([], BlobType, $ => {
+ *     return Crypto.randomBytes(32n);  // 256-bit token
+ * });
+ * ```
+ */
+export declare const crypto_random_bytes: import("@elaraai/east").PlatformDefinition<[IntegerType], BlobType>;
+/**
+ * Computes SHA-256 hash of a string.
+ *
+ * Calculates the SHA-256 cryptographic hash of a UTF-8 encoded string and returns
+ * the result as a lowercase hexadecimal string (64 characters). SHA-256 is a one-way
+ * hash function commonly used for data integrity verification.
+ *
+ * This is a platform function for the East language, enabling cryptographic hashing
+ * in East programs running in a browser.
+ *
+ * @param data - The string to hash (will be UTF-8 encoded)
+ * @returns The SHA-256 hash as a lowercase hexadecimal string (64 characters)
+ *
+ * @example
+ * ```ts
+ * const hashPassword = East.function([StringType], StringType, ($, password) => {
+ *     return Crypto.hashSha256(password);
+ *     // Returns: "5e884898da28047151d0e56f8dc6292773603d0d6aabbdd62a11ef721d1542d8"
+ * });
+ * ```
+ *
+ * @remarks
+ * The hash is East's own SHA-256 (`sha256Hex`), not the browser's
+ * `crypto.subtle.digest`: this platform function is synchronous, as it is on
+ * every runtime, and `crypto.subtle` answers only asynchronously.
+ */
+export declare const crypto_hash_sha256: import("@elaraai/east").PlatformDefinition<[StringType], StringType>;
+/**
+ * Computes SHA-256 hash of binary data.
+ *
+ * Calculates the SHA-256 cryptographic hash of binary data and returns the result
+ * as raw bytes (32 bytes / 256 bits). This is the binary variant of {@link crypto_hash_sha256},
+ * useful when working with binary protocols or when you need the raw hash bytes.
+ *
+ * This is a platform function for the East language, enabling cryptographic hashing
+ * in East programs running in a browser.
+ *
+ * @param data - The binary data to hash (Blob/Uint8Array)
+ * @returns The SHA-256 hash as binary data (32 bytes)
+ *
+ * @example
+ * ```ts
+ * const hashFile = East.function([BlobType], BlobType, ($, fileData) => {
+ *     return Crypto.hashSha256Bytes(fileData);
+ *     // Returns: 32 bytes of hash data
+ * });
+ * ```
+ *
+ * @remarks
+ * Synchronous, like {@link crypto_hash_sha256}, for the same reason.
+ */
+export declare const crypto_hash_sha256_bytes: import("@elaraai/east").PlatformDefinition<[BlobType], BlobType>;
+/**
+ * Generates a random UUID v4.
+ *
+ * Creates a version 4 UUID (Universally Unique Identifier) using cryptographically
+ * secure random numbers. UUIDs are 128-bit identifiers formatted as 36-character
+ * strings (e.g., "550e8400-e29b-41d4-a716-446655440000").
+ *
+ * This is a platform function for the East language, enabling UUID generation
+ * in East programs running in a browser, from the web-standard `crypto.randomUUID`.
+ *
+ * @returns A UUID v4 string in standard format (8-4-4-4-12 hex digits)
+ *
+ * @example
+ * ```ts
+ * const createRecord = East.function([], StringType, $ => {
+ *     const id = $.let(Crypto.uuid());
+ *     return id;
+ *     // Returns: "550e8400-e29b-41d4-a716-446655440000"
+ * });
+ * ```
+ *
+ * @remarks
+ * A browser gives `crypto.randomUUID` only to a secure context (a page served
+ * over HTTPS, or from localhost); elsewhere the call fails with an `EastError`.
+ */
+export declare const crypto_uuid: import("@elaraai/east").PlatformDefinition<[], StringType>;
+/**
+ * Browser implementation of cryptographic platform functions.
+ *
+ * Pass this array to {@link East.compile} to enable crypto operations.
+ */
+declare const CryptoImpl: PlatformFunction[];
+/**
+ * Grouped cryptographic platform functions.
+ *
+ * Provides cryptographic operations for East programs.
+ *
+ * @example
+ * ```ts
+ * import { East, StringType } from "@elaraai/east";
+ * import { Crypto } from "@elaraai/east-web-std";
+ *
+ * const generateId = East.function([], StringType, $ => {
+ *     return Crypto.uuid();
+ * });
+ *
+ * const compiled = East.compile(generateId, Crypto.Implementation);
+ * compiled();  // "550e8400-e29b-41d4-a716-446655440000"
+ * ```
+ */
+export declare const Crypto: {
+    /**
+     * Generates cryptographically secure random bytes.
+     *
+     * Produces random bytes using a CSPRNG, suitable for generating encryption keys,
+     * tokens, and other security-sensitive random data.
+     *
+     * @param length - The number of random bytes to generate (from 0 to 2^31 - 1)
+     * @returns Random bytes as a Blob (Uint8Array)
+     * @throws {EastError} When random generation fails
+     *
+     * @example
+     * ```ts
+     * const generateToken = East.function([], BlobType, $ => {
+     *     return Crypto.randomBytes(32n);
+     * });
+     *
+     * const compiled = East.compile(generateToken, Crypto.Implementation);
+     * compiled();  // Uint8Array(32) [...]
+     * ```
+     */
+    readonly randomBytes: import("@elaraai/east").PlatformDefinition<[IntegerType], BlobType>;
+    /**
+     * Computes SHA-256 hash of a string.
+     *
+     * Calculates the SHA-256 cryptographic hash of a UTF-8 encoded string and returns
+     * the result as a lowercase hexadecimal string (64 characters).
+     *
+     * @param data - The string to hash (will be UTF-8 encoded)
+     * @returns The SHA-256 hash as a lowercase hexadecimal string (64 characters)
+     *
+     * @example
+     * ```ts
+     * const hashPassword = East.function([StringType], StringType, ($, password) => {
+     *     return Crypto.hashSha256(password);
+     * });
+     *
+     * const compiled = East.compile(hashPassword, Crypto.Implementation);
+     * compiled("password");  // "5e884898da28047151d0e56f8dc6292773603d0d6aabbdd62a11ef721d1542d8"
+     * ```
+     */
+    readonly hashSha256: import("@elaraai/east").PlatformDefinition<[StringType], StringType>;
+    /**
+     * Computes SHA-256 hash of binary data.
+     *
+     * Calculates the SHA-256 cryptographic hash of binary data and returns the result
+     * as raw bytes (32 bytes).
+     *
+     * @param data - The binary data to hash (Blob/Uint8Array)
+     * @returns The SHA-256 hash as binary data (32 bytes)
+     *
+     * @example
+     * ```ts
+     * const hashFile = East.function([BlobType], BlobType, ($, fileData) => {
+     *     return Crypto.hashSha256Bytes(fileData);
+     * });
+     *
+     * const compiled = East.compile(hashFile, Crypto.Implementation);
+     * const fileData = new Uint8Array([1, 2, 3]);
+     * compiled(fileData);  // Uint8Array(32) [...]
+     * ```
+     */
+    readonly hashSha256Bytes: import("@elaraai/east").PlatformDefinition<[BlobType], BlobType>;
+    /**
+     * Generates a random UUID v4.
+     *
+     * Creates a version 4 UUID using cryptographically secure random numbers.
+     * Returns a 36-character string in standard format.
+     *
+     * @returns A UUID v4 string in standard format (8-4-4-4-12 hex digits)
+     *
+     * @example
+     * ```ts
+     * const createRecord = East.function([], StringType, $ => {
+     *     return Crypto.uuid();
+     * });
+     *
+     * const compiled = East.compile(createRecord, Crypto.Implementation);
+     * compiled();  // "550e8400-e29b-41d4-a716-446655440000"
+     * ```
+     */
+    readonly uuid: import("@elaraai/east").PlatformDefinition<[], StringType>;
+    /**
+     * Browser implementation of cryptographic platform functions.
+     *
+     * Pass this to {@link East.compile} to enable crypto operations.
+     */
+    readonly Implementation: PlatformFunction[];
+};
+export { CryptoImpl };
+//# sourceMappingURL=crypto.d.ts.map

package/dist/src/crypto.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"crypto.d.ts","sourceRoot":"","sources":["../../src/crypto.ts"],"names":[],"mappings":"AAAA;;;GAGG;AACH,OAAO,EAAQ,UAAU,EAAE,WAAW,EAAE,QAAQ,EAAa,MAAM,eAAe,CAAC;AACnF,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,wBAAwB,CAAC;AAyB/D;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AACH,eAAO,MAAM,mBAAmB,qEAAgE,CAAC;AAEjG;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AACH,eAAO,MAAM,kBAAkB,sEAAgE,CAAC;AAEhG;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AACH,eAAO,MAAM,wBAAwB,kEAAkE,CAAC;AAExG;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AACH,eAAO,MAAM,WAAW,4DAA+C,CAAC;AAExE;;;;GAIG;AACH,QAAA,MAAM,UAAU,EAAE,gBAAgB,EAgDjC,CAAC;AAEF;;;;;;;;;;;;;;;;;GAiBG;AACH,eAAO,MAAM,MAAM;IACf;;;;;;;;;;;;;;;;;;;OAmBG;;IAGH;;;;;;;;;;;;;;;;;;OAkBG;;IAGH;;;;;;;;;;;;;;;;;;;OAmBG;;IAGH;;;;;;;;;;;;;;;;;OAiBG;;IAGH;;;;OAIG;;CAEG,CAAC;AAGX,OAAO,EAAE,UAAU,EAAE,CAAC"}

package/dist/src/crypto.js

@@ -0,0 +1,295 @@
+/**
+ * Copyright (c) 2025 Elara AI Pty Ltd
+ * Dual-licensed under AGPL-3.0 and commercial license. See LICENSE for details.
+ */
+import { East, StringType, IntegerType, BlobType, sha256Hex } from "@elaraai/east";
+import { EastError } from "@elaraai/east/internal";
+/** The most bytes `crypto.getRandomValues` fills in one call. */
+const GET_RANDOM_VALUES_MAX = 65536;
+/** The most bytes one call may ask for: east-node-std's `randomBytes` gives
+ *  no more than 2^31 - 1. */
+const RANDOM_BYTES_MAX = 2147483647n;
+/** Encodes a string as UTF-8, as east-node-std hashes it. */
+const utf8 = new TextEncoder();
+/**
+ * The bytes of a SHA-256 digest, from the 64 lowercase hex digits
+ * {@link sha256Hex} gives for it.
+ */
+function digestBytes(hex) {
+    const bytes = new Uint8Array(hex.length / 2);
+    for (let i = 0; i < bytes.length; i++) {
+        bytes[i] = parseInt(hex.slice(2 * i, 2 * i + 2), 16);
+    }
+    return bytes;
+}
+/**
+ * Generates cryptographically secure random bytes.
+ *
+ * Produces random bytes using a cryptographically secure pseudo-random number generator (CSPRNG).
+ * Suitable for generating encryption keys, initialization vectors, tokens, and other security-sensitive
+ * random data.
+ *
+ * This is a platform function for the East language, enabling secure random generation
+ * in East programs running in a browser, from the web-standard `crypto.getRandomValues`.
+ *
+ * @param length - The number of random bytes to generate (from 0 to 2^31 - 1)
+ * @returns Random bytes as a Blob (Uint8Array)
+ *
+ * @throws {EastError} When random generation fails:
+ * - Negative length, or more than 2^31 - 1 bytes
+ * - The host's entropy source is unavailable
+ *
+ * @example
+ * ```ts
+ * const generateToken = East.function([], BlobType, $ => {
+ *     return Crypto.randomBytes(32n);  // 256-bit token
+ * });
+ * ```
+ */
+export const crypto_random_bytes = East.platform("crypto_random_bytes", [IntegerType], BlobType);
+/**
+ * Computes SHA-256 hash of a string.
+ *
+ * Calculates the SHA-256 cryptographic hash of a UTF-8 encoded string and returns
+ * the result as a lowercase hexadecimal string (64 characters). SHA-256 is a one-way
+ * hash function commonly used for data integrity verification.
+ *
+ * This is a platform function for the East language, enabling cryptographic hashing
+ * in East programs running in a browser.
+ *
+ * @param data - The string to hash (will be UTF-8 encoded)
+ * @returns The SHA-256 hash as a lowercase hexadecimal string (64 characters)
+ *
+ * @example
+ * ```ts
+ * const hashPassword = East.function([StringType], StringType, ($, password) => {
+ *     return Crypto.hashSha256(password);
+ *     // Returns: "5e884898da28047151d0e56f8dc6292773603d0d6aabbdd62a11ef721d1542d8"
+ * });
+ * ```
+ *
+ * @remarks
+ * The hash is East's own SHA-256 (`sha256Hex`), not the browser's
+ * `crypto.subtle.digest`: this platform function is synchronous, as it is on
+ * every runtime, and `crypto.subtle` answers only asynchronously.
+ */
+export const crypto_hash_sha256 = East.platform("crypto_hash_sha256", [StringType], StringType);
+/**
+ * Computes SHA-256 hash of binary data.
+ *
+ * Calculates the SHA-256 cryptographic hash of binary data and returns the result
+ * as raw bytes (32 bytes / 256 bits). This is the binary variant of {@link crypto_hash_sha256},
+ * useful when working with binary protocols or when you need the raw hash bytes.
+ *
+ * This is a platform function for the East language, enabling cryptographic hashing
+ * in East programs running in a browser.
+ *
+ * @param data - The binary data to hash (Blob/Uint8Array)
+ * @returns The SHA-256 hash as binary data (32 bytes)
+ *
+ * @example
+ * ```ts
+ * const hashFile = East.function([BlobType], BlobType, ($, fileData) => {
+ *     return Crypto.hashSha256Bytes(fileData);
+ *     // Returns: 32 bytes of hash data
+ * });
+ * ```
+ *
+ * @remarks
+ * Synchronous, like {@link crypto_hash_sha256}, for the same reason.
+ */
+export const crypto_hash_sha256_bytes = East.platform("crypto_hash_sha256_bytes", [BlobType], BlobType);
+/**
+ * Generates a random UUID v4.
+ *
+ * Creates a version 4 UUID (Universally Unique Identifier) using cryptographically
+ * secure random numbers. UUIDs are 128-bit identifiers formatted as 36-character
+ * strings (e.g., "550e8400-e29b-41d4-a716-446655440000").
+ *
+ * This is a platform function for the East language, enabling UUID generation
+ * in East programs running in a browser, from the web-standard `crypto.randomUUID`.
+ *
+ * @returns A UUID v4 string in standard format (8-4-4-4-12 hex digits)
+ *
+ * @example
+ * ```ts
+ * const createRecord = East.function([], StringType, $ => {
+ *     const id = $.let(Crypto.uuid());
+ *     return id;
+ *     // Returns: "550e8400-e29b-41d4-a716-446655440000"
+ * });
+ * ```
+ *
+ * @remarks
+ * A browser gives `crypto.randomUUID` only to a secure context (a page served
+ * over HTTPS, or from localhost); elsewhere the call fails with an `EastError`.
+ */
+export const crypto_uuid = East.platform("crypto_uuid", [], StringType);
+/**
+ * Browser implementation of cryptographic platform functions.
+ *
+ * Pass this array to {@link East.compile} to enable crypto operations.
+ */
+const CryptoImpl = [
+    crypto_random_bytes.implement((length) => {
+        try {
+            if (length < 0n || length > RANDOM_BYTES_MAX) {
+                throw new RangeError(`the length must be from 0 to ${RANDOM_BYTES_MAX}, got ${length}`);
+            }
+            const bytes = new Uint8Array(Number(length));
+            for (let offset = 0; offset < bytes.length; offset += GET_RANDOM_VALUES_MAX) {
+                globalThis.crypto.getRandomValues(bytes.subarray(offset, offset + GET_RANDOM_VALUES_MAX));
+            }
+            return bytes;
+        }
+        catch (err) {
+            throw new EastError(`Failed to generate random bytes: ${err.message}`, {
+                location: [{ filename: "crypto_random_bytes", line: 0n, column: 0n }],
+                cause: err
+            });
+        }
+    }),
+    crypto_hash_sha256.implement((data) => {
+        try {
+            return sha256Hex(utf8.encode(data));
+        }
+        catch (err) {
+            throw new EastError(`Failed to compute SHA-256 hash: ${err.message}`, {
+                location: [{ filename: "crypto_hash_sha256", line: 0n, column: 0n }],
+                cause: err
+            });
+        }
+    }),
+    crypto_hash_sha256_bytes.implement((data) => {
+        try {
+            return digestBytes(sha256Hex(data));
+        }
+        catch (err) {
+            throw new EastError(`Failed to compute SHA-256 hash: ${err.message}`, {
+                location: [{ filename: "crypto_hash_sha256_bytes", line: 0n, column: 0n }],
+                cause: err
+            });
+        }
+    }),
+    crypto_uuid.implement(() => {
+        try {
+            return globalThis.crypto.randomUUID();
+        }
+        catch (err) {
+            throw new EastError(`Failed to generate UUID: ${err.message}`, {
+                location: [{ filename: "crypto_uuid", line: 0n, column: 0n }],
+                cause: err
+            });
+        }
+    }),
+];
+/**
+ * Grouped cryptographic platform functions.
+ *
+ * Provides cryptographic operations for East programs.
+ *
+ * @example
+ * ```ts
+ * import { East, StringType } from "@elaraai/east";
+ * import { Crypto } from "@elaraai/east-web-std";
+ *
+ * const generateId = East.function([], StringType, $ => {
+ *     return Crypto.uuid();
+ * });
+ *
+ * const compiled = East.compile(generateId, Crypto.Implementation);
+ * compiled();  // "550e8400-e29b-41d4-a716-446655440000"
+ * ```
+ */
+export const Crypto = {
+    /**
+     * Generates cryptographically secure random bytes.
+     *
+     * Produces random bytes using a CSPRNG, suitable for generating encryption keys,
+     * tokens, and other security-sensitive random data.
+     *
+     * @param length - The number of random bytes to generate (from 0 to 2^31 - 1)
+     * @returns Random bytes as a Blob (Uint8Array)
+     * @throws {EastError} When random generation fails
+     *
+     * @example
+     * ```ts
+     * const generateToken = East.function([], BlobType, $ => {
+     *     return Crypto.randomBytes(32n);
+     * });
+     *
+     * const compiled = East.compile(generateToken, Crypto.Implementation);
+     * compiled();  // Uint8Array(32) [...]
+     * ```
+     */
+    randomBytes: crypto_random_bytes,
+    /**
+     * Computes SHA-256 hash of a string.
+     *
+     * Calculates the SHA-256 cryptographic hash of a UTF-8 encoded string and returns
+     * the result as a lowercase hexadecimal string (64 characters).
+     *
+     * @param data - The string to hash (will be UTF-8 encoded)
+     * @returns The SHA-256 hash as a lowercase hexadecimal string (64 characters)
+     *
+     * @example
+     * ```ts
+     * const hashPassword = East.function([StringType], StringType, ($, password) => {
+     *     return Crypto.hashSha256(password);
+     * });
+     *
+     * const compiled = East.compile(hashPassword, Crypto.Implementation);
+     * compiled("password");  // "5e884898da28047151d0e56f8dc6292773603d0d6aabbdd62a11ef721d1542d8"
+     * ```
+     */
+    hashSha256: crypto_hash_sha256,
+    /**
+     * Computes SHA-256 hash of binary data.
+     *
+     * Calculates the SHA-256 cryptographic hash of binary data and returns the result
+     * as raw bytes (32 bytes).
+     *
+     * @param data - The binary data to hash (Blob/Uint8Array)
+     * @returns The SHA-256 hash as binary data (32 bytes)
+     *
+     * @example
+     * ```ts
+     * const hashFile = East.function([BlobType], BlobType, ($, fileData) => {
+     *     return Crypto.hashSha256Bytes(fileData);
+     * });
+     *
+     * const compiled = East.compile(hashFile, Crypto.Implementation);
+     * const fileData = new Uint8Array([1, 2, 3]);
+     * compiled(fileData);  // Uint8Array(32) [...]
+     * ```
+     */
+    hashSha256Bytes: crypto_hash_sha256_bytes,
+    /**
+     * Generates a random UUID v4.
+     *
+     * Creates a version 4 UUID using cryptographically secure random numbers.
+     * Returns a 36-character string in standard format.
+     *
+     * @returns A UUID v4 string in standard format (8-4-4-4-12 hex digits)
+     *
+     * @example
+     * ```ts
+     * const createRecord = East.function([], StringType, $ => {
+     *     return Crypto.uuid();
+     * });
+     *
+     * const compiled = East.compile(createRecord, Crypto.Implementation);
+     * compiled();  // "550e8400-e29b-41d4-a716-446655440000"
+     * ```
+     */
+    uuid: crypto_uuid,
+    /**
+     * Browser implementation of cryptographic platform functions.
+     *
+     * Pass this to {@link East.compile} to enable crypto operations.
+     */
+    Implementation: CryptoImpl,
+};
+// Exported beside `Crypto.Implementation`, as east-node-std exports it
+export { CryptoImpl };
+//# sourceMappingURL=crypto.js.map

package/dist/src/crypto.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"crypto.js","sourceRoot":"","sources":["../../src/crypto.ts"],"names":[],"mappings":"AAAA;;;GAGG;AACH,OAAO,EAAE,IAAI,EAAE,UAAU,EAAE,WAAW,EAAE,QAAQ,EAAE,SAAS,EAAE,MAAM,eAAe,CAAC;AAEnF,OAAO,EAAE,SAAS,EAAE,MAAM,wBAAwB,CAAC;AAEnD,iEAAiE;AACjE,MAAM,qBAAqB,GAAG,KAAK,CAAC;AAEpC;6BAC6B;AAC7B,MAAM,gBAAgB,GAAG,WAAW,CAAC;AAErC,6DAA6D;AAC7D,MAAM,IAAI,GAAG,IAAI,WAAW,EAAE,CAAC;AAE/B;;;GAGG;AACH,SAAS,WAAW,CAAC,GAAW;IAC5B,MAAM,KAAK,GAAG,IAAI,UAAU,CAAC,GAAG,CAAC,MAAM,GAAG,CAAC,CAAC,CAAC;IAC7C,KAAK,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,KAAK,CAAC,MAAM,EAAE,CAAC,EAAE,EAAE,CAAC;QACpC,KAAK,CAAC,CAAC,CAAC,GAAG,QAAQ,CAAC,GAAG,CAAC,KAAK,CAAC,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,CAAC,GAAG,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC;IACzD,CAAC;IACD,OAAO,KAAK,CAAC;AACjB,CAAC;AAED;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AACH,MAAM,CAAC,MAAM,mBAAmB,GAAG,IAAI,CAAC,QAAQ,CAAC,qBAAqB,EAAE,CAAC,WAAW,CAAC,EAAE,QAAQ,CAAC,CAAC;AAEjG;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AACH,MAAM,CAAC,MAAM,kBAAkB,GAAG,IAAI,CAAC,QAAQ,CAAC,oBAAoB,EAAE,CAAC,UAAU,CAAC,EAAE,UAAU,CAAC,CAAC;AAEhG;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AACH,MAAM,CAAC,MAAM,wBAAwB,GAAG,IAAI,CAAC,QAAQ,CAAC,0BAA0B,EAAE,CAAC,QAAQ,CAAC,EAAE,QAAQ,CAAC,CAAC;AAExG;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AACH,MAAM,CAAC,MAAM,WAAW,GAAG,IAAI,CAAC,QAAQ,CAAC,aAAa,EAAE,EAAE,EAAE,UAAU,CAAC,CAAC;AAExE;;;;GAIG;AACH,MAAM,UAAU,GAAuB;IACnC,mBAAmB,CAAC,SAAS,CAAC,CAAC,MAAc,EAAE,EAAE;QAC7C,IAAI,CAAC;YACD,IAAI,MAAM,GAAG,EAAE,IAAI,MAAM,GAAG,gBAAgB,EAAE,CAAC;gBAC3C,MAAM,IAAI,UAAU,CAAC,gCAAgC,gBAAgB,SAAS,MAAM,EAAE,CAAC,CAAC;YAC5F,CAAC;YACD,MAAM,KAAK,GAAG,IAAI,UAAU,CAAC,MAAM,CAAC,MAAM,CAAC,CAAC,CAAC;YAC7C,KAAK,IAAI,MAAM,GAAG,CAAC,EAAE,MAAM,GAAG,KAAK,CAAC,MAAM,EAAE,MAAM,IAAI,qBAAqB,EAAE,CAAC;gBAC1E,UAAU,CAAC,MAAM,CAAC,eAAe,CAAC,KAAK,CAAC,QAAQ,CAAC,MAAM,EAAE,MAAM,GAAG,qBAAqB,CAAC,CAAC,CAAC;YAC9F,CAAC;YACD,OAAO,KAAK,CAAC;QACjB,CAAC;QAAC,OAAO,GAAQ,EAAE,CAAC;YAChB,MAAM,IAAI,SAAS,CAAC,oCAAoC,GAAG,CAAC,OAAO,EAAE,EAAE;gBACnE,QAAQ,EAAE,CAAC,EAAE,QAAQ,EAAE,qBAAqB,EAAE,IAAI,EAAE,EAAE,EAAE,MAAM,EAAE,EAAE,EAAE,CAAC;gBACrE,KAAK,EAAE,GAAG;aACb,CAAC,CAAC;QACP,CAAC;IACL,CAAC,CAAC;IACF,kBAAkB,CAAC,SAAS,CAAC,CAAC,IAAY,EAAE,EAAE;QAC1C,IAAI,CAAC;YACD,OAAO,SAAS,CAAC,IAAI,CAAC,MAAM,CAAC,IAAI,CAAC,CAAC,CAAC;QACxC,CAAC;QAAC,OAAO,GAAQ,EAAE,CAAC;YAChB,MAAM,IAAI,SAAS,CAAC,mCAAmC,GAAG,CAAC,OAAO,EAAE,EAAE;gBAClE,QAAQ,EAAE,CAAC,EAAE,QAAQ,EAAE,oBAAoB,EAAE,IAAI,EAAE,EAAE,EAAE,MAAM,EAAE,EAAE,EAAE,CAAC;gBACpE,KAAK,EAAE,GAAG;aACb,CAAC,CAAC;QACP,CAAC;IACL,CAAC,CAAC;IACF,wBAAwB,CAAC,SAAS,CAAC,CAAC,IAAgB,EAAE,EAAE;QACpD,IAAI,CAAC;YACD,OAAO,WAAW,CAAC,SAAS,CAAC,IAAI,CAAC,CAAC,CAAC;QACxC,CAAC;QAAC,OAAO,GAAQ,EAAE,CAAC;YAChB,MAAM,IAAI,SAAS,CAAC,mCAAmC,GAAG,CAAC,OAAO,EAAE,EAAE;gBAClE,QAAQ,EAAE,CAAC,EAAE,QAAQ,EAAE,0BAA0B,EAAE,IAAI,EAAE,EAAE,EAAE,MAAM,EAAE,EAAE,EAAE,CAAC;gBAC1E,KAAK,EAAE,GAAG;aACb,CAAC,CAAC;QACP,CAAC;IACL,CAAC,CAAC;IACF,WAAW,CAAC,SAAS,CAAC,GAAG,EAAE;QACvB,IAAI,CAAC;YACD,OAAO,UAAU,CAAC,MAAM,CAAC,UAAU,EAAE,CAAC;QAC1C,CAAC;QAAC,OAAO,GAAQ,EAAE,CAAC;YAChB,MAAM,IAAI,SAAS,CAAC,4BAA4B,GAAG,CAAC,OAAO,EAAE,EAAE;gBAC3D,QAAQ,EAAE,CAAC,EAAE,QAAQ,EAAE,aAAa,EAAE,IAAI,EAAE,EAAE,EAAE,MAAM,EAAE,EAAE,EAAE,CAAC;gBAC7D,KAAK,EAAE,GAAG;aACb,CAAC,CAAC;QACP,CAAC;IACL,CAAC,CAAC;CACL,CAAC;AAEF;;;;;;;;;;;;;;;;;GAiBG;AACH,MAAM,CAAC,MAAM,MAAM,GAAG;IAClB;;;;;;;;;;;;;;;;;;;OAmBG;IACH,WAAW,EAAE,mBAAmB;IAEhC;;;;;;;;;;;;;;;;;;OAkBG;IACH,UAAU,EAAE,kBAAkB;IAE9B;;;;;;;;;;;;;;;;;;;OAmBG;IACH,eAAe,EAAE,wBAAwB;IAEzC;;;;;;;;;;;;;;;;;OAiBG;IACH,IAAI,EAAE,WAAW;IAEjB;;;;OAIG;IACH,cAAc,EAAE,UAAU;CACpB,CAAC;AAEX,uEAAuE;AACvE,OAAO,EAAE,UAAU,EAAE,CAAC"}