@dxos/echo-query 0.8.4-main.e99c46d → 0.8.4-main.ead640a

package/package.json

@@ -1,13 +1,16 @@
 {
   "name": "@dxos/echo-query",
-  "version": "0.8.4-main.e99c46d",
+  "version": "0.8.4-main.ead640a",
   "description": "ECHO queries.",
   "homepage": "https://dxos.org",
   "bugs": "https://github.com/dxos/dxos/issues",
   "license": "MIT",
   "author": "info@dxos.org",
-  "sideEffects": true,
+  "sideEffects": false,
   "type": "module",
+  "imports": {
+    "#query-lite": "./dist/query-lite/index.js"
+  },
   "exports": {
     ".": {
       "source": "./src/index.ts",
@@ -25,13 +28,24 @@
     "src"
   ],
   "dependencies": {
+    "@lezer/common": "^1.2.2",
+    "@lezer/lezer": "^1.1.2",
+    "@lezer/lr": "^1.4.2",
     "@orama/orama": "^3.1.7",
-    "@dxos/node-std": "0.8.4-main.e99c46d",
-    "@dxos/util": "0.8.4-main.e99c46d"
+    "@dxos/context": "0.8.4-main.ead640a",
+    "@dxos/debug": "0.8.4-main.ead640a",
+    "@dxos/echo": "0.8.4-main.ead640a",
+    "@dxos/echo-protocol": "0.8.4-main.ead640a",
+    "@dxos/invariant": "0.8.4-main.ead640a",
+    "@dxos/node-std": "0.8.4-main.ead640a",
+    "@dxos/errors": "0.8.4-main.ead640a",
+    "@dxos/util": "0.8.4-main.ead640a",
+    "@dxos/vendor-quickjs": "0.8.4-main.ead640a"
   },
   "devDependencies": {
-    "@dxos/echo-generator": "0.8.4-main.e99c46d",
-    "@dxos/random": "0.8.4-main.e99c46d"
+    "@lezer/generator": "^1.7.1",
+    "@dxos/random": "0.8.4-main.ead640a",
+    "@dxos/echo-generator": "0.8.4-main.ead640a"
   },
   "publishConfig": {
     "access": "public"

package/src/env.d.ts

@@ -0,0 +1,8 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+declare module '#query-lite?raw' {
+  const code: string;
+  export default code;
+}

package/src/index.ts

@@ -1,3 +1,5 @@
 //
 // Copyright 2023 DXOS.org
 //
+
+export * from './parser';

package/src/parser/gen/index.ts

@@ -0,0 +1,13 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+import { LRParser } from '@lezer/lr';
+import { parser } from './query';
+import * as terms from './query.terms';
+
+export namespace QueryDSL {
+  export const Parser: LRParser = parser;
+  export const Node = terms;
+  export const Tokens = ['type:', 'AND', 'OR', 'NOT'];
+}

package/src/parser/gen/query.terms.ts

@@ -0,0 +1,26 @@
+// This file was generated by lezer-generator. You probably shouldn't edit it.
+export const
+  Query = 1,
+  Filter = 2,
+  TagFilter = 3,
+  Tag = 4,
+  TextFilter = 5,
+  String = 6,
+  TypeFilter = 7,
+  Identifier = 8,
+  TypeKeyword = 9,
+  PropertyFilter = 11,
+  PropertyPath = 12,
+  Value = 14,
+  Number = 15,
+  Boolean = 16,
+  Null = 17,
+  ObjectLiteral = 18,
+  ObjectProperty = 20,
+  ArrayLiteral = 23,
+  Not = 26,
+  And = 27,
+  Or = 28,
+  Relation = 29,
+  ArrowRight = 30,
+  ArrowLeft = 31

package/src/parser/gen/query.ts

@@ -0,0 +1,18 @@
+// This file was generated by lezer-generator. You probably shouldn't edit it.
+import {LRParser} from "@lezer/lr"
+const spec_Identifier = {__proto__:null,type:18, NOT:82, not:82, "!":82, AND:84, and:84, OR:86, or:86}
+export const parser = LRParser.deserialize({
+  version: 14,
+  states: "(QOVQPOOOOQO'#C_'#C_OOQO'#Ca'#CaOnQPO'#CcOsQPO'#ChO{QPO'#CnO!TQPO'#CgOOQO'#C^'#C^OOQO'#Cv'#CvOOQO'#DU'#DUOVQPO'#DUQ!YQPOOOVQPO'#DUO!jQPO,58}O!oQPO'#DOO!tQPO,59SO!|QPO'#CpOOQO,59Y,59YO#RQPO,59YO#ZQQO,59RO#oQPO,59pOOQO'#Cw'#CwOOQO'#Cx'#CxOOQO'#Cy'#CyOVQPO,59pOVQPO,59pOVQPO,59pO$jQPO,59pOOQO1G.i1G.iOOQO,59j,59jOOQO-E6|-E6|O#ZQQO,59[O$}QPO'#DPO%SQPO1G.tOOQO1G.t1G.tO%[QQO'#CsOOQO'#Cj'#CjOOQO1G.m1G.mO%cQPO1G/[O%yQPO1G/[O&aQPO1G/[OOQO1G/[1G/[OOQO1G.v1G.vOOQO,59k,59kOOQO-E6}-E6}OOQO7+$`7+$`OOQO,59_,59_O&wQPO,59_O#ZQQO'#DQO'PQPO1G.yOOQO1G.y1G.yOOQO,59l,59lOOQO-E7O-E7OOOQO7+$e7+$e",
+  stateData: "'X~OwOS~OSPOUQOWSOXROcTOp[OyWO~OY]O~O]^OY[X~OW`OfaO~OYcO~OngOogOzeO{fO~PVOWlO~OWmO~O]^OY[a~OYoO~OepOfrO~OUtO_tO`tOatOcTOhsO~OyWOSxaUxaWxaXxacxanxaoxapxauxazxa{xaqxa~OngOogOqyOzeO{fO~PVOW`O~OepOf}O~Oi!OO~P#ZOnxioxiuxizxi{xiqxi~PVOzeOnxioxiuxi{xiqxi~PVOzeO{fOnxioxiuxiqxi~PVOe!QOi!SO~Oe!QOi!VO~O",
+  goto: "%TyPPz!XP!XP!XPPP!X!fP!sPPP#PP#dPP#^PP#j#x$O$TPPPP$X$_$ePPP$kgXOYZ[hijkvwxgVOYZ[hijkvwxgUOYZ[hijkvwxQucQzoQ!PsR!T!QfVOYZ[hijkvwxXtcos!QQbTR{piYOYZ[dhijkvwxXhZkwxViZkxTjZkQ_SRn_QqbR|qQ!R!PR!U!RQZO^dYZdkvwxQk[QvhQwiRxj",
+  nodeNames: "⚠ Query Filter TagFilter Tag TextFilter String TypeFilter Identifier TypeKeyword : PropertyFilter PropertyPath . Value Number Boolean Null ObjectLiteral { ObjectProperty , } ArrayLiteral [ ] Not And Or Relation ArrowRight ArrowLeft ( )",
+  maxTerm: 43,
+  skippedNodes: [0],
+  repeatNodeCount: 3,
+  tokenData: "2w~RrX^#]pq#]rs$Qst%nwx&fxy'}yz(S|}(X}!O(^!O!P)}!Q![(g![!]*S!^!_*X!c!}*d!}#O+O#P#Q+T#R#S*d#T#Y*d#Y#Z+Y#Z#b*d#b#c.i#c#h*d#h#i1Z#i#o*d#o#p2m#q#r2r#y#z#]$f$g#]#BY#BZ#]$IS$I_#]$I|$JO#]$JT$JU#]$KV$KW#]&FU&FV#]~#bYw~X^#]pq#]#y#z#]$f$g#]#BY#BZ#]$IS$I_#]$I|$JO#]$JT$JU#]$KV$KW#]&FU&FV#]~$TVOr$Qrs$js#O$Q#O#P$o#P;'S$Q;'S;=`%h<%lO$Q~$oOU~~$rRO;'S$Q;'S;=`${;=`O$Q~%OWOr$Qrs$js#O$Q#O#P$o#P;'S$Q;'S;=`%h;=`<%l$Q<%lO$Q~%kP;=`<%l$Q~%qT}!O&Q!Q![&Q!c!}&Q#R#S&Q#T#o&Q~&VTS~}!O&Q!Q![&Q!c!}&Q#R#S&Q#T#o&Q~&iVOw&fwx$jx#O&f#O#P'O#P;'S&f;'S;=`'w<%lO&f~'RRO;'S&f;'S;=`'[;=`O&f~'_WOw&fwx$jx#O&f#O#P'O#P;'S&f;'S;=`'w;=`<%l&f<%lO&f~'zP;=`<%l&f~(SOp~~(XOq~~(^Oe~~(aQ!Q![(g!`!a)x~(lS_~!O!P(x!Q![(g!g!h)^#X#Y)^~({P!Q![)O~)TR_~!Q![)O!g!h)^#X#Y)^~)aR{|)j}!O)j!Q![)p~)mP!Q![)p~)uP_~!Q![)p~)}On~~*SO]~~*XOY~~*[P}!O*_~*dOo~P*iVWP}!O*d!O!P*d!P!Q*d!Q![*d!c!}*d#R#S*d#T#o*d~+TOh~~+YOi~R+_WWP}!O*d!O!P*d!P!Q*d!Q![*d!c!}*d#R#S*d#T#U+w#U#o*dR+|XWP}!O*d!O!P*d!P!Q*d!Q![*d!c!}*d#R#S*d#T#`*d#`#a,i#a#o*dR,nXWP}!O*d!O!P*d!P!Q*d!Q![*d!c!}*d#R#S*d#T#g*d#g#h-Z#h#o*dR-`XWP}!O*d!O!P*d!P!Q*d!Q![*d!c!}*d#R#S*d#T#X*d#X#Y-{#Y#o*dR.SV`QWP}!O*d!O!P*d!P!Q*d!Q![*d!c!}*d#R#S*d#T#o*dR.nXWP}!O*d!O!P*d!P!Q*d!Q![*d!c!}*d#R#S*d#T#i*d#i#j/Z#j#o*dR/`XWP}!O*d!O!P*d!P!Q*d!Q![*d!c!}*d#R#S*d#T#`*d#`#a/{#a#o*dR0QXWP}!O*d!O!P*d!P!Q*d!Q![*d!c!}*d#R#S*d#T#`*d#`#a0m#a#o*dR0tVWPaQ}!O*d!O!P*d!P!Q*d!Q![*d!c!}*d#R#S*d#T#o*dR1`XWP}!O*d!O!P*d!P!Q*d!Q![*d!c!}*d#R#S*d#T#f*d#f#g1{#g#o*dR2QXWP}!O*d!O!P*d!P!Q*d!Q![*d!c!}*d#R#S*d#T#i*d#i#j-Z#j#o*d~2rOc~~2wOf~",
+  tokenizers: [0, 1],
+  topRules: {"Query":[0,1]},
+  specialized: [{term: 8, get: (value: keyof typeof spec_Identifier) => spec_Identifier[value] || -1}],
+  tokenPrec: 0
+})

package/src/parser/index.ts

@@ -0,0 +1,6 @@
+//
+// Copyright 2023 DXOS.org
+//
+
+export * from './gen';
+export * from './query-builder';

package/src/parser/query-builder.ts

@@ -0,0 +1,486 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+import { type Parser, type Tree, type TreeCursor } from '@lezer/common';
+
+import { Filter, type Tag } from '@dxos/echo';
+import { invariant } from '@dxos/invariant';
+
+import { QueryDSL } from './gen';
+
+/**
+ * Stateless query builder that parses DSL trees into filters.
+ *
+ * NOTE: QueryBuilder was largely developed using Claude Sonnet 4.5 (in Windsurf)..
+ * To modify the functionality, create a minimal breaking test and direct the LLM to fix either the grammar or builder.
+ */
+export class QueryBuilder {
+  private readonly _parser: Parser = QueryDSL.Parser.configure({ strict: true });
+
+  constructor(private readonly _tags?: Tag.TagMap) {}
+
+  /**
+   * Check valid input.
+   */
+  validate(input: string): boolean {
+    try {
+      const tree = this._parser.parse(input);
+      return tree.cursor().node.name === 'Query';
+    } catch {
+      return false;
+    }
+  }
+
+  /**
+   * Build a query from the input string.
+   */
+  build(input: string): Filter.Any | undefined {
+    try {
+      const tree = this._parser.parse(input);
+      return this.buildQuery(tree, input);
+    } catch {
+      return undefined;
+    }
+  }
+
+  /**
+   * Build a query from a parsed DSL tree.
+   */
+  buildQuery(tree: Tree, input: string): Filter.Any | undefined {
+    const cursor = tree.cursor();
+
+    // Start at root (Query node).
+    if (cursor.node.name !== 'Query') {
+      return undefined;
+    }
+
+    // Check if Query has multiple children (binary expression).
+    const children: Array<{ name: string; from: number; to: number }> = [];
+    if (cursor.firstChild()) {
+      do {
+        children.push({ name: cursor.node.name, from: cursor.from, to: cursor.to });
+      } while (cursor.nextSibling());
+      cursor.parent();
+    }
+
+    // If we have an operator in the children, or multiple expressions (implicit AND), parse as binary expression.
+    const hasOperator = children.some((child) => child.name === 'And' || child.name === 'Or');
+    const hasMultipleExpressions =
+      children.filter((child) => child.name === 'Filter' || child.name === 'Not' || child.name === '(').length > 1;
+    if (hasOperator || hasMultipleExpressions) {
+      return this._parseBinaryExpression(cursor, input);
+    }
+
+    // Otherwise, parse the single expression.
+    if (!cursor.firstChild()) {
+      return Filter.nothing();
+    }
+
+    return this._parseExpression(cursor, input);
+  }
+
+  /**
+   * Parse an expression node.
+   */
+  private _parseExpression(cursor: TreeCursor, input: string): Filter.Any | undefined {
+    const nodeName = cursor.node.name;
+
+    switch (nodeName) {
+      case 'Filter':
+        return this._parseFilter(cursor, input);
+
+      case 'Not': {
+        // Move past NOT token to the expression.
+        cursor.nextSibling();
+        const notFilter = this._parseExpression(cursor, input);
+        return notFilter ? Filter.not(notFilter) : undefined;
+      }
+
+      case 'And':
+      case 'Or':
+        // This is the operator node, we need to handle the binary expression.
+        // The cursor is positioned at the operator, we need to go back to parent.
+        cursor.parent();
+        return this._parseBinaryExpression(cursor, input);
+
+      case '(': {
+        // Skip opening paren.
+        cursor.nextSibling();
+        const parenFilter = this._parseExpression(cursor, input);
+        // Skip closing paren.
+        cursor.nextSibling();
+        return parenFilter;
+      }
+
+      default: {
+        // Check if this is a binary expression (has And/Or as a child).
+        const savedPos = cursor.from;
+        if (cursor.firstChild()) {
+          // Look for And/Or operators or multiple expressions (implicit AND).
+          let hasOperator = false;
+          let expressionCount = 0;
+          do {
+            if (cursor.node.name === 'And' || cursor.node.name === 'Or') {
+              hasOperator = true;
+              break;
+            }
+            if (cursor.node.name === 'Filter' || cursor.node.name === 'Not' || cursor.node.name === '(') {
+              expressionCount++;
+            }
+          } while (cursor.nextSibling());
+          hasOperator = hasOperator || expressionCount > 1;
+
+          // Reset cursor to the saved position.
+          cursor.parent();
+          cursor.firstChild();
+          while (cursor.from !== savedPos && cursor.nextSibling()) {}
+
+          if (hasOperator) {
+            cursor.parent();
+            return this._parseBinaryExpression(cursor, input);
+          } else {
+            const result = this._parseExpression(cursor, input);
+            cursor.parent();
+            return result;
+          }
+        }
+        return Filter.nothing();
+      }
+    }
+  }
+
+  /**
+   * Parse a binary expression (AND/OR).
+   */
+  private _parseBinaryExpression(cursor: TreeCursor, input: string): Filter.Any {
+    const filters: Filter.Any[] = [];
+    let operator: 'and' | 'or' | null = null;
+
+    // Collect all filters and operators.
+    if (cursor.firstChild()) {
+      do {
+        const nodeName = cursor.node.name;
+
+        if (nodeName === 'And' || nodeName === 'Or') {
+          operator = nodeName.toLowerCase() as 'and' | 'or';
+        } else if (nodeName === '(') {
+          // Handle parenthesized expression.
+          // Look ahead to see if this is a binary expression.
+          const savedPos = cursor.from;
+          cursor.nextSibling(); // Move past '('
+
+          // Check if the parentheses contain a binary expression.
+          let hasBinaryOp = false;
+          do {
+            if (cursor.node.name === 'And' || cursor.node.name === 'Or') {
+              hasBinaryOp = true;
+              break;
+            }
+          } while (cursor.nextSibling() && cursor.node.name !== ')');
+
+          // Reset cursor to start of parenthesized content.
+          cursor.parent();
+          cursor.firstChild();
+          while (cursor.from !== savedPos && cursor.nextSibling()) {}
+          cursor.nextSibling(); // Move past '(' again.
+
+          if (hasBinaryOp) {
+            // Find the matching closing parenthesis.
+            let depth = 1;
+            const exprStart = cursor.from;
+            let exprEnd = cursor.to;
+
+            while (cursor.nextSibling() && depth > 0) {
+              if (cursor.node.name === '(') depth++;
+              else if (cursor.node.name === ')') {
+                depth--;
+                if (depth === 0) {
+                  exprEnd = cursor.from;
+                }
+              }
+            }
+
+            // Parse the expression inside parentheses as a subtree.
+            const subInput = input.slice(exprStart, exprEnd);
+            const subTree = this._parser.parse(subInput);
+            const subFilter = this.buildQuery(subTree, subInput);
+            if (subFilter) {
+              filters.push(subFilter);
+            }
+          } else {
+            // Simple parenthesized expression.
+            const subFilter = this._parseExpression(cursor, input);
+            if (subFilter) {
+              filters.push(subFilter);
+            }
+
+            // Skip until we find the closing parenthesis.
+            while (cursor.nextSibling() && cursor.node.name !== ')') {}
+          }
+        } else if (nodeName !== ')') {
+          const subFilter = this._parseExpression(cursor, input);
+          if (subFilter) {
+            filters.push(subFilter);
+          }
+        }
+      } while (cursor.nextSibling());
+
+      cursor.parent();
+    }
+
+    if (filters.length === 0) {
+      return Filter.nothing();
+    }
+
+    if (filters.length === 1) {
+      return filters[0];
+    }
+
+    return operator === 'or' ? Filter.or(...filters) : Filter.and(...filters);
+  }
+
+  /**
+   * Parse a Filter node.
+   */
+  private _parseFilter(cursor: TreeCursor, input: string): Filter.Any | undefined {
+    if (!cursor.firstChild()) {
+      return Filter.nothing();
+    }
+
+    let result: Filter.Any | undefined = undefined;
+    const filterType = cursor.node.name;
+    switch (filterType) {
+      case 'TagFilter':
+        if (this._tags) {
+          result = this._parseTagFilter(cursor, input);
+        }
+        break;
+
+      case 'TextFilter':
+        result = this._parseTextFilter(cursor, input);
+        break;
+
+      case 'TypeFilter':
+        result = this._parseTypeFilter(cursor, input);
+        break;
+
+      case 'ObjectLiteral':
+        result = this._parseObjectLiteral(cursor, input);
+        break;
+
+      case 'PropertyFilter':
+        result = this._parsePropertyFilter(cursor, input);
+        break;
+
+      default:
+        result = Filter.nothing();
+    }
+
+    cursor.parent();
+    return result;
+  }
+
+  /**
+   * Parse a TypeFilter node (type:typename).
+   */
+  private _parseTypeFilter(cursor: TreeCursor, input: string): Filter.Any {
+    // Skip TypeKeyword.
+    cursor.firstChild();
+    cursor.nextSibling(); // Skip ':'
+    cursor.nextSibling(); // Move to Identifier
+
+    const typename = this._getNodeText(cursor, input);
+    cursor.parent(); // Go back to TypeFilter.
+    return Filter.typename(typename);
+  }
+
+  /**
+   * Parse a TextFilter node (quoted string).
+   */
+  private _parseTextFilter(cursor: TreeCursor, input: string): Filter.Any {
+    cursor.firstChild(); // Move to String node.
+    const text = this._getNodeText(cursor, input);
+    cursor.parent(); // Go back to TextFilter.
+    // Remove quotes.
+    return Filter.text(text.slice(1, -1));
+  }
+
+  /**
+   * Parse an ObjectLiteral node.
+   */
+  private _parseObjectLiteral(cursor: TreeCursor, input: string): Filter.Any {
+    const props: Record<string, any> = {};
+
+    if (cursor.firstChild()) {
+      do {
+        if (cursor.node.name === 'ObjectProperty') {
+          const { key, value } = this._parseObjectProperty(cursor, input);
+          if (key) {
+            // Convert simple values to Filter.eq for compatibility with Filter.props.
+            props[key] = Filter.eq(value);
+          }
+        }
+      } while (cursor.nextSibling());
+
+      cursor.parent();
+    }
+
+    return Filter.props(props);
+  }
+
+  /**
+   * Parse an ObjectProperty node.
+   */
+  private _parseObjectProperty(cursor: TreeCursor, input: string): { key: string | null; value: any } {
+    let key: string | null = null;
+    let value: any = null;
+
+    if (cursor.firstChild()) {
+      // First child should be the property name (Identifier).
+      if (cursor.node.name === 'Identifier') {
+        key = this._getNodeText(cursor, input);
+      }
+
+      // Skip ':' and move to Value.
+      cursor.nextSibling();
+      cursor.nextSibling();
+
+      if (cursor.node.name === 'Value' && cursor.firstChild()) {
+        value = this._parseValue(cursor, input);
+        cursor.parent();
+      }
+
+      cursor.parent();
+    }
+
+    return { key, value };
+  }
+
+  /**
+   * Parse a PropertyFilter node (property:value).
+   */
+  private _parsePropertyFilter(cursor: TreeCursor, input: string): Filter.Any {
+    let path: string | null = null;
+    let value: any = null;
+
+    if (cursor.firstChild()) {
+      // First child is PropertyPath.
+      if (cursor.node.name === 'PropertyPath') {
+        path = this._parsePropertyPath(cursor, input);
+      }
+
+      // Skip ':' and move to Value.
+      cursor.nextSibling();
+      cursor.nextSibling();
+
+      if (cursor.node.name === 'Value' && cursor.firstChild()) {
+        value = this._parseValue(cursor, input);
+        cursor.parent();
+      }
+
+      cursor.parent();
+    }
+
+    if (!path) {
+      return Filter.nothing();
+    }
+
+    return Filter.props({ [path]: value });
+  }
+
+  /**
+   * Parse a PropertyPath node (supports dot notation).
+   */
+  private _parsePropertyPath(cursor: TreeCursor, input: string): string {
+    const parts: string[] = [];
+
+    if (cursor.firstChild()) {
+      do {
+        if (cursor.node.name === 'Identifier') {
+          parts.push(this._getNodeText(cursor, input));
+        }
+      } while (cursor.nextSibling());
+
+      cursor.parent();
+    }
+
+    return parts.join('.');
+  }
+
+  /**
+   * Parse a TagFilter node (#tag).
+   */
+  private _parseTagFilter(cursor: TreeCursor, input: string): Filter.Any | undefined {
+    invariant(this._tags);
+    const str = this._getNodeText(cursor, input).slice(1).toLowerCase();
+    const [key] = Object.entries(this._tags!).find(([, value]) => value.label.toLowerCase() === str) ?? [];
+    return key ? Filter.tag(key) : undefined;
+  }
+
+  /**
+   * Parse a Value node.
+   */
+  private _parseValue(cursor: TreeCursor, input: string): any {
+    const valueType = cursor.node.name;
+
+    switch (valueType) {
+      case 'String': {
+        // Remove quotes.
+        const str = this._getNodeText(cursor, input);
+        return str.slice(1, -1);
+      }
+
+      case 'Number':
+        return Number(this._getNodeText(cursor, input));
+
+      case 'Boolean':
+        return this._getNodeText(cursor, input) === 'true';
+
+      case 'Null':
+        return null;
+
+      case 'ObjectLiteral': {
+        // For nested objects, parse recursively.
+        const props: Record<string, any> = {};
+        if (cursor.firstChild()) {
+          do {
+            if (cursor.node.name === 'ObjectProperty') {
+              const { key, value } = this._parseObjectProperty(cursor, input);
+              if (key) {
+                props[key] = value;
+              }
+            }
+          } while (cursor.nextSibling());
+          cursor.parent();
+        }
+        return props;
+      }
+
+      case 'ArrayLiteral': {
+        // Parse array values
+        const array: any[] = [];
+        if (cursor.firstChild()) {
+          do {
+            if (cursor.node.name === 'Value' && cursor.firstChild()) {
+              array.push(this._parseValue(cursor, input));
+              cursor.parent();
+            }
+          } while (cursor.nextSibling());
+          cursor.parent();
+        }
+        return array;
+      }
+
+      default:
+        return null;
+    }
+  }
+
+  /**
+   * Get the text content of the current node.
+   */
+  private _getNodeText(cursor: TreeCursor, input: string): string {
+    return input.slice(cursor.from, cursor.to);
+  }
+}