@witchcraft/expressit 0.0.3 → 0.1.1

package/dist/Parser.js

@@ -0,0 +1,1476 @@
+var __defProp = Object.defineProperty;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __publicField = (obj, key, value) => {
+  __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
+  return value;
+};
+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 { 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 { 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 { Lexer, $C, $T } from "./Lexer.js";
+import { TOKEN_TYPE } from "./types/ast.js";
+import { SUGGESTION_TYPE } from "./types/autocomplete.js";
+import { extractTokens } from "./utils/extractTokens.js";
+import { getCursorInfo } from "./utils/getCursorInfo.js";
+import { getSurroundingErrors } from "./utils/getSurroundingErrors.js";
+const OPPOSITE = {
+  [TOKEN_TYPE.AND]: TOKEN_TYPE.OR,
+  [TOKEN_TYPE.OR]: TOKEN_TYPE.AND
+};
+function isEqualSet(setA, setB) {
+  if (setA.size !== setB.size)
+    return false;
+  for (const key of setA) {
+    if (!setB.has(key))
+      return false;
+  }
+  return true;
+}
+const defaultNodeDirs = {
+  before: false,
+  after: false
+};
+const createDefaultRequires = (partial = {}) => ({
+  whitespace: {
+    ...defaultNodeDirs,
+    ...partial.whitespace ? partial.whitespace : {}
+  },
+  group: partial.group ?? false,
+  prefix: partial.prefix ?? false
+});
+const tokenRequiresWhitespace = (validToken, whitespace, wordOps) => {
+  if (whitespace || validToken === void 0)
+    return false;
+  return validToken.type === TOKEN_TYPE.VALUE || [TOKEN_TYPE.AND, TOKEN_TYPE.OR, TOKEN_TYPE.NOT].includes(validToken.type) && wordOps.find((_) => _.value === validToken.value) !== void 0;
+};
+const 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
+    };
+  }
+  // eslint-disable-next-line @typescript-eslint/naming-convention
+  _checkEvaluationOptions() {
+    if (!this.evaluationOptionsChecked) {
+      checkParserOpts(this.options, true);
+      this.evaluationOptionsChecked = true;
+    }
+  }
+  // eslint-disable-next-line @typescript-eslint/naming-convention
+  _checkValidationOptions() {
+    if (!this.validationOptionsChecked) {
+      checkParserOpts(this.options, false, true);
+      this.validationOptionsChecked = true;
+    }
+  }
+  /**
+   * This is exposed mainly for debugging purposes. Use parse directly instead.
+   */
+  lex(input) {
+    if (isWhitespace(input)) {
+      return { tokens: [], shift: 0, rawInput: input };
+    }
+    let lexed = this.lexer.tokenize(input);
+    const shift = getUnclosedRightParenCount(lexed);
+    const rawInput = input;
+    if (shift) {
+      input = "(".repeat(shift) + input;
+      lexed = this.lexer.tokenize(input);
+    }
+    const lexedTokens = lexed.filter((token2) => {
+      const tokenType = this.getTokenType(token2.type);
+      if (tokenType) {
+        return !tokenType.skip;
+      } else {
+        throw new Error(`Unknown token type ${token2.type}`);
+      }
+    });
+    return { tokens: lexedTokens, shift, rawInput };
+  }
+  /**
+   * Parse an input string into an AST.
+   * 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 });
+    }
+    const { tokens: lexedTokens, shift, rawInput } = typeof input === "string" ? this.lex(input) : input;
+    this.state = {
+      rawInput,
+      shift,
+      index: -1,
+      lexedTokens
+    };
+    const res = this.ruleMain();
+    if (doSeal) {
+      seal(res);
+    }
+    this.state = {
+      rawInput: "",
+      shift: 0,
+      index: -1,
+      lexedTokens: []
+    };
+    return res;
+  }
+  createSubParserIfNotExists(opts, which = "One") {
+    if (this[`subParser${which}`] === void 0) {
+      this[`subParser${which}`] = new Parser(opts);
+    }
+    return this[`subParser${which}`];
+  }
+  transformCategoryToken(token2, categoryToken) {
+    return {
+      ...token2,
+      type: categoryToken.type
+    };
+  }
+  getCategoryTokens(type) {
+    var _a;
+    return (_a = this.$categories[type]) == null ? void 0 : _a.entries;
+  }
+  getTokenType(type) {
+    return this.$[type];
+  }
+  isExactType(token2, type) {
+    if (this.$[type]) {
+      return this.isType(token2, type);
+    }
+    return false;
+  }
+  isType(token2, type) {
+    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;
+    const category = this.$categories[type];
+    if ((category == null ? void 0 : category.entries[token2.type]) !== void 0) {
+      return true;
+    }
+    return false;
+  }
+  createErrorToken(type, index) {
+    return {
+      type,
+      value: "",
+      startOffset: index ?? this.state.index,
+      endOffset: index ?? this.state.index,
+      isError: true
+    };
+  }
+  processToken(token2) {
+    if (token2 === void 0) {
+      return [void 0, extractPosition({ startOffset: 0, endOffset: 0 }, this.state.shift)];
+    } else {
+      return [token2.value, extractPosition(token2, this.state.shift)];
+    }
+  }
+  peek(n = 1) {
+    return this.state.lexedTokens[this.state.index + n];
+  }
+  nextIsEof() {
+    return this.peek(1) === void 0;
+  }
+  consumeAny() {
+    var _a;
+    return this.consume((_a = this.peek(1)) == null ? void 0 : _a.type);
+  }
+  consume(type) {
+    if (type === void 0) {
+      throw new Error("type is undefined");
+    }
+    const nextToken = this.peek(1);
+    if (nextToken === void 0) {
+      throw new Error(`Reached end of input without consuming a token of type ${type}`);
+    }
+    if (this.$categories[type] !== void 0) {
+      const categoryToken = this.$categories[type];
+      const tokenType = categoryToken == null ? void 0 : categoryToken.entries[nextToken.type];
+      if (categoryToken && tokenType) {
+        this.state.index++;
+        return this.transformCategoryToken(nextToken, categoryToken);
+      } else {
+        throw new Error("here");
+      }
+    } else {
+      const tokenType = this.getTokenType(type);
+      if (tokenType !== void 0) {
+        if ((nextToken == null ? void 0 : 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(`Unknown token type ${type}`);
+  }
+  saveState() {
+    return { ...this.state };
+  }
+  restoreState(state) {
+    this.state = state;
+  }
+  ruleMain() {
+    const res = this.ruleBool("OR");
+    if (res === void 0) {
+      const error = token.value(void 0, { start: 0, end: 0 });
+      return error;
+    }
+    return res;
+  }
+  // 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) {
+      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";
+      const extras = [];
+      if (canAttemptErrorRecovery && (this.isType(next, $C.VALUE) || this.isType(next, $C.QUOTE_ANY) || this.isType(next, $T.PAREN_L) || this.isType(next, $T.EXP_PROP_OP) || this.isType(next, $T.REGEX_START) || this.isType(next, $T.CUSTOM_PROP_OP))) {
+        let state = this.saveState();
+        let cond = this.ruleCondition();
+        if (type === "AND") {
+          let dummyOp;
+          while (cond !== void 0) {
+            if (this.options.onMissingBooleanOperator === "and") {
+              const prev = this.peek(-1);
+              const start = prev.endOffset + 1;
+              dummyOp = operator.and("", pos({ start }, { fill: true }));
+            }
+            extras.push([dummyOp, cond]);
+            state = this.saveState();
+            cond = this.ruleCondition();
+          }
+          this.restoreState(state);
+        } else {
+          const prev = this.peek(-1);
+          const start = prev.endOffset + 1;
+          const dummyOp = operator.or("", pos({ start }, { fill: true }));
+          extras.push([dummyOp, cond]);
+        }
+        next = this.peek(1);
+      }
+      const sepToken = this.isType(next, OP_TYPE) && next ? type === "AND" ? operator.and(...this.processToken(this.consume(next.type))) : operator.or(...this.processToken(this.consume(next.type))) : void 0;
+      pairs.push([
+        exp,
+        sepToken
+      ]);
+      next = this.peek(1);
+      for (const extra of extras) {
+        pairs[pairs.length - 1].splice(1, 1, extra[0]);
+        pairs.push([extra[1]]);
+      }
+    }
+    if (pairs.length === 0 && this.isType(this.peek(1), OP_TYPE)) {
+      next = this.peek(-1);
+      let state = this.saveState();
+      while (this.isType(next, $C.OPERATOR_AND)) {
+        const token2 = this.consume($C.OPERATOR_AND);
+        pairs.push([
+          void 0,
+          type === "AND" ? operator.and(...this.processToken(token2)) : operator.or(...this.processToken(token2))
+        ]);
+        next = this.peek(-1);
+        while (this.isType(next, $C.VALUE) || this.isType(next, $C.QUOTE_ANY) || this.isType(next, $T.PAREN_L)) {
+          pairs.push([this.ruleCondition()]);
+          next = this.peek(-1);
+        }
+        state = this.saveState();
+      }
+      this.restoreState(state);
+    }
+    if (type === "AND" && pairs.length === 0)
+      return void 0;
+    let res = pairs[pairs.length - 1][0];
+    for (let i = pairs.length - 1; i > 0; i--) {
+      const before = pairs[i - 1];
+      if (type === "OR" && res === void 0 && before === void 0)
+        return void 0;
+      res = expression(before[0], before[1], res);
+    }
+    return res;
+  }
+  ruleCondition() {
+    var _a, _b, _c, _d, _e, _f, _g, _h, _i, _j;
+    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 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)) {
+      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) {
+      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) ?? ""),
+        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));
+      }
+      if (value) {
+        return group(void 0, condition(not, void 0, void 0, value), ...group$1);
+      }
+      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);
+  }
+  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(
+    this.isType(next3, $C.QUOTE_ANY) && this.isType(next4, $T.PAREN_L))))) {
+      const res = this.ruleVariable({ unprefixed: true });
+      if (res)
+        return res;
+    }
+    if (!this.isType(next, $T.PAREN_L)) {
+      const res = this.ruleVariable({ unprefixed: false });
+      if (res)
+        return res;
+    }
+    if (this.isType(next, $T.PAREN_L)) {
+      const res = this.rulePlainGroup({ onlyValues: property !== void 0, convertRegexValues, convertArrayValues });
+      if (res)
+        return res;
+    }
+    if (this.isType(next, $T.BRACKET_L)) {
+      const res = this.rulePlainBracketGroup({ convertArrayValues });
+      if (res)
+        return res;
+    }
+    return void 0;
+  }
+  rulePlainGroup({ onlyValues = false, convertRegexValues = false, convertArrayValues = false } = {}) {
+    const parenL = this.ruleParenL();
+    let parenLeftCount = 0;
+    let start;
+    let end;
+    const condition2 = !onlyValues ? this.ruleBool("OR") : void 0;
+    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);
+        if (token2.type === $T.PAREN_L) {
+          parenLeftCount++;
+        }
+        if (token2.type === $T.PAREN_R) {
+          parenLeftCount--;
+        }
+      }
+    }
+    if (start !== void 0) {
+      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) {
+      const subInput = this.state.rawInput.slice(start, end);
+      this.createSubParserIfNotExists({
+        ...this.options,
+        customPropertyOperators: [],
+        expandedPropertySeparator: void 0,
+        regexValues: convertRegexValues,
+        arrayValues: convertArrayValues
+      }, "One");
+      const parsed = this.subParserOne.parse(" ".repeat(start) + subInput, { seal: false });
+      return [parenL, parsed, parenR];
+    }
+    return [parenL, condition2, parenR];
+  }
+  rulePlainBracketGroup({ convertArrayValues = false } = {}) {
+    const bracketL = this.ruleBracketL();
+    const values = [];
+    if (!convertArrayValues) {
+      let state = this.saveState();
+      let variable2 = this.ruleVariable({ unprefixed: false });
+      while (variable2 !== void 0) {
+        values.push(variable2);
+        state = this.saveState();
+        variable2 = this.ruleVariable({ unprefixed: false });
+      }
+      this.restoreState(state);
+    } else if (convertArrayValues && !this.nextIsEof()) {
+      while (!this.nextIsEof() && !this.isType(this.peek(1), $T.BRACKET_R)) {
+        this.consumeAny();
+      }
+    }
+    const bracketR = this.isType(this.peek(1), $T.BRACKET_R) ? this.ruleBracketR() : void 0;
+    if (bracketL === void 0)
+      throw new Error("bracketL is undefined, peek before using rule.");
+    if (!convertArrayValues) {
+      return array(bracketL, values, bracketR);
+    }
+    const start = bracketL.start;
+    const end = bracketR == null ? void 0 : bracketR.end;
+    const subInput = this.state.rawInput.slice(start, end);
+    this.createSubParserIfNotExists({
+      ...this.options,
+      customPropertyOperators: [],
+      expandedPropertySeparator: void 0,
+      arrayValues: false
+    }, "Two");
+    const parsed = this.subParserTwo.parse(" ".repeat(start) + subInput, { seal: false });
+    if (parsed instanceof ConditionNode) {
+      return parsed.value;
+    }
+    if (parsed instanceof ErrorToken || parsed instanceof ExpressionNode || parsed instanceof GroupNode) {
+      unreachable("parsed.value should not be an ErrorToken, ExpressionNode, or GroupNode.");
+    }
+    return parsed;
+  }
+  ruleConditionProperty() {
+    const current = this.peek(0);
+    const next = this.peek(1);
+    const next2 = this.peek(2);
+    if (this.isType(next, $T.EXP_PROP_OP) || this.isType(next, $T.CUSTOM_PROP_OP) || this.isType(next, $T.VALUE_UNQUOTED) && (this.isType(next2, $T.EXP_PROP_OP) || this.isType(next2, $T.CUSTOM_PROP_OP)) || this.info.customOpAlsoNegation && (this.isType(next2, $T.SYM_NOT) || this.isType(current, $T.SYM_NOT) && this.isType(next, $T.SYM_NOT))) {
+      return this.ruleProperty();
+    }
+    return void 0;
+  }
+  ruleProperty() {
+    const prop = this.ruleVariable({ unprefixed: true });
+    const next = this.peek(1);
+    let rest = {};
+    if (this.isType(next, $T.EXP_PROP_OP)) {
+      const sepL = token.sep(...this.processToken(this.consume($T.EXP_PROP_OP)));
+      const op = this.isType(this.peek(1), $T.VALUE_UNQUOTED) ? token.value(...this.processToken(this.consume($T.VALUE_UNQUOTED))) : void 0;
+      const sepR = this.isType(this.peek(1), $T.EXP_PROP_OP) ? token.sep(...this.processToken(this.consume($T.EXP_PROP_OP))) : void 0;
+      if (this.info.expandedSepAlsoCustom && op === void 0 && sepR === void 0) {
+        setReadOnly(sepL, "type", TOKEN_TYPE.OP_CUSTOM);
+        rest = {
+          sepL: void 0,
+          sepR,
+          propertyOperator: sepL
+        };
+      } else {
+        rest = { sepL, sepR, propertyOperator: op };
+      }
+    } else if (this.isType(next, $T.CUSTOM_PROP_OP)) {
+      const op = token.custom(...this.processToken(this.consume($T.CUSTOM_PROP_OP)));
+      rest = { propertyOperator: op };
+    } else if (this.info.customOpAlsoNegation && this.isType(next, $T.SYM_NOT)) {
+      const op = token.custom(...this.processToken(this.consume($T.SYM_NOT)));
+      rest = { propertyOperator: op };
+    }
+    return { prop, rest };
+  }
+  ruleVariable({
+    unprefixed = false
+  } = {}) {
+    const prefix = this.ruleVariablePrefix({ onlyToken: true, unprefixed });
+    const next = this.peek(1);
+    const next2 = this.peek(2);
+    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) {
+        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) {
+        const quoteL = this.ruleQuote(quoteType);
+        const value = this.isType(next2, $T.VALUE_UNQUOTED) ? this.ruleValueUnquoted({}) : this.ruleValueNot(quoteType);
+        const quoteR = this.ruleQuote(quoteType);
+        const prefixToken = prefix ? token.value(...this.processToken(prefix)) : void 0;
+        return variable(prefixToken, quoteL, value, quoteR);
+      }
+    }
+    if (this.isType(next, $C.REGEX_ANY)) {
+      const quoteL = this.ruleRegexAny();
+      const maybeValue = this.peek(1);
+      const value = this.isType(maybeValue, $T.VALUE_REGEX) ? this.ruleValueNot($C.REGEX_ANY) : void 0;
+      const quoteR = this.isType(this.peek(1), $C.REGEX_ANY) ? this.ruleRegexAny() : void 0;
+      const args = isArray(quoteR) ? quoteR : [quoteR, void 0];
+      return variable(void 0, quoteL, value, args[0], args[1]);
+    }
+    if (this.isType(next, $T.VALUE_UNQUOTED) && this.isType(next2, $C.QUOTE_ANY)) {
+      const value = this.ruleValueUnquoted();
+      const quoteR = this.ruleValueDelimAny();
+      return variable(void 0, void 0, value, quoteR);
+    }
+    if (this.isType(next, $C.QUOTE_ANY)) {
+      const quoteToken = next;
+      const quoteL = this.ruleValueDelimAny();
+      const maybeValue = this.peek(1);
+      const value = !quoteL && this.isType(maybeValue, $T.VALUE_UNQUOTED) ? this.ruleValueUnquoted() : quoteL && this.isType(maybeValue, quoteToken.type.replace("QUOTE", "VALUE_FOR")) ? this.ruleValueNot(quoteToken.type) : void 0;
+      return variable(void 0, quoteL, value, void 0);
+    }
+    if (this.isType(next, $T.VALUE_UNQUOTED)) {
+      const value = this.ruleValueUnquoted();
+      return variable(void 0, void 0, value, void 0);
+    }
+    return void 0;
+  }
+  ruleValueDelimAny() {
+    const next = this.peek(1);
+    if (this.isType(next, $C.QUOTE_ANY)) {
+      const type = next.value === `"` ? "double" : next.value === "'" ? "single" : next.value === "`" ? "tick" : "regex";
+      return delimiter[type](...this.processToken(this.consume($C.QUOTE_ANY)));
+    }
+    return void 0;
+  }
+  ruleRegexAny() {
+    const value = this.consume($C.REGEX_ANY);
+    if (value.value.length > 1) {
+      const delim = {
+        value: "/",
+        startOffset: value.startOffset,
+        endOffset: value.startOffset
+      };
+      const flags = {
+        value: value.value.slice(1),
+        startOffset: value.startOffset + 1,
+        endOffset: value.endOffset
+      };
+      return [
+        // why the ! ??? todo
+        delimiter.regex(...this.processToken(delim)),
+        token.value(...this.processToken(flags))
+      ];
+    }
+    return delimiter.regex(...this.processToken(value));
+  }
+  ruleValueNot(type) {
+    const realType = {
+      [$T.QUOTE_SINGLE]: $C.VALUE_FOR_SINGLE,
+      [$T.QUOTE_DOUBLE]: $C.VALUE_FOR_DOUBLE,
+      [$T.QUOTE_BACKTICK]: $C.VALUE_FOR_BACKTICK,
+      [$C.REGEX_ANY]: $T.VALUE_REGEX
+    }[type];
+    if (realType === void 0) {
+      unreachable(`Unknown quote/regex type ${type}`);
+    }
+    const value = this.consume(realType);
+    if (realType !== value.type) {
+      unreachable(`Expected value type ${realType}, got ${value.type}`);
+    }
+    return token.value(...this.processToken(value));
+  }
+  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}`);
+    }
+    switch (type) {
+      case $T.QUOTE_SINGLE:
+        return delimiter.single(
+          ...this.processToken(this.consume($T.QUOTE_SINGLE))
+        );
+      case $T.QUOTE_DOUBLE:
+        return delimiter.double(
+          ...this.processToken(this.consume($T.QUOTE_DOUBLE))
+        );
+      case $T.QUOTE_BACKTICK:
+        return delimiter.tick(
+          ...this.processToken(this.consume($T.QUOTE_BACKTICK))
+        );
+    }
+    throw new Error(`Expected quote type ${type}`);
+  }
+  ruleVariablePrefix({
+    onlyToken = false,
+    unprefixed = false
+  } = {}) {
+    const next = this.peek(1);
+    const next2 = this.peek(2);
+    const next4 = this.peek(4);
+    if (!unprefixed && this.options.prefixableStrings !== void 0 && this.isType(next2, $C.QUOTE_ANY) && next2 && this.isType(next4, next2.type) && next && this.options.prefixableStrings.includes(next.value)) {
+      return this.ruleValueUnquoted({ onlyToken });
+    }
+    if (onlyToken)
+      return void 0;
+    return token.value(...this.processToken());
+  }
+  ruleValueUnquoted({
+    onlyToken = false
+  } = {}) {
+    const t = this.consume($T.VALUE_UNQUOTED);
+    const res = onlyToken ? t : token.value(...this.processToken(t));
+    return res;
+  }
+  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 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;
+  }
+  ruleParenR() {
+    const value = this.consume($T.PAREN_R);
+    return delimiter.parenR(...this.processToken(value));
+  }
+  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 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;
+  }
+  ruleBracketR() {
+    const value = this.consume($T.BRACKET_R);
+    return delimiter.bracketR(...this.processToken(value));
+  }
+  ruleNot() {
+    if (this.isType(this.peek(1), $C.OPERATOR_NOT)) {
+      const op = this.consume($C.OPERATOR_NOT);
+      return operator.not(...this.processToken(op));
+    }
+    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.
+   *
+   * 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.
+   *
+   * 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.
+   */
+  autocomplete(suggestions, {
+    values = [],
+    arrayValues = [],
+    variables = [],
+    prefixes = [],
+    properties = [],
+    expandedPropertyOperators = [],
+    customPropertyOperators = this.options.customPropertyOperators ?? [],
+    keywords = this.options.keywords,
+    regexFlags = ["i", "m", "u"],
+    quote = '"'
+  } = {}) {
+    const self = this;
+    return suggestions.map((suggestion) => {
+      const type = suggestion.type;
+      switch (type) {
+        case SUGGESTION_TYPE.BACKTICK:
+          return [{ suggestion, value: "`" }];
+        case SUGGESTION_TYPE.DOUBLEQUOTE:
+          return [{ suggestion, value: '"' }];
+        case SUGGESTION_TYPE.SINGLEQUOTE:
+          return [{ suggestion, value: "'" }];
+        case SUGGESTION_TYPE.PARENL:
+          return [{ suggestion, value: "(" }];
+        case SUGGESTION_TYPE.PARENR:
+          return [{ suggestion, value: ")" }];
+        case SUGGESTION_TYPE.BRAKCETR:
+          return [{ suggestion, value: "]" }];
+        case SUGGESTION_TYPE.REGEX:
+          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 = 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;
+            if ((_g = flags == null ? void 0 : flags.value) == null ? void 0 : _g.includes(value)) {
+              return false;
+            }
+            return true;
+          });
+        case SUGGESTION_TYPE.PROPERTY: {
+          return properties.map((value) => ({ suggestion, value }));
+        }
+        case SUGGESTION_TYPE.PROPERTY_SEP: {
+          return [{ suggestion, value: self.options.expandedPropertySeparator }];
+        }
+        case SUGGESTION_TYPE.EXPANDED_PROPERTY_OPERATOR: {
+          return expandedPropertyOperators.map((value) => ({ suggestion, value }));
+        }
+        case SUGGESTION_TYPE.CUSTOM_PROPERTY_OPERATOR: {
+          return customPropertyOperators.map((value) => ({ suggestion, value }));
+        }
+        case SUGGESTION_TYPE.BOOLEAN_SYMBOL_OP: {
+          const keywordsList = [...keywords.and, ...keywords.or];
+          const symOpts = keywordsList.filter((_) => _.isSymbol);
+          return symOpts.map(({ value }) => ({ suggestion, value }));
+        }
+        case SUGGESTION_TYPE.BOOLEAN_WORD_OP: {
+          const keywordsList = [...keywords.and, ...keywords.or];
+          const wordOpts = keywordsList.filter((_) => !_.isSymbol);
+          return wordOpts.map(({ value }) => ({ suggestion, value }));
+        }
+        case SUGGESTION_TYPE.VALUE:
+        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 };
+            }
+          });
+        }
+        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 };
+            }
+          });
+      }
+    }).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.
+   *
+   * 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.
+   */
+  autoreplace(input, { value, suggestion }) {
+    const isQuotedLeft = ['"', "'", "`"].includes(value[0]);
+    const isQuotedRight = ['"', "'", "`"].includes(value[value.length - 1]);
+    if (isQuotedLeft && !isQuotedRight || !isQuotedLeft && isQuotedRight) {
+      throw new Error(`Completion value must either be entirely quoted or entirely unquoted. But the left side is ${isQuotedLeft ? "quoted" : "unquoted"} and the right side is ${isQuotedRight ? "quoted" : "unquoted"}.`);
+    }
+    let cursor = suggestion.range.start + value.length;
+    if (suggestion.requires.prefix) {
+      value = suggestion.requires.prefix + (isQuotedLeft ? "" : '"') + value + (isQuotedRight ? "" : '"');
+      cursor += suggestion.requires.prefix.length + Number(!isQuotedLeft) + Number(!isQuotedRight);
+    }
+    if (suggestion.requires.group) {
+      value += "()";
+      cursor++;
+    }
+    if (suggestion.requires.whitespace.before) {
+      value = ` ${value}`;
+      cursor++;
+    }
+    if (suggestion.requires.whitespace.after) {
+      value = `${value} `;
+    }
+    const replacement = insert(value, input, [suggestion.range.start, suggestion.range.end]);
+    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"] .
+   *
+   * 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.
+   *
+   * When the cursor is between two tokens that have possible suggestions, only suggestion types for the token before are returned. For example:
+   *
+   * ```js
+   * prop="val"
+   * prop|="val" //returns a property suggestions to replace `prop`
+   * prop=|"val" //returns a custom operator suggestion to replace `=`
+   * prop="|val" //returns a value suggestion
+   * ```
+   *
+   * And if there are no suggestions for the previous token but there are for the next ones, they are suggested:
+   * ```js
+   * prop:op:"val"
+   * prop:op|:"val" // returns an operator suggestion
+   * prop:op:|"val" // returns a value suggestion
+   * prop:op|"val" // returns a suggestion for the missing separator
+   * ```
+   */
+  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;
+    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
+    !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);
+    const requiresWhitespacePrevOp = canSuggestOpAfterPrev ? false : requiresWhitespacePrev;
+    const requireWhitespaceNextOp = !canSuggestOpAfterPrev && canSuggestOpBeforeNext ? false : requiresWhitespaceNext;
+    const suggestions = [];
+    if (ast instanceof ErrorToken) {
+      suggestions.push({
+        type: SUGGESTION_TYPE.PREFIX,
+        requires: createDefaultRequires({ group: true }),
+        range: pos({ start: index }, { fill: true }),
+        isError: true,
+        cursorInfo: token2
+      });
+      suggestions.push({
+        type: SUGGESTION_TYPE.VARIABLE,
+        requires: createDefaultRequires(),
+        range: pos({ start: index }, { fill: true }),
+        isError: true,
+        cursorInfo: token2
+      });
+    } else {
+      const surroundingErrors = getSurroundingErrors(tokens, token2);
+      const errorTypesHandled = [];
+      const errorSuggestion = {
+        isError: true,
+        cursorInfo: token2
+      };
+      const baseSuggestion = {
+        isError: false,
+        cursorInfo: token2
+      };
+      for (const error of surroundingErrors) {
+        for (const type of error.expected) {
+          if (errorTypesHandled.includes(type))
+            continue;
+          errorTypesHandled.push(type);
+          switch (type) {
+            case TOKEN_TYPE.DOUBLEQUOTE:
+            case TOKEN_TYPE.SINGLEQUOTE:
+            case TOKEN_TYPE.BACKTICK:
+              {
+                const isLeft = error.parent.quote.left === error;
+                const isRight = error.parent.quote.right === error;
+                suggestions.push({
+                  ...errorSuggestion,
+                  type,
+                  requires: createDefaultRequires({
+                    whitespace: {
+                      before: isRight ? false : requiresWhitespacePrev,
+                      after: isLeft ? false : requiresWhitespaceNext
+                    }
+                  }),
+                  range: pos({ start: index }, { fill: true })
+                });
+              }
+              break;
+            case TOKEN_TYPE.AND:
+            case TOKEN_TYPE.OR:
+              suggestions.push({
+                ...errorSuggestion,
+                type: SUGGESTION_TYPE.BOOLEAN_SYMBOL_OP,
+                requires: createDefaultRequires(),
+                range: pos({ start: index }, { fill: true })
+              });
+              suggestions.push({
+                ...errorSuggestion,
+                type: SUGGESTION_TYPE.BOOLEAN_WORD_OP,
+                requires: createDefaultRequires({
+                  whitespace: {
+                    before: requiresWhitespacePrevOp,
+                    after: requireWhitespaceNextOp
+                  }
+                }),
+                range: pos({ start: index }, { fill: true })
+              });
+              if (type === TOKEN_TYPE.AND)
+                errorTypesHandled.push(TOKEN_TYPE.OR);
+              if (type === TOKEN_TYPE.OR)
+                errorTypesHandled.push(TOKEN_TYPE.AND);
+              break;
+            case TOKEN_TYPE.PARENL:
+            case TOKEN_TYPE.PARENR:
+              suggestions.push({
+                ...errorSuggestion,
+                type,
+                requires: createDefaultRequires(),
+                range: pos({ start: index }, { fill: true })
+              });
+              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);
+              if (!isRegexValue) {
+                if (!prefixedValue && opts.prefixableGroups) {
+                  suggestions.push({
+                    ...errorSuggestion,
+                    type: SUGGESTION_TYPE.PREFIX,
+                    requires: createDefaultRequires({
+                      whitespace: {
+                        before: requiresWhitespacePrev,
+                        after: false
+                        /* parens get inserted */
+                      },
+                      group: true
+                      // is always needed
+                    }),
+                    range: pos({ start: index }, { fill: true })
+                  });
+                }
+                suggestions.push({
+                  ...errorSuggestion,
+                  type: SUGGESTION_TYPE.VARIABLE,
+                  requires: createDefaultRequires({
+                    whitespace: {
+                      before: requiresWhitespacePrev,
+                      after: requiresWhitespaceNext
+                    },
+                    prefix: prefixedValue
+                  }),
+                  range: pos({ start: index }, { fill: true })
+                });
+              }
+              break;
+            }
+            case TOKEN_TYPE.BRACKETR: {
+              suggestions.push({
+                ...errorSuggestion,
+                type: SUGGESTION_TYPE.BRAKCETR,
+                requires: createDefaultRequires(),
+                range: pos({ start: index }, { fill: true })
+              });
+              break;
+            }
+            case TOKEN_TYPE.OP_EXPANDED_SEP:
+              suggestions.push({
+                ...errorSuggestion,
+                type: SUGGESTION_TYPE.PROPERTY_SEP,
+                requires: createDefaultRequires(),
+                range: pos({ start: index }, { fill: true })
+              });
+              break;
+            case TOKEN_TYPE.REGEX:
+              suggestions.push({
+                ...errorSuggestion,
+                type: SUGGESTION_TYPE.REGEX,
+                requires: createDefaultRequires(),
+                range: pos({ start: index }, { fill: true })
+              });
+              break;
+            case TOKEN_TYPE.OP_CUSTOM:
+            case TOKEN_TYPE.BRACKETL:
+            case TOKEN_TYPE.NOT:
+              unreachable();
+          }
+        }
+      }
+      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 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 range = pos(parent);
+          const condition2 = parent == null ? void 0 : parent.parent;
+          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 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);
+          if (!isRegexFlag && !isSepPrev && !isValue && !arrayValue && !prefixedValue && opts.prefixableGroups) {
+            suggestions.push({
+              ...baseSuggestion,
+              type: SUGGESTION_TYPE.PREFIX,
+              requires: createDefaultRequires({
+                group: !isPrefix,
+                whitespace: {
+                  before: targetRequiresWhitespacePrev && !isPrefix,
+                  after: false
+                  // parens exist or get inserted
+                }
+              }),
+              range
+            });
+          }
+          if (!isRegexFlag && !isPrefix) {
+            suggestions.push({
+              ...baseSuggestion,
+              type: arrayValue ? SUGGESTION_TYPE.ARRAY_VALUE : isValue ? SUGGESTION_TYPE.VALUE : SUGGESTION_TYPE.VARIABLE,
+              requires: createDefaultRequires({
+                whitespace: {
+                  before: targetRequiresWhitespacePrev,
+                  after: targetRequiresWhitespaceNext
+                },
+                prefix: prefixedValue
+              }),
+              range
+            });
+          }
+        }
+      }
+      if (noArrayValuesTarget) {
+        suggestions.push({
+          ...baseSuggestion,
+          type: SUGGESTION_TYPE.ARRAY_VALUE,
+          requires: createDefaultRequires(),
+          range: pos({ start: index }, { fill: true })
+        });
+      }
+      if (propertyTarget) {
+        suggestions.push({
+          ...baseSuggestion,
+          type: SUGGESTION_TYPE.PROPERTY,
+          requires: createDefaultRequires(),
+          range: pos(propertyTarget)
+        });
+      }
+      if (propOpTarget) {
+        suggestions.push({
+          ...baseSuggestion,
+          type: propOpTarget.parent.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);
+      if (canSuggestValue) {
+        const inArrayNode = [nextCondition, prevCondition, nextVar, prevVar].find((_) => _ instanceof ArrayNode) !== void 0;
+        const opsNotNeeded = ["and", "or"].includes(opts.onMissingBooleanOperator);
+        if (inArrayNode || opsNotNeeded) {
+          suggestions.push({
+            type: inArrayNode ? SUGGESTION_TYPE.ARRAY_VALUE : SUGGESTION_TYPE.VARIABLE,
+            requires: createDefaultRequires({}),
+            range: pos({ start: index }, { fill: true }),
+            ...baseSuggestion
+          });
+        }
+        if (!inArrayNode && opsNotNeeded) {
+          suggestions.push({
+            ...baseSuggestion,
+            type: SUGGESTION_TYPE.PREFIX,
+            requires: createDefaultRequires({
+              group: true
+            }),
+            range: pos({ start: index }, { fill: true })
+          });
+        }
+      }
+      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)
+      );
+      if (canSuggestRegexFlags) {
+        suggestions.push({
+          ...baseSuggestion,
+          type: SUGGESTION_TYPE.REGEX_FLAGS,
+          requires: createDefaultRequires(),
+          range: pos({ start: index }, { fill: true })
+        });
+      }
+      if (canSuggestOpAfterPrev || canSuggestOpBeforeNext) {
+        const range = pos({ start: index }, { fill: true });
+        suggestions.push({
+          ...baseSuggestion,
+          type: SUGGESTION_TYPE.BOOLEAN_SYMBOL_OP,
+          requires: createDefaultRequires(),
+          range
+        });
+        suggestions.push({
+          ...baseSuggestion,
+          type: SUGGESTION_TYPE.BOOLEAN_WORD_OP,
+          requires: createDefaultRequires({
+            whitespace: {
+              before: requiresWhitespacePrevOp,
+              after: requireWhitespaceNextOp
+            }
+          }),
+          range
+        });
+      }
+    }
+    return suggestions;
+  }
+  /**
+   * Evaluates a {@link Parser.normalize normalized} ast.
+   *
+   * How the ast is evaluated for different operators can be controlled by the {@link ParserOptions.valueComparer valueComparer} option.
+   */
+  evaluate(ast, context) {
+    this._checkEvaluationOptions();
+    const opts = this.options;
+    if (ast instanceof Condition) {
+      const contextValue = get(context, ast.property);
+      const res = opts.valueComparer({ property: ast.property, value: ast.value, operator: ast.operator }, contextValue, context);
+      return ast.negate ? !res : res;
+    }
+    if (ast instanceof 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;
+    }
+    return unreachable();
+  }
+  /**
+   * Given the set of indexes returned by {@link getBestIndex}, the set of existing indexes in a database, and the index to sort by\*, will return a list of the best/shortest sets of indexes.
+   *
+   * For example, given the query `a && b && c`, `getBestIndex` will return `[Set(a), Set(b)]`.
+   *
+   * Suppose we have indexes on all the variables and that the user wants to sort by `c`, this function will return [`Set(c)`].
+   *
+   * Suppose instead we have indexes only on `a` and `b` and that the user wants to sort by `c`, this function will return [`Set(a), Set(b)`]. Either can be picked by some other criteria (e.g. size of the indexes). Sort should then be done in memory.
+   *
+   * And then finally, if we have no existing indexes on any of the variables, the function will return `[]`.
+   *
+   * Note: This is a simple algorithm and is not designed to take into account instances where entries are indexed by two or more properties as their keys (i.e. multicolumn indexes).
+   *
+   * \* If the sort index is not in the list of existing indexes it is not taken into account.
+   */
+  getBestIndexes(indexes, existing, sortIndex = "") {
+    indexes = indexes.filter((set) => {
+      for (const key of set) {
+        if (!existing.has(key))
+          return false;
+      }
+      return true;
+    });
+    let finalIndexes = indexes;
+    if (existing.has(sortIndex)) {
+      const indexesWithSortIndex = indexes.filter((set) => set.has(sortIndex));
+      if (indexesWithSortIndex.length > 0)
+        finalIndexes = indexesWithSortIndex;
+    }
+    let smallest = Infinity;
+    if (existing instanceof Map) {
+      const scores = /* @__PURE__ */ new Map();
+      for (const set of finalIndexes) {
+        let score = 0;
+        for (const key of set) {
+          score += existing.get(key) ?? 0;
+        }
+        scores.set(set, score);
+        smallest = score < smallest ? score : smallest;
+      }
+      return indexes.filter((set) => smallest === Infinity || scores.get(set) === smallest);
+    } else {
+      for (const set of finalIndexes) {
+        smallest = set.size < smallest ? set.size : smallest;
+      }
+      return indexes.filter((set) => smallest === Infinity || set.size === smallest);
+    }
+  }
+  /**
+   * Returns a list of the different sets of keys that need to be indexed to run a normalized query on a database and hit an existing index.
+   *
+   * For example, the expression `a || b` requires both `a` AND `b` be indexed to use an index. The function would return `[Set(a, b)]`.
+   *
+   * On the otherhand, the expression `a && b` only requires `a` OR `b` to be indexed (`[Set(a), Set(b)]`) If at least one is indexed, the rest of the filtering can be done in memory. There is no need to in memory filter the entire database.
+   *
+   * Now take a more complicated query like `(a && b) || (a && c)`. This only requires `a` be indexed, or both `b` AND `c`. (`[Set(a)], [Set(b), Set(c)]`).
+   *
+   * 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) {
+      return [new Set(ast.property.join("."))];
+    }
+    if (ast instanceof Expression) {
+      const left = this.getIndexes(ast.left);
+      const right = this.getIndexes(ast.right);
+      if (ast.operator === TOKEN_TYPE.AND) {
+        const sets = [];
+        const allKeys = /* @__PURE__ */ new Set();
+        for (const leftSet of left) {
+          const exists = sets.find((set) => isEqualSet(set, leftSet));
+          if (exists)
+            continue;
+          sets.push(leftSet);
+          for (const key of leftSet) {
+            allKeys.add(key);
+          }
+        }
+        for (const rightSet of right) {
+          const exists = sets.find((set) => isEqualSet(set, rightSet));
+          if (exists)
+            continue;
+          sets.push(rightSet);
+          for (const key of rightSet) {
+            allKeys.add(key);
+          }
+        }
+        const commonKeys = /* @__PURE__ */ new Set();
+        outerCheck:
+          for (const key of allKeys) {
+            for (const set of sets) {
+              if (!set.has(key))
+                continue outerCheck;
+            }
+            commonKeys.add(key);
+          }
+        if (commonKeys.size > 0) {
+          return [commonKeys, allKeys];
+        } else {
+          return sets;
+        }
+      }
+      if (ast.operator === TOKEN_TYPE.OR) {
+        for (const rightSet of right) {
+          for (const leftSet of left) {
+            if (isEqualSet(leftSet, rightSet)) {
+              return [rightSet];
+            }
+          }
+        }
+        const res = /* @__PURE__ */ new Set();
+        for (const leftSet of left) {
+          for (const key of leftSet) {
+            res.add(key);
+          }
+        }
+        for (const rightSet of right) {
+          for (const key of rightSet) {
+            res.add(key);
+          }
+        }
+        return [res];
+      }
+    }
+    return unreachable();
+  }
+  /**
+   * 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;
+    this._checkEvaluationOptions();
+    const opts = this.options;
+    if (ast instanceof ErrorToken || !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);
+        const isNested = operator2 !== void 0;
+        if (prefix !== void 0 && !isNested) {
+          name = name ? applyPrefix(prefix, name, opts.prefixApplier) : prefix;
+        }
+        let value;
+        if (isNested) {
+          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;
+        }
+        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 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 query = {
+          value,
+          operator: operator2,
+          prefix: valuePrefix,
+          regexFlags,
+          property: propertyKeys,
+          isRegex,
+          isQuoted,
+          isExpanded,
+          isNegated: !boolValue,
+          condition: ast
+        };
+        const res = opts.conditionNormalizer(query);
+        return new Condition({ 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;
+        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);
+      const applied = applyPrefix(prefix, _prefix ?? "", opts.prefixApplier);
+      return self_.normalize(ast.expression, applied, applyBoolean(groupValue, _groupValue), operator2);
+    }
+    if (ast instanceof ExpressionNode) {
+      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 unreachable();
+  }
+  /**
+   * Allows pre-validating ASTs for syntax highlighting purposes.
+   * Works similar to evaluate. Internally it will use the prefixApplier, keyParser, and valueValidator (instead of comparer).
+   *
+   * 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;
+    const self = this;
+    self._checkValidationOptions();
+    const opts = self.options;
+    if (ast instanceof ErrorToken || !ast.valid) {
+      throw new Error("AST node must be valid.");
+    }
+    const prefix = arguments[2];
+    const groupValue = arguments[3];
+    const results = arguments[4] ?? [];
+    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;
+        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;
+        if (prefix !== void 0 && !isNested) {
+          name = name ? applyPrefix(prefix, name, opts.prefixApplier) : prefix;
+        }
+        let value;
+        let propertyNodes = [];
+        if (isNested) {
+          value = name;
+          name = prefix;
+          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;
+        }
+        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;
+        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;
+        const isExpanded = ast.sep !== void 0;
+        const regexFlags = (_i = (_h = ast.value) == null ? void 0 : _h.quote) == null ? void 0 : _i.flags;
+        const query = {
+          value,
+          operator: operator2,
+          prefix: valuePrefix,
+          prefixes,
+          property: propertyNodes,
+          propertyKeys,
+          propertyName: name,
+          regexFlags,
+          isRegex,
+          isNegated: !boolValue,
+          isQuoted,
+          isExpanded,
+          condition: ast
+        };
+        const res = opts.valueValidator(contextValue, query, context);
+        if (res && !isArray(res))
+          throw new Error("The valueValidator must return an array or nothing/undefined");
+        if (res) {
+          for (const entry of res)
+            results.push(entry);
+        }
+      } 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);
+        if (ast.property)
+          prefixes.push(ast.property);
+        const operator22 = ast.propertyOperator;
+        self_.validate(ast.value, context, name, boolValue, results, prefixes, operator22);
+      }
+    }
+    if (ast instanceof GroupNode) {
+      const _prefix = ast.prefix instanceof ConditionNode && ast.prefix.value instanceof VariableNode ? ast.prefix.value : void 0;
+      if (_prefix)
+        prefixes.push(_prefix);
+      const _groupValue = ast.prefix instanceof ConditionNode ? ast.prefix.operator === void 0 : !(ast.prefix instanceof ValidToken);
+      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) {
+      self_.validate(ast.left, context, prefix, groupValue, results, [...prefixes], operator2);
+      self_.validate(ast.right, context, prefix, groupValue, results, [...prefixes], operator2);
+    }
+    return results;
+  }
+}
+export {
+  Parser
+};