@witchcraft/expressit 0.2.1 → 0.3.0

package/src/internal/checkParserOpts.ts

@@ -5,11 +5,11 @@ 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 */
-export function checkParserOpts<T extends {}>(opts: FullParserOptions<T>, evaluatorChecks: boolean = false, validatorChecks: boolean = false): void {
+export function checkParserOpts<T>(opts: FullParserOptions<T>, evaluatorChecks: boolean = false, validatorChecks: boolean = false): void {
 	if (!evaluatorChecks) {
 		const keywordsList = [...opts.keywords.and, ...opts.keywords.or, ...opts.keywords.not].map(keyword => keyword.value)
 		const symNots = opts.keywords.not.filter(op => op.isSymbol).map(op => op.value)
@@ -27,7 +27,7 @@ export function checkParserOpts<T extends {}>(opts: FullParserOptions<T>, evalua
 		/* #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 extends {}>(opts: FullParserOptions<T>, evalua
 		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,18 +43,18 @@ export function checkParserOpts<T extends {}>(opts: FullParserOptions<T>, evalua
 		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`,
 			)
 		}
-		for (const key of ["and", "or", "not"]) {
-			const invalid = opts.keywords[key as keyof FullParserOptions["keywords"]]
+		for (const key of ["and", "or", "not"] as const) {
+			const invalid = opts.keywords[key]
 				?.find(_ => isBlank(_.value))
 				?.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 extends {}>(opts: FullParserOptions<T>, evalua
 		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 extends {}>(opts: FullParserOptions<T>, evalua
 			.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 extends {}>(opts: FullParserOptions<T>, evalua
 		: 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 extends {}>(opts: FullParserOptions<T>, evalua
 
 		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 extends {}>(opts: FullParserOptions<T>, evalua
 
 		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 extends {}>(opts: FullParserOptions<T>, evalua
 	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/internal/parseParserOptions.ts

@@ -5,10 +5,10 @@ import { defaultValueComparer } from "../defaults/defaultValueComparer.js"
 import type { FullParserOptions, ParserOptions } from "../types/parser.js"
 
 /** @internal */
-export function parseParserOptions<T extends {} = {}>(
+export function parseParserOptions<T>(
 	options: ParserOptions<T>,
 ): FullParserOptions<T> {
-	const opts: ParserOptions = {
+	const opts: ParserOptions<T> = {
 		prefixApplier: defaultPrefixApplier,
 		keyParser: defaultKeyParser,
 		valueComparer: defaultValueComparer,

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> =

package/src/types/autocomplete.ts

@@ -1,3 +1,6 @@
+import { type EnumLike } from "@alanscodelog/utils"
+import { enumFromArray } from "@alanscodelog/utils/enumFromArray.js"
+
 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.js"
+
 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

@@ -4,7 +4,7 @@ import type { ArrayNode, ConditionNode, NormalizedCondition, Position, TOKEN_TYP
 
 
 // #partially-synced
-export type FullParserOptions<T extends {} = {}> = MakeRequired<
+export type FullParserOptions<T = any> = MakeRequired<
 	ParserOptions<T>,
 	// makes required all except:
 	Exclude<keyof ParserOptions<T>,
@@ -18,7 +18,7 @@ export type FullParserOptions<T extends {} = {}> = MakeRequired<
 	// overrides
 	keywords: DeepRequired<KeywordOptions>
 }
-export type ParserOptions<T extends {} = {}> = {
+export type ParserOptions<T = any> = {
 	/**
 	 * Allows any conditions (i.e. a variable or negated variable) to precede groups and append themselves to all variables inside them. Regular use of groups for changing precedence (e.g. `(a || b) && c` ) or negating expressions `!(a || b)` is still supported even if `prefixableGroups` is false.
 	 *
@@ -116,7 +116,7 @@ export type ParserOptions<T extends {} = {}> = {
 	/**
 	 * Enables regex strings as values. The value is treated as if it was quoted by forward slashes. Any repetition of lowercase characters (even if there are multiple) attached to the end are assumed to be flags and added as a single token to the value's `quotes.mode` property.
 	 *
-	 * Can be passed a custom function to determine when to use the regex value or not (it is converted to a regular value). The function is passed the property, the operator, and whether it's an expanded operator. If their is an error token for the property or operator, an empty string is passed.
+	 * Can be passed a custom function to determine when to use the regex value or not (it is converted to a regular value). The function is passed the property, the operator, and whether it's an expanded operator. If there is an error token for the property or operator, an empty string is passed.
 	 *
 	 * ```ts
 	 * // allow anything (`prop=/val/`, `prop:op:/val`, `prop=(/val/)`, `prop:op(/val/)`) but the value alone (`/regex/`)
@@ -272,7 +272,7 @@ export type ParserOptions<T extends {} = {}> = {
 	 * ```ts
 	 * type Operators = "contains"
 	 * function valueComparer(condition: Omit<Condition, "negate">, contextValue: any, context: any): boolean {
-	 * 	switch (operator as Operators) {
+	 * 	switch (condition.operator as Operators) {
 	 * 		case "contains": return (contextValue as string[]).includes(condition.value as string)
 	 * 		// ...
 	 * 	}
@@ -307,13 +307,13 @@ export type ParserOptions<T extends {} = {}> = {
 	 * 	if (prefix) {
 	 * 		const val = value as string // it's always a string if prefixed
 	 * 		switch (prefix as RawPrefixes) {
-	 * 			case "num": finalValue = parseInt(val, 2); break
+	 * 			case "num": finalValue = parseInt(val, 10); break
 	 * 			// ...
 	 * 		}
 	 * 	}
 	 * 	// another way to allow special unquoted value types is something like this:
 	 * 	if (typeof value === "string" && !isQuoted) {
-	 * 		const asNum = parseInt(value, 2)
+	 * 		const asNum = parseInt(value, 10)
 	 * 		if (!isNaN(asNum)) finalValue = asNum
 	 * 		if (["true","false"].includes(value)) {
 	 * 			finalValue = value === "true" ? true : false
@@ -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/getCursorInfo.ts

@@ -56,7 +56,7 @@ export function getCursorInfo(
 			}
 		}
 		if (token.start >= index) {
-			info.next ||= token
+			info.next ??= token
 			if (token.valid && !info.valid.next) {
 				info.valid.next = token
 				break