@libdbm/libcel-ts 1.0.2-rc.0

package/dist/index.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.cjs","sources":["../src/parser/lexer.ts","../src/ast/operators.ts","../src/ast/expression.ts","../src/parser/parser.ts","../src/functions/functions.ts","../src/functions/utilities.ts","../src/functions/standard-functions.ts","../src/interpreter/interpreter.ts","../src/program.ts","../src/cel.ts"],"sourcesContent":["/**\n * ParseError is thrown when the lexer or parser encounters invalid syntax.\n */\nexport class ParseError extends Error {\n  constructor(\n    message: string,\n    public readonly line: number,\n    public readonly column: number\n  ) {\n    super(`${message} at ${line}:${column}`);\n    this.name = 'ParseError';\n  }\n}\n\n/**\n * Token types for CEL lexical analysis.\n */\nexport enum TokenType {\n  // Literals\n  NULL = 'NULL',\n  TRUE = 'TRUE',\n  FALSE = 'FALSE',\n  INT = 'INT',\n  UINT = 'UINT',\n  DOUBLE = 'DOUBLE',\n  STRING = 'STRING',\n  BYTES = 'BYTES',\n  IDENTIFIER = 'IDENTIFIER',\n\n  // Operators\n  PLUS = 'PLUS',\n  MINUS = 'MINUS',\n  STAR = 'STAR',\n  SLASH = 'SLASH',\n  PERCENT = 'PERCENT',\n  EQ = 'EQ',\n  NE = 'NE',\n  LT = 'LT',\n  LE = 'LE',\n  GT = 'GT',\n  GE = 'GE',\n  LOGICAL_AND = 'LOGICAL_AND',\n  LOGICAL_OR = 'LOGICAL_OR',\n  BANG = 'BANG',\n  IN = 'IN',\n\n  // Delimiters\n  LPAREN = 'LPAREN',\n  RPAREN = 'RPAREN',\n  LBRACKET = 'LBRACKET',\n  RBRACKET = 'RBRACKET',\n  LBRACE = 'LBRACE',\n  RBRACE = 'RBRACE',\n  DOT = 'DOT',\n  COMMA = 'COMMA',\n  COLON = 'COLON',\n  QUESTION = 'QUESTION',\n\n  // Special\n  EOF = 'EOF',\n}\n\n/**\n * Token representation for lexical analysis.\n */\nexport class Token {\n  constructor(\n    public readonly type: TokenType,\n    public readonly value: string,\n    public readonly line: number,\n    public readonly column: number\n  ) {}\n\n  toString(): string {\n    return `${this.type}(${this.value})`;\n  }\n}\n\n/**\n * Lexer for tokenizing CEL expressions.\n * Performs character-by-character scanning to produce tokens.\n */\nexport class Lexer {\n  private position = 0;\n  private line = 1;\n  private column = 1;\n  private readonly lookahead: Token[] = [];\n\n  constructor(private readonly input: string) {}\n\n  /**\n   * Get the next token from the input.\n   */\n  next(): Token {\n    if (this.lookahead.length > 0) {\n      return this.lookahead.shift()!;\n    }\n    return this.token();\n  }\n\n  /**\n   * Peek ahead at future tokens without consuming them.\n   * @param count Number of tokens to look ahead (1-indexed)\n   */\n  peek(count: number): Token {\n    while (this.lookahead.length < count) {\n      this.lookahead.push(this.token());\n    }\n    return this.lookahead[count - 1]!;\n  }\n\n  private step(): void {\n    if (this.position >= this.input.length) return;\n\n    const ch = this.input[this.position]!;\n    this.position++;\n\n    if (ch === '\\r') {\n      // Handle CRLF as a single newline\n      if (this.position < this.input.length && this.input[this.position] === '\\n') {\n        this.position++;\n      }\n      this.line++;\n      this.column = 1;\n    } else if (ch === '\\n') {\n      this.line++;\n      this.column = 1;\n    } else {\n      this.column++;\n    }\n  }\n\n  private forward(n: number): void {\n    for (let i = 0; i < n; i++) {\n      this.step();\n    }\n  }\n\n  private token(): Token {\n    this.whitespace();\n\n    if (this.position >= this.input.length) {\n      return new Token(TokenType.EOF, '', this.line, this.column);\n    }\n\n    const start = this.position;\n    const line = this.line;\n    const column = this.column;\n    const ch = this.input[this.position]!;\n\n    // Single character tokens\n    switch (ch) {\n      case '(':\n        this.step();\n        return new Token(TokenType.LPAREN, '(', line, column);\n      case ')':\n        this.step();\n        return new Token(TokenType.RPAREN, ')', line, column);\n      case '[':\n        this.step();\n        return new Token(TokenType.LBRACKET, '[', line, column);\n      case ']':\n        this.step();\n        return new Token(TokenType.RBRACKET, ']', line, column);\n      case '{':\n        this.step();\n        return new Token(TokenType.LBRACE, '{', line, column);\n      case '}':\n        this.step();\n        return new Token(TokenType.RBRACE, '}', line, column);\n      case ',':\n        this.step();\n        return new Token(TokenType.COMMA, ',', line, column);\n      case '.':\n        this.step();\n        return new Token(TokenType.DOT, '.', line, column);\n      case ':':\n        this.step();\n        return new Token(TokenType.COLON, ':', line, column);\n      case '?':\n        this.step();\n        return new Token(TokenType.QUESTION, '?', line, column);\n      case '+':\n        this.step();\n        return new Token(TokenType.PLUS, '+', line, column);\n      case '*':\n        this.step();\n        return new Token(TokenType.STAR, '*', line, column);\n      case '/':\n        this.step();\n        return new Token(TokenType.SLASH, '/', line, column);\n      case '%':\n        this.step();\n        return new Token(TokenType.PERCENT, '%', line, column);\n    }\n\n    // Multi-character operators\n    if (ch === '&' && this.peekChar() === '&') {\n      this.forward(2);\n      return new Token(TokenType.LOGICAL_AND, '&&', line, column);\n    }\n    if (ch === '|' && this.peekChar() === '|') {\n      this.forward(2);\n      return new Token(TokenType.LOGICAL_OR, '||', line, column);\n    }\n    if (ch === '=' && this.peekChar() === '=') {\n      this.forward(2);\n      return new Token(TokenType.EQ, '==', line, column);\n    }\n    if (ch === '!' && this.peekChar() === '=') {\n      this.forward(2);\n      return new Token(TokenType.NE, '!=', line, column);\n    }\n    if (ch === '<' && this.peekChar() === '=') {\n      this.forward(2);\n      return new Token(TokenType.LE, '<=', line, column);\n    }\n    if (ch === '>' && this.peekChar() === '=') {\n      this.forward(2);\n      return new Token(TokenType.GE, '>=', line, column);\n    }\n    if (ch === '<') {\n      this.step();\n      return new Token(TokenType.LT, '<', line, column);\n    }\n    if (ch === '>') {\n      this.step();\n      return new Token(TokenType.GT, '>', line, column);\n    }\n    if (ch === '!') {\n      this.step();\n      return new Token(TokenType.BANG, '!', line, column);\n    }\n    if (ch === '-') {\n      this.step();\n      return new Token(TokenType.MINUS, '-', line, column);\n    }\n\n    // String literals\n    if (ch === '\"' || ch === \"'\") {\n      return this.string(line, column, start);\n    }\n\n    // Raw strings or triple-quoted strings\n    if ((ch === 'r' || ch === 'R') && this.position + 1 < this.input.length) {\n      const next = this.input[this.position + 1]!;\n      if (next === '\"' || next === \"'\") {\n        return this.string(line, column, start);\n      }\n    }\n\n    // Bytes literals\n    if ((ch === 'b' || ch === 'B') && this.position + 1 < this.input.length) {\n      const next = this.input[this.position + 1]!;\n      if (next === '\"' || next === \"'\") {\n        return this.bytes(line, column, start);\n      }\n    }\n\n    // Numbers\n    if (this.isDigit(ch)) {\n      return this.number(line, column, start);\n    }\n\n    // Identifiers and keywords\n    if (this.isLetter(ch) || ch === '_') {\n      return this.identifier(line, column, start);\n    }\n\n    throw new ParseError(`Unexpected character: ${ch}`, line, column);\n  }\n\n  private string(line: number, column: number, offset: number): Token {\n    let isRaw = false;\n\n    // Check for raw prefix\n    if (this.input[this.position] === 'r' || this.input[this.position] === 'R') {\n      isRaw = true;\n      this.step();\n    }\n\n    // Check for triple-quoted string\n    if (this.position + 2 < this.input.length) {\n      const prefix = this.input.substring(this.position, this.position + 3);\n      if (prefix === '\"\"\"' || prefix === \"'''\") {\n        const quote = this.input[this.position]!;\n        this.forward(3);\n\n        // Find closing triple quotes\n        while (this.position + 2 < this.input.length) {\n          if (\n            this.input[this.position] === quote &&\n            this.input[this.position + 1] === quote &&\n            this.input[this.position + 2] === quote\n          ) {\n            this.forward(3);\n            return new Token(TokenType.STRING, this.input.substring(offset, this.position), line, column);\n          }\n          this.step();\n        }\n        throw new ParseError('Unterminated triple-quoted string', line, column);\n      }\n    }\n\n    // Regular string\n    const quote = this.input[this.position]!;\n    this.step(); // consume opening quote\n\n    while (this.position < this.input.length) {\n      const ch = this.input[this.position]!;\n      if (ch === quote) {\n        this.step();\n        return new Token(TokenType.STRING, this.input.substring(offset, this.position), line, column);\n      }\n      if (ch === '\\\\' && !isRaw && this.position + 1 < this.input.length) {\n        // Skip escape sequence as two chars\n        this.forward(2);\n      } else {\n        this.step();\n      }\n    }\n\n    throw new ParseError('Unterminated string', line, column);\n  }\n\n  private bytes(line: number, column: number, offset: number): Token {\n    this.step(); // Skip 'b' or 'B'\n    const quote = this.input[this.position]!;\n    this.step();\n\n    while (this.position < this.input.length) {\n      const ch = this.input[this.position]!;\n      if (ch === quote) {\n        this.step();\n        return new Token(TokenType.BYTES, this.input.substring(offset, this.position), line, column);\n      }\n      if (ch === '\\\\' && this.position + 1 < this.input.length) {\n        this.forward(2); // Skip escape sequence\n      } else {\n        this.step();\n      }\n    }\n\n    throw new ParseError('Unterminated bytes literal', line, column);\n  }\n\n  private number(line: number, column: number, offset: number): Token {\n    // Check for hexadecimal\n    if (this.input[this.position] === '0' && this.position + 1 < this.input.length) {\n      const next = this.input[this.position + 1]!;\n      if (next === 'x' || next === 'X') {\n        this.forward(2);\n        while (this.position < this.input.length && this.isHexDigit(this.input[this.position]!)) {\n          this.step();\n        }\n\n        // Check for uint suffix\n        if (this.position < this.input.length) {\n          const suffix = this.input[this.position]!;\n          if (suffix === 'u' || suffix === 'U') {\n            this.step();\n            return new Token(TokenType.UINT, this.input.substring(offset, this.position), line, column);\n          }\n        }\n\n        return new Token(TokenType.INT, this.input.substring(offset, this.position), line, column);\n      }\n    }\n\n    // Scan digits\n    while (this.position < this.input.length && this.isDigit(this.input[this.position]!)) {\n      this.step();\n    }\n\n    // Check for decimal point or exponent\n    let isDouble = false;\n    if (this.position < this.input.length && this.input[this.position] === '.') {\n      isDouble = true;\n      this.step();\n      while (this.position < this.input.length && this.isDigit(this.input[this.position]!)) {\n        this.step();\n      }\n    }\n\n    if (this.position < this.input.length) {\n      const c = this.input[this.position]!;\n      if (c === 'e' || c === 'E') {\n        isDouble = true;\n        this.step();\n        if (this.position < this.input.length) {\n          const sign = this.input[this.position]!;\n          if (sign === '+' || sign === '-') {\n            this.step();\n          }\n        }\n        while (this.position < this.input.length && this.isDigit(this.input[this.position]!)) {\n          this.step();\n        }\n      }\n    }\n\n    // Check for uint suffix\n    if (!isDouble && this.position < this.input.length) {\n      const suffix = this.input[this.position]!;\n      if (suffix === 'u' || suffix === 'U') {\n        this.step();\n        return new Token(TokenType.UINT, this.input.substring(offset, this.position), line, column);\n      }\n    }\n\n    const type = isDouble ? TokenType.DOUBLE : TokenType.INT;\n    return new Token(type, this.input.substring(offset, this.position), line, column);\n  }\n\n  private identifier(line: number, column: number, offset: number): Token {\n    while (this.position < this.input.length) {\n      const c = this.input[this.position]!;\n      if (!this.isLetterOrDigit(c) && c !== '_') {\n        break;\n      }\n      this.step();\n    }\n\n    const value = this.input.substring(offset, this.position);\n    const type = this.typeOf(value);\n\n    return new Token(type, value, line, column);\n  }\n\n  private typeOf(value: string): TokenType {\n    switch (value) {\n      case 'null':\n        return TokenType.NULL;\n      case 'true':\n        return TokenType.TRUE;\n      case 'false':\n        return TokenType.FALSE;\n      case 'in':\n        return TokenType.IN;\n      default:\n        return TokenType.IDENTIFIER;\n    }\n  }\n\n  private whitespace(): void {\n    while (this.position < this.input.length) {\n      const c = this.input[this.position]!;\n      if (c !== ' ' && c !== '\\t' && c !== '\\n' && c !== '\\r') {\n        break;\n      }\n      this.step();\n    }\n  }\n\n  private peekChar(): string {\n    const pos = this.position + 1;\n    if (pos >= this.input.length) {\n      return '\\0';\n    }\n    return this.input[pos]!;\n  }\n\n  private isHexDigit(c: string): boolean {\n    return (c >= '0' && c <= '9') || (c >= 'a' && c <= 'f') || (c >= 'A' && c <= 'F');\n  }\n\n  private isDigit(c: string): boolean {\n    return c >= '0' && c <= '9';\n  }\n\n  private isLetter(c: string): boolean {\n    return (c >= 'a' && c <= 'z') || (c >= 'A' && c <= 'Z');\n  }\n\n  private isLetterOrDigit(c: string): boolean {\n    return this.isLetter(c) || this.isDigit(c);\n  }\n}\n","/**\n * Binary operators in CEL expressions.\n */\nexport enum BinaryOp {\n  /** Addition (+) or string/list concatenation */\n  ADD = 'ADD',\n  /** Subtraction (-) */\n  SUBTRACT = 'SUBTRACT',\n  /** Multiplication (*) or string/list repetition */\n  MULTIPLY = 'MULTIPLY',\n  /** Division (/) */\n  DIVIDE = 'DIVIDE',\n  /** Modulo (%) */\n  MODULO = 'MODULO',\n  /** Equality (==) */\n  EQUAL = 'EQUAL',\n  /** Inequality (!=) */\n  NOT_EQUAL = 'NOT_EQUAL',\n  /** Less than (<) */\n  LESS = 'LESS',\n  /** Less than or equal (<=) */\n  LESS_EQUAL = 'LESS_EQUAL',\n  /** Greater than (>) */\n  GREATER = 'GREATER',\n  /** Greater than or equal (>=) */\n  GREATER_EQUAL = 'GREATER_EQUAL',\n  /** Membership test (in) */\n  IN = 'IN',\n  /** Logical AND (&&) */\n  LOGICAL_AND = 'LOGICAL_AND',\n  /** Logical OR (||) */\n  LOGICAL_OR = 'LOGICAL_OR',\n}\n\n/**\n * Unary operators in CEL expressions.\n */\nexport enum UnaryOp {\n  /** Logical NOT (!) */\n  NOT = 'NOT',\n  /** Numeric negation (-) */\n  NEGATE = 'NEGATE',\n}\n\n/**\n * Types of literal values in CEL.\n */\nexport enum LiteralType {\n  NULL_VALUE = 'NULL_VALUE',\n  BOOL = 'BOOL',\n  INT = 'INT',\n  UINT = 'UINT',\n  DOUBLE = 'DOUBLE',\n  STRING = 'STRING',\n  BYTES = 'BYTES',\n}\n","import { BinaryOp, UnaryOp, LiteralType } from './operators.js';\n\n/**\n * Visitor interface for traversing and operating on CEL expression nodes.\n * Implements the Visitor pattern for AST traversal.\n *\n * @template T The return type of visit operations\n */\nexport interface Visitor<T> {\n  visitLiteral(expr: Literal): T;\n  visitIdentifier(expr: Identifier): T;\n  visitSelect(expr: Select): T;\n  visitIndex(expr: Index): T;\n  visitCall(expr: Call): T;\n  visitList(expr: ListExpression): T;\n  visitMap(expr: MapExpression): T;\n  visitStruct(expr: Struct): T;\n  visitComprehension(expr: Comprehension): T;\n  visitUnary(expr: Unary): T;\n  visitBinary(expr: Binary): T;\n  visitConditional(expr: Conditional): T;\n}\n\n/**\n * Base interface for all CEL expression nodes in the Abstract Syntax Tree.\n * Uses the Visitor pattern to enable different operations on expressions.\n */\nexport interface Expression {\n  /**\n   * Accepts a visitor to perform operations on this expression node.\n   *\n   * @template T The return type of the visitor's visit operations\n   * @param visitor The visitor that will operate on this expression node\n   * @returns The result of the visitor's visit operation\n   */\n  accept<T>(visitor: Visitor<T>): T;\n}\n\n/**\n * Literal value expression (null, boolean, number, string, bytes).\n */\nexport class Literal implements Expression {\n  constructor(\n    public readonly value: any,\n    public readonly literalType: LiteralType\n  ) {}\n\n  accept<T>(visitor: Visitor<T>): T {\n    return visitor.visitLiteral(this);\n  }\n}\n\n/**\n * Identifier expression (variable reference).\n */\nexport class Identifier implements Expression {\n  constructor(public readonly name: string) {}\n\n  accept<T>(visitor: Visitor<T>): T {\n    return visitor.visitIdentifier(this);\n  }\n}\n\n/**\n * Field selection expression (operand.field).\n */\nexport class Select implements Expression {\n  constructor(\n    public readonly operand: Expression | null,\n    public readonly field: string,\n    public readonly isTest: boolean = false\n  ) {}\n\n  accept<T>(visitor: Visitor<T>): T {\n    return visitor.visitSelect(this);\n  }\n}\n\n/**\n * Index expression for array/map access (operand[index]).\n */\nexport class Index implements Expression {\n  constructor(\n    public readonly operand: Expression,\n    public readonly index: Expression\n  ) {}\n\n  accept<T>(visitor: Visitor<T>): T {\n    return visitor.visitIndex(this);\n  }\n}\n\n/**\n * Function or method call expression.\n */\nexport class Call implements Expression {\n  constructor(\n    public readonly target: Expression | null,\n    public readonly functionName: string,\n    public readonly args: Expression[],\n    public readonly isMacro: boolean = false\n  ) {}\n\n  accept<T>(visitor: Visitor<T>): T {\n    return visitor.visitCall(this);\n  }\n}\n\n/**\n * List literal expression ([1, 2, 3]).\n */\nexport class ListExpression implements Expression {\n  constructor(public readonly elements: Expression[]) {}\n\n  accept<T>(visitor: Visitor<T>): T {\n    return visitor.visitList(this);\n  }\n}\n\n/**\n * Map entry (key-value pair in a map literal).\n */\nexport class MapEntry {\n  constructor(\n    public readonly key: Expression,\n    public readonly value: Expression\n  ) {}\n}\n\n/**\n * Map literal expression ({key: value}).\n */\nexport class MapExpression implements Expression {\n  constructor(public readonly entries: MapEntry[]) {}\n\n  accept<T>(visitor: Visitor<T>): T {\n    return visitor.visitMap(this);\n  }\n}\n\n/**\n * Field initializer in a struct literal.\n */\nexport class FieldInitializer {\n  constructor(\n    public readonly field: string,\n    public readonly value: Expression\n  ) {}\n}\n\n/**\n * Struct literal expression (Type{field: value}).\n */\nexport class Struct implements Expression {\n  constructor(\n    public readonly typeName: string | null,\n    public readonly fields: FieldInitializer[]\n  ) {}\n\n  accept<T>(visitor: Visitor<T>): T {\n    return visitor.visitStruct(this);\n  }\n}\n\n/**\n * Comprehension expression for advanced iteration constructs.\n */\nexport class Comprehension implements Expression {\n  constructor(\n    public readonly variable: string,\n    public readonly range: Expression,\n    public readonly accumulator: string,\n    public readonly initializer: Expression,\n    public readonly condition: Expression,\n    public readonly step: Expression,\n    public readonly result: Expression\n  ) {}\n\n  accept<T>(visitor: Visitor<T>): T {\n    return visitor.visitComprehension(this);\n  }\n}\n\n/**\n * Unary operation expression (!, -).\n */\nexport class Unary implements Expression {\n  constructor(\n    public readonly op: UnaryOp,\n    public readonly operand: Expression\n  ) {}\n\n  accept<T>(visitor: Visitor<T>): T {\n    return visitor.visitUnary(this);\n  }\n}\n\n/**\n * Binary operation expression (+, -, *, /, etc.).\n */\nexport class Binary implements Expression {\n  constructor(\n    public readonly op: BinaryOp,\n    public readonly left: Expression,\n    public readonly right: Expression\n  ) {}\n\n  accept<T>(visitor: Visitor<T>): T {\n    return visitor.visitBinary(this);\n  }\n}\n\n/**\n * Conditional (ternary) expression (condition ? then : otherwise).\n */\nexport class Conditional implements Expression {\n  constructor(\n    public readonly condition: Expression,\n    public readonly thenExpr: Expression,\n    public readonly otherwiseExpr: Expression\n  ) {}\n\n  accept<T>(visitor: Visitor<T>): T {\n    return visitor.visitConditional(this);\n  }\n}\n","import {\n  Expression,\n  Literal,\n  Identifier,\n  Select,\n  Index,\n  Call,\n  ListExpression,\n  MapExpression,\n  MapEntry,\n  Struct,\n  FieldInitializer,\n  Unary,\n  Binary,\n  Conditional,\n  BinaryOp,\n  UnaryOp,\n  LiteralType,\n} from '../ast/index.js';\nimport { Lexer, Token, TokenType, ParseError } from './lexer.js';\n\n// Re-export ParseError for convenience\nexport { ParseError } from './lexer.js';\n\n/**\n * Set of macro method names that require special handling.\n */\nconst MACRO_METHODS = new Set(['map', 'filter', 'all', 'exists', 'existsOne']);\n\n/**\n * Recursive descent parser for CEL (Common Expression Language).\n * Parses CEL expressions into an Abstract Syntax Tree (AST).\n */\nexport class Parser {\n  private readonly lexer: Lexer;\n  private current: Token;\n\n  constructor(input: string) {\n    this.lexer = new Lexer(input);\n    this.current = this.lexer.next();\n  }\n\n  /**\n   * Parse a CEL expression from the input string.\n   * @returns The parsed Expression AST node\n   * @throws ParseError if the input contains syntax errors\n   */\n  parse(): Expression {\n    const expr = this.parseExpr();\n    if (this.current.type !== TokenType.EOF) {\n      throw new ParseError(\n        `Unexpected token after expression: ${this.current.value}`,\n        this.current.line,\n        this.current.column\n      );\n    }\n    return expr;\n  }\n\n  // expr = conditionalOr ( '?' conditionalOr ':' expr )?\n  private parseExpr(): Expression {\n    const condition = this.parseConditionalOr();\n\n    if (this.match(TokenType.QUESTION)) {\n      const thenExpr = this.parseConditionalOr();\n      this.expect(TokenType.COLON);\n      const otherwiseExpr = this.parseExpr();\n      return new Conditional(condition, thenExpr, otherwiseExpr);\n    }\n\n    return condition;\n  }\n\n  // conditionalOr = conditionalAnd ( '||' conditionalAnd )*\n  private parseConditionalOr(): Expression {\n    let left = this.parseConditionalAnd();\n\n    while (this.match(TokenType.LOGICAL_OR)) {\n      const right = this.parseConditionalAnd();\n      left = new Binary(BinaryOp.LOGICAL_OR, left, right);\n    }\n\n    return left;\n  }\n\n  // conditionalAnd = relation ( '&&' relation )*\n  private parseConditionalAnd(): Expression {\n    let left = this.parseRelation();\n\n    while (this.match(TokenType.LOGICAL_AND)) {\n      const right = this.parseRelation();\n      left = new Binary(BinaryOp.LOGICAL_AND, left, right);\n    }\n\n    return left;\n  }\n\n  // relation = addition ( relop addition )*\n  // relop = '<=' | '>=' | '!=' | '==' | '<' | '>' | 'in'\n  private parseRelation(): Expression {\n    let left = this.parseAddition();\n\n    while (this.isRelationalOp(this.current.type)) {\n      const op = this.current.type;\n      this.advance();\n      const right = this.parseAddition();\n      left = new Binary(this.toBinaryOp(op), left, right);\n    }\n\n    return left;\n  }\n\n  // addition = multiplication ( ('+' | '-') multiplication )*\n  private parseAddition(): Expression {\n    let left = this.parseMultiplication();\n\n    while (this.current.type === TokenType.PLUS || this.current.type === TokenType.MINUS) {\n      const op = this.current.type;\n      this.advance();\n      const right = this.parseMultiplication();\n      left = new Binary(op === TokenType.PLUS ? BinaryOp.ADD : BinaryOp.SUBTRACT, left, right);\n    }\n\n    return left;\n  }\n\n  // multiplication = unary ( ('*' | '/' | '%') unary )*\n  private parseMultiplication(): Expression {\n    let left = this.parseUnary();\n\n    while (\n      this.current.type === TokenType.STAR ||\n      this.current.type === TokenType.SLASH ||\n      this.current.type === TokenType.PERCENT\n    ) {\n      const op = this.current.type;\n      this.advance();\n      const right = this.parseUnary();\n      const operator =\n        op === TokenType.STAR\n          ? BinaryOp.MULTIPLY\n          : op === TokenType.SLASH\n          ? BinaryOp.DIVIDE\n          : BinaryOp.MODULO;\n      left = new Binary(operator, left, right);\n    }\n\n    return left;\n  }\n\n  // unary = '!'+ member | '-'+ member | member\n  private parseUnary(): Expression {\n    if (this.current.type === TokenType.BANG) {\n      this.advance();\n      return new Unary(UnaryOp.NOT, this.parseUnary());\n    } else if (this.current.type === TokenType.MINUS) {\n      this.advance();\n      return new Unary(UnaryOp.NEGATE, this.parseUnary());\n    }\n\n    return this.parseMember();\n  }\n\n  // member = primary ( selector | index | fieldCall )*\n  private parseMember(): Expression {\n    let expr = this.parsePrimary();\n\n    while (true) {\n      if (this.current.type === TokenType.DOT) {\n        this.advance();\n        const field = this.expectIdentifier();\n\n        // Check if it's a method call or a field selection\n        // @ts-expect-error - Token type changes after advance()\n        if (this.current.type === TokenType.LPAREN) {\n          this.advance();\n          const args = this.parseExprList();\n          this.expect(TokenType.RPAREN);\n          const isMacro = MACRO_METHODS.has(field);\n          expr = new Call(expr, field, args, isMacro);\n        } else {\n          expr = new Select(expr, field);\n        }\n      } else if (this.current.type === TokenType.LBRACKET) {\n        this.advance();\n        const index = this.parseExpr();\n        this.expect(TokenType.RBRACKET);\n        expr = new Index(expr, index);\n      } else {\n        break;\n      }\n    }\n\n    return expr;\n  }\n\n  // primary = literal | ident callArgs? | listLiteral | mapLiteral | structLiteral | '(' expr ')' | '.' ident callArgs?\n  private parsePrimary(): Expression {\n    // Check for literals\n    if (this.isLiteralToken(this.current.type)) {\n      return this.parseLiteral();\n    }\n\n    // List literal\n    if (this.current.type === TokenType.LBRACKET) {\n      return this.parseListLiteral();\n    }\n\n    // Map or struct literal\n    if (this.current.type === TokenType.LBRACE) {\n      return this.parseMapOrStructLiteral(null);\n    }\n\n    // Parenthesized expression\n    if (this.current.type === TokenType.LPAREN) {\n      this.advance();\n      const expr = this.parseExpr();\n      this.expect(TokenType.RPAREN);\n      return expr;\n    }\n\n    // Leading dot (e.g., .identifier or .method())\n    if (this.current.type === TokenType.DOT) {\n      this.advance();\n      const field = this.expectIdentifier();\n\n      // @ts-expect-error - Token type changes after advance()\n      if (this.current.type === TokenType.LPAREN) {\n        this.advance();\n        const args = this.parseExprList();\n        this.expect(TokenType.RPAREN);\n        return new Call(null, field, args);\n      }\n\n      return new Select(null, field);\n    }\n\n    // Identifier (possibly followed by call args or struct literal)\n    if (this.current.type === TokenType.IDENTIFIER) {\n      const name = this.current.value;\n      this.advance();\n\n      // Function call\n      // @ts-expect-error - Token type changes after advance()\n      if (this.current.type === TokenType.LPAREN) {\n        this.advance();\n        const args = this.parseExprList();\n        this.expect(TokenType.RPAREN);\n        return new Call(null, name, args);\n      }\n\n      // Check for qualified identifier followed by struct literal\n      // @ts-expect-error - Token type changes after advance()\n      if (this.current.type === TokenType.DOT && this.isQualifiedStructLiteral()) {\n        const qualified = this.parseQualifiedIdent(name);\n        return this.parseMapOrStructLiteral(qualified);\n      }\n\n      // Check for struct literal with simple type name\n      // @ts-expect-error - Token type changes after advance()\n      if (this.current.type === TokenType.LBRACE) {\n        return this.parseMapOrStructLiteral(name);\n      }\n\n      return new Identifier(name);\n    }\n\n    throw new ParseError(\n      `Unexpected token: ${this.current.value}`,\n      this.current.line,\n      this.current.column\n    );\n  }\n\n  // listLiteral = '[' exprList? ','? ']'\n  private parseListLiteral(): Expression {\n    this.expect(TokenType.LBRACKET);\n\n    const elements: Expression[] = [];\n    if (this.current.type !== TokenType.RBRACKET) {\n      elements.push(...this.parseExprList());\n      // Optional trailing comma\n      if (this.current.type === TokenType.COMMA) {\n        this.advance();\n      }\n    }\n\n    this.expect(TokenType.RBRACKET);\n    return new ListExpression(elements);\n  }\n\n  // mapLiteral or structLiteral\n  private parseMapOrStructLiteral(typeName: string | null): Expression {\n    this.expect(TokenType.LBRACE);\n\n    if (this.current.type === TokenType.RBRACE) {\n      this.advance();\n      if (typeName !== null) {\n        return new Struct(typeName, []);\n      }\n      return new MapExpression([]);\n    }\n\n    // Try to determine if this is a struct (field: expr) or map (expr: expr)\n    const isStruct =\n      this.current.type === TokenType.IDENTIFIER && this.peekAhead(1).type === TokenType.COLON;\n\n    if (isStruct || typeName !== null) {\n      const fields = this.parseFieldInits();\n      if (this.current.type === TokenType.COMMA) {\n        this.advance();\n      }\n      this.expect(TokenType.RBRACE);\n      return new Struct(typeName, fields);\n    } else {\n      const entries = this.parseMapInits();\n      if (this.current.type === TokenType.COMMA) {\n        this.advance();\n      }\n      this.expect(TokenType.RBRACE);\n      return new MapExpression(entries);\n    }\n  }\n\n  // exprList = expr ( ',' expr )*\n  private parseExprList(): Expression[] {\n    const expressions: Expression[] = [];\n\n    // Check for empty list - current could be RPAREN or RBRACKET\n    const currentType = this.current.type;\n    if (currentType === TokenType.RPAREN || currentType === TokenType.RBRACKET) {\n      return expressions;\n    }\n\n    expressions.push(this.parseExpr());\n\n    while (this.current.type === TokenType.COMMA) {\n      this.advance();\n      // @ts-expect-error - Token type changes after advance()\n      if (this.current.type === TokenType.RPAREN || this.current.type === TokenType.RBRACKET) {\n        break;\n      }\n      expressions.push(this.parseExpr());\n    }\n\n    return expressions;\n  }\n\n  // mapInits = mapInit ( ',' mapInit )*\n  private parseMapInits(): MapEntry[] {\n    const entries: MapEntry[] = [];\n\n    entries.push(this.parseMapInit());\n    while (this.current.type === TokenType.COMMA) {\n      this.advance();\n      // @ts-expect-error - Token type changes after advance()\n      if (this.current.type === TokenType.RBRACE) {\n        break;\n      }\n      entries.push(this.parseMapInit());\n    }\n\n    return entries;\n  }\n\n  // mapInit = expr ':' expr\n  private parseMapInit(): MapEntry {\n    const key = this.parseExpr();\n    this.expect(TokenType.COLON);\n    const value = this.parseExpr();\n    return new MapEntry(key, value);\n  }\n\n  // fieldInits = fieldInit ( ',' fieldInit )*\n  private parseFieldInits(): FieldInitializer[] {\n    const fields: FieldInitializer[] = [];\n\n    fields.push(this.parseFieldInit());\n    while (this.current.type === TokenType.COMMA) {\n      this.advance();\n      // @ts-expect-error - Token type changes after advance()\n      if (this.current.type === TokenType.RBRACE) {\n        break;\n      }\n      fields.push(this.parseFieldInit());\n    }\n\n    return fields;\n  }\n\n  // fieldInit = ident ':' expr\n  private parseFieldInit(): FieldInitializer {\n    const field = this.expectIdentifier();\n    this.expect(TokenType.COLON);\n    const value = this.parseExpr();\n    return new FieldInitializer(field, value);\n  }\n\n  // qualifiedIdent = ident ( '.' ident )*\n  private parseQualifiedIdent(first: string): string {\n    let qualified = first;\n\n    while (this.current.type === TokenType.DOT) {\n      this.advance();\n      qualified += '.';\n      qualified += this.expectIdentifier();\n    }\n\n    return qualified;\n  }\n\n  private parseLiteral(): Expression {\n    const token = this.current;\n    this.advance();\n\n    switch (token.type) {\n      case TokenType.NULL:\n        return new Literal(null, LiteralType.NULL_VALUE);\n      case TokenType.TRUE:\n        return new Literal(true, LiteralType.BOOL);\n      case TokenType.FALSE:\n        return new Literal(false, LiteralType.BOOL);\n      case TokenType.INT:\n        return new Literal(this.parseIntLiteral(token.value), LiteralType.INT);\n      case TokenType.UINT:\n        return new Literal(this.parseUintLiteral(token.value), LiteralType.UINT);\n      case TokenType.DOUBLE:\n        return new Literal(parseFloat(token.value), LiteralType.DOUBLE);\n      case TokenType.STRING:\n        return new Literal(this.parseStringLiteral(token.value), LiteralType.STRING);\n      case TokenType.BYTES:\n        return new Literal(this.parseBytesLiteral(token.value), LiteralType.BYTES);\n      default:\n        throw new ParseError(`Not a literal: ${token.value}`, token.line, token.column);\n    }\n  }\n\n  private parseIntLiteral(value: string): number {\n    if (value.startsWith('-0x') || value.startsWith('-0X')) {\n      return -parseInt(value.substring(3), 16);\n    } else if (value.startsWith('0x') || value.startsWith('0X')) {\n      return parseInt(value.substring(2), 16);\n    } else {\n      return parseInt(value, 10);\n    }\n  }\n\n  private parseUintLiteral(value: string): number {\n    // Remove 'u' or 'U' suffix\n    const number = value.substring(0, value.length - 1);\n    if (number.startsWith('0x') || number.startsWith('0X')) {\n      return parseInt(number.substring(2), 16);\n    } else {\n      return parseInt(number, 10);\n    }\n  }\n\n  private parseStringLiteral(value: string): string {\n    const isRaw = value.startsWith('r') || value.startsWith('R');\n    let content: string;\n\n    if (isRaw && (value.substring(1).startsWith('\"\"\"') || value.substring(1).startsWith(\"'''\"))) {\n      // Raw triple-quoted string: r\"\"\"...\"\"\" or r'''...'''\n      content = value.substring(4, value.length - 3);\n    } else if (value.startsWith('\"\"\"') || value.startsWith(\"'''\")) {\n      // Triple-quoted string: \"\"\"...\"\"\" or '''...'''\n      content = value.substring(3, value.length - 3);\n      content = this.unescapeString(content);\n    } else if (isRaw) {\n      // Raw string: r\"...\" or r'...'\n      content = value.substring(2, value.length - 1);\n    } else {\n      // Regular string: \"...\" or '...'\n      content = value.substring(1, value.length - 1);\n      content = this.unescapeString(content);\n    }\n\n    return content;\n  }\n\n  private parseBytesLiteral(value: string): string {\n    // Remove b\"...\" or B'...' wrapper and process escapes\n    const content = value.substring(2, value.length - 1);\n    return this.unescapeString(content);\n  }\n\n  private unescapeString(value: string): string {\n    let result = '';\n    let i = 0;\n\n    while (i < value.length) {\n      if (value[i] === '\\\\' && i + 1 < value.length) {\n        const next = value[i + 1]!;\n        switch (next) {\n          case '\\\\':\n            result += '\\\\';\n            i += 2;\n            break;\n          case '\"':\n            result += '\"';\n            i += 2;\n            break;\n          case \"'\":\n            result += \"'\";\n            i += 2;\n            break;\n          case '`':\n            result += '`';\n            i += 2;\n            break;\n          case '?':\n            result += '?';\n            i += 2;\n            break;\n          case 'a':\n            result += '\\u0007';\n            i += 2;\n            break;\n          case 'b':\n            result += '\\b';\n            i += 2;\n            break;\n          case 'f':\n            result += '\\f';\n            i += 2;\n            break;\n          case 'n':\n            result += '\\n';\n            i += 2;\n            break;\n          case 'r':\n            result += '\\r';\n            i += 2;\n            break;\n          case 't':\n            result += '\\t';\n            i += 2;\n            break;\n          case 'v':\n            result += '\\u000B';\n            i += 2;\n            break;\n          case 'x':\n            // Hexadecimal escape: \\xHH\n            if (i + 3 < value.length) {\n              const hex = value.substring(i + 2, i + 4);\n              result += String.fromCharCode(parseInt(hex, 16));\n              i += 4;\n            } else {\n              result += value[i]!;\n              i++;\n            }\n            break;\n          case 'u':\n            // Unicode escape: \\uHHHH\n            if (i + 5 < value.length) {\n              const hex = value.substring(i + 2, i + 6);\n              result += String.fromCharCode(parseInt(hex, 16));\n              i += 6;\n            } else {\n              result += value[i]!;\n              i++;\n            }\n            break;\n          case 'U':\n            // Unicode escape: \\UHHHHHHHH\n            if (i + 9 < value.length) {\n              const hex = value.substring(i + 2, i + 10);\n              const codePoint = parseInt(hex, 16);\n              result += String.fromCodePoint(codePoint);\n              i += 10;\n            } else {\n              result += value[i]!;\n              i++;\n            }\n            break;\n          default:\n            // Check for octal escape: \\[0-3][0-7][0-7]\n            if (\n              i + 3 < value.length &&\n              next >= '0' &&\n              next <= '3' &&\n              value[i + 2]! >= '0' &&\n              value[i + 2]! <= '7' &&\n              value[i + 3]! >= '0' &&\n              value[i + 3]! <= '7'\n            ) {\n              const octal = value.substring(i + 1, i + 4);\n              result += String.fromCharCode(parseInt(octal, 8));\n              i += 4;\n            } else {\n              result += value[i]!;\n              i++;\n            }\n        }\n      } else {\n        result += value[i]!;\n        i++;\n      }\n    }\n\n    return result;\n  }\n\n  private isLiteralToken(type: TokenType): boolean {\n    return (\n      type === TokenType.NULL ||\n      type === TokenType.TRUE ||\n      type === TokenType.FALSE ||\n      type === TokenType.INT ||\n      type === TokenType.UINT ||\n      type === TokenType.DOUBLE ||\n      type === TokenType.STRING ||\n      type === TokenType.BYTES\n    );\n  }\n\n  private isRelationalOp(type: TokenType): boolean {\n    return (\n      type === TokenType.LT ||\n      type === TokenType.LE ||\n      type === TokenType.GT ||\n      type === TokenType.GE ||\n      type === TokenType.EQ ||\n      type === TokenType.NE ||\n      type === TokenType.IN\n    );\n  }\n\n  private toBinaryOp(type: TokenType): BinaryOp {\n    switch (type) {\n      case TokenType.LT:\n        return BinaryOp.LESS;\n      case TokenType.LE:\n        return BinaryOp.LESS_EQUAL;\n      case TokenType.GT:\n        return BinaryOp.GREATER;\n      case TokenType.GE:\n        return BinaryOp.GREATER_EQUAL;\n      case TokenType.EQ:\n        return BinaryOp.EQUAL;\n      case TokenType.NE:\n        return BinaryOp.NOT_EQUAL;\n      case TokenType.IN:\n        return BinaryOp.IN;\n      default:\n        throw new ParseError(\n          `Unknown relational operator: ${type}`,\n          this.current.line,\n          this.current.column\n        );\n    }\n  }\n\n  private match(type: TokenType): boolean {\n    if (this.current.type === type) {\n      this.advance();\n      return true;\n    }\n    return false;\n  }\n\n  private expect(type: TokenType): void {\n    if (this.current.type !== type) {\n      throw new ParseError(\n        `Expected ${type} but found ${this.current.type}`,\n        this.current.line,\n        this.current.column\n      );\n    }\n    this.advance();\n  }\n\n  private expectIdentifier(): string {\n    if (this.current.type !== TokenType.IDENTIFIER) {\n      throw new ParseError(\n        `Expected identifier but found ${this.current.value}`,\n        this.current.line,\n        this.current.column\n      );\n    }\n    const name = this.current.value;\n    this.advance();\n    return name;\n  }\n\n  private advance(): void {\n    this.current = this.lexer.next();\n  }\n\n  private peekAhead(count: number): Token {\n    return this.lexer.peek(count);\n  }\n\n  // Check if we have a pattern like: . ident ( . ident )* {\n  private isQualifiedStructLiteral(): boolean {\n    let lookahead = 1;\n    let token = this.peekAhead(lookahead);\n\n    // Must start with identifier after dot\n    if (token.type !== TokenType.IDENTIFIER) {\n      return false;\n    }\n\n    lookahead++;\n    token = this.peekAhead(lookahead);\n\n    // Skip additional .ident sequences\n    while (token.type === TokenType.DOT) {\n      lookahead++;\n      token = this.peekAhead(lookahead);\n      if (token.type !== TokenType.IDENTIFIER) {\n        return false;\n      }\n      lookahead++;\n      token = this.peekAhead(lookahead);\n    }\n\n    // Must end with {\n    return token.type === TokenType.LBRACE;\n  }\n}\n","/**\n * Exception thrown during CEL expression evaluation.\n */\nexport class EvaluationError extends Error {\n  constructor(message: string) {\n    super(message);\n    this.name = 'EvaluationError';\n  }\n}\n\n/**\n * Interface for providing functions to CEL expressions.\n *\n * Implement this interface to provide custom functions that can be called\n * from CEL expressions. The StandardFunctions class provides all standard\n * CEL functions and can be extended for custom functionality.\n *\n * @example\n * ```typescript\n * class MyFunctions extends StandardFunctions {\n *   callFunction(name: string, args: any[]): any {\n *     if (name === 'customFunc') {\n *       return myCustomImplementation(args);\n *     }\n *     return super.callFunction(name, args);\n *   }\n * }\n * ```\n */\nexport interface Functions {\n  /**\n   * Calls a global function by name.\n   *\n   * @param name The name of the function to call\n   * @param args The arguments to pass to the function\n   * @returns The result of the function call\n   * @throws Error if the function is not found or if the arguments are invalid\n   */\n  callFunction(name: string, args: any[]): any;\n\n  /**\n   * Calls a method on a target object.\n   *\n   * @param target The object to call the method on\n   * @param method The name of the method to call\n   * @param args The arguments to pass to the method\n   * @returns The result of the method call\n   * @throws Error if the method is not found or if the arguments are invalid\n   */\n  callMethod(target: any, method: string, args: any[]): any;\n}\n","/**\n * Utility helper methods for libcel.\n * Methods are exported so library users can call them directly.\n */\n\n/**\n * Returns the size/length of the given value.\n *\n * Supported types:\n * - String: number of characters\n * - Array: number of elements\n * - Map/Record: number of entries\n * - null: 0\n *\n * @param value The value whose size should be computed; may be null\n * @returns The size for supported types, or 0 for null\n * @throws Error if the value type is unsupported\n */\nexport function sizeOf(value: any): number {\n  if (value === null || value === undefined) {\n    return 0;\n  }\n  if (typeof value === 'string') {\n    return value.length;\n  }\n  if (Array.isArray(value)) {\n    return value.length;\n  }\n  if (typeof value === 'object' && value !== null) {\n    return Object.keys(value).length;\n  }\n  throw new Error(`size() not supported for type: ${typeof value}`);\n}\n\n/**\n * Converts the given value to a signed integer (number).\n *\n * Accepted inputs: number, string (parsed as integer), boolean (true=1, false=0)\n *\n * @param value The value to convert\n * @returns The converted integer value\n * @throws Error if the value cannot be converted\n */\nexport function asInt(value: any): number {\n  if (typeof value === 'number') {\n    return Math.trunc(value);\n  }\n  if (typeof value === 'string') {\n    const parsed = parseInt(value, 10);\n    if (isNaN(parsed)) {\n      throw new Error(`Cannot convert to int: ${value}`);\n    }\n    return parsed;\n  }\n  if (typeof value === 'boolean') {\n    return value ? 1 : 0;\n  }\n  throw new Error(`Cannot convert to int: ${value}`);\n}\n\n/**\n * Converts the given value to an unsigned integer.\n *\n * Negative inputs are not allowed and will result in an exception.\n *\n * @param value The value to convert\n * @returns The non-negative integer value\n * @throws Error if the value is negative or cannot be converted\n */\nexport function asUInt(value: any): number {\n  const result = asInt(value);\n  if (result < 0) {\n    throw new Error(`Cannot convert negative value to uint: ${value}`);\n  }\n  return result;\n}\n\n/**\n * Converts the given value to a double (number).\n *\n * Accepted inputs: number, string parsable as number\n *\n * @param value The value to convert\n * @returns The converted number value\n * @throws Error if the value cannot be converted\n */\nexport function asDouble(value: any): number {\n  if (typeof value === 'number') {\n    return value;\n  }\n  if (typeof value === 'string') {\n    const parsed = parseFloat(value);\n    if (isNaN(parsed)) {\n      throw new Error(`Cannot convert to double: ${value}`);\n    }\n    return parsed;\n  }\n  throw new Error(`Cannot convert to double: ${value}`);\n}\n\n/**\n * Converts the given value to its string representation.\n *\n * Returns the literal string \"null\" for null/undefined values.\n *\n * @param value The value to stringify\n * @returns The string representation\n */\nexport function asString(value: any): string {\n  if (value === null || value === undefined) {\n    return 'null';\n  }\n  return String(value);\n}\n\n/**\n * Converts the given value to a boolean using common truthiness rules.\n *\n * Numbers are true if non-zero. Strings are true if non-empty.\n * Collections/maps are true if non-empty. Null is false.\n *\n * @param value The value to interpret\n * @returns The boolean interpretation\n */\nexport function asBool(value: any): boolean {\n  if (typeof value === 'boolean') {\n    return value;\n  }\n  if (typeof value === 'number') {\n    return value !== 0;\n  }\n  if (typeof value === 'string') {\n    return value.length > 0;\n  }\n  if (Array.isArray(value)) {\n    return value.length > 0;\n  }\n  if (typeof value === 'object' && value !== null) {\n    return Object.keys(value).length > 0;\n  }\n  return value != null;\n}\n\n/**\n * Returns a simple type name for the given value.\n *\n * Possible results: \"null\", \"bool\", \"int\", \"double\", \"string\", \"list\", \"map\", or \"unknown\"\n *\n * @param value The value whose type is to be described\n * @returns The simple type name\n */\nexport function typeOf(value: any): string {\n  if (value === null || value === undefined) {\n    return 'null';\n  }\n  if (typeof value === 'boolean') {\n    return 'bool';\n  }\n  if (typeof value === 'number') {\n    return Number.isInteger(value) ? 'int' : 'double';\n  }\n  if (typeof value === 'string') {\n    return 'string';\n  }\n  if (Array.isArray(value)) {\n    return 'list';\n  }\n  if (typeof value === 'object') {\n    return 'map';\n  }\n  return 'unknown';\n}\n\n/**\n * Checks whether a map contains the given field name.\n *\n * @param target The map-like object to check (must be an object to return true/false)\n * @param field The field/key to look for (must be a string)\n * @returns true if target is a Map/object and contains the given key; false otherwise\n */\nexport function has(target: any, field: any): boolean {\n  if (typeof target === 'object' && target !== null && typeof field === 'string') {\n    return field in target;\n  }\n  return false;\n}\n\n/**\n * Tests whether the given regular expression matches any part of the text.\n *\n * Uses RegExp pattern matching with find semantics.\n *\n * @param text The input text\n * @param pattern The regular expression pattern\n * @returns true if the pattern matches anywhere in the text; false otherwise\n * @throws Error if the pattern is invalid\n */\nexport function matches(text: string, pattern: string): boolean {\n  try {\n    const regex = new RegExp(pattern);\n    return regex.test(text);\n  } catch {\n    throw new Error(`Invalid regex pattern: ${pattern}`);\n  }\n}\n\n/**\n * Returns the maximum element from a non-empty array of values.\n *\n * Comparison rules follow compare(). All elements must be mutually comparable.\n *\n * @param values A non-empty array of values\n * @returns The maximum value in the array\n * @throws Error if the array is empty or values are not comparable\n */\nexport function max(values: any[]): any {\n  if (values.length === 0) {\n    throw new Error('max() requires at least one argument');\n  }\n\n  let result = values[0];\n  for (let i = 1; i < values.length; i++) {\n    if (compare(values[i], result) > 0) {\n      result = values[i];\n    }\n  }\n  return result;\n}\n\n/**\n * Returns the minimum element from a non-empty array of values.\n *\n * Comparison rules follow compare(). All elements must be mutually comparable.\n *\n * @param values A non-empty array of values\n * @returns The minimum value in the array\n * @throws Error if the array is empty or values are not comparable\n */\nexport function min(values: any[]): any {\n  if (values.length === 0) {\n    throw new Error('min() requires at least one argument');\n  }\n\n  let result = values[0];\n  for (let i = 1; i < values.length; i++) {\n    if (compare(values[i], result) < 0) {\n      result = values[i];\n    }\n  }\n  return result;\n}\n\n/**\n * Compares two values using a common set of rules.\n *\n * Supported comparisons: numbers (by numeric value), strings (lexicographically),\n * booleans, arrays (lexicographically).\n *\n * @param a The first value\n * @param b The second value\n * @returns A negative number, zero, or a positive number as a is less than, equal to, or greater than b\n * @throws Error if the values cannot be compared\n */\nexport function compare(a: any, b: any): number {\n  if (a === null && b === null) {\n    return 0;\n  }\n  if (a === null) {\n    return -1;\n  }\n  if (b === null) {\n    return 1;\n  }\n\n  // Number comparison\n  if (typeof a === 'number' && typeof b === 'number') {\n    return a - b;\n  }\n\n  // String comparison\n  if (typeof a === 'string' && typeof b === 'string') {\n    return a.localeCompare(b);\n  }\n\n  // Boolean comparison\n  if (typeof a === 'boolean' && typeof b === 'boolean') {\n    return a === b ? 0 : a ? 1 : -1;\n  }\n\n  // Array comparison (lexicographic)\n  if (Array.isArray(a) && Array.isArray(b)) {\n    const size = Math.min(a.length, b.length);\n    for (let i = 0; i < size; i++) {\n      const cmp = compare(a[i], b[i]);\n      if (cmp !== 0) {\n        return cmp;\n      }\n    }\n    return a.length - b.length;\n  }\n\n  throw new Error(`Cannot compare types: ${typeof a} and ${typeof b}`);\n}\n\n/**\n * Deep equality check for CEL values.\n *\n * @param left First value\n * @param right Second value\n * @returns true if values are deeply equal\n */\nexport function deepEquals(left: any, right: any): boolean {\n  if (left === null || left === undefined || right === null || right === undefined) {\n    return left === right;\n  }\n\n  // Array equality\n  if (Array.isArray(left) && Array.isArray(right)) {\n    if (left.length !== right.length) {\n      return false;\n    }\n    for (let i = 0; i < left.length; i++) {\n      if (!deepEquals(left[i], right[i])) {\n        return false;\n      }\n    }\n    return true;\n  }\n\n  // Object/Map equality\n  if (typeof left === 'object' && typeof right === 'object' && !Array.isArray(left) && !Array.isArray(right)) {\n    const leftKeys = Object.keys(left);\n    const rightKeys = Object.keys(right);\n    if (leftKeys.length !== rightKeys.length) {\n      return false;\n    }\n    for (const key of leftKeys) {\n      if (!(key in right)) {\n        return false;\n      }\n      if (!deepEquals(left[key], right[key])) {\n        return false;\n      }\n    }\n    return true;\n  }\n\n  // Numeric equality with type coercion\n  if (typeof left === 'number' && typeof right === 'number') {\n    return left === right;\n  }\n\n  // Standard equality\n  return left === right;\n}\n\n/**\n * Helper for array contains with deep equality.\n *\n * @param array The array to search\n * @param value The value to find\n * @returns true if the array contains the value (using deep equality)\n */\nexport function containsInArray(array: any[], value: any): boolean {\n  for (const item of array) {\n    if (deepEquals(item, value)) {\n      return true;\n    }\n  }\n  return false;\n}\n","import { Functions, EvaluationError } from './functions.js';\nimport * as Utilities from './utilities.js';\n\n/**\n * Standard CEL function library implementation.\n *\n * Provides all built-in CEL functions including:\n * - Type conversions: int(), double(), string(), bool()\n * - Type checking: type()\n * - Collection operations: size(), has()\n * - String operations: contains(), startsWith(), endsWith(), matches()\n * - Math operations: max(), min()\n *\n * This class can be extended to add custom functions while retaining\n * all standard CEL functionality.\n */\nexport class StandardFunctions implements Functions {\n  callFunction(name: string, args: any[]): any {\n    switch (name) {\n      case 'size':\n        return Utilities.sizeOf(args[0]);\n      case 'int':\n        return Utilities.asInt(args[0]);\n      case 'uint':\n        return Utilities.asUInt(args[0]);\n      case 'double':\n        return Utilities.asDouble(args[0]);\n      case 'string':\n        return Utilities.asString(args[0]);\n      case 'bool':\n        return Utilities.asBool(args[0]);\n      case 'type':\n        return Utilities.typeOf(args[0]);\n      case 'has':\n        if (args.length !== 2) {\n          throw new Error('has() requires 2 arguments');\n        }\n        return Utilities.has(args[0], args[1]);\n      case 'matches':\n        if (args.length !== 2) {\n          throw new Error('matches() requires 2 arguments');\n        }\n        return Utilities.matches(args[0] as string, args[1] as string);\n      case 'max':\n        return Utilities.max(args);\n      case 'min':\n        return Utilities.min(args);\n      default:\n        throw new Error(`Unknown function: ${name}`);\n    }\n  }\n\n  callMethod(target: any, method: string, args: any[]): any {\n    if (target === null || target === undefined) {\n      throw new Error('Cannot call method on null');\n    }\n\n    switch (method) {\n      case 'contains':\n        if (typeof target === 'string' && args.length === 1 && typeof args[0] === 'string') {\n          return target.includes(args[0]);\n        } else if (Array.isArray(target) && args.length === 1) {\n          return target.includes(args[0]);\n        }\n        throw new Error('Invalid arguments for contains()');\n\n      case 'startsWith':\n        if (typeof target === 'string' && args.length === 1 && typeof args[0] === 'string') {\n          return target.startsWith(args[0]);\n        }\n        throw new Error('startsWith() requires string target and argument');\n\n      case 'endsWith':\n        if (typeof target === 'string' && args.length === 1 && typeof args[0] === 'string') {\n          return target.endsWith(args[0]);\n        }\n        throw new Error('endsWith() requires string target and argument');\n\n      case 'toLowerCase':\n        if (typeof target === 'string' && args.length === 0) {\n          return target.toLowerCase();\n        }\n        throw new Error('toLowerCase() requires string target');\n\n      case 'toUpperCase':\n        if (typeof target === 'string' && args.length === 0) {\n          return target.toUpperCase();\n        }\n        throw new Error('toUpperCase() requires string target');\n\n      case 'trim':\n        if (typeof target === 'string' && args.length === 0) {\n          return target.trim();\n        }\n        throw new Error('trim() requires string target');\n\n      case 'replace':\n        if (\n          typeof target === 'string' &&\n          args.length === 2 &&\n          typeof args[0] === 'string' &&\n          typeof args[1] === 'string'\n        ) {\n          // Note: JavaScript replace() only replaces first occurrence by default\n          // Use replaceAll() or split/join for all occurrences\n          return target.replaceAll(args[0], args[1]);\n        }\n        throw new Error('replace() requires string target and 2 string arguments');\n\n      case 'split':\n        if (typeof target === 'string' && args.length === 1 && typeof args[0] === 'string') {\n          // CEL split uses literal string matching, not regex\n          return target.split(args[0]);\n        }\n        throw new Error('split() requires string target and separator');\n\n      case 'size':\n        return Utilities.sizeOf(target);\n\n      // Macro functions are handled in the interpreter with special logic\n      case 'map':\n      case 'filter':\n      case 'all':\n      case 'exists':\n      case 'existsOne':\n        throw new EvaluationError(\n          `Macro function ${method} was not properly handled by the interpreter`\n        );\n\n      default:\n        // Try to call native JavaScript method\n        return this.callNativeMethod(target, method, args);\n    }\n  }\n\n  /**\n   * Attempts to call a native JavaScript method on the target object.\n   *\n   * @param target The object to call the method on\n   * @param name The method name\n   * @param args The arguments\n   * @returns The result of the method call\n   * @throws Error if the method doesn't exist or call fails\n   */\n  private callNativeMethod(target: any, name: string, args: any[]): any {\n    if (typeof target[name] === 'function') {\n      try {\n        return target[name](...args);\n      } catch (e) {\n        throw new EvaluationError(\n          `Invocation of method '${name}' failed: ${e instanceof Error ? e.message : String(e)}`\n        );\n      }\n    }\n    throw new Error(\n      `No such method '${name}' on type ${typeof target} with ${args.length} argument(s)`\n    );\n  }\n}\n","import {\n  Expression,\n  Visitor,\n  Literal,\n  Identifier,\n  Select,\n  Index,\n  Call,\n  ListExpression,\n  MapExpression,\n  Struct,\n  Comprehension,\n  Unary,\n  Binary,\n  Conditional,\n  BinaryOp,\n  UnaryOp,\n} from '../ast/index.js';\nimport { Functions, EvaluationError } from '../functions/functions.js';\nimport { StandardFunctions } from '../functions/standard-functions.js';\nimport * as Utilities from '../functions/utilities.js';\n\n/**\n * Interpreter for evaluating CEL expressions.\n *\n * Implements the Visitor pattern to traverse and evaluate the AST produced by the parser.\n * Supports all CEL operations including macros, type conversions, and complex expressions.\n */\nexport class Interpreter implements Visitor<any> {\n  private readonly variables: Record<string, any>;\n  private readonly functions: Functions;\n\n  /**\n   * Constructs an interpreter with the specified variables and functions.\n   *\n   * @param variables A map of variable names to their values. If null, an empty object is used.\n   * @param functions An instance of Functions to handle function calls. If null, StandardFunctions is used.\n   */\n  constructor(variables?: Record<string, any> | null, functions?: Functions | null) {\n    this.variables = variables ?? {};\n    this.functions = functions ?? new StandardFunctions();\n  }\n\n  /**\n   * Evaluates a CEL expression and returns its result.\n   *\n   * @param expr The expression to evaluate\n   * @returns The result of the evaluation\n   * @throws EvaluationError if evaluation fails\n   */\n  evaluate(expr: Expression): any {\n    return expr.accept(this);\n  }\n\n  visitLiteral(expr: Literal): any {\n    // In CEL, byte literals are just strings marked as bytes\n    return expr.value;\n  }\n\n  visitIdentifier(expr: Identifier): any {\n    if (!(expr.name in this.variables)) {\n      throw new EvaluationError(`Undefined variable: ${expr.name}`);\n    }\n    return this.variables[expr.name];\n  }\n\n  visitSelect(expr: Select): any {\n    const target = expr.operand !== null ? this.evaluate(expr.operand) : this.variables;\n\n    if (target === null || target === undefined) {\n      if (expr.isTest) {\n        return false;\n      }\n      throw new EvaluationError(`Cannot select field ${expr.field} from null`);\n    }\n\n    if (typeof target === 'object') {\n      if (expr.isTest) {\n        return expr.field in target;\n      }\n      if (!(expr.field in target)) {\n        throw new EvaluationError(`Field ${expr.field} not found`);\n      }\n      return target[expr.field];\n    }\n\n    throw new EvaluationError('Cannot select field from non-object type');\n  }\n\n  visitCall(expr: Call): any {\n    // For macro calls, we need special handling\n    if (expr.isMacro && expr.target !== null) {\n      const target = this.evaluate(expr.target);\n\n      // For macros, we pass the AST expressions, not evaluated values\n      if (expr.args.length === 0) {\n        throw new EvaluationError(`Macro ${expr.functionName} requires arguments`);\n      }\n\n      // Extract variable name from first argument\n      const firstArg = expr.args[0]!;\n      if (!(firstArg instanceof Identifier)) {\n        throw new EvaluationError(\n          `First argument to macro ${expr.functionName} must be a variable name`\n        );\n      }\n      const variableName = firstArg.name;\n\n      // Second argument is the expression (kept as AST)\n      if (expr.args.length < 2) {\n        throw new EvaluationError(`Macro ${expr.functionName} requires an expression argument`);\n      }\n      const macroExpr = expr.args[1]!;\n\n      // Handle each macro function\n      return this.evaluateMacro(target, expr.functionName, variableName, macroExpr);\n    }\n\n    // Regular function call - evaluate all arguments\n    const args: any[] = [];\n    for (const arg of expr.args) {\n      args.push(this.evaluate(arg));\n    }\n\n    if (expr.target !== null) {\n      const target = this.evaluate(expr.target);\n      return this.functions.callMethod(target, expr.functionName, args);\n    } else {\n      return this.functions.callFunction(expr.functionName, args);\n    }\n  }\n\n  private evaluateMacro(target: any, functionName: string, variableName: string, expr: Expression): any {\n    if (!Array.isArray(target)) {\n      throw new EvaluationError(`Macro ${functionName} requires a list target`);\n    }\n\n    // Save the current value of the variable (if any)\n    const saved = this.variables[variableName];\n    const had = variableName in this.variables;\n\n    try {\n      switch (functionName) {\n        case 'map': {\n          const results: any[] = [];\n          for (const item of target) {\n            this.variables[variableName] = item;\n            results.push(this.evaluate(expr));\n          }\n          return results;\n        }\n\n        case 'filter': {\n          const results: any[] = [];\n          for (const item of target) {\n            this.variables[variableName] = item;\n            const condition = this.evaluate(expr);\n            if (condition === true) {\n              results.push(item);\n            }\n          }\n          return results;\n        }\n\n        case 'all': {\n          for (const item of target) {\n            this.variables[variableName] = item;\n            const condition = this.evaluate(expr);\n            if (condition !== true) {\n              return false;\n            }\n          }\n          return true;\n        }\n\n        case 'exists': {\n          for (const item of target) {\n            this.variables[variableName] = item;\n            const condition = this.evaluate(expr);\n            if (condition === true) {\n              return true;\n            }\n          }\n          return false;\n        }\n\n        case 'existsOne': {\n          let count = 0;\n          for (const item of target) {\n            this.variables[variableName] = item;\n            const condition = this.evaluate(expr);\n            if (condition === true) {\n              count++;\n              if (count > 1) {\n                return false;\n              }\n            }\n          }\n          return count === 1;\n        }\n\n        default:\n          throw new EvaluationError(`Unknown macro function: ${functionName}`);\n      }\n    } finally {\n      // Restore the original value of the variable\n      if (had) {\n        this.variables[variableName] = saved;\n      } else {\n        delete this.variables[variableName];\n      }\n    }\n  }\n\n  visitList(expr: ListExpression): any {\n    const result: any[] = [];\n    for (const element of expr.elements) {\n      result.push(this.evaluate(element));\n    }\n    return result;\n  }\n\n  visitMap(expr: MapExpression): any {\n    const map: Record<string, any> = {};\n    for (const entry of expr.entries) {\n      const key = this.evaluate(entry.key);\n      const value = this.evaluate(entry.value);\n      map[key] = value;\n    }\n    return map;\n  }\n\n  visitStruct(expr: Struct): any {\n    const map: Record<string, any> = {};\n    for (const field of expr.fields) {\n      map[field.field] = this.evaluate(field.value);\n    }\n    return map;\n  }\n\n  visitComprehension(expr: Comprehension): any {\n    const range = this.evaluate(expr.range);\n    if (!Array.isArray(range)) {\n      throw new EvaluationError('Comprehension range must be a list');\n    }\n\n    const iteratorSaved = this.variables[expr.variable];\n    const accumulatorSaved = this.variables[expr.accumulator];\n    const hadIterator = expr.variable in this.variables;\n    const hadAccumulator = expr.accumulator in this.variables;\n\n    try {\n      let accumulator = this.evaluate(expr.initializer);\n      this.variables[expr.accumulator] = accumulator;\n\n      for (const item of range) {\n        this.variables[expr.variable] = item;\n\n        const condition = this.evaluate(expr.condition);\n        if (condition !== true) {\n          continue;\n        }\n\n        accumulator = this.evaluate(expr.step);\n        this.variables[expr.accumulator] = accumulator;\n      }\n\n      return this.evaluate(expr.result);\n    } finally {\n      // Restore the original values\n      if (hadIterator) {\n        this.variables[expr.variable] = iteratorSaved;\n      } else {\n        delete this.variables[expr.variable];\n      }\n      if (hadAccumulator) {\n        this.variables[expr.accumulator] = accumulatorSaved;\n      } else {\n        delete this.variables[expr.accumulator];\n      }\n    }\n  }\n\n  visitUnary(expr: Unary): any {\n    const operand = this.evaluate(expr.operand);\n\n    switch (expr.op) {\n      case UnaryOp.NOT:\n        if (typeof operand !== 'boolean') {\n          throw new EvaluationError('NOT operator requires boolean operand');\n        }\n        return !operand;\n\n      case UnaryOp.NEGATE:\n        if (typeof operand !== 'number') {\n          throw new EvaluationError('Negation requires numeric operand');\n        }\n        return -operand;\n\n      default:\n        throw new EvaluationError(`Unknown unary operator: ${expr.op}`);\n    }\n  }\n\n  visitBinary(expr: Binary): any {\n    // Short-circuit evaluation for logical operators\n    if (expr.op === BinaryOp.LOGICAL_AND) {\n      const left = this.evaluate(expr.left);\n      if (left !== true) {\n        return false;\n      }\n      return this.evaluate(expr.right) === true;\n    } else if (expr.op === BinaryOp.LOGICAL_OR) {\n      const left = this.evaluate(expr.left);\n      if (left === true) {\n        return true;\n      }\n      return this.evaluate(expr.right) === true;\n    }\n\n    const left = this.evaluate(expr.left);\n    const right = this.evaluate(expr.right);\n\n    switch (expr.op) {\n      case BinaryOp.ADD:\n        // String concatenation\n        if (typeof left === 'string' || typeof right === 'string') {\n          return String(left) + String(right);\n        }\n        // Array concatenation\n        if (Array.isArray(left) && Array.isArray(right)) {\n          return [...left, ...right];\n        }\n        // Numeric addition\n        if (typeof left === 'number' && typeof right === 'number') {\n          return left + right;\n        }\n        throw new EvaluationError('Invalid operands for addition');\n\n      case BinaryOp.SUBTRACT:\n        if (typeof left === 'number' && typeof right === 'number') {\n          return left - right;\n        }\n        throw new EvaluationError('Subtraction requires numeric operands');\n\n      case BinaryOp.MULTIPLY:\n        if (typeof left === 'number' && typeof right === 'number') {\n          return left * right;\n        }\n        // String repetition\n        if (typeof left === 'string' && typeof right === 'number') {\n          return left.repeat(right);\n        }\n        // Array repetition\n        if (Array.isArray(left) && typeof right === 'number') {\n          const result: any[] = [];\n          for (let i = 0; i < right; i++) {\n            result.push(...left);\n          }\n          return result;\n        }\n        throw new EvaluationError('Invalid operands for multiplication');\n\n      case BinaryOp.DIVIDE:\n        if (typeof left === 'number' && typeof right === 'number') {\n          if (right === 0) {\n            throw new EvaluationError('Division by zero');\n          }\n          // Division always returns double in CEL\n          return left / right;\n        }\n        throw new EvaluationError('Division requires numeric operands');\n\n      case BinaryOp.MODULO:\n        if (typeof left === 'number' && typeof right === 'number') {\n          if (right === 0) {\n            throw new EvaluationError('Modulo by zero');\n          }\n          return left % right;\n        }\n        throw new EvaluationError('Modulo requires integer operands');\n\n      case BinaryOp.EQUAL:\n        return Utilities.deepEquals(left, right);\n\n      case BinaryOp.NOT_EQUAL:\n        return !Utilities.deepEquals(left, right);\n\n      case BinaryOp.LESS:\n        return Utilities.compare(left, right) < 0;\n\n      case BinaryOp.LESS_EQUAL:\n        return Utilities.compare(left, right) <= 0;\n\n      case BinaryOp.GREATER:\n        return Utilities.compare(left, right) > 0;\n\n      case BinaryOp.GREATER_EQUAL:\n        return Utilities.compare(left, right) >= 0;\n\n      case BinaryOp.IN:\n        if (Array.isArray(right)) {\n          return Utilities.containsInArray(right, left);\n        } else if (typeof right === 'object' && right !== null) {\n          return left in right;\n        } else if (typeof right === 'string' && typeof left === 'string') {\n          return right.includes(left);\n        }\n        throw new EvaluationError('IN operator requires list, map, or string on right side');\n\n      default:\n        throw new EvaluationError(`Unknown binary operator: ${expr.op}`);\n    }\n  }\n\n  visitConditional(expr: Conditional): any {\n    const condition = this.evaluate(expr.condition);\n    if (condition === true) {\n      return this.evaluate(expr.thenExpr);\n    } else {\n      return this.evaluate(expr.otherwiseExpr);\n    }\n  }\n\n  visitIndex(expr: Index): any {\n    const operand = this.evaluate(expr.operand);\n    const index = this.evaluate(expr.index);\n\n    if (operand === null || operand === undefined) {\n      throw new EvaluationError('Cannot index null value');\n    }\n\n    if (Array.isArray(operand)) {\n      if (typeof index !== 'number') {\n        throw new EvaluationError('List index must be an integer');\n      }\n      const idx = Math.trunc(index);\n      if (idx < 0 || idx >= operand.length) {\n        throw new EvaluationError(`List index out of bounds: ${idx}`);\n      }\n      return operand[idx];\n    } else if (typeof operand === 'object') {\n      if (!(index in operand)) {\n        throw new EvaluationError(`Map key not found: ${index}`);\n      }\n      return operand[index];\n    } else if (typeof operand === 'string') {\n      if (typeof index !== 'number') {\n        throw new EvaluationError('String index must be an integer');\n      }\n      const idx = Math.trunc(index);\n      if (idx < 0 || idx >= operand.length) {\n        throw new EvaluationError(`String index out of bounds: ${idx}`);\n      }\n      return operand[idx];\n    }\n\n    throw new EvaluationError(`Cannot index type: ${typeof operand}`);\n  }\n}\n","import { Expression } from './ast/index.js';\nimport { Functions } from './functions/index.js';\nimport { Interpreter } from './interpreter/index.js';\n\n/**\n * A compiled CEL program that can be evaluated multiple times.\n *\n * A Program represents a parsed CEL expression that can be efficiently evaluated\n * with different sets of variables. This is more efficient than parsing the\n * expression each time it needs to be evaluated.\n *\n * Programs are created using CEL.compile() and should be reused when the same\n * expression needs to be evaluated multiple times.\n *\n * @example\n * ```typescript\n * const program = cel.compile('price * quantity');\n * const result1 = program.evaluate({ price: 10, quantity: 5 });\n * const result2 = program.evaluate({ price: 20, quantity: 3 });\n * ```\n */\nexport class Program {\n  /**\n   * Creates a new compiled program.\n   *\n   * This constructor is typically called by CEL.compile() and should not be used directly.\n   *\n   * @param ast The abstract syntax tree of the compiled expression\n   * @param functions The function library to use for evaluation\n   */\n  constructor(\n    private readonly ast: Expression,\n    private readonly functions: Functions\n  ) {}\n\n  /**\n   * Evaluates the compiled program with the given variables.\n   *\n   * @param variables A map of variable names to their values\n   * @returns The result of evaluating the expression\n   * @throws EvaluationError if an error occurs during evaluation\n   *\n   * @example\n   * ```typescript\n   * const result = program.evaluate({\n   *   x: 10,\n   *   y: 20,\n   *   items: [1, 2, 3]\n   * });\n   * ```\n   */\n  evaluate(variables: Record<string, any> = {}): any {\n    const interpreter = new Interpreter({ ...variables }, this.functions);\n    return interpreter.evaluate(this.ast);\n  }\n}\n","import { Parser } from './parser/index.js';\nimport { Functions, StandardFunctions } from './functions/index.js';\nimport { Program } from './program.js';\n\n/**\n * The main entry point for evaluating CEL expressions.\n *\n * The CEL class provides methods to compile and evaluate CEL expressions.\n * It supports all standard CEL operators, functions, and macros.\n *\n * @example\n * ```typescript\n * const cel = new CEL();\n * const result = cel.eval('x * 2 + y', { x: 10, y: 5 });\n * console.log(result); // 25\n * ```\n */\nexport class CEL {\n  private readonly functions: Functions;\n\n  /**\n   * Creates a new CEL evaluator with the standard function library.\n   */\n  constructor();\n\n  /**\n   * Creates a new CEL evaluator.\n   *\n   * @param functions Optional custom function library. If not provided, the standard\n   *                  CEL function library will be used.\n   */\n  constructor(functions?: Functions | null);\n\n  constructor(functions?: Functions | null) {\n    this.functions = functions ?? new StandardFunctions();\n  }\n\n  /**\n   * Compiles a CEL expression using the provided function library.\n   *\n   * This static convenience method avoids the need to instantiate CEL when\n   * callers just need to compile once.\n   *\n   * @param expression The CEL expression to compile\n   * @param functions The function library to use when compiling the program\n   * @returns A compiled Program using the provided functions\n   * @throws ParseError if the expression is invalid\n   *\n   * @example\n   * ```typescript\n   * const program = CEL.compile('x + y', new StandardFunctions());\n   * ```\n   */\n  static compile(expression: string, functions: Functions): Program {\n    const parser = new Parser(expression);\n    return new Program(parser.parse(), functions);\n  }\n\n  /**\n   * Evaluates a CEL expression with the given variables using the provided function library.\n   *\n   * This static convenience method avoids the need to instantiate CEL when callers\n   * just need to evaluate an expression once.\n   *\n   * @param expression The CEL expression to evaluate\n   * @param functions The function library to use when evaluating the expression\n   * @param variables A map of variable names to their values\n   * @returns The result of evaluating the expression\n   * @throws ParseError if the expression is invalid\n   * @throws EvaluationError if an error occurs during evaluation\n   *\n   * @example\n   * ```typescript\n   * const result = CEL.eval('x * 2', new StandardFunctions(), { x: 5 });\n   * ```\n   */\n  static eval(expression: string, functions: Functions, variables: Record<string, any>): any {\n    const program = this.compile(expression, functions);\n    return program.evaluate(variables);\n  }\n\n  /**\n   * Compiles a CEL expression into a reusable program.\n   *\n   * This method parses the expression and returns a Program that can be evaluated\n   * multiple times with different variables. This is more efficient than calling\n   * eval() repeatedly with the same expression.\n   *\n   * @param expression The CEL expression to compile\n   * @returns A compiled program\n   * @throws ParseError if the expression is invalid\n   *\n   * @example\n   * ```typescript\n   * const program = cel.compile('price * quantity');\n   * const result1 = program.evaluate({ price: 10, quantity: 5 });\n   * const result2 = program.evaluate({ price: 20, quantity: 3 });\n   * ```\n   */\n  compile(expression: string): Program {\n    return CEL.compile(expression, this.functions);\n  }\n\n  /**\n   * Evaluates a CEL expression with the given variables.\n   *\n   * This is a convenience method that compiles and evaluates the expression in one step.\n   * For better performance when evaluating the same expression multiple times, use\n   * compile() to create a reusable Program.\n   *\n   * @param expression The CEL expression to evaluate\n   * @param variables A map of variable names to their values\n   * @returns The result of evaluating the expression\n   * @throws ParseError if the expression is invalid\n   * @throws EvaluationError if an error occurs during evaluation\n   *\n   * @example\n   * ```typescript\n   * const result = cel.eval('user.age >= 18', {\n   *   user: { name: 'Alice', age: 25 }\n   * });\n   * ```\n   */\n  eval(expression: string, variables: Record<string, any> = {}): any {\n    return CEL.eval(expression, this.functions, variables);\n  }\n}\n"],"names":["ParseError","message","line","column","TokenType","Token","type","value","Lexer","input","count","ch","n","i","start","next","offset","isRaw","prefix","quote","suffix","isDouble","c","sign","pos","BinaryOp","UnaryOp","LiteralType","Literal","literalType","visitor","Identifier","name","Select","operand","field","isTest","Index","index","Call","target","functionName","args","isMacro","ListExpression","elements","MapEntry","key","MapExpression","entries","FieldInitializer","Struct","typeName","fields","Comprehension","variable","range","accumulator","initializer","condition","step","result","Unary","op","Binary","left","right","Conditional","thenExpr","otherwiseExpr","MACRO_METHODS","Parser","expr","operator","qualified","expressions","currentType","first","token","number","content","hex","codePoint","octal","lookahead","EvaluationError","sizeOf","asInt","parsed","asUInt","asDouble","asString","asBool","typeOf","has","matches","text","pattern","max","values","compare","min","a","b","size","cmp","deepEquals","leftKeys","rightKeys","containsInArray","array","item","StandardFunctions","Utilities.sizeOf","Utilities.asInt","Utilities.asUInt","Utilities.asDouble","Utilities.asString","Utilities.asBool","Utilities.typeOf","Utilities.has","Utilities.matches","Utilities.max","Utilities.min","method","e","Interpreter","variables","functions","firstArg","variableName","macroExpr","arg","saved","had","results","element","map","entry","iteratorSaved","accumulatorSaved","hadIterator","hadAccumulator","Utilities.deepEquals","Utilities.compare","Utilities.containsInArray","idx","Program","ast","CEL","expression","parser"],"mappings":"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"}