@witchcraft/expressit 0.2.2 → 0.3.1

package/src/types/ast.ts

@@ -1,94 +1,97 @@
-import type { AnyFunction } from "@alanscodelog/utils/types"
+import { enumFromArray } from "@alanscodelog/utils/enumFromArray"
+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> =

package/src/types/autocomplete.ts

@@ -1,3 +1,6 @@
+import { type EnumLike } from "@alanscodelog/utils"
+import { enumFromArray } from "@alanscodelog/utils/enumFromArray"
+
 import type { AnyToken, Position, ValidToken } from "./ast.js"
 
 
@@ -82,35 +85,36 @@ export type CursorInfo = {
 	}
 }
 
-export enum SUGGESTION_TYPE {
-	// can ignore whitespace requirement if replacing with quoted
-	VARIABLE = "VARIABLE",
-	ARRAY_VALUE = "ARRAY_VALUE",
-	VALUE = "VALUE",
-	PREFIX = "PREFIX",
-	BOOLEAN_WORD_OP = "BOOLEAN_WORD_OP",
-	BOOLEAN_SYMBOL_OP = "BOOLEAN_SYMBOL_OP",
-	BACKTICK = "BACKTICK",
-	DOUBLEQUOTE = "DOUBLEQUOTE",
-	SINGLEQUOTE = "SINGLEQUOTE",
-	PARENL = "PARENL",
-	PARENR = "PARENR",
-	PROPERTY = "PROPERTY",
-	EXPANDED_PROPERTY_OPERATOR = "EXPANDED_PROPERTY_OPERATOR",
-	CUSTOM_PROPERTY_OPERATOR = "CUSTOM_PROPERTY_OPERATOR",
-	PROPERTY_SEP = "PROPERTY_SEP",
-	BRAKCETR = "BRAKCETR",
-	REGEX = "REGEX",
-	REGEX_FLAGS = "REGEX_FLAGS",
+export 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 type SuggestionType = EnumLike<typeof SUGGESTION_TYPE>
 
 /**
  * A suggestion entry that describes a type of suggestion.
  */
 export type Suggestion = {
-	type: SUGGESTION_TYPE
+	type: SuggestionType
 	/** The range the suggestion should replace / be inserted at. */
 	range: Position
 	/** {@link CursorInfo} */

package/src/types/errors.ts

@@ -1,29 +1,34 @@
+import { type EnumLike } from "@alanscodelog/utils"
+import { enumFromArray } from "@alanscodelog/utils/enumFromArray"
+
 import type { ParserOptions } from "./parser.js"
 
 
-export enum ERROR_CODES {
-	PARSER_POSITION_ERROR = "PARSER.POSITION",
-	PARSER_CONFLICTING_OPTIONS_ERROR = "PARSER.OPTIONS.CONFLICTING",
-	PARSER_OPTION_REQUIRED_ERROR = "PARSER.OPTIONS.CUSTOM_REQUIRED",
-}
+export const PARSER_ERROR = enumFromArray([
+	"POSITION_ERROR",
+	"CONFLICTING_OPTIONS_ERROR",
+	"OPTION_REQUIRED_ERROR",
+], "PARSER.")
+
+export type ParserError = EnumLike<typeof PARSER_ERROR>
 
 
-export type ErrorInfo<T extends ERROR_CODES> =
-	T extends ERROR_CODES
-	? ERROR_Info[T]
+export type ErrorInfo<T extends ParserError> =
+	T extends ParserError
+	? ErrorCodesInfo[T]
 	: never
 
-// eslint-disable-next-line @typescript-eslint/naming-convention
-export type ERROR_Info = {
-	[ERROR_CODES.PARSER_POSITION_ERROR]: {
+ 
+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/src/types/parser.ts

@@ -443,9 +443,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/src/utils/extractTokens.ts

@@ -1,4 +1,4 @@
-import { unreachable } from "@alanscodelog/utils/unreachable.js"
+import { unreachable } from "@alanscodelog/utils/unreachable"
 
 import { isNode } from "./isNode.js"
 import { isToken } from "./isToken.js"

package/src/utils/getCursorInfo.ts

@@ -1,5 +1,5 @@
-import { isArray } from "@alanscodelog/utils/isArray.js"
-import { unreachable } from "@alanscodelog/utils/unreachable.js"
+import { isArray } from "@alanscodelog/utils/isArray"
+import { unreachable } from "@alanscodelog/utils/unreachable"
 
 import { extractTokens } from "./extractTokens.js"
 

package/src/utils/getOppositeDelimiter.ts

@@ -1,4 +1,4 @@
-import { unreachable } from "@alanscodelog/utils/unreachable.js"
+import { unreachable } from "@alanscodelog/utils/unreachable"
 
 import type { generateParentsMap } from "./generateParentsMap.js"
 import { isBracket } from "./isBracket.js"
@@ -6,7 +6,7 @@ import { isDelimiter } from "./isDelimiter.js"
 import { isParen } from "./isParen.js"
 import { isQuote } from "./isQuote.js"
 
-import { type AnyToken, type ArrayNode, type ConditionNode,type GroupNode, TOKEN_TYPE, type TokenDelimiterTypes, type VariableNode } from "../types/ast.js"
+import { type AnyToken, type ArrayNode, type ConditionNode,type GroupNode, TOKEN_TYPE, type TokenDelimiter, type VariableNode } 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).
@@ -14,7 +14,7 @@ import { type AnyToken, type ArrayNode, type ConditionNode,type GroupNode, TOKEN
 export function getOppositeDelimiter(
 	token: AnyToken,
 	parentsMap: ReturnType<typeof generateParentsMap>
-): AnyToken<TokenDelimiterTypes> | undefined {
+): AnyToken<TokenDelimiter> | undefined {
 	const parent = parentsMap.get(token)
 	if (!isDelimiter(token)) throw new Error("Token is not a delimiter type.")
 	if (isParen(token)) {

package/src/utils/getSurroundingErrors.ts

@@ -43,10 +43,10 @@ export function getSurroundingErrors(tokens: AnyToken[], token: CursorInfo): Err
 	}
 
 	return errors.sort((a, b) => {
-		const aIsQuote = [TOKEN_TYPE.DOUBLEQUOTE, TOKEN_TYPE.BACKTICK, TOKEN_TYPE.SINGLEQUOTE].includes(a.expected[0])
-		const bIsQuote = [TOKEN_TYPE.DOUBLEQUOTE, TOKEN_TYPE.BACKTICK, TOKEN_TYPE.SINGLEQUOTE].includes(b.expected[0])
-		const aIsParen = [TOKEN_TYPE.PARENR, TOKEN_TYPE.PARENL].includes(a.expected[0])
-		const bIsParen = [TOKEN_TYPE.PARENR, TOKEN_TYPE.PARENL].includes(b.expected[0])
+		const aIsQuote = ([TOKEN_TYPE.DOUBLEQUOTE, TOKEN_TYPE.BACKTICK, TOKEN_TYPE.SINGLEQUOTE] as string[]).includes(a.expected[0])
+		const bIsQuote = ([TOKEN_TYPE.DOUBLEQUOTE, TOKEN_TYPE.BACKTICK, TOKEN_TYPE.SINGLEQUOTE]as string[]).includes(b.expected[0])
+		const aIsParen = ([TOKEN_TYPE.PARENR, TOKEN_TYPE.PARENL] as string[]).includes(a.expected[0])
+		const bIsParen = ([TOKEN_TYPE.PARENR, TOKEN_TYPE.PARENL] as string[]).includes(b.expected[0])
 		const aCloseness = Math.abs(i - tokens.indexOf(a))
 		const bCloseness = Math.abs(i - tokens.indexOf(b))
 		const closenessComparison = aCloseness - bCloseness

package/src/utils/isDelimiter.ts

@@ -1,9 +1,9 @@
-import { type AnyToken, TOKEN_TYPE, type TokenDelimiterTypes } from "../types/ast.js"
+import { type AnyToken, TOKEN_TYPE, type TokenDelimiter } from "../types/ast.js"
 
 /**
  * Returns whether token is a delimiter type (including if it's an expanded operator separator).
  */
-export function isDelimiter(token?: AnyToken): token is AnyToken<TokenDelimiterTypes> {
+export function isDelimiter(token?: AnyToken): token is AnyToken<TokenDelimiter> {
 	return ([
 		TOKEN_TYPE.BACKTICK,
 		TOKEN_TYPE.DOUBLEQUOTE,
@@ -14,5 +14,5 @@ export function isDelimiter(token?: AnyToken): token is AnyToken<TokenDelimiterT
 		TOKEN_TYPE.BRACKETR,
 		TOKEN_TYPE.OP_EXPANDED_SEP,
 		TOKEN_TYPE.REGEX,
-	] as TokenDelimiterTypes[]).includes(token?.type as TokenDelimiterTypes)
+	] as TokenDelimiter[]).includes(token?.type as TokenDelimiter)
 }

package/src/utils/isParen.ts

@@ -1,6 +1,6 @@
-import { type AnyToken, TOKEN_TYPE, type TokenParenTypes } from "../types/ast.js"
+import { type AnyToken, TOKEN_TYPE, type TokenParen } from "../types/ast.js"
 
 
-export function isParen(token?: AnyToken): token is AnyToken<TokenParenTypes> {
+export function isParen(token?: AnyToken): token is AnyToken<TokenParen> {
 	return ([TOKEN_TYPE.PARENL, TOKEN_TYPE.PARENR] as any[]).includes(token?.type)
 }

package/src/utils/isQuote.ts

@@ -1,6 +1,6 @@
-import { type AnyToken, TOKEN_TYPE, type TokenQuoteTypes } from "../types/ast.js"
+import { type AnyToken, TOKEN_TYPE, type TokenQuote } from "../types/ast.js"
 
 /** Returns if the token is a quote token. This includes regex delimiters. */
-export function isQuote(token?: AnyToken): token is AnyToken<TokenQuoteTypes> {
+export function isQuote(token?: AnyToken): token is AnyToken<TokenQuote> {
 	return ([TOKEN_TYPE.BACKTICK, TOKEN_TYPE.DOUBLEQUOTE, TOKEN_TYPE.SINGLEQUOTE, TOKEN_TYPE.REGEX] as any[]).includes(token?.type)
 }

package/src/utils/prettyAst.ts

@@ -1,8 +1,8 @@
 /* eslint-disable prefer-rest-params */
-import * as color from "@alanscodelog/utils/colors.js"
-import { isBlank } from "@alanscodelog/utils/isBlank.js"
+import * as color from "@alanscodelog/utils/colors"
+import { isBlank } from "@alanscodelog/utils/isBlank"
 import { type AddParameters } from "@alanscodelog/utils/types"
-import { unreachable } from "@alanscodelog/utils/unreachable.js"
+import { unreachable } from "@alanscodelog/utils/unreachable"
 
 import { isToken } from "./isToken.js"