@tellaro/tql 3.3.0 → 4.0.1

package/dist/src/tokenizer.d.ts

@@ -161,6 +161,24 @@ export declare const TYPE_HINTS: TqlTypeHint[];
  * enforcement in a place a reader of this file would not think to look.
  */
 export declare const VISUALIZATION_TYPES: TqlVisualizationType[];
+/**
+ * Function-style group-by bucket levels: `| stats count() by date_histogram(@timestamp, 1h)`.
+ *
+ * A name here is a `bucketFunction` token only when the next non-space character is `(`, so a
+ * FIELD with the same name (`by date_histogram`, `range eq 5`) still lexes as a field — both
+ * engines' grammars make the same distinction. `tests/statsBucketKinds.spec.ts` reads the Rust
+ * and Python grammars and fails when this list and theirs disagree.
+ */
+export declare const GROUP_BY_BUCKET_FUNCTIONS: readonly ["date_histogram", "geotile", "geohash", "range", "filters"];
+/** `[min, max, default]` precision of each geo grid (`stats_buckets.GEO_PRECISION` in both engines). */
+export declare const GEO_GRID_PRECISION: {
+    readonly geotile: readonly [0, 29, 7];
+    readonly geohash: readonly [1, 12, 5];
+};
+/** `date_histogram` calendar intervals (`stats_buckets.CALENDAR_WORDS` in both engines). */
+export declare const DATE_HISTOGRAM_CALENDAR_INTERVALS: readonly ["minute", "hour", "day", "week", "month", "quarter", "year"];
+/** `date_histogram` fixed-interval units: a positive whole number then one of these (`30s`, `1h`). */
+export declare const DATE_HISTOGRAM_FIXED_UNITS: readonly ["ms", "s", "m", "h", "d"];
 /**
  * Keywords used in TQL.
  */
@@ -200,6 +218,8 @@ export declare class TqlTokenizer {
      * Scan an identifier (field name, operator keyword, etc.)
      */
     private scanIdentifier;
+    /** True when `value` names a group-by bucket function and the next non-space character is `(`. */
+    private isBucketFunctionCall;
     /**
      * Classify an identifier into the appropriate token type
      */

package/dist/src/tokenizer.js

@@ -125,7 +125,7 @@ const l = [
   "is_loopback",
   "is_multicast",
   "is_link_local"
-], A = new Set(
+], E = new Set(
   _
 ), f = [
   // Counting
@@ -156,7 +156,7 @@ const l = [
   "values",
   "unique",
   "distinct"
-], m = [
+], T = [
   "string",
   "str",
   "number",
@@ -173,7 +173,7 @@ const l = [
   "object",
   "geo",
   "ip"
-], T = [
+], m = [
   "bar",
   "barchart",
   "horizontal_bar",
@@ -196,23 +196,31 @@ const l = [
   "nested_donut",
   "chord",
   "auto"
-], g = ["by", "as", "null", "true", "false", "stats", "top", "bottom"];
-class w {
+], g = ["date_histogram", "geotile", "geohash", "range", "filters"], v = { geotile: [0, 29, 7], geohash: [1, 12, 5] }, I = [
+  "minute",
+  "hour",
+  "day",
+  "week",
+  "month",
+  "quarter",
+  "year"
+], S = ["ms", "s", "m", "h", "d"], w = ["by", "as", "null", "true", "false", "stats", "top", "bottom"];
+class O {
   input;
   position;
   line;
   column;
   tokens;
-  constructor(e) {
-    this.input = e ?? "", this.position = 0, this.line = 1, this.column = 1, this.tokens = [];
+  constructor(t) {
+    this.input = t ?? "", this.position = 0, this.line = 1, this.column = 1, this.tokens = [];
   }
   /**
    * Tokenize the entire input string
    */
   tokenize() {
     for (this.tokens = [], this.position = 0, this.line = 1, this.column = 1; !this.isAtEnd(); ) {
-      const e = this.scanToken();
-      e && this.tokens.push(e);
+      const t = this.scanToken();
+      t && this.tokens.push(t);
     }
     return this.tokens;
   }
@@ -222,42 +230,42 @@ class w {
   scanToken() {
     if (this.isWhitespace(this.peek()))
       return this.scanWhitespace();
-    const e = this.position, n = this.line, i = this.column, t = this.advance();
-    if ((t === "&" || t === "|") && this.peek() === t)
-      return this.advance(), this.makeToken("logicalOp", t + t, e, n, i);
-    switch (t) {
+    const t = this.position, n = this.line, i = this.column, e = this.advance();
+    if ((e === "&" || e === "|") && this.peek() === e)
+      return this.advance(), this.makeToken("logicalOp", e + e, t, n, i);
+    switch (e) {
       case "(":
       case ")":
-        return this.makeToken("paren", t, e, n, i);
+        return this.makeToken("paren", e, t, n, i);
       case "[":
       case "]":
-        return this.makeToken("bracket", t, e, n, i);
+        return this.makeToken("bracket", e, t, n, i);
       case ",":
-        return this.makeToken("comma", t, e, n, i);
+        return this.makeToken("comma", e, t, n, i);
       case "|":
-        return this.makeToken("pipe", t, e, n, i);
+        return this.makeToken("pipe", e, t, n, i);
     }
-    return t === "=" && this.peek() === ">" ? (this.advance(), this.makeToken("arrow", "=>", e, n, i)) : t === ":" && this.peek() === ":" ? (this.advance(), this.makeToken("doubleColon", "::", e, n, i)) : t === '"' || t === "'" ? this.scanString(t, e, n, i) : this.isDigit(t) || t === "-" && this.isDigit(this.peek()) ? this.scanNumber(e, n, i) : this.isOperatorChar(t) ? this.scanSymbolOperator(e, n, i) : this.isIdentifierStart(t) ? this.scanIdentifier(e, n, i) : this.makeToken("unknown", t, e, n, i);
+    return e === "=" && this.peek() === ">" ? (this.advance(), this.makeToken("arrow", "=>", t, n, i)) : e === ":" && this.peek() === ":" ? (this.advance(), this.makeToken("doubleColon", "::", t, n, i)) : e === '"' || e === "'" ? this.scanString(e, t, n, i) : this.isDigit(e) || e === "-" && this.isDigit(this.peek()) ? this.scanNumber(t, n, i) : this.isOperatorChar(e) ? this.scanSymbolOperator(t, n, i) : this.isIdentifierStart(e) ? this.scanIdentifier(t, n, i) : this.makeToken("unknown", e, t, n, i);
   }
   /**
    * Scan whitespace characters
    */
   scanWhitespace() {
-    const e = this.position, n = this.line, i = this.column;
-    let t = "";
+    const t = this.position, n = this.line, i = this.column;
+    let e = "";
     for (; !this.isAtEnd() && this.isWhitespace(this.peek()); ) {
       const s = this.advance();
-      t += s;
+      e += s;
     }
-    return this.makeToken("whitespace", t, e, n, i);
+    return this.makeToken("whitespace", e, t, n, i);
   }
   /**
    * Scan a string literal (single or double quoted)
    */
-  scanString(e, n, i, t) {
+  scanString(t, n, i, e) {
     let s = "";
-    const r = e;
-    for (; !this.isAtEnd() && this.peek() !== e; )
+    const r = t;
+    for (; !this.isAtEnd() && this.peek() !== t; )
       if (this.peek() === "\\")
         if (this.advance(), this.isAtEnd())
           s += "\\";
@@ -295,7 +303,7 @@ class w {
       start: n,
       end: this.position,
       line: i,
-      column: t,
+      column: e,
       raw: r + s
     } : (this.advance(), {
       type: "string",
@@ -303,88 +311,95 @@ class w {
       start: n,
       end: this.position,
       line: i,
-      column: t,
-      raw: e + s + e
+      column: e,
+      raw: t + s + t
     });
   }
   /**
    * Scan a numeric literal
    */
-  scanNumber(e, n, i) {
-    this.position = e, this.column = i;
-    let t = "";
-    for (this.peek() === "-" && (t += this.advance()); !this.isAtEnd() && this.isDigit(this.peek()); )
-      t += this.advance();
+  scanNumber(t, n, i) {
+    this.position = t, this.column = i;
+    let e = "";
+    for (this.peek() === "-" && (e += this.advance()); !this.isAtEnd() && this.isDigit(this.peek()); )
+      e += this.advance();
     if (this.peek() === "." && this.isDigit(this.peekNext()))
-      for (t += this.advance(); !this.isAtEnd() && this.isDigit(this.peek()); )
-        t += this.advance();
+      for (e += this.advance(); !this.isAtEnd() && this.isDigit(this.peek()); )
+        e += this.advance();
     if (this.peek() === "e" || this.peek() === "E")
-      for (t += this.advance(), (this.peek() === "+" || this.peek() === "-") && (t += this.advance()); !this.isAtEnd() && this.isDigit(this.peek()); )
-        t += this.advance();
-    return this.makeToken("number", t, e, n, i);
+      for (e += this.advance(), (this.peek() === "+" || this.peek() === "-") && (e += this.advance()); !this.isAtEnd() && this.isDigit(this.peek()); )
+        e += this.advance();
+    return this.makeToken("number", e, t, n, i);
   }
   /**
    * Scan symbol-based operators (==, !=, >, >=, <, <=, !)
    */
-  scanSymbolOperator(e, n, i) {
-    this.position = e, this.column = i;
-    let t = this.advance();
+  scanSymbolOperator(t, n, i) {
+    this.position = t, this.column = i;
+    let e = this.advance();
     if (!this.isAtEnd()) {
-      const s = t + this.peek();
+      const s = e + this.peek();
       if (s === "=>")
-        return this.advance(), this.makeToken("arrow", "=>", e, n, i);
-      (s in h || s === "==" || s === "!=") && (t = s, this.advance());
+        return this.advance(), this.makeToken("arrow", "=>", t, n, i);
+      (s in h || s === "==" || s === "!=") && (e = s, this.advance());
     }
-    if (t === "!") {
+    if (e === "!") {
       const s = this.position;
       let r = "";
       for (; !this.isAtEnd() && this.isIdentifierChar(this.peek()); )
         r += this.advance();
       if (r) {
         if ("!" + r in u)
-          return this.makeToken("operator", "!" + r, e, n, i);
+          return this.makeToken("operator", "!" + r, t, n, i);
         this.position = s, this.column = i + 1;
       }
     }
-    return t in h || t === "==" || t === "=" || t === "!=" || t === ">" || t === ">=" || t === "<" || t === "<=" ? this.makeToken("operator", t, e, n, i) : t === "!" ? this.makeToken("logicalOp", t, e, n, i) : this.makeToken("unknown", t, e, n, i);
+    return e in h || e === "==" || e === "=" || e === "!=" || e === ">" || e === ">=" || e === "<" || e === "<=" ? this.makeToken("operator", e, t, n, i) : e === "!" ? this.makeToken("logicalOp", e, t, n, i) : this.makeToken("unknown", e, t, n, i);
   }
   /**
    * Scan an identifier (field name, operator keyword, etc.)
    */
-  scanIdentifier(e, n, i) {
-    this.position = e, this.column = i;
-    let t = "";
+  scanIdentifier(t, n, i) {
+    this.position = t, this.column = i;
+    let e = "";
     const s = this.advance();
-    if (t += s, s === "@" && this.peek() === "@")
-      return this.makeToken("unknown", t, e, n, i);
+    if (e += s, s === "@" && this.peek() === "@")
+      return this.makeToken("unknown", e, t, n, i);
     let r = s;
     for (; !this.isAtEnd() && this.isIdentifierChar(this.peek()); ) {
       const c = this.advance();
       if (c === "." && r === ".")
-        return this.position--, this.column--, t = t.slice(0, -1), this.makeToken("unknown", t, e, n, i);
-      t += c, r = c;
+        return this.position--, this.column--, e = e.slice(0, -1), this.makeToken("unknown", e, t, n, i);
+      e += c, r = c;
     }
-    t.endsWith(".") && (this.position--, this.column--, t = t.slice(0, -1));
-    const a = this.classifyIdentifier(t);
-    return this.makeToken(a, t, e, n, i);
+    e.endsWith(".") && (this.position--, this.column--, e = e.slice(0, -1));
+    const a = this.isBucketFunctionCall(e) ? "bucketFunction" : this.classifyIdentifier(e);
+    return this.makeToken(a, e, t, n, i);
+  }
+  /** True when `value` names a group-by bucket function and the next non-space character is `(`. */
+  isBucketFunctionCall(t) {
+    if (!g.includes(t.toLowerCase())) return !1;
+    let n = this.position;
+    for (; n < this.input.length && /\s/.test(this.input[n]); ) n++;
+    return this.input[n] === "(";
   }
   /**
    * Classify an identifier into the appropriate token type
    */
-  classifyIdentifier(e) {
-    const n = e.toUpperCase(), i = e.toLowerCase();
-    return p.includes(n) ? "logicalOp" : d.includes(n) ? "collectionOp" : i === "true" || i === "false" ? "boolean" : i === "null" ? "null" : i === "stats" ? "keyword" : l.includes(i) ? "operator" : f.includes(i) ? "aggregation" : k.includes(i) ? "mutator" : m.includes(i) ? "typeHint" : T.includes(i) ? "visualization" : g.includes(i) ? "keyword" : "field";
+  classifyIdentifier(t) {
+    const n = t.toUpperCase(), i = t.toLowerCase();
+    return p.includes(n) ? "logicalOp" : d.includes(n) ? "collectionOp" : i === "true" || i === "false" ? "boolean" : i === "null" ? "null" : i === "stats" ? "keyword" : l.includes(i) ? "operator" : f.includes(i) ? "aggregation" : k.includes(i) ? "mutator" : T.includes(i) ? "typeHint" : m.includes(i) ? "visualization" : w.includes(i) ? "keyword" : "field";
   }
   // ============================================================================
   // Helper Methods
   // ============================================================================
-  makeToken(e, n, i, t, s) {
+  makeToken(t, n, i, e, s) {
     return {
-      type: e,
+      type: t,
       value: n,
       start: i,
       end: this.position,
-      line: t,
+      line: e,
       column: s
     };
   }
@@ -398,84 +413,88 @@ class w {
     return this.position + 1 >= this.input.length ? "\0" : this.input[this.position + 1];
   }
   advance() {
-    const e = this.input[this.position];
-    return this.position++, e === `
-` ? (this.line++, this.column = 1) : this.column++, e;
+    const t = this.input[this.position];
+    return this.position++, t === `
+` ? (this.line++, this.column = 1) : this.column++, t;
   }
-  isWhitespace(e) {
-    return e === " " || e === "	" || e === `
-` || e === "\r";
+  isWhitespace(t) {
+    return t === " " || t === "	" || t === `
+` || t === "\r";
   }
-  isDigit(e) {
-    return e >= "0" && e <= "9";
+  isDigit(t) {
+    return t >= "0" && t <= "9";
   }
-  isIdentifierStart(e) {
-    return e >= "a" && e <= "z" || e >= "A" && e <= "Z" || e === "_" || e === "@";
+  isIdentifierStart(t) {
+    return t >= "a" && t <= "z" || t >= "A" && t <= "Z" || t === "_" || t === "@";
   }
   /**
    * Check if char can continue an identifier (NOT including @ which is only valid at start)
    */
-  isIdentifierChar(e) {
-    return e >= "a" && e <= "z" || e >= "A" && e <= "Z" || e === "_" || this.isDigit(e) || e === "." || // For nested field access
-    e === "-";
+  isIdentifierChar(t) {
+    return t >= "a" && t <= "z" || t >= "A" && t <= "Z" || t === "_" || this.isDigit(t) || t === "." || // For nested field access
+    t === "-";
   }
-  isOperatorChar(e) {
-    return e === "=" || e === "!" || e === ">" || e === "<";
+  isOperatorChar(t) {
+    return t === "=" || t === "!" || t === ">" || t === "<";
   }
 }
-function O(o) {
-  return new w(o).tokenize();
+function A(o) {
+  return new O(o).tokenize();
 }
-function v(o) {
-  return O(o).filter((e) => e.type !== "whitespace");
+function R(o) {
+  return A(o).filter((t) => t.type !== "whitespace");
 }
-function E(o, e) {
+function N(o, t) {
   for (const n of o)
-    if (e >= n.start && e < n.end)
+    if (t >= n.start && t < n.end)
       return n;
   return null;
 }
-function S(o, e, n) {
-  return o.filter((i) => i.start < n && i.end > e);
+function y(o, t, n) {
+  return o.filter((i) => i.start < n && i.end > t);
 }
-function I(o, e) {
+function x(o, t) {
   let n = null;
   for (const i of o)
-    if (i.end <= e)
+    if (i.end <= t)
       n = i;
     else
       break;
   return n;
 }
-function N(o, e, n = !0) {
+function D(o, t, n = !0) {
   const i = n ? o.filter((s) => s.type !== "whitespace") : o;
-  let t = null;
+  let e = null;
   for (const s of i)
-    if (s.end <= e)
-      t = s;
+    if (s.end <= t)
+      e = s;
     else
       break;
-  return t;
+  return e;
 }
 export {
   f as AGGREGATION_FUNCTIONS,
   _ as BOOLEAN_PREDICATE_MUTATORS,
-  A as BOOLEAN_PREDICATE_MUTATOR_SET,
+  E as BOOLEAN_PREDICATE_MUTATOR_SET,
   d as COLLECTION_OPERATORS,
   l as COMPARISON_OPERATORS,
-  g as KEYWORDS,
+  I as DATE_HISTOGRAM_CALENDAR_INTERVALS,
+  S as DATE_HISTOGRAM_FIXED_UNITS,
+  v as GEO_GRID_PRECISION,
+  g as GROUP_BY_BUCKET_FUNCTIONS,
+  w as KEYWORDS,
   p as LOGICAL_OPERATORS,
   k as MUTATORS,
   u as NEGATION_SYMBOL_OPERATORS,
   b as SYMBOL_LOGICAL_OPERATORS,
   h as SYMBOL_OPERATORS,
-  m as TYPE_HINTS,
-  w as TqlTokenizer,
-  T as VISUALIZATION_TYPES,
-  N as findPreviousToken,
-  E as findTokenAtPosition,
-  I as findTokenBefore,
-  S as findTokensInRange,
-  O as tokenizeTql,
-  v as tokenizeTqlNoWhitespace
+  T as TYPE_HINTS,
+  O as TqlTokenizer,
+  m as VISUALIZATION_TYPES,
+  D as findPreviousToken,
+  N as findTokenAtPosition,
+  x as findTokenBefore,
+  y as findTokensInRange,
+  A as tokenizeTql,
+  R as tokenizeTqlNoWhitespace
 };

package/dist/src/types.d.ts

@@ -4,7 +4,7 @@
  * Comprehensive type system for TQL parsing, validation, and autocomplete.
  * Synchronized with tellaro-query-language Python/Rust implementations.
  */
-export type TqlTokenType = "field" | "operator" | "logicalOp" | "collectionOp" | "string" | "number" | "boolean" | "null" | "paren" | "bracket" | "comma" | "pipe" | "arrow" | "doubleColon" | "mutator" | "aggregation" | "keyword" | "typeHint" | "visualization" | "whitespace" | "unknown" | "error";
+export type TqlTokenType = "field" | "operator" | "logicalOp" | "collectionOp" | "string" | "number" | "boolean" | "null" | "paren" | "bracket" | "comma" | "pipe" | "arrow" | "doubleColon" | "mutator" | "aggregation" | "bucketFunction" | "keyword" | "typeHint" | "visualization" | "whitespace" | "unknown" | "error";
 export interface TqlToken {
     type: TqlTokenType;
     value: string;
@@ -79,10 +79,114 @@ export interface TqlAggregationExpression {
     start: number;
     end: number;
 }
+/**
+ * A function-style group-by bucket level, as both engines' ASTs carry it in `bucket`.
+ *
+ * `| stats count() by date_histogram(@timestamp, 1h)` → `{ type: "date_histogram",
+ * interval: "1h", interval_kind: "fixed" }`. The same object is echoed in a grouped
+ * result's `group_by[i].bucket`.
+ */
+export type TqlGroupByBucket = {
+    type: "date_histogram";
+    /** `"1h"` (fixed), `"day"` (calendar) or `"auto"` */
+    interval: string;
+    interval_kind: "fixed" | "calendar" | "auto";
+    /** The auto bucket target (`auto(N)`, default 50); only for `interval_kind: "auto"` */
+    buckets?: number;
+} | {
+    /** Web-Mercator tiles; row keys are `"z/x/y"` */
+    type: "geotile";
+    precision: number;
+} | {
+    /** Geohash cells; row keys are the geohash */
+    type: "geohash";
+    precision: number;
+} | {
+    /** `range(f, 0, 1024)` → `*-0`, `0-1024`, `1024-*`; each bucket is `from <= v < to` */
+    type: "range";
+    ranges: Array<{
+        key: string;
+        from?: number;
+        to?: number;
+    }>;
+} | {
+    /**
+     * `filters(<filter> as 'label', ...)`. Result metadata carries the labels (in written
+     * order); the engines' ASTs carry `filters: [{ label, filter }]` instead.
+     */
+    type: "filters";
+    labels?: string[];
+    filters?: Array<{
+        label: string;
+        filter: unknown;
+    }>;
+};
+/** A latitude/longitude pair in degrees. */
+export interface TqlLatLon {
+    lat: number;
+    lon: number;
+}
+/** One group-by level of a stats expression. */
+export interface TqlGroupByLevel {
+    /** The bucketed field */
+    field: TqlFieldReference;
+    /** Present for a bucket function, absent for a plain terms level */
+    bucket?: TqlGroupByBucket;
+    /** `by f top N` */
+    bucketSize?: number;
+    /** `by f top N with other` */
+    withOther?: boolean;
+}
+/**
+ * One entry of a grouped stats result's `group_by` list (Python and Rust, in memory and
+ * from OpenSearch). `key` names the property each row's `key` object stores this level's
+ * value under — usually the field, `date_histogram(@timestamp)` when two levels share a field.
+ */
+export type TqlGroupByMetadata = {
+    field: string;
+    key: string;
+    bucket_size: number | null;
+    with_other: boolean;
+    bucket?: undefined;
+} | {
+    /** null for `filters(...)`, which buckets no single field (its key is `filters`) */
+    field: string | null;
+    key: string;
+    bucket: TqlGroupByBucket;
+};
+/** Per-level bucket metadata a row carries in `bucket_meta[<level key>]`. */
+export interface TqlRowBucketMeta {
+    /** date_histogram: bucket start, epoch milliseconds (UTC) */
+    epoch_ms?: number;
+    /** date_histogram with an automatic interval: the interval chosen, e.g. `"1h"` */
+    interval?: string;
+    /** geotile/geohash: cell centre latitude */
+    lat?: number;
+    /** geotile/geohash: cell centre longitude */
+    lon?: number;
+    /** geotile/geohash: north-west corner */
+    top_left?: TqlLatLon;
+    /** geotile/geohash: south-east corner */
+    bottom_right?: TqlLatLon;
+    /** range: inclusive lower bound (absent for the first bucket) */
+    from?: number;
+    /** range: exclusive upper bound (absent for the last bucket) */
+    to?: number;
+}
+/** One row of a grouped stats result. Time keys are ISO 8601 (`2026-10-14T10:00:00.000Z`). */
+export interface TqlStatsRow {
+    key: Record<string, unknown>;
+    doc_count: number;
+    bucket_meta?: Record<string, TqlRowBucketMeta>;
+    aggregations?: Record<string, unknown>;
+    /** `with other`: this row holds what the last level's limit dropped; its key there is "Other" */
+    other?: boolean;
+    [metric: string]: unknown;
+}
 export interface TqlStatsExpression {
     type: "stats";
     aggregations: TqlAggregationExpression[];
-    groupBy?: TqlFieldReference[];
+    groupBy?: TqlGroupByLevel[];
     topN?: number;
     bottomN?: number;
     visualization?: TqlVisualizationType;
@@ -224,7 +328,14 @@ export type TqlErrorCode = "UNEXPECTED_TOKEN" | "UNEXPECTED_END" | "UNBALANCED_P
  * form on `count(*)` / `count()` (`count(*, top 2)`). A spelling only one engine refuses is
  * an ENGINE_DIVERGENCE warning instead — never this.
  */
- | "INVALID_STATS_MODIFIER";
+ | "INVALID_STATS_MODIFIER"
+/**
+ * A group-by bucket function with arguments both engines refuse at parse time: a bad
+ * `date_histogram` interval or `auto(N)` target, a geo precision out of range, unsorted or
+ * malformed `range` boundaries, a duplicate `filters` label. Mirrors
+ * `cross_language_tests/fixtures/test_cases/validation/stats_bucket_errors.json`.
+ */
+ | "INVALID_STATS_BUCKET";
 export type TqlWarningCode = "UNKNOWN_FIELD" | "TYPE_MISMATCH" | "DEPRECATED_OPERATOR" | "REDUNDANT_PARENS"
 /**
  * The query parses, but only ONE of the two engines accepts it.