@witchcraft/expressit 0.0.2

package/src/methods/getIndexes.ts

@@ -0,0 +1,99 @@
+/* eslint-disable no-labels */
+
+import { type AddParameters, unreachable } from "@alanscodelog/utils"
+
+import { Condition } from "../ast/classes/Condition.js"
+import { Expression } from "../ast/classes/Expression.js"
+import { TOKEN_TYPE } from "../types/ast.js"
+
+
+export class GetIndexMixin<T> {
+	/**
+	 * Returns a list of the different sets of keys that need to be indexed to run a normalized query on a database and hit an existing index.
+	 *
+	 * For example, the expression `a || b` requires both `a` AND `b` be indexed to use an index. The function would return `[Set(a, b)]`.
+	 *
+	 * On the otherhand, the expression `a && b` only requires `a` OR `b` to be indexed (`[Set(a), Set(b)]`) If at least one is indexed, the rest of the filtering can be done in memory. There is no need to in memory filter the entire database.
+	 *
+	 * Now take a more complicated query like `(a && b) || (a && c)`. This only requires `a` be indexed, or both `b` AND `c`. (`[Set(a)], [Set(b), Set(c)]`).
+	 *
+	 * Queries like `(a || b) && (a || c)` would require all the variables to be indexed `[Set(a), Set(b), Set(c)]`.
+	 */
+	getIndexes(ast: Condition | Expression): Set<string>[] {
+		const self_ = this as any as GetIndexMixin<T> & { indexes: AddParameters<GetIndexMixin<T>["getIndexes"], []> }
+		if (ast instanceof Condition) {
+			return [new Set(ast.property.join("."))]
+		}
+		if (ast instanceof Expression) {
+			const left = self_.getIndexes(ast.left)
+			const right = self_.getIndexes(ast.right)
+
+			if (ast.operator === TOKEN_TYPE.AND) {
+				const sets: Set<string>[] = []
+				const allKeys: Set<string> = new Set()
+
+				for (const leftSet of left) {
+					const exists = sets.find(set => isEqualSet(set, leftSet))
+					if (exists) continue
+					sets.push(leftSet)
+					for (const key of leftSet) {
+						allKeys.add(key)
+					}
+				}
+				for (const rightSet of right) {
+					const exists = sets.find(set => isEqualSet(set, rightSet))
+					if (exists) continue
+					sets.push(rightSet)
+					for (const key of rightSet) {
+						allKeys.add(key)
+					}
+				}
+
+				const commonKeys: Set<string> = new Set()
+
+				outerCheck: for (const key of allKeys) {
+					for (const set of sets) {
+						if (!set.has(key)) continue outerCheck
+					}
+					commonKeys.add(key)
+				}
+				if (commonKeys.size > 0) {
+					return [commonKeys, allKeys]
+				} else {
+					return sets
+				}
+			}
+			if (ast.operator === TOKEN_TYPE.OR) {
+				for (const rightSet of right) {
+					for (const leftSet of left) {
+						if (isEqualSet(leftSet, rightSet)) {
+							return [rightSet]
+						}
+					}
+				}
+				const res = new Set<string>()
+				for (const leftSet of left) {
+					for (const key of leftSet) {
+						res.add(key)
+					}
+				}
+				for (const rightSet of right) {
+					for (const key of rightSet) {
+						res.add(key)
+					}
+				}
+				return [res]
+			}
+		}
+
+		return unreachable()
+	}
+}
+
+function isEqualSet(setA: Set<any>, setB: Set<any>): boolean {
+	if (setA.size !== setB.size) return false
+	for (const key of setA) {
+		if (!setB.has(key)) return false
+	}
+	return true
+}

package/src/methods/index.ts

@@ -0,0 +1,10 @@
+/* Autogenerated Index */
+
+export { AutocompleteMixin } from "./autocomplete.js"
+export { AutoreplaceMixin } from "./autoreplace.js"
+export { Autosuggest } from "./autosuggest.js"
+export { EvaluateMixin } from "./evaluate.js"
+export { GetBestIndexesMixin } from "./getBestIndex.js"
+export { GetIndexMixin } from "./getIndexes.js"
+export { NormalizeMixin } from "./normalize.js"
+export { ValidateMixin } from "./validate.js"

package/src/methods/normalize.ts

@@ -0,0 +1,138 @@
+import { type AddParameters, unreachable } from "@alanscodelog/utils"
+
+import { ArrayNode } from "../ast/classes/ArrayNode.js"
+import { Condition } from "../ast/classes/Condition.js"
+import { ConditionNode } from "../ast/classes/ConditionNode.js"
+import { ErrorToken } from "../ast/classes/ErrorToken.js"
+import { Expression } from "../ast/classes/Expression.js"
+import { ExpressionNode } from "../ast/classes/ExpressionNode.js"
+import { GroupNode } from "../ast/classes/GroupNode.js"
+import { ValidToken } from "../ast/classes/ValidToken.js"
+import { VariableNode } from "../ast/classes/VariableNode.js"
+import { applyBoolean } from "../helpers/general/applyBoolean.js"
+import { applyPrefix } from "../helpers/general/applyPrefix.js"
+import type { Parser } from "../parser.js"
+import { type ParserResults, TOKEN_TYPE, type TokenBooleanTypes } from "../types/ast.js"
+import type { ValueQuery } from "../types/parser.js"
+
+
+const OPPOSITE = {
+	[TOKEN_TYPE.AND]: TOKEN_TYPE.OR,
+	[TOKEN_TYPE.OR]: TOKEN_TYPE.AND,
+}
+
+export class NormalizeMixin<T extends {}> {
+	/**
+	 * Normalizes the ast by applying {@link GroupNode GroupNodes} and converting {@link ConditionNode ConditionNodes} to {@link NormalizedConditionNode NormalizedConditionNodes}.
+	 *
+	 * To do this, a
+	 */
+	normalize<TType extends string, TValue>(ast: ParserResults): Condition<TType, TValue> | Expression<TType, TValue> {
+		// @ts-expect-error private method
+		this._checkEvaluationOptions()
+		const opts = (this as any as Parser<T>).options
+		if (ast instanceof ErrorToken || !ast.valid) {
+			throw new Error("AST node must be valid.")
+		}
+		// eslint-disable-next-line prefer-rest-params
+		const prefix: string | undefined = arguments[1]
+		// eslint-disable-next-line prefer-rest-params
+		const groupValue: boolean | undefined = arguments[2]
+		// eslint-disable-next-line prefer-rest-params
+		let operator: string | undefined = arguments[3]
+
+		const self_ = this as any as NormalizeMixin<T> & { normalize: AddParameters<NormalizeMixin<T>["normalize"], [typeof prefix, typeof groupValue, typeof operator]> }
+
+		if (ast instanceof ConditionNode) {
+			if (!(ast.value instanceof GroupNode)) {
+				const isValue = ast.value instanceof ArrayNode || (ast.value as VariableNode)?.quote?.left.type === TOKEN_TYPE.REGEX
+				let name = ast.property
+					? unescape(ast.property.value.value)
+					: isValue
+						// the property might be missing, whether this is valid or not is up to the user
+						// e.g. if prefix is defined this would make some sense
+						? undefined
+						: unescape((ast.value as VariableNode)?.value.value)
+				// some ancestor node went through the else block because it was a group node (e.g. prop:op(val))
+				// so the "prefix" we passed is actually the name of the property (e.g. prop) and the value is the name we're getting here (e.g. val)
+				const isNested = operator !== undefined
+				if (prefix !== undefined && !isNested) {
+					name = name ? applyPrefix(prefix, name, opts.prefixApplier) : prefix
+				}
+				let value: any
+				if (isNested) {
+					value = name ?? true
+					name = prefix
+				} else {
+					value = ast.value instanceof ArrayNode
+						? ast.value.values.map(val => unescape(val.value.value))
+						: (ast.value as VariableNode)?.quote?.left.type === TOKEN_TYPE.REGEX
+							? ast.value.value.value
+							: ast.property && ast.value instanceof VariableNode
+								? unescape(ast.value.value.value)
+								: true
+				}
+				const propertyKeys = name ? opts.keyParser(name) : []
+
+				const boolValue = applyBoolean(groupValue, ast.operator === undefined)
+				const valuePrefix = ast.value instanceof VariableNode && ast.value.prefix
+					? unescape(ast.value.prefix.value)
+					: undefined
+				// one or the other might be defined, but never both since nested properties (e.g. `prop:op(prop:op(...))`) are not allowed
+				operator ??= ast.propertyOperator?.value
+				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
+				const regexFlags = (ast.value as VariableNode)?.quote?.flags?.value
+				const query: ValueQuery = {
+					value,
+					operator,
+					prefix: valuePrefix,
+					regexFlags,
+					property: propertyKeys,
+					isRegex,
+					isQuoted,
+					isExpanded,
+					isNegated: !boolValue,
+					condition: ast,
+				}
+				const res = opts.conditionNormalizer(query)
+				return new Condition({ property: propertyKeys, ...res })
+			} else {
+				let name = unescape((ast.property as VariableNode).value.value) // this is always a variable node
+				if (prefix !== undefined) {
+					name = applyPrefix(prefix, name, opts.prefixApplier)
+				}
+				const boolValue = applyBoolean(groupValue, ast.operator === undefined)
+				// other operator is never defined see comments in other block above
+				// eslint-disable-next-line @typescript-eslint/no-shadow
+				const operator = ast.propertyOperator?.value
+				// this call will at some point lead us to the above block with isNested = true
+				return self_.normalize(ast.value, name, boolValue, operator) as any
+			}
+		}
+
+		if (ast instanceof GroupNode) {
+			const _prefix = ast.prefix instanceof ConditionNode && ast.prefix.value instanceof VariableNode
+				? unescape(ast.prefix.value.value.value)
+				: undefined // we do not want to apply not tokens
+			const _groupValue = ast.prefix instanceof ConditionNode
+				? ast.prefix.operator === undefined
+				: !(ast.prefix instanceof ValidToken)
+
+			const applied = applyPrefix(prefix, _prefix ?? "", opts.prefixApplier)
+
+			return self_.normalize(ast.expression as any, applied, applyBoolean(groupValue, _groupValue), operator) as any
+		}
+		if (ast instanceof ExpressionNode) {
+			const left = self_.normalize(ast.left, prefix, groupValue, operator)
+			const right = self_.normalize(ast.right, prefix, groupValue, operator)
+
+			// 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
+			return new Expression<TType, TValue>({ operator: type, left: left as any, right: right as any })
+		}
+		return unreachable()
+	}
+}

package/src/methods/validate.ts

@@ -0,0 +1,141 @@
+import { type AddParameters, get, isArray } from "@alanscodelog/utils"
+
+import { ArrayNode } from "../ast/classes/ArrayNode.js"
+import { ConditionNode } from "../ast/classes/ConditionNode.js"
+import { ErrorToken } from "../ast/classes/ErrorToken.js"
+import { ExpressionNode } from "../ast/classes/ExpressionNode.js"
+import { GroupNode } from "../ast/classes/GroupNode.js"
+import { ValidToken } from "../ast/classes/ValidToken.js"
+import { VariableNode } from "../ast/classes/VariableNode.js"
+import { applyBoolean } from "../helpers/general/applyBoolean.js"
+import { applyPrefix } from "../helpers/general/applyPrefix.js"
+import type { Parser } from "../parser.js"
+import { type ParserResults, type Position, TOKEN_TYPE } from "../types/ast.js"
+import type { ValidationQuery } from "../types/parser.js"
+
+
+export class ValidateMixin<T extends {}> {
+	/**
+	 * Allows pre-validating ASTs for syntax highlighting purposes.
+	 * Works similar to evaluate. Internally it will use the prefixApplier, keyParser, and valueValidator (instead of comparer).
+	 *
+	 * The context does not need to be passed. If it's not passed, the function will not attempt to get the values (so it will not error) and the contextValue param of the valueValidator will be undefined.
+	 */
+	validate(ast: ParserResults, context?: Record<string, any>): (Position & T)[] {
+		const self = (this as any as Parser<T>)
+		self._checkValidationOptions()
+		const opts = self.options
+		// see evaluate function, this method is practically identical, except we don't keep track of the real value (since we are not evaluating) and the actual nodes/tokens are passed to the valueValidator, not just the string values.
+		if (ast instanceof ErrorToken || !ast.valid) {
+			throw new Error("AST node must be valid.")
+		}
+		/** Handle hidden recursive version of the function. */
+		// eslint-disable-next-line prefer-rest-params
+		const prefix: string | undefined = arguments[2]
+		// eslint-disable-next-line prefer-rest-params
+		const groupValue: boolean | undefined = arguments[3]
+		// eslint-disable-next-line prefer-rest-params
+		const results: (Position & T)[] = arguments[4] ?? []
+		// 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]
+
+		const self_ = this as any as ValidateMixin<T> & { validate: AddParameters<ValidateMixin<T>["validate"], [typeof prefix, typeof groupValue, typeof results, typeof prefixes, typeof operator]> }
+
+		if (ast instanceof ConditionNode) {
+			if (!(ast.value instanceof GroupNode)) {
+				const isValue = ast.value instanceof ArrayNode || (ast.value as VariableNode)?.quote?.left.type === TOKEN_TYPE.REGEX
+				const nameNode = ast.property
+					? ast.property as VariableNode
+					: isValue
+					? undefined
+					: ast.value as VariableNode
+
+				let name = nameNode ? unescape(nameNode.value.value) : undefined
+				const isNested = operator !== undefined
+				if (prefix !== undefined && !isNested) {
+					name = name ? applyPrefix(prefix, name, opts.prefixApplier) : prefix
+				}
+				let value: any
+				let propertyNodes: VariableNode[] = []
+
+				if (isNested) {
+					value = name
+					name = prefix
+					propertyNodes = [...prefixes]
+				} else {
+					propertyNodes = [...prefixes, ...(nameNode ? [nameNode] : [])]
+					value = ast.value instanceof ArrayNode
+						? ast.value.values
+						: (ast.value as VariableNode)?.quote?.left.type === TOKEN_TYPE.REGEX
+						? ast.value
+						: ast.property && ast.value instanceof VariableNode
+						? ast.value
+						: true
+				}
+				const propertyKeys = name ? opts.keyParser(name) : []
+				const contextValue = context !== undefined ? get(context, propertyKeys) : undefined
+
+				const boolValue = applyBoolean(groupValue, ast.operator === undefined)
+				const valuePrefix = ast.value instanceof VariableNode && ast.value.prefix
+					? ast.value.prefix
+					: undefined
+				operator ??= ast.propertyOperator as ValidToken<TOKEN_TYPE.VALUE | 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
+				const regexFlags = (ast.value as VariableNode)?.quote?.flags
+				const query: ValidationQuery = {
+					value,
+					operator,
+					prefix: valuePrefix,
+					prefixes,
+					property: propertyNodes,
+					propertyKeys,
+					propertyName: name,
+					regexFlags,
+					isRegex,
+					isNegated: !boolValue,
+					isQuoted,
+					isExpanded,
+					condition: ast,
+				}
+				const res = opts.valueValidator(contextValue, query, context)
+				if (res && !isArray(res)) throw new Error("The valueValidator must return an array or nothing/undefined")
+				if (res) { for (const entry of res) results.push(entry) }
+			} else {
+				let name = unescape((ast.property as VariableNode).value.value) // this is always a variable node
+				if (prefix !== undefined) {
+					name = applyPrefix(prefix, name, opts.prefixApplier)
+				}
+
+				const boolValue = applyBoolean(groupValue, ast.operator === undefined)
+
+				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>
+				self_.validate(ast.value, context, name, boolValue, results, prefixes, operator)
+			}
+		}
+
+		if (ast instanceof GroupNode) {
+			const _prefix = ast.prefix instanceof ConditionNode && ast.prefix.value instanceof VariableNode
+				? ast.prefix.value
+				: undefined // we do not want to apply not tokens
+			if (_prefix) prefixes.push(_prefix)
+
+			const _groupValue = ast.prefix instanceof ConditionNode
+				? ast.prefix.operator === undefined
+				: !(ast.prefix instanceof ValidToken)
+
+			self_.validate(ast.expression as any, context, applyPrefix(prefix, _prefix?.value.value ?? "", opts.prefixApplier), applyBoolean(groupValue, _groupValue), results, prefixes, operator)
+		}
+		if (ast instanceof ExpressionNode) {
+			// prefixes must be spread because we don't want the left branch (if it goes deeper) to affect the right
+			self_.validate(ast.left, context, prefix, groupValue, results, [...prefixes], operator)
+			self_.validate(ast.right, context, prefix, groupValue, results, [...prefixes], operator)
+		}
+		return results
+	}
+}

package/src/package.js

@@ -0,0 +1,11 @@
+import pkg from "../package.json"
+
+/**
+ * This library imports it's own package.json for inserting the version number into errors. Doing this is not a problem normally (because babel is used to transpile the typescript instead of tsc), but when tsc is used to output the types, the output is nested (dist-types/src/*) because of the json import being outside the src dir. There is a way around this but it's complicated. The easier way is to just cheat and do the importing in this js file. Typescript consumes it none the wiser and babel transpiles it to cjs/es accordingly.
+ *
+ * The values could be inlined, but there are no battle tested actively maintained babel plugins for this, and problems would be hard to debug (given when developing, the package.json never contains the real version because the library is semantically released.)
+ */
+
+
+export const version = pkg.version
+export const repository = pkg.repository

package/src/parser.ts

@@ -0,0 +1,183 @@
+/**
+ * The parser's methods are often long and have a lot of documentation per method, so it's methods have been split into mixins. They can be found in the `./methods` folder.
+ *
+ * Writing from within any of these methods is like writing a method from here except:
+ * - `this` calls are wrapped in `(this as any as Parser<T>)`
+ * - private method/property access requires `// @ts-expect-error`.
+ * - recursion with hidden parameters requires re-typing this (see evaluate/validate for examples) since otherwise if we only retyped the function it would become unbound from `this`.
+ *
+ * Docs work like normal (on methods). From the outside, users of the library cannot even tell the class is composed of mixins.
+ */
+
+import type { Mixin } from "@alanscodelog/utils"
+import { isWhitespace, mixin } from "@alanscodelog/utils"
+import { createSyntaxDiagramsCode, type ILexingResult, type Lexer } from "chevrotain"
+
+import { token as tokenHandler } from "./ast/handlers.js"
+import { createTokens } from "./grammar/createTokens.js"
+import { ParserBase } from "./grammar/ParserBase.js"
+import { BooleanParserLibraryError } from "./helpers/errors.js"
+import { checkParserOpts } from "./helpers/parser/checkParserOpts.js"
+import { getUnclosedRightParenCount } from "./helpers/parser/getUnclosedRightParenCount.js"
+import { parseParserOptions, seal } from "./helpers/parser/index.js"
+import { AutocompleteMixin } from "./methods/autocomplete.js"
+import { AutoreplaceMixin } from "./methods/autoreplace.js"
+import { Autosuggest } from "./methods/autosuggest.js"
+import { EvaluateMixin } from "./methods/evaluate.js"
+import { GetBestIndexesMixin } from "./methods/getBestIndex.js"
+import { GetIndexMixin } from "./methods/getIndexes.js"
+import { NormalizeMixin, ValidateMixin } from "./methods/index.js"
+import type { ParserResults } from "./types/ast.js"
+import { ERROR_CODES } from "./types/errors.js"
+import type { FullParserOptions, ParserOptions } from "./types/parser.js"
+
+
+/**
+ * Creates the main parser class which handles all functionality (evaluation, validation, etc).
+ */
+export class Parser<T extends {} = {}> {
+	options: FullParserOptions<T>
+
+	private readonly rawOptions: ParserOptions<T>
+
+	parser: ParserBase<T>
+
+	private readonly lexer: Lexer
+
+	private readonly tokens: ReturnType<typeof createTokens>["tokens"]
+
+	info: ReturnType<typeof createTokens>["info"]
+
+	constructor(options?: ParserOptions<T>) {
+		this.rawOptions = options ?? {}
+		const opts = parseParserOptions<T>(this.rawOptions)
+		checkParserOpts<T>(opts)
+		this.options = opts
+		const { lexer, tokens, info } = createTokens<T>(opts)
+		this.lexer = lexer
+		this.tokens = tokens
+		this.info = info
+		this.parser = new ParserBase<T>(opts, this.tokens, this.info)
+	}
+
+	/**
+	 * Parses a string.
+	 */
+	parse(input: string): ParserResults {
+		if (isWhitespace(input)) {
+			return tokenHandler.value(undefined, { start: 0, end: 0 }) as any
+		}
+
+		let lexed = this._lex(input)
+
+		const shift = getUnclosedRightParenCount(lexed.tokens, this.tokens)
+		if (shift) {
+			input = "(".repeat(shift) + input
+			lexed = this._lex(input)
+		}
+		this.parser.shift = shift
+		this.parser.input = lexed.tokens
+		this.parser.rawInput = input
+
+		/**
+		 * The parser can't handle unmatched right parens (i.e. left is missing) so we just insert them and shift the locations of all the tokens. Then the parser is designed to ignore parenthesis we added at the start and just return undefined for that rule as if the parenthesis didn't exist.
+		 */
+		try {
+			if (lexed.errors.length > 0) throw new Error("Unexpected Lexer Errors")
+			this.parser.input = lexed.tokens
+			const res = this.parser.main()
+			if (res === undefined) { throw new Error("throw") }
+			// hidden param
+			// eslint-disable-next-line prefer-rest-params
+			if (!arguments[1]?.unsealed) seal(res)
+			return res
+		} catch (error: unknown) {
+			// eslint-disable-next-line no-ex-assign
+			if ((error as Error).message === "throw") error = undefined
+			const err = new BooleanParserLibraryError(ERROR_CODES.PARSER_ERROR, {
+				input,
+				options: this.rawOptions,
+				"parsed options": this.options,
+				error: error as Error,
+				"lexed tokens": lexed.tokens,
+				"lexer errors": lexed.errors,
+				"parser errors": this.parser.errors,
+			})
+
+			throw err
+		}
+	}
+
+	// needed for evaluate and validate so they are only checked on demand
+	private evaluationOptionsChecked: boolean = false
+
+	// eslint-disable-next-line @typescript-eslint/naming-convention
+	_checkEvaluationOptions(): void {
+		if (!this.evaluationOptionsChecked) {
+			checkParserOpts(this.options, true)
+			this.evaluationOptionsChecked = true
+		}
+	}
+
+	private validationOptionsChecked: boolean = false
+
+	// eslint-disable-next-line @typescript-eslint/naming-convention
+	_checkValidationOptions(): void {
+		if (!this.validationOptionsChecked) {
+			checkParserOpts(this.options, false, true)
+			this.validationOptionsChecked = true
+		}
+	}
+
+	/**
+	 * Generates a railroad diagram for debugging. Does not 100% represent how things are actually handled internally.
+	 *
+	 * Not exposed because it uses the raw chevrotain tokens.
+	 *
+	 * **Note: It is not 100% accurate. Some special cases are parsed one way but handled internally differently.**
+	 */
+	private _generateRailRoadDiagram(): string {
+		const serialized = this.parser.getSerializedGastProductions()
+		const html = createSyntaxDiagramsCode(serialized)
+		return html
+	}
+
+	/**
+	 * For debugging.
+	 * Not exposed because it returns the raw chevrotain tokens.
+	 */
+	private _lex(input: string): ILexingResult {
+		return this.lexer.tokenize(input)
+	}
+}
+
+export interface Parser<T extends {} = {}> extends Mixin<
+	| AutocompleteMixin<T>
+	| AutoreplaceMixin
+	| Autosuggest<T>
+	| EvaluateMixin<T>
+	| ValidateMixin<T>
+	| NormalizeMixin<T>
+	| GetIndexMixin<T>
+	| GetBestIndexesMixin
+>,
+	AutocompleteMixin<T>,
+	AutoreplaceMixin,
+	Autosuggest<T>,
+	EvaluateMixin<T>,
+	ValidateMixin < T >,
+	NormalizeMixin<T>,
+	GetIndexMixin<T>,
+	GetBestIndexesMixin
+{}
+
+mixin(Parser, [
+	AutocompleteMixin,
+	AutoreplaceMixin,
+	Autosuggest,
+	EvaluateMixin,
+	ValidateMixin,
+	NormalizeMixin,
+	GetIndexMixin,
+	GetBestIndexesMixin,
+])