@dxos/echo-query 0.8.3 → 0.8.4-main.1068cf700f

package/dist/lib/neutral/index.mjs

@@ -0,0 +1,719 @@
+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: () => String2,
+  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 String2 = 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);
+  }
+};
+
+// src/sandbox/query-sandbox.ts
+import { Resource } from "@dxos/context";
+import { Query as Query2 } from "@dxos/echo";
+import { trim } from "@dxos/util";
+import { createQuickJS } from "@dxos/vendor-quickjs";
+import envCode from "#query-lite?raw";
+
+// src/sandbox/quickjs.ts
+var unwrapResult = (context, result) => {
+  if (result.error) {
+    const contextError = context.dump(result.error);
+    result.error.dispose();
+    if (typeof contextError === "object" && typeof contextError.name === "string" && typeof contextError.message === "string") {
+      const error = new Error(contextError.message);
+      Object.defineProperty(error, "name", {
+        value: contextError.name
+      });
+      const originalStack = error.stack;
+      error.stack = `${contextError.name}: ${contextError.message}
+${contextError.stack}${originalStack?.split("\n").slice(1).join("\n") ?? ""}`;
+      throw error;
+    } else {
+      throw new Error(String(contextError));
+    }
+  }
+  return result.value;
+};
+
+// src/sandbox/query-sandbox.ts
+function _ts_add_disposable_resource(env, value, async) {
+  if (value !== null && value !== void 0) {
+    if (typeof value !== "object" && typeof value !== "function") throw new TypeError("Object expected.");
+    var dispose, inner;
+    if (async) {
+      if (!Symbol.asyncDispose) throw new TypeError("Symbol.asyncDispose is not defined.");
+      dispose = value[Symbol.asyncDispose];
+    }
+    if (dispose === void 0) {
+      if (!Symbol.dispose) throw new TypeError("Symbol.dispose is not defined.");
+      dispose = value[Symbol.dispose];
+      if (async) inner = dispose;
+    }
+    if (typeof dispose !== "function") throw new TypeError("Object not disposable.");
+    if (inner) dispose = function() {
+      try {
+        inner.call(this);
+      } catch (e) {
+        return Promise.reject(e);
+      }
+    };
+    env.stack.push({
+      value,
+      dispose,
+      async
+    });
+  } else if (async) {
+    env.stack.push({
+      async: true
+    });
+  }
+  return value;
+}
+function _ts_dispose_resources(env) {
+  var _SuppressedError = typeof SuppressedError === "function" ? SuppressedError : function(error, suppressed, message) {
+    var e = new Error(message);
+    return e.name = "SuppressedError", e.error = error, e.suppressed = suppressed, e;
+  };
+  return (_ts_dispose_resources = function _ts_dispose_resources2(env2) {
+    function fail(e) {
+      env2.error = env2.hasError ? new _SuppressedError(e, env2.error, "An error was suppressed during disposal.") : e;
+      env2.hasError = true;
+    }
+    var r, s = 0;
+    function next() {
+      while (r = env2.stack.pop()) {
+        try {
+          if (!r.async && s === 1) return s = 0, env2.stack.push(r), Promise.resolve().then(next);
+          if (r.dispose) {
+            var result = r.dispose.call(r.value);
+            if (r.async) return s |= 2, Promise.resolve(result).then(next, function(e) {
+              fail(e);
+              return next();
+            });
+          } else s |= 1;
+        } catch (e) {
+          fail(e);
+        }
+      }
+      if (s === 1) return env2.hasError ? Promise.reject(env2.error) : Promise.resolve();
+      if (env2.hasError) throw env2.error;
+    }
+    return next();
+  })(env);
+}
+var QuerySandbox = class _QuerySandbox extends Resource {
+  // Caching the wasm module.
+  static quickJS = null;
+  static getQuickJS() {
+    if (!_QuerySandbox.quickJS) {
+      _QuerySandbox.quickJS = createQuickJS();
+    }
+    return _QuerySandbox.quickJS;
+  }
+  #runtime;
+  async _open() {
+    const quickJS = await _QuerySandbox.getQuickJS();
+    this.#runtime = quickJS.newRuntime({
+      moduleLoader: (moduleName, _context) => {
+        switch (moduleName) {
+          case "dxos:query-lite":
+            return envCode;
+          default:
+            throw new Error(`Module not found: ${moduleName}`);
+        }
+      }
+    });
+  }
+  async _close() {
+    this.#runtime.dispose();
+  }
+  /**
+  * Evaluates the query code.
+  * @param queryCode Example: `Query.select(Filter.typename('dxos.org/type/Person'))`
+  */
+  eval(queryCode) {
+    const env = {
+      stack: [],
+      error: void 0,
+      hasError: false
+    };
+    try {
+      const context = _ts_add_disposable_resource(env, this.#runtime.newContext(), false);
+      const globals = trim`
+      import { Filter, Order, Query } from 'dxos:query-lite';
+      globalThis.Filter = Filter;
+      globalThis.Order = Order;
+      globalThis.Query = Query;
+    `;
+      unwrapResult(context, context.evalCode(globals)).dispose();
+      const query = _ts_add_disposable_resource(env, unwrapResult(context, context.evalCode(queryCode)), false);
+      const result = context.dump(query);
+      if ("~Filter" in result) {
+        return Query2.select(result).ast;
+      } else {
+        return result.ast;
+      }
+    } catch (e) {
+      env.error = e;
+      env.hasError = true;
+    } finally {
+      _ts_dispose_resources(env);
+    }
+  }
+};
+export {
+  QueryBuilder,
+  QueryDSL,
+  QuerySandbox
+};
+//# sourceMappingURL=index.mjs.map