@witchcraft/expressit 0.2.1 → 0.3.0

package/src/Parser.ts

@@ -19,9 +19,9 @@ import { extractPosition } from "./internal/extractPosition.js"
 import { getUnclosedRightParenCount } from "./internal/getUnclosedRightParenCount.js"
 import { parseParserOptions } from "./internal/parseParserOptions.js"
 import { unescape } from "./internal/unescape.js"
-import { $C, $T, Lexer,type RealTokenType, type Token, type TokenCategoryType, type TokenType } from "./Lexer.js"
-import type { ArrayNode, ConditionNode, GroupNode, NormalizedCondition, NormalizedExpression, ParserResults, TokenBooleanTypes, ValidToken, VariableNode, } from "./types/ast.js"
-import { type AnyToken, AST_TYPE,type Completion, type Position, type Suggestion,SUGGESTION_TYPE, TOKEN_TYPE } from "./types/index.js"
+import { $C, type $CType, $T, type $TType, Lexer, type LexerCategoryToken, type LexerRealToken, type LexerToken,type Token } from "./Lexer.js"
+import type { ArrayNode, ConditionNode, GroupNode, NormalizedCondition, NormalizedExpression, ParserResults, TokenBoolean, TokenType, ValidToken, VariableNode } from "./types/ast.js"
+import { type AnyToken, AST_TYPE, type Completion, type Position, type Suggestion, SUGGESTION_TYPE, type SuggestionType,TOKEN_TYPE } from "./types/index.js"
 import type { FullParserOptions, KeywordEntry, ParserOptions, ValidationQuery, ValueQuery } from "./types/parser.js"
 import { extractTokens } from "./utils/extractTokens.js"
 import { generateParentsMap } from "./utils/generateParentsMap.js"
@@ -52,7 +52,7 @@ const defaultNodeDirs = {
 const createDefaultRequires = (partial: DeepPartial<Suggestion["requires"]> = {}): Suggestion["requires"] => ({
 	whitespace: {
 		...defaultNodeDirs,
-		...(partial.whitespace ? partial.whitespace : {}),
+		...(partial.whitespace ?? {}),
 	},
 	group: partial.group ?? false,
 	prefix: partial.prefix ?? false,
@@ -62,7 +62,7 @@ const createDefaultRequires = (partial: DeepPartial<Suggestion["requires"]> = {}
 const tokenRequiresWhitespace = (valid: ValidToken | undefined, whitespace: boolean, wordOps: KeywordEntry[]): boolean => {
 	if (whitespace || valid === undefined) return false
 	return valid.type === TOKEN_TYPE.VALUE ||
-		([TOKEN_TYPE.AND, TOKEN_TYPE.OR, TOKEN_TYPE.NOT].includes(valid.type) &&
+		(([TOKEN_TYPE.AND, TOKEN_TYPE.OR, TOKEN_TYPE.NOT] as string[]).includes(valid.type) &&
 			wordOps.find(_ => _.value === valid.value) !== undefined)
 }
 const tokenVariable = [TOKEN_TYPE.BACKTICK, TOKEN_TYPE.DOUBLEQUOTE, TOKEN_TYPE.SINGLEQUOTE, TOKEN_TYPE.VALUE, TOKEN_TYPE.REGEX]
@@ -70,7 +70,7 @@ const tokenVariable = [TOKEN_TYPE.BACKTICK, TOKEN_TYPE.DOUBLEQUOTE, TOKEN_TYPE.S
 /**
  * Creates the main parser class which handles all functionality (evaluation, validation, etc).
  */
-export class Parser<T extends {} = {}> {
+export class Parser<T = any> {
 	// needed for evaluate and validate so they are only checked on demand
 	private evaluationOptionsChecked: boolean = false
 
@@ -96,9 +96,9 @@ export class Parser<T extends {} = {}> {
 
 	private readonly lexer: Lexer
 
-	private readonly $: Record<$T, RealTokenType<$T>>
+	private readonly $: Record<$TType, LexerRealToken<$TType>>
 
-	private readonly $categories: Partial<Record<$C, TokenCategoryType<$C>>>
+	private readonly $categories: Partial<Record<$CType, LexerCategoryToken<$CType>>>
 
 	private readonly info: Pick<ReturnType<Lexer["calculateSymbolInfo"]>, "expandedSepAlsoCustom" | "customOpAlsoNegation">
 
@@ -117,7 +117,7 @@ export class Parser<T extends {} = {}> {
 
 	state: {
 		rawInput: string
-		lexedTokens: Token<$T>[]
+		lexedTokens: Token<$TType>[]
 		index: number
 		shift: number
 	} = {
@@ -131,7 +131,7 @@ export class Parser<T extends {} = {}> {
 	 * This is exposed mainly for debugging purposes. Use parse directly instead.
 	 */
 	lex(input: string): {
-		tokens: Token<$T> []
+		tokens: Token<$TType> []
 		shift: number
 		rawInput: string
 	} {
@@ -168,7 +168,7 @@ export class Parser<T extends {} = {}> {
 	parse(
 		input: string
 		| {
-			tokens: Token<$T> []
+			tokens: Token<$TType> []
 			shift: number
 			rawInput: string
 		},
@@ -206,9 +206,9 @@ export class Parser<T extends {} = {}> {
 	}
 	
 	
-	transformCategoryToken<TC extends $C>(
+	transformCategoryToken<TC extends $CType>(
 		token: Token,
-		categoryToken: TokenCategoryType<TC>,
+		categoryToken: LexerCategoryToken<TC>,
 	): Token<TC> {
 		return {
 			...token,
@@ -216,37 +216,37 @@ export class Parser<T extends {} = {}> {
 		}
 	}
 
-	getCategoryTokens<TType extends $C>(
+	getCategoryTokens<TType extends $CType>(
 		type: TType,
-	): TokenCategoryType<TType>["entries"] | undefined {
-		return this.$categories[type as $C]?.entries as any
+	): LexerCategoryToken<TType>["entries"] | undefined {
+		return this.$categories[type as $CType]?.entries as any
 	}
 
-	getTokenType(type: $T | $C): TokenType<$T> | undefined {
-		return this.$[type as any as $T] as any
+	getTokenType(type: $TType | $CType): LexerToken<$TType> | undefined {
+		return this.$[type as any as $TType] as any
 	}
 
-	isExactType<TType extends $T>(token: Token, type: TType): token is Token<TType> {
+	isExactType<TType extends $TType>(token: Token, type: TType): token is Token<TType> {
 		if (this.$[type]) {
 			return this.isType(token, type)
 		}
 		return false
 	}
 
-	isType(token: Token | undefined, type: $T | $C): boolean {
+	isType(token: Token | undefined, type: $TType | $CType): boolean {
 		if (token === undefined) return false
 		if (token.type === type) return true
 		const tokenType = this.getTokenType(token.type)
 		
 		if (tokenType?.type === type) return true
-		const category = this.$categories[type as $C]
-		if (category?.entries[token.type as $T] !== undefined) {
+		const category = this.$categories[type as $CType]
+		if (category?.entries[token.type as $TType] !== undefined) {
 			return true
 		}
 		return false
 	}
 
-	createErrorToken(type: $T, index?: number): Token {
+	createErrorToken(type: $TType, index?: number): Token {
 		return {
 			type,
 			value: "",
@@ -265,7 +265,7 @@ export class Parser<T extends {} = {}> {
 	}
 	
 
-	peek(n = 1): Token<$T> | undefined {
+	peek(n = 1): Token<$TType> | undefined {
 		return this.state.lexedTokens[this.state.index + n]
 	}
 
@@ -273,12 +273,12 @@ export class Parser<T extends {} = {}> {
 		return this.peek(1) === undefined
 	}
 
-	consumeAny(): Token<$T> {
+	consumeAny(): Token<$TType> {
 		return this.consume(this.peek(1)?.type)
 	}
 
 	consume<
-		TType extends $T | $C,
+		TType extends $TType | $CType,
 	>(
 		type: TType | undefined,
 	): Token<TType> {
@@ -289,9 +289,9 @@ export class Parser<T extends {} = {}> {
 		if (nextToken === undefined) {
 			throw new Error(`Reached end of input without consuming a token of type ${type}`)
 		}
-		if (this.$categories[type as $C] !== undefined) {
-			const categoryToken = this.$categories[type as $C]
-			const tokenType = categoryToken?.entries[nextToken.type as $T]
+		if (this.$categories[type as $CType] !== undefined) {
+			const categoryToken = this.$categories[type as $CType]
+			const tokenType = categoryToken?.entries[nextToken.type as $TType]
 			if (categoryToken && tokenType) {
 				this.state.index++
 				return this.transformCategoryToken(nextToken, categoryToken) as Token<TType>
@@ -299,7 +299,7 @@ export class Parser<T extends {} = {}> {
 				throw new Error("here")
 			}
 		} else {
-			const tokenType = this.getTokenType(type as $T)
+			const tokenType = this.getTokenType(type as $TType)
 			if (tokenType !== undefined) {
 				if (nextToken?.type === tokenType.type) {
 					this.state.index++
@@ -554,9 +554,9 @@ export class Parser<T extends {} = {}> {
 		{ onlyValues = false, convertRegexValues = false, convertArrayValues = false }:
 		{ onlyValues?: boolean, convertRegexValues?: boolean, convertArrayValues?: boolean } = {},
 	): [
-			ValidToken<TOKEN_TYPE.PARENL> | undefined,
+			ValidToken<typeof TOKEN_TYPE.PARENL> | undefined,
 			GroupNode["expression"],
-		ValidToken<TOKEN_TYPE.PARENR> | undefined,
+		ValidToken<typeof TOKEN_TYPE.PARENR> | undefined,
 		] {
 		const parenL = this.ruleParenL()
 		let parenLeftCount = 0
@@ -709,7 +709,7 @@ export class Parser<T extends {} = {}> {
 				rest = {
 					sepL: undefined,
 					sepR,
-					propertyOperator: sepL as any as AnyToken<TOKEN_TYPE.OP_CUSTOM>,
+					propertyOperator: sepL as any as AnyToken<typeof TOKEN_TYPE.OP_CUSTOM>,
 				}
 			} else {
 				rest = { sepL, sepR, propertyOperator: op }
@@ -756,7 +756,7 @@ export class Parser<T extends {} = {}> {
 		}
 		if (this.isType(next, $C.REGEX_ANY)) {
 			// this is safe since the start can never match flags
-			const quoteL = this.ruleRegexAny() as ValidToken<TOKEN_TYPE.REGEX>
+			const quoteL = this.ruleRegexAny() as ValidToken<typeof TOKEN_TYPE.REGEX>
 			// unlike other values, regexes will swallow all input if incorrect
 			const maybeValue = this.peek(1)
 			// note the inversion (todo inverse map)
@@ -774,7 +774,7 @@ export class Parser<T extends {} = {}> {
 			return handle.variable(undefined, undefined, value, quoteR)
 		}
 		if (this.isType(next, $C.QUOTE_ANY)) {
-			const quoteToken = next as Token<$T.QUOTE_BACKTICK | $T.QUOTE_DOUBLE | $T.QUOTE_SINGLE>
+			const quoteToken = next as Token<typeof $T.QUOTE_BACKTICK | typeof $T.QUOTE_DOUBLE | typeof $T.QUOTE_SINGLE>
 			const quoteL = this.ruleValueDelimAny()
 			const maybeValue = this.peek(1)
 			const value = !quoteL && this.isType(maybeValue, $T.VALUE_UNQUOTED)
@@ -792,7 +792,7 @@ export class Parser<T extends {} = {}> {
 		return undefined
 	}
 
-	ruleValueDelimAny(): ValidToken<TOKEN_TYPE.SINGLEQUOTE | TOKEN_TYPE.DOUBLEQUOTE | TOKEN_TYPE.BACKTICK | TOKEN_TYPE.REGEX> | undefined {
+	ruleValueDelimAny(): ValidToken<typeof TOKEN_TYPE.SINGLEQUOTE | typeof TOKEN_TYPE.DOUBLEQUOTE | typeof TOKEN_TYPE.BACKTICK | typeof TOKEN_TYPE.REGEX> | undefined {
 		const next = this.peek(1)!
 		
 		if (this.isType(next, $C.QUOTE_ANY)) {
@@ -802,7 +802,7 @@ export class Parser<T extends {} = {}> {
 		return undefined
 	}
 
-	ruleRegexAny(): ValidToken<TOKEN_TYPE.REGEX> | [ValidToken<TOKEN_TYPE.REGEX>, AnyToken<TOKEN_TYPE.VALUE>] {
+	ruleRegexAny(): ValidToken<typeof TOKEN_TYPE.REGEX> | [ValidToken<typeof TOKEN_TYPE.REGEX>, AnyToken<typeof TOKEN_TYPE.VALUE>] {
 		const value = this.consume($C.REGEX_ANY)
 		if (value.value.length > 1) {
 			// cheat a bit to extract the flags
@@ -826,11 +826,11 @@ export class Parser<T extends {} = {}> {
 	}
 
 	ruleValueNot<
-		TType extends $T.QUOTE_SINGLE | $T.QUOTE_DOUBLE | $T.QUOTE_BACKTICK | $C.REGEX_ANY,
+		TType extends typeof $T.QUOTE_SINGLE | typeof $T.QUOTE_DOUBLE | typeof $T.QUOTE_BACKTICK | typeof $C.REGEX_ANY,
 	>(
 		type: TType,
 	): ValidToken<
-			TOKEN_TYPE.VALUE
+			typeof TOKEN_TYPE.VALUE
 		> {
 		const realType = {
 			[$T.QUOTE_SINGLE]: $C.VALUE_FOR_SINGLE,
@@ -848,15 +848,15 @@ export class Parser<T extends {} = {}> {
 		return handle.token.value(...this.processToken(value)) as any
 	}
 
-	ruleQuote<TType extends $T.QUOTE_SINGLE | $T.QUOTE_DOUBLE | $T.QUOTE_BACKTICK >(
+	ruleQuote<TType extends typeof $T.QUOTE_SINGLE | typeof $T.QUOTE_DOUBLE | typeof $T.QUOTE_BACKTICK >(
 		type: TType,
 	): ValidToken<
-		TType extends $T.QUOTE_SINGLE
-		? TOKEN_TYPE.SINGLEQUOTE
-		: TType extends $T.QUOTE_DOUBLE
-		? TOKEN_TYPE.DOUBLEQUOTE
-		: TType extends $T.QUOTE_BACKTICK
-		? TOKEN_TYPE.BACKTICK
+		TType extends typeof $T.QUOTE_SINGLE
+		? typeof TOKEN_TYPE.SINGLEQUOTE
+		: TType extends typeof $T.QUOTE_DOUBLE
+		? typeof TOKEN_TYPE.DOUBLEQUOTE
+		: TType extends typeof $T.QUOTE_BACKTICK
+		? typeof TOKEN_TYPE.BACKTICK
 		: never
 		> {
 		const quote = this.peek(1)
@@ -891,7 +891,7 @@ export class Parser<T extends {} = {}> {
 			onlyToken?: TOnlyToken
 			unprefixed?: boolean
 		} = {},
-	): TOnlyToken extends true ? Token<$T.VALUE_UNQUOTED> | undefined : AnyToken<TOKEN_TYPE.VALUE> | undefined {
+	): TOnlyToken extends true ? Token<typeof $T.VALUE_UNQUOTED> | undefined : AnyToken<typeof TOKEN_TYPE.VALUE> | undefined {
 		const next = this.peek(1)
 		const next2 = this.peek(2)
 		const next4 = this.peek(4)
@@ -912,13 +912,13 @@ export class Parser<T extends {} = {}> {
 		}: {
 			onlyToken?: TOnlyToken
 		} = {},
-	): TOnlyToken extends true ? Token<$T.VALUE_UNQUOTED> : AnyToken<TOKEN_TYPE.VALUE> {
+	): TOnlyToken extends true ? Token<typeof $T.VALUE_UNQUOTED> : AnyToken<typeof TOKEN_TYPE.VALUE> {
 		const t = this.consume($T.VALUE_UNQUOTED)
 		const res = onlyToken ? t : handle.token.value(...this.processToken(t))
 		return (res) as any
 	}
 
-	ruleParenL(): ValidToken<TOKEN_TYPE.PARENL> | undefined {
+	ruleParenL(): ValidToken<typeof TOKEN_TYPE.PARENL> | undefined {
 		const next = this.peek(1)
 		const value = next?.type === $T.PAREN_L
 			? this.consume($T.PAREN_L)
@@ -929,12 +929,12 @@ export class Parser<T extends {} = {}> {
 			: undefined
 	}
 
-	ruleParenR(): ValidToken<TOKEN_TYPE.PARENR> | undefined {
+	ruleParenR(): ValidToken<typeof TOKEN_TYPE.PARENR> | undefined {
 		const value = this.consume($T.PAREN_R)
 		return handle.delimiter.parenR(...this.processToken(value))
 	}
 
-	ruleBracketL(): ValidToken<TOKEN_TYPE.BRACKETL> | undefined {
+	ruleBracketL(): ValidToken<typeof TOKEN_TYPE.BRACKETL> | undefined {
 		const next = this.peek(1)
 		const value = next?.type === $T.BRACKET_L
 			? this.consume($T.BRACKET_L)
@@ -945,12 +945,12 @@ export class Parser<T extends {} = {}> {
 			: undefined
 	}
 
-	ruleBracketR(): ValidToken<TOKEN_TYPE.BRACKETR> | undefined {
+	ruleBracketR(): ValidToken<typeof TOKEN_TYPE.BRACKETR> | undefined {
 		const value = this.consume($T.BRACKET_R)
 		return handle.delimiter.bracketR(...this.processToken(value))
 	}
 	
-	ruleNot(): ValidToken<TOKEN_TYPE.NOT> | undefined {
+	ruleNot(): ValidToken<typeof TOKEN_TYPE.NOT> | undefined {
 		if (this.isType(this.peek(1), $C.OPERATOR_NOT)) {
 			const op = this.consume($C.OPERATOR_NOT)
 			return handle.operator.not(...this.processToken<true>(op))
@@ -1129,13 +1129,13 @@ export class Parser<T extends {} = {}> {
 		const wordOps = [...opts.keywords.and, ...opts.keywords.or, ...opts.keywords.not].filter(op => !op.isSymbol)
 
 		const canSuggestOpAfterPrev = (
-			token.valid.prev && tokenVariable.includes(token.valid.prev?.type) &&
+			token.valid.prev && (tokenVariable as string[]).includes(token.valid.prev?.type) &&
 			(token.whitespace.prev || token.valid.prev.type === TOKEN_TYPE.PARENR) &&
 			!token.at && token.valid.next === undefined
 		)
 		const canSuggestOpBeforeNext =
 			(
-				token.valid.next && tokenVariable.includes(token.valid.next?.type) &&
+				token.valid.next && (tokenVariable as string[]).includes(token.valid.next?.type) &&
 				token.whitespace.next && // no parenL allowed since check since there will already be prefix suggestions
 				!token.at && token.valid.prev === undefined
 			)
@@ -1169,7 +1169,7 @@ export class Parser<T extends {} = {}> {
 		} else {
 			const surroundingErrors = getSurroundingErrors(tokens, token)
 
-			const errorTypesHandled: TOKEN_TYPE[] = []
+			const errorTypesHandled: TokenType[] = []
 			const errorSuggestion = {
 				isError: true,
 				cursorInfo: token,
@@ -1192,7 +1192,7 @@ export class Parser<T extends {} = {}> {
 							const isRight = (errorParent as VariableNode).quote!.right === error
 							suggestions.push({
 								...errorSuggestion,
-								type: type as any as SUGGESTION_TYPE,
+								type: type as any as SuggestionType,
 								requires: createDefaultRequires({
 									whitespace: {
 										before: isRight ? false : requiresWhitespacePrev,
@@ -1229,7 +1229,7 @@ export class Parser<T extends {} = {}> {
 						case TOKEN_TYPE.PARENR:
 							suggestions.push({
 								...errorSuggestion,
-								type: type as any as SUGGESTION_TYPE,
+								type: type as any as SuggestionType,
 								requires: createDefaultRequires(),
 								range: pos({ start: index }, { fill: true }),
 							})
@@ -1803,6 +1803,7 @@ export class Parser<T extends {} = {}> {
 				if (prefix !== undefined && !isNested) {
 					name = name ? applyPrefix(prefix, name, opts.prefixApplier) : prefix
 				}
+
 				let value: any
 				if (isNested) {
 					value = name ?? true
@@ -1855,16 +1856,21 @@ export class Parser<T extends {} = {}> {
 				return self_.normalize(ast.value, name, boolValue, operator) as any
 			}
 		}
-
 		if (ast.type === AST_TYPE.GROUP) {
 			const _prefix = ast.prefix?.type === AST_TYPE.CONDITION && ast.prefix?.value.type === AST_TYPE.VARIABLE
 				? unescape(ast.prefix.value.value.value!)
 				: undefined // we do not want to apply not tokens
+			const isNotToken = _prefix === undefined
+
 			const _groupValue = ast.prefix?.type === AST_TYPE.CONDITION
 				? ast.prefix.operator === undefined
 				: !(ast.prefix?.valid === true)
 
-			const applied = applyPrefix(prefix, _prefix ?? "", opts.prefixApplier)
+			// do not attempt to apply prefix if it's undefined (a not token)
+			// otherwise we would get weird calls to applyPrefix
+			const applied = isNotToken
+				? prefix
+				: applyPrefix(prefix, _prefix, opts.prefixApplier)
 
 			return self_.normalize(ast.expression as any, applied, applyBoolean(groupValue, _groupValue), operator) as any
 		}
@@ -1874,7 +1880,7 @@ export class Parser<T extends {} = {}> {
 
 			// apply De Morgan's laws if group prefix was negative
 			// the values are already flipped, we just have to flip the operator
-			const type: TokenBooleanTypes = (groupValue === false ? OPPOSITE[ast.operator!.type!] : ast.operator.type) as TokenBooleanTypes
+			const type: TokenBoolean = (groupValue === false ? OPPOSITE[ast.operator!.type!] : ast.operator.type)!
 			return createExpression<TType, TValue>({ operator: type, left: left as any, right: right as any })
 		}
 		return unreachable()
@@ -1904,7 +1910,7 @@ export class Parser<T extends {} = {}> {
 		// eslint-disable-next-line prefer-rest-params
 		const prefixes: VariableNode[] = arguments[5] ?? []
 		// eslint-disable-next-line prefer-rest-params
-		let operator: ValidToken<TOKEN_TYPE.VALUE | TOKEN_TYPE.OP_CUSTOM> | undefined = arguments[6]
+		let operator: ValidToken<typeof TOKEN_TYPE.VALUE | typeof TOKEN_TYPE.OP_CUSTOM> | undefined = arguments[6]
 
 		const self_ = this as any as Parser & { validate: AddParameters<Parser["validate"], [typeof prefix, typeof groupValue, typeof results, typeof prefixes, typeof operator]> }
 
@@ -1946,7 +1952,7 @@ export class Parser<T extends {} = {}> {
 				const valuePrefix = ast.value.type === AST_TYPE.VARIABLE && ast.value.prefix
 					? ast.value.prefix
 					: undefined
-				operator ??= ast.propertyOperator as ValidToken<TOKEN_TYPE.VALUE | TOKEN_TYPE.OP_CUSTOM>
+				operator ??= ast.propertyOperator as ValidToken<typeof TOKEN_TYPE.VALUE | typeof TOKEN_TYPE.OP_CUSTOM>
 				const isRegex = (ast.value as VariableNode)?.quote?.left.type === TOKEN_TYPE.REGEX
 				const isQuoted = (ast.value as VariableNode)?.quote !== undefined
 				const isExpanded = ast.sep !== undefined
@@ -1979,7 +1985,7 @@ export class Parser<T extends {} = {}> {
 
 				if (ast.property) prefixes.push((ast.property as any))
 				// eslint-disable-next-line @typescript-eslint/no-shadow
-				const operator = ast.propertyOperator as ValidToken<TOKEN_TYPE.VALUE | TOKEN_TYPE.OP_CUSTOM>
+				const operator = ast.propertyOperator as ValidToken<typeof TOKEN_TYPE.VALUE | typeof TOKEN_TYPE.OP_CUSTOM>
 				self_.validate(ast.value, context, name, boolValue, results, prefixes, operator)
 			}
 		}

package/src/ast/builders/condition.ts

@@ -21,10 +21,10 @@ export function condition(
 	| GroupNode
 	| ArrayNode
 	| ErrorToken,
-	not: true | ValidToken<TOKEN_TYPE.NOT> = true,
+	not: true | ValidToken<typeof TOKEN_TYPE.NOT> = true,
 	property?: VariableNode | ErrorToken,
-	propertyOperator?: AnyToken<TOKEN_TYPE.OP_CUSTOM | TOKEN_TYPE.VALUE>,
-	{ right, left }: Partial<Record<"right" | "left", ValidToken<TOKEN_TYPE.OP_EXPANDED_SEP>>> = { },
+	propertyOperator?: AnyToken<typeof TOKEN_TYPE.OP_CUSTOM | typeof TOKEN_TYPE.VALUE>,
+	{ right, left }: Partial<Record<"right" | "left", ValidToken<typeof TOKEN_TYPE.OP_EXPANDED_SEP>>> = { },
 ): ConditionNode {
 	const position = pos(value satisfies Position)
 	const notStart = not === true ? undefined : not.start

package/src/ast/builders/delim.ts

@@ -1,6 +1,6 @@
 import { type } from "./type.js"
 
-import { type ExtractTokenType, TOKEN_TYPE } from "../../types/ast.js"
+import { type ExtractToken, TOKEN_TYPE } from "../../types/ast.js"
 
 /**
  * Faster way, more intuitive way to generate the options for matching delimiters (e.g. quotes and parens) for functions like {@link variable} and {@link group} .
@@ -10,9 +10,9 @@ export function delim<
 	TLeft extends boolean | string,
 	TRight extends boolean | string,
 	TType extends TLeft extends string
-		? ExtractTokenType<TLeft>
+		? ExtractToken<TLeft>
 		: TRight extends string
-		? ExtractTokenType<TRight>
+		? ExtractToken<TRight>
 		: undefined,
 >(
 	left: TLeft = false as TLeft,
@@ -21,7 +21,7 @@ export function delim<
 	{
 		left: TLeft extends string ? true : TLeft
 		right: TRight extends string ? true : TRight
-	} & TType extends undefined ? {} : { type: TType } {
+	} & TType extends undefined ? Record<string,never> : { type: TType } {
 	let quoteType
 	if (typeof left === "string") quoteType = type(left)
 	else if (typeof right === "string") quoteType = type(right)
@@ -31,7 +31,7 @@ export function delim<
 		right: right === true || (typeof right === "string" && right !== undefined),
 	}
 	if (quoteType !== undefined &&
-		![TOKEN_TYPE.PARENL, TOKEN_TYPE.PARENR].includes(quoteType)
+		!([TOKEN_TYPE.PARENL, TOKEN_TYPE.PARENR] as string[]).includes(quoteType)
 	) {
 		opts.type = quoteType
 	}

package/src/ast/builders/error.ts

@@ -1,6 +1,6 @@
 import { type } from "./type.js"
 
-import { type ErrorToken,TOKEN_TYPE } from "../../types/ast.js"
+import { type ErrorToken,TOKEN_TYPE, type TokenType } from "../../types/ast.js"
 import { createToken } from "../createToken.js"
 
 
@@ -9,8 +9,8 @@ import { createToken } from "../createToken.js"
  *
  * @param expected Can be passed an array of {@link ValidToken_TYPE} or strings, in which case it will use {@link type} internally. So instead of `[TOKEN_TYPE.VALUE]` we can do `[""]` and instead of `[TOKEN_TYPE.PARENR]` we can do `[")"]`.
  */
-export function error<T extends TOKEN_TYPE>(pos: number, expected: T[]): ErrorToken
-export function error<T extends TOKEN_TYPE>(pos: number, expected_: T[]): ErrorToken {
+export function error<T extends TokenType>(pos: number, expected: T[]): ErrorToken
+export function error<T extends TokenType>(pos: number, expected_: T[]): ErrorToken {
 	const expected = expected_.map(item => {
 		if (TOKEN_TYPE[item as keyof typeof TOKEN_TYPE] === undefined) {
 			return type(item)

package/src/ast/builders/expression.ts

@@ -1,7 +1,7 @@
 import { pos } from "./pos.js"
 import { token } from "./token.js"
 
-import { type AnyToken, type ConditionNode, type ErrorToken, type ExpressionNode,type GroupNode, type Position, TOKEN_TYPE, type TokenBooleanTypes } from "../../types/ast.js"
+import { type AnyToken, type ConditionNode, type ErrorToken, type ExpressionNode,type GroupNode, type Position, TOKEN_TYPE, type TokenBoolean } from "../../types/ast.js"
 import { createExpressionNode } from "../createExpressionNode.js"
 
 
@@ -18,7 +18,7 @@ export function expression(
 		ErrorToken |
 		undefined,
 	operator:
-		AnyToken<TokenBooleanTypes> |
+		AnyToken<TokenBoolean> |
 		undefined,
 	right:
 		ConditionNode |
@@ -39,17 +39,13 @@ export function expression(
 
 	const position = pos({ start, end } as Position)
 
-	if (left === undefined) {
-		left = token(TOKEN_TYPE.VALUE, undefined, { start: position.start })
-	}
+	left ??= token(TOKEN_TYPE.VALUE, undefined, { start: position.start })
 	let op!: ExpressionNode["operator"]
 	if (operator === undefined) {
 		operator = token([TOKEN_TYPE.AND, TOKEN_TYPE.OR], undefined, { start: left.end })
 	} else op = operator
 
-	if (right === undefined) {
-		right = token(TOKEN_TYPE.VALUE, undefined, { start: op.end })
-	}
+	right ??= token(TOKEN_TYPE.VALUE, undefined, { start: op.end })
 
 	return createExpressionNode({
 		left,

package/src/ast/builders/group.ts

@@ -16,7 +16,7 @@ import { createGroupNode } from "../createGroupNode.js"
 export function group(
 	prefix:
 	| ConditionNode
-	| ValidToken<TOKEN_TYPE.NOT>
+	| ValidToken<typeof TOKEN_TYPE.NOT>
 	| undefined,
 
 	expression:
@@ -30,9 +30,7 @@ export function group(
 	parenLeftPos?: Position,
 	parenRightPos?: Position,
 ): GroupNode {
-	if (expression === undefined) {
-		expression = token(TOKEN_TYPE.VALUE, undefined, prefix?.end !== undefined ? { start: prefix.end } : undefined)
-	}
+	expression ??= token(TOKEN_TYPE.VALUE, undefined, prefix?.end !== undefined ? { start: prefix.end } : undefined)
 
 	const node: Partial<FirstParam<typeof createGroupNode>> = {
 		prefix: undefined,

package/src/ast/builders/pos.ts

@@ -1,6 +1,6 @@
 import { isFullPos } from "./isFullPos.js"
 
-import type { AnyToken, AST_TYPE, EmptyObj, Node, Position, TOKEN_TYPE } from "../../types/ast.js"
+import type { AnyToken, AstType, EmptyObj, Node, Position, TokenType } from "../../types/ast.js"
 
 /**
  * Can either:
@@ -22,9 +22,9 @@ export function pos<TItem extends Position | Partial<Position> | EmptyObj>(
 	// not sure why this needs the AnyToken check
 	TItem extends Position
 	? Position
-	: TItem extends AnyToken<TOKEN_TYPE> | Position | EmptyObj
+	: TItem extends AnyToken<TokenType> | Position | EmptyObj
 	? Position | EmptyObj
-	: TItem extends Node<AST_TYPE> | Position | EmptyObj
+	: TItem extends Node<AstType> | Position | EmptyObj
 	? Position | EmptyObj
 	: EmptyObj
 export function pos(start: number, end: number): Position

package/src/ast/builders/token.ts

@@ -2,7 +2,7 @@ import { isArray } from "@alanscodelog/utils/isArray.js"
 
 import { pos } from "./pos.js"
 
-import type { AnyToken, EmptyObj, ErrorToken, Position, TOKEN_TYPE, ValidToken } from "../../types/ast.js"
+import type { AnyToken, EmptyObj, ErrorToken, Position, TokenType, ValidToken } from "../../types/ast.js"
 import { createToken } from "../createToken.js"
 
 
@@ -16,7 +16,7 @@ import { createToken } from "../createToken.js"
 
 export function token<
 	TValue extends string | undefined,
-	TType extends TOKEN_TYPE = TOKEN_TYPE,
+	TType extends TokenType = TokenType,
 >(
 	type: TValue extends undefined ? TType | TType[] : TType,
 	value: TValue,

package/src/ast/builders/type.ts

@@ -1,10 +1,10 @@
-import { type ExtractTokenType, TOKEN_TYPE } from "../../types/ast.js"
+import { type ExtractToken, TOKEN_TYPE } from "../../types/ast.js"
 /**
  * Given a the string value of an operator or single delimiter token, returns the corresponding {@link ValidToken_TYPE} .
  */
 export function type<T extends string>(
 	operatorSymbol: T,
-): ExtractTokenType<T> {
+): ExtractToken<T> {
 	switch (operatorSymbol) {
 		case "`": return TOKEN_TYPE.BACKTICK as any
 		case `'`: return TOKEN_TYPE.SINGLEQUOTE as any

package/src/ast/builders/variable.ts

@@ -1,7 +1,7 @@
 import { pos } from "./pos.js"
 import { token } from "./token.js"
 
-import { type AnyToken, type EmptyObj,type FirstParam, type Position, TOKEN_TYPE, type TokenQuoteTypes, type ValidToken, type VariableNode } from "../../types/ast.js"
+import { type AnyToken, type EmptyObj,type FirstParam, type Position, TOKEN_TYPE, type TokenQuote, type ValidToken, type VariableNode } from "../../types/ast.js"
 import { createVariableNode } from "../createVariableNode.js"
 
 
@@ -14,9 +14,9 @@ import { createVariableNode } from "../createVariableNode.js"
  */
 
 export function variable(
-	prefix: ValidToken<TOKEN_TYPE.VALUE> | undefined,
-	value: string | AnyToken<TOKEN_TYPE.VALUE>,
-	quote?: { type: TokenQuoteTypes, left?: boolean, right?: boolean, flags?: string },
+	prefix: ValidToken<typeof TOKEN_TYPE.VALUE> | undefined,
+	value: string | AnyToken<typeof TOKEN_TYPE.VALUE>,
+	quote?: { type: TokenQuote, left?: boolean, right?: boolean, flags?: string },
 	position?: Position | EmptyObj,
 ): VariableNode {
 	if (typeof value === "string") {
@@ -76,7 +76,7 @@ export function variable(
 	return createVariableNode(node as any)
 }
 
-function quoteFromType(type: TokenQuoteTypes | undefined): string {
+function quoteFromType(type: TokenQuote | undefined): string {
 	switch (type) {
 		case TOKEN_TYPE.BACKTICK: return "`"
 		case TOKEN_TYPE.DOUBLEQUOTE: return "\""

package/src/ast/createConditionNode.ts

@@ -5,8 +5,8 @@ import { isNode } from "../utils/isNode.js"
 export function createConditionNode<
 	TValid extends boolean = boolean,
 	TOperator extends
-		ValidToken<TOKEN_TYPE.NOT> | undefined =
-		ValidToken<TOKEN_TYPE.NOT> | undefined,
+		ValidToken<typeof TOKEN_TYPE.NOT> | undefined =
+		ValidToken<typeof TOKEN_TYPE.NOT> | undefined,
 >(raw: {
 	operator?: TOperator
 	property?: ConditionNode<TValid>["property"]