@witchcraft/expressit 0.0.2

package/dist/helpers/parser/setParent.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"setParent.d.ts","sourceRoot":"","sources":["../../../src/helpers/parser/setParent.ts"],"names":[],"mappings":"AAAA;;;GAGG;AACH,eAAO,MAAM,SAAS,EAAE,OAAO,MAAyC,CAAA"}

package/dist/helpers/parser/setParent.js

@@ -0,0 +1,4 @@
+const setParent = Symbol("private set parent key");
+export {
+  setParent
+};

package/dist/helpers/parser/unescape.d.ts

@@ -0,0 +1,3 @@
+/** @internal */
+export declare function unescape(str: string): string;
+//# sourceMappingURL=unescape.d.ts.map

package/dist/helpers/parser/unescape.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"unescape.d.ts","sourceRoot":"","sources":["../../../src/helpers/parser/unescape.ts"],"names":[],"mappings":"AAAA,gBAAgB;AAChB,wBAAgB,QAAQ,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM,CAE5C"}

package/dist/helpers/parser/unescape.js

@@ -0,0 +1,6 @@
+function unescape(str) {
+  return str.replace(/\\{1,1}(.)/g, "$1");
+}
+export {
+  unescape
+};

package/dist/index.d.ts

@@ -0,0 +1,6 @@
+export * as ast from "./ast/classes/index.js";
+export * as grammar from "./grammar/index.js";
+export { Parser } from "./parser.js";
+export * from "./types/index.js";
+export * as utils from "./utils/index.js";
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,GAAG,MAAM,wBAAwB,CAAA;AAC7C,OAAO,KAAK,OAAO,MAAM,oBAAoB,CAAA;AAC7C,OAAO,EAAE,MAAM,EAAE,MAAM,aAAa,CAAA;AACpC,cAAc,kBAAkB,CAAA;AAChC,OAAO,KAAK,KAAK,MAAM,kBAAkB,CAAA"}

package/dist/index.js

@@ -0,0 +1,17 @@
+import * as index from "./ast/classes/index.js";
+import * as index$1 from "./grammar/index.js";
+import { Parser } from "./parser.js";
+import { AST_TYPE, TOKEN_TYPE } from "./types/ast.js";
+import { SUGGESTION_TYPE } from "./types/autocomplete.js";
+import { ERROR_CODES } from "./types/errors.js";
+import * as index$2 from "./utils/index.js";
+export {
+  AST_TYPE,
+  ERROR_CODES,
+  Parser,
+  SUGGESTION_TYPE,
+  TOKEN_TYPE,
+  index as ast,
+  index$1 as grammar,
+  index$2 as utils
+};

package/dist/methods/autocomplete.d.ts

@@ -0,0 +1,18 @@
+import { type Completion, type Suggestion } from "../types/autocomplete.js";
+import type { FullParserOptions } from "../types/parser.js";
+export declare class AutocompleteMixin<T extends {}> {
+    /**
+     * 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: Suggestion[], { values, arrayValues, variables, prefixes, properties, expandedPropertyOperators, customPropertyOperators, keywords, regexFlags, quote, }?: Partial<Record<"variables" | "values" | "arrayValues" | "prefixes" | "properties" | "regexFlags" | "expandedPropertyOperators" | "customPropertyOperators", string[]>> & {
+        quote?: string;
+        keywords?: FullParserOptions<T>["keywords"];
+    }): Completion[];
+}
+//# sourceMappingURL=autocomplete.d.ts.map

package/dist/methods/autocomplete.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"autocomplete.d.ts","sourceRoot":"","sources":["../../src/methods/autocomplete.ts"],"names":[],"mappings":"AAKA,OAAO,EAAE,KAAK,UAAU,EAAE,KAAK,UAAU,EAAmB,MAAM,0BAA0B,CAAA;AAC5F,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,oBAAoB,CAAA;AAG3D,qBAAa,iBAAiB,CAAC,CAAC,SAAS,EAAE;IAC1C;;;;;;;;OAQG;IACH,YAAY,CACX,WAAW,EAAE,UAAU,EAAE,EACzB,EACC,MAAW,EAAE,WAAgB,EAAE,SAAc,EAAE,QAAa,EAAE,UAAe,EAAE,yBAA8B,EAAE,uBAA0F,EAAE,QAAsD,EAAE,UAA4B,EAAE,KAAY,GAC7S,GAAE,OAAO,CAAC,MAAM,CAChB,WAAW,GACX,QAAQ,GACR,aAAa,GACb,UAAU,GACV,YAAY,GACZ,YAAY,GACZ,2BAA2B,GAC3B,yBAAyB,EAAE,MAAM,EAAE,CAAC,CAAC,GAAG;QACxC,KAAK,CAAC,EAAE,MAAM,CAAA;QACd,QAAQ,CAAC,EAAE,iBAAiB,CAAC,CAAC,CAAC,CAAC,UAAU,CAAC,CAAA;KACtC,GACJ,UAAU,EAAE;CA4Ff"}

package/dist/methods/autocomplete.js

@@ -0,0 +1,109 @@
+import { unreachable } from "@alanscodelog/utils";
+import { ConditionNode } from "../ast/classes/ConditionNode.js";
+import { VariableNode } from "../ast/classes/VariableNode.js";
+import { SUGGESTION_TYPE } from "../types/autocomplete.js";
+class AutocompleteMixin {
+  /**
+   * 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 token = suggestion2.cursorInfo;
+            const flags = token.at && ((_b = (_a = token.at.parent) == null ? void 0 : _a.quote) == null ? void 0 : _b.flags) === suggestion2.cursorInfo.at ? token.at : token.next && ((_d = (_c = token.next.parent) == null ? void 0 : _c.quote) == null ? void 0 : _d.flags) === suggestion2.cursorInfo.next ? token.next : token.prev && ((_f = (_e = token.prev.parent) == null ? void 0 : _e.quote) == null ? void 0 : _f.flags) === suggestion2.cursorInfo.prev ? token.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((variable) => {
+            const res = self.parse(variable);
+            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 + variable.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();
+  }
+}
+export {
+  AutocompleteMixin
+};

package/dist/methods/autoreplace.d.ts

@@ -0,0 +1,13 @@
+import type { Completion } from "../types/autocomplete.js";
+export declare class AutoreplaceMixin {
+    /**
+     * 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: string, { value, suggestion }: Completion): {
+        replacement: string;
+        cursor: number;
+    };
+}
+//# sourceMappingURL=autoreplace.d.ts.map

package/dist/methods/autoreplace.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"autoreplace.d.ts","sourceRoot":"","sources":["../../src/methods/autoreplace.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,0BAA0B,CAAA;AAG1D,qBAAa,gBAAgB;IAC5B;;;;OAIG;IACH,WAAW,CACV,KAAK,EAAE,MAAM,EACb,EAAE,KAAK,EAAE,UAAU,EAAE,EAAE,UAAU,GAC/B;QAAE,WAAW,EAAE,MAAM,CAAC;QAAC,MAAM,EAAE,MAAM,CAAA;KAAE;CA+B1C"}

package/dist/methods/autoreplace.js

@@ -0,0 +1,36 @@
+import { insert } from "@alanscodelog/utils";
+class AutoreplaceMixin {
+  /**
+   * 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 };
+  }
+}
+export {
+  AutoreplaceMixin
+};

package/dist/methods/autosuggest.d.ts

@@ -0,0 +1,28 @@
+import { type ParserResults } from "../types/ast.js";
+import { type Suggestion } from "../types/autocomplete.js";
+export declare class Autosuggest<T extends {}> {
+    /**
+     * 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: string, ast: ParserResults, index: number): Suggestion[];
+}
+//# sourceMappingURL=autosuggest.d.ts.map

package/dist/methods/autosuggest.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"autosuggest.d.ts","sourceRoot":"","sources":["../../src/methods/autosuggest.ts"],"names":[],"mappings":"AAWA,OAAO,EAAE,KAAK,aAAa,EAAc,MAAM,iBAAiB,CAAA;AAChE,OAAO,EAAE,KAAK,UAAU,EAAmB,MAAM,0BAA0B,CAAA;AA+B3E,qBAAa,WAAW,CAAC,CAAC,SAAS,EAAE;IACpC;;;;;;;;;;;;;;;;;;;;;OAqBG;IACH,WAAW,CAAC,KAAK,EAAE,MAAM,EAAE,GAAG,EAAE,aAAa,EAAE,KAAK,EAAE,MAAM,GAAG,UAAU,EAAE;CA4d3E"}

package/dist/methods/autosuggest.js

@@ -0,0 +1,371 @@
+import { unreachable } from "@alanscodelog/utils";
+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 { GroupNode } from "../ast/classes/GroupNode.js";
+import { VariableNode } from "../ast/classes/VariableNode.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 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 Autosuggest {
+  /**
+   * 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 token = getCursorInfo(input, tokens, index);
+    const wordOps = [...opts.keywords.and, ...opts.keywords.or, ...opts.keywords.not].filter((op) => !op.isSymbol);
+    const canSuggestOpAfterPrev = token.valid.prev && tokenVariable.includes((_a = token.valid.prev) == null ? void 0 : _a.type) && (token.whitespace.prev || token.valid.prev.type === TOKEN_TYPE.PARENR) && !token.at && token.valid.next === void 0;
+    const canSuggestOpBeforeNext = token.valid.next && tokenVariable.includes((_b = token.valid.next) == null ? void 0 : _b.type) && token.whitespace.next && // no parenL allowed since check since there will already be prefix suggestions
+    !token.at && token.valid.prev === void 0;
+    const requiresWhitespacePrev = tokenRequiresWhitespace(token.valid.prev, token.whitespace.prev, wordOps);
+    const requiresWhitespaceNext = tokenRequiresWhitespace(token.valid.next, token.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: token
+      });
+      suggestions.push({
+        type: SUGGESTION_TYPE.VARIABLE,
+        requires: createDefaultRequires(),
+        range: pos({ start: index }, { fill: true }),
+        isError: true,
+        cursorInfo: token
+      });
+    } else {
+      const surroundingErrors = getSurroundingErrors(tokens, token);
+      const errorTypesHandled = [];
+      const errorSuggestion = {
+        isError: true,
+        cursorInfo: token
+      };
+      const baseSuggestion = {
+        isError: false,
+        cursorInfo: token
+      };
+      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 = token.valid.prev) == null ? void 0 : _g.parent;
+      const nextVar = (_h = token.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 = token.at) == null ? void 0 : _i.parent;
+      const atCondition = atVar == null ? void 0 : atVar.parent;
+      const isVarPrev = !token.whitespace.prev && ((_j = token.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) === token.valid.prev || prevVar.value === token.valid.prev) || prevCondition instanceof ArrayNode);
+      const isVarNext = !token.whitespace.next && ((_l = token.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) === token.valid.next || nextVar.value === token.valid.next) || nextCondition instanceof ArrayNode);
+      const isVarAt = atVar instanceof VariableNode && atCondition instanceof ConditionNode || prevVar instanceof VariableNode && token.valid.prev === ((_n = prevVar == null ? void 0 : prevVar.quote) == null ? void 0 : _n.left) || nextVar instanceof VariableNode && token.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 && token.valid.prev === (prevVar == null ? void 0 : prevVar.propertyOperator);
+      const isPropertyOperatorNext = nextVar instanceof ConditionNode && token.valid.next === (nextVar == null ? void 0 : nextVar.propertyOperator);
+      const isPropertyOperatorAt = atVar instanceof ConditionNode && token.at === (atVar == null ? void 0 : atVar.propertyOperator);
+      const noArrayValuesTarget = ((_p = token.valid.prev) == null ? void 0 : _p.type) === TOKEN_TYPE.BRACKETL && (token.valid.next === void 0 || ((_q = token.valid.next) == null ? void 0 : _q.type) === TOKEN_TYPE.BRACKETR);
+      const target = isVarPrev ? token.valid.prev : !noArrayValuesTarget && !isPropertyPrev && !isPropertyOperatorPrev && isVarNext ? token.valid.next : isVarAt ? token.at : void 0;
+      const propertyTarget = isPropertyPrev ? token.valid.prev : !noArrayValuesTarget && !isVarPrev && !isPropertyOperatorPrev && isPropertyNext ? token.valid.next : isPropertyAt ? token.at : void 0;
+      const propOpTarget = isPropertyOperatorPrev ? token.valid.prev : !noArrayValuesTarget && !isVarPrev && !isPropertyPrev && isPropertyOperatorNext ? token.valid.next : isPropertyOperatorAt ? token.at : void 0;
+      if (target) {
+        const parent = target.parent;
+        if (parent instanceof VariableNode) {
+          const range = pos(parent);
+          const condition = parent == null ? void 0 : parent.parent;
+          const isValue = condition.propertyOperator !== void 0 && condition.value === parent;
+          const maybeGroup = (_r = parent == null ? void 0 : parent.parent) == null ? void 0 : _r.parent;
+          const isPrefix = maybeGroup instanceof GroupNode && maybeGroup.prefix === condition;
+          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 = token.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 = token.whitespace.next && (token.whitespace.prev || ((_x = token.prev) == null ? void 0 : _x.type) === TOKEN_TYPE.BRACKETL || ((_y = token.prev) == null ? void 0 : _y.type) === TOKEN_TYPE.PARENL) || token.whitespace.prev && (token.whitespace.next || ((_z = token.next) == null ? void 0 : _z.type) === TOKEN_TYPE.BRACKETR || ((_A = token.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
+        token.at && token.at === ((_D = (_C = (_B = token.at) == null ? void 0 : _B.parent) == null ? void 0 : _C.quote) == null ? void 0 : _D.flags) || token.valid.prev && token.valid.prev === ((_G = (_F = (_E = token.valid.prev) == null ? void 0 : _E.parent) == null ? void 0 : _F.quote) == null ? void 0 : _G.flags) || token.valid.next && token.valid.next === ((_J = (_I = (_H = token.valid.next) == null ? void 0 : _H.parent) == null ? void 0 : _I.quote) == null ? void 0 : _J.flags) || // no flags
+        ((_K = token.valid.prev) == null ? void 0 : _K.type) === TOKEN_TYPE.REGEX && token.valid.prev === ((_L = token.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;
+  }
+}
+export {
+  Autosuggest
+};