@witchcraft/expressit 0.3.0 → 0.3.1

package/dist/Lexer.js

@@ -1,9 +1,6 @@
-var __defProp = Object.defineProperty;
-var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
-var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
-import { enumFromArray } from "@alanscodelog/utils/enumFromArray.js";
-import { isBlank } from "@alanscodelog/utils/isBlank.js";
-import { pushIfNotIn } from "@alanscodelog/utils/pushIfNotIn.js";
+import { enumFromArray } from "@alanscodelog/utils/enumFromArray";
+import { isBlank } from "@alanscodelog/utils/isBlank";
+import { pushIfNotIn } from "@alanscodelog/utils/pushIfNotIn";
 import { checkParserOpts } from "./internal/checkParserOpts.js";
 import { parseParserOptions } from "./internal/parseParserOptions.js";
 const regexFlags = /^[a-zA-Z]+/;
@@ -104,12 +101,12 @@ function matchSymbol(symbols) {
   };
 }
 class Lexer {
+  symbols;
+  $;
+  $categories;
+  branches;
+  opts;
   constructor(opts = {}) {
-    __publicField(this, "symbols");
-    __publicField(this, "$");
-    __publicField(this, "$categories");
-    __publicField(this, "branches");
-    __publicField(this, "opts");
     this.opts = parseParserOptions(opts);
     checkParserOpts(this.opts);
     this.symbols = this.calculateSymbolInfo();
@@ -119,7 +116,6 @@ class Lexer {
     this.branches = this.createModeBranches();
   }
   calculateSymbolInfo() {
-    var _a;
     const opts = this.opts;
     const symOrs = opts.keywords.or.filter((_) => _.isSymbol).map((_) => _.value);
     const symAnds = opts.keywords.and.filter((_) => _.isSymbol).map((_) => _.value);
@@ -146,7 +142,7 @@ class Lexer {
       wordNots: wordNots.sort((a, b) => b.length - a.length),
       all: syms.sort((a, b) => b.length - a.length)
     };
-    const expandedSepAlsoCustom = ((_a = opts.customPropertyOperators) == null ? void 0 : _a.includes(opts.expandedPropertySeparator)) ?? false;
+    const expandedSepAlsoCustom = opts.customPropertyOperators?.includes(opts.expandedPropertySeparator) ?? false;
     let customOpAlsoNegation = false;
     if (symbols.symNots.length > 0) {
       for (const op of opts.customPropertyOperators ?? []) {
@@ -162,7 +158,6 @@ class Lexer {
   }
   // eslint-disable-next-line @typescript-eslint/explicit-function-return-type
   createTokens() {
-    var _a;
     const opts = this.opts;
     const symbols = this.symbols;
     const $ = {
@@ -213,7 +208,7 @@ class Lexer {
                 prevEscaped = false;
               }
             } else {
-              prevEscaped && (prevEscaped = false);
+              prevEscaped &&= false;
             }
             end++;
             c = input[end];
@@ -231,7 +226,7 @@ class Lexer {
              * Go back to main instead of searching for the quoted value
              * Otherwise input like 'a'b'c' will trap us in a MAIN <=> NOT_SINGLE loop.
              */
-            (previous == null ? void 0 : previous.type) === $T.VALUE_NOT_SINGLE || (previous == null ? void 0 : previous.type) === $T.VALUE_UNQUOTED
+            previous?.type === $T.VALUE_NOT_SINGLE || previous?.type === $T.VALUE_UNQUOTED
           ) {
             if (mode.startsWith(BRACKET_PREFIX)) return MODE.BRACKET_MAIN;
             return MODE.MAIN;
@@ -251,7 +246,7 @@ class Lexer {
       [$T.QUOTE_DOUBLE]: createTokenType($T.QUOTE_DOUBLE, {
         push: (mode, tokens) => {
           const previous = tokens[tokens.length - 2];
-          if ((previous == null ? void 0 : previous.type) === $T.VALUE_NOT_DOUBLE || (previous == null ? void 0 : previous.type) === $T.VALUE_UNQUOTED) {
+          if (previous?.type === $T.VALUE_NOT_DOUBLE || previous?.type === $T.VALUE_UNQUOTED) {
             if (mode.startsWith(BRACKET_PREFIX)) return MODE.BRACKET_MAIN;
             return MODE.MAIN;
           }
@@ -270,7 +265,7 @@ class Lexer {
       [$T.QUOTE_BACKTICK]: createTokenType($T.QUOTE_BACKTICK, {
         push: (mode, tokens) => {
           const previous = tokens[tokens.length - 2];
-          if ((previous == null ? void 0 : previous.type) === $T.VALUE_NOT_BACKTICK || (previous == null ? void 0 : previous.type) === $T.VALUE_UNQUOTED) {
+          if (previous?.type === $T.VALUE_NOT_BACKTICK || previous?.type === $T.VALUE_UNQUOTED) {
             if (mode.startsWith(BRACKET_PREFIX)) return MODE.BRACKET_MAIN;
             return MODE.MAIN;
           }
@@ -372,7 +367,7 @@ class Lexer {
           }
         })
       } : {},
-      ...(((_a = opts.customPropertyOperators) == null ? void 0 : _a.length) ?? 0) > 0 && !symbols.customOpAlsoNegation ? {
+      ...(opts.customPropertyOperators?.length ?? 0) > 0 && !symbols.customOpAlsoNegation ? {
         [$T.CUSTOM_PROP_OP]: createTokenType($T.CUSTOM_PROP_OP, {
           matches: (_c, input, start) => {
             for (const op of opts.customPropertyOperators ?? []) {

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";
@@ -59,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) {
@@ -94,6 +65,7 @@ class Parser {
       this.evaluationOptionsChecked = true;
     }
   }
+  validationOptionsChecked = false;
   // eslint-disable-next-line @typescript-eslint/naming-convention
   _checkValidationOptions() {
     if (!this.validationOptionsChecked) {
@@ -101,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.
    */
@@ -149,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);
@@ -162,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];
@@ -178,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;
@@ -208,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) {
@@ -221,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}`);
         }
       }
     }
@@ -257,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";
@@ -329,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 });
@@ -346,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);
@@ -362,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;
@@ -397,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++;
         }
@@ -407,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) {
@@ -447,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,
@@ -509,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);
@@ -595,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:
@@ -636,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;
   }
@@ -646,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;
   }
@@ -704,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;
@@ -802,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);
@@ -900,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({
@@ -972,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;
@@ -993,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,
@@ -1058,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({
@@ -1086,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({
@@ -1264,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) {
@@ -1276,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;
@@ -1287,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,
@@ -1317,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);
     }
@@ -1343,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;
@@ -1358,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;
@@ -1373,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,
@@ -1416,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);