@dxos/echo-query 0.8.4-main.84f28bd → 0.8.4-main.ae835ea

package/README.md

@@ -5,7 +5,7 @@ ECHO queries.
 ## Installation
 
 ```bash
-pnpm i @dxos/echo-schema
+pnpm i @dxos/echo-query
 ```
 
 ## DXOS Resources

package/dist/lib/browser/index.mjs

@@ -1,2 +1,563 @@
 import "@dxos/node-std/globals";
+var __defProp = Object.defineProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+
+// src/parser/gen/query.ts
+import { LRParser } from "@lezer/lr";
+var spec_Identifier = {
+  __proto__: null,
+  type: 26,
+  NOT: 86,
+  not: 86,
+  "!": 86,
+  AND: 88,
+  and: 88,
+  OR: 90,
+  or: 90
+};
+var parser = LRParser.deserialize({
+  version: 14,
+  states: "(jOVQPOOOnQPO'#ClOOQO'#Cd'#CdOOQO'#Cf'#CfOyQPO'#ChO!OQPO'#CrO!WQPO'#CkOOQO'#Cc'#CcOOQO'#Cz'#CzOOQO'#DW'#DWOVQPO'#DWQ!]QPOOOVQPO'#DWO!mQPO,58xO!rQPO'#DQO!wQPO,59WO#PQPO,59SO#UQPO'#CtOOQO,59^,59^O#ZQPO,59^O#cQQO,59VO#wQPO,59rOOQO'#C{'#C{OOQO'#C|'#C|OOQO'#C}'#C}OVQPO,59rOVQPO,59rOVQPO,59rO$rQPO,59rOVQPO1G.dOOQO,59l,59lOOQO-E7O-E7OOOQO1G.n1G.nO#cQQO,59`O%VQPO'#DRO%[QPO1G.xOOQO1G.x1G.xO%dQQO'#CwOOQO'#Cn'#CnOOQO1G.q1G.qO%kQPO1G/^O&RQPO1G/^O&iQPO1G/^OOQO1G/^1G/^O'PQPO7+$OOOQO1G.z1G.zOOQO,59m,59mOOQO-E7P-E7POOQO7+$d7+$dOOQO,59c,59cO'dQPO,59cOOQO<<Gj<<GjO#cQQO'#DSO'lQPO1G.}OOQO1G.}1G.}OOQO,59n,59nOOQO-E7Q-E7QOOQO7+$i7+$i",
+  stateData: "'t~OyOS~ORPOT[OXQOZRO]SOgTO{WO~OS]Oa^O^`X~O^`O~ORaOjbO~O^dO~OrhOshO|fO}gO~PVOTmO~ORnO~Oa^O^`a~ORpO~O^qO~OirOjtO~OZvOcvOdvOevOgTOluO~O{WORzaTzaXzaZza]zagzarzaszawza|za}zaUza~OU{OrhOshO|fO}gO~PVORaO~OirOj!QO~Om!RO~P#cOrzisziwzi|zi}ziUzi~PVO|fOrzisziwzi}ziUzi~PVO|fO}gOrzisziwziUzi~PVOU!TOrhOshO|fO}gO~PVOi!UOm!WO~Oi!UOm!ZO~O",
+  goto: "%h{PP|PPPP|!]P!]P!]PP!]!lP!{PPP#XP#nPP#hPP#t$U$]$cPP$h$n$tPPP$zkXOYZ[ijklmxyz|kVOYZ[ijklmxyz|kUOYZ[ijklmxyz|QwdQ}qQ!SuR!X!UjVOYZ[ijklmxyz|Xvdqu!UQcTR!OrmYOYZ[eijklmxyz|ZiZlyz|XjZlz|VkZl|Q_PRo_QscR!PsQ!V!SR!Y!VQZO`eYZelxyz|Ql[QxiQyjQzkR|m",
+  nodeNames: "\u26A0 Query Assignment Identifier = ( ) Filter TagFilter Tag TextFilter String TypeFilter TypeKeyword : PropertyFilter PropertyPath . Value Number Boolean Null ObjectLiteral { ObjectProperty , } ArrayLiteral [ ] Not And Or Relation ArrowRight ArrowLeft",
+  maxTerm: 45,
+  skippedNodes: [
+    0
+  ],
+  repeatNodeCount: 3,
+  tokenData: "3P~RsX^#`pq#`rs$Tst%qwx&ixy(Qyz(V|}([}!O(a!O!P*Q!Q![(j![!]*V!^!_*[!_!`*g!c!}*l!}#O+W#P#Q+]#R#S*l#T#Y*l#Y#Z+b#Z#b*l#b#c.q#c#h*l#h#i1c#i#o*l#o#p2u#q#r2z#y#z#`$f$g#`#BY#BZ#`$IS$I_#`$I|$JO#`$JT$JU#`$KV$KW#`&FU&FV#`~#eYy~X^#`pq#`#y#z#`$f$g#`#BY#BZ#`$IS$I_#`$I|$JO#`$JT$JU#`$KV$KW#`&FU&FV#`~$WVOr$Trs$ms#O$T#O#P$r#P;'S$T;'S;=`%k<%lO$T~$rOZ~~$uRO;'S$T;'S;=`%O;=`O$T~%RWOr$Trs$ms#O$T#O#P$r#P;'S$T;'S;=`%k;=`<%l$T<%lO$T~%nP;=`<%l$T~%tT}!O&T!Q![&T!c!}&T#R#S&T#T#o&T~&YTX~}!O&T!Q![&T!c!}&T#R#S&T#T#o&T~&lVOw&iwx$mx#O&i#O#P'R#P;'S&i;'S;=`'z<%lO&i~'URO;'S&i;'S;=`'_;=`O&i~'bWOw&iwx$mx#O&i#O#P'R#P;'S&i;'S;=`'z;=`<%l&i<%lO&i~'}P;=`<%l&i~(VOT~~([OU~~(aOi~~(dQ!Q![(j!`!a){~(oSc~!O!P({!Q![(j!g!h)a#X#Y)a~)OP!Q![)R~)WRc~!Q![)R!g!h)a#X#Y)a~)dR{|)m}!O)m!Q![)s~)pP!Q![)s~)xPc~!Q![)s~*QOr~~*VOa~~*[O^~~*_P}!O*b~*gOs~~*lOS~P*qVRP}!O*l!O!P*l!P!Q*l!Q![*l!c!}*l#R#S*l#T#o*l~+]Ol~~+bOm~R+gWRP}!O*l!O!P*l!P!Q*l!Q![*l!c!}*l#R#S*l#T#U,P#U#o*lR,UXRP}!O*l!O!P*l!P!Q*l!Q![*l!c!}*l#R#S*l#T#`*l#`#a,q#a#o*lR,vXRP}!O*l!O!P*l!P!Q*l!Q![*l!c!}*l#R#S*l#T#g*l#g#h-c#h#o*lR-hXRP}!O*l!O!P*l!P!Q*l!Q![*l!c!}*l#R#S*l#T#X*l#X#Y.T#Y#o*lR.[VdQRP}!O*l!O!P*l!P!Q*l!Q![*l!c!}*l#R#S*l#T#o*lR.vXRP}!O*l!O!P*l!P!Q*l!Q![*l!c!}*l#R#S*l#T#i*l#i#j/c#j#o*lR/hXRP}!O*l!O!P*l!P!Q*l!Q![*l!c!}*l#R#S*l#T#`*l#`#a0T#a#o*lR0YXRP}!O*l!O!P*l!P!Q*l!Q![*l!c!}*l#R#S*l#T#`*l#`#a0u#a#o*lR0|VRPeQ}!O*l!O!P*l!P!Q*l!Q![*l!c!}*l#R#S*l#T#o*lR1hXRP}!O*l!O!P*l!P!Q*l!Q![*l!c!}*l#R#S*l#T#f*l#f#g2T#g#o*lR2YXRP}!O*l!O!P*l!P!Q*l!Q![*l!c!}*l#R#S*l#T#i*l#i#j-c#j#o*l~2zOg~~3POj~",
+  tokenizers: [
+    0,
+    1
+  ],
+  topRules: {
+    "Query": [
+      0,
+      1
+    ]
+  },
+  specialized: [
+    {
+      term: 3,
+      get: (value) => spec_Identifier[value] || -1
+    }
+  ],
+  tokenPrec: 0
+});
+
+// src/parser/gen/query.terms.ts
+var query_terms_exports = {};
+__export(query_terms_exports, {
+  And: () => And,
+  ArrayLiteral: () => ArrayLiteral,
+  ArrowLeft: () => ArrowLeft,
+  ArrowRight: () => ArrowRight,
+  Assignment: () => Assignment,
+  Boolean: () => Boolean,
+  Filter: () => Filter,
+  Identifier: () => Identifier,
+  Not: () => Not,
+  Null: () => Null,
+  Number: () => Number2,
+  ObjectLiteral: () => ObjectLiteral,
+  ObjectProperty: () => ObjectProperty,
+  Or: () => Or,
+  PropertyFilter: () => PropertyFilter,
+  PropertyPath: () => PropertyPath,
+  Query: () => Query,
+  Relation: () => Relation,
+  String: () => String,
+  Tag: () => Tag,
+  TagFilter: () => TagFilter,
+  TextFilter: () => TextFilter,
+  TypeFilter: () => TypeFilter,
+  TypeKeyword: () => TypeKeyword,
+  Value: () => Value
+});
+var Query = 1;
+var Assignment = 2;
+var Identifier = 3;
+var Filter = 7;
+var TagFilter = 8;
+var Tag = 9;
+var TextFilter = 10;
+var String = 11;
+var TypeFilter = 12;
+var TypeKeyword = 13;
+var PropertyFilter = 15;
+var PropertyPath = 16;
+var Value = 18;
+var Number2 = 19;
+var Boolean = 20;
+var Null = 21;
+var ObjectLiteral = 22;
+var ObjectProperty = 24;
+var ArrayLiteral = 27;
+var Not = 30;
+var And = 31;
+var Or = 32;
+var Relation = 33;
+var ArrowRight = 34;
+var ArrowLeft = 35;
+
+// src/parser/gen/index.ts
+(function(QueryDSL2) {
+  QueryDSL2.Parser = parser;
+  QueryDSL2.Node = query_terms_exports;
+  QueryDSL2.Tokens = [
+    "type:",
+    "AND",
+    "OR",
+    "NOT"
+  ];
+})(QueryDSL || (QueryDSL = {}));
+var QueryDSL;
+
+// src/parser/query-builder.ts
+import { Filter as Filter2 } from "@dxos/echo";
+import { invariant } from "@dxos/invariant";
+var __dxlog_file = "/__w/dxos/dxos/packages/core/echo/echo-query/src/parser/query-builder.ts";
+var QueryBuilder = class {
+  _tags;
+  _parser = QueryDSL.Parser.configure({
+    strict: true
+  });
+  constructor(_tags) {
+    this._tags = _tags;
+  }
+  /**
+  * Check valid input.
+  */
+  validate(input) {
+    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) {
+    try {
+      const tree = this._parser.parse(input);
+      return this.buildQuery(tree, input);
+    } catch {
+      return {};
+    }
+  }
+  /**
+  * Build a query from a parsed DSL tree.
+  */
+  buildQuery(tree, input) {
+    const cursor = tree.cursor();
+    if (cursor.node.name !== "Query") {
+      return {};
+    }
+    const children = [];
+    if (cursor.firstChild()) {
+      do {
+        children.push({
+          name: cursor.node.name,
+          from: cursor.from,
+          to: cursor.to
+        });
+      } while (cursor.nextSibling());
+      cursor.parent();
+    }
+    const hasAssignment = children.some((child) => child.name === "Assignment");
+    if (hasAssignment) {
+      return this._parseAssignment(cursor, input);
+    }
+    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) {
+      const filter2 = this._parseBinaryExpression(cursor, input);
+      return {
+        filter: filter2
+      };
+    }
+    if (!cursor.firstChild()) {
+      return {
+        filter: Filter2.nothing()
+      };
+    }
+    const filter = this._parseExpression(cursor, input);
+    return {
+      filter
+    };
+  }
+  /**
+  * Parse an assignment node.
+  */
+  _parseAssignment(cursor, input) {
+    if (!cursor.firstChild()) {
+      return {};
+    }
+    let name;
+    let filter;
+    do {
+      if (cursor.node.name === "Assignment") {
+        const assignmentText = this._getNodeText(cursor, input);
+        if (cursor.firstChild()) {
+          name = this._getNodeText(cursor, input);
+          const openParenIndex = assignmentText.indexOf("(");
+          const closeParenIndex = assignmentText.lastIndexOf(")");
+          if (openParenIndex !== -1 && closeParenIndex !== -1 && closeParenIndex > openParenIndex) {
+            const subInput = assignmentText.slice(openParenIndex + 1, closeParenIndex).trim();
+            const subTree = this._parser.parse(subInput);
+            const subResult = this.buildQuery(subTree, subInput);
+            filter = subResult.filter;
+          }
+          cursor.parent();
+        }
+        break;
+      }
+    } while (cursor.nextSibling());
+    cursor.parent();
+    return {
+      filter,
+      name
+    };
+  }
+  /**
+  * Parse an expression node.
+  */
+  _parseExpression(cursor, input) {
+    const nodeName = cursor.node.name;
+    switch (nodeName) {
+      case "Filter":
+        return this._parseFilter(cursor, input);
+      case "Not": {
+        cursor.nextSibling();
+        const notFilter = this._parseExpression(cursor, input);
+        return notFilter ? Filter2.not(notFilter) : void 0;
+      }
+      case "And":
+      case "Or":
+        cursor.parent();
+        return this._parseBinaryExpression(cursor, input);
+      case "(": {
+        cursor.nextSibling();
+        const parenFilter = this._parseExpression(cursor, input);
+        cursor.nextSibling();
+        return parenFilter;
+      }
+      default: {
+        const savedPos = cursor.from;
+        if (cursor.firstChild()) {
+          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;
+          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 Filter2.nothing();
+      }
+    }
+  }
+  /**
+  * Parse a binary expression (AND/OR).
+  */
+  _parseBinaryExpression(cursor, input) {
+    const filters = [];
+    let operator = null;
+    if (cursor.firstChild()) {
+      do {
+        const nodeName = cursor.node.name;
+        if (nodeName === "And" || nodeName === "Or") {
+          operator = nodeName.toLowerCase();
+        } else if (nodeName === "(") {
+          const savedPos = cursor.from;
+          cursor.nextSibling();
+          let hasBinaryOp = false;
+          do {
+            if (cursor.node.name === "And" || cursor.node.name === "Or") {
+              hasBinaryOp = true;
+              break;
+            }
+          } while (cursor.nextSibling() && cursor.node.name !== ")");
+          cursor.parent();
+          cursor.firstChild();
+          while (cursor.from !== savedPos && cursor.nextSibling()) {
+          }
+          cursor.nextSibling();
+          if (hasBinaryOp) {
+            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;
+                }
+              }
+            }
+            const subInput = input.slice(exprStart, exprEnd);
+            const subTree = this._parser.parse(subInput);
+            const subResult = this.buildQuery(subTree, subInput);
+            if (subResult.filter) {
+              filters.push(subResult.filter);
+            }
+          } else {
+            const subFilter = this._parseExpression(cursor, input);
+            if (subFilter) {
+              filters.push(subFilter);
+            }
+            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 Filter2.nothing();
+    }
+    if (filters.length === 1) {
+      return filters[0];
+    }
+    return operator === "or" ? Filter2.or(...filters) : Filter2.and(...filters);
+  }
+  /**
+  * Parse a Filter node.
+  */
+  _parseFilter(cursor, input) {
+    if (!cursor.firstChild()) {
+      return Filter2.nothing();
+    }
+    let result = void 0;
+    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 = Filter2.nothing();
+    }
+    cursor.parent();
+    return result;
+  }
+  /**
+  * Parse a TypeFilter node (type:typename).
+  */
+  _parseTypeFilter(cursor, input) {
+    cursor.firstChild();
+    cursor.nextSibling();
+    cursor.nextSibling();
+    const typename = this._getNodeText(cursor, input);
+    cursor.parent();
+    return Filter2.typename(typename);
+  }
+  /**
+  * Parse a TextFilter node (quoted string).
+  */
+  _parseTextFilter(cursor, input) {
+    cursor.firstChild();
+    const text = this._getNodeText(cursor, input);
+    cursor.parent();
+    return Filter2.text(text.slice(1, -1));
+  }
+  /**
+  * Parse an ObjectLiteral node.
+  */
+  _parseObjectLiteral(cursor, input) {
+    const props = {};
+    if (cursor.firstChild()) {
+      do {
+        if (cursor.node.name === "ObjectProperty") {
+          const { key, value } = this._parseObjectProperty(cursor, input);
+          if (key) {
+            props[key] = Filter2.eq(value);
+          }
+        }
+      } while (cursor.nextSibling());
+      cursor.parent();
+    }
+    return Filter2.props(props);
+  }
+  /**
+  * Parse an ObjectProperty node.
+  */
+  _parseObjectProperty(cursor, input) {
+    let key = null;
+    let value = null;
+    if (cursor.firstChild()) {
+      if (cursor.node.name === "Identifier") {
+        key = this._getNodeText(cursor, input);
+      }
+      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).
+  */
+  _parsePropertyFilter(cursor, input) {
+    let path = null;
+    let value = null;
+    if (cursor.firstChild()) {
+      if (cursor.node.name === "PropertyPath") {
+        path = this._parsePropertyPath(cursor, input);
+      }
+      cursor.nextSibling();
+      cursor.nextSibling();
+      if (cursor.node.name === "Value" && cursor.firstChild()) {
+        value = this._parseValue(cursor, input);
+        cursor.parent();
+      }
+      cursor.parent();
+    }
+    if (!path) {
+      return Filter2.nothing();
+    }
+    return Filter2.props({
+      [path]: value
+    });
+  }
+  /**
+  * Parse a PropertyPath node (supports dot notation).
+  */
+  _parsePropertyPath(cursor, input) {
+    const parts = [];
+    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).
+  */
+  _parseTagFilter(cursor, input) {
+    invariant(this._tags, void 0, {
+      F: __dxlog_file,
+      L: 468,
+      S: this,
+      A: [
+        "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 ? Filter2.tag(key) : void 0;
+  }
+  /**
+  * Parse a Value node.
+  */
+  _parseValue(cursor, input) {
+    const valueType = cursor.node.name;
+    switch (valueType) {
+      case "String": {
+        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": {
+        const props = {};
+        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": {
+        const array = [];
+        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.
+  */
+  _getNodeText(cursor, input) {
+    return input.slice(cursor.from, cursor.to);
+  }
+};
+export {
+  QueryBuilder,
+  QueryDSL
+};
 //# sourceMappingURL=index.mjs.map

package/dist/lib/browser/index.mjs.map

@@ -1,7 +1,7 @@
 {
   "version": 3,
-  "sources": [],
-  "sourcesContent": [],
-  "mappings": "",
-  "names": []
+  "sources": ["../../../src/parser/gen/query.ts", "../../../src/parser/gen/query.terms.ts", "../../../src/parser/gen/index.ts", "../../../src/parser/query-builder.ts"],
+  "sourcesContent": ["// This file was generated by lezer-generator. You probably shouldn't edit it.\nimport {LRParser} from \"@lezer/lr\"\nconst spec_Identifier = {__proto__:null,type:26, NOT:86, not:86, \"!\":86, AND:88, and:88, OR:90, or:90}\nexport const parser = LRParser.deserialize({\n  version: 14,\n  states: \"(jOVQPOOOnQPO'#ClOOQO'#Cd'#CdOOQO'#Cf'#CfOyQPO'#ChO!OQPO'#CrO!WQPO'#CkOOQO'#Cc'#CcOOQO'#Cz'#CzOOQO'#DW'#DWOVQPO'#DWQ!]QPOOOVQPO'#DWO!mQPO,58xO!rQPO'#DQO!wQPO,59WO#PQPO,59SO#UQPO'#CtOOQO,59^,59^O#ZQPO,59^O#cQQO,59VO#wQPO,59rOOQO'#C{'#C{OOQO'#C|'#C|OOQO'#C}'#C}OVQPO,59rOVQPO,59rOVQPO,59rO$rQPO,59rOVQPO1G.dOOQO,59l,59lOOQO-E7O-E7OOOQO1G.n1G.nO#cQQO,59`O%VQPO'#DRO%[QPO1G.xOOQO1G.x1G.xO%dQQO'#CwOOQO'#Cn'#CnOOQO1G.q1G.qO%kQPO1G/^O&RQPO1G/^O&iQPO1G/^OOQO1G/^1G/^O'PQPO7+$OOOQO1G.z1G.zOOQO,59m,59mOOQO-E7P-E7POOQO7+$d7+$dOOQO,59c,59cO'dQPO,59cOOQO<<Gj<<GjO#cQQO'#DSO'lQPO1G.}OOQO1G.}1G.}OOQO,59n,59nOOQO-E7Q-E7QOOQO7+$i7+$i\",\n  stateData: \"'t~OyOS~ORPOT[OXQOZRO]SOgTO{WO~OS]Oa^O^`X~O^`O~ORaOjbO~O^dO~OrhOshO|fO}gO~PVOTmO~ORnO~Oa^O^`a~ORpO~O^qO~OirOjtO~OZvOcvOdvOevOgTOluO~O{WORzaTzaXzaZza]zagzarzaszawza|za}zaUza~OU{OrhOshO|fO}gO~PVORaO~OirOj!QO~Om!RO~P#cOrzisziwzi|zi}ziUzi~PVO|fOrzisziwzi}ziUzi~PVO|fO}gOrzisziwziUzi~PVOU!TOrhOshO|fO}gO~PVOi!UOm!WO~Oi!UOm!ZO~O\",\n  goto: \"%h{PP|PPPP|!]P!]P!]PP!]!lP!{PPP#XP#nPP#hPP#t$U$]$cPP$h$n$tPPP$zkXOYZ[ijklmxyz|kVOYZ[ijklmxyz|kUOYZ[ijklmxyz|QwdQ}qQ!SuR!X!UjVOYZ[ijklmxyz|Xvdqu!UQcTR!OrmYOYZ[eijklmxyz|ZiZlyz|XjZlz|VkZl|Q_PRo_QscR!PsQ!V!SR!Y!VQZO`eYZelxyz|Ql[QxiQyjQzkR|m\",\n  nodeNames: \"⚠ Query Assignment Identifier = ( ) Filter TagFilter Tag TextFilter String TypeFilter TypeKeyword : PropertyFilter PropertyPath . Value Number Boolean Null ObjectLiteral { ObjectProperty , } ArrayLiteral [ ] Not And Or Relation ArrowRight ArrowLeft\",\n  maxTerm: 45,\n  skippedNodes: [0],\n  repeatNodeCount: 3,\n  tokenData: \"3P~RsX^#`pq#`rs$Tst%qwx&ixy(Qyz(V|}([}!O(a!O!P*Q!Q![(j![!]*V!^!_*[!_!`*g!c!}*l!}#O+W#P#Q+]#R#S*l#T#Y*l#Y#Z+b#Z#b*l#b#c.q#c#h*l#h#i1c#i#o*l#o#p2u#q#r2z#y#z#`$f$g#`#BY#BZ#`$IS$I_#`$I|$JO#`$JT$JU#`$KV$KW#`&FU&FV#`~#eYy~X^#`pq#`#y#z#`$f$g#`#BY#BZ#`$IS$I_#`$I|$JO#`$JT$JU#`$KV$KW#`&FU&FV#`~$WVOr$Trs$ms#O$T#O#P$r#P;'S$T;'S;=`%k<%lO$T~$rOZ~~$uRO;'S$T;'S;=`%O;=`O$T~%RWOr$Trs$ms#O$T#O#P$r#P;'S$T;'S;=`%k;=`<%l$T<%lO$T~%nP;=`<%l$T~%tT}!O&T!Q![&T!c!}&T#R#S&T#T#o&T~&YTX~}!O&T!Q![&T!c!}&T#R#S&T#T#o&T~&lVOw&iwx$mx#O&i#O#P'R#P;'S&i;'S;=`'z<%lO&i~'URO;'S&i;'S;=`'_;=`O&i~'bWOw&iwx$mx#O&i#O#P'R#P;'S&i;'S;=`'z;=`<%l&i<%lO&i~'}P;=`<%l&i~(VOT~~([OU~~(aOi~~(dQ!Q![(j!`!a){~(oSc~!O!P({!Q![(j!g!h)a#X#Y)a~)OP!Q![)R~)WRc~!Q![)R!g!h)a#X#Y)a~)dR{|)m}!O)m!Q![)s~)pP!Q![)s~)xPc~!Q![)s~*QOr~~*VOa~~*[O^~~*_P}!O*b~*gOs~~*lOS~P*qVRP}!O*l!O!P*l!P!Q*l!Q![*l!c!}*l#R#S*l#T#o*l~+]Ol~~+bOm~R+gWRP}!O*l!O!P*l!P!Q*l!Q![*l!c!}*l#R#S*l#T#U,P#U#o*lR,UXRP}!O*l!O!P*l!P!Q*l!Q![*l!c!}*l#R#S*l#T#`*l#`#a,q#a#o*lR,vXRP}!O*l!O!P*l!P!Q*l!Q![*l!c!}*l#R#S*l#T#g*l#g#h-c#h#o*lR-hXRP}!O*l!O!P*l!P!Q*l!Q![*l!c!}*l#R#S*l#T#X*l#X#Y.T#Y#o*lR.[VdQRP}!O*l!O!P*l!P!Q*l!Q![*l!c!}*l#R#S*l#T#o*lR.vXRP}!O*l!O!P*l!P!Q*l!Q![*l!c!}*l#R#S*l#T#i*l#i#j/c#j#o*lR/hXRP}!O*l!O!P*l!P!Q*l!Q![*l!c!}*l#R#S*l#T#`*l#`#a0T#a#o*lR0YXRP}!O*l!O!P*l!P!Q*l!Q![*l!c!}*l#R#S*l#T#`*l#`#a0u#a#o*lR0|VRPeQ}!O*l!O!P*l!P!Q*l!Q![*l!c!}*l#R#S*l#T#o*lR1hXRP}!O*l!O!P*l!P!Q*l!Q![*l!c!}*l#R#S*l#T#f*l#f#g2T#g#o*lR2YXRP}!O*l!O!P*l!P!Q*l!Q![*l!c!}*l#R#S*l#T#i*l#i#j-c#j#o*l~2zOg~~3POj~\",\n  tokenizers: [0, 1],\n  topRules: {\"Query\":[0,1]},\n  specialized: [{term: 3, get: (value: keyof typeof spec_Identifier) => spec_Identifier[value] || -1}],\n  tokenPrec: 0\n})\n", "// This file was generated by lezer-generator. You probably shouldn't edit it.\nexport const\n  Query = 1,\n  Assignment = 2,\n  Identifier = 3,\n  Filter = 7,\n  TagFilter = 8,\n  Tag = 9,\n  TextFilter = 10,\n  String = 11,\n  TypeFilter = 12,\n  TypeKeyword = 13,\n  PropertyFilter = 15,\n  PropertyPath = 16,\n  Value = 18,\n  Number = 19,\n  Boolean = 20,\n  Null = 21,\n  ObjectLiteral = 22,\n  ObjectProperty = 24,\n  ArrayLiteral = 27,\n  Not = 30,\n  And = 31,\n  Or = 32,\n  Relation = 33,\n  ArrowRight = 34,\n  ArrowLeft = 35\n", "//\n// Copyright 2025 DXOS.org\n//\n\nimport { LRParser } from '@lezer/lr';\nimport { parser } from './query';\nimport * as terms from './query.terms';\n\nexport namespace QueryDSL {\n  export const Parser: LRParser = parser;\n  export const Node = terms;\n  export const Tokens = ['type:', 'AND', 'OR', 'NOT'];\n}\n", "//\n// Copyright 2025 DXOS.org\n//\n\nimport { type Parser, type Tree, type TreeCursor } from '@lezer/common';\n\nimport { Filter, type Tag } from '@dxos/echo';\nimport { invariant } from '@dxos/invariant';\n\nimport { QueryDSL } from './gen';\n\n// TODO(burdon): Return Query AST.\nexport type BuildResult = { filter?: Filter.Any; name?: string };\n\n/**\n * Stateless query builder that parses DSL trees into filters.\n *\n * NOTE: QueryBuilder was largely developed using Claude Sonnet 4.5 (in Windsurf)..\n * To modify the functionality, create a minimal breaking test and direct the LLM to fix either the grammar or builder.\n */\nexport class QueryBuilder {\n  private readonly _parser: Parser = QueryDSL.Parser.configure({ strict: true });\n\n  constructor(private readonly _tags?: Tag.TagMap) {}\n\n  /**\n   * Check valid input.\n   */\n  validate(input: string): boolean {\n    try {\n      const tree = this._parser.parse(input);\n      return tree.cursor().node.name === 'Query';\n    } catch {\n      return false;\n    }\n  }\n\n  /**\n   * Build a query from the input string.\n   */\n  build(input: string): BuildResult {\n    try {\n      const tree = this._parser.parse(input);\n      return this.buildQuery(tree, input);\n    } catch {\n      return {};\n    }\n  }\n\n  /**\n   * Build a query from a parsed DSL tree.\n   */\n  buildQuery(tree: Tree, input: string): BuildResult {\n    const cursor = tree.cursor();\n\n    // Start at root (Query node).\n    if (cursor.node.name !== 'Query') {\n      return {};\n    }\n\n    // Check if Query has multiple children (binary expression).\n    const children: Array<{ name: string; from: number; to: number }> = [];\n    if (cursor.firstChild()) {\n      do {\n        children.push({ name: cursor.node.name, from: cursor.from, to: cursor.to });\n      } while (cursor.nextSibling());\n      cursor.parent();\n    }\n\n    // Check if this is an assignment.\n    const hasAssignment = children.some((child) => child.name === 'Assignment');\n    if (hasAssignment) {\n      return this._parseAssignment(cursor, input);\n    }\n\n    // If we have an operator in the children, or multiple expressions (implicit AND), parse as binary expression.\n    const hasOperator = children.some((child) => child.name === 'And' || child.name === 'Or');\n    const hasMultipleExpressions =\n      children.filter((child) => child.name === 'Filter' || child.name === 'Not' || child.name === '(').length > 1;\n    if (hasOperator || hasMultipleExpressions) {\n      const filter = this._parseBinaryExpression(cursor, input);\n      return { filter };\n    }\n\n    // Otherwise, parse the single expression.\n    if (!cursor.firstChild()) {\n      return { filter: Filter.nothing() };\n    }\n\n    const filter = this._parseExpression(cursor, input);\n    return { filter };\n  }\n\n  /**\n   * Parse an assignment node.\n   */\n  private _parseAssignment(cursor: TreeCursor, input: string): BuildResult {\n    if (!cursor.firstChild()) {\n      return {};\n    }\n\n    let name: string | undefined;\n    let filter: Filter.Any | undefined;\n\n    // Find the Assignment node\n    do {\n      if (cursor.node.name === 'Assignment') {\n        // Get the full assignment text first\n        const assignmentText = this._getNodeText(cursor, input);\n\n        if (cursor.firstChild()) {\n          // First child should be the variable name (Identifier)\n          name = this._getNodeText(cursor, input);\n\n          // Find the parentheses in the assignment text and extract the content\n          const openParenIndex = assignmentText.indexOf('(');\n          const closeParenIndex = assignmentText.lastIndexOf(')');\n\n          if (openParenIndex !== -1 && closeParenIndex !== -1 && closeParenIndex > openParenIndex) {\n            const subInput = assignmentText.slice(openParenIndex + 1, closeParenIndex).trim();\n            const subTree = this._parser.parse(subInput);\n            const subResult = this.buildQuery(subTree, subInput);\n            filter = subResult.filter;\n          }\n\n          cursor.parent(); // Back to Assignment\n        }\n        break;\n      }\n    } while (cursor.nextSibling());\n\n    cursor.parent(); // Back to Query\n    return { filter, name };\n  }\n\n  /**\n   * Parse an expression node.\n   */\n  private _parseExpression(cursor: TreeCursor, input: string): Filter.Any | undefined {\n    const nodeName = cursor.node.name;\n\n    switch (nodeName) {\n      case 'Filter':\n        return this._parseFilter(cursor, input);\n\n      case 'Not': {\n        // Move past NOT token to the expression.\n        cursor.nextSibling();\n        const notFilter = this._parseExpression(cursor, input);\n        return notFilter ? Filter.not(notFilter) : undefined;\n      }\n\n      case 'And':\n      case 'Or':\n        // This is the operator node, we need to handle the binary expression.\n        // The cursor is positioned at the operator, we need to go back to parent.\n        cursor.parent();\n        return this._parseBinaryExpression(cursor, input);\n\n      case '(': {\n        // Skip opening paren.\n        cursor.nextSibling();\n        const parenFilter = this._parseExpression(cursor, input);\n        // Skip closing paren.\n        cursor.nextSibling();\n        return parenFilter;\n      }\n\n      default: {\n        // Check if this is a binary expression (has And/Or as a child).\n        const savedPos = cursor.from;\n        if (cursor.firstChild()) {\n          // Look for And/Or operators or multiple expressions (implicit AND).\n          let hasOperator = false;\n          let expressionCount = 0;\n          do {\n            if (cursor.node.name === 'And' || cursor.node.name === 'Or') {\n              hasOperator = true;\n              break;\n            }\n            if (cursor.node.name === 'Filter' || cursor.node.name === 'Not' || cursor.node.name === '(') {\n              expressionCount++;\n            }\n          } while (cursor.nextSibling());\n          hasOperator = hasOperator || expressionCount > 1;\n\n          // Reset cursor to the saved position.\n          cursor.parent();\n          cursor.firstChild();\n          while (cursor.from !== savedPos && cursor.nextSibling()) {}\n\n          if (hasOperator) {\n            cursor.parent();\n            return this._parseBinaryExpression(cursor, input);\n          } else {\n            const result = this._parseExpression(cursor, input);\n            cursor.parent();\n            return result;\n          }\n        }\n        return Filter.nothing();\n      }\n    }\n  }\n\n  /**\n   * Parse a binary expression (AND/OR).\n   */\n  private _parseBinaryExpression(cursor: TreeCursor, input: string): Filter.Any {\n    const filters: Filter.Any[] = [];\n    let operator: 'and' | 'or' | null = null;\n\n    // Collect all filters and operators.\n    if (cursor.firstChild()) {\n      do {\n        const nodeName = cursor.node.name;\n\n        if (nodeName === 'And' || nodeName === 'Or') {\n          operator = nodeName.toLowerCase() as 'and' | 'or';\n        } else if (nodeName === '(') {\n          // Handle parenthesized expression.\n          // Look ahead to see if this is a binary expression.\n          const savedPos = cursor.from;\n          cursor.nextSibling(); // Move past '('\n\n          // Check if the parentheses contain a binary expression.\n          let hasBinaryOp = false;\n          do {\n            if (cursor.node.name === 'And' || cursor.node.name === 'Or') {\n              hasBinaryOp = true;\n              break;\n            }\n          } while (cursor.nextSibling() && cursor.node.name !== ')');\n\n          // Reset cursor to start of parenthesized content.\n          cursor.parent();\n          cursor.firstChild();\n          while (cursor.from !== savedPos && cursor.nextSibling()) {}\n          cursor.nextSibling(); // Move past '(' again.\n\n          if (hasBinaryOp) {\n            // Find the matching closing parenthesis.\n            let depth = 1;\n            const exprStart = cursor.from;\n            let exprEnd = cursor.to;\n\n            while (cursor.nextSibling() && depth > 0) {\n              if (cursor.node.name === '(') depth++;\n              else if (cursor.node.name === ')') {\n                depth--;\n                if (depth === 0) {\n                  exprEnd = cursor.from;\n                }\n              }\n            }\n\n            // Parse the expression inside parentheses as a subtree.\n            const subInput = input.slice(exprStart, exprEnd);\n            const subTree = this._parser.parse(subInput);\n            const subResult = this.buildQuery(subTree, subInput);\n            if (subResult.filter) {\n              filters.push(subResult.filter);\n            }\n          } else {\n            // Simple parenthesized expression.\n            const subFilter = this._parseExpression(cursor, input);\n            if (subFilter) {\n              filters.push(subFilter);\n            }\n\n            // Skip until we find the closing parenthesis.\n            while (cursor.nextSibling() && cursor.node.name !== ')') {}\n          }\n        } else if (nodeName !== ')') {\n          const subFilter = this._parseExpression(cursor, input);\n          if (subFilter) {\n            filters.push(subFilter);\n          }\n        }\n      } while (cursor.nextSibling());\n\n      cursor.parent();\n    }\n\n    if (filters.length === 0) {\n      return Filter.nothing();\n    }\n\n    if (filters.length === 1) {\n      return filters[0];\n    }\n\n    return operator === 'or' ? Filter.or(...filters) : Filter.and(...filters);\n  }\n\n  /**\n   * Parse a Filter node.\n   */\n  private _parseFilter(cursor: TreeCursor, input: string): Filter.Any | undefined {\n    if (!cursor.firstChild()) {\n      return Filter.nothing();\n    }\n\n    let result: Filter.Any | undefined = undefined;\n    const filterType = cursor.node.name;\n    switch (filterType) {\n      case 'TagFilter':\n        if (this._tags) {\n          result = this._parseTagFilter(cursor, input);\n        }\n        break;\n\n      case 'TextFilter':\n        result = this._parseTextFilter(cursor, input);\n        break;\n\n      case 'TypeFilter':\n        result = this._parseTypeFilter(cursor, input);\n        break;\n\n      case 'ObjectLiteral':\n        result = this._parseObjectLiteral(cursor, input);\n        break;\n\n      case 'PropertyFilter':\n        result = this._parsePropertyFilter(cursor, input);\n        break;\n\n      default:\n        result = Filter.nothing();\n    }\n\n    cursor.parent();\n    return result;\n  }\n\n  /**\n   * Parse a TypeFilter node (type:typename).\n   */\n  private _parseTypeFilter(cursor: TreeCursor, input: string): Filter.Any {\n    // Skip TypeKeyword.\n    cursor.firstChild();\n    cursor.nextSibling(); // Skip ':'\n    cursor.nextSibling(); // Move to Identifier\n\n    const typename = this._getNodeText(cursor, input);\n    cursor.parent(); // Go back to TypeFilter.\n    return Filter.typename(typename);\n  }\n\n  /**\n   * Parse a TextFilter node (quoted string).\n   */\n  private _parseTextFilter(cursor: TreeCursor, input: string): Filter.Any {\n    cursor.firstChild(); // Move to String node.\n    const text = this._getNodeText(cursor, input);\n    cursor.parent(); // Go back to TextFilter.\n    // Remove quotes.\n    return Filter.text(text.slice(1, -1));\n  }\n\n  /**\n   * Parse an ObjectLiteral node.\n   */\n  private _parseObjectLiteral(cursor: TreeCursor, input: string): Filter.Any {\n    const props: Record<string, any> = {};\n\n    if (cursor.firstChild()) {\n      do {\n        if (cursor.node.name === 'ObjectProperty') {\n          const { key, value } = this._parseObjectProperty(cursor, input);\n          if (key) {\n            // Convert simple values to Filter.eq for compatibility with Filter.props.\n            props[key] = Filter.eq(value);\n          }\n        }\n      } while (cursor.nextSibling());\n\n      cursor.parent();\n    }\n\n    return Filter.props(props);\n  }\n\n  /**\n   * Parse an ObjectProperty node.\n   */\n  private _parseObjectProperty(cursor: TreeCursor, input: string): { key: string | null; value: any } {\n    let key: string | null = null;\n    let value: any = null;\n\n    if (cursor.firstChild()) {\n      // First child should be the property name (Identifier).\n      if (cursor.node.name === 'Identifier') {\n        key = this._getNodeText(cursor, input);\n      }\n\n      // Skip ':' and move to Value.\n      cursor.nextSibling();\n      cursor.nextSibling();\n\n      if (cursor.node.name === 'Value' && cursor.firstChild()) {\n        value = this._parseValue(cursor, input);\n        cursor.parent();\n      }\n\n      cursor.parent();\n    }\n\n    return { key, value };\n  }\n\n  /**\n   * Parse a PropertyFilter node (property:value).\n   */\n  private _parsePropertyFilter(cursor: TreeCursor, input: string): Filter.Any {\n    let path: string | null = null;\n    let value: any = null;\n\n    if (cursor.firstChild()) {\n      // First child is PropertyPath.\n      if (cursor.node.name === 'PropertyPath') {\n        path = this._parsePropertyPath(cursor, input);\n      }\n\n      // Skip ':' and move to Value.\n      cursor.nextSibling();\n      cursor.nextSibling();\n\n      if (cursor.node.name === 'Value' && cursor.firstChild()) {\n        value = this._parseValue(cursor, input);\n        cursor.parent();\n      }\n\n      cursor.parent();\n    }\n\n    if (!path) {\n      return Filter.nothing();\n    }\n\n    return Filter.props({ [path]: value });\n  }\n\n  /**\n   * Parse a PropertyPath node (supports dot notation).\n   */\n  private _parsePropertyPath(cursor: TreeCursor, input: string): string {\n    const parts: string[] = [];\n\n    if (cursor.firstChild()) {\n      do {\n        if (cursor.node.name === 'Identifier') {\n          parts.push(this._getNodeText(cursor, input));\n        }\n      } while (cursor.nextSibling());\n\n      cursor.parent();\n    }\n\n    return parts.join('.');\n  }\n\n  /**\n   * Parse a TagFilter node (#tag).\n   */\n  private _parseTagFilter(cursor: TreeCursor, input: string): Filter.Any | undefined {\n    invariant(this._tags);\n    const str = this._getNodeText(cursor, input).slice(1).toLowerCase();\n    const [key] = Object.entries(this._tags!).find(([, value]) => value.label.toLowerCase() === str) ?? [];\n    return key ? Filter.tag(key) : undefined;\n  }\n\n  /**\n   * Parse a Value node.\n   */\n  private _parseValue(cursor: TreeCursor, input: string): any {\n    const valueType = cursor.node.name;\n\n    switch (valueType) {\n      case 'String': {\n        // Remove quotes.\n        const str = this._getNodeText(cursor, input);\n        return str.slice(1, -1);\n      }\n\n      case 'Number':\n        return Number(this._getNodeText(cursor, input));\n\n      case 'Boolean':\n        return this._getNodeText(cursor, input) === 'true';\n\n      case 'Null':\n        return null;\n\n      case 'ObjectLiteral': {\n        // For nested objects, parse recursively.\n        const props: Record<string, any> = {};\n        if (cursor.firstChild()) {\n          do {\n            if (cursor.node.name === 'ObjectProperty') {\n              const { key, value } = this._parseObjectProperty(cursor, input);\n              if (key) {\n                props[key] = value;\n              }\n            }\n          } while (cursor.nextSibling());\n          cursor.parent();\n        }\n        return props;\n      }\n\n      case 'ArrayLiteral': {\n        // Parse array values\n        const array: any[] = [];\n        if (cursor.firstChild()) {\n          do {\n            if (cursor.node.name === 'Value' && cursor.firstChild()) {\n              array.push(this._parseValue(cursor, input));\n              cursor.parent();\n            }\n          } while (cursor.nextSibling());\n          cursor.parent();\n        }\n        return array;\n      }\n\n      default:\n        return null;\n    }\n  }\n\n  /**\n   * Get the text content of the current node.\n   */\n  private _getNodeText(cursor: TreeCursor, input: string): string {\n    return input.slice(cursor.from, cursor.to);\n  }\n}\n"],
+  "mappings": "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",
+  "names": ["LRParser", "spec_Identifier", "__proto__", "type", "NOT", "not", "AND", "and", "OR", "or", "parser", "LRParser", "deserialize", "version", "states", "stateData", "goto", "nodeNames", "maxTerm", "skippedNodes", "repeatNodeCount", "tokenData", "tokenizers", "topRules", "specialized", "term", "get", "value", "tokenPrec", "Number", "Query", "Assignment", "Identifier", "Filter", "TagFilter", "Tag", "TextFilter", "String", "TypeFilter", "TypeKeyword", "PropertyFilter", "PropertyPath", "Value", "Number", "Boolean", "Null", "ObjectLiteral", "ObjectProperty", "ArrayLiteral", "Not", "And", "Or", "Relation", "ArrowRight", "ArrowLeft", "QueryDSL", "Parser", "parser", "Node", "terms", "Tokens", "Filter", "invariant", "QueryBuilder", "_parser", "QueryDSL", "Parser", "configure", "strict", "_tags", "validate", "input", "tree", "parse", "cursor", "node", "name", "build", "buildQuery", "children", "firstChild", "push", "from", "to", "nextSibling", "parent", "hasAssignment", "some", "child", "_parseAssignment", "hasOperator", "hasMultipleExpressions", "filter", "length", "_parseBinaryExpression", "Filter", "nothing", "_parseExpression", "assignmentText", "_getNodeText", "openParenIndex", "indexOf", "closeParenIndex", "lastIndexOf", "subInput", "slice", "trim", "subTree", "subResult", "nodeName", "_parseFilter", "notFilter", "not", "undefined", "parenFilter", "savedPos", "expressionCount", "result", "filters", "operator", "toLowerCase", "hasBinaryOp", "depth", "exprStart", "exprEnd", "subFilter", "or", "and", "filterType", "_parseTagFilter", "_parseTextFilter", "_parseTypeFilter", "_parseObjectLiteral", "_parsePropertyFilter", "typename", "text", "props", "key", "value", "_parseObjectProperty", "eq", "_parseValue", "path", "_parsePropertyPath", "parts", "join", "invariant", "str", "Object", "entries", "find", "label", "tag", "valueType", "Number", "array"]
 }

package/dist/lib/browser/meta.json

@@ -1 +1 @@
-{"inputs":{"src/index.ts":{"bytes":368,"imports":[],"format":"esm"}},"outputs":{"dist/lib/browser/index.mjs.map":{"imports":[],"exports":[],"inputs":{},"bytes":93},"dist/lib/browser/index.mjs":{"imports":[],"exports":[],"entryPoint":"src/index.ts","inputs":{"src/index.ts":{"bytesInOutput":0}},"bytes":68}}}
+{"inputs":{"src/parser/gen/query.ts":{"bytes":9694,"imports":[{"path":"@lezer/lr","kind":"import-statement","external":true}],"format":"esm"},"src/parser/gen/query.terms.ts":{"bytes":2235,"imports":[],"format":"esm"},"src/parser/gen/index.ts":{"bytes":1305,"imports":[{"path":"src/parser/gen/query.ts","kind":"import-statement","original":"./query"},{"path":"src/parser/gen/query.terms.ts","kind":"import-statement","original":"./query.terms"}],"format":"esm"},"src/parser/query-builder.ts":{"bytes":54712,"imports":[{"path":"@dxos/echo","kind":"import-statement","external":true},{"path":"@dxos/invariant","kind":"import-statement","external":true},{"path":"src/parser/gen/index.ts","kind":"import-statement","original":"./gen"}],"format":"esm"},"src/parser/index.ts":{"bytes":555,"imports":[{"path":"src/parser/gen/index.ts","kind":"import-statement","original":"./gen"},{"path":"src/parser/query-builder.ts","kind":"import-statement","original":"./query-builder"}],"format":"esm"},"src/index.ts":{"bytes":454,"imports":[{"path":"src/parser/index.ts","kind":"import-statement","original":"./parser"}],"format":"esm"}},"outputs":{"dist/lib/browser/index.mjs.map":{"imports":[],"exports":[],"inputs":{},"bytes":32045},"dist/lib/browser/index.mjs":{"imports":[{"path":"@lezer/lr","kind":"import-statement","external":true},{"path":"@dxos/echo","kind":"import-statement","external":true},{"path":"@dxos/invariant","kind":"import-statement","external":true}],"exports":["QueryBuilder","QueryDSL"],"entryPoint":"src/index.ts","inputs":{"src/parser/gen/query.ts":{"bytesInOutput":3499},"src/parser/gen/query.terms.ts":{"bytesInOutput":1242},"src/parser/gen/index.ts":{"bytesInOutput":211},"src/parser/query-builder.ts":{"bytesInOutput":12394},"src/index.ts":{"bytesInOutput":0}},"bytes":17742}}}