@libdbm/libcel-ts 1.0.2-rc.1 → 2.0.0

package/dist/index.mjs

@@ -1,18 +1,18 @@
-class f extends Error {
-  constructor(t, e, i) {
-    super(`${t} at ${e}:${i}`), this.line = e, this.column = i, this.name = "ParseError";
+class U extends Error {
+  constructor(t, n, i) {
+    super(`${t} at ${n}:${i}`), this.line = n, 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;
+var o = /* @__PURE__ */ ((e) => (e.NULL = "NULL", e.TRUE = "TRUE", e.FALSE = "FALSE", e.INT = "INT", e.UINT = "UINT", e.DOUBLE = "DOUBLE", e.STRING = "STRING", e.BYTES = "BYTES", e.IDENTIFIER = "IDENTIFIER", e.PLUS = "PLUS", e.MINUS = "MINUS", e.STAR = "STAR", e.SLASH = "SLASH", e.PERCENT = "PERCENT", e.EQ = "EQ", e.NE = "NE", e.LT = "LT", e.LE = "LE", e.GT = "GT", e.GE = "GE", e.LOGICAL_AND = "LOGICAL_AND", e.LOGICAL_OR = "LOGICAL_OR", e.BANG = "BANG", e.IN = "IN", e.LPAREN = "LPAREN", e.RPAREN = "RPAREN", e.LBRACKET = "LBRACKET", e.RBRACKET = "RBRACKET", e.LBRACE = "LBRACE", e.RBRACE = "RBRACE", e.DOT = "DOT", e.COMMA = "COMMA", e.COLON = "COLON", e.QUESTION = "QUESTION", e.EOF = "EOF", e))(o || {});
+class w {
+  constructor(t, n, i, r) {
+    this.type = t, this.value = n, this.line = i, this.column = r;
   }
   toString() {
     return `${this.type}(${this.value})`;
   }
 }
-class F {
+class de {
   constructor(t) {
     this.input = t, this.position = 0, this.line = 1, this.column = 1, this.lookahead = [];
   }
@@ -39,139 +39,139 @@ class F {
 ` ? (this.line++, this.column = 1) : this.column++;
   }
   forward(t) {
-    for (let e = 0; e < t; e++)
+    for (let n = 0; n < t; n++)
       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) {
+      return new w("EOF", "", this.line, this.column);
+    const t = this.position, n = this.line, i = this.column, r = this.input[this.position];
+    switch (r) {
       case "(":
-        return this.step(), new h("LPAREN", "(", e, i);
+        return this.step(), new w("LPAREN", "(", n, i);
       case ")":
-        return this.step(), new h("RPAREN", ")", e, i);
+        return this.step(), new w("RPAREN", ")", n, i);
       case "[":
-        return this.step(), new h("LBRACKET", "[", e, i);
+        return this.step(), new w("LBRACKET", "[", n, i);
       case "]":
-        return this.step(), new h("RBRACKET", "]", e, i);
+        return this.step(), new w("RBRACKET", "]", n, i);
       case "{":
-        return this.step(), new h("LBRACE", "{", e, i);
+        return this.step(), new w("LBRACE", "{", n, i);
       case "}":
-        return this.step(), new h("RBRACE", "}", e, i);
+        return this.step(), new w("RBRACE", "}", n, i);
       case ",":
-        return this.step(), new h("COMMA", ",", e, i);
+        return this.step(), new w("COMMA", ",", n, i);
       case ".":
-        return this.step(), new h("DOT", ".", e, i);
+        return this.step(), new w("DOT", ".", n, i);
       case ":":
-        return this.step(), new h("COLON", ":", e, i);
+        return this.step(), new w("COLON", ":", n, i);
       case "?":
-        return this.step(), new h("QUESTION", "?", e, i);
+        return this.step(), new w("QUESTION", "?", n, i);
       case "+":
-        return this.step(), new h("PLUS", "+", e, i);
+        return this.step(), new w("PLUS", "+", n, i);
       case "*":
-        return this.step(), new h("STAR", "*", e, i);
+        return this.step(), new w("STAR", "*", n, i);
       case "/":
-        return this.step(), new h("SLASH", "/", e, i);
+        return this.step(), new w("SLASH", "/", n, 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 === "'''") {
+        return this.step(), new w("PERCENT", "%", n, i);
+    }
+    if (r === "&" && this.peekChar() === "&")
+      return this.forward(2), new w("LOGICAL_AND", "&&", n, i);
+    if (r === "|" && this.peekChar() === "|")
+      return this.forward(2), new w("LOGICAL_OR", "||", n, i);
+    if (r === "=" && this.peekChar() === "=")
+      return this.forward(2), new w("EQ", "==", n, i);
+    if (r === "!" && this.peekChar() === "=")
+      return this.forward(2), new w("NE", "!=", n, i);
+    if (r === "<" && this.peekChar() === "=")
+      return this.forward(2), new w("LE", "<=", n, i);
+    if (r === ">" && this.peekChar() === "=")
+      return this.forward(2), new w("GE", ">=", n, i);
+    if (r === "<")
+      return this.step(), new w("LT", "<", n, i);
+    if (r === ">")
+      return this.step(), new w("GT", ">", n, i);
+    if (r === "!")
+      return this.step(), new w("BANG", "!", n, i);
+    if (r === "-")
+      return this.step(), new w("MINUS", "-", n, i);
+    if (r === '"' || r === "'")
+      return this.string(n, i, t);
+    if ((r === "r" || r === "R") && this.position + 1 < this.input.length) {
+      const s = this.input[this.position + 1];
+      if (s === '"' || s === "'")
+        return this.string(n, i, t);
+    }
+    if ((r === "b" || r === "B") && this.position + 1 < this.input.length) {
+      const s = this.input[this.position + 1];
+      if (s === '"' || s === "'")
+        return this.bytes(n, i, t);
+    }
+    if (this.isDigit(r))
+      return this.number(n, i, t);
+    if (this.isLetter(r) || r === "_")
+      return this.identifier(n, i, t);
+    throw new U(`Unexpected character: ${r}`, n, i);
+  }
+  string(t, n, i) {
+    let r = !1;
+    if ((this.input[this.position] === "r" || this.input[this.position] === "R") && (r = !0, this.step()), this.position + 2 < this.input.length) {
+      const c = this.input.substring(this.position, this.position + 3);
+      if (c === '"""' || c === "'''") {
         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);
+            return this.forward(3), new w("STRING", this.input.substring(i, this.position), t, n);
           this.step();
         }
-        throw new f("Unterminated triple-quoted string", t, e);
+        throw new U("Unterminated triple-quoted string", t, n);
       }
     }
-    const o = this.input[this.position];
+    const s = 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();
+      const c = this.input[this.position];
+      if (c === s)
+        return this.step(), new w("STRING", this.input.substring(i, this.position), t, n);
+      c === "\\" && !r && this.position + 1 < this.input.length ? this.forward(2) : this.step();
     }
-    throw new f("Unterminated string", t, e);
+    throw new U("Unterminated string", t, n);
   }
-  bytes(t, e, i) {
+  bytes(t, n, i) {
     this.step();
-    const n = this.input[this.position];
+    const r = 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();
+      const s = this.input[this.position];
+      if (s === r)
+        return this.step(), new w("BYTES", this.input.substring(i, this.position), t, n);
+      s === "\\" && this.position + 1 < this.input.length ? this.forward(2) : this.step();
     }
-    throw new f("Unterminated bytes literal", t, e);
+    throw new U("Unterminated bytes literal", t, n);
   }
-  number(t, e, i) {
+  number(t, n, 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") {
+      const c = this.input[this.position + 1];
+      if (c === "x" || c === "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 this.step(), new w("UINT", this.input.substring(i, this.position), t, n);
         }
-        return new h("INT", this.input.substring(i, this.position), t, e);
+        return new w("INT", this.input.substring(i, this.position), t, n);
       }
     }
     for (; this.position < this.input.length && this.isDigit(this.input[this.position]); )
       this.step();
-    let n = !1;
+    let r = !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]); )
+      for (r = !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 c = this.input[this.position];
+      if (c === "e" || c === "E") {
+        if (r = !0, this.step(), this.position < this.input.length) {
           const u = this.input[this.position];
           (u === "+" || u === "-") && this.step();
         }
@@ -179,23 +179,23 @@ class F {
           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);
+    if (!r && this.position < this.input.length) {
+      const c = this.input[this.position];
+      if (c === "u" || c === "U")
+        return this.step(), new w("UINT", this.input.substring(i, this.position), t, n);
     }
-    const o = n ? "DOUBLE" : "INT";
-    return new h(o, this.input.substring(i, this.position), t, e);
+    const s = r ? "DOUBLE" : "INT";
+    return new w(s, this.input.substring(i, this.position), t, n);
   }
-  identifier(t, e, i) {
+  identifier(t, n, i) {
     for (; this.position < this.input.length; ) {
-      const l = this.input[this.position];
-      if (!this.isLetterOrDigit(l) && l !== "_")
+      const c = this.input[this.position];
+      if (!this.isLetterOrDigit(c) && c !== "_")
         break;
       this.step();
     }
-    const n = this.input.substring(i, this.position), o = this.typeOf(n);
-    return new h(o, n, t, e);
+    const r = this.input.substring(i, this.position), s = this.typeOf(r);
+    return new w(s, r, t, n);
   }
   typeOf(t) {
     switch (t) {
@@ -237,16 +237,16 @@ class F {
     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;
+var h = /* @__PURE__ */ ((e) => (e.ADD = "ADD", e.SUBTRACT = "SUBTRACT", e.MULTIPLY = "MULTIPLY", e.DIVIDE = "DIVIDE", e.MODULO = "MODULO", e.EQUAL = "EQUAL", e.NOT_EQUAL = "NOT_EQUAL", e.LESS = "LESS", e.LESS_EQUAL = "LESS_EQUAL", e.GREATER = "GREATER", e.GREATER_EQUAL = "GREATER_EQUAL", e.IN = "IN", e.LOGICAL_AND = "LOGICAL_AND", e.LOGICAL_OR = "LOGICAL_OR", e))(h || {}), J = /* @__PURE__ */ ((e) => (e.NOT = "NOT", e.NEGATE = "NEGATE", e))(J || {}), $ = /* @__PURE__ */ ((e) => (e.NULL_VALUE = "NULL_VALUE", e.BOOL = "BOOL", e.INT = "INT", e.UINT = "UINT", e.DOUBLE = "DOUBLE", e.STRING = "STRING", e.BYTES = "BYTES", e))($ || {});
+class z {
+  constructor(t, n) {
+    this.value = t, this.literalType = n;
   }
   accept(t) {
     return t.visitLiteral(this);
   }
 }
-class U {
+class It {
   constructor(t) {
     this.name = t;
   }
@@ -254,31 +254,31 @@ class U {
     return t.visitIdentifier(this);
   }
 }
-class N {
-  constructor(t, e, i = !1) {
-    this.operand = t, this.field = e, this.isTest = i;
+class nt {
+  constructor(t, n, i = !1) {
+    this.operand = t, this.field = n, this.isTest = i;
   }
   accept(t) {
     return t.visitSelect(this);
   }
 }
-class Q {
-  constructor(t, e) {
-    this.operand = t, this.index = e;
+class we {
+  constructor(t, n) {
+    this.operand = t, this.index = n;
   }
   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;
+class gt {
+  constructor(t, n, i, r = !1) {
+    this.target = t, this.functionName = n, this.args = i, this.isMacro = r;
   }
   accept(t) {
     return t.visitCall(this);
   }
 }
-class q {
+class ge {
   constructor(t) {
     this.elements = t;
   }
@@ -286,12 +286,12 @@ class q {
     return t.visitList(this);
   }
 }
-class W {
-  constructor(t, e) {
-    this.key = t, this.value = e;
+class be {
+  constructor(t, n) {
+    this.key = t, this.value = n;
   }
 }
-class C {
+class jt {
   constructor(t) {
     this.entries = t;
   }
@@ -299,55 +299,168 @@ class C {
     return t.visitMap(this);
   }
 }
-class j {
-  constructor(t, e) {
-    this.field = t, this.value = e;
+class me {
+  constructor(t, n) {
+    this.field = t, this.value = n;
   }
 }
-class S {
-  constructor(t, e) {
-    this.typeName = t, this.fields = e;
+class Qt {
+  constructor(t, n) {
+    this.typeName = t, this.fields = n;
   }
   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;
+class hi {
+  constructor(t, n, i, r, s, c, u) {
+    this.variable = t, this.range = n, this.accumulator = i, this.initializer = r, this.condition = s, this.step = c, this.result = u;
   }
   accept(t) {
     return t.visitComprehension(this);
   }
 }
-class O {
-  constructor(t, e) {
-    this.op = t, this.operand = e;
+class At {
+  constructor(t, n) {
+    this.op = t, this.operand = n;
   }
   accept(t) {
     return t.visitUnary(this);
   }
 }
-class L {
-  constructor(t, e, i) {
-    this.op = t, this.left = e, this.right = i;
+class X {
+  constructor(t, n, i) {
+    this.op = t, this.left = n, this.right = i;
   }
   accept(t) {
     return t.visitBinary(this);
   }
 }
-class K {
-  constructor(t, e, i) {
-    this.condition = t, this.thenExpr = e, this.otherwiseExpr = i;
+class nn {
+  constructor(t, n, i) {
+    this.condition = t, this.thenExpr = n, this.otherwiseExpr = i;
   }
   accept(t) {
     return t.visitConditional(this);
   }
 }
-const z = /* @__PURE__ */ new Set(["map", "filter", "all", "exists", "existsOne"]);
-class Y {
+const Ee = new TextEncoder(), Ie = new TextDecoder("utf-8");
+function B(e) {
+  return e instanceof Uint8Array;
+}
+function Mt(e) {
+  return Ee.encode(e);
+}
+function en(e) {
+  return Ie.decode(e);
+}
+function Ae(e, t) {
+  if (e.length !== t.length)
+    return !1;
+  for (let n = 0; n < e.length; n++)
+    if (e[n] !== t[n])
+      return !1;
+  return !0;
+}
+function ye(e, t) {
+  const n = Math.min(e.length, t.length);
+  for (let i = 0; i < n; i++) {
+    const r = e[i] << 24 >> 24, s = t[i] << 24 >> 24;
+    if (r !== s)
+      return r < s ? -1 : 1;
+  }
+  return e.length - t.length;
+}
+function Ne(e, t) {
+  const n = new Uint8Array(e.length + t.length);
+  return n.set(e, 0), n.set(t, e.length), n;
+}
+function yt(e) {
+  let t = "";
+  for (const n of e)
+    t += n.toString(16).padStart(2, "0");
+  return t;
+}
+class l extends Error {
+  constructor(t) {
+    super(t), this.name = "EvaluationError";
+  }
+}
+class a extends Error {
+  constructor(t) {
+    super(t), this.name = "ArgumentError";
+  }
+}
+function zt(e) {
+  return e instanceof l || e instanceof a;
+}
+const K = -(2n ** 63n), at = 2n ** 63n - 1n;
+function fi(e) {
+  return typeof e == "bigint";
+}
+function li(e) {
+  return typeof e == "number";
+}
+function C(e) {
+  return typeof e == "bigint" || typeof e == "number";
+}
+function Le(e) {
+  if (e < K || e > at)
+    throw new l("Integer overflow");
+  return e;
+}
+function Se(e) {
+  return Number.isNaN(e) ? 0n : e >= 2 ** 63 ? at : e <= -9223372036854776e3 ? K : BigInt(Math.trunc(e));
+}
+function Yt(e) {
+  return e === 0 ? 0 : e;
+}
+function _t(e, t) {
+  const n = Yt(e), i = Yt(t);
+  if (n < i)
+    return -1;
+  if (n > i)
+    return 1;
+  const r = Number.isNaN(n), s = Number.isNaN(i);
+  return r && s ? 0 : r ? 1 : s ? -1 : 0;
+}
+function Wt(e, t) {
+  if (Number.isInteger(t)) {
+    const i = BigInt(t);
+    return e < i ? -1 : e > i ? 1 : 0;
+  }
+  const n = BigInt(Math.floor(t));
+  return e <= n ? -1 : 1;
+}
+function Ct(e, t) {
+  if (typeof e == "bigint" && typeof t == "bigint")
+    return e < t ? -1 : e > t ? 1 : 0;
+  if (typeof e == "number" && typeof t == "number")
+    return _t(e, t);
+  const n = typeof e == "number" ? e : t;
+  return Number.isFinite(n) ? typeof e == "bigint" ? Wt(e, t) : -Wt(t, e) : _t(Number(e), Number(t));
+}
+function rn(e) {
+  if (Number.isNaN(e))
+    return "NaN";
+  if (e === 1 / 0)
+    return "Infinity";
+  if (e === -1 / 0)
+    return "-Infinity";
+  if (e === 0)
+    return Object.is(e, -0) ? "-0.0" : "0.0";
+  const t = Math.abs(e);
+  if (t >= 1e-3 && t < 1e7) {
+    const s = String(e);
+    return s.includes(".") ? s : s + ".0";
+  }
+  const [n, i] = e.toExponential().split("e");
+  return `${n.includes(".") ? n : n + ".0"}E${i.replace("+", "")}`;
+}
+const Oe = /* @__PURE__ */ new Set(["map", "filter", "all", "exists", "existsOne", "sortBy"]), $e = 256;
+class Re {
   constructor(t) {
-    this.lexer = new F(t), this.current = this.lexer.next();
+    this.depth = 0, this.lexer = new de(t), this.current = this.lexer.next();
   }
   /**
    * Parse a CEL expression from the input string.
@@ -356,8 +469,8 @@ class Y {
    */
   parse() {
     const t = this.parseExpr();
-    if (this.current.type !== s.EOF)
-      throw new f(
+    if (this.current.type !== o.EOF)
+      throw new U(
         `Unexpected token after expression: ${this.current.value}`,
         this.current.line,
         this.current.column
@@ -366,30 +479,36 @@ class Y {
   }
   // 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);
+    if (++this.depth > $e)
+      throw new U("Expression nesting too deep", this.current.line, this.current.column);
+    try {
+      const t = this.parseConditionalOr();
+      if (this.match(o.QUESTION)) {
+        const n = this.parseConditionalOr();
+        this.expect(o.COLON);
+        const i = this.parseExpr();
+        return new nn(t, n, i);
+      }
+      return t;
+    } finally {
+      this.depth--;
     }
-    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);
+    for (; this.match(o.LOGICAL_OR); ) {
+      const n = this.parseConditionalAnd();
+      t = new X(h.LOGICAL_OR, t, n);
     }
     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);
+    for (; this.match(o.LOGICAL_AND); ) {
+      const n = this.parseRelation();
+      t = new X(h.LOGICAL_AND, t, n);
     }
     return t;
   }
@@ -398,58 +517,58 @@ class Y {
   parseRelation() {
     let t = this.parseAddition();
     for (; this.isRelationalOp(this.current.type); ) {
-      const e = this.current.type;
+      const n = this.current.type;
       this.advance();
       const i = this.parseAddition();
-      t = new L(this.toBinaryOp(e), t, i);
+      t = new X(this.toBinaryOp(n), 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;
+    for (; this.current.type === o.PLUS || this.current.type === o.MINUS; ) {
+      const n = this.current.type;
       this.advance();
       const i = this.parseMultiplication();
-      t = new L(e === s.PLUS ? c.ADD : c.SUBTRACT, t, i);
+      t = new X(n === o.PLUS ? h.ADD : h.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;
+    for (; this.current.type === o.STAR || this.current.type === o.SLASH || this.current.type === o.PERCENT; ) {
+      const n = 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);
+      const i = this.parseUnary(), r = n === o.STAR ? h.MULTIPLY : n === o.SLASH ? h.DIVIDE : h.MODULO;
+      t = new X(r, 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();
+    return this.current.type === o.BANG ? (this.advance(), new At(J.NOT, this.parseUnary())) : this.current.type === o.MINUS ? (this.advance(), new At(J.NEGATE, this.parseUnary())) : this.parseMember();
   }
   // member = primary ( selector | index | fieldCall )*
   parseMember() {
     let t = this.parsePrimary();
     for (; ; )
-      if (this.current.type === s.DOT) {
+      if (this.current.type === o.DOT) {
         this.advance();
-        const e = this.expectIdentifier();
-        if (this.current.type === s.LPAREN) {
+        const n = this.expectIdentifier();
+        if (this.current.type === o.LPAREN) {
           this.advance();
           const i = this.parseExprList();
-          this.expect(s.RPAREN);
-          const n = z.has(e);
-          t = new y(t, e, i, n);
+          this.expect(o.RPAREN);
+          const r = Oe.has(n);
+          t = new gt(t, n, i, r);
         } else
-          t = new N(t, e);
-      } else if (this.current.type === s.LBRACKET) {
+          t = new nt(t, n);
+      } else if (this.current.type === o.LBRACKET) {
         this.advance();
-        const e = this.parseExpr();
-        this.expect(s.RBRACKET), t = new Q(t, e);
+        const n = this.parseExpr();
+        this.expect(o.RBRACKET), t = new we(t, n);
       } else
         break;
     return t;
@@ -458,244 +577,318 @@ class Y {
   parsePrimary() {
     if (this.isLiteralToken(this.current.type))
       return this.parseLiteral();
-    if (this.current.type === s.LBRACKET)
+    if (this.current.type === o.LBRACKET)
       return this.parseListLiteral();
-    if (this.current.type === s.LBRACE)
+    if (this.current.type === o.LBRACE)
       return this.parseMapOrStructLiteral(null);
-    if (this.current.type === s.LPAREN) {
+    if (this.current.type === o.LPAREN) {
       this.advance();
       const t = this.parseExpr();
-      return this.expect(s.RPAREN), t;
+      return this.expect(o.RPAREN), t;
     }
-    if (this.current.type === s.DOT) {
+    if (this.current.type === o.DOT) {
       this.advance();
       const t = this.expectIdentifier();
-      if (this.current.type === s.LPAREN) {
+      if (this.current.type === o.LPAREN) {
         this.advance();
-        const e = this.parseExprList();
-        return this.expect(s.RPAREN), new y(null, t, e);
+        const n = this.parseExprList();
+        return this.expect(o.RPAREN), new gt(null, t, n);
       }
-      return new N(null, t);
+      return new nt(null, t);
     }
-    if (this.current.type === s.IDENTIFIER) {
+    if (this.current.type === o.IDENTIFIER) {
       const t = this.current.value;
-      if (this.advance(), this.current.type === s.LPAREN) {
+      if (this.advance(), this.current.type === o.LPAREN) {
+        const n = this.current.line, i = this.current.column;
         this.advance();
-        const e = this.parseExprList();
-        return this.expect(s.RPAREN), new y(null, t, e);
+        const r = this.parseExprList();
+        return this.expect(o.RPAREN), t === "has" && r.length === 1 ? this.test(r[0], n, i) : new gt(null, t, r);
       }
-      if (this.current.type === s.DOT && this.isQualifiedStructLiteral()) {
-        const e = this.parseQualifiedIdent(t);
-        return this.parseMapOrStructLiteral(e);
+      if (this.current.type === o.DOT && this.isQualifiedStructLiteral()) {
+        const n = this.parseQualifiedIdent(t);
+        return this.parseMapOrStructLiteral(n);
       }
-      return this.current.type === s.LBRACE ? this.parseMapOrStructLiteral(t) : new U(t);
+      return this.current.type === o.LBRACE ? this.parseMapOrStructLiteral(t) : new It(t);
     }
-    throw new f(
+    throw new U(
       `Unexpected token: ${this.current.value}`,
       this.current.line,
       this.current.column
     );
   }
+  // Rewrites the has() macro into a presence test on the selected field
+  test(t, n, i) {
+    if (t instanceof nt)
+      return new nt(t.operand, t.field, !0);
+    throw new U("has() requires a field selection, for example has(a.b)", n, i);
+  }
   // listLiteral = '[' exprList? ','? ']'
   parseListLiteral() {
-    this.expect(s.LBRACKET);
+    this.expect(o.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);
+    return this.current.type !== o.RBRACKET && (t.push(...this.parseExprList()), this.current.type === o.COMMA && this.advance()), this.expect(o.RBRACKET), new ge(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) {
+    if (this.expect(o.LBRACE), this.current.type === o.RBRACE)
+      return this.advance(), t !== null ? new Qt(t, []) : new jt([]);
+    if (this.current.type === o.IDENTIFIER && this.peekAhead(1).type === o.COLON || t !== null) {
       const i = this.parseFieldInits();
-      return this.current.type === s.COMMA && this.advance(), this.expect(s.RBRACE), new S(t, i);
+      return this.current.type === o.COMMA && this.advance(), this.expect(o.RBRACE), new Qt(t, i);
     } else {
       const i = this.parseMapInits();
-      return this.current.type === s.COMMA && this.advance(), this.expect(s.RBRACE), new C(i);
+      return this.current.type === o.COMMA && this.advance(), this.expect(o.RBRACE), new jt(i);
     }
   }
   // exprList = expr ( ',' expr )*
   parseExprList() {
-    const t = [], e = this.current.type;
-    if (e === s.RPAREN || e === s.RBRACKET)
+    const t = [], n = this.current.type;
+    if (n === o.RPAREN || n === o.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)); )
+    for (t.push(this.parseExpr()); this.current.type === o.COMMA && (this.advance(), !(this.current.type === o.RPAREN || this.current.type === o.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); )
+    for (t.push(this.parseMapInit()); this.current.type === o.COMMA && (this.advance(), this.current.type !== o.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);
+    this.expect(o.COLON);
+    const n = this.parseExpr();
+    return new be(t, n);
   }
   // fieldInits = fieldInit ( ',' fieldInit )*
   parseFieldInits() {
     const t = [];
-    for (t.push(this.parseFieldInit()); this.current.type === s.COMMA && (this.advance(), this.current.type !== s.RBRACE); )
+    for (t.push(this.parseFieldInit()); this.current.type === o.COMMA && (this.advance(), this.current.type !== o.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);
+    this.expect(o.COLON);
+    const n = this.parseExpr();
+    return new me(t, n);
   }
   // qualifiedIdent = ident ( '.' ident )*
   parseQualifiedIdent(t) {
-    let e = t;
-    for (; this.current.type === s.DOT; )
-      this.advance(), e += ".", e += this.expectIdentifier();
-    return e;
+    let n = t;
+    for (; this.current.type === o.DOT; )
+      this.advance(), n += ".", n += this.expectIdentifier();
+    return n;
   }
   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);
+      case o.NULL:
+        return new z(null, $.NULL_VALUE);
+      case o.TRUE:
+        return new z(!0, $.BOOL);
+      case o.FALSE:
+        return new z(!1, $.BOOL);
+      case o.INT:
+        return new z(this.parseIntLiteral(t), $.INT);
+      case o.UINT:
+        return new z(this.parseUintLiteral(t), $.UINT);
+      case o.DOUBLE:
+        return new z(Number(t.value), $.DOUBLE);
+      case o.STRING:
+        return new z(this.parseStringLiteral(t.value), $.STRING);
+      case o.BYTES:
+        return new z(this.parseBytesLiteral(t.value), $.BYTES);
       default:
-        throw new f(`Not a literal: ${t.value}`, t.line, t.column);
+        throw new U(`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);
+    const n = t.value, i = n.startsWith("-"), r = i ? n.substring(1) : n, s = BigInt(r);
+    return this.checkRange(i ? -s : s, t);
   }
   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);
+    const n = t.value.substring(0, t.value.length - 1);
+    return this.checkRange(BigInt(n), t);
+  }
+  checkRange(t, n) {
+    if (t < K || t > at)
+      throw new U(
+        `Integer literal out of range: ${n.value}`,
+        n.line,
+        n.column
+      );
+    return t;
   }
   parseStringLiteral(t) {
-    const e = t.startsWith("r") || t.startsWith("R");
+    const n = 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;
+    return n && (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)) : n ? 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);
+    const n = t.substring(2, t.length - 1);
+    return this.unescapeBytes(n);
+  }
+  /**
+   * Decodes the escapes of a bytes literal.
+   *
+   * Character escapes and plain text accumulate in a pending buffer that is
+   * UTF-8 encoded when flushed, while \xHH and octal escapes write a raw byte.
+   */
+  unescapeBytes(t) {
+    const n = [];
+    let i = "";
+    const r = () => {
+      i.length > 0 && (n.push(...Mt(i)), i = "");
+    };
+    let s = 0;
+    for (; s < t.length; ) {
+      if (t[s] !== "\\" || s + 1 >= t.length) {
+        i += t[s], s++;
+        continue;
+      }
+      const c = t[s + 1], u = this.simpleEscape(c);
+      u !== null ? (i += u, s += 2) : c === "x" && s + 4 <= t.length ? (r(), n.push(parseInt(t.substring(s + 2, s + 4), 16)), s += 4) : c === "u" && s + 6 <= t.length ? (i += String.fromCharCode(parseInt(t.substring(s + 2, s + 6), 16)), s += 6) : c === "U" && s + 10 <= t.length ? (i += String.fromCodePoint(parseInt(t.substring(s + 2, s + 10), 16)), s += 10) : this.isOctal(t, s) ? (r(), n.push(parseInt(t.substring(s + 1, s + 4), 8)), s += 4) : (i += t[s], s++);
+    }
+    return r(), Uint8Array.from(n);
+  }
+  simpleEscape(t) {
+    switch (t) {
+      case "\\":
+        return "\\";
+      case '"':
+        return '"';
+      case "'":
+        return "'";
+      case "`":
+        return "`";
+      case "?":
+        return "?";
+      case "a":
+        return "\x07";
+      case "b":
+        return "\b";
+      case "f":
+        return "\f";
+      case "n":
+        return `
+`;
+      case "r":
+        return "\r";
+      case "t":
+        return "	";
+      case "v":
+        return "\v";
+      default:
+        return null;
+    }
+  }
+  isOctal(t, n) {
+    return n + 3 < t.length && t[n + 1] >= "0" && t[n + 1] <= "3" && t[n + 2] >= "0" && t[n + 2] <= "7" && t[n + 3] >= "0" && t[n + 3] <= "7";
   }
   unescapeString(t) {
-    let e = "", i = 0;
+    let n = "", i = 0;
     for (; i < t.length; )
       if (t[i] === "\\" && i + 1 < t.length) {
-        const n = t[i + 1];
-        switch (n) {
+        const r = t[i + 1];
+        switch (r) {
           case "\\":
-            e += "\\", i += 2;
+            n += "\\", i += 2;
             break;
           case '"':
-            e += '"', i += 2;
+            n += '"', i += 2;
             break;
           case "'":
-            e += "'", i += 2;
+            n += "'", i += 2;
             break;
           case "`":
-            e += "`", i += 2;
+            n += "`", i += 2;
             break;
           case "?":
-            e += "?", i += 2;
+            n += "?", i += 2;
             break;
           case "a":
-            e += "\x07", i += 2;
+            n += "\x07", i += 2;
             break;
           case "b":
-            e += "\b", i += 2;
+            n += "\b", i += 2;
             break;
           case "f":
-            e += "\f", i += 2;
+            n += "\f", i += 2;
             break;
           case "n":
-            e += `
+            n += `
 `, i += 2;
             break;
           case "r":
-            e += "\r", i += 2;
+            n += "\r", i += 2;
             break;
           case "t":
-            e += "	", i += 2;
+            n += "	", i += 2;
             break;
           case "v":
-            e += "\v", i += 2;
+            n += "\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;
+              const s = t.substring(i + 2, i + 4);
+              n += String.fromCharCode(parseInt(s, 16)), i += 4;
             } else
-              e += t[i], i++;
+              n += 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;
+              const s = t.substring(i + 2, i + 6);
+              n += String.fromCharCode(parseInt(s, 16)), i += 6;
             } else
-              e += t[i], i++;
+              n += 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;
+              const s = t.substring(i + 2, i + 10), c = parseInt(s, 16);
+              n += String.fromCodePoint(c), i += 10;
             } else
-              e += t[i], i++;
+              n += 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;
+            if (i + 3 < t.length && r >= "0" && r <= "3" && t[i + 2] >= "0" && t[i + 2] <= "7" && t[i + 3] >= "0" && t[i + 3] <= "7") {
+              const s = t.substring(i + 1, i + 4);
+              n += String.fromCharCode(parseInt(s, 8)), i += 4;
             } else
-              e += t[i], i++;
+              n += t[i], i++;
         }
       } else
-        e += t[i], i++;
-    return e;
+        n += t[i], i++;
+    return n;
   }
   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;
+    return t === o.NULL || t === o.TRUE || t === o.FALSE || t === o.INT || t === o.UINT || t === o.DOUBLE || t === o.STRING || t === o.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;
+    return t === o.LT || t === o.LE || t === o.GT || t === o.GE || t === o.EQ || t === o.NE || t === o.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;
+      case o.LT:
+        return h.LESS;
+      case o.LE:
+        return h.LESS_EQUAL;
+      case o.GT:
+        return h.GREATER;
+      case o.GE:
+        return h.GREATER_EQUAL;
+      case o.EQ:
+        return h.EQUAL;
+      case o.NE:
+        return h.NOT_EQUAL;
+      case o.IN:
+        return h.IN;
       default:
-        throw new f(
+        throw new U(
           `Unknown relational operator: ${t}`,
           this.current.line,
           this.current.column
@@ -707,7 +900,7 @@ class Y {
   }
   expect(t) {
     if (this.current.type !== t)
-      throw new f(
+      throw new U(
         `Expected ${t} but found ${this.current.type}`,
         this.current.line,
         this.current.column
@@ -715,8 +908,8 @@ class Y {
     this.advance();
   }
   expectIdentifier() {
-    if (this.current.type !== s.IDENTIFIER)
-      throw new f(
+    if (this.current.type !== o.IDENTIFIER)
+      throw new U(
         `Expected identifier but found ${this.current.value}`,
         this.current.line,
         this.current.column
@@ -732,289 +925,1709 @@ class Y {
   }
   // Check if we have a pattern like: . ident ( . ident )* {
   isQualifiedStructLiteral() {
-    let t = 1, e = this.peekAhead(t);
-    if (e.type !== s.IDENTIFIER)
+    let t = 1, n = this.peekAhead(t);
+    if (n.type !== o.IDENTIFIER)
       return !1;
-    for (t++, e = this.peekAhead(t); e.type === s.DOT; ) {
-      if (t++, e = this.peekAhead(t), e.type !== s.IDENTIFIER)
+    for (t++, n = this.peekAhead(t); n.type === o.DOT; ) {
+      if (t++, n = this.peekAhead(t), n.type !== o.IDENTIFIER)
         return !1;
-      t++, e = this.peekAhead(t);
+      t++, n = this.peekAhead(t);
     }
-    return e.type === s.LBRACE;
+    return n.type === o.LBRACE;
   }
 }
-class a extends Error {
+const p = class p {
   constructor(t) {
-    super(t), this.name = "EvaluationError";
+    this.name = t;
+  }
+  /**
+   * Returns the type with the given name, or null when the name does not denote a CEL type.
+   *
+   * Used to resolve bare type names such as `int` when they appear as identifiers.
+   * `unknown` is deliberately not resolvable.
+   *
+   * @param name The candidate type name
+   * @returns The matching type, or null
+   */
+  static of(t) {
+    return p.BY_NAME.get(t) ?? null;
+  }
+  /**
+   * Reports whether the value is a Type.
+   */
+  static isType(t) {
+    return t instanceof p;
+  }
+  equals(t) {
+    return t instanceof p && t.name === this.name;
+  }
+  toString() {
+    return this.name;
   }
+};
+p.NULL = new p("null_type"), p.BOOL = new p("bool"), p.INT = new p("int"), p.UINT = new p("uint"), p.DOUBLE = new p("double"), p.STRING = new p("string"), p.BYTES = new p("bytes"), p.LIST = new p("list"), p.MAP = new p("map"), p.TIMESTAMP = new p("timestamp"), p.DURATION = new p("duration"), p.TYPE = new p("type"), p.UNKNOWN = new p("unknown"), p.BY_NAME = new Map(
+  [
+    p.NULL,
+    p.BOOL,
+    p.INT,
+    p.UINT,
+    p.DOUBLE,
+    p.STRING,
+    p.BYTES,
+    p.LIST,
+    p.MAP,
+    p.TIMESTAMP,
+    p.DURATION,
+    p.TYPE
+  ].map((t) => [t.name, t])
+);
+let y = p;
+const rt = 86400n;
+function Ut(e, t) {
+  const n = e / t;
+  return e % t !== 0n && e < 0n != t < 0n ? n - 1n : n;
 }
-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;
+function st(e, t) {
+  const n = e % t;
+  return n !== 0n && n < 0n != t < 0n ? n + t : n;
+}
+function Bt(e, t, n) {
+  const i = t <= 2 ? e - 1n : e, r = (i >= 0n ? i : i - 399n) / 400n, s = i - r * 400n, u = (153n * (BigInt(t) + (t > 2 ? -3n : 9n)) + 2n) / 5n + BigInt(n) - 1n, d = s * 365n + s / 4n - s / 100n + u;
+  return r * 146097n + d - 719468n;
+}
+function Me(e) {
+  const t = e + 719468n, n = (t >= 0n ? t : t - 146096n) / 146097n, i = t - n * 146097n, r = (i - i / 1460n + i / 36524n - i / 146096n) / 365n, s = r + n * 400n, c = i - (365n * r + r / 4n - r / 100n), u = (5n * c + 2n) / 153n, d = Number(c - (153n * u + 2n) / 5n + 1n), E = Number(u < 10n ? u + 3n : u - 9n);
+  return { year: E <= 2 ? s + 1n : s, month: E, day: d };
+}
+function Ce(e) {
+  return e % 4n === 0n && (e % 100n !== 0n || e % 400n === 0n);
+}
+function Ue(e, t) {
+  switch (t) {
+    case 2:
+      return Ce(e) ? 29 : 28;
+    case 4:
+    case 6:
+    case 9:
+    case 11:
+      return 30;
+    default:
+      return 31;
   }
-  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 Nt(e) {
+  const t = Ut(e, rt), n = Number(st(e, rt)), { year: i, month: r, day: s } = Me(t);
+  return {
+    year: i,
+    month: r,
+    day: s,
+    hour: Math.floor(n / 3600),
+    minute: Math.floor(n % 3600 / 60),
+    second: n % 60,
+    // 1970-01-01 was a Thursday
+    weekday: Number(st(t + 4n, 7n)),
+    dayOfYear: Number(t - Bt(i, 1, 1)) + 1
+  };
 }
-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}`);
+const Kt = /* @__PURE__ */ new Map();
+function Be(e) {
+  if (typeof e != "string")
+    throw new a(`Time zone must be a string: ${String(e)}`);
+  const t = Kt.get(e);
+  if (t)
     return t;
+  let n;
+  try {
+    n = new Intl.DateTimeFormat("en-US", {
+      timeZone: e,
+      hourCycle: "h23",
+      era: "short",
+      year: "numeric",
+      month: "numeric",
+      day: "numeric",
+      hour: "numeric",
+      minute: "numeric",
+      second: "numeric"
+    });
+  } catch {
+    throw new a(`Invalid time zone: ${e}`);
+  }
+  return Kt.set(e, n), n;
+}
+const Ht = 8640000000000n;
+function Te(e, t) {
+  if (t > Ht || t < -Ht)
+    throw new l("Timestamp out of range for time zone conversion");
+  const n = e.formatToParts(new Date(Number(t) * 1e3)), i = (u) => n.find((d) => d.type === u)?.value ?? "0";
+  let r = BigInt(i("year"));
+  i("era").startsWith("B") && (r = 1n - r);
+  const s = Number(i("hour")) % 24;
+  return Bt(r, Number(i("month")), Number(i("day"))) * rt + BigInt(s * 3600 + Number(i("minute")) * 60 + Number(i("second"))) - t;
+}
+function De(e, t) {
+  if (t == null)
+    return Nt(e);
+  const n = Be(t);
+  return Nt(e + Te(n, e));
+}
+const Y = 1000000000n, xe = /^-?(?:\d+(?:\.\d+)?(?:ns|us|µs|ms|s|m|h))+$/, ke = /(\d+)(?:\.(\d+))?(ns|us|µs|ms|s|m|h)/g, Pe = {
+  ns: 1n,
+  us: 1000n,
+  µs: 1000n,
+  ms: 1000000n,
+  s: Y,
+  m: Y * 60n,
+  h: Y * 3600n
+}, S = class S {
+  constructor(t, n) {
+    this.seconds = t, this.nanos = n;
+  }
+  /**
+   * Creates a duration from seconds and a nanosecond adjustment, normalising the
+   * adjustment into the seconds.
+   */
+  static ofSeconds(t, n = 0n) {
+    const i = t + Ut(n, Y), r = Number(st(n, Y));
+    return new S(i, r);
+  }
+  static ofNanos(t) {
+    return S.ofSeconds(0n, t);
+  }
+  static ofMillis(t) {
+    return S.ofSeconds(0n, t * 1000000n);
+  }
+  static ofMinutes(t) {
+    return new S(t * 60n, 0);
+  }
+  static ofHours(t) {
+    return new S(t * 3600n, 0);
+  }
+  /**
+   * Parses a CEL duration literal such as `"300ms"`, `"-1.5h"` or `"2h45m"`.
+   *
+   * Units are `ns`, `us`, `µs`, `ms`, `s`, `m` and `h`. The value is accumulated
+   * exactly and rounded half up to the nearest nanosecond.
+   *
+   * @throws ArgumentError if the format is invalid or the span exceeds ±10 000 years
+   */
+  static parse(t) {
+    if (!xe.test(t))
+      throw new a(`Invalid duration format: ${t}`);
+    const n = Array.from(t.matchAll(ke)), i = Math.max(0, ...n.map((E) => E[2]?.length ?? 0)), r = 10n ** BigInt(i);
+    let s = 0n;
+    for (const E of n) {
+      const b = E[1], N = E[2] ?? "", L = BigInt(b + N) * 10n ** BigInt(i - N.length);
+      s += L * Pe[E[3]];
+    }
+    let c = s / r;
+    s % r * 2n >= r && (c += 1n);
+    const u = c / Y;
+    if (u > S.SPAN)
+      throw new a(`Duration out of range: ${t}`);
+    const d = S.ofSeconds(u, c % Y);
+    return t.startsWith("-") ? d.negated() : d;
+  }
+  /** Reports whether the value is a Duration. */
+  static isDuration(t) {
+    return t instanceof S;
+  }
+  isNegative() {
+    return this.seconds < 0n;
+  }
+  isZero() {
+    return this.seconds === 0n && this.nanos === 0;
+  }
+  negated() {
+    return S.ofSeconds(-this.seconds, -BigInt(this.nanos));
+  }
+  plus(t) {
+    return S.ofSeconds(this.seconds + t.seconds, BigInt(this.nanos + t.nanos));
+  }
+  minus(t) {
+    return S.ofSeconds(this.seconds - t.seconds, BigInt(this.nanos - t.nanos));
+  }
+  /** The total length in nanoseconds. */
+  toNanos() {
+    return this.seconds * Y + BigInt(this.nanos);
+  }
+  /** The whole number of milliseconds, truncated toward zero. */
+  toMillis() {
+    return this.toNanos() / 1000000n;
+  }
+  /** The whole number of seconds, truncated toward negative infinity (the seconds field). */
+  toSeconds() {
+    return this.seconds;
+  }
+  /** The whole number of minutes, truncated toward zero. */
+  toMinutes() {
+    return this.seconds / 60n;
+  }
+  /** The whole number of hours, truncated toward zero. */
+  toHours() {
+    return this.seconds / 3600n;
+  }
+  compareTo(t) {
+    return this.seconds !== t.seconds ? this.seconds < t.seconds ? -1 : 1 : this.nanos - t.nanos;
+  }
+  equals(t) {
+    return t instanceof S && t.seconds === this.seconds && t.nanos === this.nanos;
+  }
+  /**
+   * Renders the duration the way the CEL specification does: a seconds count with
+   * an `s` suffix, for example `"3600s"`, `"1.5s"` or `"-90s"`.
+   */
+  toString() {
+    if (this.isNegative())
+      return "-" + this.negated().toString();
+    if (this.nanos === 0)
+      return `${this.seconds}s`;
+    const t = String(this.nanos).padStart(9, "0").replace(/0+$/, "");
+    return `${this.seconds}.${t}s`;
+  }
+};
+S.SPAN = 315576000000n, S.ZERO = new S(0n, 0);
+let I = S;
+const Xt = 1000000000n, Ge = /^([+-]?\d{4,9})-(\d{2})-(\d{2})[Tt](\d{2}):(\d{2})(?::(\d{2})(?:\.(\d{1,9}))?)?([Zz]|[+-]\d{2}:\d{2})$/, M = class M {
+  constructor(t, n) {
+    this.seconds = t, this.nanos = n;
+  }
+  /**
+   * Creates a timestamp from epoch seconds and a nanosecond adjustment.
+   *
+   * @throws ArgumentError if the instant is outside the supported range
+   */
+  static ofEpochSeconds(t, n = 0n) {
+    const i = t + Ut(n, Xt), r = Number(st(n, Xt));
+    if (i < M.MIN_SECONDS || i > M.MAX_SECONDS)
+      throw new a(`Timestamp out of range: ${t}`);
+    return new M(i, r);
+  }
+  /** Creates a timestamp from epoch milliseconds. */
+  static ofEpochMillis(t) {
+    return M.ofEpochSeconds(0n, t * 1000000n);
+  }
+  /** Converts a JavaScript Date. */
+  static fromDate(t) {
+    const n = t.getTime();
+    if (Number.isNaN(n))
+      throw new a("Invalid timestamp value: Invalid Date");
+    return M.ofEpochMillis(BigInt(n));
+  }
+  /** The current instant, at millisecond resolution. */
+  static now() {
+    return M.ofEpochMillis(BigInt(Date.now()));
+  }
+  /**
+   * Parses an RFC 3339 timestamp such as `2024-01-01T00:00:00Z` or
+   * `2024-01-01T01:00:00.5+01:00`.
+   *
+   * @throws ArgumentError if the text is not a valid timestamp
+   */
+  static parse(t) {
+    const n = Ge.exec(t);
+    if (!n)
+      throw new a(`Invalid timestamp value: ${t}`);
+    const i = BigInt(n[1]), r = Number(n[2]), s = Number(n[3]), c = Number(n[4]), u = Number(n[5]), d = Number(n[6] ?? "0"), E = Number((n[7] ?? "").padEnd(9, "0")), b = n[8];
+    if (r < 1 || r > 12 || s < 1 || s > Ue(i, r) || c > 23 || u > 59 || d > 59)
+      throw new a(`Invalid timestamp value: ${t}`);
+    let N = 0n;
+    if (b !== "Z" && b !== "z") {
+      const k = b.startsWith("-") ? -1n : 1n, wt = Number(b.slice(1, 3)), Ft = Number(b.slice(4, 6));
+      if (wt > 18 || Ft > 59)
+        throw new a(`Invalid timestamp value: ${t}`);
+      N = k * BigInt(wt * 3600 + Ft * 60);
+    }
+    const L = Bt(i, r, s) * rt + BigInt(c * 3600 + u * 60 + d) - N;
+    return M.ofEpochSeconds(L, BigInt(E));
+  }
+  /** Reports whether the value is a Timestamp. */
+  static isTimestamp(t) {
+    return t instanceof M;
+  }
+  /** Converts to a JavaScript Date, truncating to milliseconds. */
+  toDate() {
+    return new Date(Number(this.seconds) * 1e3 + Math.floor(this.nanos / 1e6));
+  }
+  /**
+   * Adds a duration.
+   *
+   * @throws EvaluationError if the result is outside the supported range
+   */
+  plus(t) {
+    return this.shift(t.seconds, t.nanos);
+  }
+  /**
+   * Subtracts a duration.
+   *
+   * @throws EvaluationError if the result is outside the supported range
+   */
+  minus(t) {
+    return this.shift(-t.seconds, -t.nanos);
+  }
+  shift(t, n) {
+    try {
+      return M.ofEpochSeconds(this.seconds + t, BigInt(this.nanos + n));
+    } catch (i) {
+      throw i instanceof a ? new l("Timestamp out of range") : i;
+    }
+  }
+  /** The duration from this instant to another (`other - this`). */
+  until(t) {
+    return I.ofSeconds(t.seconds - this.seconds, BigInt(t.nanos - this.nanos));
+  }
+  compareTo(t) {
+    return this.seconds !== t.seconds ? this.seconds < t.seconds ? -1 : 1 : this.nanos - t.nanos;
+  }
+  equals(t) {
+    return t instanceof M && t.seconds === this.seconds && t.nanos === this.nanos;
+  }
+  /**
+   * Renders the instant in ISO-8601 form, the way java.time.Instant does:
+   * `2024-03-05T14:30:45.250Z`, with the fraction shown in groups of three
+   * digits only as far as needed.
+   */
+  toString() {
+    const t = Nt(this.seconds), n = (s) => String(s).padStart(2, "0");
+    let i;
+    t.year > 9999n ? i = "+" + t.year : t.year < 0n ? i = "-" + String(-t.year).padStart(4, "0") : i = String(t.year).padStart(4, "0");
+    let r = "";
+    return this.nanos !== 0 && (this.nanos % 1e6 === 0 ? r = "." + String(this.nanos / 1e6).padStart(3, "0") : this.nanos % 1e3 === 0 ? r = "." + String(this.nanos / 1e3).padStart(6, "0") : r = "." + String(this.nanos).padStart(9, "0")), `${i}-${n(t.month)}-${n(t.day)}T${n(t.hour)}:${n(t.minute)}:${n(t.second)}${r}Z`;
   }
-  throw new Error(`Cannot convert to double: ${r}`);
+};
+M.MIN_SECONDS = -31557014167219200n, M.MAX_SECONDS = 31556889864403199n;
+let A = M, qe = 0;
+const Vt = /* @__PURE__ */ new WeakMap();
+let Fe = 0;
+function Zt(e) {
+  let t = Vt.get(e);
+  return t === void 0 && (t = ++Fe, Vt.set(e, t)), t;
 }
-function D(r) {
-  return r == null ? "null" : String(r);
+function je(e) {
+  return Number.isNaN(e) ? `nan:${++qe}` : e === 0 ? "n:0" : Number.isInteger(e) ? `n:${BigInt(e)}` : `n:${e}`;
 }
-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 G(e) {
+  if (e == null)
+    return "z";
+  switch (typeof e) {
+    case "boolean":
+      return e ? "b:1" : "b:0";
+    case "string":
+      return `s${e.length}:${e}`;
+    case "bigint":
+      return `n:${e}`;
+    case "number":
+      return je(e);
+    case "object":
+      break;
+    default:
+      return `o:${Zt(e)}`;
+  }
+  if (B(e))
+    return `y:${yt(e)}`;
+  if (Array.isArray(e))
+    return `[${e.map(G).join(",")}]`;
+  if (e instanceof Map) {
+    const n = Array.from(
+      e.entries(),
+      ([i, r]) => `${G(i)}=${G(r)}`
+    );
+    return n.sort(), `{${n.join(",")}}`;
+  }
+  if (e instanceof A)
+    return `t:${e.seconds}.${e.nanos}`;
+  if (e instanceof I)
+    return `d:${e.seconds}.${e.nanos}`;
+  if (e instanceof y)
+    return `T:${e.name}`;
+  const t = Object.getPrototypeOf(e);
+  if (t === Object.prototype || t === null) {
+    const n = Object.entries(e).map(
+      ([i, r]) => `${G(i)}=${G(r)}`
+    );
+    return n.sort(), `{${n.join(",")}}`;
+  }
+  return `o:${Zt(e)}`;
 }
-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";
+class sn {
+  constructor() {
+    this.keys = /* @__PURE__ */ new Set();
+  }
+  /** Adds the value; returns true if it was not already present. */
+  add(t) {
+    const n = G(t);
+    return this.keys.has(n) ? !1 : (this.keys.add(n), !0);
+  }
+  has(t) {
+    return this.keys.has(G(t));
+  }
+  get size() {
+    return this.keys.size;
+  }
 }
-function B(r, t) {
-  return typeof r == "object" && r !== null && typeof t == "string" ? t in r : !1;
+class Qe {
+  constructor() {
+    this.entries = /* @__PURE__ */ new Map();
+  }
+  set(t, n) {
+    this.entries.set(G(t), n);
+  }
+  get(t) {
+    return this.entries.get(G(t));
+  }
+  has(t) {
+    return this.entries.has(G(t));
+  }
+  get size() {
+    return this.entries.size;
+  }
+}
+function Jt(e) {
+  return V(e, /* @__PURE__ */ new Set(), !0);
+}
+function bt(e) {
+  return V(e, /* @__PURE__ */ new Set(), !1);
 }
-function G(r, t) {
+function H(e) {
+  if (typeof e != "object" || e === null)
+    return !1;
+  const t = Object.getPrototypeOf(e);
+  return t === Object.prototype || t === null;
+}
+function V(e, t, n) {
+  switch (typeof e) {
+    case "undefined":
+      return null;
+    case "number":
+      return n && Number.isInteger(e) ? BigInt(e) : e;
+    case "bigint":
+    case "string":
+    case "boolean":
+      return e;
+    case "object":
+      break;
+    default:
+      return e;
+  }
+  return e === null ? null : e instanceof Uint8Array || e instanceof A || e instanceof I || e instanceof y ? e : e instanceof Date ? A.fromDate(e) : Array.isArray(e) ? mt(e, t, () => e.map((i) => V(i, t, n))) : e instanceof Map ? mt(e, t, () => {
+    const i = /* @__PURE__ */ new Map();
+    for (const [r, s] of e)
+      i.set(V(r, t, n), V(s, t, n));
+    return i;
+  }) : H(e) ? mt(e, t, () => {
+    const i = /* @__PURE__ */ new Map();
+    for (const [r, s] of Object.entries(e))
+      i.set(r, V(s, t, n));
+    return i;
+  }) : e;
+}
+function mt(e, t, n) {
+  if (t.has(e))
+    throw new a("Cyclic value");
+  t.add(e);
   try {
-    return new RegExp(t).test(r);
-  } catch {
-    throw new Error(`Invalid regex pattern: ${t}`);
+    return n();
+  } finally {
+    t.delete(e);
   }
 }
-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;
+const D = 1e6, ze = I.SPAN, Ye = /^[+-]?\d+$/, _e = /^[+-]?(?:\d+\.?\d*(?:[eE][+-]?\d+)?|\.\d+(?:[eE][+-]?\d+)?|Infinity|NaN)$/;
+function q(e, t) {
+  if (e > D)
+    throw new l(`${t} exceeds the evaluation limit of ${D}`);
+}
+function We(e) {
+  return e instanceof Map;
 }
-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]);
+function ht(e) {
+  let t = 0;
+  for (let n = 0; n < e.length; n++) {
+    const i = e.charCodeAt(n);
+    if (i >= 55296 && i <= 56319 && n + 1 < e.length) {
+      const r = e.charCodeAt(n + 1);
+      r >= 56320 && r <= 57343 && n++;
+    }
+    t++;
+  }
   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;
+function Tt(e, t) {
+  let n = 0;
+  for (let i = t; i > 0; i--) {
+    if (n >= e.length)
+      return -1;
+    const r = e.charCodeAt(n);
+    if (r >= 55296 && r <= 56319 && n + 1 < e.length) {
+      const s = e.charCodeAt(n + 1);
+      n += s >= 56320 && s <= 57343 ? 2 : 1;
+    } else
+      n++;
+  }
+  return n > e.length ? -1 : n;
+}
+function Lt(e) {
+  if (e == null)
+    return 0n;
+  if (typeof e == "string")
+    return BigInt(ht(e));
+  if (B(e) || Array.isArray(e))
+    return BigInt(e.length);
+  if (e instanceof Map)
+    return BigInt(e.size);
+  if (H(e))
+    return BigInt(Object.keys(e).length);
+  throw new a(`size() not supported for type: ${W(e)}`);
+}
+function g(e) {
+  if (typeof e == "bigint")
+    return e;
+  if (typeof e == "number")
+    return Se(e);
+  if (typeof e == "string") {
+    if (Ye.test(e.trim()) && e.trim() === e) {
+      const t = BigInt(e);
+      if (t >= K && t <= at)
+        return t;
     }
-    return r.length - t.length;
+    throw new a(`Cannot convert to int: ${e}`);
   }
-  throw new Error(`Cannot compare types: ${typeof r} and ${typeof t}`);
+  if (typeof e == "boolean")
+    return e ? 1n : 0n;
+  if (e instanceof A)
+    return e.seconds;
+  throw new a(`Cannot convert to int: ${O(e)}`);
+}
+function on(e) {
+  const t = g(e);
+  if (t < 0n)
+    throw new a(`Cannot convert negative value to uint: ${O(e)}`);
+  return t;
+}
+function T(e) {
+  if (typeof e == "number")
+    return e;
+  if (typeof e == "bigint")
+    return Number(e);
+  if (typeof e == "string") {
+    const t = e.trim();
+    if (_e.test(t))
+      return Number(t);
+    throw new a(`Cannot convert to double: ${e}`);
+  }
+  throw new a(`Cannot convert to double: ${O(e)}`);
+}
+function O(e) {
+  return e == null ? "null" : typeof e == "string" ? e : typeof e == "number" ? rn(e) : typeof e == "bigint" || typeof e == "boolean" ? String(e) : B(e) ? en(e) : Array.isArray(e) ? `[${e.map(O).join(", ")}]` : e instanceof Map ? `{${Array.from(e, ([t, n]) => `${O(t)}=${O(n)}`).join(", ")}}` : H(e) ? `{${Object.entries(e).map(([t, n]) => `${t}=${O(n)}`).join(", ")}}` : String(e);
+}
+function ft(e) {
+  if (B(e))
+    return e;
+  if (typeof e == "string")
+    return Mt(e);
+  throw new a(`Cannot convert to bytes: ${O(e)}`);
+}
+function cn(e) {
+  return typeof e == "boolean" ? e : typeof e == "bigint" ? e !== 0n : typeof e == "number" ? e !== 0 : typeof e == "string" || Array.isArray(e) ? e.length > 0 : e instanceof Map ? e.size > 0 : H(e) ? Object.keys(e).length > 0 : e != null;
+}
+function W(e) {
+  if (e == null)
+    return y.NULL;
+  switch (typeof e) {
+    case "boolean":
+      return y.BOOL;
+    case "bigint":
+      return y.INT;
+    case "number":
+      return y.DOUBLE;
+    case "string":
+      return y.STRING;
+    case "object":
+      break;
+    default:
+      return y.UNKNOWN;
+  }
+  return B(e) ? y.BYTES : e instanceof A ? y.TIMESTAMP : e instanceof I ? y.DURATION : Array.isArray(e) ? y.LIST : e instanceof Map || H(e) ? y.MAP : e instanceof y ? y.TYPE : y.UNKNOWN;
+}
+function un(e, t) {
+  return e instanceof Map ? ot(e, t) : H(e) ? typeof t == "string" && Object.prototype.hasOwnProperty.call(e, t) : !1;
+}
+function ot(e, t) {
+  if (e.has(t))
+    return !0;
+  for (const n of e.keys())
+    if (j(n, t))
+      return !0;
+  return !1;
+}
+function an(e, t) {
+  if (e.has(t))
+    return e.get(t);
+  for (const [n, i] of e)
+    if (j(n, t))
+      return i;
+}
+function St(e, t) {
+  let n;
+  try {
+    n = new RegExp(t);
+  } catch {
+    throw new a(`Invalid regular expression: ${t}`);
+  }
+  return n.test(e);
+}
+function Dt(e) {
+  if (e == null)
+    return A.now();
+  if (e instanceof A)
+    return e;
+  if (e instanceof Date)
+    return A.fromDate(e);
+  if (typeof e == "string")
+    return A.parse(e);
+  if (typeof e == "bigint")
+    return A.ofEpochSeconds(e);
+  throw new a(`Invalid timestamp value: ${O(e)}`);
+}
+function Ke(e) {
+  return I.parse(e);
+}
+function hn(e) {
+  if (e instanceof I)
+    return e;
+  if (typeof e == "string")
+    return I.parse(e);
+  throw new a(`Cannot convert to duration: ${O(e)}`);
 }
-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)
+function Q(e, t) {
+  const n = e instanceof A ? e : Dt(e);
+  return { instant: n, fields: De(n.seconds, t ?? null) };
+}
+function fn(e, t = null) {
+  return BigInt(Q(e, t).fields.day);
+}
+function ln(e, t = null) {
+  return BigInt(Q(e, t).fields.month - 1);
+}
+function pn(e, t = null) {
+  return Q(e, t).fields.year;
+}
+function dn(e, t = null) {
+  return e instanceof I ? e.toHours() : BigInt(Q(e, t).fields.hour);
+}
+function wn(e, t = null) {
+  return e instanceof I ? e.toMinutes() : BigInt(Q(e, t).fields.minute);
+}
+function gn(e, t = null) {
+  return e instanceof I ? e.toSeconds() : BigInt(Q(e, t).fields.second);
+}
+function bn(e, t = null) {
+  return e instanceof I ? e.toMillis() : BigInt(Math.floor(Q(e, t).instant.nanos / 1e6));
+}
+function mn(e, t = null) {
+  return BigInt(Q(e, t).fields.weekday);
+}
+function En(e, t = null) {
+  return BigInt(Q(e, t).fields.dayOfYear - 1);
+}
+function xt(e) {
+  if (e.length === 0)
+    throw new a("max() requires at least one argument");
+  let t = e[0];
+  for (let n = 1; n < e.length; n++)
+    v(e[n], t) > 0 && (t = e[n]);
+  return t;
+}
+function kt(e) {
+  if (e.length === 0)
+    throw new a("min() requires at least one argument");
+  let t = e[0];
+  for (let n = 1; n < e.length; n++)
+    v(e[n], t) < 0 && (t = e[n]);
+  return t;
+}
+function j(e, t) {
+  if (e == null || t === null || t === void 0)
+    return (e ?? null) === (t ?? null);
+  if (B(e) && B(t))
+    return Ae(e, t);
+  if (Array.isArray(e) && Array.isArray(t)) {
+    if (e.length !== t.length)
       return !1;
-    for (let e = 0; e < r.length; e++)
-      if (!A(r[e], t[e]))
+    for (let r = 0; r < e.length; r++)
+      if (!j(e[r], t[r]))
         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)
+  const n = vt(e), i = vt(t);
+  if (n && i) {
+    if (n.size !== i.size)
       return !1;
-    for (const n of e)
-      if (!(n in t) || !A(r[n], t[n]))
+    const r = new Qe();
+    for (const [s, c] of i)
+      r.set(s, c);
+    for (const [s, c] of n)
+      if (!r.has(s) || !j(c, r.get(s)))
         return !1;
     return !0;
   }
-  return r === t;
+  return (typeof e == "bigint" || typeof e == "number") && (typeof t == "bigint" || typeof t == "number") ? Number.isNaN(e) || Number.isNaN(t) ? !1 : Ct(e, t) === 0 : e instanceof A || e instanceof I || e instanceof y ? e.equals(t) : e === t;
 }
-function _(r, t) {
-  for (const e of r)
-    if (A(e, t))
+function vt(e) {
+  return e instanceof Map ? e : H(e) ? new Map(Object.entries(e)) : null;
+}
+const He = j;
+function v(e, t) {
+  if ((typeof e == "bigint" || typeof e == "number") && (typeof t == "bigint" || typeof t == "number"))
+    return Ct(e, t);
+  if (typeof e == "string" && typeof t == "string")
+    return e < t ? -1 : e > t ? 1 : 0;
+  if (typeof e == "boolean" && typeof t == "boolean")
+    return e === t ? 0 : e ? 1 : -1;
+  if (e instanceof A && t instanceof A || e instanceof I && t instanceof I)
+    return e.compareTo(t);
+  if (B(e) && B(t))
+    return ye(e, t);
+  throw new a("Cannot compare values of different types");
+}
+function lt(e, t) {
+  for (const n of e)
+    if (j(n, t))
       return !0;
   return !1;
 }
-const Z = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
+const pi = /* @__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
+  LIMIT: D,
+  SPAN: ze,
+  asBool: cn,
+  asBytes: ft,
+  asDouble: T,
+  asDuration: hn,
+  asInt: g,
+  asString: O,
+  asUInt: on,
+  codePointCount: ht,
+  compare: v,
+  contains: ot,
+  containsInArray: lt,
+  dateOf: fn,
+  deepEquals: He,
+  duration: Ke,
+  equals: j,
+  has: un,
+  hoursOf: dn,
+  isMap: We,
+  limit: q,
+  matches: St,
+  max: xt,
+  millisecondsOf: bn,
+  min: kt,
+  minutesOf: wn,
+  monthOf: ln,
+  offsetByCodePoints: Tt,
+  order: Ct,
+  ordinalOf: En,
+  secondsOf: gn,
+  select: an,
+  sizeOf: Lt,
+  timestamp: Dt,
+  typeOf: W,
+  weekdayOf: mn,
+  yearOf: pn
 }, Symbol.toStringTag, { value: "Module" }));
-class k {
-  callFunction(t, e) {
+function Z(e, t, n) {
+  if (t < 0n || t > BigInt(ht(e)))
+    throw new a(`${n}() index out of range: ${t}`);
+  return Tt(e, Number(t));
+}
+function Ot(e, t) {
+  return t < 0 ? -1n : BigInt(ht(e.substring(0, t)));
+}
+function In(e, t) {
+  const n = Z(e, t, "charAt");
+  return n === e.length ? "" : String.fromCodePoint(e.codePointAt(n));
+}
+function An(e, t, n = 0n) {
+  return Ot(e, e.indexOf(t, Z(e, n, "indexOf")));
+}
+function yn(e, t, n) {
+  return n === void 0 ? Ot(e, e.lastIndexOf(t)) : Ot(e, e.lastIndexOf(t, Z(e, n, "lastIndexOf")));
+}
+function Nn(e) {
+  return e.replace(/[A-Z]/g, (t) => String.fromCharCode(t.charCodeAt(0) + 32));
+}
+function Ln(e) {
+  return e.replace(/[a-z]/g, (t) => String.fromCharCode(t.charCodeAt(0) - 32));
+}
+function Sn(e, t, n) {
+  if (n === void 0)
+    return e.substring(Z(e, t, "substring"));
+  if (t > n)
+    throw new a(`substring() range out of bounds: ${t}:${n}`);
+  return e.substring(Z(e, t, "substring"), Z(e, n, "substring"));
+}
+function On(e) {
+  return Array.from(e).reverse().join("");
+}
+function $n(e, t, n, i = -1n) {
+  if (i === 0n || t === "")
+    return e;
+  let r = "", s = 0, c = 0n;
+  for (; i < 0n || c < i; ) {
+    const u = e.indexOf(t, s);
+    if (u < 0)
+      break;
+    r += e.substring(s, u) + n, q(r.length, "replace()"), s = u + t.length, c++;
+  }
+  return r += e.substring(s), q(r.length, "replace()"), r;
+}
+function Rn(e, t, n = -1n) {
+  if (n === 0n)
+    return [];
+  let i;
+  if (t === "" ? i = e === "" ? [""] : [...e.split(""), ""] : i = e.split(t), n > 0n && BigInt(i.length) > n) {
+    const r = Number(n) - 1;
+    i = [...i.slice(0, r), i.slice(r).join(t)];
+  }
+  return i;
+}
+function Mn(e, t) {
+  let n = Math.max(0, e.length - 1) * t.length;
+  for (const r of e) {
+    if (typeof r != "string")
+      throw new a("join() requires a list of strings");
+    n += r.length, q(n, "join()");
+  }
+  let i = "";
+  for (const r of e)
+    i.length > 0 && (i += t), i += r;
+  return i;
+}
+function Cn(e, t) {
+  let n = "", i = 0, r = 0;
+  for (; r < e.length; ) {
+    const s = e[r];
+    if (s !== "%") {
+      n += s, r++;
+      continue;
+    }
+    if (r + 1 >= e.length)
+      throw new a("format() has a trailing '%'");
+    if (e[r + 1] === "%") {
+      n += "%", r += 2;
+      continue;
+    }
+    let c = -1, u = r + 1;
+    if (e[u] === ".") {
+      u++;
+      const d = u;
+      for (; u < e.length && e[u] >= "0" && e[u] <= "9"; )
+        u++;
+      if (u === d)
+        throw new a("format() precision requires digits");
+      c = Xe(e.substring(d, u));
+    }
+    if (u >= e.length)
+      throw new a("format() has an incomplete verb");
+    if (i >= t.length)
+      throw new a("format() has more verbs than arguments");
+    if (n += Ve(e[u], c, t[i]), n.length > D)
+      throw new l(
+        `format() output exceeds the evaluation limit of ${D}`
+      );
+    i++, r = u + 1;
+  }
+  if (i !== t.length)
+    throw new a("format() has more arguments than verbs");
+  return n;
+}
+function Xe(e) {
+  const t = e.length > 18 ? 1 / 0 : Number(e);
+  if (t > D)
+    throw new l(
+      `format() precision exceeds the evaluation limit of ${D}`
+    );
+  return t;
+}
+function Ve(e, t, n) {
+  switch (e) {
+    case "s":
+      return O(n);
+    case "d":
+      return g(n).toString();
+    case "f":
+      return ct(T(n), t < 0 ? 6 : t);
+    case "e":
+      return Ze(T(n), t < 0 ? 6 : t);
+    case "b":
+      return typeof n == "boolean" ? String(n) : $t(g(n), 2);
+    case "o":
+      return $t(g(n), 8);
+    case "x":
+      return tn(n, !1);
+    case "X":
+      return tn(n, !0);
+    default:
+      throw new a(`format() has an unknown verb: %${e}`);
+  }
+}
+function $t(e, t) {
+  return BigInt.asUintN(64, e).toString(t);
+}
+function ct(e, t) {
+  if (!Number.isFinite(e))
+    throw new a(`Cannot format non-finite value: ${e}`);
+  const n = e < 0, [i, r] = Math.abs(e).toExponential().split("e"), s = i.replace(".", ""), c = s.length - 1 - Number(r);
+  let u = BigInt(s);
+  if (c <= t)
+    u *= 10n ** BigInt(t - c);
+  else {
+    const L = 10n ** BigInt(c - t), k = u / L;
+    u = u % L * 2n >= L ? k + 1n : k;
+  }
+  const d = u.toString().padStart(t + 1, "0"), E = d.substring(0, d.length - t), b = d.substring(d.length - t), N = t > 0 ? `${E}.${b}` : E;
+  return n && u !== 0n ? `-${N}` : N;
+}
+function Ze(e, t) {
+  if (e === 0)
+    return ct(0, t) + "e+00";
+  if (!Number.isFinite(e))
+    throw new a(`Cannot format non-finite value: ${e}`);
+  const n = Math.floor(Math.log10(Math.abs(e))), i = e / Math.pow(10, n), r = n < 0 ? "-" : "+", s = Math.abs(n);
+  return `${ct(i, t)}e${r}${s < 10 ? "0" : ""}${s}`;
+}
+function tn(e, t) {
+  let n;
+  return B(e) ? n = yt(e) : typeof e == "string" ? n = yt(Mt(e)) : n = $t(g(e), 16), t ? n.toUpperCase() : n;
+}
+function Un(e) {
+  let t = "";
+  for (let n = 0; n < e.length; n++) {
+    const i = e[n], r = e.charCodeAt(n);
+    switch (i) {
+      case "\\":
+        t += "\\\\";
+        break;
+      case '"':
+        t += '\\"';
+        break;
+      case `
+`:
+        t += "\\n";
+        break;
+      case "\r":
+        t += "\\r";
+        break;
+      case "	":
+        t += "\\t";
+        break;
+      case "\b":
+        t += "\\b";
+        break;
+      case "\f":
+        t += "\\f";
+        break;
+      case "\x07":
+        t += "\\a";
+        break;
+      case "\v":
+        t += "\\v";
+        break;
+      default:
+        r < 32 || r === 127 ? t += "\\u" + r.toString(16).padStart(4, "0") : t += i;
+    }
+  }
+  return t;
+}
+function Pt(e) {
+  return `"${Un(e)}"`;
+}
+function Bn(e) {
+  let t = "";
+  for (const n of e)
+    switch (n) {
+      case 92:
+        t += "\\\\";
+        break;
+      case 34:
+        t += '\\"';
+        break;
+      case 10:
+        t += "\\n";
+        break;
+      case 13:
+        t += "\\r";
+        break;
+      case 9:
+        t += "\\t";
+        break;
+      default:
+        n < 32 || n >= 127 ? t += "\\x" + n.toString(16).padStart(2, "0") : t += String.fromCharCode(n);
+    }
+  return t;
+}
+const di = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
+  __proto__: null,
+  charAt: In,
+  escape: Un,
+  escapeBytes: Bn,
+  fixed: ct,
+  format: Cn,
+  indexOf: An,
+  join: Mn,
+  lastIndexOf: yn,
+  lower: Nn,
+  quote: Pt,
+  replace: $n,
+  reverse: On,
+  split: Rn,
+  substring: Sn,
+  upper: Ln
+}, Symbol.toStringTag, { value: "Module" }));
+function pt(e, t) {
+  try {
+    return new RegExp(e, t);
+  } catch {
+    throw new a(`Invalid regular expression: ${e}`);
+  }
+}
+function dt(e) {
+  return pt(e, ""), new RegExp(`${e}|`).exec("").length - 1;
+}
+function Tn(e, t, n, i = -1n) {
+  const r = pt(t, "g"), s = Je(n, dt(t), t);
+  let c = "", u = 0, d = 0n, E;
+  for (; (E = r.exec(e)) !== null && !(i >= 0n && d >= i); )
+    c += e.substring(u, E.index) + ve(s, E), q(c.length, "regex.replace()"), u = E.index + E[0].length, E[0].length === 0 && r.lastIndex++, d++;
+  return c += e.substring(u), q(c.length, "regex.replace()"), c;
+}
+function Dn(e, t) {
+  const n = dt(t);
+  if (n > 1)
+    throw new a(`extract() supports at most one capture group: ${t}`);
+  const i = pt(t, "").exec(e);
+  return i === null ? null : n === 1 ? i[1] ?? null : i[0];
+}
+function xn(e, t) {
+  const n = dt(t);
+  if (n > 1)
+    throw new a(`extractAll() supports at most one capture group: ${t}`);
+  const i = pt(t, "g"), r = [];
+  let s;
+  for (; (s = i.exec(e)) !== null; ) {
+    const c = n === 1 ? s[1] : s[0];
+    c !== void 0 && r.push(c), s[0].length === 0 && i.lastIndex++;
+  }
+  return r;
+}
+function Je(e, t, n) {
+  const i = [];
+  let r = "", s = 0;
+  for (; s < e.length; ) {
+    const c = e[s];
+    if (c === "\\" && s + 1 < e.length) {
+      const u = e[s + 1];
+      if (u >= "0" && u <= "9") {
+        const d = u.charCodeAt(0) - 48;
+        if (d > t)
+          throw new a(
+            `Replacement refers to group ${d} but ${n} has ${t}`
+          );
+        r.length > 0 && (i.push({ text: r }), r = ""), i.push({ group: d });
+      } else
+        r += "\\" + u;
+      s += 2;
+    } else
+      r += c, s++;
+  }
+  return r.length > 0 && i.push({ text: r }), i;
+}
+function ve(e, t) {
+  let n = "";
+  for (const i of e)
+    "text" in i ? n += i.text : n += t[i.group] ?? "";
+  return n;
+}
+const wi = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
+  __proto__: null,
+  extract: Dn,
+  extractAll: xn,
+  groupCount: dt,
+  replace: Tn
+}, Symbol.toStringTag, { value: "Module" }));
+function kn(e) {
+  const t = new sn(), n = [];
+  for (const i of e)
+    t.add(i) && n.push(i);
+  return n;
+}
+function Gt(e, t = 1n) {
+  if (t < 1n)
+    throw new a("flatten() depth must be at least 1");
+  const n = [];
+  for (const i of e)
+    Array.isArray(i) ? n.push(...t > 1n ? Gt(i, t - 1n) : i) : n.push(i);
+  return n;
+}
+function Pn(e) {
+  return [...e].reverse();
+}
+function Gn(e, t, n) {
+  if (t < 0n || n > BigInt(e.length) || t > n)
+    throw new a(`slice() range out of bounds: ${t}:${n}`);
+  return e.slice(Number(t), Number(n));
+}
+function qn(e) {
+  return [...e].sort(v);
+}
+function Fn(e) {
+  if (e.length === 0)
+    throw new a("first() requires a non-empty list");
+  return e[0];
+}
+function jn(e) {
+  if (e.length === 0)
+    throw new a("last() requires a non-empty list");
+  return e[e.length - 1];
+}
+function Qn(e) {
+  if (e > BigInt(D))
+    throw new l(`range() exceeds the evaluation limit of ${D}`);
+  const t = [];
+  for (let n = 0n; n < e; n++)
+    t.push(n);
+  return t;
+}
+function ti(e, t) {
+  return lt(e, t);
+}
+const gi = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
+  __proto__: null,
+  contains: ti,
+  distinct: kn,
+  first: Fn,
+  flatten: Gt,
+  last: jn,
+  range: Qn,
+  reverse: Pn,
+  slice: Gn,
+  sort: qn
+}, Symbol.toStringTag, { value: "Module" }));
+function zn(e) {
+  const t = new sn();
+  for (const n of e)
+    t.add(n);
+  return t;
+}
+function ut(e, t) {
+  const n = zn(e);
+  return t.every((i) => n.has(i));
+}
+function Yn(e, t) {
+  return ut(e, t) && ut(t, e);
+}
+function _n(e, t) {
+  const n = zn(e);
+  return t.some((i) => n.has(i));
+}
+const bi = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
+  __proto__: null,
+  contains: ut,
+  equivalent: Yn,
+  intersects: _n
+}, Symbol.toStringTag, { value: "Module" }));
+function Wn(e) {
+  return e.length === 1 && Array.isArray(e[0]) ? e[0] : e;
+}
+function Kn(e) {
+  return xt(Wn(e));
+}
+function Hn(e) {
+  return kt(Wn(e));
+}
+function Xn(e) {
+  if (typeof e == "number")
+    return Math.abs(e);
+  const t = g(e);
+  if (t === K)
+    throw new l("Integer overflow");
+  return t < 0n ? -t : t;
+}
+function Vn(e) {
+  return Math.ceil(T(e));
+}
+function Zn(e) {
+  return Math.floor(T(e));
+}
+function Jn(e) {
+  const t = T(e);
+  return t < 0 ? -Math.round(-t) : Math.round(t);
+}
+function vn(e) {
+  const t = T(e);
+  return t < 0 ? Math.ceil(t) : Math.floor(t);
+}
+function te(e) {
+  if (typeof e == "number")
+    return Math.sign(e);
+  const t = g(e);
+  return t < 0n ? -1n : t > 0n ? 1n : 0n;
+}
+function ne(e) {
+  return Math.sqrt(T(e));
+}
+function ee(e) {
+  return Number.isNaN(T(e));
+}
+function ie(e) {
+  const t = T(e);
+  return t === 1 / 0 || t === -1 / 0;
+}
+function re(e) {
+  return Number.isFinite(T(e));
+}
+function se(e, t) {
+  return BigInt.asIntN(64, g(e) & g(t));
+}
+function oe(e, t) {
+  return BigInt.asIntN(64, g(e) | g(t));
+}
+function ce(e, t) {
+  return BigInt.asIntN(64, g(e) ^ g(t));
+}
+function ue(e) {
+  return BigInt.asIntN(64, ~g(e));
+}
+function ae(e) {
+  const t = g(e);
+  if (t < 0n)
+    throw new a(`Shift count must not be negative: ${t}`);
+  return t;
+}
+function he(e, t) {
+  const n = ae(t);
+  return n >= 64n ? 0n : BigInt.asIntN(64, g(e) << n);
+}
+function fe(e, t) {
+  const n = ae(t);
+  return n >= 64n ? 0n : BigInt.asIntN(64, BigInt.asUintN(64, g(e)) >> n);
+}
+const mi = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
+  __proto__: null,
+  abs: Xn,
+  and: se,
+  ceil: Vn,
+  floor: Zn,
+  greatest: Kn,
+  isFinite: re,
+  isInf: ie,
+  isNaN: ee,
+  least: Hn,
+  left: he,
+  not: ue,
+  or: oe,
+  right: fe,
+  round: Jn,
+  sign: te,
+  sqrt: ne,
+  trunc: vn,
+  xor: ce
+}, Symbol.toStringTag, { value: "Module" })), P = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/", ni = new Map(Array.from(P, (e, t) => [e, t]));
+function le(e) {
+  const t = ft(e);
+  q(4 * Math.ceil(t.length / 3), "base64.encode()");
+  let n = "", i = 0;
+  for (; i + 2 < t.length; i += 3) {
+    const s = t[i] << 16 | t[i + 1] << 8 | t[i + 2];
+    n += P[s >> 18] + P[s >> 12 & 63] + P[s >> 6 & 63] + P[s & 63];
+  }
+  const r = t.length - i;
+  if (r === 1) {
+    const s = t[i] << 16;
+    n += P[s >> 18] + P[s >> 12 & 63] + "==";
+  } else if (r === 2) {
+    const s = t[i] << 16 | t[i + 1] << 8;
+    n += P[s >> 18] + P[s >> 12 & 63] + P[s >> 6 & 63] + "=";
+  }
+  return n;
+}
+function qt(e) {
+  if (typeof e != "string")
+    throw new a("base64.decode() requires string arguments");
+  let t = e, n = 0;
+  for (; t.endsWith("=") && n < 2; )
+    t = t.substring(0, t.length - 1), n++;
+  const i = t.length % 4;
+  if (t.includes("=") || i === 1 || n > 0 && (i === 0 || n !== 4 - i))
+    throw new a(`Invalid base64 input: ${e}`);
+  const r = [];
+  let s = 0, c = 0;
+  for (const u of t) {
+    const d = ni.get(u);
+    if (d === void 0)
+      throw new a(`Invalid base64 input: ${e}`);
+    s = (s << 6 | d) & 65535, c += 6, c >= 8 && (c -= 8, r.push(s >> c & 255));
+  }
+  return Uint8Array.from(r);
+}
+function ei(e) {
+  return en(qt(e));
+}
+const Ei = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
+  __proto__: null,
+  decode: qt,
+  encode: le,
+  text: ei
+}, Symbol.toStringTag, { value: "Module" })), ii = /* @__PURE__ */ new Set([
+  "math.greatest",
+  "math.least",
+  "math.abs",
+  "math.ceil",
+  "math.floor",
+  "math.round",
+  "math.trunc",
+  "math.sign",
+  "math.sqrt",
+  "math.isNaN",
+  "math.isInf",
+  "math.isFinite",
+  "math.bitAnd",
+  "math.bitOr",
+  "math.bitXor",
+  "math.bitNot",
+  "math.bitShiftLeft",
+  "math.bitShiftRight",
+  "sets.contains",
+  "sets.equivalent",
+  "sets.intersects",
+  "base64.encode",
+  "base64.decode",
+  "lists.range",
+  "strings.quote",
+  "regex.replace",
+  "regex.extract",
+  "regex.extractAll"
+]), ri = /* @__PURE__ */ new Set(["map", "filter", "all", "exists", "existsOne", "sortBy"]), si = /* @__PURE__ */ new Set([
+  "getDate",
+  "getMonth",
+  "getFullYear",
+  "getHours",
+  "getMinutes",
+  "getSeconds",
+  "getMilliseconds",
+  "getDayOfWeek",
+  "getDayOfYear"
+]);
+function f(e, t, n, i) {
+  if (t.length < n || t.length > i)
+    throw new a(
+      `${e}() requires ${n === i ? n : `${n} to ${i}`} argument(s)`
+    );
+}
+function F(e) {
+  return e.length > 1 ? e[1] : null;
+}
+function m(e, t) {
+  if (typeof e == "string")
+    return e;
+  throw new a(`${t}() requires string arguments`);
+}
+function R(e, t) {
+  if (Array.isArray(e))
+    return e;
+  throw new a(`${t}() requires a list`);
+}
+function x(e, t, n) {
+  return f(e, t, 1, 1), n(t[0]);
+}
+function tt(e, t, n) {
+  return f(e, t, 2, 2), n(t[0], t[1]);
+}
+class pe {
+  knows(t) {
+    return ii.has(t);
+  }
+  callFunction(t, n) {
+    if (t.indexOf(".") > 0)
+      return this.callQualified(t, n);
     switch (t) {
       case "size":
-        return I(e[0]);
+        return f(t, n, 1, 1), Lt(n[0]);
       case "int":
-        return b(e[0]);
+        return f(t, n, 1, 1), g(n[0]);
       case "uint":
-        return v(e[0]);
+        return f(t, n, 1, 1), on(n[0]);
       case "double":
-        return M(e[0]);
+        return f(t, n, 1, 1), T(n[0]);
       case "string":
-        return D(e[0]);
+        return f(t, n, 1, 1), O(n[0]);
       case "bool":
-        return T(e[0]);
+        return f(t, n, 1, 1), cn(n[0]);
       case "type":
-        return x(e[0]);
+        return f(t, n, 1, 1), W(n[0]);
       case "has":
-        if (e.length !== 2)
-          throw new Error("has() requires 2 arguments");
-        return B(e[0], e[1]);
+        if (n.length !== 2)
+          throw new a("has() requires 2 arguments");
+        return un(n[0], n[1]);
       case "matches":
-        if (e.length !== 2)
-          throw new Error("matches() requires 2 arguments");
-        return G(e[0], e[1]);
+        if (n.length !== 2)
+          throw new a("matches() requires 2 arguments");
+        return St(m(n[0], t), m(n[1], t));
+      case "timestamp":
+        return f(t, n, 0, 1), Dt(n.length > 0 ? n[0] : null);
+      case "duration":
+        return f(t, n, 1, 1), hn(n[0]);
+      case "getDate":
+        return f(t, n, 1, 2), fn(n[0], F(n));
+      case "getMonth":
+        return f(t, n, 1, 2), ln(n[0], F(n));
+      case "getFullYear":
+        return f(t, n, 1, 2), pn(n[0], F(n));
+      case "getHours":
+        return f(t, n, 1, 2), dn(n[0], F(n));
+      case "getMinutes":
+        return f(t, n, 1, 2), wn(n[0], F(n));
+      case "getSeconds":
+        return f(t, n, 1, 2), gn(n[0], F(n));
+      case "getDayOfWeek":
+        return f(t, n, 1, 2), mn(n[0], F(n));
+      case "getDayOfYear":
+        return f(t, n, 1, 2), En(n[0], F(n));
+      case "getMilliseconds":
+        return f(t, n, 1, 2), bn(n[0], F(n));
+      case "bytes":
+        return f(t, n, 1, 1), ft(n[0]);
+      case "dyn":
+        return f(t, n, 1, 1), n[0];
       case "max":
-        return $(e);
+        return xt(n);
       case "min":
-        return P(e);
+        return kt(n);
       default:
-        throw new Error(`Unknown function: ${t}`);
+        throw new a(`Unknown function: ${t}`);
     }
   }
-  callMethod(t, e, i) {
+  callMethod(t, n, i) {
     if (t == null)
-      throw new Error("Cannot call method on null");
-    switch (e) {
+      throw new a("Cannot call method on null");
+    switch (n) {
       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()");
+          return lt(t, i[0]);
+        throw new a("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");
+        throw new a("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");
+        throw new a("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");
+        throw new a("toLowerCase() requires string target");
       case "toUpperCase":
         if (typeof t == "string" && i.length === 0)
           return t.toUpperCase();
-        throw new Error("toUpperCase() requires string target");
+        throw new a("toUpperCase() requires string target");
       case "trim":
         if (typeof t == "string" && i.length === 0)
           return t.trim();
-        throw new Error("trim() requires string target");
+        throw new a("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");
+        return f(n, i, 2, 3), $n(
+          m(t, n),
+          m(i[0], n),
+          m(i[1], n),
+          i.length > 2 ? g(i[2]) : -1n
+        );
       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");
+        return f(n, i, 1, 2), Rn(
+          m(t, n),
+          m(i[0], n),
+          i.length > 1 ? g(i[1]) : -1n
+        );
+      case "charAt":
+        return f(n, i, 1, 1), In(m(t, n), g(i[0]));
+      case "indexOf":
+        return f(n, i, 1, 2), An(
+          m(t, n),
+          m(i[0], n),
+          i.length > 1 ? g(i[1]) : 0n
+        );
+      case "lastIndexOf":
+        return f(n, i, 1, 2), yn(
+          m(t, n),
+          m(i[0], n),
+          i.length > 1 ? g(i[1]) : void 0
+        );
+      case "lowerAscii":
+        return f(n, i, 0, 0), Nn(m(t, n));
+      case "upperAscii":
+        return f(n, i, 0, 0), Ln(m(t, n));
+      case "substring":
+        return f(n, i, 1, 2), Sn(
+          m(t, n),
+          g(i[0]),
+          i.length > 1 ? g(i[1]) : void 0
+        );
+      case "join":
+        return f(n, i, 0, 1), Mn(R(t, n), i.length > 0 ? m(i[0], n) : "");
+      case "format":
+        return f(n, i, 1, 1), Cn(m(t, n), R(i[0], n));
+      case "matches":
+        return f(n, i, 1, 1), St(m(t, n), m(i[0], n));
+      case "reverse":
+        return f(n, i, 0, 0), Array.isArray(t) ? Pn(t) : On(m(t, n));
+      case "distinct":
+        return f(n, i, 0, 0), kn(R(t, n));
+      case "flatten":
+        return f(n, i, 0, 1), Gt(R(t, n), i.length > 0 ? g(i[0]) : 1n);
+      case "slice":
+        return f(n, i, 2, 2), Gn(
+          R(t, n),
+          g(i[0]),
+          g(i[1])
+        );
+      case "sort":
+        return f(n, i, 0, 0), qn(R(t, n));
+      case "first":
+        return f(n, i, 0, 0), Fn(R(t, n));
+      case "last":
+        return f(n, i, 0, 0), jn(R(t, n));
       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`
+        return Lt(t);
+      default:
+        if (si.has(n))
+          return f(n, i, 0, 1), this.callFunction(n, [t, ...i]);
+        if (ri.has(n))
+          throw new l(
+            `Macro function ${n} was not properly handled by the interpreter`
+          );
+        return this.callNativeMethod(t, n, i);
+    }
+  }
+  /**
+   * Dispatches a namespaced function such as `math.abs`.
+   *
+   * @throws ArgumentError if the name is unknown
+   */
+  callQualified(t, n) {
+    switch (t) {
+      case "math.greatest":
+        return Kn(n);
+      case "math.least":
+        return Hn(n);
+      case "math.abs":
+        return x(t, n, Xn);
+      case "math.ceil":
+        return x(t, n, Vn);
+      case "math.floor":
+        return x(t, n, Zn);
+      case "math.round":
+        return x(t, n, Jn);
+      case "math.trunc":
+        return x(t, n, vn);
+      case "math.sign":
+        return x(t, n, te);
+      case "math.sqrt":
+        return x(t, n, ne);
+      case "math.isNaN":
+        return x(t, n, ee);
+      case "math.isInf":
+        return x(t, n, ie);
+      case "math.isFinite":
+        return x(t, n, re);
+      case "math.bitAnd":
+        return tt(t, n, se);
+      case "math.bitOr":
+        return tt(t, n, oe);
+      case "math.bitXor":
+        return tt(t, n, ce);
+      case "math.bitNot":
+        return x(t, n, ue);
+      case "math.bitShiftLeft":
+        return tt(t, n, he);
+      case "math.bitShiftRight":
+        return tt(t, n, fe);
+      case "sets.contains":
+        return f(t, n, 2, 2), ut(R(n[0], t), R(n[1], t));
+      case "sets.equivalent":
+        return f(t, n, 2, 2), Yn(R(n[0], t), R(n[1], t));
+      case "sets.intersects":
+        return f(t, n, 2, 2), _n(R(n[0], t), R(n[1], t));
+      case "base64.encode":
+        return f(t, n, 1, 1), le(n[0]);
+      case "base64.decode":
+        return f(t, n, 1, 1), qt(m(n[0], t));
+      case "lists.range":
+        return f(t, n, 1, 1), Qn(g(n[0]));
+      case "strings.quote":
+        return f(t, n, 1, 1), Pt(m(n[0], t));
+      case "regex.replace":
+        return f(t, n, 3, 4), Tn(
+          m(n[0], t),
+          m(n[1], t),
+          m(n[2], t),
+          n.length > 3 ? g(n[3]) : -1n
         );
+      case "regex.extract":
+        return f(t, n, 2, 2), Dn(m(n[0], t), m(n[1], t));
+      case "regex.extractAll":
+        return f(t, n, 2, 2), xn(m(n[0], t), m(n[1], t));
       default:
-        return this.callNativeMethod(t, e, i);
+        throw new a(`Unknown function: ${t}`);
     }
   }
   /**
    * 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
+   * This is the last resort after every named method, the analogue of the Java
+   * library's reflective method call.
+   *
+   * @throws ArgumentError if the method doesn't exist
+   * @throws EvaluationError if the call fails
    */
-  callNativeMethod(t, e, i) {
-    if (typeof t[e] == "function")
+  callNativeMethod(t, n, i) {
+    const r = t[n];
+    if (typeof r == "function")
       try {
-        return t[e](...i);
-      } catch (n) {
-        throw new a(
-          `Invocation of method '${e}' failed: ${n instanceof Error ? n.message : String(n)}`
+        return r.apply(t, i);
+      } catch (s) {
+        throw new l(
+          `Invocation of method '${n}' failed: ${s instanceof Error ? s.message : String(s)}`
         );
       }
-    throw new Error(
-      `No such method '${e}' on type ${typeof t} with ${i.length} argument(s)`
+    throw new a(
+      `No such method '${n}' on type ${W(t)} with ${i.length} argument(s)`
     );
   }
 }
-class H {
+const oi = {
+  [h.LOGICAL_AND]: "&&",
+  [h.LOGICAL_OR]: "||"
+};
+class ci {
   /**
    * 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.
+   * @param variables Variable bindings as a plain object or Map. If null, no variables are bound.
+   * @param functions The function library. If null, StandardFunctions is used.
    */
-  constructor(t, e) {
-    this.variables = t ?? {}, this.functions = e ?? new k();
+  constructor(t, n) {
+    if (this.variables = /* @__PURE__ */ new Map(), t instanceof Map)
+      for (const [i, r] of t)
+        this.variables.set(i, Jt(r));
+    else if (t)
+      for (const [i, r] of Object.entries(t))
+        this.variables.set(i, Jt(r));
+    this.functions = n ?? new pe();
   }
   /**
    * 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) {
@@ -1024,244 +2637,418 @@ class H {
     return t.value;
   }
   visitIdentifier(t) {
-    if (!(t.name in this.variables))
-      throw new a(`Undefined variable: ${t.name}`);
-    return this.variables[t.name];
+    if (!this.variables.has(t.name)) {
+      const n = y.of(t.name);
+      if (n !== null)
+        return n;
+      throw new l(`Undefined variable: ${t.name}`);
+    }
+    return this.variables.get(t.name);
   }
   visitSelect(t) {
-    const e = t.operand !== null ? this.evaluate(t.operand) : this.variables;
-    if (e == null) {
+    const n = t.operand !== null ? this.evaluate(t.operand) : this.variables;
+    if (n == null) {
       if (t.isTest)
         return !1;
-      throw new a(`Cannot select field ${t.field} from null`);
+      throw new l(`Cannot select field ${t.field} from null`);
     }
-    if (typeof e == "object") {
+    if (n instanceof Map) {
       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];
+        return n.has(t.field);
+      if (!n.has(t.field))
+        throw new l(`Field ${t.field} not found`);
+      return n.get(t.field);
     }
-    throw new a("Cannot select field from non-object type");
+    throw new l("Cannot select field from non-map 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(
+        throw new l(`Macro ${t.functionName} requires arguments`);
+      const r = t.args[0];
+      if (!(r instanceof It))
+        throw new l(
           `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);
+        throw new l(`Macro ${t.functionName} requires an expression argument`);
+      const s = t.args.slice(1);
+      return this.evaluateMacro(i, t.functionName, r.name, s);
     }
-    const e = [];
+    const n = [];
     for (const i of t.args)
-      e.push(this.evaluate(i));
+      n.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;
+      const i = this.qualify(t.target);
+      if (i !== null) {
+        const s = `${i}.${t.functionName}`;
+        if (!this.variables.has(this.root(i)) && this.knows(s))
+          return bt(this.functions.callFunction(s, n));
+      }
+      const r = this.evaluate(t.target);
+      return bt(this.functions.callMethod(r, t.functionName, n));
+    }
+    return bt(this.functions.callFunction(t.functionName, n));
+  }
+  knows(t) {
+    return this.functions.knows?.(t) ?? !1;
+  }
+  // Flattens an identifier or a chain of selections over one into a dotted name, or null
+  qualify(t) {
+    if (t instanceof It)
+      return t.name;
+    if (t instanceof nt && t.operand !== null && !t.isTest) {
+      const n = this.qualify(t.operand);
+      return n === null ? null : `${n}.${t.field}`;
+    }
+    return null;
+  }
+  root(t) {
+    const n = t.indexOf(".");
+    return n < 0 ? t : t.substring(0, n);
+  }
+  evaluateMacro(t, n, i, r) {
+    let s;
+    if (Array.isArray(t))
+      s = t;
+    else if (t instanceof Map)
+      s = Array.from(t.keys());
+    else
+      throw new l(`Macro ${n} requires a list or map target`);
+    const c = this.variables.get(i), u = this.variables.has(i), d = (b) => {
+      this.variables.set(i, b);
+    }, E = r[0];
     try {
-      switch (e) {
+      switch (n) {
         case "map": {
-          const u = [];
-          for (const p of t)
-            this.variables[i] = p, u.push(this.evaluate(n));
-          return u;
+          const b = r.length > 1 ? r[0] : null, N = r.length > 1 ? r[1] : E, L = [];
+          for (const k of s)
+            d(k), !(b !== null && !this.test(b, n)) && L.push(this.evaluate(N));
+          return L;
         }
         case "filter": {
-          const u = [];
-          for (const p of t)
-            this.variables[i] = p, this.evaluate(n) === !0 && u.push(p);
-          return u;
+          const b = [];
+          for (const N of s)
+            d(N), this.test(E, n) && b.push(N);
+          return b;
         }
         case "all": {
-          for (const u of t)
-            if (this.variables[i] = u, this.evaluate(n) !== !0)
+          for (const b of s)
+            if (d(b), !this.test(E, n))
               return !1;
           return !0;
         }
         case "exists": {
-          for (const u of t)
-            if (this.variables[i] = u, this.evaluate(n) === !0)
+          for (const b of s)
+            if (d(b), this.test(E, n))
               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))
+          let b = 0;
+          for (const N of s)
+            if (d(N), this.test(E, n) && (b++, b > 1))
               return !1;
-          return u === 1;
+          return b === 1;
+        }
+        case "sortBy": {
+          const b = [];
+          for (const L of s)
+            d(L), b.push(this.evaluate(E));
+          const N = s.map((L, k) => k);
+          return N.sort((L, k) => v(b[L], b[k])), N.map((L) => s[L]);
         }
         default:
-          throw new a(`Unknown macro function: ${e}`);
+          throw new l(`Unknown macro function: ${n}`);
       }
     } finally {
-      l ? this.variables[i] = o : delete this.variables[i];
+      u ? this.variables.set(i, c) : this.variables.delete(i);
     }
   }
+  // Evaluates a macro predicate, which the specification requires to yield a boolean
+  test(t, n) {
+    const i = this.evaluate(t);
+    if (typeof i != "boolean")
+      throw new l(`Macro ${n} requires a boolean predicate`);
+    return i;
+  }
   visitList(t) {
-    const e = [];
+    const n = [];
     for (const i of t.elements)
-      e.push(this.evaluate(i));
-    return e;
+      n.push(this.evaluate(i));
+    return n;
   }
   visitMap(t) {
-    const e = {};
+    const n = /* @__PURE__ */ new Map();
     for (const i of t.entries) {
-      const n = this.evaluate(i.key), o = this.evaluate(i.value);
-      e[n] = o;
+      const r = this.evaluate(i.key), s = this.evaluate(i.value);
+      n.set(r, s);
     }
-    return e;
+    return n;
   }
   visitStruct(t) {
-    const e = {};
+    const n = /* @__PURE__ */ new Map();
     for (const i of t.fields)
-      e[i.field] = this.evaluate(i.value);
-    return e;
+      n.set(i.field, this.evaluate(i.value));
+    return n;
   }
   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;
+    const n = this.evaluate(t.range);
+    if (!Array.isArray(n))
+      throw new l("Comprehension range must be a list");
+    const i = this.variables.get(t.variable), r = this.variables.get(t.accumulator), s = this.variables.has(t.variable), c = this.variables.has(t.accumulator);
     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);
+      this.variables.set(t.accumulator, u);
+      for (const d of n)
+        this.variables.set(t.variable, d), this.evaluate(t.condition) === !0 && (u = this.evaluate(t.step), this.variables.set(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];
+      s ? this.variables.set(t.variable, i) : this.variables.delete(t.variable), c ? this.variables.set(t.accumulator, r) : this.variables.delete(t.accumulator);
     }
   }
   visitUnary(t) {
-    const e = this.evaluate(t.operand);
+    const n = 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;
+      case J.NOT:
+        if (typeof n != "boolean")
+          throw new l("NOT operator requires boolean operand");
+        return !n;
+      case J.NEGATE:
+        if (typeof n == "bigint") {
+          if (n === K)
+            throw new l("Integer overflow");
+          return -n;
+        }
+        if (typeof n == "number")
+          return -n;
+        if (n instanceof I)
+          return n.negated();
+        throw new l("Negation requires numeric operand");
       default:
-        throw new a(`Unknown unary operator: ${t.op}`);
+        throw new l(`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);
+    if (t.op === h.LOGICAL_AND)
+      return this.combine(t, !1);
+    if (t.op === h.LOGICAL_OR)
+      return this.combine(t, !0);
+    const n = 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;
+      case h.ADD: {
+        if (B(n) && B(i))
+          return q(n.length + i.length, "Bytes concatenation"), Ne(n, i);
+        if (n instanceof A && i instanceof I)
+          return n.plus(i);
+        if (n instanceof I && i instanceof A)
+          return i.plus(n);
+        if (n instanceof I && i instanceof I)
+          return n.plus(i);
+        if (typeof n == "string" || typeof i == "string") {
+          const r = O(n), s = O(i);
+          return q(r.length + s.length, "String concatenation"), r + s;
         }
-        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;
+        if (Array.isArray(n) && Array.isArray(i))
+          return q(n.length + i.length, "List concatenation"), [...n, ...i];
+        if (C(n) && C(i))
+          return this.arithmetic(
+            n,
+            i,
+            (r, s) => r + s,
+            (r, s) => r + s
+          );
+        throw new l("Invalid operands for addition");
+      }
+      case h.SUBTRACT: {
+        if (n instanceof A && i instanceof A)
+          return i.until(n);
+        if (n instanceof A && i instanceof I || n instanceof I && i instanceof I)
+          return n.minus(i);
+        if (C(n) && C(i))
+          return this.arithmetic(
+            n,
+            i,
+            (r, s) => r - s,
+            (r, s) => r - s
+          );
+        throw new l("Subtraction requires numeric operands");
+      }
+      case h.MULTIPLY: {
+        if (C(n) && C(i))
+          return this.arithmetic(
+            n,
+            i,
+            (r, s) => r * s,
+            (r, s) => r * s
+          );
+        if (typeof n == "string" && C(i)) {
+          const r = this.repetitions(i, n.length);
+          return n.repeat(r);
+        }
+        if (Array.isArray(n) && C(i)) {
+          const r = this.repetitions(i, n.length), s = [];
+          for (let c = 0; c < r; c++)
+            s.push(...n);
+          return s;
+        }
+        throw new l("Invalid operands for multiplication");
+      }
+      case h.DIVIDE: {
+        if (C(n) && C(i)) {
+          if (typeof n == "number" || typeof i == "number")
+            return Number(n) / Number(i);
+          if (i === 0n)
+            throw new l("Division by zero");
+          if (n === K && i === -1n)
+            throw new l("Integer overflow");
+          return n / 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 l("Division requires numeric operands");
+      }
+      case h.MODULO: {
+        if (typeof n == "bigint" && typeof i == "bigint") {
+          if (i === 0n)
+            throw new l("Modulo by zero");
+          return n % 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:
+        throw new l("Modulo requires integer operands");
+      }
+      case h.EQUAL:
+        return j(n, i);
+      case h.NOT_EQUAL:
+        return !j(n, i);
+      case h.LESS:
+        return this.compare(n, i) < 0;
+      case h.LESS_EQUAL:
+        return this.compare(n, i) <= 0;
+      case h.GREATER:
+        return this.compare(n, i) > 0;
+      case h.GREATER_EQUAL:
+        return this.compare(n, i) >= 0;
+      case h.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");
+          return lt(i, n);
+        if (i instanceof Map)
+          return ot(i, n);
+        if (typeof i == "string" && typeof n == "string")
+          return i.includes(n);
+        throw new l("IN operator requires list, map, or string on right side");
+      }
       default:
-        throw new a(`Unknown binary operator: ${t.op}`);
+        throw new l(`Unknown binary operator: ${t.op}`);
+    }
+  }
+  // Evaluates a logical operator: the absorbing value wins even when the other operand errors
+  combine(t, n) {
+    const i = this.attempt(t.left);
+    if (i === n)
+      return n;
+    const r = this.attempt(t.right);
+    if (r === n)
+      return n;
+    if (i instanceof Error)
+      throw i;
+    if (r instanceof Error)
+      throw r;
+    if (typeof i != "boolean" || typeof r != "boolean") {
+      const s = oi[t.op] ?? t.op;
+      throw new l(`Logical operator ${s} requires boolean operands`);
+    }
+    return !n;
+  }
+  // Evaluates an operand, returning the error instead of throwing it
+  attempt(t) {
+    try {
+      return this.evaluate(t);
+    } catch (n) {
+      if (zt(n))
+        return n;
+      throw n;
     }
   }
   visitConditional(t) {
-    return this.evaluate(t.condition) === !0 ? this.evaluate(t.thenExpr) : this.evaluate(t.otherwiseExpr);
+    const n = this.evaluate(t.condition);
+    if (typeof n != "boolean")
+      throw new l("Conditional requires a boolean condition");
+    return n ? 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 {
+    const n = this.evaluate(t.operand), i = this.evaluate(t.index);
+    if (n == null)
+      throw new l("Cannot index null value");
+    if (Array.isArray(n)) {
+      if (!C(i))
+        throw new l("List index must be an integer");
+      const r = Number(typeof i == "number" ? Math.trunc(i) : i);
+      if (r < 0 || r >= n.length)
+        throw new l(`List index out of bounds: ${r}`);
+      return n[r];
+    }
+    if (n instanceof Map) {
+      if (!ot(n, i))
+        throw new l(`Map key not found: ${O(i)}`);
+      return an(n, i);
+    }
+    if (B(n)) {
+      if (!C(i))
+        throw new l("Bytes index must be an integer");
+      const r = Number(typeof i == "number" ? Math.trunc(i) : i);
+      if (r < 0 || r >= n.length)
+        throw new l(`Bytes index out of bounds: ${r}`);
+      return BigInt(n[r]);
+    }
+    if (typeof n == "string") {
+      if (!C(i))
+        throw new l("String index must be an integer");
+      const r = Number(typeof i == "number" ? Math.trunc(i) : i), s = r < 0 ? -1 : Tt(n, r);
+      if (s < 0 || s >= n.length)
+        throw new l(`String index out of bounds: ${r}`);
+      return String.fromCodePoint(n.codePointAt(s));
+    }
+    throw new l(`Cannot index type: ${W(n)}`);
+  }
+  // Validates a repetition count against the evaluation limit, before anything is allocated
+  repetitions(t, n) {
+    const i = typeof t == "bigint" ? t : BigInt(Math.trunc(t));
+    if (i < 0n)
+      throw new l(`Repetition count must not be negative: ${i}`);
+    if (i > BigInt(D) || i * BigInt(n) > BigInt(D))
+      throw new l(`Repetition exceeds the evaluation limit of ${D}`);
+    return Number(i);
+  }
+  // Applies an arithmetic operator: two ints stay exact 64-bit, otherwise both become doubles
+  arithmetic(t, n, i, r) {
+    return typeof t == "bigint" && typeof n == "bigint" ? Le(i(t, n)) : r(Number(t), Number(n));
+  }
+  // Ordering for the relational operators
+  compare(t, n) {
+    if (t == null && n == null)
+      return 0;
+    if (t == null)
+      return -1;
+    if (n == null)
+      return 1;
+    if (Array.isArray(t) && Array.isArray(n)) {
+      const i = Math.min(t.length, n.length);
+      for (let r = 0; r < i; r++) {
+        const s = this.compare(t[r], n[r]);
+        if (s !== 0)
+          return s;
+      }
+      return t.length - n.length;
+    }
+    try {
+      return v(t, n);
+    } catch (i) {
+      throw zt(i) ? new l(
+        `Cannot compare types: ${W(t)} and ${W(n)}`
+      ) : i;
+    }
+  }
+}
+class ui {
   /**
    * Creates a new compiled program.
    *
@@ -1270,8 +3057,8 @@ class V {
    * @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;
+  constructor(t, n) {
+    this.ast = t, this.functions = n;
   }
   /**
    * Evaluates the compiled program with the given variables.
@@ -1290,12 +3077,12 @@ class V {
    * ```
    */
   evaluate(t = {}) {
-    return new H({ ...t }, this.functions).evaluate(this.ast);
+    return new ci(t, this.functions).evaluate(this.ast);
   }
 }
-class R {
+class Rt {
   constructor(t) {
-    this.functions = t ?? new k();
+    this.functions = t ?? new pe();
   }
   /**
    * Compiles a CEL expression using the provided function library.
@@ -1313,9 +3100,9 @@ class R {
    * const program = CEL.compile('x + y', new StandardFunctions());
    * ```
    */
-  static compile(t, e) {
-    const i = new Y(t);
-    return new V(i.parse(), e);
+  static compile(t, n) {
+    const i = new Re(t);
+    return new ui(i.parse(), n);
   }
   /**
    * Evaluates a CEL expression with the given variables using the provided function library.
@@ -1335,8 +3122,8 @@ class R {
    * const result = CEL.eval('x * 2', new StandardFunctions(), { x: 5 });
    * ```
    */
-  static eval(t, e, i) {
-    return this.compile(t, e).evaluate(i);
+  static eval(t, n, i) {
+    return this.compile(t, n).evaluate(i);
   }
   /**
    * Compiles a CEL expression into a reusable program.
@@ -1357,7 +3144,7 @@ class R {
    * ```
    */
   compile(t) {
-    return R.compile(t, this.functions);
+    return Rt.compile(t, this.functions);
   }
   /**
    * Evaluates a CEL expression with the given variables.
@@ -1379,36 +3166,291 @@ class R {
    * });
    * ```
    */
-  eval(t, e = {}) {
-    return R.eval(t, this.functions, e);
+  eval(t, n = {}) {
+    return Rt.eval(t, this.functions, n);
+  }
+}
+const it = 1, Et = 8, ai = 9;
+class et {
+  /**
+   * @param wrap Whether to break long constructs across lines
+   * @param indent The number of spaces per indentation level
+   * @param width The maximum line width before a construct is broken
+   */
+  constructor(t, n, i) {
+    this.wrap = t, this.indent = n, this.width = i;
+  }
+  /** Options for a single line rendering. */
+  static compact() {
+    return new et(!1, 0, Number.MAX_SAFE_INTEGER);
+  }
+  /** Options for a multi-line rendering indented by two spaces at a width of 100. */
+  static pretty() {
+    return new et(!0, 2, 100);
+  }
+}
+class _ {
+  constructor(t) {
+    this.options = t, this.level = 0;
+  }
+  /**
+   * Renders the given expression as CEL source.
+   *
+   * @param expr The expression to render
+   * @param options The rendering options; compact by default
+   * @returns The rendered text
+   */
+  static print(t, n = et.compact()) {
+    return new _(n).text(t);
+  }
+  static precedence(t) {
+    if (t instanceof nn)
+      return it;
+    if (t instanceof X)
+      switch (t.op) {
+        case h.LOGICAL_OR:
+          return 2;
+        case h.LOGICAL_AND:
+          return 3;
+        case h.EQUAL:
+        case h.NOT_EQUAL:
+        case h.LESS:
+        case h.LESS_EQUAL:
+        case h.GREATER:
+        case h.GREATER_EQUAL:
+        case h.IN:
+          return 4;
+        case h.ADD:
+        case h.SUBTRACT:
+          return 5;
+        case h.MULTIPLY:
+        case h.DIVIDE:
+        case h.MODULO:
+          return 6;
+      }
+    return t instanceof At ? 7 : ai;
+  }
+  static spelling(t) {
+    switch (t) {
+      case h.ADD:
+        return "+";
+      case h.SUBTRACT:
+        return "-";
+      case h.MULTIPLY:
+        return "*";
+      case h.DIVIDE:
+        return "/";
+      case h.MODULO:
+        return "%";
+      case h.EQUAL:
+        return "==";
+      case h.NOT_EQUAL:
+        return "!=";
+      case h.LESS:
+        return "<";
+      case h.LESS_EQUAL:
+        return "<=";
+      case h.GREATER:
+        return ">";
+      case h.GREATER_EQUAL:
+        return ">=";
+      case h.LOGICAL_AND:
+        return "&&";
+      case h.LOGICAL_OR:
+        return "||";
+      case h.IN:
+        return "in";
+    }
+  }
+  static decimal(t) {
+    if (!Number.isFinite(t))
+      throw new a(`Cannot render ${t} as a CEL literal`);
+    return rn(t);
+  }
+  // Renders a node without any enclosing parentheses
+  text(t) {
+    if (this.options.wrap) {
+      const n = _.print(t, et.compact());
+      if (this.level * this.options.indent + n.length <= this.options.width)
+        return n;
+    }
+    return t.accept(this);
+  }
+  // Renders a node, adding parentheses when its precedence is below the required level
+  render(t, n) {
+    const i = this.text(t);
+    return _.precedence(t) < n ? `(${i})` : i;
+  }
+  // Renders children one level deeper when wrapping
+  nested(t) {
+    const n = this.options.wrap ? 1 : 0;
+    this.level += n;
+    try {
+      return t();
+    } finally {
+      this.level -= n;
+    }
+  }
+  visitLiteral(t) {
+    const n = t.value;
+    switch (t.literalType) {
+      case $.NULL_VALUE:
+        return "null";
+      case $.BOOL:
+      case $.INT:
+        return String(n);
+      case $.UINT:
+        return `${n}u`;
+      case $.DOUBLE:
+        return _.decimal(T(n));
+      case $.STRING:
+        return Pt(O(n));
+      case $.BYTES:
+        return `b"${Bn(ft(n))}"`;
+    }
+  }
+  visitIdentifier(t) {
+    return t.name;
+  }
+  visitSelect(t) {
+    const i = `${t.operand === null ? "" : this.render(t.operand, Et)}.${t.field}`;
+    return t.isTest ? `has(${i})` : i;
+  }
+  visitCall(t) {
+    const n = t.target === null ? "" : `${this.render(t.target, Et)}.`, i = this.nested(() => t.args.map((r) => this.text(r)));
+    return `${n}${t.functionName}${this.group("(", i, ")")}`;
+  }
+  visitList(t) {
+    return this.group("[", this.parts(t.elements), "]");
+  }
+  visitMap(t) {
+    const n = this.nested(
+      () => t.entries.map((i) => `${this.text(i.key)}: ${this.text(i.value)}`)
+    );
+    return this.group("{", n, "}");
+  }
+  visitStruct(t) {
+    const n = this.nested(
+      () => t.fields.map((i) => `${i.field}: ${this.text(i.value)}`)
+    );
+    return `${t.typeName ?? ""}${this.group("{", n, "}")}`;
+  }
+  visitComprehension(t) {
+    const n = [
+      t.variable,
+      this.text(t.range),
+      t.accumulator,
+      this.text(t.initializer),
+      this.text(t.condition),
+      this.text(t.step),
+      this.text(t.result)
+    ];
+    return `__comprehension__${this.group("(", n, ")")}`;
+  }
+  visitUnary(t) {
+    return (t.op === J.NOT ? "!" : "-") + this.render(t.operand, 7);
+  }
+  visitBinary(t) {
+    const n = _.precedence(t), i = this.render(t.left, n), r = this.render(t.right, n + 1), s = _.spelling(t.op);
+    return this.options.wrap && (t.op === h.LOGICAL_AND || t.op === h.LOGICAL_OR) ? `${i}
+${this.pad(this.level)}${s} ${r}` : `${i} ${s} ${r}`;
+  }
+  visitConditional(t) {
+    const n = this.render(t.condition, it + 1), [i, r] = this.nested(() => [
+      this.render(t.thenExpr, it + 1),
+      this.render(t.otherwiseExpr, it)
+    ]);
+    if (this.options.wrap) {
+      const s = this.pad(this.level + 1);
+      return `${n}
+${s}? ${i}
+${s}: ${r}`;
+    }
+    return `${n} ? ${i} : ${r}`;
+  }
+  visitIndex(t) {
+    return `${this.render(t.operand, Et)}[${this.text(t.index)}]`;
+  }
+  parts(t) {
+    return this.nested(() => t.map((n) => this.text(n)));
+  }
+  group(t, n, i) {
+    if (!this.options.wrap || n.length === 0)
+      return `${t}${n.join(", ")}${i}`;
+    const r = this.pad(this.level + 1);
+    return `${t}
+${r}${n.join(`,
+${r}`)}
+${this.pad(this.level)}${i}`;
+  }
+  pad(t) {
+    return " ".repeat(t * this.options.indent);
   }
 }
 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
+  a as ArgumentError,
+  X as Binary,
+  h as BinaryOp,
+  Rt as CEL,
+  gt as Call,
+  Ei as Codecs,
+  hi as Comprehension,
+  nn as Conditional,
+  I as Duration,
+  l as EvaluationError,
+  me as FieldInitializer,
+  at as INT64_MAX,
+  K as INT64_MIN,
+  It as Identifier,
+  we as Index,
+  ci as Interpreter,
+  Qe as KeyMap,
+  sn as KeySet,
+  ge as ListExpression,
+  gi as Lists,
+  z as Literal,
+  $ as LiteralType,
+  be as MapEntry,
+  jt as MapExpression,
+  mi as Maths,
+  U as ParseError,
+  Re as Parser,
+  _ as Printer,
+  et as PrinterOptions,
+  ui as Program,
+  wi as Regexes,
+  nt as Select,
+  bi as Sets,
+  pe as StandardFunctions,
+  di as Strings,
+  Qt as Struct,
+  A as Timestamp,
+  y as Type,
+  At as Unary,
+  J as UnaryOp,
+  pi as Utilities,
+  cn as asBool,
+  ye as bytesCompare,
+  Ae as bytesEqual,
+  yt as bytesToHex,
+  G as canonicalKey,
+  Le as checkInt64,
+  Me as civilFromDays,
+  Ne as concatBytes,
+  Bt as daysFromCivil,
+  De as fieldsOf,
+  B as isBytes,
+  li as isDouble,
+  fi as isInt,
+  C as isNumeric,
+  H as isPlainObject,
+  rn as javaDoubleToString,
+  Jt as normalize,
+  bt as normalizeResult,
+  Ct as order,
+  Se as truncateToInt64,
+  Nt as utcFields,
+  en as utf8Decode,
+  Mt as utf8Encode
 };
 //# sourceMappingURL=index.mjs.map