@witchcraft/expressit 0.0.2 → 0.1.0

package/dist/Lexer.js

@@ -0,0 +1,960 @@
+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 { isBlank } from "@alanscodelog/utils/isBlank";
+import { pushIfNotIn } from "@alanscodelog/utils/pushIfNotIn";
+import { checkParserOpts } from "./helpers/parser/checkParserOpts.js";
+import { parseParserOptions } from "./helpers/parser/parseParserOptions.js";
+const regexFlags = /^[a-zA-Z]+/;
+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) {
+  return {
+    type,
+    isCategory: true,
+    entries: Object.fromEntries(
+      entries.filter((_) => _ !== void 0).map((_) => [_.type, _])
+    )
+  };
+}
+function createTokenType(type, opts) {
+  return {
+    type,
+    ...opts
+  };
+}
+function matchWhileCharNotEqualToUnescaped(char) {
+  return (c, input, start) => {
+    let end = start;
+    while (c !== void 0 && c !== char) {
+      if (c === "\\") {
+        end += 2;
+        c = input[end];
+        continue;
+      }
+      end++;
+      c = input[end];
+    }
+    if (start === end)
+      return false;
+    return input.slice(start, end);
+  };
+}
+function matchSymbol(symbols) {
+  return (_c, input, start) => {
+    for (const sym of symbols) {
+      const textSlice = input.slice(start, start + sym.length);
+      if (textSlice === sym) {
+        return textSlice;
+      }
+    }
+    return false;
+  };
+}
+class Lexer {
+  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();
+    const tokenTypes = this.createTokens();
+    this.$ = tokenTypes.$;
+    this.$categories = tokenTypes.$categories;
+    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);
+    const symNots = opts.keywords.not.filter((_) => _.isSymbol).map((_) => _.value);
+    const wordOrs = opts.keywords.or.filter((_) => !_.isSymbol).map((_) => _.value);
+    const wordAnds = opts.keywords.and.filter((_) => !_.isSymbol).map((_) => _.value);
+    const wordNots = opts.keywords.not.filter((_) => !_.isSymbol).map((_) => _.value);
+    const syms = [...symOrs, ...symAnds, ...symNots];
+    const customPropertyOperators = opts.customPropertyOperators ?? [];
+    const expandedPropertySeparator = opts.expandedPropertySeparator ?? "";
+    if (expandedPropertySeparator)
+      syms.push(expandedPropertySeparator);
+    if (customPropertyOperators.length > 0)
+      pushIfNotIn(syms, customPropertyOperators);
+    if (opts.regexValues)
+      syms.push("\\/");
+    if (opts.arrayValues) {
+      syms.push("\\[");
+    }
+    const symbols = {
+      // all sorted by longest first, so longest matches are matched first
+      symOrs: symOrs.sort((a, b) => b.length - a.length),
+      symAnds: symAnds.sort((a, b) => b.length - a.length),
+      symNots: symNots.sort((a, b) => b.length - a.length),
+      wordOrs: wordOrs.sort((a, b) => b.length - a.length),
+      wordAnds: wordAnds.sort((a, b) => b.length - a.length),
+      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;
+    let customOpAlsoNegation = false;
+    if (symbols.symNots.length > 0) {
+      for (const op of opts.customPropertyOperators ?? []) {
+        for (const sym of symbols.symNots) {
+          if (op === sym) {
+            customOpAlsoNegation = true;
+            break;
+          }
+        }
+      }
+    }
+    return { ...symbols, expandedSepAlsoCustom, customOpAlsoNegation };
+  }
+  // eslint-disable-next-line @typescript-eslint/explicit-function-return-type
+  createTokens() {
+    var _a;
+    const opts = this.opts;
+    const symbols = this.symbols;
+    const $ = {
+      [
+        "_"
+        /* _ */
+      ]: createTokenType("_", {
+        skip: true,
+        matches: (c, input, start) => {
+          let end = start;
+          while (c === " " || c === "	" || c === "\n" || c === "\r" || c === "\v" || c === "\f") {
+            end++;
+            c = input[end];
+          }
+          if (start === end)
+            return false;
+          return input.slice(start, end);
+        }
+      }),
+      [
+        "REGEX_START"
+        /* REGEX_START */
+      ]: createTokenType("REGEX_START", {
+        push: "NOT_REGEX",
+        matches: (c) => c === "/"
+      }),
+      [
+        "REGEX_END"
+        /* REGEX_END */
+      ]: createTokenType("REGEX_END", {
+        push: "MAIN",
+        matches: (c, input, start) => {
+          let end = start;
+          if (c === "/") {
+            end++;
+            c = input[end];
+            const match = regexFlags.exec(input.slice(end));
+            if (match !== null) {
+              end += match.input.length;
+            }
+            return input.slice(start, end);
+          } else
+            return false;
+        }
+      }),
+      [
+        "VALUE_REGEX"
+        /* VALUE_REGEX */
+      ]: createTokenType("VALUE_REGEX", {
+        push: "REGEX_END",
+        matches: (c, input, start) => {
+          let end = start;
+          let inGroup = 0;
+          let prevEscaped = false;
+          while (c !== void 0 && (c !== "/" || inGroup > 0 || prevEscaped)) {
+            if (c === "[")
+              inGroup++;
+            if (c === "]" && inGroup > 0)
+              inGroup--;
+            if (c === "\\") {
+              if (!prevEscaped) {
+                prevEscaped = true;
+              } else {
+                prevEscaped = false;
+              }
+            } else {
+              prevEscaped && (prevEscaped = false);
+            }
+            end++;
+            c = input[end];
+          }
+          if (start === end)
+            return false;
+          return input.slice(start, end);
+        }
+      }),
+      [
+        "QUOTE_SINGLE"
+        /* QUOTE_SINGLE */
+      ]: createTokenType("QUOTE_SINGLE", {
+        push: (mode, tokens) => {
+          const previous = tokens[tokens.length - 2];
+          if (
+            /**
+             * If we  just matched a quote and the previous token was the inside of a quote then we are at the end of the quoted value.
+             * 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"
+          ) {
+            return "MAIN";
+          }
+          switch (mode) {
+            case "BRACKET_MAIN":
+              return "BRACKET_NOT_SINGLE";
+            case "MAIN":
+              return "NOT_SINGLE";
+            default:
+              if (mode.startsWith(BRACKET_PREFIX))
+                return "BRACKET_MAIN";
+              return "MAIN";
+          }
+        },
+        matches: (c) => c === "'"
+      }),
+      [
+        "QUOTE_DOUBLE"
+        /* QUOTE_DOUBLE */
+      ]: createTokenType("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";
+          }
+          switch (mode) {
+            case "BRACKET_MAIN":
+              return "BRACKET_NOT_DOUBLE";
+            case "MAIN":
+              return "NOT_DOUBLE";
+            default:
+              if (mode.startsWith(BRACKET_PREFIX))
+                return "BRACKET_MAIN";
+              return "MAIN";
+          }
+        },
+        matches: (c) => c === '"'
+      }),
+      [
+        "QUOTE_BACKTICK"
+        /* QUOTE_BACKTICK */
+      ]: createTokenType("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") {
+            return "MAIN";
+          }
+          switch (mode) {
+            case "BRACKET_MAIN":
+              return "BRACKET_NOT_BACKTICK";
+            case "MAIN":
+              return "NOT_BACKTICK";
+            default:
+              if (mode.startsWith(BRACKET_PREFIX))
+                return "BRACKET_MAIN";
+              return "MAIN";
+          }
+        },
+        matches: (c) => c === "`"
+      }),
+      [
+        "VALUE_NOT_SINGLE"
+        /* VALUE_NOT_SINGLE */
+      ]: createTokenType("VALUE_NOT_SINGLE", {
+        push: (mode) => mode.startsWith(BRACKET_PREFIX) ? "BRACKET_MAIN" : "MAIN",
+        matches: matchWhileCharNotEqualToUnescaped("'")
+      }),
+      [
+        "VALUE_NOT_DOUBLE"
+        /* VALUE_NOT_DOUBLE */
+      ]: createTokenType("VALUE_NOT_DOUBLE", {
+        push: (mode) => mode.startsWith(BRACKET_PREFIX) ? "BRACKET_MAIN" : "MAIN",
+        matches: matchWhileCharNotEqualToUnescaped('"')
+      }),
+      [
+        "VALUE_NOT_BACKTICK"
+        /* VALUE_NOT_BACKTICK */
+      ]: createTokenType("VALUE_NOT_BACKTICK", {
+        push: (mode) => mode.startsWith(BRACKET_PREFIX) ? "BRACKET_MAIN" : "MAIN",
+        matches: matchWhileCharNotEqualToUnescaped("`")
+      }),
+      [
+        "VALUE_UNQUOTED"
+        /* VALUE_UNQUOTED */
+      ]: createTokenType("VALUE_UNQUOTED", {
+        push: (mode) => mode.startsWith(BRACKET_PREFIX) ? "BRACKET_MAIN" : "MAIN",
+        // manual version of pattern: /(\\[\s\S]|(${syms.length > 0 ? `(?!(${syms.join("|")}))` : ``}[^ \t()'"`\\]))+/,
+        matches: (c, input, start, mode) => {
+          let end = start;
+          while (c !== void 0) {
+            if (c === "\\") {
+              end += 2;
+              c = input[end];
+              continue;
+            }
+            if (mode === "MAIN") {
+              let found = false;
+              for (const sym of symbols.all) {
+                const textSlice = input.slice(end, end + sym.length);
+                if (textSlice === sym) {
+                  found = true;
+                  break;
+                }
+              }
+              if (found)
+                break;
+            }
+            if (c === " " || c === "	" || c === "(" || c === ")" || c === "'" || c === '"' || c === "`" || c === "\\" || mode === "BRACKET_MAIN" && c === "]") {
+              break;
+            }
+            end++;
+            c = input[end];
+          }
+          if (start === end)
+            return false;
+          return input.slice(start, end);
+        }
+      }),
+      ...symbols.symOrs.length > 0 ? {
+        [
+          "SYM_OR"
+          /* SYM_OR */
+        ]: createTokenType("SYM_OR", {
+          matches: matchSymbol(symbols.symOrs)
+        })
+      } : {},
+      ...symbols.symAnds.length > 0 ? {
+        [
+          "SYM_AND"
+          /* SYM_AND */
+        ]: createTokenType("SYM_AND", {
+          matches: matchSymbol(symbols.symAnds)
+        })
+      } : {},
+      ...symbols.symNots.length > 0 ? {
+        [
+          "SYM_NOT"
+          /* SYM_NOT */
+        ]: createTokenType("SYM_NOT", {
+          matches: matchSymbol(symbols.symNots)
+        })
+      } : {},
+      ...symbols.wordOrs.length > 0 ? {
+        [
+          "WORD_OR"
+          /* WORD_OR */
+        ]: createTokenType("WORD_OR", {
+          matches: matchSymbol(symbols.wordOrs),
+          longerAlt: "VALUE_UNQUOTED"
+          /* VALUE_UNQUOTED */
+        })
+      } : {},
+      ...symbols.wordAnds.length > 0 ? {
+        [
+          "WORD_AND"
+          /* WORD_AND */
+        ]: createTokenType("WORD_AND", {
+          matches: matchSymbol(symbols.wordAnds),
+          longerAlt: "VALUE_UNQUOTED"
+          /* VALUE_UNQUOTED */
+        })
+      } : {},
+      ...symbols.wordNots.length > 0 ? { [
+        "WORD_NOT"
+        /* WORD_NOT */
+      ]: createTokenType("WORD_NOT", {
+        matches: matchSymbol(symbols.wordNots),
+        longerAlt: "VALUE_UNQUOTED"
+        /* VALUE_UNQUOTED */
+      }) } : {},
+      ...!isBlank(opts.expandedPropertySeparator ?? "") ? {
+        [
+          "EXP_PROP_OP"
+          /* EXP_PROP_OP */
+        ]: createTokenType("EXP_PROP_OP", {
+          matches: (_c, input, start) => {
+            for (const op of opts.expandedPropertySeparator) {
+              const chars = input.slice(start, start + op.length);
+              if (chars === op)
+                return op;
+            }
+            return false;
+          }
+        })
+      } : {},
+      ...(((_a = opts.customPropertyOperators) == null ? void 0 : _a.length) ?? 0) > 0 && !symbols.customOpAlsoNegation ? {
+        [
+          "CUSTOM_PROP_OP"
+          /* CUSTOM_PROP_OP */
+        ]: createTokenType("CUSTOM_PROP_OP", {
+          matches: (_c, input, start) => {
+            for (const op of opts.customPropertyOperators ?? []) {
+              const chars = input.slice(start, start + op.length);
+              if (chars === op)
+                return op;
+            }
+            return false;
+          }
+        })
+      } : {},
+      [
+        "PAREN_L"
+        /* PAREN_L */
+      ]: createTokenType("PAREN_L", {
+        matches: (c) => c === "("
+      }),
+      [
+        "PAREN_R"
+        /* PAREN_R */
+      ]: createTokenType("PAREN_R", {
+        matches: (c) => c === ")"
+      }),
+      [
+        "BRACKET_L"
+        /* BRACKET_L */
+      ]: createTokenType("BRACKET_L", {
+        push: "BRACKET_MAIN",
+        matches: (c) => c === "["
+      }),
+      [
+        "BRACKET_R"
+        /* BRACKET_R */
+      ]: createTokenType("BRACKET_R", {
+        push: "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 */
+        ]
+      ]),
+      [
+        "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 */
+        ]
+      ]),
+      [
+        "VALUE_FOR_SINGLE"
+        /* VALUE_FOR_SINGLE */
+      ]: createTokenCategoryType("VALUE_FOR_SINGLE", [
+        $[
+          "VALUE_NOT_SINGLE"
+          /* VALUE_NOT_SINGLE */
+        ]
+      ]),
+      [
+        "VALUE_FOR_DOUBLE"
+        /* VALUE_FOR_DOUBLE */
+      ]: createTokenCategoryType("VALUE_FOR_DOUBLE", [
+        $[
+          "VALUE_NOT_DOUBLE"
+          /* VALUE_NOT_DOUBLE */
+        ]
+      ]),
+      [
+        "VALUE_FOR_BACKTICK"
+        /* VALUE_FOR_BACKTICK */
+      ]: createTokenCategoryType("VALUE_FOR_BACKTICK", [
+        $[
+          "VALUE_NOT_BACKTICK"
+          /* VALUE_NOT_BACKTICK */
+        ]
+      ]),
+      [
+        "REGEX_ANY"
+        /* REGEX_ANY */
+      ]: createTokenCategoryType("REGEX_ANY", [
+        $[
+          "REGEX_START"
+          /* REGEX_START */
+        ],
+        $[
+          "REGEX_END"
+          /* REGEX_END */
+        ]
+      ]),
+      [
+        "QUOTE_ANY"
+        /* QUOTE_ANY */
+      ]: createTokenCategoryType("QUOTE_ANY", [
+        $[
+          "QUOTE_SINGLE"
+          /* QUOTE_SINGLE */
+        ],
+        $[
+          "QUOTE_DOUBLE"
+          /* QUOTE_DOUBLE */
+        ],
+        $[
+          "QUOTE_BACKTICK"
+          /* QUOTE_BACKTICK */
+        ]
+      ]),
+      [
+        "OPERATOR_OR"
+        /* OPERATOR_OR */
+      ]: createTokenCategoryType("OPERATOR_OR", [
+        $[
+          "SYM_OR"
+          /* SYM_OR */
+        ],
+        $[
+          "WORD_OR"
+          /* WORD_OR */
+        ]
+      ]),
+      [
+        "OPERATOR_AND"
+        /* OPERATOR_AND */
+      ]: createTokenCategoryType("OPERATOR_AND", [
+        $[
+          "SYM_AND"
+          /* SYM_AND */
+        ],
+        $[
+          "WORD_AND"
+          /* WORD_AND */
+        ]
+      ]),
+      [
+        "OPERATOR_NOT"
+        /* OPERATOR_NOT */
+      ]: createTokenCategoryType("OPERATOR_NOT", [
+        $[
+          "SYM_NOT"
+          /* SYM_NOT */
+        ],
+        $[
+          "WORD_NOT"
+          /* WORD_NOT */
+        ]
+      ])
+    };
+    return { $, $categories };
+  }
+  createModeBranches() {
+    const opts = this.opts;
+    const $ = this.$;
+    const quotes = [
+      $[
+        "QUOTE_SINGLE"
+        /* QUOTE_SINGLE */
+      ],
+      $[
+        "QUOTE_DOUBLE"
+        /* QUOTE_DOUBLE */
+      ],
+      $[
+        "QUOTE_BACKTICK"
+        /* QUOTE_BACKTICK */
+      ]
+    ];
+    const parens = [$[
+      "PAREN_L"
+      /* PAREN_L */
+    ], $[
+      "PAREN_R"
+      /* 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 */
+      ]
+    ].filter((_) => _ !== void 0);
+    return {
+      [
+        "MAIN"
+        /* MAIN */
+      ]: [
+        $[
+          "_"
+          /* _ */
+        ],
+        ...parens,
+        ...opts.arrayValues ? [$[
+          "BRACKET_L"
+          /* BRACKET_L */
+        ]] : [],
+        // => MODE.BRACKET_MAIN
+        ...operators,
+        ...quotes,
+        // => MODE.NOT_*
+        ...opts.regexValues ? [$[
+          "REGEX_START"
+          /* REGEX_START */
+        ]] : [],
+        // => MODE.NOT_REGEX
+        $[
+          "VALUE_UNQUOTED"
+          /* 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 */
+      ]: [
+        ...quotes,
+        ...opts.regexValues ? [$[
+          "REGEX_END"
+          /* 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 */
+      ]],
+      ...opts.regexValues ? {
+        [
+          "NOT_REGEX"
+          /* NOT_REGEX */
+        ]: [
+          $[
+            "VALUE_REGEX"
+            /* VALUE_REGEX */
+          ],
+          $[
+            "REGEX_END"
+            /* REGEX_END */
+          ]
+          // regex is empty
+        ],
+        // => MODE.REGEX_END
+        [
+          "REGEX_END"
+          /* REGEX_END */
+        ]: [$[
+          "REGEX_END"
+          /* REGEX_END */
+        ]]
+        // => MODE.MAIN
+      } : {},
+      ...opts.arrayValues ? {
+        [
+          "BRACKET_MAIN"
+          /* BRACKET_MAIN */
+        ]: [
+          $[
+            "_"
+            /* _ */
+          ],
+          ...quotes,
+          $[
+            "BRACKET_R"
+            /* BRACKET_R */
+          ],
+          // => MODE.MAIN
+          $[
+            "VALUE_UNQUOTED"
+            /* 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 */
+          ]
+        ]
+      } : {}
+    };
+  }
+  tokenize(input) {
+    const branches = this.createModeBranches();
+    const tokens = [];
+    let mode = "MAIN";
+    let index = 0;
+    let c = input[index];
+    let branch = branches[mode];
+    while (index < input.length) {
+      for (const t of branch) {
+        let match = t.matches(c, input, index, mode);
+        if (match) {
+          let matchLength = match === true ? 1 : match.length;
+          let type = t.type;
+          if (t.longerAlt) {
+            const longerMatch = this.$[t.longerAlt].matches(c, input, index, mode);
+            const longerMatchLength = longerMatch === true ? 1 : longerMatch.length;
+            if (longerMatch && longerMatchLength > matchLength) {
+              match = longerMatch;
+              matchLength = longerMatchLength;
+              type = t.longerAlt;
+            }
+          }
+          const newIndex = index + matchLength;
+          const val = match === true ? c : match;
+          const token = createToken(type, val, index, newIndex - 1);
+          if (!t.skip)
+            tokens.push(token);
+          if (t.push) {
+            mode = typeof t.push === "function" ? t.push(mode, tokens) : t.push;
+            branch = branches[mode];
+          }
+          index = newIndex;
+          c = input[index];
+          break;
+        }
+      }
+    }
+    return tokens;
+  }
+}
+function createToken(type, value, startOffset, endOffset) {
+  return {
+    type,
+    value,
+    startOffset,
+    endOffset
+  };
+}
+export {
+  $C,
+  $T,
+  Lexer
+};