@witchcraft/expressit 0.1.2 → 0.2.0

package/dist/Parser.js

@@ -11,32 +11,27 @@ 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
@@ -62,10 +57,10 @@ const createDefaultRequires = (partial = {}) => ({
   group: partial.group ?? false,
   prefix: partial.prefix ?? false
 });
-const tokenRequiresWhitespace = (validToken, whitespace, wordOps) => {
-  if (whitespace || validToken === void 0)
+const tokenRequiresWhitespace = (valid, whitespace, wordOps) => {
+  if (whitespace || valid === 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;
+  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 +135,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 +146,6 @@ class Parser {
       lexedTokens
     };
     const res = this.ruleMain();
-    if (doSeal) {
-      seal(res);
-    }
     this.state = {
       rawInput: "",
       shift: 0,
@@ -349,26 +339,26 @@ class Parser {
     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);
     }
@@ -444,7 +434,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];
@@ -481,11 +471,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;
@@ -689,15 +679,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 +699,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 +726,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 +758,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 +796,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 +818,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 +832,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 }),
@@ -890,8 +868,9 @@ class Parser {
             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,
@@ -939,8 +918,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 +985,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 +1069,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 +1100,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 +1147,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;
@@ -1234,10 +1219,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) {
@@ -1304,20 +1289,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 +1312,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 +1335,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 +1367,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 +1380,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 +1397,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;
@@ -1457,14 +1442,14 @@ class Parser {
         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 (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 = ast.prefix instanceof ConditionNode ? ast.prefix.operator === void 0 : !(ast.prefix instanceof ValidToken);
+      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);
     }

package/dist/ast/builders/array.d.ts

@@ -1,6 +1,4 @@
-import { type Position } from "../../types/ast.js";
-import { ArrayNode } from "../classes/ArrayNode.js";
-import type { VariableNode } from "../classes/VariableNode.js";
+import { type ArrayNode, type Position, type VariableNode } from "../../types/ast.js";
 export declare function array(values: VariableNode[], bracket?: {
     left?: boolean;
     right?: boolean;

package/dist/ast/builders/array.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"array.d.ts","sourceRoot":"","sources":["../../../src/ast/builders/array.ts"],"names":[],"mappings":"AAIA,OAAO,EAAY,KAAK,QAAQ,EAAc,MAAM,oBAAoB,CAAA;AACxE,OAAO,EAAE,SAAS,EAAE,MAAM,yBAAyB,CAAA;AACnD,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,4BAA4B,CAAA;AAG9D,wBAAgB,KAAK,CACpB,MAAM,EAAE,YAAY,EAAE,EACtB,OAAO,GAAE;IAAE,IAAI,CAAC,EAAE,OAAO,CAAC;IAAC,KAAK,CAAC,EAAE,OAAO,CAAA;CAAgC,EAC1E,YAAY,CAAC,EAAE,QAAQ,EACvB,aAAa,CAAC,EAAE,QAAQ,GACtB,SAAS,CA8BX"}
+{"version":3,"file":"array.d.ts","sourceRoot":"","sources":["../../../src/ast/builders/array.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,KAAK,SAAS,EAAkB,KAAK,QAAQ,EAAc,KAAK,YAAY,EAAE,MAAM,oBAAoB,CAAA;AAIjH,wBAAgB,KAAK,CACpB,MAAM,EAAE,YAAY,EAAE,EACtB,OAAO,GAAE;IAAE,IAAI,CAAC,EAAE,OAAO,CAAC;IAAC,KAAK,CAAC,EAAE,OAAO,CAAA;CAAgC,EAC1E,YAAY,CAAC,EAAE,QAAQ,EACvB,aAAa,CAAC,EAAE,QAAQ,GACtB,SAAS,CA4BX"}

package/dist/ast/builders/array.js

@@ -1,10 +1,9 @@
 import { token } from "./token.js";
-import { AST_TYPE, TOKEN_TYPE } from "../../types/ast.js";
-import { ArrayNode } from "../classes/ArrayNode.js";
+import { TOKEN_TYPE } from "../../types/ast.js";
+import { createArrayNode } from "../createArrayNode.js";
 function array(values, bracket = { right: true, left: true }, parenLeftPos, parenRightPos) {
   var _a, _b, _c, _d, _e, _f;
   const node = {
-    type: AST_TYPE.ARRAY,
     values
   };
   node.bracket = {};
@@ -23,8 +22,7 @@ function array(values, bracket = { right: true, left: true }, parenLeftPos, pare
   }
   node.start = ((_c = node.bracket.left) == null ? void 0 : _c.start) ?? start ?? ((_d = node.bracket) == null ? void 0 : _d.right.start);
   node.end = ((_f = (_e = node.bracket) == null ? void 0 : _e.right) == null ? void 0 : _f.end) ?? end ?? node.bracket.left.end;
-  const instance = new ArrayNode(node);
-  return instance;
+  return createArrayNode(node);
 }
 export {
   array