@witchcraft/expressit 0.0.2 → 0.1.0

package/dist/Parser.js

@@ -0,0 +1,668 @@
+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 { isArray } from "@alanscodelog/utils/isArray";
+import { isWhitespace } from "@alanscodelog/utils/isWhitespace";
+import { mixin } from "@alanscodelog/utils/mixin";
+import { setReadOnly } from "@alanscodelog/utils/setReadOnly";
+import { unreachable } from "@alanscodelog/utils/unreachable";
+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 { VariableNode } from "./ast/classes/VariableNode.js";
+import { token, operator, expression, variable, condition, group, array, delimiter } from "./ast/handlers.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 { AutocompleteMixin } from "./methods/autocomplete.js";
+import { AutoreplaceMixin } from "./methods/autoreplace.js";
+import { Autosuggest } from "./methods/autosuggest.js";
+import { EvaluateMixin } from "./methods/evaluate.js";
+import { GetBestIndexesMixin } from "./methods/getBestIndex.js";
+import { GetIndexMixin } from "./methods/getIndexes.js";
+import { NormalizeMixin } from "./methods/normalize.js";
+import { ValidateMixin } from "./methods/validate.js";
+import { TOKEN_TYPE } from "./types/ast.js";
+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;
+  }
+}
+mixin(Parser, [
+  AutocompleteMixin,
+  AutoreplaceMixin,
+  Autosuggest,
+  EvaluateMixin,
+  ValidateMixin,
+  NormalizeMixin,
+  GetIndexMixin,
+  GetBestIndexesMixin
+]);
+export {
+  Parser
+};

package/dist/ast/builders/token.js

@@ -1,4 +1,4 @@
-import { isArray } from "@alanscodelog/utils";
+import { isArray } from "@alanscodelog/utils/isArray";
 import { pos } from "./pos.js";
 import { ErrorToken } from "../classes/ErrorToken.js";
 import { ValidToken } from "../classes/ValidToken.js";

package/dist/ast/handlers.d.ts

@@ -8,9 +8,9 @@ import { VariableNode } from "./classes/VariableNode.js";
 import { type AnyToken, type Position, TOKEN_TYPE, type TokenBooleanTypes, type TokenQuoteTypes } from "../types/ast.js";
 declare function error<T extends TOKEN_TYPE>(pos: number, expected: T[]): ErrorToken<T>;
 export declare const token: {
-    value: (value: string | undefined, pos: Position) => AnyToken<TOKEN_TYPE.VALUE>;
-    custom: (value: string | undefined, pos: Position) => AnyToken<TOKEN_TYPE.OP_CUSTOM>;
-    sep: (value: string | undefined, pos: Position) => AnyToken<TOKEN_TYPE.OP_EXPANDED_SEP>;
+    value: <TVal extends string | undefined>(value: TVal, pos: Position) => TVal extends string ? ValidToken<TOKEN_TYPE.VALUE> : ErrorToken<TOKEN_TYPE.VALUE>;
+    custom: <TVal_1 extends string | undefined>(value: TVal_1, pos: Position) => TVal_1 extends string ? ValidToken<TOKEN_TYPE.OP_CUSTOM> : ErrorToken<TOKEN_TYPE.OP_CUSTOM>;
+    sep: <TVal_2 extends string | undefined>(value: TVal_2, pos: Position) => TVal_2 extends string ? ValidToken<TOKEN_TYPE.OP_EXPANDED_SEP> : ErrorToken<TOKEN_TYPE.OP_EXPANDED_SEP>;
 };
 /** We want to handle all the types outside the grammar file. This makes it easier without trying to check the value. */
 export declare const delimiter: {