@vorionsys/platform-core 0.1.0

package/dist/common/expression/index.js

@@ -0,0 +1,198 @@
+/**
+ * Expression Engine for Vorion Governance DSL
+ *
+ * Provides a domain-specific language for expressing governance rules and conditions.
+ * This module combines lexer, parser, and evaluator into a unified API.
+ *
+ * Example expressions:
+ * - "intent.action == 'data:read' AND intent.riskScore > 50"
+ * - "user.role IN ['admin', 'supervisor'] OR trust.score >= 800"
+ * - "resource.sensitivity == 'high' AND NOT intent.approved"
+ *
+ * @packageDocumentation
+ */
+import { tokenize, LexerError } from './lexer.js';
+import { parse, ParserError } from './parser.js';
+import { evaluate } from './evaluator.js';
+// Re-export all types and errors
+export { LexerError } from './lexer.js';
+export { ParserError, } from './parser.js';
+export { EvaluatorError, resolvePath } from './evaluator.js';
+// Re-export core functions
+export { tokenize } from './lexer.js';
+export { parse } from './parser.js';
+export { evaluate } from './evaluator.js';
+/**
+ * Expression Engine combining lexer, parser, and evaluator
+ *
+ * Provides a high-level API for working with governance expressions.
+ *
+ * @example
+ * ```ts
+ * const engine = new ExpressionEngine();
+ *
+ * // Validate an expression
+ * const result = engine.validate("intent.action == 'read'");
+ * if (result.valid) {
+ *   console.log('Expression is valid');
+ * }
+ *
+ * // Compile for repeated evaluation
+ * const compiled = engine.compile("risk.score > 50 AND role IN ['admin', 'power-user']");
+ *
+ * // Evaluate against multiple contexts
+ * compiled.evaluate({ risk: { score: 75 }, role: 'admin' }); // true
+ * compiled.evaluate({ risk: { score: 30 }, role: 'user' });  // false
+ *
+ * // One-shot evaluation
+ * const allowed = engine.evaluate("trust.level >= 3", { trust: { level: 4 } }); // true
+ * ```
+ */
+export class ExpressionEngine {
+    /**
+     * Compile an expression for efficient repeated evaluation
+     *
+     * @param expression - The expression string to compile
+     * @returns A compiled expression object
+     * @throws LexerError if the expression has lexical errors
+     * @throws ParserError if the expression has syntax errors
+     *
+     * @example
+     * ```ts
+     * const engine = new ExpressionEngine();
+     * const compiled = engine.compile("intent.action == 'read'");
+     *
+     * // Use multiple times
+     * compiled.evaluate({ intent: { action: 'read' } }); // true
+     * compiled.evaluate({ intent: { action: 'write' } }); // false
+     * ```
+     */
+    compile(expression) {
+        const tokens = tokenize(expression);
+        const ast = parse(tokens);
+        return {
+            expression,
+            ast,
+            tokens,
+            evaluate: (context) => evaluate(ast, context),
+        };
+    }
+    /**
+     * Evaluate an expression against a context in one step
+     *
+     * For expressions that will be evaluated multiple times, consider using
+     * `compile()` instead for better performance.
+     *
+     * @param expression - The expression string to evaluate
+     * @param context - The context object to evaluate against
+     * @returns Boolean result of the evaluation
+     * @throws LexerError if the expression has lexical errors
+     * @throws ParserError if the expression has syntax errors
+     * @throws EvaluatorError if evaluation fails
+     *
+     * @example
+     * ```ts
+     * const engine = new ExpressionEngine();
+     *
+     * const result = engine.evaluate(
+     *   "user.role == 'admin' OR trust.score >= 800",
+     *   { user: { role: 'user' }, trust: { score: 850 } }
+     * );
+     * console.log(result); // true
+     * ```
+     */
+    evaluate(expression, context) {
+        const compiled = this.compile(expression);
+        return compiled.evaluate(context);
+    }
+    /**
+     * Validate an expression without evaluating it
+     *
+     * This method catches all errors during lexing and parsing and returns
+     * a structured validation result instead of throwing.
+     *
+     * @param expression - The expression string to validate
+     * @returns Validation result with error details if invalid
+     *
+     * @example
+     * ```ts
+     * const engine = new ExpressionEngine();
+     *
+     * // Valid expression
+     * const valid = engine.validate("intent.action == 'read'");
+     * console.log(valid.valid); // true
+     * console.log(valid.ast); // AST node
+     *
+     * // Invalid expression
+     * const invalid = engine.validate("intent.action ==");
+     * console.log(invalid.valid); // false
+     * console.log(invalid.error?.message); // "Unexpected end of expression"
+     * ```
+     */
+    validate(expression) {
+        try {
+            const tokens = tokenize(expression);
+            const ast = parse(tokens);
+            return {
+                valid: true,
+                ast,
+            };
+        }
+        catch (error) {
+            if (error instanceof LexerError) {
+                return {
+                    valid: false,
+                    error: {
+                        message: error.message,
+                        position: error.position,
+                        token: error.input[error.position],
+                    },
+                };
+            }
+            if (error instanceof ParserError) {
+                return {
+                    valid: false,
+                    error: {
+                        message: error.message,
+                        position: error.token.position,
+                        token: error.token.value,
+                    },
+                };
+            }
+            // Unknown error
+            return {
+                valid: false,
+                error: {
+                    message: error instanceof Error ? error.message : String(error),
+                },
+            };
+        }
+    }
+    /**
+     * Get the tokens from an expression (useful for debugging)
+     *
+     * @param expression - The expression string to tokenize
+     * @returns Array of tokens
+     * @throws LexerError if the expression has lexical errors
+     */
+    tokenize(expression) {
+        return tokenize(expression);
+    }
+    /**
+     * Parse an expression into an AST (useful for debugging)
+     *
+     * @param expression - The expression string to parse
+     * @returns The AST root node
+     * @throws LexerError if the expression has lexical errors
+     * @throws ParserError if the expression has syntax errors
+     */
+    parse(expression) {
+        const tokens = tokenize(expression);
+        return parse(tokens);
+    }
+}
+/**
+ * Default expression engine instance for convenience
+ */
+export const expressionEngine = new ExpressionEngine();
+//# sourceMappingURL=index.js.map

package/dist/common/expression/index.js.map

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

package/dist/common/expression/lexer.d.ts

@@ -0,0 +1,69 @@
+/**
+ * Expression Lexer for Vorion DSL
+ *
+ * Tokenizes governance rule expressions into a stream of tokens.
+ *
+ * Grammar (Lexical):
+ *   IDENTIFIER  := [a-zA-Z_][a-zA-Z0-9_]*(\.[a-zA-Z_][a-zA-Z0-9_]*)*
+ *   STRING      := '"' [^"]* '"' | "'" [^']* "'"
+ *   NUMBER      := [0-9]+(\.[0-9]+)?
+ *   OPERATOR    := '==' | '!=' | '>=' | '<=' | '>' | '<'
+ *   LPAREN      := '('
+ *   RPAREN      := ')'
+ *   LBRACKET    := '['
+ *   RBRACKET    := ']'
+ *   COMMA       := ','
+ *   AND         := 'AND' (case-insensitive)
+ *   OR          := 'OR' (case-insensitive)
+ *   NOT         := 'NOT' (case-insensitive)
+ *   IN          := 'IN' (case-insensitive)
+ *   LIKE        := 'LIKE' (case-insensitive)
+ *   TRUE        := 'true' | 'TRUE'
+ *   FALSE       := 'false' | 'FALSE'
+ *   NULL        := 'null' | 'NULL'
+ *
+ * @packageDocumentation
+ */
+/**
+ * Token types for the expression DSL
+ */
+export type TokenType = 'IDENTIFIER' | 'STRING' | 'NUMBER' | 'OPERATOR' | 'LPAREN' | 'RPAREN' | 'LBRACKET' | 'RBRACKET' | 'COMMA' | 'AND' | 'OR' | 'NOT' | 'IN' | 'LIKE' | 'TRUE' | 'FALSE' | 'NULL' | 'EOF';
+/**
+ * Token representing a single lexeme in the expression
+ */
+export interface Token {
+    /** Type of the token */
+    type: TokenType;
+    /** Raw string value of the token */
+    value: string;
+    /** Position in the source string */
+    position: number;
+}
+/**
+ * Error thrown during lexical analysis
+ */
+export declare class LexerError extends Error {
+    position: number;
+    input: string;
+    constructor(message: string, position: number, input: string);
+}
+/**
+ * Tokenize an expression string into an array of tokens
+ *
+ * @param input - The expression string to tokenize
+ * @returns Array of tokens including EOF
+ * @throws LexerError if invalid characters or malformed tokens are found
+ *
+ * @example
+ * ```ts
+ * const tokens = tokenize("intent.action == 'read'");
+ * // Returns: [
+ * //   { type: 'IDENTIFIER', value: 'intent.action', position: 0 },
+ * //   { type: 'OPERATOR', value: '==', position: 14 },
+ * //   { type: 'STRING', value: 'read', position: 17 },
+ * //   { type: 'EOF', value: '', position: 23 }
+ * // ]
+ * ```
+ */
+export declare function tokenize(input: string): Token[];
+//# sourceMappingURL=lexer.d.ts.map

package/dist/common/expression/lexer.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"lexer.d.ts","sourceRoot":"","sources":["../../../src/common/expression/lexer.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AAEH;;GAEG;AACH,MAAM,MAAM,SAAS,GACjB,YAAY,GACZ,QAAQ,GACR,QAAQ,GACR,UAAU,GACV,QAAQ,GACR,QAAQ,GACR,UAAU,GACV,UAAU,GACV,OAAO,GACP,KAAK,GACL,IAAI,GACJ,KAAK,GACL,IAAI,GACJ,MAAM,GACN,MAAM,GACN,OAAO,GACP,MAAM,GACN,KAAK,CAAC;AAEV;;GAEG;AACH,MAAM,WAAW,KAAK;IACpB,wBAAwB;IACxB,IAAI,EAAE,SAAS,CAAC;IAChB,oCAAoC;IACpC,KAAK,EAAE,MAAM,CAAC;IACd,oCAAoC;IACpC,QAAQ,EAAE,MAAM,CAAC;CAClB;AAED;;GAEG;AACH,qBAAa,UAAW,SAAQ,KAAK;IAG1B,QAAQ,EAAE,MAAM;IAChB,KAAK,EAAE,MAAM;gBAFpB,OAAO,EAAE,MAAM,EACR,QAAQ,EAAE,MAAM,EAChB,KAAK,EAAE,MAAM;CAKvB;AA4DD;;;;;;;;;;;;;;;;;GAiBG;AACH,wBAAgB,QAAQ,CAAC,KAAK,EAAE,MAAM,GAAG,KAAK,EAAE,CAoK/C"}

package/dist/common/expression/lexer.js

@@ -0,0 +1,255 @@
+/**
+ * Expression Lexer for Vorion DSL
+ *
+ * Tokenizes governance rule expressions into a stream of tokens.
+ *
+ * Grammar (Lexical):
+ *   IDENTIFIER  := [a-zA-Z_][a-zA-Z0-9_]*(\.[a-zA-Z_][a-zA-Z0-9_]*)*
+ *   STRING      := '"' [^"]* '"' | "'" [^']* "'"
+ *   NUMBER      := [0-9]+(\.[0-9]+)?
+ *   OPERATOR    := '==' | '!=' | '>=' | '<=' | '>' | '<'
+ *   LPAREN      := '('
+ *   RPAREN      := ')'
+ *   LBRACKET    := '['
+ *   RBRACKET    := ']'
+ *   COMMA       := ','
+ *   AND         := 'AND' (case-insensitive)
+ *   OR          := 'OR' (case-insensitive)
+ *   NOT         := 'NOT' (case-insensitive)
+ *   IN          := 'IN' (case-insensitive)
+ *   LIKE        := 'LIKE' (case-insensitive)
+ *   TRUE        := 'true' | 'TRUE'
+ *   FALSE       := 'false' | 'FALSE'
+ *   NULL        := 'null' | 'NULL'
+ *
+ * @packageDocumentation
+ */
+/**
+ * Error thrown during lexical analysis
+ */
+export class LexerError extends Error {
+    position;
+    input;
+    constructor(message, position, input) {
+        super(`Lexer error at position ${position}: ${message}`);
+        this.position = position;
+        this.input = input;
+        this.name = 'LexerError';
+    }
+}
+/**
+ * Keywords mapping to their token types
+ */
+const KEYWORDS = {
+    AND: 'AND',
+    OR: 'OR',
+    NOT: 'NOT',
+    IN: 'IN',
+    LIKE: 'LIKE',
+    TRUE: 'TRUE',
+    FALSE: 'FALSE',
+    NULL: 'NULL',
+};
+/**
+ * Single character tokens
+ */
+const SINGLE_CHAR_TOKENS = {
+    '(': 'LPAREN',
+    ')': 'RPAREN',
+    '[': 'LBRACKET',
+    ']': 'RBRACKET',
+    ',': 'COMMA',
+};
+/**
+ * Comparison operators (multi-character first for greedy matching)
+ */
+const OPERATORS = ['==', '!=', '>=', '<=', '>', '<'];
+/**
+ * Checks if a character is a valid identifier start
+ */
+function isIdentifierStart(char) {
+    return /[a-zA-Z_]/.test(char);
+}
+/**
+ * Checks if a character is a valid identifier continuation
+ */
+function isIdentifierPart(char) {
+    return /[a-zA-Z0-9_]/.test(char);
+}
+/**
+ * Checks if a character is a digit
+ */
+function isDigit(char) {
+    return /[0-9]/.test(char);
+}
+/**
+ * Checks if a character is whitespace
+ */
+function isWhitespace(char) {
+    return /\s/.test(char);
+}
+/**
+ * Tokenize an expression string into an array of tokens
+ *
+ * @param input - The expression string to tokenize
+ * @returns Array of tokens including EOF
+ * @throws LexerError if invalid characters or malformed tokens are found
+ *
+ * @example
+ * ```ts
+ * const tokens = tokenize("intent.action == 'read'");
+ * // Returns: [
+ * //   { type: 'IDENTIFIER', value: 'intent.action', position: 0 },
+ * //   { type: 'OPERATOR', value: '==', position: 14 },
+ * //   { type: 'STRING', value: 'read', position: 17 },
+ * //   { type: 'EOF', value: '', position: 23 }
+ * // ]
+ * ```
+ */
+export function tokenize(input) {
+    const tokens = [];
+    let position = 0;
+    // Handle empty or whitespace-only input
+    if (!input || input.trim() === '') {
+        return [{ type: 'EOF', value: '', position: 0 }];
+    }
+    while (position < input.length) {
+        const char = input[position];
+        // Skip whitespace
+        if (isWhitespace(char)) {
+            position++;
+            continue;
+        }
+        // Single character tokens
+        if (char in SINGLE_CHAR_TOKENS) {
+            tokens.push({
+                type: SINGLE_CHAR_TOKENS[char],
+                value: char,
+                position,
+            });
+            position++;
+            continue;
+        }
+        // Operators (check multi-char operators first)
+        const operatorMatch = OPERATORS.find((op) => input.slice(position, position + op.length) === op);
+        if (operatorMatch) {
+            tokens.push({
+                type: 'OPERATOR',
+                value: operatorMatch,
+                position,
+            });
+            position += operatorMatch.length;
+            continue;
+        }
+        // String literals (single or double quotes)
+        if (char === '"' || char === "'") {
+            const quote = char;
+            const start = position;
+            position++; // Skip opening quote
+            let value = '';
+            while (position < input.length && input[position] !== quote) {
+                // Handle escape sequences
+                if (input[position] === '\\' && position + 1 < input.length) {
+                    const nextChar = input[position + 1];
+                    if (nextChar === quote || nextChar === '\\') {
+                        value += nextChar;
+                        position += 2;
+                        continue;
+                    }
+                }
+                value += input[position];
+                position++;
+            }
+            if (position >= input.length) {
+                throw new LexerError('Unterminated string literal', start, input);
+            }
+            position++; // Skip closing quote
+            tokens.push({
+                type: 'STRING',
+                value,
+                position: start,
+            });
+            continue;
+        }
+        // Numbers
+        if (isDigit(char) || (char === '-' && position + 1 < input.length && isDigit(input[position + 1]))) {
+            const start = position;
+            let value = '';
+            // Handle negative sign
+            if (char === '-') {
+                value += char;
+                position++;
+            }
+            // Integer part
+            while (position < input.length && isDigit(input[position])) {
+                value += input[position];
+                position++;
+            }
+            // Decimal part
+            if (position < input.length && input[position] === '.' &&
+                position + 1 < input.length && isDigit(input[position + 1])) {
+                value += '.';
+                position++;
+                while (position < input.length && isDigit(input[position])) {
+                    value += input[position];
+                    position++;
+                }
+            }
+            tokens.push({
+                type: 'NUMBER',
+                value,
+                position: start,
+            });
+            continue;
+        }
+        // Identifiers and keywords
+        if (isIdentifierStart(char)) {
+            const start = position;
+            let value = '';
+            // Read identifier parts (including dots for property access)
+            while (position < input.length) {
+                if (isIdentifierPart(input[position])) {
+                    value += input[position];
+                    position++;
+                }
+                else if (input[position] === '.' &&
+                    position + 1 < input.length &&
+                    isIdentifierStart(input[position + 1])) {
+                    // Dot notation for property access
+                    value += '.';
+                    position++;
+                }
+                else {
+                    break;
+                }
+            }
+            // Check if it's a keyword
+            const upperValue = value.toUpperCase();
+            if (upperValue in KEYWORDS) {
+                tokens.push({
+                    type: KEYWORDS[upperValue],
+                    value: upperValue,
+                    position: start,
+                });
+            }
+            else {
+                tokens.push({
+                    type: 'IDENTIFIER',
+                    value,
+                    position: start,
+                });
+            }
+            continue;
+        }
+        // Unknown character
+        throw new LexerError(`Unexpected character: '${char}'`, position, input);
+    }
+    // Add EOF token
+    tokens.push({
+        type: 'EOF',
+        value: '',
+        position: input.length,
+    });
+    return tokens;
+}
+//# sourceMappingURL=lexer.js.map

package/dist/common/expression/lexer.js.map

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

package/dist/common/expression/parser.d.ts

@@ -0,0 +1,133 @@
+/**
+ * Expression Parser for Vorion DSL
+ *
+ * Recursive descent parser that converts tokens into an AST.
+ *
+ * Grammar (Syntactic):
+ *   expression    := or_expr
+ *   or_expr       := and_expr (OR and_expr)*
+ *   and_expr      := not_expr (AND not_expr)*
+ *   not_expr      := NOT not_expr | comparison
+ *   comparison    := primary (OPERATOR primary)?
+ *                  | primary IN array
+ *                  | primary LIKE primary
+ *   primary       := IDENTIFIER | STRING | NUMBER | TRUE | FALSE | NULL
+ *                  | LPAREN expression RPAREN
+ *                  | array
+ *   array         := LBRACKET (primary (COMMA primary)*)? RBRACKET
+ *
+ * Operator Precedence (lowest to highest):
+ *   1. OR
+ *   2. AND
+ *   3. NOT
+ *   4. Comparison operators (==, !=, >, <, >=, <=, IN, LIKE)
+ *
+ * @packageDocumentation
+ */
+import { Token } from './lexer.js';
+/**
+ * AST Node types
+ */
+export type ASTNodeType = 'BinaryExpression' | 'UnaryExpression' | 'ComparisonExpression' | 'InExpression' | 'LikeExpression' | 'Identifier' | 'Literal' | 'ArrayExpression';
+/**
+ * Base AST node interface
+ */
+export interface BaseASTNode {
+    type: ASTNodeType;
+}
+/**
+ * Binary expression node (AND, OR)
+ */
+export interface BinaryExpressionNode extends BaseASTNode {
+    type: 'BinaryExpression';
+    operator: 'AND' | 'OR';
+    left: ASTNode;
+    right: ASTNode;
+}
+/**
+ * Unary expression node (NOT)
+ */
+export interface UnaryExpressionNode extends BaseASTNode {
+    type: 'UnaryExpression';
+    operator: 'NOT';
+    operand: ASTNode;
+}
+/**
+ * Comparison expression node
+ */
+export interface ComparisonExpressionNode extends BaseASTNode {
+    type: 'ComparisonExpression';
+    operator: '==' | '!=' | '>' | '<' | '>=' | '<=';
+    left: ASTNode;
+    right: ASTNode;
+}
+/**
+ * IN expression node
+ */
+export interface InExpressionNode extends BaseASTNode {
+    type: 'InExpression';
+    value: ASTNode;
+    array: ArrayExpressionNode;
+}
+/**
+ * LIKE expression node
+ */
+export interface LikeExpressionNode extends BaseASTNode {
+    type: 'LikeExpression';
+    value: ASTNode;
+    pattern: ASTNode;
+}
+/**
+ * Identifier node (e.g., intent.action)
+ */
+export interface IdentifierNode extends BaseASTNode {
+    type: 'Identifier';
+    name: string;
+}
+/**
+ * Literal value types
+ */
+export type LiteralValue = string | number | boolean | null;
+/**
+ * Literal node (string, number, boolean, null)
+ */
+export interface LiteralNode extends BaseASTNode {
+    type: 'Literal';
+    value: LiteralValue;
+    raw: string;
+}
+/**
+ * Array expression node
+ */
+export interface ArrayExpressionNode extends BaseASTNode {
+    type: 'ArrayExpression';
+    elements: ASTNode[];
+}
+/**
+ * Union type for all AST nodes
+ */
+export type ASTNode = BinaryExpressionNode | UnaryExpressionNode | ComparisonExpressionNode | InExpressionNode | LikeExpressionNode | IdentifierNode | LiteralNode | ArrayExpressionNode;
+/**
+ * Error thrown during parsing
+ */
+export declare class ParserError extends Error {
+    token: Token;
+    expected?: string;
+    constructor(message: string, token: Token, expected?: string);
+}
+/**
+ * Parse tokens into an AST
+ *
+ * @param tokens - Array of tokens from the lexer
+ * @returns Root AST node
+ * @throws ParserError if syntax is invalid
+ *
+ * @example
+ * ```ts
+ * const tokens = tokenize("intent.action == 'read' AND risk > 50");
+ * const ast = parse(tokens);
+ * // Returns BinaryExpression with AND operator
+ * ```
+ */
+export declare function parse(tokens: Token[]): ASTNode;
+//# sourceMappingURL=parser.d.ts.map

package/dist/common/expression/parser.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"parser.d.ts","sourceRoot":"","sources":["../../../src/common/expression/parser.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AAEH,OAAO,EAAE,KAAK,EAAa,MAAM,YAAY,CAAC;AAE9C;;GAEG;AACH,MAAM,MAAM,WAAW,GACnB,kBAAkB,GAClB,iBAAiB,GACjB,sBAAsB,GACtB,cAAc,GACd,gBAAgB,GAChB,YAAY,GACZ,SAAS,GACT,iBAAiB,CAAC;AAEtB;;GAEG;AACH,MAAM,WAAW,WAAW;IAC1B,IAAI,EAAE,WAAW,CAAC;CACnB;AAED;;GAEG;AACH,MAAM,WAAW,oBAAqB,SAAQ,WAAW;IACvD,IAAI,EAAE,kBAAkB,CAAC;IACzB,QAAQ,EAAE,KAAK,GAAG,IAAI,CAAC;IACvB,IAAI,EAAE,OAAO,CAAC;IACd,KAAK,EAAE,OAAO,CAAC;CAChB;AAED;;GAEG;AACH,MAAM,WAAW,mBAAoB,SAAQ,WAAW;IACtD,IAAI,EAAE,iBAAiB,CAAC;IACxB,QAAQ,EAAE,KAAK,CAAC;IAChB,OAAO,EAAE,OAAO,CAAC;CAClB;AAED;;GAEG;AACH,MAAM,WAAW,wBAAyB,SAAQ,WAAW;IAC3D,IAAI,EAAE,sBAAsB,CAAC;IAC7B,QAAQ,EAAE,IAAI,GAAG,IAAI,GAAG,GAAG,GAAG,GAAG,GAAG,IAAI,GAAG,IAAI,CAAC;IAChD,IAAI,EAAE,OAAO,CAAC;IACd,KAAK,EAAE,OAAO,CAAC;CAChB;AAED;;GAEG;AACH,MAAM,WAAW,gBAAiB,SAAQ,WAAW;IACnD,IAAI,EAAE,cAAc,CAAC;IACrB,KAAK,EAAE,OAAO,CAAC;IACf,KAAK,EAAE,mBAAmB,CAAC;CAC5B;AAED;;GAEG;AACH,MAAM,WAAW,kBAAmB,SAAQ,WAAW;IACrD,IAAI,EAAE,gBAAgB,CAAC;IACvB,KAAK,EAAE,OAAO,CAAC;IACf,OAAO,EAAE,OAAO,CAAC;CAClB;AAED;;GAEG;AACH,MAAM,WAAW,cAAe,SAAQ,WAAW;IACjD,IAAI,EAAE,YAAY,CAAC;IACnB,IAAI,EAAE,MAAM,CAAC;CACd;AAED;;GAEG;AACH,MAAM,MAAM,YAAY,GAAG,MAAM,GAAG,MAAM,GAAG,OAAO,GAAG,IAAI,CAAC;AAE5D;;GAEG;AACH,MAAM,WAAW,WAAY,SAAQ,WAAW;IAC9C,IAAI,EAAE,SAAS,CAAC;IAChB,KAAK,EAAE,YAAY,CAAC;IACpB,GAAG,EAAE,MAAM,CAAC;CACb;AAED;;GAEG;AACH,MAAM,WAAW,mBAAoB,SAAQ,WAAW;IACtD,IAAI,EAAE,iBAAiB,CAAC;IACxB,QAAQ,EAAE,OAAO,EAAE,CAAC;CACrB;AAED;;GAEG;AACH,MAAM,MAAM,OAAO,GACf,oBAAoB,GACpB,mBAAmB,GACnB,wBAAwB,GACxB,gBAAgB,GAChB,kBAAkB,GAClB,cAAc,GACd,WAAW,GACX,mBAAmB,CAAC;AAExB;;GAEG;AACH,qBAAa,WAAY,SAAQ,KAAK;IAG3B,KAAK,EAAE,KAAK;IACZ,QAAQ,CAAC,EAAE,MAAM;gBAFxB,OAAO,EAAE,MAAM,EACR,KAAK,EAAE,KAAK,EACZ,QAAQ,CAAC,EAAE,MAAM;CAO3B;AA0QD;;;;;;;;;;;;;GAaG;AACH,wBAAgB,KAAK,CAAC,MAAM,EAAE,KAAK,EAAE,GAAG,OAAO,CAoC9C"}