@witchcraft/expressit 0.1.3 → 0.2.1

package/dist/Parser.js

@@ -1,9 +1,6 @@
 var __defProp = Object.defineProperty;
 var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
-var __publicField = (obj, key, value) => {
-  __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
-  return value;
-};
+var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
 import { get } from "@alanscodelog/utils/get.js";
 import { insert } from "@alanscodelog/utils/insert.js";
 import { isArray } from "@alanscodelog/utils/isArray.js";
@@ -11,42 +8,35 @@ import { isWhitespace } from "@alanscodelog/utils/isWhitespace.js";
 import { setReadOnly } from "@alanscodelog/utils/setReadOnly.js";
 import { unreachable } from "@alanscodelog/utils/unreachable.js";
 import { pos } from "./ast/builders/pos.js";
-import { ArrayNode } from "./ast/classes/ArrayNode.js";
-import { ConditionNode } from "./ast/classes/ConditionNode.js";
-import { ErrorToken } from "./ast/classes/ErrorToken.js";
-import { ExpressionNode } from "./ast/classes/ExpressionNode.js";
-import { GroupNode } from "./ast/classes/GroupNode.js";
-import { Condition } from "./ast/classes/Condition.js";
-import { Expression } from "./ast/classes/Expression.js";
-import "@alanscodelog/utils/crop.js";
-import "@alanscodelog/utils/indent.js";
-import "@alanscodelog/utils/pretty.js";
-import { ValidToken } from "./ast/classes/ValidToken.js";
-import { VariableNode } from "./ast/classes/VariableNode.js";
+import { createCondition } from "./ast/createNormalizedCondition.js";
+import { createExpression } from "./ast/createNormalizedExpression.js";
 import { token, operator, expression, variable, condition, group, array, delimiter } from "./ast/handlers.js";
-import { applyBoolean } from "./helpers/general/applyBoolean.js";
-import { applyPrefix } from "./helpers/general/applyPrefix.js";
-import { checkParserOpts } from "./helpers/parser/checkParserOpts.js";
-import { extractPosition } from "./helpers/parser/extractPosition.js";
-import { getUnclosedRightParenCount } from "./helpers/parser/getUnclosedRightParenCount.js";
-import { parseParserOptions } from "./helpers/parser/parseParserOptions.js";
-import { seal } from "./helpers/parser/seal.js";
+import { applyBoolean } from "./internal/applyBoolean.js";
+import { applyPrefix } from "./internal/applyPrefix.js";
+import { checkParserOpts } from "./internal/checkParserOpts.js";
+import { escapeVariableOrPrefix } from "./internal/escapeVariableOrPrefix.js";
+import { extractPosition } from "./internal/extractPosition.js";
+import { getUnclosedRightParenCount } from "./internal/getUnclosedRightParenCount.js";
+import { parseParserOptions } from "./internal/parseParserOptions.js";
+import { unescape } from "./internal/unescape.js";
 import { Lexer, $C, $T } from "./Lexer.js";
-import { TOKEN_TYPE } from "./types/ast.js";
+import { TOKEN_TYPE, AST_TYPE } from "./types/ast.js";
 import { SUGGESTION_TYPE } from "./types/autocomplete.js";
 import { extractTokens } from "./utils/extractTokens.js";
+import { generateParentsMap } from "./utils/generateParentsMap.js";
 import { getCursorInfo } from "./utils/getCursorInfo.js";
+import { getParent } from "./utils/getParent.js";
 import { getSurroundingErrors } from "./utils/getSurroundingErrors.js";
+import { isNode } from "./utils/isNode.js";
+import { isToken } from "./utils/isToken.js";
 const OPPOSITE = {
   [TOKEN_TYPE.AND]: TOKEN_TYPE.OR,
   [TOKEN_TYPE.OR]: TOKEN_TYPE.AND
 };
 function isEqualSet(setA, setB) {
-  if (setA.size !== setB.size)
-    return false;
+  if (setA.size !== setB.size) return false;
   for (const key of setA) {
-    if (!setB.has(key))
-      return false;
+    if (!setB.has(key)) return false;
   }
   return true;
 }
@@ -62,10 +52,9 @@ const createDefaultRequires = (partial = {}) => ({
   group: partial.group ?? false,
   prefix: partial.prefix ?? false
 });
-const tokenRequiresWhitespace = (validToken, whitespace, wordOps) => {
-  if (whitespace || validToken === void 0)
-    return false;
-  return validToken.type === TOKEN_TYPE.VALUE || [TOKEN_TYPE.AND, TOKEN_TYPE.OR, TOKEN_TYPE.NOT].includes(validToken.type) && wordOps.find((_) => _.value === validToken.value) !== void 0;
+const tokenRequiresWhitespace = (valid, whitespace, wordOps) => {
+  if (whitespace || valid === void 0) return false;
+  return valid.type === TOKEN_TYPE.VALUE || [TOKEN_TYPE.AND, TOKEN_TYPE.OR, TOKEN_TYPE.NOT].includes(valid.type) && wordOps.find((_) => _.value === valid.value) !== void 0;
 };
 const tokenVariable = [TOKEN_TYPE.BACKTICK, TOKEN_TYPE.DOUBLEQUOTE, TOKEN_TYPE.SINGLEQUOTE, TOKEN_TYPE.VALUE, TOKEN_TYPE.REGEX];
 class Parser {
@@ -140,8 +129,6 @@ class Parser {
    * It can also parse the result from `lex`, but that is really only for internal use.
    */
   parse(input) {
-    var _a;
-    const doSeal = ((_a = arguments[1]) == null ? void 0 : _a.seal) ?? true;
     if (typeof input === "string" && isWhitespace(input)) {
       return token.value(void 0, { start: 0, end: 0 });
     }
@@ -153,9 +140,6 @@ class Parser {
       lexedTokens
     };
     const res = this.ruleMain();
-    if (doSeal) {
-      seal(res);
-    }
     this.state = {
       rawInput: "",
       shift: 0,
@@ -190,13 +174,10 @@ class Parser {
     return false;
   }
   isType(token2, type) {
-    if (token2 === void 0)
-      return false;
-    if (token2.type === type)
-      return true;
+    if (token2 === void 0) return false;
+    if (token2.type === type) return true;
     const tokenType = this.getTokenType(token2.type);
-    if ((tokenType == null ? void 0 : tokenType.type) === type)
-      return true;
+    if ((tokenType == null ? void 0 : tokenType.type) === type) return true;
     const category = this.$categories[type];
     if ((category == null ? void 0 : category.entries[token2.type]) !== void 0) {
       return true;
@@ -337,38 +318,36 @@ class Parser {
       }
       this.restoreState(state);
     }
-    if (type === "AND" && pairs.length === 0)
-      return void 0;
+    if (type === "AND" && pairs.length === 0) return void 0;
     let res = pairs[pairs.length - 1][0];
     for (let i = pairs.length - 1; i > 0; i--) {
       const before = pairs[i - 1];
-      if (type === "OR" && res === void 0 && before === void 0)
-        return void 0;
+      if (type === "OR" && res === void 0 && before === void 0) return void 0;
       res = expression(before[0], before[1], res);
     }
     return res;
   }
   ruleCondition() {
-    var _a, _b, _c, _d, _e, _f, _g, _h, _i, _j;
+    var _a, _b, _c, _d, _e, _f, _g, _h, _i, _j, _k;
     const not = this.ruleNot();
     const property = this.ruleConditionProperty();
-    const propVal = ((_a = property == null ? void 0 : property.prop) == null ? void 0 : _a.value) === void 0 ? void 0 : property.prop.value instanceof ErrorToken ? "" : property.prop.value.value;
-    const propOpVal = ((_b = property == null ? void 0 : property.rest) == null ? void 0 : _b.propertyOperator) === void 0 ? void 0 : property.rest.propertyOperator instanceof ErrorToken ? "" : (_c = property.rest.propertyOperator) == null ? void 0 : _c.value;
-    const isExpanded = (((_d = property == null ? void 0 : property.rest) == null ? void 0 : _d.sepL) ?? ((_e = property == null ? void 0 : property.rest) == null ? void 0 : _e.sepR)) !== void 0;
+    const propVal = ((_a = property == null ? void 0 : property.prop) == null ? void 0 : _a.value) === void 0 ? void 0 : !property.prop.value.valid ? "" : property.prop.value.value;
+    const propOpVal = ((_b = property == null ? void 0 : property.rest) == null ? void 0 : _b.propertyOperator) === void 0 ? void 0 : !((_c = property.rest.propertyOperator) == null ? void 0 : _c.valid) ? "" : (_d = property.rest.propertyOperator) == null ? void 0 : _d.value;
+    const isExpanded = (((_e = property == null ? void 0 : property.rest) == null ? void 0 : _e.sepL) ?? ((_f = property == null ? void 0 : property.rest) == null ? void 0 : _f.sepR)) !== void 0;
     const convertRegexValues = typeof this.options.regexValues === "function" && !this.options.regexValues(propVal, propOpVal, isExpanded);
     const convertArrayValues = typeof this.options.arrayValues === "function" && !this.options.arrayValues(propVal, propOpVal, isExpanded);
     let value = this.ruleConditionValue(property, { convertRegexValues, convertArrayValues });
     let group$1;
-    if (!(value instanceof ArrayNode) && !isArray(value) && (!value || this.options.prefixableGroups) && this.isType(this.peek(1), $T.PAREN_L)) {
+    if (isNode(value) && !(value.type === AST_TYPE.ARRAY) && !isArray(value) && (!value || this.options.prefixableGroups) && this.isType(this.peek(1), $T.PAREN_L)) {
       group$1 = this.rulePlainGroup({ onlyValues: property !== void 0, convertRegexValues, convertArrayValues });
     }
     if (isArray(value)) {
       group$1 = value;
       value = void 0;
     }
-    if (convertRegexValues && value instanceof VariableNode && ((_f = value.quote) == null ? void 0 : _f.left.type) === TOKEN_TYPE.REGEX) {
+    if (convertRegexValues && isNode(value) && value.type === AST_TYPE.VARIABLE && ((_g = value.quote) == null ? void 0 : _g.left.type) === TOKEN_TYPE.REGEX) {
       value = variable(void 0, void 0, token.value(
-        (((_h = (_g = value.quote) == null ? void 0 : _g.left) == null ? void 0 : _h.value) ?? "") + (value.value.value ?? "") + (((_j = (_i = value.quote) == null ? void 0 : _i.right) == null ? void 0 : _j.value) ?? ""),
+        (((_i = (_h = value.quote) == null ? void 0 : _h.left) == null ? void 0 : _i.value) ?? "") + (value.value.value ?? "") + (((_k = (_j = value.quote) == null ? void 0 : _j.right) == null ? void 0 : _k.value) ?? ""),
         pos(value)
       ), void 0);
     }
@@ -381,8 +360,7 @@ class Parser {
       }
       return group(not, value, ...group$1);
     }
-    if ([not, property, value].every((_) => _ === void 0))
-      return void 0;
+    if ([not, property, value].every((_) => _ === void 0)) return void 0;
     return condition(not, property == null ? void 0 : property.prop, property == null ? void 0 : property.rest, value);
   }
   ruleConditionValue(property, { convertRegexValues = false, convertArrayValues = false } = {}) {
@@ -393,23 +371,19 @@ class Parser {
     if (this.options.prefixableGroups && property === void 0 && (next == null ? void 0 : next.type) !== $T.PAREN_L && (this.isType(next, $C.VALUE) && (this.isType(next2, $T.PAREN_L) || this.isType(next2, $C.QUOTE_ANY) && this.isType(next3, $T.PAREN_L)) || this.isType(next, $C.QUOTE_ANY) && (this.isType(next2, $T.PAREN_L) || this.isType(next2, $C.VALUE) && (this.isType(next3, $T.PAREN_L) || // "a(
     this.isType(next3, $C.QUOTE_ANY) && this.isType(next4, $T.PAREN_L))))) {
       const res = this.ruleVariable({ unprefixed: true });
-      if (res)
-        return res;
+      if (res) return res;
     }
     if (!this.isType(next, $T.PAREN_L)) {
       const res = this.ruleVariable({ unprefixed: false });
-      if (res)
-        return res;
+      if (res) return res;
     }
     if (this.isType(next, $T.PAREN_L)) {
       const res = this.rulePlainGroup({ onlyValues: property !== void 0, convertRegexValues, convertArrayValues });
-      if (res)
-        return res;
+      if (res) return res;
     }
     if (this.isType(next, $T.BRACKET_L)) {
       const res = this.rulePlainBracketGroup({ convertArrayValues });
-      if (res)
-        return res;
+      if (res) return res;
     }
     return void 0;
   }
@@ -444,7 +418,7 @@ class Parser {
         regexValues: convertRegexValues,
         arrayValues: convertArrayValues
       }, "One");
-      const parsed = this.subParserOne.parse(" ".repeat(start) + subInput, { seal: false });
+      const parsed = this.subParserOne.parse(" ".repeat(start) + subInput);
       return [parenL, parsed, parenR];
     }
     return [parenL, condition2, parenR];
@@ -467,8 +441,7 @@ class Parser {
       }
     }
     const bracketR = this.isType(this.peek(1), $T.BRACKET_R) ? this.ruleBracketR() : void 0;
-    if (bracketL === void 0)
-      throw new Error("bracketL is undefined, peek before using rule.");
+    if (bracketL === void 0) throw new Error("bracketL is undefined, peek before using rule.");
     if (!convertArrayValues) {
       return array(bracketL, values, bracketR);
     }
@@ -481,11 +454,11 @@ class Parser {
       expandedPropertySeparator: void 0,
       arrayValues: false
     }, "Two");
-    const parsed = this.subParserTwo.parse(" ".repeat(start) + subInput, { seal: false });
-    if (parsed instanceof ConditionNode) {
+    const parsed = this.subParserTwo.parse(" ".repeat(start) + subInput);
+    if ("type" in parsed && parsed.type === AST_TYPE.CONDITION) {
       return parsed.value;
     }
-    if (parsed instanceof ErrorToken || parsed instanceof ExpressionNode || parsed instanceof GroupNode) {
+    if ("valid" in parsed && !parsed.valid || "type" in parsed && (parsed.type === AST_TYPE.EXPRESSION || parsed.type === AST_TYPE.GROUP)) {
       unreachable("parsed.value should not be an ErrorToken, ExpressionNode, or GroupNode.");
     }
     return parsed;
@@ -650,8 +623,7 @@ class Parser {
     if (!unprefixed && this.options.prefixableStrings !== void 0 && this.isType(next2, $C.QUOTE_ANY) && next2 && this.isType(next4, next2.type) && next && this.options.prefixableStrings.includes(next.value)) {
       return this.ruleValueUnquoted({ onlyToken });
     }
-    if (onlyToken)
-      return void 0;
+    if (onlyToken) return void 0;
     return token.value(...this.processToken());
   }
   ruleValueUnquoted({
@@ -689,15 +661,15 @@ class Parser {
     return void 0;
   }
   /**
-   * Given a list of @see Suggestion entries, the parser options, and a list of variables, prefixes, operators, etc, and the preferred quote type, returns a list of @see Completion entries.
+   * Given the ast, a list of {@link Suggestion} entries, the parser options, and a list of variables, prefixes, operators, etc, and the preferred quote type, returns a list of {@link Completion} entries.
    *
    * It takes care of suggesting the correct delimiters for fixes, quoting variables/prefixes if it would not be possible to parse them unquoted, and separating symbol from non-symbol (word) operators.
    *
-   * Does not add whitespace or group requirements. The suggestion information is still in the completion if you wish to show these. But they should not be added to the completion value if using @see autoreplace which will take care of it.
+   * Does not add whitespace or group requirements. The suggestion information is still in the completion if you wish to show these. But they should not be added to the completion value if using {@link autoreplace} which will take care of it.
    *
-   * Is not aware of existing values. You will have to use @see getCursorInfo to understand the context in which the suggestion was made, so that, for example, you could filter out used regex flags.
+   * Is not aware of existing values. You will have to use {@link getCursorInfo} to understand the context in which the suggestion was made, so that, for example, you could filter out used regex flags.
    */
-  autocomplete(suggestions, {
+  autocomplete(ast, suggestions, {
     values = [],
     arrayValues = [],
     variables = [],
@@ -709,6 +681,7 @@ class Parser {
     regexFlags = ["i", "m", "u"],
     quote = '"'
   } = {}) {
+    const parentMap = generateParentsMap(ast);
     const self = this;
     return suggestions.map((suggestion) => {
       const type = suggestion.type;
@@ -735,7 +708,7 @@ class Parser {
               return true;
             }
             const token2 = suggestion2.cursorInfo;
-            const flags = token2.at && ((_b = (_a = token2.at.parent) == null ? void 0 : _a.quote) == null ? void 0 : _b.flags) === suggestion2.cursorInfo.at ? token2.at : token2.next && ((_d = (_c = token2.next.parent) == null ? void 0 : _c.quote) == null ? void 0 : _d.flags) === suggestion2.cursorInfo.next ? token2.next : token2.prev && ((_f = (_e = token2.prev.parent) == null ? void 0 : _e.quote) == null ? void 0 : _f.flags) === suggestion2.cursorInfo.prev ? token2.prev : void 0;
+            const flags = token2.at && ((_b = (_a = getParent(token2.at, parentMap)) == null ? void 0 : _a.quote) == null ? void 0 : _b.flags) === suggestion2.cursorInfo.at ? token2.at : token2.next && ((_d = (_c = getParent(token2.next, parentMap)) == null ? void 0 : _c.quote) == null ? void 0 : _d.flags) === suggestion2.cursorInfo.next ? token2.next : token2.prev && ((_f = (_e = getParent(token2.prev, parentMap)) == null ? void 0 : _e.quote) == null ? void 0 : _f.flags) === suggestion2.cursorInfo.prev ? token2.prev : void 0;
             if ((_g = flags == null ? void 0 : flags.value) == null ? void 0 : _g.includes(value)) {
               return false;
             }
@@ -767,31 +740,17 @@ class Parser {
         case SUGGESTION_TYPE.ARRAY_VALUE:
         case SUGGESTION_TYPE.VARIABLE: {
           const arr = type === SUGGESTION_TYPE.VARIABLE ? variables : type === SUGGESTION_TYPE.ARRAY_VALUE ? arrayValues : type === SUGGESTION_TYPE.VALUE ? values : unreachable();
-          return arr.map((variable2) => {
-            const res = self.parse(variable2);
-            if (res instanceof ConditionNode && res.operator === void 0 && res.value instanceof VariableNode && res.value.quote === void 0) {
-              return { suggestion, value: res.value.value.value };
-            } else {
-              return { suggestion, value: quote + variable2.replace(new RegExp(quote, "g"), `\\${quote}`) + quote };
-            }
-          });
+          return arr.map((variable2) => ({ suggestion, value: escapeVariableOrPrefix(variable2, quote) }));
         }
         case SUGGESTION_TYPE.PREFIX:
-          return prefixes.map((prefix) => {
-            const res = self.parse(prefix);
-            if (res instanceof ConditionNode && res.operator === void 0 && res.value instanceof VariableNode && res.value.quote === void 0) {
-              return { suggestion, value: res.value.value.value };
-            } else {
-              return { suggestion, value: quote + prefix.replace(new RegExp(quote, "g"), `\\${quote}`) + quote };
-            }
-          });
+          return prefixes.map((prefix) => ({ suggestion, value: escapeVariableOrPrefix(prefix, quote) }));
       }
     }).flat();
   }
   /**
-   * Given the input string and a @see Completion consisting of the value of the replacement and a @see Suggestion entry, returns the replacement string and the new position of the cursor.
+   * Given the input string and a {@link Completion} consisting of the value of the replacement and a {@link Suggestion} entry, returns the replacement string and the new position of the cursor.
    *
-   * The value passed should be escaped if it's needed (or quoted). @see autocomplete already takes care of quoting variables if you're using it.
+   * The value passed should be escaped if it's needed (or quoted). {@link autocomplete} already takes care of quoting variables if you're using it.
    */
   autoreplace(input, { value, suggestion }) {
     const isQuotedLeft = ['"', "'", "`"].includes(value[0]);
@@ -819,9 +778,9 @@ class Parser {
     return { replacement, cursor };
   }
   /**
-   * Returns a list of suggestions ( @see Suggestion ). These are not a list of autocomplete entries (with values), but more a list of entries describing possible suggestions. This list can then be passed to @see Parser["autocomplete"] to build a list to show users, from which you can then pick an entry to pass to @see Parser["autoreplace"] .
+   * Returns a list of suggestions ( {@link Suggestion} ). These are not a list of autocomplete entries (with values), but more a list of entries describing possible suggestions. This list can then be passed to {@link Parser}["autocomplete"] to build a list to show users, from which you can then pick an entry to pass to {@link Parser}["autoreplace"] .
    *
-   * The list returned is "unsorted", but there is still some logic to the order. Fixes for errors are suggested first, in the order returned by @see getSurroundingErrors. Regular suggestions come after in the following order: prefixes if enabled, variables, boolean symbol operators, then boolean word operators.
+   * The list returned is "unsorted", but there is still some logic to the order. Fixes for errors are suggested first, in the order returned by {@link getSurroundingErrors}. Regular suggestions come after in the following order: prefixes if enabled, variables, boolean symbol operators, then boolean word operators.
    *
    * When the cursor is between two tokens that have possible suggestions, only suggestion types for the token before are returned. For example:
    *
@@ -841,7 +800,8 @@ class Parser {
    * ```
    */
   autosuggest(input, ast, index) {
-    var _a, _b, _c, _d, _e, _f, _g, _h, _i, _j, _k, _l, _m, _n, _o, _p, _q, _r, _s, _t, _u, _v, _w, _x, _y, _z, _A, _B, _C, _D, _E, _F, _G, _H, _I, _J, _K, _L;
+    var _a, _b, _c, _d, _e, _f, _g, _h, _i, _j, _k, _l, _m, _n, _o, _p, _q, _r, _s, _t, _u, _v, _w, _x, _y, _z;
+    const parentMap = generateParentsMap(ast);
     const opts = this.options;
     const tokens = extractTokens(ast);
     const token2 = getCursorInfo(input, tokens, index);
@@ -854,7 +814,7 @@ class Parser {
     const requiresWhitespacePrevOp = canSuggestOpAfterPrev ? false : requiresWhitespacePrev;
     const requireWhitespaceNextOp = !canSuggestOpAfterPrev && canSuggestOpBeforeNext ? false : requiresWhitespaceNext;
     const suggestions = [];
-    if (ast instanceof ErrorToken) {
+    if (isToken(ast) && !ast.valid) {
       suggestions.push({
         type: SUGGESTION_TYPE.PREFIX,
         requires: createDefaultRequires({ group: true }),
@@ -882,16 +842,16 @@ class Parser {
       };
       for (const error of surroundingErrors) {
         for (const type of error.expected) {
-          if (errorTypesHandled.includes(type))
-            continue;
+          if (errorTypesHandled.includes(type)) continue;
           errorTypesHandled.push(type);
           switch (type) {
             case TOKEN_TYPE.DOUBLEQUOTE:
             case TOKEN_TYPE.SINGLEQUOTE:
             case TOKEN_TYPE.BACKTICK:
               {
-                const isLeft = error.parent.quote.left === error;
-                const isRight = error.parent.quote.right === error;
+                const errorParent = getParent(error, parentMap);
+                const isLeft = errorParent.quote.left === error;
+                const isRight = errorParent.quote.right === error;
                 suggestions.push({
                   ...errorSuggestion,
                   type,
@@ -924,10 +884,8 @@ class Parser {
                 }),
                 range: pos({ start: index }, { fill: true })
               });
-              if (type === TOKEN_TYPE.AND)
-                errorTypesHandled.push(TOKEN_TYPE.OR);
-              if (type === TOKEN_TYPE.OR)
-                errorTypesHandled.push(TOKEN_TYPE.AND);
+              if (type === TOKEN_TYPE.AND) errorTypesHandled.push(TOKEN_TYPE.OR);
+              if (type === TOKEN_TYPE.OR) errorTypesHandled.push(TOKEN_TYPE.AND);
               break;
             case TOKEN_TYPE.PARENL:
             case TOKEN_TYPE.PARENR:
@@ -939,8 +897,9 @@ class Parser {
               });
               break;
             case TOKEN_TYPE.VALUE: {
-              const prefixedValue = error.parent instanceof VariableNode ? (_d = (_c = error.parent) == null ? void 0 : _c.prefix) == null ? void 0 : _d.value : false;
-              const isRegexValue = error.parent instanceof VariableNode && (((_e = error.parent.quote) == null ? void 0 : _e.left.type) === TOKEN_TYPE.REGEX || ((_f = error.parent.quote) == null ? void 0 : _f.right.type) === TOKEN_TYPE.REGEX);
+              const errorParent = getParent(error, parentMap);
+              const prefixedValue = (errorParent == null ? void 0 : errorParent.type) === AST_TYPE.VARIABLE ? (_d = (_c = getParent(error, parentMap)) == null ? void 0 : _c.prefix) == null ? void 0 : _d.value : false;
+              const isRegexValue = (errorParent == null ? void 0 : errorParent.type) === AST_TYPE.VARIABLE && (((_e = errorParent.quote) == null ? void 0 : _e.left.type) === TOKEN_TYPE.REGEX || ((_f = errorParent.quote) == null ? void 0 : _f.right.type) === TOKEN_TYPE.REGEX);
               if (!isRegexValue) {
                 if (!prefixedValue && opts.prefixableGroups) {
                   suggestions.push({
@@ -1005,41 +964,42 @@ class Parser {
           }
         }
       }
-      const prevVar = (_g = token2.valid.prev) == null ? void 0 : _g.parent;
-      const nextVar = (_h = token2.valid.next) == null ? void 0 : _h.parent;
-      const prevCondition = prevVar == null ? void 0 : prevVar.parent;
-      const nextCondition = nextVar == null ? void 0 : nextVar.parent;
-      const atVar = (_i = token2.at) == null ? void 0 : _i.parent;
-      const atCondition = atVar == null ? void 0 : atVar.parent;
-      const isVarPrev = !token2.whitespace.prev && ((_j = token2.valid.prev) == null ? void 0 : _j.type) !== TOKEN_TYPE.REGEX && prevVar instanceof VariableNode && (prevCondition instanceof ConditionNode && prevCondition.value === prevVar && (((_k = prevVar.quote) == null ? void 0 : _k.right) === token2.valid.prev || prevVar.value === token2.valid.prev) || prevCondition instanceof ArrayNode);
-      const isVarNext = !token2.whitespace.next && ((_l = token2.valid.next) == null ? void 0 : _l.type) !== TOKEN_TYPE.REGEX && nextVar instanceof VariableNode && (nextCondition instanceof ConditionNode && nextCondition.value === nextVar && (((_m = nextVar.quote) == null ? void 0 : _m.left) === token2.valid.next || nextVar.value === token2.valid.next) || nextCondition instanceof ArrayNode);
-      const isVarAt = atVar instanceof VariableNode && atCondition instanceof ConditionNode || prevVar instanceof VariableNode && token2.valid.prev === ((_n = prevVar == null ? void 0 : prevVar.quote) == null ? void 0 : _n.left) || nextVar instanceof VariableNode && token2.valid.next === ((_o = nextVar == null ? void 0 : nextVar.quote) == null ? void 0 : _o.right);
-      const isPropertyPrev = prevCondition instanceof ConditionNode && prevVar !== void 0 && prevVar === (prevCondition == null ? void 0 : prevCondition.property);
-      const isPropertyNext = nextCondition instanceof ConditionNode && nextVar !== void 0 && nextVar === (nextCondition == null ? void 0 : nextCondition.property);
-      const isPropertyAt = atCondition instanceof ConditionNode && atVar !== void 0 && atVar === (atCondition == null ? void 0 : atCondition.property);
-      const isPropertyOperatorPrev = prevVar instanceof ConditionNode && token2.valid.prev === (prevVar == null ? void 0 : prevVar.propertyOperator);
-      const isPropertyOperatorNext = nextVar instanceof ConditionNode && token2.valid.next === (nextVar == null ? void 0 : nextVar.propertyOperator);
-      const isPropertyOperatorAt = atVar instanceof ConditionNode && token2.at === (atVar == null ? void 0 : atVar.propertyOperator);
-      const noArrayValuesTarget = ((_p = token2.valid.prev) == null ? void 0 : _p.type) === TOKEN_TYPE.BRACKETL && (token2.valid.next === void 0 || ((_q = token2.valid.next) == null ? void 0 : _q.type) === TOKEN_TYPE.BRACKETR);
+      const prevVar = getParent(token2.valid.prev, parentMap);
+      const nextVar = getParent(token2.valid.next, parentMap);
+      const prevCondition = getParent(prevVar, parentMap);
+      const nextCondition = getParent(nextVar, parentMap);
+      const atVar = getParent(token2.at, parentMap);
+      const atCondition = getParent(atVar, parentMap);
+      const isVarPrev = !token2.whitespace.prev && ((_g = token2.valid.prev) == null ? void 0 : _g.type) !== TOKEN_TYPE.REGEX && (prevVar == null ? void 0 : prevVar.type) === AST_TYPE.VARIABLE && ((prevCondition == null ? void 0 : prevCondition.type) === AST_TYPE.CONDITION && prevCondition.value === prevVar && (((_h = prevVar.quote) == null ? void 0 : _h.right) === token2.valid.prev || prevVar.value === token2.valid.prev) || (prevCondition == null ? void 0 : prevCondition.type) === AST_TYPE.ARRAY);
+      const isVarNext = !token2.whitespace.next && ((_i = token2.valid.next) == null ? void 0 : _i.type) !== TOKEN_TYPE.REGEX && (nextVar == null ? void 0 : nextVar.type) === AST_TYPE.VARIABLE && ((nextCondition == null ? void 0 : nextCondition.type) === AST_TYPE.CONDITION && nextCondition.value === nextVar && (((_j = nextVar.quote) == null ? void 0 : _j.left) === token2.valid.next || nextVar.value === token2.valid.next) || (nextCondition == null ? void 0 : nextCondition.type) === AST_TYPE.ARRAY);
+      const isVarAt = (atVar == null ? void 0 : atVar.type) === AST_TYPE.VARIABLE && (atCondition == null ? void 0 : atCondition.type) === AST_TYPE.CONDITION || (prevVar == null ? void 0 : prevVar.type) === AST_TYPE.VARIABLE && token2.valid.prev === ((_k = prevVar == null ? void 0 : prevVar.quote) == null ? void 0 : _k.left) || (nextVar == null ? void 0 : nextVar.type) === AST_TYPE.VARIABLE && token2.valid.next === ((_l = nextVar == null ? void 0 : nextVar.quote) == null ? void 0 : _l.right);
+      const isPropertyPrev = (prevCondition == null ? void 0 : prevCondition.type) === AST_TYPE.CONDITION && prevVar !== void 0 && prevVar === (prevCondition == null ? void 0 : prevCondition.property);
+      const isPropertyNext = (nextCondition == null ? void 0 : nextCondition.type) === AST_TYPE.CONDITION && nextVar !== void 0 && nextVar === (nextCondition == null ? void 0 : nextCondition.property);
+      const isPropertyAt = (atCondition == null ? void 0 : atCondition.type) === AST_TYPE.CONDITION && atVar !== void 0 && atVar === (atCondition == null ? void 0 : atCondition.property);
+      const isPropertyOperatorPrev = (prevVar == null ? void 0 : prevVar.type) === AST_TYPE.CONDITION && token2.valid.prev === (prevVar == null ? void 0 : prevVar.propertyOperator);
+      const isPropertyOperatorNext = (nextVar == null ? void 0 : nextVar.type) === AST_TYPE.CONDITION && token2.valid.next === (nextVar == null ? void 0 : nextVar.propertyOperator);
+      const isPropertyOperatorAt = (atVar == null ? void 0 : atVar.type) === AST_TYPE.CONDITION && token2.at === (atVar == null ? void 0 : atVar.propertyOperator);
+      const noArrayValuesTarget = ((_m = token2.valid.prev) == null ? void 0 : _m.type) === TOKEN_TYPE.BRACKETL && (token2.valid.next === void 0 || ((_n = token2.valid.next) == null ? void 0 : _n.type) === TOKEN_TYPE.BRACKETR);
       const target = isVarPrev ? token2.valid.prev : !noArrayValuesTarget && !isPropertyPrev && !isPropertyOperatorPrev && isVarNext ? token2.valid.next : isVarAt ? token2.at : void 0;
       const propertyTarget = isPropertyPrev ? token2.valid.prev : !noArrayValuesTarget && !isVarPrev && !isPropertyOperatorPrev && isPropertyNext ? token2.valid.next : isPropertyAt ? token2.at : void 0;
       const propOpTarget = isPropertyOperatorPrev ? token2.valid.prev : !noArrayValuesTarget && !isVarPrev && !isPropertyPrev && isPropertyOperatorNext ? token2.valid.next : isPropertyOperatorAt ? token2.at : void 0;
       if (target) {
-        const parent = target.parent;
-        if (parent instanceof VariableNode) {
+        const parent = getParent(target, parentMap);
+        if (parent && parent.type === AST_TYPE.VARIABLE) {
           const range = pos(parent);
-          const condition2 = parent == null ? void 0 : parent.parent;
+          const parentParent = getParent(parent, parentMap);
+          const condition2 = parentParent;
           const isValue = condition2.propertyOperator !== void 0 && condition2.value === parent;
-          const maybeGroup = (_r = parent == null ? void 0 : parent.parent) == null ? void 0 : _r.parent;
-          const isPrefix = maybeGroup instanceof GroupNode && maybeGroup.prefix === condition2;
+          const maybeGroup = getParent(parentParent, parentMap);
+          const isPrefix = (maybeGroup == null ? void 0 : maybeGroup.type) === AST_TYPE.GROUP && maybeGroup.prefix === condition2;
           const varStart = getCursorInfo(input, ast, parent.start);
           const varEnd = getCursorInfo(input, ast, parent.end);
           const targetRequiresWhitespacePrev = tokenRequiresWhitespace(varStart.valid.prev, varStart.whitespace.prev, wordOps);
           const targetRequiresWhitespaceNext = tokenRequiresWhitespace(varEnd.valid.next, varEnd.whitespace.next, wordOps);
-          const prefixedValue = target.parent instanceof VariableNode ? (_t = (_s = target.parent) == null ? void 0 : _s.prefix) == null ? void 0 : _t.value : false;
-          const isSepPrev = ((_u = token2.prev) == null ? void 0 : _u.type) === TOKEN_TYPE.OP_EXPANDED_SEP;
-          const arrayValue = ((_v = target.parent) == null ? void 0 : _v.parent) instanceof ArrayNode;
-          const isRegexFlag = target === ((_w = parent.quote) == null ? void 0 : _w.flags);
+          const prefixedValue = parent.type === AST_TYPE.VARIABLE ? (_o = parent == null ? void 0 : parent.prefix) == null ? void 0 : _o.value : false;
+          const isSepPrev = ((_p = token2.prev) == null ? void 0 : _p.type) === TOKEN_TYPE.OP_EXPANDED_SEP;
+          const arrayValue = (parentParent == null ? void 0 : parentParent.type) === AST_TYPE.ARRAY;
+          const isRegexFlag = target === ((_q = parent.quote) == null ? void 0 : _q.flags);
           if (!isRegexFlag && !isSepPrev && !isValue && !arrayValue && !prefixedValue && opts.prefixableGroups) {
             suggestions.push({
               ...baseSuggestion,
@@ -1088,16 +1048,17 @@ class Parser {
         });
       }
       if (propOpTarget) {
+        const propOpTargetParent = getParent(propOpTarget, parentMap);
         suggestions.push({
           ...baseSuggestion,
-          type: propOpTarget.parent.sep ? SUGGESTION_TYPE.EXPANDED_PROPERTY_OPERATOR : SUGGESTION_TYPE.CUSTOM_PROPERTY_OPERATOR,
+          type: propOpTargetParent.sep ? SUGGESTION_TYPE.EXPANDED_PROPERTY_OPERATOR : SUGGESTION_TYPE.CUSTOM_PROPERTY_OPERATOR,
           requires: createDefaultRequires(),
           range: pos(propOpTarget)
         });
       }
-      const canSuggestValue = token2.whitespace.next && (token2.whitespace.prev || ((_x = token2.prev) == null ? void 0 : _x.type) === TOKEN_TYPE.BRACKETL || ((_y = token2.prev) == null ? void 0 : _y.type) === TOKEN_TYPE.PARENL) || token2.whitespace.prev && (token2.whitespace.next || ((_z = token2.next) == null ? void 0 : _z.type) === TOKEN_TYPE.BRACKETR || ((_A = token2.next) == null ? void 0 : _A.type) === TOKEN_TYPE.PARENR);
+      const canSuggestValue = token2.whitespace.next && (token2.whitespace.prev || ((_r = token2.prev) == null ? void 0 : _r.type) === TOKEN_TYPE.BRACKETL || ((_s = token2.prev) == null ? void 0 : _s.type) === TOKEN_TYPE.PARENL) || token2.whitespace.prev && (token2.whitespace.next || ((_t = token2.next) == null ? void 0 : _t.type) === TOKEN_TYPE.BRACKETR || ((_u = token2.next) == null ? void 0 : _u.type) === TOKEN_TYPE.PARENR);
       if (canSuggestValue) {
-        const inArrayNode = [nextCondition, prevCondition, nextVar, prevVar].find((_) => _ instanceof ArrayNode) !== void 0;
+        const inArrayNode = [nextCondition, prevCondition, nextVar, prevVar].find((_) => (_ == null ? void 0 : _.type) === AST_TYPE.ARRAY) !== void 0;
         const opsNotNeeded = ["and", "or"].includes(opts.onMissingBooleanOperator);
         if (inArrayNode || opsNotNeeded) {
           suggestions.push({
@@ -1118,10 +1079,13 @@ class Parser {
           });
         }
       }
+      const tokenAtParent = getParent(token2.at, parentMap);
+      const tokenValidPrevParent = getParent(token2.valid.prev, parentMap);
+      const tokenValidNextParent = getParent(token2.valid.next, parentMap);
       const canSuggestRegexFlags = (
         // has existing flags before/after
-        token2.at && token2.at === ((_D = (_C = (_B = token2.at) == null ? void 0 : _B.parent) == null ? void 0 : _C.quote) == null ? void 0 : _D.flags) || token2.valid.prev && token2.valid.prev === ((_G = (_F = (_E = token2.valid.prev) == null ? void 0 : _E.parent) == null ? void 0 : _F.quote) == null ? void 0 : _G.flags) || token2.valid.next && token2.valid.next === ((_J = (_I = (_H = token2.valid.next) == null ? void 0 : _H.parent) == null ? void 0 : _I.quote) == null ? void 0 : _J.flags) || // no flags
-        ((_K = token2.valid.prev) == null ? void 0 : _K.type) === TOKEN_TYPE.REGEX && token2.valid.prev === ((_L = token2.valid.prev.parent.quote) == null ? void 0 : _L.right)
+        token2.at && token2.at === ((_v = tokenAtParent == null ? void 0 : tokenAtParent.quote) == null ? void 0 : _v.flags) || token2.valid.prev && token2.valid.prev === ((_w = tokenValidPrevParent == null ? void 0 : tokenValidPrevParent.quote) == null ? void 0 : _w.flags) || token2.valid.next && token2.valid.next === ((_x = tokenValidNextParent == null ? void 0 : tokenValidNextParent.quote) == null ? void 0 : _x.flags) || // no flags
+        ((_y = token2.valid.prev) == null ? void 0 : _y.type) === TOKEN_TYPE.REGEX && token2.valid.prev === ((_z = tokenValidPrevParent.quote) == null ? void 0 : _z.right)
       );
       if (canSuggestRegexFlags) {
         suggestions.push({
@@ -1162,12 +1126,12 @@ class Parser {
   evaluate(ast, context) {
     this._checkEvaluationOptions();
     const opts = this.options;
-    if (ast instanceof Condition) {
+    if (ast.type === AST_TYPE.NORMALIZED_CONDITION) {
       const contextValue = get(context, ast.property);
-      const res = opts.valueComparer({ property: ast.property, value: ast.value, operator: ast.operator }, contextValue, context);
+      const res = opts.valueComparer(ast, contextValue, context);
       return ast.negate ? !res : res;
     }
-    if (ast instanceof Expression) {
+    if (ast.type === AST_TYPE.NORMALIZED_EXPRESSION) {
       const left = this.evaluate(ast.left, context);
       const right = this.evaluate(ast.right, context);
       return ast.operator === TOKEN_TYPE.AND ? left && right : left || right;
@@ -1192,16 +1156,14 @@ class Parser {
   getBestIndexes(indexes, existing, sortIndex = "") {
     indexes = indexes.filter((set) => {
       for (const key of set) {
-        if (!existing.has(key))
-          return false;
+        if (!existing.has(key)) return false;
       }
       return true;
     });
     let finalIndexes = indexes;
     if (existing.has(sortIndex)) {
       const indexesWithSortIndex = indexes.filter((set) => set.has(sortIndex));
-      if (indexesWithSortIndex.length > 0)
-        finalIndexes = indexesWithSortIndex;
+      if (indexesWithSortIndex.length > 0) finalIndexes = indexesWithSortIndex;
     }
     let smallest = Infinity;
     if (existing instanceof Map) {
@@ -1234,10 +1196,10 @@ class Parser {
    * Queries like `(a || b) && (a || c)` would require all the variables to be indexed `[Set(a), Set(b), Set(c)]`.
    */
   getIndexes(ast) {
-    if (ast instanceof Condition) {
+    if (ast.type === AST_TYPE.NORMALIZED_CONDITION) {
       return [new Set(ast.property.join("."))];
     }
-    if (ast instanceof Expression) {
+    if (ast.type === AST_TYPE.NORMALIZED_EXPRESSION) {
       const left = this.getIndexes(ast.left);
       const right = this.getIndexes(ast.right);
       if (ast.operator === TOKEN_TYPE.AND) {
@@ -1245,8 +1207,7 @@ class Parser {
         const allKeys = /* @__PURE__ */ new Set();
         for (const leftSet of left) {
           const exists = sets.find((set) => isEqualSet(set, leftSet));
-          if (exists)
-            continue;
+          if (exists) continue;
           sets.push(leftSet);
           for (const key of leftSet) {
             allKeys.add(key);
@@ -1254,22 +1215,19 @@ class Parser {
         }
         for (const rightSet of right) {
           const exists = sets.find((set) => isEqualSet(set, rightSet));
-          if (exists)
-            continue;
+          if (exists) continue;
           sets.push(rightSet);
           for (const key of rightSet) {
             allKeys.add(key);
           }
         }
         const commonKeys = /* @__PURE__ */ new Set();
-        outerCheck:
-          for (const key of allKeys) {
-            for (const set of sets) {
-              if (!set.has(key))
-                continue outerCheck;
-            }
-            commonKeys.add(key);
+        outerCheck: for (const key of allKeys) {
+          for (const set of sets) {
+            if (!set.has(key)) continue outerCheck;
           }
+          commonKeys.add(key);
+        }
         if (commonKeys.size > 0) {
           return [commonKeys, allKeys];
         } else {
@@ -1304,20 +1262,20 @@ class Parser {
    * Normalizes the ast by applying {@link GroupNode GroupNodes} and converting {@link ConditionNode ConditionNodes} to {@link NormalizedConditionNode NormalizedConditionNodes}.
    */
   normalize(ast) {
-    var _a, _b, _c, _d, _e, _f, _g, _h, _i, _j, _k, _l, _m;
+    var _a, _b, _c, _d, _e, _f, _g, _h, _i, _j, _k, _l, _m, _n, _o, _p, _q, _r, _s;
     this._checkEvaluationOptions();
     const opts = this.options;
-    if (ast instanceof ErrorToken || !ast.valid) {
+    if (!ast.valid) {
       throw new Error("AST node must be valid.");
     }
     const prefix = arguments[1];
     const groupValue = arguments[2];
     let operator2 = arguments[3];
     const self_ = this;
-    if (ast instanceof ConditionNode) {
-      if (!(ast.value instanceof GroupNode)) {
-        const isValue = ast.value instanceof ArrayNode || ((_b = (_a = ast.value) == null ? void 0 : _a.quote) == null ? void 0 : _b.left.type) === TOKEN_TYPE.REGEX;
-        let name = ast.property ? unescape(ast.property.value.value) : isValue ? void 0 : unescape((_c = ast.value) == null ? void 0 : _c.value.value);
+    if (ast.type === AST_TYPE.CONDITION) {
+      if (!(ast.value.type === AST_TYPE.GROUP)) {
+        const isValue = ast.value.type === AST_TYPE.ARRAY || ((_b = (_a = ast.value) == null ? void 0 : _a.quote) == null ? void 0 : _b.left.type) === TOKEN_TYPE.REGEX;
+        let name = ((_d = (_c = ast.property) == null ? void 0 : _c.value) == null ? void 0 : _d.value) ? unescape(ast.property.value.value) : isValue ? void 0 : unescape(ast.value.value.value);
         const isNested = operator2 !== void 0;
         if (prefix !== void 0 && !isNested) {
           name = name ? applyPrefix(prefix, name, opts.prefixApplier) : prefix;
@@ -1327,16 +1285,16 @@ class Parser {
           value = name ?? true;
           name = prefix;
         } else {
-          value = ast.value instanceof ArrayNode ? ast.value.values.map((val) => unescape(val.value.value)) : ((_e = (_d = ast.value) == null ? void 0 : _d.quote) == null ? void 0 : _e.left.type) === TOKEN_TYPE.REGEX ? ast.value.value.value : ast.property && ast.value instanceof VariableNode ? unescape(ast.value.value.value) : true;
+          value = ast.value.type === AST_TYPE.ARRAY ? ast.value.values.map((val) => unescape(val.value.value)) : ((_f = (_e = ast.value) == null ? void 0 : _e.quote) == null ? void 0 : _f.left.type) === TOKEN_TYPE.REGEX ? (_g = ast.value.value) == null ? void 0 : _g.value : ast.property && ast.value.type === AST_TYPE.VARIABLE ? unescape(ast.value.value.value) : true;
         }
         const propertyKeys = name ? opts.keyParser(name) : [];
         const boolValue = applyBoolean(groupValue, ast.operator === void 0);
-        const valuePrefix = ast.value instanceof VariableNode && ast.value.prefix ? unescape(ast.value.prefix.value) : void 0;
-        operator2 ?? (operator2 = (_f = ast.propertyOperator) == null ? void 0 : _f.value);
-        const isRegex = ((_h = (_g = ast.value) == null ? void 0 : _g.quote) == null ? void 0 : _h.left.type) === TOKEN_TYPE.REGEX;
-        const isQuoted = ((_i = ast.value) == null ? void 0 : _i.quote) !== void 0;
+        const valuePrefix = ast.value.type === AST_TYPE.VARIABLE && ast.value.prefix ? unescape(ast.value.prefix.value) : void 0;
+        operator2 ?? (operator2 = (_h = ast.propertyOperator) == null ? void 0 : _h.value);
+        const isRegex = ((_j = (_i = ast.value) == null ? void 0 : _i.quote) == null ? void 0 : _j.left.type) === TOKEN_TYPE.REGEX;
+        const isQuoted = ((_k = ast.value) == null ? void 0 : _k.quote) !== void 0;
         const isExpanded = ast.sep !== void 0;
-        const regexFlags = (_l = (_k = (_j = ast.value) == null ? void 0 : _j.quote) == null ? void 0 : _k.flags) == null ? void 0 : _l.value;
+        const regexFlags = (_n = (_m = (_l = ast.value) == null ? void 0 : _l.quote) == null ? void 0 : _m.flags) == null ? void 0 : _n.value;
         const query = {
           value,
           operator: operator2,
@@ -1350,28 +1308,28 @@ class Parser {
           condition: ast
         };
         const res = opts.conditionNormalizer(query);
-        return new Condition({ property: propertyKeys, ...res });
+        return createCondition({ property: propertyKeys, ...res });
       } else {
         let name = unescape(ast.property.value.value);
         if (prefix !== void 0) {
           name = applyPrefix(prefix, name, opts.prefixApplier);
         }
         const boolValue = applyBoolean(groupValue, ast.operator === void 0);
-        const operator22 = (_m = ast.propertyOperator) == null ? void 0 : _m.value;
+        const operator22 = (_o = ast.propertyOperator) == null ? void 0 : _o.value;
         return self_.normalize(ast.value, name, boolValue, operator22);
       }
     }
-    if (ast instanceof GroupNode) {
-      const _prefix = ast.prefix instanceof ConditionNode && ast.prefix.value instanceof VariableNode ? unescape(ast.prefix.value.value.value) : void 0;
-      const _groupValue = ast.prefix instanceof ConditionNode ? ast.prefix.operator === void 0 : !(ast.prefix instanceof ValidToken);
+    if (ast.type === AST_TYPE.GROUP) {
+      const _prefix = ((_p = ast.prefix) == null ? void 0 : _p.type) === AST_TYPE.CONDITION && ((_q = ast.prefix) == null ? void 0 : _q.value.type) === AST_TYPE.VARIABLE ? unescape(ast.prefix.value.value.value) : void 0;
+      const _groupValue = ((_r = ast.prefix) == null ? void 0 : _r.type) === AST_TYPE.CONDITION ? ast.prefix.operator === void 0 : !(((_s = ast.prefix) == null ? void 0 : _s.valid) === true);
       const applied = applyPrefix(prefix, _prefix ?? "", opts.prefixApplier);
       return self_.normalize(ast.expression, applied, applyBoolean(groupValue, _groupValue), operator2);
     }
-    if (ast instanceof ExpressionNode) {
+    if (ast.type === AST_TYPE.EXPRESSION) {
       const left = self_.normalize(ast.left, prefix, groupValue, operator2);
       const right = self_.normalize(ast.right, prefix, groupValue, operator2);
       const type = groupValue === false ? OPPOSITE[ast.operator.type] : ast.operator.type;
-      return new Expression({ operator: type, left, right });
+      return createExpression({ operator: type, left, right });
     }
     return unreachable();
   }
@@ -1382,11 +1340,11 @@ class Parser {
    * The context does not need to be passed. If it's not passed, the function will not attempt to get the values (so it will not error) and the contextValue param of the valueValidator will be undefined.
    */
   validate(ast, context) {
-    var _a, _b, _c, _d, _e, _f, _g, _h, _i;
+    var _a, _b, _c, _d, _e, _f, _g, _h, _i, _j, _k, _l;
     const self = this;
     self._checkValidationOptions();
     const opts = self.options;
-    if (ast instanceof ErrorToken || !ast.valid) {
+    if (!ast.valid) {
       throw new Error("AST node must be valid.");
     }
     const prefix = arguments[2];
@@ -1395,9 +1353,9 @@ class Parser {
     const prefixes = arguments[5] ?? [];
     let operator2 = arguments[6];
     const self_ = this;
-    if (ast instanceof ConditionNode) {
-      if (!(ast.value instanceof GroupNode)) {
-        const isValue = ast.value instanceof ArrayNode || ((_b = (_a = ast.value) == null ? void 0 : _a.quote) == null ? void 0 : _b.left.type) === TOKEN_TYPE.REGEX;
+    if (ast.type === AST_TYPE.CONDITION) {
+      if (!(ast.value.type === AST_TYPE.GROUP)) {
+        const isValue = ast.value.type === AST_TYPE.ARRAY || ((_b = (_a = ast.value) == null ? void 0 : _a.quote) == null ? void 0 : _b.left.type) === TOKEN_TYPE.REGEX;
         const nameNode = ast.property ? ast.property : isValue ? void 0 : ast.value;
         let name = nameNode ? unescape(nameNode.value.value) : void 0;
         const isNested = operator2 !== void 0;
@@ -1412,12 +1370,12 @@ class Parser {
           propertyNodes = [...prefixes];
         } else {
           propertyNodes = [...prefixes, ...nameNode ? [nameNode] : []];
-          value = ast.value instanceof ArrayNode ? ast.value.values : ((_d = (_c = ast.value) == null ? void 0 : _c.quote) == null ? void 0 : _d.left.type) === TOKEN_TYPE.REGEX ? ast.value : ast.property && ast.value instanceof VariableNode ? ast.value : true;
+          value = ast.value.type === AST_TYPE.ARRAY ? ast.value.values : ((_d = (_c = ast.value) == null ? void 0 : _c.quote) == null ? void 0 : _d.left.type) === TOKEN_TYPE.REGEX ? ast.value : ast.property && ast.value.type === AST_TYPE.VARIABLE ? ast.value : true;
         }
         const propertyKeys = name ? opts.keyParser(name) : [];
         const contextValue = context !== void 0 ? get(context, propertyKeys) : void 0;
         const boolValue = applyBoolean(groupValue, ast.operator === void 0);
-        const valuePrefix = ast.value instanceof VariableNode && ast.value.prefix ? ast.value.prefix : void 0;
+        const valuePrefix = ast.value.type === AST_TYPE.VARIABLE && ast.value.prefix ? ast.value.prefix : void 0;
         operator2 ?? (operator2 = ast.propertyOperator);
         const isRegex = ((_f = (_e = ast.value) == null ? void 0 : _e.quote) == null ? void 0 : _f.left.type) === TOKEN_TYPE.REGEX;
         const isQuoted = ((_g = ast.value) == null ? void 0 : _g.quote) !== void 0;
@@ -1439,11 +1397,9 @@ class Parser {
           condition: ast
         };
         const res = opts.valueValidator(contextValue, query, context);
-        if (res && !isArray(res))
-          throw new Error("The valueValidator must return an array or nothing/undefined");
+        if (res && !isArray(res)) throw new Error("The valueValidator must return an array or nothing/undefined");
         if (res) {
-          for (const entry of res)
-            results.push(entry);
+          for (const entry of res) results.push(entry);
         }
       } else {
         let name = unescape(ast.property.value.value);
@@ -1451,20 +1407,18 @@ class Parser {
           name = applyPrefix(prefix, name, opts.prefixApplier);
         }
         const boolValue = applyBoolean(groupValue, ast.operator === void 0);
-        if (ast.property)
-          prefixes.push(ast.property);
+        if (ast.property) prefixes.push(ast.property);
         const operator22 = ast.propertyOperator;
         self_.validate(ast.value, context, name, boolValue, results, prefixes, operator22);
       }
     }
-    if (ast instanceof GroupNode) {
-      const _prefix = ast.prefix instanceof ConditionNode && ast.prefix.value instanceof VariableNode ? ast.prefix.value : void 0;
-      if (_prefix)
-        prefixes.push(_prefix);
-      const _groupValue = ast.prefix instanceof ConditionNode ? ast.prefix.operator === void 0 : !(ast.prefix instanceof ValidToken);
+    if (ast.type === AST_TYPE.GROUP) {
+      const _prefix = ((_j = ast.prefix) == null ? void 0 : _j.type) === AST_TYPE.CONDITION && ast.prefix.value.type === AST_TYPE.VARIABLE ? ast.prefix.value : void 0;
+      if (_prefix) prefixes.push(_prefix);
+      const _groupValue = ((_k = ast.prefix) == null ? void 0 : _k.type) === AST_TYPE.CONDITION ? ast.prefix.operator === void 0 : !(((_l = ast.prefix) == null ? void 0 : _l.valid) === true);
       self_.validate(ast.expression, context, applyPrefix(prefix, (_prefix == null ? void 0 : _prefix.value.value) ?? "", opts.prefixApplier), applyBoolean(groupValue, _groupValue), results, prefixes, operator2);
     }
-    if (ast instanceof ExpressionNode) {
+    if (ast.type === AST_TYPE.EXPRESSION) {
       self_.validate(ast.left, context, prefix, groupValue, results, [...prefixes], operator2);
       self_.validate(ast.right, context, prefix, groupValue, results, [...prefixes], operator2);
     }