expressionish 0.1.1 → 0.1.2

package/dist/expressionish.d.ts

@@ -1,28 +1,41 @@
 declare module "parse/base-token" {
     import { type EvaluateOptions } from "types";
+    /** Represents the base options for all Token instances */
     export interface BaseTokenOptions {
         position: number;
         type?: string;
         value?: unknown;
     }
+    /** Represents the base return value for all Token instance .toJSON() functions */
     export interface BaseTokenJSON {
         position: number;
         type: string;
         value?: unknown;
     }
+    /** The most basic token; should not be used externally */
     export default class BaseToken {
+        /** Position in the expression where the token occurs */
         position: number;
+        /** Token type */
         type: string;
+        /** Token value */
         value?: unknown;
         constructor(options: BaseTokenOptions);
+        /** Converts the token to a JSON.stringify()-able object */
         toJSON(): BaseTokenJSON;
+        /** Evaluates the token */
         evaluate(options: EvaluateOptions): Promise<unknown>;
     }
 }
 declare module "types" {
     import type BaseToken from "parse/base-token";
-    /** Result of a `tokenize()` attempt */
-    export type TokenizeResult<T = BaseToken> = [success: false] | [success: true, updatedCursor: number, result: T];
+    /** Represents a small portion of an expression's text that may or may not have significance to the parser */
+    export interface GenericToken {
+        /** The position of the generic token within the expression text */
+        position: number;
+        /** The character(s) comprising the token */
+        value: string;
+    }
     /** Data to be passed to variables when they are to be evaluated */
     export type EvaluateData = Record<string | number | symbol, unknown>;
     /** Function to call to validate a variable's arguments
@@ -39,38 +52,126 @@ declare module "types" {
     data: EvaluateData, 
     /** variable or lookup name */
     variable: Variable) => undefined | Promise<never>;
-    type GeneralEvaluateFnc = (data: EvaluateData, ...args: unknown[]) => Promise<unknown>;
-    export interface GeneralVariableDefinition<T = GeneralEvaluateFnc> {
+    /** Called to evaluate the variable */
+    export type VariableEvaluateFnc = (data: EvaluateData, ...args: unknown[]) => undefined | unknown | Promise<undefined | unknown>;
+    /** Represents a variable definition */
+    export interface Variable {
+        /** Min arguments required by the variable */
         minArgumentsCount?: number;
+        /** Max arguments required by the variable */
         maxArgumentsCount?: number;
-        argsCheck?: ArgsCheck;
+        /** During evaluation of the expression, called prior to `argsCheck()` and `evaluate()` */
         preeval?: PreEval;
-        evaluate: T;
-    }
-    /** Represents a variable definition */
-    export type Variable = GeneralVariableDefinition;
-    /** Represents a Map of variables where
-     * - the key is the variable's name
-     * - the value is the variable's definition
-     */
-    export type VariableMap = Map<string, Variable>;
-    /** Represents a Lookup handler
-     * @returns {undefined | Variable} A variable declaration or undefined
+        /** During evaluation of the expression, called to validate arguments prior to calling `evaluate()` */
+        argsCheck?: ArgsCheck;
+        /** Function to call to handle evaluation of the variable */
+        evaluate: VariableEvaluateFnc;
+    }
+    /** Represents a list of variables */
+    export interface VariableMap extends Map<string, Variable> {
+        /** Checks if the given variable name is used as a key within the map */
+        has(
+        /** Variable name to check */
+        name: string): boolean;
+        /** Retrieves the variable definition associated with the specified name */
+        get(
+        /** Name of variable to retrieve */
+        name: string): Variable;
+        /** Stores a variable definition */
+        set(
+        /** Name to associate with the variable */
+        name: string, 
+        /** Variable definition */
+        definition: Variable): this;
+    }
+    /** Handler to lookup `name`
+     * @returns A variable declaration or undefined
     */
     export type LookupFnc = (data: EvaluateData, 
     /** The variable name to look up */
     name: string) => undefined | Variable | Promise<undefined | Variable>;
-    /** Represents a Map of Lookup handlers where
-     * * the key is the lookup variable-prefix
-     * * the value is the function to handle the lookup
+    /** Represents a Map of Lookup handlers */
+    export interface LookupMap extends Map<string, LookupFnc> {
+        has(
+        /** Variable prefix to check */
+        prefix: string): boolean;
+        get(
+        /** Variable prefix to retrieve associated lookup handler */
+        prefix: string): undefined | LookupFnc;
+        /** Stores the lookup */
+        set(
+        /** Variable prefix to associated with the lookup handler */
+        prefix: string, 
+        /** Handler function to perform the lookup */
+        handler: LookupFnc): this;
+    }
+    /** Performs a logic-operation on the given inputs
+     * @returns The result of the operation
     */
-    export type LookupMap = Map<string, LookupFnc>;
     export type LogicOperatorFnc = (data: EvaluateData, ...args: unknown[]) => boolean | Promise<boolean>;
-    export type LogicOperatorDefinition = GeneralVariableDefinition<LogicOperatorFnc>;
-    export type LogicOperatorMap = Map<string, LogicOperatorDefinition>;
+    /** Logic Operator Definition */
+    export interface LogicOperator {
+        /** Min arguments required by the variable */
+        minArgumentsCount?: number;
+        /** Max arguments required by the variable */
+        maxArgumentsCount?: number;
+        /** During evaluation of the expression, called prior to `argsCheck()` and `evaluate()` */
+        preeval?: PreEval;
+        /** During evaluation of the expression, called to validate arguments prior to calling `evaluate()` */
+        argsCheck?: ArgsCheck;
+        /** Function to call to handle evaluation of the variable */
+        evaluate: LogicOperatorFnc;
+    }
+    /** Represents a list of logic operators */
+    export interface LogicOperatorMap extends Map<string, LogicOperator> {
+        /** Check if the operator is used as a key within the map */
+        has(
+        /** Operator to check */
+        operator: string): boolean;
+        /** Returns the logic operator definition associated with the specified operator */
+        get(
+        /** Operator of which to retrieve the definition */
+        operator: string): undefined | LogicOperator;
+        /** Stores the given operator definition */
+        set(
+        /** Operator to associate with the definition */
+        operator: string, 
+        /** Operator definition */
+        definition: LogicOperator): this;
+    }
+    /** Performs a comparison-operation on the given inputs
+     * @returns The result of the operation
+    */
     export type ComparisonOperatorFnc = (data: EvaluateData, v1: unknown, v2?: unknown) => boolean | Promise<boolean>;
-    export type ComparisonOperatorDefinition = GeneralVariableDefinition<ComparisonOperatorFnc>;
-    export type ComparisonOperatorMap = Map<string, ComparisonOperatorDefinition>;
+    /** Comparison Operator Definition */
+    export interface ComparisonOperator {
+        right?: 'never' | 'optional' | 'required';
+        /** During evaluation of the comparison operator called prior to `argsCheck()` and `evaluate()` */
+        preeval?: PreEval;
+        /** During evaluation of the comparison operator called to validate arguments prior to calling `evaluate()` */
+        argsCheck?: ArgsCheck;
+        /** Function to call to handle evaluation of the variable */
+        evaluate: ComparisonOperatorFnc;
+    }
+    /** Represents a list of comparison operators */
+    export interface ComparisonOperatorMap extends Map<string, ComparisonOperator> {
+        /** Check if the operator is used as a key within the map */
+        has(
+        /** Operator to check */
+        operator: string): boolean;
+        /** Returns the comparison operator definition associated with the specified operator */
+        get(
+        /** Operator of which to retrieve the definition */
+        operator: string): undefined | ComparisonOperator;
+        /** Stores the given operator definition */
+        set(
+        /** Operator to associate with the definition */
+        operator: string, 
+        /** Operator definition */
+        definition: ComparisonOperator): this;
+    }
+    /** Result of a `tokenize()` attempt */
+    export type TokenizeResult<T = BaseToken> = [success: false] | [success: true, updatedCursor: number, result: T];
     /** Options when Tokenizing an expression */
     export interface TokenizeOptions {
         /** The expression to tokenize */
@@ -93,13 +194,6 @@ declare module "types" {
         /** Data to be passed into variable and/or lookup evaluators */
         data?: EvaluateData;
     }
-    /** Represents a small portion of an expression's text that may or may not have significance to the parser */
-    export interface GenericToken {
-        /** The position of the generic token within the expression text */
-        position: number;
-        /** The character(s) comprising the token */
-        value: string;
-    }
 }
 declare module "tojson-types" {
     /** Base that all other Token JSON inherit from */
@@ -160,8 +254,11 @@ declare module "tojson-types" {
         /** Value to return when the condition is falsy */
         whenFalse?: GroupedTokensJSON;
     }
+    /** Represents a Variable Token */
     export interface VariableTokenJSON extends BaseTokenJSON {
+        /** Variable name */
         value: string;
+        /** Arguments to pass to the variable's `evaluate()` function */
         arguments?: ArgumentsTokenJSON;
     }
     export type GroupedTokensJSON = LookupTokenJSON | IfTokenJSON | VariableTokenJSON | TextTokenJSON | SequenceTokenJSON;
@@ -170,19 +267,26 @@ declare module "tojson-types" {
 declare module "parse/text/token" {
     import BaseToken from "parse/base-token";
     import type { TextTokenJSON } from "tojson-types";
+    /** Represents the options for a new TextToken instance */
     export interface TextTokenOptions {
+        /** Position of the variable within the expression */
         position: number;
+        /** The text of the token */
         value: string;
     }
+    /** Represents literal text */
     export default class TextToken extends BaseToken {
+        /** The text of the token */
         value: string;
         constructor(options: TextTokenOptions);
+        /** Converts the token to a JSON.stringify()-able object */
         toJSON(): TextTokenJSON;
     }
 }
 declare module "parse/logic/operators" {
-    import type { LogicOperatorDefinition } from "types";
-    const _default: Map<string, LogicOperatorDefinition>;
+    import type { LogicOperatorMap } from "types";
+    /** Built-in Logic Operators Map */
+    const _default: LogicOperatorMap;
     export default _default;
 }
 declare module "parse/logic/token" {
@@ -190,16 +294,25 @@ declare module "parse/logic/token" {
     import type { LogicTokenJSON } from "tojson-types";
     import type ArgumentsToken from "parse/arguments/token";
     import BaseToken from "parse/base-token";
+    /** Represents the options for a new LogicToken instance */
     export interface LogicTokenOptions {
+        /** Position of the logic conditional within the expression */
         position: number;
+        /** The operator used */
         value: string;
+        /** Arguments to be passed to the operator's `evaluate()` function */
         arguments: ArgumentsToken;
     }
+    /** Represents a logical-conditional token */
     export default class LogicToken extends BaseToken {
+        /** The operator used */
         value: string;
+        /** Arguments to be passed to the operator's `evaluate()` function */
         arguments: ArgumentsToken;
         constructor(options: LogicTokenOptions);
+        /** Converts the token to a JSON.stringify()-able object */
         toJSON(): LogicTokenJSON;
+        /** Evaluates the token */
         evaluate(options: EvaluateOptions): Promise<unknown>;
     }
 }
@@ -208,16 +321,25 @@ declare module "parse/variable/token" {
     import type { VariableTokenJSON } from "tojson-types";
     import type ArgumentsToken from "parse/arguments/token";
     import BaseToken from "parse/base-token";
+    /** Represents the options for a new VariableToken instance */
     export interface VariableTokenOptions {
+        /** Position of the variable within the expression */
         position: number;
+        /** The variable's name */
         value: string;
+        /** Arguments to evaluate & pass to the variable's evaluate function */
         arguments?: ArgumentsToken;
     }
+    /** Represents a Variable token */
     export default class VariableToken extends BaseToken {
+        /** The variable name */
         value: string;
+        /** Arguments to evaluate & pass to the variable's evaluate function */
         arguments?: ArgumentsToken;
         constructor(options: VariableTokenOptions);
+        /** Converts the token to a JSON.stringify()-able object */
         toJSON(): VariableTokenJSON;
+        /** Evaluates the token */
         evaluate(options: EvaluateOptions): Promise<unknown>;
     }
 }
@@ -229,16 +351,24 @@ declare module "parse/sequence-token" {
     import type { default as IfToken } from "parse/if/token";
     import type { default as VariableToken } from "parse/variable/token";
     import BaseToken from "parse/base-token";
+    /** Options used to create a new SequenceToken instance */
     export interface SequenceTokenOptions {
+        /** Position in the expression where the sequence started */
         position: number;
-        value?: LookupToken | IfToken | VariableToken | TextToken | SequenceToken;
     }
+    /** Represents a sequence of tokens from the expression */
     export default class SequenceToken extends BaseToken {
         value: Array<LookupToken | IfToken | VariableToken | TextToken | SequenceToken>;
         constructor(options: SequenceTokenOptions);
-        add(token: LookupToken | IfToken | VariableToken | TextToken | SequenceToken): void;
+        /** Adds a token to the end of sequence */
+        add(
+        /** Token instance to add to the sequence */
+        token: LookupToken | IfToken | VariableToken | TextToken | SequenceToken): void;
+        /** If the sequence contains a singular token it returns that token otherwise returns `this` */
         get unwrap(): SequenceToken | TextToken | LookupToken | IfToken | VariableToken;
+        /** Converts the sequence to a JSON.stringify()-able object */
         toJSON(): SequenceTokenJSON | LookupTokenJSON | IfTokenJSON | VariableTokenJSON | TextTokenJSON;
+        /** Evaluates the sequence  */
         evaluate(options: EvaluateOptions): Promise<unknown>;
     }
 }
@@ -253,14 +383,21 @@ declare module "parse/arguments/token" {
     import type VariableToken from "parse/variable/token";
     import BaseToken from "parse/base-token";
     import SequenceToken from "parse/sequence-token";
+    /** Represents the options for a new ArgumentsToken instance */
     export interface ArgumentsTokenOptions {
+        /** Position of the arguments-bloc within the expression */
         position: number;
+        /** Tokens contained in the arguments-bloc */
         value?: Array<LookupToken | IfToken | VariableToken | TextToken | SequenceToken | LogicToken | ComparisonToken>;
     }
+    /** Represents a list of arguments */
     export default class ArgumentsToken extends BaseToken {
+        /** Tokens contained in the arguments-bloc */
         value: Array<LookupToken | IfToken | VariableToken | TextToken | SequenceToken | LogicToken | ComparisonToken>;
         constructor(options: ArgumentsTokenOptions);
+        /** Converts the token to a JSON.stringify()-able object */
         toJSON(): ArgumentsTokenJSON;
+        /** Evaluates the token */
         evaluate(options: EvaluateOptions): Promise<unknown[]>;
     }
 }
@@ -325,25 +462,34 @@ declare module "parse/lookup/token" {
     import type { LookupTokenJSON } from "tojson-types";
     import BaseToken from "parse/base-token";
     import ArgumentsToken from "parse/arguments/token";
+    /** Represents the options for a new LookupToken instance */
     export interface LookupTokenOptions {
+        /** Position in the expression the token occurs */
         position: number;
+        /** The lookup's prefix */
         prefix: string;
+        /** The name following the prefix */
         value: string;
+        /** Arguments to pass to the lookup result's `evaluate()` function */
         arguments?: ArgumentsToken;
     }
     export default class LookupToken extends BaseToken {
+        /** Lookup's prefix */
         prefix: string;
+        /** The name - following the prefix - to be looked up */
         value: string;
+        /** Arguments to pass to the lookup result's `evaluate()` function */
         arguments?: ArgumentsToken;
         constructor(options: LookupTokenOptions);
+        /** Converts the token to a JSON.stringify()-able object */
         toJSON(): LookupTokenJSON;
         evaluate(options: EvaluateOptions): Promise<unknown>;
     }
 }
 declare module "parse/comparison/operators" {
-    import type { ComparisonOperatorDefinition } from "types";
-    /** Comparison Operator Map */
-    const _default_1: Map<string, ComparisonOperatorDefinition>;
+    import type { ComparisonOperatorMap } from "types";
+    /** Built-in Comparison Operators Map */
+    const _default_1: ComparisonOperatorMap;
     export default _default_1;
 }
 declare module "parse/comparison/token" {
@@ -356,18 +502,29 @@ declare module "parse/comparison/token" {
     import type { default as SequenceToken } from "parse/sequence-token";
     type operand = LookupToken | IfToken | VariableToken | TextToken | SequenceToken;
     import BaseToken from "parse/base-token";
+    /** Represents the options for a new ComparisonToken instance */
     export interface ComparisonTokenOptions {
+        /** Position of the comparison within the expression */
         position: number;
+        /** Comparison operator used */
         value: string;
+        /** Left side of comparison */
         left: operand;
+        /** Right side of comparison */
         right?: operand;
     }
+    /** Represents a Comparison Token */
     export default class ComparisonToken extends BaseToken {
+        /** Comparison operator used */
         value: string;
+        /** Left side of comparison */
         left: operand;
+        /** Right side of comparison */
         right?: operand;
         constructor(options: ComparisonTokenOptions);
+        /** Converts the token to a JSON.stringify()-able object */
         toJSON(): ComparisonTokenJSON;
+        /** Evaluates the token */
         evaluate(options: EvaluateOptions): Promise<unknown>;
     }
 }
@@ -383,18 +540,29 @@ declare module "parse/if/token" {
     type ConditionToken = ComparisonToken | LogicToken;
     type OperandToken = LookupToken | IfToken | VariableToken | TextToken | SequenceToken;
     import BaseToken from "parse/base-token";
+    /** Represents the options for a new IfToken instance */
     export interface IfTokenOptions {
+        /** Position of the if-bloc within the expression*/
         position: number;
+        /** The condition of the if-bloc */
         value: ConditionToken;
+        /** Token to evaluate if the condition is truthy */
         whenTrue: OperandToken;
+        /** Token to evaluate if the condition is not truthy */
         whenFalse?: OperandToken;
     }
+    /** Represents an if token */
     export default class IfToken extends BaseToken {
+        /** The condition of the if-bloc */
         value: ConditionToken;
+        /** Token to evaluate if the condition is truthy */
         whenTrue: OperandToken;
+        /** Token to evaluate if the condition is not truthy */
         whenFalse?: OperandToken;
         constructor(options: IfTokenOptions);
+        /** Converts the token to a JSON.stringify()-able object */
         toJSON(): IfTokenJSON;
+        /** Evaluates the token */
         evaluate(options: EvaluateOptions): Promise<unknown>;
     }
 }
@@ -420,62 +588,119 @@ declare module "parse/root/token" {
     import type { RootTokenJSON } from "tojson-types";
     import type { TokenizeOptions, PreEval, EvaluateData, LookupMap, VariableMap, LogicOperatorMap, ComparisonOperatorMap } from "types";
     import SequenceToken from "parse/sequence-token";
+    /** Represents the options for a new RootToken instance */
     export type RootTokenOptions = TokenizeOptions;
+    /** Represents the options passed to a RootToken instance's `evaluate()` function */
     export interface RootEvaluateOptions {
+        /** When true, only validation will occur. Logic Operators, Comparison Operators, Variable & Lookups will not be evaluated */
         onlyValidate?: boolean;
+        /** Called just prior to evaluating each variable and/or lookup */
         preeval?: PreEval;
+        /** Data to pass to Logic Operators, Comparison Operators, Variables and Lookup results' `evaluate()` functions */
         data?: EvaluateData;
     }
+    /** Wrapper token representing the `tokenized()` expression */
     export default class RootToken extends SequenceToken {
+        /** Map of externally defined Lookup Handlers */
         lookups: LookupMap;
+        /** Map of externally defined Variables */
         variables: VariableMap;
-        expression: string;
+        /** Map of externally defined Logic Operators */
         logicOperators: LogicOperatorMap;
+        /** Map of exernally defined Comparison Operators */
         comparisonOperators: ComparisonOperatorMap;
+        /** Expression that is/was tokenized */
+        expression: string;
         constructor(options: RootTokenOptions);
+        /** Converts the token to a JSON.stringify()-able object */
         toJSON(): RootTokenJSON;
+        /** Evaluates the token */
         evaluate(options?: RootEvaluateOptions): Promise<unknown>;
     }
 }
 declare module "parse/text/escape" {
     import type { GenericToken, TokenizeResult } from "types";
-    const _default_2: (tokens: GenericToken[], cursor: number, escapeChars?: string) => TokenizeResult<GenericToken>;
+    /** Attempts to consume an escape-sequence from `tokens` starting at `cursor` */
+    const _default_2: (
+    /** List of generic tokens to be tokenized into Token instances */
+    tokens: GenericToken[], 
+    /** Current position within the tokens list */
+    cursor: number, 
+    /** Escapable character; defaults to "$[,]\\rnt and double backticks */
+    escapeChars?: string) => TokenizeResult<GenericToken>;
     export default _default_2;
 }
 declare module "parse/text/quote" {
     import type { GenericToken, TokenizeResult } from "types";
     import TextToken from "parse/text/token";
-    const _default_3: (tokens: GenericToken[], cursor: number) => TokenizeResult<TextToken>;
+    /** Attempts to consume quoted text from `tokens` starting at `cursor` */
+    const _default_3: (
+    /** List of generic tokens to be tokenized into Token instances */
+    tokens: GenericToken[], 
+    /** Current position within the tokens list */
+    cursor: number) => TokenizeResult<TextToken>;
     export default _default_3;
 }
 declare module "parse/variable/tokenize" {
     import type { GenericToken, TokenizeOptions, TokenizeResult } from "types";
     import VariableToken from "parse/variable/token";
-    const _default_4: (tokens: GenericToken[], cursor: number, options: TokenizeOptions) => TokenizeResult<VariableToken>;
+    /** Attempts to consume a varaiable from `tokens` starting at `cursor` */
+    const _default_4: (
+    /** List of generic tokens to be tokenized into Token instances */
+    tokens: GenericToken[], 
+    /** Current position within the tokens list */
+    cursor: number, 
+    /** Options passed to the `tokenize()` call */
+    options: TokenizeOptions) => TokenizeResult<VariableToken>;
     export default _default_4;
 }
 declare module "parse/whitespace/tokenize" {
     import type { GenericToken, TokenizeResult } from "types";
-    /** Consumes sequential whitespace from `tokens` beginning at `cursor` */
-    const _default_5: (tokens: GenericToken[], cursor: number) => TokenizeResult<string>;
+    /** Attempts to consume sequential whitespace from `tokens` beginning at `cursor` */
+    const _default_5: (
+    /** List of generic tokens to be tokenized into Token instances */
+    tokens: GenericToken[], 
+    /** Current position within the tokens list */
+    cursor: number) => TokenizeResult<string>;
     export default _default_5;
 }
 declare module "parse/comparison/tokenize" {
     import type { GenericToken, TokenizeOptions, TokenizeResult } from "types";
     import ComparisonToken from "parse/comparison/token";
-    const _default_6: (tokens: GenericToken[], cursor: number, options: TokenizeOptions) => TokenizeResult<ComparisonToken>;
+    /** Attempts to consume a comparison from `tokens` starting at `cursor` */
+    const _default_6: (
+    /** List of generic tokens to be tokenized into Token instances */
+    tokens: GenericToken[], 
+    /** Current position within the tokens list */
+    cursor: number, 
+    /** Options passed to the initial `tokenize()` call */
+    options: TokenizeOptions) => TokenizeResult<ComparisonToken>;
     export default _default_6;
 }
 declare module "parse/logic/tokenize" {
     import type { GenericToken, TokenizeOptions, TokenizeResult } from "types";
     import LogicToken from "parse/logic/token";
-    const tokenizeLogicOperator: (tokens: GenericToken[], cursor: number, options: TokenizeOptions) => TokenizeResult<LogicToken>;
+    /** Attempts to consume a Logic Operator from `tokens` starting at `cursor` */
+    const tokenizeLogicOperator: (
+    /** List of generic tokens to be tokenized into Token instances */
+    tokens: GenericToken[], 
+    /** Current position within the tokens list */
+    cursor: number, 
+    /** Options passed to the `tokenize()` call */
+    options: TokenizeOptions) => TokenizeResult<LogicToken>;
     export default tokenizeLogicOperator;
 }
 declare module "parse/if/tokenize" {
     import type { GenericToken, TokenizeOptions, TokenizeResult } from "types";
     import IfToken from "parse/if/token";
-    const _default_7: (tokens: GenericToken[], cursor: number, options: TokenizeOptions) => TokenizeResult<IfToken>;
+    /** Attempts to consume an If Statement from `tokens` starting at `cursor` */
+    const _default_7: (
+    /** List of generic tokens to be tokenized into Token instances */
+    tokens: GenericToken[], 
+    /** Current position within the tokens list */
+    cursor: number, 
+    /** Options passed to the `tokenize()` call */
+    options: TokenizeOptions) => TokenizeResult<IfToken>;
     export default _default_7;
 }
 declare module "parse/arguments/argument" {
@@ -485,19 +710,40 @@ declare module "parse/arguments/argument" {
     import SequenceToken from "parse/sequence-token";
     import TextToken from "parse/text/token";
     import VariableToken from "parse/variable/token";
-    const _default_8: (tokens: GenericToken[], cursor: number, options: TokenizeOptions) => TokenizeResult<LookupToken | IfToken | VariableToken | TextToken | SequenceToken>;
+    /** Attempts to tokenize a singular argument for a arguments-bloc from `tokens` starting at `cursor` */
+    const _default_8: (
+    /** List of generic tokens to be tokenized into Token instances */
+    tokens: GenericToken[], 
+    /** Current position within the tokens list */
+    cursor: number, 
+    /** Options passed to the initial `tokenize()` call */
+    options: TokenizeOptions) => TokenizeResult<LookupToken | IfToken | VariableToken | TextToken | SequenceToken>;
     export default _default_8;
 }
 declare module "parse/arguments/tokenize" {
     import type { GenericToken, TokenizeOptions, TokenizeResult } from "types";
     import ArgumentsToken from "parse/arguments/token";
-    const _default_9: (tokens: GenericToken[], cursor: number, options: TokenizeOptions) => TokenizeResult<ArgumentsToken>;
+    /** Attempts to consume an arguments-bloc from `tokens` starting at `cursor` */
+    const _default_9: (
+    /** List of generic tokens to be tokenized into Token instances */
+    tokens: GenericToken[], 
+    /** Current position within the tokens list */
+    cursor: number, 
+    /** Options passed to the initial `tokenize()` call */
+    options: TokenizeOptions) => TokenizeResult<ArgumentsToken>;
     export default _default_9;
 }
 declare module "parse/lookup/tokenize" {
     import type { GenericToken, TokenizeOptions, TokenizeResult } from "types";
     import LookupToken from "parse/lookup/token";
-    const _default_10: (tokens: GenericToken[], cursor: number, options: TokenizeOptions) => TokenizeResult<LookupToken>;
+    /** Attempts to tokenize a Lookup from `tokens` starting at `cursor */
+    const _default_10: (
+    /** List of generic tokens to be tokenized into Token instances */
+    tokens: GenericToken[], 
+    /** Current position within the tokens list */
+    cursor: number, 
+    /** Options passed to the `tokenize()` call */
+    options: TokenizeOptions) => TokenizeResult<LookupToken>;
     export default _default_10;
 }
 declare module "parse/text/block" {
@@ -507,24 +753,36 @@ declare module "parse/text/block" {
     import type VariableToken from "parse/variable/token";
     import SequenceToken from "parse/sequence-token";
     import TextToken from "parse/text/token";
-    const _default_11: (tokens: GenericToken[], cursor: number, options: TokenizeOptions) => TokenizeResult<LookupToken | IfToken | VariableToken | TextToken | SequenceToken>;
+    /** Attempts to consume a block-escape sequence from `tokens` starting at `cursor` */
+    const _default_11: (
+    /** List of generic tokens to be tokenized into Token instances */
+    tokens: GenericToken[], 
+    /** Current position within the tokens list */
+    cursor: number, 
+    /** Options passed to initial tokenize() call */
+    options: TokenizeOptions) => TokenizeResult<LookupToken | IfToken | VariableToken | TextToken | SequenceToken>;
     export default _default_11;
 }
 declare module "parse/root/tokenize" {
     import type { TokenizeOptions } from "types";
     import RootToken from "parse/root/token";
-    const _default_12: (options: TokenizeOptions) => RootToken;
+    /** Attempts to tokenize the given expression into Token instances */
+    const _default_12: (
+    /** Options passed to initial tokenize() call */
+    options: TokenizeOptions) => RootToken;
     export default _default_12;
 }
 declare module "expressionish" {
-    import { TokenizeOptions, EvaluateOptions } from "types";
+    import { TokenizeOptions, LookupMap, EvaluateOptions, LogicOperatorMap, ComparisonOperatorMap } from "types";
+    export { TokenizeOptions, LookupMap, EvaluateOptions, LogicOperatorMap, ComparisonOperatorMap };
+    import { default as RootToken, RootTokenOptions, RootEvaluateOptions } from "parse/root/token";
+    export { RootToken, RootTokenOptions, RootEvaluateOptions };
     export { default as ArgumentsToken, ArgumentsTokenOptions } from "parse/arguments/token";
     export { default as BaseToken, BaseTokenOptions } from "parse/base-token";
     export { default as ComparisonToken, ComparisonTokenOptions } from "parse/comparison/token";
     export { default as IfToken, IfTokenOptions } from "parse/if/token";
     export { default as LogicToken, LogicTokenOptions } from "parse/logic/token";
     export { default as LookupToken, LookupTokenOptions } from "parse/lookup/token";
-    export { default as RootToken, RootTokenOptions, RootEvaluateOptions } from "parse/root/token";
     export { default as SequenceToken } from "parse/sequence-token";
     export { default as TextToken, TextTokenOptions } from "parse/text/token";
     export { default as VariableToken, VariableTokenOptions } from "parse/variable/token";
@@ -532,7 +790,7 @@ declare module "expressionish" {
     /** Parses a string expression into a usable Expressionish-Token instance */
     export const tokenize: (
     /** Options to use during tokenization */
-    options: TokenizeOptions) => import("expressionish").RootToken;
+    options: TokenizeOptions) => RootToken;
     /** Parses then evaluates expression text */
     export const evaluate: (
     /** Options passed to the parser and evaluator */