@witchcraft/expressit 0.2.2 → 0.3.1

package/dist/Lexer.js

@@ -1,52 +1,64 @@
-var __defProp = Object.defineProperty;
-var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
-var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
-import { isBlank } from "@alanscodelog/utils/isBlank.js";
-import { pushIfNotIn } from "@alanscodelog/utils/pushIfNotIn.js";
+import { enumFromArray } from "@alanscodelog/utils/enumFromArray";
+import { isBlank } from "@alanscodelog/utils/isBlank";
+import { pushIfNotIn } from "@alanscodelog/utils/pushIfNotIn";
 import { checkParserOpts } from "./internal/checkParserOpts.js";
 import { parseParserOptions } from "./internal/parseParserOptions.js";
 const regexFlags = /^[a-zA-Z]+/;
+const MODE = enumFromArray([
+  "MAIN",
+  "MAYBE_QUOTE_ERROR",
+  "NOT_SINGLE",
+  "NOT_DOUBLE",
+  "NOT_BACKTICK",
+  "NOT_REGEX",
+  "REGEX_END",
+  "BRACKET_MAIN",
+  "BRACKET_MAYBE_QUOTE_ERROR",
+  "BRACKET_NOT_SINGLE",
+  "BRACKET_NOT_DOUBLE",
+  "BRACKET_NOT_BACKTICK",
+  "BRACKET_NOT_REGEX",
+  "BRACKET_REGEX_END"
+]);
 const BRACKET_PREFIX = "BRACKET";
-var $T = /* @__PURE__ */ (($T2) => {
-  $T2["_"] = "_";
-  $T2["VALUE_UNQUOTED"] = "VALUE_UNQUOTED";
-  $T2["VALUE_REGEX"] = "VALUE_REGEX";
-  $T2["VALUE_NOT_SINGLE"] = "VALUE_NOT_SINGLE";
-  $T2["VALUE_NOT_DOUBLE"] = "VALUE_NOT_DOUBLE";
-  $T2["VALUE_NOT_BACKTICK"] = "VALUE_NOT_BACKTICK";
-  $T2["SYM_OR"] = "SYM_OR";
-  $T2["SYM_AND"] = "SYM_AND";
-  $T2["SYM_NOT"] = "SYM_NOT";
-  $T2["WORD_OR"] = "WORD_OR";
-  $T2["WORD_AND"] = "WORD_AND";
-  $T2["WORD_NOT"] = "WORD_NOT";
-  $T2["REGEX_START"] = "REGEX_START";
-  $T2["REGEX_END"] = "REGEX_END";
-  $T2["EXP_PROP_OP"] = "EXP_PROP_OP";
-  $T2["CUSTOM_PROP_OP"] = "CUSTOM_PROP_OP";
-  $T2["PAREN_L"] = "PAREN_L";
-  $T2["PAREN_R"] = "PAREN_R";
-  $T2["BRACKET_L"] = "BRACKET_L";
-  $T2["BRACKET_R"] = "BRACKET_R";
-  $T2["QUOTE_SINGLE"] = "QUOTE_SINGLE";
-  $T2["QUOTE_DOUBLE"] = "QUOTE_DOUBLE";
-  $T2["QUOTE_BACKTICK"] = "QUOTE_BACKTICK";
-  return $T2;
-})($T || {});
-var $C = /* @__PURE__ */ (($C2) => {
-  $C2["ANY"] = "ANY";
-  $C2["QUOTE_ANY"] = "QUOTE_ANY";
-  $C2["REGEX_ANY"] = "REGEX_ANY";
-  $C2["VALUE_FOR_SINGLE"] = "VALUE_FOR_SINGLE";
-  $C2["VALUE_FOR_DOUBLE"] = "VALUE_FOR_DOUBLE";
-  $C2["VALUE_FOR_BACKTICK"] = "VALUE_FOR_BACKTICK";
-  $C2["OPERATOR_OR"] = "OPERATOR_OR";
-  $C2["OPERATOR_AND"] = "OPERATOR_AND";
-  $C2["OPERATOR_NOT"] = "OPERATOR_NOT";
-  $C2["VALUE"] = "VALUE";
-  return $C2;
-})($C || {});
-function createTokenCategoryType(type, entries) {
+const $T = enumFromArray([
+  "_",
+  "VALUE_UNQUOTED",
+  "VALUE_REGEX",
+  "VALUE_NOT_SINGLE",
+  "VALUE_NOT_DOUBLE",
+  "VALUE_NOT_BACKTICK",
+  "SYM_OR",
+  "SYM_AND",
+  "SYM_NOT",
+  "WORD_OR",
+  "WORD_AND",
+  "WORD_NOT",
+  "REGEX_START",
+  "REGEX_END",
+  "EXP_PROP_OP",
+  "CUSTOM_PROP_OP",
+  "PAREN_L",
+  "PAREN_R",
+  "BRACKET_L",
+  "BRACKET_R",
+  "QUOTE_SINGLE",
+  "QUOTE_DOUBLE",
+  "QUOTE_BACKTICK"
+]);
+const $C = enumFromArray([
+  "ANY",
+  "QUOTE_ANY",
+  "REGEX_ANY",
+  "VALUE_FOR_SINGLE",
+  "VALUE_FOR_DOUBLE",
+  "VALUE_FOR_BACKTICK",
+  "OPERATOR_OR",
+  "OPERATOR_AND",
+  "OPERATOR_NOT",
+  "VALUE"
+]);
+function createLexerCategoryToken(type, entries) {
   return {
     type,
     isCategory: true,
@@ -89,12 +101,12 @@ function matchSymbol(symbols) {
   };
 }
 class Lexer {
+  symbols;
+  $;
+  $categories;
+  branches;
+  opts;
   constructor(opts = {}) {
-    __publicField(this, "symbols");
-    __publicField(this, "$");
-    __publicField(this, "$categories");
-    __publicField(this, "branches");
-    __publicField(this, "opts");
     this.opts = parseParserOptions(opts);
     checkParserOpts(this.opts);
     this.symbols = this.calculateSymbolInfo();
@@ -104,7 +116,6 @@ class Lexer {
     this.branches = this.createModeBranches();
   }
   calculateSymbolInfo() {
-    var _a;
     const opts = this.opts;
     const symOrs = opts.keywords.or.filter((_) => _.isSymbol).map((_) => _.value);
     const symAnds = opts.keywords.and.filter((_) => _.isSymbol).map((_) => _.value);
@@ -131,7 +142,7 @@ class Lexer {
       wordNots: wordNots.sort((a, b) => b.length - a.length),
       all: syms.sort((a, b) => b.length - a.length)
     };
-    const expandedSepAlsoCustom = ((_a = opts.customPropertyOperators) == null ? void 0 : _a.includes(opts.expandedPropertySeparator)) ?? false;
+    const expandedSepAlsoCustom = opts.customPropertyOperators?.includes(opts.expandedPropertySeparator) ?? false;
     let customOpAlsoNegation = false;
     if (symbols.symNots.length > 0) {
       for (const op of opts.customPropertyOperators ?? []) {
@@ -147,14 +158,10 @@ class Lexer {
   }
   // eslint-disable-next-line @typescript-eslint/explicit-function-return-type
   createTokens() {
-    var _a;
     const opts = this.opts;
     const symbols = this.symbols;
     const $ = {
-      [
-        "_"
-        /* _ */
-      ]: createTokenType("_", {
+      [$T._]: createTokenType($T._, {
         skip: true,
         matches: (c, input, start) => {
           let end = start;
@@ -166,18 +173,12 @@ class Lexer {
           return input.slice(start, end);
         }
       }),
-      [
-        "REGEX_START"
-        /* REGEX_START */
-      ]: createTokenType("REGEX_START", {
-        push: "NOT_REGEX",
+      [$T.REGEX_START]: createTokenType($T.REGEX_START, {
+        push: MODE.NOT_REGEX,
         matches: (c) => c === "/"
       }),
-      [
-        "REGEX_END"
-        /* REGEX_END */
-      ]: createTokenType("REGEX_END", {
-        push: "MAIN",
+      [$T.REGEX_END]: createTokenType($T.REGEX_END, {
+        push: MODE.MAIN,
         matches: (c, input, start) => {
           let end = start;
           if (c === "/") {
@@ -191,11 +192,8 @@ class Lexer {
           } else return false;
         }
       }),
-      [
-        "VALUE_REGEX"
-        /* VALUE_REGEX */
-      ]: createTokenType("VALUE_REGEX", {
-        push: "REGEX_END",
+      [$T.VALUE_REGEX]: createTokenType($T.VALUE_REGEX, {
+        push: MODE.REGEX_END,
         matches: (c, input, start) => {
           let end = start;
           let inGroup = 0;
@@ -210,7 +208,7 @@ class Lexer {
                 prevEscaped = false;
               }
             } else {
-              prevEscaped && (prevEscaped = false);
+              prevEscaped &&= false;
             }
             end++;
             c = input[end];
@@ -219,10 +217,7 @@ class Lexer {
           return input.slice(start, end);
         }
       }),
-      [
-        "QUOTE_SINGLE"
-        /* QUOTE_SINGLE */
-      ]: createTokenType("QUOTE_SINGLE", {
+      [$T.QUOTE_SINGLE]: createTokenType($T.QUOTE_SINGLE, {
         push: (mode, tokens) => {
           const previous = tokens[tokens.length - 2];
           if (
@@ -231,93 +226,75 @@ class Lexer {
              * Go back to main instead of searching for the quoted value
              * Otherwise input like 'a'b'c' will trap us in a MAIN <=> NOT_SINGLE loop.
              */
-            (previous == null ? void 0 : previous.type) === "VALUE_NOT_SINGLE" || (previous == null ? void 0 : previous.type) === "VALUE_UNQUOTED"
+            previous?.type === $T.VALUE_NOT_SINGLE || previous?.type === $T.VALUE_UNQUOTED
           ) {
-            if (mode.startsWith(BRACKET_PREFIX)) return "BRACKET_MAIN";
-            return "MAIN";
+            if (mode.startsWith(BRACKET_PREFIX)) return MODE.BRACKET_MAIN;
+            return MODE.MAIN;
           }
           switch (mode) {
-            case "BRACKET_MAIN":
-              return "BRACKET_NOT_SINGLE";
-            case "MAIN":
-              return "NOT_SINGLE";
+            case MODE.BRACKET_MAIN:
+              return MODE.BRACKET_NOT_SINGLE;
+            case MODE.MAIN:
+              return MODE.NOT_SINGLE;
             default:
-              if (mode.startsWith(BRACKET_PREFIX)) return "BRACKET_MAIN";
-              return "MAIN";
+              if (mode.startsWith(BRACKET_PREFIX)) return MODE.BRACKET_MAIN;
+              return MODE.MAIN;
           }
         },
         matches: (c) => c === "'"
       }),
-      [
-        "QUOTE_DOUBLE"
-        /* QUOTE_DOUBLE */
-      ]: createTokenType("QUOTE_DOUBLE", {
+      [$T.QUOTE_DOUBLE]: createTokenType($T.QUOTE_DOUBLE, {
         push: (mode, tokens) => {
           const previous = tokens[tokens.length - 2];
-          if ((previous == null ? void 0 : previous.type) === "VALUE_NOT_DOUBLE" || (previous == null ? void 0 : previous.type) === "VALUE_UNQUOTED") {
-            if (mode.startsWith(BRACKET_PREFIX)) return "BRACKET_MAIN";
-            return "MAIN";
+          if (previous?.type === $T.VALUE_NOT_DOUBLE || previous?.type === $T.VALUE_UNQUOTED) {
+            if (mode.startsWith(BRACKET_PREFIX)) return MODE.BRACKET_MAIN;
+            return MODE.MAIN;
           }
           switch (mode) {
-            case "BRACKET_MAIN":
-              return "BRACKET_NOT_DOUBLE";
-            case "MAIN":
-              return "NOT_DOUBLE";
+            case MODE.BRACKET_MAIN:
+              return MODE.BRACKET_NOT_DOUBLE;
+            case MODE.MAIN:
+              return MODE.NOT_DOUBLE;
             default:
-              if (mode.startsWith(BRACKET_PREFIX)) return "BRACKET_MAIN";
-              return "MAIN";
+              if (mode.startsWith(BRACKET_PREFIX)) return MODE.BRACKET_MAIN;
+              return MODE.MAIN;
           }
         },
         matches: (c) => c === '"'
       }),
-      [
-        "QUOTE_BACKTICK"
-        /* QUOTE_BACKTICK */
-      ]: createTokenType("QUOTE_BACKTICK", {
+      [$T.QUOTE_BACKTICK]: createTokenType($T.QUOTE_BACKTICK, {
         push: (mode, tokens) => {
           const previous = tokens[tokens.length - 2];
-          if ((previous == null ? void 0 : previous.type) === "VALUE_NOT_BACKTICK" || (previous == null ? void 0 : previous.type) === "VALUE_UNQUOTED") {
-            if (mode.startsWith(BRACKET_PREFIX)) return "BRACKET_MAIN";
-            return "MAIN";
+          if (previous?.type === $T.VALUE_NOT_BACKTICK || previous?.type === $T.VALUE_UNQUOTED) {
+            if (mode.startsWith(BRACKET_PREFIX)) return MODE.BRACKET_MAIN;
+            return MODE.MAIN;
           }
           switch (mode) {
-            case "BRACKET_MAIN":
-              return "BRACKET_NOT_BACKTICK";
-            case "MAIN":
-              return "NOT_BACKTICK";
+            case MODE.BRACKET_MAIN:
+              return MODE.BRACKET_NOT_BACKTICK;
+            case MODE.MAIN:
+              return MODE.NOT_BACKTICK;
             default:
-              if (mode.startsWith(BRACKET_PREFIX)) return "BRACKET_MAIN";
-              return "MAIN";
+              if (mode.startsWith(BRACKET_PREFIX)) return MODE.BRACKET_MAIN;
+              return MODE.MAIN;
           }
         },
         matches: (c) => c === "`"
       }),
-      [
-        "VALUE_NOT_SINGLE"
-        /* VALUE_NOT_SINGLE */
-      ]: createTokenType("VALUE_NOT_SINGLE", {
-        push: (mode) => mode.startsWith(BRACKET_PREFIX) ? "BRACKET_MAIN" : "MAIN",
+      [$T.VALUE_NOT_SINGLE]: createTokenType($T.VALUE_NOT_SINGLE, {
+        push: (mode) => mode.startsWith(BRACKET_PREFIX) ? MODE.BRACKET_MAIN : MODE.MAIN,
         matches: matchWhileCharNotEqualToUnescaped("'")
       }),
-      [
-        "VALUE_NOT_DOUBLE"
-        /* VALUE_NOT_DOUBLE */
-      ]: createTokenType("VALUE_NOT_DOUBLE", {
-        push: (mode) => mode.startsWith(BRACKET_PREFIX) ? "BRACKET_MAIN" : "MAIN",
+      [$T.VALUE_NOT_DOUBLE]: createTokenType($T.VALUE_NOT_DOUBLE, {
+        push: (mode) => mode.startsWith(BRACKET_PREFIX) ? MODE.BRACKET_MAIN : MODE.MAIN,
         matches: matchWhileCharNotEqualToUnescaped('"')
       }),
-      [
-        "VALUE_NOT_BACKTICK"
-        /* VALUE_NOT_BACKTICK */
-      ]: createTokenType("VALUE_NOT_BACKTICK", {
-        push: (mode) => mode.startsWith(BRACKET_PREFIX) ? "BRACKET_MAIN" : "MAIN",
+      [$T.VALUE_NOT_BACKTICK]: createTokenType($T.VALUE_NOT_BACKTICK, {
+        push: (mode) => mode.startsWith(BRACKET_PREFIX) ? MODE.BRACKET_MAIN : MODE.MAIN,
         matches: matchWhileCharNotEqualToUnescaped("`")
       }),
-      [
-        "VALUE_UNQUOTED"
-        /* VALUE_UNQUOTED */
-      ]: createTokenType("VALUE_UNQUOTED", {
-        push: (mode) => mode.startsWith(BRACKET_PREFIX) ? "BRACKET_MAIN" : "MAIN",
+      [$T.VALUE_UNQUOTED]: createTokenType($T.VALUE_UNQUOTED, {
+        push: (mode) => mode.startsWith(BRACKET_PREFIX) ? MODE.BRACKET_MAIN : MODE.MAIN,
         // manual version of pattern: /(\\[\s\S]|(${syms.length > 0 ? `(?!(${syms.join("|")}))` : ``}[^ \t()'"`\\]))+/,
         matches: (c, input, start, mode) => {
           let end = start;
@@ -327,7 +304,7 @@ class Lexer {
               c = input[end];
               continue;
             }
-            if (mode === "MAIN") {
+            if (mode === MODE.MAIN) {
               let found = false;
               for (const sym of symbols.all) {
                 const textSlice = input.slice(end, end + sym.length);
@@ -338,7 +315,7 @@ class Lexer {
               }
               if (found) break;
             }
-            if (c === " " || c === "	" || c === "(" || c === ")" || c === "'" || c === '"' || c === "`" || c === "\\" || mode === "BRACKET_MAIN" && c === "]") {
+            if (c === " " || c === "	" || c === "(" || c === ")" || c === "'" || c === '"' || c === "`" || c === "\\" || mode === MODE.BRACKET_MAIN && c === "]") {
               break;
             }
             end++;
@@ -349,62 +326,38 @@ class Lexer {
         }
       }),
       ...symbols.symOrs.length > 0 ? {
-        [
-          "SYM_OR"
-          /* SYM_OR */
-        ]: createTokenType("SYM_OR", {
+        [$T.SYM_OR]: createTokenType($T.SYM_OR, {
           matches: matchSymbol(symbols.symOrs)
         })
       } : {},
       ...symbols.symAnds.length > 0 ? {
-        [
-          "SYM_AND"
-          /* SYM_AND */
-        ]: createTokenType("SYM_AND", {
+        [$T.SYM_AND]: createTokenType($T.SYM_AND, {
           matches: matchSymbol(symbols.symAnds)
         })
       } : {},
       ...symbols.symNots.length > 0 ? {
-        [
-          "SYM_NOT"
-          /* SYM_NOT */
-        ]: createTokenType("SYM_NOT", {
+        [$T.SYM_NOT]: createTokenType($T.SYM_NOT, {
           matches: matchSymbol(symbols.symNots)
         })
       } : {},
       ...symbols.wordOrs.length > 0 ? {
-        [
-          "WORD_OR"
-          /* WORD_OR */
-        ]: createTokenType("WORD_OR", {
+        [$T.WORD_OR]: createTokenType($T.WORD_OR, {
           matches: matchSymbol(symbols.wordOrs),
-          longerAlt: "VALUE_UNQUOTED"
-          /* VALUE_UNQUOTED */
+          longerAlt: $T.VALUE_UNQUOTED
         })
       } : {},
       ...symbols.wordAnds.length > 0 ? {
-        [
-          "WORD_AND"
-          /* WORD_AND */
-        ]: createTokenType("WORD_AND", {
+        [$T.WORD_AND]: createTokenType($T.WORD_AND, {
           matches: matchSymbol(symbols.wordAnds),
-          longerAlt: "VALUE_UNQUOTED"
-          /* VALUE_UNQUOTED */
+          longerAlt: $T.VALUE_UNQUOTED
         })
       } : {},
-      ...symbols.wordNots.length > 0 ? { [
-        "WORD_NOT"
-        /* WORD_NOT */
-      ]: createTokenType("WORD_NOT", {
+      ...symbols.wordNots.length > 0 ? { [$T.WORD_NOT]: createTokenType($T.WORD_NOT, {
         matches: matchSymbol(symbols.wordNots),
-        longerAlt: "VALUE_UNQUOTED"
-        /* VALUE_UNQUOTED */
+        longerAlt: $T.VALUE_UNQUOTED
       }) } : {},
       ...!isBlank(opts.expandedPropertySeparator ?? "") ? {
-        [
-          "EXP_PROP_OP"
-          /* EXP_PROP_OP */
-        ]: createTokenType("EXP_PROP_OP", {
+        [$T.EXP_PROP_OP]: createTokenType($T.EXP_PROP_OP, {
           matches: (_c, input, start) => {
             for (const op of opts.expandedPropertySeparator) {
               const chars = input.slice(start, start + op.length);
@@ -414,11 +367,8 @@ class Lexer {
           }
         })
       } : {},
-      ...(((_a = opts.customPropertyOperators) == null ? void 0 : _a.length) ?? 0) > 0 && !symbols.customOpAlsoNegation ? {
-        [
-          "CUSTOM_PROP_OP"
-          /* CUSTOM_PROP_OP */
-        ]: createTokenType("CUSTOM_PROP_OP", {
+      ...(opts.customPropertyOperators?.length ?? 0) > 0 && !symbols.customOpAlsoNegation ? {
+        [$T.CUSTOM_PROP_OP]: createTokenType($T.CUSTOM_PROP_OP, {
           matches: (_c, input, start) => {
             for (const op of opts.customPropertyOperators ?? []) {
               const chars = input.slice(start, start + op.length);
@@ -428,239 +378,80 @@ class Lexer {
           }
         })
       } : {},
-      [
-        "PAREN_L"
-        /* PAREN_L */
-      ]: createTokenType("PAREN_L", {
+      [$T.PAREN_L]: createTokenType($T.PAREN_L, {
         matches: (c) => c === "("
       }),
-      [
-        "PAREN_R"
-        /* PAREN_R */
-      ]: createTokenType("PAREN_R", {
+      [$T.PAREN_R]: createTokenType($T.PAREN_R, {
         matches: (c) => c === ")"
       }),
-      [
-        "BRACKET_L"
-        /* BRACKET_L */
-      ]: createTokenType("BRACKET_L", {
-        push: "BRACKET_MAIN",
+      [$T.BRACKET_L]: createTokenType($T.BRACKET_L, {
+        push: MODE.BRACKET_MAIN,
         matches: (c) => c === "["
       }),
-      [
-        "BRACKET_R"
-        /* BRACKET_R */
-      ]: createTokenType("BRACKET_R", {
-        push: "MAIN",
+      [$T.BRACKET_R]: createTokenType($T.BRACKET_R, {
+        push: MODE.MAIN,
         matches: (c) => c === "]"
       })
     };
     const $categories = {
-      [
-        "ANY"
-        /* ANY */
-      ]: createTokenCategoryType("ANY", [
-        $[
-          "REGEX_START"
-          /* REGEX_START */
-        ],
-        $[
-          "REGEX_END"
-          /* REGEX_END */
-        ],
-        $[
-          "QUOTE_SINGLE"
-          /* QUOTE_SINGLE */
-        ],
-        $[
-          "QUOTE_DOUBLE"
-          /* QUOTE_DOUBLE */
-        ],
-        $[
-          "QUOTE_BACKTICK"
-          /* QUOTE_BACKTICK */
-        ],
-        $[
-          "VALUE_NOT_SINGLE"
-          /* VALUE_NOT_SINGLE */
-        ],
-        $[
-          "VALUE_NOT_DOUBLE"
-          /* VALUE_NOT_DOUBLE */
-        ],
-        $[
-          "VALUE_NOT_BACKTICK"
-          /* VALUE_NOT_BACKTICK */
-        ],
-        $[
-          "VALUE_UNQUOTED"
-          /* VALUE_UNQUOTED */
-        ],
-        $[
-          "SYM_OR"
-          /* SYM_OR */
-        ],
-        $[
-          "SYM_AND"
-          /* SYM_AND */
-        ],
-        $[
-          "SYM_NOT"
-          /* SYM_NOT */
-        ],
-        $[
-          "WORD_OR"
-          /* WORD_OR */
-        ],
-        $[
-          "WORD_AND"
-          /* WORD_AND */
-        ],
-        $[
-          "WORD_NOT"
-          /* WORD_NOT */
-        ],
-        $[
-          "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 */
-        ]
+      [$C.ANY]: createLexerCategoryToken($C.ANY, [
+        $[$T.REGEX_START],
+        $[$T.REGEX_END],
+        $[$T.QUOTE_SINGLE],
+        $[$T.QUOTE_DOUBLE],
+        $[$T.QUOTE_BACKTICK],
+        $[$T.VALUE_NOT_SINGLE],
+        $[$T.VALUE_NOT_DOUBLE],
+        $[$T.VALUE_NOT_BACKTICK],
+        $[$T.VALUE_UNQUOTED],
+        $[$T.SYM_OR],
+        $[$T.SYM_AND],
+        $[$T.SYM_NOT],
+        $[$T.WORD_OR],
+        $[$T.WORD_AND],
+        $[$T.WORD_NOT],
+        $[$T.EXP_PROP_OP],
+        $[$T.CUSTOM_PROP_OP],
+        $[$T.PAREN_L],
+        $[$T.PAREN_R],
+        $[$T.BRACKET_L],
+        $[$T.BRACKET_R]
       ]),
-      [
-        "VALUE"
-        /* VALUE */
-      ]: createTokenCategoryType("VALUE", [
-        $[
-          "VALUE_UNQUOTED"
-          /* VALUE_UNQUOTED */
-        ],
-        $[
-          "VALUE_NOT_SINGLE"
-          /* VALUE_NOT_SINGLE */
-        ],
-        $[
-          "VALUE_NOT_DOUBLE"
-          /* VALUE_NOT_DOUBLE */
-        ],
-        $[
-          "VALUE_NOT_BACKTICK"
-          /* VALUE_NOT_BACKTICK */
-        ]
+      [$C.VALUE]: createLexerCategoryToken($C.VALUE, [
+        $[$T.VALUE_UNQUOTED],
+        $[$T.VALUE_NOT_SINGLE],
+        $[$T.VALUE_NOT_DOUBLE],
+        $[$T.VALUE_NOT_BACKTICK]
       ]),
-      [
-        "VALUE_FOR_SINGLE"
-        /* VALUE_FOR_SINGLE */
-      ]: createTokenCategoryType("VALUE_FOR_SINGLE", [
-        $[
-          "VALUE_NOT_SINGLE"
-          /* VALUE_NOT_SINGLE */
-        ]
+      [$C.VALUE_FOR_SINGLE]: createLexerCategoryToken($C.VALUE_FOR_SINGLE, [
+        $[$T.VALUE_NOT_SINGLE]
       ]),
-      [
-        "VALUE_FOR_DOUBLE"
-        /* VALUE_FOR_DOUBLE */
-      ]: createTokenCategoryType("VALUE_FOR_DOUBLE", [
-        $[
-          "VALUE_NOT_DOUBLE"
-          /* VALUE_NOT_DOUBLE */
-        ]
+      [$C.VALUE_FOR_DOUBLE]: createLexerCategoryToken($C.VALUE_FOR_DOUBLE, [
+        $[$T.VALUE_NOT_DOUBLE]
       ]),
-      [
-        "VALUE_FOR_BACKTICK"
-        /* VALUE_FOR_BACKTICK */
-      ]: createTokenCategoryType("VALUE_FOR_BACKTICK", [
-        $[
-          "VALUE_NOT_BACKTICK"
-          /* VALUE_NOT_BACKTICK */
-        ]
+      [$C.VALUE_FOR_BACKTICK]: createLexerCategoryToken($C.VALUE_FOR_BACKTICK, [
+        $[$T.VALUE_NOT_BACKTICK]
       ]),
-      [
-        "REGEX_ANY"
-        /* REGEX_ANY */
-      ]: createTokenCategoryType("REGEX_ANY", [
-        $[
-          "REGEX_START"
-          /* REGEX_START */
-        ],
-        $[
-          "REGEX_END"
-          /* REGEX_END */
-        ]
+      [$C.REGEX_ANY]: createLexerCategoryToken($C.REGEX_ANY, [
+        $[$T.REGEX_START],
+        $[$T.REGEX_END]
       ]),
-      [
-        "QUOTE_ANY"
-        /* QUOTE_ANY */
-      ]: createTokenCategoryType("QUOTE_ANY", [
-        $[
-          "QUOTE_SINGLE"
-          /* QUOTE_SINGLE */
-        ],
-        $[
-          "QUOTE_DOUBLE"
-          /* QUOTE_DOUBLE */
-        ],
-        $[
-          "QUOTE_BACKTICK"
-          /* QUOTE_BACKTICK */
-        ]
+      [$C.QUOTE_ANY]: createLexerCategoryToken($C.QUOTE_ANY, [
+        $[$T.QUOTE_SINGLE],
+        $[$T.QUOTE_DOUBLE],
+        $[$T.QUOTE_BACKTICK]
       ]),
-      [
-        "OPERATOR_OR"
-        /* OPERATOR_OR */
-      ]: createTokenCategoryType("OPERATOR_OR", [
-        $[
-          "SYM_OR"
-          /* SYM_OR */
-        ],
-        $[
-          "WORD_OR"
-          /* WORD_OR */
-        ]
+      [$C.OPERATOR_OR]: createLexerCategoryToken($C.OPERATOR_OR, [
+        $[$T.SYM_OR],
+        $[$T.WORD_OR]
       ]),
-      [
-        "OPERATOR_AND"
-        /* OPERATOR_AND */
-      ]: createTokenCategoryType("OPERATOR_AND", [
-        $[
-          "SYM_AND"
-          /* SYM_AND */
-        ],
-        $[
-          "WORD_AND"
-          /* WORD_AND */
-        ]
+      [$C.OPERATOR_AND]: createLexerCategoryToken($C.OPERATOR_AND, [
+        $[$T.SYM_AND],
+        $[$T.WORD_AND]
       ]),
-      [
-        "OPERATOR_NOT"
-        /* OPERATOR_NOT */
-      ]: createTokenCategoryType("OPERATOR_NOT", [
-        $[
-          "SYM_NOT"
-          /* SYM_NOT */
-        ],
-        $[
-          "WORD_NOT"
-          /* WORD_NOT */
-        ]
+      [$C.OPERATOR_NOT]: createLexerCategoryToken($C.OPERATOR_NOT, [
+        $[$T.SYM_NOT],
+        $[$T.WORD_NOT]
       ])
     };
     return { $, $categories };
@@ -669,220 +460,76 @@ class Lexer {
     const opts = this.opts;
     const $ = this.$;
     const quotes = [
-      $[
-        "QUOTE_SINGLE"
-        /* QUOTE_SINGLE */
-      ],
-      $[
-        "QUOTE_DOUBLE"
-        /* QUOTE_DOUBLE */
-      ],
-      $[
-        "QUOTE_BACKTICK"
-        /* QUOTE_BACKTICK */
-      ]
+      $[$T.QUOTE_SINGLE],
+      $[$T.QUOTE_DOUBLE],
+      $[$T.QUOTE_BACKTICK]
     ];
-    const parens = [$[
-      "PAREN_L"
-      /* PAREN_L */
-    ], $[
-      "PAREN_R"
-      /* PAREN_R */
-    ]];
+    const parens = [$[$T.PAREN_L], $[$T.PAREN_R]];
     const operators = [
-      $[
-        "EXP_PROP_OP"
-        /* EXP_PROP_OP */
-      ],
-      $[
-        "CUSTOM_PROP_OP"
-        /* CUSTOM_PROP_OP */
-      ],
-      $[
-        "SYM_OR"
-        /* SYM_OR */
-      ],
-      $[
-        "SYM_AND"
-        /* SYM_AND */
-      ],
-      $[
-        "SYM_NOT"
-        /* SYM_NOT */
-      ],
-      $[
-        "WORD_OR"
-        /* WORD_OR */
-      ],
-      $[
-        "WORD_AND"
-        /* WORD_AND */
-      ],
-      $[
-        "WORD_NOT"
-        /* WORD_NOT */
-      ]
+      $[$T.EXP_PROP_OP],
+      $[$T.CUSTOM_PROP_OP],
+      $[$T.SYM_OR],
+      $[$T.SYM_AND],
+      $[$T.SYM_NOT],
+      $[$T.WORD_OR],
+      $[$T.WORD_AND],
+      $[$T.WORD_NOT]
     ].filter((_) => _ !== void 0);
     return {
-      [
-        "MAIN"
-        /* MAIN */
-      ]: [
-        $[
-          "_"
-          /* _ */
-        ],
+      [MODE.MAIN]: [
+        $[$T._],
         ...parens,
-        ...opts.arrayValues ? [$[
-          "BRACKET_L"
-          /* BRACKET_L */
-        ]] : [],
+        ...opts.arrayValues ? [$[$T.BRACKET_L]] : [],
         // => MODE.BRACKET_MAIN
         ...operators,
         ...quotes,
         // => MODE.NOT_*
-        ...opts.regexValues ? [$[
-          "REGEX_START"
-          /* REGEX_START */
-        ]] : [],
+        ...opts.regexValues ? [$[$T.REGEX_START]] : [],
         // => MODE.NOT_REGEX
-        $[
-          "VALUE_UNQUOTED"
-          /* VALUE_UNQUOTED */
-        ]
+        $[$T.VALUE_UNQUOTED]
       ],
       // this is just MAIN by another name, but allows us to properly distinguish start/end quotes
       // // we can have situations like `a"` where the left quote is missing
       // // we want the quote to match a quote so that it pushes the state to main again, instead of shifting how everything is parsed
-      [
-        "MAYBE_QUOTE_ERROR"
-        /* MAYBE_QUOTE_ERROR */
-      ]: [
+      [MODE.MAYBE_QUOTE_ERROR]: [
         ...quotes,
-        ...opts.regexValues ? [$[
-          "REGEX_END"
-          /* REGEX_END */
-        ]] : []
+        ...opts.regexValues ? [$[$T.REGEX_END]] : []
       ],
       // all => MODE.MAIN
-      [
-        "NOT_SINGLE"
-        /* NOT_SINGLE */
-      ]: [$[
-        "VALUE_NOT_SINGLE"
-        /* VALUE_NOT_SINGLE */
-      ], $[
-        "QUOTE_SINGLE"
-        /* QUOTE_SINGLE */
-      ]],
-      [
-        "NOT_DOUBLE"
-        /* NOT_DOUBLE */
-      ]: [$[
-        "VALUE_NOT_DOUBLE"
-        /* VALUE_NOT_DOUBLE */
-      ], $[
-        "QUOTE_DOUBLE"
-        /* QUOTE_DOUBLE */
-      ]],
-      [
-        "NOT_BACKTICK"
-        /* NOT_BACKTICK */
-      ]: [$[
-        "VALUE_NOT_BACKTICK"
-        /* VALUE_NOT_BACKTICK */
-      ], $[
-        "QUOTE_BACKTICK"
-        /* QUOTE_BACKTICK */
-      ]],
+      [MODE.NOT_SINGLE]: [$[$T.VALUE_NOT_SINGLE], $[$T.QUOTE_SINGLE]],
+      [MODE.NOT_DOUBLE]: [$[$T.VALUE_NOT_DOUBLE], $[$T.QUOTE_DOUBLE]],
+      [MODE.NOT_BACKTICK]: [$[$T.VALUE_NOT_BACKTICK], $[$T.QUOTE_BACKTICK]],
       ...opts.regexValues ? {
-        [
-          "NOT_REGEX"
-          /* NOT_REGEX */
-        ]: [
-          $[
-            "VALUE_REGEX"
-            /* VALUE_REGEX */
-          ],
-          $[
-            "REGEX_END"
-            /* REGEX_END */
-          ]
+        [MODE.NOT_REGEX]: [
+          $[$T.VALUE_REGEX],
+          $[$T.REGEX_END]
           // regex is empty
         ],
         // => MODE.REGEX_END
-        [
-          "REGEX_END"
-          /* REGEX_END */
-        ]: [$[
-          "REGEX_END"
-          /* REGEX_END */
-        ]]
+        [MODE.REGEX_END]: [$[$T.REGEX_END]]
         // => MODE.MAIN
       } : {},
       ...opts.arrayValues ? {
-        [
-          "BRACKET_MAIN"
-          /* BRACKET_MAIN */
-        ]: [
-          $[
-            "_"
-            /* _ */
-          ],
+        [MODE.BRACKET_MAIN]: [
+          $[$T._],
           ...quotes,
-          $[
-            "BRACKET_R"
-            /* BRACKET_R */
-          ],
+          $[$T.BRACKET_R],
           // => MODE.MAIN
-          $[
-            "VALUE_UNQUOTED"
-            /* VALUE_UNQUOTED */
-          ]
+          $[$T.VALUE_UNQUOTED]
         ],
         // all the following follow the same logic as the non-bracket modes, except operators and parens and regexes are not supported and are just parsed as values with VALUE_UNQUOTED
-        [
-          "BRACKET_MAYBE_QUOTE_ERROR"
-          /* BRACKET_MAYBE_QUOTE_ERROR */
-        ]: [...quotes],
-        [
-          "BRACKET_NOT_SINGLE"
-          /* BRACKET_NOT_SINGLE */
-        ]: [
-          $[
-            "VALUE_NOT_SINGLE"
-            /* VALUE_NOT_SINGLE */
-          ],
-          $[
-            "QUOTE_SINGLE"
-            /* QUOTE_SINGLE */
-          ]
-        ],
-        [
-          "BRACKET_NOT_DOUBLE"
-          /* BRACKET_NOT_DOUBLE */
-        ]: [
-          $[
-            "VALUE_NOT_DOUBLE"
-            /* VALUE_NOT_DOUBLE */
-          ],
-          $[
-            "QUOTE_DOUBLE"
-            /* QUOTE_DOUBLE */
-          ]
-        ],
-        [
-          "BRACKET_NOT_BACKTICK"
-          /* BRACKET_NOT_BACKTICK */
-        ]: [
-          $[
-            "VALUE_NOT_BACKTICK"
-            /* VALUE_NOT_BACKTICK */
-          ],
-          $[
-            "QUOTE_BACKTICK"
-            /* QUOTE_BACKTICK */
-          ]
+        [MODE.BRACKET_MAYBE_QUOTE_ERROR]: [...quotes],
+        [MODE.BRACKET_NOT_SINGLE]: [
+          $[$T.VALUE_NOT_SINGLE],
+          $[$T.QUOTE_SINGLE]
+        ],
+        [MODE.BRACKET_NOT_DOUBLE]: [
+          $[$T.VALUE_NOT_DOUBLE],
+          $[$T.QUOTE_DOUBLE]
+        ],
+        [MODE.BRACKET_NOT_BACKTICK]: [
+          $[$T.VALUE_NOT_BACKTICK],
+          $[$T.QUOTE_BACKTICK]
         ]
       } : {}
     };
@@ -890,7 +537,7 @@ class Lexer {
   tokenize(input) {
     const branches = this.createModeBranches();
     const tokens = [];
-    let mode = "MAIN";
+    let mode = MODE.MAIN;
     let index = 0;
     let c = input[index];
     let branch = branches[mode];