@tellaro/tql 3.2.0 → 4.0.0

package/dist/src/parser.js

@@ -1,5 +1,5 @@
-import { tokenizeTql as T, TYPE_HINTS as f, BOOLEAN_PREDICATE_MUTATOR_SET as N, COMPARISON_OPERATORS as k, NEGATION_SYMBOL_OPERATORS as g, MUTATORS as w, SYMBOL_LOGICAL_OPERATORS as E } from "./tokenizer.js";
-const L = 50, O = /* @__PURE__ */ new Set(["logicalOp", "paren"]), v = /* @__PURE__ */ new Map([
+import { tokenizeTql as b, TYPE_HINTS as g, BOOLEAN_PREDICATE_MUTATOR_SET as L, COMPARISON_OPERATORS as E, NEGATION_SYMBOL_OPERATORS as m, MUTATORS as S, SYMBOL_LOGICAL_OPERATORS as y, DATE_HISTOGRAM_CALENDAR_INTERVALS as A, GEO_GRID_PRECISION as O } from "./tokenizer.js";
+const C = 50, w = /* @__PURE__ */ new Set(["logicalOp", "paren"]), v = /* @__PURE__ */ new Map([
   ["any", { op: "ANY", negated: !1 }],
   ["all", { op: "ALL", negated: !1 }],
   ["none", { op: "NONE", negated: !1 }],
@@ -10,13 +10,13 @@ const L = 50, O = /* @__PURE__ */ new Set(["logicalOp", "paren"]), v = /* @__PUR
   ["!all", { op: "ALL", negated: !0 }],
   ["!none", { op: "NONE", negated: !0 }]
 ]);
-function S(o, e) {
+function G(a, e) {
   for (const [t, s] of v)
-    if (s.op === o && s.negated === e && /^[a-z_]+$/.test(t))
+    if (s.op === a && s.negated === e && /^[a-z_]+$/.test(t))
       return t;
-  throw new Error(`no word spelling for collection operator ${o} (negated=${e})`);
+  throw new Error(`no word spelling for collection operator ${a} (negated=${e})`);
 }
-const y = "Collection syntax accepted by the Rust engine only; the Python query API rejects it", _ = "Aggregation modifier on '*' accepted by the Rust engine only; the Python query API rejects it", A = /* @__PURE__ */ new Set([
+const T = "Collection syntax accepted by the Rust engine only; the Python query API rejects it", $ = "Aggregation modifier on '*' accepted by the Rust engine only; the Python query API rejects it", N = /* @__PURE__ */ new Set([
   "field",
   "mutator",
   "typeHint",
@@ -24,8 +24,60 @@ const y = "Collection syntax accepted by the Rust engine only; the Python query
   "keyword",
   "visualization",
   "collectionOp"
-]);
-class I {
+]), x = 1e9, _ = 1e4;
+function M(a) {
+  if (a === null || /^auto$/i.test(a)) return null;
+  const e = /^auto\s*\(/i.test(a) && a.endsWith(")") ? a.slice(a.indexOf("(") + 1, -1) : null;
+  if (e !== null) {
+    const s = e.trim(), r = Number(s);
+    return /^[0-9]+$/.test(s) && String(r) === s && r >= 1 && r <= _ ? null : {
+      message: `Invalid date_histogram auto bucket target '${s}': it must be a whole number from 1 to ${_}`,
+      suggestion: "Write auto(50), or omit the interval for the default of 50 buckets"
+    };
+  }
+  if (A.includes(a.toLowerCase())) return null;
+  const t = /^([0-9]+)(ms|s|m|h|d)$/.exec(a);
+  if (t) {
+    const s = Number(t[1]);
+    if (s >= 1 && s <= x) return null;
+  }
+  return /^-?[A-Za-z0-9_.]+$/.test(a) ? {
+    message: `Invalid date_histogram interval '${a}'`,
+    suggestion: `A fixed interval is a positive whole number and a unit: ms, s, m, h or d (e.g. 30s, 5m, 1h, 1d); a calendar interval is one of: ${A.join(", ")}; or auto / auto(N)`
+  } : null;
+}
+function R(a, e) {
+  if (e === null) return null;
+  const [t, s, r] = O[a];
+  return /^[0-9]+$/.test(e) && Number(e) >= t && Number(e) <= s || !/^-?[0-9.]+$/.test(e) ? null : {
+    message: `Invalid ${a} precision '${e}': it must be a whole number from ${t} to ${s}`,
+    suggestion: `Omit the precision for OpenSearch's default of ${r}`
+  };
+}
+const P = /^[-+]?(?:[0-9]+(?:\.[0-9]*)?|\.[0-9]+)(?:[eE][-+]?[0-9]+)?$/;
+function D(a) {
+  let e = null;
+  for (let t = 0; t < a.length; t++) {
+    const s = a[t];
+    if (!/^[-+]?[0-9.][0-9.eE+-]*$/.test(s)) return null;
+    if (!P.test(s) || !Number.isFinite(Number(s)))
+      return {
+        message: `Invalid range() boundary '${s}': it must be a number`,
+        suggestion: "Write range(field, 0, 1024, 65536): the field, then increasing numeric boundaries",
+        index: t
+      };
+    const r = s.replace(/^\+/, ""), i = Number(s);
+    if (e && !(i > e.value))
+      return {
+        message: `range() boundaries must be strictly increasing: '${r}' follows '${e.text}'`,
+        suggestion: "List each boundary once, smallest first",
+        index: t
+      };
+    e = { value: i, text: r };
+  }
+  return null;
+}
+class V {
   tokens;
   allTokens;
   // Including whitespace for highlighting
@@ -33,8 +85,9 @@ class I {
   errors;
   warnings;
   depth;
+  input;
   constructor(e) {
-    this.allTokens = T(e), this.tokens = this.allTokens.filter((t) => t.type !== "whitespace"), this.current = 0, this.errors = [], this.warnings = [], this.depth = 0;
+    this.input = e, this.allTokens = b(e), this.tokens = this.allTokens.filter((t) => t.type !== "whitespace"), this.current = 0, this.errors = [], this.warnings = [], this.depth = 0;
   }
   /**
    * Parse the input and return the result
@@ -49,7 +102,7 @@ class I {
         success: !0
       };
     if (this.isStatsQuery())
-      return this.checkStatsModifiers(), {
+      return this.checkStatsModifiers(), this.checkStatsBucketFunctions(), {
         ast: null,
         // Stats AST is produced by the Python/Rust parser
         tokens: this.allTokens,
@@ -92,7 +145,7 @@ class I {
    * Parse a full expression (lowest precedence)
    */
   parseExpression() {
-    if (this.depth++, this.depth > L)
+    if (this.depth++, this.depth > C)
       throw new Error("Maximum query depth exceeded");
     try {
       return this.parseOr();
@@ -227,35 +280,35 @@ class I {
     let t = this.createFieldReference(e);
     const s = this.readTypeHintSlot(t);
     t = s.field;
-    const n = [], i = [];
+    const r = [], i = [];
     for (; this.check("pipe"); )
       if (this.advance(), this.check("mutator") || this.isCatalogMutatorToken()) {
-        const r = this.advance();
-        n.push(r.value.toLowerCase()), i.push(this.parseMutatorCall(r));
+        const n = this.advance();
+        r.push(n.value.toLowerCase()), i.push(this.parseMutatorCall(n));
       } else if (this.check("field")) {
-        const r = this.advance();
-        n.push(r.value.toLowerCase()), this.addWarning(`Unknown mutator '${r.value}'`, r, "Check the mutator name spelling"), i.push(this.parseMutatorCall(r));
+        const n = this.advance();
+        r.push(n.value.toLowerCase()), this.addWarning(`Unknown mutator '${n.value}'`, n, "Check the mutator name spelling"), i.push(this.parseMutatorCall(n));
       } else {
-        const r = this.isAtEnd() ? this.previous() : this.peek();
+        const n = this.isAtEnd() ? this.previous() : this.peek();
         this.addError(
           "Expected mutator name after '|'",
-          r,
+          n,
           "MISSING_MUTATOR",
           "Add a mutator like 'lowercase', 'uppercase', 'trim', etc."
         );
         break;
       }
-    if (n.length > 0 && (t = {
+    if (r.length > 0 && (t = {
       ...t,
-      mutators: n,
+      mutators: r,
       mutatorCalls: i,
       end: this.previous().end
     }), this.check("doubleColon"))
       if (s.filled) {
-        const r = this.advance();
+        const n = this.advance();
         this.addError(
           "A field may carry only one type hint",
-          r,
+          n,
           "DUPLICATE_TYPE_HINT",
           `Write the hint once — either '${e.value}::${t.typeHint ?? "type"} | mutator' or '${e.value} | mutator::type'`
         ), (this.check("field") || this.check("typeHint") || this.check("mutator")) && this.advance();
@@ -281,7 +334,7 @@ class I {
     if (!this.check("doubleColon")) return { field: e, filled: !1 };
     this.advance();
     const t = this.isAtEnd() ? void 0 : this.peek();
-    if (t !== void 0 && f.includes(t.value.toLowerCase())) {
+    if (t !== void 0 && g.includes(t.value.toLowerCase())) {
       const s = this.advance();
       return {
         field: { ...e, typeHint: s.value.toLowerCase(), end: s.end },
@@ -300,13 +353,13 @@ class I {
       this.previous(),
       // Derived from the catalog rather than a hand-written excerpt, which had drifted
       // to six of the fifteen names and omitted the very one being rejected.
-      `Valid types: ${f.join(", ")}`
+      `Valid types: ${g.join(", ")}`
     ), { field: e, filled: !1 }) : (this.addError(
       "Expected type hint after '::'",
       this.peek(),
       "MISSING_TYPE_HINT",
       // Catalog-derived for the same reason as the warning arm, so the two cannot drift.
-      `Name a type (${f.join(", ")}), or remove the '::'`
+      `Name a type (${g.join(", ")}), or remove the '::'`
     ), { field: e, filled: !1 });
   }
   /**
@@ -324,15 +377,15 @@ class I {
     if (t === void 0)
       return this.createPlaceholderExpression(e);
     if (this.addWarning(
-      y,
+      T,
       e,
       `Write it field-first instead: field ${e.value.toLowerCase()} value`,
       "ENGINE_DIVERGENCE"
     ), !(this.check("field") || this.check("aggregation") || this.check("mutator") || this.check("typeHint"))) {
-      const n = this.isAtEnd() ? this.previous() : this.peek();
+      const r = this.isAtEnd() ? this.previous() : this.peek();
       return this.addError(
         `Expected a field name after '${e.value}'`,
-        n,
+        r,
         "MISSING_FIELD",
         `Use: ${e.value} field eq "value"`
       ), this.createPlaceholderExpression(e);
@@ -350,14 +403,14 @@ class I {
    * warning rather than being silently accepted or silently refused.
    */
   tryParseCollectionTail(e) {
-    const t = this.check("logicalOp") && this.logicalWord(this.peek()) === "NOT", s = t ? 1 : 0, n = this.peekAt(s);
-    if (n === void 0 || n.type !== "collectionOp" && n.type !== "operator") return null;
-    const i = v.get(n.value.toLowerCase());
+    const t = this.check("logicalOp") && this.logicalWord(this.peek()) === "NOT", s = t ? 1 : 0, r = this.peekAt(s);
+    if (r === void 0 || r.type !== "collectionOp" && r.type !== "operator") return null;
+    const i = v.get(r.value.toLowerCase());
     if (i === void 0 || t && i.negated) return null;
     t && this.advance();
-    const r = this.advance();
+    const n = this.advance();
     return this.finishCollection(
-      r,
+      n,
       i.op,
       i.negated || t,
       e,
@@ -368,33 +421,33 @@ class I {
    * The shared tail of both collection forms: an OPTIONAL inner comparison operator
    * (defaulting to `eq`, as both grammars do) followed by a value or a value list.
    */
-  finishCollection(e, t, s, n, i) {
-    let r = "eq";
+  finishCollection(e, t, s, r, i) {
+    let n = "eq";
     if (this.check("operator")) {
-      const h = this.advance();
-      r = this.normalizeOperator(h.value), this.addWarning(
-        y,
-        h,
-        `Drop the '${h.value}': the Python parser accepts only field ${e.value.toLowerCase()} value`,
+      const l = this.advance();
+      n = this.normalizeOperator(l.value), this.addWarning(
+        T,
+        l,
+        `Drop the '${l.value}': the Python parser accepts only field ${e.value.toLowerCase()} value`,
         "ENGINE_DIVERGENCE"
       );
     }
-    const u = this.check("bracket") && this.peek().value === "[" ? this.parseValueList() : this.parseValue(), a = this.previous().end;
+    const h = this.check("bracket") && this.peek().value === "[" ? this.parseValueList() : this.parseValue(), o = this.previous().end;
     return {
       type: "collection",
       operator: t,
       negated: s,
-      field: n,
+      field: r,
       condition: {
         type: "comparison",
-        field: n,
-        operator: r,
-        value: u,
-        start: n.start,
-        end: a
+        field: r,
+        operator: n,
+        value: h,
+        start: r.start,
+        end: o
       },
       start: i,
-      end: a
+      end: o
     };
   }
   /**
@@ -404,10 +457,10 @@ class I {
    * user typed rather than the normalised reference.
    */
   parseComparisonTail(e, t) {
-    const s = t.mutators ?? [], n = this.consumeNegationPrefix();
+    const s = t.mutators ?? [], r = this.consumeNegationPrefix();
     if (!this.check("operator")) {
-      const a = s.length > 0 ? s[s.length - 1] : null;
-      if (n === null && a !== null && N.has(a))
+      const o = s.length > 0 ? s[s.length - 1] : null;
+      if (r === null && o !== null && L.has(o))
         return {
           type: "comparison",
           field: t,
@@ -422,10 +475,10 @@ class I {
           start: t.start,
           end: t.end
         };
-      const h = this.isAtEnd() ? this.previous() : this.peek(), p = s.length > 0 ? `'${e.value}' with mutator` : `'${e.value}'`;
+      const l = this.isAtEnd() ? this.previous() : this.peek(), u = s.length > 0 ? `'${e.value}' with mutator` : `'${e.value}'`;
       return this.addError(
-        `Expected operator after field ${p}`,
-        h,
+        `Expected operator after field ${u}`,
+        l,
         "MISSING_OPERATOR",
         "Add an operator like 'eq', 'contains', '=', etc."
       ), {
@@ -450,21 +503,21 @@ class I {
       "INVALID_OPERATOR",
       "Use '=' or 'eq' for equality"
     );
-    let r = this.normalizeOperator(i.value);
-    if (n !== null) {
-      const a = this.negateOperator(r);
-      a === null ? this.addError(
-        `'${n.value} ${i.value}' is not a TQL operator`,
-        n,
+    let n = this.normalizeOperator(i.value);
+    if (r !== null) {
+      const o = this.negateOperator(n);
+      o === null ? this.addError(
+        `'${r.value} ${i.value}' is not a TQL operator`,
+        r,
         "INVALID_OPERATOR",
-        `'${r}' has no negated form; use 'ne' or negate the whole expression: not (field ${r} value)`
-      ) : r = a;
+        `'${n}' has no negated form; use 'ne' or negate the whole expression: not (field ${n} value)`
+      ) : n = o;
     }
-    if (r === "is" && this.check("logicalOp") && this.logicalWord(this.peek()) === "NOT" && (this.advance(), r = "is_not"), r === "exists" || r === "not_exists")
+    if (n === "is" && this.check("logicalOp") && this.logicalWord(this.peek()) === "NOT" && (this.advance(), n = "is_not"), n === "exists" || n === "not_exists")
       return {
         type: "comparison",
         field: t,
-        operator: r,
+        operator: n,
         value: {
           type: "literal",
           valueType: "boolean",
@@ -475,78 +528,78 @@ class I {
         start: t.start,
         end: i.end
       };
-    if ((r === "is" || r === "is_not") && this.check("null")) {
-      const a = this.advance();
+    if ((n === "is" || n === "is_not") && this.check("null")) {
+      const o = this.advance();
       return {
         type: "comparison",
         field: t,
-        operator: r,
+        operator: n,
         value: {
           type: "literal",
           valueType: "null",
           value: null,
-          start: a.start,
-          end: a.end
+          start: o.start,
+          end: o.end
         },
         start: t.start,
-        end: a.end
+        end: o.end
       };
     }
-    if (/^(not_)?in(_cs)?$/.test(r)) {
-      const a = this.parseValueList();
+    if (/^(not_)?in(_cs)?$/.test(n)) {
+      const o = this.parseValueList();
       return {
         type: "comparison",
         field: t,
-        operator: r,
-        value: a,
+        operator: n,
+        value: o,
         start: t.start,
         end: this.previous().end
       };
     }
-    if (r === "between" || r === "not_between") {
+    if (n === "between" || n === "not_between") {
       if (this.check("bracket") && this.peek().value === "[") {
-        const p = this.peek(), c = this.parseValueList();
+        const u = this.peek(), c = this.parseValueList();
         return c.length !== 2 && this.addError(
-          `'${r}' needs exactly 2 values, got ${c.length}`,
-          p,
+          `'${n}' needs exactly 2 values, got ${c.length}`,
+          u,
           "INVALID_VALUE",
-          `Use: field ${r} [low, high]  or  field ${r} low AND high`
+          `Use: field ${n} [low, high]  or  field ${n} low AND high`
         ), {
           type: "comparison",
           field: t,
-          operator: r,
+          operator: n,
           value: c,
           start: t.start,
           end: this.previous().end
         };
       }
-      const a = this.parseValue();
+      const o = this.parseValue();
       this.matchLogicalWord("AND") || this.addError(
         "Expected 'AND' between values in 'between' operator",
         this.isAtEnd() ? this.previous() : this.peek(),
         "INVALID_SYNTAX",
         "Use format: field between value1 AND value2"
       );
-      const h = this.parseValue();
+      const l = this.parseValue();
       return {
         type: "comparison",
         field: t,
-        operator: r,
-        value: [a, h],
+        operator: n,
+        value: [o, l],
         start: t.start,
-        end: h.end
+        end: l.end
       };
     }
     if (this.isAtEnd())
       return this.addError(
-        `Expected a value after operator '${r}'`,
+        `Expected a value after operator '${n}'`,
         i,
         "MISSING_VALUE",
         'Add a value like "text", 123, or true'
       ), {
         type: "comparison",
         field: t,
-        operator: r,
+        operator: n,
         value: {
           type: "literal",
           valueType: "string",
@@ -557,14 +610,14 @@ class I {
         start: t.start,
         end: i.end
       };
-    const u = this.parseValue();
+    const h = this.parseValue();
     return {
       type: "comparison",
       field: t,
-      operator: r,
-      value: u,
+      operator: n,
+      value: h,
       start: t.start,
-      end: u.end
+      end: h.end
     };
   }
   /**
@@ -680,9 +733,9 @@ class I {
       return { name: t, args: s, parenthesized: !1, start: e.start, end: e.end };
     if (this.advance(), !(this.check("paren") && this.peek().value === ")"))
       for (; ; ) {
-        const n = this.parseMutatorArgument(t);
-        if (n === null) break;
-        if (s.push(n), this.check("comma")) {
+        const r = this.parseMutatorArgument(t);
+        if (r === null) break;
+        if (s.push(r), this.check("comma")) {
           this.advance();
           continue;
         }
@@ -703,11 +756,11 @@ class I {
    */
   parseMutatorArgument(e) {
     const t = this.isAtEnd() ? this.previous() : this.peek();
-    if (A.has(t.type) && this.peekAt(1)?.type === "operator" && this.peekAt(1)?.value === "=") {
-      const n = this.advance();
+    if (N.has(t.type) && this.peekAt(1)?.type === "operator" && this.peekAt(1)?.value === "=") {
+      const r = this.advance();
       this.advance();
       const i = this.parseMutatorArgumentValue(e);
-      return i === null ? null : { name: n.value, ...i, start: n.start, end: i.end };
+      return i === null ? null : { name: r.value, ...i, start: r.start, end: i.end };
     }
     const s = this.parseMutatorArgumentValue(e);
     return s === null ? null : s;
@@ -736,7 +789,7 @@ class I {
       const s = this.advance();
       return { valueType: "null", value: null, start: s.start, end: s.end };
     }
-    if (A.has(t.type) && !this.isAtEnd()) {
+    if (N.has(t.type) && !this.isAtEnd()) {
       const s = this.advance();
       return { valueType: "identifier", value: s.value, start: s.start, end: s.end };
     }
@@ -806,7 +859,7 @@ class I {
    */
   negateOperator(e) {
     const t = `not_${e}`;
-    return k.includes(t) ? t : null;
+    return E.includes(t) ? t : null;
   }
   normalizeOperator(e) {
     const t = e.toLowerCase(), s = {
@@ -819,14 +872,14 @@ class I {
     };
     if (e in s)
       return s[e];
-    if (t in g)
-      return g[t];
-    const n = {
+    if (t in m)
+      return m[t];
+    const r = {
       regex: "regexp",
       starts_with: "startswith",
       ends_with: "endswith"
     };
-    return t in n ? n[t] : (k.includes(t), t);
+    return t in r ? r[t] : (E.includes(t), t);
   }
   isAtEnd() {
     return this.current >= this.tokens.length;
@@ -858,7 +911,7 @@ class I {
   isCatalogMutatorToken() {
     if (this.isAtEnd()) return !1;
     const e = this.peek();
-    return e.type !== "collectionOp" && e.type !== "aggregation" ? !1 : w.includes(e.value.toLowerCase());
+    return e.type !== "collectionOp" && e.type !== "aggregation" ? !1 : S.includes(e.value.toLowerCase());
   }
   match(...e) {
     for (const t of e)
@@ -878,7 +931,7 @@ class I {
    * source text, which the highlighting and completion surfaces read.
    */
   logicalWord(e) {
-    return E[e.value] ?? e.value.toUpperCase();
+    return y[e.value] ?? e.value.toUpperCase();
   }
   /**
    * Match the WORD spelling of a logical operator only, never the symbol.
@@ -889,9 +942,9 @@ class I {
    * would make this package the only one of the three that does.
    */
   matchLogicalWord(e) {
-    return this.check("logicalOp") && this.peek().value.toUpperCase() === e && !(this.peek().value in E) ? (this.advance(), !0) : !1;
+    return this.check("logicalOp") && this.peek().value.toUpperCase() === e && !(this.peek().value in y) ? (this.advance(), !0) : !1;
   }
-  addError(e, t, s, n) {
+  addError(e, t, s, r) {
     this.errors.push({
       message: e,
       start: t.start,
@@ -900,10 +953,10 @@ class I {
       column: t.column,
       severity: "error",
       code: s,
-      suggestion: n
+      suggestion: r
     });
   }
-  addWarning(e, t, s, n = "TYPE_MISMATCH") {
+  addWarning(e, t, s, r = "TYPE_MISMATCH") {
     this.warnings.push({
       message: e,
       start: t.start,
@@ -911,7 +964,7 @@ class I {
       line: t.line,
       column: t.column,
       severity: "warning",
-      code: n,
+      code: r,
       suggestion: s
     });
   }
@@ -921,7 +974,7 @@ class I {
    */
   synchronize() {
     for (this.advance(); !this.isAtEnd(); ) {
-      if (O.has(this.peek().type) || this.peek().type === "paren" && this.peek().value === ")")
+      if (w.has(this.peek().type) || this.peek().type === "paren" && this.peek().value === ")")
         return;
       this.advance();
     }
@@ -982,58 +1035,114 @@ class I {
     const e = (s) => s !== void 0 && s.type === "keyword" && (s.value.toLowerCase() === "top" || s.value.toLowerCase() === "bottom");
     let t = this.tokens.length;
     for (let s = 0; s < this.tokens.length; s++) {
-      const n = this.tokens[s];
-      if (n.type === "keyword" && n.value.toLowerCase() === "by" || n.value === "=>") {
+      const r = this.tokens[s];
+      if (r.type === "keyword" && r.value.toLowerCase() === "by" || r.value === "=>") {
         t = s;
         break;
       }
     }
     for (let s = 0; s < t; s++) {
       if (this.tokens[s].type !== "aggregation") continue;
-      const n = s + 1;
-      if (n >= t || this.tokens[n].value !== "(") continue;
-      let i = 0, r = -1, u = -1, a;
-      for (let l = n; l < t; l++) {
-        const d = this.tokens[l];
-        if (d.value === "(") i++;
-        else if (d.value === ")") {
+      const r = s + 1;
+      if (r >= t || this.tokens[r].value !== "(") continue;
+      let i = 0, n = -1, h = -1, o;
+      for (let d = r; d < t; d++) {
+        const p = this.tokens[d];
+        if (p.value === "(") i++;
+        else if (p.value === ")") {
           if (i--, i === 0) {
-            r = l;
+            n = d;
             break;
           }
-        } else i === 1 && d.type === "comma" && (u === -1 && (u = l), e(this.tokens[l + 1]) && (a = this.tokens[l + 1]));
+        } else i === 1 && p.type === "comma" && (h === -1 && (h = d), e(this.tokens[d + 1]) && (o = this.tokens[d + 1]));
       }
-      if (r === -1) continue;
-      const h = this.tokens.slice(n + 1, u === -1 ? r : u), p = h.length === 0 || h.length === 1 && h[0].value === "*", c = e(this.tokens[r + 1]) ? this.tokens[r + 1] : void 0;
-      a !== void 0 && c !== void 0 && this.addError(
+      if (n === -1) continue;
+      const l = this.tokens.slice(r + 1, h === -1 ? n : h), u = l.length === 0 || l.length === 1 && l[0].value === "*", c = e(this.tokens[n + 1]) ? this.tokens[n + 1] : void 0;
+      o !== void 0 && c !== void 0 && this.addError(
         "The 'top'/'bottom' modifier is given twice on one aggregation",
         c,
         "INVALID_STATS_MODIFIER",
         "Write it once — either 'sum(x, top 10)' or 'sum(x) top 10'"
       );
-      for (const l of [a, c]) {
-        if (l === void 0) continue;
-        const d = this.tokens.indexOf(l);
-        this.tokens[d + 1]?.type !== "number" && this.addError(
-          `Expected a count after '${l.value}'`,
-          l,
+      for (const d of [o, c]) {
+        if (d === void 0) continue;
+        const p = this.tokens.indexOf(d);
+        this.tokens[p + 1]?.type !== "number" && this.addError(
+          `Expected a count after '${d.value}'`,
+          d,
           "INVALID_STATS_MODIFIER",
-          `Give the modifier a number, like '${l.value.toLowerCase()} 10'`
+          `Give the modifier a number, like '${d.value.toLowerCase()} 10'`
         );
       }
-      a !== void 0 && p && this.addError(
+      o !== void 0 && u && this.addError(
         "'*' cannot take an in-parens 'top'/'bottom' modifier",
-        a,
+        o,
         "INVALID_STATS_MODIFIER",
         "Name a field, or move the modifier outside the parentheses"
-      ), c !== void 0 && p && a === void 0 && this.addWarning(
-        _,
+      ), c !== void 0 && u && o === void 0 && this.addWarning(
+        $,
         c,
         "Name a field instead of '*', which both engines accept",
         "ENGINE_DIVERGENCE"
       );
     }
   }
+  /**
+   * Flag group-by bucket functions whose ARGUMENTS both engines refuse at parse time.
+   *
+   * Like `checkStatsModifiers`, a targeted scan rather than a stats parser: it reads each
+   * `bucketFunction` call's comma-separated arguments and applies the same argument rules as
+   * `stats_buckets.parse_date_histogram_interval` (Python) / `parse_date_histogram_interval`
+   * (Rust), with the same message text, so the editor reports what the engine will. Shapes the
+   * grammars themselves refuse (a missing field, `top N` on a bucket level) are left to the
+   * engines' ordinary syntax errors. `tests/statsBucketKinds.spec.ts` replays
+   * `validation/stats_bucket_errors.json` against this.
+   */
+  checkStatsBucketFunctions() {
+    for (let e = 0; e < this.tokens.length; e++) {
+      const t = this.tokens[e];
+      if (t.type !== "bucketFunction" || this.tokens[e + 1]?.value !== "(") continue;
+      const s = [[]];
+      let r = 0, i = !1;
+      for (let l = e + 1; l < this.tokens.length; l++) {
+        const u = this.tokens[l];
+        if (u.value === "(") {
+          if (r++, r === 1) continue;
+        } else if (u.value === ")") {
+          if (r--, r === 0) {
+            i = !0;
+            break;
+          }
+        } else if (r === 1 && u.type === "comma") {
+          s.push([]);
+          continue;
+        }
+        s[s.length - 1].push(u);
+      }
+      if (!i) continue;
+      const n = (l) => l && l.length > 0 ? this.input.slice(l[0].start, l[l.length - 1].end) : null, h = t.value.toLowerCase();
+      let o = null;
+      if (h === "date_histogram" ? o = M(n(s[1])) : (h === "geotile" || h === "geohash") && (o = R(h, n(s[1]))), o) {
+        this.addError(o.message, s[1][0], "INVALID_STATS_BUCKET", o.suggestion);
+        continue;
+      }
+      if (h === "range") {
+        const l = s.slice(1).map((c) => ({ raw: n(c), at: c[0] })), u = D(l.map((c) => c.raw ?? ""));
+        u && this.addError(u.message, l[u.index]?.at ?? t, "INVALID_STATS_BUCKET", u.suggestion);
+      } else if (h === "filters") {
+        const l = /* @__PURE__ */ new Set();
+        s.forEach((u, c) => {
+          const d = u.findIndex((k) => k.type === "keyword" && k.value.toLowerCase() === "as"), p = d >= 0 ? u[d + 1] : void 0, f = p ? String(p.value) : `filter_${c + 1}`;
+          l.has(f) && this.addError(
+            `Duplicate filters() label '${f}'`,
+            p ?? u[0] ?? t,
+            "INVALID_STATS_BUCKET",
+            "Give every filter a distinct label with `as '<label>'`"
+          ), l.add(f);
+        });
+      }
+    }
+  }
   /**
    * Check if the token stream represents a stats query.
    * Handles: "| stats ...", "stats ...", or starts with a filter before "| stats".
@@ -1058,24 +1167,27 @@ class I {
     return t >= this.tokens.length ? !1 : this.tokens[t].type === "keyword" && this.tokens[t].value.toLowerCase() === "stats";
   }
 }
-function m(o) {
-  return o ? new I(o).parse() : { ast: null, errors: [], warnings: [], tokens: [], success: !0 };
+function I(a) {
+  return a ? new V(a).parse() : { ast: null, errors: [], warnings: [], tokens: [], success: !0 };
 }
-function b(o) {
-  return m(o).success;
+function W(a) {
+  return I(a).success;
 }
-function x(o) {
-  return m(o).errors;
+function F(a) {
+  return I(a).errors;
 }
-function M(o) {
-  let e = `Error at line ${o.line}, column ${o.column}: ${o.message}`;
-  return o.suggestion && (e += ` (${o.suggestion})`), e;
+function q(a) {
+  let e = `Error at line ${a.line}, column ${a.column}: ${a.message}`;
+  return a.suggestion && (e += ` (${a.suggestion})`), e;
 }
 export {
-  I as TqlParser,
-  S as collectionOperatorSpelling,
-  M as formatParseError,
-  x as getTqlErrors,
-  b as isValidTql,
-  m as parseTql
+  V as TqlParser,
+  G as collectionOperatorSpelling,
+  M as dateHistogramIntervalProblem,
+  q as formatParseError,
+  R as geoPrecisionProblem,
+  F as getTqlErrors,
+  W as isValidTql,
+  I as parseTql,
+  D as rangeBoundariesProblem
 };