wasm-cel 0.1.0 → 0.2.0

package/README.md

@@ -1,6 +1,7 @@
 # wasm-cel
 
-WebAssembly module for evaluating CEL (Common Expression Language) expressions in Node.js.
+WebAssembly module for evaluating CEL (Common Expression Language) expressions
+in Node.js.
 
 ## Installation
 
@@ -14,7 +15,8 @@ yarn add wasm-cel
 
 ## Usage
 
-The library follows the CEL pattern: create an environment, compile an expression, and then evaluate it:
+The library follows the CEL pattern: create an environment, compile an
+expression, and then evaluate it:
 
 ```typescript
 import { Env } from "wasm-cel";
@@ -48,17 +50,222 @@ const result3 = await program2.eval({ name: "Alice", age: 30 });
 console.log(result3); // "Alice is 30 years old"
 ```
 
+## CEL Environment Options
+
+The library supports configurable CEL environment options to enable additional
+CEL features. Options can be provided during environment creation or added later
+using the `extend()` method.
+
+### Available Options
+
+#### OptionalTypes
+
+Enables support for optional syntax and types in CEL, including optional field
+access (`obj.?field`), optional indexing (`list[?0]`), and optional value
+creation (`optional.of(value)`).
+
+```typescript
+import { Env, Options } from "wasm-cel";
+
+const env = await Env.new({
+  variables: [
+    {
+      name: "data",
+      type: { kind: "map", keyType: "string", valueType: "string" },
+    },
+  ],
+  options: [Options.optionalTypes()],
+});
+
+const program = await env.compile('data.?name.orValue("Anonymous")');
+const result = await program.eval({ data: {} });
+console.log(result); // "Anonymous"
+```
+
+#### ASTValidators
+
+Enables custom validation rules during CEL expression compilation. Validators
+can report errors, warnings, or info messages that are collected during
+compilation and can prevent compilation or provide detailed feedback.
+
+**Location Information**: Each AST node provides accurate location information
+through `nodeData.location` with `line` and `column` properties, enabling
+precise error reporting.
+
+```typescript
+import { Env, Options } from "wasm-cel";
+
+const env = await Env.new({
+  variables: [
+    {
+      name: "user",
+      type: { kind: "map", keyType: "string", valueType: "string" },
+    },
+  ],
+  options: [
+    Options.astValidators({
+      validators: [
+        // Validator that warns about accessing potentially unsafe fields
+        (nodeType, nodeData, context) => {
+          if (nodeType === "select" && nodeData.field === "password") {
+            return {
+              issues: [
+                {
+                  severity: "warning",
+                  message: "Accessing password field may not be secure",
+                  location: nodeData.location, // Precise location from AST
+                },
+              ],
+            };
+          }
+        },
+        // Validator that prevents certain function calls
+        (nodeType, nodeData, context) => {
+          if (
+            nodeType === "call" &&
+            nodeData.function === "dangerousFunction"
+          ) {
+            return {
+              issues: [
+                {
+                  severity: "error",
+                  message: "Use of dangerousFunction is not allowed",
+                  location: nodeData.location, // Precise location from AST
+                },
+              ],
+            };
+          }
+        },
+      ],
+      options: {
+        failOnWarning: false, // Don't fail compilation on warnings
+        includeWarnings: true, // Include warnings in results
+      },
+    }),
+  ],
+});
+
+// Use compileDetailed() to see validation issues
+const result = await env.compileDetailed("user.password");
+if (result.success) {
+  console.log("Compiled with issues:", result.issues);
+  // Example issue: { severity: "warning", message: "...", location: { line: 1, column: 5 } }
+  const evalResult = await result.program.eval({
+    user: { password: "secret" },
+  });
+} else {
+  console.log("Compilation failed:", result.error);
+}
+```
+
+**Available Node Types and Data:**
+
+- **`select`**: Field access (`obj.field`)
+  - `nodeData.field`: Field name
+  - `nodeData.testOnly`: Whether it's a test-only access
+  - `nodeData.location`: Position in source
+- **`call`**: Function calls (`func(args)`)
+  - `nodeData.function`: Function name
+  - `nodeData.argCount`: Number of arguments
+  - `nodeData.hasTarget`: Whether it's a method call
+  - `nodeData.location`: Position in source
+- **`literal`**: Literal values (`"string"`, `42`, `true`)
+  - `nodeData.value`: The literal value
+  - `nodeData.type`: Type name
+  - `nodeData.location`: Position in source
+- **`ident`**: Variable references (`varName`)
+  - `nodeData.name`: Variable name
+  - `nodeData.location`: Position in source
+- **`list`**: List literals (`[1, 2, 3]`)
+  - `nodeData.elementCount`: Number of elements
+  - `nodeData.location`: Position in source
+- **`map`**: Map literals (`{"key": "value"}`)
+  - `nodeData.entryCount`: Number of entries
+  - `nodeData.location`: Position in source
+
+#### CrossTypeNumericComparisons
+
+Enables cross-type numeric comparisons for ordering operators (`<`, `<=`, `>`,
+`>=`). This allows comparing values of different numeric types like
+`double > int` or `int <= double`. Note that this only affects ordering
+operators, not equality operators (`==`, `!=`).
+
+```typescript
+import { Env, Options } from "wasm-cel";
+
+const env = await Env.new({
+  variables: [
+    { name: "doubleValue", type: "double" },
+    { name: "intValue", type: "int" },
+  ],
+  options: [Options.crossTypeNumericComparisons()],
+});
+
+// Now you can use cross-type ordering comparisons:
+const program = await env.compile("doubleValue > intValue");
+const result = await program.eval({ doubleValue: 3.14, intValue: 3 });
+console.log(result); // true
+
+// Works with all ordering operators
+const program2 = await env.compile("intValue <= doubleValue + 1.0");
+const result2 = await program2.eval({ doubleValue: 2.5, intValue: 3 });
+console.log(result2); // true
+```
+
+### Adding Options After Creation
+
+You can also extend an environment with options after it's created:
+
+```typescript
+const env = await Env.new({
+  variables: [
+    {
+      name: "data",
+      type: { kind: "map", keyType: "string", valueType: "string" },
+    },
+  ],
+});
+
+// Add options later
+await env.extend([Options.optionalTypes()]);
+
+const program = await env.compile('data.?greeting.orValue("Hello")');
+const result = await program.eval({ data: {} });
+console.log(result); // "Hello"
+```
+
+### Complex Options with Setup
+
+The library supports an inverted architecture where complex options can handle
+their own JavaScript-side setup operations. This enables options that need to
+register custom functions or perform other setup tasks.
+
+**Architecture Benefits:**
+
+- Options handle their own complexity and setup operations
+- Environment class stays simple and focused
+- Easy to add new complex options without modifying core code
+- Clean separation of concerns
+
+Complex options implement the `OptionWithSetup` interface and can perform setup
+operations before being applied to the environment.
+
 ## API
 
 ### `Env.new(options?: EnvOptions): Promise<Env>`
 
-Creates a new CEL environment with variable declarations and optional function definitions.
+Creates a new CEL environment with variable declarations, optional function
+definitions, and CEL environment options.
 
 **Parameters:**
 
 - `options` (EnvOptions, optional): Options including:
-  - `variables` (VariableDeclaration[], optional): Array of variable declarations with name and type
-  - `functions` (CELFunctionDefinition[], optional): Array of custom function definitions
+  - `variables` (VariableDeclaration[], optional): Array of variable
+    declarations with name and type
+  - `functions` (CELFunctionDefinition[], optional): Array of custom function
+    definitions
+  - `options` (EnvOptionInput[], optional): Array of CEL environment options
+    (like OptionalTypes)
 
 **Returns:**
 
@@ -67,10 +274,18 @@ Creates a new CEL environment with variable declarations and optional function d
 **Example:**
 
 ```typescript
+import { Env, Options } from "wasm-cel";
+
 const env = await Env.new({
   variables: [
     { name: "x", type: "int" },
-    { name: "y", type: "string" },
+    {
+      name: "data",
+      type: { kind: "map", keyType: "string", valueType: "string" },
+    },
+  ],
+  options: [
+    Options.optionalTypes(), // Enable optional syntax like data.?field
   ],
 });
 ```
@@ -93,9 +308,75 @@ Compiles a CEL expression in the environment.
 const program = await env.compile("x + 10");
 ```
 
+### `env.compileDetailed(expr: string): Promise<CompilationResult>`
+
+Compiles a CEL expression with detailed results including warnings and
+validation issues. This method is particularly useful when using ASTValidators
+or when you need comprehensive feedback about the compilation process.
+
+**Parameters:**
+
+- `expr` (string): The CEL expression to compile
+
+**Returns:**
+
+- `Promise<CompilationResult>`: A promise that resolves to detailed compilation
+  results with:
+  - `success` (boolean): Whether compilation succeeded
+  - `error` (string, optional): Error message if compilation failed completely
+  - `issues` (CompilationIssue[]): All issues found during compilation (errors,
+    warnings, info)
+  - `program` (Program, optional): The compiled program if compilation succeeded
+
+**Example:**
+
+```typescript
+const result = await env.compileDetailed("user.password");
+if (result.success) {
+  console.log("Compiled successfully");
+  if (result.issues.length > 0) {
+    console.log("Validation issues:", result.issues);
+    // Example issue: { severity: "warning", message: "Accessing password field may not be secure" }
+  }
+  const evalResult = await result.program.eval({
+    user: { password: "secret" },
+  });
+} else {
+  console.log("Compilation failed:", result.error);
+  console.log("All issues:", result.issues);
+}
+```
+
+### `env.extend(options: EnvOptionInput[]): Promise<void>`
+
+Extends the environment with additional CEL environment options after creation.
+
+**Parameters:**
+
+- `options` (EnvOptionInput[]): Array of CEL environment option configurations
+  or complex options with setup
+
+**Returns:**
+
+- `Promise<void>`: A promise that resolves when the environment has been
+  extended
+
+**Example:**
+
+```typescript
+const env = await Env.new({
+  variables: [{ name: "x", type: "int" }],
+});
+
+// Add options after creation
+await env.extend([Options.optionalTypes()]);
+```
+
 ### `env.typecheck(expr: string): Promise<TypeCheckResult>`
 
-Typechecks a CEL expression in the environment without compiling it. This is useful for validating expressions and getting type information before compilation.
+Typechecks a CEL expression in the environment without compiling it. This is
+useful for validating expressions and getting type information before
+compilation.
 
 **Parameters:**
 
@@ -103,7 +384,8 @@ Typechecks a CEL expression in the environment without compiling it. This is use
 
 **Returns:**
 
-- `Promise<TypeCheckResult>`: A promise that resolves to type information with a `type` property containing the inferred type
+- `Promise<TypeCheckResult>`: A promise that resolves to type information with a
+  `type` property containing the inferred type
 
 **Example:**
 
@@ -141,7 +423,8 @@ Evaluates the compiled program with the given variables.
 
 **Parameters:**
 
-- `vars` (Record<string, any> | null, optional): Variables to use in the evaluation. Defaults to `null`.
+- `vars` (Record<string, any> | null, optional): Variables to use in the
+  evaluation. Defaults to `null`.
 
 **Returns:**
 
@@ -155,9 +438,13 @@ const result = await program.eval({ x: 5 });
 
 ### `env.destroy(): void`
 
-Destroys the environment and marks it as destroyed. After calling `destroy()`, you cannot create new programs or typecheck expressions with this environment. However, programs that were already created from this environment will continue to work until they are destroyed themselves.
+Destroys the environment and marks it as destroyed. After calling `destroy()`,
+you cannot create new programs or typecheck expressions with this environment.
+However, programs that were already created from this environment will continue
+to work until they are destroyed themselves.
 
-**Note:** This method is idempotent - calling it multiple times is safe and has no effect after the first call.
+**Note:** This method is idempotent - calling it multiple times is safe and has
+no effect after the first call.
 
 **Example:**
 
@@ -178,9 +465,11 @@ console.log(result); // 30
 
 ### `program.destroy(): void`
 
-Destroys the compiled program and frees associated WASM resources. After calling `destroy()`, you cannot evaluate the program anymore.
+Destroys the compiled program and frees associated WASM resources. After calling
+`destroy()`, you cannot evaluate the program anymore.
 
-**Note:** This method is idempotent - calling it multiple times is safe and has no effect after the first call.
+**Note:** This method is idempotent - calling it multiple times is safe and has
+no effect after the first call.
 
 **Example:**
 
@@ -194,15 +483,18 @@ await expect(program.eval()).rejects.toThrow();
 
 ### `init(): Promise<void>`
 
-Initializes the WASM module. This is called automatically by the API functions, but can be called manually to pre-initialize the module.
+Initializes the WASM module. This is called automatically by the API functions,
+but can be called manually to pre-initialize the module.
 
 ## Memory Management
 
-This library implements comprehensive memory leak prevention mechanisms to ensure WASM resources are properly cleaned up.
+This library implements comprehensive memory leak prevention mechanisms to
+ensure WASM resources are properly cleaned up.
 
 ### Explicit Cleanup
 
-Both `Env` and `Program` instances provide a `destroy()` method for explicit cleanup:
+Both `Env` and `Program` instances provide a `destroy()` method for explicit
+cleanup:
 
 ```typescript
 const env = await Env.new();
@@ -215,29 +507,38 @@ env.destroy();
 
 ### Automatic Cleanup with FinalizationRegistry
 
-The library uses JavaScript's `FinalizationRegistry` (available in Node.js 14+) to automatically clean up resources when objects are garbage collected. This provides a **best-effort** safety net in case you forget to call `destroy()`.
+The library uses JavaScript's `FinalizationRegistry` (available in Node.js 14+)
+to automatically clean up resources when objects are garbage collected. This
+provides a **best-effort** safety net in case you forget to call `destroy()`.
 
 **Important limitations:**
 
 - FinalizationRegistry callbacks are not guaranteed to run immediately or at all
-- They may run long after an object is garbage collected, or not at all in some cases
-- The timing is non-deterministic and depends on the JavaScript engine's garbage collector
+- They may run long after an object is garbage collected, or not at all in some
+  cases
+- The timing is non-deterministic and depends on the JavaScript engine's garbage
+  collector
 
-**Best practice:** Always explicitly call `destroy()` when you're done with an environment or program. Don't rely solely on automatic cleanup.
+**Best practice:** Always explicitly call `destroy()` when you're done with an
+environment or program. Don't rely solely on automatic cleanup.
 
 ### Reference Counting for Custom Functions
 
-The library uses reference counting to manage custom JavaScript functions registered with environments:
+The library uses reference counting to manage custom JavaScript functions
+registered with environments:
 
-1. **When a program is created** from an environment, reference counts are incremented for all custom functions in that environment
+1. **When a program is created** from an environment, reference counts are
+   incremented for all custom functions in that environment
 2. **When a program is destroyed**, reference counts are decremented
 3. **Functions are only unregistered** when their reference count reaches zero
 
 This means:
 
 - **Programs continue to work** even after their parent environment is destroyed
-- **Functions remain available** as long as any program that might use them still exists
-- **Functions are automatically cleaned up** when all programs using them are destroyed
+- **Functions remain available** as long as any program that might use them
+  still exists
+- **Functions are automatically cleaned up** when all programs using them are
+  destroyed
 
 **Example:**
 
@@ -266,14 +567,17 @@ program.destroy();
 
 - **Destroyed environments** cannot create new programs or typecheck expressions
 - **Existing programs** from a destroyed environment continue to work
-- **The environment entry** is cleaned up when all programs using it are destroyed
+- **The environment entry** is cleaned up when all programs using it are
+  destroyed
 
 ### Best Practices
 
 1. **Always call `destroy()`** when you're done with environments and programs
-2. **Destroy programs before environments** if you want to ensure functions are cleaned up immediately
+2. **Destroy programs before environments** if you want to ensure functions are
+   cleaned up immediately
 3. **Don't rely on automatic cleanup** - it's a safety net, not a guarantee
-4. **In long-running applications**, explicitly manage the lifecycle of resources to prevent memory leaks
+4. **In long-running applications**, explicitly manage the lifecycle of
+   resources to prevent memory leaks
 
 ## TypeScript Support
 
@@ -283,9 +587,21 @@ This package includes TypeScript type definitions. Import types as needed:
 import {
   Env,
   Program,
+  Options,
   EnvOptions,
   VariableDeclaration,
   TypeCheckResult,
+  CompilationResult,
+  CompilationIssue,
+  ValidationIssue,
+  ValidationContext,
+  ValidatorResult,
+  ASTValidatorFunction,
+  ASTValidatorsConfig,
+  CrossTypeNumericComparisonsConfig,
+  OptionalTypesConfig,
+  EnvOptionConfig,
+  EnvOptionInput,
 } from "wasm-cel";
 ```
 
@@ -293,7 +609,7 @@ import {
 
 To build the package from source, you'll need:
 
-- Go 1.16 or later
+- Go 1.21 or later
 - Node.js 18 or later
 - pnpm (or npm/yarn)
 
@@ -317,7 +633,10 @@ pnpm run example
 
 ## Package Type
 
-This is an **ESM-only** package. It uses modern ES modules and NodeNext module resolution. If you're using TypeScript, make sure your `tsconfig.json` has `"module": "NodeNext"` or `"moduleResolution": "NodeNext"` for proper type resolution.
+This is an **ESM-only** package. It uses modern ES modules and NodeNext module
+resolution. If you're using TypeScript, make sure your `tsconfig.json` has
+`"module": "NodeNext"` or `"moduleResolution": "NodeNext"` for proper type
+resolution.
 
 ## License
 

package/dist/index.d.ts

@@ -34,9 +34,13 @@ export declare class Env {
     private envID;
     private destroyed;
     private constructor();
+    /**
+     * Get the environment ID (useful for debugging or advanced use cases)
+     */
+    getID(): string;
     /**
      * Create a new CEL environment
-     * @param options - Options including variable declarations and function definitions
+     * @param options - Options including variable declarations, function definitions, and environment options
      * @returns Promise resolving to a new Env instance
      * @throws Error if environment creation fails
      *
@@ -53,6 +57,9 @@ export declare class Env {
      *       .param("b", "int")
      *       .returns("int")
      *       .implement((a, b) => a + b)
+     *   ],
+     *   options: [
+     *     Options.optionalTypes()
      *   ]
      * });
      * ```
@@ -75,6 +82,28 @@ export declare class Env {
      * ```
      */
     compile(expr: string): Promise<Program>;
+    /**
+     * Compile a CEL expression with detailed results including warnings and issues
+     * @param expr - The CEL expression to compile
+     * @returns Promise resolving to detailed compilation results
+     * @throws Error if environment has been destroyed
+     *
+     * @example
+     * ```typescript
+     * const result = await env.compileDetailed("x + y");
+     * if (result.success) {
+     *   console.log("Compiled successfully");
+     *   if (result.issues.length > 0) {
+     *     console.log("Warnings:", result.issues);
+     *   }
+     *   const evalResult = await result.program.eval({ x: 10, y: 20 });
+     * } else {
+     *   console.log("Compilation failed:", result.error);
+     *   console.log("All issues:", result.issues);
+     * }
+     * ```
+     */
+    compileDetailed(expr: string): Promise<import("./types.js").CompilationResult>;
     /**
      * Typecheck a CEL expression in this environment without compiling it
      * @param expr - The CEL expression to typecheck
@@ -94,6 +123,29 @@ export declare class Env {
      * ```
      */
     typecheck(expr: string): Promise<TypeCheckResult>;
+    /**
+     * Extend this environment with additional CEL environment options
+     * @param options - Array of CEL environment option configurations or complex options with setup
+     * @returns Promise that resolves when the environment has been extended
+     * @throws Error if extension fails or environment has been destroyed
+     *
+     * @example
+     * ```typescript
+     * const env = await Env.new({
+     *   variables: [{ name: "x", type: "int" }]
+     * });
+     *
+     * // Add options after creation
+     * await env.extend([Options.optionalTypes()]);
+     * ```
+     */
+    extend(options: import("./options/index.js").EnvOptionInput[]): Promise<void>;
+    /**
+     * Internal method to extend environment with options
+     * This method delegates to options that implement OptionWithSetup for complex operations
+     * @private
+     */
+    private _extendWithOptions;
     /**
      * Destroy this environment and free associated WASM resources.
      * This will also clean up any registered JavaScript functions associated
@@ -105,6 +157,8 @@ export declare class Env {
      */
     destroy(): void;
 }
-export type { CELType, CELTypeDef, CELListType, CELMapType, CELFunctionDefinition, CELFunctionParam, EnvOptions, VariableDeclaration, TypeCheckResult, } from "./types.js";
+export type { CELType, CELTypeDef, CELListType, CELMapType, CELFunctionDefinition, CELFunctionParam, EnvOptions, VariableDeclaration, TypeCheckResult, CompilationIssue, CompilationResult, } from "./types.js";
 export { listType, mapType, CELFunction } from "./functions.js";
+export { Options } from "./options/index.js";
+export type { EnvOptionConfig, OptionalTypesConfig, ValidationIssue, ValidationContext, ValidatorResult, ASTValidatorFunction, ASTValidatorsConfig, } from "./options/index.js";
 //# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../lib/index.ts"],"names":[],"mappings":"AAKA,OAAO,KAAK,EAGV,UAAU,EACV,eAAe,EAChB,MAAM,YAAY,CAAC;AAkCpB;;;GAGG;AACH,wBAAsB,IAAI,IAAI,OAAO,CAAC,IAAI,CAAC,CAuC1C;AA2GD;;GAEG;AACH,qBAAa,OAAO;IAClB,OAAO,CAAC,SAAS,CAAS;IAC1B,OAAO,CAAC,SAAS,CAAkB;gBAEvB,SAAS,EAAE,MAAM;IAQ7B;;;;;OAKG;IACG,IAAI,CAAC,IAAI,GAAE,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,GAAG,IAAW,GAAG,OAAO,CAAC,GAAG,CAAC;IAyBjE;;;;;;OAMG;IACH,OAAO,IAAI,IAAI;CAyBhB;AAED;;GAEG;AACH,qBAAa,GAAG;IACd,OAAO,CAAC,KAAK,CAAS;IACtB,OAAO,CAAC,SAAS,CAAkB;IAEnC,OAAO;IAQP;;;;;;;;;;;;;;;;;;;;;;OAsBG;WACU,GAAG,CAAC,OAAO,CAAC,EAAE,UAAU,GAAG,OAAO,CAAC,GAAG,CAAC;IAmCpD;;;;;;;;;;;;;;;OAeG;IACG,OAAO,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAAC,OAAO,CAAC;IA+B7C;;;;;;;;;;;;;;;;;OAiBG;IACG,SAAS,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAAC,eAAe,CAAC;IA+BvD;;;;;;;;OAQG;IACH,OAAO,IAAI,IAAI;CAyBhB;AAGD,YAAY,EACV,OAAO,EACP,UAAU,EACV,WAAW,EACX,UAAU,EACV,qBAAqB,EACrB,gBAAgB,EAChB,UAAU,EACV,mBAAmB,EACnB,eAAe,GAChB,MAAM,YAAY,CAAC;AAEpB,OAAO,EAAE,QAAQ,EAAE,OAAO,EAAE,WAAW,EAAE,MAAM,gBAAgB,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../lib/index.ts"],"names":[],"mappings":"AAKA,OAAO,KAAK,EAGV,UAAU,EACV,eAAe,EAChB,MAAM,YAAY,CAAC;AAkCpB;;;GAGG;AACH,wBAAsB,IAAI,IAAI,OAAO,CAAC,IAAI,CAAC,CAuC1C;AA2GD;;GAEG;AACH,qBAAa,OAAO;IAClB,OAAO,CAAC,SAAS,CAAS;IAC1B,OAAO,CAAC,SAAS,CAAkB;gBAEvB,SAAS,EAAE,MAAM;IAQ7B;;;;;OAKG;IACG,IAAI,CAAC,IAAI,GAAE,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,GAAG,IAAW,GAAG,OAAO,CAAC,GAAG,CAAC;IAyBjE;;;;;;OAMG;IACH,OAAO,IAAI,IAAI;CAyBhB;AAED;;GAEG;AACH,qBAAa,GAAG;IACd,OAAO,CAAC,KAAK,CAAS;IACtB,OAAO,CAAC,SAAS,CAAkB;IAEnC,OAAO;IAQP;;OAEG;IACH,KAAK,IAAI,MAAM;IAIf;;;;;;;;;;;;;;;;;;;;;;;;;OAyBG;WACU,GAAG,CAAC,OAAO,CAAC,EAAE,UAAU,GAAG,OAAO,CAAC,GAAG,CAAC;IA6CpD;;;;;;;;;;;;;;;OAeG;IACG,OAAO,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAAC,OAAO,CAAC;IA+B7C;;;;;;;;;;;;;;;;;;;;OAoBG;IACG,eAAe,CACnB,IAAI,EAAE,MAAM,GACX,OAAO,CAAC,OAAO,YAAY,EAAE,iBAAiB,CAAC;IAsDlD;;;;;;;;;;;;;;;;;OAiBG;IACG,SAAS,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAAC,eAAe,CAAC;IA+BvD;;;;;;;;;;;;;;;OAeG;IACG,MAAM,CACV,OAAO,EAAE,OAAO,oBAAoB,EAAE,cAAc,EAAE,GACrD,OAAO,CAAC,IAAI,CAAC;IAIhB;;;;OAIG;YACW,kBAAkB;IAyFhC;;;;;;;;OAQG;IACH,OAAO,IAAI,IAAI;CAyBhB;AAGD,YAAY,EACV,OAAO,EACP,UAAU,EACV,WAAW,EACX,UAAU,EACV,qBAAqB,EACrB,gBAAgB,EAChB,UAAU,EACV,mBAAmB,EACnB,eAAe,EACf,gBAAgB,EAChB,iBAAiB,GAClB,MAAM,YAAY,CAAC;AAEpB,OAAO,EAAE,QAAQ,EAAE,OAAO,EAAE,WAAW,EAAE,MAAM,gBAAgB,CAAC;AAChE,OAAO,EAAE,OAAO,EAAE,MAAM,oBAAoB,CAAC;AAC7C,YAAY,EACV,eAAe,EACf,mBAAmB,EACnB,eAAe,EACf,iBAAiB,EACjB,eAAe,EACf,oBAAoB,EACpB,mBAAmB,GACpB,MAAM,oBAAoB,CAAC"}