@witchcraft/expressit 0.2.2 → 0.3.1

package/dist/Parser.js

@@ -1,12 +1,9 @@
-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);
-import { get } from "@alanscodelog/utils/get.js";
-import { insert } from "@alanscodelog/utils/insert.js";
-import { isArray } from "@alanscodelog/utils/isArray.js";
-import { isWhitespace } from "@alanscodelog/utils/isWhitespace.js";
-import { setReadOnly } from "@alanscodelog/utils/setReadOnly.js";
-import { unreachable } from "@alanscodelog/utils/unreachable.js";
+import { get } from "@alanscodelog/utils/get";
+import { insert } from "@alanscodelog/utils/insert";
+import { isArray } from "@alanscodelog/utils/isArray";
+import { isWhitespace } from "@alanscodelog/utils/isWhitespace";
+import { setReadOnly } from "@alanscodelog/utils/setReadOnly";
+import { unreachable } from "@alanscodelog/utils/unreachable";
 import { pos } from "./ast/builders/pos.js";
 import { createCondition } from "./ast/createNormalizedCondition.js";
 import { createExpression } from "./ast/createNormalizedExpression.js";
@@ -22,6 +19,7 @@ import { unescape } from "./internal/unescape.js";
 import { Lexer, $C, $T } from "./Lexer.js";
 import { TOKEN_TYPE, AST_TYPE } from "./types/ast.js";
 import { SUGGESTION_TYPE } from "./types/autocomplete.js";
+import "./types/errors.js";
 import { extractTokens } from "./utils/extractTokens.js";
 import { generateParentsMap } from "./utils/generateParentsMap.js";
 import { getCursorInfo } from "./utils/getCursorInfo.js";
@@ -47,7 +45,7 @@ const defaultNodeDirs = {
 const createDefaultRequires = (partial = {}) => ({
   whitespace: {
     ...defaultNodeDirs,
-    ...partial.whitespace ? partial.whitespace : {}
+    ...partial.whitespace ?? {}
   },
   group: partial.group ?? false,
   prefix: partial.prefix ?? false
@@ -58,34 +56,8 @@ const tokenRequiresWhitespace = (valid, whitespace, wordOps) => {
 };
 const tokenVariable = [TOKEN_TYPE.BACKTICK, TOKEN_TYPE.DOUBLEQUOTE, TOKEN_TYPE.SINGLEQUOTE, TOKEN_TYPE.VALUE, TOKEN_TYPE.REGEX];
 class Parser {
-  constructor(options) {
-    // needed for evaluate and validate so they are only checked on demand
-    __publicField(this, "evaluationOptionsChecked", false);
-    __publicField(this, "validationOptionsChecked", false);
-    __publicField(this, "options");
-    __publicField(this, "lexer");
-    __publicField(this, "$");
-    __publicField(this, "$categories");
-    __publicField(this, "info");
-    __publicField(this, "state", {
-      rawInput: "",
-      lexedTokens: [],
-      index: 0,
-      shift: 0
-    });
-    __publicField(this, "subParserOne");
-    __publicField(this, "subParserTwo");
-    const opts = parseParserOptions(options ?? {});
-    checkParserOpts(opts);
-    this.options = opts;
-    this.lexer = new Lexer(opts);
-    this.$ = this.lexer.$;
-    this.$categories = this.lexer.$categories;
-    this.info = {
-      expandedSepAlsoCustom: this.lexer.symbols.expandedSepAlsoCustom,
-      customOpAlsoNegation: this.lexer.symbols.customOpAlsoNegation
-    };
-  }
+  // needed for evaluate and validate so they are only checked on demand
+  evaluationOptionsChecked = false;
   // eslint-disable-next-line @typescript-eslint/naming-convention
   _checkEvaluationOptions() {
     if (!this.evaluationOptionsChecked) {
@@ -93,6 +65,7 @@ class Parser {
       this.evaluationOptionsChecked = true;
     }
   }
+  validationOptionsChecked = false;
   // eslint-disable-next-line @typescript-eslint/naming-convention
   _checkValidationOptions() {
     if (!this.validationOptionsChecked) {
@@ -100,6 +73,29 @@ class Parser {
       this.validationOptionsChecked = true;
     }
   }
+  options;
+  lexer;
+  $;
+  $categories;
+  info;
+  constructor(options) {
+    const opts = parseParserOptions(options ?? {});
+    checkParserOpts(opts);
+    this.options = opts;
+    this.lexer = new Lexer(opts);
+    this.$ = this.lexer.$;
+    this.$categories = this.lexer.$categories;
+    this.info = {
+      expandedSepAlsoCustom: this.lexer.symbols.expandedSepAlsoCustom,
+      customOpAlsoNegation: this.lexer.symbols.customOpAlsoNegation
+    };
+  }
+  state = {
+    rawInput: "",
+    lexedTokens: [],
+    index: 0,
+    shift: 0
+  };
   /**
    * This is exposed mainly for debugging purposes. Use parse directly instead.
    */
@@ -148,6 +144,8 @@ class Parser {
     };
     return res;
   }
+  subParserOne;
+  subParserTwo;
   createSubParserIfNotExists(opts, which = "One") {
     if (this[`subParser${which}`] === void 0) {
       this[`subParser${which}`] = new Parser(opts);
@@ -161,8 +159,7 @@ class Parser {
     };
   }
   getCategoryTokens(type) {
-    var _a;
-    return (_a = this.$categories[type]) == null ? void 0 : _a.entries;
+    return this.$categories[type]?.entries;
   }
   getTokenType(type) {
     return this.$[type];
@@ -177,9 +174,9 @@ class Parser {
     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?.type === type) return true;
     const category = this.$categories[type];
-    if ((category == null ? void 0 : category.entries[token2.type]) !== void 0) {
+    if (category?.entries[token2.type] !== void 0) {
       return true;
     }
     return false;
@@ -207,8 +204,7 @@ class Parser {
     return this.peek(1) === void 0;
   }
   consumeAny() {
-    var _a;
-    return this.consume((_a = this.peek(1)) == null ? void 0 : _a.type);
+    return this.consume(this.peek(1)?.type);
   }
   consume(type) {
     if (type === void 0) {
@@ -220,21 +216,21 @@ class Parser {
     }
     if (this.$categories[type] !== void 0) {
       const categoryToken = this.$categories[type];
-      const tokenType = categoryToken == null ? void 0 : categoryToken.entries[nextToken.type];
+      const tokenType = categoryToken?.entries[nextToken.type];
       if (categoryToken && tokenType) {
         this.state.index++;
         return this.transformCategoryToken(nextToken, categoryToken);
       } else {
-        throw new Error("here");
+        unreachable();
       }
     } else {
       const tokenType = this.getTokenType(type);
       if (tokenType !== void 0) {
-        if ((nextToken == null ? void 0 : nextToken.type) === tokenType.type) {
+        if (nextToken?.type === tokenType.type) {
           this.state.index++;
           return nextToken;
         } else {
-          throw new Error(`Expected token type ${tokenType.type}, got ${nextToken == null ? void 0 : nextToken.type}`);
+          throw new Error(`Expected token type ${tokenType.type}, got ${nextToken?.type}`);
         }
       }
     }
@@ -256,11 +252,10 @@ class Parser {
   }
   // eslint-disable-next-line @typescript-eslint/explicit-function-return-type
   ruleBool(type) {
-    var _a;
     const OP_TYPE = type === "AND" ? $C.OPERATOR_AND : $C.OPERATOR_OR;
     const pairs = [];
     let next = this.peek(1);
-    while (pairs.length < 1 || ((_a = pairs[pairs.length - 1]) == null ? void 0 : _a[1]) !== void 0) {
+    while (pairs.length < 1 || pairs[pairs.length - 1]?.[1] !== void 0) {
       const exp = type === "AND" ? this.ruleCondition() : this.ruleBool("AND");
       next = this.peek(1);
       const canAttemptErrorRecovery = type === "AND" ? ["error", "and"].includes(this.options.onMissingBooleanOperator) : this.options.onMissingBooleanOperator === "or";
@@ -328,12 +323,11 @@ class Parser {
     return res;
   }
   ruleCondition() {
-    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.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 propVal = property?.prop?.value === void 0 ? void 0 : !property.prop.value.valid ? "" : property.prop.value.value;
+    const propOpVal = property?.rest?.propertyOperator === void 0 ? void 0 : !property.rest.propertyOperator?.valid ? "" : property.rest.propertyOperator?.value;
+    const isExpanded = (property?.rest?.sepL ?? property?.rest?.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 });
@@ -345,15 +339,15 @@ class Parser {
       group$1 = value;
       value = void 0;
     }
-    if (convertRegexValues && isNode(value) && value.type === AST_TYPE.VARIABLE && ((_g = value.quote) == null ? void 0 : _g.left.type) === TOKEN_TYPE.REGEX) {
+    if (convertRegexValues && isNode(value) && value.type === AST_TYPE.VARIABLE && value.quote?.left.type === TOKEN_TYPE.REGEX) {
       value = variable(void 0, void 0, token.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) ?? ""),
+        (value.quote?.left?.value ?? "") + (value.value.value ?? "") + (value.quote?.right?.value ?? ""),
         pos(value)
       ), void 0);
     }
     if (group$1) {
       if (property) {
-        return condition(not, property == null ? void 0 : property.prop, property == null ? void 0 : property.rest, group(void 0, void 0, ...group$1));
+        return condition(not, property?.prop, property?.rest, group(void 0, void 0, ...group$1));
       }
       if (value) {
         return group(void 0, condition(not, void 0, void 0, value), ...group$1);
@@ -361,14 +355,14 @@ class Parser {
       return group(not, value, ...group$1);
     }
     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);
+    return condition(not, property?.prop, property?.rest, value);
   }
   ruleConditionValue(property, { convertRegexValues = false, convertArrayValues = false } = {}) {
     const next = this.peek(1);
     const next2 = this.peek(2);
     const next3 = this.peek(3);
     const next4 = this.peek(4);
-    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(
+    if (this.options.prefixableGroups && property === 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;
@@ -396,7 +390,7 @@ class Parser {
     if (onlyValues && !this.nextIsEof()) {
       while (!this.nextIsEof() && (!this.isType(this.peek(1), $T.PAREN_R) || parenLeftCount !== 0)) {
         const token2 = this.consumeAny();
-        start ?? (start = extractPosition(token2, this.state.shift).start);
+        start ??= extractPosition(token2, this.state.shift).start;
         if (token2.type === $T.PAREN_L) {
           parenLeftCount++;
         }
@@ -406,7 +400,7 @@ class Parser {
       }
     }
     if (start !== void 0) {
-      end ?? (end = extractPosition(this.peek(0), this.state.shift).end);
+      end ??= extractPosition(this.peek(0), this.state.shift).end;
     }
     const parenR = this.isType(this.peek(1), $T.PAREN_R) ? this.ruleParenR() : void 0;
     if (start !== void 0) {
@@ -446,7 +440,7 @@ class Parser {
       return array(bracketL, values, bracketR);
     }
     const start = bracketL.start;
-    const end = bracketR == null ? void 0 : bracketR.end;
+    const end = bracketR?.end;
     const subInput = this.state.rawInput.slice(start, end);
     this.createSubParserIfNotExists({
       ...this.options,
@@ -508,12 +502,12 @@ class Parser {
     const next3 = this.peek(3);
     if (next && (this.isExactType(next, $T.QUOTE_DOUBLE) || this.isExactType(next, $T.QUOTE_SINGLE) || this.isExactType(next, $T.QUOTE_BACKTICK))) {
       const quoteType = next.type;
-      if ((next2 == null ? void 0 : next2.type) === quoteType) {
+      if (next2?.type === quoteType) {
         const quoteL = this.ruleQuote(quoteType);
         const quoteR = this.ruleQuote(quoteType);
         return variable(void 0, quoteL, void 0, quoteR);
       }
-      if ((next3 == null ? void 0 : next3.type) === next.type) {
+      if (next3?.type === next.type) {
         const quoteL = this.ruleQuote(quoteType);
         const value = this.isType(next2, $T.VALUE_UNQUOTED) ? this.ruleValueUnquoted({}) : this.ruleValueNot(quoteType);
         const quoteR = this.ruleQuote(quoteType);
@@ -594,8 +588,8 @@ class Parser {
   }
   ruleQuote(type) {
     const quote = this.peek(1);
-    if (type !== (quote == null ? void 0 : quote.type)) {
-      throw new Error(`Expected quote type ${type}, got ${quote == null ? void 0 : quote.type}`);
+    if (type !== quote?.type) {
+      throw new Error(`Expected quote type ${type}, got ${quote?.type}`);
     }
     switch (type) {
       case $T.QUOTE_SINGLE:
@@ -635,7 +629,7 @@ class Parser {
   }
   ruleParenL() {
     const next = this.peek(1);
-    const value = (next == null ? void 0 : next.type) === $T.PAREN_L ? this.consume($T.PAREN_L) : this.createErrorToken($T.PAREN_L);
+    const value = next?.type === $T.PAREN_L ? this.consume($T.PAREN_L) : this.createErrorToken($T.PAREN_L);
     const loc = extractPosition(value, this.state.shift);
     return this.state.shift === 0 || loc.start > 0 ? delimiter.parenL(value.isError ? void 0 : value.value, loc) : void 0;
   }
@@ -645,7 +639,7 @@ class Parser {
   }
   ruleBracketL() {
     const next = this.peek(1);
-    const value = (next == null ? void 0 : next.type) === $T.BRACKET_L ? this.consume($T.BRACKET_L) : this.createErrorToken($T.BRACKET_L);
+    const value = next?.type === $T.BRACKET_L ? this.consume($T.BRACKET_L) : this.createErrorToken($T.BRACKET_L);
     const loc = extractPosition(value, this.state.shift);
     return this.state.shift === 0 || loc.start > 0 ? delimiter.bracketL(value.isError ? void 0 : value.value, loc) : void 0;
   }
@@ -703,14 +697,13 @@ class Parser {
           return [{ suggestion, value: "/" }];
         case SUGGESTION_TYPE.REGEX_FLAGS:
           return regexFlags.map((value) => ({ suggestion, value })).filter((completion) => {
-            var _a, _b, _c, _d, _e, _f, _g;
             const { suggestion: suggestion2, value } = completion;
             if (suggestion2.type !== SUGGESTION_TYPE.REGEX_FLAGS) {
               return true;
             }
             const token2 = suggestion2.cursorInfo;
-            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)) {
+            const flags = token2.at && getParent(token2.at, parentMap)?.quote?.flags === suggestion2.cursorInfo.at ? token2.at : token2.next && getParent(token2.next, parentMap)?.quote?.flags === suggestion2.cursorInfo.next ? token2.next : token2.prev && getParent(token2.prev, parentMap)?.quote?.flags === suggestion2.cursorInfo.prev ? token2.prev : void 0;
+            if (flags?.value?.includes(value)) {
               return false;
             }
             return true;
@@ -801,14 +794,13 @@ 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;
     const parentMap = generateParentsMap(ast);
     const opts = this.options;
     const tokens = extractTokens(ast);
     const token2 = getCursorInfo(input, tokens, index);
     const wordOps = [...opts.keywords.and, ...opts.keywords.or, ...opts.keywords.not].filter((op) => !op.isSymbol);
-    const canSuggestOpAfterPrev = token2.valid.prev && tokenVariable.includes((_a = token2.valid.prev) == null ? void 0 : _a.type) && (token2.whitespace.prev || token2.valid.prev.type === TOKEN_TYPE.PARENR) && !token2.at && token2.valid.next === void 0;
-    const canSuggestOpBeforeNext = token2.valid.next && tokenVariable.includes((_b = token2.valid.next) == null ? void 0 : _b.type) && token2.whitespace.next && // no parenL allowed since check since there will already be prefix suggestions
+    const canSuggestOpAfterPrev = token2.valid.prev && tokenVariable.includes(token2.valid.prev?.type) && (token2.whitespace.prev || token2.valid.prev.type === TOKEN_TYPE.PARENR) && !token2.at && token2.valid.next === void 0;
+    const canSuggestOpBeforeNext = token2.valid.next && tokenVariable.includes(token2.valid.next?.type) && token2.whitespace.next && // no parenL allowed since check since there will already be prefix suggestions
     !token2.at && token2.valid.prev === void 0;
     const requiresWhitespacePrev = tokenRequiresWhitespace(token2.valid.prev, token2.whitespace.prev, wordOps);
     const requiresWhitespaceNext = tokenRequiresWhitespace(token2.valid.next, token2.whitespace.next, wordOps);
@@ -899,8 +891,8 @@ class Parser {
               break;
             case TOKEN_TYPE.VALUE: {
               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);
+              const prefixedValue = errorParent?.type === AST_TYPE.VARIABLE ? getParent(error, parentMap)?.prefix?.value : false;
+              const isRegexValue = errorParent?.type === AST_TYPE.VARIABLE && (errorParent.quote?.left.type === TOKEN_TYPE.REGEX || errorParent.quote?.right.type === TOKEN_TYPE.REGEX);
               if (!isRegexValue) {
                 if (!prefixedValue && opts.prefixableGroups) {
                   suggestions.push({
@@ -971,16 +963,16 @@ class Parser {
       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 isVarPrev = !token2.whitespace.prev && token2.valid.prev?.type !== TOKEN_TYPE.REGEX && prevVar?.type === AST_TYPE.VARIABLE && (prevCondition?.type === AST_TYPE.CONDITION && prevCondition.value === prevVar && (prevVar.quote?.right === token2.valid.prev || prevVar.value === token2.valid.prev) || prevCondition?.type === AST_TYPE.ARRAY);
+      const isVarNext = !token2.whitespace.next && token2.valid.next?.type !== TOKEN_TYPE.REGEX && nextVar?.type === AST_TYPE.VARIABLE && (nextCondition?.type === AST_TYPE.CONDITION && nextCondition.value === nextVar && (nextVar.quote?.left === token2.valid.next || nextVar.value === token2.valid.next) || nextCondition?.type === AST_TYPE.ARRAY);
+      const isVarAt = atVar?.type === AST_TYPE.VARIABLE && atCondition?.type === AST_TYPE.CONDITION || prevVar?.type === AST_TYPE.VARIABLE && token2.valid.prev === prevVar?.quote?.left || nextVar?.type === AST_TYPE.VARIABLE && token2.valid.next === nextVar?.quote?.right;
+      const isPropertyPrev = prevCondition?.type === AST_TYPE.CONDITION && prevVar !== void 0 && prevVar === prevCondition?.property;
+      const isPropertyNext = nextCondition?.type === AST_TYPE.CONDITION && nextVar !== void 0 && nextVar === nextCondition?.property;
+      const isPropertyAt = atCondition?.type === AST_TYPE.CONDITION && atVar !== void 0 && atVar === atCondition?.property;
+      const isPropertyOperatorPrev = prevVar?.type === AST_TYPE.CONDITION && token2.valid.prev === prevVar?.propertyOperator;
+      const isPropertyOperatorNext = nextVar?.type === AST_TYPE.CONDITION && token2.valid.next === nextVar?.propertyOperator;
+      const isPropertyOperatorAt = atVar?.type === AST_TYPE.CONDITION && token2.at === atVar?.propertyOperator;
+      const noArrayValuesTarget = token2.valid.prev?.type === TOKEN_TYPE.BRACKETL && (token2.valid.next === void 0 || token2.valid.next?.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;
@@ -992,15 +984,15 @@ class Parser {
           const condition2 = parentParent;
           const isValue = condition2.propertyOperator !== void 0 && condition2.value === parent;
           const maybeGroup = getParent(parentParent, parentMap);
-          const isPrefix = (maybeGroup == null ? void 0 : maybeGroup.type) === AST_TYPE.GROUP && maybeGroup.prefix === condition2;
+          const isPrefix = 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 = 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);
+          const prefixedValue = parent.type === AST_TYPE.VARIABLE ? parent?.prefix?.value : false;
+          const isSepPrev = token2.prev?.type === TOKEN_TYPE.OP_EXPANDED_SEP;
+          const arrayValue = parentParent?.type === AST_TYPE.ARRAY;
+          const isRegexFlag = target === parent.quote?.flags;
           if (!isRegexFlag && !isSepPrev && !isValue && !arrayValue && !prefixedValue && opts.prefixableGroups) {
             suggestions.push({
               ...baseSuggestion,
@@ -1057,9 +1049,9 @@ class Parser {
           range: pos(propOpTarget)
         });
       }
-      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);
+      const canSuggestValue = token2.whitespace.next && (token2.whitespace.prev || token2.prev?.type === TOKEN_TYPE.BRACKETL || token2.prev?.type === TOKEN_TYPE.PARENL) || token2.whitespace.prev && (token2.whitespace.next || token2.next?.type === TOKEN_TYPE.BRACKETR || token2.next?.type === TOKEN_TYPE.PARENR);
       if (canSuggestValue) {
-        const inArrayNode = [nextCondition, prevCondition, nextVar, prevVar].find((_) => (_ == null ? void 0 : _.type) === AST_TYPE.ARRAY) !== void 0;
+        const inArrayNode = [nextCondition, prevCondition, nextVar, prevVar].find((_) => _?.type === AST_TYPE.ARRAY) !== void 0;
         const opsNotNeeded = ["and", "or"].includes(opts.onMissingBooleanOperator);
         if (inArrayNode || opsNotNeeded) {
           suggestions.push({
@@ -1085,8 +1077,8 @@ class Parser {
       const tokenValidNextParent = getParent(token2.valid.next, parentMap);
       const canSuggestRegexFlags = (
         // has existing flags before/after
-        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)
+        token2.at && token2.at === tokenAtParent?.quote?.flags || token2.valid.prev && token2.valid.prev === tokenValidPrevParent?.quote?.flags || token2.valid.next && token2.valid.next === tokenValidNextParent?.quote?.flags || // no flags
+        token2.valid.prev?.type === TOKEN_TYPE.REGEX && token2.valid.prev === tokenValidPrevParent.quote?.right
       );
       if (canSuggestRegexFlags) {
         suggestions.push({
@@ -1263,7 +1255,6 @@ 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, _n, _o, _p, _q, _r, _s;
     this._checkEvaluationOptions();
     const opts = this.options;
     if (!ast.valid) {
@@ -1275,8 +1266,8 @@ class Parser {
     const self_ = this;
     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 isValue = ast.value.type === AST_TYPE.ARRAY || ast.value?.quote?.left.type === TOKEN_TYPE.REGEX;
+        let name = ast.property?.value?.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;
@@ -1286,16 +1277,16 @@ class Parser {
           value = name ?? true;
           name = prefix;
         } else {
-          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;
+          value = ast.value.type === AST_TYPE.ARRAY ? ast.value.values.map((val) => unescape(val.value.value)) : ast.value?.quote?.left.type === TOKEN_TYPE.REGEX ? ast.value.value?.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.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;
+        operator2 ??= ast.propertyOperator?.value;
+        const isRegex = ast.value?.quote?.left.type === TOKEN_TYPE.REGEX;
+        const isQuoted = ast.value?.quote !== void 0;
         const isExpanded = ast.sep !== void 0;
-        const regexFlags = (_n = (_m = (_l = ast.value) == null ? void 0 : _l.quote) == null ? void 0 : _m.flags) == null ? void 0 : _n.value;
+        const regexFlags = ast.value?.quote?.flags?.value;
         const query = {
           value,
           operator: operator2,
@@ -1316,14 +1307,14 @@ class Parser {
           name = applyPrefix(prefix, name, opts.prefixApplier);
         }
         const boolValue = applyBoolean(groupValue, ast.operator === void 0);
-        const operator22 = (_o = ast.propertyOperator) == null ? void 0 : _o.value;
+        const operator22 = ast.propertyOperator?.value;
         return self_.normalize(ast.value, name, boolValue, operator22);
       }
     }
     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 _prefix = ast.prefix?.type === AST_TYPE.CONDITION && ast.prefix?.value.type === AST_TYPE.VARIABLE ? unescape(ast.prefix.value.value.value) : void 0;
       const isNotToken = _prefix === 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 _groupValue = ast.prefix?.type === AST_TYPE.CONDITION ? ast.prefix.operator === void 0 : !(ast.prefix?.valid === true);
       const applied = isNotToken ? prefix : applyPrefix(prefix, _prefix, opts.prefixApplier);
       return self_.normalize(ast.expression, applied, applyBoolean(groupValue, _groupValue), operator2);
     }
@@ -1342,7 +1333,6 @@ 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, _j, _k, _l;
     const self = this;
     self._checkValidationOptions();
     const opts = self.options;
@@ -1357,7 +1347,7 @@ class Parser {
     const self_ = this;
     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 isValue = ast.value.type === AST_TYPE.ARRAY || ast.value?.quote?.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;
@@ -1372,17 +1362,17 @@ class Parser {
           propertyNodes = [...prefixes];
         } else {
           propertyNodes = [...prefixes, ...nameNode ? [nameNode] : []];
-          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;
+          value = ast.value.type === AST_TYPE.ARRAY ? ast.value.values : ast.value?.quote?.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.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;
+        operator2 ??= ast.propertyOperator;
+        const isRegex = ast.value?.quote?.left.type === TOKEN_TYPE.REGEX;
+        const isQuoted = ast.value?.quote !== void 0;
         const isExpanded = ast.sep !== void 0;
-        const regexFlags = (_i = (_h = ast.value) == null ? void 0 : _h.quote) == null ? void 0 : _i.flags;
+        const regexFlags = ast.value?.quote?.flags;
         const query = {
           value,
           operator: operator2,
@@ -1415,10 +1405,10 @@ class Parser {
       }
     }
     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;
+      const _prefix = ast.prefix?.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);
+      const _groupValue = ast.prefix?.type === AST_TYPE.CONDITION ? ast.prefix.operator === void 0 : !(ast.prefix?.valid === true);
+      self_.validate(ast.expression, context, applyPrefix(prefix, _prefix?.value.value ?? "", opts.prefixApplier), applyBoolean(groupValue, _groupValue), results, prefixes, operator2);
     }
     if (ast.type === AST_TYPE.EXPRESSION) {
       self_.validate(ast.left, context, prefix, groupValue, results, [...prefixes], operator2);

package/dist/ast/builders/array.js

@@ -2,17 +2,16 @@ import { token } from "./token.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 = {
     values
   };
   node.bracket = {};
-  const start = ((_a = values[0]) == null ? void 0 : _a.start) ?? (parenLeftPos == null ? void 0 : parenLeftPos.end);
-  const end = ((_b = values[values.length - 1]) == null ? void 0 : _b.end) ?? (parenRightPos == null ? void 0 : parenRightPos.start) ?? (parenLeftPos == null ? void 0 : parenLeftPos.end);
-  parenLeftPos ?? (parenLeftPos = start !== void 0 ? { start: start - 1, end: start } : void 0);
-  parenRightPos ?? (parenRightPos = end !== void 0 ? { start: end, end: end + 1 } : void 0);
+  const start = values[0]?.start ?? parenLeftPos?.end;
+  const end = values[values.length - 1]?.end ?? parenRightPos?.start ?? parenLeftPos?.end;
+  parenLeftPos ??= start !== void 0 ? { start: start - 1, end: start } : void 0;
+  parenRightPos ??= end !== void 0 ? { start: end, end: end + 1 } : void 0;
   node.bracket.left = token(TOKEN_TYPE.BRACKETL, "[", parenLeftPos);
-  if (bracket == null ? void 0 : bracket.right) {
+  if (bracket?.right) {
     node.bracket.right = token(TOKEN_TYPE.BRACKETR, "]", parenRightPos);
   } else {
     if (parenRightPos) {
@@ -20,8 +19,8 @@ function array(values, bracket = { right: true, left: true }, parenLeftPos, pare
     }
     node.bracket.right = token(TOKEN_TYPE.BRACKETR, void 0, parenRightPos);
   }
-  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;
+  node.start = node.bracket.left?.start ?? start ?? node.bracket?.right.start;
+  node.end = node.bracket?.right?.end ?? end ?? node.bracket.left.end;
   return createArrayNode(node);
 }
 export {

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

@@ -10,5 +10,5 @@ import { type AnyToken, type ArrayNode, type ConditionNode, type ErrorToken, typ
  * @param propertyOperator Set the operator for a property condition. A property must have been passed. The property operator must be a valid token. There is no case where it would not be. If using an operator that is the same as a separator, if used as an operator, should be set as an operator.
  * @param sep Pass separator tokens for expanded property conditions.
  */
-export declare function condition(value: VariableNode | GroupNode | ArrayNode | ErrorToken, not?: true | ValidToken<TOKEN_TYPE.NOT>, property?: VariableNode | ErrorToken, propertyOperator?: AnyToken<TOKEN_TYPE.OP_CUSTOM | TOKEN_TYPE.VALUE>, { right, left }?: Partial<Record<"right" | "left", ValidToken<TOKEN_TYPE.OP_EXPANDED_SEP>>>): ConditionNode;
+export declare function condition(value: VariableNode | GroupNode | ArrayNode | ErrorToken, not?: true | ValidToken<typeof TOKEN_TYPE.NOT>, property?: VariableNode | ErrorToken, propertyOperator?: AnyToken<typeof TOKEN_TYPE.OP_CUSTOM | typeof TOKEN_TYPE.VALUE>, { right, left }?: Partial<Record<"right" | "left", ValidToken<typeof TOKEN_TYPE.OP_EXPANDED_SEP>>>): ConditionNode;
 //# sourceMappingURL=condition.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"condition.d.ts","sourceRoot":"","sources":["../../../src/ast/builders/condition.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,KAAK,QAAQ,EAAE,KAAK,SAAS,EAAE,KAAK,aAAa,EAAE,KAAK,UAAU,EAAmB,KAAK,SAAS,EAAiB,KAAK,UAAU,EAAE,KAAK,UAAU,EAAE,KAAK,YAAY,EAAE,MAAM,oBAAoB,CAAA;AAG5M;;;;;;;;;;GAUG;AAEH,wBAAgB,SAAS,CACxB,KAAK,EACH,YAAY,GACZ,SAAS,GACT,SAAS,GACT,UAAU,EACZ,GAAG,GAAE,IAAI,GAAG,UAAU,CAAC,UAAU,CAAC,GAAG,CAAQ,EAC7C,QAAQ,CAAC,EAAE,YAAY,GAAG,UAAU,EACpC,gBAAgB,CAAC,EAAE,QAAQ,CAAC,UAAU,CAAC,SAAS,GAAG,UAAU,CAAC,KAAK,CAAC,EACpE,EAAE,KAAK,EAAE,IAAI,EAAE,GAAE,OAAO,CAAC,MAAM,CAAC,OAAO,GAAG,MAAM,EAAE,UAAU,CAAC,UAAU,CAAC,eAAe,CAAC,CAAC,CAAO,GAC9F,aAAa,CAsBf"}
+{"version":3,"file":"condition.d.ts","sourceRoot":"","sources":["../../../src/ast/builders/condition.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,KAAK,QAAQ,EAAE,KAAK,SAAS,EAAE,KAAK,aAAa,EAAE,KAAK,UAAU,EAAmB,KAAK,SAAS,EAAiB,KAAK,UAAU,EAAE,KAAK,UAAU,EAAE,KAAK,YAAY,EAAE,MAAM,oBAAoB,CAAA;AAG5M;;;;;;;;;;GAUG;AAEH,wBAAgB,SAAS,CACxB,KAAK,EACH,YAAY,GACZ,SAAS,GACT,SAAS,GACT,UAAU,EACZ,GAAG,GAAE,IAAI,GAAG,UAAU,CAAC,OAAO,UAAU,CAAC,GAAG,CAAQ,EACpD,QAAQ,CAAC,EAAE,YAAY,GAAG,UAAU,EACpC,gBAAgB,CAAC,EAAE,QAAQ,CAAC,OAAO,UAAU,CAAC,SAAS,GAAG,OAAO,UAAU,CAAC,KAAK,CAAC,EAClF,EAAE,KAAK,EAAE,IAAI,EAAE,GAAE,OAAO,CAAC,MAAM,CAAC,OAAO,GAAG,MAAM,EAAE,UAAU,CAAC,OAAO,UAAU,CAAC,eAAe,CAAC,CAAC,CAAO,GACrG,aAAa,CAsBf"}

package/dist/ast/builders/condition.js

@@ -1,9 +1,10 @@
 import { pos } from "./pos.js";
+import "../../types/ast.js";
 import { createConditionNode } from "../createConditionNode.js";
 function condition(value, not = true, property, propertyOperator, { right, left } = {}) {
   const position = pos(value);
   const notStart = not === true ? void 0 : not.start;
-  position.start = notStart ?? (property == null ? void 0 : property.start) ?? (propertyOperator == null ? void 0 : propertyOperator.start) ?? position.start;
+  position.start = notStart ?? property?.start ?? propertyOperator?.start ?? position.start;
   const node = {
     property,
     value,

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

@@ -1,8 +1,8 @@
-import { type ExtractTokenType } from "../../types/ast.js";
+import { type ExtractToken } from "../../types/ast.js";
 /**
  * Faster way, more intuitive way to generate the options for matching delimiters (e.g. quotes and parens) for functions like {@link variable} and {@link group} .
  */
-export declare function delim<TLeft extends boolean | string, TRight extends boolean | string, TType extends TLeft extends string ? ExtractTokenType<TLeft> : TRight extends string ? ExtractTokenType<TRight> : undefined>(left?: TLeft, right?: TRight): {
+export declare function delim<TLeft extends boolean | string, TRight extends boolean | string, TType extends TLeft extends string ? ExtractToken<TLeft> : TRight extends string ? ExtractToken<TRight> : undefined>(left?: TLeft, right?: TRight): {
     left: TLeft extends string ? true : TLeft;
     right: TRight extends string ? true : TRight;
 } & TType extends undefined ? Record<string, never> : {

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

@@ -1 +1 @@
-{"version":3,"file":"delim.d.ts","sourceRoot":"","sources":["../../../src/ast/builders/delim.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,KAAK,gBAAgB,EAAc,MAAM,oBAAoB,CAAA;AAEtE;;GAEG;AAEH,wBAAgB,KAAK,CACpB,KAAK,SAAS,OAAO,GAAG,MAAM,EAC9B,MAAM,SAAS,OAAO,GAAG,MAAM,EAC/B,KAAK,SAAS,KAAK,SAAS,MAAM,GAC/B,gBAAgB,CAAC,KAAK,CAAC,GACvB,MAAM,SAAS,MAAM,GACrB,gBAAgB,CAAC,MAAM,CAAC,GACxB,SAAS,EAEZ,IAAI,GAAE,KAAsB,EAC5B,KAAK,GAAE,MAAwB,GAE/B;IACC,IAAI,EAAE,KAAK,SAAS,MAAM,GAAG,IAAI,GAAG,KAAK,CAAA;IACzC,KAAK,EAAE,MAAM,SAAS,MAAM,GAAG,IAAI,GAAG,MAAM,CAAA;CAC5C,GAAG,KAAK,SAAS,SAAS,GAAG,MAAM,CAAC,MAAM,EAAC,KAAK,CAAC,GAAG;IAAE,IAAI,EAAE,KAAK,CAAA;CAAE,CAepE"}
+{"version":3,"file":"delim.d.ts","sourceRoot":"","sources":["../../../src/ast/builders/delim.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,KAAK,YAAY,EAAc,MAAM,oBAAoB,CAAA;AAElE;;GAEG;AAEH,wBAAgB,KAAK,CACpB,KAAK,SAAS,OAAO,GAAG,MAAM,EAC9B,MAAM,SAAS,OAAO,GAAG,MAAM,EAC/B,KAAK,SAAS,KAAK,SAAS,MAAM,GAC/B,YAAY,CAAC,KAAK,CAAC,GACnB,MAAM,SAAS,MAAM,GACrB,YAAY,CAAC,MAAM,CAAC,GACpB,SAAS,EAEZ,IAAI,GAAE,KAAsB,EAC5B,KAAK,GAAE,MAAwB,GAE/B;IACC,IAAI,EAAE,KAAK,SAAS,MAAM,GAAG,IAAI,GAAG,KAAK,CAAA;IACzC,KAAK,EAAE,MAAM,SAAS,MAAM,GAAG,IAAI,GAAG,MAAM,CAAA;CAC5C,GAAG,KAAK,SAAS,SAAS,GAAG,MAAM,CAAC,MAAM,EAAC,KAAK,CAAC,GAAG;IAAE,IAAI,EAAE,KAAK,CAAA;CAAE,CAepE"}