@witchcraft/expressit 0.0.2

package/dist/grammar/ParserBase.js

@@ -0,0 +1,516 @@
+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, unreachable } from "@alanscodelog/utils";
+import { EmbeddedActionsParser, EOF, tokenMatcher } from "chevrotain";
+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 { VariableNode } from "../ast/classes/VariableNode.js";
+import { token, operator, expression, variable, condition, group, array, delimiter } from "../ast/handlers.js";
+import { extractPosition } from "../helpers/parser/extractPosition.js";
+import { Parser } from "../parser.js";
+import { TOKEN_TYPE } from "../types/ast.js";
+function processToken(token2, shift) {
+  let val = token2.image;
+  if (token2.isInsertedInRecovery)
+    val = void 0;
+  return [val, extractPosition(token2, shift)];
+}
+class ParserBase extends EmbeddedActionsParser {
+  constructor(opts, t, { customOpAlsoNegation, expandedSepAlsoCustom }) {
+    super(t, {
+      recoveryEnabled: true
+      // skipValidations: true
+    });
+    __publicField(this, "rawInput");
+    __publicField(this, "subParser");
+    __publicField(this, "subParser2");
+    const $ = this;
+    $.RULE("main", () => {
+      const res = $.SUBRULE($.boolOr);
+      $.CONSUME(EOF);
+      return $.ACTION(() => {
+        if (res === void 0) {
+          const error = token.value(void 0, { start: 0, end: 0 });
+          return error;
+        }
+        return res;
+      });
+    });
+    $.RULE("boolOr", () => {
+      const pairs = [];
+      const DEF = () => {
+        const exp = $.SUBRULE2($.boolAnd);
+        const extras = [];
+        let next = $.LA(1);
+        $.OPTION1({
+          GATE: () => opts.onMissingBooleanOperator === "or" && (tokenMatcher(next, t.VALUE) || tokenMatcher(next, t.QUOTE_ANY) || tokenMatcher(next, t.PAREN_L) || tokenMatcher(next, t.EXP_PROP_OP) || tokenMatcher(next, t.REGEX_START) || tokenMatcher(next, t.CUSTOM_PROP_OP)),
+          DEF: () => {
+            let dummyOp;
+            const cond = $.SUBRULE3($.condition);
+            $.ACTION(() => {
+              const prev = $.LA(-1);
+              const start = prev.endOffset + 1;
+              dummyOp = operator.or("", pos({ start }, { fill: true }));
+            });
+            extras.push([dummyOp, cond]);
+          }
+        });
+        next = $.LA(1);
+        pairs.push([exp, tokenMatcher(next, t.OPERATOR_OR) ? operator.or(...processToken(next, $.shift)) : void 0]);
+        for (const extra of extras) {
+          pairs[pairs.length - 1].splice(1, 1, extra[0]);
+          pairs.push([extra[1]]);
+        }
+      };
+      $.MANY_SEP({ SEP: t.OPERATOR_OR, DEF });
+      $.OPTION({
+        // many sep sometimes fails to recover when it technically could
+        GATE: () => pairs.length === 0 && tokenMatcher($.LA(1), t.OPERATOR_OR),
+        DEF: () => {
+          $.MANY(() => {
+            const next = $.CONSUME(t.OPERATOR_OR);
+            pairs.push([void 0, operator.or(...processToken(next, $.shift))]);
+            while (tokenMatcher($.LA(1), t.VALUE) || tokenMatcher($.LA(1), t.QUOTE_ANY) || tokenMatcher($.LA(1), t.PAREN_L)) {
+              pairs.push([$.SUBRULE3($.condition)]);
+            }
+          });
+        }
+      });
+      return $.ACTION(() => {
+        let res = pairs[pairs.length - 1][0];
+        for (let i = pairs.length - 1; i > 0; i--) {
+          const before = pairs[i - 1];
+          if (res === void 0 && before === void 0)
+            return void 0;
+          res = expression(before[0], before[1], res);
+        }
+        return res;
+      });
+    });
+    $.RULE("boolAnd", () => {
+      const pairs = [];
+      const DEF = () => {
+        const exp = $.SUBRULE2($.condition);
+        const extras = [];
+        let next = $.LA(1);
+        $.OPTION1({
+          GATE: () => ["error", "and"].includes(opts.onMissingBooleanOperator) && (tokenMatcher(next, t.VALUE) || tokenMatcher(next, t.QUOTE_ANY) || tokenMatcher(next, t.PAREN_L) || tokenMatcher(next, t.EXP_PROP_OP) || tokenMatcher(next, t.REGEX_START) || tokenMatcher(next, t.CUSTOM_PROP_OP)),
+          DEF: () => {
+            $.MANY2(() => {
+              let dummyOp;
+              const cond = $.SUBRULE3($.condition);
+              $.ACTION(() => {
+                if (opts.onMissingBooleanOperator === "and") {
+                  const prev = $.LA(-1);
+                  const start = prev.endOffset + 1;
+                  dummyOp = operator.and("", pos({ start }, { fill: true }));
+                }
+              });
+              extras.push([dummyOp, cond]);
+            });
+          }
+        });
+        next = $.LA(1);
+        pairs.push([exp, tokenMatcher(next, t.OPERATOR_AND) ? operator.and(...processToken(next, $.shift)) : void 0]);
+        for (const extra of extras) {
+          pairs[pairs.length - 1].splice(1, 1, extra[0]);
+          pairs.push([extra[1]]);
+        }
+      };
+      $.MANY_SEP({ SEP: t.OPERATOR_AND, DEF });
+      $.OPTION({
+        GATE: () => pairs.length === 0 && tokenMatcher($.LA(1), t.OPERATOR_AND),
+        DEF: () => {
+          $.MANY(() => {
+            const next = $.CONSUME(t.OPERATOR_AND);
+            pairs.push([void 0, operator.and(...processToken(next, $.shift))]);
+            while (tokenMatcher($.LA(1), t.VALUE) || tokenMatcher($.LA(1), t.QUOTE_ANY) || tokenMatcher($.LA(1), t.PAREN_L)) {
+              pairs.push([$.SUBRULE3($.condition)]);
+            }
+          });
+        }
+      });
+      return $.ACTION(() => {
+        if (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];
+          res = expression(before[0], before[1], res);
+        }
+        return res;
+      });
+    });
+    $.RULE("condition", () => {
+      const not = $.OPTION(() => $.SUBRULE($.not));
+      const property = $.OPTION2({
+        GATE: () => tokenMatcher($.LA(1), t.EXP_PROP_OP) || tokenMatcher($.LA(1), t.CUSTOM_PROP_OP) || tokenMatcher($.LA(2), t.EXP_PROP_OP) || tokenMatcher($.LA(2), t.CUSTOM_PROP_OP) || customOpAlsoNegation && (tokenMatcher($.LA(2), t.SYM_NOT) || tokenMatcher($.LA(0), t.SYM_NOT) && tokenMatcher($.LA(1), t.SYM_NOT)),
+        DEF: () => $.SUBRULE($.property)
+      });
+      const propVal = $.ACTION(() => {
+        var _a;
+        return ((_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 = $.ACTION(() => (property == null ? void 0 : property.rest.propertyOperator) === void 0 ? void 0 : property.rest.propertyOperator instanceof ErrorToken ? "" : property.rest.propertyOperator.value);
+      const isExpanded = $.ACTION(() => ((property == null ? void 0 : property.rest.sepL) ?? (property == null ? void 0 : property.rest.sepR)) !== void 0);
+      const convertRegexValues = $.ACTION(() => typeof opts.regexValues === "function" && !opts.regexValues(propVal, propOpVal, isExpanded));
+      const convertArrayValues = $.ACTION(() => typeof opts.arrayValues === "function" && !opts.arrayValues(propVal, propOpVal, isExpanded));
+      let value = $.OR2([
+        {
+          GATE: () => opts.prefixableGroups && property === void 0 && $.LA(1).tokenType !== t.PAREN_L && // moves to parsing group below
+          (tokenMatcher($.LA(1), t.VALUE) && (tokenMatcher($.LA(2), t.PAREN_L) || // a(
+          tokenMatcher($.LA(2), t.QUOTE_ANY) && tokenMatcher($.LA(3), t.PAREN_L)) || tokenMatcher($.LA(1), t.QUOTE_ANY) && (tokenMatcher($.LA(2), t.PAREN_L) || // "(
+          tokenMatcher($.LA(2), t.VALUE) && (tokenMatcher($.LA(3), t.PAREN_L) || // "a(
+          tokenMatcher($.LA(3), t.QUOTE_ANY) && tokenMatcher($.LA(4), t.PAREN_L)))),
+          ALT: () => $.SUBRULE($.variable, { ARGS: [{ unprefixed: true }] })
+          // un-prefixed
+        },
+        {
+          GATE: () => $.LA(1).tokenType !== t.PAREN_L,
+          ALT: () => $.SUBRULE2($.variable)
+        },
+        {
+          GATE: () => $.LA(1).tokenType === t.PAREN_L,
+          ALT: () => $.SUBRULE2($.plainGroup, { ARGS: [{ onlyValues: property !== void 0, convertRegexValues, convertArrayValues }] })
+        },
+        {
+          GATE: () => $.LA(1).tokenType === t.BRACKET_L,
+          ALT: () => $.SUBRULE2($.plainBracketGroup, { ARGS: [{ convertArrayValues }] })
+        },
+        {
+          GATE: () => not !== void 0 || property !== void 0 || $.LA(1).tokenType === EOF,
+          ALT: () => void 0
+        }
+      ]);
+      let group$1 = $.OPTION3({
+        GATE: () => !(value instanceof ArrayNode) && !isArray(value) && (!value || opts.prefixableGroups) && $.LA(1).tokenType === t.PAREN_L,
+        // is not already plain group
+        DEF: () => $.SUBRULE3($.plainGroup, { ARGS: [{ onlyValues: property !== void 0, convertRegexValues, convertArrayValues }] })
+      });
+      return $.ACTION(() => {
+        var _a, _b, _c, _d, _e;
+        if (isArray(value)) {
+          group$1 = value;
+          value = void 0;
+        }
+        if (convertRegexValues && value instanceof VariableNode && ((_a = value.quote) == null ? void 0 : _a.left.type) === TOKEN_TYPE.REGEX) {
+          value = variable(void 0, void 0, token.value(
+            (((_c = (_b = value.quote) == null ? void 0 : _b.left) == null ? void 0 : _c.value) ?? "") + (value.value.value ?? "") + (((_e = (_d = value.quote) == null ? void 0 : _d.right) == null ? void 0 : _e.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);
+      });
+    });
+    $.RULE("property", () => {
+      const prop = $.OPTION3(() => $.SUBRULE($.variable, { ARGS: [{ unprefixed: true }] }));
+      const rest = $.OR([
+        {
+          ALT: () => {
+            let sepL = $.CONSUME(t.EXP_PROP_OP);
+            sepL && (sepL = token.sep(...processToken(sepL, $.shift)));
+            let op = $.OPTION4(() => $.CONSUME2(t.VALUE_UNQUOTED));
+            op && (op = token.value(...processToken(op, $.shift)));
+            let sepR = $.OPTION5(() => $.CONSUME2(t.EXP_PROP_OP));
+            sepR && (sepR = token.sep(...processToken(sepR, $.shift)));
+            if (expandedSepAlsoCustom && op === void 0 && sepR === void 0) {
+              op = sepL;
+              op.type = TOKEN_TYPE.OP_CUSTOM;
+              sepL = void 0;
+            }
+            return { sepL, sepR, propertyOperator: op };
+          }
+        },
+        {
+          ALT: () => {
+            let op = $.CONSUME(t.CUSTOM_PROP_OP);
+            if (!op.isInsertedInRecovery)
+              op = token.custom(...processToken(op, $.shift));
+            return { propertyOperator: op };
+          }
+        },
+        {
+          GATE: () => customOpAlsoNegation,
+          ALT: () => {
+            let op = $.CONSUME2(t.SYM_NOT);
+            if (!op.isInsertedInRecovery)
+              op = token.custom(...processToken(op, $.shift));
+            return { propertyOperator: op };
+          }
+        }
+      ]);
+      return { prop, rest };
+    });
+    $.RULE("plainGroup", ({ onlyValues = false, convertRegexValues = false, convertArrayValues = false } = {}) => {
+      const parenL = $.SUBRULE1($.parenL);
+      let parenLeftCount = 0;
+      let start;
+      let end;
+      const condition2 = $.OPTION1({
+        GATE: () => !onlyValues,
+        DEF: () => $.SUBRULE1($.boolOr)
+      });
+      if (onlyValues && $.LA(1).tokenType !== EOF) {
+        while (!tokenMatcher($.LA(1), EOF) && (!tokenMatcher($.LA(1), t.PAREN_R) || parenLeftCount !== 0)) {
+          const token2 = $.CONSUME(t.ANY);
+          start ?? (start = extractPosition(token2, this.shift).start);
+          if (tokenMatcher(token2, t.PAREN_L)) {
+            parenLeftCount++;
+          }
+          if (tokenMatcher(token2, t.PAREN_R)) {
+            parenLeftCount--;
+          }
+        }
+      }
+      if (start !== void 0) {
+        end ?? (end = extractPosition($.LA(0), this.shift).end);
+      }
+      const parenR = $.OPTION2(() => $.SUBRULE1($.parenR));
+      return $.ACTION(() => {
+        if (start !== void 0) {
+          const subInput = this.rawInput.slice(start, end);
+          if (this.subParser === void 0) {
+            this.subParser = new Parser({
+              ...opts,
+              customPropertyOperators: [],
+              expandedPropertySeparator: void 0,
+              regexValues: convertRegexValues,
+              arrayValues: convertArrayValues
+            });
+          }
+          const parsed = this.subParser.parse(" ".repeat(start) + subInput, { unsealed: true });
+          return [parenL, parsed, parenR];
+        }
+        return [parenL, condition2, parenR];
+      });
+    });
+    $.RULE("plainBracketGroup", ({ convertArrayValues = false } = {}) => {
+      const bracketL = $.SUBRULE1($.bracketL);
+      const start = bracketL.start;
+      const values = [];
+      $.MANY({
+        GATE: () => !convertArrayValues,
+        DEF: () => values.push($.SUBRULE($.variable, { ARGS: [{ unprefixed: false, bracketVal: true }] }))
+      });
+      if (convertArrayValues && $.LA(1).tokenType !== EOF) {
+        while (!tokenMatcher($.LA(1), EOF) && !tokenMatcher($.LA(1), t.BRACKET_R)) {
+          $.CONSUME(t.ANY);
+        }
+      }
+      const bracketR = $.OPTION2(() => $.SUBRULE1($.bracketR));
+      const end = bracketR == null ? void 0 : bracketR.end;
+      return $.ACTION(() => {
+        if (!convertArrayValues)
+          return array(bracketL, values, bracketR);
+        const subInput = this.rawInput.slice(start, end);
+        if (this.subParser2 === void 0) {
+          this.subParser2 = new Parser({
+            ...opts,
+            customPropertyOperators: [],
+            expandedPropertySeparator: void 0,
+            arrayValues: false
+          });
+        }
+        const parsed = this.subParser2.parse(" ".repeat(start) + subInput, { unsealed: true });
+        if (parsed instanceof ConditionNode) {
+          return parsed.value;
+        }
+        return parsed;
+      });
+    });
+    $.RULE("not", () => {
+      const op = $.CONSUME(t.OPERATOR_NOT);
+      return $.ACTION(() => operator.not(...processToken(op, $.shift)));
+    });
+    $.RULE("variable", ({ unprefixed = false, bracketVal = false } = {}) => {
+      let prefix = $.OPTION({
+        GATE: () => !unprefixed && opts.prefixableStrings !== void 0 && tokenMatcher($.LA(2), t.QUOTE_ANY) && tokenMatcher($.LA(4), $.LA(2).tokenType) && opts.prefixableStrings.includes($.LA(1).image),
+        DEF: () => $.SUBRULE7($.valueUnquoted, { ARGS: [{ bracketVal, onlyToken: true }] })
+      });
+      prefix && (prefix = token.value(...processToken(prefix, $.shift)));
+      const ARGS = [{ bracketVal }];
+      const val = $.OR([
+        {
+          ALT: () => {
+            const quoteL = $.SUBRULE($.quoteDouble);
+            const value = $.OPTION1(() => $.OR1([
+              { ALT: () => $.SUBRULE($.valueUnquoted, { ARGS }) },
+              { ALT: () => $.SUBRULE($.valueNotDouble) }
+            ]));
+            const quoteR = $.SUBRULE2($.quoteDouble);
+            return $.ACTION(() => variable(prefix, quoteL, value, quoteR));
+          }
+        },
+        {
+          ALT: () => {
+            const quoteL = $.SUBRULE($.quoteSingle);
+            const value = $.OPTION2(() => $.OR2([
+              { ALT: () => $.SUBRULE2($.valueUnquoted, { ARGS }) },
+              { ALT: () => $.SUBRULE($.valueNotSingle) }
+            ]));
+            const quoteR = $.SUBRULE2($.quoteSingle);
+            return $.ACTION(() => variable(prefix, quoteL, value, quoteR));
+          }
+        },
+        {
+          ALT: () => {
+            const quoteL = $.SUBRULE($.quoteBacktick);
+            const value = $.OPTION3(() => $.OR3([
+              { ALT: () => $.SUBRULE3($.valueUnquoted, { ARGS }) },
+              { ALT: () => $.SUBRULE($.valueNotBacktick) }
+            ]));
+            const quoteR = $.SUBRULE2($.quoteBacktick);
+            return $.ACTION(() => variable(prefix, quoteL, value, quoteR));
+          }
+        },
+        {
+          ALT: () => {
+            const quoteL = $.SUBRULE($.regexAny);
+            const value = $.OPTION4(() => $.SUBRULE5($.valueRegex));
+            const quoteR = $.OPTION5(() => $.SUBRULE5($.regexAny));
+            return $.ACTION(() => {
+              const args = isArray(quoteR) ? quoteR : [quoteR];
+              return variable(void 0, quoteL, value, args[0], args[1]);
+            });
+          }
+        },
+        {
+          // error
+          ALT: () => {
+            const value = $.SUBRULE4($.valueUnquoted, { ARGS });
+            const quoteR = $.SUBRULE4($.valueDelimAny);
+            return $.ACTION(() => variable(void 0, void 0, value, quoteR));
+          }
+        },
+        {
+          // error
+          ALT: () => {
+            const quoteL = $.SUBRULE5($.valueDelimAny);
+            const value = $.OPTION6(() => $.SUBRULE5($.valueUnquoted, { ARGS }));
+            return $.ACTION(() => variable(void 0, quoteL, value, void 0));
+          }
+        },
+        {
+          ALT: () => {
+            const value = $.SUBRULE6($.valueUnquoted, { ARGS });
+            return $.ACTION(() => variable(void 0, void 0, value, void 0));
+          }
+        }
+      ]);
+      return val;
+    });
+    $.RULE("valueDelimAny", () => {
+      const value = $.CONSUME(t.QUOTE_ANY);
+      return $.ACTION(() => {
+        const type = value.image === `"` ? "double" : value.image === "'" ? "single" : value.image === "\\" ? "regex" : value.image === "`" ? "tick" : unreachable();
+        return delimiter[type](...processToken(value, $.shift));
+      });
+    });
+    $.RULE("regexAny", () => {
+      const value = $.CONSUME(t.REGEX_ANY);
+      return $.ACTION(() => {
+        if (value.image.length > 1) {
+          const delim = {
+            image: "/",
+            startOffset: value.startOffset,
+            endOffset: value.startOffset
+          };
+          const flags = {
+            image: value.image.slice(1),
+            startOffset: value.startOffset + 1,
+            endOffset: value.endOffset
+          };
+          return [
+            delimiter.regex(...processToken(delim, $.shift)),
+            token.value(...processToken(flags, $.shift))
+          ];
+        }
+        return delimiter.regex(...processToken(value, $.shift));
+      });
+    });
+    $.RULE("valueRegex", () => {
+      const value = $.CONSUME(t.VALUE_REGEX);
+      return $.ACTION(() => token.value(...processToken(value, $.shift)));
+    });
+    $.RULE("quoteSingle", () => {
+      const value = $.CONSUME(t.QUOTE_SINGLE);
+      return $.ACTION(() => delimiter.single(...processToken(value, $.shift)));
+    });
+    $.RULE("quoteDouble", () => {
+      const value = $.CONSUME(t.QUOTE_DOUBLE);
+      return $.ACTION(() => delimiter.double(...processToken(value, $.shift)));
+    });
+    $.RULE("quoteBacktick", () => {
+      const value = $.CONSUME(t.QUOTE_BACKTICK);
+      return $.ACTION(() => delimiter.tick(...processToken(value, $.shift)));
+    });
+    $.RULE("valueNotSingle", () => {
+      const value = $.CONSUME(t.VALUE_FOR_SINGLE);
+      return $.ACTION(() => token.value(...processToken(value, $.shift)));
+    });
+    $.RULE("valueNotDouble", () => {
+      const value = $.CONSUME(t.VALUE_FOR_DOUBLE);
+      return $.ACTION(() => token.value(...processToken(value, $.shift)));
+    });
+    $.RULE("valueNotBacktick", () => {
+      const value = $.CONSUME(t.VALUE_FOR_BACKTICK);
+      return $.ACTION(() => token.value(...processToken(value, $.shift)));
+    });
+    $.RULE("valueUnquoted", ({ bracketVal = false, onlyToken = false } = {}) => {
+      const value = $.OR([
+        {
+          GATE: () => !bracketVal,
+          ALT: () => $.CONSUME(t.VALUE_UNQUOTED)
+        },
+        {
+          GATE: () => bracketVal,
+          ALT: () => $.CONSUME(t.BRACKET_VALUE_UNQUOTED)
+        }
+      ]);
+      return $.ACTION(() => onlyToken ? value : token.value(...processToken(value, $.shift)));
+    });
+    $.RULE("parenL", () => {
+      const value = $.CONSUME(t.PAREN_L);
+      return $.ACTION(() => {
+        const loc = extractPosition(value, $.shift);
+        return $.shift === 0 || loc.start > 0 ? delimiter.parenL(value.isInsertedInRecovery ? void 0 : value.image, loc) : void 0;
+      });
+    });
+    $.RULE("parenR", () => {
+      const value = $.CONSUME(t.PAREN_R);
+      return $.ACTION(() => delimiter.parenR(...processToken(value, $.shift)));
+    });
+    $.RULE("bracketL", () => {
+      const value = $.CONSUME(t.BRACKET_L);
+      return $.ACTION(() => {
+        const loc = extractPosition(value, $.shift);
+        return $.shift === 0 || loc.start > 0 ? delimiter.bracketL(value.isInsertedInRecovery ? void 0 : value.image, loc) : void 0;
+      });
+    });
+    $.RULE("bracketR", () => {
+      const value = $.CONSUME(t.BRACKET_R);
+      return $.ACTION(() => delimiter.bracketR(...processToken(value, $.shift)));
+    });
+    this.performSelfAnalysis();
+  }
+}
+export {
+  ParserBase
+};

package/dist/grammar/createTokens.d.ts

@@ -0,0 +1,56 @@
+import { Lexer, type TokenType } from "chevrotain";
+import type { FullParserOptions } from "../types/parser.js";
+/** Makes it easier to rename the tokens while still returning a properly typed record of them.*/
+declare enum $T {
+    _ = "_",
+    ANY = "ANY",
+    QUOTE_ANY = "QUOTE_ANY",
+    QUOTE_SINGLE = "QUOTE_SINGLE",
+    QUOTE_DOUBLE = "QUOTE_DOUBLE",
+    QUOTE_BACKTICK = "QUOTE_BACKTICK",
+    VALUE = "VALUE",
+    REGEX_ANY = "REGEX_ANY",
+    VALUE_UNQUOTED = "VALUE_UNQUOTED",
+    BRACKET_VALUE_UNQUOTED = "BRACKET_VALUE_UNQUOTED",
+    VALUE_REGEX = "VALUE_REGEX",
+    VALUE_NOT_SINGLE = "VALUE_NOT_SINGLE",
+    VALUE_NOT_DOUBLE = "VALUE_NOT_DOUBLE",
+    VALUE_NOT_BACKTICK = "VALUE_NOT_BACKTICK",
+    VALUE_FOR_SINGLE = "VALUE_FOR_SINGLE",
+    VALUE_FOR_DOUBLE = "VALUE_FOR_DOUBLE",
+    VALUE_FOR_BACKTICK = "VALUE_FOR_BACKTICK",
+    OPERATOR_OR = "OPERATOR_OR",
+    OPERATOR_AND = "OPERATOR_AND",
+    OPERATOR_NOT = "OPERATOR_NOT",
+    SYM_OR = "SYM_OR",
+    SYM_AND = "SYM_AND",
+    SYM_NOT = "SYM_NOT",
+    WORD_OR = "WORD_OR",
+    WORD_AND = "WORD_AND",
+    WORD_NOT = "WORD_NOT",
+    REGEX_START = "REGEX_START",
+    REGEX_END = "REGEX_END",
+    QUOTE_SINGLE_START = "QUOTE_SINGLE_START",
+    QUOTE_DOUBLE_START = "QUOTE_DOUBLE_START",
+    QUOTE_BACKTICK_START = "QUOTE_BACKTICK_START",
+    QUOTE_SINGLE_END = "QUOTE_SINGLE_END",
+    QUOTE_DOUBLE_END = "QUOTE_DOUBLE_END",
+    QUOTE_BACKTICK_END = "QUOTE_BACKTICK_END",
+    EXP_PROP_OP = "EXP_PROP_OP",
+    CUSTOM_PROP_OP = "CUSTOM_PROP_OP",
+    PAREN_L = "PAREN_L",
+    PAREN_R = "PAREN_R",
+    BRACKET_L = "BRACKET_L",
+    BRACKET_R = "BRACKET_R"
+}
+type LexerOnly = $T.VALUE_NOT_BACKTICK | $T.VALUE_NOT_DOUBLE | $T.VALUE_NOT_SINGLE | $T.SYM_OR | $T.SYM_AND | $T.WORD_OR | $T.WORD_AND | $T.REGEX_END | $T.QUOTE_SINGLE_START | $T.QUOTE_DOUBLE_START | $T.QUOTE_BACKTICK_START | $T.QUOTE_SINGLE_END | $T.QUOTE_DOUBLE_END | $T.QUOTE_BACKTICK_END | $T.WORD_NOT;
+export declare function createTokens<T extends {} = {}>(opts: FullParserOptions<T>): {
+    tokens: Record<Exclude<$T, LexerOnly>, TokenType>;
+    lexer: Lexer;
+    info: {
+        expandedSepAlsoCustom: boolean;
+        customOpAlsoNegation: boolean;
+    };
+};
+export {};
+//# sourceMappingURL=createTokens.d.ts.map

package/dist/grammar/createTokens.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"createTokens.d.ts","sourceRoot":"","sources":["../../src/grammar/createTokens.ts"],"names":[],"mappings":"AAEA,OAAO,EAAe,KAAK,EAAE,KAAK,SAAS,EAAE,MAAM,YAAY,CAAA;AAE/D,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,oBAAoB,CAAA;AAG3D,iGAAiG;AAEjG,aAAK,EAAE;IACN,CAAC,MAAM;IACP,GAAG,QAAQ;IACX,SAAS,cAAc;IACvB,YAAY,iBAAiB;IAC7B,YAAY,iBAAiB;IAC7B,cAAc,mBAAmB;IACjC,KAAK,UAAU;IACf,SAAS,cAAc;IACvB,cAAc,mBAAmB;IACjC,sBAAsB,2BAA2B;IACjD,WAAW,gBAAgB;IAC3B,gBAAgB,qBAAqB;IACrC,gBAAgB,qBAAqB;IACrC,kBAAkB,uBAAuB;IACzC,gBAAgB,qBAAqB;IACrC,gBAAgB,qBAAqB;IACrC,kBAAkB,uBAAuB;IACzC,WAAW,gBAAgB;IAC3B,YAAY,iBAAiB;IAC7B,YAAY,iBAAiB;IAC7B,MAAM,WAAW;IACjB,OAAO,YAAY;IACnB,OAAO,YAAY;IACnB,OAAO,YAAY;IACnB,QAAQ,aAAa;IACrB,QAAQ,aAAa;IACrB,WAAW,gBAAgB;IAC3B,SAAS,cAAc;IACvB,kBAAkB,uBAAuB;IACzC,kBAAkB,uBAAuB;IACzC,oBAAoB,yBAAyB;IAC7C,gBAAgB,qBAAqB;IACrC,gBAAgB,qBAAqB;IACrC,kBAAkB,uBAAuB;IACzC,WAAW,gBAAgB;IAC3B,cAAc,mBAAmB;IACjC,OAAO,YAAY;IACnB,OAAO,YAAY;IACnB,SAAS,cAAc;IACvB,SAAS,cAAc;CACvB;AAGD,KAAK,SAAS,GAEX,EAAE,CAAC,kBAAkB,GACrB,EAAE,CAAC,gBAAgB,GACnB,EAAE,CAAC,gBAAgB,GACnB,EAAE,CAAC,MAAM,GACT,EAAE,CAAC,OAAO,GACV,EAAE,CAAC,OAAO,GACV,EAAE,CAAC,QAAQ,GAEX,EAAE,CAAC,SAAS,GACZ,EAAE,CAAC,kBAAkB,GACrB,EAAE,CAAC,kBAAkB,GACrB,EAAE,CAAC,oBAAoB,GACvB,EAAE,CAAC,gBAAgB,GACnB,EAAE,CAAC,gBAAgB,GACnB,EAAE,CAAC,kBAAkB,GACrB,EAAE,CAAC,QAAQ,CAAA;AAuBd,wBAAgB,YAAY,CAAC,CAAC,SAAS,EAAE,GAAG,EAAE,EAAE,IAAI,EAAE,iBAAiB,CAAC,CAAC,CAAC,GAAG;IAC5E,MAAM,EAAE,MAAM,CAAC,OAAO,CAAC,EAAE,EAAE,SAAS,CAAC,EAAE,SAAS,CAAC,CAAA;IACjD,KAAK,EAAE,KAAK,CAAA;IACZ,IAAI,EAAE;QACL,qBAAqB,EAAE,OAAO,CAAA;QAC9B,oBAAoB,EAAE,OAAO,CAAA;KAC7B,CAAA;CACD,CA0ZA"}