@witchcraft/expressit 0.2.2 → 0.3.0

package/src/ast/error.ts

@@ -1,8 +1,8 @@
 import { createToken } from "./createToken.js"
 
-import { type ErrorToken,type TOKEN_TYPE } from "../types/ast.js"
+import { type ErrorToken,type TokenType } from "../types/ast.js"
 
-export function error<T extends TOKEN_TYPE>(pos: number, expected: T[]): ErrorToken {
+export function error<T extends TokenType>(pos: number, expected: T[]): ErrorToken {
 	if (pos === undefined) throw new Error("should never happen, passed undefined position for error token")
 	return createToken({ expected, start: pos, end: pos })
 }

package/src/ast/handlers.ts

@@ -7,28 +7,28 @@ import { createGroupNode } from "./createGroupNode.js"
 import { createToken } from "./createToken.js"
 import { createVariableNode } from "./createVariableNode.js"
 
-import { type AnyToken, type ArrayNode,AST_TYPE,type ConditionNode, type ErrorToken, type ExpressionNode,type FirstParam,type GroupNode, type Position, TOKEN_TYPE, type TokenBooleanTypes, type TokenDelimiterTypes, type TokenOperatorTypes, type TokenQuoteTypes, type ValidToken, type VariableNode } from "../types/ast.js"
+import { type AnyToken, type ArrayNode,AST_TYPE,type ConditionNode, type ErrorToken, type ExpressionNode,type FirstParam,type GroupNode, type Position, TOKEN_TYPE, type TokenBoolean, type TokenDelimiter, type TokenOperator, type TokenQuote, type TokenType, type ValidToken, type VariableNode } from "../types/ast.js"
 
 
 /* #region HELPERS */
-function error<T extends TOKEN_TYPE>(pos: number, expected: T[]): ErrorToken {
+function error<T extends TokenType>(pos: number, expected: T[]): ErrorToken {
 	if (pos === undefined) throw new Error("should never happen, passed undefined position for error token")
 	return createToken({ expected, start: pos, end: pos })
 }
 /* #regionend */
 
 /* #region TOKENS */
-const operators = <T extends TokenOperatorTypes>
+const operators = <T extends TokenOperator>
 (type: T) =>
 	(value: string, pos: Position): ValidToken<T> => createToken({ value, type, ...pos })
 
-const delimiters = <T extends TokenDelimiterTypes>
+const delimiters = <T extends TokenDelimiter>
 (type: T) =>
 	(value: string | undefined, pos: Position): ValidToken<T> | undefined =>
 		// check must be falsy, we want to return undefined when given ""
 		value ? createToken({ value, type, ...pos }) : undefined
 
-const maybeToken = <T extends TOKEN_TYPE> (type: T) => <TVal extends string | undefined> (value: TVal, pos: Position): TVal extends string ? ValidToken<T> : ErrorToken => {
+const maybeToken = <T extends TokenType> (type: T) => <TVal extends string | undefined> (value: TVal, pos: Position): TVal extends string ? ValidToken<T> : ErrorToken => {
 	if (value === undefined) {
 		return error(pos.end, [type]) as any
 	} else {
@@ -63,11 +63,11 @@ export const operator = {
 
 /* #region AST NODES */
 export function variable(
-	prefix: ValidToken<TOKEN_TYPE.VALUE> | null | undefined,
-	quoteL: AnyToken<TokenQuoteTypes> | null | undefined,
-	value: AnyToken<TOKEN_TYPE.VALUE> | null | undefined,
-	quoteR: AnyToken<TokenQuoteTypes> | null | undefined,
-	flags?: ValidToken<TOKEN_TYPE.VALUE>,
+	prefix: ValidToken<typeof TOKEN_TYPE.VALUE> | null | undefined,
+	quoteL: AnyToken<TokenQuote> | null | undefined,
+	value: AnyToken<typeof TOKEN_TYPE.VALUE> | null | undefined,
+	quoteR: AnyToken<TokenQuote> | null | undefined,
+	flags?: ValidToken<typeof TOKEN_TYPE.VALUE>,
 ): VariableNode {
 	const node: FirstParam<typeof createVariableNode> = {
 		prefix: prefix ?? undefined,
@@ -92,19 +92,19 @@ export function variable(
 
 
 export function condition(
-	not: ValidToken<TOKEN_TYPE.NOT> | null | undefined,
+	not: ValidToken<typeof TOKEN_TYPE.NOT> | null | undefined,
 	property: VariableNode | null | undefined,
 	{ propertyOperator, sepL, sepR }: {
 		propertyOperator?: ConditionNode["propertyOperator"] | null
-		sepL?: ValidToken<TOKEN_TYPE.OP_EXPANDED_SEP> | null
-		sepR?: ValidToken<TOKEN_TYPE.OP_EXPANDED_SEP> | null
+		sepL?: ValidToken<typeof TOKEN_TYPE.OP_EXPANDED_SEP> | null
+		sepR?: ValidToken<typeof TOKEN_TYPE.OP_EXPANDED_SEP> | null
 	} = {},
 	value?: VariableNode | GroupNode | ArrayNode | null,
 ): ConditionNode {
 	const start = (not?.start ?? property?.start ?? sepL?.start ?? propertyOperator?.start ?? sepR?.start ?? value?.start)!
 	const end = (value?.end ?? sepR?.end ?? propertyOperator?.end ?? sepL?.end ?? property?.end ?? not?.end)!
 	const node: FirstParam<typeof createConditionNode> = {
-		value: value ? value : error(end, [TOKEN_TYPE.VALUE]),
+		value: value ?? error(end, [TOKEN_TYPE.VALUE]),
 		start,
 		end,
 	}
@@ -130,7 +130,7 @@ export function condition(
 
 export function expression(
 	left: ConditionNode | GroupNode | null | undefined,
-	operator: ValidToken<TokenBooleanTypes> | null | undefined,
+	operator: ValidToken<TokenBoolean> | null | undefined,
 	right: ConditionNode | GroupNode | null | undefined,
 ): ExpressionNode {
 	return createExpressionNode({
@@ -143,11 +143,11 @@ export function expression(
 }
 
 export function group(
-	operator: ValidToken<TOKEN_TYPE.NOT> | null | undefined,
+	operator: ValidToken<typeof TOKEN_TYPE.NOT> | null | undefined,
 	prefix: ConditionNode | null | undefined,
-	parenL: ValidToken<TOKEN_TYPE.PARENL> | null | undefined,
+	parenL: ValidToken<typeof TOKEN_TYPE.PARENL> | null | undefined,
 	condition: GroupNode["expression"],
-	parenR: ValidToken<TOKEN_TYPE.PARENR> | null | undefined,
+	parenR: ValidToken<typeof TOKEN_TYPE.PARENR> | null | undefined,
 ): GroupNode {
 	return createGroupNode({
 		prefix: prefix ?? operator ?? undefined,
@@ -162,9 +162,9 @@ export function group(
 }
 
 export function array(
-	bracketL: ValidToken<TOKEN_TYPE.BRACKETL>,
+	bracketL: ValidToken<typeof TOKEN_TYPE.BRACKETL>,
 	values: VariableNode[],
-	bracketR: ValidToken<TOKEN_TYPE.BRACKETR> | null | undefined,
+	bracketR: ValidToken<typeof TOKEN_TYPE.BRACKETR> | null | undefined,
 ): ArrayNode {
 	return createArrayNode({
 		values,

package/src/examples/ParserWithSqlSupport.ts

@@ -29,7 +29,7 @@ export interface BaseOperatorDefinition {
 	/** How to compare the value when evualuating a condition. This is only used if using `evaluate`. */
 	valueComparer: (condition: any, contextValue: any) => boolean
 }
-export type BaseErrorTokenTypes =
+export type SqlParserError =
 	| "invalidKey"
 	| "unknownProperty"
 	| "unknownOperator"
@@ -53,11 +53,11 @@ export type BaseErrorTokenTypes =
  */
 export class ParserWithSqlSupport<TErrorToken extends
 	Position & {
-		type: BaseErrorTokenTypes
+		type: SqlParserError
 		message?: string
 	} =
 	Position & {
-		type: BaseErrorTokenTypes
+		type: SqlParserError
 		message?: string
 	},
 	TPropertyDefinition extends BasePropertyDefinition = BasePropertyDefinition,
@@ -70,9 +70,13 @@ export class ParserWithSqlSupport<TErrorToken extends
 
 	operatorMap: Record<string, string>
 
+	propertyDefinitions: TPropertyDefinitions
+
+	operatorDefinitions: TOperatorDefinitions
+
 	constructor(
-		public propertyDefinitions: TPropertyDefinitions,
-		public operatorDefinitions: TOperatorDefinitions,
+		propertyDefinitions: TPropertyDefinitions,
+		operatorDefinitions: TOperatorDefinitions,
 		{ sqlEscapeValue }: { sqlEscapeValue: TSqlEscapeValue }
 	) {
 		const operators = []
@@ -229,6 +233,8 @@ export class ParserWithSqlSupport<TErrorToken extends
 				return { value: finalValue, operator: finalOperator, negate: isNegated }
 			},
 		})
+		this.propertyDefinitions = propertyDefinitions
+		this.operatorDefinitions = operatorDefinitions
 		this.operatorMap = operatorMap
 		this.sqlEscapeValue = sqlEscapeValue
 	}

package/src/internal/ExpressitError.ts

@@ -3,12 +3,12 @@ import { indent } from "@alanscodelog/utils/indent.js"
 import { pretty } from "@alanscodelog/utils/pretty.js"
 import type { Keys } from "@alanscodelog/utils/types"
 
-import packageJson from "../../package.json" assert { type: "json" }
+import packageJson from "../../package.json" with { type: "json" }
 const { version, repository } = packageJson
-import type { ERROR_CODES, ErrorInfo } from "../types/errors.js"
+import type { ErrorInfo, ParserError } from "../types/errors.js"
 
 /** @internal */
-export class ExpressitError<T extends ERROR_CODES> extends Error {
+export class ExpressitError<T extends ParserError> extends Error {
 	version: string = version
 
 	repo: string = repository

package/src/internal/checkParserOpts.ts

@@ -5,7 +5,7 @@ import { ExpressitError } from "./ExpressitError.js"
 
 import { defaultConditionNormalizer } from "../defaults/defaultConditionNormalizer.js"
 import { defaultValueComparer } from "../defaults/defaultValueComparer.js"
-import { ERROR_CODES } from "../types/errors.js"
+import { PARSER_ERROR } from "../types/errors.js"
 import type { FullParserOptions, ParserOptions } from "../types/parser.js"
 
 /** @internal */
@@ -27,7 +27,7 @@ export function checkParserOpts<T>(opts: FullParserOptions<T>, evaluatorChecks:
 		/* #region Blank Operator Checks */
 		if (opts.expandedPropertySeparator && isBlank(opts.expandedPropertySeparator)) {
 			throw new ExpressitError(
-				ERROR_CODES.PARSER_CONFLICTING_OPTIONS_ERROR,
+				PARSER_ERROR.CONFLICTING_OPTIONS_ERROR,
 				{ prohibited: [""], invalid: opts.expandedPropertySeparator },
 			`expandedPropertySeparator cannot be blank`,
 			)
@@ -35,7 +35,7 @@ export function checkParserOpts<T>(opts: FullParserOptions<T>, evaluatorChecks:
 		const customInvalid = opts.customPropertyOperators?.find(_ => isBlank(_))
 		if (customInvalid !== undefined) {
 			throw new ExpressitError(
-				ERROR_CODES.PARSER_CONFLICTING_OPTIONS_ERROR,
+				PARSER_ERROR.CONFLICTING_OPTIONS_ERROR,
 				{ prohibited: [""], invalid: customInvalid },
 			`customPropertyOperators cannot contain blank entries`,
 			)
@@ -43,7 +43,7 @@ export function checkParserOpts<T>(opts: FullParserOptions<T>, evaluatorChecks:
 		const prefixInvalid = opts.prefixableStrings?.find(_ => isBlank(_))
 		if (prefixInvalid !== undefined) {
 			throw new ExpressitError(
-				ERROR_CODES.PARSER_CONFLICTING_OPTIONS_ERROR,
+				PARSER_ERROR.CONFLICTING_OPTIONS_ERROR,
 				{ prohibited: [""], invalid: prefixInvalid },
 			`prefixableStrings cannot contain blank entries`,
 			)
@@ -54,7 +54,7 @@ export function checkParserOpts<T>(opts: FullParserOptions<T>, evaluatorChecks:
 				?.value
 			if (invalid !== undefined) {
 				throw new ExpressitError(
-					ERROR_CODES.PARSER_CONFLICTING_OPTIONS_ERROR,
+					PARSER_ERROR.CONFLICTING_OPTIONS_ERROR,
 					{ prohibited: [""], invalid },
 				`keywords.${key} cannot contain entries with blank values`,
 				)
@@ -77,7 +77,7 @@ export function checkParserOpts<T>(opts: FullParserOptions<T>, evaluatorChecks:
 		const invalidPrefixableString = opts.prefixableStrings?.find(val => all.includes(val))
 		if (invalidPrefixableString) {
 			throw new ExpressitError(
-				ERROR_CODES.PARSER_CONFLICTING_OPTIONS_ERROR,
+				PARSER_ERROR.CONFLICTING_OPTIONS_ERROR,
 				{ prohibited: all, invalid: invalidPrefixableString },
 			`prefixableStrings ${messageInvalidAny} "${invalidPrefixableString}"`,
 			)
@@ -87,7 +87,7 @@ export function checkParserOpts<T>(opts: FullParserOptions<T>, evaluatorChecks:
 			.find(_ => _ === opts.expandedPropertySeparator as any)
 		if (invalidExpandedPropertySeparator) {
 			throw new ExpressitError(
-				ERROR_CODES.PARSER_CONFLICTING_OPTIONS_ERROR,
+				PARSER_ERROR.CONFLICTING_OPTIONS_ERROR,
 				{ prohibited: allKeywords, invalid: invalidExpandedPropertySeparator },
 			`expandedPropertySeparator ${messageInvalidBool} "${invalidExpandedPropertySeparator}"`,
 			)
@@ -98,7 +98,7 @@ export function checkParserOpts<T>(opts: FullParserOptions<T>, evaluatorChecks:
 		: undefined
 		if (invalidCustomPropertyOperator) {
 			throw new ExpressitError(
-				ERROR_CODES.PARSER_CONFLICTING_OPTIONS_ERROR,
+				PARSER_ERROR.CONFLICTING_OPTIONS_ERROR,
 				{ prohibited: keywords, invalid: invalidCustomPropertyOperator },
 			`customPropertyOperator ${messageInvalidBool} "${invalidCustomPropertyOperator}"`,
 			)
@@ -115,7 +115,7 @@ export function checkParserOpts<T>(opts: FullParserOptions<T>, evaluatorChecks:
 
 		if (requireCustomNormalizer.length > 0 && opts.conditionNormalizer === defaultConditionNormalizer) {
 			throw new ExpressitError(
-				ERROR_CODES.PARSER_OPTION_REQUIRED_ERROR,
+				PARSER_ERROR.OPTION_REQUIRED_ERROR,
 				{ options: requireCustomNormalizer, requires: "conditionNormalizer" },
 				`A custom conditionNormalizer function must be specified when using the following options: ${requireCustomNormalizer.join(", ")}`,
 			)
@@ -126,7 +126,7 @@ export function checkParserOpts<T>(opts: FullParserOptions<T>, evaluatorChecks:
 
 		if (requireCustomComparer.length > 0 && opts.valueComparer === defaultValueComparer) {
 			throw new ExpressitError(
-				ERROR_CODES.PARSER_OPTION_REQUIRED_ERROR,
+				PARSER_ERROR.OPTION_REQUIRED_ERROR,
 				{ options: requireCustomComparer, requires: "valueComparer" },
 					`A custom valueComparer function must be specified when using the following options: ${requireCustomComparer.join(", ")}`,
 			)
@@ -135,7 +135,7 @@ export function checkParserOpts<T>(opts: FullParserOptions<T>, evaluatorChecks:
 	if (validatorChecks) {
 		if (opts.valueValidator === undefined) {
 			throw new ExpressitError(
-				ERROR_CODES.PARSER_OPTION_REQUIRED_ERROR,
+				PARSER_ERROR.OPTION_REQUIRED_ERROR,
 				{ requires: "valueValidator" },
 				`A custom valueValidator function must be specified when using the validate method.`,
 			)

package/src/types/ast.ts

@@ -1,94 +1,97 @@
-import type { AnyFunction } from "@alanscodelog/utils/types"
+import { enumFromArray } from "@alanscodelog/utils/enumFromArray.js"
+import type { AnyFunction, EnumLike } from "@alanscodelog/utils/types"
 
 
 export type AddParameters<T extends AnyFunction, TExtra extends any[] = [boolean]> = (...args: [...Parameters<T>, ...TExtra]) => ReturnType<T>
 
-export enum TOKEN_TYPE {
-	VALUE = "VALUE",
-	AND = "AND",
-	OR = "OR",
-	NOT = "NOT",
-	BACKTICK = "BACKTICK",
-	SINGLEQUOTE = "SINGLEQUOTE",
-	DOUBLEQUOTE = "DOUBLEQUOTE",
-	PARENL = "PARENL",
-	PARENR = "PARENR",
-	BRACKETL = "BRACKETL",
-	BRACKETR = "BRACKETR",
-	OP_EXPANDED_SEP = "OP_EXPANDED",
-	OP_CUSTOM = "OP_CUSTOM",
-	REGEX = "REGEX",
-}
+export const TOKEN_TYPE = enumFromArray([
+	"VALUE",
+	"AND",
+	"OR",
+	"NOT",
+	"BACKTICK",
+	"SINGLEQUOTE",
+	"DOUBLEQUOTE",
+	"PARENL",
+	"PARENR",
+	"BRACKETL",
+	"BRACKETR",
+	"OP_EXPANDED_SEP",
+	"OP_CUSTOM",
+	"REGEX",
+])
+
+export type TokenType = EnumLike<typeof TOKEN_TYPE>
 
 /**
  * @internal
  * Note if the negation operator, `!`, is used as a propertyOperator, this will return the wrong type.
  */
-export type ExtractTokenType<T extends string> =
+export type ExtractToken<T extends string> =
 	T extends "`"
-	? TOKEN_TYPE.BACKTICK
+	? typeof TOKEN_TYPE.BACKTICK
 	: T extends `'`
-	? TOKEN_TYPE.SINGLEQUOTE
+	? typeof TOKEN_TYPE.SINGLEQUOTE
 	: T extends `"`
-	? TOKEN_TYPE.DOUBLEQUOTE
+	? typeof TOKEN_TYPE.DOUBLEQUOTE
 	: T extends `/`
-	? TOKEN_TYPE.REGEX
+	? typeof TOKEN_TYPE.REGEX
 	: T extends `(`
-	? TOKEN_TYPE.PARENL
+	? typeof TOKEN_TYPE.PARENL
 	: T extends `)`
-	? TOKEN_TYPE.PARENR
+	? typeof TOKEN_TYPE.PARENR
 	: T extends `[`
-	? TOKEN_TYPE.BRACKETL
+	? typeof TOKEN_TYPE.BRACKETL
 	: T extends `]`
-	? TOKEN_TYPE.BRACKETR
+	? typeof TOKEN_TYPE.BRACKETR
 	: T extends `and`
-	? TOKEN_TYPE.AND
+	? typeof TOKEN_TYPE.AND
 	: T extends `&&`
-	? TOKEN_TYPE.AND
+	? typeof TOKEN_TYPE.AND
 	: T extends `&`
-	? TOKEN_TYPE.AND
+	? typeof TOKEN_TYPE.AND
 	: T extends `or`
-	? TOKEN_TYPE.OR
+	? typeof TOKEN_TYPE.OR
 	: T extends `||`
-	? TOKEN_TYPE.OR
+	? typeof TOKEN_TYPE.OR
 	: T extends `|`
-	? TOKEN_TYPE.OR
+	? typeof TOKEN_TYPE.OR
 	: T extends `not`
-	? TOKEN_TYPE.NOT
+	? typeof TOKEN_TYPE.NOT
 	: T extends `!`
-	? TOKEN_TYPE.NOT
-	: TOKEN_TYPE.VALUE
+	? typeof TOKEN_TYPE.NOT
+	: typeof TOKEN_TYPE.VALUE
 
-export type TokenParenTypes =
-	| TOKEN_TYPE.PARENL
-	| TOKEN_TYPE.PARENR
+export type TokenParen =
+	| typeof TOKEN_TYPE.PARENL
+	| typeof TOKEN_TYPE.PARENR
 export type TokenBracketTypes =
-	| TOKEN_TYPE.BRACKETL
-	| TOKEN_TYPE.BRACKETR
+	| typeof TOKEN_TYPE.BRACKETL
+	| typeof TOKEN_TYPE.BRACKETR
 
-export type TokenDelimiterTypes =
-	| TokenParenTypes
-	| TokenQuoteTypes
+export type TokenDelimiter =
+	| TokenParen
+	| TokenQuote
 	| TokenBracketTypes
-	| TOKEN_TYPE.OP_EXPANDED_SEP
+	| typeof TOKEN_TYPE.OP_EXPANDED_SEP
 
-export type TokenQuoteTypes =
-	| TOKEN_TYPE.BACKTICK
-	| TOKEN_TYPE.SINGLEQUOTE
-	| TOKEN_TYPE.DOUBLEQUOTE
-	| TOKEN_TYPE.REGEX
+export type TokenQuote =
+	| typeof TOKEN_TYPE.BACKTICK
+	| typeof TOKEN_TYPE.SINGLEQUOTE
+	| typeof TOKEN_TYPE.DOUBLEQUOTE
+	| typeof TOKEN_TYPE.REGEX
 
-export type TokenBooleanTypes =
-	| TOKEN_TYPE.AND
-	| TOKEN_TYPE.OR
+export type TokenBoolean =
+	| typeof TOKEN_TYPE.AND
+	| typeof TOKEN_TYPE.OR
 
-export type TokenOperatorTypes =
-	| TokenBooleanTypes
-	| TOKEN_TYPE.NOT
+export type TokenOperator =
+	| TokenBoolean
+	| typeof TOKEN_TYPE.NOT
 
-export type TokenPropertyOperatorTypes =
-	| TOKEN_TYPE.OP_CUSTOM
-	| TOKEN_TYPE.OP_EXPANDED_SEP
+export type TokenPropertyOperator =
+	| typeof TOKEN_TYPE.OP_CUSTOM
+	| typeof TOKEN_TYPE.OP_EXPANDED_SEP
 
 
 // export type EmptyObj = Record<"start"|"end", undefined>
@@ -101,16 +104,18 @@ export type Position = {
 	end: number
 }
 
-export enum AST_TYPE {
-	EXPRESSION = "EXPRESSION",
-	NORMALIZED_EXPRESSION = "NORMALIZED_EXPRESSION",
-	GROUP = "GROUP",
-	ARRAY = "ARRAY",
-	CONDITION = "CONDITION",
-	NORMALIZED_CONDITION = "NORMALIZED_CONDITION",
-	VARIABLE = "VARIABLE",
-}
+export const AST_TYPE = enumFromArray([
+	"EXPRESSION",
+	"NORMALIZED_EXPRESSION",
+	"GROUP",
+	"ARRAY",
+	"CONDITION",
+	"NORMALIZED_CONDITION",
+	"VARIABLE",
+])
+
 // #region AST nodes
+export type AstType = EnumLike<typeof AST_TYPE>
 
 
 export type RawNode<T extends Node> = Omit<T, "valid" | "type" | "isNode">
@@ -130,7 +135,7 @@ export interface BaseToken {
 /**
  * Valid tokens always have a value, even if it might be an empty string.
  */
-export interface ValidToken<TType extends TOKEN_TYPE = TOKEN_TYPE> extends BaseToken {
+export interface ValidToken<TType extends TokenType = TokenType> extends BaseToken {
 	valid: true
 	type: TType
 	value: string
@@ -150,7 +155,7 @@ export interface ErrorToken extends BaseToken {
 	type?: undefined
 	value?: undefined
 	valid: false
-	expected: TOKEN_TYPE[]
+	expected: TokenType[]
 }
 
 /**
@@ -159,7 +164,7 @@ export interface ErrorToken extends BaseToken {
  * Using {@link Token} does not work well in certain situations and is also more complex because it has so many generics.
  */
 export type AnyToken<
-	TType extends TOKEN_TYPE = TOKEN_TYPE,
+	TType extends TokenType = TokenType,
 > =
 	| ValidToken<TType>
 	| ErrorToken
@@ -175,7 +180,7 @@ export type ParserResults = ExpressionNode | ConditionNode | GroupNode | ErrorTo
  */
 
 export interface Node<
-	TType extends AST_TYPE = AST_TYPE,
+	TType extends AstType = AstType,
 	TValid extends boolean = boolean,
 > {
 	isNode: true
@@ -222,16 +227,16 @@ export interface GroupNode<
 	TPrefix extends
 		TPrefixable extends true
 			? ConditionNode<TValid> |
-			ValidToken<TOKEN_TYPE.NOT> |
+			ValidToken<typeof TOKEN_TYPE.NOT> |
 			undefined
-			: ValidToken<TOKEN_TYPE.NOT> |
+			: ValidToken<typeof TOKEN_TYPE.NOT> |
 			undefined =
 		TPrefixable extends true
 			? ConditionNode<TValid> |
-			ValidToken<TOKEN_TYPE.NOT> |
+			ValidToken<typeof TOKEN_TYPE.NOT> |
 			undefined
-			: ValidToken<TOKEN_TYPE.NOT>,
-> extends Node<AST_TYPE.GROUP> {
+			: ValidToken<typeof TOKEN_TYPE.NOT>,
+> extends Node<typeof AST_TYPE.GROUP> {
 	/**
 	 * If the condition is negated this will contain a "not" **token**, {@link ValidToken} .
 	 *
@@ -250,7 +255,7 @@ export interface GroupNode<
 	/**
 	 * The parenthesis tokens, {@link ValidToken} . These will always be defined (although not necessarily with valid tokens).
 	 */
-	paren: NodeDelimiters<TOKEN_TYPE.PARENL, TOKEN_TYPE.PARENR>
+	paren: NodeDelimiters<typeof TOKEN_TYPE.PARENL, typeof TOKEN_TYPE.PARENR>
 }
 
 
@@ -266,18 +271,18 @@ export interface GroupNode<
  * If `prefixableStrings` is true, the `prefix` property might contain a value token.
  */
 
-export interface VariableNode<TValid extends boolean = boolean> extends Node<AST_TYPE.VARIABLE, TValid> {
+export interface VariableNode<TValid extends boolean = boolean> extends Node<typeof AST_TYPE.VARIABLE, TValid> {
 	value: TValid extends boolean
-		? AnyToken<TOKEN_TYPE.VALUE>
+		? AnyToken<typeof TOKEN_TYPE.VALUE>
 		: TValid extends true
-		? ValidToken<TOKEN_TYPE.VALUE>
+		? ValidToken<typeof TOKEN_TYPE.VALUE>
 	: ErrorToken
-	prefix?: ValidToken<TOKEN_TYPE.VALUE> // todo
-	quote?: NodeDelimiters<TokenQuoteTypes, TokenQuoteTypes>
+	prefix?: ValidToken<typeof TOKEN_TYPE.VALUE> // todo
+	quote?: NodeDelimiters<TokenQuote, TokenQuote>
 }
 
-export interface ExpressionNode<TValid extends boolean = boolean> extends Node<AST_TYPE.EXPRESSION> {
-	operator: AnyToken<TokenBooleanTypes>
+export interface ExpressionNode<TValid extends boolean = boolean> extends Node<typeof AST_TYPE.EXPRESSION> {
+	operator: AnyToken<TokenBoolean>
 	left:
 	| ExpressionNode<TValid>
 	| ConditionNode<TValid>
@@ -298,17 +303,17 @@ export type Nodes = ExpressionNode | ConditionNode | GroupNode | VariableNode |
  *
  * These are usually not important for evaluating an expression but are useful for syntax highlighting.
  */
-export type NodeDelimiters<TLEFT extends TOKEN_TYPE, TRIGHT extends TOKEN_TYPE = TLEFT> = {
+export type NodeDelimiters<TLEFT extends TokenType, TRIGHT extends TokenType = TLEFT> = {
 	left: AnyToken<TLEFT>
 	right: AnyToken<TRIGHT>
 	/** Only exists if regexes are enabled and this is a regex value. */
-	flags?: ValidToken<TOKEN_TYPE.VALUE>
+	flags?: ValidToken<typeof TOKEN_TYPE.VALUE>
 }
 
 
-export interface ArrayNode<TValid extends boolean = boolean> extends Node<AST_TYPE.ARRAY> {
+export interface ArrayNode<TValid extends boolean = boolean> extends Node<typeof AST_TYPE.ARRAY> {
 	values: VariableNode[]
-	bracket: NodeDelimiters<TOKEN_TYPE.BRACKETL, TOKEN_TYPE.BRACKETR>
+	bracket: NodeDelimiters<typeof TOKEN_TYPE.BRACKETL, typeof TOKEN_TYPE.BRACKETR>
 	valid: TValid
 }
 
@@ -321,7 +326,7 @@ export interface ArrayNode<TValid extends boolean = boolean> extends Node<AST_TY
  */
 export interface ConditionNode<
 	TValid extends boolean = boolean,
-> extends Node<AST_TYPE.CONDITION> {
+> extends Node<typeof AST_TYPE.CONDITION> {
 	/**
 	 * Contains a value node which could be a variable, an array node (if enabled), or a group.
 	 *
@@ -337,7 +342,7 @@ export interface ConditionNode<
 	/**
 	 * If the condition was negated, contains the "not" token, {@link ValidToken} , the condition was negated with.
 	 */
-	operator?: ValidToken<TOKEN_TYPE.NOT>
+	operator?: ValidToken<typeof TOKEN_TYPE.NOT>
 	/**
 	 * If condition property operators are used, this will contain the property (as a variable), or an error token if it was missing (but some separator or operator was passed).
 	 *
@@ -355,7 +360,7 @@ export interface ConditionNode<
 	 *
 	 * See the corresponding {@link ParserOptions} for more details.
 	 */
-	propertyOperator?: AnyToken<TOKEN_TYPE.OP_CUSTOM | TOKEN_TYPE.VALUE>
+	propertyOperator?: AnyToken<typeof TOKEN_TYPE.OP_CUSTOM | typeof TOKEN_TYPE.VALUE>
 	/**
 	 * If "long/expanded" form condition property operators are used, this will contain the separators, otherwise it is undefined.
 	 *
@@ -368,8 +373,8 @@ export interface ConditionNode<
 	 * See the corresponding {@link ParserOptions} for more details.
 	 */
 	sep?: {
-		left?: AnyToken<TOKEN_TYPE.OP_EXPANDED_SEP>
-		right?: AnyToken<TOKEN_TYPE.OP_EXPANDED_SEP>
+		left?: AnyToken<typeof TOKEN_TYPE.OP_EXPANDED_SEP>
+		right?: AnyToken<typeof TOKEN_TYPE.OP_EXPANDED_SEP>
 	}
 }
 
@@ -377,7 +382,7 @@ export interface NormalizedCondition<
 	TOp extends string = string,
 	TValue = any,
 > {
-	type: AST_TYPE.NORMALIZED_CONDITION
+	type: typeof AST_TYPE.NORMALIZED_CONDITION
 	value: TValue
 	operator?: TOp
 	property: string[]
@@ -386,14 +391,14 @@ export interface NormalizedCondition<
 
 
 export interface NormalizedExpression<TType extends string = string, TValue = any> {
-	type: AST_TYPE.NORMALIZED_EXPRESSION
+	type: typeof AST_TYPE.NORMALIZED_EXPRESSION
 	left:
 	| NormalizedExpression<TType, TValue>
 	| NormalizedCondition<TType, TValue>
 	right:
 	| NormalizedExpression<TType, TValue>
 	| NormalizedCondition<TType, TValue>
-	operator: TokenBooleanTypes
+	operator: TokenBoolean
 }
 
 export type ParentTypes<T extends Node | BaseToken | undefined> =