@libdbm/libcel-ts 1.0.2-rc.0

package/dist/index.mjs

@@ -0,0 +1,1414 @@
+class f extends Error {
+  constructor(t, e, i) {
+    super(`${t} at ${e}:${i}`), this.line = e, this.column = i, this.name = "ParseError";
+  }
+}
+var s = /* @__PURE__ */ ((r) => (r.NULL = "NULL", r.TRUE = "TRUE", r.FALSE = "FALSE", r.INT = "INT", r.UINT = "UINT", r.DOUBLE = "DOUBLE", r.STRING = "STRING", r.BYTES = "BYTES", r.IDENTIFIER = "IDENTIFIER", r.PLUS = "PLUS", r.MINUS = "MINUS", r.STAR = "STAR", r.SLASH = "SLASH", r.PERCENT = "PERCENT", r.EQ = "EQ", r.NE = "NE", r.LT = "LT", r.LE = "LE", r.GT = "GT", r.GE = "GE", r.LOGICAL_AND = "LOGICAL_AND", r.LOGICAL_OR = "LOGICAL_OR", r.BANG = "BANG", r.IN = "IN", r.LPAREN = "LPAREN", r.RPAREN = "RPAREN", r.LBRACKET = "LBRACKET", r.RBRACKET = "RBRACKET", r.LBRACE = "LBRACE", r.RBRACE = "RBRACE", r.DOT = "DOT", r.COMMA = "COMMA", r.COLON = "COLON", r.QUESTION = "QUESTION", r.EOF = "EOF", r))(s || {});
+class h {
+  constructor(t, e, i, n) {
+    this.type = t, this.value = e, this.line = i, this.column = n;
+  }
+  toString() {
+    return `${this.type}(${this.value})`;
+  }
+}
+class F {
+  constructor(t) {
+    this.input = t, this.position = 0, this.line = 1, this.column = 1, this.lookahead = [];
+  }
+  /**
+   * Get the next token from the input.
+   */
+  next() {
+    return this.lookahead.length > 0 ? this.lookahead.shift() : this.token();
+  }
+  /**
+   * Peek ahead at future tokens without consuming them.
+   * @param count Number of tokens to look ahead (1-indexed)
+   */
+  peek(t) {
+    for (; this.lookahead.length < t; )
+      this.lookahead.push(this.token());
+    return this.lookahead[t - 1];
+  }
+  step() {
+    if (this.position >= this.input.length) return;
+    const t = this.input[this.position];
+    this.position++, t === "\r" ? (this.position < this.input.length && this.input[this.position] === `
+` && this.position++, this.line++, this.column = 1) : t === `
+` ? (this.line++, this.column = 1) : this.column++;
+  }
+  forward(t) {
+    for (let e = 0; e < t; e++)
+      this.step();
+  }
+  token() {
+    if (this.whitespace(), this.position >= this.input.length)
+      return new h("EOF", "", this.line, this.column);
+    const t = this.position, e = this.line, i = this.column, n = this.input[this.position];
+    switch (n) {
+      case "(":
+        return this.step(), new h("LPAREN", "(", e, i);
+      case ")":
+        return this.step(), new h("RPAREN", ")", e, i);
+      case "[":
+        return this.step(), new h("LBRACKET", "[", e, i);
+      case "]":
+        return this.step(), new h("RBRACKET", "]", e, i);
+      case "{":
+        return this.step(), new h("LBRACE", "{", e, i);
+      case "}":
+        return this.step(), new h("RBRACE", "}", e, i);
+      case ",":
+        return this.step(), new h("COMMA", ",", e, i);
+      case ".":
+        return this.step(), new h("DOT", ".", e, i);
+      case ":":
+        return this.step(), new h("COLON", ":", e, i);
+      case "?":
+        return this.step(), new h("QUESTION", "?", e, i);
+      case "+":
+        return this.step(), new h("PLUS", "+", e, i);
+      case "*":
+        return this.step(), new h("STAR", "*", e, i);
+      case "/":
+        return this.step(), new h("SLASH", "/", e, i);
+      case "%":
+        return this.step(), new h("PERCENT", "%", e, i);
+    }
+    if (n === "&" && this.peekChar() === "&")
+      return this.forward(2), new h("LOGICAL_AND", "&&", e, i);
+    if (n === "|" && this.peekChar() === "|")
+      return this.forward(2), new h("LOGICAL_OR", "||", e, i);
+    if (n === "=" && this.peekChar() === "=")
+      return this.forward(2), new h("EQ", "==", e, i);
+    if (n === "!" && this.peekChar() === "=")
+      return this.forward(2), new h("NE", "!=", e, i);
+    if (n === "<" && this.peekChar() === "=")
+      return this.forward(2), new h("LE", "<=", e, i);
+    if (n === ">" && this.peekChar() === "=")
+      return this.forward(2), new h("GE", ">=", e, i);
+    if (n === "<")
+      return this.step(), new h("LT", "<", e, i);
+    if (n === ">")
+      return this.step(), new h("GT", ">", e, i);
+    if (n === "!")
+      return this.step(), new h("BANG", "!", e, i);
+    if (n === "-")
+      return this.step(), new h("MINUS", "-", e, i);
+    if (n === '"' || n === "'")
+      return this.string(e, i, t);
+    if ((n === "r" || n === "R") && this.position + 1 < this.input.length) {
+      const o = this.input[this.position + 1];
+      if (o === '"' || o === "'")
+        return this.string(e, i, t);
+    }
+    if ((n === "b" || n === "B") && this.position + 1 < this.input.length) {
+      const o = this.input[this.position + 1];
+      if (o === '"' || o === "'")
+        return this.bytes(e, i, t);
+    }
+    if (this.isDigit(n))
+      return this.number(e, i, t);
+    if (this.isLetter(n) || n === "_")
+      return this.identifier(e, i, t);
+    throw new f(`Unexpected character: ${n}`, e, i);
+  }
+  string(t, e, i) {
+    let n = !1;
+    if ((this.input[this.position] === "r" || this.input[this.position] === "R") && (n = !0, this.step()), this.position + 2 < this.input.length) {
+      const l = this.input.substring(this.position, this.position + 3);
+      if (l === '"""' || l === "'''") {
+        const u = this.input[this.position];
+        for (this.forward(3); this.position + 2 < this.input.length; ) {
+          if (this.input[this.position] === u && this.input[this.position + 1] === u && this.input[this.position + 2] === u)
+            return this.forward(3), new h("STRING", this.input.substring(i, this.position), t, e);
+          this.step();
+        }
+        throw new f("Unterminated triple-quoted string", t, e);
+      }
+    }
+    const o = this.input[this.position];
+    for (this.step(); this.position < this.input.length; ) {
+      const l = this.input[this.position];
+      if (l === o)
+        return this.step(), new h("STRING", this.input.substring(i, this.position), t, e);
+      l === "\\" && !n && this.position + 1 < this.input.length ? this.forward(2) : this.step();
+    }
+    throw new f("Unterminated string", t, e);
+  }
+  bytes(t, e, i) {
+    this.step();
+    const n = this.input[this.position];
+    for (this.step(); this.position < this.input.length; ) {
+      const o = this.input[this.position];
+      if (o === n)
+        return this.step(), new h("BYTES", this.input.substring(i, this.position), t, e);
+      o === "\\" && this.position + 1 < this.input.length ? this.forward(2) : this.step();
+    }
+    throw new f("Unterminated bytes literal", t, e);
+  }
+  number(t, e, i) {
+    if (this.input[this.position] === "0" && this.position + 1 < this.input.length) {
+      const l = this.input[this.position + 1];
+      if (l === "x" || l === "X") {
+        for (this.forward(2); this.position < this.input.length && this.isHexDigit(this.input[this.position]); )
+          this.step();
+        if (this.position < this.input.length) {
+          const u = this.input[this.position];
+          if (u === "u" || u === "U")
+            return this.step(), new h("UINT", this.input.substring(i, this.position), t, e);
+        }
+        return new h("INT", this.input.substring(i, this.position), t, e);
+      }
+    }
+    for (; this.position < this.input.length && this.isDigit(this.input[this.position]); )
+      this.step();
+    let n = !1;
+    if (this.position < this.input.length && this.input[this.position] === ".")
+      for (n = !0, this.step(); this.position < this.input.length && this.isDigit(this.input[this.position]); )
+        this.step();
+    if (this.position < this.input.length) {
+      const l = this.input[this.position];
+      if (l === "e" || l === "E") {
+        if (n = !0, this.step(), this.position < this.input.length) {
+          const u = this.input[this.position];
+          (u === "+" || u === "-") && this.step();
+        }
+        for (; this.position < this.input.length && this.isDigit(this.input[this.position]); )
+          this.step();
+      }
+    }
+    if (!n && this.position < this.input.length) {
+      const l = this.input[this.position];
+      if (l === "u" || l === "U")
+        return this.step(), new h("UINT", this.input.substring(i, this.position), t, e);
+    }
+    const o = n ? "DOUBLE" : "INT";
+    return new h(o, this.input.substring(i, this.position), t, e);
+  }
+  identifier(t, e, i) {
+    for (; this.position < this.input.length; ) {
+      const l = this.input[this.position];
+      if (!this.isLetterOrDigit(l) && l !== "_")
+        break;
+      this.step();
+    }
+    const n = this.input.substring(i, this.position), o = this.typeOf(n);
+    return new h(o, n, t, e);
+  }
+  typeOf(t) {
+    switch (t) {
+      case "null":
+        return "NULL";
+      case "true":
+        return "TRUE";
+      case "false":
+        return "FALSE";
+      case "in":
+        return "IN";
+      default:
+        return "IDENTIFIER";
+    }
+  }
+  whitespace() {
+    for (; this.position < this.input.length; ) {
+      const t = this.input[this.position];
+      if (t !== " " && t !== "	" && t !== `
+` && t !== "\r")
+        break;
+      this.step();
+    }
+  }
+  peekChar() {
+    const t = this.position + 1;
+    return t >= this.input.length ? "\0" : this.input[t];
+  }
+  isHexDigit(t) {
+    return t >= "0" && t <= "9" || t >= "a" && t <= "f" || t >= "A" && t <= "F";
+  }
+  isDigit(t) {
+    return t >= "0" && t <= "9";
+  }
+  isLetter(t) {
+    return t >= "a" && t <= "z" || t >= "A" && t <= "Z";
+  }
+  isLetterOrDigit(t) {
+    return this.isLetter(t) || this.isDigit(t);
+  }
+}
+var c = /* @__PURE__ */ ((r) => (r.ADD = "ADD", r.SUBTRACT = "SUBTRACT", r.MULTIPLY = "MULTIPLY", r.DIVIDE = "DIVIDE", r.MODULO = "MODULO", r.EQUAL = "EQUAL", r.NOT_EQUAL = "NOT_EQUAL", r.LESS = "LESS", r.LESS_EQUAL = "LESS_EQUAL", r.GREATER = "GREATER", r.GREATER_EQUAL = "GREATER_EQUAL", r.IN = "IN", r.LOGICAL_AND = "LOGICAL_AND", r.LOGICAL_OR = "LOGICAL_OR", r))(c || {}), g = /* @__PURE__ */ ((r) => (r.NOT = "NOT", r.NEGATE = "NEGATE", r))(g || {}), w = /* @__PURE__ */ ((r) => (r.NULL_VALUE = "NULL_VALUE", r.BOOL = "BOOL", r.INT = "INT", r.UINT = "UINT", r.DOUBLE = "DOUBLE", r.STRING = "STRING", r.BYTES = "BYTES", r))(w || {});
+class d {
+  constructor(t, e) {
+    this.value = t, this.literalType = e;
+  }
+  accept(t) {
+    return t.visitLiteral(this);
+  }
+}
+class U {
+  constructor(t) {
+    this.name = t;
+  }
+  accept(t) {
+    return t.visitIdentifier(this);
+  }
+}
+class N {
+  constructor(t, e, i = !1) {
+    this.operand = t, this.field = e, this.isTest = i;
+  }
+  accept(t) {
+    return t.visitSelect(this);
+  }
+}
+class Q {
+  constructor(t, e) {
+    this.operand = t, this.index = e;
+  }
+  accept(t) {
+    return t.visitIndex(this);
+  }
+}
+class y {
+  constructor(t, e, i, n = !1) {
+    this.target = t, this.functionName = e, this.args = i, this.isMacro = n;
+  }
+  accept(t) {
+    return t.visitCall(this);
+  }
+}
+class q {
+  constructor(t) {
+    this.elements = t;
+  }
+  accept(t) {
+    return t.visitList(this);
+  }
+}
+class W {
+  constructor(t, e) {
+    this.key = t, this.value = e;
+  }
+}
+class C {
+  constructor(t) {
+    this.entries = t;
+  }
+  accept(t) {
+    return t.visitMap(this);
+  }
+}
+class j {
+  constructor(t, e) {
+    this.field = t, this.value = e;
+  }
+}
+class S {
+  constructor(t, e) {
+    this.typeName = t, this.fields = e;
+  }
+  accept(t) {
+    return t.visitStruct(this);
+  }
+}
+class X {
+  constructor(t, e, i, n, o, l, u) {
+    this.variable = t, this.range = e, this.accumulator = i, this.initializer = n, this.condition = o, this.step = l, this.result = u;
+  }
+  accept(t) {
+    return t.visitComprehension(this);
+  }
+}
+class O {
+  constructor(t, e) {
+    this.op = t, this.operand = e;
+  }
+  accept(t) {
+    return t.visitUnary(this);
+  }
+}
+class L {
+  constructor(t, e, i) {
+    this.op = t, this.left = e, this.right = i;
+  }
+  accept(t) {
+    return t.visitBinary(this);
+  }
+}
+class K {
+  constructor(t, e, i) {
+    this.condition = t, this.thenExpr = e, this.otherwiseExpr = i;
+  }
+  accept(t) {
+    return t.visitConditional(this);
+  }
+}
+const z = /* @__PURE__ */ new Set(["map", "filter", "all", "exists", "existsOne"]);
+class Y {
+  constructor(t) {
+    this.lexer = new F(t), this.current = this.lexer.next();
+  }
+  /**
+   * Parse a CEL expression from the input string.
+   * @returns The parsed Expression AST node
+   * @throws ParseError if the input contains syntax errors
+   */
+  parse() {
+    const t = this.parseExpr();
+    if (this.current.type !== s.EOF)
+      throw new f(
+        `Unexpected token after expression: ${this.current.value}`,
+        this.current.line,
+        this.current.column
+      );
+    return t;
+  }
+  // expr = conditionalOr ( '?' conditionalOr ':' expr )?
+  parseExpr() {
+    const t = this.parseConditionalOr();
+    if (this.match(s.QUESTION)) {
+      const e = this.parseConditionalOr();
+      this.expect(s.COLON);
+      const i = this.parseExpr();
+      return new K(t, e, i);
+    }
+    return t;
+  }
+  // conditionalOr = conditionalAnd ( '||' conditionalAnd )*
+  parseConditionalOr() {
+    let t = this.parseConditionalAnd();
+    for (; this.match(s.LOGICAL_OR); ) {
+      const e = this.parseConditionalAnd();
+      t = new L(c.LOGICAL_OR, t, e);
+    }
+    return t;
+  }
+  // conditionalAnd = relation ( '&&' relation )*
+  parseConditionalAnd() {
+    let t = this.parseRelation();
+    for (; this.match(s.LOGICAL_AND); ) {
+      const e = this.parseRelation();
+      t = new L(c.LOGICAL_AND, t, e);
+    }
+    return t;
+  }
+  // relation = addition ( relop addition )*
+  // relop = '<=' | '>=' | '!=' | '==' | '<' | '>' | 'in'
+  parseRelation() {
+    let t = this.parseAddition();
+    for (; this.isRelationalOp(this.current.type); ) {
+      const e = this.current.type;
+      this.advance();
+      const i = this.parseAddition();
+      t = new L(this.toBinaryOp(e), t, i);
+    }
+    return t;
+  }
+  // addition = multiplication ( ('+' | '-') multiplication )*
+  parseAddition() {
+    let t = this.parseMultiplication();
+    for (; this.current.type === s.PLUS || this.current.type === s.MINUS; ) {
+      const e = this.current.type;
+      this.advance();
+      const i = this.parseMultiplication();
+      t = new L(e === s.PLUS ? c.ADD : c.SUBTRACT, t, i);
+    }
+    return t;
+  }
+  // multiplication = unary ( ('*' | '/' | '%') unary )*
+  parseMultiplication() {
+    let t = this.parseUnary();
+    for (; this.current.type === s.STAR || this.current.type === s.SLASH || this.current.type === s.PERCENT; ) {
+      const e = this.current.type;
+      this.advance();
+      const i = this.parseUnary(), n = e === s.STAR ? c.MULTIPLY : e === s.SLASH ? c.DIVIDE : c.MODULO;
+      t = new L(n, t, i);
+    }
+    return t;
+  }
+  // unary = '!'+ member | '-'+ member | member
+  parseUnary() {
+    return this.current.type === s.BANG ? (this.advance(), new O(g.NOT, this.parseUnary())) : this.current.type === s.MINUS ? (this.advance(), new O(g.NEGATE, this.parseUnary())) : this.parseMember();
+  }
+  // member = primary ( selector | index | fieldCall )*
+  parseMember() {
+    let t = this.parsePrimary();
+    for (; ; )
+      if (this.current.type === s.DOT) {
+        this.advance();
+        const e = this.expectIdentifier();
+        if (this.current.type === s.LPAREN) {
+          this.advance();
+          const i = this.parseExprList();
+          this.expect(s.RPAREN);
+          const n = z.has(e);
+          t = new y(t, e, i, n);
+        } else
+          t = new N(t, e);
+      } else if (this.current.type === s.LBRACKET) {
+        this.advance();
+        const e = this.parseExpr();
+        this.expect(s.RBRACKET), t = new Q(t, e);
+      } else
+        break;
+    return t;
+  }
+  // primary = literal | ident callArgs? | listLiteral | mapLiteral | structLiteral | '(' expr ')' | '.' ident callArgs?
+  parsePrimary() {
+    if (this.isLiteralToken(this.current.type))
+      return this.parseLiteral();
+    if (this.current.type === s.LBRACKET)
+      return this.parseListLiteral();
+    if (this.current.type === s.LBRACE)
+      return this.parseMapOrStructLiteral(null);
+    if (this.current.type === s.LPAREN) {
+      this.advance();
+      const t = this.parseExpr();
+      return this.expect(s.RPAREN), t;
+    }
+    if (this.current.type === s.DOT) {
+      this.advance();
+      const t = this.expectIdentifier();
+      if (this.current.type === s.LPAREN) {
+        this.advance();
+        const e = this.parseExprList();
+        return this.expect(s.RPAREN), new y(null, t, e);
+      }
+      return new N(null, t);
+    }
+    if (this.current.type === s.IDENTIFIER) {
+      const t = this.current.value;
+      if (this.advance(), this.current.type === s.LPAREN) {
+        this.advance();
+        const e = this.parseExprList();
+        return this.expect(s.RPAREN), new y(null, t, e);
+      }
+      if (this.current.type === s.DOT && this.isQualifiedStructLiteral()) {
+        const e = this.parseQualifiedIdent(t);
+        return this.parseMapOrStructLiteral(e);
+      }
+      return this.current.type === s.LBRACE ? this.parseMapOrStructLiteral(t) : new U(t);
+    }
+    throw new f(
+      `Unexpected token: ${this.current.value}`,
+      this.current.line,
+      this.current.column
+    );
+  }
+  // listLiteral = '[' exprList? ','? ']'
+  parseListLiteral() {
+    this.expect(s.LBRACKET);
+    const t = [];
+    return this.current.type !== s.RBRACKET && (t.push(...this.parseExprList()), this.current.type === s.COMMA && this.advance()), this.expect(s.RBRACKET), new q(t);
+  }
+  // mapLiteral or structLiteral
+  parseMapOrStructLiteral(t) {
+    if (this.expect(s.LBRACE), this.current.type === s.RBRACE)
+      return this.advance(), t !== null ? new S(t, []) : new C([]);
+    if (this.current.type === s.IDENTIFIER && this.peekAhead(1).type === s.COLON || t !== null) {
+      const i = this.parseFieldInits();
+      return this.current.type === s.COMMA && this.advance(), this.expect(s.RBRACE), new S(t, i);
+    } else {
+      const i = this.parseMapInits();
+      return this.current.type === s.COMMA && this.advance(), this.expect(s.RBRACE), new C(i);
+    }
+  }
+  // exprList = expr ( ',' expr )*
+  parseExprList() {
+    const t = [], e = this.current.type;
+    if (e === s.RPAREN || e === s.RBRACKET)
+      return t;
+    for (t.push(this.parseExpr()); this.current.type === s.COMMA && (this.advance(), !(this.current.type === s.RPAREN || this.current.type === s.RBRACKET)); )
+      t.push(this.parseExpr());
+    return t;
+  }
+  // mapInits = mapInit ( ',' mapInit )*
+  parseMapInits() {
+    const t = [];
+    for (t.push(this.parseMapInit()); this.current.type === s.COMMA && (this.advance(), this.current.type !== s.RBRACE); )
+      t.push(this.parseMapInit());
+    return t;
+  }
+  // mapInit = expr ':' expr
+  parseMapInit() {
+    const t = this.parseExpr();
+    this.expect(s.COLON);
+    const e = this.parseExpr();
+    return new W(t, e);
+  }
+  // fieldInits = fieldInit ( ',' fieldInit )*
+  parseFieldInits() {
+    const t = [];
+    for (t.push(this.parseFieldInit()); this.current.type === s.COMMA && (this.advance(), this.current.type !== s.RBRACE); )
+      t.push(this.parseFieldInit());
+    return t;
+  }
+  // fieldInit = ident ':' expr
+  parseFieldInit() {
+    const t = this.expectIdentifier();
+    this.expect(s.COLON);
+    const e = this.parseExpr();
+    return new j(t, e);
+  }
+  // qualifiedIdent = ident ( '.' ident )*
+  parseQualifiedIdent(t) {
+    let e = t;
+    for (; this.current.type === s.DOT; )
+      this.advance(), e += ".", e += this.expectIdentifier();
+    return e;
+  }
+  parseLiteral() {
+    const t = this.current;
+    switch (this.advance(), t.type) {
+      case s.NULL:
+        return new d(null, w.NULL_VALUE);
+      case s.TRUE:
+        return new d(!0, w.BOOL);
+      case s.FALSE:
+        return new d(!1, w.BOOL);
+      case s.INT:
+        return new d(this.parseIntLiteral(t.value), w.INT);
+      case s.UINT:
+        return new d(this.parseUintLiteral(t.value), w.UINT);
+      case s.DOUBLE:
+        return new d(parseFloat(t.value), w.DOUBLE);
+      case s.STRING:
+        return new d(this.parseStringLiteral(t.value), w.STRING);
+      case s.BYTES:
+        return new d(this.parseBytesLiteral(t.value), w.BYTES);
+      default:
+        throw new f(`Not a literal: ${t.value}`, t.line, t.column);
+    }
+  }
+  parseIntLiteral(t) {
+    return t.startsWith("-0x") || t.startsWith("-0X") ? -parseInt(t.substring(3), 16) : t.startsWith("0x") || t.startsWith("0X") ? parseInt(t.substring(2), 16) : parseInt(t, 10);
+  }
+  parseUintLiteral(t) {
+    const e = t.substring(0, t.length - 1);
+    return e.startsWith("0x") || e.startsWith("0X") ? parseInt(e.substring(2), 16) : parseInt(e, 10);
+  }
+  parseStringLiteral(t) {
+    const e = t.startsWith("r") || t.startsWith("R");
+    let i;
+    return e && (t.substring(1).startsWith('"""') || t.substring(1).startsWith("'''")) ? i = t.substring(4, t.length - 3) : t.startsWith('"""') || t.startsWith("'''") ? (i = t.substring(3, t.length - 3), i = this.unescapeString(i)) : e ? i = t.substring(2, t.length - 1) : (i = t.substring(1, t.length - 1), i = this.unescapeString(i)), i;
+  }
+  parseBytesLiteral(t) {
+    const e = t.substring(2, t.length - 1);
+    return this.unescapeString(e);
+  }
+  unescapeString(t) {
+    let e = "", i = 0;
+    for (; i < t.length; )
+      if (t[i] === "\\" && i + 1 < t.length) {
+        const n = t[i + 1];
+        switch (n) {
+          case "\\":
+            e += "\\", i += 2;
+            break;
+          case '"':
+            e += '"', i += 2;
+            break;
+          case "'":
+            e += "'", i += 2;
+            break;
+          case "`":
+            e += "`", i += 2;
+            break;
+          case "?":
+            e += "?", i += 2;
+            break;
+          case "a":
+            e += "\x07", i += 2;
+            break;
+          case "b":
+            e += "\b", i += 2;
+            break;
+          case "f":
+            e += "\f", i += 2;
+            break;
+          case "n":
+            e += `
+`, i += 2;
+            break;
+          case "r":
+            e += "\r", i += 2;
+            break;
+          case "t":
+            e += "	", i += 2;
+            break;
+          case "v":
+            e += "\v", i += 2;
+            break;
+          case "x":
+            if (i + 3 < t.length) {
+              const o = t.substring(i + 2, i + 4);
+              e += String.fromCharCode(parseInt(o, 16)), i += 4;
+            } else
+              e += t[i], i++;
+            break;
+          case "u":
+            if (i + 5 < t.length) {
+              const o = t.substring(i + 2, i + 6);
+              e += String.fromCharCode(parseInt(o, 16)), i += 6;
+            } else
+              e += t[i], i++;
+            break;
+          case "U":
+            if (i + 9 < t.length) {
+              const o = t.substring(i + 2, i + 10), l = parseInt(o, 16);
+              e += String.fromCodePoint(l), i += 10;
+            } else
+              e += t[i], i++;
+            break;
+          default:
+            if (i + 3 < t.length && n >= "0" && n <= "3" && t[i + 2] >= "0" && t[i + 2] <= "7" && t[i + 3] >= "0" && t[i + 3] <= "7") {
+              const o = t.substring(i + 1, i + 4);
+              e += String.fromCharCode(parseInt(o, 8)), i += 4;
+            } else
+              e += t[i], i++;
+        }
+      } else
+        e += t[i], i++;
+    return e;
+  }
+  isLiteralToken(t) {
+    return t === s.NULL || t === s.TRUE || t === s.FALSE || t === s.INT || t === s.UINT || t === s.DOUBLE || t === s.STRING || t === s.BYTES;
+  }
+  isRelationalOp(t) {
+    return t === s.LT || t === s.LE || t === s.GT || t === s.GE || t === s.EQ || t === s.NE || t === s.IN;
+  }
+  toBinaryOp(t) {
+    switch (t) {
+      case s.LT:
+        return c.LESS;
+      case s.LE:
+        return c.LESS_EQUAL;
+      case s.GT:
+        return c.GREATER;
+      case s.GE:
+        return c.GREATER_EQUAL;
+      case s.EQ:
+        return c.EQUAL;
+      case s.NE:
+        return c.NOT_EQUAL;
+      case s.IN:
+        return c.IN;
+      default:
+        throw new f(
+          `Unknown relational operator: ${t}`,
+          this.current.line,
+          this.current.column
+        );
+    }
+  }
+  match(t) {
+    return this.current.type === t ? (this.advance(), !0) : !1;
+  }
+  expect(t) {
+    if (this.current.type !== t)
+      throw new f(
+        `Expected ${t} but found ${this.current.type}`,
+        this.current.line,
+        this.current.column
+      );
+    this.advance();
+  }
+  expectIdentifier() {
+    if (this.current.type !== s.IDENTIFIER)
+      throw new f(
+        `Expected identifier but found ${this.current.value}`,
+        this.current.line,
+        this.current.column
+      );
+    const t = this.current.value;
+    return this.advance(), t;
+  }
+  advance() {
+    this.current = this.lexer.next();
+  }
+  peekAhead(t) {
+    return this.lexer.peek(t);
+  }
+  // Check if we have a pattern like: . ident ( . ident )* {
+  isQualifiedStructLiteral() {
+    let t = 1, e = this.peekAhead(t);
+    if (e.type !== s.IDENTIFIER)
+      return !1;
+    for (t++, e = this.peekAhead(t); e.type === s.DOT; ) {
+      if (t++, e = this.peekAhead(t), e.type !== s.IDENTIFIER)
+        return !1;
+      t++, e = this.peekAhead(t);
+    }
+    return e.type === s.LBRACE;
+  }
+}
+class a extends Error {
+  constructor(t) {
+    super(t), this.name = "EvaluationError";
+  }
+}
+function I(r) {
+  if (r == null)
+    return 0;
+  if (typeof r == "string" || Array.isArray(r))
+    return r.length;
+  if (typeof r == "object" && r !== null)
+    return Object.keys(r).length;
+  throw new Error(`size() not supported for type: ${typeof r}`);
+}
+function b(r) {
+  if (typeof r == "number")
+    return Math.trunc(r);
+  if (typeof r == "string") {
+    const t = parseInt(r, 10);
+    if (isNaN(t))
+      throw new Error(`Cannot convert to int: ${r}`);
+    return t;
+  }
+  if (typeof r == "boolean")
+    return r ? 1 : 0;
+  throw new Error(`Cannot convert to int: ${r}`);
+}
+function v(r) {
+  const t = b(r);
+  if (t < 0)
+    throw new Error(`Cannot convert negative value to uint: ${r}`);
+  return t;
+}
+function M(r) {
+  if (typeof r == "number")
+    return r;
+  if (typeof r == "string") {
+    const t = parseFloat(r);
+    if (isNaN(t))
+      throw new Error(`Cannot convert to double: ${r}`);
+    return t;
+  }
+  throw new Error(`Cannot convert to double: ${r}`);
+}
+function D(r) {
+  return r == null ? "null" : String(r);
+}
+function T(r) {
+  return typeof r == "boolean" ? r : typeof r == "number" ? r !== 0 : typeof r == "string" || Array.isArray(r) ? r.length > 0 : typeof r == "object" && r !== null ? Object.keys(r).length > 0 : r != null;
+}
+function x(r) {
+  return r == null ? "null" : typeof r == "boolean" ? "bool" : typeof r == "number" ? Number.isInteger(r) ? "int" : "double" : typeof r == "string" ? "string" : Array.isArray(r) ? "list" : typeof r == "object" ? "map" : "unknown";
+}
+function B(r, t) {
+  return typeof r == "object" && r !== null && typeof t == "string" ? t in r : !1;
+}
+function G(r, t) {
+  try {
+    return new RegExp(t).test(r);
+  } catch {
+    throw new Error(`Invalid regex pattern: ${t}`);
+  }
+}
+function $(r) {
+  if (r.length === 0)
+    throw new Error("max() requires at least one argument");
+  let t = r[0];
+  for (let e = 1; e < r.length; e++)
+    E(r[e], t) > 0 && (t = r[e]);
+  return t;
+}
+function P(r) {
+  if (r.length === 0)
+    throw new Error("min() requires at least one argument");
+  let t = r[0];
+  for (let e = 1; e < r.length; e++)
+    E(r[e], t) < 0 && (t = r[e]);
+  return t;
+}
+function E(r, t) {
+  if (r === null && t === null)
+    return 0;
+  if (r === null)
+    return -1;
+  if (t === null)
+    return 1;
+  if (typeof r == "number" && typeof t == "number")
+    return r - t;
+  if (typeof r == "string" && typeof t == "string")
+    return r.localeCompare(t);
+  if (typeof r == "boolean" && typeof t == "boolean")
+    return r === t ? 0 : r ? 1 : -1;
+  if (Array.isArray(r) && Array.isArray(t)) {
+    const e = Math.min(r.length, t.length);
+    for (let i = 0; i < e; i++) {
+      const n = E(r[i], t[i]);
+      if (n !== 0)
+        return n;
+    }
+    return r.length - t.length;
+  }
+  throw new Error(`Cannot compare types: ${typeof r} and ${typeof t}`);
+}
+function A(r, t) {
+  if (r == null || t === null || t === void 0)
+    return r === t;
+  if (Array.isArray(r) && Array.isArray(t)) {
+    if (r.length !== t.length)
+      return !1;
+    for (let e = 0; e < r.length; e++)
+      if (!A(r[e], t[e]))
+        return !1;
+    return !0;
+  }
+  if (typeof r == "object" && typeof t == "object" && !Array.isArray(r) && !Array.isArray(t)) {
+    const e = Object.keys(r), i = Object.keys(t);
+    if (e.length !== i.length)
+      return !1;
+    for (const n of e)
+      if (!(n in t) || !A(r[n], t[n]))
+        return !1;
+    return !0;
+  }
+  return r === t;
+}
+function _(r, t) {
+  for (const e of r)
+    if (A(e, t))
+      return !0;
+  return !1;
+}
+const Z = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
+  __proto__: null,
+  asBool: T,
+  asDouble: M,
+  asInt: b,
+  asString: D,
+  asUInt: v,
+  compare: E,
+  containsInArray: _,
+  deepEquals: A,
+  has: B,
+  matches: G,
+  max: $,
+  min: P,
+  sizeOf: I,
+  typeOf: x
+}, Symbol.toStringTag, { value: "Module" }));
+class k {
+  callFunction(t, e) {
+    switch (t) {
+      case "size":
+        return I(e[0]);
+      case "int":
+        return b(e[0]);
+      case "uint":
+        return v(e[0]);
+      case "double":
+        return M(e[0]);
+      case "string":
+        return D(e[0]);
+      case "bool":
+        return T(e[0]);
+      case "type":
+        return x(e[0]);
+      case "has":
+        if (e.length !== 2)
+          throw new Error("has() requires 2 arguments");
+        return B(e[0], e[1]);
+      case "matches":
+        if (e.length !== 2)
+          throw new Error("matches() requires 2 arguments");
+        return G(e[0], e[1]);
+      case "max":
+        return $(e);
+      case "min":
+        return P(e);
+      default:
+        throw new Error(`Unknown function: ${t}`);
+    }
+  }
+  callMethod(t, e, i) {
+    if (t == null)
+      throw new Error("Cannot call method on null");
+    switch (e) {
+      case "contains":
+        if (typeof t == "string" && i.length === 1 && typeof i[0] == "string")
+          return t.includes(i[0]);
+        if (Array.isArray(t) && i.length === 1)
+          return t.includes(i[0]);
+        throw new Error("Invalid arguments for contains()");
+      case "startsWith":
+        if (typeof t == "string" && i.length === 1 && typeof i[0] == "string")
+          return t.startsWith(i[0]);
+        throw new Error("startsWith() requires string target and argument");
+      case "endsWith":
+        if (typeof t == "string" && i.length === 1 && typeof i[0] == "string")
+          return t.endsWith(i[0]);
+        throw new Error("endsWith() requires string target and argument");
+      case "toLowerCase":
+        if (typeof t == "string" && i.length === 0)
+          return t.toLowerCase();
+        throw new Error("toLowerCase() requires string target");
+      case "toUpperCase":
+        if (typeof t == "string" && i.length === 0)
+          return t.toUpperCase();
+        throw new Error("toUpperCase() requires string target");
+      case "trim":
+        if (typeof t == "string" && i.length === 0)
+          return t.trim();
+        throw new Error("trim() requires string target");
+      case "replace":
+        if (typeof t == "string" && i.length === 2 && typeof i[0] == "string" && typeof i[1] == "string")
+          return t.replaceAll(i[0], i[1]);
+        throw new Error("replace() requires string target and 2 string arguments");
+      case "split":
+        if (typeof t == "string" && i.length === 1 && typeof i[0] == "string")
+          return t.split(i[0]);
+        throw new Error("split() requires string target and separator");
+      case "size":
+        return I(t);
+      // Macro functions are handled in the interpreter with special logic
+      case "map":
+      case "filter":
+      case "all":
+      case "exists":
+      case "existsOne":
+        throw new a(
+          `Macro function ${e} was not properly handled by the interpreter`
+        );
+      default:
+        return this.callNativeMethod(t, e, i);
+    }
+  }
+  /**
+   * Attempts to call a native JavaScript method on the target object.
+   *
+   * @param target The object to call the method on
+   * @param name The method name
+   * @param args The arguments
+   * @returns The result of the method call
+   * @throws Error if the method doesn't exist or call fails
+   */
+  callNativeMethod(t, e, i) {
+    if (typeof t[e] == "function")
+      try {
+        return t[e](...i);
+      } catch (n) {
+        throw new a(
+          `Invocation of method '${e}' failed: ${n instanceof Error ? n.message : String(n)}`
+        );
+      }
+    throw new Error(
+      `No such method '${e}' on type ${typeof t} with ${i.length} argument(s)`
+    );
+  }
+}
+class H {
+  /**
+   * Constructs an interpreter with the specified variables and functions.
+   *
+   * @param variables A map of variable names to their values. If null, an empty object is used.
+   * @param functions An instance of Functions to handle function calls. If null, StandardFunctions is used.
+   */
+  constructor(t, e) {
+    this.variables = t ?? {}, this.functions = e ?? new k();
+  }
+  /**
+   * Evaluates a CEL expression and returns its result.
+   *
+   * @param expr The expression to evaluate
+   * @returns The result of the evaluation
+   * @throws EvaluationError if evaluation fails
+   */
+  evaluate(t) {
+    return t.accept(this);
+  }
+  visitLiteral(t) {
+    return t.value;
+  }
+  visitIdentifier(t) {
+    if (!(t.name in this.variables))
+      throw new a(`Undefined variable: ${t.name}`);
+    return this.variables[t.name];
+  }
+  visitSelect(t) {
+    const e = t.operand !== null ? this.evaluate(t.operand) : this.variables;
+    if (e == null) {
+      if (t.isTest)
+        return !1;
+      throw new a(`Cannot select field ${t.field} from null`);
+    }
+    if (typeof e == "object") {
+      if (t.isTest)
+        return t.field in e;
+      if (!(t.field in e))
+        throw new a(`Field ${t.field} not found`);
+      return e[t.field];
+    }
+    throw new a("Cannot select field from non-object type");
+  }
+  visitCall(t) {
+    if (t.isMacro && t.target !== null) {
+      const i = this.evaluate(t.target);
+      if (t.args.length === 0)
+        throw new a(`Macro ${t.functionName} requires arguments`);
+      const n = t.args[0];
+      if (!(n instanceof U))
+        throw new a(
+          `First argument to macro ${t.functionName} must be a variable name`
+        );
+      const o = n.name;
+      if (t.args.length < 2)
+        throw new a(`Macro ${t.functionName} requires an expression argument`);
+      const l = t.args[1];
+      return this.evaluateMacro(i, t.functionName, o, l);
+    }
+    const e = [];
+    for (const i of t.args)
+      e.push(this.evaluate(i));
+    if (t.target !== null) {
+      const i = this.evaluate(t.target);
+      return this.functions.callMethod(i, t.functionName, e);
+    } else
+      return this.functions.callFunction(t.functionName, e);
+  }
+  evaluateMacro(t, e, i, n) {
+    if (!Array.isArray(t))
+      throw new a(`Macro ${e} requires a list target`);
+    const o = this.variables[i], l = i in this.variables;
+    try {
+      switch (e) {
+        case "map": {
+          const u = [];
+          for (const p of t)
+            this.variables[i] = p, u.push(this.evaluate(n));
+          return u;
+        }
+        case "filter": {
+          const u = [];
+          for (const p of t)
+            this.variables[i] = p, this.evaluate(n) === !0 && u.push(p);
+          return u;
+        }
+        case "all": {
+          for (const u of t)
+            if (this.variables[i] = u, this.evaluate(n) !== !0)
+              return !1;
+          return !0;
+        }
+        case "exists": {
+          for (const u of t)
+            if (this.variables[i] = u, this.evaluate(n) === !0)
+              return !0;
+          return !1;
+        }
+        case "existsOne": {
+          let u = 0;
+          for (const p of t)
+            if (this.variables[i] = p, this.evaluate(n) === !0 && (u++, u > 1))
+              return !1;
+          return u === 1;
+        }
+        default:
+          throw new a(`Unknown macro function: ${e}`);
+      }
+    } finally {
+      l ? this.variables[i] = o : delete this.variables[i];
+    }
+  }
+  visitList(t) {
+    const e = [];
+    for (const i of t.elements)
+      e.push(this.evaluate(i));
+    return e;
+  }
+  visitMap(t) {
+    const e = {};
+    for (const i of t.entries) {
+      const n = this.evaluate(i.key), o = this.evaluate(i.value);
+      e[n] = o;
+    }
+    return e;
+  }
+  visitStruct(t) {
+    const e = {};
+    for (const i of t.fields)
+      e[i.field] = this.evaluate(i.value);
+    return e;
+  }
+  visitComprehension(t) {
+    const e = this.evaluate(t.range);
+    if (!Array.isArray(e))
+      throw new a("Comprehension range must be a list");
+    const i = this.variables[t.variable], n = this.variables[t.accumulator], o = t.variable in this.variables, l = t.accumulator in this.variables;
+    try {
+      let u = this.evaluate(t.initializer);
+      this.variables[t.accumulator] = u;
+      for (const p of e)
+        this.variables[t.variable] = p, this.evaluate(t.condition) === !0 && (u = this.evaluate(t.step), this.variables[t.accumulator] = u);
+      return this.evaluate(t.result);
+    } finally {
+      o ? this.variables[t.variable] = i : delete this.variables[t.variable], l ? this.variables[t.accumulator] = n : delete this.variables[t.accumulator];
+    }
+  }
+  visitUnary(t) {
+    const e = this.evaluate(t.operand);
+    switch (t.op) {
+      case g.NOT:
+        if (typeof e != "boolean")
+          throw new a("NOT operator requires boolean operand");
+        return !e;
+      case g.NEGATE:
+        if (typeof e != "number")
+          throw new a("Negation requires numeric operand");
+        return -e;
+      default:
+        throw new a(`Unknown unary operator: ${t.op}`);
+    }
+  }
+  visitBinary(t) {
+    if (t.op === c.LOGICAL_AND)
+      return this.evaluate(t.left) !== !0 ? !1 : this.evaluate(t.right) === !0;
+    if (t.op === c.LOGICAL_OR)
+      return this.evaluate(t.left) === !0 ? !0 : this.evaluate(t.right) === !0;
+    const e = this.evaluate(t.left), i = this.evaluate(t.right);
+    switch (t.op) {
+      case c.ADD:
+        if (typeof e == "string" || typeof i == "string")
+          return String(e) + String(i);
+        if (Array.isArray(e) && Array.isArray(i))
+          return [...e, ...i];
+        if (typeof e == "number" && typeof i == "number")
+          return e + i;
+        throw new a("Invalid operands for addition");
+      case c.SUBTRACT:
+        if (typeof e == "number" && typeof i == "number")
+          return e - i;
+        throw new a("Subtraction requires numeric operands");
+      case c.MULTIPLY:
+        if (typeof e == "number" && typeof i == "number")
+          return e * i;
+        if (typeof e == "string" && typeof i == "number")
+          return e.repeat(i);
+        if (Array.isArray(e) && typeof i == "number") {
+          const n = [];
+          for (let o = 0; o < i; o++)
+            n.push(...e);
+          return n;
+        }
+        throw new a("Invalid operands for multiplication");
+      case c.DIVIDE:
+        if (typeof e == "number" && typeof i == "number") {
+          if (i === 0)
+            throw new a("Division by zero");
+          return e / i;
+        }
+        throw new a("Division requires numeric operands");
+      case c.MODULO:
+        if (typeof e == "number" && typeof i == "number") {
+          if (i === 0)
+            throw new a("Modulo by zero");
+          return e % i;
+        }
+        throw new a("Modulo requires integer operands");
+      case c.EQUAL:
+        return A(e, i);
+      case c.NOT_EQUAL:
+        return !A(e, i);
+      case c.LESS:
+        return E(e, i) < 0;
+      case c.LESS_EQUAL:
+        return E(e, i) <= 0;
+      case c.GREATER:
+        return E(e, i) > 0;
+      case c.GREATER_EQUAL:
+        return E(e, i) >= 0;
+      case c.IN:
+        if (Array.isArray(i))
+          return _(i, e);
+        if (typeof i == "object" && i !== null)
+          return e in i;
+        if (typeof i == "string" && typeof e == "string")
+          return i.includes(e);
+        throw new a("IN operator requires list, map, or string on right side");
+      default:
+        throw new a(`Unknown binary operator: ${t.op}`);
+    }
+  }
+  visitConditional(t) {
+    return this.evaluate(t.condition) === !0 ? this.evaluate(t.thenExpr) : this.evaluate(t.otherwiseExpr);
+  }
+  visitIndex(t) {
+    const e = this.evaluate(t.operand), i = this.evaluate(t.index);
+    if (e == null)
+      throw new a("Cannot index null value");
+    if (Array.isArray(e)) {
+      if (typeof i != "number")
+        throw new a("List index must be an integer");
+      const n = Math.trunc(i);
+      if (n < 0 || n >= e.length)
+        throw new a(`List index out of bounds: ${n}`);
+      return e[n];
+    } else if (typeof e == "object") {
+      if (!(i in e))
+        throw new a(`Map key not found: ${i}`);
+      return e[i];
+    } else if (typeof e == "string") {
+      if (typeof i != "number")
+        throw new a("String index must be an integer");
+      const n = Math.trunc(i);
+      if (n < 0 || n >= e.length)
+        throw new a(`String index out of bounds: ${n}`);
+      return e[n];
+    }
+    throw new a(`Cannot index type: ${typeof e}`);
+  }
+}
+class V {
+  /**
+   * Creates a new compiled program.
+   *
+   * This constructor is typically called by CEL.compile() and should not be used directly.
+   *
+   * @param ast The abstract syntax tree of the compiled expression
+   * @param functions The function library to use for evaluation
+   */
+  constructor(t, e) {
+    this.ast = t, this.functions = e;
+  }
+  /**
+   * Evaluates the compiled program with the given variables.
+   *
+   * @param variables A map of variable names to their values
+   * @returns The result of evaluating the expression
+   * @throws EvaluationError if an error occurs during evaluation
+   *
+   * @example
+   * ```typescript
+   * const result = program.evaluate({
+   *   x: 10,
+   *   y: 20,
+   *   items: [1, 2, 3]
+   * });
+   * ```
+   */
+  evaluate(t = {}) {
+    return new H({ ...t }, this.functions).evaluate(this.ast);
+  }
+}
+class R {
+  constructor(t) {
+    this.functions = t ?? new k();
+  }
+  /**
+   * Compiles a CEL expression using the provided function library.
+   *
+   * This static convenience method avoids the need to instantiate CEL when
+   * callers just need to compile once.
+   *
+   * @param expression The CEL expression to compile
+   * @param functions The function library to use when compiling the program
+   * @returns A compiled Program using the provided functions
+   * @throws ParseError if the expression is invalid
+   *
+   * @example
+   * ```typescript
+   * const program = CEL.compile('x + y', new StandardFunctions());
+   * ```
+   */
+  static compile(t, e) {
+    const i = new Y(t);
+    return new V(i.parse(), e);
+  }
+  /**
+   * Evaluates a CEL expression with the given variables using the provided function library.
+   *
+   * This static convenience method avoids the need to instantiate CEL when callers
+   * just need to evaluate an expression once.
+   *
+   * @param expression The CEL expression to evaluate
+   * @param functions The function library to use when evaluating the expression
+   * @param variables A map of variable names to their values
+   * @returns The result of evaluating the expression
+   * @throws ParseError if the expression is invalid
+   * @throws EvaluationError if an error occurs during evaluation
+   *
+   * @example
+   * ```typescript
+   * const result = CEL.eval('x * 2', new StandardFunctions(), { x: 5 });
+   * ```
+   */
+  static eval(t, e, i) {
+    return this.compile(t, e).evaluate(i);
+  }
+  /**
+   * Compiles a CEL expression into a reusable program.
+   *
+   * This method parses the expression and returns a Program that can be evaluated
+   * multiple times with different variables. This is more efficient than calling
+   * eval() repeatedly with the same expression.
+   *
+   * @param expression The CEL expression to compile
+   * @returns A compiled program
+   * @throws ParseError if the expression is invalid
+   *
+   * @example
+   * ```typescript
+   * const program = cel.compile('price * quantity');
+   * const result1 = program.evaluate({ price: 10, quantity: 5 });
+   * const result2 = program.evaluate({ price: 20, quantity: 3 });
+   * ```
+   */
+  compile(t) {
+    return R.compile(t, this.functions);
+  }
+  /**
+   * Evaluates a CEL expression with the given variables.
+   *
+   * This is a convenience method that compiles and evaluates the expression in one step.
+   * For better performance when evaluating the same expression multiple times, use
+   * compile() to create a reusable Program.
+   *
+   * @param expression The CEL expression to evaluate
+   * @param variables A map of variable names to their values
+   * @returns The result of evaluating the expression
+   * @throws ParseError if the expression is invalid
+   * @throws EvaluationError if an error occurs during evaluation
+   *
+   * @example
+   * ```typescript
+   * const result = cel.eval('user.age >= 18', {
+   *   user: { name: 'Alice', age: 25 }
+   * });
+   * ```
+   */
+  eval(t, e = {}) {
+    return R.eval(t, this.functions, e);
+  }
+}
+export {
+  L as Binary,
+  c as BinaryOp,
+  R as CEL,
+  y as Call,
+  X as Comprehension,
+  K as Conditional,
+  a as EvaluationError,
+  j as FieldInitializer,
+  U as Identifier,
+  Q as Index,
+  H as Interpreter,
+  q as ListExpression,
+  d as Literal,
+  w as LiteralType,
+  W as MapEntry,
+  C as MapExpression,
+  f as ParseError,
+  Y as Parser,
+  V as Program,
+  N as Select,
+  k as StandardFunctions,
+  S as Struct,
+  O as Unary,
+  g as UnaryOp,
+  Z as Utilities,
+  T as asBool
+};
+//# sourceMappingURL=index.mjs.map