@witchcraft/expressit 0.2.2 → 0.3.0

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

@@ -1 +1 @@
-{"version":3,"file":"autocomplete.d.ts","sourceRoot":"","sources":["../../src/types/autocomplete.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,QAAQ,EAAE,QAAQ,EAAE,UAAU,EAAE,MAAM,UAAU,CAAA;AAG9D;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAoDG;AACH,MAAM,MAAM,UAAU,GAAG;IACxB,KAAK,EAAE,MAAM,CAAA;IACb;;;;OAIG;IACH,EAAE,CAAC,EAAE,UAAU,CAAA;IACf,qFAAqF;IACrF,IAAI,CAAC,EAAE,QAAQ,CAAA;IACf,sGAAsG;IACtG,IAAI,CAAC,EAAE,QAAQ,CAAA;IACf,4BAA4B;IAC5B,KAAK,EAAE;QACN,gCAAgC;QAChC,IAAI,CAAC,EAAE,UAAU,CAAA;QACjB,gCAAgC;QAChC,IAAI,CAAC,EAAE,UAAU,CAAA;KACjB,CAAA;IACD,+GAA+G;IAC/G,UAAU,EAAE;QACX,uGAAuG;QACvG,IAAI,EAAE,OAAO,CAAA;QACb,yGAAyG;QACzG,IAAI,EAAE,OAAO,CAAA;KACb,CAAA;CACD,CAAA;AAED,oBAAY,eAAe;IAE1B,QAAQ,aAAa;IACrB,WAAW,gBAAgB;IAC3B,KAAK,UAAU;IACf,MAAM,WAAW;IACjB,eAAe,oBAAoB;IACnC,iBAAiB,sBAAsB;IACvC,QAAQ,aAAa;IACrB,WAAW,gBAAgB;IAC3B,WAAW,gBAAgB;IAC3B,MAAM,WAAW;IACjB,MAAM,WAAW;IACjB,QAAQ,aAAa;IACrB,0BAA0B,+BAA+B;IACzD,wBAAwB,6BAA6B;IACrD,YAAY,iBAAiB;IAC7B,QAAQ,aAAa;IACrB,KAAK,UAAU;IACf,WAAW,gBAAgB;CAG3B;AAED;;GAEG;AACH,MAAM,MAAM,UAAU,GAAG;IACxB,IAAI,EAAE,eAAe,CAAA;IACrB,gEAAgE;IAChE,KAAK,EAAE,QAAQ,CAAA;IACf,yBAAyB;IACzB,UAAU,EAAE,UAAU,CAAA;IACtB,yEAAyE;IACzE,QAAQ,EAAE;QACT;;;;WAIG;QACH,UAAU,EAAE;YACX,KAAK,EAAE,OAAO,CAAA;YACd,MAAM,EAAE,OAAO,CAAA;SACf,CAAA;QACD;;;;;;WAMG;QACH,KAAK,EAAE,OAAO,CAAA;QACd,6OAA6O;QAC7O,MAAM,EAAE,MAAM,GAAG,KAAK,CAAA;KACtB,CAAA;IACD;;OAEG;IACH,OAAO,EAAE,OAAO,CAAA;CAChB,CAAA;AAGD,MAAM,MAAM,UAAU,GAAG;IACxB,UAAU,EAAE,UAAU,CAAA;IACtB,KAAK,EAAE,MAAM,CAAA;CACb,CAAA"}
+{"version":3,"file":"autocomplete.d.ts","sourceRoot":"","sources":["../../src/types/autocomplete.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,QAAQ,EAAE,MAAM,qBAAqB,CAAA;AAGnD,OAAO,KAAK,EAAE,QAAQ,EAAE,QAAQ,EAAE,UAAU,EAAE,MAAM,UAAU,CAAA;AAG9D;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAoDG;AACH,MAAM,MAAM,UAAU,GAAG;IACxB,KAAK,EAAE,MAAM,CAAA;IACb;;;;OAIG;IACH,EAAE,CAAC,EAAE,UAAU,CAAA;IACf,qFAAqF;IACrF,IAAI,CAAC,EAAE,QAAQ,CAAA;IACf,sGAAsG;IACtG,IAAI,CAAC,EAAE,QAAQ,CAAA;IACf,4BAA4B;IAC5B,KAAK,EAAE;QACN,gCAAgC;QAChC,IAAI,CAAC,EAAE,UAAU,CAAA;QACjB,gCAAgC;QAChC,IAAI,CAAC,EAAE,UAAU,CAAA;KACjB,CAAA;IACD,+GAA+G;IAC/G,UAAU,EAAE;QACX,uGAAuG;QACvG,IAAI,EAAE,OAAO,CAAA;QACb,yGAAyG;QACzG,IAAI,EAAE,OAAO,CAAA;KACb,CAAA;CACD,CAAA;AAED,eAAO,MAAM,eAAe;;;;;;;;;;;;;;;;;;;CAqB1B,CAAA;AAEF,MAAM,MAAM,cAAc,GAAG,QAAQ,CAAC,OAAO,eAAe,CAAC,CAAA;AAE7D;;GAEG;AACH,MAAM,MAAM,UAAU,GAAG;IACxB,IAAI,EAAE,cAAc,CAAA;IACpB,gEAAgE;IAChE,KAAK,EAAE,QAAQ,CAAA;IACf,yBAAyB;IACzB,UAAU,EAAE,UAAU,CAAA;IACtB,yEAAyE;IACzE,QAAQ,EAAE;QACT;;;;WAIG;QACH,UAAU,EAAE;YACX,KAAK,EAAE,OAAO,CAAA;YACd,MAAM,EAAE,OAAO,CAAA;SACf,CAAA;QACD;;;;;;WAMG;QACH,KAAK,EAAE,OAAO,CAAA;QACd,6OAA6O;QAC7O,MAAM,EAAE,MAAM,GAAG,KAAK,CAAA;KACtB,CAAA;IACD;;OAEG;IACH,OAAO,EAAE,OAAO,CAAA;CAChB,CAAA;AAGD,MAAM,MAAM,UAAU,GAAG;IACxB,UAAU,EAAE,UAAU,CAAA;IACtB,KAAK,EAAE,MAAM,CAAA;CACb,CAAA"}

package/dist/types/autocomplete.js

@@ -1,24 +1,27 @@
-var SUGGESTION_TYPE = /* @__PURE__ */ ((SUGGESTION_TYPE2) => {
-  SUGGESTION_TYPE2["VARIABLE"] = "VARIABLE";
-  SUGGESTION_TYPE2["ARRAY_VALUE"] = "ARRAY_VALUE";
-  SUGGESTION_TYPE2["VALUE"] = "VALUE";
-  SUGGESTION_TYPE2["PREFIX"] = "PREFIX";
-  SUGGESTION_TYPE2["BOOLEAN_WORD_OP"] = "BOOLEAN_WORD_OP";
-  SUGGESTION_TYPE2["BOOLEAN_SYMBOL_OP"] = "BOOLEAN_SYMBOL_OP";
-  SUGGESTION_TYPE2["BACKTICK"] = "BACKTICK";
-  SUGGESTION_TYPE2["DOUBLEQUOTE"] = "DOUBLEQUOTE";
-  SUGGESTION_TYPE2["SINGLEQUOTE"] = "SINGLEQUOTE";
-  SUGGESTION_TYPE2["PARENL"] = "PARENL";
-  SUGGESTION_TYPE2["PARENR"] = "PARENR";
-  SUGGESTION_TYPE2["PROPERTY"] = "PROPERTY";
-  SUGGESTION_TYPE2["EXPANDED_PROPERTY_OPERATOR"] = "EXPANDED_PROPERTY_OPERATOR";
-  SUGGESTION_TYPE2["CUSTOM_PROPERTY_OPERATOR"] = "CUSTOM_PROPERTY_OPERATOR";
-  SUGGESTION_TYPE2["PROPERTY_SEP"] = "PROPERTY_SEP";
-  SUGGESTION_TYPE2["BRAKCETR"] = "BRAKCETR";
-  SUGGESTION_TYPE2["REGEX"] = "REGEX";
-  SUGGESTION_TYPE2["REGEX_FLAGS"] = "REGEX_FLAGS";
-  return SUGGESTION_TYPE2;
-})(SUGGESTION_TYPE || {});
+import "@alanscodelog/utils";
+import { enumFromArray } from "@alanscodelog/utils/enumFromArray.js";
+const SUGGESTION_TYPE = enumFromArray([
+  "VARIABLE",
+  "ARRAY_VALUE",
+  "VALUE",
+  "PREFIX",
+  "BOOLEAN_WORD_OP",
+  "BOOLEAN_SYMBOL_OP",
+  "BACKTICK",
+  "DOUBLEQUOTE",
+  "SINGLEQUOTE",
+  "PARENL",
+  "PARENR",
+  "PROPERTY",
+  "EXPANDED_PROPERTY_OPERATOR",
+  "CUSTOM_PROPERTY_OPERATOR",
+  "PROPERTY_SEP",
+  "BRAKCETR",
+  "REGEX",
+  "REGEX_FLAGS"
+  /** This is not an oversight, I haven't figured out a fast way to detect left bracket errors. */
+  // BRAKCETL = "BRAKCETL",
+]);
 export {
   SUGGESTION_TYPE
 };

package/dist/types/errors.d.ts

@@ -1,20 +1,22 @@
+import { type EnumLike } from "@alanscodelog/utils";
 import type { ParserOptions } from "./parser.js";
-export declare enum ERROR_CODES {
-    PARSER_POSITION_ERROR = "PARSER.POSITION",
-    PARSER_CONFLICTING_OPTIONS_ERROR = "PARSER.OPTIONS.CONFLICTING",
-    PARSER_OPTION_REQUIRED_ERROR = "PARSER.OPTIONS.CUSTOM_REQUIRED"
-}
-export type ErrorInfo<T extends ERROR_CODES> = T extends ERROR_CODES ? ERROR_Info[T] : never;
-export type ERROR_Info = {
-    [ERROR_CODES.PARSER_POSITION_ERROR]: {
+export declare const PARSER_ERROR: {
+    POSITION_ERROR: "PARSER.POSITION_ERROR";
+    CONFLICTING_OPTIONS_ERROR: "PARSER.CONFLICTING_OPTIONS_ERROR";
+    OPTION_REQUIRED_ERROR: "PARSER.OPTION_REQUIRED_ERROR";
+};
+export type ParserError = EnumLike<typeof PARSER_ERROR>;
+export type ErrorInfo<T extends ParserError> = T extends ParserError ? ErrorCodesInfo[T] : never;
+export type ErrorCodesInfo = {
+    [PARSER_ERROR.POSITION_ERROR]: {
         start?: number;
         end?: number;
     };
-    [ERROR_CODES.PARSER_CONFLICTING_OPTIONS_ERROR]: {
+    [PARSER_ERROR.CONFLICTING_OPTIONS_ERROR]: {
         prohibited: string[];
         invalid: string;
     };
-    [ERROR_CODES.PARSER_OPTION_REQUIRED_ERROR]: {
+    [PARSER_ERROR.OPTION_REQUIRED_ERROR]: {
         options?: (keyof ParserOptions)[];
         requires: keyof ParserOptions;
     };

package/dist/types/errors.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"errors.d.ts","sourceRoot":"","sources":["../../src/types/errors.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,aAAa,CAAA;AAGhD,oBAAY,WAAW;IACtB,qBAAqB,oBAAoB;IACzC,gCAAgC,+BAA+B;IAC/D,4BAA4B,mCAAmC;CAC/D;AAGD,MAAM,MAAM,SAAS,CAAC,CAAC,SAAS,WAAW,IAC1C,CAAC,SAAS,WAAW,GACnB,UAAU,CAAC,CAAC,CAAC,GACb,KAAK,CAAA;AAGR,MAAM,MAAM,UAAU,GAAG;IACxB,CAAC,WAAW,CAAC,qBAAqB,CAAC,EAAE;QACpC,KAAK,CAAC,EAAE,MAAM,CAAA;QACd,GAAG,CAAC,EAAE,MAAM,CAAA;KACZ,CAAA;IACD,CAAC,WAAW,CAAC,gCAAgC,CAAC,EAAE;QAC/C,UAAU,EAAE,MAAM,EAAE,CAAA;QACpB,OAAO,EAAE,MAAM,CAAA;KACf,CAAA;IACD,CAAC,WAAW,CAAC,4BAA4B,CAAC,EAAE;QAC3C,OAAO,CAAC,EAAE,CAAC,MAAM,aAAa,CAAC,EAAE,CAAA;QACjC,QAAQ,EAAE,MAAM,aAAa,CAAA;KAC7B,CAAA;CACD,CAAA"}
+{"version":3,"file":"errors.d.ts","sourceRoot":"","sources":["../../src/types/errors.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,QAAQ,EAAE,MAAM,qBAAqB,CAAA;AAGnD,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,aAAa,CAAA;AAGhD,eAAO,MAAM,YAAY;;;;CAIZ,CAAA;AAEb,MAAM,MAAM,WAAW,GAAG,QAAQ,CAAC,OAAO,YAAY,CAAC,CAAA;AAGvD,MAAM,MAAM,SAAS,CAAC,CAAC,SAAS,WAAW,IAC1C,CAAC,SAAS,WAAW,GACnB,cAAc,CAAC,CAAC,CAAC,GACjB,KAAK,CAAA;AAGR,MAAM,MAAM,cAAc,GAAG;IAC5B,CAAC,YAAY,CAAC,cAAc,CAAC,EAAE;QAC9B,KAAK,CAAC,EAAE,MAAM,CAAA;QACd,GAAG,CAAC,EAAE,MAAM,CAAA;KACZ,CAAA;IACD,CAAC,YAAY,CAAC,yBAAyB,CAAC,EAAE;QACzC,UAAU,EAAE,MAAM,EAAE,CAAA;QACpB,OAAO,EAAE,MAAM,CAAA;KACf,CAAA;IACD,CAAC,YAAY,CAAC,qBAAqB,CAAC,EAAE;QACrC,OAAO,CAAC,EAAE,CAAC,MAAM,aAAa,CAAC,EAAE,CAAA;QACjC,QAAQ,EAAE,MAAM,aAAa,CAAA;KAC7B,CAAA;CACD,CAAA"}

package/dist/types/errors.js

@@ -1,9 +1,10 @@
-var ERROR_CODES = /* @__PURE__ */ ((ERROR_CODES2) => {
-  ERROR_CODES2["PARSER_POSITION_ERROR"] = "PARSER.POSITION";
-  ERROR_CODES2["PARSER_CONFLICTING_OPTIONS_ERROR"] = "PARSER.OPTIONS.CONFLICTING";
-  ERROR_CODES2["PARSER_OPTION_REQUIRED_ERROR"] = "PARSER.OPTIONS.CUSTOM_REQUIRED";
-  return ERROR_CODES2;
-})(ERROR_CODES || {});
+import "@alanscodelog/utils";
+import { enumFromArray } from "@alanscodelog/utils/enumFromArray.js";
+const PARSER_ERROR = enumFromArray([
+  "POSITION_ERROR",
+  "CONFLICTING_OPTIONS_ERROR",
+  "OPTION_REQUIRED_ERROR"
+], "PARSER.");
 export {
-  ERROR_CODES
+  PARSER_ERROR
 };

package/dist/types/index.js

@@ -1,9 +1,9 @@
 import { AST_TYPE, TOKEN_TYPE } from "./ast.js";
 import { SUGGESTION_TYPE } from "./autocomplete.js";
-import { ERROR_CODES } from "./errors.js";
+import { PARSER_ERROR } from "./errors.js";
 export {
   AST_TYPE,
-  ERROR_CODES,
+  PARSER_ERROR,
   SUGGESTION_TYPE,
   TOKEN_TYPE
 };

package/dist/types/parser.d.ts

@@ -415,9 +415,9 @@ export type ValueQuery = {
 /** {@link ParserOptions}["valueValidator"] */
 export type ValidationQuery = Omit<ValueQuery, "value" | "operator" | "prefix" | "regexFlags" | "property"> & {
     value?: VariableNode | ArrayNode;
-    operator?: ValidToken<TOKEN_TYPE.VALUE | TOKEN_TYPE.OP_CUSTOM>;
-    prefix?: ValidToken<TOKEN_TYPE.VALUE>;
-    regexFlags?: ValidToken<TOKEN_TYPE.VALUE>;
+    operator?: ValidToken<typeof TOKEN_TYPE.VALUE | typeof TOKEN_TYPE.OP_CUSTOM>;
+    prefix?: ValidToken<typeof TOKEN_TYPE.VALUE>;
+    regexFlags?: ValidToken<typeof TOKEN_TYPE.VALUE>;
     property: VariableNode[];
     /** The property as would be passed to the {@link ParserOptions}["valueComparer"] function (i.e. joined as a string using the {@link ParseOptions}["prefixApplier"] ) */
     propertyName?: string;

package/dist/types/parser.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"parser.d.ts","sourceRoot":"","sources":["../../src/types/parser.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"parser.d.ts","sourceRoot":"","sources":["../../src/types/parser.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,YAAY,EAAE,YAAY,EAAE,MAAM,2BAA2B,CAAA;AAE3E,OAAO,KAAK,EAAE,SAAS,EAAE,aAAa,EAAE,mBAAmB,EAAE,QAAQ,EAAE,UAAU,EAAE,UAAU,EAAE,YAAY,EAAE,MAAM,UAAU,CAAA;AAI7H,MAAM,MAAM,iBAAiB,CAAC,CAAC,GAAG,GAAG,IAAI,YAAY,CACpD,aAAa,CAAC,CAAC,CAAC,EAEhB,OAAO,CAAC,MAAM,aAAa,CAAC,CAAC,CAAC,EAC3B,mBAAmB,GACnB,2BAA2B,GAC3B,yBAAyB,GACzB,UAAU,CACZ,CACD,GACC;IAED,QAAQ,EAAE,YAAY,CAAC,cAAc,CAAC,CAAA;CACtC,CAAA;AACD,MAAM,MAAM,aAAa,CAAC,CAAC,GAAG,GAAG,IAAI;IACpC;;;;;;;;;;;;;;;OAeG;IACH,gBAAgB,CAAC,EAAE,OAAO,CAAA;IAC1B;;;;;;OAMG;IACH,iBAAiB,CAAC,EAAE,MAAM,EAAE,CAAA;IAC5B;;;;;;;;;;;;;;;;;;OAkBG;IACH,yBAAyB,CAAC,EAAE,MAAM,CAAA;IAClC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OA6BG;IACH,uBAAuB,CAAC,EAAE,MAAM,EAAE,CAAA;IAClC;;;;;;;;;;;;;;;;OAgBG;IACH,wBAAwB,CAAC,EAAE,OAAO,GAAG,KAAK,GAAG,IAAI,CAAA;IACjD;;;;;;;;;;;;;;;;;;;;;;;;;;;;OA4BG;IACH,WAAW,CAAC,EAAE,OAAO,GAAG,CAAC,CAAC,QAAQ,EAAE,MAAM,GAAG,SAAS,EAAE,QAAQ,EAAE,MAAM,GAAG,SAAS,EAAE,UAAU,EAAE,OAAO,KAAK,OAAO,CAAC,CAAA;IACtH;;;;;;;;OAQG;IACH,WAAW,CAAC,EAAE,OAAO,GAAG,CAAC,CAAC,QAAQ,EAAE,MAAM,GAAG,SAAS,EAAE,QAAQ,EAAE,MAAM,GAAG,SAAS,EAAE,UAAU,EAAE,OAAO,KAAK,OAAO,CAAC,CAAA;IACtH;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OA8BG;IACH,QAAQ,CAAC,EAAE,cAAc,CAAA;IACzB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OAkCG;IACH,aAAa,CAAC,EAAE,aAAa,CAAA;IAC7B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OAqCG;IACH,SAAS,CAAC,EAAE,SAAS,CAAA;IACrB;;;;;;;;;;;;;;;;;;;;;;;OAuBG;IACH,aAAa,CAAC,EAAE,aAAa,CAAA;IAC7B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OAuDG;IACH,mBAAmB,CAAC,EAAE,mBAAmB,CAAA;IACzC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OA+CG;IACH,cAAc,CAAC,EAAE,cAAc,CAAC,CAAC,CAAC,CAAA;CAClC,CAAA;AAED,gDAAgD;AAChD,MAAM,MAAM,UAAU,GAWnB;IACD,SAAS,EAAE,aAAa,CAAA;IACxB;;OAEG;IACH,6CAA6C;IAC7C,QAAQ,EAAE,MAAM,GAAG,SAAS,CAAA;IAC5B,0HAA0H;IAC1H,MAAM,EAAE,MAAM,GAAG,SAAS,CAAA;IAC1B;;;;;;;;OAQG;IACH,KAAK,EAAE,IAAI,GAAG,MAAM,GAAG,MAAM,EAAE,CAAA;IAC/B;;OAEG;IACH,QAAQ,CAAC,EAAE,MAAM,EAAE,CAAA;IACnB,yDAAyD;IACzD,UAAU,CAAC,EAAE,MAAM,CAAA;IACnB,yGAAyG;IACzG,OAAO,EAAE,OAAO,CAAA;IAChB,mHAAmH;IACnH,QAAQ,EAAE,OAAO,CAAA;IACjB,8IAA8I;IAC9I,SAAS,EAAE,OAAO,CAAA;IAClB,+CAA+C;IAC/C,UAAU,EAAE,OAAO,CAAA;CACnB,CAAA;AAEF,8CAA8C;AAC9C,MAAM,MAAM,eAAe,GAAG,IAAI,CAAC,UAAU,EAAE,OAAO,GAAG,UAAU,GAAG,QAAQ,GAAG,YAAY,GAAG,UAAU,CAAC,GAAG;IAC7G,KAAK,CAAC,EAAE,YAAY,GAAG,SAAS,CAAA;IAChC,QAAQ,CAAC,EAAE,UAAU,CAAC,OAAO,UAAU,CAAC,KAAK,GAAG,OAAO,UAAU,CAAC,SAAS,CAAC,CAAA;IAC5E,MAAM,CAAC,EAAE,UAAU,CAAC,OAAO,UAAU,CAAC,KAAK,CAAC,CAAA;IAC5C,UAAU,CAAC,EAAE,UAAU,CAAC,OAAO,UAAU,CAAC,KAAK,CAAC,CAAA;IAChD,QAAQ,EAAE,YAAY,EAAE,CAAA;IACxB,wKAAwK;IACxK,YAAY,CAAC,EAAE,MAAM,CAAA;IACrB,0EAA0E;IAC1E,YAAY,EAAE,MAAM,EAAE,CAAA;IACtB;;OAEG;IACH,QAAQ,CAAC,EAAE,YAAY,EAAE,CAAA;CACzB,CAAA;AACD,MAAM,MAAM,aAAa,GAAG,CAAC,SAAS,EAAE,IAAI,CAAC,mBAAmB,EAAE,QAAQ,CAAC,EAAE,YAAY,EAAE,GAAG,EAAE,OAAO,EAAE,GAAG,KAAK,OAAO,CAAA;AACxH,MAAM,MAAM,mBAAmB,GAAG,CAAC,KAAK,EAAE,UAAU,KAAK;IAAE,KAAK,EAAE,GAAG,CAAC;IAAC,QAAQ,EAAE,GAAG,CAAC;IAAC,MAAM,EAAE,OAAO,CAAA;CAAE,CAAA;AACvG,MAAM,MAAM,cAAc,CAAC,CAAC,GAAG,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,IAAI,CAAC,YAAY,EAAE,GAAG,GAAG,SAAS,EAAE,KAAK,EAAE,eAAe,EAAE,OAAO,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,KAAK,CAAC,QAAQ,GAAG,CAAC,CAAC,EAAE,GAAG,SAAS,GAAG,IAAI,CAAA;AAEnL,MAAM,MAAM,SAAS,GAAG,CAAC,GAAG,EAAE,MAAM,KAAK,MAAM,EAAE,CAAA;AACjD,MAAM,MAAM,aAAa,GAAG,CAAC,MAAM,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,KAAK,MAAM,CAAA;AAExE,MAAM,MAAM,YAAY,GAAG;IAC1B,kDAAkD;IAClD,QAAQ,EAAE,OAAO,CAAA;IACjB,KAAK,EAAE,MAAM,CAAA;CACb,CAAA;AACD,MAAM,MAAM,cAAc,GAAG;IAC5B,EAAE,CAAC,EAAE,YAAY,EAAE,CAAA;IACnB,GAAG,CAAC,EAAE,YAAY,EAAE,CAAA;IACpB,GAAG,CAAC,EAAE,YAAY,EAAE,CAAA;CACpB,CAAA"}

package/dist/utils/getCursorInfo.js

@@ -1,6 +1,8 @@
 import { isArray } from "@alanscodelog/utils/isArray.js";
 import { unreachable } from "@alanscodelog/utils/unreachable.js";
 import { extractTokens } from "./extractTokens.js";
+import "../types/ast.js";
+import "../types/autocomplete.js";
 function getCursorInfo(input, ast, index) {
   const tokens = isArray(ast) ? ast : extractTokens(ast);
   if (input.length < index || index < 0) {

package/dist/utils/getOppositeDelimiter.d.ts

@@ -1,7 +1,7 @@
 import type { generateParentsMap } from "./generateParentsMap.js";
-import { type AnyToken, type TokenDelimiterTypes } from "../types/ast.js";
+import { type AnyToken, type TokenDelimiter } from "../types/ast.js";
 /**
  * Given a delimiter token, returns it's opposite pair, or undefined if the type passed was not a delimiter token (so you can pass any type without checking).
  */
-export declare function getOppositeDelimiter(token: AnyToken, parentsMap: ReturnType<typeof generateParentsMap>): AnyToken<TokenDelimiterTypes> | undefined;
+export declare function getOppositeDelimiter(token: AnyToken, parentsMap: ReturnType<typeof generateParentsMap>): AnyToken<TokenDelimiter> | undefined;
 //# sourceMappingURL=getOppositeDelimiter.d.ts.map

package/dist/utils/getOppositeDelimiter.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"getOppositeDelimiter.d.ts","sourceRoot":"","sources":["../../src/utils/getOppositeDelimiter.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,yBAAyB,CAAA;AAMjE,OAAO,EAAE,KAAK,QAAQ,EAAiE,KAAK,mBAAmB,EAAqB,MAAM,iBAAiB,CAAA;AAE3J;;GAEG;AACH,wBAAgB,oBAAoB,CACnC,KAAK,EAAE,QAAQ,EACf,UAAU,EAAE,UAAU,CAAC,OAAO,kBAAkB,CAAC,GAC/C,QAAQ,CAAC,mBAAmB,CAAC,GAAG,SAAS,CAuB3C"}
+{"version":3,"file":"getOppositeDelimiter.d.ts","sourceRoot":"","sources":["../../src/utils/getOppositeDelimiter.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,yBAAyB,CAAA;AAMjE,OAAO,EAAE,KAAK,QAAQ,EAAiE,KAAK,cAAc,EAAqB,MAAM,iBAAiB,CAAA;AAEtJ;;GAEG;AACH,wBAAgB,oBAAoB,CACnC,KAAK,EAAE,QAAQ,EACf,UAAU,EAAE,UAAU,CAAC,OAAO,kBAAkB,CAAC,GAC/C,QAAQ,CAAC,cAAc,CAAC,GAAG,SAAS,CAuBtC"}

package/dist/utils/isDelimiter.d.ts

@@ -1,6 +1,6 @@
-import { type AnyToken, type TokenDelimiterTypes } from "../types/ast.js";
+import { type AnyToken, type TokenDelimiter } from "../types/ast.js";
 /**
  * Returns whether token is a delimiter type (including if it's an expanded operator separator).
  */
-export declare function isDelimiter(token?: AnyToken): token is AnyToken<TokenDelimiterTypes>;
+export declare function isDelimiter(token?: AnyToken): token is AnyToken<TokenDelimiter>;
 //# sourceMappingURL=isDelimiter.d.ts.map

package/dist/utils/isDelimiter.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"isDelimiter.d.ts","sourceRoot":"","sources":["../../src/utils/isDelimiter.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,QAAQ,EAAc,KAAK,mBAAmB,EAAE,MAAM,iBAAiB,CAAA;AAErF;;GAEG;AACH,wBAAgB,WAAW,CAAC,KAAK,CAAC,EAAE,QAAQ,GAAG,KAAK,IAAI,QAAQ,CAAC,mBAAmB,CAAC,CAYpF"}
+{"version":3,"file":"isDelimiter.d.ts","sourceRoot":"","sources":["../../src/utils/isDelimiter.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,QAAQ,EAAc,KAAK,cAAc,EAAE,MAAM,iBAAiB,CAAA;AAEhF;;GAEG;AACH,wBAAgB,WAAW,CAAC,KAAK,CAAC,EAAE,QAAQ,GAAG,KAAK,IAAI,QAAQ,CAAC,cAAc,CAAC,CAY/E"}

package/dist/utils/isParen.d.ts

@@ -1,3 +1,3 @@
-import { type AnyToken, type TokenParenTypes } from "../types/ast.js";
-export declare function isParen(token?: AnyToken): token is AnyToken<TokenParenTypes>;
+import { type AnyToken, type TokenParen } from "../types/ast.js";
+export declare function isParen(token?: AnyToken): token is AnyToken<TokenParen>;
 //# sourceMappingURL=isParen.d.ts.map

package/dist/utils/isParen.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"isParen.d.ts","sourceRoot":"","sources":["../../src/utils/isParen.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,QAAQ,EAAc,KAAK,eAAe,EAAE,MAAM,iBAAiB,CAAA;AAGjF,wBAAgB,OAAO,CAAC,KAAK,CAAC,EAAE,QAAQ,GAAG,KAAK,IAAI,QAAQ,CAAC,eAAe,CAAC,CAE5E"}
+{"version":3,"file":"isParen.d.ts","sourceRoot":"","sources":["../../src/utils/isParen.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,QAAQ,EAAc,KAAK,UAAU,EAAE,MAAM,iBAAiB,CAAA;AAG5E,wBAAgB,OAAO,CAAC,KAAK,CAAC,EAAE,QAAQ,GAAG,KAAK,IAAI,QAAQ,CAAC,UAAU,CAAC,CAEvE"}

package/dist/utils/isQuote.d.ts

@@ -1,4 +1,4 @@
-import { type AnyToken, type TokenQuoteTypes } from "../types/ast.js";
+import { type AnyToken, type TokenQuote } from "../types/ast.js";
 /** Returns if the token is a quote token. This includes regex delimiters. */
-export declare function isQuote(token?: AnyToken): token is AnyToken<TokenQuoteTypes>;
+export declare function isQuote(token?: AnyToken): token is AnyToken<TokenQuote>;
 //# sourceMappingURL=isQuote.d.ts.map

package/dist/utils/isQuote.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"isQuote.d.ts","sourceRoot":"","sources":["../../src/utils/isQuote.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,QAAQ,EAAc,KAAK,eAAe,EAAE,MAAM,iBAAiB,CAAA;AAEjF,6EAA6E;AAC7E,wBAAgB,OAAO,CAAC,KAAK,CAAC,EAAE,QAAQ,GAAG,KAAK,IAAI,QAAQ,CAAC,eAAe,CAAC,CAE5E"}
+{"version":3,"file":"isQuote.d.ts","sourceRoot":"","sources":["../../src/utils/isQuote.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,QAAQ,EAAc,KAAK,UAAU,EAAE,MAAM,iBAAiB,CAAA;AAE5E,6EAA6E;AAC7E,wBAAgB,OAAO,CAAC,KAAK,CAAC,EAAE,QAAQ,GAAG,KAAK,IAAI,QAAQ,CAAC,UAAU,CAAC,CAEvE"}

package/package.json

@@ -1,10 +1,10 @@
 {
 	"name": "@witchcraft/expressit",
 	"description": "A blazing fast, customizable, error-tolerant expression parser that creates safe to eval expressions + a few other goodies like autocomplete.",
-	"version": "0.2.2",
+	"version": "0.3.0",
 	"types": "./dist/index.d.ts",
 	"type": "module",
-	"module": "./dist/index.js",
+	"main": "./dist/index.js",
 	"sideEffects": false,
 	"exports": {
 		".": {
@@ -85,21 +85,21 @@
 		"prepare": "husky && npm run build"
 	},
 	"dependencies": {
-		"@alanscodelog/utils": "^4.0.0"
+		"@alanscodelog/utils": "^5.1.0"
 	},
 	"devDependencies": {
 		"@alanscodelog/commitlint-config": "^3.0.1",
 		"@alanscodelog/eslint-config": "5.0.3",
-		"@alanscodelog/semantic-release-config": "^5.0.3",
-		"@alanscodelog/tsconfigs": "^5.0.1",
+		"@alanscodelog/semantic-release-config": "^5.0.4",
+		"@alanscodelog/tsconfigs": "^6.0.0",
 		"@commitlint/cli": "^19.6.1",
 		"@electric-sql/pglite": "^0.2.12",
 		"@types/node": "^22.10.2",
-		"@vitest/coverage-v8": "^2.1.8",
+		"@vitest/coverage-v8": "^3.1.1",
 		"concurrently": "^9.1.0",
 		"cross-env": "^7.0.3",
-		"drizzle-kit": "^0.30.1",
-		"drizzle-orm": "^0.38.2",
+		"drizzle-kit": "^0.31.0",
+		"drizzle-orm": "^0.42.0",
 		"fast-glob": "^3.3.1",
 		"http-server": "^14.1.1",
 		"husky": "^9.1.7",
@@ -108,12 +108,12 @@
 		"onchange": "^7.1.0",
 		"semantic-release": "^24.2.0",
 		"ts-node": "^10.9.1",
-		"typedoc": "0.27.5",
-		"typescript": "~5.7.2",
+		"typedoc": "0.28.3",
+		"typescript": "~5.8.3",
 		"vite": "^6.0.2",
-		"vite-plugin-externalize-deps": "^0.8.0",
+		"vite-plugin-externalize-deps": "^0.9.0",
 		"vite-tsconfig-paths": "^5.1.4",
-		"vitest": "^2.1.8"
+		"vitest": "^3.1.1"
 	},
 	"author": "Alan <alanscodelog@gmail.com>",
 	"repository": "https://github.com/witchcraftjs/expressit",
@@ -143,7 +143,7 @@
 	},
 	"browserslist": "defaults and supports es6-module,maintained node versions",
 	"engines": {
-		"node": ">=18.0.0"
+		"node": ">=20.0.0"
 	},
 	"@comments": {
 		"scripts": {

package/src/Lexer.ts

@@ -1,3 +1,5 @@
+import type { EnumLike } from "@alanscodelog/utils"
+import { enumFromArray } from "@alanscodelog/utils/enumFromArray.js"
 import { isBlank } from "@alanscodelog/utils/isBlank.js"
 import { pushIfNotIn } from "@alanscodelog/utils/pushIfNotIn.js"
 
@@ -7,63 +9,68 @@ import type { FullParserOptions } from "./types/index.js"
 
 const regexFlags = /^[a-zA-Z]+/
 
-enum MODE {
-	MAIN = "MAIN",
-	MAYBE_QUOTE_ERROR = "MAYBE_QUOTE_ERROR",
-	NOT_SINGLE = "NOT_SINGLE",
-	NOT_DOUBLE = "NOT_DOUBLE",
-	NOT_BACKTICK = "NOT_BACKTICK",
-	NOT_REGEX = "NOT_REGEX",
-	REGEX_END = "REGEX_END",
-	BRACKET_MAIN = "BRACKET_MAIN",
-	BRACKET_MAYBE_QUOTE_ERROR = "BRACKET_MAYBE_QUOTE_ERROR",
-	BRACKET_NOT_SINGLE = "BRACKET_NOT_SINGLE",
-	BRACKET_NOT_DOUBLE = "BRACKET_NOT_DOUBLE",
-	BRACKET_NOT_BACKTICK = "BRACKET_NOT_BACKTICK",
-	
-}
+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"
 
+export 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",
+])
+
 // eslint-disable-next-line @typescript-eslint/naming-convention
-export enum $T {
-	_ = "_", // whitespace,
-	VALUE_UNQUOTED = "VALUE_UNQUOTED",
-	VALUE_REGEX = "VALUE_REGEX",
-	VALUE_NOT_SINGLE = "VALUE_NOT_SINGLE",
-	VALUE_NOT_DOUBLE = "VALUE_NOT_DOUBLE",
-	VALUE_NOT_BACKTICK = "VALUE_NOT_BACKTICK",
-	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",
-	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",
-	QUOTE_SINGLE = "QUOTE_SINGLE",
-	QUOTE_DOUBLE = "QUOTE_DOUBLE",
-	QUOTE_BACKTICK = "QUOTE_BACKTICK",
-}
+export type $TType = EnumLike<typeof $T>
 
+export const $C = enumFromArray([
+	"ANY",
+	"QUOTE_ANY",
+	"REGEX_ANY",
+	"VALUE_FOR_SINGLE",
+	"VALUE_FOR_DOUBLE",
+	"VALUE_FOR_BACKTICK",
+	"OPERATOR_OR",
+	"OPERATOR_AND",
+	"OPERATOR_NOT",
+	"VALUE",
+])
 // eslint-disable-next-line @typescript-eslint/naming-convention
-export enum $C {
-	ANY = "ANY",
-	QUOTE_ANY = "QUOTE_ANY",
-	REGEX_ANY = "REGEX_ANY",
-	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",
-	VALUE = "VALUE",
-}
+export type $CType = EnumLike<typeof $C>
 	
 
 type SymbolInfo = {
@@ -80,40 +87,42 @@ type SymbolInfo = {
 
 type TokenMatchFunc = (c: string, input: string, start: number, mode: string) => string | boolean
 
-interface BaseTokenType<T extends $T | $C> {
+interface LexerBaseToken<T extends $TType | $CType> {
 	type: T
 	skip?: boolean
 }
-export interface RealTokenType<
-	T extends $T = $T,
+
+export interface LexerRealToken<
+	T extends $TType = $TType,
 	TPush extends string | undefined = undefined,
 	// TCategories extends $C[] | undefined = undefined,
-> extends BaseTokenType<T> {
+> extends LexerBaseToken<T> {
 	matches: TokenMatchFunc
 	push?: TPush | ((mode: string, tokens: Token[]) => TPush)
 	// categories?: TCategories
-	longerAlt?: $T
+	longerAlt?: $TType
 	skip?: boolean
 }
-export interface TokenCategoryType<
-	TC extends $C,
-	TTokens extends RealTokenType<$T, any>[] = RealTokenType<$T, any>[],
-> extends BaseTokenType<TC> {
+
+export interface LexerCategoryToken<
+	TC extends $CType,
+	TTokens extends LexerRealToken<$TType, any>[] = LexerRealToken<$TType, any>[],
+> extends LexerBaseToken<TC> {
 	isCategory: true
 	entries: Partial<Record<TTokens[number]["type"], TTokens[number]>>
 	// entries: Partial<Record<TTokens[number]["type"], TTokens[number]>>
 }
 
-export type TokenType<TC extends $C | $T> = TC extends $T
-? RealTokenType<TC, any>
-: TC extends $C
-? TokenCategoryType<TC>
+export type LexerToken<TC extends $CType | $TType> = TC extends $TType
+? LexerRealToken<TC, any>
+: TC extends $CType
+? LexerCategoryToken<TC>
 : never
 
-function createTokenCategoryType<T extends $C, TTokens extends RealTokenType<$T, any>>(
+function createLexerCategoryToken<T extends $CType, TTokens extends LexerRealToken<$TType, any>>(
 	type: T,
 	entries: (TTokens | undefined)[],
-): TokenCategoryType<T, TTokens[]> {
+): LexerCategoryToken<T, TTokens[]> {
 	return {
 		type,
 		isCategory: true,
@@ -125,12 +134,12 @@ function createTokenCategoryType<T extends $C, TTokens extends RealTokenType<$T,
 }
 
 function createTokenType<
-	T extends $T,
+	T extends $TType,
 	TPush extends string | undefined = undefined,
 >(
 	type: T,
-	opts: Omit<RealTokenType<T, TPush>, "type">,
-): RealTokenType<T, TPush > {
+	opts: Omit<LexerRealToken<T, TPush>, "type">,
+): LexerRealToken<T, TPush > {
 	return {
 		type,
 		...opts,
@@ -164,7 +173,7 @@ function matchSymbol(symbols: string[]): TokenMatchFunc {
 	}
 }
 
-export interface Token<T extends $T | $C = $T | $C> {
+export interface Token<T extends $TType | $CType = $TType | $CType> {
 	type: T
 	value: string
 	startOffset: number
@@ -175,11 +184,11 @@ export interface Token<T extends $T | $C = $T | $C> {
 export class Lexer {
 	symbols: SymbolInfo
 
-	$: {[key in $T]: RealTokenType<key, any> }
+	$: {[key in $TType]: LexerRealToken<key, any> }
 
 	$categories: ReturnType<Lexer["createTokens"]>["$categories"]
 
-	branches: {[key in keyof typeof MODE]?: TokenType<$T>[] }
+	branches: {[key in keyof typeof MODE]?: LexerToken<$TType>[] }
 
 	opts: FullParserOptions<any>
 
@@ -509,7 +518,7 @@ export class Lexer {
 			}),
 		}
 		const $categories = {
-			[$C.ANY]: createTokenCategoryType($C.ANY, [
+			[$C.ANY]: createLexerCategoryToken($C.ANY, [
 				$[$T.REGEX_START],
 				$[$T.REGEX_END],
 				$[$T.QUOTE_SINGLE],
@@ -532,39 +541,39 @@ export class Lexer {
 				$[$T.BRACKET_L],
 				$[$T.BRACKET_R],
 			] as const),
-			[$C.VALUE]: createTokenCategoryType($C.VALUE, [
+			[$C.VALUE]: createLexerCategoryToken($C.VALUE, [
 				$[$T.VALUE_UNQUOTED],
 				$[$T.VALUE_NOT_SINGLE],
 				$[$T.VALUE_NOT_DOUBLE],
 				$[$T.VALUE_NOT_BACKTICK],
 			] as const),
-			[$C.VALUE_FOR_SINGLE]: createTokenCategoryType($C.VALUE_FOR_SINGLE, [
+			[$C.VALUE_FOR_SINGLE]: createLexerCategoryToken($C.VALUE_FOR_SINGLE, [
 				$[$T.VALUE_NOT_SINGLE],
 			] as const),
-			[$C.VALUE_FOR_DOUBLE]: createTokenCategoryType($C.VALUE_FOR_DOUBLE, [
+			[$C.VALUE_FOR_DOUBLE]: createLexerCategoryToken($C.VALUE_FOR_DOUBLE, [
 				$[$T.VALUE_NOT_DOUBLE],
 			] as const),
-			[$C.VALUE_FOR_BACKTICK]: createTokenCategoryType($C.VALUE_FOR_BACKTICK, [
+			[$C.VALUE_FOR_BACKTICK]: createLexerCategoryToken($C.VALUE_FOR_BACKTICK, [
 				$[$T.VALUE_NOT_BACKTICK],
 			] as const),
-			[$C.REGEX_ANY]: createTokenCategoryType($C.REGEX_ANY, [
+			[$C.REGEX_ANY]: createLexerCategoryToken($C.REGEX_ANY, [
 				$[$T.REGEX_START],
 				$[$T.REGEX_END],
 			] as const),
-			[$C.QUOTE_ANY]: createTokenCategoryType($C.QUOTE_ANY, [
+			[$C.QUOTE_ANY]: createLexerCategoryToken($C.QUOTE_ANY, [
 				$[$T.QUOTE_SINGLE],
 				$[$T.QUOTE_DOUBLE],
 				$[$T.QUOTE_BACKTICK],
 			] as const),
-			[$C.OPERATOR_OR]: createTokenCategoryType($C.OPERATOR_OR, [
+			[$C.OPERATOR_OR]: createLexerCategoryToken($C.OPERATOR_OR, [
 				$[$T.SYM_OR],
 				$[$T.WORD_OR],
 			] as const),
-			[$C.OPERATOR_AND]: createTokenCategoryType($C.OPERATOR_AND, [
+			[$C.OPERATOR_AND]: createLexerCategoryToken($C.OPERATOR_AND, [
 				$[$T.SYM_AND],
 				$[$T.WORD_AND],
 			] as const),
-			[$C.OPERATOR_NOT]: createTokenCategoryType($C.OPERATOR_NOT, [
+			[$C.OPERATOR_NOT]: createLexerCategoryToken($C.OPERATOR_NOT, [
 				$[$T.SYM_NOT],
 				$[$T.WORD_NOT],
 			] as const),
@@ -572,7 +581,7 @@ export class Lexer {
 		return { $, $categories }
 	}
 
-	createModeBranches(): {[key in keyof typeof MODE]?: TokenType<$T>[] } {
+	createModeBranches(): {[key in keyof typeof MODE]?: LexerToken<$TType>[] } {
 		const opts = this.opts
 		const $ = this.$
 		const quotes = [
@@ -652,13 +661,13 @@ export class Lexer {
 	}
 	
 	
-	tokenize(input: string): Token<$T>[] {
+	tokenize(input: string): Token<$TType>[] {
 		const branches = this.createModeBranches()
-		const tokens: Token<$T>[] = []
+		const tokens: Token<$TType>[] = []
 		let mode = MODE.MAIN
 		let index = 0
 		let c = input[index]
-		let branch = branches[mode] as any as TokenType<$T>[]
+		let branch = branches[mode] as any as LexerToken<$TType>[]
 		while (index < input.length) {
 			for (const t of branch) {
 				let match = t.matches(c, input, index, mode)
@@ -694,7 +703,8 @@ export class Lexer {
 		return tokens
 	}
 }
-function createToken<T extends $T>(type: T, value: string, startOffset: number, endOffset: number): Token<T> {
+
+function createToken<T extends $TType>(type: T, value: string, startOffset: number, endOffset: number): Token<T> {
 	return {
 		type,
 		value,